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);
171 if (
common_unpack(xml_ip, &tuple->ip, parent, data_set) ==
false) {
181 create_docker_resource(
182 resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
185 int offset = 0, max = 4096;
186 char *buffer = calloc(1, max+1);
188 int doffset = 0, dmax = 1024;
189 char *dbuffer = calloc(1, dmax+1);
192 xmlNode *xml_docker = NULL;
193 xmlNode *xml_obj = NULL;
197 xml_docker = create_resource(
id,
"heartbeat",
"docker");
201 crm_xml_set_id(xml_obj,
"%s-attributes-%d", data->prefix, tuple->offset);
208 offset += snprintf(buffer+offset, max-offset,
" --restart=no");
215 if (data->ip_range_start != NULL) {
216 offset += snprintf(buffer+offset, max-offset,
" -h %s-%d",
217 data->prefix, tuple->offset);
220 offset += snprintf(buffer+offset, max-offset,
" -e PCMK_stderr=1");
222 if(data->docker_network) {
224 offset += snprintf(buffer+offset, max-offset,
" --net=%s", data->docker_network);
227 if(data->control_port) {
228 offset += snprintf(buffer+offset, max-offset,
" -e PCMK_remote_port=%s", data->control_port);
230 offset += snprintf(buffer+offset, max-offset,
" -e PCMK_remote_port=%d",
DEFAULT_REMOTE_PORT);
233 for(
GListPtr pIter = data->mounts; pIter != NULL; pIter = pIter->next) {
234 container_mount_t *mount = pIter->data;
238 "%s/%s-%d", mount->source, data->prefix, tuple->offset);
241 doffset += snprintf(dbuffer+doffset, dmax-doffset,
",");
243 doffset += snprintf(dbuffer+doffset, dmax-doffset,
"%s", source);
244 offset += snprintf(buffer+offset, max-offset,
" -v %s:%s", source, mount->target);
248 offset += snprintf(buffer+offset, max-offset,
" -v %s:%s", mount->source, mount->target);
251 offset += snprintf(buffer+offset, max-offset,
":%s", mount->options);
255 for(
GListPtr pIter = data->ports; pIter != NULL; pIter = pIter->next) {
256 container_port_t *port = pIter->data;
259 offset += snprintf(buffer+offset, max-offset,
" -p %s:%s:%s",
260 tuple->ipaddr, port->source, port->target);
263 offset += snprintf(buffer+offset, max-offset,
" -p %s:%s", port->source, port->target);
267 if(data->docker_run_options) {
268 offset += snprintf(buffer+offset, max-offset,
" %s", data->docker_run_options);
271 if(data->docker_host_options) {
272 offset += snprintf(buffer+offset, max-offset,
" %s", data->docker_host_options);
282 if(data->docker_run_command) {
284 "run_cmd", data->docker_run_command);
287 "run_cmd",
SBIN_DIR "/pacemaker_remoted");
311 if(data->docker_run_command) {
313 "run_cmd", data->docker_run_command);
330 if (
common_unpack(xml_docker, &tuple->docker, parent, data_set) == FALSE) {
339 resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
342 int offset = 0, max = 4096;
343 char *buffer = calloc(1, max+1);
345 int doffset = 0, dmax = 1024;
346 char *dbuffer = calloc(1, dmax+1);
349 xmlNode *xml_docker = NULL;
350 xmlNode *xml_obj = NULL;
356 xml_docker = create_resource(
id,
"heartbeat",
"rkt");
360 crm_xml_set_id(xml_obj,
"%s-attributes-%d", data->prefix, tuple->offset);
372 if (data->ip_range_start != NULL) {
373 offset += snprintf(buffer+offset, max-offset,
" --hostname=%s-%d",
374 data->prefix, tuple->offset);
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);
489 if (
common_unpack(xml_docker, &tuple->docker, parent, data_set) == FALSE) {
505 gpointer match = g_hash_table_lookup(rsc->
allowed_nodes, uname);
514 for (child = rsc->
children; child != NULL; child = child->next) {
515 disallow_node((
resource_t *) (child->data), uname);
521 create_remote_resource(
522 resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
525 if (tuple->child && valid_network(data)) {
529 xmlNode *xml_remote = NULL;
532 const char *uname = NULL;
533 const char *connect_name = NULL;
538 id =
crm_strdup_printf(
"pcmk-internal-%s-remote-%d", tuple->child->id, tuple->offset);
546 connect_name = (tuple->ipaddr? tuple->ipaddr :
"#uname");
548 if (data->control_port == NULL) {
561 data->control_port : port_s));
570 uname =
ID(xml_remote);
602 for (rsc_iter = data_set->
resources; rsc_iter; rsc_iter = rsc_iter->next) {
603 disallow_node((
resource_t *) (rsc_iter->data), uname);
607 tuple->node->weight = 500;
611 g_hash_table_destroy(tuple->child->allowed_nodes);
613 g_hash_table_insert(tuple->child->allowed_nodes, (gpointer) tuple->node->details->id,
node_copy(tuple->node));
618 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++) {
779 name = attr_list[lpc];
781 if (
safe_str_eq(value, value_list[lpc]) == FALSE) {
794 container_grouping_t *tuple = NULL;
800 tuple = tuple_for_remote(rsc);
805 node = tuple->docker->allocated_to;
806 if(node == NULL && tuple->docker->running_on) {
810 node = tuple->docker->running_on->data;
814 crm_trace(
"Cannot fix address for %s", tuple->remote->id);
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;
1002 const char *key_loc = NULL;
1004 int offset = 0, max = 1024;
1005 char *buffer = NULL;
1007 if (
common_unpack(xml_resource, &new_rsc, rsc, data_set) == FALSE) {
1008 pe_err(
"Failed unpacking resource %s",
ID(rsc->
xml));
1009 if (new_rsc != NULL && new_rsc->
fns != NULL) {
1015 container_data->child = new_rsc;
1037 key_loc = getenv(
"PCMK_authkey_location");
1038 if (key_loc == NULL) {
1044 mount_add(container_data,
CRM_LOG_DIR "/bundles",
"/var/log", NULL, 1);
1046 port = calloc(1,
sizeof(container_port_t));
1047 if(container_data->control_port) {
1048 port->source = strdup(container_data->control_port);
1060 port->target = strdup(port->source);
1061 container_data->ports = g_list_append(container_data->ports, port);
1063 buffer = calloc(1, max+1);
1064 for(childIter = container_data->child->children; childIter != NULL; childIter = childIter->next) {
1065 container_grouping_t *tuple = calloc(1,
sizeof(container_grouping_t));
1066 tuple->child = childIter->data;
1067 tuple->child->exclusive_discover = TRUE;
1068 tuple->offset = lpc++;
1075 offset += allocate_ip(container_data, tuple, buffer+offset, max-offset);
1076 container_data->tuples = g_list_append(container_data->tuples, tuple);
1077 container_data->attribute_target = g_hash_table_lookup(tuple->child->meta,
XML_RSC_ATTR_TARGET);
1079 container_data->docker_host_options = buffer;
1080 if(container_data->attribute_target) {
1082 g_hash_table_replace(container_data->child->meta, strdup(
XML_RSC_ATTR_TARGET), strdup(container_data->attribute_target));
1087 int offset = 0, max = 1024;
1088 char *buffer = calloc(1, max+1);
1090 for(
int lpc = 0; lpc < container_data->replicas; lpc++) {
1091 container_grouping_t *tuple = calloc(1,
sizeof(container_grouping_t));
1092 tuple->offset = lpc;
1093 offset += allocate_ip(container_data, tuple, buffer+offset, max-offset);
1094 container_data->tuples = g_list_append(container_data->tuples, tuple);
1097 container_data->docker_host_options = buffer;
1100 for (
GListPtr gIter = container_data->tuples; gIter != NULL; gIter = gIter->next) {
1101 container_grouping_t *tuple = (container_grouping_t *)gIter->data;
1102 if (create_container(rsc, container_data, tuple, data_set) == FALSE) {
1103 pe_err(
"Failed unpacking resource %s", rsc->
id);
1109 if(container_data->child) {
1116 tuple_rsc_active(
resource_t *rsc, gboolean all)
1119 gboolean child_active = rsc->
fns->
active(rsc, all);
1121 if (child_active && !all) {
1123 }
else if (!child_active && all) {
1133 container_variant_data_t *container_data = NULL;
1136 get_container_variant_data(container_data, rsc);
1137 for (iter = container_data->tuples; iter != NULL; iter = iter->next) {
1138 container_grouping_t *tuple = (container_grouping_t *)(iter->data);
1141 rsc_active = tuple_rsc_active(tuple->ip, all);
1142 if (rsc_active >= 0) {
1143 return (gboolean) rsc_active;
1146 rsc_active = tuple_rsc_active(tuple->child, all);
1147 if (rsc_active >= 0) {
1148 return (gboolean) rsc_active;
1151 rsc_active = tuple_rsc_active(tuple->docker, all);
1152 if (rsc_active >= 0) {
1153 return (gboolean) rsc_active;
1156 rsc_active = tuple_rsc_active(tuple->remote, all);
1157 if (rsc_active >= 0) {
1158 return (gboolean) rsc_active;
1172 container_variant_data_t *container_data = NULL;
1177 get_container_variant_data(container_data, parent);
1180 for (
GListPtr gIter = container_data->tuples; gIter != NULL; gIter = gIter->next) {
1181 container_grouping_t *tuple = (container_grouping_t *)gIter->data;
1184 if(tuple->node->details == node->
details) {
1200 print_rsc_in_list(
resource_t *rsc,
const char *pre_text,
long options,
1207 rsc->
fns->
print(rsc, pre_text, options, print_data);
1208 if (options & pe_print_html) {
1215 container_type_as_string(
enum container_type t)
1217 if (t == PE_CONTAINER_TYPE_DOCKER) {
1218 return PE_CONTAINER_TYPE_DOCKER_S;
1219 }
else if (t == PE_CONTAINER_TYPE_RKT) {
1220 return PE_CONTAINER_TYPE_RKT_S;
1222 return PE_CONTAINER_TYPE_UNKNOWN_S;
1227 container_print_xml(
resource_t * rsc,
const char *pre_text,
long options,
void *print_data)
1229 container_variant_data_t *container_data = NULL;
1230 char *child_text = NULL;
1233 if (pre_text == NULL) {
1238 get_container_variant_data(container_data, rsc);
1245 for (
const char *c = container_type_as_string(container_data->type);
1257 for (
GListPtr gIter = container_data->tuples; gIter != NULL; gIter = gIter->next) {
1258 container_grouping_t *tuple = (container_grouping_t *)gIter->data;
1261 status_print(
"%s <replica id=\"%d\">\n", pre_text, tuple->offset);
1262 print_rsc_in_list(tuple->ip, child_text, options, print_data);
1263 print_rsc_in_list(tuple->child, child_text, options, print_data);
1264 print_rsc_in_list(tuple->docker, child_text, options, print_data);
1265 print_rsc_in_list(tuple->remote, child_text, options, print_data);
1273 tuple_print(container_grouping_t * tuple,
const char *pre_text,
long options,
void *print_data)
1279 char buffer[LINE_MAX];
1282 rsc = tuple->docker;
1286 offset += snprintf(buffer + offset, LINE_MAX - offset,
"%s",
rsc_printable_id(tuple->remote));
1288 offset += snprintf(buffer + offset, LINE_MAX - offset,
"%s",
rsc_printable_id(tuple->docker));
1291 offset += snprintf(buffer + offset, LINE_MAX - offset,
" (%s)", tuple->ipaddr);
1294 if (tuple->docker->running_on) {
1295 node = tuple->docker->running_on->data;
1297 common_print(rsc, pre_text, buffer, node, options, print_data);
1303 container_variant_data_t *container_data = NULL;
1304 char *child_text = NULL;
1308 container_print_xml(rsc, pre_text, options, print_data);
1312 get_container_variant_data(container_data, rsc);
1314 if (pre_text == NULL) {
1319 pre_text, container_type_as_string(container_data->type),
1320 container_data->replicas>1?
" set":
"", rsc->
id, container_data->image,
1328 for (
GListPtr gIter = container_data->tuples; gIter != NULL; gIter = gIter->next) {
1329 container_grouping_t *tuple = (container_grouping_t *)gIter->data;
1332 if (options & pe_print_html) {
1338 if(g_list_length(container_data->tuples) > 1) {
1339 status_print(
" %sReplica[%d]\n", pre_text, tuple->offset);
1341 if (options & pe_print_html) {
1344 print_rsc_in_list(tuple->ip, child_text, options, print_data);
1345 print_rsc_in_list(tuple->docker, child_text, options, print_data);
1346 print_rsc_in_list(tuple->remote, child_text, options, print_data);
1347 print_rsc_in_list(tuple->child, child_text, options, print_data);
1348 if (options & pe_print_html) {
1353 tuple_print(tuple, child_text, options, print_data);
1357 if (options & pe_print_html) {
1361 if (options & pe_print_html) {
1380 tuple->ip->xml = NULL;
1381 tuple->ip->fns->free(tuple->ip);
1386 tuple->docker->xml = NULL;
1387 tuple->docker->fns->free(tuple->docker);
1388 tuple->docker = NULL;
1392 tuple->remote->xml = NULL;
1393 tuple->remote->fns->free(tuple->remote);
1394 tuple->remote = NULL;
1396 free(tuple->ipaddr);
1403 container_variant_data_t *container_data = NULL;
1406 get_container_variant_data(container_data, rsc);
1409 free(container_data->prefix);
1410 free(container_data->image);
1411 free(container_data->control_port);
1412 free(container_data->host_network);
1413 free(container_data->host_netmask);
1414 free(container_data->ip_range_start);
1415 free(container_data->docker_network);
1416 free(container_data->docker_run_options);
1417 free(container_data->docker_run_command);
1418 free(container_data->docker_host_options);
1420 g_list_free_full(container_data->tuples, (GDestroyNotify)
tuple_free);
1421 g_list_free_full(container_data->mounts, (GDestroyNotify)mount_free);
1422 g_list_free_full(container_data->ports, (GDestroyNotify)port_free);
1425 if(container_data->child) {
1426 free_xml(container_data->child->xml);
1427 container_data->child->xml = NULL;
1428 container_data->child->fns->free(container_data->child);
1437 return container_role;
1453 container_variant_data_t *container_data = NULL;
1455 get_container_variant_data(container_data, rsc);
1456 return container_data->replicas;
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)
#define status_print(fmt, args...)
int crm_parse_int(const char *text, const char *default_text)
char * crm_element_value_copy(xmlNode *data, const char *name)
node_t * pe_find_node(GListPtr node_list, const char *uname)
#define CRM_LOG_ASSERT(expr)
resource_t * uber_parent(resource_t *rsc)
#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)
#define XML_CIB_TAG_RESOURCE
resource_object_functions_t * fns
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)
const char * crm_element_value(xmlNode *data, 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)
const char * crm_xml_add(xmlNode *node, const char *name, const char *value)
#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)
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 crm_xml_set_id(xmlNode *xml, const char *format,...) __attribute__((__format__(__printf__
gboolean container_active(resource_t *rsc, gboolean all)
xmlNode * crm_create_nvpair_xml(xmlNode *parent, const char *id, const char *name, const char *value)
Create an XML name/value pair.
#define XML_CIB_TAG_MASTER
xmlNode * first_named_child(xmlNode *parent, const char *name)
#define crm_log_xml_trace(xml, text)
#define pe_rsc_trace(rsc, fmt, args...)
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)
resource_t * find_container_child(const char *stem, resource_t *rsc, node_t *node)
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)