root/lib/cluster/cluster.c

/* */

DEFINITIONS

1. crm_peer_uuid
2. crm_cluster_connect
3. crm_cluster_disconnect
4. pcmk_cluster_new
5. pcmk_cluster_free
6. send_cluster_message
7. get_local_node_name
8. get_node_name
9. crm_peer_uname
10. name_for_cluster_type
11. get_cluster_type
12. is_corosync_cluster
13. set_uuid

   1 /*
   2  * Copyright 2004-2023 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 Lesser General Public License
   7  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
   8  */
   9 
  10 #include <crm_internal.h>
  11 #include <dlfcn.h>
  12 
  13 #include <stdio.h>
  14 #include <unistd.h>
  15 #include <string.h>
  16 #include <stdlib.h>
  17 #include <time.h>
  18 #include <sys/param.h>
  19 #include <sys/types.h>
  20 
  21 #include <crm/crm.h>
  22 #include <crm/msg_xml.h>
  23 
  24 #include <crm/common/ipc.h>
  25 #include <crm/cluster/internal.h>
  26 #include "crmcluster_private.h"
  27 
  28 CRM_TRACE_INIT_DATA(cluster);
  29 
  30 /*!
  31  * \brief Get (and set if needed) a node's UUID
  32  *
  33  * \param[in,out] peer  Node to check
  34  *
  35  * \return Node UUID of \p peer, or NULL if unknown
  36  */
  37 const char *
  38 crm_peer_uuid(crm_node_t *peer)
     /*  */
  39 {
  40     char *uuid = NULL;
  41 
  42     // Check simple cases first, to avoid any calls that might block
  43     if (peer == NULL) {
  44         return NULL;
  45     }
  46     if (peer->uuid != NULL) {
  47         return peer->uuid;
  48     }
  49 
  50     switch (get_cluster_type()) {
  51         case pcmk_cluster_corosync:
  52 #if SUPPORT_COROSYNC
  53             uuid = pcmk__corosync_uuid(peer);
  54 #endif
  55             break;
  56 
  57         case pcmk_cluster_unknown:
  58         case pcmk_cluster_invalid:
  59             crm_err("Unsupported cluster type");
  60             break;
  61     }
  62 
  63     peer->uuid = uuid;
  64     return peer->uuid;
  65 }
  66 
  67 /*!
  68  * \brief Connect to the cluster layer
  69  *
  70  * \param[in,out] Initialized cluster object to connect
  71  *
  72  * \return TRUE on success, otherwise FALSE
  73  */
  74 gboolean
  75 crm_cluster_connect(crm_cluster_t *cluster)
     /*  */
  76 {
  77     enum cluster_type_e type = get_cluster_type();
  78 
  79     crm_notice("Connecting to %s cluster infrastructure",
  80                name_for_cluster_type(type));
  81     switch (type) {
  82         case pcmk_cluster_corosync:
  83 #if SUPPORT_COROSYNC
  84             crm_peer_init();
  85             return pcmk__corosync_connect(cluster);
  86 #else
  87             break;
  88 #endif // SUPPORT_COROSYNC
  89         default:
  90             break;
  91     }
  92     return FALSE;
  93 }
  94 
  95 /*!
  96  * \brief Disconnect from the cluster layer
  97  *
  98  * \param[in,out] cluster  Cluster object to disconnect
  99  */
 100 void
 101 crm_cluster_disconnect(crm_cluster_t *cluster)
     /*  */
 102 {
 103     enum cluster_type_e type = get_cluster_type();
 104 
 105     crm_info("Disconnecting from %s cluster infrastructure",
 106              name_for_cluster_type(type));
 107     switch (type) {
 108         case pcmk_cluster_corosync:
 109 #if SUPPORT_COROSYNC
 110             crm_peer_destroy();
 111             pcmk__corosync_disconnect(cluster);
 112 #endif // SUPPORT_COROSYNC
 113             break;
 114         default:
 115             break;
 116     }
 117 }
 118 
 119 /*!
 120  * \brief Allocate a new \p crm_cluster_t object
 121  *
 122  * \return A newly allocated \p crm_cluster_t object (guaranteed not \p NULL)
 123  * \note The caller is responsible for freeing the return value using
 124  *       \p pcmk_cluster_free().
 125  */
 126 crm_cluster_t *
 127 pcmk_cluster_new(void)
     /*  */
 128 {
 129     crm_cluster_t *cluster = calloc(1, sizeof(crm_cluster_t));
 130 
 131     CRM_ASSERT(cluster != NULL);
 132     return cluster;
 133 }
 134 
 135 /*!
 136  * \brief Free a \p crm_cluster_t object and its dynamically allocated members
 137  *
 138  * \param[in,out] cluster  Cluster object to free
 139  */
 140 void
 141 pcmk_cluster_free(crm_cluster_t *cluster)
     /*  */
 142 {
 143     if (cluster == NULL) {
 144         return;
 145     }
 146     free(cluster->uuid);
 147     free(cluster->uname);
 148     free(cluster);
 149 }
 150 
 151 /*!
 152  * \brief Send an XML message via the cluster messaging layer
 153  *
 154  * \param[in] node     Cluster node to send message to
 155  * \param[in] service  Message type to use in message host info
 156  * \param[in] data     XML message to send
 157  * \param[in] ordered  Ignored for currently supported messaging layers
 158  *
 159  * \return TRUE on success, otherwise FALSE
 160  */
 161 gboolean
 162 send_cluster_message(const crm_node_t *node, enum crm_ais_msg_types service,
     /*  */
 163                      const xmlNode *data, gboolean ordered)
 164 {
 165     switch (get_cluster_type()) {
 166         case pcmk_cluster_corosync:
 167 #if SUPPORT_COROSYNC
 168             return pcmk__cpg_send_xml(data, node, service);
 169 #endif
 170             break;
 171         default:
 172             break;
 173     }
 174     return FALSE;
 175 }
 176 
 177 /*!
 178  * \brief Get the local node's name
 179  *
 180  * \return Local node's name
 181  * \note This will fatally exit if local node name cannot be known.
 182  */
 183 const char *
 184 get_local_node_name(void)
     /*  */
 185 {
 186     static char *name = NULL;
 187 
 188     if (name == NULL) {
 189         name = get_node_name(0);
 190     }
 191     return name;
 192 }
 193 
 194 /*!
 195  * \brief Get the node name corresponding to a cluster node ID
 196  *
 197  * \param[in] nodeid  Node ID to check (or 0 for local node)
 198  *
 199  * \return Node name corresponding to \p nodeid
 200  * \note This will fatally exit if \p nodeid is 0 and local node name cannot be
 201  *       known.
 202  */
 203 char *
 204 get_node_name(uint32_t nodeid)
     /*  */
 205 {
 206     char *name = NULL;
 207     enum cluster_type_e stack = get_cluster_type();
 208 
 209     switch (stack) {
 210         case pcmk_cluster_corosync:
 211 #if SUPPORT_COROSYNC
 212             name = pcmk__corosync_name(0, nodeid);
 213             break;
 214 #endif // SUPPORT_COROSYNC
 215 
 216         default:
 217             crm_err("Unknown cluster type: %s (%d)", name_for_cluster_type(stack), stack);
 218     }
 219 
 220     if ((name == NULL) && (nodeid == 0)) {
 221         name = pcmk_hostname();
 222         if (name == NULL) {
 223             // @TODO Maybe let the caller decide what to do
 224             crm_err("Could not obtain the local %s node name",
 225                     name_for_cluster_type(stack));
 226             crm_exit(CRM_EX_FATAL);
 227         }
 228         crm_notice("Defaulting to uname -n for the local %s node name",
 229                    name_for_cluster_type(stack));
 230     }
 231 
 232     if (name == NULL) {
 233         crm_notice("Could not obtain a node name for %s node with id %u",
 234                    name_for_cluster_type(stack), nodeid);
 235     }
 236     return name;
 237 }
 238 
 239 /*!
 240  * \brief Get the node name corresponding to a node UUID
 241  *
 242  * \param[in] uuid  UUID of desired node
 243  *
 244  * \return name of desired node
 245  *
 246  * \note This relies on the remote peer cache being populated with all
 247  *       remote nodes in the cluster, so callers should maintain that cache.
 248  */
 249 const char *
 250 crm_peer_uname(const char *uuid)
     /*  */
 251 {
 252     GHashTableIter iter;
 253     crm_node_t *node = NULL;
 254 
 255     CRM_CHECK(uuid != NULL, return NULL);
 256 
 257     /* remote nodes have the same uname and uuid */
 258     if (g_hash_table_lookup(crm_remote_peer_cache, uuid)) {
 259         return uuid;
 260     }
 261 
 262     /* avoid blocking calls where possible */
 263     g_hash_table_iter_init(&iter, crm_peer_cache);
 264     while (g_hash_table_iter_next(&iter, NULL, (gpointer *) &node)) {
 265         if (pcmk__str_eq(node->uuid, uuid, pcmk__str_casei)) {
 266             if (node->uname != NULL) {
 267                 return node->uname;
 268             }
 269             break;
 270         }
 271     }
 272     node = NULL;
 273 
 274     if (is_corosync_cluster()) {
 275         long long id;
 276 
 277         if ((pcmk__scan_ll(uuid, &id, 0LL) != pcmk_rc_ok)
 278             || (id < 1LL) || (id > UINT32_MAX))  {
 279             crm_err("Invalid Corosync node ID '%s'", uuid);
 280             return NULL;
 281         }
 282 
 283         node = pcmk__search_cluster_node_cache((uint32_t) id, NULL, NULL);
 284         if (node != NULL) {
 285             crm_info("Setting uuid for node %s[%u] to %s",
 286                      node->uname, node->id, uuid);
 287             node->uuid = strdup(uuid);
 288             return node->uname;
 289         }
 290         return NULL;
 291     }
 292 
 293     return NULL;
 294 }
 295 
 296 /*!
 297  * \brief  Get a log-friendly string equivalent of a cluster type
 298  *
 299  * \param[in] type  Cluster type
 300  *
 301  * \return Log-friendly string corresponding to \p type
 302  */
 303 const char *
 304 name_for_cluster_type(enum cluster_type_e type)
     /*  */
 305 {
 306     switch (type) {
 307         case pcmk_cluster_corosync:
 308             return "corosync";
 309         case pcmk_cluster_unknown:
 310             return "unknown";
 311         case pcmk_cluster_invalid:
 312             return "invalid";
 313     }
 314     crm_err("Invalid cluster type: %d", type);
 315     return "invalid";
 316 }
 317 
 318 /*!
 319  * \brief Get (and validate) the local cluster type
 320  *
 321  * \return Local cluster type
 322  * \note This will fatally exit if the local cluster type is invalid.
 323  */
 324 enum cluster_type_e
 325 get_cluster_type(void)
     /*  */
 326 {
 327     bool detected = false;
 328     const char *cluster = NULL;
 329     static enum cluster_type_e cluster_type = pcmk_cluster_unknown;
 330 
 331     /* Return the previous calculation, if any */
 332     if (cluster_type != pcmk_cluster_unknown) {
 333         return cluster_type;
 334     }
 335 
 336     cluster = pcmk__env_option(PCMK__ENV_CLUSTER_TYPE);
 337 
 338 #if SUPPORT_COROSYNC
 339     /* If nothing is defined in the environment, try corosync (if supported) */
 340     if (cluster == NULL) {
 341         crm_debug("Testing with Corosync");
 342         cluster_type = pcmk__corosync_detect();
 343         if (cluster_type != pcmk_cluster_unknown) {
 344             detected = true;
 345             goto done;
 346         }
 347     }
 348 #endif
 349 
 350     /* Something was defined in the environment, test it against what we support */
 351     crm_info("Verifying cluster type: '%s'",
 352              ((cluster == NULL)? "-unspecified-" : cluster));
 353     if (cluster == NULL) {
 354 
 355 #if SUPPORT_COROSYNC
 356     } else if (pcmk__str_eq(cluster, "corosync", pcmk__str_casei)) {
 357         cluster_type = pcmk_cluster_corosync;
 358 #endif
 359 
 360     } else {
 361         cluster_type = pcmk_cluster_invalid;
 362         goto done; /* Keep the compiler happy when no stacks are supported */
 363     }
 364 
 365   done:
 366     if (cluster_type == pcmk_cluster_unknown) {
 367         crm_notice("Could not determine the current cluster type");
 368 
 369     } else if (cluster_type == pcmk_cluster_invalid) {
 370         crm_notice("This installation does not support the '%s' cluster infrastructure: terminating.",
 371                    cluster);
 372         crm_exit(CRM_EX_FATAL);
 373 
 374     } else {
 375         crm_info("%s an active '%s' cluster",
 376                  (detected? "Detected" : "Assuming"),
 377                  name_for_cluster_type(cluster_type));
 378     }
 379 
 380     return cluster_type;
 381 }
 382 
 383 /*!
 384  * \brief Check whether the local cluster is a Corosync cluster
 385  *
 386  * \return TRUE if the local cluster is a Corosync cluster, otherwise FALSE
 387  */
 388 gboolean
 389 is_corosync_cluster(void)
     /*  */
 390 {
 391     return get_cluster_type() == pcmk_cluster_corosync;
 392 }
 393 
 394 // Deprecated functions kept only for backward API compatibility
 395 // LCOV_EXCL_START
 396 
 397 #include <crm/cluster/compat.h>
 398 
 399 void
 400 set_uuid(xmlNode *xml, const char *attr, crm_node_t *node)
     /*  */
 401 {
 402     crm_xml_add(xml, attr, crm_peer_uuid(node));
 403 }
 404 
 405 // LCOV_EXCL_STOP
 406 // End deprecated API

/* */