pacemaker  2.0.4-2deceaa3ae
Scalable High-Availability cluster resource manager
output_xml.c
Go to the documentation of this file.
1 /*
2  * Copyright 2019 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 #ifndef _GNU_SOURCE
11 # define _GNU_SOURCE
12 #endif
13 
14 #include <config.h>
15 #include <ctype.h>
16 #include <stdarg.h>
17 #include <stdlib.h>
18 #include <stdio.h>
19 #include <crm/crm.h>
20 #include <crm/common/output.h>
21 #include <crm/common/xml.h>
22 #include <glib.h>
23 
24 static gboolean legacy_xml = FALSE;
25 static gboolean simple_list = FALSE;
26 
27 GOptionEntry pcmk__xml_output_entries[] = {
28  { "xml-legacy", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &legacy_xml,
29  NULL,
30  NULL },
31  { "xml-simple-list", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &simple_list,
32  NULL,
33  NULL },
34 
35  { NULL }
36 };
37 
38 typedef struct private_data_s {
39  xmlNode *root;
40  GQueue *parent_q;
41  GSList *errors;
42  bool legacy_xml;
44 
45 static void
46 xml_free_priv(pcmk__output_t *out) {
47  private_data_t *priv = out->priv;
48 
49  if (priv == NULL) {
50  return;
51  }
52 
53  xmlFreeNode(priv->root);
54  g_queue_free(priv->parent_q);
55  g_slist_free(priv->errors);
56  free(priv);
57  out->priv = NULL;
58 }
59 
60 static bool
61 xml_init(pcmk__output_t *out) {
62  private_data_t *priv = NULL;
63 
64  /* If xml_init was previously called on this output struct, just return. */
65  if (out->priv != NULL) {
66  return true;
67  } else {
68  out->priv = calloc(1, sizeof(private_data_t));
69  if (out->priv == NULL) {
70  return false;
71  }
72 
73  priv = out->priv;
74  }
75 
76  if (legacy_xml) {
77  priv->root = create_xml_node(NULL, "crm_mon");
78  xmlSetProp(priv->root, (pcmkXmlStr) "version", (pcmkXmlStr) VERSION);
79  } else {
80  priv->root = create_xml_node(NULL, "pacemaker-result");
81  xmlSetProp(priv->root, (pcmkXmlStr) "api-version", (pcmkXmlStr) PCMK__API_VERSION);
82 
83  if (out->request != NULL) {
84  xmlSetProp(priv->root, (pcmkXmlStr) "request", (pcmkXmlStr) out->request);
85  }
86  }
87 
88  priv->parent_q = g_queue_new();
89  priv->errors = NULL;
90  g_queue_push_tail(priv->parent_q, priv->root);
91 
92  /* Copy this from the file-level variable. This means that it is only settable
93  * as a command line option, and that pcmk__output_new must be called after all
94  * command line processing is completed.
95  */
96  priv->legacy_xml = legacy_xml;
97 
98  return true;
99 }
100 
101 static void
102 add_error_node(gpointer data, gpointer user_data) {
103  char *str = (char *) data;
104  xmlNodePtr node = (xmlNodePtr) user_data;
105  pcmk_create_xml_text_node(node, "error", str);
106 }
107 
108 static void
109 finish_reset_common(pcmk__output_t *out, crm_exit_t exit_status, bool print) {
110  xmlNodePtr node;
111  private_data_t *priv = out->priv;
112 
113  if (legacy_xml) {
114  GSList *node = priv->errors;
115 
116  if (exit_status != CRM_EX_OK) {
117  fprintf(stderr, "%s\n", crm_exit_str(exit_status));
118  }
119 
120  while (node != NULL) {
121  fprintf(stderr, "%s\n", (char *) node->data);
122  node = node->next;
123  }
124  } else {
125  char *rc_as_str = crm_itoa(exit_status);
126 
127  node = create_xml_node(priv->root, "status");
128  xmlSetProp(node, (pcmkXmlStr) "code", (pcmkXmlStr) rc_as_str);
129  xmlSetProp(node, (pcmkXmlStr) "message", (pcmkXmlStr) crm_exit_str(exit_status));
130 
131  if (g_slist_length(priv->errors) > 0) {
132  xmlNodePtr errors_node = create_xml_node(node, "errors");
133  g_slist_foreach(priv->errors, add_error_node, (gpointer) errors_node);
134  }
135 
136  free(rc_as_str);
137  }
138 
139  if (print) {
140  char *buf = dump_xml_formatted_with_text(priv->root);
141  fprintf(out->dest, "%s", buf);
142  free(buf);
143  }
144 }
145 
146 static void
147 xml_finish(pcmk__output_t *out, crm_exit_t exit_status, bool print, void **copy_dest) {
148  private_data_t *priv = out->priv;
149 
150  /* If root is NULL, xml_init failed and we are being called from pcmk__output_free
151  * in the pcmk__output_new path.
152  */
153  if (priv == NULL || priv->root == NULL) {
154  return;
155  }
156 
157  finish_reset_common(out, exit_status, print);
158 
159  if (copy_dest != NULL) {
160  *copy_dest = copy_xml(priv->root);
161  }
162 }
163 
164 static void
165 xml_reset(pcmk__output_t *out) {
166 
167  CRM_ASSERT(out != NULL);
168 
169  out->dest = freopen(NULL, "w", out->dest);
170  CRM_ASSERT(out->dest != NULL);
171 
172  if (out->priv != NULL) {
173  finish_reset_common(out, CRM_EX_OK, true);
174  }
175 
176  xml_free_priv(out);
177  xml_init(out);
178 }
179 
180 static void
181 xml_subprocess_output(pcmk__output_t *out, int exit_status,
182  const char *proc_stdout, const char *proc_stderr) {
183  xmlNodePtr node, child_node;
184  char *rc_as_str = NULL;
185 
186  rc_as_str = crm_itoa(exit_status);
187 
188  node = pcmk__output_xml_create_parent(out, "command");
189  xmlSetProp(node, (pcmkXmlStr) "code", (pcmkXmlStr) rc_as_str);
190 
191  if (proc_stdout != NULL) {
192  child_node = pcmk_create_xml_text_node(node, "output", proc_stdout);
193  xmlSetProp(child_node, (pcmkXmlStr) "source", (pcmkXmlStr) "stdout");
194  }
195 
196  if (proc_stderr != NULL) {
197  child_node = pcmk_create_xml_text_node(node, "output", proc_stderr);
198  xmlSetProp(child_node, (pcmkXmlStr) "source", (pcmkXmlStr) "stderr");
199  }
200 
201  pcmk__output_xml_add_node(out, node);
202  free(rc_as_str);
203 }
204 
205 static void
206 xml_version(pcmk__output_t *out, bool extended) {
207  xmlNodePtr node;
208  private_data_t *priv = out->priv;
209  CRM_ASSERT(priv != NULL);
210 
211  node = pcmk__output_create_xml_node(out, "version");
212  xmlSetProp(node, (pcmkXmlStr) "program", (pcmkXmlStr) "Pacemaker");
213  xmlSetProp(node, (pcmkXmlStr) "version", (pcmkXmlStr) PACEMAKER_VERSION);
214  xmlSetProp(node, (pcmkXmlStr) "author", (pcmkXmlStr) "Andrew Beekhof");
215  xmlSetProp(node, (pcmkXmlStr) "build", (pcmkXmlStr) BUILD_VERSION);
216  xmlSetProp(node, (pcmkXmlStr) "features", (pcmkXmlStr) CRM_FEATURES);
217 }
218 
219 G_GNUC_PRINTF(2, 3)
220 static void
221 xml_err(pcmk__output_t *out, const char *format, ...) {
222  private_data_t *priv = out->priv;
223  int len = 0;
224  char *buf = NULL;
225  va_list ap;
226 
227  CRM_ASSERT(priv != NULL);
228  va_start(ap, format);
229  len = vasprintf(&buf, format, ap);
230  CRM_ASSERT(len > 0);
231  va_end(ap);
232 
233  priv->errors = g_slist_append(priv->errors, buf);
234 }
235 
236 G_GNUC_PRINTF(2, 3)
237 static void
238 xml_info(pcmk__output_t *out, const char *format, ...) {
239  /* This function intentially left blank */
240 }
241 
242 static void
243 xml_output_xml(pcmk__output_t *out, const char *name, const char *buf) {
244  xmlNodePtr parent = NULL;
245  xmlNodePtr cdata_node = NULL;
246  private_data_t *priv = out->priv;
247 
248  CRM_ASSERT(priv != NULL);
249 
250  parent = pcmk__output_create_xml_node(out, name);
251  cdata_node = xmlNewCDataBlock(getDocPtr(parent), (pcmkXmlStr) buf, strlen(buf));
252  xmlAddChild(parent, cdata_node);
253 }
254 
255 G_GNUC_PRINTF(4, 5)
256 static void
257 xml_begin_list(pcmk__output_t *out, const char *singular_noun, const char *plural_noun,
258  const char *format, ...) {
259  va_list ap;
260  char *buf = NULL;
261  int len;
262 
263  va_start(ap, format);
264  len = vasprintf(&buf, format, ap);
265  CRM_ASSERT(len >= 0);
266  va_end(ap);
267 
268  if (legacy_xml || simple_list) {
270  } else {
271  xmlNodePtr list_node = NULL;
272 
273  list_node = pcmk__output_xml_create_parent(out, "list");
274  xmlSetProp(list_node, (pcmkXmlStr) "name", (pcmkXmlStr) buf);
275  }
276 
277  free(buf);
278 }
279 
280 G_GNUC_PRINTF(3, 4)
281 static void
282 xml_list_item(pcmk__output_t *out, const char *name, const char *format, ...) {
283  private_data_t *priv = out->priv;
284  xmlNodePtr item_node = NULL;
285  va_list ap;
286  char *buf = NULL;
287  int len;
288 
289  CRM_ASSERT(priv != NULL);
290 
291  va_start(ap, format);
292  len = vasprintf(&buf, format, ap);
293  CRM_ASSERT(len >= 0);
294  va_end(ap);
295 
296  item_node = pcmk__output_create_xml_text_node(out, "item", buf);
297  free(buf);
298 
299  xmlSetProp(item_node, (pcmkXmlStr) "name", (pcmkXmlStr) name);
300 }
301 
302 static void
303 xml_increment_list(pcmk__output_t *out) {
304  /* This function intentially left blank */
305 }
306 
307 static void
308 xml_end_list(pcmk__output_t *out) {
309  private_data_t *priv = out->priv;
310 
311  CRM_ASSERT(priv != NULL);
312 
313  if (priv->legacy_xml || simple_list) {
314  g_queue_pop_tail(priv->parent_q);
315  } else {
316  char *buf = NULL;
317  xmlNodePtr node;
318 
319  node = g_queue_pop_tail(priv->parent_q);
320  buf = crm_strdup_printf("%lu", xmlChildElementCount(node));
321  xmlSetProp(node, (pcmkXmlStr) "count", (pcmkXmlStr) buf);
322  free(buf);
323  }
324 }
325 
327 pcmk__mk_xml_output(char **argv) {
328  pcmk__output_t *retval = calloc(1, sizeof(pcmk__output_t));
329 
330  if (retval == NULL) {
331  return NULL;
332  }
333 
334  retval->fmt_name = "xml";
335  retval->request = argv == NULL ? NULL : g_strjoinv(" ", argv);
336  retval->supports_quiet = false;
337 
338  retval->init = xml_init;
339  retval->free_priv = xml_free_priv;
340  retval->finish = xml_finish;
341  retval->reset = xml_reset;
342 
344  retval->message = pcmk__call_message;
345 
346  retval->subprocess_output = xml_subprocess_output;
347  retval->version = xml_version;
348  retval->info = xml_info;
349  retval->err = xml_err;
350  retval->output_xml = xml_output_xml;
351 
352  retval->begin_list = xml_begin_list;
353  retval->list_item = xml_list_item;
354  retval->increment_list = xml_increment_list;
355  retval->end_list = xml_end_list;
356 
357  return retval;
358 }
359 
360 xmlNodePtr
362  xmlNodePtr node = pcmk__output_create_xml_node(out, name);
363  pcmk__output_xml_push_parent(out, node);
364  return node;
365 }
366 
367 void
369  private_data_t *priv = out->priv;
370 
371  CRM_ASSERT(priv != NULL);
372  CRM_ASSERT(node != NULL);
373 
374  xmlAddChild(g_queue_peek_tail(priv->parent_q), node);
375 }
376 
377 xmlNodePtr
379  private_data_t *priv = out->priv;
380 
381  CRM_ASSERT(priv != NULL);
382 
383  return create_xml_node(g_queue_peek_tail(priv->parent_q), name);
384 }
385 
386 xmlNodePtr
387 pcmk__output_create_xml_text_node(pcmk__output_t *out, const char *name, const char *content) {
388  xmlNodePtr node = pcmk__output_create_xml_node(out, name);
389  xmlNodeSetContent(node, (pcmkXmlStr) content);
390  return node;
391 }
392 
393 void
395  private_data_t *priv = out->priv;
396 
397  CRM_ASSERT(priv != NULL);
398  CRM_ASSERT(parent != NULL);
399 
400  g_queue_push_tail(priv->parent_q, parent);
401 }
402 
403 void
405  private_data_t *priv = out->priv;
406 
407  CRM_ASSERT(priv != NULL);
408  CRM_ASSERT(g_queue_get_length(priv->parent_q) > 0);
409 
410  g_queue_pop_tail(priv->parent_q);
411 }
412 
413 xmlNodePtr
415  private_data_t *priv = out->priv;
416 
417  CRM_ASSERT(priv != NULL);
418 
419  /* If queue is empty NULL will be returned */
420  return g_queue_peek_tail(priv->parent_q);
421 }
char data[0]
Definition: internal.h:10
char * crm_strdup_printf(char const *format,...) __attribute__((__format__(__printf__
#define VERSION
Definition: config.h:621
#define PACEMAKER_VERSION
Definition: config.h:511
#define CRM_FEATURES
Definition: config.h:35
#define BUILD_VERSION
Definition: config.h:8
A dumping ground.
Formatted output for pacemaker tools.
#define PCMK__API_VERSION
Definition: output.h:30
int pcmk__call_message(pcmk__output_t *out, const char *message_id,...)
Definition: output.c:116
void pcmk__register_message(pcmk__output_t *out, const char *message_id, pcmk__message_fn_t fn)
Definition: output.c:134
struct private_data_s private_data_t
GOptionEntry pcmk__xml_output_entries[]
Definition: output_xml.c:27
void pcmk__output_xml_pop_parent(pcmk__output_t *out)
Definition: output_xml.c:404
xmlNodePtr pcmk__output_xml_create_parent(pcmk__output_t *out, const char *name)
Definition: output_xml.c:361
void pcmk__output_xml_push_parent(pcmk__output_t *out, xmlNodePtr parent)
Definition: output_xml.c:394
xmlNodePtr pcmk__output_xml_peek_parent(pcmk__output_t *out)
Definition: output_xml.c:414
void pcmk__output_xml_add_node(pcmk__output_t *out, xmlNodePtr node)
Definition: output_xml.c:368
pcmk__output_t * pcmk__mk_xml_output(char **argv)
Definition: output_xml.c:327
struct private_data_s private_data_t
xmlNodePtr pcmk__output_create_xml_node(pcmk__output_t *out, const char *name)
Definition: output_xml.c:378
xmlNodePtr pcmk__output_create_xml_text_node(pcmk__output_t *out, const char *name, const char *content)
Definition: output_xml.c:387
char * name
Definition: pcmk_fence.c:30
#define CRM_ASSERT(expr)
Definition: results.h:42
@ CRM_EX_OK
Definition: results.h:173
const char * crm_exit_str(crm_exit_t exit_code)
Definition: results.c:519
enum crm_exit_e crm_exit_t
This structure contains everything that makes up a single output formatter.
Definition: output.h:153
void(*) void(*) void(* increment_list)(pcmk__output_t *out)
Definition: output.h:420
void(* end_list)(pcmk__output_t *out)
Definition: output.h:432
void(* version)(pcmk__output_t *out, bool extended)
Definition: output.h:333
int(* message)(pcmk__output_t *out, const char *message_id,...)
Definition: output.h:311
bool supports_quiet
Does this formatter support a special quiet mode?
Definition: output.h:174
const char * fmt_name
The name of this output formatter.
Definition: output.h:157
FILE * dest
Where output should be written.
Definition: output.h:182
void(* register_message)(pcmk__output_t *out, const char *message_id, pcmk__message_fn_t fn)
Definition: output.h:293
void(*) void(* list_item)(pcmk__output_t *out, const char *name, const char *format,...) G_GNUC_PRINTF(3
Definition: output.h:405
void(*) void(*) void(* output_xml)(pcmk__output_t *out, const char *name, const char *buf)
Definition: output.h:371
void(* info)(pcmk__output_t *out, const char *format,...) G_GNUC_PRINTF(2
Definition: output.h:347
void(* finish)(pcmk__output_t *out, crm_exit_t exit_status, bool print, void **copy_dest)
Definition: output.h:262
void(* subprocess_output)(pcmk__output_t *out, int exit_status, const char *proc_stdout, const char *proc_stderr)
Definition: output.h:322
void(* begin_list)(pcmk__output_t *out, const char *singular_noun, const char *plural_noun, const char *format,...) G_GNUC_PRINTF(4
Definition: output.h:392
bool(* init)(pcmk__output_t *out)
Definition: output.h:215
void * priv
Implementation-specific private data.
Definition: output.h:199
void(* reset)(pcmk__output_t *out)
Definition: output.h:280
void(*) void(* err)(pcmk__output_t *out, const char *format,...) G_GNUC_PRINTF(2
Definition: output.h:361
void(* free_priv)(pcmk__output_t *out)
Definition: output.h:226
gchar * request
A copy of the request that generated this output.
Definition: output.h:165
Wrappers for and extensions to libxml2.
xmlNode * copy_xml(xmlNode *src_node)
Definition: xml.c:2142
xmlNode * pcmk_create_xml_text_node(xmlNode *parent, const char *name, const char *content)
Definition: xml.c:2001
const xmlChar * pcmkXmlStr
Definition: xml.h:51
char * dump_xml_formatted_with_text(xmlNode *msg)
Definition: xml.c:3299
xmlDoc * getDocPtr(xmlNode *node)
Definition: xml.c:1938
xmlNode * create_xml_node(xmlNode *parent, const char *name)
Definition: xml.c:1976