diff --git a/crm/pengine/graph.c b/crm/pengine/graph.c index eabc26c0c4..8315bb1696 100644 --- a/crm/pengine/graph.c +++ b/crm/pengine/graph.c @@ -1,305 +1,318 @@ -/* $Id: graph.c,v 1.3 2004/06/08 11:47:48 andrew Exp $ */ +/* $Id: graph.c,v 1.4 2004/06/09 14:34:48 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include GListPtr create_action_set(action_t *action) { int lpc; GListPtr tmp = NULL; GListPtr result = NULL; gboolean preceeding_complete = FALSE; if(action->processed) { return NULL; } crm_debug_action(print_action("Create action set for", action, FALSE)); // process actions_before if(action->seen_count == 0) { crm_verbose("Processing \"before\" for action %d", action->id); slist_iter( other, action_wrapper_t, action->actions_before, lpc, tmp = create_action_set(other->action); result = g_list_concat(result, tmp); preceeding_complete = TRUE; ); } else { crm_verbose("Already seen action %d", action->id); crm_verbose("Processing \"before\" for action %d", action->id); slist_iter( other, action_wrapper_t, action->actions_before, lpc, if(other->action->seen_count > action->seen_count && other->strength == must) { tmp = create_action_set(other->action); result = g_list_concat(result, tmp); } ); } // add ourselves if(action->runnable) { if(action->processed == FALSE) { crm_verbose("Adding self %d", action->id); result = g_list_append(result, action); } else { crm_verbose("Already added self %d", action->id); } } else { crm_verbose("Skipping ourselves, we're not runnable"); } action->processed = TRUE; if(preceeding_complete == FALSE) { /* add any "before" actions that arent already processed */ slist_iter( other, action_wrapper_t, action->actions_before, lpc, tmp = create_action_set(other->action); result = g_list_concat(result, tmp); ); } action->seen_count = action->seen_count + 1; /* process actions_after * * do this regardless of whether we are runnable. Any direct or * indirect hard/XML_STRENGTH_VAL_MUST dependancies on us will have * been picked up earlier on in stage 7 */ crm_verbose("Processing \"after\" for action %d", action->id); slist_iter( other, action_wrapper_t, action->actions_after, lpc, tmp = create_action_set(other->action); result = g_list_concat(result, tmp); ); return result; } gboolean update_runnable(GListPtr actions) { int lpc = 0, lpc2 = 0; gboolean change = TRUE; while(change) { change = FALSE; slist_iter( action, action_t, actions, lpc, if(action->runnable) { continue; } else if(action->optional) { continue; } slist_iter( other, action_wrapper_t, action->actions_after, lpc2, if(other->action->runnable == FALSE) { continue; } change = TRUE; crm_debug_action( print_action("Marking unrunnable", other->action, FALSE)); other->action->runnable = FALSE; ); ); } return TRUE; } gboolean shutdown_constraints( node_t *node, action_t *shutdown_op, GListPtr *action_constraints) { int lpc = 0; slist_iter( rsc, resource_t, node->details->running_rsc, lpc, order_constraint_t *order = (order_constraint_t*) crm_malloc(sizeof(order_constraint_t)); /* stop resources before shutdown */ order->id = order_id++; order->lh_action = rsc->stop; order->rh_action = shutdown_op; order->strength = must; *action_constraints = g_list_append(*action_constraints,order); crm_debug_action( print_action("LH (Shutdown)",order->lh_action, FALSE)); crm_debug_action( print_action("RH (Shutdown)",order->rh_action, FALSE)); ); return TRUE; } gboolean -stonith_constraints(node_t *node, action_t *stonith_op, action_t *shutdown_op, +stonith_constraints(node_t *node, + action_t *stonith_op, action_t *shutdown_op, GListPtr *action_constraints) { int lpc = 0; order_constraint_t *order = NULL; if(shutdown_op != NULL) { order = (order_constraint_t*) crm_malloc(sizeof(order_constraint_t)); /* shutdown before stonith if both are requested */ order->lh_action = shutdown_op; order->rh_action = stonith_op; order->id = order_id++; order->strength = must; *action_constraints = g_list_append( *action_constraints, order); } slist_iter( rsc, resource_t, node->details->running_rsc, lpc, #if 0 /* * Mark the stop as irrelevant * * Possibly one day failed actions wont terminate * the transition, but not yet */ rsc->stop->discard = TRUE; #else /* need to add timeouts in the TE for actions such as this. * ie. the node may be cactus and unable to receive the * stop let alone reply with failed. */ rsc->stop->failure_is_fatal = FALSE; #endif #if 0 obsoleted by shutdown before stonith /* try stopping the resource before stonithing the node * * if the stop succeeds, the transitioner can then * decided if stonith is needed */ order = (order_constraint_t*) crm_malloc(sizeof(order_constraint_t)); order->lh_action = rsc->stop; order->rh_action = stonith_op; order->id = order_id++; order->strength = must; *action_constraints = g_list_append(*action_constraints,order); #endif /* stonith before start */ order = (order_constraint_t*) crm_malloc(sizeof(order_constraint_t)); order->id = order_id++; order->lh_action = stonith_op; order->rh_action = rsc->start; order->strength = must; *action_constraints = g_list_append(*action_constraints,order); ); return TRUE; } xmlNodePtr action2xml(action_t *action) { xmlNodePtr action_xml = NULL; if(action == NULL) { return NULL; } switch(action->task) { case stonith_op: action_xml = create_xml_node(NULL, "pseduo_event"); + + set_xml_property_copy( + action_xml, XML_ATTR_ID, crm_itoa(action->id)); + break; case shutdown_crm: action_xml = create_xml_node(NULL, "crm_event"); + + set_xml_property_copy( + action_xml, XML_ATTR_ID, crm_itoa(action->id)); + break; default: action_xml = create_xml_node(NULL, "rsc_op"); add_node_copy(action_xml, action->rsc->xml); + + set_xml_property_copy( + action_xml, XML_ATTR_ID, crm_itoa(action->id)); + + set_xml_property_copy( + action_xml, "rsc_id", + safe_val3(NULL, action, rsc, id)); break; } set_xml_property_copy( action_xml, XML_LRM_ATTR_TARGET, safe_val4(NULL, action, node, details, id)); set_xml_property_copy( - action_xml, XML_ATTR_ID, crm_itoa(action->id)); + action_xml, XML_LRM_ATTR_TASK, task2text(action->task)); set_xml_property_copy( action_xml, XML_LRM_ATTR_RUNNABLE, action->runnable?XML_BOOLEAN_TRUE:XML_BOOLEAN_FALSE); set_xml_property_copy( action_xml, XML_LRM_ATTR_OPTIONAL, action->optional?XML_BOOLEAN_TRUE:XML_BOOLEAN_FALSE); - set_xml_property_copy( - action_xml, XML_LRM_ATTR_TASK, task2text(action->task)); - set_xml_property_copy( action_xml, XML_LRM_ATTR_DISCARD, action->discard?XML_BOOLEAN_TRUE:XML_BOOLEAN_FALSE); set_xml_property_copy( action_xml, "allow_fail", action->failure_is_fatal?XML_BOOLEAN_FALSE:XML_BOOLEAN_TRUE); return action_xml; } diff --git a/crm/pengine/regression.sh b/crm/pengine/regression.sh index 3f6a72072d..0868ee4565 100755 --- a/crm/pengine/regression.sh +++ b/crm/pengine/regression.sh @@ -1,72 +1,98 @@ #!/bin/bash # Copyright (C) 2004 Andrew Beekhof # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This software is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # io_dir=testcases diff_opts="--ignore-all-space --minimal" + +# zero out the error log > regression.failed function do_test { base=$1; name=$2; - input=$io_dir/${base}.in + input=$io_dir/${base}.xml output=$io_dir/${base}.out expected=$io_dir/${base}.exp if [ ! -f $input ]; then - echo "Test $name ($base)... Error (no input: $input)"; + echo "Test $name ($base)... Error (no input: $input)"; return; fi - if [ ! -f $expected ]; then - echo "Test $name ($base)... Error (expected output: $expected)"; + if [ "$create_mode" != "true" -a ! -f $expected ]; then + echo "Test $name ($base)... Error (expected output: $expected)"; return; fi ./ptest < $input 2>/dev/null 2>/dev/null > $output - if [ ! -f $output ]; then - echo "Test $name ($base)... Error (pe output)"; + if [ ! -s $output ]; then + echo "Test $name ($base)... Error (pe output)"; + rm $output return; fi ./fix_xml.pl $output - if [ ! -f $output ]; then - echo "Test $name ($base)... Error (fixed output)"; + if [ ! -s $output ]; then + echo "Test $name ($base)... Error (fixed output)"; + rm $output return; fi + if [ "$create_mode" = "true" ]; then + cp "$output" "$expected" + fi + diff $diff_opts -q $expected $output rc=$? if [ "$rc" = 0 ]; then - echo "Test $name ($base)... Passed"; + echo "Test $name ($base)... Passed"; elif [ "$rc" = 1 ]; then - echo "Test $name ($base)... Failed"; + echo "Test $name ($base)... Failed"; diff $diff_opts -C 1 $expected $output >> regression.failed else - echo "Test $name ($base)... Error (diff rc=$rc)"; + echo "Test $name ($base)... Error (diff: $rc)"; fi rm $output } -do_test t1 "Simple" -do_test cib1 "Simple" +create_mode="false" +do_test simple1 "Offline " +do_test simple2 "Start " +do_test simple3 "Start 2 " +do_test simple4 "Start Failed" +do_test simple5 "Stop Failed" +do_test simple6 "Stop Start " +do_test simple7 "Shutdown " +do_test simple8 "Stonith " + + +#create_mode="true" + + +if [ -s regression.failed ]; then + echo "Results of failed tests...." + cat regression.failed +fi + + diff --git a/crm/pengine/stages.c b/crm/pengine/stages.c index 11d4e3f65b..c10bf02768 100644 --- a/crm/pengine/stages.c +++ b/crm/pengine/stages.c @@ -1,603 +1,604 @@ -/* $Id: stages.c,v 1.3 2004/06/08 11:47:48 andrew Exp $ */ +/* $Id: stages.c,v 1.4 2004/06/09 14:34:48 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include /* * Unpack everything * At the end you'll have: * - A list of nodes * - A list of resources (each with any dependancies on other resources) * - A list of constraints between resources and nodes * - A list of constraints between start/stop actions * - A list of nodes that need to be stonith'd * - A list of nodes that need to be shutdown * - A list of the possible stop/start actions (without dependancies) */ gboolean stage0(xmlNodePtr cib, GListPtr *resources, GListPtr *nodes, GListPtr *node_constraints, GListPtr *actions, GListPtr *action_constraints, GListPtr *stonith_list, GListPtr *shutdown_list) { // int lpc; xmlNodePtr cib_nodes = get_object_root( XML_CIB_TAG_NODES, cib); xmlNodePtr cib_status = get_object_root( XML_CIB_TAG_STATUS, cib); xmlNodePtr cib_resources = get_object_root( XML_CIB_TAG_RESOURCES, cib); xmlNodePtr cib_constraints = get_object_root( XML_CIB_TAG_CONSTRAINTS, cib); /* reset remaining global variables */ max_valid_nodes = 0; order_id = 1; action_id = 1; unpack_nodes(safe_val(NULL, cib_nodes, children), nodes); unpack_resources(safe_val(NULL, cib_resources, children), resources, actions, action_constraints, *nodes); int old_log = 0; old_log = set_crm_log_level(LOG_TRACE); unpack_status(safe_val(NULL, cib_status, children), *nodes, *resources, node_constraints); unpack_constraints(safe_val(NULL, cib_constraints, children), *nodes, *resources, node_constraints, action_constraints); // set_crm_log_level(old_log); #if 0 avoid this loop... just go off the various flags later slist_iter( node, node_t, *nodes, lpc, if(node->details->shutdown) { *shutdown_list = g_list_append(*shutdown_list, node); crm_verbose("Scheduling Node %s for shutdown", node->details->id); } else if(node->details->unclean) { *stonith_list = g_list_append(*stonith_list, node); crm_verbose("Scheduling Node %s for STONITH", node->details->id); } ); #endif return TRUE; } /* * Count how many valid nodes we have (so we know the maximum number of * colors we can resolve). * * Apply node constraints (ie. filter the "allowed_nodes" part of resources */ gboolean stage1(GListPtr node_constraints, GListPtr nodes, GListPtr resources) { int lpc = 0; slist_iter( node, node_t, nodes, lpc, if(node == NULL) { /* error */ } else if(node->weight >= 0.0 /* global weight */ && node->details->online && node->details->type == node_member) { max_valid_nodes++; } ); apply_node_constraints(node_constraints, nodes); /* will also filter -ve "final" weighted nodes from resources' * allowed lists while we are there */ apply_agent_constraints(resources); return TRUE; } /* * Choose a color for all resources from highest priority and XML_STRENGTH_VAL_MUST * dependancies to lowest, creating new colors as necessary (returned * as "colors"). * * Some nodes may be colored as a "no_color" meaning that it was unresolvable * given the current node stati and constraints. */ gboolean stage2(GListPtr sorted_rscs, GListPtr sorted_nodes, GListPtr *colors) { int lpc; color_t *current_color = NULL; crm_trace("setup"); // Set initial color // Set color.candidate_nodes = all active nodes if(no_color != NULL) { crm_free(no_color->details); crm_free(no_color); } crm_trace("create \"no color\""); no_color = create_color(NULL, NULL, sorted_rscs); crm_trace("create default color"); current_color = create_color(colors, sorted_nodes, sorted_rscs); // Set resource.color = color (all resources) // Set resource.provisional = TRUE (all resources) /* slist_iter( this_resource, resource_t, sorted_rscs, lpc, this_resource->color = NULL; this_resource->provisional = TRUE; ); */ crm_verbose("initialized resources to default color"); // Take (next) highest resource slist_iter( lh_resource, resource_t, sorted_rscs, lpc, // if resource.provisional == FALSE, repeat if(lh_resource->provisional == FALSE) { // already processed this resource continue; } color_resource(lh_resource, colors, sorted_rscs); // next resource ); return TRUE; } /* * not sure if this is a good idea or not, but eventually we might like * to utilize as many nodes as possible... and this might be a convienient * hook */ gboolean stage3(GListPtr colors) { // not sure if this is a good idea or not if(g_list_length(colors) > max_valid_nodes) { // we need to consolidate some } else if(g_list_length(colors) < max_valid_nodes) { // we can create a few more } return TRUE; } #define color_n_nodes color_n->details->candidate_nodes #define color_n_plus_1_nodes color_n_plus_1->details->candidate_nodes /* * Choose a node for each (if possible) color */ gboolean stage4(GListPtr colors) { int lpc = 0; color_t *color_n = NULL; color_t *color_n_plus_1 = NULL; GListPtr xor = NULL; GListPtr minus = NULL; for(lpc = 0; lpc < g_list_length(colors); lpc++) { color_n = color_n_plus_1; color_n_plus_1 = (color_t*)g_list_nth_data(colors, lpc); crm_debug_action( print_color("Choose node for...", color_n, FALSE)); if(color_n == NULL) { continue; } xor = node_list_xor(color_n_nodes, color_n_plus_1_nodes); minus = node_list_minus(color_n_nodes, color_n_plus_1_nodes); if(g_list_length(xor) == 0 || g_list_length(minus) == 0) { crm_verbose("Choose any node from our list"); choose_node_from_list(colors, color_n, color_n_nodes); } else { crm_verbose("Choose a node not in n+1"); choose_node_from_list(colors, color_n, minus); } pe_free_shallow(xor); pe_free_shallow(minus); } // choose last color if(color_n_plus_1 != NULL) { crm_debug_action(print_color("Choose node for last color...", color_n_plus_1, FALSE)); choose_node_from_list(colors, color_n_plus_1, color_n_plus_1_nodes); } crm_verbose("done"); return TRUE; } /* * Attach nodes to the actions that need to be taken * * Mark actions XML_LRM_ATTR_OPTIONAL if possible (Ie. if the start and stop are * for the same node) * * Mark unrunnable actions */ gboolean stage5(GListPtr resources) { crm_verbose("filling in the nodes to perform the actions on"); int lpc = 0; slist_iter( rsc, resource_t, resources, lpc, crm_debug_action(print_resource("Processing", rsc, FALSE)); if(safe_val(NULL, rsc, stop) == NULL || safe_val(NULL, rsc, start) == NULL) { // error crm_err("Either start action (%p) or" " stop action (%p) were not defined", safe_val(NULL, rsc, stop), safe_val(NULL, rsc, start)); continue; } if(safe_val4(NULL, rsc, color, details, chosen_node) == NULL){ rsc->stop->node = safe_val(NULL, rsc, cur_node); rsc->start->node = NULL; crm_warn("Stop resource %s (%s)", safe_val(NULL, rsc, id), safe_val5(NULL, rsc, stop, node,details,id)); crm_debug_action( print_action( CRMD_STATE_ACTIVE, rsc->stop, FALSE)); } else if(safe_str_eq(safe_val4(NULL, rsc,cur_node,details,id), safe_val6(NULL, rsc, color ,details, chosen_node, details, id))){ crm_verbose("No change for Resource %s (%s)", safe_val(NULL, rsc, id), safe_val4(NULL,rsc,cur_node,details,id)); rsc->stop->optional = TRUE; rsc->start->optional = TRUE; rsc->stop->node = safe_val(NULL, rsc, cur_node); rsc->start->node = safe_val4(NULL, rsc, color, details, chosen_node); } else if(safe_val4(NULL, rsc,cur_node,details,id) == NULL) { rsc->stop->optional = TRUE; rsc->start->node = safe_val4(NULL, rsc, color, details, chosen_node); crm_debug("Start resource %s (%s)", safe_val(NULL, rsc, id), safe_val5(NULL, rsc, start,node,details,id)); } else { rsc->stop->node = safe_val(NULL, rsc, cur_node); rsc->start->node = safe_val4(NULL, rsc, color, details, chosen_node); crm_debug("Move resource %s (%s -> %s)", safe_val(NULL, rsc, id), safe_val5(NULL, rsc, stop, node,details,id), safe_val5(NULL, rsc, start,node,details,id)); } if(rsc->stop->node != NULL) { rsc->stop->runnable = TRUE; } if(rsc->start->node != NULL) { rsc->start->runnable = TRUE; } ); return TRUE; } /* * Create dependacies for stonith and shutdown operations */ gboolean stage6(GListPtr *actions, GListPtr *action_constraints, GListPtr nodes) { int lpc = 0; action_t *down_node = NULL; action_t *stonith_node = NULL; slist_iter( node, node_t, nodes, lpc, if(node->details->shutdown) { crm_warn("Scheduling Node %s for shutdown", node->details->id); down_node = action_new(action_id++, NULL,shutdown_crm); down_node->node = node; down_node->runnable = TRUE; *actions = g_list_append(*actions, down_node); shutdown_constraints( node, down_node, action_constraints); } if(node->details->unclean) { crm_warn("Scheduling Node %s for STONITH", node->details->id); stonith_node = action_new(action_id++,NULL,stonith_op); stonith_node->node = node; stonith_node->runnable = TRUE; *actions = g_list_append(*actions, stonith_node); stonith_constraints(node, stonith_node, down_node, action_constraints); } ); return TRUE; } /* * Determin the sets of independant actions and the correct order for the * actions in each set. * * Mark dependancies of un-runnable actions un-runnable * */ gboolean stage7(GListPtr resources, GListPtr actions, GListPtr action_constraints, GListPtr *action_sets) { int lpc; action_wrapper_t *wrapper = NULL; GListPtr list = NULL; /* for(lpc = 0; lpc < g_list_length(action_constraints); lpc++) { order_constraint_t *order = (order_constraint_t*) g_list_nth_data(action_constraints, lpc); */ slist_iter( order, order_constraint_t, action_constraints, lpc, - crm_verbose("Processing %d -> %d", + crm_verbose("%d Processing %d -> %d", + order->id, order->lh_action->id, order->rh_action->id); crm_debug_action( print_action("LH (stage7)", order->lh_action, FALSE)); crm_debug_action( print_action("RH (stage7)", order->rh_action, FALSE)); wrapper = (action_wrapper_t*) crm_malloc(sizeof(action_wrapper_t)); wrapper->action = order->rh_action; wrapper->strength = order->strength; list = order->lh_action->actions_after; list = g_list_append(list, wrapper); order->lh_action->actions_after = list; wrapper = (action_wrapper_t*) crm_malloc(sizeof(action_wrapper_t)); wrapper->action = order->lh_action; wrapper->strength = order->strength; list = order->rh_action->actions_before; list = g_list_append(list, wrapper); order->rh_action->actions_before = list; ); // } update_runnable(actions); slist_iter( rsc, resource_t, resources, lpc, GListPtr action_set = NULL; /* any non-essential stop actions will be marked redundant by * during stage6 */ action_set = create_action_set(rsc->start); if(action_set != NULL) { crm_verbose("Created action set for %s->start", rsc->id); *action_sets = g_list_append(*action_sets, action_set); } else { crm_verbose("No actions resulting from %s->start", rsc->id); } ); return TRUE; } /* * Create a dependancy graph to send to the transitioner (via the CRMd) */ gboolean stage8(GListPtr action_sets, xmlNodePtr *graph) { int lpc = 0; xmlNodePtr xml_action_set = NULL; *graph = create_xml_node(NULL, "transition_graph"); /* errors... slist_iter(action, action_t, action_list, lpc, if(action->optional == FALSE && action->runnable == FALSE) { print_action("Ignoring", action, TRUE); } ); */ int lpc2; slist_iter(action_set, GList, action_sets, lpc, crm_verbose("Processing Action Set %d", lpc); xml_action_set = create_xml_node(NULL, "actions"); set_xml_property_copy( xml_action_set, XML_ATTR_ID, crm_itoa(lpc)); slist_iter(action, action_t, action_set, lpc2, xmlNodePtr xml_action = action2xml(action); xmlAddChild(xml_action_set, xml_action); ) xmlAddChild(*graph, xml_action_set); ); xml_message_debug(*graph, "created action list"); return TRUE; } /* * Print a nice human readable high-level summary of what we're going to do */ gboolean summary(GListPtr resources) { int lpc = 0; const char *rsc_id = NULL; const char *node_id = NULL; const char *new_node_id = NULL; slist_iter( rsc, resource_t, resources, lpc, rsc_id = safe_val(NULL, rsc, id); node_id = safe_val4(NULL, rsc, cur_node, details, id); new_node_id = safe_val6( NULL, rsc, color, details, chosen_node, details, id); if(rsc->runnable == FALSE) { crm_err("Resource %s was not runnable", rsc_id); if(node_id != NULL) { crm_warn("Stopping Resource (%s) on node %s", rsc_id, node_id); } } else if(safe_val4(NULL, rsc, color, details, chosen_node) == NULL) { crm_err("Could not allocate Resource %s", rsc_id); crm_debug_action( print_resource("Could not allocate",rsc,TRUE)); if(node_id != NULL) { crm_warn("Stopping Resource (%s) on node %s", rsc_id, node_id); } } else if(safe_str_eq(node_id, new_node_id)){ crm_debug("No change for Resource %s (%s)", rsc_id, safe_val4(NULL, rsc, cur_node, details, id)); } else if(node_id == NULL) { crm_info("Starting Resource %s on %s", rsc_id, new_node_id); } else { crm_info("Moving Resource %s from %s to %s", rsc_id, node_id, new_node_id); } ); return TRUE; } gboolean choose_node_from_list(GListPtr colors, color_t *color, GListPtr nodes) { int lpc; /* 1. Sort by weight 2. color.chosen_node = highest wieghted node 3. remove color.chosen_node from all other colors */ nodes = g_list_sort(nodes, sort_node_weight); color->details->chosen_node = node_copy((node_t*)g_list_nth_data(nodes, 0)); if(color->details->chosen_node == NULL) { crm_err("Could not allocate a node for color %d", color->id); return FALSE; } slist_iter( color_n, color_t, colors, lpc, node_t *other_node = pe_find_node(color_n->details->candidate_nodes, color->details->chosen_node->details->id); if(color_n != color) { color_n->details->candidate_nodes = g_list_remove( color_n->details->candidate_nodes, other_node); // crm_free(other_node); } ); return TRUE; } diff --git a/crm/pengine/unpack.c b/crm/pengine/unpack.c index e729fdfa8d..f994076323 100644 --- a/crm/pengine/unpack.c +++ b/crm/pengine/unpack.c @@ -1,895 +1,902 @@ -/* $Id: unpack.c,v 1.3 2004/06/08 11:47:48 andrew Exp $ */ +/* $Id: unpack.c,v 1.4 2004/06/09 14:34:48 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include // for ONLINESTATUS #include #include int max_valid_nodes = 0; int order_id = 1; int action_id = 1; GListPtr match_attrs(xmlNodePtr attr_exp, GListPtr node_list); gboolean unpack_rsc_to_attr(xmlNodePtr xml_obj, GListPtr rsc_list, GListPtr node_list, GListPtr *node_constraints); gboolean unpack_rsc_to_node(xmlNodePtr xml_obj, GListPtr rsc_list, GListPtr node_list, GListPtr *node_constraints); gboolean unpack_rsc_to_rsc( xmlNodePtr xml_obj, GListPtr rsc_list, GListPtr *action_constraints); gboolean unpack_lrm_rsc_state(node_t *node, xmlNodePtr lrm_state, GListPtr rsc_list, GListPtr *node_constraints); gboolean add_node_attrs(xmlNodePtr attrs, node_t *node); gboolean unpack_healthy_resource(GListPtr *node_constraints, xmlNodePtr rsc_entry, resource_t *rsc_lh, node_t *node); gboolean unpack_failed_resource(GListPtr *node_constraints, xmlNodePtr rsc_entry, resource_t *rsc_lh, node_t *node); gboolean determine_online_status(xmlNodePtr node_state, node_t *this_node); gboolean unpack_lrm_agents(node_t *node, xmlNodePtr agent_list); gboolean is_node_unclean(xmlNodePtr node_state); gboolean create_rsc_to_rsc(const char *id, enum con_strength strength, resource_t *rsc_lh, resource_t *rsc_rh); gboolean create_ordering(const char *id, enum con_strength strength, resource_t *rsc_lh, resource_t *rsc_rh, GListPtr *action_constraints); gboolean unpack_nodes(xmlNodePtr xml_nodes, GListPtr *nodes) { crm_verbose("Begining unpack..."); while(xml_nodes != NULL) { xmlNodePtr xml_obj = xml_nodes; xmlNodePtr attrs = xml_obj->children; const char *id = xmlGetProp(xml_obj, XML_ATTR_ID); const char *type = xmlGetProp(xml_obj, XML_ATTR_TYPE); crm_verbose("Processing node %s", id); if(attrs != NULL) { attrs = attrs->children; } xml_nodes = xml_nodes->next; if(id == NULL) { crm_err("Must specify id tag in "); continue; } if(type == NULL) { crm_err("Must specify type tag in "); continue; } node_t *new_node = crm_malloc(sizeof(node_t)); new_node->weight = 1.0; new_node->fixed = FALSE; new_node->details = (struct node_shared_s*) crm_malloc(sizeof(struct node_shared_s)); // new_node->details->id = crm_strdup(id); new_node->details->id = id; new_node->details->type = node_ping; new_node->details->online = FALSE; new_node->details->unclean = FALSE; new_node->details->shutdown = FALSE; new_node->details->running_rsc = NULL; new_node->details->agents = NULL; new_node->details->attrs = g_hash_table_new( g_str_hash, g_str_equal); - if(safe_str_eq(type, "node")) { + if(safe_str_eq(type, "member")) { new_node->details->type = node_member; } add_node_attrs(attrs, new_node); *nodes = g_list_append(*nodes, new_node); crm_verbose("Done with node %s", xmlGetProp(xml_obj, "uname")); crm_debug_action(print_node("Added", new_node, FALSE)); } *nodes = g_list_sort(*nodes, sort_node_weight); return TRUE; } gboolean unpack_resources(xmlNodePtr xml_resources, GListPtr *resources, GListPtr *actions, GListPtr *action_cons, GListPtr all_nodes) { crm_verbose("Begining unpack..."); while(xml_resources != NULL) { action_t *action_stop = NULL; action_t *action_start = NULL; xmlNodePtr xml_obj = xml_resources; const char *id = xmlGetProp(xml_obj, XML_ATTR_ID); const char *priority = xmlGetProp( xml_obj, XML_CIB_ATTR_PRIORITY); // todo: check for null float priority_f = atof(priority); xml_resources = xml_resources->next; crm_verbose("Processing resource..."); if(id == NULL) { crm_err("Must specify id tag in "); continue; } resource_t *new_rsc = crm_malloc(sizeof(resource_t)); new_rsc->id = id; new_rsc->class = xmlGetProp(xml_obj, "class"); new_rsc->type = xmlGetProp(xml_obj, "type"); new_rsc->xml = xml_obj; new_rsc->priority = priority_f; new_rsc->candidate_colors = NULL; new_rsc->color = NULL; new_rsc->runnable = TRUE; new_rsc->provisional = TRUE; new_rsc->allowed_nodes = node_list_dup(all_nodes); new_rsc->rsc_cons = NULL; new_rsc->node_cons = NULL; new_rsc->cur_node = NULL; action_stop = action_new(action_id++, new_rsc, stop_rsc); action_start = action_new(action_id++, new_rsc, start_rsc); new_rsc->stop = action_stop; *actions = g_list_append(*actions, action_stop); new_rsc->start = action_start; *actions = g_list_append(*actions, action_start); order_constraint_t *order = (order_constraint_t*) crm_malloc(sizeof(order_constraint_t)); order->id = order_id++; order->lh_action = action_stop; order->rh_action = action_start; order->strength = startstop; *action_cons = g_list_append(*action_cons, order); *resources = g_list_append(*resources, new_rsc); crm_debug_action(print_resource("Added", new_rsc, FALSE)); } *resources = g_list_sort(*resources, sort_rsc_priority); return TRUE; } gboolean unpack_constraints(xmlNodePtr xml_constraints, GListPtr nodes, GListPtr resources, GListPtr *node_constraints, GListPtr *action_constraints) { crm_verbose("Begining unpack..."); while(xml_constraints != NULL) { const char *id = xmlGetProp(xml_constraints, XML_ATTR_ID); xmlNodePtr xml_obj = xml_constraints; xml_constraints = xml_constraints->next; if(id == NULL) { crm_err("Constraint must have an id"); continue; } crm_verbose("Processing constraint %s %s", xml_obj->name,id); if(safe_str_eq("rsc_to_rsc", xml_obj->name)) { unpack_rsc_to_rsc(xml_obj, resources, action_constraints); } else if(safe_str_eq("rsc_to_node", xml_obj->name)) { unpack_rsc_to_node(xml_obj, resources, nodes, node_constraints); } else if(safe_str_eq("rsc_to_attr", xml_obj->name)) { unpack_rsc_to_attr(xml_obj, resources, nodes, node_constraints); } else { crm_err("Unsupported constraint type: %s", xml_obj->name); } } return TRUE; } gboolean unpack_rsc_to_node(xmlNodePtr xml_obj, GListPtr rsc_list, GListPtr node_list, GListPtr *node_constraints) { xmlNodePtr node_ref = xml_obj->children; rsc_to_node_t *new_con = NULL; const char *id_lh = xmlGetProp(xml_obj, "from"); const char *id = xmlGetProp(xml_obj, XML_ATTR_ID); const char *mod = xmlGetProp(xml_obj, "modifier"); const char *weight = xmlGetProp(xml_obj, "weight"); float weight_f = atof(weight); resource_t *rsc_lh = pe_find_resource(rsc_list, id_lh); if(rsc_lh == NULL) { crm_err("No resource (con=%s, rsc=%s)", id, id_lh); } - new_con = (rsc_to_node_t*)crm_malloc(sizeof(rsc_to_node_t)); - new_con->id = id; - new_con->rsc_lh = rsc_lh; - new_con->weight = weight_f; - + new_con = (rsc_to_node_t*)crm_malloc(sizeof(rsc_to_node_t)); + new_con->id = id; + new_con->rsc_lh = rsc_lh; + new_con->weight = weight_f; + new_con->node_list_rh = NULL; + if(safe_str_eq(mod, "set")){ new_con->modifier = set; } else if(safe_str_eq(mod, "inc")){ new_con->modifier = inc; } else if(safe_str_eq(mod, "dec")){ new_con->modifier = dec; } else { // error } /* */ // while(node_ref != NULL) { const char *xml_name = node_ref->name; const char *id_rh = xmlGetProp(node_ref, XML_NVPAIR_ATTR_NAME); node_t *node_rh = pe_find_node(node_list, id_rh); node_ref = node_ref->next; if(node_rh == NULL) { crm_err("node %s (from %s) not found",id_rh, xml_name); continue; } new_con->node_list_rh = g_list_append(new_con->node_list_rh, node_rh); /* dont add it to the resource, * the information is in the resouce's node list */ } *node_constraints = g_list_append(*node_constraints, new_con); return TRUE; } gboolean unpack_rsc_to_attr(xmlNodePtr xml_obj, GListPtr rsc_list, GListPtr node_list, GListPtr *node_constraints) { /* Translation: give any node a +ve weight of 20.0 to run rsc2 if: attr "cpu" is set _and_ "kernel"="2.6", _or_ attr "hdd" is set _and_ "kernel"="2.4" Further translation: 2 constraints that give any node a +ve weight of 20.0 to run rsc2 cons1: attr "cpu" is set and "kernel"="2.6" cons2: attr "hdd" is set and "kernel"="2.4" */ xmlNodePtr attr_exp = xml_obj->children; const char *id_lh = xmlGetProp(xml_obj, "from"); const char *mod = xmlGetProp(xml_obj, "modifier"); const char *weight = xmlGetProp(xml_obj, "weight"); const char *id = xmlGetProp(attr_exp, XML_ATTR_ID); float weight_f = atof(weight); enum con_modifier a_modifier = modifier_none; resource_t *rsc_lh = pe_find_resource(rsc_list, id_lh); if(rsc_lh == NULL) { crm_err("No resource (con=%s, rsc=%s)", id, id_lh); return FALSE; } if(safe_str_eq(mod, "set")){ a_modifier = set; } else if(safe_str_eq(mod, "inc")){ a_modifier = inc; } else if(safe_str_eq(mod, "dec")){ a_modifier = dec; } else { // error } if(attr_exp == NULL) { crm_err("no attrs for constraint %s", id); } while(attr_exp != NULL) { rsc_to_node_t *new_con = crm_malloc(sizeof(rsc_to_node_t)); new_con->id = xmlGetProp(attr_exp, XML_ATTR_ID); new_con->rsc_lh = rsc_lh; new_con->weight = weight_f; new_con->modifier = a_modifier; new_con->node_list_rh = match_attrs(attr_exp, node_list); if(new_con->node_list_rh == NULL) { crm_warn("No matching nodes for constraint %s (%s)", xmlGetProp(attr_exp, XML_NVPAIR_ATTR_NAME), attr_exp->name); } crm_debug_action(print_rsc_to_node("Added", new_con, FALSE)); *node_constraints = g_list_append(*node_constraints, new_con); /* dont add it to the resource, * the information is in the resouce's node list */ attr_exp = attr_exp->next; } return TRUE; } // remove nodes that are down, stopping // create +ve rsc_to_node constraints between resources and the nodes they are running on // anything else? gboolean unpack_status(xmlNodePtr status, GListPtr nodes, GListPtr rsc_list, GListPtr *node_constraints) { const char *id = NULL; xmlNodePtr node_state = NULL; xmlNodePtr lrm_rsc = NULL; xmlNodePtr lrm_agents = NULL; xmlNodePtr attrs = NULL; node_t *this_node = NULL; crm_verbose("Begining unpack"); while(status != NULL) { node_state = status; status = status->next; id = xmlGetProp(node_state, XML_ATTR_ID); attrs = find_xml_node(node_state, "attributes"); lrm_rsc = find_xml_node(node_state, XML_CIB_TAG_LRM); lrm_agents = find_xml_node(lrm_rsc, "lrm_agents"); lrm_rsc = find_xml_node(lrm_rsc, XML_LRM_TAG_RESOURCES); lrm_rsc = find_xml_node(lrm_rsc, "lrm_resource"); crm_verbose("Processing node %s", id); this_node = pe_find_node(nodes, id); if(id == NULL) { // error continue; } else if(this_node == NULL) { crm_err("Node %s in status section no longer exists", id); continue; } crm_verbose("Adding runtime node attrs"); add_node_attrs(attrs, this_node); crm_verbose("determining node state"); determine_online_status(node_state, this_node); crm_verbose("Processing lrm resource entries"); unpack_lrm_rsc_state( this_node, lrm_rsc, rsc_list, node_constraints); crm_verbose("Processing lrm agents"); unpack_lrm_agents(this_node, lrm_agents); } return TRUE; } gboolean determine_online_status(xmlNodePtr node_state, node_t *this_node) { const char *id = xmlGetProp(node_state,XML_ATTR_ID); - const char *state = xmlGetProp(node_state,XML_LRM_ATTR_STATE); + const char *state = xmlGetProp(node_state,XML_NODE_ATTR_STATE); const char *exp_state = xmlGetProp(node_state,XML_CIB_ATTR_EXPSTATE); const char *join_state = xmlGetProp(node_state,XML_CIB_ATTR_JOINSTATE); const char *crm_state = xmlGetProp(node_state,XML_CIB_ATTR_CRMDSTATE); const char *ccm_state = xmlGetProp(node_state,XML_CIB_ATTR_INCCM); const char *shutdown = xmlGetProp(node_state,XML_CIB_ATTR_SHUTDOWN); const char *unclean = xmlGetProp(node_state,XML_CIB_ATTR_STONITH); if(safe_str_eq(join_state, CRMD_JOINSTATE_MEMBER) && safe_str_eq(ccm_state, XML_BOOLEAN_YES) && safe_str_eq(crm_state, ONLINESTATUS) && shutdown == NULL) { this_node->details->online = TRUE; } else { crm_verbose("remove"); // remove node from contention this_node->weight = -1; this_node->fixed = TRUE; crm_verbose("state %s, expected %s, shutdown %s", state, exp_state, shutdown); if(unclean != NULL) { this_node->details->unclean = TRUE; } else if(shutdown != NULL) { this_node->details->shutdown = TRUE; } else if(is_node_unclean(node_state)) { /* report and or take remedial action */ this_node->details->unclean = TRUE; } if(this_node->details->unclean) { crm_verbose("Node %s is due for STONITH", id); } if(this_node->details->shutdown) { crm_verbose("Node %s is due for shutdown", id); } } return TRUE; } gboolean is_node_unclean(xmlNodePtr node_state) { - const char *state = xmlGetProp(node_state,XML_LRM_ATTR_STATE); + const char *state = xmlGetProp(node_state,XML_NODE_ATTR_STATE); const char *exp_state = xmlGetProp(node_state,XML_CIB_ATTR_EXPSTATE); const char *join_state = xmlGetProp(node_state,XML_CIB_ATTR_JOINSTATE); const char *crm_state = xmlGetProp(node_state,XML_CIB_ATTR_CRMDSTATE); const char *ccm_state = xmlGetProp(node_state,XML_CIB_ATTR_INCCM); if(safe_str_eq(exp_state, CRMD_STATE_INACTIVE)) { return FALSE; /* do an actual calculation once STONITH is available */ // } else if(...) { } // for now... if(0) { state = NULL; join_state = NULL; crm_state = NULL; ccm_state = NULL; } return FALSE; } gboolean unpack_lrm_agents(node_t *node, xmlNodePtr agent_list) { /* if the agent is not listed, remove the node from * the resource's list of allowed_nodes */ lrm_agent_t *agent = NULL; xmlNodePtr xml_agent = agent_list->children; while(xml_agent != NULL){ agent = (lrm_agent_t*)crm_malloc(sizeof(lrm_agent_t)); agent->class = xmlGetProp(xml_agent, "class"); agent->type = xmlGetProp(xml_agent, "type"); node->details->agents = g_list_append( node->details->agents, agent); xml_agent = xml_agent->next; } return TRUE; } gboolean unpack_lrm_rsc_state(node_t *node, xmlNodePtr lrm_rsc, GListPtr rsc_list, GListPtr *node_constraints) { xmlNodePtr rsc_entry = NULL; const char *rsc_id = NULL; const char *node_id = NULL; const char *rsc_state = NULL; const char *rsc_code = NULL; resource_t *rsc_lh = NULL; while(lrm_rsc != NULL) { rsc_entry = lrm_rsc; lrm_rsc = lrm_rsc->next; rsc_id = xmlGetProp(rsc_entry, XML_ATTR_ID); node_id = xmlGetProp(rsc_entry, XML_LRM_ATTR_TARGET); - rsc_state = xmlGetProp(rsc_entry, XML_LRM_ATTR_STATE); + rsc_state = xmlGetProp(rsc_entry, XML_LRM_ATTR_OPSTATE); rsc_code = xmlGetProp(rsc_entry, "op_code"); rsc_lh = pe_find_resource(rsc_list, rsc_id); crm_verbose("[%s] Processing %s on %s (%s)", rsc_entry->name, rsc_id, node_id, rsc_state); if(rsc_lh == NULL) { crm_err("Could not find a match for resource" " %s in %s's status section", rsc_id, node_id); continue; } op_status_t rsc_code_i = atoi(rsc_code); switch(rsc_code_i) { case LRM_OP_DONE: unpack_healthy_resource(node_constraints, rsc_entry,rsc_lh,node); break; case LRM_OP_ERROR: case LRM_OP_TIMEOUT: case LRM_OP_NOTSUPPORTED: unpack_failed_resource(node_constraints, rsc_entry,rsc_lh,node); break; case LRM_OP_CANCELLED: // do nothing?? + crm_warn("Dont know what to do for cancelled ops yet"); break; } } return TRUE; } gboolean unpack_failed_resource(GListPtr *node_constraints, xmlNodePtr rsc_entry, resource_t *rsc_lh, node_t *node) { const char *last_op = xmlGetProp(rsc_entry, "last_op"); + crm_debug("Unpacking failed action %s on %s", last_op, rsc_lh->id); + if(safe_str_eq(last_op, "start")) { /* not running */ /* do not run the resource here again */ rsc_to_node_t *new_cons = crm_malloc(sizeof(rsc_to_node_t)); new_cons->id = "dont_run_generate"; // genereate new_cons->weight = -1.0; new_cons->modifier = set; new_cons->rsc_lh = rsc_lh; new_cons->node_list_rh = g_list_append(NULL, node); *node_constraints = g_list_append(*node_constraints, new_cons); } else if(safe_str_eq(last_op, "stop")) { /* must assume still running */ + rsc_lh->cur_node = node; + node->details->running_rsc = g_list_append( + node->details->running_rsc, rsc_lh); + /* remedial action: * shutdown (so all other resources are stopped gracefully) * and then STONITH node */ if(node->details->online) { node->details->shutdown = TRUE; } node->details->unclean = TRUE; // } else if(safe_str_eq(last_op, "???")) { } else { /* unknown action... */ /* remedial action: ??? * shutdown (so all other resources are stopped gracefully) * and then STONITH node */ - if(node->details->online) { - node->details->shutdown = TRUE; - } - node->details->unclean = TRUE; } return TRUE; } gboolean unpack_healthy_resource(GListPtr *node_constraints, xmlNodePtr rsc_entry, resource_t *rsc_lh, node_t *node) { const char *last_op = xmlGetProp(rsc_entry, "last_op"); rsc_to_node_t *new_cons = crm_malloc(sizeof(rsc_to_node_t)); + + crm_debug("Unpacking healthy action %s on %s", last_op, rsc_lh->id); + new_cons->id = "healthy_generate"; // genereate one new_cons->weight = 1.0; new_cons->modifier = inc; new_cons->rsc_lh = rsc_lh; new_cons->node_list_rh = g_list_append(NULL, node); *node_constraints = g_list_append(*node_constraints, new_cons); if(safe_str_neq(last_op, "stop")) { if(rsc_lh->cur_node != NULL) { crm_err("Resource %s running on multiple nodes %s, %s", rsc_lh->id, rsc_lh->cur_node->details->id, node->details->id); // TODO: some recovery action!! // like force a stop on the second node? } else { /* we prefer to stay running here */ new_cons->weight = 100.0; /* create the link between this node and the rsc */ crm_verbose("Setting cur_node = %s for rsc = %s", node->details->id, rsc_lh->id); rsc_lh->cur_node = node; node->details->running_rsc = g_list_append( node->details->running_rsc, rsc_lh); } } else { /* we prefer to start where we once ran successfully */ new_cons->weight = 20.0; } crm_debug_action(print_rsc_to_node("Added", new_cons, FALSE)); return TRUE; } gboolean create_rsc_to_rsc(const char *id, enum con_strength strength, resource_t *rsc_lh, resource_t *rsc_rh) { if(rsc_lh == NULL || rsc_rh == NULL){ // error return FALSE; } - rsc_to_rsc_t *new_con = crm_malloc(sizeof(rsc_to_node_t)); + rsc_to_rsc_t *new_con = crm_malloc(sizeof(rsc_to_rsc_t)); rsc_to_rsc_t *inverted_con = NULL; new_con->id = id; new_con->rsc_lh = rsc_lh; new_con->rsc_rh = rsc_rh; new_con->strength = strength; inverted_con = invert_constraint(new_con); rsc_lh->rsc_cons = g_list_insert_sorted( rsc_lh->rsc_cons, new_con, sort_cons_strength); rsc_rh->rsc_cons = g_list_insert_sorted( rsc_rh->rsc_cons, inverted_con, sort_cons_strength); return TRUE; } gboolean create_ordering(const char *id, enum con_strength strength, resource_t *rsc_lh, resource_t *rsc_rh, GListPtr *action_constraints) { if(rsc_lh == NULL || rsc_rh == NULL){ // error return FALSE; } action_t *lh_stop = rsc_lh->stop; action_t *lh_start = rsc_lh->start; action_t *rh_stop = rsc_rh->stop; action_t *rh_start = rsc_rh->start; order_constraint_t *order = (order_constraint_t*) crm_malloc(sizeof(order_constraint_t)); order->id = order_id++; order->lh_action = lh_stop; order->rh_action = rh_stop; order->strength = strength; *action_constraints = g_list_append(*action_constraints, order); order = (order_constraint_t*) crm_malloc(sizeof(order_constraint_t)); order->id = order_id++; order->lh_action = rh_start; order->rh_action = lh_start; order->strength = strength; *action_constraints = g_list_append(*action_constraints, order); return TRUE; } gboolean unpack_rsc_to_rsc(xmlNodePtr xml_obj, GListPtr rsc_list, GListPtr *action_constraints) { enum con_strength strength_e = ignore; const char *id_lh = xmlGetProp(xml_obj, "from"); const char *id = xmlGetProp(xml_obj, XML_ATTR_ID); const char *id_rh = xmlGetProp(xml_obj, "to"); const char *strength = xmlGetProp(xml_obj, "strength"); const char *type = xmlGetProp(xml_obj, XML_ATTR_TYPE); resource_t *rsc_lh = pe_find_resource(rsc_list, id_lh); resource_t *rsc_rh = pe_find_resource(rsc_list, id_rh); if(rsc_lh == NULL) { crm_err("No resource (con=%s, rsc=%s)", id, id_lh); return FALSE; } if(safe_str_eq(strength, XML_STRENGTH_VAL_MUST)) { strength_e = must; } else if(safe_str_eq(strength, XML_STRENGTH_VAL_SHOULD)) { strength_e = should; } else if(safe_str_eq(strength, XML_STRENGTH_VAL_SHOULDNOT)) { strength_e = should_not; } else if(safe_str_eq(strength, XML_STRENGTH_VAL_MUSTNOT)) { strength_e = must_not; } else { crm_err("Unknown value for %s: %s", "strength", strength); return FALSE; } if(safe_str_eq(type, "ordering")) { // make an action_cons instead return create_ordering( id, strength_e, rsc_lh, rsc_rh, action_constraints); } return create_rsc_to_rsc(id, strength_e, rsc_lh, rsc_rh); } GListPtr match_attrs(xmlNodePtr attr_exp, GListPtr node_list) { int lpc = 0; GListPtr result = NULL; slist_iter( node, node_t, node_list, lpc, xmlNodePtr node_match = attr_exp->children; gboolean accept = TRUE; while(accept && node_match != NULL) { const char *type = xmlGetProp( node_match, XML_ATTR_TYPE); const char *value= xmlGetProp( node_match, XML_NVPAIR_ATTR_VALUE); const char *name = xmlGetProp(node_match, "target"); node_match = node_match->next; if(name == NULL || type == NULL) { crm_err("Attribute %s (%s) was invalid", name, type); continue; } const char *h_val = (const char*) g_hash_table_lookup(node->details->attrs,name); if(h_val != NULL && safe_str_eq(type, "has_attr")){ accept = TRUE; } else if(h_val==NULL && safe_str_eq(type,"not_attr")){ accept = TRUE; } else if(h_val != NULL && safe_str_eq(type, "attr_value") && safe_str_eq(h_val, value)) { accept = TRUE; } else { accept = FALSE; } } if(accept) { result = g_list_append(result, node); } ); return result; } gboolean add_node_attrs(xmlNodePtr attrs, node_t *node) { const char *name = NULL; const char *value = NULL; while(attrs != NULL){ name = xmlGetProp(attrs, XML_NVPAIR_ATTR_NAME); value = xmlGetProp(attrs, XML_NVPAIR_ATTR_VALUE); if(name != NULL && value != NULL && safe_val(NULL, node, details) != NULL) { crm_verbose("Adding %s => %s", name, value); /* this is frustrating... no way to pass in const * keys or values yet docs say: * Note: If keys and/or values are dynamically * allocated, you should free them first. */ g_hash_table_insert(node->details->attrs, crm_strdup(name), crm_strdup(value)); } attrs = attrs->next; } return TRUE; }