diff --git a/pengine/graph.c b/pengine/graph.c index 517e3079fd..8bede8d2d6 100644 --- a/pengine/graph.c +++ b/pengine/graph.c @@ -1,886 +1,886 @@ /* * 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 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include #include #include #include #include #include #include #include #include #include gboolean update_action(action_t * action); gboolean rsc_update_action(action_t * first, action_t * then, enum pe_ordering type); static enum pe_action_flags get_action_flags(action_t * action, node_t * node) { enum pe_action_flags flags = action->flags; if (action->rsc) { flags = action->rsc->cmds->action_flags(action, NULL); if (action->rsc->variant >= pe_clone && node) { /* We only care about activity on $node */ enum pe_action_flags clone_flags = action->rsc->cmds->action_flags(action, node); /* Go to great lengths to ensure the correct value for pe_action_runnable... * * If we are a clone, then for _ordering_ constraints, its only relevant * if we are runnable _anywhere_. * * This only applies to _runnable_ though, and only for ordering constraints. * If this function is ever used during colocation, then we'll need additional logic * * Not very satisfying, but its logical and appears to work well. */ if (is_not_set(clone_flags, pe_action_runnable) && is_set(flags, pe_action_runnable)) { crm_trace("Fixing up runnable flag for %s", action->uuid); set_bit_inplace(clone_flags, pe_action_runnable); } flags = clone_flags; } } return flags; } static char * convert_non_atomic_uuid(char *old_uuid, resource_t * rsc, gboolean allow_notify, gboolean free_original) { int interval = 0; char *uuid = NULL; char *rid = NULL; char *raw_task = NULL; int task = no_action; crm_trace("Processing %s", old_uuid); if (old_uuid == NULL) { return NULL; } else if (strstr(old_uuid, "notify") != NULL) { goto done; /* no conversion */ } else if (rsc->variant < pe_group) { goto done; /* no conversion */ } CRM_ASSERT(parse_op_key(old_uuid, &rid, &raw_task, &interval)); if (interval > 0) { goto done; /* no conversion */ } task = text2task(raw_task); switch (task) { case stop_rsc: case start_rsc: case action_notify: case action_promote: case action_demote: break; case stopped_rsc: case started_rsc: case action_notified: case action_promoted: case action_demoted: task--; break; case monitor_rsc: case shutdown_crm: case stonith_node: task = no_action; break; default: crm_err("Unknown action: %s", raw_task); task = no_action; break; } if (task != no_action) { if (is_set(rsc->flags, pe_rsc_notify) && allow_notify) { uuid = generate_notify_key(rid, "confirmed-post", task2text(task + 1)); } else { uuid = generate_op_key(rid, task2text(task + 1), 0); } crm_trace("Converted %s -> %s", old_uuid, uuid); } done: if (uuid == NULL) { uuid = crm_strdup(old_uuid); } if (free_original) { crm_free(old_uuid); } crm_free(raw_task); crm_free(rid); return uuid; } static action_t * rsc_expand_action(action_t * action) { action_t *result = action; if (action->rsc && action->rsc->variant >= pe_group) { /* Expand 'start' -> 'started' */ char *uuid = NULL; gboolean notify = FALSE; if (action->rsc->parent == NULL) { /* Only outter-most resources have notification actions */ notify = is_set(action->rsc->flags, pe_rsc_notify); } uuid = convert_non_atomic_uuid(action->uuid, action->rsc, notify, FALSE); if (uuid) { crm_trace("Converting %s to %s %d", action->uuid, uuid, is_set(action->rsc->flags, pe_rsc_notify)); result = find_first_action(action->rsc->actions, uuid, NULL, NULL); if (result == NULL) { crm_err("Couldn't expand %s", action->uuid); result = action; } crm_free(uuid); } } return result; } static enum pe_graph_flags graph_update_action(action_t * first, action_t * then, node_t * node, enum pe_action_flags flags, enum pe_ordering type) { enum pe_graph_flags changed = pe_graph_none; gboolean processed = FALSE; /* TODO: Do as many of these in parallel as possible */ if (type & pe_order_implies_then) { processed = TRUE; if (then->rsc) { changed |= then->rsc->cmds->update_actions(first, then, node, flags & pe_action_optional, pe_action_optional, pe_order_implies_then); } else if (is_set(flags, pe_action_optional) == FALSE) { if (update_action_flags(then, pe_action_optional | pe_action_clear)) { changed |= pe_graph_updated_then; } } crm_trace("implies right: %s then %s%s", first->uuid, then->uuid, changed?": changed":""); } if ((type & pe_order_restart) && then->rsc) { enum pe_action_flags restart = (pe_action_optional | pe_action_runnable); processed = TRUE; changed |= then->rsc->cmds->update_actions(first, then, node, flags & restart, restart, pe_order_restart); crm_trace("restart: %s then %s%s", first->uuid, then->uuid, changed?": changed":""); } if (type & pe_order_implies_first) { processed = TRUE; if (first->rsc) { changed |= first->rsc->cmds->update_actions(first, then, node, flags & pe_action_optional, pe_action_optional, pe_order_implies_first); } else if (is_set(flags, pe_action_optional) == FALSE) { if (update_action_flags(first, pe_action_runnable | pe_action_clear)) { changed |= pe_graph_updated_first; } } crm_trace("implies left: %s then %s%s", first->uuid, then->uuid, changed?": changed":""); } if (type & pe_order_one_or_more) { processed = TRUE; if (then->rsc) { changed |= then->rsc->cmds->update_actions(first, then, node, flags & pe_action_runnable, pe_action_runnable, pe_order_one_or_more); } else if (is_set(flags, pe_action_runnable)) { if (update_action_flags(then, pe_action_runnable)) { changed |= pe_graph_updated_then; } } - crm_trace("runnable_left_optional: %s then %s%s", first->uuid, then->uuid, changed?": changed":""); + crm_trace("runnable_one_or_more: %s then %s%s", first->uuid, then->uuid, changed?": changed":""); } if (type & pe_order_runnable_left) { processed = TRUE; if (then->rsc) { changed |= then->rsc->cmds->update_actions(first, then, node, flags & pe_action_runnable, pe_action_runnable, pe_order_runnable_left); } else if (is_set(flags, pe_action_runnable) == FALSE) { if (update_action_flags(then, pe_action_runnable | pe_action_clear)) { changed |= pe_graph_updated_then; } } crm_trace("runnable: %s then %s%s", first->uuid, then->uuid, changed?": changed":""); } if (type & pe_order_optional) { processed = TRUE; if (then->rsc) { changed |= then->rsc->cmds->update_actions(first, then, node, flags & pe_action_runnable, pe_action_runnable, pe_order_optional); } crm_trace("optional: %s then %s%s", first->uuid, then->uuid, changed?": changed":""); } if (type & pe_order_asymmetrical) { crm_trace("asymmetrical: %s then %s", first->uuid, then->uuid); processed = TRUE; if (then->rsc) { changed |= then->rsc->cmds->update_actions(first, then, node, flags & pe_action_runnable, pe_action_runnable, pe_order_asymmetrical); } } if ((first->flags & pe_action_runnable) && (type & pe_order_implies_then_printed) && (flags & pe_action_optional) == 0) { processed = TRUE; crm_trace("%s implies %s printed", first->uuid, then->uuid); update_action_flags(then, pe_action_print_always); /* dont care about changed */ } if ((type & pe_order_implies_first_printed) && (flags & pe_action_optional) == 0) { processed = TRUE; crm_trace("%s implies %s printed", then->uuid, first->uuid); update_action_flags(first, pe_action_print_always); /* dont care about changed */ } if (processed == FALSE) { crm_trace("Constraint 0x%.6x not applicable", type); } return changed; } gboolean update_action(action_t * then) { GListPtr lpc = NULL; enum pe_graph_flags changed = pe_graph_none; int last_flags = then->flags; crm_trace("Processing %s (%s %s %s)", then->uuid, is_set(then->flags, pe_action_optional) ? "optional" : "required", is_set(then->flags, pe_action_runnable) ? "runnable" : "unrunnable", is_set(then->flags, pe_action_pseudo) ? "pseudo" : then->node ? then->node->details->uname : ""); if (is_set(then->flags, pe_action_requires_any)) { clear_bit_inplace(then->flags, pe_action_runnable); } for (lpc = then->actions_before; lpc != NULL; lpc = lpc->next) { action_wrapper_t *other = (action_wrapper_t *) lpc->data; action_t *first = other->action; node_t *then_node = then->node; node_t *first_node = first->node; enum pe_action_flags then_flags = 0; enum pe_action_flags first_flags = 0; if (first->rsc && first->rsc->variant == pe_group && safe_str_eq(first->task, RSC_START)) { first_node = first->rsc->fns->location(first->rsc, NULL, FALSE); if (first_node) { crm_trace("First: Found node %s for %s", first_node->details->uname, first->uuid); } } if (then->rsc && then->rsc->variant == pe_group && safe_str_eq(then->task, RSC_START)) { then_node = then->rsc->fns->location(then->rsc, NULL, FALSE); if (then_node) { crm_trace("Then: Found node %s for %s", then_node->details->uname, then->uuid); } } clear_bit_inplace(changed, pe_graph_updated_first); if (first->rsc != then->rsc && first->rsc != NULL && then->rsc != NULL && first->rsc != then->rsc->parent) { first = rsc_expand_action(first); } if (first != other->action) { crm_trace("Ordering %s afer %s instead of %s", then->uuid, first->uuid, other->action->uuid); } first_flags = get_action_flags(first, then_node); then_flags = get_action_flags(then, first_node); crm_trace("Checking %s (%s %s %s) against %s (%s %s %s) 0x%.6x", then->uuid, is_set(then_flags, pe_action_optional) ? "optional" : "required", is_set(then_flags, pe_action_runnable) ? "runnable" : "unrunnable", is_set(then_flags, pe_action_pseudo) ? "pseudo" : then->node ? then->node->details-> uname : "", first->uuid, is_set(first_flags, pe_action_optional) ? "optional" : "required", is_set(first_flags, pe_action_runnable) ? "runnable" : "unrunnable", is_set(first_flags, pe_action_pseudo) ? "pseudo" : first->node ? first->node->details-> uname : "", other->type); if (first == other->action) { clear_bit_inplace(first_flags, pe_action_pseudo); changed |= graph_update_action(first, then, then->node, first_flags, other->type); } else if (order_actions(first, then, other->type)) { /* Start again to get the new actions_before list */ changed |= (pe_graph_updated_then | pe_graph_disable); } if (changed & pe_graph_disable) { crm_trace("Disabled constraint %s -> %s", other->action->uuid, then->uuid); clear_bit_inplace(changed, pe_graph_disable); other->type = pe_order_none; } if (changed & pe_graph_updated_first) { GListPtr lpc2 = NULL; crm_trace("Updated %s (first %s %s %s), processing dependants ", first->uuid, is_set(first->flags, pe_action_optional) ? "optional" : "required", is_set(first->flags, pe_action_runnable) ? "runnable" : "unrunnable", is_set(first->flags, pe_action_pseudo) ? "pseudo" : first->node ? first->node->details-> uname : ""); for (lpc2 = first->actions_after; lpc2 != NULL; lpc2 = lpc2->next) { action_wrapper_t *other = (action_wrapper_t *) lpc2->data; update_action(other->action); } update_action(first); } } if (is_set(then->flags, pe_action_requires_any)) { if (last_flags != then->flags) { changed |= pe_graph_updated_then; } else { clear_bit_inplace(changed, pe_graph_updated_then); } } if (changed & pe_graph_updated_then) { crm_trace("Updated %s (then %s %s %s), processing dependants ", then->uuid, is_set(then->flags, pe_action_optional) ? "optional" : "required", is_set(then->flags, pe_action_runnable) ? "runnable" : "unrunnable", is_set(then->flags, pe_action_pseudo) ? "pseudo" : then->node ? then->node->details-> uname : ""); update_action(then); for (lpc = then->actions_after; lpc != NULL; lpc = lpc->next) { action_wrapper_t *other = (action_wrapper_t *) lpc->data; update_action(other->action); } } return FALSE; } gboolean shutdown_constraints(node_t * node, action_t * shutdown_op, pe_working_set_t * data_set) { /* add the stop to the before lists so it counts as a pre-req * for the shutdown */ GListPtr lpc = NULL; for (lpc = data_set->actions; lpc != NULL; lpc = lpc->next) { action_t *action = (action_t *) lpc->data; if (action->rsc == NULL || action->node == NULL) { continue; } else if(action->node->details != node->details) { continue; } else if(is_set(data_set->flags, pe_flag_maintenance_mode)) { crm_trace("Skipping %s: maintainence mode", action->uuid); continue; } else if(safe_str_neq(action->task, RSC_STOP)) { continue; } else if(is_not_set(action->rsc->flags, pe_rsc_managed) && is_not_set(action->rsc->flags, pe_rsc_block)) { /* * If another action depends on this one, we may still end up blocking */ crm_trace("Skipping %s: unmanaged", action->uuid); continue; } crm_trace("Ordering %s before shutdown on %s", action->uuid, node->details->uname); clear_bit_inplace(action->flags, pe_action_optional); custom_action_order(action->rsc, NULL, action, NULL, crm_strdup(CRM_OP_SHUTDOWN), shutdown_op, pe_order_optional|pe_order_runnable_left, data_set); } return TRUE; } gboolean stonith_constraints(node_t * node, action_t * stonith_op, pe_working_set_t * data_set) { CRM_CHECK(stonith_op != NULL, return FALSE); /* * Make sure the stonith OP occurs before we start any shared resources */ if (stonith_op != NULL) { GListPtr lpc = NULL; for (lpc = data_set->resources; lpc != NULL; lpc = lpc->next) { resource_t *rsc = (resource_t *) lpc->data; rsc_stonith_ordering(rsc, stonith_op, data_set); } } /* add the stonith OP as a stop pre-req and the mark the stop * as a pseudo op - since its now redundant */ return TRUE; } xmlNode * action2xml(action_t * action, gboolean as_input) { gboolean needs_node_info = TRUE; xmlNode *action_xml = NULL; xmlNode *args_xml = NULL; char *action_id_s = NULL; if (action == NULL) { return NULL; } crm_trace("Dumping action %d as XML", action->id); if (safe_str_eq(action->task, CRM_OP_FENCE)) { action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT); /* needs_node_info = FALSE; */ } else if (safe_str_eq(action->task, CRM_OP_SHUTDOWN)) { action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT); } else if (safe_str_eq(action->task, CRM_OP_CLEAR_FAILCOUNT)) { action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT); } else if (safe_str_eq(action->task, CRM_OP_LRM_REFRESH)) { action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT); /* } else if(safe_str_eq(action->task, RSC_PROBED)) { */ /* action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT); */ } else if (is_set(action->flags, pe_action_pseudo)) { action_xml = create_xml_node(NULL, XML_GRAPH_TAG_PSEUDO_EVENT); needs_node_info = FALSE; } else { action_xml = create_xml_node(NULL, XML_GRAPH_TAG_RSC_OP); } action_id_s = crm_itoa(action->id); crm_xml_add(action_xml, XML_ATTR_ID, action_id_s); crm_free(action_id_s); crm_xml_add(action_xml, XML_LRM_ATTR_TASK, action->task); if (action->rsc != NULL && action->rsc->clone_name != NULL) { char *clone_key = NULL; const char *interval_s = g_hash_table_lookup(action->meta, "interval"); int interval = crm_parse_int(interval_s, "0"); if (safe_str_eq(action->task, RSC_NOTIFY)) { const char *n_type = g_hash_table_lookup(action->meta, "notify_type"); const char *n_task = g_hash_table_lookup(action->meta, "notify_operation"); CRM_CHECK(n_type != NULL, crm_err("No notify type value found for %s", action->uuid)); CRM_CHECK(n_task != NULL, crm_err("No notify operation value found for %s", action->uuid)); clone_key = generate_notify_key(action->rsc->clone_name, n_type, n_task); } else { clone_key = generate_op_key(action->rsc->clone_name, action->task, interval); } CRM_CHECK(clone_key != NULL, crm_err("Could not generate a key for %s", action->uuid)); crm_xml_add(action_xml, XML_LRM_ATTR_TASK_KEY, clone_key); crm_xml_add(action_xml, "internal_" XML_LRM_ATTR_TASK_KEY, action->uuid); crm_free(clone_key); } else { crm_xml_add(action_xml, XML_LRM_ATTR_TASK_KEY, action->uuid); } if (needs_node_info && action->node != NULL) { crm_xml_add(action_xml, XML_LRM_ATTR_TARGET, action->node->details->uname); crm_xml_add(action_xml, XML_LRM_ATTR_TARGET_UUID, action->node->details->id); } if (is_set(action->flags, pe_action_failure_is_fatal) == FALSE) { add_hash_param(action->meta, XML_ATTR_TE_ALLOWFAIL, XML_BOOLEAN_TRUE); } if (as_input) { return action_xml; } if (action->rsc) { if (is_set(action->flags, pe_action_pseudo) == FALSE) { int lpc = 0; xmlNode *rsc_xml = create_xml_node(action_xml, crm_element_name(action->rsc->xml)); const char *attr_list[] = { XML_AGENT_ATTR_CLASS, XML_AGENT_ATTR_PROVIDER, XML_ATTR_TYPE }; if (action->rsc->clone_name != NULL) { crm_debug("Using clone name %s for %s", action->rsc->clone_name, action->rsc->id); crm_xml_add(rsc_xml, XML_ATTR_ID, action->rsc->clone_name); crm_xml_add(rsc_xml, XML_ATTR_ID_LONG, action->rsc->id); } else { crm_xml_add(rsc_xml, XML_ATTR_ID, action->rsc->id); crm_xml_add(rsc_xml, XML_ATTR_ID_LONG, action->rsc->long_name); } for (lpc = 0; lpc < DIMOF(attr_list); lpc++) { crm_xml_add(rsc_xml, attr_list[lpc], g_hash_table_lookup(action->rsc->meta, attr_list[lpc])); } } } args_xml = create_xml_node(NULL, XML_TAG_ATTRS); crm_xml_add(args_xml, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET); g_hash_table_foreach(action->extra, hash2field, args_xml); if (action->rsc != NULL) { g_hash_table_foreach(action->rsc->parameters, hash2smartfield, args_xml); } g_hash_table_foreach(action->meta, hash2metafield, args_xml); if (action->rsc != NULL) { resource_t *parent = action->rsc; while (parent != NULL) { parent->cmds->append_meta(parent, args_xml); parent = parent->parent; } } else if (safe_str_eq(action->task, CRM_OP_FENCE)) { g_hash_table_foreach(action->node->details->attrs, hash2metafield, args_xml); } sorted_xml(args_xml, action_xml, FALSE); crm_log_xml_trace(action_xml, "dumped action"); free_xml(args_xml); return action_xml; } static gboolean should_dump_action(action_t * action) { CRM_CHECK(action != NULL, return FALSE); if (is_set(action->flags, pe_action_dumped)) { crm_trace( "action %d (%s) was already dumped", action->id, action->uuid); return FALSE; } else if (is_set(action->flags, pe_action_runnable) == FALSE) { crm_trace( "action %d (%s) was not runnable", action->id, action->uuid); return FALSE; } else if (is_set(action->flags, pe_action_optional) && is_set(action->flags, pe_action_print_always) == FALSE) { crm_trace( "action %d (%s) was optional", action->id, action->uuid); return FALSE; } else if (action->rsc != NULL && is_not_set(action->rsc->flags, pe_rsc_managed)) { const char *interval = NULL; interval = g_hash_table_lookup(action->meta, XML_LRM_ATTR_INTERVAL); /* make sure probes and recurring monitors go through */ if (safe_str_neq(action->task, RSC_STATUS) && interval == NULL) { crm_trace( "action %d (%s) was for an unmanaged resource (%s)", action->id, action->uuid, action->rsc->id); return FALSE; } } if (is_set(action->flags, pe_action_pseudo) || safe_str_eq(action->task, CRM_OP_FENCE) || safe_str_eq(action->task, CRM_OP_SHUTDOWN)) { /* skip the next checks */ return TRUE; } if (action->node == NULL) { pe_err("action %d (%s) was not allocated", action->id, action->uuid); log_action(LOG_DEBUG, "Unallocated action", action, FALSE); return FALSE; } else if (action->node->details->online == FALSE) { pe_err("action %d was (%s) scheduled for offline node", action->id, action->uuid); log_action(LOG_DEBUG, "Action for offline node", action, FALSE); return FALSE; #if 0 /* but this would also affect resources that can be safely * migrated before a fencing op */ } else if (action->node->details->unclean == FALSE) { pe_err("action %d was (%s) scheduled for unclean node", action->id, action->uuid); log_action(LOG_DEBUG, "Action for unclean node", action, FALSE); return FALSE; #endif } return TRUE; } /* lowest to highest */ static gint sort_action_id(gconstpointer a, gconstpointer b) { const action_wrapper_t *action_wrapper2 = (const action_wrapper_t *)a; const action_wrapper_t *action_wrapper1 = (const action_wrapper_t *)b; if (a == NULL) { return 1; } if (b == NULL) { return -1; } if (action_wrapper1->action->id > action_wrapper2->action->id) { return -1; } if (action_wrapper1->action->id < action_wrapper2->action->id) { return 1; } return 0; } static gboolean should_dump_input(int last_action, action_t * action, action_wrapper_t * wrapper) { int type = wrapper->type; type &= ~pe_order_implies_first_printed; type &= ~pe_order_implies_then_printed; type &= ~pe_order_optional; wrapper->state = pe_link_not_dumped; if (last_action == wrapper->action->id) { crm_trace( "Input (%d) %s duplicated for %s", wrapper->action->id, wrapper->action->uuid, action->uuid); wrapper->state = pe_link_dup; return FALSE; } else if (wrapper->type == pe_order_none) { crm_trace( "Input (%d) %s suppressed for %s", wrapper->action->id, wrapper->action->uuid, action->uuid); return FALSE; } else if (is_set(wrapper->action->flags, pe_action_runnable) == FALSE && type == pe_order_none && safe_str_neq(wrapper->action->uuid, CRM_OP_PROBED)) { crm_trace( "Input (%d) %s optional (ordering) for %s", wrapper->action->id, wrapper->action->uuid, action->uuid); return FALSE; } else if (is_set(action->flags, pe_action_pseudo) && (wrapper->type & pe_order_stonith_stop)) { crm_trace( "Input (%d) %s suppressed for %s", wrapper->action->id, wrapper->action->uuid, action->uuid); return FALSE; } else if (wrapper->type == pe_order_load) { crm_trace("check load filter %s.%s -> %s.%s", wrapper->action->uuid, wrapper->action->node->details->uname, action->uuid, action->node->details->uname); if (action->rsc && safe_str_eq(action->task, RSC_MIGRATE)) { /* For migrate_to ops, we care about where it has been * allocated to, not where the action will be executed */ if(wrapper->action->node == NULL || action->rsc->allocated_to == NULL || wrapper->action->node->details != action->rsc->allocated_to->details) { /* Check if the actions are for the same node, ignore otherwise */ crm_trace("load filter - migrate"); wrapper->type = pe_order_none; return FALSE; } } else if (wrapper->action->node == NULL || action->node == NULL || wrapper->action->node->details != action->node->details) { /* Check if the actions are for the same node, ignore otherwise */ crm_trace("load filter - node"); wrapper->type = pe_order_none; return FALSE; } else if(is_set(wrapper->action->flags, pe_action_optional)) { /* Check if the pre-req is optional, ignore if so */ crm_trace("load filter - optional"); wrapper->type = pe_order_none; return FALSE; } } else if (wrapper->action->rsc && wrapper->action->rsc != action->rsc && is_set(wrapper->action->rsc->flags, pe_rsc_failed) && is_not_set(wrapper->action->rsc->flags, pe_rsc_managed) && strstr(wrapper->action->uuid, "_stop_0") && action->rsc && action->rsc->variant >= pe_clone) { crm_warn("Ignoring requirement that %s comeplete before %s:" " unmanaged failed resources cannot prevent clone shutdown", wrapper->action->uuid, action->uuid); return FALSE; } else if (is_set(wrapper->action->flags, pe_action_dumped) || should_dump_action(wrapper->action)) { crm_trace( "Input (%d) %s should be dumped for %s", wrapper->action->id, wrapper->action->uuid, action->uuid); goto dump; #if 0 } else if (is_set(wrapper->action->flags, pe_action_runnable) && is_set(wrapper->action->flags, pe_action_pseudo) && wrapper->action->rsc->variant != pe_native) { crm_crit("Input (%d) %s should be dumped for %s", wrapper->action->id, wrapper->action->uuid, action->uuid); goto dump; #endif } else if (is_set(wrapper->action->flags, pe_action_optional) == TRUE && is_set(wrapper->action->flags, pe_action_print_always) == FALSE) { crm_trace( "Input (%d) %s optional for %s", wrapper->action->id, wrapper->action->uuid, action->uuid); crm_trace( "Input (%d) %s n=%p p=%d r=%d o=%d a=%d f=0x%.6x", wrapper->action->id, wrapper->action->uuid, wrapper->action->node, is_set(wrapper->action->flags, pe_action_pseudo), is_set(wrapper->action->flags, pe_action_runnable), is_set(wrapper->action->flags, pe_action_optional), is_set(wrapper->action->flags, pe_action_print_always), wrapper->type); return FALSE; } dump: crm_trace( "Input (%d) %s n=%p p=%d r=%d o=%d a=%d f=0x%.6x dumped for %s", wrapper->action->id, wrapper->action->uuid, wrapper->action->node, is_set(wrapper->action->flags, pe_action_pseudo), is_set(wrapper->action->flags, pe_action_runnable), is_set(wrapper->action->flags, pe_action_optional), is_set(wrapper->action->flags, pe_action_print_always), wrapper->type, action->uuid); return TRUE; } void graph_element_from_action(action_t * action, pe_working_set_t * data_set) { GListPtr lpc = NULL; int last_action = -1; int synapse_priority = 0; xmlNode *syn = NULL; xmlNode *set = NULL; xmlNode *in = NULL; xmlNode *input = NULL; xmlNode *xml_action = NULL; if (should_dump_action(action) == FALSE) { return; } set_bit_inplace(action->flags, pe_action_dumped); syn = create_xml_node(data_set->graph, "synapse"); set = create_xml_node(syn, "action_set"); in = create_xml_node(syn, "inputs"); crm_xml_add_int(syn, XML_ATTR_ID, data_set->num_synapse); data_set->num_synapse++; if (action->rsc != NULL) { synapse_priority = action->rsc->priority; } if (action->priority > synapse_priority) { synapse_priority = action->priority; } if (synapse_priority > 0) { crm_xml_add_int(syn, XML_CIB_ATTR_PRIORITY, synapse_priority); } xml_action = action2xml(action, FALSE); add_node_nocopy(set, crm_element_name(xml_action), xml_action); action->actions_before = g_list_sort(action->actions_before, sort_action_id); for (lpc = action->actions_before; lpc != NULL; lpc = lpc->next) { action_wrapper_t *wrapper = (action_wrapper_t *) lpc->data; if (should_dump_input(last_action, action, wrapper) == FALSE) { continue; } wrapper->state = pe_link_dumped; CRM_CHECK(last_action < wrapper->action->id,; ); last_action = wrapper->action->id; input = create_xml_node(in, "trigger"); xml_action = action2xml(wrapper->action, TRUE); add_node_nocopy(input, crm_element_name(xml_action), xml_action); } } diff --git a/pengine/native.c b/pengine/native.c index 0dcf783565..348e17205c 100644 --- a/pengine/native.c +++ b/pengine/native.c @@ -1,3074 +1,3021 @@ /* * 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 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include #include #include #include #include #include #define DELETE_THEN_REFRESH 1 /* The crmd will remove the resource from the CIB itself, making this redundant */ #define INFINITY_HACK (INFINITY * -100) #define VARIANT_NATIVE 1 #include void native_rsc_colocation_rh_must(resource_t * rsc_lh, gboolean update_lh, resource_t * rsc_rh, gboolean update_rh); void native_rsc_colocation_rh_mustnot(resource_t * rsc_lh, gboolean update_lh, resource_t * rsc_rh, gboolean update_rh); void Recurring(resource_t * rsc, action_t * start, node_t * node, pe_working_set_t * data_set); void RecurringOp(resource_t * rsc, action_t * start, node_t * node, xmlNode * operation, pe_working_set_t * data_set); void Recurring_Stopped(resource_t * rsc, action_t * start, node_t * node, pe_working_set_t * data_set); void RecurringOp_Stopped(resource_t * rsc, action_t * start, node_t * node, xmlNode * operation, pe_working_set_t * data_set); void pe_post_notify(resource_t * rsc, node_t * node, action_t * op, notify_data_t * n_data, pe_working_set_t * data_set); -void NoRoleChange(resource_t * rsc, node_t * current, node_t * next, pe_working_set_t * data_set); gboolean DeleteRsc(resource_t * rsc, node_t * node, gboolean optional, pe_working_set_t * data_set); gboolean StopRsc(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set); gboolean StartRsc(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set); gboolean DemoteRsc(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set); gboolean PromoteRsc(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set); gboolean RoleError(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set); gboolean NullOp(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set); /* *INDENT-OFF* */ enum rsc_role_e rsc_state_matrix[RSC_ROLE_MAX][RSC_ROLE_MAX] = { /* Current State */ /* Next State: Unknown Stopped Started Slave Master */ /* Unknown */ { RSC_ROLE_UNKNOWN, RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, }, /* Stopped */ { RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_STARTED, RSC_ROLE_SLAVE, RSC_ROLE_SLAVE, }, /* Started */ { RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_STARTED, RSC_ROLE_SLAVE, RSC_ROLE_MASTER, }, /* Slave */ { RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_UNKNOWN, RSC_ROLE_SLAVE, RSC_ROLE_MASTER, }, /* Master */ { RSC_ROLE_STOPPED, RSC_ROLE_SLAVE, RSC_ROLE_UNKNOWN, RSC_ROLE_SLAVE, RSC_ROLE_MASTER, }, }; gboolean (*rsc_action_matrix[RSC_ROLE_MAX][RSC_ROLE_MAX])(resource_t*,node_t*,gboolean,pe_working_set_t*) = { /* Current State */ /* Next State: Unknown Stopped Started Slave Master */ /* Unknown */ { RoleError, StopRsc, RoleError, RoleError, RoleError, }, /* Stopped */ { RoleError, NullOp, StartRsc, StartRsc, RoleError, }, /* Started */ { RoleError, StopRsc, NullOp, NullOp, PromoteRsc, }, /* Slave */ { RoleError, StopRsc, RoleError, NullOp, PromoteRsc, }, /* Master */ { RoleError, DemoteRsc, RoleError, DemoteRsc, NullOp, }, }; /* *INDENT-ON* */ struct capacity_data { node_t *node; resource_t *rsc; gboolean is_enough; }; static void check_capacity(gpointer key, gpointer value, gpointer user_data) { int required = 0; int remaining = 0; struct capacity_data *data = user_data; required = crm_parse_int(value, "0"); remaining = crm_parse_int(g_hash_table_lookup(data->node->details->utilization, key), "0"); if (required > remaining) { crm_debug("Node %s has no enough %s for resource %s: required=%d remaining=%d", data->node->details->uname, (char *)key, data->rsc->id, required, remaining); data->is_enough = FALSE; } } static gboolean have_enough_capacity(node_t * node, resource_t * rsc) { struct capacity_data data; data.node = node; data.rsc = rsc; data.is_enough = TRUE; g_hash_table_foreach(rsc->utilization, check_capacity, &data); return data.is_enough; } static gboolean native_choose_node(resource_t * rsc, node_t * prefer, pe_working_set_t * data_set) { /* 1. Sort by weight 2. color.chosen_node = the node (of those with the highest wieght) with the fewest resources 3. remove color.chosen_node from all other colors */ int alloc_details = scores_log_level + 1; GListPtr nodes = NULL; node_t *chosen = NULL; int lpc = 0; int multiple = 0; int length = 0; gboolean result = FALSE; if (safe_str_neq(data_set->placement_strategy, "default")) { GListPtr gIter = NULL; for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) { node_t *node = (node_t *) gIter->data; if (have_enough_capacity(node, rsc) == FALSE) { crm_debug("Resource %s cannot be allocated to node %s: none of enough capacity", rsc->id, node->details->uname); resource_location(rsc, node, -INFINITY, "__limit_utilization_", data_set); } } dump_node_scores(alloc_details, rsc, "Post-utilization", rsc->allowed_nodes); } length = g_hash_table_size(rsc->allowed_nodes); if (is_not_set(rsc->flags, pe_rsc_provisional)) { return rsc->allocated_to ? TRUE : FALSE; } if (prefer) { chosen = g_hash_table_lookup(rsc->allowed_nodes, prefer->details->id); if (chosen && chosen->weight >= 0 && can_run_resources(chosen)) { crm_trace("Using preferred node %s for %s instead of choosing from %d candidates", chosen->details->uname, rsc->id, length); } else if (chosen && chosen->weight < 0) { crm_trace("Preferred node %s for %s was unavailable", chosen->details->uname, rsc->id); chosen = NULL; } else if (chosen && can_run_resources(chosen)) { crm_trace("Preferred node %s for %s was unsuitable", chosen->details->uname, rsc->id); chosen = NULL; } else { crm_trace("Preferred node %s for %s was unknown", prefer->details->uname, rsc->id); } } if (chosen == NULL && rsc->allowed_nodes) { nodes = g_hash_table_get_values(rsc->allowed_nodes); nodes = g_list_sort_with_data(nodes, sort_node_weight, g_list_nth_data(rsc->running_on, 0)); chosen = g_list_nth_data(nodes, 0); crm_trace("Chose node %s for %s from %d candidates", chosen ? chosen->details->uname : "", rsc->id, length); if (chosen && chosen->weight > 0 && can_run_resources(chosen)) { node_t *running = g_list_nth_data(rsc->running_on, 0); if (running && can_run_resources(running) == FALSE) { crm_trace("Current node for %s (%s) can't run resources", rsc->id, running->details->uname); running = NULL; } for (lpc = 1; lpc < length && running; lpc++) { node_t *tmp = g_list_nth_data(nodes, lpc); if (tmp->weight == chosen->weight) { multiple++; if (tmp->details == running->details) { /* prefer the existing node if scores are equal */ chosen = tmp; } } } } } if (multiple > 1) { int log_level = LOG_INFO; char *score = score2char(chosen->weight); if (chosen->weight >= INFINITY) { log_level = LOG_WARNING; } do_crm_log(log_level, "%d nodes with equal score (%s) for" " running %s resources. Chose %s.", multiple, score, rsc->id, chosen->details->uname); crm_free(score); } result = native_assign_node(rsc, nodes, chosen, FALSE); g_list_free(nodes); return result; } static int node_list_attr_score(GHashTable * list, const char *attr, const char *value) { GHashTableIter iter; node_t *node = NULL; int best_score = -INFINITY; const char *best_node = NULL; if (attr == NULL) { attr = "#" XML_ATTR_UNAME; } g_hash_table_iter_init(&iter, list); while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) { int weight = node->weight; if (can_run_resources(node) == FALSE) { weight = -INFINITY; } if (weight > best_score || best_node == NULL) { const char *tmp = g_hash_table_lookup(node->details->attrs, attr); if (safe_str_eq(value, tmp)) { best_score = weight; best_node = node->details->uname; } } } if (safe_str_neq(attr, "#" XML_ATTR_UNAME)) { crm_info("Best score for %s=%s was %s with %d", attr, value, best_node ? best_node : "", best_score); } return best_score; } static void node_hash_update(GHashTable * list1, GHashTable * list2, const char *attr, int factor, gboolean only_positive) { int score = 0; int new_score = 0; GHashTableIter iter; node_t *node = NULL; if (attr == NULL) { attr = "#" XML_ATTR_UNAME; } g_hash_table_iter_init(&iter, list1); while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) { CRM_CHECK(node != NULL, continue); score = node_list_attr_score(list2, attr, g_hash_table_lookup(node->details->attrs, attr)); new_score = merge_weights(factor * score, node->weight); if (factor < 0 && score < 0) { /* Negative preference for a node with a negative score * should not become a positive preference * * TODO: Decide if we want to filter only if weight == -INFINITY * */ crm_trace("%s: Filtering %d + %d*%d (factor * score)", node->details->uname, node->weight, factor, score); } else if (node->weight == INFINITY_HACK) { crm_trace("%s: Filtering %d + %d*%d (node < 0)", node->details->uname, node->weight, factor, score); } else if (only_positive && new_score < 0 && node->weight > 0) { node->weight = INFINITY_HACK; crm_trace("%s: Filtering %d + %d*%d (score > 0)", node->details->uname, node->weight, factor, score); } else if (only_positive && new_score < 0 && node->weight == 0) { crm_trace("%s: Filtering %d + %d*%d (score == 0)", node->details->uname, node->weight, factor, score); } else { crm_trace("%s: %d + %d*%d", node->details->uname, node->weight, factor, score); node->weight = new_score; } } } static GHashTable * node_hash_dup(GHashTable * hash) { /* Hack! */ GListPtr list = g_hash_table_get_values(hash); GHashTable *result = node_hash_from_list(list); g_list_free(list); return result; } GHashTable * native_merge_weights(resource_t * rsc, const char *rhs, GHashTable * nodes, const char *attr, int factor, gboolean allow_rollback, gboolean only_positive) { enum pe_weights flags = pe_weights_none; if (only_positive) { set_bit_inplace(flags, pe_weights_positive); } if (allow_rollback) { set_bit_inplace(flags, pe_weights_rollback); } return rsc_merge_weights(rsc, rhs, nodes, attr, factor, flags); } GHashTable * rsc_merge_weights(resource_t * rsc, const char *rhs, GHashTable * nodes, const char *attr, int factor, enum pe_weights flags) { GHashTable *work = NULL; int multiplier = 1; if (factor < 0) { multiplier = -1; } if (is_set(rsc->flags, pe_rsc_merging)) { crm_info("%s: Breaking dependency loop at %s", rhs, rsc->id); return nodes; } set_bit(rsc->flags, pe_rsc_merging); if (is_set(flags, pe_weights_init)) { if (rsc->variant == pe_group && rsc->children) { GListPtr last = rsc->children; while (last->next != NULL) { last = last->next; } crm_trace("Merging %s as a group %p %p", rsc->id, rsc->children, last); work = rsc_merge_weights(last->data, rhs, NULL, attr, factor, flags); } else { work = node_hash_dup(rsc->allowed_nodes); } clear_bit_inplace(flags, pe_weights_init); } else { crm_trace("%s: Combining scores from %s", rhs, rsc->id); work = node_hash_dup(nodes); node_hash_update(work, rsc->allowed_nodes, attr, factor, is_set(flags, pe_weights_positive)); } if (is_set(flags, pe_weights_rollback) && can_run_any(work) == FALSE) { crm_info("%s: Rolling back scores from %s", rhs, rsc->id); g_hash_table_destroy(work); clear_bit(rsc->flags, pe_rsc_merging); return nodes; } if (can_run_any(work)) { GListPtr gIter = NULL; if (is_set(flags, pe_weights_forward)) { gIter = rsc->rsc_cons; } else { gIter = rsc->rsc_cons_lhs; } for (; gIter != NULL; gIter = gIter->next) { resource_t *other = NULL; rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data; if (is_set(flags, pe_weights_forward)) { other = constraint->rsc_rh; } else { other = constraint->rsc_lh; } crm_trace("Applying %s (%s)", constraint->id, other->id); work = rsc_merge_weights(other, rhs, work, constraint->node_attribute, multiplier * constraint->score / INFINITY, flags); dump_node_scores(LOG_TRACE, NULL, rhs, work); } } if(is_set(flags, pe_weights_positive)) { node_t *node = NULL; GHashTableIter iter; g_hash_table_iter_init(&iter, work); while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) { if (node->weight == INFINITY_HACK) { node->weight = 1; } } } if (nodes) { g_hash_table_destroy(nodes); } clear_bit(rsc->flags, pe_rsc_merging); return work; } node_t * native_color(resource_t * rsc, node_t * prefer, pe_working_set_t * data_set) { GListPtr gIter = NULL; int alloc_details = scores_log_level + 1; const char *class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS); if (rsc->parent && is_not_set(rsc->parent->flags, pe_rsc_allocating)) { /* never allocate children on their own */ crm_debug("Escalating allocation of %s to its parent: %s", rsc->id, rsc->parent->id); rsc->parent->cmds->allocate(rsc->parent, prefer, data_set); } if (is_not_set(rsc->flags, pe_rsc_provisional)) { return rsc->allocated_to; } if (is_set(rsc->flags, pe_rsc_allocating)) { crm_debug("Dependency loop detected involving %s", rsc->id); return NULL; } set_bit(rsc->flags, pe_rsc_allocating); print_resource(alloc_details, "Allocating: ", rsc, FALSE); dump_node_scores(alloc_details, rsc, "Pre-allloc", rsc->allowed_nodes); for (gIter = rsc->rsc_cons; gIter != NULL; gIter = gIter->next) { rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data; GHashTable *archive = NULL; resource_t *rsc_rh = constraint->rsc_rh; crm_trace("%s: Pre-Processing %s (%s, %d, %s)", rsc->id, constraint->id, rsc_rh->id, constraint->score, role2text(constraint->role_lh)); if (constraint->role_lh >= RSC_ROLE_MASTER || (constraint->score < 0 && constraint->score > -INFINITY)) { archive = node_hash_dup(rsc->allowed_nodes); } rsc_rh->cmds->allocate(rsc_rh, NULL, data_set); rsc->cmds->rsc_colocation_lh(rsc, rsc_rh, constraint); if (archive && can_run_any(rsc->allowed_nodes) == FALSE) { crm_info("%s: Rolling back scores from %s", rsc->id, rsc_rh->id); g_hash_table_destroy(rsc->allowed_nodes); rsc->allowed_nodes = archive; archive = NULL; } if (archive) { g_hash_table_destroy(archive); } } dump_node_scores(alloc_details, rsc, "Post-coloc", rsc->allowed_nodes); for (gIter = rsc->rsc_cons_lhs; gIter != NULL; gIter = gIter->next) { rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data; rsc->allowed_nodes = constraint->rsc_lh->cmds->merge_weights(constraint->rsc_lh, rsc->id, rsc->allowed_nodes, constraint->node_attribute, constraint->score / INFINITY, TRUE, FALSE); } for (gIter = rsc->rsc_tickets; gIter != NULL; gIter = gIter->next) { rsc_ticket_t *rsc_ticket = (rsc_ticket_t *) gIter->data; if (rsc_ticket->ticket->granted == FALSE || rsc_ticket->ticket->standby) { rsc_ticket_constraint(rsc, rsc_ticket, data_set); } } print_resource(LOG_DEBUG_2, "Allocating: ", rsc, FALSE); if (rsc->next_role == RSC_ROLE_STOPPED) { crm_trace("Making sure %s doesn't get allocated", rsc->id); /* make sure it doesnt come up again */ resource_location(rsc, NULL, -INFINITY, XML_RSC_ATTR_TARGET_ROLE, data_set); } dump_node_scores(show_scores ? 0 : scores_log_level, rsc, __PRETTY_FUNCTION__, rsc->allowed_nodes); if (is_set(data_set->flags, pe_flag_stonith_enabled) && is_set(data_set->flags, pe_flag_have_stonith_resource) == FALSE) { clear_bit(rsc->flags, pe_rsc_managed); } if (is_not_set(rsc->flags, pe_rsc_managed)) { const char *reason = NULL; node_t *assign_to = NULL; rsc->next_role = rsc->role; if (rsc->running_on == NULL) { reason = "inactive"; } else if (rsc->role == RSC_ROLE_MASTER) { assign_to = rsc->running_on->data; reason = "master"; } else if (is_set(rsc->flags, pe_rsc_failed)) { reason = "failed"; } else { assign_to = rsc->running_on->data; reason = "active"; } crm_info("Unmanaged resource %s allocated to %s: %s", rsc->id, assign_to ? assign_to->details->uname : "'nowhere'", reason); native_assign_node(rsc, NULL, assign_to, TRUE); } else if (is_set(data_set->flags, pe_flag_stop_everything) && safe_str_neq(class, "stonith")) { crm_debug("Forcing %s to stop", rsc->id); native_assign_node(rsc, NULL, NULL, TRUE); } else if (is_set(rsc->flags, pe_rsc_provisional) && native_choose_node(rsc, prefer, data_set)) { crm_trace("Allocated resource %s to %s", rsc->id, rsc->allocated_to->details->uname); } else if (rsc->allocated_to == NULL) { if (is_not_set(rsc->flags, pe_rsc_orphan)) { crm_info("Resource %s cannot run anywhere", rsc->id); } else if (rsc->running_on != NULL) { crm_info("Stopping orphan resource %s", rsc->id); } } else { crm_debug("Pre-Allocated resource %s to %s", rsc->id, rsc->allocated_to->details->uname); } clear_bit(rsc->flags, pe_rsc_allocating); print_resource(LOG_DEBUG_3, "Allocated ", rsc, TRUE); return rsc->allocated_to; } static gboolean is_op_dup(resource_t * rsc, const char *name, const char *interval) { gboolean dup = FALSE; const char *id = NULL; const char *value = NULL; xmlNode *operation = NULL; for (operation = __xml_first_child(rsc->ops_xml); operation != NULL; operation = __xml_next(operation)) { if (crm_str_eq((const char *)operation->name, "op", TRUE)) { value = crm_element_value(operation, "name"); if (safe_str_neq(value, name)) { continue; } value = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); if (value == NULL) { value = "0"; } if (safe_str_neq(value, interval)) { continue; } if (id == NULL) { id = ID(operation); } else { crm_config_err("Operation %s is a duplicate of %s", ID(operation), id); crm_config_err ("Do not use the same (name, interval) combination more than once per resource"); dup = TRUE; } } } return dup; } void RecurringOp(resource_t * rsc, action_t * start, node_t * node, xmlNode * operation, pe_working_set_t * data_set) { char *key = NULL; const char *name = NULL; const char *value = NULL; const char *interval = NULL; const char *node_uname = NULL; unsigned long long interval_ms = 0; action_t *mon = NULL; gboolean is_optional = TRUE; GListPtr possible_matches = NULL; /* Only process for the operations without role="Stopped" */ value = crm_element_value(operation, "role"); if (value && text2role(value) == RSC_ROLE_STOPPED) { return; } crm_trace("Creating recurring action %s for %s in role %s on %s", ID(operation), rsc->id, role2text(rsc->next_role), node ? node->details->uname : "n/a"); if (node != NULL) { node_uname = node->details->uname; } interval = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); interval_ms = crm_get_interval(interval); if (interval_ms == 0) { return; } name = crm_element_value(operation, "name"); if (is_op_dup(rsc, name, interval)) { return; } if (safe_str_eq(name, RSC_STOP) || safe_str_eq(name, RSC_START) || safe_str_eq(name, RSC_DEMOTE) || safe_str_eq(name, RSC_PROMOTE) ) { crm_config_err("Invalid recurring action %s wth name: '%s'", ID(operation), name); return; } key = generate_op_key(rsc->id, name, interval_ms); if (find_rsc_op_entry(rsc, key) == NULL) { /* disabled */ crm_free(key); return; } if (start != NULL) { crm_trace("Marking %s %s due to %s", key, is_set(start->flags, pe_action_optional) ? "optional" : "manditory", start->uuid); is_optional = (rsc->cmds->action_flags(start, NULL) & pe_action_optional); } else { crm_trace("Marking %s optional", key); is_optional = TRUE; } /* start a monitor for an already active resource */ possible_matches = find_actions_exact(rsc->actions, key, node); if (possible_matches == NULL) { is_optional = FALSE; crm_trace("Marking %s manditory: not active", key); } else { g_list_free(possible_matches); } if ((rsc->next_role == RSC_ROLE_MASTER && value == NULL) || (value != NULL && text2role(value) != rsc->next_role)) { int log_level = LOG_DEBUG_2; const char *result = "Ignoring"; if (is_optional) { char *local_key = crm_strdup(key); log_level = LOG_INFO; result = "Cancelling"; /* its running : cancel it */ mon = custom_action(rsc, local_key, RSC_CANCEL, node, FALSE, TRUE, data_set); crm_free(mon->task); mon->task = crm_strdup(RSC_CANCEL); add_hash_param(mon->meta, XML_LRM_ATTR_INTERVAL, interval); add_hash_param(mon->meta, XML_LRM_ATTR_TASK, name); local_key = NULL; switch (rsc->role) { case RSC_ROLE_SLAVE: case RSC_ROLE_STARTED: if (rsc->next_role == RSC_ROLE_MASTER) { local_key = promote_key(rsc); } else if (rsc->next_role == RSC_ROLE_STOPPED) { local_key = stop_key(rsc); } break; case RSC_ROLE_MASTER: local_key = demote_key(rsc); break; default: break; } if (local_key) { custom_action_order(rsc, NULL, mon, rsc, local_key, NULL, pe_order_runnable_left, data_set); } mon = NULL; } do_crm_log(log_level, "%s action %s (%s vs. %s)", result, key, value ? value : role2text(RSC_ROLE_SLAVE), role2text(rsc->next_role)); crm_free(key); key = NULL; return; } mon = custom_action(rsc, key, name, node, is_optional, TRUE, data_set); key = mon->uuid; if (is_optional) { crm_trace("%s\t %s (optional)", crm_str(node_uname), mon->uuid); } if (start == NULL || is_set(start->flags, pe_action_runnable) == FALSE) { crm_debug("%s\t %s (cancelled : start un-runnable)", crm_str(node_uname), mon->uuid); update_action_flags(mon, pe_action_runnable | pe_action_clear); } else if (node == NULL || node->details->online == FALSE || node->details->unclean) { crm_debug("%s\t %s (cancelled : no node available)", crm_str(node_uname), mon->uuid); update_action_flags(mon, pe_action_runnable | pe_action_clear); } else if (is_set(mon->flags, pe_action_optional) == FALSE) { crm_info(" Start recurring %s (%llus) for %s on %s", mon->task, interval_ms / 1000, rsc->id, crm_str(node_uname)); } if (rsc->next_role == RSC_ROLE_MASTER) { char *running_master = crm_itoa(EXECRA_RUNNING_MASTER); add_hash_param(mon->meta, XML_ATTR_TE_TARGET_RC, running_master); crm_free(running_master); } if (node == NULL || is_set(rsc->flags, pe_rsc_managed)) { custom_action_order(rsc, start_key(rsc), NULL, NULL, crm_strdup(key), mon, pe_order_implies_then | pe_order_runnable_left, data_set); if (rsc->next_role == RSC_ROLE_MASTER) { custom_action_order(rsc, promote_key(rsc), NULL, rsc, NULL, mon, pe_order_optional | pe_order_runnable_left, data_set); } else if (rsc->role == RSC_ROLE_MASTER) { custom_action_order(rsc, demote_key(rsc), NULL, rsc, NULL, mon, pe_order_optional | pe_order_runnable_left, data_set); } } } void Recurring(resource_t * rsc, action_t * start, node_t * node, pe_working_set_t * data_set) { if (is_not_set(data_set->flags, pe_flag_maintenance_mode)) { xmlNode *operation = NULL; for (operation = __xml_first_child(rsc->ops_xml); operation != NULL; operation = __xml_next(operation)) { if (crm_str_eq((const char *)operation->name, "op", TRUE)) { RecurringOp(rsc, start, node, operation, data_set); } } } } void RecurringOp_Stopped(resource_t * rsc, action_t * start, node_t * node, xmlNode * operation, pe_working_set_t * data_set) { char *key = NULL; const char *name = NULL; const char *role = NULL; const char *interval = NULL; const char *node_uname = NULL; unsigned long long interval_ms = 0; GListPtr possible_matches = NULL; GListPtr gIter = NULL; /* TODO: Support of non-unique clone */ if (is_set(rsc->flags, pe_rsc_unique) == FALSE) { return; } /* Only process for the operations with role="Stopped" */ role = crm_element_value(operation, "role"); if (role == NULL || text2role(role) != RSC_ROLE_STOPPED) { return; } crm_trace ("Creating recurring actions %s for %s in role %s on nodes where it'll not be running", ID(operation), rsc->id, role2text(rsc->next_role)); if (node != NULL) { node_uname = node->details->uname; } interval = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); interval_ms = crm_get_interval(interval); if (interval_ms == 0) { return; } name = crm_element_value(operation, "name"); if (is_op_dup(rsc, name, interval)) { return; } if (safe_str_eq(name, RSC_STOP) || safe_str_eq(name, RSC_START) || safe_str_eq(name, RSC_DEMOTE) || safe_str_eq(name, RSC_PROMOTE) ) { crm_config_err("Invalid recurring action %s wth name: '%s'", ID(operation), name); return; } key = generate_op_key(rsc->id, name, interval_ms); if (find_rsc_op_entry(rsc, key) == NULL) { /* disabled */ crm_free(key); return; } /* if the monitor exists on the node where the resource will be running, cancel it */ if (node != NULL) { possible_matches = find_actions_exact(rsc->actions, key, node); if (possible_matches) { action_t *cancel_op = NULL; char *local_key = crm_strdup(key); g_list_free(possible_matches); cancel_op = custom_action(rsc, local_key, RSC_CANCEL, node, FALSE, TRUE, data_set); crm_free(cancel_op->task); cancel_op->task = crm_strdup(RSC_CANCEL); add_hash_param(cancel_op->meta, XML_LRM_ATTR_INTERVAL, interval); add_hash_param(cancel_op->meta, XML_LRM_ATTR_TASK, name); local_key = NULL; if (rsc->next_role == RSC_ROLE_STARTED || rsc->next_role == RSC_ROLE_SLAVE) { /* rsc->role == RSC_ROLE_STOPPED: cancel the monitor before start */ /* rsc->role == RSC_ROLE_STARTED: for a migration, cancel the monitor on the target node before start */ custom_action_order(rsc, NULL, cancel_op, rsc, start_key(rsc), NULL, pe_order_runnable_left, data_set); } crm_info("Cancel action %s (%s vs. %s) on %s", key, role, role2text(rsc->next_role), crm_str(node_uname)); } } for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) { node_t *stop_node = (node_t *) gIter->data; const char *stop_node_uname = stop_node->details->uname; gboolean is_optional = TRUE; gboolean probe_is_optional = TRUE; gboolean stop_is_optional = TRUE; action_t *stopped_mon = NULL; char *rc_inactive = NULL; GListPtr probe_complete_ops = NULL; GListPtr stop_ops = NULL; GListPtr local_gIter = NULL; char *stop_op_key = NULL; if (node_uname && safe_str_eq(stop_node_uname, node_uname)) { continue; } crm_trace("Creating recurring action %s for %s on %s", ID(operation), rsc->id, crm_str(stop_node_uname)); /* start a monitor for an already stopped resource */ possible_matches = find_actions_exact(rsc->actions, key, stop_node); if (possible_matches == NULL) { crm_trace("Marking %s manditory on %s: not active", key, crm_str(stop_node_uname)); is_optional = FALSE; } else { crm_trace("Marking %s optional on %s: already active", key, crm_str(stop_node_uname)); is_optional = TRUE; g_list_free(possible_matches); } stopped_mon = custom_action(rsc, crm_strdup(key), name, stop_node, is_optional, TRUE, data_set); rc_inactive = crm_itoa(EXECRA_NOT_RUNNING); add_hash_param(stopped_mon->meta, XML_ATTR_TE_TARGET_RC, rc_inactive); crm_free(rc_inactive); probe_complete_ops = find_actions(data_set->actions, CRM_OP_PROBED, NULL); for (local_gIter = probe_complete_ops; local_gIter != NULL; local_gIter = local_gIter->next) { action_t *probe_complete = (action_t *) local_gIter->data; if (probe_complete->node == NULL) { if (is_set(probe_complete->flags, pe_action_optional) == FALSE) { probe_is_optional = FALSE; } if (is_set(probe_complete->flags, pe_action_runnable) == FALSE) { crm_debug("%s\t %s (cancelled : probe un-runnable)", crm_str(stop_node_uname), stopped_mon->uuid); update_action_flags(stopped_mon, pe_action_runnable | pe_action_clear); } if (is_set(rsc->flags, pe_rsc_managed)) { custom_action_order(NULL, NULL, probe_complete, NULL, crm_strdup(key), stopped_mon, pe_order_optional, data_set); } break; } } if (probe_complete_ops) { g_list_free(probe_complete_ops); } stop_op_key = stop_key(rsc); stop_ops = find_actions_exact(rsc->actions, stop_op_key, stop_node); for (local_gIter = stop_ops; local_gIter != NULL; local_gIter = local_gIter->next) { action_t *stop = (action_t *) local_gIter->data; if (is_set(stop->flags, pe_action_optional) == FALSE) { stop_is_optional = FALSE; } if (is_set(stop->flags, pe_action_runnable) == FALSE) { crm_debug("%s\t %s (cancelled : stop un-runnable)", crm_str(stop_node_uname), stopped_mon->uuid); update_action_flags(stopped_mon, pe_action_runnable | pe_action_clear); } if (is_set(rsc->flags, pe_rsc_managed)) { custom_action_order(rsc, crm_strdup(stop_op_key), stop, NULL, crm_strdup(key), stopped_mon, pe_order_implies_then | pe_order_runnable_left, data_set); } } if (stop_ops) { g_list_free(stop_ops); } crm_free(stop_op_key); if (is_optional == FALSE && probe_is_optional && stop_is_optional && is_set(rsc->flags, pe_rsc_managed) == FALSE) { crm_trace("Marking %s optional on %s due to unmanaged", key, crm_str(stop_node_uname)); update_action_flags(stopped_mon, pe_action_optional); } if (is_set(stopped_mon->flags, pe_action_optional)) { crm_trace("%s\t %s (optional)", crm_str(stop_node_uname), stopped_mon->uuid); } if (stop_node->details->online == FALSE || stop_node->details->unclean) { crm_debug("%s\t %s (cancelled : no node available)", crm_str(stop_node_uname), stopped_mon->uuid); update_action_flags(stopped_mon, pe_action_runnable | pe_action_clear); } if (is_set(stopped_mon->flags, pe_action_runnable) && is_set(stopped_mon->flags, pe_action_optional) == FALSE) { crm_notice(" Start recurring %s (%llus) for %s on %s", stopped_mon->task, interval_ms / 1000, rsc->id, crm_str(stop_node_uname)); } } crm_free(key); } void Recurring_Stopped(resource_t * rsc, action_t * start, node_t * node, pe_working_set_t * data_set) { if (is_not_set(data_set->flags, pe_flag_maintenance_mode)) { xmlNode *operation = NULL; for (operation = __xml_first_child(rsc->ops_xml); operation != NULL; operation = __xml_next(operation)) { if (crm_str_eq((const char *)operation->name, "op", TRUE)) { RecurringOp_Stopped(rsc, start, node, operation, data_set); } } } } void native_create_actions(resource_t * rsc, pe_working_set_t * data_set) { action_t *start = NULL; node_t *chosen = NULL; + node_t *current = NULL; + gboolean need_stop = FALSE; + GListPtr gIter = NULL; int num_active_nodes = g_list_length(rsc->running_on); enum rsc_role_e role = RSC_ROLE_UNKNOWN; enum rsc_role_e next_role = RSC_ROLE_UNKNOWN; - crm_trace("Createing actions for %s: %s->%s", rsc->id, - role2text(rsc->role), role2text(rsc->next_role)); - chosen = rsc->allocated_to; if (chosen != NULL && rsc->next_role == RSC_ROLE_UNKNOWN) { rsc->next_role = RSC_ROLE_STARTED; + crm_trace("Fixed next_role: unknown -> %s", role2text(rsc->next_role)); } else if (rsc->next_role == RSC_ROLE_UNKNOWN) { rsc->next_role = RSC_ROLE_STOPPED; + crm_trace("Fixed next_role: unknown -> %s", role2text(rsc->next_role)); } + crm_trace("Processing state transition for %s: %s->%s", rsc->id, + role2text(rsc->role), role2text(rsc->next_role)); + + if(rsc->running_on) { + current = rsc->running_on->data; + } + get_rsc_attributes(rsc->parameters, rsc, chosen, data_set); for (gIter = rsc->dangling_migrations; gIter != NULL; gIter = gIter->next) { node_t *current = (node_t *) gIter->data; action_t *stop = stop_action(rsc, current, FALSE); set_bit_inplace(stop->flags, pe_action_dangle); crm_trace("Forcing a cleanup of %s on %s", rsc->id, current->details->uname); if (is_set(data_set->flags, pe_flag_remove_after_stop)) { DeleteRsc(rsc, current, FALSE, data_set); } } - if (num_active_nodes == 2 && - chosen && - rsc->partial_migration_target && - (chosen->details == rsc->partial_migration_target->details)) { - - /* Here the chosen node is still the migration target from a partial - * migration. Attempt to continue the migration instead of recovering - * by stopping the resource everywhere and starting it on a single node. */ - crm_trace("Attempting to continue with a partial migration to target %s from %s", - rsc->partial_migration_target->details->id, - rsc->partial_migration_source->details->id); - - NoRoleChange(rsc, - rsc->partial_migration_source, - rsc->partial_migration_target, - data_set); - - } else if (num_active_nodes > 1) { - const char *type = crm_element_value(rsc->xml, XML_ATTR_TYPE); - const char *class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS); - - pe_proc_err("Resource %s (%s::%s) is active on %d nodes %s", - rsc->id, class, type, num_active_nodes, - recovery2text(rsc->recovery_type)); - crm_warn("See %s for more information.", - "http://clusterlabs.org/wiki/FAQ#Resource_is_Too_Active"); + if (num_active_nodes > 1) { - if (rsc->recovery_type == recovery_stop_start) { - if (rsc->role == RSC_ROLE_MASTER) { - DemoteRsc(rsc, NULL, FALSE, data_set); + if (num_active_nodes == 2 + && chosen + && rsc->partial_migration_target + && (chosen->details == rsc->partial_migration_target->details)) { + /* Here the chosen node is still the migration target from a partial + * migration. Attempt to continue the migration instead of recovering + * by stopping the resource everywhere and starting it on a single node. */ + crm_trace("Will attempt to continue with a partial migration to target %s from %s", + rsc->partial_migration_target->details->id, + rsc->partial_migration_source->details->id); + } else { + const char *type = crm_element_value(rsc->xml, XML_ATTR_TYPE); + const char *class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS); + + pe_proc_err("Resource %s (%s::%s) is active on %d nodes %s", + rsc->id, class, type, num_active_nodes, + recovery2text(rsc->recovery_type)); + crm_warn("See %s for more information.", + "http://clusterlabs.org/wiki/FAQ#Resource_is_Too_Active"); + + if (rsc->recovery_type == recovery_stop_start) { + need_stop = TRUE; } - StopRsc(rsc, NULL, FALSE, data_set); - rsc->role = RSC_ROLE_STOPPED; - } - - /* If by chance a partial migration is in process, - * but the migration target is not chosen still, clear all - * partial migration data. */ - rsc->partial_migration_source = rsc->partial_migration_target = NULL; - } else if (rsc->running_on != NULL) { - node_t *current = rsc->running_on->data; + /* If by chance a partial migration is in process, + * but the migration target is not chosen still, clear all + * partial migration data. */ + rsc->partial_migration_source = rsc->partial_migration_target = NULL; + } + } - NoRoleChange(rsc, current, chosen, data_set); + if (is_set(rsc->flags, pe_rsc_start_pending)) { + start = start_action(rsc, chosen, TRUE); + set_bit_inplace(start->flags, pe_action_print_always); + } - } else if (rsc->role == RSC_ROLE_STOPPED && rsc->next_role == RSC_ROLE_STOPPED) { - char *key = start_key(rsc); - GListPtr possible_matches = find_actions(rsc->actions, key, NULL); - GListPtr gIter = NULL; + if(current && chosen && current->details != chosen->details) { + crm_trace("Moving %s", rsc->id); + need_stop = TRUE; - for (gIter = possible_matches; gIter != NULL; gIter = gIter->next) { - action_t *action = (action_t *) gIter->data; + } else if(is_set(rsc->flags, pe_rsc_failed)) { + crm_trace("Recovering %s", rsc->id); + need_stop = TRUE; - update_action_flags(action, pe_action_optional); -/* action->pseudo = TRUE; */ + } else if(rsc->role > RSC_ROLE_STARTED && current != NULL && chosen != NULL) { + /* Recovery of a promoted resource */ + start = start_action(rsc, chosen, TRUE); + if(is_set(start->flags, pe_action_optional) == FALSE) { + crm_trace("Forced start %s", rsc->id); + need_stop = TRUE; } + } - g_list_free(possible_matches); - crm_trace("Stopping a stopped resource"); - crm_free(key); - goto do_recurring; + crm_trace("Creating actions for %s: %s->%s", rsc->id, + role2text(rsc->role), role2text(rsc->next_role)); - } else if (rsc->role != RSC_ROLE_STOPPED) { - /* A cheap trick to account for the fact that Master/Slave groups may not be - * completely running when we set their role to Slave - */ - crm_trace("Resetting %s.role = %s (was %s)", - rsc->id, role2text(RSC_ROLE_STOPPED), role2text(rsc->role)); - rsc->role = RSC_ROLE_STOPPED; + role = rsc->role; + /* Potentiall optional steps on brining the resource down and back up to the same level */ + while (role != RSC_ROLE_STOPPED) { + next_role = rsc_state_matrix[role][RSC_ROLE_STOPPED]; + crm_trace("Down: Executing: %s->%s (%s)%s", role2text(role), role2text(next_role), rsc->id, need_stop?" required":""); + if (rsc_action_matrix[role][next_role] (rsc, current, !need_stop, data_set) == FALSE) { + break; + } + role = next_role; } + while (rsc->role <= rsc->next_role && role != rsc->role) { + next_role = rsc_state_matrix[role][rsc->role]; + crm_trace("Up: Executing: %s->%s (%s)%s", role2text(role), role2text(next_role), rsc->id, need_stop?" required":""); + if (rsc_action_matrix[role][next_role] (rsc, chosen, !need_stop, data_set) == FALSE) { + break; + } + role = next_role; + } role = rsc->role; + /* Required steps from this role to the next */ while (role != rsc->next_role) { next_role = rsc_state_matrix[role][rsc->next_role]; - crm_trace("Executing: %s->%s (%s)", role2text(role), role2text(next_role), rsc->id); + crm_trace("Role: Executing: %s->%s (%s)", role2text(role), role2text(next_role), rsc->id); if (rsc_action_matrix[role][next_role] (rsc, chosen, FALSE, data_set) == FALSE) { break; } role = next_role; } - do_recurring: if (rsc->next_role != RSC_ROLE_STOPPED || is_set(rsc->flags, pe_rsc_managed) == FALSE) { start = start_action(rsc, chosen, TRUE); Recurring(rsc, start, chosen, data_set); Recurring_Stopped(rsc, start, chosen, data_set); } else { Recurring_Stopped(rsc, NULL, NULL, data_set); } } void native_internal_constraints(resource_t * rsc, pe_working_set_t * data_set) { /* This function is on the critical path and worth optimizing as much as possible */ resource_t *top = uber_parent(rsc); int type = pe_order_optional | pe_order_implies_then | pe_order_restart; const char *class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS); custom_action_order(rsc, generate_op_key(rsc->id, RSC_STOP, 0), NULL, rsc, generate_op_key(rsc->id, RSC_START, 0), NULL, type, data_set); if (top->variant == pe_master) { custom_action_order(rsc, generate_op_key(rsc->id, RSC_DEMOTE, 0), NULL, rsc, generate_op_key(rsc->id, RSC_STOP, 0), NULL, pe_order_optional, data_set); custom_action_order(rsc, generate_op_key(rsc->id, RSC_START, 0), NULL, rsc, generate_op_key(rsc->id, RSC_PROMOTE, 0), NULL, pe_order_runnable_left, data_set); } if (is_not_set(rsc->flags, pe_rsc_managed)) { crm_trace("Skipping fencing constraints for unmanaged resource: %s", rsc->id); return; } if (safe_str_neq(class, "stonith")) { action_t *all_stopped = get_pseudo_op(ALL_STOPPED, data_set); custom_action_order(rsc, stop_key(rsc), NULL, NULL, crm_strdup(all_stopped->task), all_stopped, pe_order_implies_then | pe_order_runnable_left, data_set); } if (g_hash_table_size(rsc->utilization) > 0 && safe_str_neq(data_set->placement_strategy, "default")) { GHashTableIter iter; node_t *next = NULL; GListPtr gIter = NULL; crm_trace("Creating utilization constraints for %s - strategy: %s", rsc->id, data_set->placement_strategy); for (gIter = rsc->running_on; gIter != NULL; gIter = gIter->next) { node_t *current = (node_t *) gIter->data; char *load_stopped_task = crm_concat(LOAD_STOPPED, current->details->uname, '_'); action_t *load_stopped = get_pseudo_op(load_stopped_task, data_set); if (load_stopped->node == NULL) { load_stopped->node = node_copy(current); update_action_flags(load_stopped, pe_action_optional | pe_action_clear); } custom_action_order(rsc, stop_key(rsc), NULL, NULL, load_stopped_task, load_stopped, pe_order_load, data_set); } g_hash_table_iter_init(&iter, rsc->allowed_nodes); while (g_hash_table_iter_next(&iter, NULL, (void **)&next)) { char *load_stopped_task = crm_concat(LOAD_STOPPED, next->details->uname, '_'); action_t *load_stopped = get_pseudo_op(load_stopped_task, data_set); if (load_stopped->node == NULL) { load_stopped->node = node_copy(next); update_action_flags(load_stopped, pe_action_optional | pe_action_clear); } custom_action_order(NULL, crm_strdup(load_stopped_task), load_stopped, rsc, start_key(rsc), NULL, pe_order_load, data_set); custom_action_order(NULL, crm_strdup(load_stopped_task), load_stopped, rsc, generate_op_key(rsc->id, RSC_MIGRATE, 0), NULL, pe_order_load, data_set); crm_free(load_stopped_task); } } } void native_rsc_colocation_lh(resource_t * rsc_lh, resource_t * rsc_rh, rsc_colocation_t * constraint) { if (rsc_lh == NULL) { pe_err("rsc_lh was NULL for %s", constraint->id); return; } else if (constraint->rsc_rh == NULL) { pe_err("rsc_rh was NULL for %s", constraint->id); return; } crm_trace("Processing colocation constraint between %s and %s", rsc_lh->id, rsc_rh->id); rsc_rh->cmds->rsc_colocation_rh(rsc_lh, rsc_rh, constraint); } static gboolean filter_colocation_constraint(resource_t * rsc_lh, resource_t * rsc_rh, rsc_colocation_t * constraint) { if (constraint->score == 0) { return FALSE; } if (constraint->score > 0 && constraint->role_lh != RSC_ROLE_UNKNOWN && constraint->role_lh != rsc_lh->next_role) { crm_trace( "LH: Skipping constraint: \"%s\" state filter", role2text(constraint->role_rh)); return FALSE; } if (constraint->score > 0 && constraint->role_rh != RSC_ROLE_UNKNOWN && constraint->role_rh != rsc_rh->next_role) { crm_trace( "RH: Skipping constraint: \"%s\" state filter", role2text(constraint->role_rh)); return FALSE; } if (constraint->score < 0 && constraint->role_lh != RSC_ROLE_UNKNOWN && constraint->role_lh == rsc_lh->next_role) { crm_trace( "LH: Skipping -ve constraint: \"%s\" state filter", role2text(constraint->role_rh)); return FALSE; } if (constraint->score < 0 && constraint->role_rh != RSC_ROLE_UNKNOWN && constraint->role_rh == rsc_rh->next_role) { crm_trace( "RH: Skipping -ve constraint: \"%s\" state filter", role2text(constraint->role_rh)); return FALSE; } return TRUE; } static void colocation_match(resource_t * rsc_lh, resource_t * rsc_rh, rsc_colocation_t * constraint) { const char *tmp = NULL; const char *value = NULL; const char *attribute = "#id"; GHashTable *work = NULL; gboolean do_check = FALSE; GHashTableIter iter; node_t *node = NULL; if (constraint->node_attribute != NULL) { attribute = constraint->node_attribute; } if (rsc_rh->allocated_to) { value = g_hash_table_lookup(rsc_rh->allocated_to->details->attrs, attribute); do_check = TRUE; } else if (constraint->score < 0) { /* nothing to do: * anti-colocation with something thats not running */ return; } work = node_hash_dup(rsc_lh->allowed_nodes); g_hash_table_iter_init(&iter, work); while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) { tmp = g_hash_table_lookup(node->details->attrs, attribute); if (do_check && safe_str_eq(tmp, value)) { if (constraint->score < INFINITY) { crm_trace("%s: %s.%s += %d", constraint->id, rsc_lh->id, node->details->uname, constraint->score); node->weight = merge_weights(constraint->score, node->weight); } } else if (do_check == FALSE || constraint->score >= INFINITY) { crm_trace("%s: %s.%s -= %d (%s)", constraint->id, rsc_lh->id, node->details->uname, constraint->score, do_check ? "failed" : "unallocated"); node->weight = merge_weights(-constraint->score, node->weight); } } if (can_run_any(work) || constraint->score <= -INFINITY || constraint->score >= INFINITY) { g_hash_table_destroy(rsc_lh->allowed_nodes); rsc_lh->allowed_nodes = work; work = NULL; } else { char *score = score2char(constraint->score); crm_info("%s: Rolling back scores from %s (%d, %s)", rsc_lh->id, rsc_rh->id, do_check, score); crm_free(score); } if (work) { g_hash_table_destroy(work); } } void native_rsc_colocation_rh(resource_t * rsc_lh, resource_t * rsc_rh, rsc_colocation_t * constraint) { crm_trace("%sColocating %s with %s (%s, weight=%d)", constraint->score >= 0 ? "" : "Anti-", rsc_lh->id, rsc_rh->id, constraint->id, constraint->score); if (filter_colocation_constraint(rsc_lh, rsc_rh, constraint) == FALSE) { return; } if (is_set(rsc_rh->flags, pe_rsc_provisional)) { return; } else if (is_not_set(rsc_lh->flags, pe_rsc_provisional)) { /* error check */ struct node_shared_s *details_lh; struct node_shared_s *details_rh; if ((constraint->score > -INFINITY) && (constraint->score < INFINITY)) { return; } details_rh = rsc_rh->allocated_to ? rsc_rh->allocated_to->details : NULL; details_lh = rsc_lh->allocated_to ? rsc_lh->allocated_to->details : NULL; if (constraint->score == INFINITY && details_lh != details_rh) { crm_err("%s and %s are both allocated" " but to different nodes: %s vs. %s", rsc_lh->id, rsc_rh->id, details_lh ? details_lh->uname : "n/a", details_rh ? details_rh->uname : "n/a"); } else if (constraint->score == -INFINITY && details_lh == details_rh) { crm_err("%s and %s are both allocated" " but to the SAME node: %s", rsc_lh->id, rsc_rh->id, details_rh ? details_rh->uname : "n/a"); } return; } else { colocation_match(rsc_lh, rsc_rh, constraint); } } static gboolean filter_rsc_ticket(resource_t * rsc_lh, rsc_ticket_t * rsc_ticket) { if (rsc_ticket->role_lh != RSC_ROLE_UNKNOWN && rsc_ticket->role_lh != rsc_lh->role) { crm_trace( "LH: Skipping constraint: \"%s\" state filter", role2text(rsc_ticket->role_lh)); return FALSE; } return TRUE; } void rsc_ticket_constraint(resource_t * rsc_lh, rsc_ticket_t * rsc_ticket, pe_working_set_t * data_set) { if (rsc_ticket == NULL) { pe_err("rsc_ticket was NULL"); return; } if (rsc_lh == NULL) { pe_err("rsc_lh was NULL for %s", rsc_ticket->id); return; } if (rsc_ticket->ticket->granted && rsc_ticket->ticket->standby == FALSE) { return; } if (rsc_lh->children) { GListPtr gIter = rsc_lh->children; crm_trace("Processing ticket dependencies from %s", rsc_lh->id); for (; gIter != NULL; gIter = gIter->next) { resource_t *child_rsc = (resource_t *) gIter->data; rsc_ticket_constraint(child_rsc, rsc_ticket, data_set); } return; } crm_trace("%s: Processing ticket dependency on %s (%s, %s)", rsc_lh->id, rsc_ticket->ticket->id, rsc_ticket->id, role2text(rsc_ticket->role_lh)); if (rsc_ticket->ticket->granted == FALSE && g_list_length(rsc_lh->running_on) > 0) { GListPtr gIter = NULL; switch (rsc_ticket->loss_policy) { case loss_ticket_stop: resource_location(rsc_lh, NULL, -INFINITY, "__loss_of_ticket__", data_set); break; case loss_ticket_demote: /*Promotion score will be set to -INFINITY in master_promotion_order() */ if (rsc_ticket->role_lh != RSC_ROLE_MASTER) { resource_location(rsc_lh, NULL, -INFINITY, "__loss_of_ticket__", data_set); } break; case loss_ticket_fence: if (filter_rsc_ticket(rsc_lh, rsc_ticket) == FALSE) { return; } resource_location(rsc_lh, NULL, -INFINITY, "__loss_of_ticket__", data_set); for (gIter = rsc_lh->running_on; gIter != NULL; gIter = gIter->next) { node_t *node = (node_t *) gIter->data; crm_warn("Node %s will be fenced for deadman", node->details->uname); node->details->unclean = TRUE; } break; case loss_ticket_freeze: if (filter_rsc_ticket(rsc_lh, rsc_ticket) == FALSE) { return; } if (g_list_length(rsc_lh->running_on) > 0) { clear_bit(rsc_lh->flags, pe_rsc_managed); set_bit(rsc_lh->flags, pe_rsc_block); } break; } } else if (rsc_ticket->ticket->granted == FALSE){ if (rsc_ticket->role_lh != RSC_ROLE_MASTER || rsc_ticket->loss_policy == loss_ticket_stop) { resource_location(rsc_lh, NULL, -INFINITY, "__no_ticket__", data_set); } } else if (rsc_ticket->ticket->standby) { if (rsc_ticket->role_lh != RSC_ROLE_MASTER || rsc_ticket->loss_policy == loss_ticket_stop) { resource_location(rsc_lh, NULL, -INFINITY, "__ticket_standby__", data_set); } } } const char *convert_non_atomic_task(char *raw_task, resource_t * rsc, gboolean allow_notify); const char * convert_non_atomic_task(char *raw_task, resource_t * rsc, gboolean allow_notify) { int task = no_action; const char *atomic_task = raw_task; crm_trace("Processing %s for %s", crm_str(raw_task), rsc->id); if (raw_task == NULL) { return NULL; } else if (strstr(raw_task, "notify") != NULL) { goto done; /* no conversion */ } else if (rsc->variant < pe_group) { goto done; /* no conversion */ } task = text2task(raw_task); switch (task) { case stop_rsc: case start_rsc: case action_notify: case action_promote: case action_demote: break; case stopped_rsc: case started_rsc: case action_notified: case action_promoted: case action_demoted: task--; break; case monitor_rsc: case shutdown_crm: case stonith_node: goto done; break; default: crm_trace("Unknown action: %s", raw_task); goto done; break; } if (task != no_action) { if (is_set(rsc->flags, pe_rsc_notify) && allow_notify) { /* atomic_task = generate_notify_key(rid, "confirmed-post", task2text(task+1)); */ crm_err("Not handled"); } else { atomic_task = task2text(task + 1); } crm_trace("Converted %s -> %s", raw_task, atomic_task); } done: return atomic_task; } enum pe_action_flags native_action_flags(action_t * action, node_t * node) { return action->flags; } enum pe_graph_flags native_update_actions(action_t * first, action_t * then, node_t * node, enum pe_action_flags flags, enum pe_action_flags filter, enum pe_ordering type) { enum pe_graph_flags changed = pe_graph_none; enum pe_action_flags then_flags = then->flags; enum pe_action_flags first_flags = first->flags; if (type & pe_order_asymmetrical) { resource_t *then_rsc = then->rsc; enum rsc_role_e then_rsc_role = then_rsc ? then_rsc->fns->state(then_rsc, TRUE) : 0; if (!then_rsc) { /* ignore */ } else if ((then_rsc_role == RSC_ROLE_STOPPED) && safe_str_eq(then->task, RSC_STOP)) { /* ignore... if 'then' is supposed to be stopped after 'first', but * then is already stopped, there is nothing to be done when non-symmetrical. */ } else if ((then_rsc_role == RSC_ROLE_STARTED) && safe_str_eq(then->task, RSC_START)) { /* ignore... if 'then' is supposed to be started after 'first', but * then is already started, there is nothing to be done when non-symmetrical. */ } else if (!(first->flags & pe_action_runnable)) { /* prevent 'then' action from happening if 'first' is not runnable and * 'then' has not yet occurred. */ clear_bit_inplace(then->flags, pe_action_runnable); clear_bit_inplace(then->flags, pe_action_optional); } else { /* ignore... then is allowed to start/stop if it wants to. */ } } if (type & pe_order_implies_first) { if ((filter & pe_action_optional) && (flags & pe_action_optional) == 0) { clear_bit_inplace(first->flags, pe_action_optional); } } if (is_set(type, pe_order_runnable_left) && is_set(filter, pe_action_runnable) && is_set(flags, pe_action_runnable) == FALSE) { clear_bit_inplace(then->flags, pe_action_runnable); } if (is_set(type, pe_order_implies_then) && is_set(filter, pe_action_optional) && is_set(flags, pe_action_optional) == FALSE) { clear_bit_inplace(then->flags, pe_action_optional); } if (is_set(type, pe_order_restart)) { const char *reason = NULL; CRM_ASSERT(first->rsc && first->rsc->variant == pe_native); CRM_ASSERT(then->rsc && then->rsc->variant == pe_native); if ((filter & pe_action_runnable) && (then->flags & pe_action_runnable) == 0) { reason = "shutdown"; } if ((filter & pe_action_optional) && (then->flags & pe_action_optional) == 0) { reason = "recover"; } if (reason && is_set(first->flags, pe_action_optional) && is_set(first->flags, pe_action_runnable)) { crm_trace("Handling %s: %s -> %s", reason, first->uuid, then->uuid); clear_bit_inplace(first->flags, pe_action_optional); } if (reason && is_not_set(first->flags, pe_action_optional) && is_not_set(first->flags, pe_action_runnable)) { crm_trace("Handling %s: %s -> %s", reason, first->uuid, then->uuid); clear_bit_inplace(then->flags, pe_action_runnable); } } if (then_flags != then->flags) { changed |= pe_graph_updated_then; - crm_trace("Then: Flags for %s on %s are now 0x%.6x (were 0x%.6x) because of %s", + crm_trace("Then: Flags for %s on %s are now 0x%.6x (was 0x%.6x) because of %s", then->uuid, then->node ? then->node->details->uname : "[none]", then->flags, then_flags, first->uuid); } if (first_flags != first->flags) { changed |= pe_graph_updated_first; - crm_trace("First: Flags for %s on %s are now 0x%.6x (were 0x%.6x) because of %s", + crm_trace("First: Flags for %s on %s are now 0x%.6x (was 0x%.6x) because of %s", first->uuid, first->node ? first->node->details->uname : "[none]", first->flags, first_flags, then->uuid); } return changed; } void native_rsc_location(resource_t * rsc, rsc_to_node_t * constraint) { GListPtr gIter = NULL; GHashTableIter iter; node_t *node = NULL; if (constraint == NULL) { pe_err("Constraint is NULL"); return; } else if (rsc == NULL) { pe_err("LHS of rsc_to_node (%s) is NULL", constraint->id); return; } crm_trace("Applying %s (%s) to %s", constraint->id, role2text(constraint->role_filter), rsc->id); /* take "lifetime" into account */ if (constraint->role_filter > 0 && constraint->role_filter != rsc->next_role) { crm_debug("Constraint (%s) is not active (role : %s)", constraint->id, role2text(constraint->role_filter)); return; } else if (is_active(constraint) == FALSE) { crm_trace("Constraint (%s) is not active", constraint->id); return; } if (constraint->node_list_rh == NULL) { crm_trace("RHS of constraint %s is NULL", constraint->id); return; } for (gIter = constraint->node_list_rh; gIter != NULL; gIter = gIter->next) { node_t *node = (node_t *) gIter->data; node_t *other_node = NULL; other_node = (node_t *) pe_hash_table_lookup(rsc->allowed_nodes, node->details->id); if (other_node != NULL) { crm_trace("%s + %s: %d + %d", node->details->uname, other_node->details->uname, node->weight, other_node->weight); other_node->weight = merge_weights(other_node->weight, node->weight); } else { node_t *new_node = node_copy(node); g_hash_table_insert(rsc->allowed_nodes, (gpointer) new_node->details->id, new_node); } } g_hash_table_iter_init(&iter, rsc->allowed_nodes); while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) { crm_trace("%s + %s : %d", rsc->id, node->details->uname, node->weight); } } void native_expand(resource_t * rsc, pe_working_set_t * data_set) { GListPtr gIter = NULL; crm_trace("Processing actions from %s", rsc->id); for (gIter = rsc->actions; gIter != NULL; gIter = gIter->next) { action_t *action = (action_t *) gIter->data; crm_trace("processing action %d for rsc=%s", action->id, rsc->id); graph_element_from_action(action, data_set); } for (gIter = rsc->children; gIter != NULL; gIter = gIter->next) { resource_t *child_rsc = (resource_t *) gIter->data; child_rsc->cmds->expand(child_rsc, data_set); } } void #define log_change(fmt, args...) do { \ if(terminal) { \ printf(" * "fmt"\n", ##args); \ } else { \ crm_notice(fmt, ##args); \ } \ } while(0) LogActions(resource_t * rsc, pe_working_set_t * data_set, gboolean terminal) { node_t *next = NULL; node_t *current = NULL; action_t *stop = NULL; action_t *start = NULL; char *key = NULL; gboolean moving = FALSE; GListPtr possible_matches = NULL; if (rsc->children) { GListPtr gIter = NULL; for (gIter = rsc->children; gIter != NULL; gIter = gIter->next) { resource_t *child_rsc = (resource_t *) gIter->data; LogActions(child_rsc, data_set, terminal); } return; } next = rsc->allocated_to; if (rsc->running_on) { current = rsc->running_on->data; if (rsc->role == RSC_ROLE_STOPPED) { /* * This can occur when resources are being recovered * We fiddle with the current role in native_create_actions() */ rsc->role = RSC_ROLE_STARTED; } } if (current == NULL && is_set(rsc->flags, pe_rsc_orphan)) { /* Don't log stopped orphans */ return; } if (is_not_set(rsc->flags, pe_rsc_managed) || (current == NULL && next == NULL)) { crm_info("Leave %s\t(%s%s)", rsc->id, role2text(rsc->role), is_not_set(rsc->flags, pe_rsc_managed) ? " unmanaged" : ""); return; } if (current != NULL && next != NULL && safe_str_neq(current->details->id, next->details->id)) { moving = TRUE; } key = stop_key(rsc); possible_matches = find_actions(rsc->actions, key, next); crm_free(key); if (possible_matches) { stop = possible_matches->data; g_list_free(possible_matches); } key = start_key(rsc); possible_matches = find_actions(rsc->actions, key, next); crm_free(key); if (possible_matches) { start = possible_matches->data; g_list_free(possible_matches); } if (rsc->role == rsc->next_role) { key = generate_op_key(rsc->id, RSC_MIGRATED, 0); possible_matches = find_actions(rsc->actions, key, next); crm_free(key); CRM_CHECK(next != NULL,); if (next == NULL) { } else if (possible_matches && current) { log_change("Migrate %s\t(%s %s -> %s)", rsc->id, role2text(rsc->role), current->details->uname, next->details->uname); g_list_free(possible_matches); } else if(is_set(rsc->flags, pe_rsc_reload)) { log_change("Reload %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else if (start == NULL || is_set(start->flags, pe_action_optional)) { crm_info("Leave %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else if (moving && current) { log_change("Move %s\t(%s %s -> %s)", rsc->id, role2text(rsc->role), current->details->uname, next->details->uname); } else if (is_set(rsc->flags, pe_rsc_failed)) { log_change("Recover %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else if (start && is_set(start->flags, pe_action_runnable) == FALSE) { log_change("Stop %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else { log_change("Restart %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } return; } if (rsc->role > RSC_ROLE_SLAVE && rsc->role > rsc->next_role) { CRM_CHECK(current != NULL,); if (current != NULL) { log_change("Demote %s\t(%s -> %s %s)", rsc->id, role2text(rsc->role), role2text(rsc->next_role), current->details->uname); if (stop != NULL && is_not_set(stop->flags, pe_action_optional) && rsc->next_role > RSC_ROLE_STOPPED) { if (is_set(rsc->flags, pe_rsc_failed)) { log_change("Recover %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else if(is_set(rsc->flags, pe_rsc_reload)) { log_change("Reload %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else { log_change("Restart %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } } } } else if (rsc->next_role == RSC_ROLE_STOPPED) { GListPtr gIter = NULL; CRM_CHECK(current != NULL,); for (gIter = rsc->running_on; gIter != NULL; gIter = gIter->next) { node_t *node = (node_t *) gIter->data; log_change("Stop %s\t(%s)", rsc->id, node->details->uname); } } if (moving) { log_change("Move %s\t(%s %s -> %s)", rsc->id, role2text(rsc->next_role), current->details->uname, next->details->uname); } if (rsc->role == RSC_ROLE_STOPPED) { gboolean allowed = FALSE; if(start && (start->flags & pe_action_runnable)) { allowed = TRUE; } CRM_CHECK(next != NULL,); if (next != NULL) { log_change("Start %s\t(%s%s)", rsc->id, next->details->uname, allowed?"":" - blocked"); } if(allowed == FALSE) { return; } } if (rsc->next_role > RSC_ROLE_SLAVE && rsc->role < rsc->next_role) { CRM_CHECK(next != NULL,); if (stop != NULL && is_not_set(stop->flags, pe_action_optional) && rsc->role > RSC_ROLE_STOPPED) { if (is_set(rsc->flags, pe_rsc_failed)) { log_change("Recover %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else if(is_set(rsc->flags, pe_rsc_reload)) { log_change("Reload %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else { log_change("Restart %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } } log_change("Promote %s\t(%s -> %s %s)", rsc->id, role2text(rsc->role), role2text(rsc->next_role), next->details->uname); } } -void -NoRoleChange(resource_t * rsc, node_t * current, node_t * next, pe_working_set_t * data_set) -{ - GListPtr gIter = NULL; - action_t *stop = NULL; - action_t *start = NULL; - GListPtr possible_matches = NULL; - - crm_trace("Executing: %s (role=%s)", rsc->id, role2text(rsc->next_role)); - - if (current == NULL || next == NULL) { - return; - } - - if (is_set(rsc->flags, pe_rsc_failed) - || safe_str_neq(current->details->id, next->details->id)) { - - if (rsc->next_role > RSC_ROLE_STARTED) { - gboolean optional = TRUE; - - if (rsc->role == RSC_ROLE_MASTER) { - optional = FALSE; - } - DemoteRsc(rsc, current, optional, data_set); - } - if (rsc->role == RSC_ROLE_MASTER) { - DemoteRsc(rsc, current, FALSE, data_set); - } - StopRsc(rsc, current, FALSE, data_set); - StartRsc(rsc, next, FALSE, data_set); - if (rsc->next_role == RSC_ROLE_MASTER) { - PromoteRsc(rsc, next, FALSE, data_set); - } - - possible_matches = find_recurring_actions(rsc->actions, next); - for (gIter = possible_matches; gIter != NULL; gIter = gIter->next) { - action_t *match = (action_t *) gIter->data; - - if (is_set(match->flags, pe_action_optional) == FALSE) { - crm_debug("Fixing recurring action: %s", match->uuid); - update_action_flags(match, pe_action_optional); - } - } - g_list_free(possible_matches); - - } else if (is_set(rsc->flags, pe_rsc_start_pending)) { - start = start_action(rsc, next, TRUE); - if (is_set(start->flags, pe_action_runnable)) { - /* wait for StartRsc() to be called */ - rsc->role = RSC_ROLE_STOPPED; - } else { - /* wait for StopRsc() to be called */ - rsc->next_role = RSC_ROLE_STOPPED; - } - - } else { - stop = stop_action(rsc, current, TRUE); - start = start_action(rsc, next, TRUE); - if (is_set(start->flags, pe_action_optional)) { - update_action_flags(stop, pe_action_optional); - } else { - update_action_flags(stop, pe_action_optional | pe_action_clear); - } - if (rsc->next_role > RSC_ROLE_STARTED) { - DemoteRsc(rsc, current, is_set(start->flags, pe_action_optional), data_set); - } - StopRsc(rsc, current, is_set(start->flags, pe_action_optional), data_set); - StartRsc(rsc, current, is_set(start->flags, pe_action_optional), data_set); - if (rsc->next_role == RSC_ROLE_MASTER) { - PromoteRsc(rsc, next, is_set(start->flags, pe_action_optional), data_set); - } - - if (is_set(start->flags, pe_action_runnable) == FALSE) { - rsc->next_role = RSC_ROLE_STOPPED; - } - } -} - gboolean StopRsc(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set) { GListPtr gIter = NULL; const char *class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS); - crm_trace("Executing: %s", rsc->id); + crm_trace("%s", rsc->id); if (rsc->next_role == RSC_ROLE_STOPPED && rsc->variant == pe_native && safe_str_eq(class, "stonith")) { action_t *all_stopped = get_pseudo_op(ALL_STOPPED, data_set); custom_action_order(NULL, crm_strdup(all_stopped->task), all_stopped, rsc, stop_key(rsc), NULL, pe_order_optional | pe_order_stonith_stop, data_set); } for (gIter = rsc->running_on; gIter != NULL; gIter = gIter->next) { node_t *current = (node_t *) gIter->data; action_t *stop; - if (next && next->details != current->details) { - continue; + if (rsc->partial_migration_target) { + if(rsc->partial_migration_target->details == current->details) { + crm_trace("Filtered %s -> %s %s", current->details->uname, next->details->uname, rsc->id); + continue; + } else { + crm_trace("Forced on %s %s", current->details->uname, rsc->id); + optional = FALSE; + } } + crm_trace("%s on %s", rsc->id, current->details->uname); stop = stop_action(rsc, current, optional); + if(is_not_set(rsc->flags, pe_rsc_managed)) { update_action_flags(stop, pe_action_runnable|pe_action_clear); } if (is_set(data_set->flags, pe_flag_remove_after_stop)) { DeleteRsc(rsc, current, optional, data_set); } } return TRUE; } gboolean StartRsc(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set) { action_t *start = NULL; - crm_trace("Executing: %s", rsc->id); + crm_trace("%s on %s", rsc->id, next?next->details->uname:"N/A"); start = start_action(rsc, next, TRUE); if (is_set(start->flags, pe_action_runnable) && optional == FALSE) { update_action_flags(start, pe_action_optional | pe_action_clear); } return TRUE; } gboolean PromoteRsc(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set) { char *key = NULL; GListPtr gIter = NULL; gboolean runnable = TRUE; GListPtr action_list = NULL; - crm_trace("Executing: %s", rsc->id); - - CRM_CHECK(rsc->next_role == RSC_ROLE_MASTER, - crm_err("Next role: %s", role2text(rsc->next_role)); return FALSE); + crm_trace("%s on %s", rsc->id, next?next->details->uname:"N/A"); CRM_CHECK(next != NULL, return FALSE); key = start_key(rsc); action_list = find_actions_exact(rsc->actions, key, next); crm_free(key); for (gIter = action_list; gIter != NULL; gIter = gIter->next) { action_t *start = (action_t *) gIter->data; if (is_set(start->flags, pe_action_runnable) == FALSE) { runnable = FALSE; } } g_list_free(action_list); if (runnable) { promote_action(rsc, next, optional); return TRUE; } crm_debug("%s\tPromote %s (canceled)", next->details->uname, rsc->id); key = promote_key(rsc); action_list = find_actions_exact(rsc->actions, key, next); crm_free(key); for (gIter = action_list; gIter != NULL; gIter = gIter->next) { action_t *promote = (action_t *) gIter->data; update_action_flags(promote, pe_action_runnable | pe_action_clear); } g_list_free(action_list); return TRUE; } gboolean DemoteRsc(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set) { GListPtr gIter = NULL; - crm_trace("Executing: %s", rsc->id); + crm_trace("%s", rsc->id); /* CRM_CHECK(rsc->next_role == RSC_ROLE_SLAVE, return FALSE); */ for (gIter = rsc->running_on; gIter != NULL; gIter = gIter->next) { node_t *current = (node_t *) gIter->data; + crm_trace("%s on %s", rsc->id, next?next->details->uname:"N/A"); demote_action(rsc, current, optional); } return TRUE; } gboolean RoleError(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set) { - crm_debug("Executing: %s", rsc->id); + crm_err("%s on %s", rsc->id, next?next->details->uname:"N/A"); CRM_CHECK(FALSE, return FALSE); return FALSE; } gboolean NullOp(resource_t * rsc, node_t * next, gboolean optional, pe_working_set_t * data_set) { - crm_trace("Executing: %s", rsc->id); + crm_trace("%s", rsc->id); return FALSE; } gboolean DeleteRsc(resource_t * rsc, node_t * node, gboolean optional, pe_working_set_t * data_set) { action_t *delete = NULL; #if DELETE_THEN_REFRESH action_t *refresh = NULL; #endif if (is_set(rsc->flags, pe_rsc_failed)) { crm_trace("Resource %s not deleted from %s: failed", rsc->id, node->details->uname); return FALSE; } else if (node == NULL) { crm_trace("Resource %s not deleted: NULL node", rsc->id); return FALSE; } else if (node->details->unclean || node->details->online == FALSE) { crm_trace("Resource %s not deleted from %s: unrunnable", rsc->id, node->details->uname); return FALSE; } crm_notice("Removing %s from %s", rsc->id, node->details->uname); delete = delete_action(rsc, node, optional); new_rsc_order(rsc, RSC_STOP, rsc, RSC_DELETE, optional ? pe_order_implies_then : pe_order_optional, data_set); new_rsc_order(rsc, RSC_DELETE, rsc, RSC_START, optional ? pe_order_implies_then : pe_order_optional, data_set); #if DELETE_THEN_REFRESH refresh = custom_action(NULL, crm_strdup(CRM_OP_LRM_REFRESH), CRM_OP_LRM_REFRESH, node, FALSE, TRUE, data_set); add_hash_param(refresh->meta, XML_ATTR_TE_NOWAIT, XML_BOOLEAN_TRUE); order_actions(delete, refresh, pe_order_optional); #endif return TRUE; } #include <../lib/pengine/unpack.h> static node_t * probe_grouped_clone(resource_t * rsc, node_t * node, pe_working_set_t * data_set) { node_t *running = NULL; resource_t *top = uber_parent(rsc); if (running == NULL && is_set(top->flags, pe_rsc_unique) == FALSE) { /* Annoyingly we also need to check any other clone instances * Clumsy, but it will work. * * An alternative would be to update known_on for every peer * during process_rsc_state() * * This code desperately needs optimization * ptest -x with 100 nodes, 100 clones and clone-max=10: * No probes O(25s) * Detection without clone loop O(3m) * Detection with clone loop O(8m) ptest[32211]: 2010/02/18_14:27:55 CRIT: stage5: Probing for unknown resources ptest[32211]: 2010/02/18_14:33:39 CRIT: stage5: Done ptest[32211]: 2010/02/18_14:35:05 CRIT: stage7: Updating action states ptest[32211]: 2010/02/18_14:35:05 CRIT: stage7: Done */ char *clone_id = clone_zero(rsc->id); resource_t *peer = pe_find_resource(top->children, clone_id); while (peer && running == NULL) { running = pe_hash_table_lookup(peer->known_on, node->details->id); if (running != NULL) { /* we already know the status of the resource on this node */ crm_trace("Skipping active clone: %s", rsc->id); crm_free(clone_id); return running; } clone_id = increment_clone(clone_id); peer = pe_find_resource(data_set->resources, clone_id); } crm_free(clone_id); } return running; } gboolean native_create_probe(resource_t * rsc, node_t * node, action_t * complete, gboolean force, pe_working_set_t * data_set) { char *key = NULL; action_t *probe = NULL; node_t *running = NULL; resource_t *top = uber_parent(rsc); static const char *rc_master = NULL; static const char *rc_inactive = NULL; if (rc_inactive == NULL) { rc_inactive = crm_itoa(EXECRA_NOT_RUNNING); rc_master = crm_itoa(EXECRA_RUNNING_MASTER); } CRM_CHECK(node != NULL, return FALSE); if (force == FALSE && is_not_set(data_set->flags, pe_flag_startup_probes)) { crm_trace("Skipping active resource detection for %s", rsc->id); return FALSE; } if (rsc->children) { GListPtr gIter = NULL; gboolean any_created = FALSE; for (gIter = rsc->children; gIter != NULL; gIter = gIter->next) { resource_t *child_rsc = (resource_t *) gIter->data; any_created = child_rsc->cmds->create_probe(child_rsc, node, complete, force, data_set) || any_created; } return any_created; } if (is_set(rsc->flags, pe_rsc_orphan)) { crm_trace("Skipping orphan: %s", rsc->id); return FALSE; } running = g_hash_table_lookup(rsc->known_on, node->details->id); if (running == NULL && is_set(rsc->flags, pe_rsc_unique) == FALSE) { /* Anonymous clones */ if (rsc->parent == top) { running = g_hash_table_lookup(rsc->parent->known_on, node->details->id); } else { /* Grouped anonymous clones need extra special handling */ running = probe_grouped_clone(rsc, node, data_set); } } if (force == FALSE && running != NULL) { /* we already know the status of the resource on this node */ crm_trace("Skipping active: %s", rsc->id); return FALSE; } key = generate_op_key(rsc->id, RSC_STATUS, 0); probe = custom_action(rsc, key, RSC_STATUS, node, FALSE, TRUE, data_set); update_action_flags(probe, pe_action_optional | pe_action_clear); /* * We need to know if it's running_on (not just known_on) this node * to correctly determine the target rc. */ running = pe_find_node_id(rsc->running_on, node->details->id); if (running == NULL) { add_hash_param(probe->meta, XML_ATTR_TE_TARGET_RC, rc_inactive); } else if (rsc->role == RSC_ROLE_MASTER) { add_hash_param(probe->meta, XML_ATTR_TE_TARGET_RC, rc_master); } crm_debug("Probing %s on %s (%s)", rsc->id, node->details->uname, role2text(rsc->role)); order_actions(probe, complete, pe_order_implies_then); return TRUE; } static void native_start_constraints(resource_t * rsc, action_t * stonith_op, gboolean is_stonith, pe_working_set_t * data_set) { node_t *target = stonith_op ? stonith_op->node : NULL; if (is_stonith) { char *key = start_key(rsc); action_t *ready = get_pseudo_op(STONITH_UP, data_set); crm_trace("Ordering %s action before stonith events", key); custom_action_order(rsc, key, NULL, NULL, crm_strdup(ready->task), ready, pe_order_optional | pe_order_implies_then, data_set); } else { GListPtr gIter = NULL; action_t *all_stopped = get_pseudo_op(ALL_STOPPED, data_set); action_t *stonith_done = get_pseudo_op(STONITH_DONE, data_set); for (gIter = rsc->actions; gIter != NULL; gIter = gIter->next) { action_t *action = (action_t *) gIter->data; if (action->needs == rsc_req_stonith) { order_actions(stonith_done, action, pe_order_optional); } else if (target != NULL && safe_str_eq(action->task, RSC_START) && NULL == pe_hash_table_lookup(rsc->known_on, target->details->id)) { /* if known == NULL, then we dont know if * the resource is active on the node * we're about to shoot * * in this case, regardless of action->needs, * the only safe option is to wait until * the node is shot before doing anything * to with the resource * * its analogous to waiting for all the probes * for rscX to complete before starting rscX * * the most likely explaination is that the * DC died and took its status with it */ crm_debug("Ordering %s after %s recovery", action->uuid, target->details->uname); order_actions(all_stopped, action, pe_order_optional | pe_order_runnable_left); } } } } static void native_stop_constraints(resource_t * rsc, action_t * stonith_op, gboolean is_stonith, pe_working_set_t * data_set) { char *key = NULL; GListPtr gIter = NULL; GListPtr action_list = NULL; resource_t *top = uber_parent(rsc); key = stop_key(rsc); action_list = find_actions(rsc->actions, key, stonith_op->node); crm_free(key); /* add the stonith OP as a stop pre-req and the mark the stop * as a pseudo op - since its now redundant */ for (gIter = action_list; gIter != NULL; gIter = gIter->next) { action_t *action = (action_t *) gIter->data; if (action->node->details->online && action->node->details->unclean == FALSE && is_set(rsc->flags, pe_rsc_failed)) { continue; } if (is_set(rsc->flags, pe_rsc_failed)) { crm_notice("Stop of failed resource %s is" " implicit after %s is fenced", rsc->id, action->node->details->uname); } else { crm_info("%s is implicit after %s is fenced", action->uuid, action->node->details->uname); } /* the stop would never complete and is * now implied by the stonith operation */ update_action_flags(action, pe_action_pseudo); update_action_flags(action, pe_action_runnable); update_action_flags(action, pe_action_implied_by_stonith); if (is_stonith == FALSE) { action_t *parent_stop = find_first_action(top->actions, NULL, RSC_STOP, NULL); order_actions(stonith_op, action, pe_order_optional); order_actions(stonith_op, parent_stop, pe_order_optional); } if (is_set(rsc->flags, pe_rsc_notify)) { /* Create a second notification that will be delivered * immediately after the node is fenced * * Basic problem: * - C is a clone active on the node to be shot and stopping on another * - R is a resource that depends on C * * + C.stop depends on R.stop * + C.stopped depends on STONITH * + C.notify depends on C.stopped * + C.healthy depends on C.notify * + R.stop depends on C.healthy * * The extra notification here changes * + C.healthy depends on C.notify * into: * + C.healthy depends on C.notify' * + C.notify' depends on STONITH' * thus breaking the loop */ notify_data_t *n_data = create_notification_boundaries(rsc, RSC_STOP, NULL, stonith_op, data_set); crm_info("Creating secondary notification for %s", action->uuid); collect_notification_data(rsc, TRUE, FALSE, n_data); g_hash_table_insert(n_data->keys, crm_strdup("notify_stop_resource"), crm_strdup(rsc->id)); g_hash_table_insert(n_data->keys, crm_strdup("notify_stop_uname"), crm_strdup(action->node->details->uname)); create_notifications(uber_parent(rsc), n_data, data_set); free_notification_data(n_data); } /* From Bug #1601, successful fencing must be an input to a failed resources stop action. However given group(rA, rB) running on nodeX and B.stop has failed, A := stop healthy resource (rA.stop) B := stop failed resource (pseudo operation B.stop) C := stonith nodeX A requires B, B requires C, C requires A This loop would prevent the cluster from making progress. This block creates the "C requires A" dependency and therefore must (at least for now) be disabled. Instead, run the block above and treat all resources on nodeX as B would be (marked as a pseudo op depending on the STONITH). TODO: Break the "A requires B" dependency in update_action() and re-enable this block } else if(is_stonith == FALSE) { crm_info("Moving healthy resource %s" " off %s before fencing", rsc->id, node->details->uname); * stop healthy resources before the * stonith op * custom_action_order( rsc, stop_key(rsc), NULL, NULL,crm_strdup(CRM_OP_FENCE),stonith_op, pe_order_optional, data_set); */ } g_list_free(action_list); key = demote_key(rsc); action_list = find_actions(rsc->actions, key, stonith_op->node); crm_free(key); for (gIter = action_list; gIter != NULL; gIter = gIter->next) { action_t *action = (action_t *) gIter->data; if (action->node->details->online == FALSE || action->node->details->unclean == TRUE || is_set(rsc->flags, pe_rsc_failed)) { if (is_set(rsc->flags, pe_rsc_failed)) { crm_info("Demote of failed resource %s is" " implict after %s is fenced", rsc->id, action->node->details->uname); } else { crm_info("%s is implicit after %s is fenced", action->uuid, action->node->details->uname); } /* the stop would never complete and is * now implied by the stonith operation */ crm_trace("here - 1"); update_action_flags(action, pe_action_pseudo); update_action_flags(action, pe_action_runnable); if (is_stonith == FALSE) { order_actions(stonith_op, action, pe_order_optional); } } } g_list_free(action_list); } void rsc_stonith_ordering(resource_t * rsc, action_t * stonith_op, pe_working_set_t * data_set) { gboolean is_stonith = FALSE; const char *class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS); if (rsc->children) { GListPtr gIter = NULL; for (gIter = rsc->children; gIter != NULL; gIter = gIter->next) { resource_t *child_rsc = (resource_t *) gIter->data; rsc_stonith_ordering(child_rsc, stonith_op, data_set); } return; } if (is_not_set(rsc->flags, pe_rsc_managed)) { crm_trace("Skipping fencing constraints for unmanaged resource: %s", rsc->id); return; } if (stonith_op != NULL && safe_str_eq(class, "stonith")) { is_stonith = TRUE; } /* Start constraints */ native_start_constraints(rsc, stonith_op, is_stonith, data_set); /* Stop constraints */ native_stop_constraints(rsc, stonith_op, is_stonith, data_set); } enum stack_activity { stack_stable = 0, stack_starting = 1, stack_stopping = 2, stack_middle = 4, }; static enum stack_activity find_clone_activity_on(resource_t * rsc, resource_t * target, node_t * node, const char *type) { int mode = stack_stable; action_t *active = NULL; if (target->children) { GListPtr gIter = NULL; for (gIter = target->children; gIter != NULL; gIter = gIter->next) { resource_t *child = (resource_t *) gIter->data; mode |= find_clone_activity_on(rsc, child, node, type); } return mode; } active = find_first_action(target->actions, NULL, RSC_START, NULL); if (active && is_set(active->flags, pe_action_optional) == FALSE && is_set(active->flags, pe_action_pseudo) == FALSE) { crm_debug("%s: found scheduled %s action (%s)", rsc->id, active->uuid, type); mode |= stack_starting; } active = find_first_action(target->actions, NULL, RSC_STOP, node); if (active && is_set(active->flags, pe_action_optional) == FALSE && is_set(active->flags, pe_action_pseudo) == FALSE) { crm_debug("%s: found scheduled %s action (%s)", rsc->id, active->uuid, type); mode |= stack_stopping; } return mode; } static enum stack_activity check_stack_element(resource_t * rsc, resource_t * other_rsc, const char *type) { resource_t *other_p = uber_parent(other_rsc); if (other_rsc == NULL || other_rsc == rsc) { return stack_stable; } else if (other_p->variant == pe_native) { crm_notice("Cannot migrate %s due to dependency on %s (%s)", rsc->id, other_rsc->id, type); return stack_middle; } else if (other_rsc == rsc->parent) { int mode = 0; GListPtr gIter = NULL; for (gIter = other_rsc->rsc_cons; gIter != NULL; gIter = gIter->next) { rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data; if (constraint->score > 0) { mode |= check_stack_element(rsc, constraint->rsc_rh, type); } } return mode; } else if (other_p->variant == pe_group) { crm_notice("Cannot migrate %s due to dependency on group %s (%s)", rsc->id, other_rsc->id, type); return stack_middle; } /* else: >= clone */ /* ## Assumption A depends on clone(B) ## Resource Activity During Move N1 N2 N3 --- --- --- t0 A.stop t1 B.stop B.stop t2 B.start B.start t3 A.start ## Resource Activity During Migration N1 N2 N3 --- --- --- t0 B.start B.start t1 A.stop (1) t2 A.start (2) t3 B.stop B.stop Node 1: Rewritten to be a migrate-to operation Node 2: Rewritten to be a migrate-from operation # Constraints The following constraints already exist in the system. The 'ok' and 'fail' column refers to whether they still hold for migration. a) A.stop -> A.start - ok b) B.stop -> B.start - fail c) A.stop -> B.stop - ok d) B.start -> A.start - ok e) B.stop -> A.start - fail f) A.stop -> B.start - fail ## Scenarios B unchanged - ok B stopping only - fail - possible after fixing 'e' B starting only - fail - possible after fixing 'f' B stoping and starting - fail - constraint 'b' is unfixable B restarting only on N2 - fail - as-per previous only rarer */ /* Only allow migration when the clone is either stable, only starting or only stopping */ return find_clone_activity_on(rsc, other_rsc, NULL, type); } static gboolean at_stack_bottom(resource_t * rsc) { char *key = NULL; action_t *start = NULL; action_t *other = NULL; int mode = stack_stable; GListPtr action_list = NULL; GListPtr gIter = NULL; key = start_key(rsc); action_list = find_actions(rsc->actions, key, NULL); crm_free(key); crm_trace("%s: processing", rsc->id); CRM_CHECK(action_list != NULL, return FALSE); start = action_list->data; g_list_free(action_list); for (gIter = rsc->rsc_cons; gIter != NULL; gIter = gIter->next) { rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data; resource_t *target = constraint->rsc_rh; crm_trace("Checking %s: %s == %s (%d)", constraint->id, rsc->id, target->id, constraint->score); if (constraint->score > 0) { mode |= check_stack_element(rsc, target, "coloc"); if (mode & stack_middle) { return FALSE; } else if ((mode & stack_stopping) && (mode & stack_starting)) { crm_notice("Cannot migrate %s due to colocation activity (last was %s)", rsc->id, target->id); return FALSE; } } } for (gIter = start->actions_before; gIter != NULL; gIter = gIter->next) { action_wrapper_t *other_w = (action_wrapper_t *) gIter->data; other = other_w->action; if (other_w->type & pe_order_serialize_only) { crm_trace("%s: depends on %s (serialize ordering)", rsc->id, other->uuid); continue; } crm_trace("%s: Checking %s ordering", rsc->id, other->uuid); if (is_set(other->flags, pe_action_optional) == FALSE) { mode |= check_stack_element(rsc, other->rsc, "order"); if (mode & stack_middle) { return FALSE; } else if ((mode & stack_stopping) && (mode & stack_starting)) { crm_notice("Cannot migrate %s due to ordering activity (last was %s)", rsc->id, other->rsc->id); return FALSE; } } } return TRUE; } static action_t * get_first_named_action(resource_t *rsc, const char *action, gboolean only_valid, node_t *current) { action_t *a = NULL; GListPtr action_list = NULL; char *key = generate_op_key(rsc->id, action, 0); action_list = find_actions(rsc->actions, key, current); crm_free(key); if (action_list == NULL || action_list->data == NULL) { crm_trace("%s: no %s action", rsc->id, action); return NULL; } a = action_list->data; g_list_free(action_list); if(only_valid && is_set(a->flags, pe_action_pseudo)) { crm_trace("%s: pseudo", key); return NULL; } else if(only_valid && is_not_set(a->flags, pe_action_runnable)) { crm_trace("%s: runnable", key); return NULL; } return a; } static void MigrateRsc(resource_t * rsc, action_t *stop, action_t *start, pe_working_set_t * data_set, gboolean partial) { action_t *to = NULL; action_t *from = NULL; action_t *then = NULL; action_t *other = NULL; action_t *done = get_pseudo_op(STONITH_DONE, data_set); GListPtr gIter = NULL; const char *value = g_hash_table_lookup(rsc->meta, XML_OP_ATTR_ALLOW_MIGRATE); + crm_trace("%s %s -> %s", rsc->id, stop->node->details->uname, start->node->details->uname); if (crm_is_true(value) == FALSE) { return; } if (rsc->next_role > RSC_ROLE_SLAVE) { crm_trace("%s: resource role: role=%s", rsc->id, role2text(rsc->next_role)); return; } if(start == NULL || stop == NULL) { crm_trace("%s: not exists %p -> %p", rsc->id, stop, start); return; } else if (start->node == NULL || stop->node == NULL) { crm_trace("%s: no node %p -> %p", rsc->id, stop->node, start->node); return; } else if(is_set(stop->flags, pe_action_optional)) { crm_trace("%s: stop action", rsc->id); return; } else if(is_set(start->flags, pe_action_optional)) { crm_trace("%s: start action", rsc->id); return; } else if (stop->node->details == start->node->details) { crm_trace("%s: not moving %p -> %p", rsc->id, stop->node, start->node); return; } else if (at_stack_bottom(rsc) == FALSE) { crm_trace("%s: not at stack bottom", rsc->id); return; } if (partial) { crm_info("Completing partial migration from %s to %s", rsc->id, stop->node ? stop->node->details->uname : "unknown", start->node ? start->node->details->uname : "unknown"); } else { crm_info("Migrating %s from %s to %s", rsc->id, stop->node ? stop->node->details->uname : "unknown", start->node ? start->node->details->uname : "unknown"); } /* Preserve the stop to ensure the end state is sane on that node, * Make the start a pseudo op * Create migrate_to, have it depend on everything the stop did * Create migrate_from * *-> migrate_to -> migrate_from -> stop -> start */ update_action_flags(start, pe_action_pseudo); /* easier than trying to delete it from the graph * but perhaps we should have it run anyway */ if (!partial) { to = custom_action(rsc, generate_op_key(rsc->id, RSC_MIGRATE, 0), RSC_MIGRATE, stop->node, FALSE, TRUE, data_set); } from = custom_action(rsc, generate_op_key(rsc->id, RSC_MIGRATED, 0), RSC_MIGRATED, start->node, FALSE, TRUE, data_set); /* This is slightly sub-optimal if 'to' fails, but always * run both halves of the migration before terminating the * transition. * * This can be removed if/when we update unpack_rsc_op() to * 'correctly' handle partial migrations. * * Without this, we end up stopping both sides */ from->priority = INFINITY; if (!partial) { order_actions(to, from, pe_order_optional); add_hash_param(to->meta, XML_LRM_ATTR_MIGRATE_SOURCE, stop->node->details->uname); add_hash_param(to->meta, XML_LRM_ATTR_MIGRATE_TARGET, start->node->details->uname); } then = to ? to : from; order_actions(from, stop, pe_order_optional); order_actions(done, then, pe_order_optional); add_hash_param(from->meta, XML_LRM_ATTR_MIGRATE_SOURCE, stop->node->details->uname); add_hash_param(from->meta, XML_LRM_ATTR_MIGRATE_TARGET, start->node->details->uname); /* Create the correct ordering ajustments based on find_clone_activity_on(); */ for (gIter = rsc->rsc_cons; gIter != NULL; gIter = gIter->next) { rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data; resource_t *target = constraint->rsc_rh; crm_info("Repairing %s: %s == %s (%d)", constraint->id, rsc->id, target->id, constraint->score); if (constraint->score > 0) { int mode = check_stack_element(rsc, target, "coloc"); action_t *clone_stop = find_first_action(target->actions, NULL, RSC_STOP, NULL); action_t *clone_start = find_first_action(target->actions, NULL, RSC_STARTED, NULL); CRM_ASSERT(clone_stop != NULL); CRM_ASSERT(clone_start != NULL); CRM_ASSERT((mode & stack_middle) == 0); CRM_ASSERT(((mode & stack_stopping) && (mode & stack_starting)) == 0); if (mode & stack_stopping) { #if 0 crm_debug("Creating %s.start -> %s.stop ordering", rsc->id, target->id); order_actions(from, clone_stop, pe_order_optional); #endif GListPtr lpc2 = NULL; for (lpc2 = start->actions_before; lpc2 != NULL; lpc2 = lpc2->next) { action_wrapper_t *other_w = (action_wrapper_t *) lpc2->data; /* Needed if the clone's started pseudo-action ever gets printed in the graph */ if (other_w->action == clone_start) { crm_debug("Breaking %s -> %s ordering", other_w->action->uuid, start->uuid); other_w->type = pe_order_none; } } } else if (mode & stack_starting) { #if 0 crm_debug("Creating %s.started -> %s.stop ordering", target->id, rsc->id); order_actions(clone_start, to, pe_order_optional); #endif GListPtr lpc2 = NULL; for (lpc2 = clone_stop->actions_before; lpc2 != NULL; lpc2 = lpc2->next) { action_wrapper_t *other_w = (action_wrapper_t *) lpc2->data; /* Needed if the clone's stop pseudo-action ever gets printed in the graph */ if (other_w->action == stop) { crm_debug("Breaking %s -> %s ordering", other_w->action->uuid, clone_stop->uuid); other_w->type = pe_order_none; } } } } } #if 0 /* Implied now that start/stop are not morphed into migrate ops */ /* Anything that needed stop to complete, now also needs start to have completed */ for (gIter = stop->actions_after; gIter != NULL; gIter = gIter->next) { action_wrapper_t *other_w = (action_wrapper_t *) gIter->data; other = other_w->action; if (is_set(other->flags, pe_action_optional) || other->rsc != NULL) { continue; } crm_debug("Ordering %s before %s (stop)", from->uuid, other->uuid); order_actions(from, other, other_w->type); } #endif /* migrate 'then' action also needs anything that the stop needed to have completed too */ for (gIter = stop->actions_before; gIter != NULL; gIter = gIter->next) { action_wrapper_t *other_w = (action_wrapper_t *) gIter->data; other = other_w->action; if (other->rsc == NULL) { /* nothing */ } else if (is_set(other->flags, pe_action_optional) || other->rsc == rsc || other->rsc == rsc->parent) { continue; } crm_debug("Ordering %s before %s (stop)", other_w->action->uuid, stop->uuid); order_actions(other, then, other_w->type); } /* migrate 'then' action also needs anything that the start needed to have completed too */ for (gIter = start->actions_before; gIter != NULL; gIter = gIter->next) { action_wrapper_t *other_w = (action_wrapper_t *) gIter->data; other = other_w->action; if (other->rsc == NULL) { /* nothing */ } else if (is_set(other->flags, pe_action_optional) || other->rsc == rsc || other->rsc == rsc->parent) { continue; } crm_debug("Ordering %s before %s (start)", other_w->action->uuid, stop->uuid); order_actions(other, then, other_w->type); } } static void ReloadRsc(resource_t * rsc, action_t *stop, action_t *start, pe_working_set_t * data_set) { action_t *action = NULL; action_t *rewrite = NULL; if(is_not_set(rsc->flags, pe_rsc_try_reload)) { return; } else if(is_not_set(stop->flags, pe_action_optional)) { crm_trace("%s: stop action", rsc->id); return; } else if(is_not_set(start->flags, pe_action_optional)) { crm_trace("%s: start action", rsc->id); return; } + crm_trace("%s on %s", rsc->id, stop->node->details->uname); + action = get_first_named_action(rsc, RSC_PROMOTE, TRUE, NULL); if (action && is_set(action->flags, pe_action_optional) == FALSE) { update_action_flags(action, pe_action_pseudo); } action = get_first_named_action(rsc, RSC_DEMOTE, TRUE, NULL); if (action && is_set(action->flags, pe_action_optional) == FALSE) { rewrite = action; update_action_flags(stop, pe_action_pseudo); } else { rewrite = start; } crm_info("Rewriting %s of %s on %s as a reload", rewrite->task, rsc->id, stop->node->details->uname); set_bit(rsc->flags, pe_rsc_reload); update_action_flags(rewrite, pe_action_optional|pe_action_clear); crm_free(rewrite->uuid); crm_free(rewrite->task); rewrite->task = crm_strdup("reload"); rewrite->uuid = generate_op_key(rsc->id, rewrite->task, 0); } void rsc_migrate_reload(resource_t * rsc, pe_working_set_t * data_set) { GListPtr gIter = NULL; action_t *stop = NULL; action_t *start = NULL; gboolean partial = FALSE; if (rsc->children) { for (gIter = rsc->children; gIter != NULL; gIter = gIter->next) { resource_t *child_rsc = (resource_t *) gIter->data; rsc_migrate_reload(child_rsc, data_set); } return; } else if (rsc->variant > pe_native) { return; } crm_trace("Processing %s", rsc->id); if (rsc->partial_migration_target) { start = get_first_named_action(rsc, RSC_START, TRUE, rsc->partial_migration_target); stop = get_first_named_action(rsc, RSC_STOP, TRUE, rsc->partial_migration_source); if (start && stop) { partial = TRUE; } } + crm_trace("%s %s %p", rsc->id, partial?"partial":"full", stop); + if (!partial) { stop = get_first_named_action(rsc, RSC_STOP, TRUE, rsc->running_on ? rsc->running_on->data : NULL); start = get_first_named_action(rsc, RSC_START, TRUE, NULL); } if (is_not_set(rsc->flags, pe_rsc_managed) || is_set(rsc->flags, pe_rsc_failed) || is_set(rsc->flags, pe_rsc_start_pending) || rsc->next_role < RSC_ROLE_STARTED || ((g_list_length(rsc->running_on) != 1) && !partial)) { crm_trace("%s: general resource state: flags=0x%.16llx", rsc->id, rsc->flags); return; } if(stop == NULL) { return; } else if (is_set(stop->flags, pe_action_optional) && is_set(rsc->flags, pe_rsc_try_reload)) { ReloadRsc(rsc, stop, start, data_set); } else if(is_not_set(stop->flags, pe_action_optional)) { MigrateRsc(rsc, stop, start, data_set, partial); } } void native_append_meta(resource_t * rsc, xmlNode * xml) { char *value = g_hash_table_lookup(rsc->meta, XML_RSC_ATTR_INCARNATION); if (value) { char *name = NULL; name = crm_meta_name(XML_RSC_ATTR_INCARNATION); crm_xml_add(xml, name, value); crm_free(name); } } diff --git a/pengine/test10/696.exp b/pengine/test10/696.exp index a118f89864..648b7b565c 100644 --- a/pengine/test10/696.exp +++ b/pengine/test10/696.exp @@ -1,413 +1,413 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/726.exp b/pengine/test10/726.exp index bf48e6111c..f00ed4e498 100644 --- a/pengine/test10/726.exp +++ b/pengine/test10/726.exp @@ -1,692 +1,692 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/735.exp b/pengine/test10/735.exp index f4471e0058..fe01364f1e 100644 --- a/pengine/test10/735.exp +++ b/pengine/test10/735.exp @@ -1,229 +1,229 @@ - + - + - + - + - + - + diff --git a/pengine/test10/764.dot b/pengine/test10/764.dot index 15aa9ebcce..3a9929e740 100644 --- a/pengine/test10/764.dot +++ b/pengine/test10/764.dot @@ -1,56 +1,66 @@ digraph "g" { "DcIPaddr_monitor_0 posic041" -> "probe_complete posic041" [ style = bold] "DcIPaddr_monitor_0 posic041" [ style=bold color="green" fontcolor="black" ] +"DcIPaddr_monitor_5000 posic043" [ style=dashed color="red" fontcolor="black"] +"DcIPaddr_start_0 posic043" -> "DcIPaddr_monitor_5000 posic043" [ style = dashed] "DcIPaddr_start_0 posic043" [ style=dashed color="red" fontcolor="black" ] "DcIPaddr_stop_0 posic043" -> "DcIPaddr_start_0 posic043" [ style = dashed] "DcIPaddr_stop_0 posic043" -> "all_stopped" [ style = bold] "DcIPaddr_stop_0 posic043" [ style=bold color="green" fontcolor="black" ] "all_stopped" [ style=bold color="green" fontcolor="orange" ] "child_DoFencing:0_monitor_5000 posic043" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 posic043" -> "probe_complete posic043" [ style = bold] "child_DoFencing:1_monitor_0 posic043" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_5000 posic041" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 posic041" -> "probe_complete posic041" [ style = bold] "child_DoFencing:2_monitor_0 posic041" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 posic041" -> "probe_complete posic041" [ style = bold] "child_DoFencing:3_monitor_0 posic041" [ style=bold color="green" fontcolor="black" ] "probe_complete posic041" -> "probe_complete" [ style = bold] "probe_complete posic041" [ style=bold color="green" fontcolor="black" ] "probe_complete posic043" -> "probe_complete" [ style = bold] "probe_complete posic043" [ style=bold color="green" fontcolor="black" ] "probe_complete" -> "DcIPaddr_start_0 posic043" [ style = dashed] "probe_complete" -> "DcIPaddr_stop_0 posic043" [ style = bold] "probe_complete" -> "rsc_posic041_start_0 posic041" [ style = dashed] "probe_complete" -> "rsc_posic041_stop_0 posic041" [ style = bold] "probe_complete" -> "rsc_posic042_start_0 posic041" [ style = dashed] "probe_complete" -> "rsc_posic042_stop_0 posic041" [ style = bold] "probe_complete" -> "rsc_posic043_start_0 posic043" [ style = dashed] "probe_complete" -> "rsc_posic043_stop_0 posic043" [ style = bold] "probe_complete" -> "rsc_posic044_start_0 posic041" [ style = dashed] "probe_complete" -> "rsc_posic044_stop_0 posic041" [ style = bold] "probe_complete" [ style=bold color="green" fontcolor="orange" ] "rsc_posic041_monitor_0 posic043" -> "probe_complete posic043" [ style = bold] "rsc_posic041_monitor_0 posic043" [ style=bold color="green" fontcolor="black" ] +"rsc_posic041_monitor_5000 posic041" [ style=dashed color="red" fontcolor="black"] +"rsc_posic041_start_0 posic041" -> "rsc_posic041_monitor_5000 posic041" [ style = dashed] "rsc_posic041_start_0 posic041" [ style=dashed color="red" fontcolor="black" ] "rsc_posic041_stop_0 posic041" -> "all_stopped" [ style = bold] "rsc_posic041_stop_0 posic041" -> "rsc_posic041_start_0 posic041" [ style = dashed] "rsc_posic041_stop_0 posic041" [ style=bold color="green" fontcolor="black" ] "rsc_posic042_monitor_0 posic043" -> "probe_complete posic043" [ style = bold] "rsc_posic042_monitor_0 posic043" [ style=bold color="green" fontcolor="black" ] +"rsc_posic042_monitor_5000 posic041" [ style=dashed color="red" fontcolor="black"] +"rsc_posic042_start_0 posic041" -> "rsc_posic042_monitor_5000 posic041" [ style = dashed] "rsc_posic042_start_0 posic041" [ style=dashed color="red" fontcolor="black" ] "rsc_posic042_stop_0 posic041" -> "all_stopped" [ style = bold] "rsc_posic042_stop_0 posic041" -> "rsc_posic042_start_0 posic041" [ style = dashed] "rsc_posic042_stop_0 posic041" [ style=bold color="green" fontcolor="black" ] "rsc_posic043_monitor_0 posic041" -> "probe_complete posic041" [ style = bold] "rsc_posic043_monitor_0 posic041" [ style=bold color="green" fontcolor="black" ] +"rsc_posic043_monitor_5000 posic043" [ style=dashed color="red" fontcolor="black"] +"rsc_posic043_start_0 posic043" -> "rsc_posic043_monitor_5000 posic043" [ style = dashed] "rsc_posic043_start_0 posic043" [ style=dashed color="red" fontcolor="black" ] "rsc_posic043_stop_0 posic043" -> "all_stopped" [ style = bold] "rsc_posic043_stop_0 posic043" -> "rsc_posic043_start_0 posic043" [ style = dashed] "rsc_posic043_stop_0 posic043" [ style=bold color="green" fontcolor="black" ] "rsc_posic044_monitor_0 posic043" -> "probe_complete posic043" [ style = bold] "rsc_posic044_monitor_0 posic043" [ style=bold color="green" fontcolor="black" ] +"rsc_posic044_monitor_5000 posic041" [ style=dashed color="red" fontcolor="black"] +"rsc_posic044_start_0 posic041" -> "rsc_posic044_monitor_5000 posic041" [ style = dashed] "rsc_posic044_start_0 posic041" [ style=dashed color="red" fontcolor="black" ] "rsc_posic044_stop_0 posic041" -> "all_stopped" [ style = bold] "rsc_posic044_stop_0 posic041" -> "rsc_posic044_start_0 posic041" [ style = dashed] "rsc_posic044_stop_0 posic041" [ style=bold color="green" fontcolor="black" ] } diff --git a/pengine/test10/764.exp b/pengine/test10/764.exp index f0a0e03011..510912a7f2 100644 --- a/pengine/test10/764.exp +++ b/pengine/test10/764.exp @@ -1,239 +1,239 @@ - + - + - + - + - + - + diff --git a/pengine/test10/797.dot b/pengine/test10/797.dot index 67d100e09d..514dfddd86 100644 --- a/pengine/test10/797.dot +++ b/pengine/test10/797.dot @@ -1,107 +1,113 @@ digraph "g" { "DcIPaddr_delete_0 c001n03" -> "DcIPaddr_start_0 c001n03" [ style = dashed] "DcIPaddr_delete_0 c001n03" -> "lrm_refresh c001n03" [ style = bold] "DcIPaddr_delete_0 c001n03" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "DcIPaddr_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "DcIPaddr_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] +"DcIPaddr_monitor_5000 c001n03" [ style=dashed color="red" fontcolor="black"] +"DcIPaddr_start_0 c001n03" -> "DcIPaddr_monitor_5000 c001n03" [ style = dashed] "DcIPaddr_start_0 c001n03" [ style=dashed color="red" fontcolor="black" ] "DcIPaddr_stop_0 c001n03" -> "DcIPaddr_delete_0 c001n03" [ style = bold] "DcIPaddr_stop_0 c001n03" -> "DcIPaddr_start_0 c001n03" [ style = dashed] "DcIPaddr_stop_0 c001n03" -> "all_stopped" [ style = bold] "DcIPaddr_stop_0 c001n03" [ style=bold color="green" fontcolor="black" ] "DoFencing_running_0" [ style=bold color="green" fontcolor="orange" ] "DoFencing_start_0" -> "DoFencing_running_0" [ style = bold] "DoFencing_start_0" -> "child_DoFencing:0_start_0 c001n01" [ style = bold] "DoFencing_start_0" [ style=bold color="green" fontcolor="orange" ] "DoFencing_stop_0" -> "DoFencing_stopped_0" [ style = bold] "DoFencing_stop_0" -> "child_DoFencing:0_stop_0 c001n01" [ style = bold] "DoFencing_stop_0" -> "child_DoFencing:0_stop_0 c001n03" [ style = bold] "DoFencing_stop_0" -> "child_DoFencing:1_stop_0 c001n02" [ style = bold] "DoFencing_stop_0" [ style=bold color="green" fontcolor="orange" ] "DoFencing_stopped_0" -> "DoFencing_start_0" [ style = bold] "DoFencing_stopped_0" [ style=bold color="green" fontcolor="orange" ] "all_stopped" -> "child_DoFencing:1_stop_0 c001n02" [ style = bold] "all_stopped" [ style=bold color="green" fontcolor="orange" ] "child_DoFencing:0_monitor_5000 c001n01" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_start_0 c001n01" -> "DoFencing_running_0" [ style = bold] "child_DoFencing:0_start_0 c001n01" -> "child_DoFencing:0_monitor_5000 c001n01" [ style = bold] "child_DoFencing:0_start_0 c001n01" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_stop_0 c001n01" -> "DoFencing_stopped_0" [ style = bold] "child_DoFencing:0_stop_0 c001n01" -> "child_DoFencing:0_start_0 c001n01" [ style = bold] "child_DoFencing:0_stop_0 c001n01" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_stop_0 c001n03" -> "DoFencing_stopped_0" [ style = bold] "child_DoFencing:0_stop_0 c001n03" -> "child_DoFencing:0_start_0 c001n01" [ style = bold] "child_DoFencing:0_stop_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_stop_0 c001n02" -> "DoFencing_stopped_0" [ style = bold] "child_DoFencing:1_stop_0 c001n02" -> "do_shutdown c001n02" [ style = bold] "child_DoFencing:1_stop_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "child_DoFencing:2_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "child_DoFencing:3_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:3_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:3_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "do_shutdown c001n02" [ style=bold color="green" fontcolor="black" ] "lrm_refresh c001n03" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n01" -> "probe_complete" [ style = bold] "probe_complete c001n01" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n02" -> "probe_complete" [ style = bold] "probe_complete c001n02" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n03" -> "probe_complete" [ style = bold] "probe_complete c001n03" [ style=bold color="green" fontcolor="black" ] "probe_complete" -> "DcIPaddr_start_0 c001n03" [ style = dashed] "probe_complete" -> "DcIPaddr_stop_0 c001n03" [ style = bold] "probe_complete" -> "child_DoFencing:0_start_0 c001n01" [ style = bold] "probe_complete" -> "child_DoFencing:0_stop_0 c001n01" [ style = bold] "probe_complete" -> "child_DoFencing:0_stop_0 c001n03" [ style = bold] "probe_complete" -> "child_DoFencing:1_stop_0 c001n02" [ style = bold] "probe_complete" -> "rsc_c001n01_start_0 c001n01" [ style = dashed] "probe_complete" -> "rsc_c001n01_stop_0 c001n01" [ style = bold] "probe_complete" -> "rsc_c001n02_start_0 c001n01" [ style = dashed] "probe_complete" -> "rsc_c001n02_stop_0 c001n02" [ style = bold] "probe_complete" -> "rsc_c001n03_start_0 c001n03" [ style = dashed] "probe_complete" -> "rsc_c001n03_stop_0 c001n03" [ style = bold] "probe_complete" -> "rsc_c001n08_start_0 c001n01" [ style = dashed] "probe_complete" -> "rsc_c001n08_stop_0 c001n02" [ style = bold] "probe_complete" [ style=bold color="green" fontcolor="orange" ] "rsc_c001n01_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n01_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] +"rsc_c001n01_monitor_5000 c001n01" [ style=dashed color="red" fontcolor="black"] +"rsc_c001n01_start_0 c001n01" -> "rsc_c001n01_monitor_5000 c001n01" [ style = dashed] "rsc_c001n01_start_0 c001n01" [ style=dashed color="red" fontcolor="black" ] "rsc_c001n01_stop_0 c001n01" -> "all_stopped" [ style = bold] "rsc_c001n01_stop_0 c001n01" -> "rsc_c001n01_start_0 c001n01" [ style = dashed] "rsc_c001n01_stop_0 c001n01" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "rsc_c001n02_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n02_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_5000 c001n01" [ style=dashed color="red" fontcolor="black" ] "rsc_c001n02_start_0 c001n01" -> "rsc_c001n02_monitor_5000 c001n01" [ style = dashed] "rsc_c001n02_start_0 c001n01" [ style=dashed color="red" fontcolor="black" ] "rsc_c001n02_stop_0 c001n02" -> "all_stopped" [ style = bold] "rsc_c001n02_stop_0 c001n02" -> "do_shutdown c001n02" [ style = bold] "rsc_c001n02_stop_0 c001n02" -> "rsc_c001n02_start_0 c001n01" [ style = dashed] "rsc_c001n02_stop_0 c001n02" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "rsc_c001n03_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "rsc_c001n03_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] +"rsc_c001n03_monitor_5000 c001n03" [ style=dashed color="red" fontcolor="black"] +"rsc_c001n03_start_0 c001n03" -> "rsc_c001n03_monitor_5000 c001n03" [ style = dashed] "rsc_c001n03_start_0 c001n03" [ style=dashed color="red" fontcolor="black" ] "rsc_c001n03_stop_0 c001n03" -> "all_stopped" [ style = bold] "rsc_c001n03_stop_0 c001n03" -> "rsc_c001n03_start_0 c001n03" [ style = dashed] "rsc_c001n03_stop_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "rsc_c001n08_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n08_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_5000 c001n01" [ style=dashed color="red" fontcolor="black" ] "rsc_c001n08_start_0 c001n01" -> "rsc_c001n08_monitor_5000 c001n01" [ style = dashed] "rsc_c001n08_start_0 c001n01" [ style=dashed color="red" fontcolor="black" ] "rsc_c001n08_stop_0 c001n02" -> "all_stopped" [ style = bold] "rsc_c001n08_stop_0 c001n02" -> "do_shutdown c001n02" [ style = bold] "rsc_c001n08_stop_0 c001n02" -> "rsc_c001n08_start_0 c001n01" [ style = dashed] "rsc_c001n08_stop_0 c001n02" [ style=bold color="green" fontcolor="black" ] } diff --git a/pengine/test10/asymmetric.exp b/pengine/test10/asymmetric.exp index 6f3b2d6761..6ad2fab014 100644 --- a/pengine/test10/asymmetric.exp +++ b/pengine/test10/asymmetric.exp @@ -1,78 +1,78 @@ - + diff --git a/pengine/test10/bug-1572-1.exp b/pengine/test10/bug-1572-1.exp index 9720d07638..ad63df1f78 100644 --- a/pengine/test10/bug-1572-1.exp +++ b/pengine/test10/bug-1572-1.exp @@ -1,791 +1,791 @@ - + - + - + + + + - + - - - - + - + - + - + - + diff --git a/pengine/test10/bug-1572-2.exp b/pengine/test10/bug-1572-2.exp index 633d6298a0..3ec0480769 100644 --- a/pengine/test10/bug-1572-2.exp +++ b/pengine/test10/bug-1572-2.exp @@ -1,409 +1,409 @@ - + - + diff --git a/pengine/test10/bug-1685.exp b/pengine/test10/bug-1685.exp index 3eb8f13b89..d185efa18e 100644 --- a/pengine/test10/bug-1685.exp +++ b/pengine/test10/bug-1685.exp @@ -1,190 +1,190 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/bug-1822.exp b/pengine/test10/bug-1822.exp index 745f411ece..3cc06e4f01 100644 --- a/pengine/test10/bug-1822.exp +++ b/pengine/test10/bug-1822.exp @@ -1,198 +1,198 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/bug-5007-masterslave_colocation.exp b/pengine/test10/bug-5007-masterslave_colocation.exp index 7e0264a042..012ad83690 100644 --- a/pengine/test10/bug-5007-masterslave_colocation.exp +++ b/pengine/test10/bug-5007-masterslave_colocation.exp @@ -1,62 +1,62 @@ - + - + - + - + - + - + - + - + diff --git a/pengine/test10/bug-lf-2317.exp b/pengine/test10/bug-lf-2317.exp index dba13e9b61..4b24c48c4e 100644 --- a/pengine/test10/bug-lf-2317.exp +++ b/pengine/test10/bug-lf-2317.exp @@ -1,179 +1,179 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/bug-lf-2544.exp b/pengine/test10/bug-lf-2544.exp index 2b17ce5e03..4568cb4b1d 100644 --- a/pengine/test10/bug-lf-2544.exp +++ b/pengine/test10/bug-lf-2544.exp @@ -1,36 +1,36 @@ - + - + - + - + - + diff --git a/pengine/test10/bug-lf-2606.exp b/pengine/test10/bug-lf-2606.exp index f3ad56da8b..929312cc97 100644 --- a/pengine/test10/bug-lf-2606.exp +++ b/pengine/test10/bug-lf-2606.exp @@ -1,218 +1,218 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/bug-pm-11.exp b/pengine/test10/bug-pm-11.exp index 77d47af4de..a4c4fb9c2d 100644 --- a/pengine/test10/bug-pm-11.exp +++ b/pengine/test10/bug-pm-11.exp @@ -1,260 +1,260 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/bug-pm-12.dot b/pengine/test10/bug-pm-12.dot index f0146c972a..a0d7bb686e 100644 --- a/pengine/test10/bug-pm-12.dot +++ b/pengine/test10/bug-pm-12.dot @@ -1,83 +1,75 @@ digraph "g" { "all_stopped" [ style=bold color="green" fontcolor="orange" ] -"group:0_demote_0" -> "stateful-2:0_demote_0 node-b" [ style = bold] -"group:0_demote_0" [ style=bold color="green" fontcolor="orange" ] -"group:0_demoted_0" -> "ms-sf_demoted_0" [ style = bold] -"group:0_demoted_0" [ style=bold color="green" fontcolor="orange" ] "group:0_running_0" -> "ms-sf_running_0" [ style = bold] "group:0_running_0" [ style=bold color="green" fontcolor="orange" ] "group:0_start_0" -> "group:0_running_0" [ style = bold] "group:0_start_0" -> "stateful-2:0_start_0 node-b" [ style = bold] "group:0_start_0" [ style=bold color="green" fontcolor="orange" ] "group:0_stop_0" -> "group:0_stopped_0" [ style = bold] "group:0_stop_0" -> "stateful-2:0_stop_0 node-b" [ style = bold] "group:0_stop_0" [ style=bold color="green" fontcolor="orange" ] "group:0_stopped_0" -> "group:0_start_0" [ style = bold] "group:0_stopped_0" -> "ms-sf_stopped_0" [ style = bold] "group:0_stopped_0" [ style=bold color="green" fontcolor="orange" ] "group:1_demote_0" -> "group:1_promote_0" [ style = bold] "group:1_demote_0" -> "stateful-2:1_demote_0 node-a" [ style = bold] "group:1_demote_0" [ style=bold color="green" fontcolor="orange" ] "group:1_demoted_0" -> "ms-sf_demoted_0" [ style = bold] "group:1_demoted_0" [ style=bold color="green" fontcolor="orange" ] "group:1_promote_0" -> "stateful-2:1_promote_0 node-a" [ style = bold] "group:1_promote_0" [ style=bold color="green" fontcolor="orange" ] "group:1_promoted_0" -> "ms-sf_promoted_0" [ style = bold] "group:1_promoted_0" [ style=bold color="green" fontcolor="orange" ] "group:1_running_0" -> "ms-sf_running_0" [ style = bold] "group:1_running_0" [ style=bold color="green" fontcolor="orange" ] "group:1_start_0" -> "group:1_running_0" [ style = bold] "group:1_start_0" -> "stateful-2:1_start_0 node-a" [ style = bold] "group:1_start_0" [ style=bold color="green" fontcolor="orange" ] "group:1_stop_0" -> "group:1_stopped_0" [ style = bold] "group:1_stop_0" -> "stateful-2:1_stop_0 node-a" [ style = bold] "group:1_stop_0" [ style=bold color="green" fontcolor="orange" ] "group:1_stopped_0" -> "group:1_start_0" [ style = bold] "group:1_stopped_0" -> "ms-sf_stopped_0" [ style = bold] "group:1_stopped_0" [ style=bold color="green" fontcolor="orange" ] -"ms-sf_demote_0" -> "group:0_demote_0" [ style = bold] "ms-sf_demote_0" -> "group:1_demote_0" [ style = bold] "ms-sf_demote_0" -> "ms-sf_demoted_0" [ style = bold] "ms-sf_demote_0" [ style=bold color="green" fontcolor="orange" ] "ms-sf_demoted_0" -> "ms-sf_promote_0" [ style = bold] "ms-sf_demoted_0" -> "ms-sf_start_0" [ style = bold] "ms-sf_demoted_0" -> "ms-sf_stop_0" [ style = bold] "ms-sf_demoted_0" [ style=bold color="green" fontcolor="orange" ] "ms-sf_promote_0" -> "group:1_promote_0" [ style = bold] "ms-sf_promote_0" [ style=bold color="green" fontcolor="orange" ] "ms-sf_promoted_0" [ style=bold color="green" fontcolor="orange" ] "ms-sf_running_0" -> "ms-sf_promote_0" [ style = bold] "ms-sf_running_0" [ style=bold color="green" fontcolor="orange" ] "ms-sf_start_0" -> "group:0_start_0" [ style = bold] "ms-sf_start_0" -> "group:1_start_0" [ style = bold] "ms-sf_start_0" -> "ms-sf_running_0" [ style = bold] "ms-sf_start_0" [ style=bold color="green" fontcolor="orange" ] "ms-sf_stop_0" -> "group:0_stop_0" [ style = bold] "ms-sf_stop_0" -> "group:1_stop_0" [ style = bold] "ms-sf_stop_0" -> "ms-sf_stopped_0" [ style = bold] "ms-sf_stop_0" [ style=bold color="green" fontcolor="orange" ] "ms-sf_stopped_0" -> "ms-sf_promote_0" [ style = bold] "ms-sf_stopped_0" -> "ms-sf_start_0" [ style = bold] "ms-sf_stopped_0" [ style=bold color="green" fontcolor="orange" ] -"stateful-2:0_demote_0 node-b" -> "group:0_demoted_0" [ style = bold] -"stateful-2:0_demote_0 node-b" -> "stateful-2:0_stop_0 node-b" [ style = bold] -"stateful-2:0_demote_0 node-b" [ style=bold color="green" fontcolor="black" ] "stateful-2:0_start_0 node-b" -> "group:0_running_0" [ style = bold] "stateful-2:0_start_0 node-b" [ style=bold color="green" fontcolor="black" ] "stateful-2:0_stop_0 node-b" -> "all_stopped" [ style = bold] "stateful-2:0_stop_0 node-b" -> "group:0_stopped_0" [ style = bold] "stateful-2:0_stop_0 node-b" -> "stateful-2:0_start_0 node-b" [ style = bold] "stateful-2:0_stop_0 node-b" [ style=bold color="green" fontcolor="black" ] "stateful-2:1_demote_0 node-a" -> "group:1_demoted_0" [ style = bold] "stateful-2:1_demote_0 node-a" -> "stateful-2:1_stop_0 node-a" [ style = bold] "stateful-2:1_demote_0 node-a" [ style=bold color="green" fontcolor="black" ] "stateful-2:1_promote_0 node-a" -> "group:1_promoted_0" [ style = bold] "stateful-2:1_promote_0 node-a" [ style=bold color="green" fontcolor="black" ] "stateful-2:1_start_0 node-a" -> "group:1_running_0" [ style = bold] "stateful-2:1_start_0 node-a" -> "stateful-2:1_promote_0 node-a" [ style = bold] "stateful-2:1_start_0 node-a" [ style=bold color="green" fontcolor="black" ] "stateful-2:1_stop_0 node-a" -> "all_stopped" [ style = bold] "stateful-2:1_stop_0 node-a" -> "group:1_stopped_0" [ style = bold] "stateful-2:1_stop_0 node-a" -> "stateful-2:1_start_0 node-a" [ style = bold] "stateful-2:1_stop_0 node-a" [ style=bold color="green" fontcolor="black" ] } diff --git a/pengine/test10/bug-pm-12.exp b/pengine/test10/bug-pm-12.exp index c345559d41..8ff18fcd98 100644 --- a/pengine/test10/bug-pm-12.exp +++ b/pengine/test10/bug-pm-12.exp @@ -1,432 +1,389 @@ - + - + - - - - - - - - - - + - + - + - - - - + - + - - - - - - - - - - - - - + - + - + - + - - - - + - - - - - - - - - - - + - + - + - - - - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + + + + - + - + - - - - + - + - + - + - + - + - + - - - - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/coloc-clone-stays-active.exp b/pengine/test10/coloc-clone-stays-active.exp index e3a43ff764..a97fcfd91b 100644 --- a/pengine/test10/coloc-clone-stays-active.exp +++ b/pengine/test10/coloc-clone-stays-active.exp @@ -1,75 +1,75 @@ - + - + - + - + - + - + diff --git a/pengine/test10/coloc-slave-anti.exp b/pengine/test10/coloc-slave-anti.exp index 716a806aa4..2e0113189f 100644 --- a/pengine/test10/coloc-slave-anti.exp +++ b/pengine/test10/coloc-slave-anti.exp @@ -1,116 +1,116 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-12.exp b/pengine/test10/master-12.exp index f0edbc24cd..3dfb793c98 100644 --- a/pengine/test10/master-12.exp +++ b/pengine/test10/master-12.exp @@ -1,36 +1,36 @@ - + - + - + - + - + diff --git a/pengine/test10/master-13.exp b/pengine/test10/master-13.exp index 68e1e88612..1b52afb28b 100644 --- a/pengine/test10/master-13.exp +++ b/pengine/test10/master-13.exp @@ -1,443 +1,443 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-4.exp b/pengine/test10/master-4.exp index 13adfb9a73..9dd80f5abf 100644 --- a/pengine/test10/master-4.exp +++ b/pengine/test10/master-4.exp @@ -1,442 +1,442 @@ - + - + - + - + - + - + - + diff --git a/pengine/test10/master-7.exp b/pengine/test10/master-7.exp index 09646ad7f7..372535b294 100644 --- a/pengine/test10/master-7.exp +++ b/pengine/test10/master-7.exp @@ -1,777 +1,777 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-8.exp b/pengine/test10/master-8.exp index be7c86a18d..10ee340ce8 100644 --- a/pengine/test10/master-8.exp +++ b/pengine/test10/master-8.exp @@ -1,833 +1,833 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-colocation.exp b/pengine/test10/master-colocation.exp index 7b9560bdab..18a9498227 100644 --- a/pengine/test10/master-colocation.exp +++ b/pengine/test10/master-colocation.exp @@ -1,58 +1,58 @@ - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-demote-2.exp b/pengine/test10/master-demote-2.exp index 1d58931afc..6a8e3aa5b3 100644 --- a/pengine/test10/master-demote-2.exp +++ b/pengine/test10/master-demote-2.exp @@ -1,315 +1,315 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-demote.exp b/pengine/test10/master-demote.exp index f126aaa5b6..219f51f520 100644 --- a/pengine/test10/master-demote.exp +++ b/pengine/test10/master-demote.exp @@ -1,204 +1,204 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-failed-demote-2.exp b/pengine/test10/master-failed-demote-2.exp index 303644a90d..ab979595a3 100644 --- a/pengine/test10/master-failed-demote-2.exp +++ b/pengine/test10/master-failed-demote-2.exp @@ -1,208 +1,208 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-failed-demote.exp b/pengine/test10/master-failed-demote.exp index 4ac9dbac36..eab4b9680f 100644 --- a/pengine/test10/master-failed-demote.exp +++ b/pengine/test10/master-failed-demote.exp @@ -1,472 +1,472 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-group.exp b/pengine/test10/master-group.exp index 0e6dfdd0c7..406a6118fa 100644 --- a/pengine/test10/master-group.exp +++ b/pengine/test10/master-group.exp @@ -1,85 +1,85 @@ - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-move.exp b/pengine/test10/master-move.exp index 419e5b58e4..770fab1477 100644 --- a/pengine/test10/master-move.exp +++ b/pengine/test10/master-move.exp @@ -1,570 +1,570 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-promotion-constraint.exp b/pengine/test10/master-promotion-constraint.exp index 095cd46c14..ca8b7ebbcd 100644 --- a/pengine/test10/master-promotion-constraint.exp +++ b/pengine/test10/master-promotion-constraint.exp @@ -1,64 +1,64 @@ - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-pseudo.exp b/pengine/test10/master-pseudo.exp index 3a314538ab..fe20ecb04d 100644 --- a/pengine/test10/master-pseudo.exp +++ b/pengine/test10/master-pseudo.exp @@ -1,403 +1,403 @@ - + - + - + - + - + - + - + - + - - - - + - + - + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/master-reattach.exp b/pengine/test10/master-reattach.exp index bd9a341113..37ed2effdb 100644 --- a/pengine/test10/master-reattach.exp +++ b/pengine/test10/master-reattach.exp @@ -1,64 +1,64 @@ - + - + - + - + diff --git a/pengine/test10/master-role.exp b/pengine/test10/master-role.exp index ed90a23410..8291753e4d 100644 --- a/pengine/test10/master-role.exp +++ b/pengine/test10/master-role.exp @@ -1,39 +1,39 @@ - + - + diff --git a/pengine/test10/master-unmanaged-monitor.exp b/pengine/test10/master-unmanaged-monitor.exp index 2df6302e15..45f965d0bb 100644 --- a/pengine/test10/master-unmanaged-monitor.exp +++ b/pengine/test10/master-unmanaged-monitor.exp @@ -1,117 +1,117 @@ - + - + - + diff --git a/pengine/test10/migrate-fail-7.dot b/pengine/test10/migrate-fail-7.dot index 0ac7045223..2879f223a8 100644 --- a/pengine/test10/migrate-fail-7.dot +++ b/pengine/test10/migrate-fail-7.dot @@ -1,11 +1,6 @@ digraph "g" { -"all_stopped" [ style=bold color="green" fontcolor="orange" ] "load_stopped_hex-13 hex-13" -> "test-vm_start_0 hex-13" [ style = bold] "load_stopped_hex-13 hex-13" [ style=bold color="green" fontcolor="orange" ] "load_stopped_hex-14 hex-14" [ style=bold color="green" fontcolor="orange" ] "test-vm_start_0 hex-13" [ style=bold color="green" fontcolor="black" ] -"test-vm_stop_0 hex-13" -> "all_stopped" [ style = bold] -"test-vm_stop_0 hex-13" -> "load_stopped_hex-13 hex-13" [ style = bold] -"test-vm_stop_0 hex-13" -> "test-vm_start_0 hex-13" [ style = bold] -"test-vm_stop_0 hex-13" [ style=bold color="green" fontcolor="black" ] } diff --git a/pengine/test10/migrate-fail-7.exp b/pengine/test10/migrate-fail-7.exp index bc10300020..f4f4a133eb 100644 --- a/pengine/test10/migrate-fail-7.exp +++ b/pengine/test10/migrate-fail-7.exp @@ -1,60 +1,32 @@ - + - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - + diff --git a/pengine/test10/migrate-fencing.exp b/pengine/test10/migrate-fencing.exp index 504cfb3e0a..05a0166773 100644 --- a/pengine/test10/migrate-fencing.exp +++ b/pengine/test10/migrate-fencing.exp @@ -1,689 +1,689 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/mon-rsc-3.exp b/pengine/test10/mon-rsc-3.exp index bec1c3d245..24cc6b7127 100644 --- a/pengine/test10/mon-rsc-3.exp +++ b/pengine/test10/mon-rsc-3.exp @@ -1,73 +1,73 @@ - + diff --git a/pengine/test10/mon-rsc-4.exp b/pengine/test10/mon-rsc-4.exp index f0243fafe8..3643b38511 100644 --- a/pengine/test10/mon-rsc-4.exp +++ b/pengine/test10/mon-rsc-4.exp @@ -1,101 +1,101 @@ - + - + - - - - + + + + - + diff --git a/pengine/test10/novell-239082.exp b/pengine/test10/novell-239082.exp index 8f8c9859d1..e1ae4e9cd9 100644 --- a/pengine/test10/novell-239082.exp +++ b/pengine/test10/novell-239082.exp @@ -1,489 +1,489 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/probe-2.exp b/pengine/test10/probe-2.exp index eddd3dce5d..df8351e61b 100644 --- a/pengine/test10/probe-2.exp +++ b/pengine/test10/probe-2.exp @@ -1,1171 +1,1171 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/rec-node-13.exp b/pengine/test10/rec-node-13.exp index 56dd3be5ee..e2ed647ef2 100644 --- a/pengine/test10/rec-node-13.exp +++ b/pengine/test10/rec-node-13.exp @@ -1,95 +1,95 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/rsc-sets-master.exp b/pengine/test10/rsc-sets-master.exp index 7ff2f1a7d8..6d71a45296 100644 --- a/pengine/test10/rsc-sets-master.exp +++ b/pengine/test10/rsc-sets-master.exp @@ -1,244 +1,244 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/stonith-0.exp b/pengine/test10/stonith-0.exp index 38f2d4c9eb..d0a3deb200 100644 --- a/pengine/test10/stonith-0.exp +++ b/pengine/test10/stonith-0.exp @@ -1,456 +1,456 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/stonith-1.exp b/pengine/test10/stonith-1.exp index 1746e4998b..ff225ff2ff 100644 --- a/pengine/test10/stonith-1.exp +++ b/pengine/test10/stonith-1.exp @@ -1,611 +1,611 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/stonith-2.exp b/pengine/test10/stonith-2.exp index d939d42967..cbe4cf0906 100644 --- a/pengine/test10/stonith-2.exp +++ b/pengine/test10/stonith-2.exp @@ -1,76 +1,76 @@ - + - + - + - + - + - + - + - + diff --git a/pengine/test10/ticket-master-11.exp b/pengine/test10/ticket-master-11.exp index 955452cdd6..4d9ce03ad9 100644 --- a/pengine/test10/ticket-master-11.exp +++ b/pengine/test10/ticket-master-11.exp @@ -1,52 +1,52 @@ - + - + - + - + - + diff --git a/pengine/test10/ticket-master-17.exp b/pengine/test10/ticket-master-17.exp index c36f0f190b..e8202871d6 100644 --- a/pengine/test10/ticket-master-17.exp +++ b/pengine/test10/ticket-master-17.exp @@ -1,55 +1,55 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-master-18.exp b/pengine/test10/ticket-master-18.exp index c36f0f190b..e8202871d6 100644 --- a/pengine/test10/ticket-master-18.exp +++ b/pengine/test10/ticket-master-18.exp @@ -1,55 +1,55 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-master-20.exp b/pengine/test10/ticket-master-20.exp index c36f0f190b..e8202871d6 100644 --- a/pengine/test10/ticket-master-20.exp +++ b/pengine/test10/ticket-master-20.exp @@ -1,55 +1,55 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-master-21.exp b/pengine/test10/ticket-master-21.exp index 3e82468855..f4da26b886 100644 --- a/pengine/test10/ticket-master-21.exp +++ b/pengine/test10/ticket-master-21.exp @@ -1,153 +1,153 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/ticket-master-23.exp b/pengine/test10/ticket-master-23.exp index c36f0f190b..e8202871d6 100644 --- a/pengine/test10/ticket-master-23.exp +++ b/pengine/test10/ticket-master-23.exp @@ -1,55 +1,55 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-master-5.exp b/pengine/test10/ticket-master-5.exp index 955452cdd6..4d9ce03ad9 100644 --- a/pengine/test10/ticket-master-5.exp +++ b/pengine/test10/ticket-master-5.exp @@ -1,52 +1,52 @@ - + - + - + - + - + diff --git a/pengine/test10/ticket-master-6.exp b/pengine/test10/ticket-master-6.exp index c36f0f190b..e8202871d6 100644 --- a/pengine/test10/ticket-master-6.exp +++ b/pengine/test10/ticket-master-6.exp @@ -1,55 +1,55 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-master-8.exp b/pengine/test10/ticket-master-8.exp index 955452cdd6..4d9ce03ad9 100644 --- a/pengine/test10/ticket-master-8.exp +++ b/pengine/test10/ticket-master-8.exp @@ -1,52 +1,52 @@ - + - + - + - + - + diff --git a/pengine/test10/ticket-master-9.exp b/pengine/test10/ticket-master-9.exp index 3e82468855..f4da26b886 100644 --- a/pengine/test10/ticket-master-9.exp +++ b/pengine/test10/ticket-master-9.exp @@ -1,153 +1,153 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/pengine/test10/ticket-rsc-sets-10.exp b/pengine/test10/ticket-rsc-sets-10.exp index b8278ba905..1209c96d48 100644 --- a/pengine/test10/ticket-rsc-sets-10.exp +++ b/pengine/test10/ticket-rsc-sets-10.exp @@ -1,195 +1,195 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-rsc-sets-13.exp b/pengine/test10/ticket-rsc-sets-13.exp index b8278ba905..1209c96d48 100644 --- a/pengine/test10/ticket-rsc-sets-13.exp +++ b/pengine/test10/ticket-rsc-sets-13.exp @@ -1,195 +1,195 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-rsc-sets-14.exp b/pengine/test10/ticket-rsc-sets-14.exp index b8278ba905..1209c96d48 100644 --- a/pengine/test10/ticket-rsc-sets-14.exp +++ b/pengine/test10/ticket-rsc-sets-14.exp @@ -1,195 +1,195 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-rsc-sets-2.exp b/pengine/test10/ticket-rsc-sets-2.exp index a336fbad6a..81ab98a1f0 100644 --- a/pengine/test10/ticket-rsc-sets-2.exp +++ b/pengine/test10/ticket-rsc-sets-2.exp @@ -1,233 +1,233 @@ - + - + - + - + - + diff --git a/pengine/test10/ticket-rsc-sets-3.exp b/pengine/test10/ticket-rsc-sets-3.exp index b8278ba905..1209c96d48 100644 --- a/pengine/test10/ticket-rsc-sets-3.exp +++ b/pengine/test10/ticket-rsc-sets-3.exp @@ -1,195 +1,195 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-rsc-sets-6.exp b/pengine/test10/ticket-rsc-sets-6.exp index 8751b22bcf..f9ab006795 100644 --- a/pengine/test10/ticket-rsc-sets-6.exp +++ b/pengine/test10/ticket-rsc-sets-6.exp @@ -1,130 +1,130 @@ - + - + - + - + - + diff --git a/pengine/test10/ticket-rsc-sets-7.exp b/pengine/test10/ticket-rsc-sets-7.exp index b8278ba905..1209c96d48 100644 --- a/pengine/test10/ticket-rsc-sets-7.exp +++ b/pengine/test10/ticket-rsc-sets-7.exp @@ -1,195 +1,195 @@ - + - + - + - + - + - + diff --git a/pengine/test10/ticket-rsc-sets-9.exp b/pengine/test10/ticket-rsc-sets-9.exp index b8278ba905..1209c96d48 100644 --- a/pengine/test10/ticket-rsc-sets-9.exp +++ b/pengine/test10/ticket-rsc-sets-9.exp @@ -1,195 +1,195 @@ - + - + - + - + - + - + diff --git a/pengine/test10/unmanaged-master.exp b/pengine/test10/unmanaged-master.exp index 4e7e4b84f6..0ed28fd6b5 100644 --- a/pengine/test10/unmanaged-master.exp +++ b/pengine/test10/unmanaged-master.exp @@ -1,23 +1,23 @@ - + - + - +