Merge pull request #4005 from clumens/fenced-ipc-cleanup

Standardize fenced IPC/corosync code

Author: nrwahl2

daemons/attrd/attrd_corosync.c

@@ -23,6 +23,8 @@
 
 #include "pacemaker-attrd.h"
 
+pcmk_cluster_t *attrd_cluster = NULL;
+
 /*!
  * \internal
  * \brief Nodes removed by \c attrd_peer_remove()
@@ -133,21 +135,31 @@ attrd_peer_message(pcmk__node_status_t *peer, xmlNode *xml)
     }
 }
 
+#if SUPPORT_COROSYNC
+/*!
+ * \internal
+ * \brief Callback for when a peer message is received
+ *
+ * \param[in]     handle     The cluster connection
+ * \param[in]     group_name The group that \p nodeid is a member of
+ * \param[in]     nodeid     Peer node that sent \p msg
+ * \param[in]     pid        Process that sent \p msg
+ * \param[in,out] msg        Received message
+ * \param[in]     msg_len    Length of \p msg
+ */
 static void
-attrd_cpg_dispatch(cpg_handle_t handle,
-                 const struct cpg_name *groupName,
-                 uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len)
+attrd_cpg_dispatch(cpg_handle_t handle, const struct cpg_name *group_name,
+                   uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len)
 {
     xmlNode *xml = NULL;
     const char *from = NULL;
     char *data = pcmk__cpg_message_data(handle, nodeid, pid, msg, &from);
 
-    if(data == NULL) {
+    if (data == NULL) {
         return;
     }
 
     xml = pcmk__xml_parse(data);
-
     if (xml == NULL) {
         crm_err("Bad message received from %s[%" PRIu32 "]: '%.120s'",
                 from, nodeid, data);
@@ -161,6 +173,12 @@ attrd_cpg_dispatch(cpg_handle_t handle,
     free(data);
 }
 
+/*!
+ * \internal
+ * \brief Callback for when the cluster object is destroyed
+ *
+ * \param[in] unused Unused
+ */
 static void
 attrd_cpg_destroy(gpointer unused)
 {
@@ -173,6 +191,7 @@ attrd_cpg_destroy(gpointer unused)
         attrd_shutdown(0);
     }
 }
+#endif // SUPPORT_COROSYNC
 
 /*!
  * \internal
@@ -194,6 +213,14 @@ attrd_broadcast_value(const attribute_t *a, const attribute_value_t *v)
 
 #define state_text(state) pcmk__s((state), "in unknown state")
 
+/*!
+ * \internal
+ * \brief Callback for peer status changes
+ *
+ * \param[in] type  What changed
+ * \param[in] node  What peer had the change
+ * \param[in] data  Previous value of what changed
+ */
 static void
 attrd_peer_change_cb(enum pcmk__node_update kind, pcmk__node_status_t *peer,
                      const void *data)
@@ -462,19 +489,29 @@ attrd_cluster_connect(void)
 
     attrd_cluster = pcmk_cluster_new();
 
-    pcmk_cluster_set_destroy_fn(attrd_cluster, attrd_cpg_destroy);
-    pcmk_cpg_set_deliver_fn(attrd_cluster, attrd_cpg_dispatch);
-    pcmk_cpg_set_confchg_fn(attrd_cluster, pcmk__cpg_confchg_cb);
+#if SUPPORT_COROSYNC
+    if (pcmk_get_cluster_layer() == pcmk_cluster_layer_corosync) {
+        pcmk_cluster_set_destroy_fn(attrd_cluster, attrd_cpg_destroy);
+        pcmk_cpg_set_deliver_fn(attrd_cluster, attrd_cpg_dispatch);
+        pcmk_cpg_set_confchg_fn(attrd_cluster, pcmk__cpg_confchg_cb);
+    }
+#endif // SUPPORT_COROSYNC
 
     pcmk__cluster_set_status_callback(&attrd_peer_change_cb);
 
     rc = pcmk_cluster_connect(attrd_cluster);
-    rc = pcmk_rc2legacy(rc);
-    if (rc != pcmk_ok) {
+    if (rc != pcmk_rc_ok) {
         crm_err("Cluster connection failed");
-        return rc;
     }
-    return pcmk_ok;
+
+    return rc;
+}
+
+void
+attrd_cluster_disconnect(void)
+{
+    pcmk_cluster_disconnect(attrd_cluster);
+    pcmk_cluster_free(attrd_cluster);
 }
 
 void

daemons/attrd/attrd_messages.c

@@ -55,7 +55,8 @@ remove_unsupported_sync_points(pcmk__request_t *request)
 static xmlNode *
 handle_unknown_request(pcmk__request_t *request)
 {
-    crm_err("Unknown IPC request %s from %s %s",
+    crm_err("Unknown %s request %s from %s %s",
+            (request->ipc_client != NULL) ? "IPC" : "CPG",
             request->op, pcmk__request_origin_type(request),
             pcmk__request_origin(request));
     pcmk__format_result(&request->result, CRM_EX_PROTOCOL, PCMK_EXEC_INVALID,
@@ -104,54 +105,56 @@ handle_clear_failure_request(pcmk__request_t *request)
 static xmlNode *
 handle_confirm_request(pcmk__request_t *request)
 {
-    if (request->peer != NULL) {
-        int callid;
+    int callid = 0;
 
-        crm_debug("Received confirmation from %s", request->peer);
+    if (request->ipc_client != NULL) {
+        return handle_unknown_request(request);
+    }
 
-        if (pcmk__xe_get_int(request->xml, PCMK__XA_CALL_ID,
-                             &callid) != pcmk_rc_ok) {
-            pcmk__set_result(&request->result, CRM_EX_PROTOCOL, PCMK_EXEC_INVALID,
-                             "Could not get callid from XML");
-        } else {
-            attrd_handle_confirmation(callid, request->peer);
-        }
+    crm_debug("Received confirmation from %s", request->peer);
 
-        pcmk__set_result(&request->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
-        return NULL;
+    if (pcmk__xe_get_int(request->xml, PCMK__XA_CALL_ID,
+                         &callid) != pcmk_rc_ok) {
+        pcmk__set_result(&request->result, CRM_EX_PROTOCOL, PCMK_EXEC_INVALID,
+                         "Could not get callid from XML");
     } else {
-        return handle_unknown_request(request);
+        attrd_handle_confirmation(callid, request->peer);
     }
+
+    pcmk__set_result(&request->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
+    return NULL;
 }
 
 static xmlNode *
 handle_query_request(pcmk__request_t *request)
 {
     if (request->peer != NULL) {
         return handle_unknown_request(request);
-    } else {
-        return attrd_client_query(request);
     }
+
+    return attrd_client_query(request);
 }
 
 static xmlNode *
 handle_remove_request(pcmk__request_t *request)
 {
-    if (request->peer != NULL) {
-        const char *host = pcmk__xe_get(request->xml, PCMK__XA_ATTR_HOST);
-        bool reap = false;
-
-        if (pcmk__xe_get_bool(request->xml, PCMK__XA_REAP,
-                              &reap) != pcmk_rc_ok) {
-            reap = true; // Default to true for backward compatibility
-        }
-        attrd_peer_remove(host, reap, request->peer);
-        pcmk__set_result(&request->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
+    const char *host = NULL;
+    bool reap = false;
 
-    } else {
+    if (request->ipc_client != NULL) {
         attrd_client_peer_remove(request);
+        return NULL;
     }
 
+    host = pcmk__xe_get(request->xml, PCMK__XA_ATTR_HOST);
+
+    if (pcmk__xe_get_bool(request->xml, PCMK__XA_REAP,
+                          &reap) != pcmk_rc_ok) {
+        reap = true; // Default to true for backward compatibility
+    }
+
+    attrd_peer_remove(host, reap, request->peer);
+    pcmk__set_result(&request->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
     return NULL;
 }
 
@@ -161,31 +164,32 @@ handle_refresh_request(pcmk__request_t *request)
     if (request->peer != NULL) {
         return handle_unknown_request(request);
     }
+
     attrd_client_refresh(request);
     return NULL;
 }
 
 static xmlNode *
 handle_sync_response_request(pcmk__request_t *request)
 {
+    pcmk__node_status_t *peer = NULL;
+    bool peer_won = false;
+
     if (request->ipc_client != NULL) {
         return handle_unknown_request(request);
-    } else {
-        if (request->peer != NULL) {
-            pcmk__node_status_t *peer =
-                pcmk__get_node(0, request->peer, NULL,
-                               pcmk__node_search_cluster_member);
-            bool peer_won = attrd_check_for_new_writer(peer, request->xml);
-
-            if (!pcmk__str_eq(peer->name, attrd_cluster->priv->node_name,
-                              pcmk__str_casei)) {
-                attrd_peer_sync_response(peer, peer_won, request->xml);
-            }
-        }
+    }
 
-        pcmk__set_result(&request->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
-        return NULL;
+    peer = pcmk__get_node(0, request->peer, NULL,
+                          pcmk__node_search_cluster_member);
+    peer_won = attrd_check_for_new_writer(peer, request->xml);
+
+    if (!pcmk__str_eq(peer->name, attrd_cluster->priv->node_name,
+                      pcmk__str_casei)) {
+        attrd_peer_sync_response(peer, peer_won, request->xml);
     }
+
+    pcmk__set_result(&request->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
+    return NULL;
 }
 
 static xmlNode *

daemons/attrd/pacemaker-attrd.c

@@ -56,7 +56,6 @@ static pcmk__supported_format_t formats[] = {
 };
 
 lrmd_t *the_lrmd = NULL;
-pcmk_cluster_t *attrd_cluster = NULL;
 crm_trigger_t *attrd_config_read = NULL;
 crm_exit_t attrd_exit_status = CRM_EX_OK;
 
@@ -73,7 +72,7 @@ ipc_already_running(void)
 
     rc = pcmk__connect_ipc(old_instance, pcmk_ipc_dispatch_sync, 2);
     if (rc != pcmk_rc_ok) {
-        crm_debug("No existing %s manager instance found: %s",
+        crm_debug("No existing %s instance found: %s",
                   pcmk_ipc_name(old_instance, true), pcmk_rc_str(rc));
         pcmk_free_ipc_api(old_instance);
         return false;
@@ -164,12 +163,13 @@ main(int argc, char **argv)
         crm_info("CIB connection active");
     }
 
-    if (attrd_cluster_connect() != pcmk_ok) {
+    if (attrd_cluster_connect() != pcmk_rc_ok) {
         attrd_exit_status = CRM_EX_FATAL;
         g_set_error(&error, PCMK__EXITC_ERROR, attrd_exit_status,
                     "Could not connect to the cluster");
         goto done;
     }
+
     crm_info("Cluster connection active");
 
     // Initialization that requires the cluster to be connected
@@ -203,8 +203,7 @@ main(int argc, char **argv)
 
         attrd_free_removed_peers();
         attrd_free_waitlist();
-        pcmk_cluster_disconnect(attrd_cluster);
-        pcmk_cluster_free(attrd_cluster);
+        attrd_cluster_disconnect();
         g_hash_table_destroy(attributes);
     }
 

daemons/attrd/pacemaker-attrd.h

@@ -191,6 +191,7 @@ void attrd_free_removed_peers(void);
 void attrd_erase_removed_peer_attributes(void);
 
 int attrd_cluster_connect(void);
+void attrd_cluster_disconnect(void);
 void attrd_broadcast_value(const attribute_t *a, const attribute_value_t *v);
 void attrd_peer_update(const pcmk__node_status_t *peer, xmlNode *xml,
                        const char *host, bool filter);

daemons/execd/execd_messages.c

@@ -402,7 +402,7 @@ handle_unknown_request(pcmk__request_t *request)
                        PCMK__XE_NACK, NULL, CRM_EX_PROTOCOL);
 
     pcmk__format_result(&request->result, CRM_EX_PROTOCOL, PCMK_EXEC_INVALID,
-                        "Unknown IPC request type '%s' (bug?)",
+                        "Unknown request type '%s' (bug?)",
                         pcmk__s(request->op, ""));
     return NULL;
 }

daemons/fenced/Makefile.am

@@ -2,7 +2,7 @@
 # Original Author: Sun Jiang Dong <sunjd@cn.ibm.com>
 # Copyright 2004 International Business Machines
 #
-# with later changes copyright 2004-2024 the Pacemaker project contributors.
+# with later changes copyright 2004-2025 the Pacemaker project contributors.
 # The version control history for this file may have further details.
 #
 # This source code is licensed under the GNU General Public License version 2
@@ -42,6 +42,8 @@ pacemaker_fenced_LDADD += $(CLUSTERLIBS)
 pacemaker_fenced_SOURCES	= pacemaker-fenced.c	\
 				  fenced_cib.c		\
 				  fenced_commands.c	\
+				  fenced_corosync.c	\
+				  fenced_ipc.c		\
 				  fenced_remote.c	\
 				  fenced_scheduler.c	\
 				  fenced_history.c