From de05f6b52c667155d262ceeb541dc1041d079d71 Mon Sep 17 00:00:00 2001

From: Chris Lumens <clumens@redhat.com>

Date: Thu, 8 Sep 2022 11:36:58 -0400

Subject: [PATCH 01/26] Refactor: tools: Use a uint32_t for attr_options.

---

 tools/attrd_updater.c | 2 +-

 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/attrd_updater.c b/tools/attrd_updater.c

index d90567a..b85a281 100644

--- a/tools/attrd_updater.c

+++ b/tools/attrd_updater.c

@@ -47,7 +47,7 @@ struct {

     gchar *attr_node;

     gchar *attr_set;

     char *attr_value;

-    int attr_options;

+    uint32_t attr_options;

     gboolean query_all;

     gboolean quiet;

 } options = {

-- 

2.31.1

From c6637520b474d44553ade52c0dbe9e36e873135f Mon Sep 17 00:00:00 2001

From: Chris Lumens <clumens@redhat.com>

Date: Fri, 21 Oct 2022 14:31:16 -0400

Subject: [PATCH 02/26] Refactor: libcrmcommon: Make pcmk__xe_match more

 broadly useful.

If attr_v is NULL, simply return the first node with a matching name.

---

 lib/common/xml.c | 10 ++++++----

 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/lib/common/xml.c b/lib/common/xml.c

index 036dd87..ac6f46a 100644

--- a/lib/common/xml.c

+++ b/lib/common/xml.c

@@ -510,7 +510,7 @@ find_xml_node(const xmlNode *root, const char *search_path, gboolean must_find)

  * \param[in] parent     XML element to search

  * \param[in] node_name  If not NULL, only match children of this type

  * \param[in] attr_n     If not NULL, only match children with an attribute

- *                       of this name and a value of \p attr_v

+ *                       of this name.

  * \param[in] attr_v     If \p attr_n and this are not NULL, only match children

  *                       with an attribute named \p attr_n and this value

  *

@@ -520,14 +520,16 @@ xmlNode *

 pcmk__xe_match(const xmlNode *parent, const char *node_name,

                const char *attr_n, const char *attr_v)

 {

-    /* ensure attr_v specified when attr_n is */

-    CRM_CHECK(attr_n == NULL || attr_v != NULL, return NULL);

+    CRM_CHECK(parent != NULL, return NULL);

+    CRM_CHECK(attr_v == NULL || attr_n != NULL, return NULL);

     for (xmlNode *child = pcmk__xml_first_child(parent); child != NULL;

          child = pcmk__xml_next(child)) {

         if (pcmk__str_eq(node_name, (const char *) (child->name),

                          pcmk__str_null_matches)

-            && ((attr_n == NULL) || attr_matches(child, attr_n, attr_v))) {

+            && ((attr_n == NULL) ||

+                (attr_v == NULL && xmlHasProp(child, (pcmkXmlStr) attr_n)) ||

+                (attr_v != NULL && attr_matches(child, attr_n, attr_v)))) {

             return child;

         }

     }

-- 

2.31.1

From dd520579484c6ec091f7fbb550347941302dad0e Mon Sep 17 00:00:00 2001

From: Chris Lumens <clumens@redhat.com>

Date: Fri, 21 Oct 2022 14:32:46 -0400

Subject: [PATCH 03/26] Tests: libcrmcommon: Add tests for pcmk__xe_match.

---

 lib/common/tests/xml/Makefile.am           |   3 +-

 lib/common/tests/xml/pcmk__xe_match_test.c | 105 +++++++++++++++++++++

 2 files changed, 107 insertions(+), 1 deletion(-)

 create mode 100644 lib/common/tests/xml/pcmk__xe_match_test.c

diff --git a/lib/common/tests/xml/Makefile.am b/lib/common/tests/xml/Makefile.am

index 342ca07..0ccdcc3 100644

--- a/lib/common/tests/xml/Makefile.am

+++ b/lib/common/tests/xml/Makefile.am

@@ -11,6 +11,7 @@ include $(top_srcdir)/mk/tap.mk

 include $(top_srcdir)/mk/unittest.mk

 # Add "_test" to the end of all test program names to simplify .gitignore.

-check_PROGRAMS =	pcmk__xe_foreach_child_test

+check_PROGRAMS =	pcmk__xe_foreach_child_test \

+					pcmk__xe_match_test

 TESTS = $(check_PROGRAMS)

diff --git a/lib/common/tests/xml/pcmk__xe_match_test.c b/lib/common/tests/xml/pcmk__xe_match_test.c

new file mode 100644

index 0000000..fd529ba

--- /dev/null

+++ b/lib/common/tests/xml/pcmk__xe_match_test.c

@@ -0,0 +1,105 @@

+/*

+ * Copyright 2022 the Pacemaker project contributors

+ *

+ * The version control history for this file may have further details.

+ *

+ * This source code is licensed under the GNU Lesser General Public License

+ * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.

+ */

+

+#include <crm_internal.h>

+

+#include <crm/common/unittest_internal.h>

+#include <crm/common/xml_internal.h>

+

+const char *str1 =

+    "<xml>\n"

+    "  \n"

+    "  <nodeA attrA=\"123\" id=\"1\">\n"

+    "    content\n"

+    "  </nodeA>\n"

+    "  \n"

+    "  <nodeA attrA=\"456\" id=\"2\">\n"

+    "    content\n"

+    "  </nodeA>\n"

+    "  \n"

+    "  <nodeA attrB=\"XYZ\" id=\"3\">\n"

+    "    content\n"

+    "  </nodeA>\n"

+    "  \n"

+    "  <nodeB attrA=\"123\" id=\"4\">\n"

+    "    content\n"

+    "  </nodeA>\n"

+    "  \n"

+    "  <nodeB attrB=\"ABC\" id=\"5\">\n"

+    "    content\n"

+    "  </nodeA>\n"

+    "</xml>";

+

+static void

+bad_input(void **state) {

+    xmlNode *xml = string2xml(str1);

+

+    assert_null(pcmk__xe_match(NULL, NULL, NULL, NULL));

+    assert_null(pcmk__xe_match(NULL, NULL, NULL, "attrX"));

+

+    free_xml(xml);

+}

+

+static void

+not_found(void **state) {

+    xmlNode *xml = string2xml(str1);

+

+    /* No node with an attrX attribute */

+    assert_null(pcmk__xe_match(xml, NULL, "attrX", NULL));

+    /* No nodeX node */

+    assert_null(pcmk__xe_match(xml, "nodeX", NULL, NULL));

+    /* No nodeA node with attrX */

+    assert_null(pcmk__xe_match(xml, "nodeA", "attrX", NULL));

+    /* No nodeA node with attrA=XYZ */

+    assert_null(pcmk__xe_match(xml, "nodeA", "attrA", "XYZ"));

+

+    free_xml(xml);

+}

+

+static void

+find_attrB(void **state) {

+    xmlNode *xml = string2xml(str1);

+    xmlNode *result = NULL;

+

+    /* Find the first node with attrB */

+    result = pcmk__xe_match(xml, NULL, "attrB", NULL);

+    assert_non_null(result);

+    assert_string_equal(crm_element_value(result, "id"), "3");

+

+    /* Find the first nodeB with attrB */

+    result = pcmk__xe_match(xml, "nodeB", "attrB", NULL);

+    assert_non_null(result);

+    assert_string_equal(crm_element_value(result, "id"), "5");

+

+    free_xml(xml);

+}

+

+static void

+find_attrA_matching(void **state) {

+    xmlNode *xml = string2xml(str1);

+    xmlNode *result = NULL;

+

+    /* Find attrA=456 */

+    result = pcmk__xe_match(xml, NULL, "attrA", "456");

+    assert_non_null(result);

+    assert_string_equal(crm_element_value(result, "id"), "2");

+

+    /* Find a nodeB with attrA=123 */

+    result = pcmk__xe_match(xml, "nodeB", "attrA", "123");

+    assert_non_null(result);

+    assert_string_equal(crm_element_value(result, "id"), "4");

+

+    free_xml(xml);

+}

+

+PCMK__UNIT_TEST(NULL, NULL,

+                cmocka_unit_test(bad_input),

+                cmocka_unit_test(not_found),

+                cmocka_unit_test(find_attrB),

+                cmocka_unit_test(find_attrA_matching));

-- 

2.31.1

From 03af8498d8aaf21c509cec9b0ec4b78475da41d7 Mon Sep 17 00:00:00 2001

From: Chris Lumens <clumens@redhat.com>

Date: Thu, 8 Sep 2022 12:22:26 -0400

Subject: [PATCH 04/26] Feature: libcrmcommon: Add attrd options for specifying

 a sync point.

---

 include/crm/common/attrd_internal.h | 16 +++++++++-------

 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/include/crm/common/attrd_internal.h b/include/crm/common/attrd_internal.h

index f7033ad..389be48 100644

--- a/include/crm/common/attrd_internal.h

+++ b/include/crm/common/attrd_internal.h

@@ -16,13 +16,15 @@ extern "C" {

 // Options for clients to use with functions below

 enum pcmk__node_attr_opts {

-    pcmk__node_attr_none    = 0,

-    pcmk__node_attr_remote  = (1 << 0),

-    pcmk__node_attr_private = (1 << 1),

-    pcmk__node_attr_pattern = (1 << 2),

-    pcmk__node_attr_value   = (1 << 3),

-    pcmk__node_attr_delay   = (1 << 4),

-    pcmk__node_attr_perm    = (1 << 5),

+    pcmk__node_attr_none           = 0,

+    pcmk__node_attr_remote         = (1 << 0),

+    pcmk__node_attr_private        = (1 << 1),

+    pcmk__node_attr_pattern        = (1 << 2),

+    pcmk__node_attr_value          = (1 << 3),

+    pcmk__node_attr_delay          = (1 << 4),

+    pcmk__node_attr_perm           = (1 << 5),

+    pcmk__node_attr_sync_local     = (1 << 6),

+    pcmk__node_attr_sync_cluster   = (1 << 7),

 };

 #define pcmk__set_node_attr_flags(node_attr_flags, flags_to_set) do {   \

-- 

2.31.1

From 5c8825293ee21d3823bdcd01b0df9c7d39739940 Mon Sep 17 00:00:00 2001

From: Chris Lumens <clumens@redhat.com>

Date: Thu, 8 Sep 2022 12:23:09 -0400

Subject: [PATCH 05/26] Feature: libcrmcommon: Add sync point to IPC request

 XML.

If one of the pcmk__node_attr_sync_* options is provided, add an

attribute to the request XML.  This will later be inspected by the

server to determine when to send the reply to the client.

---

 include/crm/common/options_internal.h | 2 ++

 include/crm_internal.h                | 1 +

 lib/common/ipc_attrd.c                | 6 ++++++

 3 files changed, 9 insertions(+)

diff --git a/include/crm/common/options_internal.h b/include/crm/common/options_internal.h

index b153c67..f29ba3f 100644

--- a/include/crm/common/options_internal.h

+++ b/include/crm/common/options_internal.h

@@ -145,9 +145,11 @@ bool pcmk__valid_sbd_timeout(const char *value);

 #define PCMK__META_ALLOW_UNHEALTHY_NODES    "allow-unhealthy-nodes"

 // Constants for enumerated values for various options

+#define PCMK__VALUE_CLUSTER                 "cluster"

 #define PCMK__VALUE_CUSTOM                  "custom"

 #define PCMK__VALUE_FENCING                 "fencing"

 #define PCMK__VALUE_GREEN                   "green"

+#define PCMK__VALUE_LOCAL                   "local"

 #define PCMK__VALUE_MIGRATE_ON_RED          "migrate-on-red"

 #define PCMK__VALUE_NONE                    "none"

 #define PCMK__VALUE_NOTHING                 "nothing"

diff --git a/include/crm_internal.h b/include/crm_internal.h

index e6e2e96..08193c3 100644

--- a/include/crm_internal.h

+++ b/include/crm_internal.h

@@ -71,6 +71,7 @@

 #define PCMK__XA_ATTR_RESOURCE          "attr_resource"

 #define PCMK__XA_ATTR_SECTION           "attr_section"

 #define PCMK__XA_ATTR_SET               "attr_set"

+#define PCMK__XA_ATTR_SYNC_POINT        "attr_sync_point"

 #define PCMK__XA_ATTR_USER              "attr_user"

 #define PCMK__XA_ATTR_UUID              "attr_key"

 #define PCMK__XA_ATTR_VALUE             "attr_value"

diff --git a/lib/common/ipc_attrd.c b/lib/common/ipc_attrd.c

index f6cfbc4..4606509 100644

--- a/lib/common/ipc_attrd.c

+++ b/lib/common/ipc_attrd.c

@@ -431,6 +431,12 @@ populate_update_op(xmlNode *op, const char *node, const char *name, const char *

                     pcmk_is_set(options, pcmk__node_attr_remote));

     crm_xml_add_int(op, PCMK__XA_ATTR_IS_PRIVATE,

                     pcmk_is_set(options, pcmk__node_attr_private));

+

+    if (pcmk_is_set(options, pcmk__node_attr_sync_local)) {

+        crm_xml_add(op, PCMK__XA_ATTR_SYNC_POINT, PCMK__VALUE_LOCAL);

+    } else if (pcmk_is_set(options, pcmk__node_attr_sync_cluster)) {

+        crm_xml_add(op, PCMK__XA_ATTR_SYNC_POINT, PCMK__VALUE_CLUSTER);

+    }

 }

 int

-- 

2.31.1

From e2b3fee630caf0846ca8bbffcef4d6d2acfd32a5 Mon Sep 17 00:00:00 2001

From: Chris Lumens <clumens@redhat.com>

Date: Thu, 8 Sep 2022 12:26:28 -0400

Subject: [PATCH 06/26] Feature: tools: Add --wait= parameter to attrd_updater.

This command line option is used to specify the sync point to use.  For

the moment, it has no effect.

---

 tools/attrd_updater.c | 24 ++++++++++++++++++++++++

 1 file changed, 24 insertions(+)

diff --git a/tools/attrd_updater.c b/tools/attrd_updater.c

index b85a281..c4779a6 100644

--- a/tools/attrd_updater.c

+++ b/tools/attrd_updater.c

@@ -97,6 +97,22 @@ section_cb (const gchar *option_name, const gchar *optarg, gpointer data, GError

     return TRUE;

 }

+static gboolean

+wait_cb (const gchar *option_name, const gchar *optarg, gpointer data, GError **err) {

+    if (pcmk__str_eq(optarg, "no", pcmk__str_none)) {

+        pcmk__clear_node_attr_flags(options.attr_options, pcmk__node_attr_sync_local | pcmk__node_attr_sync_cluster);

+        return TRUE;

+    } else if (pcmk__str_eq(optarg, PCMK__VALUE_LOCAL, pcmk__str_none)) {

+        pcmk__clear_node_attr_flags(options.attr_options, pcmk__node_attr_sync_local | pcmk__node_attr_sync_cluster);

+        pcmk__set_node_attr_flags(options.attr_options, pcmk__node_attr_sync_local);

+        return TRUE;

+    } else {

+        g_set_error(err, PCMK__EXITC_ERROR, CRM_EX_USAGE,

+                    "--wait= must be one of 'no', 'local', 'cluster'");

+        return FALSE;

+    }

+}

+

 #define INDENT "                              "

 static GOptionEntry required_entries[] = {

@@ -175,6 +191,14 @@ static GOptionEntry addl_entries[] = {

       "If this creates a new attribute, never write the attribute to CIB",

       NULL },

+    { "wait", 'W', 0, G_OPTION_ARG_CALLBACK, wait_cb,

+      "Wait for some event to occur before returning.  Values are 'no' (wait\n"

+      INDENT "only for the attribute daemon to acknowledge the request) or\n"

+      INDENT "'local' (wait until the change has propagated to where a local\n"

+      INDENT "query will return the request value, or the value set by a\n"

+      INDENT "later request).  Default is 'no'.",

+      "UNTIL" },

+

     { NULL }

 };

-- 

2.31.1

From 52d51ab41b2f00e72724ab39835b3db86605a96b Mon Sep 17 00:00:00 2001

From: Chris Lumens <clumens@redhat.com>

Date: Thu, 20 Oct 2022 14:40:13 -0400

Subject: [PATCH 07/26] Feature: daemons: Add functions for checking a request

 for a sync point.

---

 daemons/attrd/Makefile.am       |  1 +

 daemons/attrd/attrd_sync.c      | 38 +++++++++++++++++++++++++++++++++

 daemons/attrd/pacemaker-attrd.h |  3 +++

 3 files changed, 42 insertions(+)

 create mode 100644 daemons/attrd/attrd_sync.c

diff --git a/daemons/attrd/Makefile.am b/daemons/attrd/Makefile.am

index 1a3d360..6bb81c4 100644

--- a/daemons/attrd/Makefile.am

+++ b/daemons/attrd/Makefile.am

@@ -32,6 +32,7 @@ pacemaker_attrd_SOURCES	= attrd_alerts.c 	\

 						  attrd_elections.c \

 						  attrd_ipc.c 		\

 						  attrd_messages.c 		\

+						  attrd_sync.c 		\

 						  attrd_utils.c 	\

 						  pacemaker-attrd.c

diff --git a/daemons/attrd/attrd_sync.c b/daemons/attrd/attrd_sync.c

new file mode 100644

index 0000000..92759d2

--- /dev/null

+++ b/daemons/attrd/attrd_sync.c

@@ -0,0 +1,38 @@

+/*

+ * Copyright 2022 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

+ * or later (GPLv2+) WITHOUT ANY WARRANTY.

+ */

+

+#include <crm_internal.h>

+

+#include <crm/msg_xml.h>

+#include <crm/common/attrd_internal.h>

+

+#include "pacemaker-attrd.h"

+

+const char *

+attrd_request_sync_point(xmlNode *xml)

+{

+    if (xml_has_children(xml)) {

+        xmlNode *child = pcmk__xe_match(xml, XML_ATTR_OP, PCMK__XA_ATTR_SYNC_POINT, NULL);

+

+        if (child) {

+            return crm_element_value(child, PCMK__XA_ATTR_SYNC_POINT);

+        } else {

+            return NULL;

+        }

+

+    } else {

+        return crm_element_value(xml, PCMK__XA_ATTR_SYNC_POINT);

+    }

+}

+

+bool

+attrd_request_has_sync_point(xmlNode *xml)

+{

+    return attrd_request_sync_point(xml) != NULL;

+}

diff --git a/daemons/attrd/pacemaker-attrd.h b/daemons/attrd/pacemaker-attrd.h

index 71ce90a..ff850bb 100644

--- a/daemons/attrd/pacemaker-attrd.h

+++ b/daemons/attrd/pacemaker-attrd.h

@@ -182,4 +182,7 @@ mainloop_timer_t *attrd_add_timer(const char *id, int timeout_ms, attribute_t *a

 void attrd_unregister_handlers(void);

 void attrd_handle_request(pcmk__request_t *request);

+const char *attrd_request_sync_point(xmlNode *xml);

+bool attrd_request_has_sync_point(xmlNode *xml);

+

 #endif /* PACEMAKER_ATTRD__H */

-- 

2.31.1

From 2e0509a12ee7d4a612133ee65b75245eea7d271d Mon Sep 17 00:00:00 2001

From: Chris Lumens <clumens@redhat.com>

Date: Thu, 20 Oct 2022 14:42:04 -0400

Subject: [PATCH 08/26] Refactor: daemons: Don't ACK update requests that give

 a sync point.

The ACK is the only response from the server for update messages.  If

the message specified that it wanted to wait for a sync point, we need

to delay sending that response until the sync point is reached.

Therefore, do not always immediately send the ACK.

---

 daemons/attrd/attrd_messages.c | 19 ++++++++++++++-----

 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/daemons/attrd/attrd_messages.c b/daemons/attrd/attrd_messages.c

index de4a28a..9e8ae40 100644

--- a/daemons/attrd/attrd_messages.c

+++ b/daemons/attrd/attrd_messages.c

@@ -137,12 +137,21 @@ handle_update_request(pcmk__request_t *request)

         attrd_peer_update(peer, request->xml, host, false);

         pcmk__set_result(&request->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);

         return NULL;

+

     } else {

-        /* Because attrd_client_update can be called recursively, we send the ACK

-         * here to ensure that the client only ever receives one.

-         */

-        attrd_send_ack(request->ipc_client, request->ipc_id,

-                       request->flags|crm_ipc_client_response);

+        if (!attrd_request_has_sync_point(request->xml)) {

+            /* If the client doesn't want to wait for a sync point, go ahead and send

+             * the ACK immediately.  Otherwise, we'll send the ACK when the appropriate

+             * sync point is reached.

+             *

+             * In the normal case, attrd_client_update can be called recursively which

+             * makes where to send the ACK tricky.  Doing it here ensures the client

+             * only ever receives one.

+             */

+            attrd_send_ack(request->ipc_client, request->ipc_id,

+                           request->flags|crm_ipc_client_response);

+        }

+

         return attrd_client_update(request);

     }

 }

-- 

2.31.1

From 2a0ff66cdf0085c4c8ab1992ef7e785a4facc8c7 Mon Sep 17 00:00:00 2001

From: Chris Lumens <clumens@redhat.com>

Date: Thu, 20 Oct 2022 14:48:48 -0400

Subject: [PATCH 09/26] Feature: daemons: Add support for local sync points on

 updates.

In the IPC dispatcher for attrd, add the client to a wait list if its

request specifies a sync point.  When the attribute's value is changed

on the local attrd, alert any clients waiting on a local sync point by

then sending the previously delayed ACK.

Sync points for other requests and the global sync point are not yet

supported.

Fixes T35.

---

 daemons/attrd/attrd_corosync.c  |  18 +++++

 daemons/attrd/attrd_messages.c  |  12 ++-

 daemons/attrd/attrd_sync.c      | 137 ++++++++++++++++++++++++++++++++

 daemons/attrd/pacemaker-attrd.h |   7 ++

 4 files changed, 173 insertions(+), 1 deletion(-)

diff --git a/daemons/attrd/attrd_corosync.c b/daemons/attrd/attrd_corosync.c

index 539e5bf..4337280 100644

--- a/daemons/attrd/attrd_corosync.c

+++ b/daemons/attrd/attrd_corosync.c

@@ -568,14 +568,32 @@ void

 attrd_peer_update(const crm_node_t *peer, xmlNode *xml, const char *host,

                   bool filter)

 {

+    bool handle_sync_point = false;

+

     if (xml_has_children(xml)) {

         for (xmlNode *child = first_named_child(xml, XML_ATTR_OP); child != NULL;

              child = crm_next_same_xml(child)) {

             copy_attrs(xml, child);

             attrd_peer_update_one(peer, child, filter);

+

+            if (attrd_request_has_sync_point(child)) {

+                handle_sync_point = true;

+            }

         }

     } else {

         attrd_peer_update_one(peer, xml, filter);

+

+        if (attrd_request_has_sync_point(xml)) {

+            handle_sync_point = true;

+        }

+    }

+

+    /* If the update XML specified that the client wanted to wait for a sync

+     * point, process that now.

+     */

+    if (handle_sync_point) {

+        crm_debug("Hit local sync point for attribute update");

+        attrd_ack_waitlist_clients(attrd_sync_point_local, xml);

     }

 }

diff --git a/daemons/attrd/attrd_messages.c b/daemons/attrd/attrd_messages.c

index 9e8ae40..c96700f 100644

--- a/daemons/attrd/attrd_messages.c

+++ b/daemons/attrd/attrd_messages.c

@@ -139,7 +139,17 @@ handle_update_request(pcmk__request_t *request)

         return NULL;

     } else {

-        if (!attrd_request_has_sync_point(request->xml)) {

+        if (attrd_request_has_sync_point(request->xml)) {

+            /* If this client supplied a sync point it wants to wait for, add it to

+             * the wait list.  Clients on this list will not receive an ACK until

+             * their sync point is hit which will result in the client stalled there

+             * until it receives a response.

+             *

+             * All other clients will receive the expected response as normal.

+             */

+            attrd_add_client_to_waitlist(request);

+

+        } else {

             /* If the client doesn't want to wait for a sync point, go ahead and send

              * the ACK immediately.  Otherwise, we'll send the ACK when the appropriate

              * sync point is reached.

diff --git a/daemons/attrd/attrd_sync.c b/daemons/attrd/attrd_sync.c

index 92759d2..2981bd0 100644

--- a/daemons/attrd/attrd_sync.c

+++ b/daemons/attrd/attrd_sync.c

@@ -14,6 +14,143 @@

 #include "pacemaker-attrd.h"

+/* A hash table storing clients that are waiting on a sync point to be reached.

+ * The key is waitlist_client - just a plain int.  The obvious key would be

+ * the IPC client's ID, but this is not guaranteed to be unique.  A single client

+ * could be waiting on a sync point for multiple attributes at the same time.

+ *

+ * It is not expected that this hash table will ever be especially large.

+ */

+static GHashTable *waitlist = NULL;

+static int waitlist_client = 0;

+

+struct waitlist_node {

+    /* What kind of sync point does this node describe? */

+    enum attrd_sync_point sync_point;

+

+    /* Information required to construct and send a reply to the client. */

+    char *client_id;

+    uint32_t ipc_id;

+    uint32_t flags;

+};

+

+static void

+next_key(void)

+{

+    do {

+        waitlist_client++;

+        if (waitlist_client < 0) {

+            waitlist_client = 1;

+        }

+    } while (g_hash_table_contains(waitlist, GINT_TO_POINTER(waitlist_client)));

+}

+

+static void

+free_waitlist_node(gpointer data)

+{

+    struct waitlist_node *wl = (struct waitlist_node *) data;

+

+    free(wl->client_id);

+    free(wl);

+}

+

+static const char *

+sync_point_str(enum attrd_sync_point sync_point)

+{

+    if (sync_point == attrd_sync_point_local) {

+        return PCMK__VALUE_LOCAL;

+    } else if  (sync_point == attrd_sync_point_cluster) {

+        return PCMK__VALUE_CLUSTER;

+    } else {

+        return "unknown";

+    }

+}

+

+void

+attrd_add_client_to_waitlist(pcmk__request_t *request)

+{

+    const char *sync_point = attrd_request_sync_point(request->xml);

+    struct waitlist_node *wl = NULL;

+

+    if (sync_point == NULL) {

+        return;

+    }

+

+    if (waitlist == NULL) {

+        waitlist = pcmk__intkey_table(free_waitlist_node);

+    }

+

+    wl = calloc(sizeof(struct waitlist_node), 1);

+

+    CRM_ASSERT(wl != NULL);

+

+    wl->client_id = strdup(request->ipc_client->id);

+

+    CRM_ASSERT(wl->client_id);

+

+    if (pcmk__str_eq(sync_point, PCMK__VALUE_LOCAL, pcmk__str_none)) {

+        wl->sync_point = attrd_sync_point_local;

+    } else if (pcmk__str_eq(sync_point, PCMK__VALUE_CLUSTER, pcmk__str_none)) {

+        wl->sync_point = attrd_sync_point_cluster;

+    } else {

+        free_waitlist_node(wl);

+        return;

+    }

+

+    wl->ipc_id = request->ipc_id;

+    wl->flags = request->flags;

+

+    crm_debug("Added client %s to waitlist for %s sync point",

+              wl->client_id, sync_point_str(wl->sync_point));

+

+    next_key();

+    pcmk__intkey_table_insert(waitlist, waitlist_client, wl);

+

+    /* And then add the key to the request XML so we can uniquely identify

+     * it when it comes time to issue the ACK.

+     */

+    crm_xml_add_int(request->xml, XML_LRM_ATTR_CALLID, waitlist_client);

+}

+

+void

+attrd_ack_waitlist_clients(enum attrd_sync_point sync_point, const xmlNode *xml)

+{

+    int callid;

+    gpointer value;

+

+    if (waitlist == NULL) {

+        return;

+    }

+

+    if (crm_element_value_int(xml, XML_LRM_ATTR_CALLID, &callid) == -1) {

+        crm_warn("Could not get callid from request XML");

+        return;

+    }

+

+    value = pcmk__intkey_table_lookup(waitlist, callid);

+    if (value != NULL) {

+        struct waitlist_node *wl = (struct waitlist_node *) value;

+        pcmk__client_t *client = NULL;

+

+        if (wl->sync_point != sync_point) {

+            return;

+        }

+

+        crm_debug("Alerting client %s for reached %s sync point",

+                  wl->client_id, sync_point_str(wl->sync_point));

+

+        client = pcmk__find_client_by_id(wl->client_id);

+        if (client == NULL) {

+            return;