Refactor: libcrmcommon: New pcmk__xe_create()

To replace create_xml_node(). This one asserts on error.

Signed-off-by: Reid Wahl <nrwahl@protonmail.com>

daemons/attrd/attrd_attributes.c

@@ -136,7 +136,7 @@ xmlNode *
 attrd_add_value_xml(xmlNode *parent, const attribute_t *a,
                     const attribute_value_t *v, bool force_write)
 {
-    xmlNode *xml = create_xml_node(parent, __func__);
+    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);

daemons/attrd/attrd_cib.c

@@ -346,31 +346,19 @@ static int
 add_set_attr_update(const attribute_t *attr, const char *attr_id,
                     const char *node_id, const char *set_id, const char *value)
 {
-    xmlNode *update = create_xml_node(NULL, PCMK__XE_NODE_STATE);
+    xmlNode *update = pcmk__xe_create(NULL, PCMK__XE_NODE_STATE);
     xmlNode *child = update;
     int rc = ENOMEM;
 
-    if (child == NULL) {
-        goto done;
-    }
     crm_xml_add(child, PCMK_XA_ID, node_id);
 
-    child = create_xml_node(child, PCMK__XE_TRANSIENT_ATTRIBUTES);
-    if (child == NULL) {
-        goto done;
-    }
+    child = pcmk__xe_create(child, PCMK__XE_TRANSIENT_ATTRIBUTES);
     crm_xml_add(child, PCMK_XA_ID, node_id);
 
-    child = create_xml_node(child, attr->set_type);
-    if (child == NULL) {
-        goto done;
-    }
+    child = pcmk__xe_create(child, attr->set_type);
     crm_xml_add(child, PCMK_XA_ID, set_id);
 
-    child = create_xml_node(child, PCMK_XE_NVPAIR);
-    if (child == NULL) {
-        goto done;
-    }
+    child = pcmk__xe_create(child, PCMK_XE_NVPAIR);
     crm_xml_add(child, PCMK_XA_ID, attr_id);
     crm_xml_add(child, PCMK_XA_NAME, attr->id);
     crm_xml_add(child, PCMK_XA_VALUE, value);
@@ -379,7 +367,6 @@ add_set_attr_update(const attribute_t *attr, const char *attr_id,
                                cib_can_create|cib_transaction);
     rc = pcmk_legacy2rc(rc);
 
-done:
     free_xml(update);
     return rc;
 }

daemons/attrd/attrd_corosync.c

@@ -26,7 +26,7 @@
 static xmlNode *
 attrd_confirmation(int callid)
 {
-    xmlNode *node = create_xml_node(NULL, __func__);
+    xmlNode *node = pcmk__xe_create(NULL, __func__);
 
     crm_xml_add(node, PCMK__XA_T, PCMK__VALUE_ATTRD);
     crm_xml_add(node, PCMK__XA_SRC, get_local_node_name());
@@ -151,7 +151,7 @@ attrd_cpg_destroy(gpointer unused)
 void
 attrd_broadcast_value(const attribute_t *a, const attribute_value_t *v)
 {
-    xmlNode *op = create_xml_node(NULL, PCMK_XE_OP);
+    xmlNode *op = pcmk__xe_create(NULL, PCMK_XE_OP);
 
     crm_xml_add(op, PCMK_XA_TASK, PCMK__ATTRD_CMD_UPDATE);
     attrd_add_value_xml(op, a, v, false);
@@ -390,7 +390,7 @@ broadcast_unseen_local_values(void)
                 crm_trace("* %s[%s]='%s' is local-only",
                           a->id, v->nodename, readable_value(v));
                 if (sync == NULL) {
-                    sync = create_xml_node(NULL, __func__);
+                    sync = pcmk__xe_create(NULL, __func__);
                     crm_xml_add(sync, PCMK_XA_TASK, PCMK__ATTRD_CMD_SYNC_RESPONSE);
                 }
                 attrd_add_value_xml(sync, a, v, a->timeout_ms && a->timer);
@@ -546,7 +546,7 @@ attrd_peer_sync(crm_node_t *peer)
 
     attribute_t *a = NULL;
     attribute_value_t *v = NULL;
-    xmlNode *sync = create_xml_node(NULL, __func__);
+    xmlNode *sync = pcmk__xe_create(NULL, __func__);
 
     crm_xml_add(sync, PCMK_XA_TASK, PCMK__ATTRD_CMD_SYNC_RESPONSE);
 

daemons/attrd/attrd_ipc.c

@@ -40,12 +40,9 @@ static qb_ipcs_service_t *ipcs = NULL;
  */
 static xmlNode *build_query_reply(const char *attr, const char *host)
 {
-    xmlNode *reply = create_xml_node(NULL, __func__);
+    xmlNode *reply = pcmk__xe_create(NULL, __func__);
     attribute_t *a;
 
-    if (reply == NULL) {
-        return NULL;
-    }
     crm_xml_add(reply, PCMK__XA_T, PCMK__VALUE_ATTRD);
     crm_xml_add(reply, PCMK__XA_SUBT, PCMK__ATTRD_CMD_QUERY);
     crm_xml_add(reply, PCMK__XA_ATTR_VERSION, ATTRD_PROTOCOL_VERSION);
@@ -67,11 +64,7 @@ static xmlNode *build_query_reply(const char *attr, const char *host)
         /* If a specific node was requested, add its value */
         if (host) {
             v = g_hash_table_lookup(a->values, host);
-            host_value = create_xml_node(reply, PCMK_XE_NODE);
-            if (host_value == NULL) {
-                free_xml(reply);
-                return NULL;
-            }
+            host_value = pcmk__xe_create(reply, PCMK_XE_NODE);
             pcmk__xe_add_node(host_value, host, 0);
             crm_xml_add(host_value, PCMK__XA_ATTR_VALUE,
                         (v? v->current : NULL));
@@ -82,11 +75,7 @@ static xmlNode *build_query_reply(const char *attr, const char *host)
 
             g_hash_table_iter_init(&iter, a->values);
             while (g_hash_table_iter_next(&iter, NULL, (gpointer *) &v)) {
-                host_value = create_xml_node(reply, PCMK_XE_NODE);
-                if (host_value == NULL) {
-                    free_xml(reply);
-                    return NULL;
-                }
+                host_value = pcmk__xe_create(reply, PCMK_XE_NODE);
                 pcmk__xe_add_node(host_value, v->nodename, 0);
                 crm_xml_add(host_value, PCMK__XA_ATTR_VALUE, v->current);
             }
@@ -272,7 +261,7 @@ expand_regexes(xmlNode *xml, const char *attr, const char *value, const char *re
             int status = regexec(&r_patt, attr, 0, NULL, 0);
 
             if (status == 0) {
-                xmlNode *child = create_xml_node(xml, PCMK_XE_OP);
+                xmlNode *child = pcmk__xe_create(xml, PCMK_XE_OP);
 
                 crm_trace("Matched %s with %s", attr, regex);
                 matched = true;

daemons/attrd/attrd_messages.c

@@ -318,7 +318,7 @@ attrd_handle_request(pcmk__request_t *request)
 void
 attrd_broadcast_protocol(void)
 {
-    xmlNode *attrd_op = create_xml_node(NULL, __func__);
+    xmlNode *attrd_op = pcmk__xe_create(NULL, __func__);
 
     crm_xml_add(attrd_op, PCMK__XA_T, PCMK__VALUE_ATTRD);
     crm_xml_add(attrd_op, PCMK__XA_SRC, crm_system_name);

daemons/based/based_callbacks.c

@@ -158,9 +158,7 @@ static xmlNode *
 create_cib_reply(const char *op, const char *call_id, const char *client_id,
                  int call_options, int rc, xmlNode *call_data)
 {
-    xmlNode *reply = create_xml_node(NULL, PCMK__XE_CIB_REPLY);
-
-    pcmk__mem_assert(reply);
+    xmlNode *reply = pcmk__xe_create(NULL, PCMK__XE_CIB_REPLY);
 
     crm_xml_add(reply, PCMK__XA_T, PCMK__VALUE_CIB);
     crm_xml_add(reply, PCMK__XA_CIB_OP, op);
@@ -265,7 +263,7 @@ cib_common_callback_worker(uint32_t id, uint32_t flags, xmlNode * op_request,
 
     if (pcmk__str_eq(op, CRM_OP_REGISTER, pcmk__str_none)) {
         if (flags & crm_ipc_client_response) {
-            xmlNode *ack = create_xml_node(NULL, __func__);
+            xmlNode *ack = pcmk__xe_create(NULL, __func__);
 
             crm_xml_add(ack, PCMK__XA_CIB_OP, CRM_OP_REGISTER);
             crm_xml_add(ack, PCMK__XA_CIB_CLIENTID, cib_client->id);
@@ -399,7 +397,7 @@ cib_digester_cb(gpointer data)
 {
     if (based_is_primary) {
         char buffer[32];
-        xmlNode *ping = create_xml_node(NULL, PCMK__XE_PING);
+        xmlNode *ping = pcmk__xe_create(NULL, PCMK__XE_PING);
 
         ping_seq++;
         free(ping_digest);
@@ -1614,7 +1612,7 @@ initiate_exit(void)
 
     crm_info("Sending shutdown request to %d peers", active);
 
-    leaving = create_xml_node(NULL, PCMK__XE_EXIT_NOTIFICATION);
+    leaving = pcmk__xe_create(NULL, PCMK__XE_EXIT_NOTIFICATION);
     crm_xml_add(leaving, PCMK__XA_T, PCMK__VALUE_CIB);
     crm_xml_add(leaving, PCMK__XA_CIB_OP, PCMK__CIB_REQUEST_SHUTDOWN);
 

daemons/based/based_io.c

@@ -264,7 +264,7 @@ readCibXmlFile(const char *dir, const char *file, gboolean discard_status)
         status = NULL;
     }
     if (status == NULL) {
-        create_xml_node(root, PCMK_XE_STATUS);
+        pcmk__xe_create(root, PCMK_XE_STATUS);
     }
 
     /* Do this before schema validation happens */

daemons/based/based_messages.c

@@ -116,7 +116,7 @@ static int sync_in_progress = 0;
 void
 send_sync_request(const char *host)
 {
-    xmlNode *sync_me = create_xml_node(NULL, "sync-me");
+    xmlNode *sync_me = pcmk__xe_create(NULL, "sync-me");
     crm_node_t *peer = NULL;
 
     crm_info("Requesting re-sync from %s", (host? host : "all peers"));
@@ -143,7 +143,7 @@ cib_process_ping(const char *op, int options, const char *section, xmlNode * req
     char *digest = calculate_xml_versioned_digest(the_cib, FALSE, TRUE, CRM_FEATURE_SET);
 
     crm_trace("Processing \"%s\" event %s from %s", op, seq, host);
-    *answer = create_xml_node(NULL, PCMK__XE_PING_RESPONSE);
+    *answer = pcmk__xe_create(NULL, PCMK__XE_PING_RESPONSE);
 
     crm_xml_add(*answer, PCMK_XA_CRM_FEATURE_SET, CRM_FEATURE_SET);
     crm_xml_add(*answer, PCMK__XA_DIGEST, digest);
@@ -156,7 +156,7 @@ cib_process_ping(const char *op, int options, const char *section, xmlNode * req
         },
         if (the_cib != NULL) {
             // Always include at least the version details
-            xmlNode *shallow = create_xml_node(NULL,
+            xmlNode *shallow = pcmk__xe_create(NULL,
                                                (const char *) the_cib->name);
 
             copy_in_properties(shallow, the_cib);
@@ -218,7 +218,7 @@ cib_process_upgrade_server(const char *op, int options, const char *section, xml
 
         rc = update_validation(&scratch, &new_version, 0, TRUE, TRUE);
         if (new_version > current_version) {
-            xmlNode *up = create_xml_node(NULL, __func__);
+            xmlNode *up = pcmk__xe_create(NULL, __func__);
 
             rc = pcmk_ok;
             crm_notice("Upgrade request from %s verified", host);
@@ -258,7 +258,7 @@ cib_process_upgrade_server(const char *op, int options, const char *section, xml
                      (origin? origin->uname : "lost"));
 
             if (origin) {
-                xmlNode *up = create_xml_node(NULL, __func__);
+                xmlNode *up = pcmk__xe_create(NULL, __func__);
 
                 crm_xml_add(up, PCMK__XA_T, PCMK__VALUE_CIB);
                 crm_xml_add(up, PCMK__XA_CIB_OP, PCMK__CIB_REQUEST_UPGRADE);
@@ -397,9 +397,7 @@ cib_msg_copy(xmlNode *msg)
         PCMK__XA_CIB_NOTIFY_ACTIVATE,
     };
 
-    xmlNode *copy = create_xml_node(NULL, PCMK__XE_COPY);
-
-    pcmk__mem_assert(copy);
+    xmlNode *copy = pcmk__xe_create(NULL, PCMK__XE_COPY);
 
     for (int lpc = 0; lpc < PCMK__NELEM(field_list); lpc++) {
         const char *field = field_list[lpc];
@@ -498,7 +496,7 @@ cib_process_schemas(const char *op, int options, const char *section, xmlNode *r
     GList *schemas = NULL;
     GList *already_included = NULL;
 
-    *answer = create_xml_node(NULL, PCMK__XA_SCHEMAS);
+    *answer = pcmk__xe_create(NULL, PCMK__XA_SCHEMAS);
 
     data = get_message_xml(req, PCMK__XA_CIB_CALLDATA);
     if (data == NULL) {

daemons/based/based_notify.c

@@ -128,11 +128,7 @@ cib_notify_send(const xmlNode *xml)
 static void
 attach_cib_generation(xmlNode *msg)
 {
-    xmlNode *generation = create_xml_node(NULL, PCMK__XE_GENERATION_TUPLE);
-
-    if (generation == NULL) {
-        return;
-    }
+    xmlNode *generation = pcmk__xe_create(NULL, PCMK__XE_GENERATION_TUPLE);
 
     if (the_cib != NULL) {
         copy_in_properties(generation, the_cib);
@@ -196,7 +192,7 @@ cib_diff_notify(const char *op, int result, const char *call_id,
                    pcmk__s(origin, "unspecified peer"), pcmk_strerror(result));
     }
 
-    update_msg = create_xml_node(NULL, PCMK__XE_NOTIFY);
+    update_msg = pcmk__xe_create(NULL, PCMK__XE_NOTIFY);
 
     crm_xml_add(update_msg, PCMK__XA_T, PCMK__VALUE_CIB_NOTIFY);
     crm_xml_add(update_msg, PCMK__XA_SUBT, PCMK__VALUE_CIB_DIFF_NOTIFY);

daemons/based/based_remote.c

@@ -515,7 +515,7 @@ cib_remote_msg(gpointer data)
         }
 
         /* send ACK */
-        reg = create_xml_node(NULL, PCMK__XE_CIB_RESULT);
+        reg = pcmk__xe_create(NULL, PCMK__XE_CIB_RESULT);
         crm_xml_add(reg, PCMK__XA_CIB_OP, CRM_OP_REGISTER);
         crm_xml_add(reg, PCMK__XA_CIB_CLIENTID, client->id);
         pcmk__remote_send_xml(client->remote, reg);

daemons/controld/controld_cib.c

@@ -489,7 +489,7 @@ build_parameter_list(const lrmd_event_data_t *op,
 {
     GString *list = NULL;
 
-    *result = create_xml_node(NULL, PCMK_XE_PARAMETERS);
+    *result = pcmk__xe_create(NULL, PCMK_XE_PARAMETERS);
 
     /* Consider all parameters only except private ones to be consistent with
      * what scheduler does with calculate_secure_digest().
@@ -892,10 +892,10 @@ controld_update_resource_history(const char *node_name,
     }
 
     // <status>
-    update = create_xml_node(NULL, PCMK_XE_STATUS);
+    update = pcmk__xe_create(NULL, PCMK_XE_STATUS);
 
     //   <node_state ...>
-    xml = create_xml_node(update, PCMK__XE_NODE_STATE);
+    xml = pcmk__xe_create(update, PCMK__XE_NODE_STATE);
     if (pcmk__str_eq(node_name, controld_globals.our_nodename,
                      pcmk__str_casei)) {
         node_id = controld_globals.our_uuid;
@@ -908,14 +908,14 @@ controld_update_resource_history(const char *node_name,
     crm_xml_add(xml, PCMK_XA_CRM_DEBUG_ORIGIN, __func__);
 
     //     <lrm ...>
-    xml = create_xml_node(xml, PCMK__XE_LRM);
+    xml = pcmk__xe_create(xml, PCMK__XE_LRM);
     crm_xml_add(xml, PCMK_XA_ID, node_id);
 
     //       <lrm_resources>
-    xml = create_xml_node(xml, PCMK__XE_LRM_RESOURCES);
+    xml = pcmk__xe_create(xml, PCMK__XE_LRM_RESOURCES);
 
     //         <lrm_resource ...>
-    xml = create_xml_node(xml, PCMK__XE_LRM_RESOURCE);
+    xml = pcmk__xe_create(xml, PCMK__XE_LRM_RESOURCE);
     crm_xml_add(xml, PCMK_XA_ID, op->rsc_id);
     crm_xml_add(xml, PCMK_XA_CLASS, rsc->standard);
     crm_xml_add(xml, PCMK_XA_PROVIDER, rsc->provider);
@@ -964,7 +964,7 @@ controld_delete_action_history(const lrmd_event_data_t *op)
 
     CRM_CHECK(op != NULL, return);
 
-    xml_top = create_xml_node(NULL, PCMK__XE_LRM_RSC_OP);
+    xml_top = pcmk__xe_create(NULL, PCMK__XE_LRM_RSC_OP);
     crm_xml_add_int(xml_top, PCMK__XA_CALL_ID, op->call_id);
     crm_xml_add(xml_top, PCMK__XA_TRANSITION_KEY, op->user_data);
 

daemons/controld/controld_election.c

@@ -226,7 +226,7 @@ do_dc_takeover(long long action,
     controld_globals.cib_conn->cmds->set_primary(controld_globals.cib_conn,
                                                  cib_scope_local);
 
-    cib = create_xml_node(NULL, PCMK_XE_CIB);
+    cib = pcmk__xe_create(NULL, PCMK_XE_CIB);
     crm_xml_add(cib, PCMK_XA_CRM_FEATURE_SET, CRM_FEATURE_SET);
     controld_update_cib(PCMK_XE_CIB, cib, cib_none, feature_update_callback);
 

daemons/controld/controld_execd.c

@@ -538,7 +538,7 @@ build_active_RAs(lrm_state_t * lrm_state, xmlNode * rsc_list)
     while (g_hash_table_iter_next(&iter, NULL, (void **)&entry)) {
 
         GList *gIter = NULL;
-        xmlNode *xml_rsc = create_xml_node(rsc_list, PCMK__XE_LRM_RESOURCE);
+        xmlNode *xml_rsc = pcmk__xe_create(rsc_list, PCMK__XE_LRM_RESOURCE);
 
         crm_xml_add(xml_rsc, PCMK_XA_ID, entry->id);
         crm_xml_add(xml_rsc, PCMK_XA_TYPE, entry->rsc.type);
@@ -593,9 +593,9 @@ controld_query_executor_state(void)
         return NULL;
     }
 
-    xml_data = create_xml_node(xml_state, PCMK__XE_LRM);
+    xml_data = pcmk__xe_create(xml_state, PCMK__XE_LRM);
     crm_xml_add(xml_data, PCMK_XA_ID, peer->uuid);
-    rsc_list = create_xml_node(xml_data, PCMK__XE_LRM_RESOURCES);
+    rsc_list = pcmk__xe_create(xml_data, PCMK__XE_LRM_RESOURCES);
 
     /* Build a list of active (not always running) resources */
     build_active_RAs(lrm_state, rsc_list);
@@ -1765,10 +1765,10 @@ controld_ack_event_directly(const char *to_host, const char *to_sys,
     update = create_node_state_update(peer, node_update_none, NULL,
                                       __func__);
 
-    iter = create_xml_node(update, PCMK__XE_LRM);
+    iter = pcmk__xe_create(update, PCMK__XE_LRM);
     crm_xml_add(iter, PCMK_XA_ID, controld_globals.our_uuid);
-    iter = create_xml_node(iter, PCMK__XE_LRM_RESOURCES);
-    iter = create_xml_node(iter, PCMK__XE_LRM_RESOURCE);
+    iter = pcmk__xe_create(iter, PCMK__XE_LRM_RESOURCES);
+    iter = pcmk__xe_create(iter, PCMK__XE_LRM_RESOURCE);
 
     crm_xml_add(iter, PCMK_XA_ID, op->rsc_id);
 

daemons/controld/controld_execd_state.c

@@ -575,7 +575,7 @@ crmd_remote_proxy_cb(lrmd_t *lrmd, void *userdata, xmlNode *msg)
         crm_element_value_int(msg, PCMK__XA_LRMD_IPC_MSG_FLAGS, &flags);
         if (flags & crm_ipc_client_response) {
             int msg_id = 0;
-            xmlNode *op_reply = create_xml_node(NULL, PCMK__XE_ACK);
+            xmlNode *op_reply = pcmk__xe_create(NULL, PCMK__XE_ACK);
 
             crm_xml_add(op_reply, PCMK_XA_FUNCTION, __func__);
             crm_xml_add_int(op_reply, PCMK__XA_LINE, __LINE__);