diff --git a/pengine/allocate.c b/pengine/allocate.c index ef36f5e2d4..eda1449c85 100644 --- a/pengine/allocate.c +++ b/pengine/allocate.c @@ -1,1938 +1,1931 @@ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include #include #include #include CRM_TRACE_INIT_DATA(pe_allocate); void set_alloc_actions(pe_working_set_t *data_set); void migrate_reload_madness(pe_working_set_t *data_set); -GHashTable* -native_merge_weights( - resource_t *rsc, const char *rhs, GHashTable *nodes, const char *attr, int factor, gboolean allow_rollback) -{ - return rsc_merge_weights(rsc, rhs, nodes, attr, factor, allow_rollback, FALSE); -} - resource_alloc_functions_t resource_class_alloc_functions[] = { { - native_merge_weights, + rsc_merge_weights, native_color, native_create_actions, native_create_probe, native_internal_constraints, native_rsc_colocation_lh, native_rsc_colocation_rh, native_rsc_location, native_action_flags, native_update_actions, native_expand, native_append_meta, }, { group_merge_weights, group_color, group_create_actions, native_create_probe, group_internal_constraints, group_rsc_colocation_lh, group_rsc_colocation_rh, group_rsc_location, group_action_flags, group_update_actions, group_expand, group_append_meta, }, { - native_merge_weights, + rsc_merge_weights, clone_color, clone_create_actions, clone_create_probe, clone_internal_constraints, clone_rsc_colocation_lh, clone_rsc_colocation_rh, clone_rsc_location, clone_action_flags, clone_update_actions, clone_expand, clone_append_meta, }, { - native_merge_weights, + rsc_merge_weights, master_color, master_create_actions, clone_create_probe, master_internal_constraints, clone_rsc_colocation_lh, master_rsc_colocation_rh, clone_rsc_location, clone_action_flags, clone_update_actions, clone_expand, master_append_meta, } }; static gboolean check_rsc_parameters(resource_t *rsc, node_t *node, xmlNode *rsc_entry, pe_working_set_t *data_set) { int attr_lpc = 0; gboolean force_restart = FALSE; gboolean delete_resource = FALSE; const char *value = NULL; const char *old_value = NULL; const char *attr_list[] = { XML_ATTR_TYPE, XML_AGENT_ATTR_CLASS, XML_AGENT_ATTR_PROVIDER }; for(; attr_lpc < DIMOF(attr_list); attr_lpc++) { value = crm_element_value(rsc->xml, attr_list[attr_lpc]); old_value = crm_element_value(rsc_entry, attr_list[attr_lpc]); if(value == old_value /* ie. NULL */ || crm_str_eq(value, old_value, TRUE)) { continue; } force_restart = TRUE; crm_notice("Forcing restart of %s on %s, %s changed: %s -> %s", rsc->id, node->details->uname, attr_list[attr_lpc], crm_str(old_value), crm_str(value)); } if(force_restart) { /* make sure the restart happens */ stop_action(rsc, node, FALSE); set_bit(rsc->flags, pe_rsc_start_pending); delete_resource = TRUE; } return delete_resource; } static void CancelXmlOp(resource_t *rsc, xmlNode *xml_op, node_t *active_node, const char *reason, pe_working_set_t *data_set) { int interval = 0; action_t *cancel = NULL; char *key = NULL; const char *task = NULL; const char *call_id = NULL; const char *interval_s = NULL; CRM_CHECK(xml_op != NULL, return); CRM_CHECK(active_node != NULL, return); task = crm_element_value(xml_op, XML_LRM_ATTR_TASK); call_id = crm_element_value(xml_op, XML_LRM_ATTR_CALLID); interval_s = crm_element_value(xml_op, XML_LRM_ATTR_INTERVAL); interval = crm_parse_int(interval_s, "0"); /* we need to reconstruct the key because of the way we used to construct resource IDs */ key = generate_op_key(rsc->id, task, interval); crm_info("Action %s on %s will be stopped: %s", key, active_node->details->uname, reason?reason:"unknown"); cancel = custom_action(rsc, crm_strdup(key), RSC_CANCEL, active_node, FALSE, TRUE, data_set); crm_free(cancel->task); cancel->task = crm_strdup(RSC_CANCEL); add_hash_param(cancel->meta, XML_LRM_ATTR_TASK, task); add_hash_param(cancel->meta, XML_LRM_ATTR_CALLID, call_id); add_hash_param(cancel->meta, XML_LRM_ATTR_INTERVAL, interval_s); custom_action_order(rsc, stop_key(rsc), NULL, rsc, NULL, cancel, pe_order_optional, data_set); crm_free(key); key = NULL; } static gboolean check_action_definition(resource_t *rsc, node_t *active_node, xmlNode *xml_op, pe_working_set_t *data_set) { char *key = NULL; int interval = 0; const char *interval_s = NULL; gboolean did_change = FALSE; gboolean start_op = FALSE; xmlNode *params_all = NULL; xmlNode *params_restart = NULL; GHashTable *local_rsc_params = NULL; char *digest_all_calc = NULL; const char *digest_all = NULL; const char *restart_list = NULL; const char *digest_restart = NULL; char *digest_restart_calc = NULL; action_t *action = NULL; const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK); const char *op_version = crm_element_value(xml_op, XML_ATTR_CRM_VERSION); CRM_CHECK(active_node != NULL, return FALSE); interval_s = crm_element_value(xml_op, XML_LRM_ATTR_INTERVAL); interval = crm_parse_int(interval_s, "0"); /* we need to reconstruct the key because of the way we used to construct resource IDs */ key = generate_op_key(rsc->id, task, interval); if(interval > 0) { xmlNode *op_match = NULL; crm_debug_2("Checking parameters for %s", key); op_match = find_rsc_op_entry(rsc, key); if(op_match == NULL && is_set(data_set->flags, pe_flag_stop_action_orphans)) { CancelXmlOp(rsc, xml_op, active_node, "orphan", data_set); crm_free(key); key = NULL; return TRUE; } else if(op_match == NULL) { crm_debug("Orphan action detected: %s on %s", key, active_node->details->uname); crm_free(key); key = NULL; return TRUE; } } action = custom_action(rsc, key, task, active_node, TRUE, FALSE, data_set); local_rsc_params = g_hash_table_new_full( g_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); get_rsc_attributes(local_rsc_params, rsc, active_node, data_set); params_all = create_xml_node(NULL, XML_TAG_PARAMS); g_hash_table_foreach(local_rsc_params, hash2field, params_all); g_hash_table_foreach(action->extra, hash2field, params_all); g_hash_table_foreach(rsc->parameters, hash2field, params_all); g_hash_table_foreach(action->meta, hash2metafield, params_all); filter_action_parameters(params_all, op_version); digest_all_calc = calculate_operation_digest(params_all, op_version); digest_all = crm_element_value(xml_op, XML_LRM_ATTR_OP_DIGEST); digest_restart = crm_element_value(xml_op, XML_LRM_ATTR_RESTART_DIGEST); restart_list = crm_element_value(xml_op, XML_LRM_ATTR_OP_RESTART); if(crm_str_eq(task, RSC_START, TRUE)) { start_op = TRUE; } if(start_op && digest_restart) { params_restart = copy_xml(params_all); if(restart_list) { filter_reload_parameters(params_restart, restart_list); } digest_restart_calc = calculate_operation_digest(params_restart, op_version); if(safe_str_neq(digest_restart_calc, digest_restart)) { did_change = TRUE; crm_log_xml_info(params_restart, "params:restart"); crm_warn("Parameters to %s on %s changed: recorded %s vs. %s (restart:%s) %s", key, active_node->details->uname, crm_str(digest_restart), digest_restart_calc, op_version, crm_element_value(xml_op, XML_ATTR_TRANSITION_MAGIC)); key = generate_op_key(rsc->id, task, interval); custom_action(rsc, key, task, NULL, FALSE, TRUE, data_set); goto cleanup; } } if(safe_str_neq(digest_all_calc, digest_all)) { action_t *op = NULL; did_change = TRUE; crm_log_xml_info(params_all, "params:all"); crm_warn("Parameters to %s on %s changed: recorded %s vs. %s (all:%s) %s", key, active_node->details->uname, crm_str(digest_all), digest_all_calc, op_version, crm_element_value(xml_op, XML_ATTR_TRANSITION_MAGIC)); if(interval == 0 && safe_str_neq(task, RSC_STOP)) { /* Anything except stop actions should result in a restart, * never a re-probe */ task = RSC_START; } key = generate_op_key(rsc->id, task, interval); op = custom_action(rsc, key, task, NULL, FALSE, TRUE, data_set); if(start_op && digest_restart) { update_action_flags(op, pe_action_allow_reload_conversion); } else if(interval > 0) { custom_action_order(rsc, start_key(rsc), NULL, NULL, crm_strdup(op->task), op, pe_order_runnable_left, data_set); } } cleanup: free_xml(params_all); free_xml(params_restart); crm_free(digest_all_calc); crm_free(digest_restart_calc); g_hash_table_destroy(local_rsc_params); pe_free_action(action); return did_change; } extern gboolean DeleteRsc(resource_t *rsc, node_t *node, gboolean optional, pe_working_set_t *data_set); static void check_actions_for(xmlNode *rsc_entry, resource_t *rsc, node_t *node, pe_working_set_t *data_set) { int interval = 0; int stop_index = 0; int start_index = 0; const char *task = NULL; const char *interval_s = NULL; GListPtr op_list = NULL; GListPtr sorted_op_list = NULL; gboolean is_probe = FALSE; CRM_CHECK(node != NULL, return); if(is_set(rsc->flags, pe_rsc_orphan)) { crm_debug_2("Skipping param check for %s: orphan", rsc->id); return; } else if(pe_find_node_id(rsc->running_on, node->details->id) == NULL) { crm_debug_2("Skipping param check for %s: no longer active on %s", rsc->id, node->details->uname); return; } crm_debug_3("Processing %s on %s", rsc->id, node->details->uname); if(check_rsc_parameters(rsc, node, rsc_entry, data_set)) { DeleteRsc(rsc, node, FALSE, data_set); } xml_child_iter_filter( rsc_entry, rsc_op, XML_LRM_TAG_RSC_OP, op_list = g_list_prepend(op_list, rsc_op); ); sorted_op_list = g_list_sort(op_list, sort_op_by_callid); calculate_active_ops(sorted_op_list, &start_index, &stop_index); slist_iter( rsc_op, xmlNode, sorted_op_list, lpc, if(start_index < stop_index) { /* stopped */ continue; } else if(lpc < start_index) { /* action occurred prior to a start */ continue; } is_probe = FALSE; task = crm_element_value(rsc_op, XML_LRM_ATTR_TASK); interval_s = crm_element_value(rsc_op, XML_LRM_ATTR_INTERVAL); interval = crm_parse_int(interval_s, "0"); if(interval == 0 && safe_str_eq(task, RSC_STATUS)) { is_probe = TRUE; } if(interval > 0 && is_set(data_set->flags, pe_flag_maintenance_mode)) { CancelXmlOp(rsc, rsc_op, node, "maintenance mode", data_set); } else if(is_probe || safe_str_eq(task, RSC_START) || interval > 0) { check_action_definition(rsc, node, rsc_op, data_set); } ); g_list_free(sorted_op_list); } static GListPtr find_rsc_list( GListPtr result, resource_t *rsc, const char *id, gboolean renamed_clones, gboolean partial, pe_working_set_t *data_set) { gboolean match = FALSE; if(id == NULL) { return NULL; } else if(rsc == NULL && data_set) { slist_iter(child, resource_t, data_set->resources, lpc, result = find_rsc_list(result, child, id, renamed_clones, partial, NULL)); return result; } else if(rsc == NULL) { return NULL; } if(partial) { if(strstr(rsc->id, id)) { match = TRUE; } else if(rsc->long_name && strstr(rsc->long_name, id)) { match = TRUE; } else if(renamed_clones && rsc->clone_name && strstr(rsc->clone_name, id)) { match = TRUE; } } else { if(strcmp(rsc->id, id) == 0){ match = TRUE; } else if(rsc->long_name && strcmp(rsc->long_name, id) == 0) { match = TRUE; } else if(renamed_clones && rsc->clone_name && strcmp(rsc->clone_name, id) == 0) { match = TRUE; } } if(match) { result = g_list_prepend(result, rsc); } if(rsc->children) { slist_iter(child, resource_t, rsc->children, lpc, result = find_rsc_list(result, child, id, renamed_clones, partial, NULL); ); } return result; } static void check_actions(pe_working_set_t *data_set) { const char *id = NULL; node_t *node = NULL; xmlNode *lrm_rscs = NULL; xmlNode *status = get_object_root(XML_CIB_TAG_STATUS, data_set->input); xml_child_iter_filter( status, node_state, XML_CIB_TAG_STATE, id = crm_element_value(node_state, XML_ATTR_ID); lrm_rscs = find_xml_node(node_state, XML_CIB_TAG_LRM, FALSE); lrm_rscs = find_xml_node(lrm_rscs, XML_LRM_TAG_RESOURCES, FALSE); node = pe_find_node_id(data_set->nodes, id); if(node == NULL) { continue; } else if(can_run_resources(node) == FALSE) { crm_debug_2("Skipping param check for %s: cant run resources", node->details->uname); continue; } crm_debug_2("Processing node %s", node->details->uname); if(node->details->online || is_set(data_set->flags, pe_flag_stonith_enabled)) { xml_child_iter_filter( lrm_rscs, rsc_entry, XML_LRM_TAG_RESOURCE, if(xml_has_children(rsc_entry)) { GListPtr result = NULL; const char *rsc_id = ID(rsc_entry); CRM_CHECK(rsc_id != NULL, return); result = find_rsc_list(NULL, NULL, rsc_id, TRUE, FALSE, data_set); slist_iter(rsc, resource_t, result, lpc, check_actions_for(rsc_entry, rsc, node, data_set)); g_list_free(result); } ); } ); } static gboolean apply_placement_constraints(pe_working_set_t *data_set) { crm_debug_3("Applying constraints..."); slist_iter( cons, rsc_to_node_t, data_set->placement_constraints, lpc, cons->rsc_lh->cmds->rsc_location(cons->rsc_lh, cons); ); return TRUE; } static void common_apply_stickiness(resource_t *rsc, node_t *node, pe_working_set_t *data_set) { int fail_count = 0; resource_t *failed = rsc; if(rsc->children) { slist_iter( child_rsc, resource_t, rsc->children, lpc, common_apply_stickiness(child_rsc, node, data_set); ); return; } if(is_set(rsc->flags, pe_rsc_managed) && rsc->stickiness != 0 && g_list_length(rsc->running_on) == 1) { node_t *current = pe_find_node_id(rsc->running_on, node->details->id); node_t *match = pe_hash_table_lookup(rsc->allowed_nodes, node->details->id); if(current == NULL) { } else if(match != NULL || is_set(data_set->flags, pe_flag_symmetric_cluster)) { resource_t *sticky_rsc = rsc; resource_location(sticky_rsc, node, rsc->stickiness, "stickiness", data_set); crm_debug("Resource %s: preferring current location" " (node=%s, weight=%d)", sticky_rsc->id, node->details->uname, rsc->stickiness); } else { GHashTableIter iter; node_t *node = NULL; crm_debug("Ignoring stickiness for %s: the cluster is asymmetric" " and node %s is not explicitly allowed", rsc->id, node->details->uname); g_hash_table_iter_init (&iter, rsc->allowed_nodes); while (g_hash_table_iter_next (&iter, NULL, (void**)&node)) { crm_err("%s[%s] = %d", rsc->id, node->details->uname, node->weight); } } } if(is_not_set(rsc->flags, pe_rsc_unique)) { failed = uber_parent(rsc); } fail_count = get_failcount(node, rsc, NULL, data_set); if(fail_count > 0 && rsc->migration_threshold != 0) { if(rsc->migration_threshold <= fail_count) { resource_location(failed, node, -INFINITY, "__fail_limit__", data_set); crm_warn("Forcing %s away from %s after %d failures (max=%d)", failed->id, node->details->uname, fail_count, rsc->migration_threshold); } else { crm_notice("%s can fail %d more times on %s before being forced off", failed->id, rsc->migration_threshold - fail_count, node->details->uname); } } } static void complex_set_cmds(resource_t *rsc) { rsc->cmds = &resource_class_alloc_functions[rsc->variant]; slist_iter( child_rsc, resource_t, rsc->children, lpc, complex_set_cmds(child_rsc); ); } void set_alloc_actions(pe_working_set_t *data_set) { slist_iter( rsc, resource_t, data_set->resources, lpc, complex_set_cmds(rsc); ); } static void calculate_system_health (gpointer gKey, gpointer gValue, gpointer user_data) { const char *key = (const char *)gKey; const char *value = (const char *)gValue; int *system_health = (int *)user_data; if (!gKey || !gValue || !user_data) { return; } /* Does it start with #health? */ if (0 == strncmp (key, "#health", 7)) { int score; /* Convert the value into an integer */ score = char2score (value); /* Add it to the running total */ *system_health = merge_weights (score, *system_health); } } static gboolean apply_system_health(pe_working_set_t *data_set) { const char *health_strategy = pe_pref(data_set->config_hash, "node-health-strategy"); if (health_strategy == NULL || safe_str_eq (health_strategy, "none")) { /* Prevent any accidental health -> score translation */ node_score_red = 0; node_score_yellow = 0; node_score_green = 0; return TRUE; } else if (safe_str_eq (health_strategy, "migrate-on-red")) { /* Resources on nodes which have health values of red are * weighted away from that node. */ node_score_red = -INFINITY; node_score_yellow = 0; node_score_green = 0; } else if (safe_str_eq (health_strategy, "only-green")) { /* Resources on nodes which have health values of red or yellow * are forced away from that node. */ node_score_red = -INFINITY; node_score_yellow = -INFINITY; node_score_green = 0; } else if (safe_str_eq (health_strategy, "progressive")) { /* Same as the above, but use the r/y/g scores provided by the user * Defaults are provided by the pe_prefs table */ } else if (safe_str_eq (health_strategy, "custom")) { /* Requires the admin to configure the rsc_location constaints for * processing the stored health scores */ /* TODO: Check for the existance of appropriate node health constraints */ return TRUE; } else { crm_err ("Unknown node health strategy: %s", health_strategy); return FALSE; } crm_info ("Applying automated node health strategy: %s", health_strategy); slist_iter( node, node_t, data_set->nodes, lpc, int system_health = 0; /* Search through the node hash table for system health entries. */ g_hash_table_foreach ( node->details->attrs, calculate_system_health, &system_health); crm_info (" Node %s has an combined system health of %d", node->details->uname, system_health); /* If the health is non-zero, then create a new rsc2node so that the * weight will be added later on. */ if (system_health != 0) { slist_iter( rsc, resource_t, data_set->resources, lpc, rsc2node_new (health_strategy, rsc, system_health, node, data_set); ); } ); return TRUE; } gboolean stage0(pe_working_set_t *data_set) { xmlNode * cib_constraints = get_object_root( XML_CIB_TAG_CONSTRAINTS, data_set->input); if(data_set->input == NULL) { return FALSE; } if(is_set(data_set->flags, pe_flag_have_status) == FALSE) { crm_trace("Calculating status"); cluster_status(data_set); } set_alloc_actions(data_set); apply_system_health(data_set); unpack_constraints(cib_constraints, data_set); return TRUE; } static void wait_for_probe( resource_t *rsc, const char *action, action_t *probe_complete, pe_working_set_t *data_set) { if(probe_complete == NULL) { return; } if(rsc->children) { slist_iter( child, resource_t, rsc->children, lpc, wait_for_probe(child, action, probe_complete, data_set); ); } else { char *key = generate_op_key(rsc->id, action, 0); custom_action_order( NULL, NULL, probe_complete, rsc, key, NULL, pe_order_optional, data_set); } } /* * Check nodes for resources started outside of the LRM */ gboolean probe_resources(pe_working_set_t *data_set) { action_t *probe_complete = NULL; action_t *probe_node_complete = NULL; slist_iter( node, node_t, data_set->nodes, lpc, gboolean force_probe = FALSE; const char *probed = g_hash_table_lookup( node->details->attrs, CRM_OP_PROBED); if(node->details->online == FALSE) { continue; } else if(node->details->unclean) { continue; } else if(probe_complete == NULL) { probe_complete = get_pseudo_op(CRM_OP_PROBED, data_set); } if(probed != NULL && crm_is_true(probed) == FALSE) { force_probe = TRUE; } probe_node_complete = custom_action( NULL, crm_strdup(CRM_OP_PROBED), CRM_OP_PROBED, node, FALSE, TRUE, data_set); if(crm_is_true(probed)) { crm_trace("unset"); update_action_flags(probe_node_complete, pe_action_optional); } else { crm_trace("set"); update_action_flags(probe_node_complete, pe_action_optional|pe_action_clear); } crm_trace("%s - %d", node->details->uname, probe_node_complete->flags & pe_action_optional); probe_node_complete->priority = INFINITY; add_hash_param(probe_node_complete->meta, XML_ATTR_TE_NOWAIT, XML_BOOLEAN_TRUE); if(node->details->pending) { update_action_flags(probe_node_complete, pe_action_runnable|pe_action_clear); crm_info("Action %s on %s is unrunnable (pending)", probe_node_complete->uuid, probe_node_complete->node->details->uname); } order_actions(probe_node_complete, probe_complete, pe_order_runnable_left/*|pe_order_implies_then*/); slist_iter( rsc, resource_t, data_set->resources, lpc2, if(rsc->cmds->create_probe( rsc, node, probe_node_complete, force_probe, data_set)) { update_action_flags(probe_complete, pe_action_optional|pe_action_clear); update_action_flags(probe_node_complete, pe_action_optional|pe_action_clear); wait_for_probe(rsc, CRMD_ACTION_START, probe_complete, data_set); } ); ); slist_iter( rsc, resource_t, data_set->resources, lpc, wait_for_probe(rsc, CRMD_ACTION_STOP, probe_complete, data_set)); return TRUE; } /* * Count how many valid nodes we have (so we know the maximum number of * colors we can resolve). * * Apply node constraints (ie. filter the "allowed_nodes" part of resources */ gboolean stage2(pe_working_set_t *data_set) { crm_debug_3("Applying placement constraints"); slist_iter( node, node_t, data_set->nodes, lpc, if(node == NULL) { /* error */ } else if(node->weight >= 0.0 /* global weight */ && node->details->online && node->details->type == node_member) { data_set->max_valid_nodes++; } ); apply_placement_constraints(data_set); slist_iter(node, node_t, data_set->nodes, lpc, slist_iter( rsc, resource_t, data_set->resources, lpc2, common_apply_stickiness(rsc, node, data_set); ); ); return TRUE; } /* * Create internal resource constraints before allocation */ gboolean stage3(pe_working_set_t *data_set) { slist_iter( rsc, resource_t, data_set->resources, lpc, rsc->cmds->internal_constraints(rsc, data_set); ); return TRUE; } /* * Check for orphaned or redefined actions */ gboolean stage4(pe_working_set_t *data_set) { check_actions(data_set); return TRUE; } gboolean stage5(pe_working_set_t *data_set) { slist_iter( node, node_t, data_set->nodes, lpc, dump_node_capacity(show_utilization?0:utilization_log_level, "Original", node); ); crm_trace("Allocating services"); /* Take (next) highest resource, assign it and create its actions */ slist_iter( rsc, resource_t, data_set->resources, lpc, rsc->cmds->allocate(rsc, data_set); ); slist_iter( node, node_t, data_set->nodes, lpc, dump_node_capacity(show_utilization?0:utilization_log_level, "Remaining", node); ); if(is_set(data_set->flags, pe_flag_startup_probes)) { crm_trace("Calculating needed probes"); /* This code probably needs optimization * ptest -x with 100 nodes, 100 clones and clone-max=100: With probes: ptest[14781]: 2010/09/27_17:56:46 notice: TRACE: do_calculations: pengine.c:258 Calculate cluster status ptest[14781]: 2010/09/27_17:56:46 notice: TRACE: do_calculations: pengine.c:278 Applying placement constraints ptest[14781]: 2010/09/27_17:56:47 notice: TRACE: do_calculations: pengine.c:285 Create internal constraints ptest[14781]: 2010/09/27_17:56:47 notice: TRACE: do_calculations: pengine.c:292 Check actions ptest[14781]: 2010/09/27_17:56:48 notice: TRACE: do_calculations: pengine.c:299 Allocate resources ptest[14781]: 2010/09/27_17:56:48 notice: TRACE: stage5: allocate.c:881 Allocating services ptest[14781]: 2010/09/27_17:56:49 notice: TRACE: stage5: allocate.c:894 Calculating needed probes ptest[14781]: 2010/09/27_17:56:51 notice: TRACE: stage5: allocate.c:899 Creating actions ptest[14781]: 2010/09/27_17:56:52 notice: TRACE: stage5: allocate.c:905 Creating done ptest[14781]: 2010/09/27_17:56:52 notice: TRACE: do_calculations: pengine.c:306 Processing fencing and shutdown cases ptest[14781]: 2010/09/27_17:56:52 notice: TRACE: do_calculations: pengine.c:313 Applying ordering constraints 36s ptest[14781]: 2010/09/27_17:57:28 notice: TRACE: do_calculations: pengine.c:320 Create transition graph Without probes: ptest[14637]: 2010/09/27_17:56:21 notice: TRACE: do_calculations: pengine.c:258 Calculate cluster status ptest[14637]: 2010/09/27_17:56:22 notice: TRACE: do_calculations: pengine.c:278 Applying placement constraints ptest[14637]: 2010/09/27_17:56:22 notice: TRACE: do_calculations: pengine.c:285 Create internal constraints ptest[14637]: 2010/09/27_17:56:22 notice: TRACE: do_calculations: pengine.c:292 Check actions ptest[14637]: 2010/09/27_17:56:23 notice: TRACE: do_calculations: pengine.c:299 Allocate resources ptest[14637]: 2010/09/27_17:56:23 notice: TRACE: stage5: allocate.c:881 Allocating services ptest[14637]: 2010/09/27_17:56:24 notice: TRACE: stage5: allocate.c:899 Creating actions ptest[14637]: 2010/09/27_17:56:25 notice: TRACE: stage5: allocate.c:905 Creating done ptest[14637]: 2010/09/27_17:56:25 notice: TRACE: do_calculations: pengine.c:306 Processing fencing and shutdown cases ptest[14637]: 2010/09/27_17:56:25 notice: TRACE: do_calculations: pengine.c:313 Applying ordering constraints ptest[14637]: 2010/09/27_17:56:25 notice: TRACE: do_calculations: pengine.c:320 Create transition graph */ probe_resources(data_set); } crm_trace("Creating actions"); slist_iter( rsc, resource_t, data_set->resources, lpc, rsc->cmds->create_actions(rsc, data_set); ); crm_trace("Creating done"); return TRUE; } static gboolean is_managed(const resource_t *rsc) { if(is_set(rsc->flags, pe_rsc_managed)) { return TRUE; } slist_iter( child_rsc, resource_t, rsc->children, lpc, if(is_managed(child_rsc)) { return TRUE; } ); return FALSE; } static gboolean any_managed_resouces(pe_working_set_t *data_set) { slist_iter( rsc, resource_t, data_set->resources, lpc, if(is_managed(rsc)) { return TRUE; } ); return FALSE; } /* * Create dependancies for stonith and shutdown operations */ gboolean stage6(pe_working_set_t *data_set) { action_t *dc_down = NULL; action_t *stonith_op = NULL; action_t *last_stonith = NULL; gboolean integrity_lost = FALSE; action_t *ready = get_pseudo_op(STONITH_UP, data_set); action_t *all_stopped = get_pseudo_op(ALL_STOPPED, data_set); action_t *done = get_pseudo_op(STONITH_DONE, data_set); gboolean need_stonith = FALSE; crm_debug_3("Processing fencing and shutdown cases"); if(is_set(data_set->flags, pe_flag_stonith_enabled) && (is_set(data_set->flags, pe_flag_have_quorum) || data_set->no_quorum_policy == no_quorum_ignore || data_set->no_quorum_policy == no_quorum_suicide)) { need_stonith = TRUE; } if(need_stonith && any_managed_resouces(data_set) == FALSE) { crm_notice("Delaying fencing operations until there are resources to manage"); need_stonith = FALSE; } slist_iter( node, node_t, data_set->nodes, lpc, stonith_op = NULL; if(node->details->unclean && need_stonith) { pe_warn("Scheduling Node %s for STONITH", node->details->uname); stonith_op = custom_action( NULL, crm_strdup(CRM_OP_FENCE), CRM_OP_FENCE, node, FALSE, TRUE, data_set); add_hash_param( stonith_op->meta, XML_LRM_ATTR_TARGET, node->details->uname); add_hash_param( stonith_op->meta, XML_LRM_ATTR_TARGET_UUID, node->details->id); add_hash_param( stonith_op->meta, "stonith_action", data_set->stonith_action); stonith_constraints(node, stonith_op, data_set); order_actions(ready, stonith_op, pe_order_runnable_left); order_actions(stonith_op, all_stopped, pe_order_implies_then); clear_bit_inplace(ready->flags, pe_action_optional); if(node->details->is_dc) { dc_down = stonith_op; } else { if(last_stonith) { order_actions(last_stonith, stonith_op, pe_order_optional); } last_stonith = stonith_op; } } else if(node->details->online && node->details->shutdown) { action_t *down_op = NULL; crm_notice("Scheduling Node %s for shutdown", node->details->uname); down_op = custom_action( NULL, crm_strdup(CRM_OP_SHUTDOWN), CRM_OP_SHUTDOWN, node, FALSE, TRUE, data_set); shutdown_constraints(node, down_op, data_set); add_hash_param(down_op->meta, XML_ATTR_TE_NOWAIT, XML_BOOLEAN_TRUE); if(node->details->is_dc) { dc_down = down_op; } } if(node->details->unclean && stonith_op == NULL) { integrity_lost = TRUE; pe_warn("Node %s is unclean!", node->details->uname); } ); if(integrity_lost) { if(is_set(data_set->flags, pe_flag_stonith_enabled) == FALSE) { pe_warn("YOUR RESOURCES ARE NOW LIKELY COMPROMISED"); pe_err("ENABLE STONITH TO KEEP YOUR RESOURCES SAFE"); } else if(is_set(data_set->flags, pe_flag_have_quorum) == FALSE) { crm_notice("Cannot fence unclean nodes until quorum is" " attained (or no-quorum-policy is set to ignore)"); } } if(dc_down != NULL) { GListPtr shutdown_matches = find_actions( data_set->actions, CRM_OP_SHUTDOWN, NULL); crm_debug_2("Ordering shutdowns before %s on %s (DC)", dc_down->task, dc_down->node->details->uname); add_hash_param(dc_down->meta, XML_ATTR_TE_NOWAIT, XML_BOOLEAN_TRUE); slist_iter( node_stop, action_t, shutdown_matches, lpc, if(node_stop->node->details->is_dc) { continue; } crm_debug("Ordering shutdown on %s before %s on %s", node_stop->node->details->uname, dc_down->task, dc_down->node->details->uname); order_actions(node_stop, dc_down, pe_order_optional); ); if(last_stonith && dc_down != last_stonith) { order_actions(last_stonith, dc_down, pe_order_optional); } g_list_free(shutdown_matches); } if(last_stonith) { order_actions(last_stonith, done, pe_order_implies_then); } order_actions(ready, done, pe_order_optional); return TRUE; } /* * Determin the sets of independant actions and the correct order for the * actions in each set. * * Mark dependencies of un-runnable actions un-runnable * */ static GListPtr find_actions_by_task(GListPtr actions, resource_t *rsc, const char *original_key) { GListPtr list = NULL; list = find_actions(actions, original_key, NULL); if(list == NULL) { /* we're potentially searching a child of the original resource */ char *key = NULL; char *tmp = NULL; char *task = NULL; int interval = 0; if(parse_op_key(original_key, &tmp, &task, &interval)) { key = generate_op_key(rsc->id, task, interval); /* crm_err("looking up %s instead of %s", key, original_key); */ /* slist_iter(action, action_t, actions, lpc, */ /* crm_err(" - %s", action->uuid)); */ list = find_actions(actions, key, NULL); } else { crm_err("search key: %s", original_key); } crm_free(key); crm_free(tmp); crm_free(task); } return list; } static void rsc_order_then( action_t *lh_action, resource_t *rsc, order_constraint_t *order) { GListPtr rh_actions = NULL; action_t *rh_action = NULL; enum pe_ordering type = order->type; CRM_CHECK(rsc != NULL, return); CRM_CHECK(order != NULL, return); rh_action = order->rh_action; crm_debug_3("Processing RH of ordering constraint %d", order->id); if(rh_action != NULL) { rh_actions = g_list_prepend(NULL, rh_action); } else if(rsc != NULL) { rh_actions = find_actions_by_task( rsc->actions, rsc, order->rh_action_task); } if(rh_actions == NULL) { crm_debug_4("No RH-Side (%s/%s) found for constraint..." " ignoring", rsc->id,order->rh_action_task); if(lh_action) { crm_debug_4("LH-Side was: %s", lh_action->uuid); } return; } if(lh_action->rsc == rsc && is_set(lh_action->flags, pe_action_dangle)) { crm_trace("Detected dangling operation %s -> %s", lh_action->uuid, order->rh_action_task); clear_bit_inplace(type, pe_order_implies_then); } slist_iter( rh_action_iter, action_t, rh_actions, lpc, if(lh_action) { order_actions(lh_action, rh_action_iter, type); } else if(type & pe_order_implies_then) { update_action_flags(rh_action_iter, pe_action_runnable|pe_action_clear); crm_warn("Unrunnable %s 0x%.6x", rh_action_iter->uuid, type); } else { crm_warn("neither %s 0x%.6x", rh_action_iter->uuid, type); } ); pe_free_shallow_adv(rh_actions, FALSE); } static void rsc_order_first(resource_t *lh_rsc, order_constraint_t *order, pe_working_set_t *data_set) { GListPtr lh_actions = NULL; action_t *lh_action = order->lh_action; resource_t *rh_rsc = order->rh_rsc; crm_debug_3("Processing LH of ordering constraint %d", order->id); CRM_ASSERT(lh_rsc != NULL); if(lh_action != NULL) { lh_actions = g_list_prepend(NULL, lh_action); } else if(lh_action == NULL) { lh_actions = find_actions_by_task( lh_rsc->actions, lh_rsc, order->lh_action_task); } if(lh_actions == NULL && lh_rsc != rh_rsc) { char *key = NULL; char *rsc_id = NULL; char *op_type = NULL; int interval = 0; parse_op_key(order->lh_action_task, &rsc_id, &op_type, &interval); key = generate_op_key(lh_rsc->id, op_type, interval); if(lh_rsc->fns->state(lh_rsc, TRUE) != RSC_ROLE_STOPPED || safe_str_neq(op_type, RSC_STOP)) { crm_debug_4("No LH-Side (%s/%s) found for constraint %d with %s - creating", lh_rsc->id, order->lh_action_task, order->id, order->rh_action_task); lh_action = custom_action(lh_rsc, key, op_type, NULL, TRUE, TRUE, data_set); lh_actions = g_list_prepend(NULL, lh_action); } else { crm_free(key); crm_debug_4("No LH-Side (%s/%s) found for constraint %d with %s - ignoring", lh_rsc->id, order->lh_action_task, order->id, order->rh_action_task); } crm_free(op_type); crm_free(rsc_id); } slist_iter( lh_action_iter, action_t, lh_actions, lpc, if(rh_rsc == NULL && order->rh_action) { rh_rsc = order->rh_action->rsc; } if(rh_rsc) { rsc_order_then(lh_action_iter, rh_rsc, order); } else if(order->rh_action) { order_actions(lh_action_iter, order->rh_action, order->type); } ); pe_free_shallow_adv(lh_actions, FALSE); } extern gboolean update_action(action_t *action); gboolean stage7(pe_working_set_t *data_set) { crm_debug_4("Applying ordering constraints"); /* Don't ask me why, but apparently they need to be processed in * the order they were created in... go figure * * Also g_list_prepend() has horrendous performance characteristics * So we need to use g_list_prepend() and then reverse the list here */ data_set->ordering_constraints = g_list_reverse( data_set->ordering_constraints); slist_iter( order, order_constraint_t, data_set->ordering_constraints, lpc, resource_t *rsc = order->lh_rsc; crm_debug_3("Applying ordering constraint: %d", order->id); if(rsc != NULL) { crm_debug_4("rsc_action-to-*"); rsc_order_first(rsc, order, data_set); continue; } rsc = order->rh_rsc; if(rsc != NULL) { crm_debug_4("action-to-rsc_action"); rsc_order_then(order->lh_action, rsc, order); } else { crm_debug_4("action-to-action"); order_actions( order->lh_action, order->rh_action, order->type); } ); crm_debug_2("Updating %d actions", g_list_length(data_set->actions)); slist_iter( action, action_t, data_set->actions, lpc, update_action(action); ); crm_debug_2("Processing migrations"); slist_iter( rsc, resource_t, data_set->resources, lpc, rsc_migrate_reload(rsc, data_set); LogActions(rsc, data_set); ); return TRUE; } static gint sort_notify_entries(gconstpointer a, gconstpointer b) { int tmp; const notify_entry_t *entry_a = a; const notify_entry_t *entry_b = b; if(entry_a == NULL && entry_b == NULL) { return 0; } if(entry_a == NULL) { return 1; } if(entry_b == NULL) { return -1; } if(entry_a->rsc == NULL && entry_b->rsc == NULL) { return 0; } if(entry_a->rsc == NULL) { return 1; } if(entry_b->rsc == NULL) { return -1; } tmp = strcmp(entry_a->rsc->id, entry_b->rsc->id); if(tmp != 0) { return tmp; } if(entry_a->node == NULL && entry_b->node == NULL) { return 0; } if(entry_a->node == NULL) { return 1; } if(entry_b->node == NULL) { return -1; } return strcmp(entry_a->node->details->id, entry_b->node->details->id); } static void expand_list(GListPtr list, char **rsc_list, char **node_list) { const char *uname = NULL; const char *rsc_id = NULL; const char *last_rsc_id = NULL; if(list == NULL) { *rsc_list = crm_strdup(" "); if(node_list) { *node_list = crm_strdup(" "); } return; } *rsc_list = NULL; if(node_list) { *node_list = NULL; } slist_iter(entry, notify_entry_t, list, lpc, CRM_CHECK(entry != NULL, continue); CRM_CHECK(entry->rsc != NULL, continue); CRM_CHECK(node_list == NULL || entry->node != NULL, continue); uname = NULL; rsc_id = entry->rsc->id; CRM_ASSERT(rsc_id != NULL); /* filter dups */ if(safe_str_eq(rsc_id, last_rsc_id)) { continue; } last_rsc_id = rsc_id; if(rsc_list != NULL) { int existing_len = 0; int len = 2 + strlen(rsc_id); /* +1 space, +1 EOS */ if(rsc_list && *rsc_list) { existing_len = strlen(*rsc_list); } crm_debug_5("Adding %s (%dc) at offset %d", rsc_id, len-2, existing_len); crm_realloc(*rsc_list, len + existing_len); sprintf(*rsc_list + existing_len, "%s ", rsc_id); } if(entry->node != NULL) { uname = entry->node->details->uname; } if(node_list != NULL && uname) { int existing_len = 0; int len = 2 + strlen(uname); if(node_list && *node_list) { existing_len = strlen(*node_list); } crm_debug_5("Adding %s (%dc) at offset %d", uname, len-2, existing_len); crm_realloc(*node_list, len + existing_len); sprintf(*node_list + existing_len, "%s ", uname); } ); } static void dup_attr(gpointer key, gpointer value, gpointer user_data) { add_hash_param(user_data, key, value); } static action_t * pe_notify(resource_t *rsc, node_t *node, action_t *op, action_t *confirm, notify_data_t *n_data, pe_working_set_t *data_set) { char *key = NULL; action_t *trigger = NULL; const char *value = NULL; const char *task = NULL; if(op == NULL || confirm == NULL) { crm_debug_2("Op=%p confirm=%p", op, confirm); return NULL; } CRM_CHECK(node != NULL, return NULL); if(node->details->online == FALSE) { crm_debug_2("Skipping notification for %s: node offline", rsc->id); return NULL; } else if(is_set(op->flags, pe_action_runnable) == FALSE) { crm_debug_2("Skipping notification for %s: not runnable", op->uuid); return NULL; } value = g_hash_table_lookup(op->meta, "notify_type"); task = g_hash_table_lookup(op->meta, "notify_operation"); crm_debug_2("Creating notify actions for %s: %s (%s-%s)", op->uuid, rsc->id, value, task); key = generate_notify_key(rsc->id, value, task); trigger = custom_action(rsc, key, op->task, node, is_set(op->flags, pe_action_optional), TRUE, data_set); g_hash_table_foreach(op->meta, dup_attr, trigger->meta); g_hash_table_foreach(n_data->keys, dup_attr, trigger->meta); /* pseudo_notify before notify */ crm_debug_3("Ordering %s before %s (%d->%d)", op->uuid, trigger->uuid, trigger->id, op->id); order_actions(op, trigger, pe_order_optional); order_actions(trigger, confirm, pe_order_optional); return trigger; } static void pe_post_notify(resource_t *rsc, node_t *node, notify_data_t *n_data, pe_working_set_t *data_set) { action_t *notify = NULL; CRM_CHECK(rsc != NULL, return); if(n_data->post == NULL) { return; /* Nothing to do */ } notify = pe_notify(rsc, node, n_data->post, n_data->post_done, n_data, data_set); if(notify != NULL) { notify->priority = INFINITY; } if(n_data->post_done) { slist_iter( mon, action_t, rsc->actions, lpc, const char *interval = g_hash_table_lookup(mon->meta, "interval"); if(interval == NULL || safe_str_eq(interval, "0")) { crm_debug_3("Skipping %s: interval", mon->uuid); continue; } else if(safe_str_eq(mon->task, "cancel")) { crm_debug_3("Skipping %s: cancel", mon->uuid); continue; } order_actions(n_data->post_done, mon, pe_order_optional); ); } } notify_data_t * create_notification_boundaries( resource_t *rsc, const char *action, action_t *start, action_t *end, pe_working_set_t *data_set) { /* Create the pseudo ops that preceed and follow the actual notifications */ /* * Creates two sequences (conditional on start and end being supplied): * pre_notify -> pre_notify_complete -> start, and * end -> post_notify -> post_notify_complete * * 'start' and 'end' may be the same event or ${X} and ${X}ed as per clones */ char *key = NULL; notify_data_t *n_data = NULL; if(is_not_set(rsc->flags, pe_rsc_notify)) { return NULL; } crm_malloc0(n_data, sizeof(notify_data_t)); n_data->action = action; n_data->keys = g_hash_table_new_full( g_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); if(start) { /* create pre-event notification wrappers */ key = generate_notify_key(rsc->id, "pre", start->task); n_data->pre = custom_action( rsc, key, RSC_NOTIFY, NULL, is_set(start->flags, pe_action_optional), TRUE, data_set); update_action_flags(n_data->pre, pe_action_pseudo); update_action_flags(n_data->pre, pe_action_runnable); add_hash_param(n_data->pre->meta, "notify_type", "pre"); add_hash_param(n_data->pre->meta, "notify_operation", n_data->action); /* create pre_notify_complete */ key = generate_notify_key(rsc->id, "confirmed-pre", start->task); n_data->pre_done = custom_action( rsc, key, RSC_NOTIFIED, NULL, is_set(start->flags, pe_action_optional), TRUE, data_set); update_action_flags(n_data->pre_done, pe_action_pseudo); update_action_flags(n_data->pre_done, pe_action_runnable); add_hash_param(n_data->pre_done->meta, "notify_type", "pre"); add_hash_param(n_data->pre_done->meta, "notify_operation", n_data->action); order_actions(n_data->pre_done, start, pe_order_optional); order_actions(n_data->pre, n_data->pre_done, pe_order_optional); } if(end) { /* create post-event notification wrappers */ key = generate_notify_key(rsc->id, "post", end->task); n_data->post = custom_action( rsc, key, RSC_NOTIFY, NULL, is_set(end->flags, pe_action_optional), TRUE, data_set); n_data->post->priority = INFINITY; update_action_flags(n_data->post, pe_action_pseudo); if(is_set(end->flags, pe_action_runnable)) { update_action_flags(n_data->post, pe_action_runnable); } else { update_action_flags(n_data->post, pe_action_runnable|pe_action_clear); } add_hash_param(n_data->post->meta, "notify_type", "post"); add_hash_param(n_data->post->meta, "notify_operation", n_data->action); /* create post_notify_complete */ key = generate_notify_key(rsc->id, "confirmed-post", end->task); n_data->post_done = custom_action( rsc, key, RSC_NOTIFIED, NULL, is_set(end->flags, pe_action_optional), TRUE, data_set); n_data->post_done->priority = INFINITY; update_action_flags(n_data->post_done, pe_action_pseudo); if(is_set(end->flags, pe_action_runnable)) { update_action_flags(n_data->post_done, pe_action_runnable); } else { update_action_flags(n_data->post_done, pe_action_runnable|pe_action_clear); } add_hash_param(n_data->post_done->meta, "notify_type", "pre"); add_hash_param(n_data->post_done->meta, "notify_operation", n_data->action); order_actions(end, n_data->post, pe_order_implies_then); order_actions(n_data->post, n_data->post_done, pe_order_implies_then); } if(start && end) { order_actions(n_data->pre_done, n_data->post, pe_order_optional); } if(safe_str_eq(action, RSC_STOP)) { action_t *all_stopped = get_pseudo_op(ALL_STOPPED, data_set); order_actions(n_data->post_done, all_stopped, pe_order_optional); } return n_data; } void collect_notification_data(resource_t *rsc, gboolean state, gboolean activity, notify_data_t *n_data) { if(rsc->children) { slist_iter(child, resource_t, rsc->children, lpc, collect_notification_data(child, state, activity, n_data); ); return; } if(state) { notify_entry_t *entry = NULL; crm_malloc0(entry, sizeof(notify_entry_t)); entry->rsc = rsc; if(rsc->running_on) { /* we only take the first one */ entry->node = rsc->running_on->data; } crm_debug_2("%s state: %s", rsc->id, role2text(rsc->role)); switch(rsc->role) { case RSC_ROLE_STOPPED: n_data->inactive = g_list_prepend(n_data->inactive, entry); break; case RSC_ROLE_STARTED: n_data->active = g_list_prepend(n_data->active, entry); break; case RSC_ROLE_SLAVE: n_data->slave = g_list_prepend(n_data->slave, entry); break; case RSC_ROLE_MASTER: n_data->master = g_list_prepend(n_data->master, entry); break; default: crm_err("Unsupported notify role"); crm_free(entry); break; } } if(activity) { notify_entry_t *entry = NULL; enum action_tasks task; slist_iter( op, action_t, rsc->actions, lpc, if(is_set(op->flags, pe_action_optional) == FALSE && op->node != NULL) { crm_malloc0(entry, sizeof(notify_entry_t)); entry->node = op->node; entry->rsc = rsc; task = text2task(op->task); switch(task) { case start_rsc: n_data->start = g_list_prepend(n_data->start, entry); break; case stop_rsc: n_data->stop = g_list_prepend(n_data->stop, entry); break; case action_promote: n_data->promote = g_list_prepend(n_data->promote, entry); break; case action_demote: n_data->demote = g_list_prepend(n_data->demote, entry); break; default: crm_free(entry); break; } } ); } } gboolean expand_notification_data(notify_data_t *n_data) { /* Expand the notification entries into a key=value hashtable * This hashtable is later used in action2xml() */ gboolean required = FALSE; char *rsc_list = NULL; char *node_list = NULL; if(n_data->stop) { n_data->stop = g_list_sort(n_data->stop, sort_notify_entries); } expand_list(n_data->stop, &rsc_list, &node_list); if(rsc_list != NULL && safe_str_neq(" ", rsc_list)) { if(safe_str_eq(n_data->action, RSC_STOP)) { required = TRUE; } } g_hash_table_insert(n_data->keys, crm_strdup("notify_stop_resource"), rsc_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_stop_uname"), node_list); if(n_data->start) { n_data->start = g_list_sort(n_data->start, sort_notify_entries); if(rsc_list && safe_str_eq(n_data->action, RSC_START)) { required = TRUE; } } expand_list(n_data->start, &rsc_list, &node_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_start_resource"), rsc_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_start_uname"), node_list); if(n_data->demote) { n_data->demote = g_list_sort(n_data->demote, sort_notify_entries); if(safe_str_eq(n_data->action, RSC_DEMOTE)) { required = TRUE; } } expand_list(n_data->demote, &rsc_list, &node_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_demote_resource"), rsc_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_demote_uname"), node_list); if(n_data->promote) { n_data->promote = g_list_sort(n_data->promote, sort_notify_entries); if(safe_str_eq(n_data->action, RSC_PROMOTE)) { required = TRUE; } } expand_list(n_data->promote, &rsc_list, &node_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_promote_resource"), rsc_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_promote_uname"), node_list); if(n_data->active) { n_data->active = g_list_sort(n_data->active, sort_notify_entries); } expand_list(n_data->active, &rsc_list, &node_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_active_resource"), rsc_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_active_uname"), node_list); if(n_data->slave) { n_data->slave = g_list_sort(n_data->slave, sort_notify_entries); } expand_list(n_data->slave, &rsc_list, &node_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_slave_resource"), rsc_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_slave_uname"), node_list); if(n_data->master) { n_data->master = g_list_sort(n_data->master, sort_notify_entries); } expand_list(n_data->master, &rsc_list, &node_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_master_resource"), rsc_list); g_hash_table_insert(n_data->keys, crm_strdup("notify_master_uname"), node_list); if(n_data->inactive) { n_data->inactive = g_list_sort(n_data->inactive, sort_notify_entries); } expand_list(n_data->inactive, &rsc_list, NULL); g_hash_table_insert(n_data->keys, crm_strdup("notify_inactive_resource"), rsc_list); if(required && n_data->pre) { update_action_flags(n_data->pre, pe_action_optional|pe_action_clear); update_action_flags(n_data->pre_done, pe_action_optional|pe_action_clear); } if(required && n_data->post) { update_action_flags(n_data->post, pe_action_optional|pe_action_clear); update_action_flags(n_data->post_done, pe_action_optional|pe_action_clear); } return required; } void create_notifications(resource_t *rsc, notify_data_t *n_data, pe_working_set_t *data_set) { action_t *stop = NULL; action_t *start = NULL; enum action_tasks task = text2task(n_data->action); if(rsc->children) { slist_iter( child, resource_t, rsc->children, lpc, create_notifications(child, n_data, data_set); ); return; } /* Copy notification details into standard ops */ slist_iter( op, action_t, rsc->actions, lpc, if(is_set(op->flags, pe_action_optional) == FALSE && op->node != NULL) { enum action_tasks t = text2task(op->task); switch(t) { case start_rsc: case stop_rsc: case action_promote: case action_demote: g_hash_table_foreach(n_data->keys, dup_attr, op->meta); break; default: break; } } ); crm_debug_2("Creating notificaitons for: %s.%s (%s->%s)", n_data->action, rsc->id, role2text(rsc->role), role2text(rsc->next_role)); stop = find_first_action(rsc->actions, NULL, RSC_STOP, NULL); start = find_first_action(rsc->actions, NULL, RSC_START, NULL); /* stop / demote */ if(rsc->role != RSC_ROLE_STOPPED) { if(task == stop_rsc || task == action_demote) { slist_iter(current_node, node_t, rsc->running_on, lpc, pe_notify(rsc, current_node, n_data->pre, n_data->pre_done, n_data, data_set); if(task == action_demote || stop == NULL || is_set(stop->flags, pe_action_optional)) { pe_post_notify(rsc, current_node, n_data, data_set); } ); } } /* start / promote */ if(rsc->next_role != RSC_ROLE_STOPPED) { if(rsc->allocated_to == NULL) { pe_proc_err("Next role '%s' but %s is not allocated", role2text(rsc->next_role), rsc->id); } else if(task == start_rsc || task == action_promote) { if(task != start_rsc || start == NULL || is_set(start->flags, pe_action_optional)) { pe_notify(rsc, rsc->allocated_to, n_data->pre, n_data->pre_done, n_data, data_set); } pe_post_notify(rsc, rsc->allocated_to, n_data, data_set); } } } void free_notification_data(notify_data_t *n_data) { if(n_data == NULL) { return; } pe_free_shallow(n_data->stop); pe_free_shallow(n_data->start); pe_free_shallow(n_data->demote); pe_free_shallow(n_data->promote); pe_free_shallow(n_data->master); pe_free_shallow(n_data->slave); pe_free_shallow(n_data->active); pe_free_shallow(n_data->inactive); g_hash_table_destroy(n_data->keys); crm_free(n_data); } int transition_id = -1; /* * Create a dependency graph to send to the transitioner (via the CRMd) */ gboolean stage8(pe_working_set_t *data_set) { const char *value = NULL; transition_id++; crm_debug_2("Creating transition graph %d.", transition_id); data_set->graph = create_xml_node(NULL, XML_TAG_GRAPH); value = pe_pref(data_set->config_hash, "cluster-delay"); crm_xml_add(data_set->graph, "cluster-delay", value); value = pe_pref(data_set->config_hash, "stonith-timeout"); crm_xml_add(data_set->graph, "stonith-timeout", value); crm_xml_add(data_set->graph, "failed-stop-offset", "INFINITY"); if(is_set(data_set->flags, pe_flag_start_failure_fatal)) { crm_xml_add(data_set->graph, "failed-start-offset", "INFINITY"); } else { crm_xml_add(data_set->graph, "failed-start-offset", "1"); } value = pe_pref(data_set->config_hash, "batch-limit"); crm_xml_add(data_set->graph, "batch-limit", value); crm_xml_add_int(data_set->graph, "transition_id", transition_id); /* errors... slist_iter(action, action_t, action_list, lpc, if(action->optional == FALSE && action->runnable == FALSE) { print_action("Ignoring", action, TRUE); } ); */ slist_iter( rsc, resource_t, data_set->resources, lpc, crm_debug_4("processing actions for rsc=%s", rsc->id); rsc->cmds->expand(rsc, data_set); ); crm_log_xml_debug_3( data_set->graph, "created resource-driven action list"); /* catch any non-resource specific actions */ crm_debug_4("processing non-resource actions"); slist_iter( action, action_t, data_set->actions, lpc, graph_element_from_action(action, data_set); ); crm_log_xml_debug_3(data_set->graph, "created generic action list"); crm_debug_2("Created transition graph %d.", transition_id); return TRUE; } void cleanup_alloc_calculations(pe_working_set_t *data_set) { if(data_set == NULL) { return; } crm_debug_3("deleting %d order cons: %p", g_list_length(data_set->ordering_constraints), data_set->ordering_constraints); pe_free_ordering(data_set->ordering_constraints); data_set->ordering_constraints = NULL; crm_debug_3("deleting %d node cons: %p", g_list_length(data_set->placement_constraints), data_set->placement_constraints); pe_free_rsc_to_node(data_set->placement_constraints); data_set->placement_constraints = NULL; crm_debug_3("deleting %d inter-resource cons: %p", g_list_length(data_set->colocation_constraints), data_set->colocation_constraints); pe_free_shallow(data_set->colocation_constraints); data_set->colocation_constraints = NULL; cleanup_calculations(data_set); } diff --git a/pengine/allocate.h b/pengine/allocate.h index 017db333f1..2032427290 100644 --- a/pengine/allocate.h +++ b/pengine/allocate.h @@ -1,199 +1,196 @@ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef CRM_PENGINE_COMPLEX_ALLOC__H #define CRM_PENGINE_COMPLEX_ALLOC__H #include #include #include #include #include typedef struct notify_entry_s { resource_t *rsc; node_t *node; } notify_entry_t; struct resource_alloc_functions_s { - GHashTable *(*merge_weights)(resource_t*, const char*, GHashTable*, const char*, int, gboolean); + GHashTable *(*merge_weights)(resource_t*, const char*, GHashTable*, const char*, int, gboolean, gboolean); node_t *(*allocate)(resource_t *, pe_working_set_t *); void (*create_actions)(resource_t *, pe_working_set_t *); gboolean (*create_probe)( resource_t *, node_t *, action_t *, gboolean, pe_working_set_t *); void (*internal_constraints)(resource_t *, pe_working_set_t *); void (*rsc_colocation_lh)(resource_t *, resource_t *, rsc_colocation_t *); void (*rsc_colocation_rh)(resource_t *, resource_t *, rsc_colocation_t *); void (*rsc_location)(resource_t *, rsc_to_node_t *); enum pe_action_flags (*action_flags)(action_t *, node_t*); enum pe_graph_flags (*update_actions)(action_t *, action_t *, node_t*, enum pe_action_flags, enum pe_action_flags, enum pe_ordering); void (*expand)(resource_t *, pe_working_set_t *); void (*append_meta)(resource_t *rsc, xmlNode *xml); }; extern GHashTable *rsc_merge_weights( resource_t *rsc, const char *rhs, GHashTable *nodes, const char *attr, int factor, gboolean allow_rollback, gboolean only_positive); -extern GHashTable *native_merge_weights( - resource_t *rsc, const char *rhs, GHashTable *nodes, const char *attr, int factor, gboolean allow_rollback); - extern GHashTable *group_merge_weights( - resource_t *rsc, const char *rhs, GHashTable *nodes, const char *attr, int factor, gboolean allow_rollback); + resource_t *rsc, const char *rhs, GHashTable *nodes, const char *attr, int factor, gboolean allow_rollback, gboolean only_positive); extern node_t * native_color(resource_t *rsc, pe_working_set_t *data_set); extern void native_create_actions( resource_t *rsc, pe_working_set_t *data_set); extern void native_internal_constraints( resource_t *rsc, pe_working_set_t *data_set); extern void native_rsc_colocation_lh( resource_t *lh_rsc, resource_t *rh_rsc, rsc_colocation_t *constraint); extern void native_rsc_colocation_rh( resource_t *lh_rsc, resource_t *rh_rsc, rsc_colocation_t *constraint); extern enum pe_action_flags native_action_flags(action_t *action, node_t *node); extern void native_rsc_location(resource_t *rsc, rsc_to_node_t *constraint); extern void native_expand(resource_t *rsc, pe_working_set_t *data_set); extern void native_dump(resource_t *rsc, const char *pre_text, gboolean details); extern void create_notify_element( resource_t *rsc, action_t *op, notify_data_t *n_data, pe_working_set_t *data_set); extern void native_assign_color(resource_t *rsc, node_t *node); extern gboolean native_create_probe( resource_t *rsc, node_t *node, action_t *complete, gboolean force, pe_working_set_t *data_set); extern void native_append_meta(resource_t *rsc, xmlNode *xml); extern int group_num_allowed_nodes(resource_t *rsc); extern node_t *group_color(resource_t *rsc, pe_working_set_t *data_set); extern void group_create_actions( resource_t *rsc, pe_working_set_t *data_set); extern void group_internal_constraints( resource_t *rsc, pe_working_set_t *data_set); extern void group_rsc_colocation_lh( resource_t *lh_rsc, resource_t *rh_rsc, rsc_colocation_t *constraint); extern void group_rsc_colocation_rh( resource_t *lh_rsc, resource_t *rh_rsc, rsc_colocation_t *constraint); extern enum pe_action_flags group_action_flags(action_t *action, node_t *node); extern void group_rsc_location(resource_t *rsc, rsc_to_node_t *constraint); extern void group_expand(resource_t *rsc, pe_working_set_t *data_set); extern void group_append_meta(resource_t *rsc, xmlNode *xml); extern int clone_num_allowed_nodes(resource_t *rsc); extern node_t *clone_color(resource_t *rsc, pe_working_set_t *data_set); extern void clone_create_actions(resource_t *rsc, pe_working_set_t *data_set); extern void clone_internal_constraints( resource_t *rsc, pe_working_set_t *data_set); extern void clone_rsc_colocation_lh( resource_t *lh_rsc, resource_t *rh_rsc, rsc_colocation_t *constraint); extern void clone_rsc_colocation_rh( resource_t *lh_rsc, resource_t *rh_rsc, rsc_colocation_t *constraint); extern void clone_rsc_location(resource_t *rsc, rsc_to_node_t *constraint); extern enum pe_action_flags clone_action_flags(action_t *action, node_t *node); extern void clone_expand(resource_t *rsc, pe_working_set_t *data_set); extern gboolean clone_create_probe( resource_t *rsc, node_t *node, action_t *complete, gboolean force, pe_working_set_t *data_set); extern void clone_append_meta(resource_t *rsc, xmlNode *xml); extern gboolean master_unpack(resource_t *rsc, pe_working_set_t *data_set); extern node_t *master_color(resource_t *rsc, pe_working_set_t *data_set); extern void master_create_actions(resource_t *rsc, pe_working_set_t *data_set); extern void master_internal_constraints( resource_t *rsc, pe_working_set_t *data_set); extern void master_rsc_colocation_rh( resource_t *lh_rsc, resource_t *rh_rsc, rsc_colocation_t *constraint); extern void master_append_meta(resource_t *rsc, xmlNode *xml); /* extern resource_object_functions_t resource_variants[]; */ extern resource_alloc_functions_t resource_class_alloc_functions[]; extern gboolean is_active(rsc_to_node_t *cons); extern gboolean native_constraint_violated( resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint); extern gboolean unpack_rsc_to_attr(xmlNode *xml_obj, pe_working_set_t *data_set); extern gboolean unpack_rsc_to_node(xmlNode *xml_obj, pe_working_set_t *data_set); extern gboolean unpack_rsc_order(xmlNode *xml_obj, pe_working_set_t *data_set); extern gboolean unpack_rsc_colocation(xmlNode *xml_obj, pe_working_set_t *data_set); extern gboolean unpack_rsc_location(xmlNode *xml_obj, pe_working_set_t *data_set); extern void LogActions(resource_t *rsc, pe_working_set_t *data_set); extern void cleanup_alloc_calculations(pe_working_set_t *data_set); extern notify_data_t *create_notification_boundaries( resource_t *rsc, const char *action, action_t *start, action_t *end, pe_working_set_t *data_set); extern void collect_notification_data(resource_t *rsc, gboolean state, gboolean activity, notify_data_t *n_data); extern gboolean expand_notification_data(notify_data_t *n_data); extern void create_notifications(resource_t *rsc, notify_data_t *n_data, pe_working_set_t *data_set); extern void free_notification_data(notify_data_t *n_data); extern void rsc_migrate_reload(resource_t *rsc, pe_working_set_t *data_set); extern void rsc_stonith_ordering(resource_t *rsc, action_t *stonith_op, pe_working_set_t *data_set); extern 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); extern enum pe_graph_flags group_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); extern enum pe_graph_flags clone_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); static inline enum pe_action_flags get_action_flags(action_t *action, node_t *node) { if(action->rsc) { return action->rsc->cmds->action_flags(action, action->rsc->variant >= pe_clone?node:NULL); } return action->flags; } static inline gboolean update_action_flags(action_t *action, enum pe_action_flags flags) { gboolean changed = FALSE; gboolean clear = is_set(flags, pe_action_clear); enum pe_action_flags last = action->flags; if(clear) { clear_bit_inplace(action->flags, flags); } else { set_bit_inplace(action->flags, flags); } if(last != action->flags) { changed = TRUE; clear_bit_inplace(flags, pe_action_clear); crm_trace("%sset flags 0x%.6x (was 0x%.6x, now 0x%.6x) for %s on %s", clear?"un-":"", flags, last, action->flags, action->uuid, action->node?action->node->details->uname:"[none]"); } return changed; } #endif diff --git a/pengine/clone.c b/pengine/clone.c index 296e8b13fa..9dc00c42d1 100644 --- a/pengine/clone.c +++ b/pengine/clone.c @@ -1,1376 +1,1376 @@ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #define VARIANT_CLONE 1 #include gint sort_clone_instance(gconstpointer a, gconstpointer b, gpointer data_set); static node_t * parent_node_instance(const resource_t *rsc, node_t *node) { node_t *ret = NULL; if(node != NULL) { ret = pe_hash_table_lookup(rsc->parent->allowed_nodes, node->details->id); } return ret; } static gboolean did_fail(const resource_t *rsc) { if(is_set(rsc->flags, pe_rsc_failed)) { return TRUE; } slist_iter( child_rsc, resource_t, rsc->children, lpc, if(did_fail(child_rsc)) { return TRUE; } ); return FALSE; } gint sort_clone_instance(gconstpointer a, gconstpointer b, gpointer data_set) { int level = LOG_DEBUG_3; node_t *node1 = NULL; node_t *node2 = NULL; gboolean can1 = TRUE; gboolean can2 = TRUE; gboolean with_scores = TRUE; const resource_t *resource1 = (const resource_t*)a; const resource_t *resource2 = (const resource_t*)b; CRM_ASSERT(resource1 != NULL); CRM_ASSERT(resource2 != NULL); /* allocation order: * - active instances * - instances running on nodes with the least copies * - active instances on nodes that cant support them or are to be fenced * - failed instances * - inactive instances */ do_crm_log_unlikely(level+1, "%s ? %s", resource1->id, resource2->id); if(resource1->running_on && resource2->running_on) { if(g_list_length(resource1->running_on) < g_list_length(resource2->running_on)) { do_crm_log_unlikely(level, "%s < %s: running_on", resource1->id, resource2->id); return -1; } else if(g_list_length(resource1->running_on) > g_list_length(resource2->running_on)) { do_crm_log_unlikely(level, "%s > %s: running_on", resource1->id, resource2->id); return 1; } } if(resource1->running_on) { node1 = resource1->running_on->data; } if(resource2->running_on) { node2 = resource2->running_on->data; } if(node1) { node_t *match = pe_hash_table_lookup(resource1->allowed_nodes, node1->details->id); if(match == NULL || match->weight < 0) { do_crm_log_unlikely(level, "%s: current location is unavailable", resource1->id); node1 = NULL; can1 = FALSE; } } if(node2) { node_t *match = pe_hash_table_lookup(resource2->allowed_nodes, node2->details->id); if(match == NULL || match->weight < 0) { do_crm_log_unlikely(level, "%s: current location is unavailable", resource2->id); node2 = NULL; can2 = FALSE; } } if(can1 != can2) { if(can1) { do_crm_log_unlikely(level, "%s < %s: availability of current location", resource1->id, resource2->id); return -1; } do_crm_log_unlikely(level, "%s > %s: availability of current location", resource1->id, resource2->id); return 1; } if(resource1->priority < resource2->priority) { do_crm_log_unlikely(level, "%s < %s: priority", resource1->id, resource2->id); return 1; } else if(resource1->priority > resource2->priority) { do_crm_log_unlikely(level, "%s > %s: priority", resource1->id, resource2->id); return -1; } if(node1 == NULL && node2 == NULL) { do_crm_log_unlikely(level, "%s == %s: not active", resource1->id, resource2->id); return 0; } if(node1 != node2) { if(node1 == NULL) { do_crm_log_unlikely(level, "%s > %s: active", resource1->id, resource2->id); return 1; } else if(node2 == NULL) { do_crm_log_unlikely(level, "%s < %s: active", resource1->id, resource2->id); return -1; } } can1 = can_run_resources(node1); can2 = can_run_resources(node2); if(can1 != can2) { if(can1) { do_crm_log_unlikely(level, "%s < %s: can", resource1->id, resource2->id); return -1; } do_crm_log_unlikely(level, "%s > %s: can", resource1->id, resource2->id); return 1; } node1 = parent_node_instance(resource1, node1); node2 = parent_node_instance(resource2, node2); if(node1 != NULL && node2 == NULL) { do_crm_log_unlikely(level, "%s < %s: not allowed", resource1->id, resource2->id); return -1; } else if(node1 == NULL && node2 != NULL) { do_crm_log_unlikely(level, "%s > %s: not allowed", resource1->id, resource2->id); return 1; } if(node1 == NULL) { do_crm_log_unlikely(level, "%s == %s: not allowed", resource1->id, resource2->id); return 0; } if(node1->count < node2->count) { do_crm_log_unlikely(level, "%s < %s: count", resource1->id, resource2->id); return -1; } else if(node1->count > node2->count) { do_crm_log_unlikely(level, "%s > %s: count", resource1->id, resource2->id); return 1; } if(with_scores) { int rc = 0; int max = 0; int lpc = 0; GListPtr list1 = g_hash_table_get_values(resource1->allowed_nodes); GListPtr list2 = g_hash_table_get_values(resource2->allowed_nodes); list1 = g_list_sort_with_data(list1, sort_node_weight, g_list_nth_data(resource1->running_on, 0)); list2 = g_list_sort_with_data(list2, sort_node_weight, g_list_nth_data(resource2->running_on, 0)); max = g_list_length(list1); if(max < g_list_length(list2)) { max = g_list_length(list2); } for(;lpc < max; lpc++) { node1 = g_list_nth_data(list1, lpc); node2 = g_list_nth_data(list2, lpc); if(node1 == NULL) { do_crm_log_unlikely(level, "%s < %s: node score NULL", resource1->id, resource2->id); rc = 1; break; } else if(node2 == NULL) { do_crm_log_unlikely(level, "%s > %s: node score NULL", resource1->id, resource2->id); rc = -1; break; } if(node1->weight < node2->weight) { do_crm_log_unlikely(level, "%s < %s: node score", resource1->id, resource2->id); rc = 1; break; } else if(node1->weight > node2->weight) { do_crm_log_unlikely(level, "%s > %s: node score", resource1->id, resource2->id); rc = -1; break; } } g_list_free(list1); g_list_free(list2); if(rc != 0) { return rc; } } can1 = did_fail(resource1); can2 = did_fail(resource2); if(can1 != can2) { if(can1) { do_crm_log_unlikely(level, "%s > %s: failed", resource1->id, resource2->id); return 1; } do_crm_log_unlikely(level, "%s < %s: failed", resource1->id, resource2->id); return -1; } if(node1 && node2) { int rc = 0; int max = 0; int lpc = 0; node_t *n = NULL; GListPtr list1 = NULL; GListPtr list2 = NULL; GHashTable *hash1 = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_hash_destroy_str); GHashTable *hash2 = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_hash_destroy_str); n = node_copy(resource1->running_on->data); g_hash_table_insert(hash1, (gpointer)n->details->id, n); n = node_copy(resource2->running_on->data); g_hash_table_insert(hash2, (gpointer)n->details->id, n); /* Possibly a replacement for the with_scores block above */ slist_iter( constraint, rsc_colocation_t, resource1->parent->rsc_cons_lhs, lpc, do_crm_log_unlikely(level+1, "Applying %s to %s", constraint->id, resource1->id); - hash1 = native_merge_weights( + hash1 = rsc_merge_weights( constraint->rsc_lh, resource1->id, hash1, constraint->node_attribute, - constraint->score/INFINITY, FALSE); + constraint->score/INFINITY, FALSE, TRUE); ); slist_iter( constraint, rsc_colocation_t, resource2->parent->rsc_cons_lhs, lpc, do_crm_log_unlikely(level+1, "Applying %s to %s", constraint->id, resource2->id); - hash2 = native_merge_weights( + hash2 = rsc_merge_weights( constraint->rsc_lh, resource2->id, hash2, constraint->node_attribute, - constraint->score/INFINITY, FALSE); + constraint->score/INFINITY, FALSE, TRUE); ); list1 = g_hash_table_get_values(hash1); list2 = g_hash_table_get_values(hash2); list1 = g_list_sort_with_data(list1, sort_node_weight, g_list_nth_data(resource1->running_on, 0)); list2 = g_list_sort_with_data(list2, sort_node_weight, g_list_nth_data(resource2->running_on, 0)); max = g_list_length(list1); if(max < g_list_length(list2)) { max = g_list_length(list2); } for(;lpc < max; lpc++) { node1 = g_list_nth_data(list1, lpc); node2 = g_list_nth_data(list2, lpc); if(node1 == NULL) { do_crm_log_unlikely(level, "%s < %s: colocated score NULL", resource1->id, resource2->id); rc = 1; break; } else if(node2 == NULL) { do_crm_log_unlikely(level, "%s > %s: colocated score NULL", resource1->id, resource2->id); rc = -1; break; } if(node1->weight < node2->weight) { do_crm_log_unlikely(level, "%s < %s: colocated score", resource1->id, resource2->id); rc = 1; break; } else if(node1->weight > node2->weight) { do_crm_log_unlikely(level, "%s > %s: colocated score", resource1->id, resource2->id); rc = -1; break; } } g_hash_table_destroy(hash1); /* Free mem */ g_hash_table_destroy(hash2); /* Free mem */ g_list_free(list1); g_list_free(list2); if(rc != 0) { return rc; } } do_crm_log_unlikely(level, "%s == %s: default %d", resource1->id, resource2->id, node2->weight); return 0; } static node_t * can_run_instance(resource_t *rsc, node_t *node) { node_t *local_node = NULL; clone_variant_data_t *clone_data = NULL; if(can_run_resources(node) == FALSE) { goto bail; } else if(is_set(rsc->flags, pe_rsc_orphan)) { goto bail; } local_node = parent_node_instance(rsc, node); get_clone_variant_data(clone_data, rsc->parent); if(local_node == NULL) { crm_warn("%s cannot run on %s: node not allowed", rsc->id, node->details->uname); goto bail; } else if(local_node->count < clone_data->clone_node_max) { return local_node; } else { crm_debug_2("%s cannot run on %s: node full", rsc->id, node->details->uname); } bail: if(node) { common_update_score(rsc, node->details->id, -INFINITY); } return NULL; } static node_t * color_instance(resource_t *rsc, pe_working_set_t *data_set) { node_t *chosen = NULL; node_t *local_node = NULL; crm_debug_2("Processing %s", rsc->id); if(is_not_set(rsc->flags, pe_rsc_provisional)) { return rsc->fns->location(rsc, NULL, FALSE); } else if(is_set(rsc->flags, pe_rsc_allocating)) { crm_debug("Dependency loop detected involving %s", rsc->id); return NULL; } if(rsc->allowed_nodes) { GHashTableIter iter; node_t *try_node = NULL; g_hash_table_iter_init (&iter, rsc->allowed_nodes); while (g_hash_table_iter_next (&iter, NULL, (void**)&try_node)) { can_run_instance(rsc, try_node); } } chosen = rsc->cmds->allocate(rsc, data_set); if(chosen) { local_node = pe_hash_table_lookup( rsc->parent->allowed_nodes, chosen->details->id); if(local_node) { local_node->count++; } else if(is_set(rsc->flags, pe_rsc_managed)) { /* what to do? we can't enforce per-node limits in this case */ crm_config_err("%s not found in %s (list=%d)", chosen->details->id, rsc->parent->id, g_hash_table_size(rsc->parent->allowed_nodes)); } } return chosen; } static void append_parent_colocation(resource_t *rsc, resource_t *child, gboolean all) { slist_iter(cons, rsc_colocation_t, rsc->rsc_cons, lpc, if(all || cons->score < 0 || cons->score == INFINITY) { child->rsc_cons = g_list_prepend(child->rsc_cons, cons); } ); slist_iter(cons, rsc_colocation_t, rsc->rsc_cons_lhs, lpc, if(all || cons->score < 0) { child->rsc_cons_lhs = g_list_prepend(child->rsc_cons_lhs, cons); } ); } node_t * clone_color(resource_t *rsc, pe_working_set_t *data_set) { int allocated = 0; GHashTableIter iter; node_t *node = NULL; int available_nodes = 0; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); if(is_not_set(rsc->flags, pe_rsc_provisional)) { return NULL; } else 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); crm_debug_2("Processing %s", rsc->id); /* this information is used by sort_clone_instance() when deciding in which * order to allocate clone instances */ slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons_lhs, lpc, rsc->allowed_nodes = constraint->rsc_lh->cmds->merge_weights( constraint->rsc_lh, rsc->id, rsc->allowed_nodes, - constraint->node_attribute, constraint->score/INFINITY, TRUE); + constraint->node_attribute, constraint->score/INFINITY, TRUE, TRUE); ); dump_node_scores(show_scores?0:scores_log_level, rsc, __FUNCTION__, rsc->allowed_nodes); /* count now tracks the number of clones currently allocated */ g_hash_table_iter_init (&iter, rsc->allowed_nodes); while (g_hash_table_iter_next (&iter, NULL, (void**)&node)) { node->count = 0; } slist_iter(child, resource_t, rsc->children, lpc, if(g_list_length(child->running_on) > 0) { node_t *child_node = child->running_on->data; node_t *local_node = parent_node_instance( child, child->running_on->data); if(local_node) { local_node->count++; } else { crm_err("%s is running on %s which isn't allowed", child->id, child_node->details->uname); } } ); rsc->children = g_list_sort_with_data(rsc->children, sort_clone_instance, data_set); /* count now tracks the number of clones we have allocated */ g_hash_table_iter_init (&iter, rsc->allowed_nodes); while (g_hash_table_iter_next (&iter, NULL, (void**)&node)) { node->count = 0; } /* allowed = g_hash_table_get_values(rsc->allowed_nodes); allowed = g_list_sort_with_data( allowed, sort_node_weight, data_set); */ g_hash_table_iter_init (&iter, rsc->allowed_nodes); while (g_hash_table_iter_next (&iter, NULL, (void**)&node)) { if(can_run_resources(node)) { available_nodes++; } } slist_iter(child, resource_t, rsc->children, lpc, if(allocated >= clone_data->clone_max) { crm_debug("Child %s not allocated - limit reached", child->id); resource_location(child, NULL, -INFINITY, "clone_color:limit_reached", data_set); } else if (clone_data->clone_max < available_nodes) { /* Only include positive colocation preferences of dependant resources * if not every node will get a copy of the clone */ append_parent_colocation(rsc, child, TRUE); } else { append_parent_colocation(rsc, child, FALSE); } if(color_instance(child, data_set)) { allocated++; } ); crm_debug("Allocated %d %s instances of a possible %d", allocated, rsc->id, clone_data->clone_max); clear_bit(rsc->flags, pe_rsc_provisional); clear_bit(rsc->flags, pe_rsc_allocating); return NULL; } static void clone_update_pseudo_status( resource_t *rsc, gboolean *stopping, gboolean *starting, gboolean *active) { if(rsc->children) { slist_iter(child, resource_t, rsc->children, lpc, clone_update_pseudo_status(child, stopping, starting, active) ); return; } CRM_ASSERT(active != NULL); CRM_ASSERT(starting != NULL); CRM_ASSERT(stopping != NULL); if(rsc->running_on) { *active = TRUE; } slist_iter( action, action_t, rsc->actions, lpc, if(*starting && *stopping) { return; } else if(is_set(action->flags, pe_action_optional)) { crm_debug_3("Skipping optional: %s", action->uuid); continue; } else if(is_set(action->flags, pe_action_pseudo) == FALSE && is_set(action->flags, pe_action_runnable) == FALSE){ crm_debug_3("Skipping unrunnable: %s", action->uuid); continue; } else if(safe_str_eq(RSC_STOP, action->task)) { crm_debug_2("Stopping due to: %s", action->uuid); *stopping = TRUE; } else if(safe_str_eq(RSC_START, action->task)) { if(is_set(action->flags, pe_action_runnable) == FALSE) { crm_debug_3("Skipping pseudo-op: %s run=%d, pseudo=%d", action->uuid, is_set(action->flags, pe_action_runnable), is_set(action->flags, pe_action_pseudo)); } else { crm_debug_2("Starting due to: %s", action->uuid); crm_debug_3("%s run=%d, pseudo=%d", action->uuid, is_set(action->flags, pe_action_runnable), is_set(action->flags, pe_action_pseudo)); *starting = TRUE; } } ); } static action_t * find_rsc_action(resource_t *rsc, const char *key, gboolean active_only, GListPtr *list) { action_t *match = NULL; GListPtr possible = NULL; GListPtr active = NULL; possible = find_actions(rsc->actions, key, NULL); if(active_only) { slist_iter(op, action_t, possible, lpc, if(is_set(op->flags, pe_action_optional) == FALSE) { active = g_list_prepend(active, op); } ); if(active && g_list_length(active) == 1) { match = g_list_nth_data(active, 0); } if(list) { *list = active; active = NULL; } } else if(possible && g_list_length(possible) == 1) { match = g_list_nth_data(possible, 0); } if(list) { *list = possible; possible = NULL; } if(possible) { g_list_free(possible); } if(active) { g_list_free(active); } return match; } static void child_ordering_constraints(resource_t *rsc, pe_working_set_t *data_set) { char *key = NULL; action_t *stop = NULL; action_t *start = NULL; action_t *last_stop = NULL; action_t *last_start = NULL; gboolean active_only = TRUE; /* change to false to get the old behavior */ clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); if(clone_data->ordered == FALSE) { return; } slist_iter( child, resource_t, rsc->children, lpc, key = stop_key(child); stop = find_rsc_action(child, key, active_only, NULL); crm_free(key); key = start_key(child); start = find_rsc_action(child, key, active_only, NULL); crm_free(key); if(stop) { if(last_stop) { /* child/child relative stop */ order_actions(stop, last_stop, pe_order_optional); } last_stop = stop; } if(start) { if(last_start) { /* child/child relative start */ order_actions(last_start, start, pe_order_optional); } last_start = start; } ); } void clone_create_actions(resource_t *rsc, pe_working_set_t *data_set) { gboolean child_active = FALSE; gboolean child_starting = FALSE; gboolean child_stopping = FALSE; action_t *stop = NULL; action_t *stopped = NULL; action_t *start = NULL; action_t *started = NULL; resource_t *last_start_rsc = NULL; resource_t *last_stop_rsc = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); crm_debug_2("Creating actions for %s", rsc->id); slist_iter( child_rsc, resource_t, rsc->children, lpc, child_rsc->cmds->create_actions(child_rsc, data_set); clone_update_pseudo_status( child_rsc, &child_stopping, &child_starting, &child_active); if(is_set(child_rsc->flags, pe_rsc_starting)) { last_start_rsc = child_rsc; } if(is_set(child_rsc->flags, pe_rsc_stopping)) { last_stop_rsc = child_rsc; } ); /* start */ start = start_action(rsc, NULL, !child_starting); started = custom_action(rsc, started_key(rsc), RSC_STARTED, NULL, !child_starting, TRUE, data_set); update_action_flags(start, pe_action_pseudo|pe_action_runnable); update_action_flags(started, pe_action_pseudo); started->priority = INFINITY; if(child_active || child_starting) { update_action_flags(started, pe_action_runnable); } child_ordering_constraints(rsc, data_set); if(clone_data->start_notify == NULL) { clone_data->start_notify = create_notification_boundaries(rsc, RSC_START, start, started, data_set); } /* stop */ stop = stop_action(rsc, NULL, !child_stopping); stopped = custom_action(rsc, stopped_key(rsc), RSC_STOPPED, NULL, !child_stopping, TRUE, data_set); stopped->priority = INFINITY; update_action_flags(stop, pe_action_pseudo|pe_action_runnable); update_action_flags(stopped, pe_action_pseudo|pe_action_runnable); if(clone_data->stop_notify == NULL) { clone_data->stop_notify = create_notification_boundaries(rsc, RSC_STOP, stop, stopped, data_set); if(clone_data->stop_notify && clone_data->start_notify) { order_actions(clone_data->stop_notify->post_done, clone_data->start_notify->pre, pe_order_optional); } } } void clone_internal_constraints(resource_t *rsc, pe_working_set_t *data_set) { resource_t *last_rsc = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); crm_trace("Internal constraints for %s", rsc->id); new_rsc_order(rsc, RSC_STOPPED, rsc, RSC_START, pe_order_optional, data_set); new_rsc_order(rsc, RSC_START, rsc, RSC_STARTED, pe_order_runnable_left, data_set); new_rsc_order(rsc, RSC_STOP, rsc, RSC_STOPPED, pe_order_runnable_left, data_set); if(rsc->variant == pe_master) { new_rsc_order(rsc, RSC_DEMOTED, rsc, RSC_STOP, pe_order_optional, data_set); new_rsc_order(rsc, RSC_STARTED, rsc, RSC_PROMOTE, pe_order_runnable_left, data_set); } slist_iter( child_rsc, resource_t, rsc->children, lpc, child_rsc->cmds->internal_constraints(child_rsc, data_set); order_start_start(rsc, child_rsc, pe_order_runnable_left|pe_order_implies_first_printed); new_rsc_order(child_rsc, RSC_START, rsc, RSC_STARTED, pe_order_implies_then_printed, data_set); if(clone_data->ordered && last_rsc){ order_start_start(last_rsc, child_rsc, pe_order_optional); } order_stop_stop(rsc, child_rsc, pe_order_implies_first_printed); new_rsc_order(child_rsc, RSC_STOP, rsc, RSC_STOPPED, pe_order_implies_then_printed, data_set); if(clone_data->ordered && last_rsc){ order_stop_stop(child_rsc, last_rsc, pe_order_optional); } last_rsc = child_rsc; ); } static void assign_node(resource_t *rsc, node_t *node, gboolean force) { if(rsc->children) { slist_iter( child_rsc, resource_t, rsc->children, lpc, native_assign_node(child_rsc, NULL, node, force); ); return; } native_assign_node(rsc, NULL, node, force); } static resource_t* find_compatible_child_by_node( resource_t *local_child, node_t *local_node, resource_t *rsc, enum rsc_role_e filter, gboolean current) { node_t *node = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); if(local_node == NULL) { crm_err("Can't colocate unrunnable child %s with %s", local_child->id, rsc->id); return NULL; } crm_trace("Looking for compatible child from %s for %s on %s", local_child->id, rsc->id, local_node->details->uname); slist_iter( child_rsc, resource_t, rsc->children, lpc, /* enum rsc_role_e next_role = minimum_resource_state(child_rsc, current); */ enum rsc_role_e next_role = child_rsc->fns->state(child_rsc, current); node = child_rsc->fns->location(child_rsc, NULL, current); if(filter != RSC_ROLE_UNKNOWN && next_role != filter) { crm_trace("Filtered %s", child_rsc->id); continue; } if(node && local_node && node->details == local_node->details) { crm_debug_2("Pairing %s with %s on %s", local_child->id, child_rsc->id, node->details->uname); return child_rsc; } else if(node) { crm_trace("%s - %s vs %s", child_rsc->id, node->details->uname, local_node->details->uname); } else { crm_trace("%s - not allocated %d", child_rsc->id, current); } ); crm_debug_3("Can't pair %s with %s", local_child->id, rsc->id); return NULL; } resource_t* find_compatible_child( resource_t *local_child, resource_t *rsc, enum rsc_role_e filter, gboolean current) { resource_t *pair = NULL; GListPtr scratch = NULL; node_t *local_node = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); local_node = local_child->fns->location(local_child, NULL, current); if(local_node) { return find_compatible_child_by_node(local_child, local_node, rsc, filter, current); } scratch = g_hash_table_get_values(local_child->allowed_nodes); scratch = g_list_sort_with_data(scratch, sort_node_weight, NULL); slist_iter( node, node_t, scratch, lpc, pair = find_compatible_child_by_node( local_child, node, rsc, filter, current); if(pair) { goto done; } ); crm_debug("Can't pair %s with %s", local_child->id, rsc->id); done: g_list_free(scratch); return pair; } void clone_rsc_colocation_lh( resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint) { /* -- Never called -- * * Instead we add the colocation constraints to the child and call from there */ CRM_CHECK(FALSE, crm_err("This functionality is not thought to be used. Please report a bug.")); CRM_CHECK(rsc_lh, return); CRM_CHECK(rsc_rh, return); slist_iter( child_rsc, resource_t, rsc_lh->children, lpc, child_rsc->cmds->rsc_colocation_lh(child_rsc, rsc_rh, constraint); ); return; } void clone_rsc_colocation_rh( resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint) { gboolean do_interleave = FALSE; clone_variant_data_t *clone_data = NULL; clone_variant_data_t *clone_data_lh = NULL; CRM_CHECK(rsc_lh != NULL, return); CRM_CHECK(rsc_lh->variant == pe_native, return); get_clone_variant_data(clone_data, constraint->rsc_rh); crm_debug_3("Processing constraint %s: %s -> %s %d", constraint->id, rsc_lh->id, rsc_rh->id, constraint->score); if(constraint->rsc_lh->variant >= pe_clone) { get_clone_variant_data(clone_data_lh, constraint->rsc_lh); if(clone_data->clone_node_max != clone_data_lh->clone_node_max) { crm_config_err("Cannot interleave "XML_CIB_TAG_INCARNATION " %s and %s because" " they do not support the same number of" " resources per node", constraint->rsc_lh->id, constraint->rsc_rh->id); /* only the LHS side needs to be labeled as interleave */ } else if(clone_data_lh->interleave) { do_interleave = TRUE; } } if(rsc_rh == NULL) { pe_err("rsc_rh was NULL for %s", constraint->id); return; } else if(is_set(rsc_rh->flags, pe_rsc_provisional)) { crm_debug_3("%s is still provisional", rsc_rh->id); return; } else if(do_interleave) { resource_t *rh_child = NULL; rh_child = find_compatible_child(rsc_lh, rsc_rh, RSC_ROLE_UNKNOWN, FALSE); if(rh_child) { crm_debug("Pairing %s with %s", rsc_lh->id, rh_child->id); rsc_lh->cmds->rsc_colocation_lh(rsc_lh, rh_child, constraint); } else if(constraint->score >= INFINITY) { crm_notice("Cannot pair %s with instance of %s", rsc_lh->id, rsc_rh->id); assign_node(rsc_lh, NULL, TRUE); } else { crm_debug("Cannot pair %s with instance of %s", rsc_lh->id, rsc_rh->id); } return; } else if(constraint->score >= INFINITY) { GListPtr rhs = NULL; slist_iter( child_rsc, resource_t, rsc_rh->children, lpc, node_t *chosen = child_rsc->fns->location(child_rsc, NULL, FALSE); if(chosen != NULL) { rhs = g_list_prepend(rhs, chosen); } ); node_list_exclude(rsc_lh->allowed_nodes, rhs, FALSE); g_list_free(rhs); return; } slist_iter( child_rsc, resource_t, rsc_rh->children, lpc, child_rsc->cmds->rsc_colocation_rh(rsc_lh, child_rsc, constraint); ); } static enum action_tasks clone_child_action(action_t *action) { enum action_tasks result = no_action; if(safe_str_eq(action->task, "notify") || safe_str_eq(action->task, "notified")) { /* Find the action we're notifying about instead */ int stop = 0; char *key = action->uuid; int lpc = strlen(key); for(; lpc > 0; lpc--) { if(key[lpc] == '_' && stop == 0) { stop = lpc; } else if(key[lpc] == '_') { char *task_mutable = NULL; lpc++; task_mutable = crm_strdup(key+lpc); task_mutable[stop-lpc] = 0; crm_trace("Extracted action '%s' from '%s'", task_mutable, key); result = text2task(task_mutable); crm_free(task_mutable); break; } } } else { result = text2task(action->task); } switch(result) { case stopped_rsc: case started_rsc: case action_demoted: case action_promoted: result--; break; default: break; } return result; } enum pe_action_flags clone_action_flags(action_t *action, node_t *node) { gboolean any_runnable = FALSE; gboolean check_runnable = TRUE; enum action_tasks task = clone_child_action(action); enum pe_action_flags flags = (pe_action_optional | pe_action_runnable | pe_action_pseudo); const char *task_s = task2text(task); slist_iter( child, resource_t, action->rsc->children, lpc, action_t *child_action = NULL; child_action = find_first_action(child->actions, NULL, task_s, child->children?NULL:node); crm_trace("Checking for %s in %s on %s", task_s, child->id, node?node->details->uname:"none"); if(child_action) { enum pe_action_flags child_flags = child->cmds->action_flags(child_action, node); if(is_set(flags, pe_action_optional) && is_set(child_flags, pe_action_optional) == FALSE) { crm_trace("%s is manditory because of %s", action->uuid, child_action->uuid); clear_bit_inplace(flags, pe_action_optional); clear_bit_inplace(action->flags, pe_action_optional); } if(is_set(child_flags, pe_action_runnable)) { any_runnable = TRUE; } } else { slist_iter(op, action_t, child->actions, lpc2, crm_trace("%s on %s (%s)", op->uuid, op->node?op->node->details->uname:"none", op->task)); } ); if(check_runnable && any_runnable == FALSE) { crm_trace("%s is not runnable because no children are", action->uuid); clear_bit_inplace(flags, pe_action_runnable); if(node == NULL) { clear_bit_inplace(action->flags, pe_action_runnable); } } return flags; } static enum pe_graph_flags clone_update_actions_interleave( action_t *first, action_t *then, node_t *node, enum pe_action_flags flags, enum pe_action_flags filter, enum pe_ordering type) { gboolean current = FALSE; resource_t *first_child = NULL; enum pe_graph_flags changed = pe_graph_none; /*pe_graph_disable*/ enum action_tasks task = clone_child_action(first); const char *first_task = task2text(task); /* Fix this - lazy */ if(strstr(first->uuid, "_stopped_0") || strstr(first->uuid, "_demoted_0")) { current = TRUE; } slist_iter( then_child, resource_t, then->rsc->children, lpc, CRM_ASSERT(then_child != NULL); first_child = find_compatible_child(then_child, first->rsc, RSC_ROLE_UNKNOWN, current); if(first_child == NULL && current) { crm_trace("Ignore"); } else if(first_child == NULL) { crm_debug("No match found for %s (%d / %s / %s)", then_child->id, current, first->uuid, then->uuid); /* Me no like this hack - but what else can we do? * * If there is no-one active or about to be active * on the same node as then_child, then they must * not be allowed to start */ if(type & (pe_order_runnable_left|pe_order_implies_then) /* Mandatory */) { crm_info("Inhibiting %s from being active", then_child->id); assign_node(then_child, NULL, TRUE); } } else { action_t *first_action = NULL; action_t *then_action = NULL; crm_debug("Pairing %s with %s", first_child->id, then_child->id); first_action = find_first_action(first_child->actions, NULL, first_task, node); then_action = find_first_action(then_child->actions, NULL, then->task, node); CRM_CHECK(first_action != NULL, crm_err("No action found for %s in %s (first)", first_task, first_child->id)); CRM_CHECK(then_action != NULL, crm_err("No action found for %s in %s (then)", then->task, then_child->id)); if(first_action == NULL || then_action == NULL) { continue; } if(order_actions(first_action, then_action, type)) { crm_debug("Created constraint for %s -> %s", first_action->uuid, then_action->uuid); changed |= (pe_graph_updated_first|pe_graph_updated_then); } changed |= then_child->cmds->update_actions(first_action, then_action, node, then_child->cmds->action_flags(then_action, node), filter, type); } ); return changed; } enum pe_graph_flags clone_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) { const char *rsc = "none"; gboolean interleave = FALSE; enum pe_graph_flags changed = pe_graph_none; if(first->rsc != then->rsc && first->rsc && first->rsc->variant >= pe_clone && then->rsc && then->rsc->variant >= pe_clone) { clone_variant_data_t *clone_data = NULL; if(strstr(then->uuid, "_stop_0") || strstr(then->uuid, "_demote_0")) { get_clone_variant_data(clone_data, first->rsc); rsc = first->rsc->id; } else { get_clone_variant_data(clone_data, then->rsc); rsc = then->rsc->id; } interleave = clone_data->interleave; } crm_trace("Interleave %s -> %s: %s (based on %s)", first->uuid, then->uuid, interleave?"yes":"no", rsc); if(interleave) { changed = clone_update_actions_interleave(first, then, node, flags, filter, type); } else { changed |= native_update_actions(first, then, node, flags, filter, type); slist_iter( child, resource_t, then->rsc->children, lpc, action_t *child_action = find_first_action(child->actions, NULL, then->task, node); if(child_action) { enum pe_action_flags child_flags = child->cmds->action_flags(child_action, node); if(is_set(child_flags, pe_action_runnable)) { changed |= child->cmds->update_actions(first, child_action, node, flags, filter, type); } } ); } return changed; } void clone_rsc_location(resource_t *rsc, rsc_to_node_t *constraint) { clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); crm_debug_3("Processing location constraint %s for %s", constraint->id, rsc->id); native_rsc_location(rsc, constraint); slist_iter( child_rsc, resource_t, rsc->children, lpc, child_rsc->cmds->rsc_location(child_rsc, constraint); ); } void clone_expand(resource_t *rsc, pe_working_set_t *data_set) { clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); slist_iter(op, action_t, rsc->actions, lpc, rsc->cmds->action_flags(op, NULL); ); if(clone_data->start_notify) { collect_notification_data(rsc, TRUE, TRUE, clone_data->start_notify); expand_notification_data(clone_data->start_notify); create_notifications(rsc, clone_data->start_notify, data_set); } if(clone_data->stop_notify) { collect_notification_data(rsc, TRUE, TRUE, clone_data->stop_notify); expand_notification_data(clone_data->stop_notify); create_notifications(rsc, clone_data->stop_notify, data_set); } if(clone_data->promote_notify) { collect_notification_data(rsc, TRUE, TRUE, clone_data->promote_notify); expand_notification_data(clone_data->promote_notify); create_notifications(rsc, clone_data->promote_notify, data_set); } if(clone_data->demote_notify) { collect_notification_data(rsc, TRUE, TRUE, clone_data->demote_notify); expand_notification_data(clone_data->demote_notify); create_notifications(rsc, clone_data->demote_notify, data_set); } /* Now that the notifcations have been created we can expand the children */ slist_iter( child_rsc, resource_t, rsc->children, lpc, child_rsc->cmds->expand(child_rsc, data_set)); native_expand(rsc, data_set); /* The notifications are in the graph now, we can destroy the notify_data */ free_notification_data(clone_data->demote_notify); clone_data->demote_notify = NULL; free_notification_data(clone_data->stop_notify); clone_data->stop_notify = NULL; free_notification_data(clone_data->start_notify); clone_data->start_notify = NULL; free_notification_data(clone_data->promote_notify); clone_data->promote_notify = NULL; } static gint sort_rsc_id(gconstpointer a, gconstpointer b) { const resource_t *resource1 = (const resource_t*)a; const resource_t *resource2 = (const resource_t*)b; CRM_ASSERT(resource1 != NULL); CRM_ASSERT(resource2 != NULL); return strcmp(resource1->id, resource2->id); } node_t *rsc_known_on(resource_t *rsc, GListPtr *list) { node_t *one = NULL; GListPtr result = NULL; if(rsc->children) { slist_iter(child, resource_t, rsc->children, lpc, rsc_known_on(child, &result); ); } else if(rsc->known_on) { result = g_hash_table_get_values(rsc->known_on); } if(result && g_list_length(result) == 1) { one = g_list_nth_data(result, 0); } if(list) { slist_iter(node, node_t, result, lpc, if(*list == NULL || pe_find_node_id(*list, node->details->id) == NULL) { *list = g_list_prepend(*list, node); } ); } g_list_free(result); return one; } static resource_t *find_instance_on(resource_t *rsc, node_t *node) { slist_iter(child, resource_t, rsc->children, lpc, GListPtr known_list = NULL; rsc_known_on(child, &known_list); slist_iter(known, node_t, known_list, lpc2, if(node->details == known->details) { g_list_free(known_list); return child; } ); g_list_free(known_list); ); return NULL; } gboolean clone_create_probe(resource_t *rsc, node_t *node, action_t *complete, gboolean force, pe_working_set_t *data_set) { gboolean any_created = FALSE; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); rsc->children = g_list_sort(rsc->children, sort_rsc_id); if(rsc->children == NULL) { pe_warn("Clone %s has no children", rsc->id); return FALSE; } if(is_not_set(rsc->flags, pe_rsc_unique) && clone_data->clone_node_max == 1) { /* only look for one copy */ resource_t *child = NULL; /* Try whoever we probed last time */ child = find_instance_on(rsc, node); if(child) { return child->cmds->create_probe( child, node, complete, force, data_set); } /* Try whoever we plan on starting there */ slist_iter( child_rsc, resource_t, rsc->children, lpc, node_t *local_node = child_rsc->fns->location(child_rsc, NULL, FALSE); if(local_node == NULL) { continue; } if(local_node->details == node->details) { return child_rsc->cmds->create_probe( child_rsc, node, complete, force, data_set); } ); /* Fall back to the first clone instance */ child = rsc->children->data; return child->cmds->create_probe(child, node, complete, force, data_set); } slist_iter( child_rsc, resource_t, rsc->children, lpc, if(child_rsc->cmds->create_probe( child_rsc, node, complete, force, data_set)) { any_created = TRUE; } if(any_created && is_not_set(rsc->flags, pe_rsc_unique) && clone_data->clone_node_max == 1) { /* only look for one copy (clone :0) */ break; } ); return any_created; } void clone_append_meta(resource_t *rsc, xmlNode *xml) { char *name = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); name = crm_meta_name(XML_RSC_ATTR_UNIQUE); crm_xml_add(xml, name, is_set(rsc->flags, pe_rsc_unique)?"true":"false"); crm_free(name); name = crm_meta_name(XML_RSC_ATTR_NOTIFY); crm_xml_add(xml, name, is_set(rsc->flags, pe_rsc_notify)?"true":"false"); crm_free(name); name = crm_meta_name(XML_RSC_ATTR_INCARNATION_MAX); crm_xml_add_int(xml, name, clone_data->clone_max); crm_free(name); name = crm_meta_name(XML_RSC_ATTR_INCARNATION_NODEMAX); crm_xml_add_int(xml, name, clone_data->clone_node_max); crm_free(name); } diff --git a/pengine/group.c b/pengine/group.c index b0800a69f8..4dd376f390 100644 --- a/pengine/group.c +++ b/pengine/group.c @@ -1,481 +1,481 @@ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #define VARIANT_GROUP 1 #include node_t * group_color(resource_t *rsc, pe_working_set_t *data_set) { node_t *node = NULL; node_t *group_node = NULL; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); if(is_not_set(rsc->flags, pe_rsc_provisional)) { return rsc->allocated_to; } crm_debug_2("Processing %s", rsc->id); if(is_set(rsc->flags, pe_rsc_allocating)) { crm_debug("Dependency loop detected involving %s", rsc->id); return NULL; } if(group_data->first_child == NULL) { /* nothign to allocate */ clear_bit(rsc->flags, pe_rsc_provisional); return NULL; } set_bit(rsc->flags, pe_rsc_allocating); rsc->role = group_data->first_child->role; group_data->first_child->rsc_cons = g_list_concat( group_data->first_child->rsc_cons, rsc->rsc_cons); rsc->rsc_cons = NULL; group_data->first_child->rsc_cons_lhs = g_list_concat( group_data->first_child->rsc_cons_lhs, rsc->rsc_cons_lhs); rsc->rsc_cons_lhs = NULL; dump_node_scores(show_scores?0:scores_log_level, rsc, __PRETTY_FUNCTION__, rsc->allowed_nodes); slist_iter( child_rsc, resource_t, rsc->children, lpc, node = child_rsc->cmds->allocate(child_rsc, data_set); if(group_node == NULL) { group_node = node; } ); rsc->next_role = group_data->first_child->next_role; clear_bit(rsc->flags, pe_rsc_allocating); clear_bit(rsc->flags, pe_rsc_provisional); if(group_data->colocated) { return group_node; } return NULL; } void group_update_pseudo_status(resource_t *parent, resource_t *child); void group_create_actions(resource_t *rsc, pe_working_set_t *data_set) { action_t *op = NULL; const char *value = NULL; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); crm_debug_2("Creating actions for %s", rsc->id); slist_iter( child_rsc, resource_t, rsc->children, lpc, child_rsc->cmds->create_actions(child_rsc, data_set); group_update_pseudo_status(rsc, child_rsc); ); op = start_action(rsc, NULL, TRUE/* !group_data->child_starting */); set_bit_inplace(op->flags, pe_action_pseudo|pe_action_runnable); op = custom_action(rsc, started_key(rsc), RSC_STARTED, NULL, TRUE/* !group_data->child_starting */, TRUE, data_set); set_bit_inplace(op->flags, pe_action_pseudo|pe_action_runnable); op = stop_action(rsc, NULL, TRUE/* !group_data->child_stopping */); set_bit_inplace(op->flags, pe_action_pseudo|pe_action_runnable); op = custom_action(rsc, stopped_key(rsc), RSC_STOPPED, NULL, TRUE/* !group_data->child_stopping */, TRUE, data_set); set_bit_inplace(op->flags, pe_action_pseudo|pe_action_runnable); value = g_hash_table_lookup(rsc->meta, "stateful"); if(crm_is_true(value)) { op = custom_action(rsc, demote_key(rsc), RSC_DEMOTE, NULL, TRUE, TRUE, data_set); set_bit_inplace(op->flags, pe_action_pseudo); set_bit_inplace(op->flags, pe_action_runnable); op = custom_action(rsc, demoted_key(rsc), RSC_DEMOTED, NULL, TRUE, TRUE, data_set); set_bit_inplace(op->flags, pe_action_pseudo); set_bit_inplace(op->flags, pe_action_runnable); op = custom_action(rsc, promote_key(rsc), RSC_PROMOTE, NULL, TRUE, TRUE, data_set); set_bit_inplace(op->flags, pe_action_pseudo); set_bit_inplace(op->flags, pe_action_runnable); op = custom_action(rsc, promoted_key(rsc), RSC_PROMOTED, NULL, TRUE, TRUE, data_set); set_bit_inplace(op->flags, pe_action_pseudo); set_bit_inplace(op->flags, pe_action_runnable); } } void group_update_pseudo_status(resource_t *parent, resource_t *child) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, parent); if(group_data->ordered == FALSE) { /* If this group is not ordered, then leave the meta-actions as optional */ return; } if(group_data->child_stopping && group_data->child_starting) { return; } slist_iter( action, action_t, child->actions, lpc, if(is_set(action->flags, pe_action_optional)) { continue; } if(safe_str_eq(RSC_STOP, action->task) && is_set(action->flags, pe_action_runnable)) { group_data->child_stopping = TRUE; crm_debug_3("Based on %s the group is stopping", action->uuid); } else if(safe_str_eq(RSC_START, action->task) && is_set(action->flags, pe_action_runnable)) { group_data->child_starting = TRUE; crm_debug_3("Based on %s the group is starting", action->uuid); } ); } void group_internal_constraints(resource_t *rsc, pe_working_set_t *data_set) { resource_t *last_rsc = NULL; resource_t *top = uber_parent(rsc); group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); new_rsc_order(rsc, RSC_STOPPED, rsc, RSC_START, pe_order_optional, data_set); new_rsc_order(rsc, RSC_START, rsc, RSC_STARTED, pe_order_runnable_left, data_set); new_rsc_order(rsc, RSC_STOP, rsc, RSC_STOPPED, pe_order_runnable_left, data_set); slist_iter( child_rsc, resource_t, rsc->children, lpc, int stop = pe_order_none; int stopped = pe_order_implies_then_printed; int start = pe_order_implies_then|pe_order_runnable_left; int started = pe_order_runnable_left|pe_order_implies_then|pe_order_implies_then_printed; child_rsc->cmds->internal_constraints(child_rsc, data_set); if(last_rsc == NULL) { if(group_data->ordered) { stop |= pe_order_optional; stopped = pe_order_implies_then; } } else if(group_data->colocated) { rsc_colocation_new( "group:internal_colocation", NULL, INFINITY, child_rsc, last_rsc, NULL, NULL, data_set); } if(top->variant == pe_master) { new_rsc_order(rsc, RSC_DEMOTE, child_rsc, RSC_DEMOTE, stop|pe_order_implies_first_printed, data_set); new_rsc_order(child_rsc, RSC_DEMOTE, rsc, RSC_DEMOTED, stopped, data_set); new_rsc_order(child_rsc, RSC_PROMOTE, rsc, RSC_PROMOTED, started, data_set); new_rsc_order(rsc, RSC_PROMOTE, child_rsc, RSC_PROMOTE, pe_order_implies_first_printed, data_set); } order_start_start(rsc, child_rsc, pe_order_implies_first_printed); order_stop_stop(rsc, child_rsc, stop|pe_order_implies_first_printed); new_rsc_order(child_rsc, RSC_STOP, rsc, RSC_STOPPED, stopped, data_set); new_rsc_order(child_rsc, RSC_START, rsc, RSC_STARTED, started, data_set); if(group_data->ordered == FALSE) { order_start_start(rsc, child_rsc, start|pe_order_implies_first_printed); if(top->variant == pe_master) { new_rsc_order(rsc, RSC_PROMOTE, child_rsc, RSC_PROMOTE, start|pe_order_implies_first_printed, data_set); } } else if(last_rsc != NULL) { child_rsc->restart_type = pe_restart_restart; order_start_start(last_rsc, child_rsc, start); order_stop_stop(child_rsc, last_rsc, pe_order_optional); if(top->variant == pe_master) { new_rsc_order(last_rsc, RSC_PROMOTE, child_rsc, RSC_PROMOTE, start, data_set); new_rsc_order(child_rsc, RSC_DEMOTE, last_rsc, RSC_DEMOTE, pe_order_optional, data_set); } } else { /* If anyone in the group is starting, then * pe_order_implies_then will cause _everyone_ in the group * to be sent a start action * But this is safe since starting something that is already * started is required to be "safe" */ int flags = pe_order_none; order_start_start(rsc, child_rsc, flags); if(top->variant == pe_master) { new_rsc_order(rsc, RSC_PROMOTE, child_rsc, RSC_PROMOTE, flags, data_set); } } last_rsc = child_rsc; ); if(group_data->ordered && last_rsc != NULL) { int stop_stop_flags = pe_order_implies_then; int stop_stopped_flags = pe_order_optional; order_stop_stop(rsc, last_rsc, stop_stop_flags); new_rsc_order(last_rsc, RSC_STOP, rsc, RSC_STOPPED, stop_stopped_flags, data_set); if(top->variant == pe_master) { new_rsc_order(rsc, RSC_DEMOTE, last_rsc, RSC_DEMOTE, stop_stop_flags, data_set); new_rsc_order(last_rsc, RSC_DEMOTE, rsc, RSC_DEMOTED, stop_stopped_flags, data_set); } } } void group_rsc_colocation_lh( resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint) { group_variant_data_t *group_data = NULL; if(rsc_lh == NULL) { pe_err("rsc_lh was NULL for %s", constraint->id); return; } else if(rsc_rh == NULL) { pe_err("rsc_rh was NULL for %s", constraint->id); return; } crm_debug_4("Processing constraints from %s", rsc_lh->id); get_group_variant_data(group_data, rsc_lh); if(group_data->colocated) { group_data->first_child->cmds->rsc_colocation_lh( group_data->first_child, rsc_rh, constraint); return; } else if(constraint->score >= INFINITY) { crm_config_err("%s: Cannot perform manditory colocation" " between non-colocated group and %s", rsc_lh->id, rsc_rh->id); return; } slist_iter( child_rsc, resource_t, rsc_lh->children, lpc, child_rsc->cmds->rsc_colocation_lh( child_rsc, rsc_rh, constraint); ); } void group_rsc_colocation_rh( resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc_rh); CRM_CHECK(rsc_lh->variant == pe_native, return); crm_debug_3("Processing RH of constraint %s", constraint->id); print_resource(LOG_DEBUG_3, "LHS", rsc_lh, TRUE); if(is_set(rsc_rh->flags, pe_rsc_provisional)) { return; } else if(group_data->colocated && group_data->first_child) { if(constraint->score >= INFINITY) { /* Ensure RHS is _fully_ up before can start LHS */ group_data->last_child->cmds->rsc_colocation_rh( rsc_lh, group_data->last_child, constraint); } else { /* A partially active RHS is fine */ group_data->first_child->cmds->rsc_colocation_rh( rsc_lh, group_data->first_child, constraint); } return; } else if(constraint->score >= INFINITY) { crm_config_err("%s: Cannot perform manditory colocation with" " non-colocated group: %s", rsc_lh->id, rsc_rh->id); return; } slist_iter( child_rsc, resource_t, rsc_rh->children, lpc, child_rsc->cmds->rsc_colocation_rh( rsc_lh, child_rsc, constraint); ); } enum pe_action_flags group_action_flags(action_t *action, node_t *node) { gboolean check_runnable = FALSE; const char *task_s = action->task; enum action_tasks task = text2task(task_s); enum pe_action_flags flags = (pe_action_optional | pe_action_runnable | pe_action_pseudo); switch(task) { case stopped_rsc: case started_rsc: case action_demoted: case action_promoted: task_s = task2text(task-1); check_runnable = TRUE; break; default: break; } slist_iter( child, resource_t, action->rsc->children, lpc, action_t *child_action = find_first_action(child->actions, NULL, task_s, node); if(child_action) { enum pe_action_flags child_flags = child->cmds->action_flags(child_action, node); if(is_set(flags, pe_action_optional) && is_set(child_flags, pe_action_optional) == FALSE) { crm_trace("%s is manditory because of %s", action->uuid, child_action->uuid); clear_bit_inplace(flags, pe_action_optional); clear_bit_inplace(action->flags, pe_action_optional); } if(check_runnable && is_set(flags, pe_action_runnable) && is_set(child_flags, pe_action_runnable) == FALSE) { crm_trace("%s is not runnable because of %s", action->uuid, child_action->uuid); clear_bit_inplace(flags, pe_action_runnable); clear_bit_inplace(action->flags, pe_action_runnable); } } ); return flags; } enum pe_graph_flags group_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; CRM_ASSERT(then->rsc != NULL); changed |= native_update_actions(first, then, node, flags, filter, type); slist_iter( child, resource_t, then->rsc->children, lpc, action_t *child_action = find_first_action(child->actions, NULL, then->task, node); if(child_action) { changed |= child->cmds->update_actions(first, child_action, node, flags, filter, type); } ); return changed; } void group_rsc_location(resource_t *rsc, rsc_to_node_t *constraint) { GListPtr saved = constraint->node_list_rh; GListPtr zero = node_list_dup(constraint->node_list_rh, TRUE, FALSE); gboolean reset_scores = TRUE; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); crm_debug("Processing rsc_location %s for %s", constraint->id, rsc->id); native_rsc_location(rsc, constraint); slist_iter( child_rsc, resource_t, rsc->children, lpc, child_rsc->cmds->rsc_location(child_rsc, constraint); if(group_data->colocated && reset_scores) { reset_scores = FALSE; constraint->node_list_rh = zero; } ); constraint->node_list_rh = saved; pe_free_shallow_adv(zero, TRUE); } void group_expand(resource_t *rsc, pe_working_set_t *data_set) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); crm_debug_3("Processing actions from %s", rsc->id); CRM_CHECK(rsc != NULL, return); native_expand(rsc, data_set); slist_iter( child_rsc, resource_t, rsc->children, lpc, child_rsc->cmds->expand(child_rsc, data_set); ); } GHashTable * group_merge_weights( - resource_t *rsc, const char *rhs, GHashTable *nodes, const char *attr, int factor, gboolean allow_rollback) + resource_t *rsc, const char *rhs, GHashTable *nodes, const char *attr, int factor, gboolean allow_rollback, gboolean only_positive) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); if(is_set(rsc->flags, pe_rsc_merging)) { crm_info("Breaking dependency loop with %s at %s", rsc->id, rhs); return nodes; } set_bit(rsc->flags, pe_rsc_merging); nodes = group_data->first_child->cmds->merge_weights( - group_data->first_child, rhs, nodes, attr, factor, allow_rollback); + group_data->first_child, rhs, nodes, attr, factor, allow_rollback, only_positive); slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons_lhs, lpc, - nodes = native_merge_weights( + nodes = rsc_merge_weights( constraint->rsc_lh, rsc->id, nodes, constraint->node_attribute, - constraint->score/INFINITY, allow_rollback); + constraint->score/INFINITY, allow_rollback, only_positive); ); clear_bit(rsc->flags, pe_rsc_merging); return nodes; } void group_append_meta(resource_t *rsc, xmlNode *xml) { } diff --git a/pengine/master.c b/pengine/master.c index 8980e09a08..40eec57dfe 100644 --- a/pengine/master.c +++ b/pengine/master.c @@ -1,904 +1,905 @@ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #define VARIANT_CLONE 1 #include extern gint sort_clone_instance(gconstpointer a, gconstpointer b, gpointer data_set); extern int master_score(resource_t *rsc, node_t *node, int not_set_value); static void child_promoting_constraints( clone_variant_data_t *clone_data, enum pe_ordering type, resource_t *rsc, resource_t *child, resource_t *last, pe_working_set_t *data_set) { if(child == NULL) { if(clone_data->ordered && last != NULL) { crm_debug_4("Ordered version (last node)"); /* last child promote before promoted started */ new_rsc_order(last, RSC_PROMOTE, rsc, RSC_PROMOTED, type, data_set); } return; } /* child promote before global promoted */ new_rsc_order(child, RSC_PROMOTE, rsc, RSC_PROMOTED, type, data_set); /* global promote before child promote */ new_rsc_order(rsc, RSC_PROMOTE, child, RSC_PROMOTE, type, data_set); if(clone_data->ordered) { crm_debug_4("Ordered version"); if(last == NULL) { /* global promote before first child promote */ last = rsc; } /* else: child/child relative promote */ order_start_start(last, child, type); new_rsc_order(last, RSC_PROMOTE, child, RSC_PROMOTE, type, data_set); } else { crm_debug_4("Un-ordered version"); } } static void child_demoting_constraints( clone_variant_data_t *clone_data, enum pe_ordering type, resource_t *rsc, resource_t *child, resource_t *last, pe_working_set_t *data_set) { if(child == NULL) { if(clone_data->ordered && last != NULL) { crm_debug_4("Ordered version (last node)"); /* global demote before first child demote */ new_rsc_order(rsc, RSC_DEMOTE, last, RSC_DEMOTE, pe_order_optional, data_set); } return; } /* child demote before global demoted */ new_rsc_order(child, RSC_DEMOTE, rsc, RSC_DEMOTED, pe_order_implies_then_printed, data_set); /* global demote before child demote */ new_rsc_order(rsc, RSC_DEMOTE, child, RSC_DEMOTE, pe_order_implies_first_printed, data_set); if(clone_data->ordered && last != NULL) { crm_debug_4("Ordered version"); /* child/child relative demote */ new_rsc_order(child, RSC_DEMOTE, last, RSC_DEMOTE, type, data_set); } else if(clone_data->ordered) { crm_debug_4("Ordered version (1st node)"); /* first child stop before global stopped */ new_rsc_order(child, RSC_DEMOTE, rsc, RSC_DEMOTED, type, data_set); } else { crm_debug_4("Un-ordered version"); } } static void master_update_pseudo_status( resource_t *rsc, gboolean *demoting, gboolean *promoting) { if(rsc->children) { slist_iter(child, resource_t, rsc->children, lpc, master_update_pseudo_status(child, demoting, promoting) ); return; } CRM_ASSERT(demoting != NULL); CRM_ASSERT(promoting != NULL); slist_iter( action, action_t, rsc->actions, lpc, if(*promoting && *demoting) { return; } else if(is_set(action->flags, pe_action_optional)) { continue; } else if(safe_str_eq(RSC_DEMOTE, action->task)) { *demoting = TRUE; } else if(safe_str_eq(RSC_PROMOTE, action->task)) { *promoting = TRUE; } ); } #define apply_master_location(list) \ slist_iter( \ cons, rsc_to_node_t, list, lpc2, \ cons_node = NULL; \ if(cons->role_filter == RSC_ROLE_MASTER) { \ crm_debug_2("Applying %s to %s", \ cons->id, child_rsc->id); \ cons_node = pe_find_node_id( \ cons->node_list_rh, chosen->details->id); \ } \ if(cons_node != NULL) { \ int new_priority = merge_weights( \ child_rsc->priority, cons_node->weight); \ crm_debug_2("\t%s: %d->%d (%d)", child_rsc->id, \ child_rsc->priority, new_priority, cons_node->weight); \ child_rsc->priority = new_priority; \ } \ ); static node_t * can_be_master(resource_t *rsc) { node_t *node = NULL; node_t *local_node = NULL; resource_t *parent = uber_parent(rsc); clone_variant_data_t *clone_data = NULL; int level = LOG_DEBUG_2; #if 0 enum rsc_role_e role = RSC_ROLE_UNKNOWN; role = rsc->fns->state(rsc, FALSE); crm_info("%s role: %s", rsc->id, role2text(role)); #endif if(rsc->children) { slist_iter( child, resource_t, rsc->children, lpc, if(can_be_master(child) == NULL) { do_crm_log_unlikely(level, "Child %s of %s can't be promoted", child->id, rsc->id); return NULL; } ); } node = rsc->fns->location(rsc, NULL, FALSE); if(node == NULL) { do_crm_log_unlikely(level, "%s cannot be master: not allocated", rsc->id); return NULL; } else if(is_not_set(rsc->flags, pe_rsc_managed)) { if(rsc->fns->state(rsc, TRUE) == RSC_ROLE_MASTER) { crm_notice("Forcing unmanaged master %s to remain promoted on %s", rsc->id, node->details->uname); } else { return NULL; } } else if(rsc->priority < 0) { do_crm_log_unlikely(level, "%s cannot be master: preference: %d", rsc->id, rsc->priority); return NULL; } else if(can_run_resources(node) == FALSE) { do_crm_log_unlikely(level, "Node cant run any resources: %s", node->details->uname); return NULL; } get_clone_variant_data(clone_data, parent); local_node = pe_hash_table_lookup( parent->allowed_nodes, node->details->id); if(local_node == NULL) { crm_err("%s cannot run on %s: node not allowed", rsc->id, node->details->uname); return NULL; } else if(local_node->count < clone_data->master_node_max || is_not_set(rsc->flags, pe_rsc_managed)) { return local_node; } else { do_crm_log_unlikely(level, "%s cannot be master on %s: node full", rsc->id, node->details->uname); } return NULL; } static gint sort_master_instance(gconstpointer a, gconstpointer b, gpointer data_set) { int rc; enum rsc_role_e role1 = RSC_ROLE_UNKNOWN; enum rsc_role_e role2 = RSC_ROLE_UNKNOWN; const resource_t *resource1 = (const resource_t*)a; const resource_t *resource2 = (const resource_t*)b; CRM_ASSERT(resource1 != NULL); CRM_ASSERT(resource2 != NULL); role1 = resource1->fns->state(resource1, TRUE); role2 = resource2->fns->state(resource2, TRUE); rc = sort_rsc_index(a, b); if( rc != 0 ) { return rc; } if(role1 > role2) { return -1; } else if(role1 < role2) { return 1; } return sort_clone_instance(a, b, data_set); } static void master_promotion_order(resource_t *rsc, pe_working_set_t *data_set) { node_t *node = NULL; node_t *chosen = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); if(clone_data->merged_master_weights) { return; } clone_data->merged_master_weights = TRUE; crm_debug_2("Merging weights for %s", rsc->id); slist_iter( child, resource_t, rsc->children, lpc, crm_debug_2("%s: %d", child->id, child->sort_index); ); dump_node_scores(LOG_DEBUG_3, rsc, "Before", rsc->allowed_nodes); slist_iter( child, resource_t, rsc->children, lpc, chosen = child->fns->location(child, NULL, FALSE); if(chosen == NULL || child->sort_index < 0) { crm_debug_3("Skipping %s", child->id); continue; } node = (node_t*)pe_hash_table_lookup( rsc->allowed_nodes, chosen->details->id); CRM_ASSERT(node != NULL); /* adds in master preferences and rsc_location.role=Master */ node->weight = merge_weights(child->sort_index, node->weight); ); dump_node_scores(LOG_DEBUG_3, rsc, "Middle", rsc->allowed_nodes); slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons, lpc, /* (re-)adds location preferences of resources that the * master instance should/must be colocated with */ if(constraint->role_lh == RSC_ROLE_MASTER) { crm_debug_2("RHS: %s with %s: %d", constraint->rsc_lh->id, constraint->rsc_rh->id, constraint->score); rsc->allowed_nodes = constraint->rsc_rh->cmds->merge_weights( constraint->rsc_rh, rsc->id, rsc->allowed_nodes, - constraint->node_attribute, constraint->score/INFINITY, constraint->score==INFINITY?FALSE:TRUE); + constraint->node_attribute, constraint->score/INFINITY, constraint->score==INFINITY?FALSE:TRUE, FALSE); } ); slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons_lhs, lpc, /* (re-)adds location preferences of resource that wish to be * colocated with the master instance */ if(constraint->role_rh == RSC_ROLE_MASTER) { crm_debug_2("LHS: %s with %s: %d", constraint->rsc_lh->id, constraint->rsc_rh->id, constraint->score); - rsc->allowed_nodes = rsc_merge_weights( + rsc->allowed_nodes = constraint->rsc_lh->cmds->merge_weights( constraint->rsc_lh, rsc->id, rsc->allowed_nodes, constraint->node_attribute, constraint->score/INFINITY, TRUE, TRUE); } ); dump_node_scores(LOG_DEBUG_3, rsc, "After", rsc->allowed_nodes); /* write them back and sort */ slist_iter( child, resource_t, rsc->children, lpc, chosen = child->fns->location(child, NULL, FALSE); if(chosen == NULL || child->sort_index < 0) { crm_debug_2("%s: %d", child->id, child->sort_index); continue; } node = (node_t*)pe_hash_table_lookup( rsc->allowed_nodes, chosen->details->id); CRM_ASSERT(node != NULL); child->sort_index = node->weight; crm_debug_2("%s: %d", child->id, child->sort_index); ); rsc->children = g_list_sort_with_data(rsc->children, sort_master_instance, data_set); } int master_score(resource_t *rsc, node_t *node, int not_set_value) { char *attr_name; char *name = rsc->id; const char *attr_value; int score = not_set_value, len = 0; if(rsc->children) { slist_iter( child, resource_t, rsc->children, lpc, int c_score = master_score(child, node, not_set_value); if(score == not_set_value) { score = c_score; } else { score += c_score; } ); return score; } if(rsc->fns->state(rsc, TRUE) < RSC_ROLE_STARTED) { return score; } if(rsc->running_on) { node_t *match = pe_hash_table_lookup(rsc->allowed_nodes, node->details->id); if(match && match->weight < 0) { crm_debug_2("%s on %s has score: %d - ignoring master pref", rsc->id, match->details->uname, match->weight); return score; } } if(rsc->clone_name) { /* Use the name the lrm knows this resource as, * since that's what crm_master would have used too */ name = rsc->clone_name; } len = 8 + strlen(name); crm_malloc0(attr_name, len); sprintf(attr_name, "master-%s", name); crm_debug_3("looking for %s on %s", attr_name, node->details->uname); attr_value = g_hash_table_lookup( node->details->attrs, attr_name); if(attr_value == NULL) { crm_free(attr_name); len = 8 + strlen(rsc->long_name); crm_malloc0(attr_name, len); sprintf(attr_name, "master-%s", rsc->long_name); crm_debug_3("looking for %s on %s", attr_name, node->details->uname); attr_value = g_hash_table_lookup( node->details->attrs, attr_name); } if(attr_value != NULL) { crm_debug_2("%s[%s] = %s", attr_name, node->details->uname, crm_str(attr_value)); score = char2score(attr_value); } crm_free(attr_name); return score; } #define max(a, b) aapplied_master_prefs) { /* Make sure we only do this once */ return; } clone_data->applied_master_prefs = TRUE; slist_iter( child_rsc, resource_t, rsc->children, lpc, GHashTableIter iter; node_t *node = NULL; g_hash_table_iter_init (&iter, child_rsc->allowed_nodes); while (g_hash_table_iter_next (&iter, NULL, (void**)&node)) { if(can_run_resources(node) == FALSE) { /* This node will never be promoted to master, * so don't apply the master score as that may * lead to clone shuffling */ continue; } score = master_score(child_rsc, node, 0); if(score > 0) { new_score = merge_weights(node->weight, score); if(new_score != node->weight) { crm_debug_2("\t%s: Updating preference for %s (%d->%d)", child_rsc->id, node->details->uname, node->weight, new_score); node->weight = new_score; } } new_score = max(child_rsc->priority, score); if(new_score != child_rsc->priority) { crm_debug_2("\t%s: Updating priority (%d->%d)", child_rsc->id, child_rsc->priority, new_score); child_rsc->priority = new_score; } } ); } static void set_role_slave(resource_t *rsc, gboolean current) { if(current) { if(rsc->role == RSC_ROLE_STARTED) { rsc->role = RSC_ROLE_SLAVE; } } else { GListPtr allocated = NULL; rsc->fns->location(rsc, &allocated, FALSE); if(allocated) { rsc->next_role = RSC_ROLE_SLAVE; } else { rsc->next_role = RSC_ROLE_STOPPED; } g_list_free(allocated); } slist_iter( child_rsc, resource_t, rsc->children, lpc, set_role_slave(child_rsc, current); ); } static void set_role_master(resource_t *rsc) { if(rsc->next_role == RSC_ROLE_UNKNOWN) { rsc->next_role = RSC_ROLE_MASTER; } slist_iter( child_rsc, resource_t, rsc->children, lpc, set_role_master(child_rsc); ); } node_t * master_color(resource_t *rsc, pe_working_set_t *data_set) { int promoted = 0; GHashTableIter iter; node_t *node = NULL; node_t *chosen = NULL; node_t *cons_node = NULL; enum rsc_role_e next_role = RSC_ROLE_UNKNOWN; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); apply_master_prefs(rsc); clone_color(rsc, data_set); /* count now tracks the number of masters allocated */ g_hash_table_iter_init (&iter, rsc->allowed_nodes); while (g_hash_table_iter_next (&iter, NULL, (void**)&node)) { node->count = 0; } /* * assign priority */ slist_iter( child_rsc, resource_t, rsc->children, lpc, GListPtr list = NULL; crm_debug_2("Assigning priority for %s: %s", child_rsc->id, role2text(child_rsc->next_role)); if(child_rsc->fns->state(child_rsc, TRUE) == RSC_ROLE_STARTED) { set_role_slave(child_rsc, TRUE); } chosen = child_rsc->fns->location(child_rsc, &list, FALSE); if(g_list_length(list) > 1) { crm_config_err("Cannot promote non-colocated child %s", child_rsc->id); } g_list_free(list); if(chosen == NULL) { continue; } next_role = child_rsc->fns->state(child_rsc, FALSE); switch(next_role) { case RSC_ROLE_STARTED: case RSC_ROLE_UNKNOWN: CRM_CHECK(chosen != NULL, break); /* * Default to -1 if no value is set * * This allows master locations to be specified * based solely on rsc_location constraints, * but prevents anyone from being promoted if * neither a constraint nor a master-score is present */ child_rsc->priority = master_score(child_rsc, chosen, -1); break; case RSC_ROLE_SLAVE: case RSC_ROLE_STOPPED: child_rsc->priority = -INFINITY; break; case RSC_ROLE_MASTER: /* We will arrive here if we're re-creating actions after a stonith * OR target-role is set */ break; default: CRM_CHECK(FALSE/* unhandled */, crm_err("Unknown resource role: %d for %s", next_role, child_rsc->id)); } apply_master_location(child_rsc->rsc_location); apply_master_location(rsc->rsc_location); slist_iter( cons, rsc_colocation_t, child_rsc->rsc_cons, lpc2, child_rsc->cmds->rsc_colocation_lh(child_rsc, cons->rsc_rh, cons); ); child_rsc->sort_index = child_rsc->priority; crm_debug_2("Assigning priority for %s: %d", child_rsc->id, child_rsc->priority); if(next_role == RSC_ROLE_MASTER) { child_rsc->sort_index = INFINITY; } ); + dump_node_scores(LOG_DEBUG_3, rsc, "Pre merge", rsc->allowed_nodes); master_promotion_order(rsc, data_set); /* mark the first N as masters */ slist_iter( child_rsc, resource_t, rsc->children, lpc, char *score = score2char(child_rsc->sort_index); chosen = child_rsc->fns->location(child_rsc, NULL, FALSE); if(show_scores) { fprintf(stdout, "%s promotion score on %s: %s\n", child_rsc->id, chosen?chosen->details->uname:"none", score); } else { do_crm_log_unlikely(scores_log_level, "%s promotion score on %s: %s", child_rsc->id, chosen?chosen->details->uname:"none", score); } crm_free(score); chosen = NULL; /* nuke 'chosen' so that we don't promote more than the * required number of instances */ if(child_rsc->sort_index < 0) { crm_debug_2("Not supposed to promote child: %s", child_rsc->id); } else if(promoted < clone_data->master_max || is_not_set(rsc->flags, pe_rsc_managed)) { chosen = can_be_master(child_rsc); } crm_debug("%s master score: %d", child_rsc->id, child_rsc->priority); if(chosen == NULL) { set_role_slave(child_rsc, FALSE); continue; } chosen->count++; crm_info("Promoting %s (%s %s)", child_rsc->id, role2text(child_rsc->role), chosen->details->uname); set_role_master(child_rsc); promoted++; ); clone_data->masters_allocated = promoted; crm_info("%s: Promoted %d instances of a possible %d to master", rsc->id, promoted, clone_data->master_max); return NULL; } void master_create_actions(resource_t *rsc, pe_working_set_t *data_set) { action_t *action = NULL; action_t *action_complete = NULL; gboolean any_promoting = FALSE; gboolean any_demoting = FALSE; resource_t *last_promote_rsc = NULL; resource_t *last_demote_rsc = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); crm_debug("Creating actions for %s", rsc->id); /* create actions as normal */ clone_create_actions(rsc, data_set); slist_iter( child_rsc, resource_t, rsc->children, lpc, gboolean child_promoting = FALSE; gboolean child_demoting = FALSE; crm_debug_2("Creating actions for %s", child_rsc->id); child_rsc->cmds->create_actions(child_rsc, data_set); master_update_pseudo_status( child_rsc, &child_demoting, &child_promoting); any_demoting = any_demoting || child_demoting; any_promoting = any_promoting || child_promoting; crm_debug_2("Created actions for %s: %d %d", child_rsc->id, child_promoting, child_demoting); ); /* promote */ action = promote_action(rsc, NULL, !any_promoting); action_complete = custom_action( rsc, promoted_key(rsc), RSC_PROMOTED, NULL, !any_promoting, TRUE, data_set); action_complete->priority = INFINITY; update_action_flags(action, pe_action_pseudo); update_action_flags(action, pe_action_runnable); update_action_flags(action_complete, pe_action_pseudo); update_action_flags(action_complete, pe_action_runnable); if(clone_data->masters_allocated > 0) { update_action_flags(action, pe_action_runnable); update_action_flags(action_complete, pe_action_runnable); } child_promoting_constraints(clone_data, pe_order_optional, rsc, NULL, last_promote_rsc, data_set); if(clone_data->promote_notify == NULL) { clone_data->promote_notify = create_notification_boundaries( rsc, RSC_PROMOTE, action, action_complete, data_set); } /* demote */ action = demote_action(rsc, NULL, !any_demoting); action_complete = custom_action( rsc, demoted_key(rsc), RSC_DEMOTED, NULL, !any_demoting, TRUE, data_set); action_complete->priority = INFINITY; update_action_flags(action, pe_action_pseudo); update_action_flags(action, pe_action_runnable); update_action_flags(action_complete, pe_action_pseudo); update_action_flags(action_complete, pe_action_runnable); child_demoting_constraints(clone_data, pe_order_optional, rsc, NULL, last_demote_rsc, data_set); if(clone_data->demote_notify == NULL) { clone_data->demote_notify = create_notification_boundaries( rsc, RSC_DEMOTE, action, action_complete, data_set); if(clone_data->promote_notify) { /* If we ever wanted groups to have notifications we'd need to move this to native_internal_constraints() one day * Requires exposing *_notify */ order_actions(clone_data->stop_notify->post_done, clone_data->promote_notify->pre, pe_order_optional); order_actions(clone_data->start_notify->post_done, clone_data->promote_notify->pre, pe_order_optional); order_actions(clone_data->demote_notify->post_done, clone_data->promote_notify->pre, pe_order_optional); order_actions(clone_data->demote_notify->post_done, clone_data->start_notify->pre, pe_order_optional); order_actions(clone_data->demote_notify->post_done, clone_data->stop_notify->pre, pe_order_optional); } } /* restore the correct priority */ slist_iter( child_rsc, resource_t, rsc->children, lpc, child_rsc->priority = rsc->priority; ); } void master_internal_constraints(resource_t *rsc, pe_working_set_t *data_set) { resource_t *last_rsc = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); clone_internal_constraints(rsc, data_set); /* global stopped before start */ new_rsc_order(rsc, RSC_STOPPED, rsc, RSC_START, pe_order_optional, data_set); /* global stopped before promote */ new_rsc_order(rsc, RSC_STOPPED, rsc, RSC_PROMOTE, pe_order_optional, data_set); /* global demoted before start */ new_rsc_order(rsc, RSC_DEMOTED, rsc, RSC_START, pe_order_optional, data_set); /* global started before promote */ new_rsc_order(rsc, RSC_STARTED, rsc, RSC_PROMOTE, pe_order_optional, data_set); /* global demoted before stop */ new_rsc_order(rsc, RSC_DEMOTED, rsc, RSC_STOP, pe_order_optional, data_set); /* global demote before demoted */ new_rsc_order(rsc, RSC_DEMOTE, rsc, RSC_DEMOTED, pe_order_optional, data_set); /* global demoted before promote */ new_rsc_order(rsc, RSC_DEMOTED, rsc, RSC_PROMOTE, pe_order_optional, data_set); slist_iter( child_rsc, resource_t, rsc->children, lpc, /* child demote before promote */ new_rsc_order(child_rsc, RSC_DEMOTE, child_rsc, RSC_PROMOTE, pe_order_optional, data_set); child_promoting_constraints(clone_data, pe_order_optional, rsc, child_rsc, last_rsc, data_set); child_demoting_constraints(clone_data, pe_order_optional, rsc, child_rsc, last_rsc, data_set); last_rsc = child_rsc; ); } static void node_hash_update_one(GHashTable *hash, node_t *other, const char *attr, int score) { GHashTableIter iter; node_t *node = NULL; const char *value = NULL; if(other == NULL) { return; } else if(attr == NULL) { attr = "#"XML_ATTR_UNAME; } value = g_hash_table_lookup(other->details->attrs, attr); g_hash_table_iter_init (&iter, hash); while (g_hash_table_iter_next (&iter, NULL, (void**)&node)) { const char *tmp = g_hash_table_lookup(node->details->attrs, attr); if(safe_str_eq(value, tmp)) { crm_debug_2("%s: %d + %d", node->details->uname, node->weight, other->weight); node->weight = merge_weights(node->weight, score); } } } void master_rsc_colocation_rh( resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint) { clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc_rh); CRM_CHECK(rsc_rh != NULL, return); if(is_set(rsc_rh->flags, pe_rsc_provisional)) { return; } else if(constraint->role_rh == RSC_ROLE_UNKNOWN) { crm_debug_3("Handling %s as a clone colocation", constraint->id); clone_rsc_colocation_rh(rsc_lh, rsc_rh, constraint); return; } CRM_CHECK(rsc_lh != NULL, return); CRM_CHECK(rsc_lh->variant == pe_native, return); crm_debug_2("Processing constraint %s: %d", constraint->id, constraint->score); if(constraint->role_rh == RSC_ROLE_UNKNOWN) { slist_iter( child_rsc, resource_t, rsc_rh->children, lpc, child_rsc->cmds->rsc_colocation_rh(rsc_lh, child_rsc, constraint); ); } else if(is_set(rsc_lh->flags, pe_rsc_provisional)) { GListPtr rhs = NULL; slist_iter( child_rsc, resource_t, rsc_rh->children, lpc, node_t *chosen = child_rsc->fns->location(child_rsc, NULL, FALSE); enum rsc_role_e next_role = child_rsc->fns->state(child_rsc, FALSE); crm_debug_3("Processing: %s", child_rsc->id); if(chosen != NULL && next_role == constraint->role_rh) { crm_debug_3("Applying: %s %s %s %d", child_rsc->id, role2text(next_role), chosen->details->uname, constraint->score); if(constraint->score < INFINITY) { node_hash_update_one(rsc_lh->allowed_nodes, chosen, constraint->node_attribute, constraint->score); } rhs = g_list_prepend(rhs, chosen); } ); /* Only do this if its not a master-master colocation * Doing this unconditionally would prevent the slaves from being started */ if(constraint->role_lh != RSC_ROLE_MASTER || constraint->role_rh != RSC_ROLE_MASTER) { if(constraint->score > 0) { node_list_exclude(rsc_lh->allowed_nodes, rhs, TRUE); } } g_list_free(rhs); } else if(constraint->role_lh == RSC_ROLE_MASTER) { resource_t *rh_child = find_compatible_child(rsc_lh, rsc_rh, constraint->role_rh, FALSE); if(rh_child == NULL && constraint->score >= INFINITY) { crm_debug_2("%s can't be promoted %s", rsc_lh->id, constraint->id); rsc_lh->priority = -INFINITY; } else if(rh_child != NULL) { int new_priority = merge_weights(rsc_lh->priority, constraint->score); crm_debug("Applying %s to %s", constraint->id, rsc_lh->id); crm_debug("\t%s: %d->%d", rsc_lh->id, rsc_lh->priority, new_priority); rsc_lh->priority = new_priority; } } return; } void master_append_meta(resource_t *rsc, xmlNode *xml) { char *name = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); clone_append_meta(rsc, xml); name = crm_meta_name(XML_RSC_ATTR_MASTER_MAX); crm_xml_add_int(xml, name, clone_data->master_max); crm_free(name); name = crm_meta_name(XML_RSC_ATTR_MASTER_NODEMAX); crm_xml_add_int(xml, name, clone_data->master_node_max); crm_free(name); } diff --git a/pengine/native.c b/pengine/native.c index 005294b3bf..1b1a2d321d 100644 --- a/pengine/native.c +++ b/pengine/native.c @@ -1,2396 +1,2401 @@ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #define DELETE_THEN_REFRESH 1 /* The crmd will remove the resource from the CIB itself, making this redundant */ #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 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); 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, RoleError, RoleError, DemoteRsc, NullOp, }, }; 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, 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")) { slist_iter( node, node_t, data_set->nodes, lpc, 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; } crm_debug_3("Choosing node for %s from %d candidates", rsc->id, length); if(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); 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; lpc++) { node_t *tmp = g_list_nth_data(nodes, lpc); if(tmp->weight == chosen->weight) { multiple++; if(running && 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_debug_2("%s: Filtering %d + %d*%d (factor * score)", - node->details->uname, node->weight, factor, score); + crm_trace("%s: Filtering %d + %d*%d (factor * score)", + node->details->uname, node->weight, factor, score); + + } else if(only_positive && new_score < 0 && node->weight > 0) { + node->weight = 1; + 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 if(only_positive && new_score < 0 && score > 0) { - new_score = 1; - crm_debug_2("%s: Filtering %d + %d*%d (score)", - node->details->uname, node->weight, factor, score); } else { - crm_debug_2("%s: %d + %d*%d", - node->details->uname, node->weight, factor, score); + 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 * rsc_merge_weights(resource_t *rsc, const char *rhs, GHashTable *nodes, const char *attr, int factor, gboolean allow_rollback, gboolean only_positive) { 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); crm_debug_2("%s: Combining scores from %s", rhs, rsc->id); work = node_hash_dup(nodes); node_hash_update(work, rsc->allowed_nodes, attr, factor, only_positive); if(allow_rollback && can_run_any(work) == FALSE) { crm_info("%s: Rolling back scores from %s", rhs, rsc->id); g_hash_table_destroy(work); /* TODO: Free memory */ clear_bit(rsc->flags, pe_rsc_merging); return nodes; } if(can_run_any(work)) { slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons_lhs, lpc, crm_debug_2("Applying %s", constraint->id); work = rsc_merge_weights(constraint->rsc_lh, rhs, work, constraint->node_attribute, multiplier*constraint->score/INFINITY, allow_rollback, only_positive); ); } g_hash_table_destroy(nodes); /* TODO: Free memory */ clear_bit(rsc->flags, pe_rsc_merging); return work; } node_t * native_color(resource_t *rsc, pe_working_set_t *data_set) { 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, 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); slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons, lpc, GHashTable *archive = NULL; resource_t *rsc_rh = constraint->rsc_rh; crm_debug_2("%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, 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); slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons_lhs, lpc, rsc->allowed_nodes = constraint->rsc_lh->cmds->merge_weights( constraint->rsc_lh, rsc->id, rsc->allowed_nodes, - constraint->node_attribute, constraint->score/INFINITY, TRUE); + constraint->node_attribute, constraint->score/INFINITY, TRUE, FALSE); ); print_resource(LOG_DEBUG_2, "Allocating: ", rsc, FALSE); if(rsc->next_role == RSC_ROLE_STOPPED) { crm_debug_2("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; 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, data_set) ) { crm_debug_3("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; xml_child_iter_filter( rsc->ops_xml, operation, "op", 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; crm_debug_2("Creating recurring action %s for %s in role %s", 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(start != NULL) { crm_debug_3("Marking %s %s due to %s", key, is_set(start->flags, pe_action_optional)?"optional":"manditory", start->uuid); is_optional = (get_action_flags(start, NULL) & pe_action_optional); } else { crm_debug_2("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_debug_3("Marking %s manditory: not active", key); } else { g_list_free(possible_matches); } value = crm_element_value(operation, "role"); 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_debug_2("%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_notice(" 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)) { xml_child_iter_filter( rsc->ops_xml, operation, "op", RecurringOp(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; enum rsc_role_e role = RSC_ROLE_UNKNOWN; enum rsc_role_e next_role = RSC_ROLE_UNKNOWN; crm_debug_2("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; } else if(rsc->next_role == RSC_ROLE_UNKNOWN) { rsc->next_role = RSC_ROLE_STOPPED; } get_rsc_attributes(rsc->parameters, rsc, chosen, data_set); slist_iter( current, node_t, rsc->dangling_migrations, lpc, 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(g_list_length(rsc->running_on) > 1) { if(rsc->recovery_type == recovery_stop_start) { pe_proc_warn("Attempting recovery of resource %s", rsc->id); if(rsc->role == RSC_ROLE_MASTER) { DemoteRsc(rsc, NULL, FALSE, data_set); } StopRsc(rsc, NULL, FALSE, data_set); rsc->role = RSC_ROLE_STOPPED; } } else if(rsc->running_on != NULL) { node_t *current = rsc->running_on->data; NoRoleChange(rsc, current, chosen, data_set); } 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); slist_iter( action, action_t, possible_matches, lpc, update_action_flags(action, pe_action_optional); /* action->pseudo = TRUE; */ ); g_list_free(possible_matches); crm_debug_2("Stopping a stopped resource"); crm_free(key); goto do_recurring; } 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_debug_2("Resetting %s.role = %s (was %s)", rsc->id, role2text(RSC_ROLE_STOPPED), role2text(rsc->role)); rsc->role = RSC_ROLE_STOPPED; } role = rsc->role; while(role != rsc->next_role) { next_role = rsc_state_matrix[role][rsc->next_role]; crm_debug_2("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); } } 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_debug_3("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; crm_trace("Creating utilization constraints for %s - strategy: %s", rsc->id, data_set->placement_strategy); slist_iter( current, node_t, rsc->running_on, lpc, 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_optional, 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, load_stopped_task, load_stopped, rsc, start_key(rsc), NULL, pe_order_optional, data_set); } } } 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_debug_2("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) { int level = LOG_DEBUG_4; if(constraint->score == 0){ return FALSE; } if(constraint->score > 0 && constraint->role_lh != RSC_ROLE_UNKNOWN && constraint->role_lh != rsc_lh->next_role) { do_crm_log_unlikely(level, "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) { do_crm_log_unlikely(level, "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) { do_crm_log_unlikely(level, "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) { do_crm_log_unlikely(level, "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_debug_2("%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_debug_2("%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_debug_2("%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); } } 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_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)) { gboolean unset = FALSE; crm_trace("Handle restart 0x%.6x 0x%.6x", filter, then->flags); CRM_ASSERT(then->rsc == first->rsc); CRM_ASSERT(then->rsc->variant == pe_native); if((filter & pe_action_runnable) && (then->flags & pe_action_runnable) == 0) { crm_trace("Handling shutdown: %s -> %s %d", first->uuid, then->uuid, is_set(first->flags, pe_action_runnable)); unset = TRUE; } if((filter & pe_action_optional) && (then->flags & pe_action_optional) == 0) { crm_trace("Handling recover: %s -> %s %d", first->uuid, then->uuid, is_set(first->flags, pe_action_runnable)); unset = TRUE; } if(unset && is_set(first->flags, pe_action_runnable)) { clear_bit_inplace(first->flags, pe_action_optional); } } if(then_flags != then->flags) { changed |= pe_graph_updated_then; crm_trace("Flags for %s on %s are now 0x%.6x (were 0x%.6x)", then->uuid, then->node?then->node->details->uname:"[none]", then->flags, then_flags); } if(first_flags != first->flags) { changed |= pe_graph_updated_first; crm_trace("Flags for %s on %s are now 0x%.6x (were 0x%.6x)", first->uuid, first->node?first->node->details->uname:"[none]", first->flags, first_flags); } return changed; } void native_rsc_location(resource_t *rsc, rsc_to_node_t *constraint) { GHashTableIter iter; node_t *node = NULL; crm_debug_2("Applying %s (%s) to %s", constraint->id, role2text(constraint->role_filter), rsc->id); /* take "lifetime" into account */ 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; } else 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_debug_2("Constraint (%s) is not active", constraint->id); return; } if(constraint->node_list_rh == NULL) { crm_debug_2("RHS of constraint %s is NULL", constraint->id); return; } slist_iter( node, node_t, constraint->node_list_rh, lpc, node_t *other_node = NULL; other_node = (node_t*)pe_hash_table_lookup( rsc->allowed_nodes, node->details->id); if(other_node != NULL) { crm_debug_4("%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_debug_3("%s + %s : %d", rsc->id, node->details->uname, node->weight); } } void native_expand(resource_t *rsc, pe_working_set_t *data_set) { crm_debug_3("Processing actions from %s", rsc->id); slist_iter( action, action_t, rsc->actions, lpc, crm_debug_4("processing action %d for rsc=%s", action->id, rsc->id); graph_element_from_action(action, data_set); ); slist_iter( child_rsc, resource_t, rsc->children, lpc, child_rsc->cmds->expand(child_rsc, data_set); ); } void LogActions(resource_t *rsc, pe_working_set_t *data_set) { node_t *next = NULL; node_t *current = NULL; gboolean moving = FALSE; if(rsc->children) { slist_iter( child_rsc, resource_t, rsc->children, lpc, LogActions(child_rsc, data_set); ); 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_notice("Leave resource %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; } if(rsc->role == rsc->next_role) { action_t *start = NULL; char *key = start_key(rsc); GListPtr possible_matches = find_actions(rsc->actions, key, next); crm_free(key); if(possible_matches) { start = possible_matches->data; g_list_free(possible_matches); } key = generate_op_key(rsc->id, CRMD_ACTION_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) { crm_notice("Migrate resource %s\t(%s %s -> %s)", rsc->id, role2text(rsc->role), current->details->uname, next->details->uname); g_list_free(possible_matches); } else if(start == NULL || is_set(start->flags, pe_action_optional)) { crm_notice("Leave resource %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else if(moving && current) { crm_notice("Move resource %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)) { crm_notice("Recover resource %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else if(start && is_set(start->flags, pe_action_runnable) == FALSE) { crm_notice("Stop resource %s\t(%s %s)", rsc->id, role2text(rsc->role), next->details->uname); } else { crm_notice("Restart resource %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) { crm_notice("Demote %s\t(%s -> %s %s)", rsc->id, role2text(rsc->role), role2text(rsc->next_role), current->details->uname); } } if(rsc->next_role == RSC_ROLE_STOPPED || moving) { CRM_CHECK(current != NULL,); slist_iter(node, node_t, rsc->running_on, lpc, crm_notice("Stop resource %s\t(%s)", rsc->id, node->details->uname)); } if(rsc->role == RSC_ROLE_STOPPED || moving) { CRM_CHECK(next != NULL,); if(next != NULL) { crm_notice("Start %s\t(%s)", rsc->id, next->details->uname); } } if(rsc->next_role > RSC_ROLE_SLAVE && rsc->role < rsc->next_role) { CRM_CHECK(next != NULL,); crm_notice("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) { action_t *stop = NULL; action_t *start = NULL; GListPtr possible_matches = NULL; crm_debug_2("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); slist_iter(match, action_t, possible_matches, lpc, 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) { const char *class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS); crm_debug_2("Executing: %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); } slist_iter( current, node_t, rsc->running_on, lpc, stop_action(rsc, current, optional); 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_debug_2("Executing: %s", rsc->id); 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; gboolean runnable = TRUE; GListPtr action_list = NULL; crm_debug_2("Executing: %s", rsc->id); CRM_CHECK(rsc->next_role == RSC_ROLE_MASTER, crm_err("Next role: %s", role2text(rsc->next_role)); return FALSE); CRM_CHECK(next != NULL, return FALSE); key = start_key(rsc); action_list = find_actions_exact(rsc->actions, key, next); crm_free(key); slist_iter(start, action_t, action_list, lpc, 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); slist_iter(promote, action_t, action_list, lpc, 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) { crm_debug_2("Executing: %s", rsc->id); /* CRM_CHECK(rsc->next_role == RSC_ROLE_SLAVE, return FALSE); */ slist_iter( current, node_t, rsc->running_on, lpc, 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_CHECK(FALSE, return FALSE); return FALSE; } gboolean NullOp(resource_t *rsc, node_t *next, gboolean optional, pe_working_set_t *data_set) { crm_debug_2("Executing: %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_debug_2("Resource %s not deleted from %s: failed", rsc->id, node->details->uname); return FALSE; } else if(node == NULL) { crm_debug_2("Resource %s not deleted: NULL node", rsc->id); return FALSE; } else if(node->details->unclean || node->details->online == FALSE) { crm_debug_2("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_debug_3("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_debug_2("Skipping active resource detection for %s", rsc->id); return FALSE; } if(rsc->children) { gboolean any_created = FALSE; slist_iter( child_rsc, resource_t, rsc->children, lpc, 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_debug_2("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_debug_3("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); 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_debug_2("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 { action_t *all_stopped = get_pseudo_op(ALL_STOPPED, data_set); action_t *stonith_done = get_pseudo_op(STONITH_DONE, data_set); slist_iter(action, action_t, rsc->actions, lpc2, 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 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 */ slist_iter( action, action_t, action_list, lpc2, 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_warn("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); slist_iter( action, action_t, action_list, lpc2, if(action->node->details->online == FALSE || 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); /* 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) { slist_iter( child_rsc, resource_t, rsc->children, lpc, rsc_stonith_ordering(child_rsc, stonith_op, data_set); ); return; } if(is_not_set(rsc->flags, pe_rsc_managed)) { crm_debug_3("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) { slist_iter( child, resource_t, target->children, lpc, mode |= find_clone_activity_on(rsc, child, node, type); ); return mode; } active = find_first_action(target->actions, NULL, CRMD_ACTION_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, CRMD_ACTION_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; slist_iter(constraint, rsc_colocation_t, other_rsc->rsc_cons, lpc, 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; key = start_key(rsc); action_list = find_actions(rsc->actions, key, NULL); crm_free(key); crm_debug_3("%s: processing", rsc->id); CRM_CHECK(action_list != NULL, return FALSE); start = action_list->data; g_list_free(action_list); slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons, lpc, resource_t *target = constraint->rsc_rh; crm_debug_4("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; } } ); slist_iter( other_w, action_wrapper_t, start->actions_before, lpc, other = other_w->action; if(other_w->type & pe_order_serialize_only) { crm_debug_3("%s: depends on %s (serialize ordering)", rsc->id, other->uuid); continue; } crm_debug_2("%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; } void rsc_migrate_reload(resource_t *rsc, pe_working_set_t *data_set) { char *key = NULL; int level = LOG_DEBUG; GListPtr action_list = NULL; action_t *stop = NULL; action_t *start = NULL; action_t *other = NULL; action_t *action = NULL; const char *value = NULL; if(rsc->children) { slist_iter( child_rsc, resource_t, rsc->children, lpc, rsc_migrate_reload(child_rsc, data_set); ); other = NULL; return; } else if(rsc->variant > pe_native) { return; } do_crm_log_unlikely(level+1, "Processing %s", rsc->id); 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) { do_crm_log_unlikely( level+1, "%s: general resource state: flags=0x%.16llx", rsc->id, rsc->flags); return; } value = g_hash_table_lookup(rsc->meta, XML_OP_ATTR_ALLOW_MIGRATE); if(crm_is_true(value)) { set_bit(rsc->flags, pe_rsc_can_migrate); } if(rsc->next_role > RSC_ROLE_SLAVE) { clear_bit(rsc->flags, pe_rsc_can_migrate); do_crm_log_unlikely( level+1, "%s: resource role: role=%s", rsc->id, role2text(rsc->next_role)); } key = start_key(rsc); action_list = find_actions(rsc->actions, key, NULL); crm_free(key); if(action_list == NULL) { do_crm_log_unlikely(level, "%s: no start action", rsc->id); return; } start = action_list->data; g_list_free(action_list); if(is_not_set(rsc->flags, pe_rsc_can_migrate) && is_set(start->flags, pe_action_allow_reload_conversion) == FALSE) { do_crm_log_unlikely(level+1, "%s: no need to continue", rsc->id); return; } key = stop_key(rsc); action_list = find_actions(rsc->actions, key, NULL); crm_free(key); if(action_list == NULL) { do_crm_log_unlikely(level, "%s: no stop action", rsc->id); return; } stop = action_list->data; g_list_free(action_list); action = start; if(action->node == NULL || is_set(action->flags, pe_action_pseudo) || is_set(action->flags, pe_action_optional) || is_set(action->flags, pe_action_runnable) == FALSE) { do_crm_log_unlikely(level, "%s: %s", rsc->id, action->task); return; } action = stop; if(action->node == NULL || is_set(action->flags, pe_action_pseudo) || is_set(action->flags, pe_action_optional) || is_set(action->flags, pe_action_runnable) == FALSE) { do_crm_log_unlikely(level, "%s: %s", rsc->id, action->task); return; } if(is_set(rsc->flags, pe_rsc_can_migrate)) { if(start->node == NULL || stop->node == NULL || stop->node->details == start->node->details) { clear_bit(rsc->flags, pe_rsc_can_migrate); } else if(at_stack_bottom(rsc) == FALSE) { clear_bit(rsc->flags, pe_rsc_can_migrate); } } if(is_set(rsc->flags, pe_rsc_can_migrate)) { action_t *to = NULL; action_t *from = NULL; crm_info("Migrating %s from %s to %s", rsc->id, stop->node->details->uname, start->node->details->uname); /* 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 keep it */ 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); order_actions(to, from, pe_order_optional); order_actions(from, stop, pe_order_optional); add_hash_param(to->meta, XML_LRM_ATTR_MIGRATE_SOURCE, stop->node->details->id); add_hash_param(to->meta, XML_LRM_ATTR_MIGRATE_TARGET, start->node->details->id); add_hash_param(from->meta, XML_LRM_ATTR_MIGRATE_SOURCE, stop->node->details->id); add_hash_param(from->meta, XML_LRM_ATTR_MIGRATE_TARGET, start->node->details->id); /* Create the correct ordering ajustments based on find_clone_activity_on(); */ slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons, lpc, 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 slist_iter( other_w, action_wrapper_t, start->actions_before, lpc2, /* 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 slist_iter( other_w, action_wrapper_t, clone_stop->actions_before, lpc2, /* 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 */ slist_iter( other_w, action_wrapper_t, stop->actions_after, lpc, 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_to also needs anything that the stop needed to have completed too */ slist_iter( other_w, action_wrapper_t, stop->actions_before, lpc, 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, to, other_w->type); ); /* migrate_to also needs anything that the start needed to have completed too */ slist_iter( other_w, action_wrapper_t, start->actions_before, lpc, 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, to, other_w->type); ); } else if(start && stop && is_set(start->flags, pe_action_allow_reload_conversion) && stop->node->details == start->node->details) { action_t *rewrite = NULL; update_action_flags(start, pe_action_pseudo); /* easier than trying to delete it from the graph */ action = NULL; key = promote_key(rsc); action_list = find_actions(rsc->actions, key, NULL); if(action_list) { action = action_list->data; } if(action && is_set(action->flags, pe_action_optional) == FALSE) { update_action_flags(action, pe_action_pseudo); } g_list_free(action_list); crm_free(key); action = NULL; key = demote_key(rsc); action_list = find_actions(rsc->actions, key, NULL); if(action_list) { action = action_list->data; } g_list_free(action_list); crm_free(key); if(action && is_set(action->flags, pe_action_optional) == FALSE) { rewrite = action; update_action_flags(stop, pe_action_pseudo); } else { rewrite = stop; } crm_info("Rewriting %s of %s on %s as a reload", rewrite->task, rsc->id, stop->node->details->uname); crm_free(rewrite->uuid); crm_free(rewrite->task); rewrite->task = crm_strdup("reload"); rewrite->uuid = generate_op_key(rsc->id, rewrite->task, 0); } else { do_crm_log_unlikely(level+1, "%s nothing to do", rsc->id); } } 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/asymmetric.scores b/pengine/test10/asymmetric.scores index f0612f3edd..dd650968ea 100644 --- a/pengine/test10/asymmetric.scores +++ b/pengine/test10/asymmetric.scores @@ -1,16 +1,16 @@ Allocation scores: clone_color: ebe3fb6e-7778-426e-be58-190ab1ff3dd3:0 allocation score on puma1: 0 clone_color: ebe3fb6e-7778-426e-be58-190ab1ff3dd3:0 allocation score on puma3: 101 clone_color: ebe3fb6e-7778-426e-be58-190ab1ff3dd3:1 allocation score on puma1: 6 clone_color: ebe3fb6e-7778-426e-be58-190ab1ff3dd3:1 allocation score on puma3: 0 clone_color: ms_drbd_poolA allocation score on puma1: 0 clone_color: ms_drbd_poolA allocation score on puma3: 0 -ebe3fb6e-7778-426e-be58-190ab1ff3dd3:0 promotion score on puma3: 100 +ebe3fb6e-7778-426e-be58-190ab1ff3dd3:0 promotion score on puma3: 1 ebe3fb6e-7778-426e-be58-190ab1ff3dd3:0 promotion score on puma3: INFINITY ebe3fb6e-7778-426e-be58-190ab1ff3dd3:1 promotion score on puma1: -INFINITY -ebe3fb6e-7778-426e-be58-190ab1ff3dd3:1 promotion score on puma1: 5 +ebe3fb6e-7778-426e-be58-190ab1ff3dd3:1 promotion score on puma1: 1 native_color: ebe3fb6e-7778-426e-be58-190ab1ff3dd3:0 allocation score on puma1: 0 native_color: ebe3fb6e-7778-426e-be58-190ab1ff3dd3:0 allocation score on puma3: 101 native_color: ebe3fb6e-7778-426e-be58-190ab1ff3dd3:1 allocation score on puma1: 6 native_color: ebe3fb6e-7778-426e-be58-190ab1ff3dd3:1 allocation score on puma3: -INFINITY native_color: vpool_ip_poolA allocation score on puma3: -INFINITY diff --git a/pengine/test10/bug-1572-1.scores b/pengine/test10/bug-1572-1.scores index fbecac7ea8..ff28c0c342 100644 --- a/pengine/test10/bug-1572-1.scores +++ b/pengine/test10/bug-1572-1.scores @@ -1,31 +1,31 @@ Allocation scores: -clone_color: ms_drbd_7788 allocation score on arc-dknightlx: -INFINITY +clone_color: ms_drbd_7788 allocation score on arc-dknightlx: 0 clone_color: ms_drbd_7788 allocation score on arc-tkincaidlx.wsicorp.com: 0 clone_color: rsc_drbd_7788:0 allocation score on arc-dknightlx: 1 clone_color: rsc_drbd_7788:0 allocation score on arc-tkincaidlx.wsicorp.com: 100 clone_color: rsc_drbd_7788:1 allocation score on arc-dknightlx: 0 clone_color: rsc_drbd_7788:1 allocation score on arc-tkincaidlx.wsicorp.com: 101 group_color: IPaddr_147_81_84_133 allocation score on arc-dknightlx: 0 group_color: IPaddr_147_81_84_133 allocation score on arc-tkincaidlx.wsicorp.com: 0 group_color: fs_mirror allocation score on arc-dknightlx: 0 group_color: fs_mirror allocation score on arc-tkincaidlx.wsicorp.com: 0 group_color: grp_pgsql_mirror allocation score on arc-dknightlx: 0 group_color: grp_pgsql_mirror allocation score on arc-tkincaidlx.wsicorp.com: 0 group_color: pgsql_5555 allocation score on arc-dknightlx: 0 group_color: pgsql_5555 allocation score on arc-tkincaidlx.wsicorp.com: 0 native_color: IPaddr_147_81_84_133 allocation score on arc-dknightlx: -INFINITY native_color: IPaddr_147_81_84_133 allocation score on arc-tkincaidlx.wsicorp.com: 0 native_color: fs_mirror allocation score on arc-dknightlx: -INFINITY native_color: fs_mirror allocation score on arc-tkincaidlx.wsicorp.com: 101 native_color: pgsql_5555 allocation score on arc-dknightlx: -INFINITY native_color: pgsql_5555 allocation score on arc-tkincaidlx.wsicorp.com: 0 native_color: rsc_drbd_7788:0 allocation score on arc-dknightlx: -INFINITY native_color: rsc_drbd_7788:0 allocation score on arc-tkincaidlx.wsicorp.com: -INFINITY native_color: rsc_drbd_7788:1 allocation score on arc-dknightlx: -INFINITY native_color: rsc_drbd_7788:1 allocation score on arc-tkincaidlx.wsicorp.com: 101 rsc_drbd_7788:0 promotion score on none: 0 rsc_drbd_7788:0 promotion score on none: 0 rsc_drbd_7788:1 promotion score on arc-tkincaidlx.wsicorp.com: 200 rsc_drbd_7788:1 promotion score on arc-tkincaidlx.wsicorp.com: INFINITY rsc_drbd_7788:2 promotion score on none: 0 rsc_drbd_7788:2 promotion score on none: 0 diff --git a/pengine/test10/bug-1572-2.scores b/pengine/test10/bug-1572-2.scores index 9d68b07e69..c04edc0723 100644 --- a/pengine/test10/bug-1572-2.scores +++ b/pengine/test10/bug-1572-2.scores @@ -1,31 +1,31 @@ Allocation scores: -clone_color: ms_drbd_7788 allocation score on arc-dknightlx: -INFINITY +clone_color: ms_drbd_7788 allocation score on arc-dknightlx: 0 clone_color: ms_drbd_7788 allocation score on arc-tkincaidlx.wsicorp.com: 0 clone_color: rsc_drbd_7788:0 allocation score on arc-dknightlx: 1 clone_color: rsc_drbd_7788:0 allocation score on arc-tkincaidlx.wsicorp.com: 0 clone_color: rsc_drbd_7788:1 allocation score on arc-dknightlx: 0 clone_color: rsc_drbd_7788:1 allocation score on arc-tkincaidlx.wsicorp.com: 1 group_color: IPaddr_147_81_84_133 allocation score on arc-dknightlx: 0 group_color: IPaddr_147_81_84_133 allocation score on arc-tkincaidlx.wsicorp.com: 0 group_color: fs_mirror allocation score on arc-dknightlx: 0 group_color: fs_mirror allocation score on arc-tkincaidlx.wsicorp.com: 0 group_color: grp_pgsql_mirror allocation score on arc-dknightlx: 0 group_color: grp_pgsql_mirror allocation score on arc-tkincaidlx.wsicorp.com: 0 group_color: pgsql_5555 allocation score on arc-dknightlx: 0 group_color: pgsql_5555 allocation score on arc-tkincaidlx.wsicorp.com: 0 native_color: IPaddr_147_81_84_133 allocation score on arc-dknightlx: -INFINITY native_color: IPaddr_147_81_84_133 allocation score on arc-tkincaidlx.wsicorp.com: -INFINITY native_color: fs_mirror allocation score on arc-dknightlx: -INFINITY native_color: fs_mirror allocation score on arc-tkincaidlx.wsicorp.com: -INFINITY native_color: pgsql_5555 allocation score on arc-dknightlx: -INFINITY native_color: pgsql_5555 allocation score on arc-tkincaidlx.wsicorp.com: -INFINITY native_color: rsc_drbd_7788:0 allocation score on arc-dknightlx: -INFINITY native_color: rsc_drbd_7788:0 allocation score on arc-tkincaidlx.wsicorp.com: -INFINITY native_color: rsc_drbd_7788:1 allocation score on arc-dknightlx: -INFINITY native_color: rsc_drbd_7788:1 allocation score on arc-tkincaidlx.wsicorp.com: 1 rsc_drbd_7788:0 promotion score on none: 0 rsc_drbd_7788:0 promotion score on none: 0 rsc_drbd_7788:1 promotion score on arc-tkincaidlx.wsicorp.com: -1 rsc_drbd_7788:1 promotion score on arc-tkincaidlx.wsicorp.com: -INFINITY rsc_drbd_7788:2 promotion score on none: 0 rsc_drbd_7788:2 promotion score on none: 0 diff --git a/pengine/test10/bug-lf-2153.scores b/pengine/test10/bug-lf-2153.scores index 1872d8b83c..1fdec3de7b 100644 --- a/pengine/test10/bug-lf-2153.scores +++ b/pengine/test10/bug-lf-2153.scores @@ -1,55 +1,55 @@ Allocation scores: clone_color: cl_tgtd allocation score on alice: 1500 -clone_color: cl_tgtd allocation score on bob: -INFINITY +clone_color: cl_tgtd allocation score on bob: 0 clone_color: ms_drbd_iscsivg01 allocation score on alice: 1500 -clone_color: ms_drbd_iscsivg01 allocation score on bob: -INFINITY +clone_color: ms_drbd_iscsivg01 allocation score on bob: 0 clone_color: res_drbd_iscsivg01:0 allocation score on alice: 0 clone_color: res_drbd_iscsivg01:0 allocation score on bob: 1 clone_color: res_drbd_iscsivg01:1 allocation score on alice: 101 clone_color: res_drbd_iscsivg01:1 allocation score on bob: 0 clone_color: res_tgtd:0 allocation score on alice: 0 clone_color: res_tgtd:0 allocation score on bob: 1 clone_color: res_tgtd:1 allocation score on alice: 1 clone_color: res_tgtd:1 allocation score on bob: 0 group_color: res_ip_alicebob01 allocation score on alice: 200 group_color: res_ip_alicebob01 allocation score on bob: 0 group_color: res_lu_iscsivg01_lun1 allocation score on alice: 200 group_color: res_lu_iscsivg01_lun1 allocation score on bob: 0 group_color: res_lu_iscsivg01_lun2 allocation score on alice: 200 group_color: res_lu_iscsivg01_lun2 allocation score on bob: 0 group_color: res_lvm_iscsivg01 allocation score on alice: 200 group_color: res_lvm_iscsivg01 allocation score on bob: 0 group_color: res_portblock_iscsivg01_block allocation score on alice: 300 group_color: res_portblock_iscsivg01_block allocation score on bob: 0 group_color: res_portblock_iscsivg01_unblock allocation score on alice: 200 group_color: res_portblock_iscsivg01_unblock allocation score on bob: 0 group_color: res_target_iscsivg01 allocation score on alice: 200 group_color: res_target_iscsivg01 allocation score on bob: 0 group_color: rg_iscsivg01 allocation score on alice: 100 group_color: rg_iscsivg01 allocation score on bob: 0 native_color: res_drbd_iscsivg01:0 allocation score on alice: -INFINITY native_color: res_drbd_iscsivg01:0 allocation score on bob: -INFINITY native_color: res_drbd_iscsivg01:1 allocation score on alice: 101 native_color: res_drbd_iscsivg01:1 allocation score on bob: -INFINITY native_color: res_ip_alicebob01 allocation score on alice: 400 native_color: res_ip_alicebob01 allocation score on bob: -INFINITY native_color: res_lu_iscsivg01_lun1 allocation score on alice: 800 native_color: res_lu_iscsivg01_lun1 allocation score on bob: -INFINITY native_color: res_lu_iscsivg01_lun2 allocation score on alice: 600 native_color: res_lu_iscsivg01_lun2 allocation score on bob: -INFINITY native_color: res_lvm_iscsivg01 allocation score on alice: 1200 native_color: res_lvm_iscsivg01 allocation score on bob: -INFINITY native_color: res_portblock_iscsivg01_block allocation score on alice: 1601 native_color: res_portblock_iscsivg01_block allocation score on bob: -INFINITY native_color: res_portblock_iscsivg01_unblock allocation score on alice: 200 native_color: res_portblock_iscsivg01_unblock allocation score on bob: -INFINITY native_color: res_target_iscsivg01 allocation score on alice: 1000 native_color: res_target_iscsivg01 allocation score on bob: -INFINITY native_color: res_tgtd:0 allocation score on alice: -INFINITY native_color: res_tgtd:0 allocation score on bob: -INFINITY native_color: res_tgtd:1 allocation score on alice: 1 native_color: res_tgtd:1 allocation score on bob: -INFINITY res_drbd_iscsivg01:0 promotion score on none: 0 res_drbd_iscsivg01:0 promotion score on none: 0 -res_drbd_iscsivg01:1 promotion score on alice: 1700 +res_drbd_iscsivg01:1 promotion score on alice: 3100 res_drbd_iscsivg01:1 promotion score on alice: INFINITY diff --git a/pengine/test10/bug-n-387749.scores b/pengine/test10/bug-n-387749.scores index 01b1250aea..c9a6fbc12d 100644 --- a/pengine/test10/bug-n-387749.scores +++ b/pengine/test10/bug-n-387749.scores @@ -1,37 +1,37 @@ Allocation scores: clone_color: export_home_ocfs2:0 allocation score on power720-1: 0 clone_color: export_home_ocfs2:0 allocation score on power720-2: 0 clone_color: export_home_ocfs2:0 allocation score on power720-4: 0 clone_color: export_home_ocfs2:1 allocation score on power720-1: 0 clone_color: export_home_ocfs2:1 allocation score on power720-2: 1 clone_color: export_home_ocfs2:1 allocation score on power720-4: 0 clone_color: export_home_ocfs2:2 allocation score on power720-1: 0 clone_color: export_home_ocfs2:2 allocation score on power720-2: 0 clone_color: export_home_ocfs2:2 allocation score on power720-4: 0 clone_color: export_home_ocfs2_clone_set allocation score on power720-1: INFINITY clone_color: export_home_ocfs2_clone_set allocation score on power720-2: 2000 -clone_color: export_home_ocfs2_clone_set allocation score on power720-4: -INFINITY +clone_color: export_home_ocfs2_clone_set allocation score on power720-4: 0 group_color: group_nfs allocation score on power720-1: INFINITY group_color: group_nfs allocation score on power720-2: 0 group_color: group_nfs allocation score on power720-4: 0 group_color: resource_ipaddr1_single allocation score on power720-1: INFINITY group_color: resource_ipaddr1_single allocation score on power720-2: 1000 group_color: resource_ipaddr1_single allocation score on power720-4: 0 group_color: resource_nfsserver_single allocation score on power720-1: 0 group_color: resource_nfsserver_single allocation score on power720-2: 1000 group_color: resource_nfsserver_single allocation score on power720-4: 0 native_color: export_home_ocfs2:0 allocation score on power720-1: 0 native_color: export_home_ocfs2:0 allocation score on power720-2: -INFINITY native_color: export_home_ocfs2:0 allocation score on power720-4: -INFINITY native_color: export_home_ocfs2:1 allocation score on power720-1: 0 native_color: export_home_ocfs2:1 allocation score on power720-2: 1 native_color: export_home_ocfs2:1 allocation score on power720-4: -INFINITY native_color: export_home_ocfs2:2 allocation score on power720-1: -INFINITY native_color: export_home_ocfs2:2 allocation score on power720-2: -INFINITY native_color: export_home_ocfs2:2 allocation score on power720-4: -INFINITY native_color: resource_ipaddr1_single allocation score on power720-1: INFINITY native_color: resource_ipaddr1_single allocation score on power720-2: 2000 native_color: resource_ipaddr1_single allocation score on power720-4: -INFINITY native_color: resource_nfsserver_single allocation score on power720-1: 0 native_color: resource_nfsserver_single allocation score on power720-2: -INFINITY native_color: resource_nfsserver_single allocation score on power720-4: -INFINITY diff --git a/pengine/test10/colocate-primitive-with-clone.scores b/pengine/test10/colocate-primitive-with-clone.scores index 43ad573fda..0091b51141 100644 --- a/pengine/test10/colocate-primitive-with-clone.scores +++ b/pengine/test10/colocate-primitive-with-clone.scores @@ -1,453 +1,453 @@ Allocation scores: -clone_color: clnDiskd1 allocation score on srv01: -INFINITY +clone_color: clnDiskd1 allocation score on srv01: 0 clone_color: clnDiskd1 allocation score on srv02: 500 clone_color: clnDiskd1 allocation score on srv03: 500 clone_color: clnDiskd1 allocation score on srv04: 500 clone_color: clnG3dummy01:0 allocation score on srv01: 0 clone_color: clnG3dummy01:0 allocation score on srv02: 0 clone_color: clnG3dummy01:0 allocation score on srv03: 0 clone_color: clnG3dummy01:0 allocation score on srv04: 0 clone_color: clnG3dummy01:1 allocation score on srv01: 0 clone_color: clnG3dummy01:1 allocation score on srv02: 100 clone_color: clnG3dummy01:1 allocation score on srv03: 0 clone_color: clnG3dummy01:1 allocation score on srv04: 0 clone_color: clnG3dummy01:2 allocation score on srv01: 0 clone_color: clnG3dummy01:2 allocation score on srv02: 0 clone_color: clnG3dummy01:2 allocation score on srv03: 100 clone_color: clnG3dummy01:2 allocation score on srv04: 0 clone_color: clnG3dummy01:3 allocation score on srv01: 0 clone_color: clnG3dummy01:3 allocation score on srv02: 0 clone_color: clnG3dummy01:3 allocation score on srv03: 0 clone_color: clnG3dummy01:3 allocation score on srv04: 100 clone_color: clnG3dummy02:0 allocation score on srv01: 0 clone_color: clnG3dummy02:0 allocation score on srv02: 0 clone_color: clnG3dummy02:0 allocation score on srv03: 0 clone_color: clnG3dummy02:0 allocation score on srv04: 0 clone_color: clnG3dummy02:1 allocation score on srv01: 0 clone_color: clnG3dummy02:1 allocation score on srv02: 100 clone_color: clnG3dummy02:1 allocation score on srv03: 0 clone_color: clnG3dummy02:1 allocation score on srv04: 0 clone_color: clnG3dummy02:2 allocation score on srv01: 0 clone_color: clnG3dummy02:2 allocation score on srv02: 0 clone_color: clnG3dummy02:2 allocation score on srv03: 100 clone_color: clnG3dummy02:2 allocation score on srv04: 0 clone_color: clnG3dummy02:3 allocation score on srv01: 0 clone_color: clnG3dummy02:3 allocation score on srv02: 0 clone_color: clnG3dummy02:3 allocation score on srv03: 0 clone_color: clnG3dummy02:3 allocation score on srv04: 100 -clone_color: clnG3dummy1 allocation score on srv01: -INFINITY +clone_color: clnG3dummy1 allocation score on srv01: 0 clone_color: clnG3dummy1 allocation score on srv02: 500 clone_color: clnG3dummy1 allocation score on srv03: 500 clone_color: clnG3dummy1 allocation score on srv04: 500 -clone_color: clnG3dummy2 allocation score on srv01: -INFINITY +clone_color: clnG3dummy2 allocation score on srv01: 0 clone_color: clnG3dummy2 allocation score on srv02: 500 clone_color: clnG3dummy2 allocation score on srv03: 500 clone_color: clnG3dummy2 allocation score on srv04: 500 -clone_color: clnPingd allocation score on srv01: -INFINITY +clone_color: clnPingd allocation score on srv01: 0 clone_color: clnPingd allocation score on srv02: 500 clone_color: clnPingd allocation score on srv03: 500 clone_color: clnPingd allocation score on srv04: 500 clone_color: clnPrmDiskd1:0 allocation score on srv01: 0 clone_color: clnPrmDiskd1:0 allocation score on srv02: 0 clone_color: clnPrmDiskd1:0 allocation score on srv03: 0 clone_color: clnPrmDiskd1:0 allocation score on srv04: 0 clone_color: clnPrmDiskd1:1 allocation score on srv01: 0 clone_color: clnPrmDiskd1:1 allocation score on srv02: 100 clone_color: clnPrmDiskd1:1 allocation score on srv03: 0 clone_color: clnPrmDiskd1:1 allocation score on srv04: 0 clone_color: clnPrmDiskd1:2 allocation score on srv01: 0 clone_color: clnPrmDiskd1:2 allocation score on srv02: 0 clone_color: clnPrmDiskd1:2 allocation score on srv03: 100 clone_color: clnPrmDiskd1:2 allocation score on srv04: 0 clone_color: clnPrmDiskd1:3 allocation score on srv01: 0 clone_color: clnPrmDiskd1:3 allocation score on srv02: 0 clone_color: clnPrmDiskd1:3 allocation score on srv03: 0 clone_color: clnPrmDiskd1:3 allocation score on srv04: 100 clone_color: clnPrmPingd:0 allocation score on srv01: 0 clone_color: clnPrmPingd:0 allocation score on srv02: 0 clone_color: clnPrmPingd:0 allocation score on srv03: 0 clone_color: clnPrmPingd:0 allocation score on srv04: 0 clone_color: clnPrmPingd:1 allocation score on srv01: 0 clone_color: clnPrmPingd:1 allocation score on srv02: 100 clone_color: clnPrmPingd:1 allocation score on srv03: 0 clone_color: clnPrmPingd:1 allocation score on srv04: 0 clone_color: clnPrmPingd:2 allocation score on srv01: 0 clone_color: clnPrmPingd:2 allocation score on srv02: 0 clone_color: clnPrmPingd:2 allocation score on srv03: 100 clone_color: clnPrmPingd:2 allocation score on srv04: 0 clone_color: clnPrmPingd:3 allocation score on srv01: 0 clone_color: clnPrmPingd:3 allocation score on srv02: 0 clone_color: clnPrmPingd:3 allocation score on srv03: 0 clone_color: clnPrmPingd:3 allocation score on srv04: 100 clone_color: clnUMdummy01:0 allocation score on srv01: 0 clone_color: clnUMdummy01:0 allocation score on srv02: -INFINITY clone_color: clnUMdummy01:0 allocation score on srv03: -INFINITY clone_color: clnUMdummy01:0 allocation score on srv04: 100 clone_color: clnUMdummy01:1 allocation score on srv01: 0 clone_color: clnUMdummy01:1 allocation score on srv02: -INFINITY clone_color: clnUMdummy01:1 allocation score on srv03: -INFINITY clone_color: clnUMdummy01:1 allocation score on srv04: 0 clone_color: clnUMdummy02:0 allocation score on srv01: 0 clone_color: clnUMdummy02:0 allocation score on srv02: 0 clone_color: clnUMdummy02:0 allocation score on srv03: 0 clone_color: clnUMdummy02:0 allocation score on srv04: 100 clone_color: clnUMdummy02:1 allocation score on srv01: 0 clone_color: clnUMdummy02:1 allocation score on srv02: 0 clone_color: clnUMdummy02:1 allocation score on srv03: 0 clone_color: clnUMdummy02:1 allocation score on srv04: 0 -clone_color: clnUMgroup01 allocation score on srv01: -INFINITY +clone_color: clnUMgroup01 allocation score on srv01: 0 clone_color: clnUMgroup01 allocation score on srv02: -INFINITY clone_color: clnUMgroup01 allocation score on srv03: -INFINITY clone_color: clnUMgroup01 allocation score on srv04: 0 clone_color: clnUmResource:0 allocation score on srv01: 0 clone_color: clnUmResource:0 allocation score on srv02: -INFINITY clone_color: clnUmResource:0 allocation score on srv03: -INFINITY clone_color: clnUmResource:0 allocation score on srv04: 0 clone_color: clnUmResource:1 allocation score on srv01: 0 clone_color: clnUmResource:1 allocation score on srv02: -INFINITY clone_color: clnUmResource:1 allocation score on srv03: -INFINITY clone_color: clnUmResource:1 allocation score on srv04: 0 group_color: OVDBgroup02-1 allocation score on srv01: -INFINITY group_color: OVDBgroup02-1 allocation score on srv02: -INFINITY group_color: OVDBgroup02-1 allocation score on srv03: -INFINITY group_color: OVDBgroup02-1 allocation score on srv04: 100 group_color: OVDBgroup02-2 allocation score on srv01: -INFINITY group_color: OVDBgroup02-2 allocation score on srv02: 200 group_color: OVDBgroup02-2 allocation score on srv03: -INFINITY group_color: OVDBgroup02-2 allocation score on srv04: 100 group_color: OVDBgroup02-3 allocation score on srv01: -INFINITY group_color: OVDBgroup02-3 allocation score on srv02: -INFINITY group_color: OVDBgroup02-3 allocation score on srv03: 200 group_color: OVDBgroup02-3 allocation score on srv04: 100 group_color: UMgroup01 allocation score on srv01: -INFINITY group_color: UMgroup01 allocation score on srv02: -INFINITY group_color: UMgroup01 allocation score on srv03: -INFINITY group_color: UMgroup01 allocation score on srv04: 100 group_color: UmDummy01 allocation score on srv01: 0 group_color: UmDummy01 allocation score on srv02: 0 group_color: UmDummy01 allocation score on srv03: 0 group_color: UmDummy01 allocation score on srv04: 0 group_color: UmDummy02 allocation score on srv01: 0 group_color: UmDummy02 allocation score on srv02: 0 group_color: UmDummy02 allocation score on srv03: 0 group_color: UmDummy02 allocation score on srv04: 0 group_color: UmIPaddr allocation score on srv01: 0 group_color: UmIPaddr allocation score on srv02: 0 group_color: UmIPaddr allocation score on srv03: 0 group_color: UmIPaddr allocation score on srv04: 0 group_color: UmVIPcheck allocation score on srv01: -INFINITY group_color: UmVIPcheck allocation score on srv02: -INFINITY group_color: UmVIPcheck allocation score on srv03: -INFINITY group_color: UmVIPcheck allocation score on srv04: 100 group_color: clnUMdummy01:0 allocation score on srv01: -INFINITY group_color: clnUMdummy01:0 allocation score on srv02: -INFINITY group_color: clnUMdummy01:0 allocation score on srv03: -INFINITY group_color: clnUMdummy01:0 allocation score on srv04: 100 group_color: clnUMdummy01:1 allocation score on srv01: -INFINITY group_color: clnUMdummy01:1 allocation score on srv02: -INFINITY group_color: clnUMdummy01:1 allocation score on srv03: -INFINITY group_color: clnUMdummy01:1 allocation score on srv04: -INFINITY group_color: clnUMdummy02:0 allocation score on srv01: -INFINITY group_color: clnUMdummy02:0 allocation score on srv02: 0 group_color: clnUMdummy02:0 allocation score on srv03: 0 group_color: clnUMdummy02:0 allocation score on srv04: 100 group_color: clnUMdummy02:1 allocation score on srv01: -INFINITY group_color: clnUMdummy02:1 allocation score on srv02: 0 group_color: clnUMdummy02:1 allocation score on srv03: 0 group_color: clnUMdummy02:1 allocation score on srv04: -INFINITY group_color: clnUmResource:0 allocation score on srv01: -INFINITY group_color: clnUmResource:0 allocation score on srv02: -INFINITY group_color: clnUmResource:0 allocation score on srv03: -INFINITY group_color: clnUmResource:0 allocation score on srv04: 0 group_color: clnUmResource:1 allocation score on srv01: -INFINITY group_color: clnUmResource:1 allocation score on srv02: -INFINITY group_color: clnUmResource:1 allocation score on srv03: -INFINITY group_color: clnUmResource:1 allocation score on srv04: -INFINITY group_color: grpStonith1 allocation score on srv01: -INFINITY group_color: grpStonith1 allocation score on srv02: 100 group_color: grpStonith1 allocation score on srv03: 100 group_color: grpStonith1 allocation score on srv04: 200 group_color: grpStonith2 allocation score on srv01: 200 group_color: grpStonith2 allocation score on srv02: -INFINITY group_color: grpStonith2 allocation score on srv03: 100 group_color: grpStonith2 allocation score on srv04: 100 group_color: grpStonith3 allocation score on srv01: 100 group_color: grpStonith3 allocation score on srv02: 200 group_color: grpStonith3 allocation score on srv03: -INFINITY group_color: grpStonith3 allocation score on srv04: 100 group_color: grpStonith4 allocation score on srv01: 100 group_color: grpStonith4 allocation score on srv02: 100 group_color: grpStonith4 allocation score on srv03: 200 group_color: grpStonith4 allocation score on srv04: -INFINITY group_color: prmApPostgreSQLDB1 allocation score on srv01: 0 group_color: prmApPostgreSQLDB1 allocation score on srv02: 0 group_color: prmApPostgreSQLDB1 allocation score on srv03: 0 group_color: prmApPostgreSQLDB1 allocation score on srv04: 100 group_color: prmApPostgreSQLDB2 allocation score on srv01: 0 group_color: prmApPostgreSQLDB2 allocation score on srv02: 100 group_color: prmApPostgreSQLDB2 allocation score on srv03: 0 group_color: prmApPostgreSQLDB2 allocation score on srv04: 0 group_color: prmApPostgreSQLDB3 allocation score on srv01: 0 group_color: prmApPostgreSQLDB3 allocation score on srv02: 0 group_color: prmApPostgreSQLDB3 allocation score on srv03: 100 group_color: prmApPostgreSQLDB3 allocation score on srv04: 0 group_color: prmExPostgreSQLDB1 allocation score on srv01: -INFINITY group_color: prmExPostgreSQLDB1 allocation score on srv02: -INFINITY group_color: prmExPostgreSQLDB1 allocation score on srv03: -INFINITY group_color: prmExPostgreSQLDB1 allocation score on srv04: 200 group_color: prmExPostgreSQLDB2 allocation score on srv01: -INFINITY group_color: prmExPostgreSQLDB2 allocation score on srv02: 300 group_color: prmExPostgreSQLDB2 allocation score on srv03: -INFINITY group_color: prmExPostgreSQLDB2 allocation score on srv04: 100 group_color: prmExPostgreSQLDB3 allocation score on srv01: -INFINITY group_color: prmExPostgreSQLDB3 allocation score on srv02: -INFINITY group_color: prmExPostgreSQLDB3 allocation score on srv03: 300 group_color: prmExPostgreSQLDB3 allocation score on srv04: 100 group_color: prmFsPostgreSQLDB1-1 allocation score on srv01: 0 group_color: prmFsPostgreSQLDB1-1 allocation score on srv02: 0 group_color: prmFsPostgreSQLDB1-1 allocation score on srv03: 0 group_color: prmFsPostgreSQLDB1-1 allocation score on srv04: 100 group_color: prmFsPostgreSQLDB1-2 allocation score on srv01: 0 group_color: prmFsPostgreSQLDB1-2 allocation score on srv02: 0 group_color: prmFsPostgreSQLDB1-2 allocation score on srv03: 0 group_color: prmFsPostgreSQLDB1-2 allocation score on srv04: 100 group_color: prmFsPostgreSQLDB1-3 allocation score on srv01: 0 group_color: prmFsPostgreSQLDB1-3 allocation score on srv02: 0 group_color: prmFsPostgreSQLDB1-3 allocation score on srv03: 0 group_color: prmFsPostgreSQLDB1-3 allocation score on srv04: 100 group_color: prmFsPostgreSQLDB2-1 allocation score on srv01: 0 group_color: prmFsPostgreSQLDB2-1 allocation score on srv02: 100 group_color: prmFsPostgreSQLDB2-1 allocation score on srv03: 0 group_color: prmFsPostgreSQLDB2-1 allocation score on srv04: 0 group_color: prmFsPostgreSQLDB2-2 allocation score on srv01: 0 group_color: prmFsPostgreSQLDB2-2 allocation score on srv02: 100 group_color: prmFsPostgreSQLDB2-2 allocation score on srv03: 0 group_color: prmFsPostgreSQLDB2-2 allocation score on srv04: 0 group_color: prmFsPostgreSQLDB2-3 allocation score on srv01: 0 group_color: prmFsPostgreSQLDB2-3 allocation score on srv02: 100 group_color: prmFsPostgreSQLDB2-3 allocation score on srv03: 0 group_color: prmFsPostgreSQLDB2-3 allocation score on srv04: 0 group_color: prmFsPostgreSQLDB3-1 allocation score on srv01: 0 group_color: prmFsPostgreSQLDB3-1 allocation score on srv02: 0 group_color: prmFsPostgreSQLDB3-1 allocation score on srv03: 100 group_color: prmFsPostgreSQLDB3-1 allocation score on srv04: 0 group_color: prmFsPostgreSQLDB3-2 allocation score on srv01: 0 group_color: prmFsPostgreSQLDB3-2 allocation score on srv02: 0 group_color: prmFsPostgreSQLDB3-2 allocation score on srv03: 100 group_color: prmFsPostgreSQLDB3-2 allocation score on srv04: 0 group_color: prmFsPostgreSQLDB3-3 allocation score on srv01: 0 group_color: prmFsPostgreSQLDB3-3 allocation score on srv02: 0 group_color: prmFsPostgreSQLDB3-3 allocation score on srv03: 100 group_color: prmFsPostgreSQLDB3-3 allocation score on srv04: 0 group_color: prmIpPostgreSQLDB1 allocation score on srv01: 0 group_color: prmIpPostgreSQLDB1 allocation score on srv02: 0 group_color: prmIpPostgreSQLDB1 allocation score on srv03: 0 group_color: prmIpPostgreSQLDB1 allocation score on srv04: 100 group_color: prmIpPostgreSQLDB2 allocation score on srv01: 0 group_color: prmIpPostgreSQLDB2 allocation score on srv02: 100 group_color: prmIpPostgreSQLDB2 allocation score on srv03: 0 group_color: prmIpPostgreSQLDB2 allocation score on srv04: 0 group_color: prmIpPostgreSQLDB3 allocation score on srv01: 0 group_color: prmIpPostgreSQLDB3 allocation score on srv02: 0 group_color: prmIpPostgreSQLDB3 allocation score on srv03: 100 group_color: prmIpPostgreSQLDB3 allocation score on srv04: 0 group_color: prmStonithN1 allocation score on srv01: -INFINITY group_color: prmStonithN1 allocation score on srv02: 100 group_color: prmStonithN1 allocation score on srv03: 100 group_color: prmStonithN1 allocation score on srv04: 300 group_color: prmStonithN2 allocation score on srv01: 200 group_color: prmStonithN2 allocation score on srv02: -INFINITY group_color: prmStonithN2 allocation score on srv03: 200 group_color: prmStonithN2 allocation score on srv04: 100 group_color: prmStonithN3 allocation score on srv01: 100 group_color: prmStonithN3 allocation score on srv02: 300 group_color: prmStonithN3 allocation score on srv03: -INFINITY group_color: prmStonithN3 allocation score on srv04: 100 group_color: prmStonithN4 allocation score on srv01: 100 group_color: prmStonithN4 allocation score on srv02: 100 group_color: prmStonithN4 allocation score on srv03: 300 group_color: prmStonithN4 allocation score on srv04: -INFINITY native_color: UmDummy01 allocation score on srv01: -INFINITY native_color: UmDummy01 allocation score on srv02: -INFINITY native_color: UmDummy01 allocation score on srv03: -INFINITY native_color: UmDummy01 allocation score on srv04: 0 native_color: UmDummy02 allocation score on srv01: -INFINITY native_color: UmDummy02 allocation score on srv02: -INFINITY native_color: UmDummy02 allocation score on srv03: -INFINITY native_color: UmDummy02 allocation score on srv04: 0 native_color: UmIPaddr allocation score on srv01: -INFINITY native_color: UmIPaddr allocation score on srv02: -INFINITY native_color: UmIPaddr allocation score on srv03: -INFINITY native_color: UmIPaddr allocation score on srv04: 0 native_color: UmVIPcheck allocation score on srv01: -INFINITY native_color: UmVIPcheck allocation score on srv02: -INFINITY native_color: UmVIPcheck allocation score on srv03: -INFINITY native_color: UmVIPcheck allocation score on srv04: 100 native_color: clnG3dummy01:0 allocation score on srv01: -INFINITY native_color: clnG3dummy01:0 allocation score on srv02: -INFINITY native_color: clnG3dummy01:0 allocation score on srv03: -INFINITY native_color: clnG3dummy01:0 allocation score on srv04: -INFINITY native_color: clnG3dummy01:1 allocation score on srv01: -INFINITY native_color: clnG3dummy01:1 allocation score on srv02: 100 native_color: clnG3dummy01:1 allocation score on srv03: 0 native_color: clnG3dummy01:1 allocation score on srv04: 0 native_color: clnG3dummy01:2 allocation score on srv01: -INFINITY native_color: clnG3dummy01:2 allocation score on srv02: -INFINITY native_color: clnG3dummy01:2 allocation score on srv03: 100 native_color: clnG3dummy01:2 allocation score on srv04: 0 native_color: clnG3dummy01:3 allocation score on srv01: -INFINITY native_color: clnG3dummy01:3 allocation score on srv02: -INFINITY native_color: clnG3dummy01:3 allocation score on srv03: -INFINITY native_color: clnG3dummy01:3 allocation score on srv04: 100 native_color: clnG3dummy02:0 allocation score on srv01: -INFINITY native_color: clnG3dummy02:0 allocation score on srv02: -INFINITY native_color: clnG3dummy02:0 allocation score on srv03: -INFINITY native_color: clnG3dummy02:0 allocation score on srv04: -INFINITY native_color: clnG3dummy02:1 allocation score on srv01: -INFINITY native_color: clnG3dummy02:1 allocation score on srv02: 100 native_color: clnG3dummy02:1 allocation score on srv03: 0 native_color: clnG3dummy02:1 allocation score on srv04: 0 native_color: clnG3dummy02:2 allocation score on srv01: -INFINITY native_color: clnG3dummy02:2 allocation score on srv02: -INFINITY native_color: clnG3dummy02:2 allocation score on srv03: 100 native_color: clnG3dummy02:2 allocation score on srv04: 0 native_color: clnG3dummy02:3 allocation score on srv01: -INFINITY native_color: clnG3dummy02:3 allocation score on srv02: -INFINITY native_color: clnG3dummy02:3 allocation score on srv03: -INFINITY native_color: clnG3dummy02:3 allocation score on srv04: 100 native_color: clnPrmDiskd1:0 allocation score on srv01: -INFINITY native_color: clnPrmDiskd1:0 allocation score on srv02: -INFINITY native_color: clnPrmDiskd1:0 allocation score on srv03: -INFINITY native_color: clnPrmDiskd1:0 allocation score on srv04: -INFINITY native_color: clnPrmDiskd1:1 allocation score on srv01: -INFINITY native_color: clnPrmDiskd1:1 allocation score on srv02: 100 native_color: clnPrmDiskd1:1 allocation score on srv03: 0 native_color: clnPrmDiskd1:1 allocation score on srv04: 0 native_color: clnPrmDiskd1:2 allocation score on srv01: -INFINITY native_color: clnPrmDiskd1:2 allocation score on srv02: -INFINITY native_color: clnPrmDiskd1:2 allocation score on srv03: 100 native_color: clnPrmDiskd1:2 allocation score on srv04: 0 native_color: clnPrmDiskd1:3 allocation score on srv01: -INFINITY native_color: clnPrmDiskd1:3 allocation score on srv02: -INFINITY native_color: clnPrmDiskd1:3 allocation score on srv03: -INFINITY native_color: clnPrmDiskd1:3 allocation score on srv04: 100 native_color: clnPrmPingd:0 allocation score on srv01: -INFINITY native_color: clnPrmPingd:0 allocation score on srv02: -INFINITY native_color: clnPrmPingd:0 allocation score on srv03: -INFINITY native_color: clnPrmPingd:0 allocation score on srv04: -INFINITY native_color: clnPrmPingd:1 allocation score on srv01: -INFINITY native_color: clnPrmPingd:1 allocation score on srv02: 100 native_color: clnPrmPingd:1 allocation score on srv03: 0 native_color: clnPrmPingd:1 allocation score on srv04: 0 native_color: clnPrmPingd:2 allocation score on srv01: -INFINITY native_color: clnPrmPingd:2 allocation score on srv02: -INFINITY native_color: clnPrmPingd:2 allocation score on srv03: 100 native_color: clnPrmPingd:2 allocation score on srv04: 0 native_color: clnPrmPingd:3 allocation score on srv01: -INFINITY native_color: clnPrmPingd:3 allocation score on srv02: -INFINITY native_color: clnPrmPingd:3 allocation score on srv03: -INFINITY native_color: clnPrmPingd:3 allocation score on srv04: 100 native_color: clnUMdummy01:0 allocation score on srv01: -INFINITY native_color: clnUMdummy01:0 allocation score on srv02: -INFINITY native_color: clnUMdummy01:0 allocation score on srv03: -INFINITY native_color: clnUMdummy01:0 allocation score on srv04: 200 native_color: clnUMdummy01:1 allocation score on srv01: -INFINITY native_color: clnUMdummy01:1 allocation score on srv02: -INFINITY native_color: clnUMdummy01:1 allocation score on srv03: -INFINITY native_color: clnUMdummy01:1 allocation score on srv04: -INFINITY native_color: clnUMdummy02:0 allocation score on srv01: -INFINITY native_color: clnUMdummy02:0 allocation score on srv02: -INFINITY native_color: clnUMdummy02:0 allocation score on srv03: -INFINITY native_color: clnUMdummy02:0 allocation score on srv04: 100 native_color: clnUMdummy02:1 allocation score on srv01: -INFINITY native_color: clnUMdummy02:1 allocation score on srv02: -INFINITY native_color: clnUMdummy02:1 allocation score on srv03: -INFINITY native_color: clnUMdummy02:1 allocation score on srv04: -INFINITY native_color: prmApPostgreSQLDB1 allocation score on srv01: -INFINITY native_color: prmApPostgreSQLDB1 allocation score on srv02: -INFINITY native_color: prmApPostgreSQLDB1 allocation score on srv03: -INFINITY native_color: prmApPostgreSQLDB1 allocation score on srv04: 100 native_color: prmApPostgreSQLDB2 allocation score on srv01: -INFINITY native_color: prmApPostgreSQLDB2 allocation score on srv02: 100 native_color: prmApPostgreSQLDB2 allocation score on srv03: -INFINITY native_color: prmApPostgreSQLDB2 allocation score on srv04: -INFINITY native_color: prmApPostgreSQLDB3 allocation score on srv01: -INFINITY native_color: prmApPostgreSQLDB3 allocation score on srv02: -INFINITY native_color: prmApPostgreSQLDB3 allocation score on srv03: 100 native_color: prmApPostgreSQLDB3 allocation score on srv04: -INFINITY native_color: prmExPostgreSQLDB1 allocation score on srv01: -INFINITY native_color: prmExPostgreSQLDB1 allocation score on srv02: -INFINITY native_color: prmExPostgreSQLDB1 allocation score on srv03: -INFINITY native_color: prmExPostgreSQLDB1 allocation score on srv04: 700 native_color: prmExPostgreSQLDB2 allocation score on srv01: -INFINITY native_color: prmExPostgreSQLDB2 allocation score on srv02: 800 native_color: prmExPostgreSQLDB2 allocation score on srv03: -INFINITY native_color: prmExPostgreSQLDB2 allocation score on srv04: 100 native_color: prmExPostgreSQLDB3 allocation score on srv01: -INFINITY native_color: prmExPostgreSQLDB3 allocation score on srv02: -INFINITY native_color: prmExPostgreSQLDB3 allocation score on srv03: 800 native_color: prmExPostgreSQLDB3 allocation score on srv04: 100 native_color: prmFsPostgreSQLDB1-1 allocation score on srv01: -INFINITY native_color: prmFsPostgreSQLDB1-1 allocation score on srv02: -INFINITY native_color: prmFsPostgreSQLDB1-1 allocation score on srv03: -INFINITY native_color: prmFsPostgreSQLDB1-1 allocation score on srv04: 500 native_color: prmFsPostgreSQLDB1-2 allocation score on srv01: -INFINITY native_color: prmFsPostgreSQLDB1-2 allocation score on srv02: -INFINITY native_color: prmFsPostgreSQLDB1-2 allocation score on srv03: -INFINITY native_color: prmFsPostgreSQLDB1-2 allocation score on srv04: 400 native_color: prmFsPostgreSQLDB1-3 allocation score on srv01: -INFINITY native_color: prmFsPostgreSQLDB1-3 allocation score on srv02: -INFINITY native_color: prmFsPostgreSQLDB1-3 allocation score on srv03: -INFINITY native_color: prmFsPostgreSQLDB1-3 allocation score on srv04: 300 native_color: prmFsPostgreSQLDB2-1 allocation score on srv01: -INFINITY native_color: prmFsPostgreSQLDB2-1 allocation score on srv02: 500 native_color: prmFsPostgreSQLDB2-1 allocation score on srv03: -INFINITY native_color: prmFsPostgreSQLDB2-1 allocation score on srv04: -INFINITY native_color: prmFsPostgreSQLDB2-2 allocation score on srv01: -INFINITY native_color: prmFsPostgreSQLDB2-2 allocation score on srv02: 400 native_color: prmFsPostgreSQLDB2-2 allocation score on srv03: -INFINITY native_color: prmFsPostgreSQLDB2-2 allocation score on srv04: -INFINITY native_color: prmFsPostgreSQLDB2-3 allocation score on srv01: -INFINITY native_color: prmFsPostgreSQLDB2-3 allocation score on srv02: 300 native_color: prmFsPostgreSQLDB2-3 allocation score on srv03: -INFINITY native_color: prmFsPostgreSQLDB2-3 allocation score on srv04: -INFINITY native_color: prmFsPostgreSQLDB3-1 allocation score on srv01: -INFINITY native_color: prmFsPostgreSQLDB3-1 allocation score on srv02: -INFINITY native_color: prmFsPostgreSQLDB3-1 allocation score on srv03: 500 native_color: prmFsPostgreSQLDB3-1 allocation score on srv04: -INFINITY native_color: prmFsPostgreSQLDB3-2 allocation score on srv01: -INFINITY native_color: prmFsPostgreSQLDB3-2 allocation score on srv02: -INFINITY native_color: prmFsPostgreSQLDB3-2 allocation score on srv03: 400 native_color: prmFsPostgreSQLDB3-2 allocation score on srv04: -INFINITY native_color: prmFsPostgreSQLDB3-3 allocation score on srv01: -INFINITY native_color: prmFsPostgreSQLDB3-3 allocation score on srv02: -INFINITY native_color: prmFsPostgreSQLDB3-3 allocation score on srv03: 300 native_color: prmFsPostgreSQLDB3-3 allocation score on srv04: -INFINITY native_color: prmIpPostgreSQLDB1 allocation score on srv01: -INFINITY native_color: prmIpPostgreSQLDB1 allocation score on srv02: -INFINITY native_color: prmIpPostgreSQLDB1 allocation score on srv03: -INFINITY native_color: prmIpPostgreSQLDB1 allocation score on srv04: 200 native_color: prmIpPostgreSQLDB2 allocation score on srv01: -INFINITY native_color: prmIpPostgreSQLDB2 allocation score on srv02: 200 native_color: prmIpPostgreSQLDB2 allocation score on srv03: -INFINITY native_color: prmIpPostgreSQLDB2 allocation score on srv04: -INFINITY native_color: prmIpPostgreSQLDB3 allocation score on srv01: -INFINITY native_color: prmIpPostgreSQLDB3 allocation score on srv02: -INFINITY native_color: prmIpPostgreSQLDB3 allocation score on srv03: 200 native_color: prmIpPostgreSQLDB3 allocation score on srv04: -INFINITY native_color: prmStonithN1 allocation score on srv01: -INFINITY native_color: prmStonithN1 allocation score on srv02: 100 native_color: prmStonithN1 allocation score on srv03: 100 native_color: prmStonithN1 allocation score on srv04: 300 native_color: prmStonithN2 allocation score on srv01: 200 native_color: prmStonithN2 allocation score on srv02: -INFINITY native_color: prmStonithN2 allocation score on srv03: 200 native_color: prmStonithN2 allocation score on srv04: 100 native_color: prmStonithN3 allocation score on srv01: 100 native_color: prmStonithN3 allocation score on srv02: 300 native_color: prmStonithN3 allocation score on srv03: -INFINITY native_color: prmStonithN3 allocation score on srv04: 100 native_color: prmStonithN4 allocation score on srv01: 100 native_color: prmStonithN4 allocation score on srv02: 100 native_color: prmStonithN4 allocation score on srv03: 300 native_color: prmStonithN4 allocation score on srv04: -INFINITY diff --git a/pengine/test10/master-13.scores b/pengine/test10/master-13.scores index 45e43e6691..e0a8abbcfe 100644 --- a/pengine/test10/master-13.scores +++ b/pengine/test10/master-13.scores @@ -1,27 +1,27 @@ Allocation scores: clone_color: drbd0:0 allocation score on frigg: 76 clone_color: drbd0:0 allocation score on odin: 0 clone_color: drbd0:1 allocation score on frigg: 0 clone_color: drbd0:1 allocation score on odin: 76 -clone_color: ms_drbd allocation score on frigg: -INFINITY +clone_color: ms_drbd allocation score on frigg: 0 clone_color: ms_drbd allocation score on odin: 0 drbd0:0 promotion score on frigg: -INFINITY -drbd0:0 promotion score on frigg: -INFINITY +drbd0:0 promotion score on frigg: 1 drbd0:1 promotion score on odin: 75 drbd0:1 promotion score on odin: INFINITY drbd0:2 promotion score on none: 0 drbd0:2 promotion score on none: 0 group_color: IPaddr0 allocation score on frigg: -INFINITY group_color: IPaddr0 allocation score on odin: 0 group_color: MailTo allocation score on frigg: 0 group_color: MailTo allocation score on odin: 0 group_color: group allocation score on frigg: 0 group_color: group allocation score on odin: 0 native_color: IPaddr0 allocation score on frigg: -INFINITY native_color: IPaddr0 allocation score on odin: 76 native_color: MailTo allocation score on frigg: -INFINITY native_color: MailTo allocation score on odin: 0 native_color: drbd0:0 allocation score on frigg: 76 native_color: drbd0:0 allocation score on odin: 0 native_color: drbd0:1 allocation score on frigg: -INFINITY native_color: drbd0:1 allocation score on odin: 76 diff --git a/pengine/test10/master-demote.scores b/pengine/test10/master-demote.scores index 53efad17a4..11bb2da802 100644 --- a/pengine/test10/master-demote.scores +++ b/pengine/test10/master-demote.scores @@ -1,76 +1,76 @@ Allocation scores: -clone_color: cyrus_drbd allocation score on cxa1: 210 -clone_color: cyrus_drbd allocation score on cxb1: 200 +clone_color: cyrus_drbd allocation score on cxa1: 1 +clone_color: cyrus_drbd allocation score on cxb1: 1 clone_color: cyrus_drbd_node:0 allocation score on cxa1: 76 clone_color: cyrus_drbd_node:0 allocation score on cxb1: 0 clone_color: cyrus_drbd_node:1 allocation score on cxa1: 0 clone_color: cyrus_drbd_node:1 allocation score on cxb1: 76 clone_color: fence_clone allocation score on cxa1: 0 clone_color: fence_clone allocation score on cxb1: 0 clone_color: fence_node:0 allocation score on cxa1: 1 clone_color: fence_node:0 allocation score on cxb1: 0 clone_color: fence_node:1 allocation score on cxa1: 0 clone_color: fence_node:1 allocation score on cxb1: 1 -clone_color: named_drbd allocation score on cxa1: 200 -clone_color: named_drbd allocation score on cxb1: 210 +clone_color: named_drbd allocation score on cxa1: 1 +clone_color: named_drbd allocation score on cxb1: 1 clone_color: named_drbd_node:0 allocation score on cxa1: 75 clone_color: named_drbd_node:0 allocation score on cxb1: 76 clone_color: named_drbd_node:1 allocation score on cxa1: 76 clone_color: named_drbd_node:1 allocation score on cxb1: 75 clone_color: pingd_clone allocation score on cxa1: 0 clone_color: pingd_clone allocation score on cxb1: 0 clone_color: pingd_node:0 allocation score on cxa1: 1 clone_color: pingd_node:0 allocation score on cxb1: 0 clone_color: pingd_node:1 allocation score on cxa1: 0 clone_color: pingd_node:1 allocation score on cxb1: 1 -cyrus_drbd_node:0 promotion score on cxa1: 285 +cyrus_drbd_node:0 promotion score on cxa1: 1 cyrus_drbd_node:0 promotion score on cxa1: INFINITY cyrus_drbd_node:0 promotion score on cxa1: INFINITY cyrus_drbd_node:1 promotion score on cxb1: -INFINITY cyrus_drbd_node:1 promotion score on cxb1: -INFINITY -cyrus_drbd_node:1 promotion score on cxb1: 275 -named_drbd_node:0 promotion score on cxb1: 285 +cyrus_drbd_node:1 promotion score on cxb1: 1 +named_drbd_node:0 promotion score on cxb1: 76 named_drbd_node:0 promotion score on cxb1: INFINITY named_drbd_node:0 promotion score on cxb1: INFINITY named_drbd_node:1 promotion score on cxa1: -INFINITY named_drbd_node:1 promotion score on cxa1: -INFINITY -named_drbd_node:1 promotion score on cxa1: 275 +named_drbd_node:1 promotion score on cxa1: 76 named_drbd_node:2 promotion score on none: 0 named_drbd_node:2 promotion score on none: 0 named_drbd_node:2 promotion score on none: 0 native_color: cyrus_address allocation score on cxa1: 210 native_color: cyrus_address allocation score on cxb1: 200 native_color: cyrus_drbd_node:0 allocation score on cxa1: 76 native_color: cyrus_drbd_node:0 allocation score on cxb1: 0 native_color: cyrus_drbd_node:1 allocation score on cxa1: -INFINITY native_color: cyrus_drbd_node:1 allocation score on cxb1: 76 native_color: cyrus_filesys allocation score on cxa1: -INFINITY native_color: cyrus_filesys allocation score on cxb1: -INFINITY native_color: cyrus_master allocation score on cxa1: -INFINITY native_color: cyrus_master allocation score on cxb1: -INFINITY native_color: cyrus_syslogd allocation score on cxa1: -INFINITY native_color: cyrus_syslogd allocation score on cxb1: -INFINITY native_color: cyrus_volgroup allocation score on cxa1: -INFINITY native_color: cyrus_volgroup allocation score on cxb1: -INFINITY native_color: fence_node:0 allocation score on cxa1: 1 native_color: fence_node:0 allocation score on cxb1: 0 native_color: fence_node:1 allocation score on cxa1: -INFINITY native_color: fence_node:1 allocation score on cxb1: 1 native_color: named_address allocation score on cxa1: 200 native_color: named_address allocation score on cxb1: 210 native_color: named_daemon allocation score on cxa1: -INFINITY native_color: named_daemon allocation score on cxb1: -INFINITY native_color: named_drbd_node:0 allocation score on cxa1: 75 native_color: named_drbd_node:0 allocation score on cxb1: 76 native_color: named_drbd_node:1 allocation score on cxa1: 76 native_color: named_drbd_node:1 allocation score on cxb1: -INFINITY native_color: named_filesys allocation score on cxa1: -INFINITY native_color: named_filesys allocation score on cxb1: -INFINITY native_color: named_syslogd allocation score on cxa1: -INFINITY native_color: named_syslogd allocation score on cxb1: -INFINITY native_color: named_volgroup allocation score on cxa1: -INFINITY native_color: named_volgroup allocation score on cxb1: -INFINITY native_color: pingd_node:0 allocation score on cxa1: 1 native_color: pingd_node:0 allocation score on cxb1: 0 native_color: pingd_node:1 allocation score on cxa1: -INFINITY native_color: pingd_node:1 allocation score on cxb1: 1 diff --git a/pengine/test10/master-depend.scores b/pengine/test10/master-depend.scores index de9c934357..c73ef1f64e 100644 --- a/pengine/test10/master-depend.scores +++ b/pengine/test10/master-depend.scores @@ -1,45 +1,45 @@ Allocation scores: clone_color: clvmd:0 allocation score on vbox3: 0 clone_color: clvmd:0 allocation score on vbox4: 0 clone_color: clvmd:1 allocation score on vbox3: 0 clone_color: clvmd:1 allocation score on vbox4: 0 -clone_color: clvmd_clone allocation score on vbox3: -INFINITY +clone_color: clvmd_clone allocation score on vbox3: 0 clone_color: clvmd_clone allocation score on vbox4: 0 clone_color: cman:0 allocation score on vbox3: 0 clone_color: cman:0 allocation score on vbox4: 0 clone_color: cman:1 allocation score on vbox3: 0 clone_color: cman:1 allocation score on vbox4: 0 -clone_color: cman_clone allocation score on vbox3: -INFINITY +clone_color: cman_clone allocation score on vbox3: 0 clone_color: cman_clone allocation score on vbox4: 0 -clone_color: drbd allocation score on vbox3: -INFINITY +clone_color: drbd allocation score on vbox3: 1 clone_color: drbd allocation score on vbox4: 0 clone_color: drbd0:0 allocation score on vbox3: 1 clone_color: drbd0:0 allocation score on vbox4: 0 clone_color: drbd0:1 allocation score on vbox3: 1 clone_color: drbd0:1 allocation score on vbox4: 0 drbd0:0 promotion score on vbox4: -1 drbd0:0 promotion score on vbox4: -INFINITY drbd0:0 promotion score on vbox4: -INFINITY drbd0:1 promotion score on none: 0 drbd0:1 promotion score on none: 0 drbd0:1 promotion score on none: 0 native_color: clvmd:0 allocation score on vbox3: -INFINITY native_color: clvmd:0 allocation score on vbox4: -INFINITY native_color: clvmd:1 allocation score on vbox3: -INFINITY native_color: clvmd:1 allocation score on vbox4: -INFINITY native_color: cman:0 allocation score on vbox3: -INFINITY native_color: cman:0 allocation score on vbox4: 0 native_color: cman:1 allocation score on vbox3: -INFINITY native_color: cman:1 allocation score on vbox4: -INFINITY native_color: drbd0:0 allocation score on vbox3: -INFINITY native_color: drbd0:0 allocation score on vbox4: 0 native_color: drbd0:1 allocation score on vbox3: -INFINITY native_color: drbd0:1 allocation score on vbox4: -INFINITY native_color: vmnci36 allocation score on vbox3: -INFINITY native_color: vmnci36 allocation score on vbox4: -INFINITY native_color: vmnci37 allocation score on vbox3: -INFINITY native_color: vmnci37 allocation score on vbox4: -INFINITY native_color: vmnci38 allocation score on vbox3: -INFINITY native_color: vmnci38 allocation score on vbox4: -INFINITY native_color: vmnci55 allocation score on vbox3: -INFINITY native_color: vmnci55 allocation score on vbox4: -INFINITY diff --git a/pengine/test10/master-ordering.scores b/pengine/test10/master-ordering.scores index 581f29eac5..26a8a912ad 100644 --- a/pengine/test10/master-ordering.scores +++ b/pengine/test10/master-ordering.scores @@ -1,93 +1,93 @@ Allocation scores: clone_color: apache2:0 allocation score on webcluster01: 0 clone_color: apache2:0 allocation score on webcluster02: 0 clone_color: apache2:1 allocation score on webcluster01: 0 clone_color: apache2:1 allocation score on webcluster02: 0 clone_color: clone_ocfs2_www allocation score on webcluster01: 0 -clone_color: clone_ocfs2_www allocation score on webcluster02: -INFINITY +clone_color: clone_ocfs2_www allocation score on webcluster02: 0 clone_color: clone_webservice allocation score on webcluster01: 0 clone_color: clone_webservice allocation score on webcluster02: 0 clone_color: drbd_mysql:0 allocation score on webcluster01: 0 clone_color: drbd_mysql:0 allocation score on webcluster02: 0 clone_color: drbd_mysql:1 allocation score on webcluster01: 0 clone_color: drbd_mysql:1 allocation score on webcluster02: 0 clone_color: drbd_www:0 allocation score on webcluster01: 0 clone_color: drbd_www:0 allocation score on webcluster02: 0 clone_color: drbd_www:1 allocation score on webcluster01: 0 clone_color: drbd_www:1 allocation score on webcluster02: 0 clone_color: group_webservice:0 allocation score on webcluster01: 0 clone_color: group_webservice:0 allocation score on webcluster02: 0 clone_color: group_webservice:1 allocation score on webcluster01: 0 clone_color: group_webservice:1 allocation score on webcluster02: 0 clone_color: ms_drbd_mysql allocation score on webcluster01: 100 -clone_color: ms_drbd_mysql allocation score on webcluster02: -INFINITY +clone_color: ms_drbd_mysql allocation score on webcluster02: 0 clone_color: ms_drbd_www allocation score on webcluster01: 0 -clone_color: ms_drbd_www allocation score on webcluster02: -INFINITY +clone_color: ms_drbd_www allocation score on webcluster02: 0 clone_color: mysql-proxy:0 allocation score on webcluster01: 0 clone_color: mysql-proxy:0 allocation score on webcluster02: 0 clone_color: mysql-proxy:1 allocation score on webcluster01: 0 clone_color: mysql-proxy:1 allocation score on webcluster02: 0 clone_color: ocfs2_www:0 allocation score on webcluster01: 0 clone_color: ocfs2_www:0 allocation score on webcluster02: 0 clone_color: ocfs2_www:1 allocation score on webcluster01: 0 clone_color: ocfs2_www:1 allocation score on webcluster02: 0 drbd_mysql:0 promotion score on webcluster01: -1 drbd_mysql:0 promotion score on webcluster01: -INFINITY drbd_mysql:1 promotion score on none: 0 drbd_mysql:1 promotion score on none: 0 drbd_www:0 promotion score on webcluster01: -1 drbd_www:0 promotion score on webcluster01: -INFINITY drbd_www:0 promotion score on webcluster01: -INFINITY drbd_www:1 promotion score on none: 0 drbd_www:1 promotion score on none: 0 drbd_www:1 promotion score on none: 0 group_color: apache2:0 allocation score on webcluster01: 0 group_color: apache2:0 allocation score on webcluster02: -INFINITY group_color: apache2:1 allocation score on webcluster01: 0 group_color: apache2:1 allocation score on webcluster02: -INFINITY group_color: group_main allocation score on webcluster01: 100 group_color: group_main allocation score on webcluster02: 0 group_color: group_webservice:0 allocation score on webcluster01: 0 group_color: group_webservice:0 allocation score on webcluster02: -INFINITY group_color: group_webservice:1 allocation score on webcluster01: 0 group_color: group_webservice:1 allocation score on webcluster02: -INFINITY group_color: intip_0_main allocation score on webcluster01: 100 group_color: intip_0_main allocation score on webcluster02: 0 group_color: mysql-proxy:0 allocation score on webcluster01: 0 group_color: mysql-proxy:0 allocation score on webcluster02: -INFINITY group_color: mysql-proxy:1 allocation score on webcluster01: 0 group_color: mysql-proxy:1 allocation score on webcluster02: -INFINITY native_color: apache2:0 allocation score on webcluster01: -INFINITY native_color: apache2:0 allocation score on webcluster02: -INFINITY native_color: apache2:1 allocation score on webcluster01: -INFINITY native_color: apache2:1 allocation score on webcluster02: -INFINITY native_color: drbd_mysql:0 allocation score on webcluster01: 0 native_color: drbd_mysql:0 allocation score on webcluster02: -INFINITY native_color: drbd_mysql:1 allocation score on webcluster01: -INFINITY native_color: drbd_mysql:1 allocation score on webcluster02: -INFINITY native_color: drbd_www:0 allocation score on webcluster01: 0 native_color: drbd_www:0 allocation score on webcluster02: -INFINITY native_color: drbd_www:1 allocation score on webcluster01: -INFINITY native_color: drbd_www:1 allocation score on webcluster02: -INFINITY native_color: extip_1 allocation score on webcluster01: 100 native_color: extip_1 allocation score on webcluster02: 0 native_color: extip_2 allocation score on webcluster01: 0 native_color: extip_2 allocation score on webcluster02: 100 native_color: fs_mysql allocation score on webcluster01: -INFINITY native_color: fs_mysql allocation score on webcluster02: -INFINITY native_color: intip_0_main allocation score on webcluster01: -INFINITY native_color: intip_0_main allocation score on webcluster02: -INFINITY native_color: intip_1_master allocation score on webcluster01: 200 native_color: intip_1_master allocation score on webcluster02: 0 native_color: intip_2_slave allocation score on webcluster01: 0 native_color: intip_2_slave allocation score on webcluster02: 100 native_color: mysql-proxy:0 allocation score on webcluster01: -INFINITY native_color: mysql-proxy:0 allocation score on webcluster02: -INFINITY native_color: mysql-proxy:1 allocation score on webcluster01: -INFINITY native_color: mysql-proxy:1 allocation score on webcluster02: -INFINITY native_color: mysql-server allocation score on webcluster01: -INFINITY native_color: mysql-server allocation score on webcluster02: -INFINITY native_color: ocfs2_www:0 allocation score on webcluster01: -INFINITY native_color: ocfs2_www:0 allocation score on webcluster02: -INFINITY native_color: ocfs2_www:1 allocation score on webcluster01: -INFINITY native_color: ocfs2_www:1 allocation score on webcluster02: -INFINITY diff --git a/pengine/test10/master-pseudo.scores b/pengine/test10/master-pseudo.scores index 221ed16f0f..7fb8e0aaad 100644 --- a/pengine/test10/master-pseudo.scores +++ b/pengine/test10/master-pseudo.scores @@ -1,21 +1,21 @@ Allocation scores: clone_color: drbd_float:0 allocation score on raki.linbit: 0 clone_color: drbd_float:0 allocation score on sambuca.linbit: 0 -clone_color: ms_drbd_float allocation score on raki.linbit: -INFINITY +clone_color: ms_drbd_float allocation score on raki.linbit: 0 clone_color: ms_drbd_float allocation score on sambuca.linbit: 0 -drbd_float:0 promotion score on sambuca.linbit: INFINITY +drbd_float:0 promotion score on sambuca.linbit: 1 drbd_float:0 promotion score on sambuca.linbit: INFINITY group_color: fs_float allocation score on raki.linbit: 0 group_color: fs_float allocation score on sambuca.linbit: -INFINITY group_color: ip_nfs allocation score on raki.linbit: 0 group_color: ip_nfs allocation score on sambuca.linbit: 0 group_color: nfsexport allocation score on raki.linbit: 0 group_color: nfsexport allocation score on sambuca.linbit: 0 native_color: drbd_float:0 allocation score on raki.linbit: -INFINITY native_color: drbd_float:0 allocation score on sambuca.linbit: 0 native_color: fs_float allocation score on raki.linbit: -INFINITY native_color: fs_float allocation score on sambuca.linbit: -INFINITY native_color: ip_float_right allocation score on raki.linbit: -INFINITY native_color: ip_float_right allocation score on sambuca.linbit: 0 native_color: ip_nfs allocation score on raki.linbit: -INFINITY native_color: ip_nfs allocation score on sambuca.linbit: 0 diff --git a/pengine/test10/migrate-5.scores b/pengine/test10/migrate-5.scores index 7bdcec65ba..b5c709cb61 100644 --- a/pengine/test10/migrate-5.scores +++ b/pengine/test10/migrate-5.scores @@ -1,25 +1,25 @@ Allocation scores: clone_color: clone-dom0-iscsi1 allocation score on dom0-01: 0 -clone_color: clone-dom0-iscsi1 allocation score on dom0-02: -INFINITY +clone_color: clone-dom0-iscsi1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: 1 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-02: 0 group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:0 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:1 allocation score on dom0-01: 0 group_color: dom0-iscsi1:1 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: -INFINITY native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY native_color: domU-test01 allocation score on dom0-01: 0 native_color: domU-test01 allocation score on dom0-02: -INFINITY diff --git a/pengine/test10/migrate-begin.scores b/pengine/test10/migrate-begin.scores index 24c1809ef0..4d63d040e5 100644 --- a/pengine/test10/migrate-begin.scores +++ b/pengine/test10/migrate-begin.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 0 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 0 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-fail-2.scores b/pengine/test10/migrate-fail-2.scores index 24c1809ef0..4d63d040e5 100644 --- a/pengine/test10/migrate-fail-2.scores +++ b/pengine/test10/migrate-fail-2.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 0 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 0 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-fail-3.scores b/pengine/test10/migrate-fail-3.scores index cfe8c07502..00f1d6b3dc 100644 --- a/pengine/test10/migrate-fail-3.scores +++ b/pengine/test10/migrate-fail-3.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 1 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 1 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-fail-4.scores b/pengine/test10/migrate-fail-4.scores index 24c1809ef0..4d63d040e5 100644 --- a/pengine/test10/migrate-fail-4.scores +++ b/pengine/test10/migrate-fail-4.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 0 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 0 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-fail-5.scores b/pengine/test10/migrate-fail-5.scores index 24c1809ef0..4d63d040e5 100644 --- a/pengine/test10/migrate-fail-5.scores +++ b/pengine/test10/migrate-fail-5.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 0 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 0 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-fail-6.scores b/pengine/test10/migrate-fail-6.scores index 24c1809ef0..4d63d040e5 100644 --- a/pengine/test10/migrate-fail-6.scores +++ b/pengine/test10/migrate-fail-6.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 0 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 0 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-fail-7.scores b/pengine/test10/migrate-fail-7.scores index cfe8c07502..00f1d6b3dc 100644 --- a/pengine/test10/migrate-fail-7.scores +++ b/pengine/test10/migrate-fail-7.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 1 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 1 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-fail-8.scores b/pengine/test10/migrate-fail-8.scores index 24c1809ef0..4d63d040e5 100644 --- a/pengine/test10/migrate-fail-8.scores +++ b/pengine/test10/migrate-fail-8.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 0 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 0 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-fail-9.scores b/pengine/test10/migrate-fail-9.scores index 24c1809ef0..4d63d040e5 100644 --- a/pengine/test10/migrate-fail-9.scores +++ b/pengine/test10/migrate-fail-9.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 0 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 0 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-partial-1.scores b/pengine/test10/migrate-partial-1.scores index cfe8c07502..00f1d6b3dc 100644 --- a/pengine/test10/migrate-partial-1.scores +++ b/pengine/test10/migrate-partial-1.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 1 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 1 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-partial-2.scores b/pengine/test10/migrate-partial-2.scores index 24c1809ef0..4d63d040e5 100644 --- a/pengine/test10/migrate-partial-2.scores +++ b/pengine/test10/migrate-partial-2.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 0 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 0 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/migrate-partial-3.scores b/pengine/test10/migrate-partial-3.scores index 29e41e00e3..a8eecc12ed 100644 --- a/pengine/test10/migrate-partial-3.scores +++ b/pengine/test10/migrate-partial-3.scores @@ -1,25 +1,25 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 0 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY -clone_color: c-clusterfs allocation score on hex-15: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 +clone_color: c-clusterfs allocation score on hex-15: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-15: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 clone_color: dlm:1 allocation score on hex-15: 0 clone_color: dlm:2 allocation score on hex-13: 0 clone_color: dlm:2 allocation score on hex-14: 0 clone_color: dlm:2 allocation score on hex-15: 0 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:0 allocation score on hex-15: -INFINITY native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:1 allocation score on hex-15: -INFINITY native_color: dlm:2 allocation score on hex-13: -INFINITY native_color: dlm:2 allocation score on hex-14: -INFINITY native_color: dlm:2 allocation score on hex-15: -INFINITY native_color: test-vm allocation score on hex-13: 0 native_color: test-vm allocation score on hex-14: -INFINITY native_color: test-vm allocation score on hex-15: -INFINITY diff --git a/pengine/test10/migrate-stop-complex.scores b/pengine/test10/migrate-stop-complex.scores index 104a46c86f..5ed52deb32 100644 --- a/pengine/test10/migrate-stop-complex.scores +++ b/pengine/test10/migrate-stop-complex.scores @@ -1,37 +1,37 @@ Allocation scores: clone_color: bottom:0 allocation score on dom0-01: 1 clone_color: bottom:0 allocation score on dom0-02: 0 clone_color: bottom:1 allocation score on dom0-01: 0 clone_color: bottom:1 allocation score on dom0-02: 1 clone_color: clone-bottom allocation score on dom0-01: 0 -clone_color: clone-bottom allocation score on dom0-02: -INFINITY +clone_color: clone-bottom allocation score on dom0-02: 0 clone_color: clone-dom0-iscsi1 allocation score on dom0-01: 0 -clone_color: clone-dom0-iscsi1 allocation score on dom0-02: -INFINITY +clone_color: clone-dom0-iscsi1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: 1 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-02: 0 group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:0 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:1 allocation score on dom0-01: 0 group_color: dom0-iscsi1:1 allocation score on dom0-02: -INFINITY native_color: bottom:0 allocation score on dom0-01: 1 native_color: bottom:0 allocation score on dom0-02: -INFINITY native_color: bottom:1 allocation score on dom0-01: -INFINITY native_color: bottom:1 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: -INFINITY native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY native_color: domU-test01 allocation score on dom0-01: 0 native_color: domU-test01 allocation score on dom0-02: -INFINITY native_color: top allocation score on dom0-01: 0 native_color: top allocation score on dom0-02: -INFINITY diff --git a/pengine/test10/migrate-stop-start-complex.scores b/pengine/test10/migrate-stop-start-complex.scores index 368201628e..7021ff9ba6 100644 --- a/pengine/test10/migrate-stop-start-complex.scores +++ b/pengine/test10/migrate-stop-start-complex.scores @@ -1,37 +1,37 @@ Allocation scores: clone_color: bottom:0 allocation score on dom0-01: 0 clone_color: bottom:0 allocation score on dom0-02: 1 clone_color: bottom:1 allocation score on dom0-01: 0 clone_color: bottom:1 allocation score on dom0-02: 0 clone_color: clone-bottom allocation score on dom0-01: 10000 -clone_color: clone-bottom allocation score on dom0-02: -INFINITY +clone_color: clone-bottom allocation score on dom0-02: 0 clone_color: clone-dom0-iscsi1 allocation score on dom0-01: 5000 -clone_color: clone-dom0-iscsi1 allocation score on dom0-02: -INFINITY +clone_color: clone-dom0-iscsi1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: 1 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-02: 0 group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:0 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:1 allocation score on dom0-01: 0 group_color: dom0-iscsi1:1 allocation score on dom0-02: -INFINITY native_color: bottom:0 allocation score on dom0-01: 0 native_color: bottom:0 allocation score on dom0-02: -INFINITY native_color: bottom:1 allocation score on dom0-01: -INFINITY native_color: bottom:1 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: -INFINITY native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY native_color: domU-test01 allocation score on dom0-01: 5000 native_color: domU-test01 allocation score on dom0-02: -INFINITY native_color: top allocation score on dom0-01: 5000 native_color: top allocation score on dom0-02: -INFINITY diff --git a/pengine/test10/migrate-stop.scores b/pengine/test10/migrate-stop.scores index 7bdcec65ba..b5c709cb61 100644 --- a/pengine/test10/migrate-stop.scores +++ b/pengine/test10/migrate-stop.scores @@ -1,25 +1,25 @@ Allocation scores: clone_color: clone-dom0-iscsi1 allocation score on dom0-01: 0 -clone_color: clone-dom0-iscsi1 allocation score on dom0-02: -INFINITY +clone_color: clone-dom0-iscsi1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: 1 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-02: 0 group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:0 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:1 allocation score on dom0-01: 0 group_color: dom0-iscsi1:1 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: -INFINITY native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 1 native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY native_color: domU-test01 allocation score on dom0-01: 0 native_color: domU-test01 allocation score on dom0-02: -INFINITY diff --git a/pengine/test10/migrate-stop_start.scores b/pengine/test10/migrate-stop_start.scores index c04d1bfda7..649e40f3e9 100644 --- a/pengine/test10/migrate-stop_start.scores +++ b/pengine/test10/migrate-stop_start.scores @@ -1,25 +1,25 @@ Allocation scores: clone_color: clone-dom0-iscsi1 allocation score on dom0-01: 0 -clone_color: clone-dom0-iscsi1 allocation score on dom0-02: -INFINITY +clone_color: clone-dom0-iscsi1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: 1 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: 0 clone_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:0 allocation score on dom0-02: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-01: 0 clone_color: dom0-iscsi1:1 allocation score on dom0-02: 0 group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: 0 group_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:0 allocation score on dom0-01: 0 group_color: dom0-iscsi1:0 allocation score on dom0-02: -INFINITY group_color: dom0-iscsi1:1 allocation score on dom0-01: -INFINITY group_color: dom0-iscsi1:1 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-01: 0 native_color: dom0-iscsi1-cnx1:0 allocation score on dom0-02: -INFINITY native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-01: -INFINITY native_color: dom0-iscsi1-cnx1:1 allocation score on dom0-02: -INFINITY native_color: domU-test01 allocation score on dom0-01: 0 native_color: domU-test01 allocation score on dom0-02: -INFINITY diff --git a/pengine/test10/migrate-success.scores b/pengine/test10/migrate-success.scores index cfe8c07502..00f1d6b3dc 100644 --- a/pengine/test10/migrate-success.scores +++ b/pengine/test10/migrate-success.scores @@ -1,13 +1,13 @@ Allocation scores: clone_color: c-clusterfs allocation score on hex-13: 1 -clone_color: c-clusterfs allocation score on hex-14: -INFINITY +clone_color: c-clusterfs allocation score on hex-14: 0 clone_color: dlm:0 allocation score on hex-13: 1 clone_color: dlm:0 allocation score on hex-14: 0 clone_color: dlm:1 allocation score on hex-13: 0 clone_color: dlm:1 allocation score on hex-14: 1 native_color: dlm:0 allocation score on hex-13: 1 native_color: dlm:0 allocation score on hex-14: 0 native_color: dlm:1 allocation score on hex-13: -INFINITY native_color: dlm:1 allocation score on hex-14: 1 native_color: test-vm allocation score on hex-13: 1 native_color: test-vm allocation score on hex-14: -INFINITY diff --git a/pengine/test10/novell-239082.scores b/pengine/test10/novell-239082.scores index a4c4278bef..1d3a0b0a3b 100644 --- a/pengine/test10/novell-239082.scores +++ b/pengine/test10/novell-239082.scores @@ -1,19 +1,19 @@ Allocation scores: clone_color: drbd0:0 allocation score on xen-1: 0 clone_color: drbd0:0 allocation score on xen-2: 11 clone_color: drbd0:1 allocation score on xen-1: 1 clone_color: drbd0:1 allocation score on xen-2: 0 -clone_color: ms-drbd0 allocation score on xen-1: -INFINITY +clone_color: ms-drbd0 allocation score on xen-1: 0 clone_color: ms-drbd0 allocation score on xen-2: 0 drbd0:0 promotion score on xen-2: 10 drbd0:0 promotion score on xen-2: INFINITY drbd0:1 promotion score on none: 0 drbd0:1 promotion score on none: 0 drbd0:2 promotion score on none: 0 drbd0:2 promotion score on none: 0 native_color: drbd0:0 allocation score on xen-1: -INFINITY native_color: drbd0:0 allocation score on xen-2: 11 native_color: drbd0:1 allocation score on xen-1: -INFINITY native_color: drbd0:1 allocation score on xen-2: -INFINITY native_color: fs_1 allocation score on xen-1: -INFINITY native_color: fs_1 allocation score on xen-2: 11 diff --git a/pengine/test10/probe-2.scores b/pengine/test10/probe-2.scores index 92b82eb447..d29e8d0767 100644 --- a/pengine/test10/probe-2.scores +++ b/pengine/test10/probe-2.scores @@ -1,155 +1,155 @@ Allocation scores: clone_color: DoFencing allocation score on wc01: 0 clone_color: DoFencing allocation score on wc02: 0 clone_color: apache2:0 allocation score on wc01: 1 clone_color: apache2:0 allocation score on wc02: 0 clone_color: apache2:1 allocation score on wc01: 0 clone_color: apache2:1 allocation score on wc02: 1 clone_color: clone_mysql-proxy allocation score on wc01: 0 clone_color: clone_mysql-proxy allocation score on wc02: 0 clone_color: clone_nfs-common allocation score on wc01: 0 -clone_color: clone_nfs-common allocation score on wc02: -INFINITY +clone_color: clone_nfs-common allocation score on wc02: 0 clone_color: clone_webservice allocation score on wc01: 0 -clone_color: clone_webservice allocation score on wc02: -INFINITY +clone_color: clone_webservice allocation score on wc02: 0 clone_color: drbd_mysql:0 allocation score on wc01: 76 clone_color: drbd_mysql:0 allocation score on wc02: 0 clone_color: drbd_mysql:1 allocation score on wc01: 0 clone_color: drbd_mysql:1 allocation score on wc02: 1 clone_color: drbd_www:0 allocation score on wc01: 76 clone_color: drbd_www:0 allocation score on wc02: 0 clone_color: drbd_www:1 allocation score on wc01: 0 clone_color: drbd_www:1 allocation score on wc02: 1 clone_color: fs_www:0 allocation score on wc01: 1 clone_color: fs_www:0 allocation score on wc02: 0 clone_color: fs_www:1 allocation score on wc01: 0 clone_color: fs_www:1 allocation score on wc02: 1 clone_color: group_mysql-proxy:0 allocation score on wc01: 0 clone_color: group_mysql-proxy:0 allocation score on wc02: 0 clone_color: group_mysql-proxy:1 allocation score on wc01: 0 clone_color: group_mysql-proxy:1 allocation score on wc02: 0 clone_color: group_nfs-common:0 allocation score on wc01: 0 clone_color: group_nfs-common:0 allocation score on wc02: 0 clone_color: group_nfs-common:1 allocation score on wc01: 0 clone_color: group_nfs-common:1 allocation score on wc02: 0 clone_color: group_webservice:0 allocation score on wc01: 0 clone_color: group_webservice:0 allocation score on wc02: 0 clone_color: group_webservice:1 allocation score on wc01: 0 clone_color: group_webservice:1 allocation score on wc02: 0 clone_color: ms_drbd_mysql allocation score on wc01: 0 -clone_color: ms_drbd_mysql allocation score on wc02: -INFINITY +clone_color: ms_drbd_mysql allocation score on wc02: 0 clone_color: ms_drbd_www allocation score on wc01: 0 -clone_color: ms_drbd_www allocation score on wc02: -INFINITY +clone_color: ms_drbd_www allocation score on wc02: 0 clone_color: mysql-proxy:0 allocation score on wc01: 1 clone_color: mysql-proxy:0 allocation score on wc02: 0 clone_color: mysql-proxy:1 allocation score on wc01: 0 clone_color: mysql-proxy:1 allocation score on wc02: 1 clone_color: nfs-common:0 allocation score on wc01: 1 clone_color: nfs-common:0 allocation score on wc02: 0 clone_color: nfs-common:1 allocation score on wc01: 0 clone_color: nfs-common:1 allocation score on wc02: 1 clone_color: stonith_rackpdu:0 allocation score on wc01: 1 clone_color: stonith_rackpdu:0 allocation score on wc02: 0 clone_color: stonith_rackpdu:1 allocation score on wc01: 0 clone_color: stonith_rackpdu:1 allocation score on wc02: 1 drbd_mysql:0 promotion score on wc01: 75 drbd_mysql:0 promotion score on wc01: INFINITY drbd_mysql:1 promotion score on none: 0 drbd_mysql:1 promotion score on none: 0 drbd_www:0 promotion score on wc01: 175 drbd_www:0 promotion score on wc01: INFINITY drbd_www:1 promotion score on none: 0 drbd_www:1 promotion score on none: 0 group_color: apache2:0 allocation score on wc01: 1 group_color: apache2:0 allocation score on wc02: -INFINITY group_color: apache2:1 allocation score on wc01: -INFINITY group_color: apache2:1 allocation score on wc02: -INFINITY group_color: extip_ftp allocation score on wc01: 0 group_color: extip_ftp allocation score on wc02: 0 group_color: fs_mysql allocation score on wc01: 0 group_color: fs_mysql allocation score on wc02: 0 group_color: fs_www:0 allocation score on wc01: 1 group_color: fs_www:0 allocation score on wc02: -INFINITY group_color: fs_www:1 allocation score on wc01: -INFINITY group_color: fs_www:1 allocation score on wc02: -INFINITY group_color: fs_www_data allocation score on wc01: 0 group_color: fs_www_data allocation score on wc02: 0 group_color: group_ftpd allocation score on wc01: 0 group_color: group_ftpd allocation score on wc02: 0 group_color: group_mysql allocation score on wc01: 0 group_color: group_mysql allocation score on wc02: 0 group_color: group_mysql-proxy:0 allocation score on wc01: 0 group_color: group_mysql-proxy:0 allocation score on wc02: -INFINITY group_color: group_mysql-proxy:1 allocation score on wc01: -INFINITY group_color: group_mysql-proxy:1 allocation score on wc02: -INFINITY group_color: group_nfs-common:0 allocation score on wc01: 0 group_color: group_nfs-common:0 allocation score on wc02: -INFINITY group_color: group_nfs-common:1 allocation score on wc01: -INFINITY group_color: group_nfs-common:1 allocation score on wc02: -INFINITY group_color: group_webservice:0 allocation score on wc01: 0 group_color: group_webservice:0 allocation score on wc02: -INFINITY group_color: group_webservice:1 allocation score on wc01: -INFINITY group_color: group_webservice:1 allocation score on wc02: -INFINITY group_color: group_www_data allocation score on wc01: 0 group_color: group_www_data allocation score on wc02: 0 group_color: intip_nfs allocation score on wc01: 0 group_color: intip_nfs allocation score on wc02: 0 group_color: intip_sql allocation score on wc01: 0 group_color: intip_sql allocation score on wc02: 0 group_color: mysql-proxy:0 allocation score on wc01: 1 group_color: mysql-proxy:0 allocation score on wc02: -INFINITY group_color: mysql-proxy:1 allocation score on wc01: -INFINITY group_color: mysql-proxy:1 allocation score on wc02: -INFINITY group_color: mysql-server allocation score on wc01: 0 group_color: mysql-server allocation score on wc02: 0 group_color: nfs-common:0 allocation score on wc01: 1 group_color: nfs-common:0 allocation score on wc02: -INFINITY group_color: nfs-common:1 allocation score on wc01: -INFINITY group_color: nfs-common:1 allocation score on wc02: -INFINITY group_color: nfs-kernel-server allocation score on wc01: 0 group_color: nfs-kernel-server allocation score on wc02: 0 group_color: pure-ftpd allocation score on wc01: 0 group_color: pure-ftpd allocation score on wc02: 0 native_color: apache2:0 allocation score on wc01: 1 native_color: apache2:0 allocation score on wc02: -INFINITY native_color: apache2:1 allocation score on wc01: -INFINITY native_color: apache2:1 allocation score on wc02: -INFINITY native_color: drbd_mysql:0 allocation score on wc01: 76 native_color: drbd_mysql:0 allocation score on wc02: -INFINITY native_color: drbd_mysql:1 allocation score on wc01: -INFINITY native_color: drbd_mysql:1 allocation score on wc02: -INFINITY native_color: drbd_www:0 allocation score on wc01: 76 native_color: drbd_www:0 allocation score on wc02: -INFINITY native_color: drbd_www:1 allocation score on wc01: -INFINITY native_color: drbd_www:1 allocation score on wc02: -INFINITY native_color: extip_ftp allocation score on wc01: 0 native_color: extip_ftp allocation score on wc02: -INFINITY native_color: fs_mysql allocation score on wc01: 76 native_color: fs_mysql allocation score on wc02: -INFINITY native_color: fs_www:0 allocation score on wc01: 2 native_color: fs_www:0 allocation score on wc02: -INFINITY native_color: fs_www:1 allocation score on wc01: -INFINITY native_color: fs_www:1 allocation score on wc02: -INFINITY native_color: fs_www_data allocation score on wc01: 76 native_color: fs_www_data allocation score on wc02: -INFINITY native_color: intip_nfs allocation score on wc01: 0 native_color: intip_nfs allocation score on wc02: -INFINITY native_color: intip_sql allocation score on wc01: 0 native_color: intip_sql allocation score on wc02: -INFINITY native_color: mysql-proxy:0 allocation score on wc01: 1 native_color: mysql-proxy:0 allocation score on wc02: -INFINITY native_color: mysql-proxy:1 allocation score on wc01: -INFINITY native_color: mysql-proxy:1 allocation score on wc02: -INFINITY native_color: mysql-server allocation score on wc01: 0 native_color: mysql-server allocation score on wc02: -INFINITY native_color: nfs-common:0 allocation score on wc01: 1 native_color: nfs-common:0 allocation score on wc02: -INFINITY native_color: nfs-common:1 allocation score on wc01: -INFINITY native_color: nfs-common:1 allocation score on wc02: -INFINITY native_color: nfs-kernel-server allocation score on wc01: 0 native_color: nfs-kernel-server allocation score on wc02: -INFINITY native_color: pure-ftpd allocation score on wc01: 0 native_color: pure-ftpd allocation score on wc02: -INFINITY native_color: stonith_rackpdu:0 allocation score on wc01: 1 native_color: stonith_rackpdu:0 allocation score on wc02: -INFINITY native_color: stonith_rackpdu:1 allocation score on wc01: -INFINITY native_color: stonith_rackpdu:1 allocation score on wc02: -INFINITY diff --git a/pengine/test10/probe-3.scores b/pengine/test10/probe-3.scores index 62ee93f58d..320c7fa871 100644 --- a/pengine/test10/probe-3.scores +++ b/pengine/test10/probe-3.scores @@ -1,169 +1,169 @@ Allocation scores: clone_color: Connectivity allocation score on pcmk-1: 0 clone_color: Connectivity allocation score on pcmk-2: 0 clone_color: Connectivity allocation score on pcmk-3: 0 clone_color: Connectivity allocation score on pcmk-4: 0 clone_color: Fencing allocation score on pcmk-1: 0 clone_color: Fencing allocation score on pcmk-2: 0 clone_color: Fencing allocation score on pcmk-3: 0 clone_color: Fencing allocation score on pcmk-4: 0 clone_color: FencingChild:0 allocation score on pcmk-1: 0 clone_color: FencingChild:0 allocation score on pcmk-2: 0 clone_color: FencingChild:0 allocation score on pcmk-3: 1 clone_color: FencingChild:0 allocation score on pcmk-4: 0 clone_color: FencingChild:1 allocation score on pcmk-1: 0 clone_color: FencingChild:1 allocation score on pcmk-2: 0 clone_color: FencingChild:1 allocation score on pcmk-3: 0 clone_color: FencingChild:1 allocation score on pcmk-4: 0 clone_color: FencingChild:2 allocation score on pcmk-1: 0 clone_color: FencingChild:2 allocation score on pcmk-2: 1 clone_color: FencingChild:2 allocation score on pcmk-3: 0 clone_color: FencingChild:2 allocation score on pcmk-4: 0 clone_color: FencingChild:3 allocation score on pcmk-1: 1 clone_color: FencingChild:3 allocation score on pcmk-2: 0 clone_color: FencingChild:3 allocation score on pcmk-3: 0 clone_color: FencingChild:3 allocation score on pcmk-4: 0 clone_color: master-1 allocation score on pcmk-1: 0 clone_color: master-1 allocation score on pcmk-2: 0 clone_color: master-1 allocation score on pcmk-3: 0 -clone_color: master-1 allocation score on pcmk-4: -INFINITY +clone_color: master-1 allocation score on pcmk-4: 0 clone_color: ping-1:0 allocation score on pcmk-1: 1 clone_color: ping-1:0 allocation score on pcmk-2: 0 clone_color: ping-1:0 allocation score on pcmk-3: 0 clone_color: ping-1:0 allocation score on pcmk-4: 0 clone_color: ping-1:1 allocation score on pcmk-1: 0 clone_color: ping-1:1 allocation score on pcmk-2: 1 clone_color: ping-1:1 allocation score on pcmk-3: 0 clone_color: ping-1:1 allocation score on pcmk-4: 0 clone_color: ping-1:2 allocation score on pcmk-1: 0 clone_color: ping-1:2 allocation score on pcmk-2: 0 clone_color: ping-1:2 allocation score on pcmk-3: 1 clone_color: ping-1:2 allocation score on pcmk-4: 0 clone_color: ping-1:3 allocation score on pcmk-1: 0 clone_color: ping-1:3 allocation score on pcmk-2: 0 clone_color: ping-1:3 allocation score on pcmk-3: 0 clone_color: ping-1:3 allocation score on pcmk-4: 0 clone_color: stateful-1:0 allocation score on pcmk-1: 11 clone_color: stateful-1:0 allocation score on pcmk-2: 5 clone_color: stateful-1:0 allocation score on pcmk-3: 5 clone_color: stateful-1:0 allocation score on pcmk-4: 0 clone_color: stateful-1:1 allocation score on pcmk-1: 10 clone_color: stateful-1:1 allocation score on pcmk-2: 6 clone_color: stateful-1:1 allocation score on pcmk-3: 5 clone_color: stateful-1:1 allocation score on pcmk-4: 0 clone_color: stateful-1:2 allocation score on pcmk-1: 10 clone_color: stateful-1:2 allocation score on pcmk-2: 5 clone_color: stateful-1:2 allocation score on pcmk-3: 6 clone_color: stateful-1:2 allocation score on pcmk-4: 0 clone_color: stateful-1:3 allocation score on pcmk-1: 0 clone_color: stateful-1:3 allocation score on pcmk-2: 0 clone_color: stateful-1:3 allocation score on pcmk-3: 0 clone_color: stateful-1:3 allocation score on pcmk-4: 0 group_color: group-1 allocation score on pcmk-1: 0 group_color: group-1 allocation score on pcmk-2: 0 group_color: group-1 allocation score on pcmk-3: 0 group_color: group-1 allocation score on pcmk-4: 0 group_color: r192.168.101.181 allocation score on pcmk-1: 0 group_color: r192.168.101.181 allocation score on pcmk-2: 0 group_color: r192.168.101.181 allocation score on pcmk-3: 0 group_color: r192.168.101.181 allocation score on pcmk-4: 0 group_color: r192.168.101.182 allocation score on pcmk-1: 0 group_color: r192.168.101.182 allocation score on pcmk-2: 0 group_color: r192.168.101.182 allocation score on pcmk-3: 0 group_color: r192.168.101.182 allocation score on pcmk-4: 0 group_color: r192.168.101.183 allocation score on pcmk-1: 0 group_color: r192.168.101.183 allocation score on pcmk-2: 0 group_color: r192.168.101.183 allocation score on pcmk-3: 0 group_color: r192.168.101.183 allocation score on pcmk-4: 0 native_color: FencingChild:0 allocation score on pcmk-1: 0 native_color: FencingChild:0 allocation score on pcmk-2: 0 native_color: FencingChild:0 allocation score on pcmk-3: 1 native_color: FencingChild:0 allocation score on pcmk-4: -INFINITY native_color: FencingChild:1 allocation score on pcmk-1: -INFINITY native_color: FencingChild:1 allocation score on pcmk-2: -INFINITY native_color: FencingChild:1 allocation score on pcmk-3: -INFINITY native_color: FencingChild:1 allocation score on pcmk-4: -INFINITY native_color: FencingChild:2 allocation score on pcmk-1: 0 native_color: FencingChild:2 allocation score on pcmk-2: 1 native_color: FencingChild:2 allocation score on pcmk-3: -INFINITY native_color: FencingChild:2 allocation score on pcmk-4: -INFINITY native_color: FencingChild:3 allocation score on pcmk-1: 1 native_color: FencingChild:3 allocation score on pcmk-2: -INFINITY native_color: FencingChild:3 allocation score on pcmk-3: -INFINITY native_color: FencingChild:3 allocation score on pcmk-4: -INFINITY native_color: lsb-dummy allocation score on pcmk-1: 0 native_color: lsb-dummy allocation score on pcmk-2: -INFINITY native_color: lsb-dummy allocation score on pcmk-3: -INFINITY native_color: lsb-dummy allocation score on pcmk-4: -INFINITY native_color: migrator allocation score on pcmk-1: 0 native_color: migrator allocation score on pcmk-2: 0 native_color: migrator allocation score on pcmk-3: 0 native_color: migrator allocation score on pcmk-4: 0 native_color: ping-1:0 allocation score on pcmk-1: 1 native_color: ping-1:0 allocation score on pcmk-2: 0 native_color: ping-1:0 allocation score on pcmk-3: 0 native_color: ping-1:0 allocation score on pcmk-4: -INFINITY native_color: ping-1:1 allocation score on pcmk-1: -INFINITY native_color: ping-1:1 allocation score on pcmk-2: 1 native_color: ping-1:1 allocation score on pcmk-3: 0 native_color: ping-1:1 allocation score on pcmk-4: -INFINITY native_color: ping-1:2 allocation score on pcmk-1: -INFINITY native_color: ping-1:2 allocation score on pcmk-2: -INFINITY native_color: ping-1:2 allocation score on pcmk-3: 1 native_color: ping-1:2 allocation score on pcmk-4: -INFINITY native_color: ping-1:3 allocation score on pcmk-1: -INFINITY native_color: ping-1:3 allocation score on pcmk-2: -INFINITY native_color: ping-1:3 allocation score on pcmk-3: -INFINITY native_color: ping-1:3 allocation score on pcmk-4: -INFINITY native_color: r192.168.101.181 allocation score on pcmk-1: 11 native_color: r192.168.101.181 allocation score on pcmk-2: -INFINITY native_color: r192.168.101.181 allocation score on pcmk-3: -INFINITY native_color: r192.168.101.181 allocation score on pcmk-4: -INFINITY native_color: r192.168.101.182 allocation score on pcmk-1: 0 native_color: r192.168.101.182 allocation score on pcmk-2: -INFINITY native_color: r192.168.101.182 allocation score on pcmk-3: -INFINITY native_color: r192.168.101.182 allocation score on pcmk-4: -INFINITY native_color: r192.168.101.183 allocation score on pcmk-1: 0 native_color: r192.168.101.183 allocation score on pcmk-2: -INFINITY native_color: r192.168.101.183 allocation score on pcmk-3: -INFINITY native_color: r192.168.101.183 allocation score on pcmk-4: -INFINITY native_color: rsc_pcmk-1 allocation score on pcmk-1: 100 native_color: rsc_pcmk-1 allocation score on pcmk-2: 0 native_color: rsc_pcmk-1 allocation score on pcmk-3: 0 native_color: rsc_pcmk-1 allocation score on pcmk-4: 0 native_color: rsc_pcmk-2 allocation score on pcmk-1: 0 native_color: rsc_pcmk-2 allocation score on pcmk-2: 100 native_color: rsc_pcmk-2 allocation score on pcmk-3: 0 native_color: rsc_pcmk-2 allocation score on pcmk-4: 0 native_color: rsc_pcmk-3 allocation score on pcmk-1: 0 native_color: rsc_pcmk-3 allocation score on pcmk-2: 0 native_color: rsc_pcmk-3 allocation score on pcmk-3: 100 native_color: rsc_pcmk-3 allocation score on pcmk-4: 0 native_color: rsc_pcmk-4 allocation score on pcmk-1: 0 native_color: rsc_pcmk-4 allocation score on pcmk-2: 0 native_color: rsc_pcmk-4 allocation score on pcmk-3: 0 native_color: rsc_pcmk-4 allocation score on pcmk-4: 100 native_color: stateful-1:0 allocation score on pcmk-1: 11 native_color: stateful-1:0 allocation score on pcmk-2: 5 native_color: stateful-1:0 allocation score on pcmk-3: 5 native_color: stateful-1:0 allocation score on pcmk-4: -INFINITY native_color: stateful-1:1 allocation score on pcmk-1: -INFINITY native_color: stateful-1:1 allocation score on pcmk-2: 6 native_color: stateful-1:1 allocation score on pcmk-3: 5 native_color: stateful-1:1 allocation score on pcmk-4: -INFINITY native_color: stateful-1:2 allocation score on pcmk-1: -INFINITY native_color: stateful-1:2 allocation score on pcmk-2: -INFINITY native_color: stateful-1:2 allocation score on pcmk-3: 6 native_color: stateful-1:2 allocation score on pcmk-4: -INFINITY native_color: stateful-1:3 allocation score on pcmk-1: -INFINITY native_color: stateful-1:3 allocation score on pcmk-2: -INFINITY native_color: stateful-1:3 allocation score on pcmk-3: -INFINITY native_color: stateful-1:3 allocation score on pcmk-4: -INFINITY stateful-1:0 promotion score on pcmk-1: 10 stateful-1:0 promotion score on pcmk-1: INFINITY stateful-1:1 promotion score on pcmk-2: -INFINITY stateful-1:1 promotion score on pcmk-2: 5 stateful-1:2 promotion score on pcmk-3: -INFINITY stateful-1:2 promotion score on pcmk-3: 5 stateful-1:3 promotion score on none: 0 stateful-1:3 promotion score on none: 0 diff --git a/pengine/test10/probe-4.scores b/pengine/test10/probe-4.scores index 2adea1b267..ca14c06e00 100644 --- a/pengine/test10/probe-4.scores +++ b/pengine/test10/probe-4.scores @@ -1,171 +1,171 @@ Allocation scores: An invalid transition was produced Transition failed: terminated clone_color: Connectivity allocation score on pcmk-1: 0 clone_color: Connectivity allocation score on pcmk-2: 0 clone_color: Connectivity allocation score on pcmk-3: 0 clone_color: Connectivity allocation score on pcmk-4: 0 clone_color: Fencing allocation score on pcmk-1: 0 clone_color: Fencing allocation score on pcmk-2: 0 clone_color: Fencing allocation score on pcmk-3: 0 clone_color: Fencing allocation score on pcmk-4: 0 clone_color: FencingChild:0 allocation score on pcmk-1: 0 clone_color: FencingChild:0 allocation score on pcmk-2: 0 clone_color: FencingChild:0 allocation score on pcmk-3: 1 clone_color: FencingChild:0 allocation score on pcmk-4: 0 clone_color: FencingChild:1 allocation score on pcmk-1: 0 clone_color: FencingChild:1 allocation score on pcmk-2: 0 clone_color: FencingChild:1 allocation score on pcmk-3: 0 clone_color: FencingChild:1 allocation score on pcmk-4: 0 clone_color: FencingChild:2 allocation score on pcmk-1: 0 clone_color: FencingChild:2 allocation score on pcmk-2: 1 clone_color: FencingChild:2 allocation score on pcmk-3: 0 clone_color: FencingChild:2 allocation score on pcmk-4: 0 clone_color: FencingChild:3 allocation score on pcmk-1: 1 clone_color: FencingChild:3 allocation score on pcmk-2: 0 clone_color: FencingChild:3 allocation score on pcmk-3: 0 clone_color: FencingChild:3 allocation score on pcmk-4: 0 clone_color: master-1 allocation score on pcmk-1: 0 clone_color: master-1 allocation score on pcmk-2: 0 clone_color: master-1 allocation score on pcmk-3: 0 -clone_color: master-1 allocation score on pcmk-4: -INFINITY +clone_color: master-1 allocation score on pcmk-4: 0 clone_color: ping-1:0 allocation score on pcmk-1: 1 clone_color: ping-1:0 allocation score on pcmk-2: 0 clone_color: ping-1:0 allocation score on pcmk-3: 0 clone_color: ping-1:0 allocation score on pcmk-4: 0 clone_color: ping-1:1 allocation score on pcmk-1: 0 clone_color: ping-1:1 allocation score on pcmk-2: 1 clone_color: ping-1:1 allocation score on pcmk-3: 0 clone_color: ping-1:1 allocation score on pcmk-4: 0 clone_color: ping-1:2 allocation score on pcmk-1: 0 clone_color: ping-1:2 allocation score on pcmk-2: 0 clone_color: ping-1:2 allocation score on pcmk-3: 1 clone_color: ping-1:2 allocation score on pcmk-4: 0 clone_color: ping-1:3 allocation score on pcmk-1: 0 clone_color: ping-1:3 allocation score on pcmk-2: 0 clone_color: ping-1:3 allocation score on pcmk-3: 0 clone_color: ping-1:3 allocation score on pcmk-4: 0 clone_color: stateful-1:0 allocation score on pcmk-1: 11 clone_color: stateful-1:0 allocation score on pcmk-2: 5 clone_color: stateful-1:0 allocation score on pcmk-3: 5 clone_color: stateful-1:0 allocation score on pcmk-4: 0 clone_color: stateful-1:1 allocation score on pcmk-1: 10 clone_color: stateful-1:1 allocation score on pcmk-2: 6 clone_color: stateful-1:1 allocation score on pcmk-3: 5 clone_color: stateful-1:1 allocation score on pcmk-4: 0 clone_color: stateful-1:2 allocation score on pcmk-1: 10 clone_color: stateful-1:2 allocation score on pcmk-2: 5 clone_color: stateful-1:2 allocation score on pcmk-3: 6 clone_color: stateful-1:2 allocation score on pcmk-4: 0 clone_color: stateful-1:3 allocation score on pcmk-1: 0 clone_color: stateful-1:3 allocation score on pcmk-2: 0 clone_color: stateful-1:3 allocation score on pcmk-3: 0 clone_color: stateful-1:3 allocation score on pcmk-4: 0 group_color: group-1 allocation score on pcmk-1: 0 group_color: group-1 allocation score on pcmk-2: 0 group_color: group-1 allocation score on pcmk-3: 0 group_color: group-1 allocation score on pcmk-4: 0 group_color: r192.168.101.181 allocation score on pcmk-1: 0 group_color: r192.168.101.181 allocation score on pcmk-2: 0 group_color: r192.168.101.181 allocation score on pcmk-3: 0 group_color: r192.168.101.181 allocation score on pcmk-4: 0 group_color: r192.168.101.182 allocation score on pcmk-1: 0 group_color: r192.168.101.182 allocation score on pcmk-2: 0 group_color: r192.168.101.182 allocation score on pcmk-3: 0 group_color: r192.168.101.182 allocation score on pcmk-4: 0 group_color: r192.168.101.183 allocation score on pcmk-1: 0 group_color: r192.168.101.183 allocation score on pcmk-2: 0 group_color: r192.168.101.183 allocation score on pcmk-3: 0 group_color: r192.168.101.183 allocation score on pcmk-4: 0 native_color: FencingChild:0 allocation score on pcmk-1: 0 native_color: FencingChild:0 allocation score on pcmk-2: 0 native_color: FencingChild:0 allocation score on pcmk-3: 1 native_color: FencingChild:0 allocation score on pcmk-4: -INFINITY native_color: FencingChild:1 allocation score on pcmk-1: -INFINITY native_color: FencingChild:1 allocation score on pcmk-2: -INFINITY native_color: FencingChild:1 allocation score on pcmk-3: -INFINITY native_color: FencingChild:1 allocation score on pcmk-4: -INFINITY native_color: FencingChild:2 allocation score on pcmk-1: 0 native_color: FencingChild:2 allocation score on pcmk-2: 1 native_color: FencingChild:2 allocation score on pcmk-3: -INFINITY native_color: FencingChild:2 allocation score on pcmk-4: -INFINITY native_color: FencingChild:3 allocation score on pcmk-1: 1 native_color: FencingChild:3 allocation score on pcmk-2: -INFINITY native_color: FencingChild:3 allocation score on pcmk-3: -INFINITY native_color: FencingChild:3 allocation score on pcmk-4: -INFINITY native_color: lsb-dummy allocation score on pcmk-1: 0 native_color: lsb-dummy allocation score on pcmk-2: -INFINITY native_color: lsb-dummy allocation score on pcmk-3: -INFINITY native_color: lsb-dummy allocation score on pcmk-4: -INFINITY native_color: migrator allocation score on pcmk-1: 0 native_color: migrator allocation score on pcmk-2: 0 native_color: migrator allocation score on pcmk-3: 0 native_color: migrator allocation score on pcmk-4: 0 native_color: ping-1:0 allocation score on pcmk-1: 1 native_color: ping-1:0 allocation score on pcmk-2: 0 native_color: ping-1:0 allocation score on pcmk-3: 0 native_color: ping-1:0 allocation score on pcmk-4: -INFINITY native_color: ping-1:1 allocation score on pcmk-1: -INFINITY native_color: ping-1:1 allocation score on pcmk-2: 1 native_color: ping-1:1 allocation score on pcmk-3: 0 native_color: ping-1:1 allocation score on pcmk-4: -INFINITY native_color: ping-1:2 allocation score on pcmk-1: -INFINITY native_color: ping-1:2 allocation score on pcmk-2: -INFINITY native_color: ping-1:2 allocation score on pcmk-3: 1 native_color: ping-1:2 allocation score on pcmk-4: -INFINITY native_color: ping-1:3 allocation score on pcmk-1: -INFINITY native_color: ping-1:3 allocation score on pcmk-2: -INFINITY native_color: ping-1:3 allocation score on pcmk-3: -INFINITY native_color: ping-1:3 allocation score on pcmk-4: -INFINITY native_color: r192.168.101.181 allocation score on pcmk-1: 11 native_color: r192.168.101.181 allocation score on pcmk-2: -INFINITY native_color: r192.168.101.181 allocation score on pcmk-3: -INFINITY native_color: r192.168.101.181 allocation score on pcmk-4: -INFINITY native_color: r192.168.101.182 allocation score on pcmk-1: 0 native_color: r192.168.101.182 allocation score on pcmk-2: -INFINITY native_color: r192.168.101.182 allocation score on pcmk-3: -INFINITY native_color: r192.168.101.182 allocation score on pcmk-4: -INFINITY native_color: r192.168.101.183 allocation score on pcmk-1: 0 native_color: r192.168.101.183 allocation score on pcmk-2: -INFINITY native_color: r192.168.101.183 allocation score on pcmk-3: -INFINITY native_color: r192.168.101.183 allocation score on pcmk-4: -INFINITY native_color: rsc_pcmk-1 allocation score on pcmk-1: 100 native_color: rsc_pcmk-1 allocation score on pcmk-2: 0 native_color: rsc_pcmk-1 allocation score on pcmk-3: 0 native_color: rsc_pcmk-1 allocation score on pcmk-4: 0 native_color: rsc_pcmk-2 allocation score on pcmk-1: 0 native_color: rsc_pcmk-2 allocation score on pcmk-2: 100 native_color: rsc_pcmk-2 allocation score on pcmk-3: 0 native_color: rsc_pcmk-2 allocation score on pcmk-4: 0 native_color: rsc_pcmk-3 allocation score on pcmk-1: 0 native_color: rsc_pcmk-3 allocation score on pcmk-2: 0 native_color: rsc_pcmk-3 allocation score on pcmk-3: 100 native_color: rsc_pcmk-3 allocation score on pcmk-4: 0 native_color: rsc_pcmk-4 allocation score on pcmk-1: 0 native_color: rsc_pcmk-4 allocation score on pcmk-2: 0 native_color: rsc_pcmk-4 allocation score on pcmk-3: 0 native_color: rsc_pcmk-4 allocation score on pcmk-4: 100 native_color: stateful-1:0 allocation score on pcmk-1: 11 native_color: stateful-1:0 allocation score on pcmk-2: 5 native_color: stateful-1:0 allocation score on pcmk-3: 5 native_color: stateful-1:0 allocation score on pcmk-4: -INFINITY native_color: stateful-1:1 allocation score on pcmk-1: -INFINITY native_color: stateful-1:1 allocation score on pcmk-2: 6 native_color: stateful-1:1 allocation score on pcmk-3: 5 native_color: stateful-1:1 allocation score on pcmk-4: -INFINITY native_color: stateful-1:2 allocation score on pcmk-1: -INFINITY native_color: stateful-1:2 allocation score on pcmk-2: -INFINITY native_color: stateful-1:2 allocation score on pcmk-3: 6 native_color: stateful-1:2 allocation score on pcmk-4: -INFINITY native_color: stateful-1:3 allocation score on pcmk-1: -INFINITY native_color: stateful-1:3 allocation score on pcmk-2: -INFINITY native_color: stateful-1:3 allocation score on pcmk-3: -INFINITY native_color: stateful-1:3 allocation score on pcmk-4: -INFINITY stateful-1:0 promotion score on pcmk-1: 10 stateful-1:0 promotion score on pcmk-1: INFINITY stateful-1:1 promotion score on pcmk-2: -INFINITY stateful-1:1 promotion score on pcmk-2: 5 stateful-1:2 promotion score on pcmk-3: -INFINITY stateful-1:2 promotion score on pcmk-3: 5 stateful-1:3 promotion score on none: 0 stateful-1:3 promotion score on none: 0 diff --git a/pengine/test10/rsc-sets-clone.scores b/pengine/test10/rsc-sets-clone.scores index ceb1cf6c60..1efaa18ce8 100644 --- a/pengine/test10/rsc-sets-clone.scores +++ b/pengine/test10/rsc-sets-clone.scores @@ -1,17 +1,17 @@ Allocation scores: -clone_color: clone-rsc allocation score on node1: -INFINITY +clone_color: clone-rsc allocation score on node1: 0 clone_color: clone-rsc allocation score on node2: 0 clone_color: rsc:0 allocation score on node1: 1 clone_color: rsc:0 allocation score on node2: 0 clone_color: rsc:1 allocation score on node1: 0 clone_color: rsc:1 allocation score on node2: 1 native_color: rsc1 allocation score on node1: -INFINITY native_color: rsc1 allocation score on node2: 0 native_color: rsc2 allocation score on node1: -INFINITY native_color: rsc2 allocation score on node2: 0 native_color: rsc3 allocation score on node1: -INFINITY native_color: rsc3 allocation score on node2: 0 native_color: rsc:0 allocation score on node1: -INFINITY native_color: rsc:0 allocation score on node2: -INFINITY native_color: rsc:1 allocation score on node1: -INFINITY native_color: rsc:1 allocation score on node2: 1 diff --git a/pengine/test10/rsc-sets-master.scores b/pengine/test10/rsc-sets-master.scores index ce3c96b529..561d8bdfbb 100644 --- a/pengine/test10/rsc-sets-master.scores +++ b/pengine/test10/rsc-sets-master.scores @@ -1,25 +1,25 @@ Allocation scores: -clone_color: ms-rsc allocation score on node1: -INFINITY +clone_color: ms-rsc allocation score on node1: 0 clone_color: ms-rsc allocation score on node2: 0 clone_color: rsc:0 allocation score on node1: 1 clone_color: rsc:0 allocation score on node2: 0 clone_color: rsc:1 allocation score on node1: 0 clone_color: rsc:1 allocation score on node2: 1 native_color: rsc1 allocation score on node1: -INFINITY native_color: rsc1 allocation score on node2: 1 native_color: rsc2 allocation score on node1: -INFINITY native_color: rsc2 allocation score on node2: 1 native_color: rsc3 allocation score on node1: -INFINITY native_color: rsc3 allocation score on node2: 1 native_color: rsc:0 allocation score on node1: -INFINITY native_color: rsc:0 allocation score on node2: -INFINITY native_color: rsc:1 allocation score on node1: -INFINITY native_color: rsc:1 allocation score on node2: 1 rsc:0 promotion score on none: 0 rsc:0 promotion score on none: 0 rsc:0 promotion score on none: 0 rsc:0 promotion score on none: 0 rsc:1 promotion score on node2: 299 rsc:1 promotion score on node2: INFINITY rsc:1 promotion score on node2: INFINITY rsc:1 promotion score on node2: INFINITY