Refactor-and-deprecation preview dumping ground

daemons/attrd/attrd_alerts.c

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2024 the Pacemaker project contributors
+ * Copyright 2015-2025 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
@@ -26,7 +26,7 @@ attrd_lrmd_callback(lrmd_event_data_t * op)
     CRM_CHECK(op != NULL, return);
     switch (op->type) {
         case lrmd_event_disconnect:
-            crm_info("Lost connection to executor");
+            pcmk__info("Lost connection to executor");
             attrd_lrmd_disconnect();
             break;
         default:
@@ -52,8 +52,8 @@ attrd_lrmd_connect(void)
                 break;
             }
 
-            crm_debug("Could not connect to executor, %d tries remaining",
-                      (max_attempts - fails));
+            pcmk__debug("Could not connect to executor, %d tries remaining",
+                        (max_attempts - fails));
             /* @TODO We don't want to block here with sleep, but we should wait
              * some time between connection attempts. We could possibly add a
              * timer with a callback, but then we'd likely need an alert queue.
@@ -84,10 +84,10 @@ config_query_callback(xmlNode * msg, int call_id, int rc, xmlNode * output, void
     xmlNode *crmalerts = NULL;
 
     if (rc == -ENXIO) {
-        crm_debug("Local CIB has no alerts section");
+        pcmk__debug("Local CIB has no alerts section");
         return;
     } else if (rc != pcmk_ok) {
-        crm_notice("Could not query local CIB: %s", pcmk_strerror(rc));
+        pcmk__notice("Could not query local CIB: %s", pcmk_strerror(rc));
         return;
     }
 
@@ -96,7 +96,7 @@ config_query_callback(xmlNode * msg, int call_id, int rc, xmlNode * output, void
         crmalerts = pcmk__xe_first_child(crmalerts, PCMK_XE_ALERTS, NULL, NULL);
     }
     if (!crmalerts) {
-        crm_notice("CIB query result has no " PCMK_XE_ALERTS " section");
+        pcmk__notice("CIB query result has no " PCMK_XE_ALERTS " section");
         return;
     }
 
@@ -119,7 +119,7 @@ attrd_read_options(gpointer user_data)
                                           "config_query_callback",
                                           config_query_callback, free);
 
-    crm_trace("Querying the CIB... call %d", call_id);
+    pcmk__trace("Querying the CIB... call %d", call_id);
     return TRUE;
 }
 

daemons/attrd/attrd_attributes.c

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2024 the Pacemaker project contributors
+ * Copyright 2013-2025 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
@@ -26,9 +26,9 @@ attrd_create_attribute(xmlNode *xml)
 {
     int is_private = 0;
     long long dampen = 0;
-    const char *name = crm_element_value(xml, PCMK__XA_ATTR_NAME);
-    const char *set_type = crm_element_value(xml, PCMK__XA_ATTR_SET_TYPE);
-    const char *dampen_s = crm_element_value(xml, PCMK__XA_ATTR_DAMPENING);
+    const char *name = pcmk__xe_get(xml, PCMK__XA_ATTR_NAME);
+    const char *set_type = pcmk__xe_get(xml, PCMK__XA_ATTR_SET_TYPE);
+    const char *dampen_s = pcmk__xe_get(xml, PCMK__XA_ATTR_DAMPENING);
     attribute_t *a = NULL;
 
     if (set_type == NULL) {
@@ -38,42 +38,42 @@ attrd_create_attribute(xmlNode *xml)
     /* Set type is meaningful only when writing to the CIB. Private
      * attributes are not written.
      */
-    crm_element_value_int(xml, PCMK__XA_ATTR_IS_PRIVATE, &is_private);
+    pcmk__xe_get_int(xml, PCMK__XA_ATTR_IS_PRIVATE, &is_private);
     if (!is_private && !pcmk__str_any_of(set_type,
                                          PCMK_XE_INSTANCE_ATTRIBUTES,
                                          PCMK_XE_UTILIZATION, NULL)) {
-        crm_warn("Ignoring attribute %s with invalid set type %s",
-                 pcmk__s(name, "(unidentified)"), set_type);
+        pcmk__warn("Ignoring attribute %s with invalid set type %s",
+                   pcmk__s(name, "(unidentified)"), set_type);
         return NULL;
     }
 
     a = pcmk__assert_alloc(1, sizeof(attribute_t));
 
     a->id = pcmk__str_copy(name);
     a->set_type = pcmk__str_copy(set_type);
-    a->set_id = crm_element_value_copy(xml, PCMK__XA_ATTR_SET);
-    a->user = crm_element_value_copy(xml, PCMK__XA_ATTR_USER);
+    a->set_id = pcmk__xe_get_copy(xml, PCMK__XA_ATTR_SET);
+    a->user = pcmk__xe_get_copy(xml, PCMK__XA_ATTR_USER);
     a->values = pcmk__strikey_table(NULL, attrd_free_attribute_value);
 
     if (is_private) {
         attrd_set_attr_flags(a, attrd_attr_is_private);
     }
 
     if (dampen_s != NULL) {
-        dampen = crm_get_msec(dampen_s);
-    }
+        if ((pcmk__parse_ms(dampen_s, &dampen) != pcmk_rc_ok) || (dampen < 0)) {
+            pcmk__warn("Ignoring invalid delay %s for attribute %s", dampen_s,
+                       a->id);
 
-    if (dampen > 0) {
-        a->timeout_ms = (int) QB_MIN(dampen, INT_MAX);
-        a->timer = attrd_add_timer(a->id, a->timeout_ms, a);
-    } else if (dampen < 0) {
-        crm_warn("Ignoring invalid delay %s for attribute %s", dampen_s, a->id);
+        } else if (dampen > 0) {
+            a->timeout_ms = (int) QB_MIN(dampen, INT_MAX);
+            a->timer = attrd_add_timer(a->id, a->timeout_ms, a);
+        }
     }
 
-    crm_trace("Created attribute %s with %s write delay and %s CIB user",
-              a->id,
-              ((dampen > 0)? pcmk__readable_interval(a->timeout_ms) : "no"),
-              pcmk__s(a->user, "default"));
+    pcmk__trace("Created attribute %s with %s write delay and %s CIB user",
+                a->id,
+                ((dampen > 0)? pcmk__readable_interval(a->timeout_ms) : "no"),
+                pcmk__s(a->user, "default"));
 
     g_hash_table_replace(attributes, a->id, a);
     return a;
@@ -82,19 +82,18 @@ attrd_create_attribute(xmlNode *xml)
 static int
 attrd_update_dampening(attribute_t *a, xmlNode *xml, const char *attr)
 {
-    const char *dvalue = crm_element_value(xml, PCMK__XA_ATTR_DAMPENING);
+    const char *dvalue = pcmk__xe_get(xml, PCMK__XA_ATTR_DAMPENING);
     long long dampen = 0;
 
     if (dvalue == NULL) {
-        crm_warn("Could not update %s: peer did not specify value for delay",
-                 attr);
+        pcmk__warn("Could not update %s: peer did not specify value for delay",
+                   attr);
         return EINVAL;
     }
 
-    dampen = crm_get_msec(dvalue);
-    if (dampen < 0) {
-        crm_warn("Could not update %s: invalid delay value %dms (%s)",
-                 attr, dampen, dvalue);
+    if ((pcmk__parse_ms(dvalue, &dampen) != pcmk_rc_ok) || (dampen < 0)) {
+        pcmk__warn("Could not update %s: invalid delay value %dms (%s)", attr,
+                   dampen, dvalue);
         return EINVAL;
     }
 
@@ -103,11 +102,11 @@ attrd_update_dampening(attribute_t *a, xmlNode *xml, const char *attr)
         a->timeout_ms = (int) QB_MIN(dampen, INT_MAX);
         if (dampen > 0) {
             a->timer = attrd_add_timer(attr, a->timeout_ms, a);
-            crm_info("Update attribute %s delay to %dms (%s)",
-                     attr, dampen, dvalue);
+            pcmk__info("Update attribute %s delay to %dms (%s)",
+                       attr, dampen, dvalue);
         } else {
             a->timer = NULL;
-            crm_info("Update attribute %s to remove delay", attr);
+            pcmk__info("Update attribute %s to remove delay", attr);
         }
 
         /* If dampening changed, do an immediate write-out,
@@ -138,28 +137,29 @@ attrd_add_value_xml(xmlNode *parent, const attribute_t *a,
 {
     xmlNode *xml = pcmk__xe_create(parent, __func__);
 
-    crm_xml_add(xml, PCMK__XA_ATTR_NAME, a->id);
-    crm_xml_add(xml, PCMK__XA_ATTR_SET_TYPE, a->set_type);
-    crm_xml_add(xml, PCMK__XA_ATTR_SET, a->set_id);
-    crm_xml_add(xml, PCMK__XA_ATTR_USER, a->user);
-    crm_xml_add(xml, PCMK__XA_ATTR_HOST, v->nodename);
+    pcmk__xe_set(xml, PCMK__XA_ATTR_NAME, a->id);
+    pcmk__xe_set(xml, PCMK__XA_ATTR_SET_TYPE, a->set_type);
+    pcmk__xe_set(xml, PCMK__XA_ATTR_SET, a->set_id);
+    pcmk__xe_set(xml, PCMK__XA_ATTR_USER, a->user);
+    pcmk__xe_set(xml, PCMK__XA_ATTR_HOST, v->nodename);
 
     /* @COMPAT Prior to 2.1.10 and 3.0.1, the node's cluster ID was added
      * instead of its XML ID. For Corosync and Pacemaker Remote nodes, those are
      * the same, but if we ever support node XML IDs that differ from their
      * cluster IDs, we will have to drop support for rolling upgrades from
      * versions before those.
      */
-    crm_xml_add(xml, PCMK__XA_ATTR_HOST_ID, attrd_get_node_xml_id(v->nodename));
-
-    crm_xml_add(xml, PCMK__XA_ATTR_VALUE, v->current);
-    crm_xml_add_int(xml, PCMK__XA_ATTR_DAMPENING,
-                    pcmk__timeout_ms2s(a->timeout_ms));
-    crm_xml_add_int(xml, PCMK__XA_ATTR_IS_PRIVATE,
-                    pcmk_is_set(a->flags, attrd_attr_is_private));
-    crm_xml_add_int(xml, PCMK__XA_ATTR_IS_REMOTE,
-                    pcmk_is_set(v->flags, attrd_value_remote));
-    crm_xml_add_int(xml, PCMK__XA_ATTRD_IS_FORCE_WRITE, force_write);
+    pcmk__xe_set(xml, PCMK__XA_ATTR_HOST_ID,
+                 attrd_get_node_xml_id(v->nodename));
+
+    pcmk__xe_set(xml, PCMK__XA_ATTR_VALUE, v->current);
+    pcmk__xe_set_int(xml, PCMK__XA_ATTR_DAMPENING,
+                     pcmk__timeout_ms2s(a->timeout_ms));
+    pcmk__xe_set_int(xml, PCMK__XA_ATTR_IS_PRIVATE,
+                     pcmk__is_set(a->flags, attrd_attr_is_private));
+    pcmk__xe_set_int(xml, PCMK__XA_ATTR_IS_REMOTE,
+                     pcmk__is_set(v->flags, attrd_value_remote));
+    pcmk__xe_set_int(xml, PCMK__XA_ATTRD_IS_FORCE_WRITE, force_write);
 
     return xml;
 }
@@ -187,7 +187,7 @@ attrd_populate_attribute(xmlNode *xml, const char *attr)
     attribute_t *a = NULL;
     bool update_both = false;
 
-    const char *op = crm_element_value(xml, PCMK_XA_TASK);
+    const char *op = pcmk__xe_get(xml, PCMK_XA_TASK);
 
     // NULL because PCMK__ATTRD_CMD_SYNC_RESPONSE has no PCMK_XA_TASK
     update_both = pcmk__str_eq(op, PCMK__ATTRD_CMD_UPDATE_BOTH,
@@ -203,7 +203,7 @@ attrd_populate_attribute(xmlNode *xml, const char *attr)
             }
 
         } else {
-            crm_warn("Could not update %s: attribute not found", attr);
+            pcmk__warn("Could not update %s: attribute not found", attr);
             return NULL;
         }
     }
@@ -243,7 +243,7 @@ attrd_set_id(const attribute_t *attr, const char *node_state_id)
          * not limited by the schema in any way, but it's still unfortunate.
          * For backward compatibility reasons, we can't change this.
          */
-        set_id = crm_strdup_printf("%s-%s", PCMK_XE_STATUS, node_state_id);
+        set_id = pcmk__assert_asprintf("%s-%s", PCMK_XE_STATUS, node_state_id);
     } else {
         /* @COMPAT When the user specifies a set ID for an attribute, it is the
          * same for every node. That is less than ideal, but again, the schema
@@ -273,11 +273,11 @@ attrd_nvpair_id(const attribute_t *attr, const char *node_state_id)
     char *nvpair_id = NULL;
 
     if (attr->set_id != NULL) {
-        nvpair_id = crm_strdup_printf("%s-%s", attr->set_id, attr->id);
+        nvpair_id = pcmk__assert_asprintf("%s-%s", attr->set_id, attr->id);
 
     } else {
-        nvpair_id = crm_strdup_printf(PCMK_XE_STATUS "-%s-%s",
-                                      node_state_id, attr->id);
+        nvpair_id = pcmk__assert_asprintf(PCMK_XE_STATUS "-%s-%s",
+                                          node_state_id, attr->id);
     }
     pcmk__xml_sanitize_id(nvpair_id);
     return nvpair_id;