20 #define VARIANT_NATIVE 1
30 unsigned int count = 0;
44 for (; gIter != NULL; gIter = gIter->next) {
79 if (is_multiply_active(rsc)) {
92 while (g_hash_table_iter_next(&gIter, NULL, (
void **)&local_node)) {
111 for (; gIter != NULL; gIter = gIter->next) {
120 crm_debug(
"%s is active on multiple nodes including %s: %s",
128 if (rsc->
parent != NULL) {
139 for (GList *child = rsc->
children; child != NULL; child = child->next) {
148 native_variant_data_t *native_data = NULL;
154 native_data = calloc(1,
sizeof(native_variant_data_t));
173 recursive_clear_unique(parent);
174 recursive_clear_unique(rsc);
179 pe_err(
"Resource %s is of type %s and therefore "
180 "cannot be used as a promotable clone resource",
223 const char *rid =
ID(rsc->
xml);
232 }
else if (!strcmp(
id, rsc->
id)) {
242 match = pe_base_name_eq(rsc,
id);
245 if (match && on_node) {
246 bool match_node = rsc_is_on_node(rsc, on_node,
flags);
248 if (match_node == FALSE) {
272 char *value_copy = NULL;
273 const char *value = NULL;
274 GHashTable *hash = NULL;
275 GHashTable *local_hash = NULL;
278 CRM_CHECK(name != NULL && strlen(name) != 0,
return NULL);
282 if (create || g_hash_table_size(rsc->
parameters) == 0) {
289 local_hash = crm_str_table_new();
298 value = g_hash_table_lookup(hash, name);
301 value = g_hash_table_lookup(rsc->
meta, name);
305 value_copy = strdup(value);
307 if (local_hash != NULL) {
308 g_hash_table_destroy(local_hash);
318 for (; gIter != NULL; gIter = gIter->next) {
335 struct print_data_s {
341 native_print_attr(gpointer key, gpointer value, gpointer user_data)
343 long options = ((
struct print_data_s *)user_data)->options;
344 void *print_data = ((
struct print_data_s *)user_data)->print_data;
346 status_print(
"Option: %s = %s\n", (
char *)key, (
char *)value);
352 const char *pending_state = NULL;
355 pending_state =
"Starting";
358 pending_state =
"Stopping";
361 pending_state =
"Migrating";
365 pending_state =
"Migrating";
368 pending_state =
"Promoting";
371 pending_state =
"Demoting";
374 return pending_state;
380 const char *pending_task = NULL;
383 pending_task =
"Monitoring";
413 native_displayable_state(
resource_t *rsc,
long options)
415 const char *rsc_state = NULL;
418 rsc_state = native_pending_state(rsc);
420 if (rsc_state == NULL) {
421 rsc_state =
role2text(native_displayable_role(rsc));
427 native_print_xml(
resource_t * rsc,
const char *pre_text,
long options,
void *print_data)
431 const char *rsc_state = native_displayable_state(rsc, options);
432 const char *target_role = NULL;
458 const char *pending_task = native_pending_task(rsc);
481 for (; gIter != NULL; gIter = gIter->next) {
484 status_print(
"%s <node name=\"%s\" id=\"%s\" cached=\"%s\"/>\n", pre_text,
497 static inline const char *
505 const char *target_role)
507 char *
flags[6] = { NULL, };
512 flags[ndx++] = strdup(
"UNCLEAN");
516 const char *pending_task = native_pending_task(rsc);
519 flags[ndx++] = strdup(pending_task);
530 flags[ndx++] = strdup(
"disabled");
539 flags[ndx++] = strdup(
"blocked");
542 flags[ndx++] = strdup(
"unmanaged");
546 flags[ndx++] = strdup(
"failure ignored");
550 char *total = g_strjoinv(
" ",
flags);
563 native_output_string(
resource_t *rsc,
const char *name,
node_t *node,
long options,
564 const char *target_role) {
565 const char *desc = NULL;
568 enum rsc_role_e role = native_displayable_role(rsc);
573 char *provider = NULL;
574 const char *orphan = NULL;
577 char *print_dev_s = NULL;
578 char *flags_s = NULL;
587 orphan =
" ORPHANED";
608 gchar **arr = calloc(g_list_length(rsc->
running_on)+1,
sizeof(gchar *));
612 for (; gIter != NULL; gIter = gIter->next) {
618 total = g_strjoinv(
" ", arr);
629 crm_element_name(rsc->
xml), (
double)rsc->
priority);
632 flags_s = flags_string(rsc, node, options, target_role);
636 provider ? provider :
"",
638 orphan ? orphan :
"",
641 print_dev_s ? print_dev_s :
"",
642 flags_s ? flags_s :
"",
643 desc ?
" " :
"", desc ? desc :
"",
644 unames ? unames :
"");
658 const char *name,
node_t *node,
long options)
662 const char *target_role = NULL;
664 xmlNodePtr list_node = NULL;
665 const char *cl = NULL;
673 crm_trace(
"skipping print of internal resource %s", rsc->
id);
692 }
else if (g_list_length(rsc->
running_on) > 1) {
696 cl =
"rsc-failure-ignored";
702 s = native_output_string(rsc, name, node, options, target_role);
712 g_hash_table_iter_init(&iter, rsc->
parameters);
713 while (g_hash_table_iter_next(&iter, &key, &value)) {
714 out->
list_item(out, NULL,
"Option: %s = %s", (
char *) key, (
char *) value);
723 out->
begin_list(out, NULL, NULL,
"Allowed Nodes");
725 while (g_hash_table_iter_next(&iter, NULL, (
void **)&n)) {
726 out->
list_item(out, NULL,
"%s %d", n->details->uname, n->weight);
735 out->
begin_list(out, NULL, NULL,
"=== Allowed Nodes");
737 while (g_hash_table_iter_next(&iter, NULL, (
void **)&n)) {
746 const char *name,
node_t *node,
long options)
749 const char *target_role = NULL;
756 crm_trace(
"skipping print of internal resource %s", rsc->
id);
766 s = native_output_string(rsc, name, node, options, target_role);
775 g_hash_table_iter_init(&iter, rsc->
parameters);
776 while (g_hash_table_iter_next(&iter, &key, &value)) {
777 out->
list_item(out, NULL,
"Option: %s = %s", (
char *) key, (
char *) value);
786 out->
begin_list(out, NULL, NULL,
"Allowed Nodes");
788 while (g_hash_table_iter_next(&iter, NULL, (
void **)&n)) {
789 out->
list_item(out, NULL,
"%s %d", n->details->uname, n->weight);
798 out->
begin_list(out, NULL, NULL,
"=== Allowed Nodes");
800 while (g_hash_table_iter_next(&iter, NULL, (
void **)&n)) {
810 const char *desc = NULL;
813 const char *target_role = NULL;
814 enum rsc_role_e role = native_displayable_role(rsc);
818 char buffer[LINE_MAX];
819 char flagBuffer[LINE_MAX];
827 crm_trace(
"skipping print of internal resource %s", rsc->id);
838 native_print_xml(rsc, pre_text, options, print_data);
853 }
else if (rsc->variant ==
pe_native && (rsc->running_on == NULL)) {
856 }
else if (g_list_length(rsc->running_on) > 1) {
868 offset += snprintf(buffer + offset, LINE_MAX - offset,
"%s", pre_text);
870 offset += snprintf(buffer + offset, LINE_MAX - offset,
"%s", name);
871 offset += snprintf(buffer + offset, LINE_MAX - offset,
"\t(%s",
class);
874 offset += snprintf(buffer + offset, LINE_MAX - offset,
"::%s", prov);
876 offset += snprintf(buffer + offset, LINE_MAX - offset,
":%s):\t", kind);
878 offset += snprintf(buffer + offset, LINE_MAX - offset,
" ORPHANED ");
881 offset += snprintf(buffer + offset, LINE_MAX - offset,
"FAILED %s",
role2text(role));
883 offset += snprintf(buffer + offset, LINE_MAX - offset,
"FAILED");
885 const char *rsc_state = native_displayable_state(rsc, options);
887 offset += snprintf(buffer + offset, LINE_MAX - offset,
"%s", rsc_state);
891 offset += snprintf(buffer + offset, LINE_MAX - offset,
" %s", node->
details->
uname);
894 flagOffset += snprintf(flagBuffer + flagOffset, LINE_MAX - flagOffset,
895 "%sUNCLEAN", comma_if(flagOffset));
900 const char *pending_task = native_pending_task(rsc);
903 flagOffset += snprintf(flagBuffer + flagOffset, LINE_MAX - flagOffset,
904 "%s%s", comma_if(flagOffset), pending_task);
915 flagOffset += snprintf(flagBuffer + flagOffset, LINE_MAX - flagOffset,
916 "%sdisabled", comma_if(flagOffset));
920 flagOffset += snprintf(flagBuffer + flagOffset, LINE_MAX - flagOffset,
921 "%starget-role:%s", comma_if(flagOffset), target_role);
926 flagOffset += snprintf(flagBuffer + flagOffset, LINE_MAX - flagOffset,
927 "%sblocked", comma_if(flagOffset));
930 flagOffset += snprintf(flagBuffer + flagOffset, LINE_MAX - flagOffset,
931 "%sunmanaged", comma_if(flagOffset));
935 flagOffset += snprintf(flagBuffer + flagOffset, LINE_MAX - flagOffset,
936 "%sfailure ignored", comma_if(flagOffset));
945 status_print(
"%s (%s)%s%s", buffer, flagBuffer, desc?
" ":
"", desc?desc:
"");
947 status_print(
"%s%s%s", buffer, desc?
" ":
"", desc?desc:
"");
966 }
else if (g_list_length(rsc->running_on) > 1) {
977 for (; gIter != NULL; gIter = gIter->next) {
1018 struct print_data_s pdata;
1020 pdata.options = options;
1021 pdata.print_data = print_data;
1022 g_hash_table_foreach(rsc->parameters, native_print_attr, &pdata);
1026 GHashTableIter iter;
1029 status_print(
"%s\t(%s%svariant=%s, priority=%f)", pre_text,
1032 crm_element_name(rsc->xml), (
double)rsc->priority);
1034 g_hash_table_iter_init(&iter, rsc->allowed_nodes);
1035 while (g_hash_table_iter_next(&iter, NULL, (
void **)&n)) {
1036 status_print(
"%s\t * %s %d", pre_text, n->details->uname, n->weight);
1041 GHashTableIter iter;
1045 g_hash_table_iter_init(&iter, rsc->allowed_nodes);
1046 while (g_hash_table_iter_next(&iter, NULL, (
void **)&n)) {
1059 native_print_xml(rsc, pre_text, options, print_data);
1063 node = pe__current_node(rsc);
1076 long options = va_arg(args,
int);
1081 const char *rsc_state = native_displayable_state(rsc, options);
1086 char ra_name[LINE_MAX];
1087 char *nodes_running_on = NULL;
1088 char *priority = NULL;
1094 sprintf(ra_name,
"%s%s%s:%s",
class, prov ?
"::" :
"", prov ? prov :
""
1097 nodes_running_on = crm_itoa(g_list_length(rsc->running_on));
1098 priority = crm_ftoa(rsc->priority);
1102 ,
"resource_agent", ra_name
1105 ,
"active",
BOOL2STR(rsc->fns->active(rsc, TRUE))
1111 ,
"nodes_running_on", nodes_running_on
1112 ,
"pending", (is_print_pending ? native_pending_task(rsc) : NULL)
1115 ,
"priority", (is_print_dev ? priority : NULL)
1116 ,
"variant", (is_print_dev ? crm_element_name(rsc->xml) : NULL));
1118 free(nodes_running_on);
1122 if (rsc->running_on != NULL) {
1125 for (; gIter != NULL; gIter = gIter->next) {
1143 long options = va_arg(args,
int);
1145 node_t *node = pe__current_node(rsc);
1160 long options = va_arg(args,
int);
1163 node_t *node = pe__current_node(rsc);
1178 pe_rsc_trace(rsc,
"Freeing resource action list (not the data)");
1213 for (; gIter != NULL; gIter = gIter->next) {
1219 }
else if (current) {
1233 if (result && (result->next == NULL)) {
1240 for (; gIter != NULL; gIter = gIter->next) {
1244 *list = g_list_append(*list, node);
1249 g_list_free(result);
1254 get_rscs_brief(
GListPtr rsc_list, GHashTable * rsc_table, GHashTable * active_table)
1258 for (; gIter != NULL; gIter = gIter->next) {
1265 char buffer[LINE_MAX];
1267 int *rsc_counter = NULL;
1268 int *active_counter = NULL;
1274 offset += snprintf(buffer + offset, LINE_MAX - offset,
"%s",
class);
1277 offset += snprintf(buffer + offset, LINE_MAX - offset,
"::%s", prov);
1279 offset += snprintf(buffer + offset, LINE_MAX - offset,
":%s", kind);
1283 rsc_counter = g_hash_table_lookup(rsc_table, buffer);
1284 if (rsc_counter == NULL) {
1285 rsc_counter = calloc(1,
sizeof(
int));
1287 g_hash_table_insert(rsc_table, strdup(buffer), rsc_counter);
1295 for (; gIter2 != NULL; gIter2 = gIter2->next) {
1297 GHashTable *node_table = NULL;
1303 node_table = g_hash_table_lookup(active_table, node->
details->
uname);
1304 if (node_table == NULL) {
1305 node_table = crm_str_table_new();
1306 g_hash_table_insert(active_table, strdup(node->
details->
uname), node_table);
1309 active_counter = g_hash_table_lookup(node_table, buffer);
1310 if (active_counter == NULL) {
1311 active_counter = calloc(1,
sizeof(
int));
1312 *active_counter = 0;
1313 g_hash_table_insert(node_table, strdup(buffer), active_counter);
1315 (*active_counter)++;
1322 destroy_node_table(gpointer
data)
1324 GHashTable *node_table =
data;
1327 g_hash_table_destroy(node_table);
1333 void *print_data, gboolean print_all)
1335 GHashTable *rsc_table = crm_str_table_new();
1336 GHashTable *active_table = g_hash_table_new_full(
crm_str_hash, g_str_equal,
1337 free, destroy_node_table);
1338 GHashTableIter hash_iter;
1340 int *rsc_counter = NULL;
1342 get_rscs_brief(rsc_list, rsc_table, active_table);
1344 g_hash_table_iter_init(&hash_iter, rsc_table);
1345 while (g_hash_table_iter_next(&hash_iter, (gpointer *)&
type, (gpointer *)&rsc_counter)) {
1346 GHashTableIter hash_iter2;
1347 char *node_name = NULL;
1348 GHashTable *node_table = NULL;
1349 int active_counter_all = 0;
1351 g_hash_table_iter_init(&hash_iter2, active_table);
1352 while (g_hash_table_iter_next(&hash_iter2, (gpointer *)&node_name, (gpointer *)&node_table)) {
1353 int *active_counter = g_hash_table_lookup(node_table,
type);
1355 if (active_counter == NULL || *active_counter == 0) {
1359 active_counter_all += *active_counter;
1371 status_print(
"%s%d/%d\t(%s):\tActive %s\n", pre_text ? pre_text :
"",
1372 active_counter ? *active_counter : 0,
1373 rsc_counter ? *rsc_counter : 0,
type,
1374 active_counter && (*active_counter > 0) && node_name ? node_name :
"");
1376 status_print(
"%s%d\t(%s):\tActive %s\n", pre_text ? pre_text :
"",
1377 active_counter ? *active_counter : 0,
type,
1378 active_counter && (*active_counter > 0) && node_name ? node_name :
"");
1386 if (print_all && active_counter_all == 0) {
1391 status_print(
"%s%d/%d\t(%s):\tActive\n", pre_text ? pre_text :
"",
1393 rsc_counter ? *rsc_counter : 0,
type);
1402 g_hash_table_destroy(rsc_table);
1406 g_hash_table_destroy(active_table);
1407 active_table = NULL;
1414 GHashTable *rsc_table = crm_str_table_new();
1415 GHashTable *active_table = g_hash_table_new_full(
crm_str_hash, g_str_equal,
1416 free, destroy_node_table);
1417 GHashTableIter hash_iter;
1419 int *rsc_counter = NULL;
1421 get_rscs_brief(rsc_list, rsc_table, active_table);
1423 g_hash_table_iter_init(&hash_iter, rsc_table);
1424 while (g_hash_table_iter_next(&hash_iter, (gpointer *)&
type, (gpointer *)&rsc_counter)) {
1425 GHashTableIter hash_iter2;
1426 char *node_name = NULL;
1427 GHashTable *node_table = NULL;
1428 int active_counter_all = 0;
1430 g_hash_table_iter_init(&hash_iter2, active_table);
1431 while (g_hash_table_iter_next(&hash_iter2, (gpointer *)&node_name, (gpointer *)&node_table)) {
1432 int *active_counter = g_hash_table_lookup(node_table,
type);
1434 if (active_counter == NULL || *active_counter == 0) {
1438 active_counter_all += *active_counter;
1446 out->
list_item(out, NULL,
" %d/%d\t(%s):\tActive %s",
1448 rsc_counter ? *rsc_counter : 0,
type,
1449 (*active_counter > 0) && node_name ? node_name :
"");
1451 out->
list_item(out, NULL,
" %d\t(%s):\tActive %s",
1452 *active_counter,
type,
1453 (*active_counter > 0) && node_name ? node_name :
"");
1457 if (print_all && active_counter_all == 0) {
1458 out->
list_item(out, NULL,
" %d/%d\t(%s):\tActive",
1460 rsc_counter ? *rsc_counter : 0,
type);
1465 g_hash_table_destroy(rsc_table);
1469 g_hash_table_destroy(active_table);
1470 active_table = NULL;