daemons/attrd/attrd

/* */
This source file includes following definitions.
attrd_set_requesting_shutdown
attrd_clear_requesting_shutdown
attrd_shutting_down
attrd_shutdown
attrd_init_mainloop
attrd_run_mainloop
attrd_value_needs_expansion
attrd_expand_value
attrd_failure_regex
attrd_free_attribute_value
attrd_free_attribute
attrd_remove_peer_protocol_ver
attrd_update_minimum_protocol_ver
   1 /*
   2  * Copyright 2004-2024 the Pacemaker project contributors
   3  *
   4  * The version control history for this file may have further details.
   5  *
   6  * This source code is licensed under the GNU General Public License version 2
   7  * or later (GPLv2+) WITHOUT ANY WARRANTY.
   8  */
   9 
  10 #include <crm_internal.h>
  11 
  12 #include <stdio.h>
  13 #include <stdbool.h>
  14 #include <errno.h>
  15 #include <glib.h>
  16 #include <regex.h>
  17 #include <sys/types.h>
  18 
  19 #include <crm/crm.h>
  20 #include <crm/common/ipc_internal.h>
  21 #include <crm/common/mainloop.h>
  22 #include <crm/common/xml.h>
  23 
  24 #include "pacemaker-attrd.h"
  25 
  26 cib_t *the_cib = NULL;
  27 
  28 static bool requesting_shutdown = false;
  29 static bool shutting_down = false;
  30 static GMainLoop *mloop = NULL;
  31 
  32 /* A hash table storing information on the protocol version of each peer attrd.
  33  * The key is the peer's uname, and the value is the protocol version number.
  34  */
  35 GHashTable *peer_protocol_vers = NULL;
  36 
  37 /*!
  38  * \internal
  39  * \brief  Set requesting_shutdown state
  40  */
  41 void
  42 attrd_set_requesting_shutdown(void)
     /*  */
  43 {
  44     requesting_shutdown = true;
  45 }
  46 
  47 /*!
  48  * \internal
  49  * \brief  Clear requesting_shutdown state
  50  */
  51 void
  52 attrd_clear_requesting_shutdown(void)
     /*  */
  53 {
  54     requesting_shutdown = false;
  55 }
  56 
  57 /*!
  58  * \internal
  59  * \brief Check whether local attribute manager is shutting down
  60  *
  61  * \param[in] if_requested  If \c true, also consider presence of
  62  *                          \c PCMK__NODE_ATTR_SHUTDOWN attribute
  63  *
  64  * \return \c true if local attribute manager has begun shutdown sequence
  65  *         or (if \p if_requested is \c true) whether local node has a nonzero
  66  *         \c PCMK__NODE_ATTR_SHUTDOWN attribute set, otherwise \c false
  67  * \note Most callers should pass \c false for \p if_requested, because the
  68  *       attribute manager needs to continue performing while the controller is
  69  *       shutting down, and even needs to be eligible for election in case all
  70  *       nodes are shutting down.
  71  */
  72 bool
  73 attrd_shutting_down(bool if_requested)
     /*  */
  74 {
  75     return shutting_down || (if_requested && requesting_shutdown);
  76 }
  77 
  78 /*!
  79  * \internal
  80  * \brief  Exit (using mainloop or not, as appropriate)
  81  *
  82  * \param[in] nsig  Ignored
  83  */
  84 void
  85 attrd_shutdown(int nsig)
     /*  */
  86 {
  87     // Tell various functions not to do anthing
  88     shutting_down = true;
  89 
  90     // Don't respond to signals while shutting down
  91     mainloop_destroy_signal(SIGTERM);
  92     mainloop_destroy_signal(SIGCHLD);
  93     mainloop_destroy_signal(SIGPIPE);
  94     mainloop_destroy_signal(SIGUSR1);
  95     mainloop_destroy_signal(SIGUSR2);
  96     mainloop_destroy_signal(SIGTRAP);
  97 
  98     attrd_free_waitlist();
  99     attrd_free_confirmations();
 100 
 101     if (peer_protocol_vers != NULL) {
 102         g_hash_table_destroy(peer_protocol_vers);
 103         peer_protocol_vers = NULL;
 104     }
 105 
 106     if ((mloop == NULL) || !g_main_loop_is_running(mloop)) {
 107         /* If there's no main loop active, just exit. This should be possible
 108          * only if we get SIGTERM in brief windows at start-up and shutdown.
 109          */
 110         crm_exit(CRM_EX_OK);
 111     } else {
 112         g_main_loop_quit(mloop);
 113         g_main_loop_unref(mloop);
 114     }
 115 }
 116 
 117 /*!
 118  * \internal
 119  * \brief Create a main loop for attrd
 120  */
 121 void
 122 attrd_init_mainloop(void)
     /*  */
 123 {
 124     mloop = g_main_loop_new(NULL, FALSE);
 125 }
 126 
 127 /*!
 128  * \internal
 129  * \brief Run attrd main loop
 130  */
 131 void
 132 attrd_run_mainloop(void)
     /*  */
 133 {
 134     g_main_loop_run(mloop);
 135 }
 136 
 137 /* strlen("value") */
 138 #define plus_plus_len (5)
 139 
 140 /*!
 141  * \internal
 142  * \brief  Check whether an attribute value should be expanded
 143  *
 144  * \param[in] value  Attribute value to check
 145  *
 146  * \return true if value needs expansion, false otherwise
 147  */
 148 bool
 149 attrd_value_needs_expansion(const char *value)
     /*  */
 150 {
 151     return ((strlen(value) >= (plus_plus_len + 2))
 152            && (value[plus_plus_len] == '+')
 153            && ((value[plus_plus_len + 1] == '+')
 154                || (value[plus_plus_len + 1] == '=')));
 155 }
 156 
 157 /*!
 158  * \internal
 159  * \brief Expand an increment expression into an integer
 160  *
 161  * \param[in] value      Attribute increment expression to expand
 162  * \param[in] old_value  Previous value of attribute
 163  *
 164  * \return Expanded value
 165  */
 166 int
 167 attrd_expand_value(const char *value, const char *old_value)
     /*  */
 168 {
 169     int increment = 1;
 170     int score = 0;
 171 
 172     if (pcmk_parse_score(old_value, &score, 0) != pcmk_rc_ok) {
 173         return 0; // Original value is not a score
 174     }
 175 
 176     // value++ means increment by one, value+=OFFSET means incremement by OFFSET
 177     if ((value[plus_plus_len + 1] != '+')
 178         && (pcmk_parse_score(value + plus_plus_len + 2, &increment,
 179                              0) != pcmk_rc_ok)) {
 180         increment = 0; // Invalid increment
 181     }
 182 
 183     if (increment < 0) {
 184         return QB_MAX(score + increment, -PCMK_SCORE_INFINITY);
 185     }
 186     return QB_MIN(score + increment, PCMK_SCORE_INFINITY);
 187 }
 188 
 189 /*!
 190  * \internal
 191  * \brief Create regular expression matching failure-related attributes
 192  *
 193  * \param[out] regex  Where to store created regular expression
 194  * \param[in]  rsc    Name of resource to clear (or NULL for all)
 195  * \param[in]  op     Operation to clear if rsc is specified (or NULL for all)
 196  * \param[in]  interval_ms  Interval of operation to clear if op is specified
 197  *
 198  * \return pcmk_ok on success, -EINVAL if arguments are invalid
 199  *
 200  * \note The caller is responsible for freeing the result with regfree().
 201  */
 202 int
 203 attrd_failure_regex(regex_t *regex, const char *rsc, const char *op,
     /*  */
 204                     guint interval_ms)
 205 {
 206     char *pattern = NULL;
 207     int rc;
 208 
 209     /* Create a pattern that matches desired attributes */
 210 
 211     if (rsc == NULL) {
 212         pattern = pcmk__str_copy(ATTRD_RE_CLEAR_ALL);
 213     } else if (op == NULL) {
 214         pattern = crm_strdup_printf(ATTRD_RE_CLEAR_ONE, rsc);
 215     } else {
 216         pattern = crm_strdup_printf(ATTRD_RE_CLEAR_OP, rsc, op, interval_ms);
 217     }
 218 
 219     /* Compile pattern into regular expression */
 220     crm_trace("Clearing attributes matching %s", pattern);
 221     rc = regcomp(regex, pattern, REG_EXTENDED|REG_NOSUB);
 222     free(pattern);
 223 
 224     return (rc == 0)? pcmk_ok : -EINVAL;
 225 }
 226 
 227 void
 228 attrd_free_attribute_value(gpointer data)
     /*  */
 229 {
 230     attribute_value_t *v = data;
 231 
 232     free(v->nodename);
 233     free(v->current);
 234     free(v->requested);
 235     free(v);
 236 }
 237 
 238 void
 239 attrd_free_attribute(gpointer data)
     /*  */
 240 {
 241     attribute_t *a = data;
 242     if(a) {
 243         free(a->id);
 244         free(a->set_id);
 245         free(a->set_type);
 246         free(a->user);
 247 
 248         mainloop_timer_del(a->timer);
 249         g_hash_table_destroy(a->values);
 250 
 251         free(a);
 252     }
 253 }
 254 
 255 /*!
 256  * \internal
 257  * \brief When a peer node leaves the cluster, stop tracking its protocol version.
 258  *
 259  * \param[in] host  The peer node's uname to be removed
 260  */
 261 void
 262 attrd_remove_peer_protocol_ver(const char *host)
     /*  */
 263 {
 264     if (peer_protocol_vers != NULL) {
 265         g_hash_table_remove(peer_protocol_vers, host);
 266     }
 267 }
 268 
 269 /*!
 270  * \internal
 271  * \brief When a peer node broadcasts a message with its protocol version, keep
 272  *        track of that information.
 273  *
 274  * We keep track of each peer's protocol version so we know which peers to
 275  * expect confirmation messages from when handling cluster-wide sync points.
 276  * We additionally keep track of the lowest protocol version supported by all
 277  * peers so we know when we can send IPC messages containing more than one
 278  * request.
 279  *
 280  * \param[in] host  The peer node's uname to be tracked
 281  * \param[in] value The peer node's protocol version
 282  */
 283 void
 284 attrd_update_minimum_protocol_ver(const char *host, const char *value)
     /*  */
 285 {
 286     int ver;
 287 
 288     if (peer_protocol_vers == NULL) {
 289         peer_protocol_vers = pcmk__strkey_table(free, NULL);
 290     }
 291 
 292     pcmk__scan_min_int(value, &ver, 0);
 293 
 294     if (ver > 0) {
 295         /* Record the peer attrd's protocol version. */
 296         g_hash_table_insert(peer_protocol_vers, pcmk__str_copy(host),
 297                             GINT_TO_POINTER(ver));
 298 
 299         /* If the protocol version is a new minimum, record it as such. */
 300         if (minimum_protocol_version == -1 || ver < minimum_protocol_version) {
 301             minimum_protocol_version = ver;
 302             crm_trace("Set minimum attrd protocol version to %d",
 303                       minimum_protocol_version);
 304         }
 305     }
 306 }
/* */
root/daemons/attrd/attrd_utils.c

DEFINITIONS
