29 #define VARIANT_CONTAINER 1 35 next_ip(
const char *last_ip)
37 unsigned int oct1 = 0;
38 unsigned int oct2 = 0;
39 unsigned int oct3 = 0;
40 unsigned int oct4 = 0;
41 int rc = sscanf(last_ip,
"%u.%u.%u.%u", &oct1, &oct2, &oct3, &oct4);
47 }
else if (oct3 > 253) {
50 }
else if (oct4 > 253) {
62 allocate_ip(container_variant_data_t *
data, container_grouping_t *tuple,
char *buffer,
int max)
64 if(data->ip_range_start == NULL) {
67 }
else if(data->ip_last) {
68 tuple->ipaddr = next_ip(data->ip_last);
71 tuple->ipaddr = strdup(data->ip_range_start);
74 data->ip_last = tuple->ipaddr;
76 return snprintf(buffer, max,
" --add-host=%s-%d:%s --link %s-docker-%d:%s-link-%d",
77 data->prefix, tuple->offset, tuple->ipaddr,
78 data->prefix, tuple->offset, data->prefix, tuple->offset);
80 if (data->type == PE_CONTAINER_TYPE_DOCKER) {
81 return snprintf(buffer, max,
" --add-host=%s-%d:%s",
82 data->prefix, tuple->offset, tuple->ipaddr);
83 }
else if (data->type == PE_CONTAINER_TYPE_RKT) {
84 return snprintf(buffer, max,
" --hosts-entry=%s=%s-%d",
85 tuple->ipaddr, data->prefix, tuple->offset);
93 create_resource(
const char *name,
const char *provider,
const char *kind)
118 valid_network(container_variant_data_t *data)
120 if(data->ip_range_start) {
123 if(data->control_port) {
124 if(data->replicas_per_host > 1) {
125 pe_err(
"Specifying the 'control-port' for %s requires 'replicas-per-host=1'", data->prefix);
126 data->replicas_per_host = 1;
136 resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
139 if(data->ip_range_start) {
141 xmlNode *xml_ip = NULL;
142 xmlNode *xml_obj = NULL;
146 xml_ip = create_resource(
id,
"heartbeat",
"IPaddr2");
150 crm_xml_set_id(xml_obj,
"%s-attributes-%d", data->prefix, tuple->offset);
153 if(data->host_network) {
157 if(data->host_netmask) {
159 "cidr_netmask", data->host_netmask);
170 if (
common_unpack(xml_ip, &tuple->ip, parent, data_set) ==
false) {
180 create_docker_resource(
181 resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
184 int offset = 0, max = 4096;
185 char *buffer = calloc(1, max+1);
187 int doffset = 0, dmax = 1024;
188 char *dbuffer = calloc(1, dmax+1);
191 xmlNode *xml_docker = NULL;
192 xmlNode *xml_obj = NULL;
196 xml_docker = create_resource(
id,
"heartbeat",
"docker");
200 crm_xml_set_id(xml_obj,
"%s-attributes-%d", data->prefix, tuple->offset);
207 offset += snprintf(buffer+offset, max-offset,
" --restart=no");
214 if (data->ip_range_start != NULL) {
215 offset += snprintf(buffer+offset, max-offset,
" -h %s-%d",
216 data->prefix, tuple->offset);
219 offset += snprintf(buffer+offset, max-offset,
" -e PCMK_stderr=1");
221 if(data->docker_network) {
223 offset += snprintf(buffer+offset, max-offset,
" --net=%s", data->docker_network);
226 if(data->control_port) {
227 offset += snprintf(buffer+offset, max-offset,
" -e PCMK_remote_port=%s", data->control_port);
229 offset += snprintf(buffer+offset, max-offset,
" -e PCMK_remote_port=%d",
DEFAULT_REMOTE_PORT);
232 for(
GListPtr pIter = data->mounts; pIter != NULL; pIter = pIter->next) {
233 container_mount_t *mount = pIter->data;
237 "%s/%s-%d", mount->source, data->prefix, tuple->offset);
240 doffset += snprintf(dbuffer+doffset, dmax-doffset,
",");
242 doffset += snprintf(dbuffer+doffset, dmax-doffset,
"%s", source);
243 offset += snprintf(buffer+offset, max-offset,
" -v %s:%s", source, mount->target);
247 offset += snprintf(buffer+offset, max-offset,
" -v %s:%s", mount->source, mount->target);
250 offset += snprintf(buffer+offset, max-offset,
":%s", mount->options);
254 for(
GListPtr pIter = data->ports; pIter != NULL; pIter = pIter->next) {
255 container_port_t *port = pIter->data;
258 offset += snprintf(buffer+offset, max-offset,
" -p %s:%s:%s",
259 tuple->ipaddr, port->source, port->target);
262 offset += snprintf(buffer+offset, max-offset,
" -p %s:%s", port->source, port->target);
266 if(data->docker_run_options) {
267 offset += snprintf(buffer+offset, max-offset,
" %s", data->docker_run_options);
270 if(data->docker_host_options) {
271 offset += snprintf(buffer+offset, max-offset,
" %s", data->docker_host_options);
281 if(data->docker_run_command) {
283 "run_cmd", data->docker_run_command);
286 "run_cmd",
SBIN_DIR "/pacemaker_remoted");
310 if(data->docker_run_command) {
312 "run_cmd", data->docker_run_command);
328 if (
common_unpack(xml_docker, &tuple->docker, parent, data_set) == FALSE) {
337 resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
340 int offset = 0, max = 4096;
341 char *buffer = calloc(1, max+1);
343 int doffset = 0, dmax = 1024;
344 char *dbuffer = calloc(1, dmax+1);
347 xmlNode *xml_docker = NULL;
348 xmlNode *xml_obj = NULL;
354 xml_docker = create_resource(
id,
"heartbeat",
"rkt");
358 crm_xml_set_id(xml_obj,
"%s-attributes-%d", data->prefix, tuple->offset);
370 if (data->ip_range_start != NULL) {
371 offset += snprintf(buffer+offset, max-offset,
" --hostname=%s-%d",
372 data->prefix, tuple->offset);
375 offset += snprintf(buffer+offset, max-offset,
" --environment=PCMK_stderr=1");
377 if(data->docker_network) {
379 offset += snprintf(buffer+offset, max-offset,
" --net=%s", data->docker_network);
382 if(data->control_port) {
383 offset += snprintf(buffer+offset, max-offset,
" --environment=PCMK_remote_port=%s", data->control_port);
385 offset += snprintf(buffer+offset, max-offset,
" --environment=PCMK_remote_port=%d",
DEFAULT_REMOTE_PORT);
388 for(
GListPtr pIter = data->mounts; pIter != NULL; pIter = pIter->next) {
389 container_mount_t *mount = pIter->data;
393 "%s/%s-%d", mount->source, data->prefix, tuple->offset);
396 doffset += snprintf(dbuffer+doffset, dmax-doffset,
",");
398 doffset += snprintf(dbuffer+doffset, dmax-doffset,
"%s", source);
399 offset += snprintf(buffer+offset, max-offset,
" --volume vol%d,kind=host,source=%s", volid, source);
401 offset += snprintf(buffer+offset, max-offset,
",%s", mount->options);
403 offset += snprintf(buffer+offset, max-offset,
" --mount volume=vol%d,target=%s", volid, mount->target);
407 offset += snprintf(buffer+offset, max-offset,
" --volume vol%d,kind=host,source=%s", volid, mount->source);
409 offset += snprintf(buffer+offset, max-offset,
",%s", mount->options);
411 offset += snprintf(buffer+offset, max-offset,
" --mount volume=vol%d,target=%s", volid, mount->target);
416 for(
GListPtr pIter = data->ports; pIter != NULL; pIter = pIter->next) {
417 container_port_t *port = pIter->data;
420 offset += snprintf(buffer+offset, max-offset,
" --port=%s:%s:%s",
421 port->target, tuple->ipaddr, port->source);
423 offset += snprintf(buffer+offset, max-offset,
" --port=%s:%s", port->target, port->source);
427 if(data->docker_run_options) {
428 offset += snprintf(buffer+offset, max-offset,
" %s", data->docker_run_options);
431 if(data->docker_host_options) {
432 offset += snprintf(buffer+offset, max-offset,
" %s", data->docker_host_options);
442 if(data->docker_run_command) {
469 if(data->docker_run_command) {
471 data->docker_run_command);
488 if (
common_unpack(xml_docker, &tuple->docker, parent, data_set) == FALSE) {
504 gpointer match = g_hash_table_lookup(rsc->
allowed_nodes, uname);
513 for (child = rsc->
children; child != NULL; child = child->next) {
514 disallow_node((
resource_t *) (child->data), uname);
520 create_remote_resource(
521 resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
524 if (tuple->child && valid_network(data)) {
528 xmlNode *xml_remote = NULL;
531 const char *uname = NULL;
532 const char *connect_name = NULL;
537 id =
crm_strdup_printf(
"pcmk-internal-%s-remote-%d", tuple->child->id, tuple->offset);
545 connect_name = (tuple->ipaddr? tuple->ipaddr :
"#uname");
547 if (data->control_port == NULL) {
557 NULL, NULL,
"60s", NULL,
560 data->control_port : port_s));
569 uname =
ID(xml_remote);
601 for (rsc_iter = data_set->
resources; rsc_iter; rsc_iter = rsc_iter->next) {
602 disallow_node((
resource_t *) (rsc_iter->data), uname);
606 tuple->node->weight = 500;
610 if (tuple->child->allowed_nodes != NULL) {
611 g_hash_table_destroy(tuple->child->allowed_nodes);
614 g_hash_table_insert(tuple->child->allowed_nodes, (gpointer) tuple->node->details->id,
node_copy(tuple->node));
619 g_hash_table_insert(tuple->child->parent->allowed_nodes, (gpointer) tuple->node->details->id, copy);
621 if (
common_unpack(xml_remote, &tuple->remote, parent, data_set) == FALSE) {
625 g_hash_table_iter_init(&gIter, tuple->remote->allowed_nodes);
626 while (g_hash_table_iter_next(&gIter, NULL, (
void **)&node)) {
633 tuple->node->details->remote_rsc = tuple->remote;
634 tuple->remote->container = tuple->docker;
639 g_hash_table_insert(tuple->node->details->attrs,
658 resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
662 if (data->type == PE_CONTAINER_TYPE_DOCKER &&
663 create_docker_resource(parent, data, tuple, data_set) == FALSE) {
666 if (data->type == PE_CONTAINER_TYPE_RKT &&
667 create_rkt_resource(parent, data, tuple, data_set) == FALSE) {
671 if(create_ip_resource(parent, data, tuple, data_set) == FALSE) {
674 if(create_remote_resource(parent, data, tuple, data_set) == FALSE) {
677 if(tuple->child && tuple->ipaddr) {
698 mount_add(container_variant_data_t *container_data,
const char *source,
699 const char *target,
const char *options,
int flags)
701 container_mount_t *mount = calloc(1,
sizeof(container_mount_t));
703 mount->source = strdup(source);
704 mount->target = strdup(target);
706 mount->options = strdup(options);
708 mount->flags =
flags;
709 container_data->mounts = g_list_append(container_data->mounts, mount);
712 static void mount_free(container_mount_t *mount)
716 free(mount->options);
720 static void port_free(container_port_t *port)
727 static container_grouping_t *
731 container_variant_data_t *container_data = NULL;
737 while (top->
parent != NULL) {
741 get_container_variant_data(container_data, top);
742 for (
GListPtr gIter = container_data->tuples; gIter != NULL; gIter = gIter->next) {
743 container_grouping_t *tuple = (container_grouping_t *)gIter->data;
744 if(tuple->remote == remote) {
757 const char *attr_list[] = {
762 const char *value_list[] = {
773 value = g_hash_table_lookup(rsc->
parameters, name);
778 for (
int lpc = 0; lpc <
DIMOF(attr_list); lpc++) {
780 if (
safe_str_eq(value, value_list[lpc]) == FALSE) {
793 container_grouping_t *tuple = NULL;
799 tuple = tuple_for_remote(rsc);
804 node = tuple->docker->allocated_to;
809 node = pe__current_node(tuple->docker);
813 crm_trace(
"Cannot determine address for bundle connection %s", rsc->
id);
817 crm_trace(
"Setting address for bundle connection %s to bundle host %s",
819 if(xml != NULL && field != NULL) {
829 const char *value = NULL;
830 xmlNode *xml_obj = NULL;
831 xmlNode *xml_resource = NULL;
832 container_variant_data_t *container_data = NULL;
837 container_data = calloc(1,
sizeof(container_variant_data_t));
839 container_data->prefix = strdup(rsc->
id);
842 if (xml_obj != NULL) {
843 container_data->type = PE_CONTAINER_TYPE_DOCKER;
846 if (xml_obj != NULL) {
847 container_data->type = PE_CONTAINER_TYPE_RKT;
855 if (container_data->masters < 0) {
856 pe_err(
"'masters' for %s must be nonnegative integer, using 0",
858 container_data->masters = 0;
862 if ((value == NULL) && (container_data->masters > 0)) {
863 container_data->replicas = container_data->masters;
867 if (container_data->replicas < 1) {
868 pe_err(
"'replicas' for %s must be positive integer, using 1", rsc->
id);
869 container_data->replicas = 1;
878 container_data->replicas_per_host =
crm_parse_int(value,
"1");
879 if (container_data->replicas_per_host < 1) {
880 pe_err(
"'replicas-per-host' for %s must be positive integer, using 1",
882 container_data->replicas_per_host = 1;
884 if (container_data->replicas_per_host == 1) {
901 for (xmlNode *xml_child = __xml_first_child_element(xml_obj); xml_child != NULL;
902 xml_child = __xml_next_element(xml_child)) {
904 container_port_t *port = calloc(1,
sizeof(container_port_t));
907 if(port->source == NULL) {
913 if(port->source != NULL && strlen(port->source) > 0) {
914 if(port->target == NULL) {
915 port->target = strdup(port->source);
917 container_data->ports = g_list_append(container_data->ports, port);
920 pe_err(
"Invalid port directive %s",
ID(xml_child));
927 for (xmlNode *xml_child = __xml_first_child_element(xml_obj); xml_child != NULL;
928 xml_child = __xml_next_element(xml_child)) {
935 if (source == NULL) {
940 if (source && target) {
941 mount_add(container_data, source, target, options, flags);
943 pe_err(
"Invalid mount directive %s",
ID(xml_child));
948 if (xml_obj && valid_network(container_data)) {
950 xmlNode *xml_set = NULL;
952 if(container_data->masters > 0) {
959 crm_xml_set_id(xml_resource,
"%s-%s", container_data->prefix, xml_resource->name);
962 crm_xml_set_id(xml_set,
"%s-%s-meta", container_data->prefix, xml_resource->name);
967 value =
crm_itoa(container_data->replicas);
972 value =
crm_itoa(container_data->replicas_per_host);
978 (container_data->replicas_per_host > 1)?
981 if(container_data->masters) {
982 value =
crm_itoa(container_data->masters);
992 pe_err(
"Cannot control %s inside %s without either ip-range-start or control-port",
993 rsc->
id,
ID(xml_obj));
1001 container_port_t *port = NULL;
1003 int offset = 0, max = 1024;
1004 char *buffer = NULL;
1006 if (
common_unpack(xml_resource, &new_rsc, rsc, data_set) == FALSE) {
1007 pe_err(
"Failed unpacking resource %s",
ID(rsc->
xml));
1008 if (new_rsc != NULL && new_rsc->
fns != NULL) {
1014 container_data->child = new_rsc;
1040 mount_add(container_data,
CRM_LOG_DIR "/bundles",
"/var/log", NULL, 1);
1042 port = calloc(1,
sizeof(container_port_t));
1043 if(container_data->control_port) {
1044 port->source = strdup(container_data->control_port);
1056 port->target = strdup(port->source);
1057 container_data->ports = g_list_append(container_data->ports, port);
1059 buffer = calloc(1, max+1);
1060 for(childIter = container_data->child->children; childIter != NULL; childIter = childIter->next) {
1061 container_grouping_t *tuple = calloc(1,
sizeof(container_grouping_t));
1062 tuple->child = childIter->data;
1063 tuple->child->exclusive_discover = TRUE;
1064 tuple->offset = lpc++;
1071 offset += allocate_ip(container_data, tuple, buffer+offset, max-offset);
1072 container_data->tuples = g_list_append(container_data->tuples, tuple);
1073 container_data->attribute_target = g_hash_table_lookup(tuple->child->meta,
XML_RSC_ATTR_TARGET);
1075 container_data->docker_host_options = buffer;
1076 if(container_data->attribute_target) {
1078 g_hash_table_replace(container_data->child->meta, strdup(
XML_RSC_ATTR_TARGET), strdup(container_data->attribute_target));
1083 int offset = 0, max = 1024;
1084 char *buffer = calloc(1, max+1);
1086 for(
int lpc = 0; lpc < container_data->replicas; lpc++) {
1087 container_grouping_t *tuple = calloc(1,
sizeof(container_grouping_t));
1088 tuple->offset = lpc;
1089 offset += allocate_ip(container_data, tuple, buffer+offset, max-offset);
1090 container_data->tuples = g_list_append(container_data->tuples, tuple);
1093 container_data->docker_host_options = buffer;
1096 for (
GListPtr gIter = container_data->tuples; gIter != NULL; gIter = gIter->next) {
1097 container_grouping_t *tuple = (container_grouping_t *)gIter->data;
1098 if (create_container(rsc, container_data, tuple, data_set) == FALSE) {
1099 pe_err(
"Failed unpacking resource %s", rsc->
id);
1105 if(container_data->child) {
1112 tuple_rsc_active(
resource_t *rsc, gboolean all)
1115 gboolean child_active = rsc->
fns->
active(rsc, all);
1117 if (child_active && !all) {
1119 }
else if (!child_active && all) {
1129 container_variant_data_t *container_data = NULL;
1132 get_container_variant_data(container_data, rsc);
1133 for (iter = container_data->tuples; iter != NULL; iter = iter->next) {
1134 container_grouping_t *tuple = (container_grouping_t *)(iter->data);
1137 rsc_active = tuple_rsc_active(tuple->ip, all);
1138 if (rsc_active >= 0) {
1139 return (gboolean) rsc_active;
1142 rsc_active = tuple_rsc_active(tuple->child, all);
1143 if (rsc_active >= 0) {
1144 return (gboolean) rsc_active;
1147 rsc_active = tuple_rsc_active(tuple->docker, all);
1148 if (rsc_active >= 0) {
1149 return (gboolean) rsc_active;
1152 rsc_active = tuple_rsc_active(tuple->remote, all);
1153 if (rsc_active >= 0) {
1154 return (gboolean) rsc_active;
1177 container_variant_data_t *container_data = NULL;
1180 get_container_variant_data(container_data, bundle);
1181 for (
GListPtr gIter = container_data->tuples; gIter != NULL;
1182 gIter = gIter->next) {
1183 container_grouping_t *tuple = (container_grouping_t *)gIter->data;
1186 if (tuple->node->details == node->
details) {
1187 return tuple->child;
1194 print_rsc_in_list(
resource_t *rsc,
const char *pre_text,
long options,
1201 rsc->
fns->
print(rsc, pre_text, options, print_data);
1202 if (options & pe_print_html) {
1209 container_type_as_string(
enum container_type t)
1211 if (t == PE_CONTAINER_TYPE_DOCKER) {
1212 return PE_CONTAINER_TYPE_DOCKER_S;
1213 }
else if (t == PE_CONTAINER_TYPE_RKT) {
1214 return PE_CONTAINER_TYPE_RKT_S;
1216 return PE_CONTAINER_TYPE_UNKNOWN_S;
1221 container_print_xml(
resource_t * rsc,
const char *pre_text,
long options,
void *print_data)
1223 container_variant_data_t *container_data = NULL;
1224 char *child_text = NULL;
1227 if (pre_text == NULL) {
1232 get_container_variant_data(container_data, rsc);
1239 for (
const char *c = container_type_as_string(container_data->type);
1251 for (
GListPtr gIter = container_data->tuples; gIter != NULL; gIter = gIter->next) {
1252 container_grouping_t *tuple = (container_grouping_t *)gIter->data;
1255 status_print(
"%s <replica id=\"%d\">\n", pre_text, tuple->offset);
1256 print_rsc_in_list(tuple->ip, child_text, options, print_data);
1257 print_rsc_in_list(tuple->child, child_text, options, print_data);
1258 print_rsc_in_list(tuple->docker, child_text, options, print_data);
1259 print_rsc_in_list(tuple->remote, child_text, options, print_data);
1267 tuple_print(container_grouping_t * tuple,
const char *pre_text,
long options,
void *print_data)
1273 char buffer[LINE_MAX];
1276 rsc = tuple->docker;
1280 offset += snprintf(buffer + offset, LINE_MAX - offset,
"%s",
rsc_printable_id(tuple->remote));
1282 offset += snprintf(buffer + offset, LINE_MAX - offset,
"%s",
rsc_printable_id(tuple->docker));
1285 offset += snprintf(buffer + offset, LINE_MAX - offset,
" (%s)", tuple->ipaddr);
1288 node = pe__current_node(tuple->docker);
1289 common_print(rsc, pre_text, buffer, node, options, print_data);
1295 container_variant_data_t *container_data = NULL;
1296 char *child_text = NULL;
1300 container_print_xml(rsc, pre_text, options, print_data);
1304 get_container_variant_data(container_data, rsc);
1306 if (pre_text == NULL) {
1311 pre_text, container_type_as_string(container_data->type),
1312 container_data->replicas>1?
" set":
"", rsc->
id, container_data->image,
1320 for (
GListPtr gIter = container_data->tuples; gIter != NULL; gIter = gIter->next) {
1321 container_grouping_t *tuple = (container_grouping_t *)gIter->data;
1324 if (options & pe_print_html) {
1330 if(g_list_length(container_data->tuples) > 1) {
1331 status_print(
" %sReplica[%d]\n", pre_text, tuple->offset);
1333 if (options & pe_print_html) {
1336 print_rsc_in_list(tuple->ip, child_text, options, print_data);
1337 print_rsc_in_list(tuple->docker, child_text, options, print_data);
1338 print_rsc_in_list(tuple->remote, child_text, options, print_data);
1339 print_rsc_in_list(tuple->child, child_text, options, print_data);
1340 if (options & pe_print_html) {
1345 tuple_print(tuple, child_text, options, print_data);
1349 if (options & pe_print_html) {
1353 if (options & pe_print_html) {
1372 tuple->ip->xml = NULL;
1373 tuple->ip->fns->free(tuple->ip);
1378 tuple->docker->xml = NULL;
1379 tuple->docker->fns->free(tuple->docker);
1380 tuple->docker = NULL;
1384 tuple->remote->xml = NULL;
1385 tuple->remote->fns->free(tuple->remote);
1386 tuple->remote = NULL;
1388 free(tuple->ipaddr);
1395 container_variant_data_t *container_data = NULL;
1398 get_container_variant_data(container_data, rsc);
1401 free(container_data->prefix);
1402 free(container_data->image);
1403 free(container_data->control_port);
1404 free(container_data->host_network);
1405 free(container_data->host_netmask);
1406 free(container_data->ip_range_start);
1407 free(container_data->docker_network);
1408 free(container_data->docker_run_options);
1409 free(container_data->docker_run_command);
1410 free(container_data->docker_host_options);
1412 g_list_free_full(container_data->tuples, (GDestroyNotify)
tuple_free);
1413 g_list_free_full(container_data->mounts, (GDestroyNotify)mount_free);
1414 g_list_free_full(container_data->ports, (GDestroyNotify)port_free);
1417 if(container_data->child) {
1418 free_xml(container_data->child->xml);
1419 container_data->child->xml = NULL;
1420 container_data->child->fns->free(container_data->child);
1429 return container_role;
1445 container_variant_data_t *container_data = NULL;
1447 get_container_variant_data(container_data, rsc);
1448 return container_data->replicas;
1455 container_variant_data_t *bundle_data = NULL;
1457 get_container_variant_data(bundle_data, rsc);
1458 for (GList *item = bundle_data->tuples; item != NULL; item = item->next) {
1459 container_grouping_t *replica = item->data;
1462 replica->ip->fns->count(replica->ip);
1464 if (replica->child) {
1465 replica->child->fns->count(replica->child);
1467 if (replica->docker) {
1468 replica->docker->fns->count(replica->docker);
1470 if (replica->remote) {
1471 replica->remote->fns->count(replica->remote);
bool remote_id_conflict(const char *remote_name, pe_working_set_t *data)
#define CRM_CHECK(expr, failure_action)
gboolean safe_str_neq(const char *a, const char *b)
int pe_bundle_replicas(const resource_t *rsc)
Get the number of configured replicas in a bundle.
node_t * node_copy(const node_t *this_node)
node_t * pe_create_node(const char *id, const char *uname, const char *type, const char *score, pe_working_set_t *data_set)
void(* free)(resource_t *)
#define XML_BOOLEAN_FALSE
gboolean common_unpack(xmlNode *xml_obj, resource_t **rsc, resource_t *parent, pe_working_set_t *data_set)
enum pe_obj_types variant
void common_free(resource_t *rsc)
const char * crm_xml_add(xmlNode *node, const char *name, const char *value)
Create an XML attribute with specified name and value.
#define status_print(fmt, args...)
int crm_parse_int(const char *text, const char *default_text)
Parse an integer value from a string.
node_t * pe_find_node(GListPtr node_list, const char *uname)
#define CRM_LOG_ASSERT(expr)
#define clear_bit(word, bit)
#define XML_RSC_ATTR_INCARNATION_MAX
#define XML_RSC_ATTR_TARGET
#define pe_rsc_allow_remote_remotes
void crm_xml_sanitize_id(char *id)
Sanitize a string so it is usable as an XML ID.
#define DEFAULT_REMOTE_PORT
#define DEFAULT_REMOTE_KEY_LOCATION
#define XML_TAG_ATTR_SETS
gboolean is_remote_node(node_t *node)
struct node_shared_s * details
#define set_bit(word, bit)
#define PCMK_RESOURCE_CLASS_OCF
xmlNode * pe_create_remote_xml(xmlNode *parent, const char *uname, const char *container_id, const char *migrateable, const char *is_managed, const char *interval, const char *monitor_timeout, const char *start_timeout, const char *server, const char *port)
char * crm_element_value_copy(const xmlNode *data, const char *name)
Retrieve a copy of the value of an XML attribute.
const char * crm_element_value(const xmlNode *data, const char *name)
Retrieve the value of an XML attribute.
#define XML_CIB_TAG_RESOURCE
resource_object_functions_t * fns
resource_t * find_container_child(const resource_t *bundle, const node_t *node)
GHashTable * allowed_nodes
#define crm_trace(fmt, args...)
xmlNode * add_node_copy(xmlNode *new_parent, xmlNode *xml_node)
xmlNode * crm_create_op_xml(xmlNode *parent, const char *prefix, const char *task, const char *interval, const char *timeout)
Create a CIB XML element for an operation.
#define XML_AGENT_ATTR_PROVIDER
#define XML_RSC_ATTR_ORDERED
#define XML_TAG_META_SETS
xmlNode * create_xml_node(xmlNode *parent, const char *name)
#define XML_RSC_ATTR_INCARNATION_NODEMAX
void free_xml(xmlNode *child)
bool container_fix_remote_addr(resource_t *rsc)
#define XML_RSC_ATTR_UNIQUE
gboolean(* active)(resource_t *, gboolean)
void common_print(resource_t *rsc, const char *pre_text, const char *name, node_t *node, long options, void *print_data)
#define XML_RSC_ATTR_MASTER_MAX
void(* print)(resource_t *, const char *, long, void *)
gboolean container_unpack(resource_t *rsc, pe_working_set_t *data_set)
enum rsc_role_e container_resource_state(const resource_t *rsc, gboolean current)
Cluster status and scheduling.
void tuple_free(container_grouping_t *tuple)
#define XML_CIB_TAG_INCARNATION
void add_hash_param(GHashTable *hash, const char *name, const char *value)
void pe__count_bundle(pe_resource_t *rsc)
void crm_xml_set_id(xmlNode *xml, const char *format,...) __attribute__((__format__(__printf__
gboolean container_active(resource_t *rsc, gboolean all)
#define XML_CIB_TAG_MASTER
xmlNode * first_named_child(xmlNode *parent, const char *name)
#define pe_rsc_trace(rsc, fmt, args...)
xmlNode * crm_create_nvpair_xml(xmlNode *parent, const char *id, const char *name, const char *value)
Create an XML name/value pair.
char * crm_concat(const char *prefix, const char *suffix, char join)
char * crm_itoa(int an_int)
#define safe_str_eq(a, b)
char * crm_strdup_printf(char const *format,...) __attribute__((__format__(__printf__
const char * container_fix_remote_addr_in(resource_t *rsc, xmlNode *xml, const char *field)
void container_print(resource_t *rsc, const char *pre_text, long options, void *print_data)
void g_hash_destroy_str(gpointer data)
const char * rsc_printable_id(resource_t *rsc)
#define XML_AGENT_ATTR_CLASS
void container_free(resource_t *rsc)