diff --git a/crm/admin/Makefile.am b/crm/admin/Makefile.am index 09f6c5d812..157e2287ea 100644 --- a/crm/admin/Makefile.am +++ b/crm/admin/Makefile.am @@ -1,116 +1,118 @@ # # Copyright (C) 2004 Andrew Beekhof # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program 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 program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # MAINTAINERCLEANFILES = Makefile.in INCLUDES = -I$(top_builddir)/include -I$(top_srcdir)/include \ -I$(top_builddir)/libltdl -I$(top_srcdir)/libltdl \ -I$(top_builddir)/linux-ha -I$(top_srcdir)/linux-ha \ -I$(top_builddir) -I$(top_srcdir) +halibdir = $(libdir)/@HB_PKG@ hasbindir = $(sbindir) LIBRT = @LIBRT@ AM_CFLAGS = @CFLAGS@ $(CRM_DEBUG_FLAGS) COMMONLIBS = $(CRM_DEBUG_LIBS) \ $(top_builddir)/lib/clplumbing/libplumb.la \ $(top_builddir)/lib/pils/libpils.la \ $(top_builddir)/lib/crm/common/libcrmcommon.la \ $(top_builddir)/lib/crm/cib/libcib.la \ $(top_builddir)/lib/apphb/libapphb.la \ $(top_builddir)/lib/hbclient/libhbclient.la \ $(GLIBLIB) \ $(CURSESLIBS) \ $(LIBRT) -hasbin_SCRIPTS = crm_primitive.py cluster.py crm_utils.py crm_commands.py -## binary progs +halib_PYTHON = crm_primitive.py crm_utils.py crm_commands.py hasbin_PROGRAMS = crmadmin cibadmin ccm_tool crm_diff crm_mon iso8601 \ crm_master crm_standby crm_failcount crm_attribute \ - crm_resource crm_verify crm_uuid + crm_resource crm_verify crm_uuid + +hasbin_SCRIPTS = cluster ## SOURCES #noinst_HEADERS = config.h control.h crmd.h noinst_HEADERS = crmadmin_SOURCES = crmadmin.c crmadmin_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crmadmin_LDADD = $(COMMONLIBS) \ $(top_builddir)/lib/crm/pengine/libpe_status.la crm_uuid_SOURCES = crm_uuid.c crm_uuid_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crm_uuid_LDADD = $(GLIBLIB) $(top_builddir)/lib/clplumbing/libplumb.la cibadmin_SOURCES = cibadmin.c cibadmin_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' cibadmin_LDADD = $(COMMONLIBS) ccm_tool_SOURCES = ccm_epoche.c ccm_tool_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' ccm_tool_LDADD = $(COMMONLIBS) \ $(top_builddir)/membership/ccm/libccmclient.la crm_diff_SOURCES = xml_diff.c crm_diff_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crm_diff_LDADD = $(COMMONLIBS) crm_mon_SOURCES = crm_mon.c crm_mon_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crm_mon_LDADD = $(COMMONLIBS) \ $(top_builddir)/lib/crm/pengine/libpe_status.la # Arguments could be made that this should live in crm/pengine crm_verify_SOURCES = crm_verify.c crm_verify_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crm_verify_LDADD = $(COMMONLIBS) \ $(top_builddir)/lib/crm/pengine/libpe_status.la \ $(top_builddir)/crm/pengine/libpengine.la crm_master_SOURCES = crm_attribute.c crm_master_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crm_master_LDADD = $(COMMONLIBS) crm_standby_SOURCES = crm_attribute.c crm_standby_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crm_standby_LDADD = $(COMMONLIBS) crm_attribute_SOURCES = crm_attribute.c crm_attribute_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crm_attribute_LDADD = $(COMMONLIBS) crm_failcount_SOURCES = crm_attribute.c crm_failcount_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crm_failcount_LDADD = $(COMMONLIBS) crm_resource_SOURCES = crm_resource.c crm_resource_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' crm_resource_LDADD = $(COMMONLIBS) \ $(top_builddir)/lib/crm/pengine/libpe_status.la iso8601_SOURCES = test.iso8601.c iso8601_CFLAGS = -DHA_VARLIBDIR='"@HA_VARLIBDIR@"' iso8601_LDADD = $(COMMONLIBS) clean-generic: rm -f *.log *.debug *.xml *~ install-exec-local: uninstall-local: diff --git a/crm/admin/cluster.in b/crm/admin/cluster.in new file mode 100644 index 0000000000..df6c8b4f50 --- /dev/null +++ b/crm/admin/cluster.in @@ -0,0 +1,361 @@ +#!@PYTHON@ +# +# Copyright (c) 2006 Andrew Beekhof +# All Rights Reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of version 2 of the GNU General Public License as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it would be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# +# Further, this software is distributed without any warranty that it is +# free of the rightful claim of any third person regarding infringement +# or the like. Any license provided herein, whether implied or +# otherwise, applies only to this software file. Patent licenses, if +# any, provided herein do not apply to combinations of this program with +# other software, or any other product whatsoever. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA. +# +####################################################################### + +import os +import sys +import readline +import traceback +from popen2 import Popen3 + +# Module copied from Mercurial + +sys.path.append("@HA_LIBDIR@/heartbeat") +import crm_utils as utl +import crm_commands as crm + + +class ParseError(Exception): + """Exception raised on errors in parsing the command line.""" +class QuotingError(Exception): + """Exception raised on errors in parsing the command line.""" +class UnknownCommand(Exception): + """Exception raised if command is not in the command table.""" +class AmbiguousCommand(Exception): + """Exception raised if command shortcut matches more than one command.""" + +table = { + "^help": ( + crm.help, None, [('v', 'verbose', None, 'extra information')], + "[-v]"), + "^up": (crm.up, None, [], None, "Move up a level in the heirarchy"), + "^crm": (crm.cd_, ["crm"], [], None), + "^nodes": (crm.cd_, ["crm"], [], None), + "^resources": (crm.cd_, ["crm"], [], None), + "^config": (crm.cd_, ["crm"], [], None), + "^list": ( + crm.do_list, ["nodes", "resources"], [('t', 'topic', "", '')], + None), + "^status": ( + crm.do_status, ["nodes", "resources"], [], + "[list of objects]"), + "^debug": (crm.toggle_flag, None, [('f', 'flag', 'debug', '')], None, "Toggle debugging information"), + "^exit": (crm.exit, None, [], "exit"), + "^debugstate": ( + crm.debugstate, None, [], + None, + "Dump information about the internal state of the program"), + } + +global_opt_table = [ + ('q', 'quiet', None, 'suppress output'), + ('v', 'verbose', None, 'enable additional output'), + ('', 'debug', None, 'enable debugging output'), + ('', 'devlog', None, 'enable developmental debugging output'), + ('', 'debugger', None, 'start debugger'), + ('', 'lsprof', None, 'print improved command execution profile'), + ('', 'traceback', None, 'print traceback on exception'), + ('', 'time', None, 'time how long the command takes'), + ('', 'profile', None, 'print command execution profile'), + ('', 'version', None, 'output version information and exit'), + ('i', 'interactive', None, 'run in interactive mode'), + ('h', 'help', None, 'display help and exit'), + ] + +def help_(text): + utl.log_dev("Looking up help text for: %s" % text) + if text == "short": + utl.log_info("cluster.py [global options] [topic [topic...]] [command]") + return + if text: + choice = findpossible(text, None, False) + for key in choice.keys(): + alias, e = choice[key] + text = alias[0] + utl.log_dev("Help text for: %s" % text) + if e: + sub_cmd="" + if len(e) > 4: + utl.log_info("\n"+e[4]+"\n") + possible = findpossible("", text).keys() + utl.log_dev("Possible sub-commands: "+repr(possible)) + possible.remove("up") + possible.remove("help") + possible.remove("exit") + if text in possible: + possible.remove(text) + if possible: + sub_cmd=' ('+'|'.join(possible)+')' + if e[3]: + utl.log_info("Usage: %s %s%s" % (text, e[3], sub_cmd)) + else: + utl.log_info("Usage: %s%s" % (text, sub_cmd)) + if choice: + return; + utl.log_err("No help text available for: %s" % text) + + +# Stolen from Mercurial commands.py + +def findpossible(cmd, topic=None, filter=True): + """ + Return cmd -> (aliases, command table entry) + for each matching command. + Return debug commands (or their aliases) only if no normal command matches. + """ + if not topic: + topic = utl.crm_topic + utl.log_dev("Searching in default topic: %s" % topic) + + utl.log_dev("Looking for completions of %s in %s" % (cmd, topic)) + choice = {} + debugchoice = {} + topicchoice = {} + for e in table.keys(): + t = table[e] + #utl.log_dev("Processing: %s / %s" % (e, repr(t))) + aliases = e.lstrip("^").split("|") + found = None + if "^%s"%topic == e and t[0] == crm.cd_: + #utl.log_dev("Found: topic") + topicchoice[topic] = (aliases, table[e]) + if filter and t[1] and topic not in t[1]: + #utl.log_dev("Skip: filter") + continue + elif cmd in aliases: + #utl.log_dev("Found: alias") + found = cmd + else: + for a in aliases: + if a.startswith(cmd): + #utl.log_dev("Found: alias prefix") + found = a + break + if found is not None: + if aliases[0].startswith("debug"): + debugchoice[found] = (aliases, table[e]) + else: + choice[found] = (aliases, table[e]) + + if not choice and debugchoice: + choice = debugchoice + + if not choice and topicchoice: + choice = topicchoice + + return choice + +def findcmd(cmd): + """Return (aliases, command table entry) for command string.""" + choice = findpossible(cmd) + + if choice.has_key(cmd): + #utl.log_dev("Choice has: %s" % cmd) + return choice[cmd] + + if len(choice) > 1: + clist = choice.keys() + clist.sort() + raise AmbiguousCommand(cmd, clist) + + if choice: + #utl.log_dev("Returning first: %s" % (repr(choice.values()[0]))) + return choice.values()[0] + + raise UnknownCommand(cmd) + +def find_completer(start, i): + choice = findpossible(start) + if not choice: + return None + elif len(choice.keys()) < i: + return None + return choice.keys()[i] + +def parse(args): + options = {} + cmdoptions = {} + + try: + args = utl.fancyopts(args, global_opt_table, options) + except utl.getopt.GetoptError, inst: + raise ParseError(None, inst) + + if args: + cmd, args = args[0], args[1:] + utl.log_dev("Initial Command: %s" % cmd) + aliases, i = findcmd(cmd) + cmd = aliases[0] + utl.log_dev("Found Command: %s" % cmd) + defaults = [] + if defaults: + args = defaults.split() + args + c = list(i[2]) + else: + cmd = None + c = [] + + # combine global options into local + for o in global_opt_table: + c.append((o[0], o[1], options[o[1]], o[3])) + + try: + args = utl.fancyopts(args, c, cmdoptions) + except utl.getopt.GetoptError, inst: + raise ParseError(cmd, inst) + + # separate global options back out + for o in global_opt_table: + n = o[1] + options[n] = cmdoptions[n] + del cmdoptions[n] + + utl.log_dev("args: %s\ncmdoptions: %s" + % (repr(args), repr(cmdoptions))) + return (cmd, cmd and i[0] or None, args, options, cmdoptions) + +def main_loop(args): + cmd = None + if not args: + return 0 + + try: + cmd, func, cmd_args, ignore, cmd_options = parse(args) + + if func == crm.cd_: + cmd_options["topic"] = cmd + + utl.log_dev("Func Command: %s" % cmd) + utl.log_dev("Func Args: %s" % repr(cmd_args)) + utl.log_dev("Func Opts: %s" % repr(cmd_options)) + + if not cmd: + utl.log_dev(repr(args)) + return 0 + d = lambda: func(*cmd_args, **cmd_options) + return d() + + except crm.HelpRequest, inst: + help_(inst.args[0]) + return 0 + + except crm.ReparseRequest: + return main_loop(cmd_args) + + except ParseError, inst: + if inst.args[0]: + utl.log_err("%s: %s\n" % (inst.args[0], inst.args[1])) + help_(inst.args[0]) + else: + utl.log_err("%s\n" % inst.args[1]) + help_('short') + + except AmbiguousCommand, inst: + utl.log_info("%s: command '%s' is ambiguous:\n %s\n" + % (" ".join(utl.topic_stack), inst.args[0], " ".join(inst.args[1]))) + + except UnknownCommand, inst: + utl.log_err("%s: unknown command '%s'\n" % (" ".join(utl.topic_stack), inst.args[0])) + help_(utl.crm_topic) + + except IOError, inst: + if hasattr(inst, "code"): + utl.log_err("abort: %s\n" % inst) + elif hasattr(inst, "reason"): + utl.log_err("abort: error: %s\n" % inst.reason[1]) + elif hasattr(inst, "args"): + utl.log_err("broken pipe\n") + elif getattr(inst, "strerror", None): + if getattr(inst, "filename", None): + utl.log_err("abort: %s - %s\n" % (inst.strerror, inst.filename)) + else: + utl.log_err("abort: %s\n" % inst.strerror) + else: + raise + except OSError, inst: + if hasattr(inst, "filename"): + utl.log_err("abort: %s: %s\n" % (inst.strerror, inst.filename)) + else: + utl.log_err("abort: %s\n" % inst.strerror) + + except TypeError, inst: + # was this an argument error? + tb = traceback.extract_tb(sys.exc_info()[2]) + if len(tb) > 2: # no + raise + utl.log_err((inst, "\n")) + utl.log_err(("%s: invalid arguments\n" % cmd)) + help_(cmd) + raise + except SystemExit, inst: + # Exit gracefully + utl.exit_(inst.code) + + except: + utl.log_err("** unknown exception encountered, details follow\n") + raise + + return -1 + +args = sys.argv[1:] +utl.init_readline(find_completer) +try: + cmd, f_ignore, a_ignore, utl.global_opts, o_ignore = parse(args) +except: + pass + +if len(sys.argv) == 1: + utl.global_opts["interactive"] = 1 +elif not utl.global_opts.has_key("interactive"): + utl.global_opts["interactive"] = 0 + +while True: + rc = 0 + if args: + utl.set_topic(utl.topic_stack[-1]) + rc = main_loop(args) + utl.log_debug("rc: %s" % (repr(rc))) + + if not utl.global_opts["interactive"]: + utl.exit_(rc) + + try: + text = raw_input(" ".join(utl.topic_stack) +" # ") + args = utl.create_argv(text) + + except QuotingError, inst: + if inst.args[1]: + utl.log_err("%s. Found tokens: %s\n" % (inst.args[0], inst.args[1])) + else: + utl.log_err("%s\n" % inst.args[0]) + + except KeyboardInterrupt: + pass + + except EOFError: + utl.exit_(0) + + + diff --git a/crm/crm-1.0.dtd b/crm/crm-1.0.dtd index a3f2ead607..a4db41b33d 100644 --- a/crm/crm-1.0.dtd +++ b/crm/crm-1.0.dtd @@ -1,825 +1,825 @@ + score CDATA #REQUIRED> diff --git a/crm/pengine/allocate.c b/crm/pengine/allocate.c index 39f9bcacc3..9a78220f93 100644 --- a/crm/pengine/allocate.c +++ b/crm/pengine/allocate.c @@ -1,1493 +1,1318 @@ /* $Id: allocate.c,v 1.12 2006/08/14 09:06:31 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include void set_alloc_actions(pe_working_set_t *data_set); resource_alloc_functions_t resource_class_alloc_functions[] = { { native_set_cmds, native_num_allowed_nodes, native_color, native_create_actions, native_create_probe, native_internal_constraints, native_agent_constraints, native_rsc_colocation_lh, native_rsc_colocation_rh, native_rsc_order_lh, native_rsc_order_rh, native_rsc_location, native_expand, native_stonith_ordering, native_create_notify_element, }, { group_set_cmds, group_num_allowed_nodes, group_color, group_create_actions, group_create_probe, group_internal_constraints, group_agent_constraints, group_rsc_colocation_lh, group_rsc_colocation_rh, group_rsc_order_lh, group_rsc_order_rh, group_rsc_location, group_expand, group_stonith_ordering, group_create_notify_element, }, { clone_set_cmds, clone_num_allowed_nodes, clone_color, clone_create_actions, clone_create_probe, clone_internal_constraints, clone_agent_constraints, clone_rsc_colocation_lh, clone_rsc_colocation_rh, clone_rsc_order_lh, clone_rsc_order_rh, clone_rsc_location, clone_expand, clone_stonith_ordering, clone_create_notify_element, }, { clone_set_cmds, clone_num_allowed_nodes, clone_color, master_create_actions, clone_create_probe, master_internal_constraints, clone_agent_constraints, clone_rsc_colocation_lh, clone_rsc_colocation_rh, clone_rsc_order_lh, clone_rsc_order_rh, clone_rsc_location, clone_expand, clone_stonith_ordering, clone_create_notify_element, } }; -color_t *add_color(resource_t *rh_resource, color_t *color); - -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; - -} - -color_t * -add_color(resource_t *resource, color_t *color) -{ - color_t *local_color = NULL; - - if(color == NULL) { - pe_err("Cannot add NULL color"); - return NULL; - } - - local_color = find_color(resource->candidate_colors, color); - - if(local_color == NULL) { - crm_debug_4("Adding color %d", color->id); - - local_color = copy_color(color); - resource->candidate_colors = - g_list_append(resource->candidate_colors, local_color); - - } else { - crm_debug_4("Color %d already present", color->id); - } - - return local_color; -} - -void -set_alloc_actions(pe_working_set_t *data_set) -{ - slist_iter( - rsc, resource_t, data_set->resources, lpc, - rsc->cmds = &resource_class_alloc_functions[rsc->variant]; - rsc->cmds->set_cmds(rsc); - ); -} - -gboolean -stage0(pe_working_set_t *data_set) -{ - crm_data_t * cib_constraints = get_object_root( - XML_CIB_TAG_CONSTRAINTS, data_set->input); - - if(data_set->input == NULL) { - return FALSE; - } - - cluster_status(data_set); - - set_alloc_actions(data_set); - data_set->no_color = create_color(data_set, NULL, NULL); - - unpack_constraints(cib_constraints, 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 -stage1(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); - - return TRUE; -} - -/* - * Choose a color for all resources from highest priority and XML_STRENGTH_VAL_MUST - * dependencies to lowest, creating new colors as necessary (returned - * as "colors"). - * - * Some nodes may be colored as a "no_color" meaning that it was unresolvable - * given the current node stati and constraints. - */ -gboolean -stage3(pe_working_set_t *data_set) -{ - crm_debug_3("Coloring resources"); - - crm_debug_5("create \"no color\""); - - /* Take (next) highest resource */ - slist_iter( - rsc, resource_t, data_set->resources, lpc, - rsc->cmds->internal_constraints(rsc, data_set); - rsc->cmds->color(rsc, data_set); - ); - - return TRUE; -} - -/* - * Check nodes for resources started outside of the LRM - */ -gboolean -stage2(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); - - crm_debug_2("%s probed: %s", node->details->uname, probed); - if(node->details->online == FALSE) { - continue; - - } else if(node->details->unclean) { - continue; - - } else if(probe_complete == NULL) { - probe_complete = custom_action( - NULL, crm_strdup(CRM_OP_PROBED), - CRM_OP_PROBED, NULL, FALSE, TRUE, - data_set); - - probe_complete->pseudo = TRUE; - probe_complete->optional = TRUE; - } - - 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); - probe_node_complete->optional = crm_is_true(probed); - probe_node_complete->priority = INFINITY; - add_hash_param(probe_node_complete->meta, - XML_ATTR_TE_NOWAIT, XML_BOOLEAN_TRUE); - - custom_action_order(NULL, NULL, probe_node_complete, - NULL, NULL, probe_complete, - pe_ordering_optional, data_set); - - slist_iter( - rsc, resource_t, data_set->resources, lpc2, - - if(rsc->cmds->create_probe( - rsc, node, probe_node_complete, - force_probe, data_set)) { - - probe_complete->optional = FALSE; - probe_node_complete->optional = FALSE; - custom_action_order( - NULL, NULL, probe_complete, - rsc, start_key(rsc), NULL, - pe_ordering_manditory, data_set); - } - ); - ); - - return TRUE; -} - -/* - * Choose a node for each (if possible) color - */ -gboolean -stage4(pe_working_set_t *data_set) -{ - node_t *chosen = NULL; - crm_debug_3("Assigning nodes to colors"); - - slist_iter( - color, color_t, data_set->colors, lpc, - - crm_debug_4("assigning node to color %d", color->id); - - if(color == NULL) { - pe_err("NULL color detected"); - continue; - - } else if(color->details->pending == FALSE) { - continue; - } - - choose_node_from_list(color); - - slist_iter( - rsc, resource_t, color->details->allocated_resources, lpc2, - crm_debug_2("Processing colocation constraints for %s" - " now that color %d is allocated", - rsc->id, color->details->id); - - slist_iter( - constraint, rsc_colocation_t, rsc->rsc_cons, lpc, - rsc->cmds->rsc_colocation_lh( - rsc, constraint->rsc_rh, constraint); - ); - - ); - - chosen = color->details->chosen_node; - - slist_iter( - rsc, resource_t, color->details->allocated_resources, lpc2, - if(chosen == NULL) { - rsc->next_role = RSC_ROLE_STOPPED; - - } else if(rsc->next_role == RSC_ROLE_UNKNOWN) { - rsc->next_role = RSC_ROLE_STARTED; - } - ); - ); - - crm_debug_3("done"); - return TRUE; - -} - static gboolean check_rsc_parameters(resource_t *rsc, node_t *node, crm_data_t *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(safe_str_eq(value, old_value)) { 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); rsc->start_pending = TRUE; delete_resource = TRUE; } return delete_resource; } static gboolean check_action_definition(resource_t *rsc, node_t *active_node, crm_data_t *xml_op, pe_working_set_t *data_set) { char *key = NULL; int interval = 0; const char *interval_s = NULL; gboolean did_change = FALSE; crm_data_t *pnow = NULL; GHashTable *local_rsc_params = NULL; char *pnow_digest = NULL; const char *param_digest = NULL; char *local_param_digest = NULL; #if CRM_DEPRECATED_SINCE_2_0_4 crm_data_t *params = NULL; #endif 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 = get_interval(xml_op); interval = crm_parse_int(interval_s, "0"); key = generate_op_key(rsc->id, task, interval); if(interval > 0) { crm_data_t *op_match = NULL; crm_debug_2("Checking parameters for %s %s", key, task); op_match = find_rsc_op_entry(rsc, key); if(op_match == NULL && data_set->stop_action_orphans) { /* create a cancel action */ action_t *cancel = NULL; char *cancel_key = NULL; crm_info("Orphan action will be stopped: %s on %s", key, active_node->details->uname); cancel_key = generate_op_key(rsc->id, CRMD_ACTION_CANCEL, interval); cancel = custom_action( rsc, cancel_key, CRMD_ACTION_CANCEL, active_node, FALSE, TRUE, data_set); add_hash_param(cancel->meta, XML_LRM_ATTR_TASK, task); add_hash_param(cancel->meta, XML_LRM_ATTR_INTERVAL, interval_s); custom_action_order( rsc, NULL, cancel, rsc, stop_key(rsc), NULL, pe_ordering_optional, data_set); } 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); unpack_instance_attributes( rsc->xml, XML_TAG_ATTR_SETS, active_node->details->attrs, local_rsc_params, NULL, data_set->now); pnow = create_xml_node(NULL, XML_TAG_PARAMS); g_hash_table_foreach(action->extra, hash2field, pnow); g_hash_table_foreach(rsc->parameters, hash2field, pnow); g_hash_table_foreach(local_rsc_params, hash2field, pnow); filter_action_parameters(pnow, op_version); pnow_digest = calculate_xml_digest(pnow, TRUE); param_digest = crm_element_value(xml_op, XML_LRM_ATTR_OP_DIGEST); #if CRM_DEPRECATED_SINCE_2_0_4 if(param_digest == NULL) { params = find_xml_node(xml_op, XML_TAG_PARAMS, TRUE); } if(params != NULL) { crm_data_t *local_params = copy_xml(params); crm_warn("Faking parameter digest creation for %s", ID(xml_op)); filter_action_parameters(local_params, op_version); xml_remove_prop(local_params, "interval"); xml_remove_prop(local_params, "timeout"); crm_log_xml_warn(local_params, "params:used"); local_param_digest = calculate_xml_digest(local_params, TRUE); param_digest = local_param_digest; free_xml(local_params); } #endif if(safe_str_neq(pnow_digest, param_digest)) { did_change = TRUE; crm_log_xml_info(pnow, "params:calc"); crm_warn("Parameters to %s on %s changed: recorded %s vs. calculated %s", ID(xml_op), active_node->details->uname, crm_str(param_digest), pnow_digest); key = generate_op_key(rsc->id, task, interval); custom_action(rsc, key, task, NULL, FALSE, TRUE, data_set); } free_xml(pnow); crm_free(pnow_digest); crm_free(local_param_digest); g_hash_table_destroy(local_rsc_params); pe_free_action(action); return did_change; } extern gboolean DeleteRsc(resource_t *rsc, node_t *node, pe_working_set_t *data_set); static void check_actions_for(crm_data_t *rsc_entry, node_t *node, pe_working_set_t *data_set) { const char *id = NULL; const char *task = NULL; int interval = 0; const char *interval_s = NULL; GListPtr op_list = NULL; GListPtr sorted_op_list = NULL; const char *rsc_id = ID(rsc_entry); gboolean is_probe = FALSE; resource_t *rsc = pe_find_resource(data_set->resources, rsc_id); CRM_CHECK(rsc_id != NULL, return); if(rsc == NULL) { crm_warn("Skipping param check for resource with no actions"); return; } else if(rsc->orphan) { crm_debug_2("Skipping param check for orphan: %s %s", rsc->id, task); return; } crm_debug_2("Processing %s on %s", rsc->id, node->details->uname); if(check_rsc_parameters(rsc, node, rsc_entry, data_set)) { DeleteRsc(rsc, node, data_set); } xml_child_iter_filter( rsc_entry, rsc_op, XML_LRM_TAG_RSC_OP, op_list = g_list_append(op_list, rsc_op); ); sorted_op_list = g_list_sort(op_list, sort_op_by_callid); slist_iter( rsc_op, crm_data_t, sorted_op_list, lpc, id = ID(rsc_op); is_probe = FALSE; task = crm_element_value(rsc_op, XML_LRM_ATTR_TASK); interval_s = get_interval(rsc_op); interval = crm_parse_int(interval_s, "0"); if(interval == 0 && safe_str_eq(task, CRMD_ACTION_STATUS)) { is_probe = TRUE; } if(is_probe || safe_str_eq(task, CRMD_ACTION_START) || interval > 0) { crm_debug_2("Checking resource definition: %s", rsc->id); check_action_definition(rsc, node, rsc_op, data_set); } crm_debug_3("Ignoring %s params: %s", task, id); ); g_list_free(sorted_op_list); } static void check_actions(pe_working_set_t *data_set) { const char *id = NULL; node_t *node = NULL; crm_data_t *lrm_rscs = NULL; crm_data_t *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; } crm_debug("Processing node %s", node->details->uname); if(node->details->online || data_set->stonith_enabled) { xml_child_iter_filter( lrm_rscs, rsc_entry, XML_LRM_TAG_RESOURCE, check_actions_for(rsc_entry, node, data_set); ); } ); } +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; + +} + +void +set_alloc_actions(pe_working_set_t *data_set) +{ + slist_iter( + rsc, resource_t, data_set->resources, lpc, + rsc->cmds = &resource_class_alloc_functions[rsc->variant]; + rsc->cmds->set_cmds(rsc); + ); +} + +gboolean +stage0(pe_working_set_t *data_set) +{ + crm_data_t * cib_constraints = get_object_root( + XML_CIB_TAG_CONSTRAINTS, data_set->input); + + if(data_set->input == NULL) { + return FALSE; + } + + cluster_status(data_set); + + set_alloc_actions(data_set); + + unpack_constraints(cib_constraints, data_set); + return TRUE; +} + +/* + * Check nodes for resources started outside of the LRM + */ +gboolean +stage1(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); + + crm_debug_2("%s probed: %s", node->details->uname, probed); + if(node->details->online == FALSE) { + continue; + + } else if(node->details->unclean) { + continue; + + } else if(probe_complete == NULL) { + probe_complete = custom_action( + NULL, crm_strdup(CRM_OP_PROBED), + CRM_OP_PROBED, NULL, FALSE, TRUE, + data_set); + + probe_complete->pseudo = TRUE; + probe_complete->optional = TRUE; + } + + 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); + probe_node_complete->optional = crm_is_true(probed); + probe_node_complete->priority = INFINITY; + add_hash_param(probe_node_complete->meta, + XML_ATTR_TE_NOWAIT, XML_BOOLEAN_TRUE); + + custom_action_order(NULL, NULL, probe_node_complete, + NULL, NULL, probe_complete, + pe_ordering_optional, data_set); + + slist_iter( + rsc, resource_t, data_set->resources, lpc2, + + if(rsc->cmds->create_probe( + rsc, node, probe_node_complete, + force_probe, data_set)) { + + probe_complete->optional = FALSE; + probe_node_complete->optional = FALSE; + custom_action_order( + NULL, NULL, probe_complete, + rsc, start_key(rsc), NULL, + pe_ordering_manditory, 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); + + return TRUE; +} + + +/* + * Choose a color for all resources from highest priority and XML_STRENGTH_VAL_MUST + * dependencies to lowest, creating new colors as necessary (returned + * as "colors"). + * + * Some nodes may be colored as a "no_color" meaning that it was unresolvable + * given the current node stati and constraints. + */ +gboolean +stage3(pe_working_set_t *data_set) +{ + + /* Take (next) highest resource */ + slist_iter( + rsc, resource_t, data_set->resources, lpc, + rsc->cmds->internal_constraints(rsc, data_set); + rsc->cmds->color(rsc, data_set); + ); + + return TRUE; +} + +/* + * Choose a node for each (if possible) color + */ +gboolean +stage4(pe_working_set_t *data_set) +{ + return TRUE; +} + + /* * Attach nodes to the actions that need to be taken * * Mark actions XML_LRM_ATTR_OPTIONAL if possible (Ie. if the start and stop are * for the same node) * * Mark unrunnable actions */ gboolean stage5(pe_working_set_t *data_set) { crm_debug_3("Creating actions and internal ording constraints"); check_actions(data_set); slist_iter( rsc, resource_t, data_set->resources, lpc, rsc->cmds->create_actions(rsc, data_set); ); return TRUE; } /* * Create dependacies 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; crm_debug_3("Processing fencing and shutdown cases"); slist_iter( node, node_t, data_set->nodes, lpc, stonith_op = NULL; if(node->details->unclean && data_set->stonith_enabled && (data_set->have_quorum || data_set->no_quorum_policy == no_quorum_ignore)) { 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); if(node->details->is_dc) { dc_down = stonith_op; } else { if(last_stonith) { order_actions(last_stonith, stonith_op, pe_ordering_manditory); } last_stonith = stonith_op; } } else if(node->details->online && node->details->shutdown) { action_t *down_op = NULL; crm_info("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); 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(data_set->have_quorum == FALSE) { crm_notice("Cannot fence unclean nodes until quorum is" " attained (or no_quorum_policy is set to ignore)"); } else if(data_set->stonith_enabled == FALSE) { pe_warn("YOUR RESOURCES ARE NOW LIKELY COMPROMISED"); pe_err("ENABLE STONITH TO KEEP YOUR RESOURCES SAFE"); } } 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_ordering_manditory); ); if(last_stonith && dc_down != last_stonith) { order_actions(last_stonith, dc_down, pe_ordering_manditory); } } 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 * */ gboolean stage7(pe_working_set_t *data_set) { crm_debug_3("Applying ordering constraints"); slist_iter( order, order_constraint_t, data_set->ordering_constraints, lpc, /* try rsc_action-to-rsc_action */ resource_t *rsc = order->lh_rsc; if(rsc == NULL && order->lh_action) { rsc = order->lh_action->rsc; } if(rsc != NULL) { rsc->cmds->rsc_order_lh(rsc, order); continue; } /* try action-to-rsc_action */ /* que off the rh resource */ rsc = order->rh_rsc; if(rsc == NULL && order->rh_action) { rsc = order->rh_action->rsc; } if(rsc != NULL) { rsc->cmds->rsc_order_rh(order->lh_action, rsc, order); } else { /* fall back to action-to-action */ order_actions( order->lh_action, order->rh_action, order->type); } ); update_action_states(data_set->actions); return TRUE; } 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; char *transition_id_s = NULL; transition_id++; transition_id_s = crm_itoa(transition_id); value = pe_pref(data_set->config_hash, "network-delay"); crm_debug("Creating transition graph %d.", transition_id); data_set->graph = create_xml_node(NULL, XML_TAG_GRAPH); crm_xml_add(data_set->graph, "network-delay", value); crm_xml_add(data_set->graph, "transition_id", transition_id_s); crm_free(transition_id_s); /* 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_notice("Created transition graph %d.", transition_id); return TRUE; } - -gboolean -choose_node_from_list(color_t *color) -{ - /* - 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 - */ - GListPtr nodes = color->details->candidate_nodes; - node_t *chosen = NULL; - int multiple = 0; - - crm_debug_3("Choosing node for color %d", color->id); - color->details->candidate_nodes = g_list_sort(nodes, sort_node_weight); - nodes = color->details->candidate_nodes; - - chosen = g_list_nth_data(nodes, 0); - - color->details->chosen_node = NULL; - color->details->pending = FALSE; - - if(chosen == NULL) { - if(color->id != 0) { - crm_debug("Could not allocate a node for color %d", color->id); - } - return FALSE; - - } else if(chosen->details->unclean - || chosen->details->standby - || chosen->details->shutdown) { - crm_debug("All nodes for color %d are unavailable" - ", unclean or shutting down", color->id); - color->details->chosen_node = NULL; - return FALSE; - - } else if(chosen->weight < 0) { - crm_debug_2("Even highest ranked node for color %d, had weight %d", - color->id, chosen->weight); - color->details->chosen_node = NULL; - return FALSE; - } - - slist_iter(candidate, node_t, nodes, lpc, - crm_debug("Color %d, Node[%d] %s: %d", color->id, lpc, - candidate->details->uname, candidate->weight); - if(chosen->weight > 0 - && candidate->details->unclean == FALSE - && candidate->weight == chosen->weight) { - multiple++; - } else { - break; - } - ); - - if(multiple > 1) { - int log_level = LOG_INFO; - char *score = score2char(chosen->weight); - if(chosen->weight >= INFINITY) { - log_level = LOG_WARNING; - } - - crm_log_maybe(log_level, "%d nodes with equal score (%s) for" - " running the listed resources (chose %s):", - multiple, score, chosen->details->uname); - slist_iter(rsc, resource_t, - color->details->allocated_resources, lpc, - rsc->fns->print( - rsc, "\t", pe_print_log|pe_print_rsconly, - &log_level); - ); - crm_free(score); - } - - /* todo: update the old node for each resource to reflect its - * new resource count - */ - - chosen->details->num_resources += color->details->num_resources; - color->details->chosen_node = node_copy(chosen); - - return TRUE; -} - void cleanup_alloc_calculations(pe_working_set_t *data_set) { if(data_set == NULL) { return; } crm_debug_3("deleting order cons: %p", data_set->ordering_constraints); pe_free_ordering(data_set->ordering_constraints); data_set->ordering_constraints = NULL; - crm_debug_3("deleting colors: %p", data_set->colors); - pe_free_colors(data_set->colors); - data_set->colors = NULL; - crm_debug_3("deleting node cons: %p", data_set->placement_constraints); pe_free_rsc_to_node(data_set->placement_constraints); data_set->placement_constraints = NULL; cleanup_calculations(data_set); } gboolean unpack_constraints(crm_data_t * xml_constraints, pe_working_set_t *data_set) { crm_data_t *lifetime = NULL; crm_debug_2("Begining unpack... %s", xml_constraints?crm_element_name(xml_constraints):""); xml_child_iter( xml_constraints, xml_obj, const char *id = crm_element_value(xml_obj, XML_ATTR_ID); if(id == NULL) { crm_config_err("Constraint <%s...> must have an id", crm_element_name(xml_obj)); continue; } crm_debug_3("Processing constraint %s %s", crm_element_name(xml_obj),id); lifetime = cl_get_struct(xml_obj, "lifetime"); if(test_ruleset(lifetime, NULL, data_set->now) == FALSE) { crm_info("Constraint %s %s is not active", crm_element_name(xml_obj), id); } else if(safe_str_eq(XML_CONS_TAG_RSC_ORDER, crm_element_name(xml_obj))) { unpack_rsc_order(xml_obj, data_set); } else if(safe_str_eq(XML_CONS_TAG_RSC_DEPEND, crm_element_name(xml_obj))) { unpack_rsc_colocation(xml_obj, data_set); } else if(safe_str_eq(XML_CONS_TAG_RSC_LOCATION, crm_element_name(xml_obj))) { unpack_rsc_location(xml_obj, data_set); } else { pe_err("Unsupported constraint type: %s", crm_element_name(xml_obj)); } ); return TRUE; } static const char * invert_action(const char *action) { if(safe_str_eq(action, CRMD_ACTION_START)) { return CRMD_ACTION_STOP; } else if(safe_str_eq(action, CRMD_ACTION_STOP)) { return CRMD_ACTION_START; } else if(safe_str_eq(action, CRMD_ACTION_PROMOTE)) { return CRMD_ACTION_DEMOTE; } else if(safe_str_eq(action, CRMD_ACTION_DEMOTE)) { return CRMD_ACTION_PROMOTE; } else if(safe_str_eq(action, CRMD_ACTION_STARTED)) { return CRMD_ACTION_STOPPED; } else if(safe_str_eq(action, CRMD_ACTION_STOPPED)) { return CRMD_ACTION_STARTED; } pe_err("Unknown action: %s", action); return NULL; } gboolean unpack_rsc_order(crm_data_t * xml_obj, pe_working_set_t *data_set) { gboolean symmetrical_bool = TRUE; enum pe_ordering cons_weight = pe_ordering_optional; const char *id = crm_element_value(xml_obj, XML_ATTR_ID); const char *type = crm_element_value(xml_obj, XML_ATTR_TYPE); const char *id_rh = crm_element_value(xml_obj, XML_CONS_ATTR_TO); const char *id_lh = crm_element_value(xml_obj, XML_CONS_ATTR_FROM); const char *score = crm_element_value(xml_obj, XML_RULE_ATTR_SCORE); const char *action = crm_element_value(xml_obj, XML_CONS_ATTR_ACTION); const char *action_rh = crm_element_value(xml_obj, XML_CONS_ATTR_TOACTION); const char *symmetrical = crm_element_value( xml_obj, XML_CONS_ATTR_SYMMETRICAL); resource_t *rsc_lh = NULL; resource_t *rsc_rh = NULL; if(xml_obj == NULL) { crm_config_err("No constraint object to process."); return FALSE; } else if(id == NULL) { crm_config_err("%s constraint must have an id", crm_element_name(xml_obj)); return FALSE; } else if(id_lh == NULL || id_rh == NULL) { crm_config_err("Constraint %s needs two sides lh: %s rh: %s", id, crm_str(id_lh), crm_str(id_rh)); return FALSE; } if(action == NULL) { action = CRMD_ACTION_START; } if(action_rh == NULL) { action_rh = action; } CRM_CHECK(action != NULL, return FALSE); CRM_CHECK(action_rh != NULL, return FALSE); if(safe_str_eq(type, "before")) { id_lh = crm_element_value(xml_obj, XML_CONS_ATTR_TO); id_rh = crm_element_value(xml_obj, XML_CONS_ATTR_FROM); action = crm_element_value(xml_obj, XML_CONS_ATTR_TOACTION); action_rh = crm_element_value(xml_obj, XML_CONS_ATTR_ACTION); if(action_rh == NULL) { action_rh = CRMD_ACTION_START; } if(action == NULL) { action = action_rh; } } CRM_CHECK(action != NULL, return FALSE); CRM_CHECK(action_rh != NULL, return FALSE); rsc_lh = pe_find_resource(data_set->resources, id_rh); rsc_rh = pe_find_resource(data_set->resources, id_lh); if(rsc_lh == NULL) { crm_config_err("Constraint %s: no resource found for LHS of %s", id, id_lh); return FALSE; } else if(rsc_rh == NULL) { crm_config_err("Constraint %s: no resource found for RHS of %s", id, id_rh); return FALSE; } if(crm_atoi(score, "0") > 0) { /* the name seems weird but the effect is correct */ cons_weight = pe_ordering_restart; } custom_action_order( rsc_lh, generate_op_key(rsc_lh->id, action, 0), NULL, rsc_rh, generate_op_key(rsc_rh->id, action_rh, 0), NULL, cons_weight, data_set); if(rsc_rh->restart_type == pe_restart_restart && safe_str_eq(action, action_rh)) { if(safe_str_eq(action, CRMD_ACTION_START)) { crm_debug_2("Recover start-start: %s-%s", rsc_lh->id, rsc_rh->id); order_start_start(rsc_lh, rsc_rh, pe_ordering_recover); } else if(safe_str_eq(action, CRMD_ACTION_STOP)) { crm_debug_2("Recover stop-stop: %s-%s", rsc_rh->id, rsc_lh->id); order_stop_stop(rsc_rh, rsc_lh, pe_ordering_recover); } } cl_str_to_boolean(symmetrical, &symmetrical_bool); if(symmetrical_bool == FALSE) { return TRUE; } action = invert_action(action); action_rh = invert_action(action_rh); custom_action_order( rsc_rh, generate_op_key(rsc_rh->id, action_rh, 0), NULL, rsc_lh, generate_op_key(rsc_lh->id, action, 0), NULL, cons_weight, data_set); if(rsc_lh->restart_type == pe_restart_restart && safe_str_eq(action, action_rh)) { if(safe_str_eq(action, CRMD_ACTION_START)) { crm_debug_2("Recover start-start (2): %s-%s", rsc_lh->id, rsc_rh->id); order_start_start(rsc_lh, rsc_rh, pe_ordering_recover); } else if(safe_str_eq(action, CRMD_ACTION_STOP)) { crm_debug_2("Recover stop-stop (2): %s-%s", rsc_rh->id, rsc_lh->id); order_stop_stop(rsc_rh, rsc_lh, pe_ordering_recover); } } return TRUE; } gboolean unpack_rsc_location(crm_data_t * xml_obj, pe_working_set_t *data_set) { gboolean empty = TRUE; const char *id_lh = crm_element_value(xml_obj, "rsc"); const char *id = crm_element_value(xml_obj, XML_ATTR_ID); resource_t *rsc_lh = pe_find_resource(data_set->resources, id_lh); if(rsc_lh == NULL) { /* only a warn as BSC adds the constraint then the resource */ crm_config_warn("No resource (con=%s, rsc=%s)", id, id_lh); return FALSE; } else if(rsc_lh->is_managed == FALSE) { crm_debug_2("Ignoring constraint %s: resource %s not managed", id, id_lh); return FALSE; } xml_child_iter_filter( xml_obj, rule_xml, XML_TAG_RULE, empty = FALSE; crm_debug_2("Unpacking %s/%s", id, ID(rule_xml)); generate_location_rule(rsc_lh, rule_xml, data_set); ); if(empty) { crm_config_err("Invalid location constraint %s:" " rsc_location must contain at least one rule", ID(xml_obj)); } return TRUE; } rsc_to_node_t * generate_location_rule( resource_t *rsc, crm_data_t *rule_xml, pe_working_set_t *data_set) { const char *rule_id = NULL; const char *score = NULL; const char *boolean = NULL; const char *role = NULL; const char *attr_score = NULL; GListPtr match_L = NULL; int score_f = 0; gboolean do_and = TRUE; gboolean accept = TRUE; gboolean raw_score = TRUE; rsc_to_node_t *location_rule = NULL; rule_id = crm_element_value(rule_xml, XML_ATTR_ID); boolean = crm_element_value(rule_xml, XML_RULE_ATTR_BOOLEAN_OP); role = crm_element_value(rule_xml, XML_RULE_ATTR_ROLE); crm_debug_2("Processing rule: %s", rule_id); if(role != NULL && text2role(role) == RSC_ROLE_UNKNOWN) { pe_err("Bad role specified for %s: %s", rule_id, role); return NULL; } score = crm_element_value(rule_xml, XML_RULE_ATTR_SCORE); if(score != NULL) { score_f = char2score(score); } else { score = crm_element_value( rule_xml, XML_RULE_ATTR_SCORE_ATTRIBUTE); if(score == NULL) { score = crm_element_value( rule_xml, XML_RULE_ATTR_SCORE_MANGLED); } if(score != NULL) { raw_score = FALSE; } } if(safe_str_eq(boolean, "or")) { do_and = FALSE; } location_rule = rsc2node_new(rule_id, rsc, 0, NULL, data_set); if(location_rule == NULL) { return NULL; } if(role != NULL) { crm_debug_2("Setting role filter: %s", role); location_rule->role_filter = text2role(role); } if(do_and) { match_L = node_list_dup(data_set->nodes, TRUE, FALSE); slist_iter( node, node_t, match_L, lpc, node->weight = score_f; ); } xml_child_iter( rule_xml, expr, enum expression_type type = find_expression_type(expr); if(type == not_expr) { pe_err("Expression <%s id=%s...> is not valid", crm_element_name(expr), crm_str(ID(expr))); continue; } slist_iter( node, node_t, data_set->nodes, lpc, if(type == nested_rule) { accept = test_rule( expr, node->details->attrs, RSC_ROLE_UNKNOWN, data_set->now); } else { accept = test_expression( expr, node->details->attrs, RSC_ROLE_UNKNOWN, data_set->now); } if(raw_score == FALSE) { attr_score = g_hash_table_lookup( node->details->attrs, score); if(attr_score == NULL) { accept = FALSE; pe_warn("node %s did not have a value" " for %s", node->details->uname, score); } else { crm_debug("Rule %s: node %s had value %s for %s", rule_id, node->details->uname, attr_score, score); score_f = char2score(attr_score); } } if(accept) { node_t *local = pe_find_node_id( match_L, node->details->id); if(local == NULL && do_and) { continue; } else if(local == NULL) { local = node_copy(node); match_L = g_list_append(match_L, local); } local->weight = merge_weights( local->weight, score_f); crm_debug_3("node %s now has weight %d", node->details->uname,local->weight); } else if(do_and && !accept) { /* remove it */ node_t *delete = pe_find_node_id( match_L, node->details->id); if(delete != NULL) { match_L = g_list_remove(match_L,delete); crm_debug_5("node %s did not match", node->details->uname); } crm_free(delete); } ); ); location_rule->node_list_rh = match_L; if(location_rule->node_list_rh == NULL) { crm_debug_2("No matching nodes for rule %s", rule_id); return NULL; } crm_debug_3("%s: %d nodes matched", rule_id, g_list_length(location_rule->node_list_rh)); crm_action_debug_3(print_rsc_to_node("Added", location_rule, FALSE)); return location_rule; } gboolean -rsc_colocation_new(const char *id, enum con_strength strength, +rsc_colocation_new(const char *id, int score, resource_t *rsc_lh, resource_t *rsc_rh, const char *state_lh, const char *state_rh) { rsc_colocation_t *new_con = NULL; - rsc_colocation_t *inverted_con = NULL; if(rsc_lh == NULL){ crm_config_err("No resource found for LHS %s", id); return FALSE; } else if(rsc_rh == NULL){ crm_config_err("No resource found for RHS of %s", id); return FALSE; } crm_malloc0(new_con, sizeof(rsc_colocation_t)); if(new_con == NULL) { return FALSE; } if(safe_str_eq(state_lh, CRMD_ACTION_STARTED)) { state_lh = NULL; } if(safe_str_eq(state_rh, CRMD_ACTION_STARTED)) { state_rh = NULL; } new_con->id = id; new_con->rsc_lh = rsc_lh; new_con->rsc_rh = rsc_rh; - new_con->strength = strength; + new_con->score = score; new_con->state_lh = state_lh; new_con->state_rh = state_rh; - inverted_con = invert_constraint(new_con); crm_debug_4("Adding constraint %s (%p) to %s", new_con->id, new_con, rsc_lh->id); rsc_lh->rsc_cons = g_list_insert_sorted( rsc_lh->rsc_cons, new_con, sort_cons_strength); - - crm_debug_4("Adding constraint %s (%p) to %s", - inverted_con->id, inverted_con, rsc_rh->id); - - rsc_rh->rsc_cons = g_list_insert_sorted( - rsc_rh->rsc_cons, inverted_con, sort_cons_strength); - + return TRUE; } /* LHS before RHS */ gboolean custom_action_order( resource_t *lh_rsc, char *lh_action_task, action_t *lh_action, resource_t *rh_rsc, char *rh_action_task, action_t *rh_action, enum pe_ordering type, pe_working_set_t *data_set) { order_constraint_t *order = NULL; if((lh_action == NULL && lh_rsc == NULL) || (rh_action == NULL && rh_rsc == NULL)){ crm_config_err("Invalid inputs lh_rsc=%p, lh_a=%p," " rh_rsc=%p, rh_a=%p", lh_rsc, lh_action, rh_rsc, rh_action); crm_free(lh_action_task); crm_free(rh_action_task); return FALSE; } crm_malloc0(order, sizeof(order_constraint_t)); if(order == NULL) { return FALSE; } order->id = data_set->order_id++; order->type = type; order->lh_rsc = lh_rsc; order->rh_rsc = rh_rsc; order->lh_action = lh_action; order->rh_action = rh_action; order->lh_action_task = lh_action_task; order->rh_action_task = rh_action_task; data_set->ordering_constraints = g_list_append( data_set->ordering_constraints, order); if(lh_rsc != NULL && rh_rsc != NULL) { crm_debug_4("Created ordering constraint %d (%s):" " %s/%s before %s/%s", order->id, ordering_type2text(order->type), lh_rsc->id, lh_action_task, rh_rsc->id, rh_action_task); } else if(lh_rsc != NULL) { crm_debug_4("Created ordering constraint %d (%s):" " %s/%s before action %d (%s)", order->id, ordering_type2text(order->type), lh_rsc->id, lh_action_task, rh_action->id, rh_action_task); } else if(rh_rsc != NULL) { crm_debug_4("Created ordering constraint %d (%s):" " action %d (%s) before %s/%s", order->id, ordering_type2text(order->type), lh_action->id, lh_action_task, rh_rsc->id, rh_action_task); } else { crm_debug_4("Created ordering constraint %d (%s):" " action %d (%s) before action %d (%s)", order->id, ordering_type2text(order->type), lh_action->id, lh_action_task, rh_action->id, rh_action_task); } return TRUE; } gboolean unpack_rsc_colocation(crm_data_t * xml_obj, pe_working_set_t *data_set) { - enum con_strength strength_e = pecs_ignore; - + int score_i = 0; const char *id = crm_element_value(xml_obj, XML_ATTR_ID); const char *id_rh = crm_element_value(xml_obj, XML_CONS_ATTR_TO); const char *id_lh = crm_element_value(xml_obj, XML_CONS_ATTR_FROM); const char *score = crm_element_value(xml_obj, XML_RULE_ATTR_SCORE); const char *state_lh = crm_element_value(xml_obj, XML_RULE_ATTR_FROMSTATE); const char *state_rh = crm_element_value(xml_obj, XML_RULE_ATTR_TOSTATE); resource_t *rsc_lh = pe_find_resource(data_set->resources, id_lh); resource_t *rsc_rh = pe_find_resource(data_set->resources, id_rh); if(rsc_lh == NULL) { crm_config_err("No resource (con=%s, rsc=%s)", id, id_lh); return FALSE; } else if(rsc_rh == NULL) { crm_config_err("No resource (con=%s, rsc=%s)", id, id_rh); return FALSE; } /* the docs indicate that only +/- INFINITY are allowed, * but no-one ever reads the docs so all positive values will * count as "must" and negative values as "must not" */ - if(score == NULL || score[0] != '-') { - strength_e = pecs_must; - } else { - strength_e = pecs_must_not; + if(score) { + score_i = char2score(score); } - return rsc_colocation_new(id, strength_e, rsc_lh, rsc_rh, - state_lh, state_rh); + return rsc_colocation_new( + id, score_i, rsc_lh, rsc_rh, state_lh, state_rh); } gboolean is_active(rsc_to_node_t *cons) { return TRUE; } diff --git a/crm/pengine/allocate.h b/crm/pengine/allocate.h index 575e3f1c80..657712d638 100644 --- a/crm/pengine/allocate.h +++ b/crm/pengine/allocate.h @@ -1,186 +1,186 @@ /* $Id: allocate.h,v 1.2 2006/06/08 13:39:10 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #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; typedef struct notify_data_s { GHashTable *keys; GListPtr active; /* notify_entry_t* */ GListPtr inactive; /* notify_entry_t* */ GListPtr start; /* notify_entry_t* */ GListPtr stop; /* notify_entry_t* */ GListPtr demote; /* notify_entry_t* */ GListPtr promote; /* notify_entry_t* */ GListPtr master; /* notify_entry_t* */ GListPtr slave; /* notify_entry_t* */ } notify_data_t; struct resource_alloc_functions_s { void (*set_cmds)(resource_t *); int (*num_allowed_nodes)(resource_t *); - color_t *(*color)(resource_t *, pe_working_set_t *); + node_t *(*color)(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 (*agent_constraints)(resource_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_order_lh)(resource_t *, order_constraint_t *); void (*rsc_order_rh)( action_t *, resource_t *, order_constraint_t *); void (*rsc_location)(resource_t *, rsc_to_node_t *); void (*expand)(resource_t *, pe_working_set_t *); void (*stonith_ordering)( resource_t *, action_t *, pe_working_set_t *); void (*create_notify_element)(resource_t*,action_t*, notify_data_t*,pe_working_set_t*); }; extern void native_set_cmds(resource_t *rsc); extern void group_set_cmds(resource_t *rsc); extern void clone_set_cmds(resource_t *rsc); extern int native_num_allowed_nodes(resource_t *rsc); -extern color_t * native_color(resource_t *rsc, pe_working_set_t *data_set); +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_agent_constraints(resource_t *rsc); 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 void native_rsc_order_lh(resource_t *rsc, order_constraint_t *order); extern void native_rsc_order_rh( action_t *lh_action, resource_t *rsc, order_constraint_t *order); 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 native_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, color_t *color); +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_stonith_ordering( resource_t *rsc, action_t *stonith_op, pe_working_set_t *data_set); extern int group_num_allowed_nodes(resource_t *rsc); -extern color_t *group_color(resource_t *rsc, pe_working_set_t *data_set); +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_agent_constraints(resource_t *rsc); 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 void group_rsc_order_lh(resource_t *rsc, order_constraint_t *order); extern void group_rsc_order_rh( action_t *lh_action, resource_t *rsc, order_constraint_t *order); 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 enum rsc_role_e group_resource_state(resource_t *rsc); extern void group_create_notify_element( resource_t *rsc, action_t *op, notify_data_t *n_data,pe_working_set_t *data_set); extern gboolean group_create_probe( resource_t *rsc, node_t *node, action_t *complete, gboolean force, pe_working_set_t *data_set); extern void group_stonith_ordering( resource_t *rsc, action_t *stonith_op, pe_working_set_t *data_set); extern int clone_num_allowed_nodes(resource_t *rsc); -extern color_t *clone_color(resource_t *rsc, pe_working_set_t *data_set); +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_agent_constraints(resource_t *rsc); 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_order_lh(resource_t *rsc, order_constraint_t *order); extern void clone_rsc_order_rh( action_t *lh_action, resource_t *rsc, order_constraint_t *order); extern void clone_rsc_location(resource_t *rsc, rsc_to_node_t *constraint); extern void clone_expand(resource_t *rsc, pe_working_set_t *data_set); extern enum rsc_role_e clone_resource_state(resource_t *rsc); extern void clone_create_notify_element( resource_t *rsc, action_t *op, notify_data_t *n_data,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_stonith_ordering( resource_t *rsc, action_t *stonith_op, pe_working_set_t *data_set); extern gboolean master_unpack(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 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 void common_agent_constraints( GListPtr node_list, lrm_agent_t *agent, const char *id); extern gboolean unpack_rsc_to_attr(crm_data_t *xml_obj, pe_working_set_t *data_set); extern gboolean unpack_rsc_to_node(crm_data_t *xml_obj, pe_working_set_t *data_set); extern gboolean unpack_rsc_order(crm_data_t *xml_obj, pe_working_set_t *data_set); extern gboolean unpack_rsc_colocation(crm_data_t *xml_obj, pe_working_set_t *data_set); extern gboolean unpack_rsc_location(crm_data_t *xml_obj, pe_working_set_t *data_set); extern void cleanup_alloc_calculations(pe_working_set_t *data_set); #endif diff --git a/crm/pengine/clone.c b/crm/pengine/clone.c index 2f9bc801c8..0317a26591 100644 --- a/crm/pengine/clone.c +++ b/crm/pengine/clone.c @@ -1,1307 +1,1323 @@ /* $Id: clone.c,v 1.6 2006/07/18 06:19:33 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include void clone_create_notifications( resource_t *rsc, action_t *action, action_t *action_complete, pe_working_set_t *data_set); -extern gboolean rsc_colocation_new( - const char *id, enum con_strength strength, - resource_t *rsc_lh, resource_t *rsc_rh, - const char *state_lh, const char *state_rh); - typedef struct clone_variant_data_s { resource_t *self; int clone_max; int clone_node_max; int active_clones; int max_nodes; gboolean interleave; gboolean ordered; crm_data_t *xml_obj_child; gboolean notify_confirm; GListPtr child_list; /* resource_t* */ } clone_variant_data_t; void child_stopping_constraints( clone_variant_data_t *clone_data, enum pe_ordering type, resource_t *child, resource_t *last, pe_working_set_t *data_set); void child_starting_constraints( clone_variant_data_t *clone_data, enum pe_ordering type, resource_t *child, resource_t *last, pe_working_set_t *data_set); #define get_clone_variant_data(data, rsc) \ CRM_ASSERT(rsc->variant == pe_clone || rsc->variant == pe_master); \ data = (clone_variant_data_t *)rsc->variant_opaque; void clone_set_cmds(resource_t *rsc) { clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); clone_data->self->cmds = &resource_class_alloc_functions[clone_data->self->variant]; slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, child_rsc->cmds = &resource_class_alloc_functions[child_rsc->variant]; child_rsc->cmds->set_cmds(child_rsc); ); } int clone_num_allowed_nodes(resource_t *rsc) { int num_nodes = 0; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); /* what *should* we return here? */ slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, int tmp_num_nodes = child_rsc->cmds->num_allowed_nodes(child_rsc); if(tmp_num_nodes > num_nodes) { num_nodes = tmp_num_nodes; } ); return num_nodes; } static gint sort_rsc_provisional(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); if(resource1->provisional == resource2->provisional) { return 0; } else if(resource1->provisional) { return 1; } else if(resource2->provisional) { return -1; } CRM_CHECK(FALSE, return 0); return 0; } - -static GListPtr -next_color(GListPtr head, GListPtr iter, int max) +static resource_t * +find_clone_child(resource_t *rsc, GListPtr resource_list) { - color_t *color = NULL; - GListPtr local_iter = iter; - crm_debug_4("Checking iter: %p", iter); - if(local_iter != NULL) { - local_iter = local_iter->next; - } - for(; local_iter != NULL; local_iter = local_iter->next) { - color = local_iter->data; - crm_debug_5("Color %d: %d", - color->details->id, color->details->num_resources); - if(color->details->num_resources < max) { - return local_iter; + crm_debug("foo"); + slist_iter( + child, resource_t, resource_list, lpc, + if(child->parent) { + crm_debug("%p / %p vs. %s / %s", rsc, child->parent, rsc->id, child->parent->id); + if(child->parent == rsc) { + return child; + } + } else { + crm_debug("Child %s has no parent", child->id); } - } + ); - local_iter = head; - crm_debug_4("Now checking head: %p", head); - for(; local_iter != NULL; local_iter = local_iter->next) { - color = local_iter->data; - crm_debug_5("Color %d: %d", - color->details->id, color->details->num_resources); - if(color->details->num_resources < max) { - return local_iter; - } - } - - crm_debug_3("Nothing available: %p", head); return NULL; } -extern void group_assign_color(resource_t *rsc, color_t *group_color); - -color_t * +node_t * clone_color(resource_t *rsc, pe_working_set_t *data_set) { - GListPtr color_ptr = NULL; - GListPtr child_colors = NULL; int local_node_max = 0; + GListPtr node_list = NULL; int reverse_pointer = 0; + int allocated = 0, pre_allocated = 0; +/* int level = LOG_ERR; */ + clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); if(clone_data->self->provisional == FALSE) { return NULL; } local_node_max = clone_data->clone_node_max; clone_data->max_nodes = rsc->cmds->num_allowed_nodes(rsc); /* give already allocated resources every chance to run on the node * specified. other resources can be moved/started where we want * as required */ clone_data->child_list = g_list_sort( clone_data->child_list, sort_rsc_provisional); crm_debug_2("Coloring children of: %s", rsc->id); +/* rsc->fns->print(rsc, "alloc: ", */ +/* pe_print_details|pe_print_dev|pe_print_log, &level); */ + + clone_data->self->allowed_nodes = g_list_sort( + clone_data->self->allowed_nodes, sort_node_weight); if(rsc->stickiness <= 0) { while(local_node_max > 1 && clone_data->max_nodes * (local_node_max -1) >= clone_data->clone_max) { local_node_max--; crm_debug("Dropped the effective value of" " clone_node_max to: %d", local_node_max); } } - clone_data->self->allowed_nodes = g_list_sort( - clone_data->self->allowed_nodes, sort_node_weight); - - slist_iter(a_node, node_t, clone_data->self->allowed_nodes, lpc, - color_t *new_color = NULL; - if(can_run_resources(a_node) == FALSE) { + slist_iter(child, resource_t, clone_data->child_list, lpc2, + node_t *current = NULL; + node_t *chosen = NULL; + + if(child->running_on != NULL) { + current = child->running_on->data; + } + + if(current == NULL) { + crm_debug_2("Not active: %s", child->id); + continue; + + } else if(can_run_resources(current) == FALSE) { crm_debug_2("Node cant run resources: %s", - a_node->details->uname); + current->details->uname); + continue; + + } else if(g_list_length(child->running_on) != 1) { + crm_debug("active != 1: %s", child->id); + + continue; + + } + + chosen = pe_find_node_id( + clone_data->self->allowed_nodes, current->details->id); + + if(chosen == NULL) { + /* unmanaged mode */ continue; + + } else if(chosen->count >= local_node_max) { + crm_warn("Node %s too full for: %s", + chosen->details->uname, + child->id); + continue; + + } else if(allocated >= clone_data->clone_max) { + crm_debug_2("Reached maximum allocation: %s", child->id); + break; + } + + chosen->weight = merge_weights(chosen->weight, child->stickiness); + if(native_assign_node(child, NULL, chosen)) { + allocated++; } - crm_debug_3("Processing node %s for: %s", - a_node->details->uname, rsc->id); - - new_color = create_color(data_set, NULL, NULL); - new_color->local_weight = a_node->weight; - new_color->details->candidate_nodes = g_list_append( - NULL, node_copy(a_node)); - child_colors = g_list_append(child_colors, new_color); - crm_debug_3("Created color %d for node %s (score = %d): %s", - new_color->id, a_node->details->uname, a_node->weight, rsc->id); - - slist_iter(child, resource_t, clone_data->child_list, lpc2, - node_t *current = NULL; - if(child->provisional == FALSE) { - CRM_CHECK(child->color != NULL, continue); - current = child->color->details->chosen_node; - - } else if(child->running_on != NULL) { - current = child->running_on->data; - } - - if(current == NULL) { - crm_debug_2("Not active: %s", child->id); - continue; - - } else if(current->details->online == FALSE - || current->details->unclean - || current->details->shutdown) { - crm_debug_2("Unavailable node: %s", child->id); - continue; - - } else if(current->details != a_node->details) { - crm_debug_2("Wrong node: %s", child->id); - continue; - - } else if(child->provisional == FALSE) { - /* make sure it shows up */ - native_assign_color(child, new_color); - crm_debug("Previously colored: %s", - child->id); - - continue; - - } else if(g_list_length(child->running_on) != 1) { - crm_debug("active != 1: %s", child->id); - - continue; - - } else if(new_color->details->num_resources - >= local_node_max) { - crm_warn("Node %s too full for: %s", - a_node->details->uname, - child->id); - continue; - } - - a_node->weight = merge_weights(a_node->weight, child->stickiness); - new_color->local_weight = a_node->weight; - - crm_debug_2("Assigning color: %s", child->id); - native_assign_color(child, new_color); - ); - native_assign_color(rsc, new_color); +/* native_assign_node(clone_data->self, NULL, current); */ ); - while(local_node_max > 1 - && clone_data->max_nodes * (local_node_max -1) - >= clone_data->clone_max) { - local_node_max--; - crm_debug("Dropped the effective value of clone_node_max to: %d", - local_node_max); + crm_debug("Running: Total=%d, New=%d, Max=%d", + pre_allocated+allocated, allocated, clone_data->clone_max); + + if(clone_data->max_nodes) { + local_node_max = (int) (clone_data->clone_max / clone_data->max_nodes); + if(local_node_max < 1) { + local_node_max = 1; + } + } + + if(local_node_max > clone_data->clone_node_max) { + local_node_max = clone_data->clone_node_max; + } + + pre_allocated = allocated; + allocated = 0; + + if(rsc->stickiness != 0) { + clone_data->self->allowed_nodes = g_list_sort( + clone_data->self->allowed_nodes, sort_node_weight); } + /* distribute a constant spread */ + node_list = clone_data->self->allowed_nodes; + slist_iter(child, resource_t, clone_data->child_list, lpc2, + if(allocated+pre_allocated >= clone_data->clone_max) { + break; + } + if(child->provisional == FALSE) { + crm_debug_3("Spread: Skipping allocated resource: %s", child->id); + continue; + } - child_colors = g_list_sort(child_colors, sort_color_weight); + while(node_list) { + node_t *node = node_list->data; + if(can_run_resources(node) == FALSE) { + node_list = node_list->next; + } else if(local_node_max <= node->count) { + node_list = node_list->next; + } else { + break; + } + } + + if(node_list) { + allocated++; + native_assign_node(child, NULL, node_list->data); + } + ); + + crm_debug("Spread: Total=%d, New=%d, Max=%d", + pre_allocated+allocated, allocated, clone_data->clone_max); + + CRM_ASSERT(pre_allocated+allocated <= clone_data->clone_max); + pre_allocated += allocated; + allocated = 0; + + /* allocate the rest - if possible */ + if(local_node_max < clone_data->clone_node_max) { + local_node_max++; + } - /* allocate the rest */ + node_list = clone_data->self->allowed_nodes; + slist_iter(child, resource_t, clone_data->child_list, lpc2, if(child->provisional == FALSE) { - crm_debug_2("Skipping allocated resource: %s", child->id); + crm_debug("Remainder: Skipping allocated resource: %s", child->id); continue; } - crm_debug_2("Processing unalloc'd resource: %s", child->id); - color_ptr = next_color( - child_colors, color_ptr, local_node_max); - if(child->variant == pe_native) { - native_assign_color(child, color_ptr?color_ptr->data:data_set->no_color); - } else if(child->variant == pe_group) { - group_assign_color(child, color_ptr?color_ptr->data:data_set->no_color); + + crm_debug("Remainder: Processing: %s", child->id); + if(node_list && (pre_allocated+allocated) >= clone_data->clone_max) { + crm_debug("Allocated maximum possible clone instances"); + node_list = NULL; + } + + while(node_list) { + node_t *node = node_list->data; + if(can_run_resources(node) == FALSE) { + node_list = node_list->next; + } else if(local_node_max <= node->count) { + node_list = node_list->next; + } else { + break; + } + } + + if(node_list) { + allocated++; + native_assign_node(child, NULL, node_list->data); + } else { - crm_err("Bad variant: %d", child->variant); + crm_debug("Child %s not allocated", child->id); + native_assign_node(child, NULL, NULL); } + ); + crm_debug("Remainder: Total=%d, New=%d, Max=%d", pre_allocated, allocated, clone_data->clone_max); + CRM_ASSERT(pre_allocated+allocated <= clone_data->clone_max); + clone_data->self->provisional = FALSE; if(rsc->stickiness >= INFINITY) { return NULL; } - reverse_pointer = g_list_length(child_colors) - 1; - slist_iter(color, color_t, child_colors, lpc, - color_t *replace_color = NULL; + /* observe node preferences */ + reverse_pointer = g_list_length(clone_data->self->allowed_nodes) - 1; + slist_iter(a_node, node_t, clone_data->self->allowed_nodes, lpc, + node_t *replace_node = NULL; resource_t *replace_rsc = NULL; - CRM_CHECK(color != NULL, continue); - if(color->details->num_resources != 0) { - crm_debug_4("color %d has %d resources", - color->id, color->details->num_resources); + CRM_ASSERT(a_node != NULL); + if(a_node->count != 0) { + crm_debug_4("Node %s has %d resources", + a_node->details->uname, a_node->count); break; } else if(lpc >= reverse_pointer) { crm_debug_3("lpc %d, reverse lpc %d", lpc, reverse_pointer); break; } - crm_debug_3("Color %d has %d resources, stealing one from...", - color->id, color->details->num_resources); - - do { + crm_debug_3("Node %s has %d resources, stealing one from...", + a_node->details->uname, a_node->count); + + while(replace_rsc == NULL) { crm_debug_3("lpc %d, reverse lpc %d", lpc, reverse_pointer); if(lpc >= reverse_pointer) { return NULL; } - replace_color = g_list_nth_data(child_colors, reverse_pointer); + replace_node = g_list_nth_data(clone_data->self->allowed_nodes, reverse_pointer); reverse_pointer--; - CRM_CHECK(replace_color != NULL, continue); - CRM_CHECK(replace_color->details->num_resources >= 0, continue); - if(replace_color->details->num_resources == 0) { - continue; + crm_debug("Trying to reallocated an instance of %s to %s from %s", + rsc->id, a_node->details->uname, replace_node->details->uname); + replace_rsc = find_clone_child(rsc, replace_node->details->allocated_rsc); + if(replace_rsc == NULL) { + CRM_ASSERT(replace_node->count == 0); + crm_debug("nothing on %s", replace_node->details->uname); } + } - CRM_CHECK(replace_color->details->allocated_resources != NULL, continue); - replace_rsc = replace_color->details->allocated_resources->data; - - crm_debug_3("\tColor %d with %d resources (index = %d, rsc = %s)", - replace_color->id, replace_color->details->num_resources, - reverse_pointer+1, replace_rsc?replace_rsc->id:"none"); - - } while(replace_color == NULL - || replace_color->id == 0 - || replace_color->details->num_resources == 0); - - if(replace_rsc->variant == pe_native) { - native_assign_color(replace_rsc, color); - - } else if(replace_rsc->variant == pe_group) { - group_assign_color(replace_rsc, color); - - } else { - crm_err("Bad variant: %d", replace_rsc->variant); - } + crm_debug("Reallocating %s to %s from %s", + replace_rsc->id, a_node->details->uname, replace_node->details->uname); + native_assign_node(replace_rsc, NULL, a_node); ); - + return NULL; } static void clone_update_pseudo_status( resource_t *child, gboolean *stopping, gboolean *starting) { CRM_ASSERT(stopping != NULL); CRM_ASSERT(starting != NULL); slist_iter( action, action_t, child->actions, lpc, if(*starting && *stopping) { return; } else if(action->optional) { crm_debug_3("Skipping optional: %s", action->uuid); continue; } else if(action->pseudo == FALSE && action->runnable == FALSE){ crm_debug_3("Skipping unrunnable: %s", action->uuid); continue; } else if(safe_str_eq(CRMD_ACTION_STOP, action->task)) { crm_debug_2("Stopping due to: %s", action->uuid); *stopping = TRUE; } else if(safe_str_eq(CRMD_ACTION_START, action->task)) { if(action->runnable == FALSE) { crm_debug_3("Skipping pseduo-op: %s run=%d, pseudo=%d", action->uuid, action->runnable, action->pseudo); } else { crm_debug_2("Starting due to: %s", action->uuid); crm_debug_3("%s run=%d, pseudo=%d", action->uuid, action->runnable, action->pseudo); *starting = TRUE; } } ); } void clone_create_actions(resource_t *rsc, pe_working_set_t *data_set) { gboolean child_starting = FALSE; gboolean child_stopping = FALSE; action_t *stop = NULL; action_t *start = NULL; action_t *action_complete = 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); slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, child_rsc->cmds->create_actions(child_rsc, data_set); clone_update_pseudo_status( child_rsc, &child_stopping, &child_starting); if(child_rsc->starting) { last_start_rsc = child_rsc; } if(child_rsc->stopping) { last_stop_rsc = child_rsc; } ); /* start */ start = start_action(clone_data->self, NULL, !child_starting); action_complete = custom_action( clone_data->self, started_key(rsc), CRMD_ACTION_STARTED, NULL, !child_starting, TRUE, data_set); start->pseudo = TRUE; action_complete->pseudo = TRUE; action_complete->priority = INFINITY; child_starting_constraints(clone_data, pe_ordering_optional, NULL, last_start_rsc, data_set); clone_create_notifications( rsc, start, action_complete, data_set); /* stop */ stop = stop_action(clone_data->self, NULL, !child_stopping); action_complete = custom_action( clone_data->self, stopped_key(rsc), CRMD_ACTION_STOPPED, NULL, !child_stopping, TRUE, data_set); stop->pseudo = TRUE; action_complete->pseudo = TRUE; action_complete->priority = INFINITY; child_stopping_constraints(clone_data, pe_ordering_optional, NULL, last_stop_rsc, data_set); clone_create_notifications(rsc, stop, action_complete, data_set); rsc->actions = clone_data->self->actions; if(stop->post_notified != NULL && start->pre_notify != NULL) { order_actions(stop->post_notified, start->pre_notify, pe_ordering_optional); } } void clone_create_notifications( resource_t *rsc, action_t *action, action_t *action_complete, pe_working_set_t *data_set) { /* * pre_notify -> pre_notify_complete -> pseudo_action * -> (real actions) -> pseudo_action_complete * -> post_notify -> post_notify_complete * * if the pre_noitfy requires confirmation, * then a list of confirmations will be added as triggers * to pseudo_action in clone_expand() */ action_t *notify = NULL; action_t *notify_complete = NULL; enum action_tasks task; char *notify_key = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); if(rsc->notify == FALSE) { return; } task = text2task(action->task); /* create pre_notify */ notify_key = generate_notify_key( clone_data->self->id, "pre", action->task); notify = custom_action(clone_data->self, notify_key, CRMD_ACTION_NOTIFY, NULL, action->optional, TRUE, data_set); add_hash_param(notify->meta, "notify_type", "pre"); add_hash_param(notify->meta, "notify_operation", action->task); if(clone_data->notify_confirm) { add_hash_param(notify->meta, "notify_confirm", "yes"); } else { add_hash_param(notify->meta, "notify_confirm", "no"); } notify->pseudo = TRUE; /* create pre_notify_complete */ notify_key = generate_notify_key( clone_data->self->id, "confirmed-pre", action->task); notify_complete = custom_action(clone_data->self, notify_key, CRMD_ACTION_NOTIFIED, NULL, action->optional, TRUE, data_set); add_hash_param(notify_complete->meta, "notify_type", "pre"); add_hash_param(notify_complete->meta, "notify_operation", action->task); if(clone_data->notify_confirm) { add_hash_param(notify->meta, "notify_confirm", "yes"); } else { add_hash_param(notify->meta, "notify_confirm", "no"); } notify->pseudo = TRUE; notify_complete->pseudo = TRUE; /* pre_notify before pre_notify_complete */ custom_action_order( clone_data->self, NULL, notify, clone_data->self, NULL, notify_complete, pe_ordering_manditory, data_set); /* pre_notify_complete before action */ custom_action_order( clone_data->self, NULL, notify_complete, clone_data->self, NULL, action, pe_ordering_manditory, data_set); action->pre_notify = notify; action->pre_notified = notify_complete; /* create post_notify */ notify_key = generate_notify_key (clone_data->self->id, "post", action->task); notify = custom_action(clone_data->self, notify_key, CRMD_ACTION_NOTIFY, NULL, action_complete->optional, TRUE, data_set); add_hash_param(notify->meta, "notify_type", "post"); add_hash_param(notify->meta, "notify_operation", action->task); if(clone_data->notify_confirm) { add_hash_param(notify->meta, "notify_confirm", "yes"); } else { add_hash_param(notify->meta, "notify_confirm", "no"); } notify->pseudo = TRUE; /* action_complete before post_notify */ custom_action_order( clone_data->self, NULL, action_complete, clone_data->self, NULL, notify, pe_ordering_postnotify, data_set); /* create post_notify_complete */ notify_key = generate_notify_key( clone_data->self->id, "confirmed-post", action->task); notify_complete = custom_action(clone_data->self, notify_key, CRMD_ACTION_NOTIFIED, NULL, action->optional, TRUE, data_set); add_hash_param(notify_complete->meta, "notify_type", "pre"); add_hash_param(notify_complete->meta, "notify_operation", action->task); if(clone_data->notify_confirm) { add_hash_param(notify->meta, "notify_confirm", "yes"); } else { add_hash_param(notify->meta, "notify_confirm", "no"); } notify_complete->pseudo = TRUE; /* post_notify before post_notify_complete */ custom_action_order( clone_data->self, NULL, notify, clone_data->self, NULL, notify_complete, pe_ordering_manditory, data_set); action->post_notify = notify; action->post_notified = notify_complete; if(safe_str_eq(action->task, CRMD_ACTION_STOP)) { /* post_notify_complete before start */ custom_action_order( clone_data->self, NULL, notify_complete, clone_data->self, start_key(clone_data->self), NULL, pe_ordering_optional, data_set); } else if(safe_str_eq(action->task, CRMD_ACTION_START)) { /* post_notify_complete before promote */ custom_action_order( clone_data->self, NULL, notify_complete, clone_data->self, promote_key(clone_data->self), NULL, pe_ordering_optional, data_set); } else if(safe_str_eq(action->task, CRMD_ACTION_DEMOTE)) { /* post_notify_complete before promote */ custom_action_order( clone_data->self, NULL, notify_complete, clone_data->self, stop_key(clone_data->self), NULL, pe_ordering_optional, data_set); } } void child_starting_constraints( clone_variant_data_t *clone_data, enum pe_ordering type, resource_t *child, resource_t *last, pe_working_set_t *data_set) { if(clone_data->ordered || clone_data->self->restart_type == pe_restart_restart) { type = pe_ordering_manditory; } if(child == NULL) { if(clone_data->ordered && last != NULL) { crm_debug_4("Ordered version (last node)"); /* last child start before global started */ custom_action_order( last, start_key(last), NULL, clone_data->self, started_key(clone_data->self), NULL, type, data_set); } } else if(clone_data->ordered) { crm_debug_4("Ordered version"); if(last == NULL) { /* global start before first child start */ last = clone_data->self; } /* else: child/child relative start */ order_start_start(last, child, type); } else { crm_debug_4("Un-ordered version"); /* child start before global started */ custom_action_order( child, start_key(child), NULL, clone_data->self, started_key(clone_data->self), NULL, type, data_set); /* global start before child start */ /* order_start_start(clone_data->self, child, type); */ order_start_start( clone_data->self, child, pe_ordering_manditory); } } void child_stopping_constraints( clone_variant_data_t *clone_data, enum pe_ordering type, resource_t *child, resource_t *last, pe_working_set_t *data_set) { if(clone_data->ordered || clone_data->self->restart_type == pe_restart_restart) { type = pe_ordering_manditory; } if(child == NULL) { if(clone_data->ordered && last != NULL) { crm_debug_4("Ordered version (last node)"); /* global stop before first child stop */ order_stop_stop(clone_data->self, last, pe_ordering_manditory); } } else if(clone_data->ordered && last != NULL) { crm_debug_4("Ordered version"); /* child/child relative stop */ order_stop_stop(child, last, type); } else if(clone_data->ordered) { crm_debug_4("Ordered version (1st node)"); /* first child stop before global stopped */ custom_action_order( child, stop_key(child), NULL, clone_data->self, stopped_key(clone_data->self), NULL, type, data_set); } else { crm_debug_4("Un-ordered version"); /* child stop before global stopped */ custom_action_order( child, stop_key(child), NULL, clone_data->self, stopped_key(clone_data->self), NULL, type, data_set); /* global stop before child stop */ order_stop_stop(clone_data->self, child, type); } } 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); clone_data->self->cmds->internal_constraints(clone_data->self, data_set); /* global stop before stopped */ custom_action_order( clone_data->self, stop_key(clone_data->self), NULL, clone_data->self, stopped_key(clone_data->self), NULL, pe_ordering_optional, data_set); /* global start before started */ custom_action_order( clone_data->self, start_key(clone_data->self), NULL, clone_data->self, started_key(clone_data->self), NULL, pe_ordering_optional, data_set); /* global stopped before start */ custom_action_order( clone_data->self, stopped_key(clone_data->self), NULL, clone_data->self, start_key(clone_data->self), NULL, pe_ordering_optional, data_set); slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, child_rsc->cmds->internal_constraints(child_rsc, data_set); child_starting_constraints( clone_data, pe_ordering_optional, child_rsc, last_rsc, data_set); child_stopping_constraints( clone_data, pe_ordering_optional, child_rsc, last_rsc, data_set); last_rsc = child_rsc; ); child_starting_constraints( clone_data, pe_ordering_optional, NULL, last_rsc, data_set); child_stopping_constraints( clone_data, pe_ordering_optional, NULL, last_rsc, data_set); } static resource_t* find_compatible_child(resource_t *local_child, resource_t *rsc) { node_t *local_node = NULL; node_t *node = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); - CRM_ASSERT(local_child->color != NULL); - local_node = local_child->color->details->candidate_nodes->data; + local_node = local_child->allocated_to; if(local_node == NULL) { crm_debug("Can't colocate unrunnable child %s with %s", local_child->id, rsc->id); return NULL; } slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, - CRM_ASSERT(child_rsc->color != NULL); - node = child_rsc->color->details->candidate_nodes->data; + node = child_rsc->allocated_to; if(node->details == local_node->details) { crm_info("Colocating %s with %s on %s", local_child->id, child_rsc->id, node->details->uname); return child_rsc; } ); crm_debug("Can't colocate child %s with %s", local_child->id, rsc->id); return NULL; } void clone_rsc_colocation_lh( resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint) { gboolean do_interleave = FALSE; resource_t *rsc = constraint->rsc_lh; clone_variant_data_t *clone_data = NULL; clone_variant_data_t *clone_data_rh = NULL; if(rsc == 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; } else { crm_debug_4("Processing constraints from %s", rsc->id); } get_clone_variant_data(clone_data, rsc); if(constraint->rsc_rh->variant == pe_clone) { get_clone_variant_data( clone_data_rh, constraint->rsc_rh); if(clone_data->clone_node_max != clone_data_rh->clone_node_max) { pe_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->interleave) { do_interleave = TRUE; - } else if(constraint->strength != pecs_must_not) { + } else if(constraint->score != INFINITY) { pe_warn("rsc_colocations other than \"-INFINITY\"" " are not supported for non-interleaved " XML_CIB_TAG_INCARNATION" resources"); return; } - } else if(constraint->strength != pecs_must_not) { + } else if(constraint->score != -INFINITY) { pe_warn("Co-location scores other than \"-INFINITY\" are not " " allowed for non-"XML_CIB_TAG_INCARNATION" resources"); return; } if(do_interleave) { resource_t *rh_child = NULL; slist_iter(lh_child, resource_t, clone_data->child_list, lpc, CRM_ASSERT(lh_child != NULL); rh_child = find_compatible_child(lh_child, rsc_rh); if(rh_child == NULL) { continue; } lh_child->cmds->rsc_colocation_lh( lh_child, rh_child, constraint); ); return; } slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, child_rsc->cmds->rsc_colocation_lh(child_rsc, constraint->rsc_rh, constraint); ); } void clone_rsc_colocation_rh( resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint) { clone_variant_data_t *clone_data = NULL; CRM_CHECK(rsc_lh != NULL, return); CRM_CHECK(rsc_lh->variant == pe_native, return); crm_debug_3("Processing RH of constraint %s", constraint->id); if(rsc_rh == NULL) { pe_err("rsc_rh was NULL for %s", constraint->id); return; - } else if(constraint->strength != pecs_must_not) { + } else if(constraint->score != -INFINITY) { pe_warn("rsc_dependencies other than \"must_not\" " "are not supported for clone resources"); return; } else { print_resource(LOG_DEBUG_3, "LHS", rsc_lh, FALSE); } get_clone_variant_data(clone_data, rsc_rh); slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, print_resource(LOG_DEBUG_3, "RHS", child_rsc, FALSE); child_rsc->cmds->rsc_colocation_rh(rsc_lh, child_rsc, constraint); ); } void clone_rsc_order_lh(resource_t *rsc, order_constraint_t *order) { char *stop_id = NULL; char *start_id = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); crm_debug_3("Processing LH of ordering constraint %d", order->id); stop_id = stop_key(rsc); start_id = start_key(rsc); if(safe_str_eq(order->lh_action_task, start_id)) { crm_free(order->lh_action_task); order->lh_action_task = started_key(rsc); } else if(safe_str_eq(order->lh_action_task, stop_id)) { crm_free(order->lh_action_task); order->lh_action_task = stopped_key(rsc); } crm_free(start_id); crm_free(stop_id); clone_data->self->cmds->rsc_order_lh(clone_data->self, order); } void clone_rsc_order_rh( action_t *lh_action, resource_t *rsc, order_constraint_t *order) { clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); crm_debug_3("Processing RH of ordering constraint %d", order->id); clone_data->self->cmds->rsc_order_rh(lh_action, clone_data->self, order); } 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); clone_data->self->cmds->rsc_location(clone_data->self, constraint); slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, child_rsc->cmds->rsc_location(child_rsc, constraint); ); } 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, int clones, char **rsc_list, char **node_list, char **uuid_list) { const char *uname = NULL; const char *rsc_id = NULL; const char *last_rsc_id = NULL; CRM_CHECK(list != NULL, return); if(rsc_list) { CRM_CHECK(*rsc_list == NULL, *rsc_list = NULL); } if(node_list) { CRM_CHECK(*node_list == NULL, *node_list = NULL); } slist_iter(entry, notify_entry_t, list, lpc, CRM_CHECK(entry != NULL, continue); rsc_id = entry->rsc->id; CRM_CHECK(rsc_id != NULL, rsc_id = "__none__"); uname = NULL; if(entry->node) { uname = entry->node->details->uname; } CRM_CHECK(uname != NULL, uname = "__none__"); /* 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(node_list != NULL) { 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); } ); } void clone_expand(resource_t *rsc, pe_working_set_t *data_set) { char *rsc_list = NULL; char *node_list = NULL; char *uuid_list = NULL; notify_data_t *n_data = NULL; clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); crm_malloc0(n_data, sizeof(notify_data_t)); n_data->keys = g_hash_table_new_full( g_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); crm_debug_2("Processing actions from %s", rsc->id); if(rsc->notify) { slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, slist_iter( op, action_t, clone_data->self->actions, lpc2, child_rsc->cmds->create_notify_element( child_rsc, op, n_data, data_set); ); ); } /* expand the notify data */ if(rsc->notify && n_data->stop) { n_data->stop = g_list_sort( n_data->stop, sort_notify_entries); rsc_list = NULL; node_list = NULL; expand_list(n_data->stop, clone_data->clone_max, &rsc_list, &node_list, &uuid_list); 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(rsc->notify && n_data->start) { n_data->start = g_list_sort( n_data->start, sort_notify_entries); rsc_list = NULL; node_list = NULL; expand_list(n_data->start, clone_data->clone_max, &rsc_list, &node_list, &uuid_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(rsc->notify && n_data->demote) { n_data->demote = g_list_sort( n_data->demote, sort_notify_entries); rsc_list = NULL; node_list = NULL; expand_list(n_data->demote, clone_data->clone_max, &rsc_list, &node_list, &uuid_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(rsc->notify && n_data->promote) { n_data->promote = g_list_sort( n_data->promote, sort_notify_entries); rsc_list = NULL; node_list = NULL; uuid_list = NULL; expand_list(n_data->promote, clone_data->clone_max, &rsc_list, &node_list, &uuid_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(rsc->notify && n_data->active) { n_data->active = g_list_sort( n_data->active, sort_notify_entries); rsc_list = NULL; node_list = NULL; uuid_list = NULL; expand_list(n_data->active, clone_data->clone_max, &rsc_list, &node_list, &uuid_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(rsc->notify && n_data->slave) { n_data->slave = g_list_sort( n_data->slave, sort_notify_entries); rsc_list = NULL; node_list = NULL; uuid_list = NULL; expand_list(n_data->slave, clone_data->clone_max, &rsc_list, &node_list, &uuid_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(rsc->notify && n_data->master) { n_data->master = g_list_sort( n_data->master, sort_notify_entries); rsc_list = NULL; node_list = NULL; uuid_list = NULL; expand_list(n_data->master, clone_data->clone_max, &rsc_list, &node_list, &uuid_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(rsc->notify && n_data->inactive) { n_data->inactive = g_list_sort( n_data->inactive, sort_notify_entries); rsc_list = NULL; node_list = NULL; uuid_list = NULL; expand_list(n_data->inactive, clone_data->clone_max, &rsc_list, &node_list, &uuid_list); g_hash_table_insert( n_data->keys, crm_strdup("notify_inactive_resource"), rsc_list); g_hash_table_insert( n_data->keys, crm_strdup("notify_inactive_uname"), node_list); } /* yes, we DO need this second loop */ slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, child_rsc->cmds->expand(child_rsc, data_set); ); /* slist_iter( */ /* action, action_t, clone_data->self->actions, lpc2, */ /* if(safe_str_eq(action->task, CRMD_ACTION_NOTIFY)) { */ /* action->meta_xml = notify_xml; */ /* } */ /* ); */ clone_data->self->cmds->expand(clone_data->self, data_set); /* destroy the notify_data */ 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); } void clone_agent_constraints(resource_t *rsc) { clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, child_rsc->cmds->agent_constraints(child_rsc); ); } void clone_create_notify_element(resource_t *rsc, action_t *op, notify_data_t *n_data, pe_working_set_t *data_set) { clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, child_rsc->cmds->create_notify_element( child_rsc, op, n_data, data_set); ); } 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); } 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); clone_data->child_list = g_list_sort( clone_data->child_list, sort_rsc_id); if(rsc->globally_unique == FALSE && clone_data->clone_node_max == 1) { /* only look for one copy */ slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, if(pe_find_node_id(child_rsc->running_on, node->details->id)) { return child_rsc->cmds->create_probe( child_rsc, node, complete, force, data_set); } ); } slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, if(child_rsc->cmds->create_probe( child_rsc, node, complete, force, data_set)) { any_created = TRUE; } if(any_created && rsc->globally_unique == FALSE && clone_data->clone_node_max == 1) { /* only look for one copy (clone :0) */ break; } ); return any_created; } void clone_stonith_ordering( resource_t *rsc, action_t *stonith_op, pe_working_set_t *data_set) { clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, child_rsc->cmds->stonith_ordering( child_rsc, stonith_op, data_set); ); } diff --git a/crm/pengine/group.c b/crm/pengine/group.c index ea2e6b6841..a0cd4960dd 100644 --- a/crm/pengine/group.c +++ b/crm/pengine/group.c @@ -1,481 +1,481 @@ /* $Id: group.c,v 1.69 2006/08/14 09:06:31 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include - -extern gboolean rsc_colocation_new( - const char *id, enum con_strength strength, - resource_t *rsc_lh, resource_t *rsc_rh, - const char *state_lh, const char *state_rh); - +#include typedef struct group_variant_data_s { int num_children; GListPtr child_list; /* resource_t* */ resource_t *self; resource_t *first_child; resource_t *last_child; gboolean colocated; gboolean ordered; gboolean child_starting; gboolean child_stopping; } group_variant_data_t; #define get_group_variant_data(data, rsc) \ CRM_ASSERT(rsc != NULL); \ CRM_ASSERT(rsc->variant == pe_group); \ CRM_ASSERT(rsc->variant_opaque != NULL); \ data = (group_variant_data_t *)rsc->variant_opaque; \ -void group_assign_color(resource_t *rsc, color_t *group_color); - void group_set_cmds(resource_t *rsc) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); group_data->self->cmds = &resource_class_alloc_functions[group_data->self->variant]; slist_iter( child_rsc, resource_t, group_data->child_list, lpc, child_rsc->cmds = &resource_class_alloc_functions[child_rsc->variant]; child_rsc->cmds->set_cmds(child_rsc); ); } int group_num_allowed_nodes(resource_t *rsc) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); if(group_data->colocated == FALSE) { crm_config_err("Cannot clone non-colocated group: %s", rsc->id); return 0; } return group_data->self->cmds->num_allowed_nodes(group_data->self); } -color_t * +node_t * group_color(resource_t *rsc, pe_working_set_t *data_set) { - color_t *group_color = NULL; + gboolean first = TRUE; + node_t *group_node = NULL; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); + if(rsc->provisional == FALSE) { + return rsc->allocated_to; + } + if(rsc->is_allocating) { + crm_err("Dependancy loop detected involving %s", rsc->id); + return NULL; + } + rsc->is_allocating = TRUE; + crm_debug_3("Coloring children of: %s", rsc->id); slist_iter( coloc, rsc_colocation_t, rsc->rsc_cons, lpc, - crm_debug_3("Pre-Processing %s for %s", coloc->id, rsc->id); + crm_debug("Pre-Processing %s for %s", coloc->id, rsc->id); + coloc->rsc_rh->cmds->color(coloc->rsc_rh, data_set); group_data->first_child->cmds->rsc_colocation_lh( group_data->first_child, coloc->rsc_rh, coloc); ); - - slist_iter( - child_rsc, resource_t, group_data->child_list, lpc, - group_color = child_rsc->cmds->color(child_rsc, data_set); - CRM_CHECK(group_color != NULL, continue); - native_assign_color(rsc, group_color); - ); - - return group_color; -} -void -group_assign_color(resource_t *rsc, color_t *group_color) -{ - group_variant_data_t *group_data = NULL; - get_group_variant_data(group_data, rsc); - - crm_debug_3("Coloring children of: %s", rsc->id); - CRM_CHECK(group_color != NULL, return); - - native_assign_color(rsc, group_color); + /* combine the child weights */ + crm_debug("Processing %s", rsc->id); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, - native_assign_color(child_rsc, group_color); + if(first) { + crm_debug("Color %s", child_rsc->id); + group_node = child_rsc->cmds->color(child_rsc, data_set); + first = FALSE; + } else if(child_rsc->provisional) { + native_assign_node(child_rsc, NULL, group_node); + } else { + crm_debug_2("Skip %s", child_rsc->id); + break; + } ); + + rsc->provisional = FALSE; + rsc->is_allocating = FALSE; + + return group_node; } 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; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, child_rsc->cmds->create_actions(child_rsc, data_set); group_update_pseudo_status(rsc, child_rsc); ); op = start_action(group_data->self, NULL, !group_data->child_starting); op->pseudo = TRUE; op = custom_action(group_data->self, started_key(group_data->self), CRMD_ACTION_STARTED, NULL, !group_data->child_starting, TRUE, data_set); op->pseudo = TRUE; op = stop_action(group_data->self, NULL, !group_data->child_stopping); op->pseudo = TRUE; op = custom_action(group_data->self, stopped_key(group_data->self), CRMD_ACTION_STOPPED, NULL, !group_data->child_stopping, TRUE, data_set); op->pseudo = TRUE; rsc->actions = group_data->self->actions; } 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->child_stopping && group_data->child_starting) { return; } slist_iter( action, action_t, child->actions, lpc, if(action->optional) { continue; } if(safe_str_eq(CRMD_ACTION_STOP, action->task) && action->runnable) { group_data->child_stopping = TRUE; } else if(safe_str_eq(CRMD_ACTION_START, action->task) && action->runnable) { group_data->child_starting = TRUE; } ); } void group_internal_constraints(resource_t *rsc, pe_working_set_t *data_set) { resource_t *last_rsc = NULL; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); group_data->self->cmds->internal_constraints(group_data->self, data_set); custom_action_order( group_data->self, stopped_key(group_data->self), NULL, group_data->self, start_key(group_data->self), NULL, pe_ordering_optional, data_set); custom_action_order( group_data->self, stop_key(group_data->self), NULL, group_data->self, stopped_key(group_data->self), NULL, pe_ordering_optional, data_set); custom_action_order( group_data->self, start_key(group_data->self), NULL, group_data->self, started_key(group_data->self), NULL, pe_ordering_optional, data_set); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, child_rsc->cmds->internal_constraints(child_rsc, data_set); if(group_data->colocated && child_rsc != group_data->first_child) { rsc_colocation_new( - "group:internal_colocation", pecs_must, - group_data->first_child, child_rsc, + "group:internal_colocation", INFINITY, + child_rsc, group_data->first_child, NULL, NULL); } if(group_data->ordered == FALSE) { order_start_start( group_data->self, child_rsc, pe_ordering_optional); custom_action_order( child_rsc, start_key(child_rsc), NULL, group_data->self, started_key(group_data->self), NULL, pe_ordering_optional, data_set); order_stop_stop( group_data->self, child_rsc, pe_ordering_optional); custom_action_order( child_rsc, stop_key(child_rsc), NULL, group_data->self, stopped_key(group_data->self), NULL, pe_ordering_optional, data_set); continue; } if(last_rsc != NULL) { order_start_start( last_rsc, child_rsc, pe_ordering_optional); order_stop_stop( child_rsc, last_rsc, pe_ordering_optional); /* recovery */ child_rsc->restart_type = pe_restart_restart; order_start_start( last_rsc, child_rsc, pe_ordering_recover); order_stop_stop( child_rsc, last_rsc, pe_ordering_recover); } else { custom_action_order( child_rsc, stop_key(child_rsc), NULL, group_data->self, stopped_key(group_data->self), NULL, pe_ordering_optional, data_set); order_start_start(group_data->self, child_rsc, pe_ordering_optional); } last_rsc = child_rsc; ); if(group_data->ordered && last_rsc != NULL) { custom_action_order( last_rsc, start_key(last_rsc), NULL, group_data->self, started_key(group_data->self), NULL, pe_ordering_optional, data_set); order_stop_stop( group_data->self, last_rsc, pe_ordering_optional); } } 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; } - if(constraint->strength != pecs_must_not) { + if(constraint->score > 0) { crm_config_err("Cannot colocate resources with" " non-colocated group: %s", rsc_lh->id); return; } slist_iter( child_rsc, resource_t, group_data->child_list, 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(group_data->colocated) { group_data->first_child->cmds->rsc_colocation_rh( rsc_lh, group_data->first_child, constraint); return; } - if(constraint->strength != pecs_must_not) { + if(constraint->score > 0) { crm_config_err("Cannot colocate resources with" " non-colocated group: %s", rsc_rh->id); return; } slist_iter( child_rsc, resource_t, group_data->child_list, lpc, child_rsc->cmds->rsc_colocation_rh( rsc_lh, child_rsc, constraint); ); } void group_rsc_order_lh(resource_t *rsc, order_constraint_t *order) { char *stop_id = NULL; char *start_id = NULL; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); crm_debug_3("Processing LH of ordering constraint %d", order->id); if(group_data->self == NULL) { return; } stop_id = stop_key(group_data->self); start_id = start_key(group_data->self); if(safe_str_eq(order->lh_action_task, start_id)) { crm_free(order->lh_action_task); order->lh_action_task = started_key(group_data->self); } else if(safe_str_eq(order->lh_action_task, stop_id)) { crm_free(order->lh_action_task); order->lh_action_task = stopped_key(group_data->self); } crm_free(start_id); crm_free(stop_id); group_data->self->cmds->rsc_order_lh(group_data->self, order); } void group_rsc_order_rh( action_t *lh_action, resource_t *rsc, order_constraint_t *order) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); crm_debug_3("Processing RH of ordering constraint %d", order->id); if(group_data->self == NULL) { return; } group_data->self->cmds->rsc_order_rh(lh_action, group_data->self, order); } void group_rsc_location(resource_t *rsc, rsc_to_node_t *constraint) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); crm_debug_3("Processing actions from %s", group_data->self->id); group_data->self->cmds->rsc_location(group_data->self, constraint); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, child_rsc->cmds->rsc_location(child_rsc, constraint); ); } 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(group_data->self != NULL, return); group_data->self->cmds->expand(group_data->self, data_set); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, child_rsc->cmds->expand(child_rsc, data_set); ); } void group_agent_constraints(resource_t *rsc) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, child_rsc->cmds->agent_constraints(child_rsc); ); } void group_create_notify_element(resource_t *rsc, action_t *op, notify_data_t *n_data, pe_working_set_t *data_set) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, child_rsc->cmds->create_notify_element( child_rsc, op, n_data, data_set); ); } gboolean group_create_probe(resource_t *rsc, node_t *node, action_t *complete, gboolean force, pe_working_set_t *data_set) { gboolean any_created = FALSE; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, any_created = child_rsc->cmds->create_probe( child_rsc, node, complete, force, data_set) || any_created; ); return any_created; } void group_stonith_ordering( resource_t *rsc, action_t *stonith_op, pe_working_set_t *data_set) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, child_rsc->cmds->stonith_ordering( child_rsc, stonith_op, data_set); ); } diff --git a/crm/pengine/master.c b/crm/pengine/master.c index 8366e887ab..0bfdae3cab 100644 --- a/crm/pengine/master.c +++ b/crm/pengine/master.c @@ -1,519 +1,516 @@ /* $Id: master.c,v 1.22 2006/06/07 12:46:58 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include extern void clone_create_notifications( resource_t *rsc, action_t *action, action_t *action_complete, pe_working_set_t *data_set); typedef struct clone_variant_data_s { resource_t *self; int clone_max; int clone_node_max; int active_clones; int max_nodes; gboolean interleave; gboolean ordered; crm_data_t *xml_obj_child; gboolean notify_confirm; GListPtr child_list; /* resource_t* */ } clone_variant_data_t; #define NO_MASTER_PREFS 0 #define get_clone_variant_data(data, rsc) \ CRM_ASSERT(rsc->variant == pe_master); \ data = (clone_variant_data_t *)rsc->variant_opaque; static void child_promoting_constraints( clone_variant_data_t *clone_data, enum pe_ordering type, resource_t *child, resource_t *last, pe_working_set_t *data_set) { /* if(clone_data->ordered */ /* || clone_data->self->restart_type == pe_restart_restart) { */ /* type = pe_ordering_manditory; */ /* } */ if(child == NULL) { if(clone_data->ordered && last != NULL) { crm_debug_4("Ordered version (last node)"); /* last child promote before promoted started */ custom_action_order( last, promote_key(last), NULL, clone_data->self, promoted_key(clone_data->self), NULL, type, data_set); } } else if(clone_data->ordered) { crm_debug_4("Ordered version"); if(last == NULL) { /* global promote before first child promote */ last = clone_data->self; } /* else: child/child relative promote */ order_start_start(last, child, type); custom_action_order( last, promote_key(last), NULL, child, promote_key(child), NULL, type, data_set); } else { crm_debug_4("Un-ordered version"); /* child promote before global promoted */ custom_action_order( child, promote_key(child), NULL, clone_data->self, promoted_key(clone_data->self), NULL, type, data_set); /* global promote before child promote */ custom_action_order( clone_data->self, promote_key(clone_data->self), NULL, child, promote_key(child), NULL, type, data_set); } } static void child_demoting_constraints( clone_variant_data_t *clone_data, enum pe_ordering type, resource_t *child, resource_t *last, pe_working_set_t *data_set) { /* if(clone_data->ordered */ /* || clone_data->self->restart_type == pe_restart_restart) { */ /* type = pe_ordering_manditory; */ /* } */ if(child == NULL) { if(clone_data->ordered && last != NULL) { crm_debug_4("Ordered version (last node)"); /* global demote before first child demote */ custom_action_order( clone_data->self, demote_key(clone_data->self), NULL, last, demote_key(last), NULL, pe_ordering_manditory, data_set); } } else if(clone_data->ordered && last != NULL) { crm_debug_4("Ordered version"); /* child/child relative demote */ custom_action_order(child, demote_key(child), NULL, last, demote_key(last), NULL, type, data_set); } else if(clone_data->ordered) { crm_debug_4("Ordered version (1st node)"); /* first child stop before global stopped */ custom_action_order( child, demote_key(child), NULL, clone_data->self, demoted_key(clone_data->self), NULL, type, data_set); } else { crm_debug_4("Un-ordered version"); /* child demote before global demoted */ custom_action_order( child, demote_key(child), NULL, clone_data->self, demoted_key(clone_data->self), NULL, type, data_set); /* global demote before child demote */ custom_action_order( clone_data->self, demote_key(clone_data->self), NULL, child, demote_key(child), NULL, type, data_set); } } - static void master_update_pseudo_status( resource_t *child, gboolean *demoting, gboolean *promoting) { CRM_ASSERT(demoting != NULL); CRM_ASSERT(promoting != NULL); slist_iter( action, action_t, child->actions, lpc, if(*promoting && *demoting) { return; } else if(action->optional) { continue; } else if(safe_str_eq(CRMD_ACTION_DEMOTE, action->task)) { *demoting = TRUE; } else if(safe_str_eq(CRMD_ACTION_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("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("\t%s: %d->%d", child_rsc->id, \ child_rsc->priority, new_priority); \ child_rsc->priority = new_priority; \ } \ ); struct masters_s { node_t *node; int num_masters; }; void master_create_actions(resource_t *rsc, pe_working_set_t *data_set) { int len = 0; node_t *chosen = NULL; char *attr_name = NULL; const char *attr_value = NULL; node_t *cons_node = NULL; 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; const char *master_max_s = g_hash_table_lookup( rsc->meta, XML_RSC_ATTR_MASTER_MAX); const char *master_node_max_s = g_hash_table_lookup( rsc->meta, XML_RSC_ATTR_MASTER_NODEMAX); int promoted = 0; int master_max = crm_parse_int(master_max_s, "1"); int master_node_max = crm_parse_int(master_node_max_s, "1"); struct masters_s *master_hash_obj = NULL; GHashTable *master_hash = g_hash_table_new_full( g_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); clone_variant_data_t *clone_data = NULL; get_clone_variant_data(clone_data, rsc); /* how many can we have? */ if(master_max > clone_data->max_nodes * clone_data->clone_node_max) { master_max = clone_data->max_nodes * clone_data->clone_node_max; crm_info("Limited to %d masters (potential slaves)",master_max); } if(master_max > clone_data->max_nodes * master_node_max) { master_max = clone_data->max_nodes * master_node_max; crm_info("Limited to %d masters (available nodes)", master_max); } /* * assign priority */ slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, crm_debug_2("Assigning priority for %s", child_rsc->id); - CRM_CHECK(child_rsc->color != NULL, - crm_err("Resource %s is uncolored", child_rsc->id); - continue); - chosen = child_rsc->color->details->chosen_node; - - if(child_rsc->role == RSC_ROLE_STARTED) { + chosen = child_rsc->allocated_to; + if(chosen == NULL) { + continue; + + } else if(child_rsc->role == RSC_ROLE_STARTED) { child_rsc->role = RSC_ROLE_SLAVE; } switch(child_rsc->next_role) { case RSC_ROLE_STARTED: if(NO_MASTER_PREFS) { child_rsc->priority = clone_data->clone_max - lpc; break; } child_rsc->priority = -1; CRM_CHECK(chosen != NULL, break); len = 8 + strlen(child_rsc->id); crm_malloc0(attr_name, len); sprintf(attr_name, "master-%s", child_rsc->id); crm_debug_2("looking for %s on %s", attr_name, - chosen->details->uname); + chosen->details->uname); attr_value = g_hash_table_lookup( chosen->details->attrs, attr_name); if(attr_value == NULL) { crm_free(attr_name); len = 8 + strlen(child_rsc->long_name); crm_malloc0(attr_name, len); sprintf(attr_name, "master-%s", child_rsc->long_name); crm_debug_2("looking for %s on %s", attr_name, chosen->details->uname); attr_value = g_hash_table_lookup( chosen->details->attrs, attr_name); } if(attr_value != NULL) { crm_debug("%s=%s for %s", attr_name, crm_str(attr_value), chosen->details->uname); child_rsc->priority = char2score( attr_value); } crm_free(attr_name); apply_master_location(child_rsc->rsc_location); apply_master_location(rsc->rsc_location); break; case RSC_ROLE_SLAVE: case RSC_ROLE_STOPPED: child_rsc->priority = -INFINITY; break; case RSC_ROLE_MASTER: /* the only reason we should be here is if * we're re-creating actions after a stonith */ promoted++; break; default: CRM_CHECK(FALSE/* unhandled */, crm_err("Unknown resource role: %d for %s", child_rsc->next_role, child_rsc->id)); } ); /* sort based on the new "promote" priority */ clone_data->child_list = g_list_sort( clone_data->child_list, sort_rsc_priority); /* mark the first N as masters */ slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, - CRM_CHECK(child_rsc->color != NULL, - crm_err("Resource %s is uncolored", child_rsc->id); - continue); - - chosen = child_rsc->color->details->chosen_node; - + chosen = child_rsc->allocated_to; + if(chosen == NULL) { + continue; + } + switch(child_rsc->next_role) { case RSC_ROLE_STARTED: master_hash_obj = g_hash_table_lookup( master_hash, chosen->details->id); if(master_hash_obj == NULL) { crm_malloc0(master_hash_obj, sizeof(struct masters_s)); master_hash_obj->node = chosen; g_hash_table_insert( master_hash, crm_strdup(chosen->details->id), master_hash_obj); } if(master_hash_obj->num_masters >= master_node_max) { crm_info("Demoting %s (node master max)", child_rsc->id); child_rsc->next_role = RSC_ROLE_SLAVE; } else if(child_rsc->priority < 0) { crm_info("Demoting %s (priority)", child_rsc->id); child_rsc->next_role = RSC_ROLE_SLAVE; } else if(master_max <= promoted) { crm_info("Demoting %s (masters max)", child_rsc->id); child_rsc->next_role = RSC_ROLE_SLAVE; } else { crm_info("Promoting %s", child_rsc->id); child_rsc->next_role = RSC_ROLE_MASTER; promoted++; master_hash_obj->num_masters++; } break; case RSC_ROLE_SLAVE: if(child_rsc->priority < 0 ||master_max <= lpc){ pe_warn("Cannot promote %s (slave)", child_rsc->id); lpc--; } break; case RSC_ROLE_STOPPED: if(child_rsc->priority < 0 ||master_max <= lpc){ crm_debug("Cannot promote %s (stopping)", child_rsc->id); lpc--; } break; case RSC_ROLE_MASTER: /* the only reason we should be here is if * we're re-creating actions after a stonith */ promoted++; break; default: CRM_CHECK(FALSE/* unhandled */, crm_err("Unknown resource role: %d for %s", child_rsc->next_role, child_rsc->id)); } add_hash_param(child_rsc->parameters, crm_meta_name("role"), role2text(child_rsc->next_role)); ); crm_info("Promoted %d (of %d) slaves to master", promoted, master_max); g_hash_table_destroy(master_hash); /* create actions as normal */ clone_create_actions(rsc, data_set); slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, gboolean child_promoting = FALSE; gboolean child_demoting = FALSE; master_update_pseudo_status( child_rsc, &child_demoting, &child_promoting); any_demoting = any_demoting || child_demoting; any_promoting = any_promoting || child_promoting; ); /* promote */ action = promote_action(clone_data->self, NULL, !any_promoting); action_complete = custom_action( clone_data->self, promoted_key(rsc), CRMD_ACTION_PROMOTED, NULL, !any_promoting, TRUE, data_set); action->pseudo = TRUE; action_complete->pseudo = TRUE; action_complete->priority = INFINITY; child_promoting_constraints(clone_data, pe_ordering_optional, NULL, last_promote_rsc, data_set); clone_create_notifications(rsc, action, action_complete, data_set); /* demote */ action = demote_action(clone_data->self, NULL, !any_demoting); action_complete = custom_action( clone_data->self, demoted_key(rsc), CRMD_ACTION_DEMOTED, NULL, !any_demoting, TRUE, data_set); action_complete->priority = INFINITY; action->pseudo = TRUE; action_complete->pseudo = TRUE; child_demoting_constraints(clone_data, pe_ordering_optional, NULL, last_demote_rsc, data_set); clone_create_notifications(rsc, action, action_complete, data_set); } 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 demoted before start */ custom_action_order( clone_data->self, demoted_key(clone_data->self), NULL, clone_data->self, start_key(clone_data->self), NULL, pe_ordering_optional, data_set); /* global started before promote */ custom_action_order( clone_data->self, started_key(clone_data->self), NULL, clone_data->self, promote_key(clone_data->self), NULL, pe_ordering_optional, data_set); /* global demoted before stop */ custom_action_order( clone_data->self, demoted_key(clone_data->self), NULL, clone_data->self, stop_key(clone_data->self), NULL, pe_ordering_optional, data_set); /* global demote before demoted */ custom_action_order( clone_data->self, demote_key(clone_data->self), NULL, clone_data->self, demoted_key(clone_data->self), NULL, pe_ordering_optional, data_set); slist_iter( child_rsc, resource_t, clone_data->child_list, lpc, /* child demote before promote */ custom_action_order( child_rsc, demote_key(child_rsc), NULL, child_rsc, promote_key(child_rsc), NULL, pe_ordering_restart, data_set); child_promoting_constraints(clone_data, pe_ordering_optional, child_rsc, last_rsc, data_set); child_demoting_constraints(clone_data, pe_ordering_optional, child_rsc, last_rsc, data_set); last_rsc = child_rsc; ); } diff --git a/crm/pengine/native.c b/crm/pengine/native.c index a16917cd7e..b25a5afb14 100644 --- a/crm/pengine/native.c +++ b/crm/pengine/native.c @@ -1,1914 +1,1482 @@ /* $Id: native.c,v 1.161 2006/08/17 07:17:15 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #define DELETE_THEN_REFRESH 1 -extern color_t *add_color(resource_t *rh_resource, color_t *color); - -gboolean native_choose_color(resource_t *lh_resource, color_t *no_color); - -void native_update_node_weight(resource_t *rsc, rsc_to_node_t *cons, - node_t *cons_node, GListPtr nodes); +void node_list_update(GListPtr list1, GListPtr list2); 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 filter_nodes(resource_t *rsc); -int num_allowed_nodes4color(color_t *color); - void create_notifications(resource_t *rsc, pe_working_set_t *data_set); void Recurring(resource_t *rsc, action_t *start, node_t *node, pe_working_set_t *data_set); void pe_pre_notify( resource_t *rsc, node_t *node, action_t *op, notify_data_t *n_data, 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); gboolean DeleteRsc(resource_t *rsc, node_t *node, pe_working_set_t *data_set); void NoRoleChange(resource_t *rsc, node_t *current, node_t *next, pe_working_set_t *data_set); gboolean StopRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set); gboolean StartRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set); extern gboolean DemoteRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set); gboolean PromoteRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set); gboolean RoleError(resource_t *rsc, node_t *next, pe_working_set_t *data_set); gboolean NullOp(resource_t *rsc, node_t *next, 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*,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, }, }; typedef struct native_variant_data_s { /* GListPtr allowed_nodes; /\* node_t* *\/ */ } native_variant_data_t; #define get_native_variant_data(data, rsc) \ CRM_ASSERT(rsc->variant == pe_native); \ CRM_ASSERT(rsc->variant_opaque != NULL); \ data = (native_variant_data_t *)rsc->variant_opaque; -void native_set_cmds(resource_t *rsc) -{ -} -int native_num_allowed_nodes(resource_t *rsc) + +static gboolean +native_choose_node(resource_t *rsc) { - int num_nodes = 0; + /* + 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 + */ + GListPtr nodes = NULL; + node_t *chosen = NULL; - if(rsc->next_role == RSC_ROLE_STOPPED) { - return 0; + if(rsc->provisional == FALSE) { + return rsc->allocated_to?TRUE:FALSE; } - if(rsc->color) { - crm_debug_4("Colored case"); - num_nodes = num_allowed_nodes4color(rsc->color); - - } else if(rsc->candidate_colors) { - /* TODO: sort colors first */ - color_t *color = g_list_nth_data(rsc->candidate_colors, 0); - crm_debug_4("Candidate colors case"); - num_nodes = num_allowed_nodes4color(color); - - } else { - crm_debug_4("Default case"); - slist_iter( - this_node, node_t, rsc->allowed_nodes, lpc, - crm_debug_3("Rsc %s Checking %s: %d", - rsc->id, this_node->details->uname, - this_node->weight); - if(this_node->details->shutdown - || this_node->details->online == FALSE) { - this_node->weight = -INFINITY; - } - if(this_node->weight < 0) { - continue; -/* } else if(this_node->details->unclean) { */ -/* continue; */ - } - - num_nodes++; - ); + crm_debug_3("Choosing node for %s from %d candidates", + rsc->id, g_list_length(rsc->allowed_nodes)); + + if(rsc->allowed_nodes) { + rsc->allowed_nodes = g_list_sort( + rsc->allowed_nodes, sort_node_weight); + nodes = rsc->allowed_nodes; + chosen = g_list_nth_data(nodes, 0); } - crm_debug_2("Resource %s can run on %d nodes", rsc->id, num_nodes); - return num_nodes; + + return native_assign_node(rsc, nodes, chosen); } -int num_allowed_nodes4color(color_t *color) +void native_set_cmds(resource_t *rsc) +{ +} + +int native_num_allowed_nodes(resource_t *rsc) { int num_nodes = 0; - if(color->details->pending == FALSE) { - if(color->details->chosen_node) { - return 1; - } + if(rsc->next_role == RSC_ROLE_STOPPED) { return 0; } + crm_debug_4("Default case"); slist_iter( - this_node, node_t, color->details->candidate_nodes, lpc, - crm_debug_3("Checking %s: %d", - this_node->details->uname, this_node->weight); + this_node, node_t, rsc->allowed_nodes, lpc, + crm_debug_3("Rsc %s Checking %s: %d", + rsc->id, this_node->details->uname, + this_node->weight); if(this_node->details->shutdown || this_node->details->online == FALSE) { this_node->weight = -INFINITY; } - if(this_node->weight < 0) { + if(this_node->weight < 0) { continue; -/* } else if(this_node->details->unclean) { */ -/* continue; */ +/* } else if(this_node->details->unclean) { */ +/* continue; */ } + num_nodes++; ); + crm_debug_2("Resource %s can run on %d nodes", rsc->id, num_nodes); return num_nodes; } -color_t * +node_t * native_color(resource_t *rsc, pe_working_set_t *data_set) { - color_t *new_color = NULL; - - print_resource(LOG_DEBUG_2, "Coloring: ", rsc, FALSE); + print_resource(LOG_DEBUG_2, "Allocating: ", rsc, FALSE); if(rsc->provisional == FALSE) { - return rsc->color; + return rsc->allocated_to; + } + if(rsc->is_allocating) { + crm_err("Dependancy loop detected involving %s", rsc->id); + return NULL; } - rsc->rsc_cons = g_list_sort( - rsc->rsc_cons, sort_cons_strength); + rsc->is_allocating = TRUE; + rsc->rsc_cons = g_list_sort(rsc->rsc_cons, sort_cons_strength); - /*------ Pre-processing */ + /*------ Pre-processing ------*/ slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons, lpc, - crm_debug_3("Pre-Processing %s", constraint->id); - + crm_debug_3("Pre-Processing %s", constraint->id); + + /* or use ordering constraints? */ + constraint->rsc_rh->cmds->color( + constraint->rsc_rh, data_set); rsc->cmds->rsc_colocation_lh( rsc, constraint->rsc_rh, constraint); + ); - if( native_choose_color(rsc, data_set->no_color) ) { - crm_debug_3("Colored resource %s with color %d", - rsc->id, rsc->color->id); - new_color = rsc->color; - + if(native_choose_node(rsc) ) { + crm_debug("Allocated resource %s to %s", + rsc->id, rsc->allocated_to->details->uname); } else { - if(rsc->allowed_nodes != NULL) { - /* filter out nodes with a negative weight */ - filter_nodes(rsc); - new_color = create_color(data_set, rsc, - rsc->allowed_nodes); - native_assign_color(rsc, new_color); - crm_debug_3("Colored resource %s with new color %d", - rsc->id, rsc->color->id); - } - - if(new_color == NULL) { - pe_warn("Resource %s cannot run anywhere", rsc->id); - print_resource(LOG_ERR, "No color: ", rsc, FALSE); - native_assign_color(rsc, data_set->no_color); - new_color = data_set->no_color; - } + pe_warn("Resource %s cannot run anywhere", rsc->id); } rsc->provisional = FALSE; + rsc->is_allocating = FALSE; - /*------ Post-processing */ -#if 1 + /*------ Post-processing ------*/ slist_iter( constraint, rsc_colocation_t, rsc->rsc_cons, lpc, crm_debug_3("Post-Processing %s", constraint->id); rsc->cmds->rsc_colocation_lh( rsc, constraint->rsc_rh, constraint); ); -#endif - print_resource(LOG_DEBUG_3, "Colored ", rsc, TRUE); + print_resource(LOG_DEBUG_3, "Allocated ", rsc, TRUE); - return new_color; + return rsc->allocated_to; } void Recurring(resource_t *rsc, action_t *start, node_t *node, 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; int interval_ms = 0; action_t *mon = NULL; gboolean is_optional = TRUE; GListPtr possible_matches = NULL; crm_debug_2("Creating recurring actions for %s", rsc->id); if(node != NULL) { node_uname = node->details->uname; } xml_child_iter_filter( rsc->ops_xml, operation, "op", is_optional = TRUE; name = crm_element_value(operation, "name"); interval = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); interval_ms = crm_get_msec(interval); if(interval_ms <= 0) { continue; } value = crm_element_value(operation, "disabled"); if(crm_is_true(value)) { continue; } key = generate_op_key(rsc->id, name, interval_ms); if(start != NULL) { crm_debug_3("Marking %s %s due to %s", key, start->optional?"optional":"manditory", start->uuid); is_optional = start->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); } 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 *foo = "Ignoring"; if(is_optional) { log_level = LOG_INFO; foo = "Cancelling"; /* its running : cancel it */ mon = custom_action( rsc, crm_strdup(key), CRMD_ACTION_CANCEL, node, FALSE, TRUE, data_set); mon->task = CRMD_ACTION_CANCEL; add_hash_param(mon->meta, XML_LRM_ATTR_INTERVAL, interval); add_hash_param(mon->meta, XML_LRM_ATTR_TASK, name); custom_action_order( rsc, NULL, mon, rsc, promote_key(rsc), NULL, pe_ordering_optional, data_set); mon = NULL; } crm_log_maybe(log_level, "%s action %s (%s vs. %s)", foo , key, value?value:role2text(RSC_ROLE_SLAVE), role2text(rsc->next_role)); crm_free(key); key = NULL; continue; } mon = custom_action(rsc, key, name, node, is_optional, TRUE, data_set); if(is_optional) { crm_debug("%s\t %s (optional)", crm_str(node_uname), mon->uuid); } if(start == NULL || start->runnable == FALSE) { crm_debug("%s\t %s (cancelled : start un-runnable)", crm_str(node_uname), mon->uuid); mon->runnable = FALSE; } 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); mon->runnable = FALSE; } else if(mon->optional == FALSE) { crm_notice("%s\t %s", crm_str(node_uname),mon->uuid); } custom_action_order(rsc, start_key(rsc), NULL, NULL, crm_strdup(key), mon, pe_ordering_restart, data_set); 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); custom_action_order( rsc, promote_key(rsc), NULL, rsc, NULL, mon, pe_ordering_optional, data_set); crm_free(running_master); } ); } 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_CHECK(rsc->color != NULL, return); - - chosen = rsc->color->details->chosen_node; + chosen = rsc->allocated_to; if(chosen != NULL) { CRM_CHECK(rsc->next_role != RSC_ROLE_UNKNOWN, rsc->next_role = RSC_ROLE_STARTED); } unpack_instance_attributes( rsc->xml, XML_TAG_ATTR_SETS, chosen?chosen->details->attrs:NULL, rsc->parameters, NULL, data_set->now); crm_debug_2("%s: %s->%s", rsc->id, role2text(rsc->role), role2text(rsc->next_role)); if(g_list_length(rsc->running_on) > 1) { if(rsc->recovery_type == recovery_stop_start) { pe_proc_err("Attempting recovery of resource %s", rsc->id); StopRsc(rsc, NULL, 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, action->optional = TRUE; /* action->pseudo = TRUE; */ ); crm_debug_2("Stopping a stopped resource"); crm_free(key); return; } 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, data_set) == FALSE) { break; } role = next_role; } if(rsc->next_role != RSC_ROLE_STOPPED && rsc->is_managed) { 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) { order_restart(rsc); custom_action_order(rsc, demote_key(rsc), NULL, rsc, stop_key(rsc), NULL, pe_ordering_manditory, data_set); custom_action_order(rsc, start_key(rsc), NULL, rsc, promote_key(rsc), NULL, pe_ordering_optional, data_set); custom_action_order( rsc, stop_key(rsc), NULL, rsc, delete_key(rsc), NULL, pe_ordering_optional, data_set); custom_action_order( rsc, delete_key(rsc), NULL, rsc, start_key(rsc), NULL, pe_ordering_manditory, 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) { - if(constraint->strength == pecs_ignore - || constraint->strength == pecs_startstop){ - crm_debug_4("Skipping constraint type %d", constraint->strength); + if(constraint->score == 0){ return FALSE; } if(constraint->state_lh != NULL && text2role(constraint->state_lh) != rsc_lh->next_role) { crm_debug_4("RH: Skipping constraint: \"%s\" state filter", constraint->state_rh); return FALSE; } if(constraint->state_rh != NULL && text2role(constraint->state_rh) != rsc_rh->next_role) { crm_debug_4("RH: Skipping constraint: \"%s\" state filter", constraint->state_rh); return FALSE; } return TRUE; } +static gboolean +native_update_node_weight( + resource_t *rsc, const char *id, node_t *node, int score) +{ + node_t *node_rh = NULL; + CRM_CHECK(node != NULL, return FALSE); + + node_rh = pe_find_node_id( + rsc->allowed_nodes, node->details->id); + + if(node_rh == NULL) { + pe_warn("%s not found in %s", + node->details->uname, rsc->id); + return FALSE; + } + + if(node_rh->weight >= INFINITY && score <= -INFINITY) { + pe_err("Constraint \"%s\" mixes +/- INFINITY (%s)", + id, rsc->id); + + } else if(node_rh->details->shutdown == TRUE + || node_rh->details->online == FALSE + || node_rh->details->unclean == TRUE) { + + } else if(node_rh->weight <= -INFINITY && score >= INFINITY) { + pe_err("Constraint \"%s\" mixes +/- INFINITY (%s)", + id, rsc->id); + } + + if(node_rh->fixed) { + /* warning */ + crm_debug_2("Constraint %s is irrelevant as the" + " weight of node %s is fixed as %d (%s).", + id, node_rh->details->uname, + node_rh->weight, rsc->id); + return TRUE; + } + + crm_debug_3("Constraint %s, node %s, rsc %s: %d + %d", + id, node_rh->details->uname, rsc->id, + node_rh->weight, score); + node_rh->weight = merge_weights(node_rh->weight, score); + if(node_rh->weight <= -INFINITY) { + crm_debug_3("Constraint %s (-INFINITY): node %s weight %d (%s).", + id, node_rh->details->uname, + node_rh->weight, rsc->id); + + } else if(node_rh->weight >= INFINITY) { + crm_debug_3("Constraint %s (+INFINITY): node %s weight %d (%s).", + id, node_rh->details->uname, + node_rh->weight, rsc->id); + + } else { + crm_debug_3("Constraint %s (%d): node %s weight %d (%s).", + id, score, node_rh->details->uname, + node_rh->weight, rsc->id); + } + + if(node_rh->weight < 0) { + node_rh->fixed = TRUE; + } + + crm_action_debug_3(print_node("Updated", node_rh, FALSE)); + + return TRUE; +} + void native_rsc_colocation_rh( resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint) { - gboolean do_check = FALSE; - gboolean update_lh = FALSE; - gboolean update_rh = FALSE; - - crm_debug_2("%sColocating %s with %s (%s)", - constraint->strength == pecs_must?"":"Anti-", - rsc_lh->id, rsc_rh->id, constraint->id); + 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(rsc_lh->provisional && rsc_rh->provisional) { - if(constraint->strength == pecs_must) { - /* update effective_priorities */ - crm_debug_3("Priority update"); - native_rsc_colocation_rh_must( - rsc_lh, update_lh, rsc_rh, update_rh); - } else { - /* nothing */ - crm_debug_4( - "Skipping constraint, both sides provisional"); - } +#if 0 + /* should we do this? */ + crm_debug("combine priorities of %s and %s", + rsc_lh->id, rsc_rh->id); + node_list_update(rsc_lh->allowed_nodes, rsc_rh->allowed_nodes); +#endif return; - } else if( (!rsc_lh->provisional) && (!rsc_rh->provisional) - && (!rsc_lh->color->details->pending) - && (!rsc_rh->color->details->pending) ) { + } else if( (!rsc_lh->provisional) && (!rsc_rh->provisional) ) { /* error check */ - do_check = TRUE; - if(rsc_lh->effective_priority < rsc_rh->effective_priority) { - update_lh = TRUE; - - } else if(rsc_lh->effective_priority - > rsc_rh->effective_priority) { - update_rh = TRUE; - - } else { - update_lh = TRUE; - update_rh = TRUE; + struct node_shared_s *details_lh; + struct node_shared_s *details_rh; + if((constraint->score > -INFINITY) && (constraint->score < INFINITY)) { + return; } - } else if(rsc_lh->provisional == FALSE - && rsc_lh->color->details->pending == FALSE) { - /* update _them_ : postproc color version */ - update_rh = TRUE; + 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 if(rsc_rh->provisional == FALSE - && rsc_rh->color->details->pending == FALSE) { - /* update _us_ : postproc color alt version */ - update_lh = TRUE; - } else if(rsc_lh->provisional == FALSE) { - /* update _them_ : preproc version */ - update_rh = TRUE; + crm_debug_3("update _them_ : postproc version"); + if(rsc_lh->allocated_to) { + if(native_update_node_weight( + rsc_rh, constraint->id, rsc_lh->allocated_to, + constraint->score) == FALSE) { + rsc_rh->provisional = FALSE; + crm_warn("%s cant run on %s", rsc_rh->id, + rsc_lh->allocated_to->details->uname); + } + + } else { + rsc_rh->provisional = FALSE; + } } else if(rsc_rh->provisional == FALSE) { - /* update _us_ : postproc version */ - update_lh = TRUE; - - } else { - pe_warn("Un-expected combination of inputs"); - return; + crm_debug_3("update _us_ : postproc version"); + if(rsc_rh->allocated_to) { + if(native_update_node_weight( + rsc_lh, constraint->id, rsc_rh->allocated_to, + constraint->score) == FALSE) { + crm_warn("%s cant run on %s", rsc_lh->id, + rsc_rh->allocated_to->details->uname); + rsc_lh->provisional = FALSE; + } + + } else { + rsc_lh->provisional = FALSE; + } } - +} - if(update_lh) { - crm_debug_4("Updating LHS"); - } - if(update_rh) { - crm_debug_4("Updating RHS"); - } +void +node_list_update(GListPtr list1, GListPtr list2) +{ + node_t *other_node = NULL; - if(do_check) { - if(native_constraint_violated( - rsc_lh, rsc_rh, constraint) == FALSE) { + slist_iter( + node, node_t, list1, lpc, - crm_debug_4("Constraint satisfied"); - return; - } - /* else constraint cant be satisified */ - pe_warn("Constraint %s could not be satisfied", - constraint->id); - - if(update_lh) { - pe_warn("Marking resource %s unrunnable as a result", - rsc_lh->id); - resource_location(rsc_lh, NULL, -INFINITY, - constraint->id, NULL); - if(rsc_lh->color) { - crm_free(rsc_lh->color->details->chosen_node); - rsc_lh->color->details->chosen_node = NULL; - - pe_free_shallow_adv( - rsc_lh->color->details->candidate_nodes, - TRUE); - rsc_lh->color->details->candidate_nodes = NULL; - } + if(node == NULL) { + continue; } - if(update_rh) { - pe_warn("Marking resource %s unrunnable as a result", - rsc_rh->id); - resource_location(rsc_rh, NULL, -INFINITY, - constraint->id, NULL); - if(rsc_rh->color) { - crm_free(rsc_rh->color->details->chosen_node); - rsc_rh->color->details->chosen_node = NULL; - - pe_free_shallow_adv( - rsc_rh->color->details->candidate_nodes, - TRUE); - rsc_rh->color->details->candidate_nodes = NULL; - } - } - } - if(constraint->strength == pecs_must) { - native_rsc_colocation_rh_must( - rsc_lh, update_lh, rsc_rh, update_rh); - return; - - } else if(constraint->strength != pecs_must_not) { - /* unknown type */ - pe_err("Unknown constraint type %d", constraint->strength); - return; - } + other_node = (node_t*)pe_find_node_id( + list2, node->details->id); - native_rsc_colocation_rh_mustnot(rsc_lh, update_lh,rsc_rh, update_rh); + if(other_node != NULL) { + crm_debug_4("%s + %s: %d + %d", + node->details->uname, + other_node->details->uname, + node->weight, other_node->weight); + node->weight = merge_weights( + other_node->weight, node->weight); + } + ); } - void native_rsc_order_lh(resource_t *lh_rsc, order_constraint_t *order) { GListPtr lh_actions = NULL; action_t *lh_action = order->lh_action; crm_debug_3("Processing LH of ordering constraint %d", order->id); if(lh_action != NULL) { lh_actions = g_list_append(NULL, lh_action); } else if(lh_action == NULL && lh_rsc != NULL) { lh_actions = find_actions( lh_rsc->actions, order->lh_action_task, NULL); if(lh_actions == NULL) { crm_debug_4("No LH-Side (%s/%s) found for constraint", lh_rsc->id, order->lh_action_task); if(lh_rsc->next_role == RSC_ROLE_STOPPED) { resource_t *rh_rsc = order->rh_rsc; if(order->rh_action && order->type == pe_ordering_restart) { crm_debug_3("No LH(%s/%s) found for RH(%s)...", lh_rsc->id, order->lh_action_task, order->rh_action->uuid); order->rh_action->runnable = FALSE; return; } else if(rh_rsc != NULL) { crm_debug_3("No LH(%s/%s) found for RH(%s/%s)...", lh_rsc->id, order->lh_action_task, rh_rsc->id, order->rh_action_task); rh_rsc->cmds->rsc_order_rh(NULL, rh_rsc, order); return; } } return; } } else { pe_warn("No LH-Side (%s) specified for constraint", order->lh_action_task); if(order->rh_rsc != NULL) { crm_debug_4("RH-Side was: (%s/%s)", order->rh_rsc->id, order->rh_action_task); } else if(order->rh_action != NULL && order->rh_action->rsc != NULL) { crm_debug_4("RH-Side was: (%s/%s)", order->rh_action->rsc->id, order->rh_action_task); } else if(order->rh_action != NULL) { crm_debug_4("RH-Side was: %s", order->rh_action_task); } else { crm_debug_4("RH-Side was NULL"); } return; } slist_iter( lh_action_iter, action_t, lh_actions, lpc, resource_t *rh_rsc = order->rh_rsc; if(rh_rsc == NULL && order->rh_action) { rh_rsc = order->rh_action->rsc; } if(rh_rsc) { rh_rsc->cmds->rsc_order_rh( 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); } void native_rsc_order_rh( action_t *lh_action, resource_t *rsc, order_constraint_t *order) { GListPtr rh_actions = NULL; action_t *rh_action = order->rh_action; crm_debug_3("Processing RH of ordering constraint %d", order->id); if(rh_action != NULL) { rh_actions = g_list_append(NULL, rh_action); } else if(rh_action == NULL && rsc != NULL) { rh_actions = find_actions( rsc->actions, order->rh_action_task, NULL); if(rh_actions == NULL) { crm_debug_4("No RH-Side (%s/%s) found for constraint..." " ignoring", rsc->id, order->rh_action_task); crm_debug_4("LH-Side was: (%s/%s)", order->lh_rsc?order->lh_rsc->id:order->lh_action?order->lh_action->rsc->id:"", order->lh_action_task); return; } } else if(rh_action == NULL) { crm_debug_4("No RH-Side (%s) specified for constraint..." " ignoring", order->rh_action_task); crm_debug_4("LH-Side was: (%s/%s)", order->lh_rsc?order->lh_rsc->id:order->lh_action?order->lh_action->rsc->id:"", order->lh_action_task); return; } slist_iter( rh_action_iter, action_t, rh_actions, lpc, if(lh_action) { order_actions(lh_action, rh_action_iter, order->type); } else if(order->type == pe_ordering_restart) { rh_action_iter->runnable = FALSE; } ); pe_free_shallow_adv(rh_actions, FALSE); } void native_rsc_location(resource_t *rsc, rsc_to_node_t *constraint) { GListPtr or_list; 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; } or_list = node_list_or( rsc->allowed_nodes, constraint->node_list_rh, FALSE); pe_free_shallow(rsc->allowed_nodes); rsc->allowed_nodes = or_list; slist_iter(node, node_t, or_list, lpc, 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) { 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); ); } -void native_rsc_colocation_rh_must(resource_t *rsc_lh, gboolean update_lh, - resource_t *rsc_rh, gboolean update_rh) -{ - gboolean do_merge = FALSE; - GListPtr old_list = NULL; - GListPtr merged_node_list = NULL; - int max_pri = rsc_lh->effective_priority; - if(max_pri < rsc_rh->effective_priority) { - max_pri = rsc_rh->effective_priority; - } - rsc_lh->effective_priority = max_pri; - rsc_rh->effective_priority = max_pri; - - crm_debug_2("Colocating %s with %s." - " Update LHS: %s, Update RHS: %s", - rsc_lh->id, rsc_rh->id, - update_lh?"true":"false", update_rh?"true":"false"); - - if(rsc_lh->color && rsc_rh->color) { - do_merge = TRUE; - merged_node_list = node_list_and( - rsc_lh->color->details->candidate_nodes, - rsc_rh->color->details->candidate_nodes, TRUE); - - } else if(rsc_lh->color) { - do_merge = TRUE; - merged_node_list = node_list_and( - rsc_lh->color->details->candidate_nodes, - rsc_rh->allowed_nodes, TRUE); - - } else if(rsc_rh->color) { - do_merge = TRUE; - merged_node_list = node_list_and( - rsc_lh->allowed_nodes, - rsc_rh->color->details->candidate_nodes, TRUE); - } - - if(update_lh && rsc_rh != rsc_lh) { - CRM_CHECK(rsc_lh->color != rsc_rh->color, return); - crm_free(rsc_lh->color); - rsc_lh->runnable = rsc_rh->runnable; - rsc_lh->provisional = rsc_rh->provisional; - - CRM_CHECK(rsc_rh->color != NULL, return); - native_assign_color(rsc_lh, rsc_rh->color); - } - if(update_rh && rsc_rh != rsc_lh) { - CRM_CHECK(rsc_lh->color != rsc_rh->color, return); - crm_free(rsc_rh->color); - rsc_rh->runnable = rsc_lh->runnable; - rsc_rh->provisional = rsc_lh->provisional; - - CRM_CHECK(rsc_lh->color != NULL, return); - native_assign_color(rsc_rh, rsc_lh->color); - } - - if((update_rh || update_lh) && do_merge) { - crm_debug_4("Merging candidate nodes"); - old_list = rsc_rh->color->details->candidate_nodes; - rsc_rh->color->details->candidate_nodes = merged_node_list; - pe_free_shallow(old_list); - } - - crm_debug_4("Finished processing pecs_must constraint"); -} - -void native_rsc_colocation_rh_mustnot(resource_t *rsc_lh, gboolean update_lh, - resource_t *rsc_rh, gboolean update_rh) -{ - color_t *color_lh = NULL; - color_t *color_rh = NULL; - - crm_debug_4("Processing pecs_must_not constraint"); - /* pecs_must_not */ - color_rh = rsc_rh->color; - color_lh = rsc_lh->color; - - if(update_lh) { - if(rsc_lh->provisional && color_rh != NULL) { - color_lh = add_color(rsc_lh, color_rh); - color_lh->local_weight = -INFINITY; - crm_debug_2("LH: Removed color %d from resource %s", - color_lh->id, rsc_lh->id); - - crm_action_debug_3( - print_color("Removed LH", color_lh, FALSE)); - - print_resource(LOG_DEBUG_3, "Modified LH", rsc_lh,TRUE); - - } else if(rsc_lh->provisional) { - - } else if(color_lh && color_lh->details->pending) { - node_t *node_lh = NULL; - - node_lh = pe_find_node_id( - color_lh->details->candidate_nodes, - safe_val5(NULL, color_rh, details, - chosen_node, details, id)); - - if(node_lh != NULL) { - node_lh->weight = -INFINITY; - - crm_debug_2("LH: Removed node %s from color %d", - node_lh->details->uname, color_lh->id); - - crm_action_debug_3( - print_node("Removed LH", node_lh, FALSE)); - - crm_action_debug_3( - print_color("Modified LH", color_lh, FALSE)); - } - - } else { - /* error, rsc marked as unrunnable above */ - pe_warn("lh else"); - } - } - - /* in case anything was modified */ - color_rh = rsc_rh->color; - color_lh = rsc_lh->color; - if(update_rh) { - if(rsc_rh->provisional && color_lh != NULL) { - color_rh = add_color(rsc_lh, color_lh); - color_rh->local_weight = -INFINITY; - crm_debug_2("RH: Removed color %d from resource %s", - color_rh->id, rsc_rh->id); - - crm_action_debug_3( - print_color("Removed RH", color_rh, FALSE)); - - print_resource(LOG_DEBUG_3, "Modified RH", rsc_rh, TRUE); - - } else if(rsc_rh->provisional) { - - } else if(color_rh->details == NULL) { - CRM_ASSERT(FALSE); /* This is never true but it keeps BEAM happy */ - - } else if(color_rh && color_rh->details->pending) { - node_t *node_rh = NULL; - node_rh = pe_find_node_id( - color_rh->details->candidate_nodes, - safe_val5(NULL, color_lh, details, - chosen_node, details, id)); - - if(node_rh != NULL) { - node_rh->weight = -INFINITY; - - crm_debug_2("RH: Removed node %s from color %d", - node_rh->details->uname, color_rh->id); - - crm_action_debug_3( - print_node("Removed RH", node_rh, FALSE)); - - crm_action_debug_3( - print_color("Modified RH", color_rh, FALSE)); - } - - } else { - /* error, rsc marked as unrunnable above */ - pe_warn("rh else"); - } - } -} - - void native_agent_constraints(resource_t *rsc) { } -gboolean -native_choose_color(resource_t *rsc, color_t *no_color) -{ - GListPtr sorted_colors = NULL; - if(rsc->runnable == FALSE) { - native_assign_color(rsc, no_color); - } - - if(rsc->provisional == FALSE) { - return !rsc->provisional; - } - - sorted_colors = g_list_sort( - rsc->candidate_colors, sort_color_weight); - - rsc->candidate_colors = sorted_colors; - - crm_debug_2("Choose a color from %d possibilities", - g_list_length(sorted_colors)); - - slist_iter( - this_color, color_t, rsc->candidate_colors, lpc, - GListPtr intersection = NULL; - GListPtr minus = NULL; - int len = 0; - - if(this_color == NULL) { - pe_err("color was NULL"); - continue; - - } else if(this_color->local_weight < 0) { - /* no valid color available */ - crm_debug("no valid color available"); - break; - - } else if(rsc->effective_priority - < this_color->details->highest_priority) { - - minus = node_list_minus( - this_color->details->candidate_nodes, - rsc->allowed_nodes, TRUE); - - len = g_list_length(minus); - pe_free_shallow(minus); - - } else { - intersection = node_list_and( - this_color->details->candidate_nodes, - rsc->allowed_nodes, TRUE); - - len = g_list_length(intersection); - pe_free_shallow(intersection); - - } - if(len > 0) { - crm_debug("Assigning color to %s", rsc->id); - native_assign_color(rsc, this_color); - break; - } - ); - - return !rsc->provisional; -} - - -void -native_assign_color(resource_t *rsc, color_t *color) -{ - color_t *local_color = NULL; - - rsc->provisional = FALSE; - - if(rsc->color != NULL) { - /* TODO: check its a clone */ - CRM_CHECK(color->id != rsc->color->id, return); - rsc->color->details->allocated_resources = - g_list_remove(rsc->color->details->allocated_resources, rsc); - (rsc->color->details->num_resources)--; - rsc->candidate_colors = - g_list_remove(rsc->candidate_colors, rsc->color); - crm_free(rsc->color); - rsc->color = NULL; - } - - local_color = add_color(rsc, color); - CRM_CHECK(local_color != NULL, return); - - local_color->details->allocated_resources = - g_list_append(local_color->details->allocated_resources,rsc); - - if(rsc->variant == pe_native) { - GListPtr old_list = NULL; - GListPtr intersection = NULL; - - (local_color->details->num_resources)++; - rsc->color = copy_color(local_color); - crm_debug_3("Created intersection for color %d", - local_color->id); - intersection = node_list_and( - local_color->details->candidate_nodes, - rsc->allowed_nodes, FALSE); - old_list = local_color->details->candidate_nodes; - - pe_free_shallow(old_list); - - local_color->details->candidate_nodes = intersection; - } - - crm_debug_2("Colored resource %s with color %d", - rsc->id, local_color->id); - - return; -} - -void -native_update_node_weight(resource_t *rsc, rsc_to_node_t *cons, - node_t *cons_node, GListPtr nodes) -{ - node_t *node_rh = NULL; - CRM_CHECK(cons_node != NULL, return); - - node_rh = pe_find_node_id( - rsc->allowed_nodes, cons_node->details->id); - - if(node_rh == NULL) { - pe_err("Node not found - adding %s to %s", - cons_node->details->id, rsc->id); - node_rh = node_copy(cons_node); - rsc->allowed_nodes = g_list_append( - rsc->allowed_nodes, node_rh); - - node_rh = pe_find_node_id( - rsc->allowed_nodes, cons_node->details->id); - - CRM_CHECK(node_rh != NULL, return); - return; - } - - CRM_CHECK(node_rh != NULL, return); - - if(node_rh == NULL) { - pe_err("Node not found - cant update"); - return; - } - - if(node_rh->weight >= INFINITY && cons_node->weight <= -INFINITY) { - pe_err("Constraint \"%s\" mixes +/- INFINITY (%s)", - cons->id, rsc->id); - - } else if(node_rh->details->shutdown == TRUE - || node_rh->details->online == FALSE - || node_rh->details->unclean == TRUE) { - - } else if(node_rh->weight <= -INFINITY && cons_node->weight >= INFINITY) { - pe_err("Constraint \"%s\" mixes +/- INFINITY (%s)", - cons->id, rsc->id); - } - - if(node_rh->fixed) { - /* warning */ - crm_debug_2("Constraint %s is irrelevant as the" - " weight of node %s is fixed as %d (%s).", - cons->id, node_rh->details->uname, - node_rh->weight, rsc->id); - return; - } - - crm_debug_3("Constraint %s, node %s, rsc %s: %d + %d", - cons->id, node_rh->details->uname, rsc->id, - node_rh->weight, cons_node->weight); - node_rh->weight = merge_weights(node_rh->weight, cons_node->weight); - if(node_rh->weight <= -INFINITY) { - crm_debug_3("Constraint %s (-INFINITY): node %s weight %d (%s).", - cons->id, node_rh->details->uname, - node_rh->weight, rsc->id); - - } else if(node_rh->weight >= INFINITY) { - crm_debug_3("Constraint %s (+INFINITY): node %s weight %d (%s).", - cons->id, node_rh->details->uname, - node_rh->weight, rsc->id); - - } else { - crm_debug_3("Constraint %s (%d): node %s weight %d (%s).", - cons->id, cons_node->weight, node_rh->details->uname, - node_rh->weight, rsc->id); - } - - if(node_rh->weight < 0) { - node_rh->fixed = TRUE; - } - - crm_action_debug_3(print_node("Updated", node_rh, FALSE)); - - return; -} - -gboolean -native_constraint_violated( - resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint) -{ - GListPtr result = NULL; - color_t *color_lh = NULL; - color_t *color_rh = NULL; - - GListPtr candidate_nodes_lh = NULL; - GListPtr candidate_nodes_rh = NULL; - gboolean matched = FALSE; - - color_lh = rsc_lh->color; - color_rh = rsc_rh->color; - - if(constraint->strength == pecs_must_not) { - matched = TRUE; - } - - if(rsc_lh->provisional || rsc_rh->provisional) { - return FALSE; - } - - if(color_lh == NULL && color_rh == NULL) { - return matched; - - } else if(color_lh == NULL || color_rh == NULL) { - return !matched; - - } else if(color_lh->details->pending - && color_rh->details->pending) { - candidate_nodes_lh = color_lh->details->candidate_nodes; - candidate_nodes_rh = color_rh->details->candidate_nodes; - - } else if(color_lh->details->pending == FALSE - && color_rh->details->pending == FALSE) { - - if(color_lh->details->chosen_node == NULL - && color_rh->details->chosen_node == NULL) { - return matched; - - } else if(color_lh->details->chosen_node == NULL - || color_rh->details->chosen_node == NULL) { - return !matched; - - } else if(safe_str_eq( - color_lh->details->chosen_node->details->id, - color_rh->details->chosen_node->details->id)) { - return matched; - } - return !matched; - - } else if(color_lh->details->pending) { - candidate_nodes_lh = color_lh->details->candidate_nodes; - candidate_nodes_rh = g_list_append( - NULL, color_rh->details->chosen_node); - - } else if(color_rh->details->pending) { - candidate_nodes_rh = color_rh->details->candidate_nodes; - candidate_nodes_lh = g_list_append( - NULL, color_lh->details->chosen_node); - } - - result = node_list_and(candidate_nodes_lh, candidate_nodes_rh, TRUE); - - if(g_list_length(result) == 0 && constraint->strength == pecs_must) { - /* free result */ - return TRUE; - } - return FALSE; -} /* * Remove any nodes with a -ve weight */ void filter_nodes(resource_t *rsc) { print_resource(LOG_DEBUG_3, "Filtering nodes for: ", rsc, FALSE); slist_iter( node, node_t, rsc->allowed_nodes, lpc, if(node == NULL) { pe_err("Invalid NULL node"); } else if(node->weight < 0.0 || node->details->shutdown || node->details->online == FALSE || node->details->type == node_ping) { crm_action_debug_3(print_node("Removing", node, FALSE)); rsc->allowed_nodes = g_list_remove(rsc->allowed_nodes, node); crm_free(node); lpc = -1; /* restart the loop */ } ); } void create_notifications(resource_t *rsc, pe_working_set_t *data_set) { if(rsc->notify == FALSE) { return; } /* slist_iter( */ /* action, action_t, rsc->actions, lpc, */ /* ); */ } static void register_activity(resource_t *rsc, enum action_tasks task, node_t *node, notify_data_t *n_data) { notify_entry_t *entry = NULL; crm_malloc0(entry, sizeof(notify_entry_t)); entry->rsc = rsc; entry->node = node; switch(task) { case start_rsc: n_data->start = g_list_append(n_data->start, entry); break; case stop_rsc: n_data->stop = g_list_append(n_data->stop, entry); break; case action_promote: n_data->promote = g_list_append(n_data->promote, entry); break; case action_demote: n_data->demote = g_list_append(n_data->demote, entry); break; default: crm_err("Unsupported notify action: %s", task2text(task)); break; } } static void register_state(resource_t *rsc, node_t *on_node, notify_data_t *n_data) { notify_entry_t *entry = NULL; crm_malloc0(entry, sizeof(notify_entry_t)); entry->rsc = rsc; entry->node = on_node; crm_debug_2("%s state: %s", rsc->id, role2text(rsc->next_role)); switch(rsc->next_role) { case RSC_ROLE_STOPPED: /* n_data->inactive = g_list_append(n_data->inactive, entry); */ crm_free(entry); break; case RSC_ROLE_STARTED: n_data->active = g_list_append(n_data->active, entry); break; case RSC_ROLE_SLAVE: n_data->slave = g_list_append(n_data->slave, entry); break; case RSC_ROLE_MASTER: n_data->master = g_list_append(n_data->master, entry); break; default: crm_err("Unsupported notify role"); break; } } void native_create_notify_element(resource_t *rsc, action_t *op, notify_data_t *n_data, pe_working_set_t *data_set) { node_t *next_node = NULL; gboolean registered = FALSE; char *op_key = NULL; GListPtr possible_matches = NULL; enum action_tasks task = text2task(op->task); if(op->pre_notify == NULL || op->post_notify == NULL) { /* no notifications required */ crm_debug_4("No notificaitons required for %s", op->task); return; } - if(rsc->color != NULL) { - next_node = rsc->color->details->chosen_node; - } - + next_node = rsc->allocated_to; op_key = generate_op_key(rsc->id, op->task, 0); possible_matches = find_actions(rsc->actions, op_key, NULL); crm_debug_2("Creating notificaitons for: %s (%s->%s)", op->uuid, role2text(rsc->role), role2text(rsc->next_role)); if(rsc->role == rsc->next_role) { register_state(rsc, next_node, n_data); } slist_iter( local_op, action_t, possible_matches, lpc, local_op->notify_keys = n_data->keys; if(local_op->optional == FALSE) { registered = TRUE; register_activity(rsc, task, local_op->node, n_data); } ); /* 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_pre_notify(rsc, current_node, op, n_data, data_set); if(task == action_demote || registered == FALSE) { pe_post_notify(rsc, current_node, op, n_data, data_set); } ); } } /* start / promote */ if(rsc->next_role != RSC_ROLE_STOPPED) { CRM_CHECK(next_node != NULL,;); if(next_node == NULL) { pe_proc_err("next role: %s", role2text(rsc->next_role)); } else if(task == start_rsc || task == action_promote) { if(task != start_rsc || registered == FALSE) { pe_pre_notify(rsc, next_node, op, n_data, data_set); } pe_post_notify(rsc, next_node, op, n_data, data_set); } } crm_free(op_key); pe_free_shallow_adv(possible_matches, FALSE); } static void dup_attr(gpointer key, gpointer value, gpointer user_data) { char *meta_key = crm_concat(CRM_META, key, '_'); g_hash_table_replace(user_data, meta_key, crm_strdup(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_info("Skipping notification for %s", rsc->id); return NULL; } value = g_hash_table_lookup(op->meta, "notify_type"); task = g_hash_table_lookup(op->meta, "notify_operation"); crm_debug_2("Creating 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, op->optional, TRUE, data_set); g_hash_table_foreach(op->meta, dup_attr, trigger->extra); trigger->notify_keys = n_data->keys; /* 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_ordering_manditory); value = g_hash_table_lookup(op->meta, "notify_confirm"); if(crm_is_true(value)) { /* notify before pseudo_notified */ crm_debug_3("Ordering %s before %s (%d->%d)", trigger->uuid, confirm->uuid, confirm->id, trigger->id); order_actions(trigger, confirm, pe_ordering_manditory); } return trigger; } void pe_pre_notify(resource_t *rsc, node_t *node, action_t *op, notify_data_t *n_data, pe_working_set_t *data_set) { crm_debug_2("%s: %s", rsc->id, op->uuid); pe_notify(rsc, node, op->pre_notify, op->pre_notified, n_data, 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) { action_t *notify = NULL; CRM_CHECK(op != NULL, return); CRM_CHECK(rsc != NULL, return); crm_debug_2("%s: %s", rsc->id, op->uuid); notify = pe_notify(rsc, node, op->post_notify, op->post_notified, n_data, data_set); if(notify != NULL) { notify->priority = INFINITY; } notify = op->post_notified; if(notify != NULL) { notify->priority = INFINITY; 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(notify, mon, pe_ordering_optional); ); } } void NoRoleChange(resource_t *rsc, node_t *current, node_t *next, pe_working_set_t *data_set) { action_t *start = NULL; action_t *stop = NULL; GListPtr possible_matches = NULL; crm_debug("Executing: %s (role=%s)",rsc->id, role2text(rsc->next_role)); if(current == NULL || next == NULL) { return; } /* use StartRsc/StopRsc */ if(safe_str_neq(current->details->id, next->details->id)) { crm_notice("Move resource %s\t(%s -> %s)", rsc->id, current->details->uname, next->details->uname); stop = stop_action(rsc, current, FALSE); start = start_action(rsc, next, FALSE); possible_matches = find_recurring_actions(rsc->actions, next); slist_iter(match, action_t, possible_matches, lpc, if(match->optional == FALSE) { crm_err("Found bad recurring action: %s", match->uuid); match->optional = TRUE; } ); if(data_set->remove_after_stop) { DeleteRsc(rsc, current, data_set); } } else { if(rsc->failed) { crm_notice("Recover resource %s\t(%s)", rsc->id, next->details->uname); stop = stop_action(rsc, current, FALSE); start = start_action(rsc, next, FALSE); /* /\* make the restart required *\/ */ /* order_stop_start(rsc, rsc, pe_ordering_manditory); */ } else if(rsc->start_pending) { start = start_action(rsc, next, TRUE); if(start->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); stop->optional = start->optional; if(start->runnable == FALSE) { rsc->next_role = RSC_ROLE_STOPPED; } else if(start->optional) { crm_notice("Leave resource %s\t(%s)", rsc->id, next->details->uname); } else { crm_notice("Restart resource %s\t(%s)", rsc->id, next->details->uname); } } } } gboolean StopRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set) { action_t *stop = NULL; crm_debug_2("Executing: %s", rsc->id); slist_iter( current, node_t, rsc->running_on, lpc, crm_notice(" %s\tStop %s", current->details->uname, rsc->id); stop = stop_action(rsc, current, FALSE); if(data_set->remove_after_stop) { DeleteRsc(rsc, current, data_set); } ); return TRUE; } gboolean StartRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set) { action_t *start = NULL; crm_debug_2("Executing: %s", rsc->id); start = start_action(rsc, next, TRUE); if(start->runnable) { crm_notice(" %s\tStart %s", next->details->uname, rsc->id); start->optional = FALSE; } return TRUE; } gboolean PromoteRsc(resource_t *rsc, node_t *next, 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, 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(start->runnable == FALSE) { runnable = FALSE; } ); if(runnable) { promote_action(rsc, next, FALSE); crm_notice("%s\tPromote %s", next->details->uname, rsc->id); 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, promote->runnable = FALSE; ); return TRUE; } gboolean DemoteRsc(resource_t *rsc, node_t *next, 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, crm_notice("%s\tDeomote %s", current->details->uname, rsc->id); demote_action(rsc, current, FALSE); ); return TRUE; } gboolean RoleError(resource_t *rsc, node_t *next, 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, pe_working_set_t *data_set) { crm_debug("Executing: %s", rsc->id); return FALSE; } gboolean native_create_probe(resource_t *rsc, node_t *node, action_t *complete, gboolean force, pe_working_set_t *data_set) { char *key = NULL; char *target_rc = NULL; action_t *probe = NULL; node_t *running = NULL; CRM_CHECK(node != NULL, return FALSE); if(rsc->orphan) { crm_debug_2("Skipping orphan: %s", rsc->id); return FALSE; } running = pe_find_node_id(rsc->known_on, node->details->id); 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, CRMD_ACTION_STATUS, 0); probe = custom_action(rsc, key, CRMD_ACTION_STATUS, node, FALSE, TRUE, data_set); probe->priority = INFINITY; running = pe_find_node_id(rsc->running_on, node->details->id); if(running == NULL) { target_rc = crm_itoa(EXECRA_NOT_RUNNING); add_hash_param(probe->meta, XML_ATTR_TE_TARGET_RC, target_rc); crm_free(target_rc); } crm_notice("%s: Created probe for %s", node->details->uname, rsc->id); custom_action_order(rsc, NULL, probe, rsc, NULL, complete, pe_ordering_manditory, data_set); return TRUE; } static void native_start_constraints( resource_t *rsc, action_t *stonith_op, gboolean is_stonith, pe_working_set_t *data_set) { gboolean is_unprotected = FALSE; gboolean run_unprotected = TRUE; if(is_stonith) { char *key = start_key(rsc); crm_debug_2("Ordering %s action before stonith events", key); custom_action_order( rsc, key, NULL, NULL, crm_strdup(CRM_OP_FENCE), stonith_op, pe_ordering_optional, data_set); } else { slist_iter(action, action_t, rsc->actions, lpc2, if(action->needs != rsc_req_stonith) { crm_debug_3("%s doesnt need to wait for stonith events", action->uuid); continue; } crm_debug_2("Ordering %s after stonith events", action->uuid); if(stonith_op != NULL) { custom_action_order( NULL, crm_strdup(CRM_OP_FENCE), stonith_op, rsc, NULL, action, pe_ordering_manditory, data_set); } else if(run_unprotected == FALSE) { /* mark the start unrunnable */ action->runnable = FALSE; } else { is_unprotected = TRUE; } ); } if(is_unprotected) { pe_err("SHARED RESOURCE %s IS NOT PROTECTED:" " Stonith disabled", rsc->id); } } 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; node_t *node = stonith_op->node; key = stop_key(rsc); action_list = find_actions(rsc->actions, key, 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(node->details->online == FALSE || rsc->failed) { resource_t *parent = NULL; crm_warn("Stop of failed resource %s is" " implict after %s is fenced", rsc->id, node->details->uname); /* the stop would never complete and is * now implied by the stonith operation */ action->pseudo = TRUE; action->runnable = TRUE; if(is_stonith) { /* do nothing */ } else { custom_action_order( NULL, crm_strdup(CRM_OP_FENCE),stonith_op, rsc, start_key(rsc), NULL, pe_ordering_manditory, data_set); } /* find the top-most resource */ parent = rsc->parent; while(parent != NULL && parent->parent != NULL) { parent = parent->parent; } if(parent) { crm_info("Re-creating actions for %s", parent->id); parent->cmds->create_actions(parent, data_set); } } 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_ordering_manditory, data_set); } ); key = demote_key(rsc); action_list = find_actions(rsc->actions, key, node); crm_free(key); slist_iter( action, action_t, action_list, lpc2, if(node->details->online == FALSE || rsc->failed) { crm_info("Demote of failed resource %s is" " implict after %s is fenced", rsc->id, node->details->uname); /* the stop would never complete and is * now implied by the stonith operation */ action->pseudo = TRUE; action->runnable = TRUE; if(is_stonith == FALSE) { custom_action_order( NULL, crm_strdup(CRM_OP_FENCE), stonith_op, rsc, demote_key(rsc), NULL, pe_ordering_manditory, data_set); } } ); } void native_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->is_managed == FALSE) { 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); - } + diff --git a/crm/pengine/pengine.h b/crm/pengine/pengine.h index 4bc251e875..59821d6dc8 100644 --- a/crm/pengine/pengine.h +++ b/crm/pengine/pengine.h @@ -1,180 +1,151 @@ /* $Id: pengine.h,v 1.115 2006/06/09 06:42:16 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef PENGINE__H #define PENGINE__H #include typedef struct rsc_to_node_s rsc_to_node_t; typedef struct rsc_colocation_s rsc_colocation_t; typedef struct lrm_agent_s lrm_agent_t; typedef struct order_constraint_s order_constraint_t; #include #include #include #include #include #include #include #include #include -enum con_strength { - pecs_ignore, - pecs_must, - pecs_must_not, - pecs_startstop -}; - - enum pe_stop_fail { pesf_block, pesf_stonith, pesf_ignore }; -struct color_shared_s { - int id; - int highest_priority; - GListPtr candidate_nodes; /* node_t* */ - GListPtr allocated_resources; /* resources_t* */ - node_t *chosen_node; - gboolean pending; - int num_resources; -}; - -struct color_s { - int id; - struct color_shared_s *details; - int local_weight; -}; - struct rsc_colocation_s { const char *id; resource_t *rsc_lh; resource_t *rsc_rh; const char *state_lh; const char *state_rh; - enum con_strength strength; + int score; }; struct rsc_to_node_s { const char *id; resource_t *rsc_lh; enum rsc_role_e role_filter; GListPtr node_list_rh; /* node_t* */ }; struct order_constraint_s { int id; enum pe_ordering type; void *lh_opaque; resource_t *lh_rsc; action_t *lh_action; char *lh_action_task; void *rh_opaque; resource_t *rh_rsc; action_t *rh_action; char *rh_action_task; /* (soon to be) variant specific */ /* int lh_rsc_incarnation; */ /* int rh_rsc_incarnation; */ }; extern gboolean stage0(pe_working_set_t *data_set); extern gboolean stage1(pe_working_set_t *data_set); extern gboolean stage2(pe_working_set_t *data_set); extern gboolean stage3(pe_working_set_t *data_set); extern gboolean stage4(pe_working_set_t *data_set); extern gboolean stage5(pe_working_set_t *data_set); extern gboolean stage6(pe_working_set_t *data_set); extern gboolean stage7(pe_working_set_t *data_set); extern gboolean stage8(pe_working_set_t *data_set); extern gboolean summary(GListPtr resources); extern gboolean pe_msg_dispatch(IPC_Channel *sender, void *user_data); extern gboolean process_pe_message( HA_Message *msg, crm_data_t *xml_data, IPC_Channel *sender); extern gboolean unpack_constraints( crm_data_t *xml_constraints, pe_working_set_t *data_set); -extern gboolean apply_placement_constraints(pe_working_set_t *data_set); - -extern gboolean choose_node_from_list(color_t *color); - extern gboolean update_action_states(GListPtr actions); extern gboolean shutdown_constraints( node_t *node, action_t *shutdown_op, pe_working_set_t *data_set); extern gboolean stonith_constraints( node_t *node, action_t *stonith_op, pe_working_set_t *data_set); extern gboolean custom_action_order( resource_t *lh_rsc, char *lh_task, action_t *lh_action, resource_t *rh_rsc, char *rh_task, action_t *rh_action, enum pe_ordering type, pe_working_set_t *data_set); #define order_start_start(rsc1,rsc2, type) \ custom_action_order(rsc1, start_key(rsc1), NULL, \ rsc2, start_key(rsc2) ,NULL, \ type, data_set) #define order_stop_stop(rsc1, rsc2, type) \ custom_action_order(rsc1, stop_key(rsc1), NULL, \ rsc2, stop_key(rsc2) ,NULL, \ type, data_set) #define order_restart(rsc1) \ custom_action_order(rsc1, stop_key(rsc1), NULL, \ rsc1, start_key(rsc1), NULL, \ pe_ordering_restart, data_set) #define order_stop_start(rsc1, rsc2, type) \ custom_action_order(rsc1, stop_key(rsc1), NULL, \ rsc2, start_key(rsc2) ,NULL, \ type, data_set) #define order_start_stop(rsc1, rsc2, type) \ custom_action_order(rsc1, start_key(rsc1), NULL, \ rsc2, stop_key(rsc2) ,NULL, \ type, data_set) -extern gboolean process_colored_constraints(resource_t *rsc); extern void graph_element_from_action( action_t *action, pe_working_set_t *data_set); extern const char* transition_idle_timeout; #endif diff --git a/crm/pengine/ptest.c b/crm/pengine/ptest.c index 8d21c82939..76b3ca8aaf 100644 --- a/crm/pengine/ptest.c +++ b/crm/pengine/ptest.c @@ -1,447 +1,446 @@ /* $Id: ptest.c,v 1.80 2006/07/18 06:15:54 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include #include #include #include #define OPTARGS "V?X:D:G:I:Lwxd:a" #ifdef HAVE_GETOPT_H # include #endif #include #include #include #include gboolean use_stdin = FALSE; gboolean inhibit_exit = FALSE; gboolean all_actions = FALSE; extern crm_data_t * do_calculations( pe_working_set_t *data_set, crm_data_t *xml_input, ha_time_t *now); extern void cleanup_calculations(pe_working_set_t *data_set); char *use_date = NULL; FILE *dot_strm = NULL; #define DOT_PREFIX "PE_DOT: " /* #define DOT_PREFIX "" */ #define dot_write(fmt...) if(dot_strm != NULL) { \ fprintf(dot_strm, fmt); \ fprintf(dot_strm, "\n"); \ fflush(dot_strm); \ } else { \ crm_debug(DOT_PREFIX""fmt); \ } static void init_dotfile(void) { dot_write("digraph \"g\" {"); dot_write(" size = \"30,30\""); /* dot_write(" graph ["); */ /* dot_write(" fontsize = \"12\""); */ /* dot_write(" fontname = \"Times-Roman\""); */ /* dot_write(" fontcolor = \"black\""); */ /* dot_write(" bb = \"0,0,398.922306,478.927856\""); */ /* dot_write(" color = \"black\""); */ /* dot_write(" ]"); */ /* dot_write(" node ["); */ /* dot_write(" fontsize = \"12\""); */ /* dot_write(" fontname = \"Times-Roman\""); */ /* dot_write(" fontcolor = \"black\""); */ /* dot_write(" shape = \"ellipse\""); */ /* dot_write(" color = \"black\""); */ /* dot_write(" ]"); */ /* dot_write(" edge ["); */ /* dot_write(" fontsize = \"12\""); */ /* dot_write(" fontname = \"Times-Roman\""); */ /* dot_write(" fontcolor = \"black\""); */ /* dot_write(" color = \"black\""); */ /* dot_write(" ]"); */ } static void usage(const char *cli, int exitcode) { FILE *out = exitcode?stderr:stdout; fprintf(out, "Usage: %s -(?|L|X|x) [-V] [-D] [-G] [-I]\n", cli); fprintf(out, " --%s (-%c): This text\n\n", "help", '?'); fprintf(out, " --%s (-%c): Increase verbosity (can be supplied multiple times)\n\n", "verbose", 'V'); fprintf(out, " --%s (-%c): Connect to the CIB and use the current contents as input\n", "live-check", 'L'); fprintf(out, " --%s (-%c): Look for xml on stdin\n", "xml-stream", 'x'); fprintf(out, " --%s (-%c)\t : Look for xml in the named file\n\n", "xml-file", 'X'); fprintf(out, " --%s (-%c)\t : Save the transition graph to the named file\n", "save-graph", 'G'); fprintf(out, " --%s (-%c)\t : Save the DOT formatted transition graph to the named file\n", "save-dotfile", 'D'); fprintf(out, " --%s (-%c)\t : Save the input to the named file\n", "save-input", 'I'); exit(exitcode); } static char * create_action_name(action_t *action) { char *action_name = NULL; const char *action_host = NULL; if(action->node) { action_host = action->node->details->uname; action_name = crm_concat(action->uuid, action_host, ' '); } else if(action->pseudo) { action_name = crm_strdup(action->uuid); } else { action_host = ""; action_name = crm_concat(action->uuid, action_host, ' '); } return action_name; } gboolean USE_LIVE_CIB = FALSE; int main(int argc, char **argv) { gboolean all_good = TRUE; enum transition_status graph_rc = -1; crm_graph_t *transition = NULL; ha_time_t *a_date = NULL; cib_t * cib_conn = NULL; crm_data_t * cib_object = NULL; int argerr = 0; int flag; char *msg_buffer = NULL; gboolean optional = FALSE; pe_working_set_t data_set; const char *xml_file = NULL; const char *dot_file = NULL; const char *graph_file = NULL; const char *input_file = NULL; cl_log_set_entity("ptest"); cl_log_set_facility(LOG_USER); set_crm_log_level(LOG_CRIT-1); while (1) { #ifdef HAVE_GETOPT_H int option_index = 0; static struct option long_options[] = { /* Top-level Options */ {"help", 0, 0, '?'}, {"verbose", 0, 0, 'V'}, {"live-check", 0, 0, 'L'}, {"xml-stream", 0, 0, 'x'}, {"xml-file", 1, 0, 'X'}, {"save-graph", 1, 0, 'G'}, {"save-dotfile",1, 0, 'D'}, {"save-input", 1, 0, 'I'}, {0, 0, 0, 0} }; #endif #ifdef HAVE_GETOPT_H flag = getopt_long(argc, argv, OPTARGS, long_options, &option_index); #else flag = getopt(argc, argv, OPTARGS); #endif if (flag == -1) break; switch(flag) { #ifdef HAVE_GETOPT_H case 0: printf("option %s", long_options[option_index].name); if (optarg) printf(" with arg %s", optarg); printf("\n"); break; #endif case 'a': all_actions = TRUE; break; case 'w': inhibit_exit = TRUE; break; case 'x': use_stdin = TRUE; break; case 'X': xml_file = crm_strdup(optarg); break; case 'd': use_date = crm_strdup(optarg); break; case 'D': dot_file = crm_strdup(optarg); break; case 'G': graph_file = crm_strdup(optarg); break; case 'I': input_file = crm_strdup(optarg); break; case 'V': cl_log_enable_stderr(TRUE); alter_debug(DEBUG_INC); break; case 'L': USE_LIVE_CIB = TRUE; break; case '?': usage("ptest", 0); break; default: printf("?? getopt returned character code 0%o ??\n", flag); ++argerr; break; } } if (optind < argc) { printf("non-option ARGV-elements: "); while (optind < argc) { printf("%s ", argv[optind++]); } printf("\n"); } if (optind > argc) { ++argerr; } if (argerr) { crm_err("%d errors in option parsing", argerr); usage("ptest", 1); } crm_info("=#=#=#=#= Getting XML =#=#=#=#="); if(USE_LIVE_CIB) { int rc = cib_ok; cib_conn = cib_new(); rc = cib_conn->cmds->signon( cib_conn, "ptest", cib_command_synchronous); if(rc == cib_ok) { crm_info("Reading XML from: live cluster"); cib_object = get_cib_copy(cib_conn); } else { fprintf(stderr, "Live CIB query failed: %s\n", cib_error2string(rc)); return 3; } if(cib_object == NULL) { fprintf(stderr, "Live CIB query failed: empty result\n"); return 3; } } else if(xml_file != NULL) { FILE *xml_strm = fopen(xml_file, "r"); if(strstr(xml_file, ".bz2") != NULL) { cib_object = file2xml(xml_strm, TRUE); } else { cib_object = file2xml(xml_strm, FALSE); } } else if(use_stdin) { cib_object = stdin2xml(); } else { usage("ptest", 1); } #ifdef MCHECK mtrace(); #endif CRM_CHECK(cib_object != NULL, return 4); crm_notice("Required feature set: %s", feature_set(cib_object)); do_id_check(cib_object, NULL, FALSE, FALSE); if(!validate_with_dtd(cib_object,FALSE,HA_LIBDIR"/heartbeat/crm.dtd")) { crm_crit("%s is not a valid configuration", xml_file?xml_file:"stding"); all_good = FALSE; } if(input_file != NULL) { FILE *input_strm = fopen(input_file, "w"); msg_buffer = dump_xml_formatted(cib_object); fprintf(input_strm, "%s\n", msg_buffer); fflush(input_strm); fclose(input_strm); crm_free(msg_buffer); } crm_zero_mem_stats(NULL); #ifdef HA_MALLOC_TRACK cl_malloc_dump_allocated(LOG_DEBUG_2, TRUE); #endif if(use_date != NULL) { a_date = parse_date(&use_date); log_date(LOG_WARNING, "Set fake 'now' to", a_date, ha_log_date|ha_log_time); log_date(LOG_WARNING, "Set fake 'now' to (localtime)", a_date, ha_log_date|ha_log_time|ha_log_local); } do_calculations(&data_set, cib_object, a_date); msg_buffer = dump_xml_formatted(data_set.graph); if(graph_file != NULL) { FILE *graph_strm = fopen(graph_file, "w"); fprintf(graph_strm, "%s\n", msg_buffer); fflush(graph_strm); fclose(graph_strm); } else { fprintf(stdout, "%s\n", msg_buffer); fflush(stdout); } crm_free(msg_buffer); dot_strm = fopen(dot_file, "w"); init_dotfile(); slist_iter( action, action_t, data_set.actions, lpc, char *action_name = create_action_name(action); crm_debug_3("Action %d: %p", action->id, action); if(action->dumped == FALSE) { if(action->rsc != NULL && action->rsc->is_managed == FALSE) { dot_write("\"%s\" [ font_color=black style=filled fillcolor=%s ]", action_name, "purple"); } else if(action->optional) { if(all_actions) { dot_write("\"%s\" [ style=\"dashed\" color=\"%s\" fontcolor=\"%s\" ]", action_name, "blue", action->pseudo?"orange":"black"); } } else { dot_write("\"%s\" [ font_color=purple style=filled fillcolor=%s ]", action_name, "red"); CRM_CHECK(action->runnable == FALSE, ;); } } else { dot_write("\"%s\" [ style=bold color=\"%s\" fontcolor=\"%s\" ]", action_name, "green", action->pseudo?"orange":"black"); } crm_free(action_name); ); slist_iter( action, action_t, data_set.actions, lpc, int last_action = -1; slist_iter( before, action_wrapper_t, action->actions_before, lpc2, char *before_name = NULL; char *after_name = NULL; optional = FALSE; if(last_action == before->action->id) { continue; } last_action = before->action->id; if(action->dumped && before->action->dumped) { } else if(action->optional || before->action->optional) { optional = TRUE; } before_name = create_action_name(before->action); after_name = create_action_name(action); if(all_actions || optional == FALSE) { dot_write("\"%s\" -> \"%s\" [ style = %s]", before_name, after_name, optional?"dashed":"bold"); } crm_free(before_name); crm_free(after_name); ); ); dot_write("}"); transition = unpack_graph(data_set.graph); print_graph(LOG_NOTICE, transition); do { graph_rc = run_graph(transition); } while(graph_rc == transition_active); if(graph_rc != transition_complete) { crm_crit("Transition failed: %s", transition_status(graph_rc)); print_graph(LOG_ERR, transition); } - data_set.input = NULL; cleanup_alloc_calculations(&data_set); destroy_graph(transition); crm_mem_stats(NULL); #ifdef HA_MALLOC_TRACK cl_malloc_dump_allocated(LOG_ERR, TRUE); #endif CRM_CHECK(crm_mem_stats(NULL) == FALSE, all_good = FALSE; crm_err("Memory leak detected")); CRM_CHECK(graph_rc == transition_complete, all_good = FALSE; crm_err("An invalid transition was produced")); crm_free(cib_object); #ifdef MCHECK muntrace(); #endif /* required for MallocDebug.app */ if(inhibit_exit) { GMainLoop* mainloop = g_main_new(FALSE); g_main_run(mainloop); } if(all_good) { return 0; } return 5; } diff --git a/crm/pengine/regression.sh b/crm/pengine/regression.sh index ef713a6099..dca364cdf1 100755 --- a/crm/pengine/regression.sh +++ b/crm/pengine/regression.sh @@ -1,222 +1,220 @@ #!/bin/bash # Copyright (C) 2004 Andrew Beekhof # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This software is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # . regression.core.sh create_mode="true" echo Generating test outputs for these tests... echo "" echo Done. echo "" echo Performing the following tests... create_mode="false" echo "" do_test simple1 "Offline " do_test simple2 "Start " do_test simple3 "Start 2 " do_test simple4 "Start Failed" do_test simple6 "Stop Start " do_test simple7 "Shutdown " #do_test simple8 "Stonith " #do_test simple9 "Lower version" #do_test simple10 "Higher version" do_test simple11 "Priority (ne)" do_test simple12 "Priority (eq)" do_test simple8 "Stickiness" echo "" do_test params-0 "Params: No change" do_test params-1 "Params: Changed" do_test params-2 "Params: Resource definition" echo "" do_test orphan-0 "Orphan ignore" do_test orphan-1 "Orphan stop" echo "" do_test target-0 "Target Role : baseline" do_test target-1 "Target Role : test" echo "" do_test date-1 "Dates" -d "2005-020" do_test probe-0 "Probe (anon clone)" do_test probe-1 "Pending Probe" do_test standby "Standby" do_test comments "Comments" -echo "" -do_test master-0 "Stopped -> Slave" -do_test master-1 "Stopped -> Promote" -do_test master-2 "Stopped -> Promote : notify" -do_test master-3 "Stopped -> Promote : master location" -do_test master-4 "Started -> Promote : master location" -do_test master-5 "Promoted -> Promoted" -do_test master-6 "Promoted -> Promoted (2)" -do_test master-7 "Promoted -> Fenced" -do_test master-8 "Promoted -> Fenced -> Moved" -do_test master-9 "Stopped + Promotable + No quorum" -do_test master-10 "Stopped -> Promotable : notify with monitor" - echo "" do_test rsc_dep1 "Must not " do_test rsc_dep3 "Must " do_test rsc_dep5 "Must not 3 " do_test rsc_dep7 "Must 3 " do_test rsc_dep10 "Must (but cant)" do_test rsc_dep2 "Must (running) " do_test rsc_dep8 "Must (running : alt) " do_test rsc_dep4 "Must (running + move)" echo "" do_test order1 "Order start 1 " do_test order2 "Order start 2 " do_test order3 "Order stop " do_test order4 "Order (multiple) " do_test order5 "Order (move) " do_test order6 "Order (move w/ restart) " do_test order7 "Order (manditory) " #echo "" #do_test agent1 "version: lt (empty)" #do_test agent2 "version: eq " #do_test agent3 "version: gt " echo "" do_test attrs1 "string: eq (and) " do_test attrs2 "string: lt / gt (and)" do_test attrs3 "string: ne (or) " do_test attrs4 "string: exists " do_test attrs5 "string: not_exists " do_test attrs6 "is_dc: true " do_test attrs7 "is_dc: false " do_test attrs8 "score_attribute " echo "" do_test mon-rsc-1 "Schedule Monitor - start" do_test mon-rsc-2 "Schedule Monitor - move " do_test mon-rsc-3 "Schedule Monitor - pending start " do_test mon-rsc-4 "Schedule Monitor - move/pending start" echo "" do_test rec-rsc-0 "Resource Recover - no start " do_test rec-rsc-1 "Resource Recover - start " do_test rec-rsc-2 "Resource Recover - monitor " do_test rec-rsc-3 "Resource Recover - stop - ignore" do_test rec-rsc-4 "Resource Recover - stop - block " do_test rec-rsc-5 "Resource Recover - stop - fence " do_test rec-rsc-6 "Resource Recover - multiple - restart" do_test rec-rsc-7 "Resource Recover - multiple - stop " do_test rec-rsc-8 "Resource Recover - multiple - block " echo "" do_test quorum-1 "No quorum - ignore" do_test quorum-2 "No quorum - freeze" do_test quorum-3 "No quorum - stop " do_test quorum-4 "No quorum - start anyway" do_test quorum-5 "No quorum - start anyway (group)" do_test quorum-6 "No quorum - start anyway (clone)" echo "" do_test rec-node-1 "Node Recover - Startup - no fence" do_test rec-node-2 "Node Recover - Startup - fence " do_test rec-node-3 "Node Recover - HA down - no fence" do_test rec-node-4 "Node Recover - HA down - fence " do_test rec-node-5 "Node Recover - CRM down - no fence" do_test rec-node-6 "Node Recover - CRM down - fence " do_test rec-node-7 "Node Recover - no quorum - ignore " do_test rec-node-8 "Node Recover - no quorum - freeze " do_test rec-node-9 "Node Recover - no quorum - stop " do_test rec-node-10 "Node Recover - no quorum - stop w/fence" do_test rec-node-11 "Node Recover - CRM down w/ group - fence " do_test rec-node-12 "Node Recover - nothing active - fence " do_test rec-node-13 "Node Recover - failed resource + shutdown - fence " do_test rec-node-14 "Serialize all stonith's" echo "" do_test multi1 "Multiple Active (stop/start)" #echo "" #do_test complex1 "Complex " echo "" do_test group1 "Group " do_test group2 "Group + Native " do_test group3 "Group + Group " do_test group4 "Group + Native (nothing)" do_test group5 "Group + Native (move) " do_test group6 "Group + Group (move) " do_test group7 "Group colocation" do_test group13 "Group colocation (cant run)" do_test group8 "Group anti-colocation" do_test group9 "Group recovery" do_test group10 "Group partial recovery" do_test group11 "Group target_role" echo "" do_test inc0 "Incarnation start " do_test inc1 "Incarnation start order " do_test inc2 "Incarnation silent restart, stop, move " do_test inc3 "Inter-incarnation ordering, silent restart, stop, move" do_test inc4 "Inter-incarnation ordering, silent restart, stop, move (ordered)" do_test inc5 "Inter-incarnation ordering, silent restart, stop, move (restart 1)" do_test inc6 "Inter-incarnation ordering, silent restart, stop, move (restart 2)" do_test inc7 "Clone colocation" do_test inc8 "Clone anti-colocation" do_test inc9 "Non-unique clone" do_test inc10 "Non-unique clone (stop)" echo "" +do_test master-0 "Stopped -> Slave" +do_test master-1 "Stopped -> Promote" +do_test master-2 "Stopped -> Promote : notify" +do_test master-3 "Stopped -> Promote : master location" +do_test master-4 "Started -> Promote : master location" +do_test master-5 "Promoted -> Promoted" +do_test master-6 "Promoted -> Promoted (2)" +do_test master-7 "Promoted -> Fenced" +do_test master-8 "Promoted -> Fenced -> Moved" +do_test master-9 "Stopped + Promotable + No quorum" +do_test master-10 "Stopped -> Promotable : notify with monitor" + +echo "" do_test managed-0 "Managed (reference)" do_test managed-1 "Not managed - down " do_test managed-2 "Not managed - up " echo "" - do_test interleave-0 "Interleave (reference)" do_test interleave-1 "coloc - not interleaved" do_test interleave-2 "coloc - interleaved " do_test interleave-3 "coloc - interleaved (2)" echo "" do_test notify-0 "Notify reference" do_test notify-1 "Notify simple" do_test notify-2 "Notify simple, confirm" do_test notify-3 "Notify move, confirm" #do_test notify-2 "Notify - 764" echo "" - do_test 594 "OSDL #594" do_test 662 "OSDL #662" do_test 696 "OSDL #696" do_test 726 "OSDL #726" do_test 735 "OSDL #735" do_test 764 "OSDL #764" do_test 797 "OSDL #797" do_test 829 "OSDL #829" do_test 994 "OSDL #994" do_test 1360 "OSDL #1360 - Clone stickiness" do_test unrunnable-1 "Unrunnable" do_test stonith-0 "Stonith loop" echo "" test_results diff --git a/crm/pengine/testcases/group11.dot b/crm/pengine/testcases/group11.dot index 0fcba38ddb..5bfddfb560 100644 --- a/crm/pengine/testcases/group11.dot +++ b/crm/pengine/testcases/group11.dot @@ -1,14 +1,8 @@ digraph "g" { size = "30,30" "probe_complete node1" [ style=bold color="green" fontcolor="black" ] -"rsc1_stop_0 node1" [ style=bold color="green" fontcolor="black" ] "rsc2_stop_0 node1" [ style=bold color="green" fontcolor="black" ] -"rsc3_stop_0 node1" [ style=bold color="green" fontcolor="black" ] "1_stop_0" [ style=bold color="green" fontcolor="orange" ] "1_stopped_0" [ style=bold color="green" fontcolor="orange" ] -"rsc2_stop_0 node1" -> "rsc1_stop_0 node1" [ style = bold] -"rsc3_stop_0 node1" -> "rsc2_stop_0 node1" [ style = bold] -"1_stop_0" -> "rsc3_stop_0 node1" [ style = bold] -"rsc1_stop_0 node1" -> "1_stopped_0" [ style = bold] "1_stop_0" -> "1_stopped_0" [ style = bold] } diff --git a/crm/pengine/testcases/group11.exp b/crm/pengine/testcases/group11.exp index adedac954f..2845ea175b 100644 --- a/crm/pengine/testcases/group11.exp +++ b/crm/pengine/testcases/group11.exp @@ -1,73 +1,40 @@ - + - + - - - - + - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - + - + diff --git a/crm/pengine/testcases/group13.exp b/crm/pengine/testcases/group13.exp index 42b2c63dc1..15822e08ea 100644 --- a/crm/pengine/testcases/group13.exp +++ b/crm/pengine/testcases/group13.exp @@ -1,39 +1,39 @@ - + - + - + - + diff --git a/crm/pengine/testcases/group8.xml b/crm/pengine/testcases/group8.xml index 78cd500111..cedb0e743a 100644 --- a/crm/pengine/testcases/group8.xml +++ b/crm/pengine/testcases/group8.xml @@ -1,34 +1,34 @@ - + diff --git a/crm/pengine/testcases/group9.xml b/crm/pengine/testcases/group9.xml index 456b631d5b..c659819a51 100644 --- a/crm/pengine/testcases/group9.xml +++ b/crm/pengine/testcases/group9.xml @@ -1,67 +1,67 @@ - + diff --git a/crm/pengine/testcases/inc0.dot b/crm/pengine/testcases/inc0.dot index 789b178c44..ac42e3f993 100644 --- a/crm/pengine/testcases/inc0.dot +++ b/crm/pengine/testcases/inc0.dot @@ -1,44 +1,44 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_start_0 node2" [ style=bold color="green" fontcolor="black" ] "rsc1_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_running_0" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "child_rsc1:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] "rsc1_start_0" -> "child_rsc1:0_start_0 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:1_start_0 node2" [ style = bold] -"rsc1_start_0" -> "child_rsc1:2_start_0 node1" [ style = bold] +"rsc1_start_0" -> "child_rsc1:1_start_0 node1" [ style = bold] +"rsc1_start_0" -> "child_rsc1:2_start_0 node2" [ style = bold] "rsc1_start_0" -> "child_rsc1:3_start_0 node2" [ style = bold] "probe_complete" -> "rsc1_start_0" [ style = bold] "child_rsc1:0_start_0 node1" -> "rsc1_running_0" [ style = bold] -"child_rsc1:1_start_0 node2" -> "rsc1_running_0" [ style = bold] -"child_rsc1:2_start_0 node1" -> "rsc1_running_0" [ style = bold] +"child_rsc1:1_start_0 node1" -> "rsc1_running_0" [ style = bold] +"child_rsc1:2_start_0 node2" -> "rsc1_running_0" [ style = bold] "child_rsc1:3_start_0 node2" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_running_0" [ style = bold] } diff --git a/crm/pengine/testcases/inc0.exp b/crm/pengine/testcases/inc0.exp index 403ad629ab..75474a74de 100644 --- a/crm/pengine/testcases/inc0.exp +++ b/crm/pengine/testcases/inc0.exp @@ -1,244 +1,244 @@ - + - + - + - + diff --git a/crm/pengine/testcases/inc1.dot b/crm/pengine/testcases/inc1.dot index ae555bb905..4d8d43a673 100644 --- a/crm/pengine/testcases/inc1.dot +++ b/crm/pengine/testcases/inc1.dot @@ -1,58 +1,58 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "rsc1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "rsc3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "rsc1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "rsc3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "rsc1_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc2:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc2:0_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:2_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc2:3_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc2:3_start_0 node1" [ style=bold color="green" fontcolor="black" ] "rsc2_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc2_running_0" [ style=bold color="green" fontcolor="orange" ] "rsc3_start_0 node2" [ style=bold color="green" fontcolor="black" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "rsc1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "rsc3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "rsc1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] "rsc3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "probe_complete" -> "rsc1_start_0 node1" [ style = bold] -"rsc2_start_0" -> "child_rsc2:0_start_0 node1" [ style = bold] +"rsc2_start_0" -> "child_rsc2:0_start_0 node2" [ style = bold] "rsc2_start_0" -> "child_rsc2:1_start_0 node2" [ style = bold] "rsc2_start_0" -> "child_rsc2:2_start_0 node1" [ style = bold] -"rsc2_start_0" -> "child_rsc2:3_start_0 node2" [ style = bold] +"rsc2_start_0" -> "child_rsc2:3_start_0 node1" [ style = bold] "probe_complete" -> "rsc2_start_0" [ style = bold] "rsc1_start_0 node1" -> "rsc2_start_0" [ style = bold] -"child_rsc2:0_start_0 node1" -> "rsc2_running_0" [ style = bold] +"child_rsc2:0_start_0 node2" -> "rsc2_running_0" [ style = bold] "child_rsc2:1_start_0 node2" -> "rsc2_running_0" [ style = bold] "child_rsc2:2_start_0 node1" -> "rsc2_running_0" [ style = bold] -"child_rsc2:3_start_0 node2" -> "rsc2_running_0" [ style = bold] +"child_rsc2:3_start_0 node1" -> "rsc2_running_0" [ style = bold] "rsc2_start_0" -> "rsc2_running_0" [ style = bold] "probe_complete" -> "rsc3_start_0 node2" [ style = bold] "rsc2_running_0" -> "rsc3_start_0 node2" [ style = bold] } diff --git a/crm/pengine/testcases/inc1.exp b/crm/pengine/testcases/inc1.exp index 7256808ff6..c4821bd7f9 100644 --- a/crm/pengine/testcases/inc1.exp +++ b/crm/pengine/testcases/inc1.exp @@ -1,324 +1,324 @@ - + - + - + - + diff --git a/crm/pengine/testcases/inc10.exp b/crm/pengine/testcases/inc10.exp index a9da38b5ba..2e82dcf084 100644 --- a/crm/pengine/testcases/inc10.exp +++ b/crm/pengine/testcases/inc10.exp @@ -1,235 +1,235 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/crm/pengine/testcases/inc7.dot b/crm/pengine/testcases/inc7.dot index 43bad9b793..53ef20080a 100644 --- a/crm/pengine/testcases/inc7.dot +++ b/crm/pengine/testcases/inc7.dot @@ -1,117 +1,117 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "rsc0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "rsc0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "probe_complete node3" [ style=bold color="green" fontcolor="black" ] "rsc0_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc2:0_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc2:1_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc2:2_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc2:3_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc2:4_monitor_0 node3" [ style=bold color="green" fontcolor="black" ] "rsc0_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_start_0 node3" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:3_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:4_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:0_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_start_0 node3" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:3_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:4_start_0 node3" [ style=bold color="green" fontcolor="black" ] "rsc1_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_running_0" [ style=bold color="green" fontcolor="orange" ] "child_rsc2:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:2_start_0 node3" [ style=bold color="green" fontcolor="black" ] "child_rsc2:3_start_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:4_start_0 node2" [ style=bold color="green" fontcolor="black" ] "rsc2_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc2_running_0" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "probe_complete node3" -> "probe_complete" [ style = bold] "rsc0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "rsc0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] "rsc0_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc1:0_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc1:1_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc1:2_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc1:3_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc1:4_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc2:0_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc2:1_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc2:2_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc2:3_monitor_0 node3" -> "probe_complete node3" [ style = bold] "child_rsc2:4_monitor_0 node3" -> "probe_complete node3" [ style = bold] "probe_complete" -> "rsc0_start_0 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:0_start_0 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:1_start_0 node2" [ style = bold] -"rsc1_start_0" -> "child_rsc1:2_start_0 node3" [ style = bold] -"rsc1_start_0" -> "child_rsc1:3_start_0 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:4_start_0 node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:0_start_0 node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:1_start_0 node3" [ style = bold] +"rsc1_start_0" -> "child_rsc1:2_start_0 node1" [ style = bold] +"rsc1_start_0" -> "child_rsc1:3_start_0 node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:4_start_0 node3" [ style = bold] "probe_complete" -> "rsc1_start_0" [ style = bold] -"child_rsc1:0_start_0 node1" -> "rsc1_running_0" [ style = bold] -"child_rsc1:1_start_0 node2" -> "rsc1_running_0" [ style = bold] -"child_rsc1:2_start_0 node3" -> "rsc1_running_0" [ style = bold] -"child_rsc1:3_start_0 node1" -> "rsc1_running_0" [ style = bold] -"child_rsc1:4_start_0 node2" -> "rsc1_running_0" [ style = bold] +"child_rsc1:0_start_0 node2" -> "rsc1_running_0" [ style = bold] +"child_rsc1:1_start_0 node3" -> "rsc1_running_0" [ style = bold] +"child_rsc1:2_start_0 node1" -> "rsc1_running_0" [ style = bold] +"child_rsc1:3_start_0 node2" -> "rsc1_running_0" [ style = bold] +"child_rsc1:4_start_0 node3" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_running_0" [ style = bold] "rsc2_start_0" -> "child_rsc2:0_start_0 node1" [ style = bold] "rsc2_start_0" -> "child_rsc2:1_start_0 node2" [ style = bold] "rsc2_start_0" -> "child_rsc2:2_start_0 node3" [ style = bold] "rsc2_start_0" -> "child_rsc2:3_start_0 node1" [ style = bold] "rsc2_start_0" -> "child_rsc2:4_start_0 node2" [ style = bold] "probe_complete" -> "rsc2_start_0" [ style = bold] "rsc1_running_0" -> "rsc2_start_0" [ style = bold] "child_rsc2:0_start_0 node1" -> "rsc2_running_0" [ style = bold] "child_rsc2:1_start_0 node2" -> "rsc2_running_0" [ style = bold] "child_rsc2:2_start_0 node3" -> "rsc2_running_0" [ style = bold] "child_rsc2:3_start_0 node1" -> "rsc2_running_0" [ style = bold] "child_rsc2:4_start_0 node2" -> "rsc2_running_0" [ style = bold] "rsc2_start_0" -> "rsc2_running_0" [ style = bold] } diff --git a/crm/pengine/testcases/inc7.exp b/crm/pengine/testcases/inc7.exp index aec9569f16..1724842295 100644 --- a/crm/pengine/testcases/inc7.exp +++ b/crm/pengine/testcases/inc7.exp @@ -1,668 +1,668 @@ - + - + - + - + - + - + - + - + - + - + diff --git a/crm/pengine/testcases/inc8.dot b/crm/pengine/testcases/inc8.dot index 3914d6c7f2..03ad51ca86 100644 --- a/crm/pengine/testcases/inc8.dot +++ b/crm/pengine/testcases/inc8.dot @@ -1,64 +1,74 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "rsc0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc2:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "rsc0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc2:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "rsc0_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:0_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_start_0 node1" [ style=bold color="green" fontcolor="black" ] "rsc1_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_running_0" [ style=bold color="green" fontcolor="orange" ] +"child_rsc2:0_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc2:1_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"rsc2_start_0" [ style=bold color="green" fontcolor="orange" ] +"rsc2_running_0" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "rsc0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc2:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "rsc0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc2:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] "probe_complete" -> "rsc0_start_0 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:0_start_0 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:1_start_0 node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:0_start_0 node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:1_start_0 node1" [ style = bold] "probe_complete" -> "rsc1_start_0" [ style = bold] -"child_rsc1:0_start_0 node1" -> "rsc1_running_0" [ style = bold] -"child_rsc1:1_start_0 node2" -> "rsc1_running_0" [ style = bold] +"child_rsc1:0_start_0 node2" -> "rsc1_running_0" [ style = bold] +"child_rsc1:1_start_0 node1" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_running_0" [ style = bold] +"rsc2_start_0" -> "child_rsc2:0_start_0 node2" [ style = bold] +"rsc2_start_0" -> "child_rsc2:1_start_0 node1" [ style = bold] +"probe_complete" -> "rsc2_start_0" [ style = bold] +"child_rsc2:0_start_0 node2" -> "rsc2_running_0" [ style = bold] +"child_rsc2:1_start_0 node1" -> "rsc2_running_0" [ style = bold] +"rsc2_start_0" -> "rsc2_running_0" [ style = bold] } diff --git a/crm/pengine/testcases/inc8.exp b/crm/pengine/testcases/inc8.exp index 93522ede2e..563707e18c 100644 --- a/crm/pengine/testcases/inc8.exp +++ b/crm/pengine/testcases/inc8.exp @@ -1,369 +1,425 @@ - + - + - + - + - + + + + + + + + + + + + + + - + - + + + + + + + + + + + + + + - + - + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + diff --git a/crm/pengine/testcases/managed-0.xml b/crm/pengine/testcases/managed-0.xml index 17d906a222..b15c82328d 100644 --- a/crm/pengine/testcases/managed-0.xml +++ b/crm/pengine/testcases/managed-0.xml @@ -1,613 +1,613 @@ - - - - - - - - + + + + + + + + diff --git a/crm/pengine/testcases/managed-1.dot b/crm/pengine/testcases/managed-1.dot index ff6ea1226d..e7f358b52a 100644 --- a/crm/pengine/testcases/managed-1.dot +++ b/crm/pengine/testcases/managed-1.dot @@ -1,210 +1,202 @@ digraph "g" { size = "30,30" "child_DoFencing:7_monitor_5000 c001n09" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:0_monitor_5000 c001n02" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:1_monitor_5000 c001n03" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:2_monitor_5000 c001n04" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:3_monitor_5000 c001n05" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:4_monitor_5000 c001n06" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:5_monitor_5000 c001n07" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:6_monitor_5000 c001n08" [ font_color=black style=filled fillcolor=purple ] "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n02" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n03" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n04" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n05" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n06" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n07" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n08" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_stop_0 c001n02" [ font_color=black style=filled fillcolor=purple ] -"child_DoFencing:0_start_0 c001n02" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:1_stop_0 c001n03" [ font_color=black style=filled fillcolor=purple ] -"child_DoFencing:1_start_0 c001n03" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:2_stop_0 c001n04" [ font_color=black style=filled fillcolor=purple ] -"child_DoFencing:2_start_0 c001n04" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:3_stop_0 c001n05" [ font_color=black style=filled fillcolor=purple ] -"child_DoFencing:3_start_0 c001n05" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:4_stop_0 c001n06" [ font_color=black style=filled fillcolor=purple ] -"child_DoFencing:4_start_0 c001n06" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:5_stop_0 c001n07" [ font_color=black style=filled fillcolor=purple ] -"child_DoFencing:5_start_0 c001n07" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:6_stop_0 c001n08" [ font_color=black style=filled fillcolor=purple ] -"child_DoFencing:6_start_0 c001n08" [ font_color=black style=filled fillcolor=purple ] "child_DoFencing:7_stop_0 c001n09" [ font_color=black style=filled fillcolor=purple ] -"child_DoFencing:7_start_0 c001n09" [ font_color=black style=filled fillcolor=purple ] "DoFencing_start_0" [ font_color=black style=filled fillcolor=purple ] "DoFencing_running_0" [ font_color=black style=filled fillcolor=purple ] "DoFencing_stop_0" [ font_color=black style=filled fillcolor=purple ] "DoFencing_stopped_0" [ font_color=black style=filled fillcolor=purple ] "probe_complete c001n09" -> "probe_complete" [ style = bold] "probe_complete c001n02" -> "probe_complete" [ style = bold] "probe_complete c001n03" -> "probe_complete" [ style = bold] "probe_complete c001n04" -> "probe_complete" [ style = bold] "probe_complete c001n05" -> "probe_complete" [ style = bold] "probe_complete c001n06" -> "probe_complete" [ style = bold] "probe_complete c001n07" -> "probe_complete" [ style = bold] "probe_complete c001n08" -> "probe_complete" [ style = bold] "rsc_c001n02_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n03_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n04_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n05_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n06_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n07_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n08_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:0_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:2_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:4_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:6_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "DcIPaddr_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "rsc_c001n09_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "rsc_c001n03_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "rsc_c001n04_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "rsc_c001n05_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:1_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:3_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:5_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:7_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "DcIPaddr_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n09_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n04_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n05_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n06_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:2_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:4_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:7_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "DcIPaddr_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n09_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n02_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n03_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n05_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n06_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n07_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:3_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:5_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:6_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:7_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "DcIPaddr_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n09_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n02_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n03_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n04_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n06_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n07_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n08_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:4_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:5_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:6_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:7_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "DcIPaddr_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "rsc_c001n05_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "rsc_c001n07_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "DcIPaddr_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n09_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n02_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n03_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n04_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n05_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n06_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n08_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:0_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:1_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:2_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:6_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:7_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "DcIPaddr_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n09_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n02_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n03_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n04_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n05_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n06_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n07_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:0_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:1_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:2_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:3_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:5_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:7_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] } diff --git a/crm/pengine/testcases/managed-1.xml b/crm/pengine/testcases/managed-1.xml index 67b4c57dfb..5fbe349dcc 100644 --- a/crm/pengine/testcases/managed-1.xml +++ b/crm/pengine/testcases/managed-1.xml @@ -1,613 +1,613 @@ - - - - - - - - + + + + + + + + diff --git a/crm/pengine/testcases/managed-2.dot b/crm/pengine/testcases/managed-2.dot index e3c6ba0299..17ba4d54be 100644 --- a/crm/pengine/testcases/managed-2.dot +++ b/crm/pengine/testcases/managed-2.dot @@ -1,262 +1,254 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n09" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n02" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n02" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n03" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n04" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n04" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n05" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n05" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n06" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n06" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n07" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n07" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n08" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n09_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n04_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n05_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n06_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n07_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:4_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:5_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:6_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:7_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] -"rsc_c001n09_stop_0 c001n09" [ style=bold color="green" fontcolor="black" ] -"rsc_c001n02_stop_0 c001n02" [ style=bold color="green" fontcolor="black" ] -"rsc_c001n03_stop_0 c001n03" [ style=bold color="green" fontcolor="black" ] -"rsc_c001n04_stop_0 c001n04" [ style=bold color="green" fontcolor="black" ] -"rsc_c001n05_stop_0 c001n05" [ style=bold color="green" fontcolor="black" ] -"rsc_c001n06_stop_0 c001n06" [ style=bold color="green" fontcolor="black" ] -"rsc_c001n07_stop_0 c001n07" [ style=bold color="green" fontcolor="black" ] -"rsc_c001n08_stop_0 c001n08" [ style=bold color="green" fontcolor="black" ] "DoFencing_start_0" [ font_color=black style=filled fillcolor=purple ] "DoFencing_running_0" [ font_color=black style=filled fillcolor=purple ] "DoFencing_stop_0" [ font_color=black style=filled fillcolor=purple ] "DoFencing_stopped_0" [ font_color=black style=filled fillcolor=purple ] "probe_complete c001n09" -> "probe_complete" [ style = bold] "probe_complete c001n02" -> "probe_complete" [ style = bold] "probe_complete c001n03" -> "probe_complete" [ style = bold] "probe_complete c001n04" -> "probe_complete" [ style = bold] "probe_complete c001n05" -> "probe_complete" [ style = bold] "probe_complete c001n06" -> "probe_complete" [ style = bold] "probe_complete c001n07" -> "probe_complete" [ style = bold] "probe_complete c001n08" -> "probe_complete" [ style = bold] "rsc_c001n02_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n03_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n04_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n05_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n06_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n07_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "rsc_c001n08_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:0_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:1_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:2_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:3_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:4_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:5_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:6_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "child_DoFencing:7_monitor_0 c001n09" -> "probe_complete c001n09" [ style = bold] "DcIPaddr_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "rsc_c001n09_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "rsc_c001n03_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "rsc_c001n04_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "rsc_c001n05_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:0_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:1_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:2_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:3_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:4_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:5_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:6_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "child_DoFencing:7_monitor_0 c001n02" -> "probe_complete c001n02" [ style = bold] "DcIPaddr_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n09_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n04_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n05_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n06_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:0_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:1_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:2_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:3_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:4_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:5_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:6_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:7_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "DcIPaddr_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n09_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n02_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n03_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n05_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n06_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "rsc_c001n07_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:0_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:1_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:2_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:3_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:4_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:5_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:6_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "child_DoFencing:7_monitor_0 c001n04" -> "probe_complete c001n04" [ style = bold] "DcIPaddr_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n09_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n02_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n03_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n04_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n06_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n07_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "rsc_c001n08_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:0_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:1_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:2_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:3_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:4_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:5_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:6_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "child_DoFencing:7_monitor_0 c001n05" -> "probe_complete c001n05" [ style = bold] "DcIPaddr_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "rsc_c001n05_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "rsc_c001n07_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "child_DoFencing:0_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "child_DoFencing:1_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "child_DoFencing:2_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "child_DoFencing:3_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "child_DoFencing:4_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "child_DoFencing:5_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "child_DoFencing:6_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "child_DoFencing:7_monitor_0 c001n06" -> "probe_complete c001n06" [ style = bold] "DcIPaddr_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n09_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n02_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n03_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n04_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n05_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n06_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "rsc_c001n08_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:0_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:1_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:2_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:3_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:4_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:5_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:6_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "child_DoFencing:7_monitor_0 c001n07" -> "probe_complete c001n07" [ style = bold] "DcIPaddr_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n09_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n02_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n03_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n04_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n05_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n06_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n07_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:0_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:1_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:2_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:3_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:4_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:5_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:6_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:7_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] } diff --git a/crm/pengine/testcases/managed-2.exp b/crm/pengine/testcases/managed-2.exp index 3a85a718de..55b826df8a 100644 --- a/crm/pengine/testcases/managed-2.exp +++ b/crm/pengine/testcases/managed-2.exp @@ -1,1560 +1,1488 @@ - - - - - - - - - - + - + - + - + - + - - - - - - - - - - + - + - + - + - + - + - - - - - - - - - - + - + - + - + - + - + - - - - - - - - - - + - + - + - + - + - + - + - - - - - - - - - - + - + - + - + - + - + - - - - - - - - - - + - + - + - + - + - - - - - - - - - - + - + - + - - - - - - - - - - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/crm/pengine/testcases/managed-2.xml b/crm/pengine/testcases/managed-2.xml index fcc99b44b9..9d1c3aee4c 100644 --- a/crm/pengine/testcases/managed-2.xml +++ b/crm/pengine/testcases/managed-2.xml @@ -1,411 +1,411 @@ - - - - - - - - + + + + + + + + diff --git a/crm/pengine/testcases/master-0.dot b/crm/pengine/testcases/master-0.dot index 789b178c44..ac42e3f993 100644 --- a/crm/pengine/testcases/master-0.dot +++ b/crm/pengine/testcases/master-0.dot @@ -1,44 +1,44 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_start_0 node2" [ style=bold color="green" fontcolor="black" ] "rsc1_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_running_0" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "child_rsc1:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] "rsc1_start_0" -> "child_rsc1:0_start_0 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:1_start_0 node2" [ style = bold] -"rsc1_start_0" -> "child_rsc1:2_start_0 node1" [ style = bold] +"rsc1_start_0" -> "child_rsc1:1_start_0 node1" [ style = bold] +"rsc1_start_0" -> "child_rsc1:2_start_0 node2" [ style = bold] "rsc1_start_0" -> "child_rsc1:3_start_0 node2" [ style = bold] "probe_complete" -> "rsc1_start_0" [ style = bold] "child_rsc1:0_start_0 node1" -> "rsc1_running_0" [ style = bold] -"child_rsc1:1_start_0 node2" -> "rsc1_running_0" [ style = bold] -"child_rsc1:2_start_0 node1" -> "rsc1_running_0" [ style = bold] +"child_rsc1:1_start_0 node1" -> "rsc1_running_0" [ style = bold] +"child_rsc1:2_start_0 node2" -> "rsc1_running_0" [ style = bold] "child_rsc1:3_start_0 node2" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_running_0" [ style = bold] } diff --git a/crm/pengine/testcases/master-0.exp b/crm/pengine/testcases/master-0.exp index d8473eefd8..114f4757e6 100644 --- a/crm/pengine/testcases/master-0.exp +++ b/crm/pengine/testcases/master-0.exp @@ -1,244 +1,244 @@ + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - - - - - - - - - - - - - - - - - - - + - + diff --git a/crm/pengine/testcases/master-1.dot b/crm/pengine/testcases/master-1.dot index e1a700de53..326ae5a7f8 100644 --- a/crm/pengine/testcases/master-1.dot +++ b/crm/pengine/testcases/master-1.dot @@ -1,56 +1,56 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_promote_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_promote_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_start_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:3_promote_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_promote_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] "rsc1_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_running_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_promoted_0" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "child_rsc1:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:2_start_0 node2" [ style = bold] +"child_rsc1:2_start_0 node2" -> "child_rsc1:2_promote_0 node2" [ style = bold] +"rsc1_promote_0" -> "child_rsc1:2_promote_0 node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:1_start_0 node1" [ style = bold] +"child_rsc1:1_start_0 node1" -> "child_rsc1:1_promote_0 node1" [ style = bold] +"rsc1_promote_0" -> "child_rsc1:1_promote_0 node1" [ style = bold] "rsc1_start_0" -> "child_rsc1:3_start_0 node2" [ style = bold] -"child_rsc1:3_start_0 node2" -> "child_rsc1:3_promote_0 node2" [ style = bold] -"rsc1_promote_0" -> "child_rsc1:3_promote_0 node2" [ style = bold] -"rsc1_start_0" -> "child_rsc1:1_start_0 node2" [ style = bold] -"rsc1_start_0" -> "child_rsc1:2_start_0 node1" [ style = bold] -"child_rsc1:2_start_0 node1" -> "child_rsc1:2_promote_0 node1" [ style = bold] -"rsc1_promote_0" -> "child_rsc1:2_promote_0 node1" [ style = bold] "rsc1_start_0" -> "child_rsc1:0_start_0 node1" [ style = bold] "probe_complete" -> "rsc1_start_0" [ style = bold] +"child_rsc1:2_start_0 node2" -> "rsc1_running_0" [ style = bold] +"child_rsc1:1_start_0 node1" -> "rsc1_running_0" [ style = bold] "child_rsc1:3_start_0 node2" -> "rsc1_running_0" [ style = bold] -"child_rsc1:1_start_0 node2" -> "rsc1_running_0" [ style = bold] -"child_rsc1:2_start_0 node1" -> "rsc1_running_0" [ style = bold] "child_rsc1:0_start_0 node1" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_promote_0" [ style = bold] "rsc1_running_0" -> "rsc1_promote_0" [ style = bold] -"child_rsc1:3_promote_0 node2" -> "rsc1_promoted_0" [ style = bold] -"child_rsc1:2_promote_0 node1" -> "rsc1_promoted_0" [ style = bold] +"child_rsc1:2_promote_0 node2" -> "rsc1_promoted_0" [ style = bold] +"child_rsc1:1_promote_0 node1" -> "rsc1_promoted_0" [ style = bold] } diff --git a/crm/pengine/testcases/master-1.exp b/crm/pengine/testcases/master-1.exp index 790f54ee44..5c8607f366 100644 --- a/crm/pengine/testcases/master-1.exp +++ b/crm/pengine/testcases/master-1.exp @@ -1,306 +1,306 @@ - - - + + + - - - + + + - + - - - + + + - + - - - + + + - + - + - + - + - + - + - + - - - + + + - + + + + + + + + - - - + + + - + - - - + + + - - - - - + - + - - - + + + - - - - + - + - + - + - + - + - + - + diff --git a/crm/pengine/testcases/master-10.dot b/crm/pengine/testcases/master-10.dot index b398e114f5..fff95cc214 100644 --- a/crm/pengine/testcases/master-10.dot +++ b/crm/pengine/testcases/master-10.dot @@ -1,127 +1,127 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_promote_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_monitor_11000 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_promote_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_monitor_11000 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_promote_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_11000 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_1000 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_monitor_1000 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_monitor_1000 node2" [ style=bold color="green" fontcolor="black" ] "rsc1_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_running_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_pre_notify_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_confirmed-pre_notify_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_post_notify_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_confirmed-post_notify_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_promoted_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_pre_notify_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_confirmed-pre_notify_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_post_notify_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_confirmed-post_notify_promote_0" [ style=bold color="green" fontcolor="orange" ] -"child_rsc1:2_post_notify_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_pre_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_post_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_post_notify_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_pre_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_post_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_post_notify_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_pre_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_post_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_post_notify_start_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_pre_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_post_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_post_notify_start_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_pre_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_post_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_post_notify_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_pre_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_post_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "child_rsc1:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] -"rsc1_start_0" -> "child_rsc1:2_start_0 node1" [ style = bold] -"child_rsc1:2_start_0 node1" -> "child_rsc1:2_promote_0 node1" [ style = bold] -"rsc1_promote_0" -> "child_rsc1:2_promote_0 node1" [ style = bold] -"child_rsc1:2_start_0 node1" -> "child_rsc1:2_monitor_11000 node1" [ style = bold] -"child_rsc1:2_promote_0 node1" -> "child_rsc1:2_monitor_11000 node1" [ style = bold] -"rsc1_confirmed-post_notify_start_0" -> "child_rsc1:2_monitor_11000 node1" [ style = bold] -"rsc1_confirmed-post_notify_promote_0" -> "child_rsc1:2_monitor_11000 node1" [ style = bold] +"rsc1_start_0" -> "child_rsc1:1_start_0 node1" [ style = bold] +"child_rsc1:1_start_0 node1" -> "child_rsc1:1_promote_0 node1" [ style = bold] +"rsc1_promote_0" -> "child_rsc1:1_promote_0 node1" [ style = bold] +"child_rsc1:1_start_0 node1" -> "child_rsc1:1_monitor_11000 node1" [ style = bold] +"child_rsc1:1_promote_0 node1" -> "child_rsc1:1_monitor_11000 node1" [ style = bold] +"rsc1_confirmed-post_notify_start_0" -> "child_rsc1:1_monitor_11000 node1" [ style = bold] +"rsc1_confirmed-post_notify_promote_0" -> "child_rsc1:1_monitor_11000 node1" [ style = bold] "rsc1_start_0" -> "child_rsc1:3_start_0 node2" [ style = bold] "child_rsc1:3_start_0 node2" -> "child_rsc1:3_promote_0 node2" [ style = bold] "rsc1_promote_0" -> "child_rsc1:3_promote_0 node2" [ style = bold] "child_rsc1:3_start_0 node2" -> "child_rsc1:3_monitor_11000 node2" [ style = bold] "child_rsc1:3_promote_0 node2" -> "child_rsc1:3_monitor_11000 node2" [ style = bold] "rsc1_confirmed-post_notify_start_0" -> "child_rsc1:3_monitor_11000 node2" [ style = bold] "rsc1_confirmed-post_notify_promote_0" -> "child_rsc1:3_monitor_11000 node2" [ style = bold] "rsc1_start_0" -> "child_rsc1:0_start_0 node1" [ style = bold] "child_rsc1:0_start_0 node1" -> "child_rsc1:0_monitor_1000 node1" [ style = bold] "rsc1_confirmed-post_notify_start_0" -> "child_rsc1:0_monitor_1000 node1" [ style = bold] "rsc1_confirmed-post_notify_promote_0" -> "child_rsc1:0_monitor_1000 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:1_start_0 node2" [ style = bold] -"child_rsc1:1_start_0 node2" -> "child_rsc1:1_monitor_1000 node2" [ style = bold] -"rsc1_confirmed-post_notify_start_0" -> "child_rsc1:1_monitor_1000 node2" [ style = bold] -"rsc1_confirmed-post_notify_promote_0" -> "child_rsc1:1_monitor_1000 node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:2_start_0 node2" [ style = bold] +"child_rsc1:2_start_0 node2" -> "child_rsc1:2_monitor_1000 node2" [ style = bold] +"rsc1_confirmed-post_notify_start_0" -> "child_rsc1:2_monitor_1000 node2" [ style = bold] +"rsc1_confirmed-post_notify_promote_0" -> "child_rsc1:2_monitor_1000 node2" [ style = bold] "probe_complete" -> "rsc1_start_0" [ style = bold] "rsc1_confirmed-pre_notify_start_0" -> "rsc1_start_0" [ style = bold] -"child_rsc1:2_start_0 node1" -> "rsc1_running_0" [ style = bold] +"child_rsc1:1_start_0 node1" -> "rsc1_running_0" [ style = bold] "child_rsc1:3_start_0 node2" -> "rsc1_running_0" [ style = bold] "child_rsc1:0_start_0 node1" -> "rsc1_running_0" [ style = bold] -"child_rsc1:1_start_0 node2" -> "rsc1_running_0" [ style = bold] +"child_rsc1:2_start_0 node2" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_running_0" [ style = bold] "rsc1_pre_notify_start_0" -> "rsc1_confirmed-pre_notify_start_0" [ style = bold] "rsc1_running_0" -> "rsc1_post_notify_start_0" [ style = bold] "rsc1_post_notify_start_0" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] -"child_rsc1:2_post_notify_start_0 node1" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] +"child_rsc1:1_post_notify_start_0 node1" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] "child_rsc1:3_post_notify_start_0 node2" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] "child_rsc1:0_post_notify_start_0 node1" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] -"child_rsc1:1_post_notify_start_0 node2" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] +"child_rsc1:2_post_notify_start_0 node2" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] "rsc1_start_0" -> "rsc1_promote_0" [ style = bold] "rsc1_running_0" -> "rsc1_promote_0" [ style = bold] "rsc1_confirmed-post_notify_start_0" -> "rsc1_promote_0" [ style = bold] "rsc1_confirmed-pre_notify_promote_0" -> "rsc1_promote_0" [ style = bold] -"child_rsc1:2_promote_0 node1" -> "rsc1_promoted_0" [ style = bold] +"child_rsc1:1_promote_0 node1" -> "rsc1_promoted_0" [ style = bold] "child_rsc1:3_promote_0 node2" -> "rsc1_promoted_0" [ style = bold] "rsc1_pre_notify_promote_0" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] -"child_rsc1:2_pre_notify_promote_0 node1" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] +"child_rsc1:1_pre_notify_promote_0 node1" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] "child_rsc1:3_pre_notify_promote_0 node2" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] "child_rsc1:0_pre_notify_promote_0 node1" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] -"child_rsc1:1_pre_notify_promote_0 node2" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] +"child_rsc1:2_pre_notify_promote_0 node2" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] "rsc1_promoted_0" -> "rsc1_post_notify_promote_0" [ style = bold] "rsc1_post_notify_promote_0" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] -"child_rsc1:2_post_notify_promote_0 node1" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] +"child_rsc1:1_post_notify_promote_0 node1" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] "child_rsc1:3_post_notify_promote_0 node2" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] "child_rsc1:0_post_notify_promote_0 node1" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] -"child_rsc1:1_post_notify_promote_0 node2" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] -"rsc1_post_notify_start_0" -> "child_rsc1:2_post_notify_start_0 node1" [ style = bold] -"rsc1_pre_notify_promote_0" -> "child_rsc1:2_pre_notify_promote_0 node1" [ style = bold] -"rsc1_post_notify_promote_0" -> "child_rsc1:2_post_notify_promote_0 node1" [ style = bold] +"child_rsc1:2_post_notify_promote_0 node2" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] +"rsc1_post_notify_start_0" -> "child_rsc1:1_post_notify_start_0 node1" [ style = bold] +"rsc1_pre_notify_promote_0" -> "child_rsc1:1_pre_notify_promote_0 node1" [ style = bold] +"rsc1_post_notify_promote_0" -> "child_rsc1:1_post_notify_promote_0 node1" [ style = bold] "rsc1_post_notify_start_0" -> "child_rsc1:3_post_notify_start_0 node2" [ style = bold] "rsc1_pre_notify_promote_0" -> "child_rsc1:3_pre_notify_promote_0 node2" [ style = bold] "rsc1_post_notify_promote_0" -> "child_rsc1:3_post_notify_promote_0 node2" [ style = bold] "rsc1_post_notify_start_0" -> "child_rsc1:0_post_notify_start_0 node1" [ style = bold] "rsc1_pre_notify_promote_0" -> "child_rsc1:0_pre_notify_promote_0 node1" [ style = bold] "rsc1_post_notify_promote_0" -> "child_rsc1:0_post_notify_promote_0 node1" [ style = bold] -"rsc1_post_notify_start_0" -> "child_rsc1:1_post_notify_start_0 node2" [ style = bold] -"rsc1_pre_notify_promote_0" -> "child_rsc1:1_pre_notify_promote_0 node2" [ style = bold] -"rsc1_post_notify_promote_0" -> "child_rsc1:1_post_notify_promote_0 node2" [ style = bold] +"rsc1_post_notify_start_0" -> "child_rsc1:2_post_notify_start_0 node2" [ style = bold] +"rsc1_pre_notify_promote_0" -> "child_rsc1:2_pre_notify_promote_0 node2" [ style = bold] +"rsc1_post_notify_promote_0" -> "child_rsc1:2_post_notify_promote_0 node2" [ style = bold] } diff --git a/crm/pengine/testcases/master-10.exp b/crm/pengine/testcases/master-10.exp index d521bc557f..3c1976a520 100644 --- a/crm/pengine/testcases/master-10.exp +++ b/crm/pengine/testcases/master-10.exp @@ -1,677 +1,677 @@ - - - + + + - - - + + + - - - + + + - - - + + + - + - - - + + + - + - + - - - + + + - - - + + + - - - + + + - + - + - + - + - + - + - + - + - + - - - + + + - - - + + + - - - + + + - - - + + + - + - - - + + + - - - + + + - - - + + + - + - + - + - + - + - + - + - + - + - + - + diff --git a/crm/pengine/testcases/master-10.xml b/crm/pengine/testcases/master-10.xml index a8c7820fdb..6207d635d6 100644 --- a/crm/pengine/testcases/master-10.xml +++ b/crm/pengine/testcases/master-10.xml @@ -1,67 +1,67 @@ - + - + diff --git a/crm/pengine/testcases/master-2.dot b/crm/pengine/testcases/master-2.dot index e905b768f3..b707f04f79 100644 --- a/crm/pengine/testcases/master-2.dot +++ b/crm/pengine/testcases/master-2.dot @@ -1,109 +1,109 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_promote_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_promote_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_promote_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_start_0 node2" [ style=bold color="green" fontcolor="black" ] "rsc1_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_running_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_pre_notify_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_confirmed-pre_notify_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_post_notify_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_confirmed-post_notify_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_promoted_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_pre_notify_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_confirmed-pre_notify_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_post_notify_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_confirmed-post_notify_promote_0" [ style=bold color="green" fontcolor="orange" ] -"child_rsc1:2_post_notify_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_pre_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_post_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_post_notify_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_pre_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_post_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_post_notify_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_pre_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_post_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_post_notify_start_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_pre_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_post_notify_promote_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_post_notify_start_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_pre_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_post_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_post_notify_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_pre_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_post_notify_promote_0 node2" [ style=bold color="green" fontcolor="black" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "child_rsc1:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] -"rsc1_start_0" -> "child_rsc1:2_start_0 node1" [ style = bold] -"child_rsc1:2_start_0 node1" -> "child_rsc1:2_promote_0 node1" [ style = bold] -"rsc1_promote_0" -> "child_rsc1:2_promote_0 node1" [ style = bold] +"rsc1_start_0" -> "child_rsc1:1_start_0 node1" [ style = bold] +"child_rsc1:1_start_0 node1" -> "child_rsc1:1_promote_0 node1" [ style = bold] +"rsc1_promote_0" -> "child_rsc1:1_promote_0 node1" [ style = bold] "rsc1_start_0" -> "child_rsc1:3_start_0 node2" [ style = bold] "child_rsc1:3_start_0 node2" -> "child_rsc1:3_promote_0 node2" [ style = bold] "rsc1_promote_0" -> "child_rsc1:3_promote_0 node2" [ style = bold] "rsc1_start_0" -> "child_rsc1:0_start_0 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:1_start_0 node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:2_start_0 node2" [ style = bold] "probe_complete" -> "rsc1_start_0" [ style = bold] "rsc1_confirmed-pre_notify_start_0" -> "rsc1_start_0" [ style = bold] -"child_rsc1:2_start_0 node1" -> "rsc1_running_0" [ style = bold] +"child_rsc1:1_start_0 node1" -> "rsc1_running_0" [ style = bold] "child_rsc1:3_start_0 node2" -> "rsc1_running_0" [ style = bold] "child_rsc1:0_start_0 node1" -> "rsc1_running_0" [ style = bold] -"child_rsc1:1_start_0 node2" -> "rsc1_running_0" [ style = bold] +"child_rsc1:2_start_0 node2" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_running_0" [ style = bold] "rsc1_pre_notify_start_0" -> "rsc1_confirmed-pre_notify_start_0" [ style = bold] "rsc1_running_0" -> "rsc1_post_notify_start_0" [ style = bold] "rsc1_post_notify_start_0" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] -"child_rsc1:2_post_notify_start_0 node1" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] +"child_rsc1:1_post_notify_start_0 node1" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] "child_rsc1:3_post_notify_start_0 node2" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] "child_rsc1:0_post_notify_start_0 node1" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] -"child_rsc1:1_post_notify_start_0 node2" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] +"child_rsc1:2_post_notify_start_0 node2" -> "rsc1_confirmed-post_notify_start_0" [ style = bold] "rsc1_start_0" -> "rsc1_promote_0" [ style = bold] "rsc1_running_0" -> "rsc1_promote_0" [ style = bold] "rsc1_confirmed-post_notify_start_0" -> "rsc1_promote_0" [ style = bold] "rsc1_confirmed-pre_notify_promote_0" -> "rsc1_promote_0" [ style = bold] -"child_rsc1:2_promote_0 node1" -> "rsc1_promoted_0" [ style = bold] +"child_rsc1:1_promote_0 node1" -> "rsc1_promoted_0" [ style = bold] "child_rsc1:3_promote_0 node2" -> "rsc1_promoted_0" [ style = bold] "rsc1_pre_notify_promote_0" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] -"child_rsc1:2_pre_notify_promote_0 node1" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] +"child_rsc1:1_pre_notify_promote_0 node1" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] "child_rsc1:3_pre_notify_promote_0 node2" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] "child_rsc1:0_pre_notify_promote_0 node1" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] -"child_rsc1:1_pre_notify_promote_0 node2" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] +"child_rsc1:2_pre_notify_promote_0 node2" -> "rsc1_confirmed-pre_notify_promote_0" [ style = bold] "rsc1_promoted_0" -> "rsc1_post_notify_promote_0" [ style = bold] "rsc1_post_notify_promote_0" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] -"child_rsc1:2_post_notify_promote_0 node1" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] +"child_rsc1:1_post_notify_promote_0 node1" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] "child_rsc1:3_post_notify_promote_0 node2" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] "child_rsc1:0_post_notify_promote_0 node1" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] -"child_rsc1:1_post_notify_promote_0 node2" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] -"rsc1_post_notify_start_0" -> "child_rsc1:2_post_notify_start_0 node1" [ style = bold] -"rsc1_pre_notify_promote_0" -> "child_rsc1:2_pre_notify_promote_0 node1" [ style = bold] -"rsc1_post_notify_promote_0" -> "child_rsc1:2_post_notify_promote_0 node1" [ style = bold] +"child_rsc1:2_post_notify_promote_0 node2" -> "rsc1_confirmed-post_notify_promote_0" [ style = bold] +"rsc1_post_notify_start_0" -> "child_rsc1:1_post_notify_start_0 node1" [ style = bold] +"rsc1_pre_notify_promote_0" -> "child_rsc1:1_pre_notify_promote_0 node1" [ style = bold] +"rsc1_post_notify_promote_0" -> "child_rsc1:1_post_notify_promote_0 node1" [ style = bold] "rsc1_post_notify_start_0" -> "child_rsc1:3_post_notify_start_0 node2" [ style = bold] "rsc1_pre_notify_promote_0" -> "child_rsc1:3_pre_notify_promote_0 node2" [ style = bold] "rsc1_post_notify_promote_0" -> "child_rsc1:3_post_notify_promote_0 node2" [ style = bold] "rsc1_post_notify_start_0" -> "child_rsc1:0_post_notify_start_0 node1" [ style = bold] "rsc1_pre_notify_promote_0" -> "child_rsc1:0_pre_notify_promote_0 node1" [ style = bold] "rsc1_post_notify_promote_0" -> "child_rsc1:0_post_notify_promote_0 node1" [ style = bold] -"rsc1_post_notify_start_0" -> "child_rsc1:1_post_notify_start_0 node2" [ style = bold] -"rsc1_pre_notify_promote_0" -> "child_rsc1:1_pre_notify_promote_0 node2" [ style = bold] -"rsc1_post_notify_promote_0" -> "child_rsc1:1_post_notify_promote_0 node2" [ style = bold] +"rsc1_post_notify_start_0" -> "child_rsc1:2_post_notify_start_0 node2" [ style = bold] +"rsc1_pre_notify_promote_0" -> "child_rsc1:2_pre_notify_promote_0 node2" [ style = bold] +"rsc1_post_notify_promote_0" -> "child_rsc1:2_post_notify_promote_0 node2" [ style = bold] } diff --git a/crm/pengine/testcases/master-2.exp b/crm/pengine/testcases/master-2.exp index 4e885ca20e..5963792ffd 100644 --- a/crm/pengine/testcases/master-2.exp +++ b/crm/pengine/testcases/master-2.exp @@ -1,595 +1,595 @@ - - - + + + - - - + + + - - - + + + - - - + + + - + - - - + + + - - - + + + - - - + + + - + - + - + - + - + - + - + - + - + - - - + + + - - - + + + - - - + + + - - - + + + - - - + + + - - - + + + - + - + - + - + - + - + - + - + - + - + - + diff --git a/crm/pengine/testcases/master-2.xml b/crm/pengine/testcases/master-2.xml index 4256c753a9..e80ea3b5e7 100644 --- a/crm/pengine/testcases/master-2.xml +++ b/crm/pengine/testcases/master-2.xml @@ -1,62 +1,62 @@ - + - + diff --git a/crm/pengine/testcases/master-3.dot b/crm/pengine/testcases/master-3.dot index c275c92071..bfc1d8b1df 100644 --- a/crm/pengine/testcases/master-3.dot +++ b/crm/pengine/testcases/master-3.dot @@ -1,52 +1,52 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:4_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_start_0 node2" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:2_promote_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:3_start_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:3_promote_0 node2" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:1_start_0 node2" [ style=bold color="green" fontcolor="black" ] "child_rsc1:0_start_0 node1" [ style=bold color="green" fontcolor="black" ] -"child_rsc1:2_start_0 node1" [ style=bold color="green" fontcolor="black" ] +"child_rsc1:1_start_0 node1" [ style=bold color="green" fontcolor="black" ] "rsc1_start_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_running_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_promote_0" [ style=bold color="green" fontcolor="orange" ] "rsc1_promoted_0" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "child_rsc1:0_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:3_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:4_monitor_0 node1" -> "probe_complete node1" [ style = bold] "child_rsc1:0_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:2_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:3_monitor_0 node2" -> "probe_complete node2" [ style = bold] "child_rsc1:4_monitor_0 node2" -> "probe_complete node2" [ style = bold] +"rsc1_start_0" -> "child_rsc1:2_start_0 node2" [ style = bold] +"child_rsc1:2_start_0 node2" -> "child_rsc1:2_promote_0 node2" [ style = bold] +"rsc1_promote_0" -> "child_rsc1:2_promote_0 node2" [ style = bold] "rsc1_start_0" -> "child_rsc1:3_start_0 node2" [ style = bold] -"child_rsc1:3_start_0 node2" -> "child_rsc1:3_promote_0 node2" [ style = bold] -"rsc1_promote_0" -> "child_rsc1:3_promote_0 node2" [ style = bold] -"rsc1_start_0" -> "child_rsc1:1_start_0 node2" [ style = bold] "rsc1_start_0" -> "child_rsc1:0_start_0 node1" [ style = bold] -"rsc1_start_0" -> "child_rsc1:2_start_0 node1" [ style = bold] +"rsc1_start_0" -> "child_rsc1:1_start_0 node1" [ style = bold] "probe_complete" -> "rsc1_start_0" [ style = bold] +"child_rsc1:2_start_0 node2" -> "rsc1_running_0" [ style = bold] "child_rsc1:3_start_0 node2" -> "rsc1_running_0" [ style = bold] -"child_rsc1:1_start_0 node2" -> "rsc1_running_0" [ style = bold] "child_rsc1:0_start_0 node1" -> "rsc1_running_0" [ style = bold] -"child_rsc1:2_start_0 node1" -> "rsc1_running_0" [ style = bold] +"child_rsc1:1_start_0 node1" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_running_0" [ style = bold] "rsc1_start_0" -> "rsc1_promote_0" [ style = bold] "rsc1_running_0" -> "rsc1_promote_0" [ style = bold] -"child_rsc1:3_promote_0 node2" -> "rsc1_promoted_0" [ style = bold] +"child_rsc1:2_promote_0 node2" -> "rsc1_promoted_0" [ style = bold] } diff --git a/crm/pengine/testcases/master-3.exp b/crm/pengine/testcases/master-3.exp index fca5020973..fe617dd96d 100644 --- a/crm/pengine/testcases/master-3.exp +++ b/crm/pengine/testcases/master-3.exp @@ -1,287 +1,287 @@ - - - + + + - - - + + + - + - - - + + + - + - - - + + + - + - - - + + + - - - + + + - + - - - + + + + + + + + + + + + + + + + + + + + + - + - + - + - - - + + + - + - - - + + + - + - - - + + + - - - - - - - - - - - - - - - - - - - + - + - + - + diff --git a/crm/pengine/testcases/master-7.exp b/crm/pengine/testcases/master-7.exp index 5f4de7e24b..59cc599548 100644 --- a/crm/pengine/testcases/master-7.exp +++ b/crm/pengine/testcases/master-7.exp @@ -1,633 +1,633 @@ - + - - - - + + + - + + + + + + + + - + - - - - + + + - + + + + + + + + - - - + + + - - - + + + - - - - - - - - - - - - + + + - + - - + + - - - - + - + - - - + + + + - - - - - - - - + + + + + + + + + + - - - + + + - - - + + + - - - + + + - + - - - + + + + - - - - - + - + - + - + diff --git a/crm/pengine/testcases/master-8.exp b/crm/pengine/testcases/master-8.exp index c7e406e1f6..38ff60e0ad 100644 --- a/crm/pengine/testcases/master-8.exp +++ b/crm/pengine/testcases/master-8.exp @@ -1,698 +1,698 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/crm/pengine/testcases/master-9.exp b/crm/pengine/testcases/master-9.exp index c904be9e66..cc37be32c9 100644 --- a/crm/pengine/testcases/master-9.exp +++ b/crm/pengine/testcases/master-9.exp @@ -1,288 +1,288 @@ - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/crm/pengine/testcases/notify-0.xml b/crm/pengine/testcases/notify-0.xml index 1dfd6af286..592b221722 100644 --- a/crm/pengine/testcases/notify-0.xml +++ b/crm/pengine/testcases/notify-0.xml @@ -1,55 +1,55 @@ - + diff --git a/crm/pengine/testcases/rec-node-12.dot b/crm/pengine/testcases/rec-node-12.dot index dee9b12204..25710d11ce 100644 --- a/crm/pengine/testcases/rec-node-12.dot +++ b/crm/pengine/testcases/rec-node-12.dot @@ -1,107 +1,107 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete c001n08" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n01_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n08" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n03" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n01_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n03" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n01" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "rsc_c001n01_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:0_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:1_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:2_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "child_DoFencing:3_monitor_0 c001n01" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_start_0 c001n08" [ style=bold color="green" fontcolor="black" ] "DcIPaddr_monitor_5000 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_start_0 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n08_monitor_5000 c001n08" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_start_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n02_monitor_5000 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_start_0 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n03_monitor_5000 c001n03" [ style=bold color="green" fontcolor="black" ] "rsc_c001n01_start_0 c001n01" [ style=bold color="green" fontcolor="black" ] "rsc_c001n01_monitor_5000 c001n01" [ style=bold color="green" fontcolor="black" ] -"child_DoFencing:0_start_0 c001n08" [ style=bold color="green" fontcolor="black" ] -"child_DoFencing:0_monitor_5000 c001n08" [ style=bold color="green" fontcolor="black" ] -"child_DoFencing:1_start_0 c001n03" [ style=bold color="green" fontcolor="black" ] -"child_DoFencing:1_monitor_5000 c001n03" [ style=bold color="green" fontcolor="black" ] -"child_DoFencing:2_start_0 c001n01" [ style=bold color="green" fontcolor="black" ] -"child_DoFencing:2_monitor_5000 c001n01" [ style=bold color="green" fontcolor="black" ] +"child_DoFencing:0_start_0 c001n01" [ style=bold color="green" fontcolor="black" ] +"child_DoFencing:0_monitor_5000 c001n01" [ style=bold color="green" fontcolor="black" ] +"child_DoFencing:1_start_0 c001n08" [ style=bold color="green" fontcolor="black" ] +"child_DoFencing:1_monitor_5000 c001n08" [ style=bold color="green" fontcolor="black" ] +"child_DoFencing:2_start_0 c001n03" [ style=bold color="green" fontcolor="black" ] +"child_DoFencing:2_monitor_5000 c001n03" [ style=bold color="green" fontcolor="black" ] "DoFencing_start_0" [ style=bold color="green" fontcolor="orange" ] "DoFencing_running_0" [ style=bold color="green" fontcolor="orange" ] "stonith c001n02" [ style=bold color="green" fontcolor="black" ] "probe_complete c001n08" -> "probe_complete" [ style = bold] "probe_complete c001n03" -> "probe_complete" [ style = bold] "probe_complete c001n01" -> "probe_complete" [ style = bold] "DcIPaddr_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n08_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n02_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n03_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "rsc_c001n01_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:0_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:1_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:2_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "child_DoFencing:3_monitor_0 c001n08" -> "probe_complete c001n08" [ style = bold] "DcIPaddr_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n08_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n02_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n03_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "rsc_c001n01_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:0_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:1_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:2_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "child_DoFencing:3_monitor_0 c001n03" -> "probe_complete c001n03" [ style = bold] "DcIPaddr_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "rsc_c001n08_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "rsc_c001n02_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "rsc_c001n03_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "rsc_c001n01_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "child_DoFencing:0_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "child_DoFencing:1_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "child_DoFencing:2_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "child_DoFencing:3_monitor_0 c001n01" -> "probe_complete c001n01" [ style = bold] "probe_complete" -> "DcIPaddr_start_0 c001n08" [ style = bold] "DcIPaddr_start_0 c001n08" -> "DcIPaddr_monitor_5000 c001n08" [ style = bold] "probe_complete" -> "rsc_c001n08_start_0 c001n08" [ style = bold] "rsc_c001n08_start_0 c001n08" -> "rsc_c001n08_monitor_5000 c001n08" [ style = bold] "probe_complete" -> "rsc_c001n02_start_0 c001n03" [ style = bold] "rsc_c001n02_start_0 c001n03" -> "rsc_c001n02_monitor_5000 c001n03" [ style = bold] "probe_complete" -> "rsc_c001n03_start_0 c001n03" [ style = bold] "rsc_c001n03_start_0 c001n03" -> "rsc_c001n03_monitor_5000 c001n03" [ style = bold] "probe_complete" -> "rsc_c001n01_start_0 c001n01" [ style = bold] "rsc_c001n01_start_0 c001n01" -> "rsc_c001n01_monitor_5000 c001n01" [ style = bold] -"DoFencing_start_0" -> "child_DoFencing:0_start_0 c001n08" [ style = bold] -"child_DoFencing:0_start_0 c001n08" -> "child_DoFencing:0_monitor_5000 c001n08" [ style = bold] -"DoFencing_start_0" -> "child_DoFencing:1_start_0 c001n03" [ style = bold] -"child_DoFencing:1_start_0 c001n03" -> "child_DoFencing:1_monitor_5000 c001n03" [ style = bold] -"DoFencing_start_0" -> "child_DoFencing:2_start_0 c001n01" [ style = bold] -"child_DoFencing:2_start_0 c001n01" -> "child_DoFencing:2_monitor_5000 c001n01" [ style = bold] +"DoFencing_start_0" -> "child_DoFencing:0_start_0 c001n01" [ style = bold] +"child_DoFencing:0_start_0 c001n01" -> "child_DoFencing:0_monitor_5000 c001n01" [ style = bold] +"DoFencing_start_0" -> "child_DoFencing:1_start_0 c001n08" [ style = bold] +"child_DoFencing:1_start_0 c001n08" -> "child_DoFencing:1_monitor_5000 c001n08" [ style = bold] +"DoFencing_start_0" -> "child_DoFencing:2_start_0 c001n03" [ style = bold] +"child_DoFencing:2_start_0 c001n03" -> "child_DoFencing:2_monitor_5000 c001n03" [ style = bold] "probe_complete" -> "DoFencing_start_0" [ style = bold] -"child_DoFencing:0_start_0 c001n08" -> "DoFencing_running_0" [ style = bold] -"child_DoFencing:1_start_0 c001n03" -> "DoFencing_running_0" [ style = bold] -"child_DoFencing:2_start_0 c001n01" -> "DoFencing_running_0" [ style = bold] +"child_DoFencing:0_start_0 c001n01" -> "DoFencing_running_0" [ style = bold] +"child_DoFencing:1_start_0 c001n08" -> "DoFencing_running_0" [ style = bold] +"child_DoFencing:2_start_0 c001n03" -> "DoFencing_running_0" [ style = bold] "DoFencing_start_0" -> "DoFencing_running_0" [ style = bold] -"child_DoFencing:0_start_0 c001n08" -> "stonith c001n02" [ style = bold] -"child_DoFencing:1_start_0 c001n03" -> "stonith c001n02" [ style = bold] -"child_DoFencing:2_start_0 c001n01" -> "stonith c001n02" [ style = bold] +"child_DoFencing:0_start_0 c001n01" -> "stonith c001n02" [ style = bold] +"child_DoFencing:1_start_0 c001n08" -> "stonith c001n02" [ style = bold] +"child_DoFencing:2_start_0 c001n03" -> "stonith c001n02" [ style = bold] } diff --git a/crm/pengine/testcases/rec-node-12.exp b/crm/pengine/testcases/rec-node-12.exp index c46bc430ac..8f0730da0e 100644 --- a/crm/pengine/testcases/rec-node-12.exp +++ b/crm/pengine/testcases/rec-node-12.exp @@ -1,631 +1,631 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/crm/pengine/testcases/rsc_dep10.dot b/crm/pengine/testcases/rsc_dep10.dot index 3c015d350a..fcce0c3986 100644 --- a/crm/pengine/testcases/rsc_dep10.dot +++ b/crm/pengine/testcases/rsc_dep10.dot @@ -1,16 +1,18 @@ digraph "g" { size = "30,30" "probe_complete" [ style=bold color="green" fontcolor="orange" ] "probe_complete node1" [ style=bold color="green" fontcolor="black" ] "rsc1_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "rsc2_monitor_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node2" [ style=bold color="green" fontcolor="black" ] "rsc1_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] "rsc2_monitor_0 node2" [ style=bold color="green" fontcolor="black" ] +"rsc2_start_0 node1" [ style=bold color="green" fontcolor="black" ] "probe_complete node1" -> "probe_complete" [ style = bold] "probe_complete node2" -> "probe_complete" [ style = bold] "rsc1_monitor_0 node1" -> "probe_complete node1" [ style = bold] "rsc2_monitor_0 node1" -> "probe_complete node1" [ style = bold] "rsc1_monitor_0 node2" -> "probe_complete node2" [ style = bold] "rsc2_monitor_0 node2" -> "probe_complete node2" [ style = bold] +"probe_complete" -> "rsc2_start_0 node1" [ style = bold] } diff --git a/crm/pengine/testcases/rsc_dep10.exp b/crm/pengine/testcases/rsc_dep10.exp index d380cdb873..c75cf04520 100644 --- a/crm/pengine/testcases/rsc_dep10.exp +++ b/crm/pengine/testcases/rsc_dep10.exp @@ -1,84 +1,97 @@ + + + + + + + + + + + + + - + - + diff --git a/crm/pengine/testcases/rsc_dep10.xml b/crm/pengine/testcases/rsc_dep10.xml index 0ec68cc1e3..c19d95241e 100644 --- a/crm/pengine/testcases/rsc_dep10.xml +++ b/crm/pengine/testcases/rsc_dep10.xml @@ -1,44 +1,36 @@ - - - - - - - - - - + + diff --git a/crm/pengine/testcases/rsc_dep5.xml b/crm/pengine/testcases/rsc_dep5.xml index bb6a1508ad..27a42e8657 100644 --- a/crm/pengine/testcases/rsc_dep5.xml +++ b/crm/pengine/testcases/rsc_dep5.xml @@ -1,46 +1,46 @@ - + diff --git a/crm/pengine/utils.c b/crm/pengine/utils.c index 02b2e18693..3fe0a3a088 100644 --- a/crm/pengine/utils.c +++ b/crm/pengine/utils.c @@ -1,534 +1,378 @@ /* $Id: utils.c,v 1.147 2006/07/05 14:20:02 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include /* only for rsc_colocation constraints */ rsc_colocation_t * invert_constraint(rsc_colocation_t *constraint) { rsc_colocation_t *inverted_con = NULL; crm_debug_3("Inverting constraint"); if(constraint == NULL) { pe_err("Cannot invert NULL constraint"); return NULL; } crm_malloc0(inverted_con, sizeof(rsc_colocation_t)); if(inverted_con == NULL) { return NULL; } inverted_con->id = constraint->id; - inverted_con->strength = constraint->strength; + inverted_con->score = constraint->score; /* swap the direction */ inverted_con->rsc_lh = constraint->rsc_rh; inverted_con->rsc_rh = constraint->rsc_lh; inverted_con->state_lh = constraint->state_rh; inverted_con->state_rh = constraint->state_lh; crm_action_debug_3( print_rsc_colocation("Inverted constraint", inverted_con, FALSE)); return inverted_con; } -/* - * Create a new color with the contents of "nodes" as the list of - * possible nodes that resources with this color can be run on. - * - * Typically, when creating a color you will provide the node list from - * the resource you will first assign the color to. - * - * If "colors" != NULL, it will be added to that list - * If "resources" != NULL, it will be added to every provisional resource - * in that list - */ -color_t * -create_color( - pe_working_set_t *data_set, resource_t *resource, GListPtr node_list) -{ - color_t *new_color = NULL; - - crm_debug_5("Creating color"); - crm_malloc0(new_color, sizeof(color_t)); - if(new_color == NULL) { - return NULL; - } - - new_color->id = data_set->color_id++; - new_color->local_weight = 1.0; - - crm_debug_5("Creating color details"); - crm_malloc0(new_color->details, sizeof(struct color_shared_s)); - - if(new_color->details == NULL) { - crm_free(new_color); - return NULL; - } - - new_color->details->id = new_color->id; - new_color->details->highest_priority = -1; - new_color->details->chosen_node = NULL; - new_color->details->candidate_nodes = NULL; - new_color->details->allocated_resources = NULL; - new_color->details->pending = TRUE; - - if(resource != NULL) { - crm_debug_5("populating node list"); - new_color->details->highest_priority = resource->priority; - new_color->details->candidate_nodes = - node_list_dup(node_list, TRUE, TRUE); - } - - crm_action_debug_3(print_color("Created color", new_color, TRUE)); - - CRM_CHECK(data_set != NULL, return NULL); - data_set->colors = g_list_append(data_set->colors, new_color); - return new_color; -} - -color_t * -copy_color(color_t *a_color) -{ - color_t *color_copy = NULL; - - if(a_color == NULL) { - pe_err("Cannot copy NULL"); - return NULL; - } - - crm_malloc0(color_copy, sizeof(color_t)); - if(color_copy != NULL) { - color_copy->id = a_color->id; - color_copy->details = a_color->details; - color_copy->local_weight = 1.0; - } - return color_copy; -} - -gint gslist_color_compare(gconstpointer a, gconstpointer b); -color_t * -find_color(GListPtr candidate_colors, color_t *other_color) -{ - GListPtr tmp = g_list_find_custom(candidate_colors, other_color, - gslist_color_compare); - if(tmp != NULL) { - return (color_t *)tmp->data; - } - return NULL; -} - - -gint gslist_color_compare(gconstpointer a, gconstpointer b) -{ - const color_t *color_a = (const color_t*)a; - const color_t *color_b = (const color_t*)b; - -/* crm_debug_5("%d vs. %d", a?color_a->id:-2, b?color_b->id:-2); */ - if(a == b) { - return 0; - } else if(a == NULL || b == NULL) { - return 1; - } else if(color_a->id == color_b->id) { - return 0; - } - return 1; -} gint sort_cons_strength(gconstpointer a, gconstpointer b) { const rsc_colocation_t *rsc_constraint1 = (const rsc_colocation_t*)a; const rsc_colocation_t *rsc_constraint2 = (const rsc_colocation_t*)b; if(a == NULL) { return 1; } if(b == NULL) { return -1; } - if(rsc_constraint1->strength > rsc_constraint2->strength) { + if(rsc_constraint1->score > rsc_constraint2->score) { return 1; } - if(rsc_constraint1->strength < rsc_constraint2->strength) { + if(rsc_constraint1->score < rsc_constraint2->score) { return -1; } return 0; } -void -print_color_details(const char *pre_text, - struct color_shared_s *color, - gboolean details) -{ - if(color == NULL) { - crm_debug_4("%s%s: ", - pre_text==NULL?"":pre_text, - pre_text==NULL?"":": "); - return; - } - crm_debug_4("%s%sColor %d: node=%s (from %d candidates)", - pre_text==NULL?"":pre_text, - pre_text==NULL?"":": ", - color->id, - color->chosen_node==NULL?"":color->chosen_node->details->uname, - g_list_length(color->candidate_nodes)); - if(details) { - slist_iter(node, node_t, color->candidate_nodes, lpc, - print_node("\t", node, FALSE)); - } -} - -void -print_color(const char *pre_text, color_t *color, gboolean details) -{ - if(color == NULL) { - crm_debug_4("%s%s: ", - pre_text==NULL?"":pre_text, - pre_text==NULL?"":": "); - return; - } - crm_debug_4("%s%sColor %d: (weight=%d, node=%s, possible=%d)", - pre_text==NULL?"":pre_text, - pre_text==NULL?"":": ", - color->id, - color->local_weight, - safe_val5("",color,details,chosen_node,details,uname), - g_list_length(color->details->candidate_nodes)); - if(details) { - print_color_details("\t", color->details, details); - } -} - void print_rsc_to_node(const char *pre_text, rsc_to_node_t *cons, gboolean details) { if(cons == NULL) { crm_debug_4("%s%s: ", pre_text==NULL?"":pre_text, pre_text==NULL?"":": "); return; } crm_debug_4("%s%s%s Constraint %s (%p) - %d nodes:", pre_text==NULL?"":pre_text, pre_text==NULL?"":": ", "rsc_to_node", cons->id, cons, g_list_length(cons->node_list_rh)); if(details == FALSE) { crm_debug_4("\t%s (node placement rule)", safe_val3(NULL, cons, rsc_lh, id)); slist_iter( node, node_t, cons->node_list_rh, lpc, print_node("\t\t-->", node, FALSE) ); } } void print_rsc_colocation(const char *pre_text, rsc_colocation_t *cons, gboolean details) { if(cons == NULL) { crm_debug_4("%s%s: ", pre_text==NULL?"":pre_text, pre_text==NULL?"":": "); return; } crm_debug_4("%s%s%s Constraint %s (%p):", pre_text==NULL?"":pre_text, pre_text==NULL?"":": ", XML_CONS_TAG_RSC_DEPEND, cons->id, cons); if(details == FALSE) { - crm_debug_4("\t%s --> %s, %s", + crm_debug_4("\t%s --> %s, %d", safe_val3(NULL, cons, rsc_lh, id), safe_val3(NULL, cons, rsc_rh, id), - strength2text(cons->strength)); + cons->score); } } -void -pe_free_colors(GListPtr colors) -{ - GListPtr iterator = colors; - while(iterator != NULL) { - color_t *color = (color_t *)iterator->data; - struct color_shared_s *details = color->details; - iterator = iterator->next; - - if(details != NULL) { - pe_free_shallow(details->candidate_nodes); - pe_free_shallow_adv(details->allocated_resources, FALSE); - crm_free(details->chosen_node); - crm_free(details); - } - crm_free(color); - } - if(colors != NULL) { - g_list_free(colors); - } -} - - void pe_free_ordering(GListPtr constraints) { GListPtr iterator = constraints; while(iterator != NULL) { order_constraint_t *order = iterator->data; iterator = iterator->next; crm_free(order->lh_action_task); crm_free(order->rh_action_task); crm_free(order); } if(constraints != NULL) { g_list_free(constraints); } } void pe_free_rsc_to_node(GListPtr constraints) { GListPtr iterator = constraints; while(iterator != NULL) { rsc_to_node_t *cons = iterator->data; iterator = iterator->next; pe_free_shallow(cons->node_list_rh); crm_free(cons); } if(constraints != NULL) { g_list_free(constraints); } } rsc_to_node_t * rsc2node_new(const char *id, resource_t *rsc, int node_weight, node_t *foo_node, pe_working_set_t *data_set) { rsc_to_node_t *new_con = NULL; if(rsc == NULL || id == NULL) { pe_err("Invalid constraint %s for rsc=%p", crm_str(id), rsc); return NULL; } crm_malloc0(new_con, sizeof(rsc_to_node_t)); if(new_con != NULL) { new_con->id = id; new_con->rsc_lh = rsc; new_con->node_list_rh = NULL; new_con->role_filter = RSC_ROLE_UNKNOWN; if(foo_node != NULL) { node_t *copy = node_copy(foo_node); copy->weight = node_weight; new_con->node_list_rh = g_list_append(NULL, copy); } else { CRM_CHECK(node_weight == 0, return NULL); } data_set->placement_constraints = g_list_append( data_set->placement_constraints, new_con); rsc->rsc_location = g_list_append( rsc->rsc_location, new_con); } return new_con; } - -const char * -strength2text(enum con_strength strength) -{ - const char *result = ""; - switch(strength) - { - case pecs_ignore: - result = "ignore"; - break; - case pecs_must: - result = XML_STRENGTH_VAL_MUST; - break; - case pecs_must_not: - result = XML_STRENGTH_VAL_MUSTNOT; - break; - case pecs_startstop: - result = "start/stop"; - break; - } - return result; -} - const char * ordering_type2text(enum pe_ordering type) { const char *result = ""; switch(type) { case pe_ordering_manditory: result = "manditory"; break; case pe_ordering_restart: result = "restart"; break; case pe_ordering_recover: result = "recover"; break; case pe_ordering_optional: result = "optional"; break; case pe_ordering_postnotify: result = "post_notify"; break; } return result; } gboolean can_run_resources(const node_t *node) { if(node->details->online == FALSE || node->details->shutdown || node->details->unclean || node->details->standby) { crm_debug_2("%s: online=%d, unclean=%d, standby=%d", node->details->uname, node->details->online, node->details->unclean, node->details->standby); return FALSE; } return TRUE; } /* return -1 if 'a' is more preferred * return 1 if 'b' is more preferred */ gint sort_node_weight(gconstpointer a, gconstpointer b) { const node_t *node1 = (const node_t*)a; const node_t *node2 = (const node_t*)b; int node1_weight = 0; int node2_weight = 0; if(a == NULL) { return 1; } if(b == NULL) { return -1; } node1_weight = node1->weight; node2_weight = node2->weight; if(can_run_resources(node1) == FALSE) { node1_weight = -INFINITY; } if(can_run_resources(node2) == FALSE) { node2_weight = -INFINITY; } if(node1_weight > node2_weight) { crm_debug_3("%s (%d) > %s (%d) : weight", node1->details->uname, node1_weight, node2->details->uname, node2_weight); return -1; } if(node1_weight < node2_weight) { crm_debug_3("%s (%d) < %s (%d) : weight", node1->details->uname, node1_weight, node2->details->uname, node2_weight); return 1; } crm_debug_3("%s (%d) == %s (%d) : weight", node1->details->uname, node1_weight, node2->details->uname, node2_weight); /* now try to balance resources across the cluster */ if(node1->details->num_resources < node2->details->num_resources) { crm_debug_3("%s (%d) < %s (%d) : resources", node1->details->uname, node1->details->num_resources, node2->details->uname, node2->details->num_resources); return -1; } else if(node1->details->num_resources > node2->details->num_resources) { crm_debug_3("%s (%d) > %s (%d) : resources", node1->details->uname, node1->details->num_resources, node2->details->uname, node2->details->num_resources); return 1; } crm_debug_4("%s = %s", node1->details->uname, node2->details->uname); return 0; } -gint sort_color_weight(gconstpointer a, gconstpointer b) -{ - const color_t *color1 = (const color_t*)a; - const color_t *color2 = (const color_t*)b; - int color1_weight = 0; - int color2_weight = 0; +gboolean +native_assign_node(resource_t *rsc, GListPtr nodes, node_t *chosen) +{ + int multiple = 0; + CRM_ASSERT(rsc->variant == pe_native); - if(a == NULL) { return 1; } - if(b == NULL) { return -1; } + if(chosen == NULL) { + crm_debug("Could not allocate a node for %s", rsc->id); + rsc->next_role = RSC_ROLE_STOPPED; + return FALSE; - color1_weight = color1->local_weight; - color2_weight = color2->local_weight; + } else if(chosen->details->unclean + || chosen->details->standby + || chosen->details->shutdown) { + crm_debug("All nodes for color %s are unavailable" + ", unclean or shutting down", rsc->id); + rsc->next_role = RSC_ROLE_STOPPED; + return FALSE; + + } else if(chosen->weight < 0) { + crm_debug("Even highest ranked node for %s, had weight %d", + rsc->id, chosen->weight); + rsc->next_role = RSC_ROLE_STOPPED; + return FALSE; + } - if(color1_weight > color2_weight) { - crm_debug_3("%d (%d) > %d (%d) : weight", - color1->id, color1_weight, - color2->id, color2_weight); - return -1; + if(rsc->next_role == RSC_ROLE_UNKNOWN) { + rsc->next_role = RSC_ROLE_STARTED; } - if(color1_weight < color2_weight) { - crm_debug_3("%d (%d) < %d (%d) : weight", - color1->id, color1_weight, - color2->id, color2_weight); - return 1; + slist_iter(candidate, node_t, nodes, lpc, + crm_debug("Color %s, Node[%d] %s: %d", rsc->id, lpc, + candidate->details->uname, candidate->weight); + if(chosen->weight > 0 + && candidate->details->unclean == FALSE + && candidate->weight == chosen->weight) { + multiple++; + } else { + break; + } + ); + + if(multiple > 1) { + int log_level = LOG_INFO; + char *score = score2char(chosen->weight); + if(chosen->weight >= INFINITY) { + log_level = LOG_WARNING; + } + + crm_log_maybe(log_level, "%d nodes with equal score (%s) for" + " running the listed resources (chose %s):", + multiple, score, chosen->details->uname); + crm_free(score); } - - crm_debug_3("%d (%d) == %d (%d) : weight", - color1->id, color1_weight, - color2->id, color2_weight); - if(color1->id < color2->id) { - return -1; - - } else if(color1->id > color2->id) { - return 1; + /* todo: update the old node for each resource to reflect its + * new resource count + */ + + if(rsc->allocated_to) { + node_t *old = rsc->allocated_to; + old->details->allocated_rsc = g_list_remove(old->details->allocated_rsc, rsc); + old->details->num_resources--; + old->count--; } - CRM_CHECK(color1->id != color2->id, - crm_err("Color %d duplicated in list", color1->id)); - return 0; + + crm_debug("Assigning %s to %s", chosen->details->uname, rsc->id); + rsc->provisional = FALSE; + crm_free(rsc->allocated_to); + rsc->allocated_to = node_copy(chosen); + + chosen->details->allocated_rsc = g_list_append(chosen->details->allocated_rsc, rsc); + chosen->details->num_resources++; + chosen->count++; + + return TRUE; } diff --git a/crm/pengine/utils.h b/crm/pengine/utils.h index 8d23c20a71..4916f11fd9 100644 --- a/crm/pengine/utils.h +++ b/crm/pengine/utils.h @@ -1,79 +1,56 @@ /* $Id: utils.h,v 1.3 2006/07/05 14:20:02 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef PENGINE_AUTILS__H #define PENGINE_AUTILS__H /* Constraint helper functions */ extern rsc_colocation_t *invert_constraint(rsc_colocation_t *constraint); extern rsc_to_node_t *copy_constraint(rsc_to_node_t *constraint); - -/* Color helper functions */ -extern void add_color_to_rsc(resource_t *rsc, color_t *color); - -extern color_t *find_color(GListPtr candidate_colors, color_t *other_color); - -extern color_t *create_color( - pe_working_set_t *data_set, resource_t *resource, GListPtr resources); - -extern color_t *copy_color(color_t *a_color); - extern void print_rsc_to_node( const char *pre_text, rsc_to_node_t *cons, gboolean details); extern void print_rsc_colocation( const char *pre_text, rsc_colocation_t *cons, gboolean details); -extern void print_color( - const char *pre_text, color_t *color, gboolean details); - -extern void print_color_details( - const char *pre_text, struct color_shared_s *color, gboolean details); - extern rsc_to_node_t *rsc2node_new( const char *id, resource_t *rsc, int weight, node_t *node, pe_working_set_t *data_set); -extern void pe_free_colors(GListPtr colors); extern void pe_free_rsc_to_node(GListPtr constraints); extern void pe_free_ordering(GListPtr constraints); -extern const char *strength2text(enum con_strength strength); extern const char *ordering_type2text(enum pe_ordering type); extern gboolean rsc_colocation_new( - const char *id, enum con_strength strength, + const char *id, int score, resource_t *rsc_lh, resource_t *rsc_rh, const char *state_lh, const char *state_rh); -extern gboolean create_ordering( - const char *id, enum con_strength strength, - resource_t *rsc_lh, resource_t *rsc_rh, pe_working_set_t *data_set); - extern rsc_to_node_t *generate_location_rule( resource_t *rsc, crm_data_t *location_rule, pe_working_set_t *data_set); extern gint sort_cons_strength(gconstpointer a, gconstpointer b); extern gint sort_node_weight(gconstpointer a, gconstpointer b); -extern gint sort_color_weight(gconstpointer a, gconstpointer b); extern gboolean can_run_resources(const node_t *node); +extern gboolean native_assign_node(resource_t *rsc, GListPtr candidates, node_t *chosen); #endif diff --git a/crm/tengine/events.c b/crm/tengine/events.c index 19d9d993cb..0fd0cc7698 100644 --- a/crm/tengine/events.c +++ b/crm/tengine/events.c @@ -1,550 +1,552 @@ /* $Id: events.c,v 1.23 2006/08/14 09:14:45 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include #include crm_data_t *need_abort(crm_data_t *update); void process_graph_event(crm_data_t *event, const char *event_node); int match_graph_event( crm_action_t *action, crm_data_t *event, const char *event_node); crm_data_t * need_abort(crm_data_t *update) { crm_data_t *section_xml = NULL; const char *section = NULL; if(update == NULL) { return NULL; } section = XML_CIB_TAG_NODES; section_xml = get_object_root(section, update); xml_child_iter(section_xml, child, return section_xml; ); section = XML_CIB_TAG_RESOURCES; section_xml = get_object_root(section, update); xml_child_iter(section_xml, child, return section_xml; ); section = XML_CIB_TAG_CONSTRAINTS; section_xml = get_object_root(section, update); xml_child_iter(section_xml, child, return section_xml; ); section = XML_CIB_TAG_CRMCONFIG; section_xml = get_object_root(section, update); xml_child_iter(section_xml, child, return section_xml; ); return NULL; } static gboolean fail_incompletable_actions(crm_graph_t *graph, const char *down_node) { const char *target = NULL; crm_data_t *last_action = NULL; slist_iter( synapse, synapse_t, graph->synapses, lpc, if (synapse->confirmed) { continue; } slist_iter( action, crm_action_t, synapse->actions, lpc, if(action->type == action_type_pseudo || action->confirmed) { continue; } target = crm_element_value(action->xml, XML_LRM_ATTR_TARGET); if(safe_str_eq(target, down_node)) { action->failed = TRUE; last_action = action->xml; update_graph(graph, action); crm_notice("Action %d (%s) is scheduled for %s (offline)", action->id, ID(action->xml), down_node); } ); ); if(last_action != NULL) { crm_warn("Node %s shutdown resulted in un-runnable actions", down_node); abort_transition(INFINITY, tg_restart, "Node failure", last_action); return TRUE; } return FALSE; } gboolean extract_event(crm_data_t *msg) { int shutdown = 0; const char *event_node = NULL; /* [cib fragment] ... */ crm_debug_4("Extracting event from %s", crm_element_name(msg)); xml_child_iter_filter( msg, node_state, XML_CIB_TAG_STATE, crm_data_t *attrs = NULL; crm_data_t *resources = NULL; const char *ccm_state = crm_element_value( node_state, XML_CIB_ATTR_INCCM); const char *crmd_state = crm_element_value( node_state, XML_CIB_ATTR_CRMDSTATE); /* Transient node attribute changes... */ event_node = crm_element_value(node_state, XML_ATTR_ID); crm_debug_2("Processing state update from %s", event_node); crm_log_xml_debug_3(node_state, "Processing"); attrs = find_xml_node( node_state, XML_TAG_TRANSIENT_NODEATTRS, FALSE); if(attrs != NULL) { crm_info("Aborting on "XML_TAG_TRANSIENT_NODEATTRS" changes for %s", event_node); abort_transition(INFINITY, tg_restart, XML_TAG_TRANSIENT_NODEATTRS, attrs); } resources = find_xml_node(node_state, XML_CIB_TAG_LRM, FALSE); resources = find_xml_node( resources, XML_LRM_TAG_RESOURCES, FALSE); /* LRM resource update... */ xml_child_iter( resources, rsc, xml_child_iter( rsc, rsc_op, crm_log_xml_debug_3(rsc_op, "Processing resource update"); process_graph_event(rsc_op, event_node); ); ); /* * node state update... possibly from a shutdown we requested */ if(safe_str_eq(ccm_state, XML_BOOLEAN_FALSE) || safe_str_eq(crmd_state, CRMD_JOINSTATE_DOWN)) { crm_action_t *shutdown = NULL; shutdown = match_down_event(0, event_node, NULL); if(shutdown != NULL) { update_graph(transition_graph, shutdown); trigger_graph(); } else { crm_info("Stonith/shutdown of %s not matched", event_node); abort_transition(INFINITY, tg_restart, "Node failure", node_state); } fail_incompletable_actions(transition_graph, event_node); } shutdown = 0; ha_msg_value_int(node_state, XML_CIB_ATTR_SHUTDOWN, &shutdown); if(shutdown != 0) { crm_info("Aborting on "XML_CIB_ATTR_SHUTDOWN" attribute for %s", event_node); abort_transition(INFINITY, tg_restart, "Shutdown request", node_state); } ); return TRUE; } static void update_failcount(crm_data_t *event, const char *event_node, int rc) { char *attr_name = NULL; char *task = NULL; char *rsc_id = NULL; const char *on_node = event_node; const char *on_uuid = event_node; int interval = 0; if(rc == 99) { /* this is an internal code for "we're busy, try again" */ return; } CRM_CHECK(on_uuid != NULL, return); - CRM_CHECK(parse_op_key(ID(event), &rsc_id, &task, &interval),return); + CRM_CHECK(parse_op_key(ID(event), &rsc_id, &task, &interval), + crm_err("Couldn't parse: %s", ID(event)); + return); CRM_CHECK(task != NULL, crm_free(rsc_id); return); CRM_CHECK(rsc_id != NULL, crm_free(task); return); /* CRM_CHECK(on_node != NULL, return); */ if(interval > 0) { attr_name = crm_concat("fail-count", rsc_id, '-'); crm_warn("Updating failcount for %s on %s after failed %s: rc=%d", rsc_id, on_node, task, rc); update_attr(te_cib_conn, cib_none, XML_CIB_TAG_STATUS, on_uuid, NULL,NULL, attr_name, XML_NVPAIR_ATTR_VALUE"++"); crm_free(attr_name); } crm_free(rsc_id); crm_free(task); } static int status_from_rc(crm_action_t *action, int orig_status, int rc) { int status = orig_status; const char *target_rc_s = g_hash_table_lookup( action->params, crm_meta_name(XML_ATTR_TE_TARGET_RC)); if(target_rc_s != NULL) { int target_rc = 0; crm_debug_2("Target rc: %s vs. %d", target_rc_s, rc); target_rc = crm_parse_int(target_rc_s, NULL); if(target_rc == rc) { crm_debug_2("Target rc: == %d", rc); if(status != LRM_OP_DONE) { crm_debug_2("Re-mapping op status to" " LRM_OP_DONE for rc=%d", rc); status = LRM_OP_DONE; } } else { crm_debug_2("Target rc: != %d", rc); if(status != LRM_OP_ERROR) { crm_info("Re-mapping op status to" " LRM_OP_ERROR for rc=%d", rc); status = LRM_OP_ERROR; } } } /* 99 is the code we use for direct nack's */ if(rc != 99 && status != LRM_OP_DONE) { const char *task, *uname; task = crm_element_value(action->xml, XML_LRM_ATTR_TASK); uname = crm_element_value(action->xml, XML_LRM_ATTR_TARGET); crm_warn("Action %s on %s failed (target: %s vs. rc: %d): %s", task, uname, target_rc_s, rc, op_status2text(status)); } return status; } /* * returns the ID of the action if a match is found * returns -1 if a match was not found * returns -2 if a match was found but the action failed (and was * not allowed to) */ int match_graph_event( crm_action_t *action, crm_data_t *event, const char *event_node) { const char *allow_fail = NULL; const char *this_action = NULL; const char *this_node = NULL; const char *this_uname = NULL; const char *magic = NULL; const char *this_event; char *update_te_uuid = NULL; const char *update_event; int op_status_i = -3; int op_rc_i = -3; int transition_i = -1; CRM_CHECK(event != NULL, return -1); crm_debug_3("Processing \"%s\" change", crm_element_name(event)); update_event = crm_element_value(event, XML_ATTR_ID); magic = crm_element_value(event, XML_ATTR_TRANSITION_MAGIC); CRM_CHECK(magic != NULL, return -2); this_action = crm_element_value(action->xml, XML_LRM_ATTR_TASK); this_uname = crm_element_value(action->xml, XML_LRM_ATTR_TARGET); this_event = crm_element_value(action->xml, XML_LRM_ATTR_TASK_KEY); this_node = crm_element_value(action->xml, XML_LRM_ATTR_TARGET_UUID); CRM_CHECK(this_event != NULL, return -2); if(safe_str_neq(this_event, update_event)) { crm_debug_2("Action %d : Event mismatch %s vs. %s", action->id, this_event, update_event); return -1; } else if(safe_str_neq(this_node, event_node)) { crm_debug_2("Action %d : Node mismatch %s (%s) vs. %s", action->id, this_node, this_uname, event_node); return -1; } crm_debug_2("Matched action (%d) %s", action->id, this_event); CRM_CHECK(decode_transition_magic( magic, &update_te_uuid, &transition_i, &op_status_i, &op_rc_i), return -2); op_status_i = status_from_rc(action, op_status_i, op_rc_i); if(op_status_i != LRM_OP_DONE) { update_failcount(event, event_node, op_rc_i); } if(transition_i == -1) { /* we never expect these - recompute */ crm_err("Detected action %s initiated outside of a transition", this_event); crm_log_message(LOG_ERR, event); crm_free(update_te_uuid); return -2; } else if(safe_str_neq(update_te_uuid, te_uuid)) { crm_info("Detected action %s from a different transitioner:" " %s vs. %s", this_event, update_te_uuid, te_uuid); crm_log_message(LOG_INFO, event); crm_free(update_te_uuid); return -3; } else if(transition_graph->id != transition_i) { crm_warn("Detected an action %s from a different transition:" " %d vs. %d", this_event, transition_i, transition_graph->id); crm_log_message(LOG_INFO, event); crm_free(update_te_uuid); return -4; } crm_free(update_te_uuid); /* stop this event's timer if it had one */ stop_te_timer(action->timer); action->confirmed = TRUE; /* Process OP status */ switch(op_status_i) { case -3: crm_err("Action returned the same as last time..." " whatever that was!"); crm_log_message(LOG_ERR, event); break; case LRM_OP_PENDING: crm_debug("Ignoring pending operation"); return -5; break; case LRM_OP_DONE: break; case LRM_OP_ERROR: case LRM_OP_TIMEOUT: case LRM_OP_NOTSUPPORTED: action->failed = TRUE; break; case LRM_OP_CANCELLED: /* do nothing?? */ crm_err("Dont know what to do for cancelled ops yet"); break; default: action->failed = TRUE; crm_err("Unsupported action result: %d", op_status_i); } update_graph(transition_graph, action); trigger_graph(); if(action->failed) { allow_fail = g_hash_table_lookup( action->params, crm_meta_name(XML_ATTR_TE_ALLOWFAIL)); if(crm_is_true(allow_fail)) { action->failed = FALSE; } } if(action->failed) { abort_transition(action->synapse->priority+1, tg_restart, "Event failed", event); } else if(transition_graph->complete) { abort_transition(INFINITY, tg_restart,"No active graph", event); } te_log_action(LOG_INFO, "Action %s (%d) confirmed", this_event, action->id); return action->id; } crm_action_t * match_down_event(int id, const char *target, const char *filter) { const char *this_action = NULL; const char *this_node = NULL; crm_action_t *match = NULL; slist_iter( synapse, synapse_t, transition_graph->synapses, lpc, /* lookup event */ slist_iter( action, crm_action_t, synapse->actions, lpc2, if(id > 0 && action->id == id) { match = action; break; } this_action = crm_element_value( action->xml, XML_LRM_ATTR_TASK); if(action->type != action_type_crm) { continue; } else if(safe_str_eq(this_action, CRM_OP_LRM_REFRESH)){ continue; } else if(filter != NULL && safe_str_neq(this_action, filter)) { continue; } this_node = crm_element_value( action->xml, XML_LRM_ATTR_TARGET_UUID); if(this_node == NULL) { crm_log_xml_err(action->xml, "No node uuid"); } if(safe_str_neq(this_node, target)) { crm_debug("Action %d : Node mismatch: %s", action->id, this_node); continue; } match = action; break; ); if(match != NULL) { /* stop this event's timer if it had one */ break; } ); if(match != NULL) { /* stop this event's timer if it had one */ crm_debug("Match found for action %d: %s on %s", id, crm_element_value(match->xml, XML_LRM_ATTR_TASK_KEY), target); stop_te_timer(match->timer); match->confirmed = TRUE; } else if(id > 0) { crm_err("No match for action %d", id); } else { crm_warn("No match for shutdown action on %s", target); } return match; } void process_graph_event(crm_data_t *event, const char *event_node) { int rc = -1; const char *magic = NULL; const char *rsc_id = NULL; CRM_ASSERT(event != NULL); rsc_id = crm_element_value(event, XML_ATTR_ID); magic = crm_element_value(event, XML_ATTR_TRANSITION_MAGIC); if(magic == NULL) { crm_log_xml_debug_2(event, "Skipping \"non-change\""); return; } else { crm_debug_2("Processing CIB update: %s on %s: %s", rsc_id, event_node, magic); } slist_iter( synapse, synapse_t, transition_graph->synapses, lpc, /* lookup event */ slist_iter( action, crm_action_t, synapse->actions, lpc2, rc = match_graph_event(action, event, event_node); if(rc >= 0) { crm_log_xml_debug_2(event, "match:found"); } else if(rc == -5) { crm_log_xml_debug_2(event, "match:pending"); } else if(rc != -1) { crm_warn("Search for %s terminated: %d", ID(event), rc); abort_transition(INFINITY, tg_restart, "Unexpected event", event); } if(rc != -1) { return; } ); ); /* unexpected event, trigger a pe-recompute */ /* possibly do this only for certain types of actions */ crm_warn("Event not found."); if(rc != EXECRA_OK) { update_failcount(event, event_node, rc); } crm_log_xml_info(event, "match:not-found"); abort_transition(INFINITY, tg_restart, "Unexpected event", event); return; } diff --git a/include/crm/pengine/status.h b/include/crm/pengine/status.h index 7ad2c8c44b..44525aa4d8 100644 --- a/include/crm/pengine/status.h +++ b/include/crm/pengine/status.h @@ -1,222 +1,217 @@ /* $Id: status.h,v 1.3 2006/06/21 14:48:01 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef PENGINE_STATUS__H #define PENGINE_STATUS__H #include #include #include typedef struct node_s node_t; -typedef struct color_s color_t; typedef struct action_s action_t; typedef struct resource_s resource_t; typedef struct action_wrapper_s action_wrapper_t; typedef enum no_quorum_policy_e { no_quorum_freeze, no_quorum_stop, no_quorum_ignore } no_quorum_policy_t; enum node_type { node_ping, node_member }; enum pe_restart { pe_restart_restart, pe_restart_ignore }; typedef struct pe_working_set_s { crm_data_t *input; ha_time_t *now; /* options extracted from the input */ char *transition_idle_timeout; char *dc_uuid; node_t *dc_node; gboolean have_quorum; gboolean stonith_enabled; const char *stonith_action; gboolean symmetric_cluster; gboolean is_managed_default; gboolean remove_after_stop; gboolean stop_rsc_orphans; gboolean stop_action_orphans; int default_resource_stickiness; int default_resource_fail_stickiness; no_quorum_policy_t no_quorum_policy; GHashTable *config_hash; - /* intermediate steps */ - color_t *no_color; - GListPtr nodes; GListPtr resources; GListPtr placement_constraints; GListPtr ordering_constraints; - GListPtr colors; GListPtr actions; /* stats */ int num_synapse; int max_valid_nodes; int order_id; int action_id; - int color_id; /* final output */ crm_data_t *graph; } pe_working_set_t; struct node_shared_s { const char *id; const char *uname; gboolean online; gboolean standby; gboolean unclean; gboolean shutdown; gboolean expected_up; gboolean is_dc; int num_resources; GListPtr running_rsc; /* resource_t* */ + GListPtr allocated_rsc; /* resource_t* */ GHashTable *attrs; /* char* => char* */ enum node_type type; }; struct node_s { int weight; gboolean fixed; + int count; struct node_shared_s *details; }; #include struct resource_s { char *id; char *clone_name; char *long_name; crm_data_t *xml; crm_data_t *ops_xml; resource_t *parent; void *variant_opaque; enum pe_obj_types variant; resource_object_functions_t *fns; resource_alloc_functions_t *cmds; enum rsc_recovery_type recovery_type; enum pe_restart restart_type; int priority; int stickiness; int fail_stickiness; int effective_priority; gboolean notify; gboolean is_managed; gboolean starting; gboolean stopping; gboolean runnable; gboolean provisional; gboolean globally_unique; + gboolean is_allocating; gboolean failed; gboolean start_pending; gboolean orphan; - GListPtr candidate_colors; /* color_t* */ GListPtr rsc_cons; /* rsc_colocation_t* */ GListPtr rsc_location; /* rsc_to_node_t* */ GListPtr actions; /* action_t* */ - color_t *color; - GListPtr colors; /* color_t* */ + node_t *allocated_to; GListPtr running_on; /* node_t* */ GListPtr known_on; /* node_t* */ GListPtr allowed_nodes; /* node_t* */ enum rsc_role_e role; enum rsc_role_e next_role; GHashTable *meta; GHashTable *parameters; }; struct action_s { int id; int priority; resource_t *rsc; void *rsc_opaque; node_t *node; const char *task; char *uuid; crm_data_t *op_entry; gboolean pseudo; gboolean runnable; gboolean optional; gboolean failure_is_fatal; enum rsc_start_requirement needs; enum action_fail_response on_fail; enum rsc_role_e fail_role; gboolean dumped; gboolean processed; action_t *pre_notify; action_t *pre_notified; action_t *post_notify; action_t *post_notified; int seen_count; GHashTable *meta; GHashTable *extra; GHashTable *notify_keys; /* do NOT free */ GListPtr actions_before; /* action_warpper_t* */ GListPtr actions_after; /* action_warpper_t* */ }; struct action_wrapper_s { enum pe_ordering type; action_t *action; }; gboolean cluster_status(pe_working_set_t *data_set); extern void set_working_set_defaults(pe_working_set_t *data_set); extern void cleanup_calculations(pe_working_set_t *data_set); extern resource_t *pe_find_resource(GListPtr rsc_list, const char *id_rh); #endif diff --git a/lib/crm/common/utils.c b/lib/crm/common/utils.c index 2f19ad33fa..d01430b418 100644 --- a/lib/crm/common/utils.c +++ b/lib/crm/common/utils.c @@ -1,1683 +1,1722 @@ /* $Id: utils.c,v 1.64 2006/08/14 09:06:31 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #ifndef _GNU_SOURCE # define _GNU_SOURCE #endif #include #include #include #include #include #include - +#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef MAXLINE # define MAXLINE 512 #endif static uint ref_counter = 0; gboolean crm_assert_failed = FALSE; unsigned int crm_log_level = LOG_INFO; gboolean crm_config_error = FALSE; gboolean crm_config_warning = FALSE; void crm_set_env_options(void); gboolean check_time(const char *value) { if(crm_get_msec(value) < 5000) { return FALSE; } return TRUE; } gboolean check_timer(const char *value) { if(crm_get_msec(value) < 0) { return FALSE; } return TRUE; } gboolean check_boolean(const char *value) { int tmp = FALSE; if(crm_str_to_boolean(value, &tmp) != 1) { return FALSE; } return TRUE; } gboolean check_number(const char *value) { errno = 0; crm_int_helper(value, NULL); if(errno != 0) { return FALSE; } return TRUE; } const char * cluster_option(GHashTable* options, gboolean(*validate)(const char*), const char *name, const char *old_name, const char *def_value) { const char *value = NULL; CRM_ASSERT(name != NULL); CRM_ASSERT(options != NULL); value = g_hash_table_lookup(options, name); if(value == NULL && old_name) { value = g_hash_table_lookup(options, old_name); if(value != NULL) { crm_config_warn("Using deprecated name '%s' for" " cluster option '%s'", old_name, name); } } if(value == NULL) { g_hash_table_insert( options, crm_strdup(name), crm_strdup(def_value)); value = g_hash_table_lookup(options, name); crm_notice("Using default value '%s' for cluster option '%s'", value, name); } if(validate && validate(value) == FALSE) { crm_config_err("Value '%s' for cluster option '%s' is invalid." " Defaulting to %s", value, name, def_value); g_hash_table_replace(options, crm_strdup(name), crm_strdup(def_value)); value = g_hash_table_lookup(options, name); } return value; } const char * get_cluster_pref(GHashTable *options, pe_cluster_option *option_list, int len, const char *name) { int lpc = 0; const char *value = NULL; gboolean found = FALSE; for(lpc = 0; lpc < len; lpc++) { if(safe_str_eq(name, option_list[lpc].name)) { found = TRUE; value = cluster_option(options, option_list[lpc].is_valid, option_list[lpc].name, option_list[lpc].alt_name, option_list[lpc].default_value); } } CRM_CHECK(found, crm_err("No option named: %s", name)); CRM_ASSERT(value != NULL); return value; } void config_metadata(const char *name, const char *version, const char *desc_short, const char *desc_long, pe_cluster_option *option_list, int len) { int lpc = 0; fprintf(stdout, "" "\n" "\n" " %s\n" " %s\n" " %s\n" " \n", name, version, desc_long, desc_short); for(lpc = 0; lpc < len; lpc++) { if(option_list[lpc].description_long == NULL && option_list[lpc].description_short == NULL) { continue; } fprintf(stdout, " \n" " %s\n" " \n" " %s%s%s\n" " \n", option_list[lpc].name, option_list[lpc].description_short, option_list[lpc].type, option_list[lpc].default_value, option_list[lpc].description_long?option_list[lpc].description_long:option_list[lpc].description_short, option_list[lpc].values?" Allowed values: ":"", option_list[lpc].values?option_list[lpc].values:""); } fprintf(stdout, " \n\n"); } void verify_all_options(GHashTable *options, pe_cluster_option *option_list, int len) { int lpc = 0; for(lpc = 0; lpc < len; lpc++) { cluster_option(options, option_list[lpc].is_valid, option_list[lpc].name, option_list[lpc].alt_name, option_list[lpc].default_value); } } char * generateReference(const char *custom1, const char *custom2) { const char *local_cust1 = custom1; const char *local_cust2 = custom2; int reference_len = 4; char *since_epoch = NULL; reference_len += 20; /* too big */ reference_len += 40; /* too big */ if(local_cust1 == NULL) { local_cust1 = "_empty_"; } reference_len += strlen(local_cust1); if(local_cust2 == NULL) { local_cust2 = "_empty_"; } reference_len += strlen(local_cust2); crm_malloc0(since_epoch, reference_len); if(since_epoch != NULL) { sprintf(since_epoch, "%s-%s-%ld-%u", local_cust1, local_cust2, (unsigned long)time(NULL), ref_counter++); } return since_epoch; } gboolean decodeNVpair(const char *srcstring, char separator, char **name, char **value) { int lpc = 0; int len = 0; const char *temp = NULL; CRM_ASSERT(name != NULL && value != NULL); *name = NULL; *value = NULL; crm_debug_4("Attempting to decode: [%s]", srcstring); if (srcstring != NULL) { len = strlen(srcstring); while(lpc <= len) { if (srcstring[lpc] == separator) { crm_malloc0(*name, lpc+1); if(*name == NULL) { break; /* and return FALSE */ } strncpy(*name, srcstring, lpc); (*name)[lpc] = '\0'; /* this sucks but as the strtok manpage says.. * it *is* a bug */ len = len-lpc; len--; if(len <= 0) { *value = NULL; } else { crm_malloc0(*value, len+1); if(*value == NULL) { crm_free(*name); break; /* and return FALSE */ } temp = srcstring+lpc+1; strncpy(*value, temp, len); (*value)[len] = '\0'; } return TRUE; } lpc++; } } if(*name != NULL) { crm_free(*name); } *name = NULL; *value = NULL; return FALSE; } char * crm_concat(const char *prefix, const char *suffix, char join) { int len = 0; char *new_str = NULL; CRM_ASSERT(prefix != NULL); CRM_ASSERT(suffix != NULL); len = strlen(prefix) + strlen(suffix) + 2; crm_malloc0(new_str, (len)); sprintf(new_str, "%s%c%s", prefix, join, suffix); new_str[len-1] = 0; return new_str; } char * generate_hash_key(const char *crm_msg_reference, const char *sys) { char *hash_key = crm_concat(sys?sys:"none", crm_msg_reference, '_'); crm_debug_3("created hash key: (%s)", hash_key); return hash_key; } char * generate_hash_value(const char *src_node, const char *src_subsys) { char *hash_value = NULL; if (src_node == NULL || src_subsys == NULL) { return NULL; } if (strcasecmp(CRM_SYSTEM_DC, src_subsys) == 0) { hash_value = crm_strdup(src_subsys); if (!hash_value) { crm_err("memory allocation failed in " "generate_hash_value()"); } return hash_value; } hash_value = crm_concat(src_node, src_subsys, '_'); crm_info("created hash value: (%s)", hash_value); return hash_value; } gboolean decode_hash_value(gpointer value, char **node, char **subsys) { char *char_value = (char*)value; int value_len = strlen(char_value); CRM_CHECK(value != NULL, return FALSE); CRM_CHECK(node != NULL, return FALSE); CRM_CHECK(subsys != NULL, return FALSE); *node = NULL; *subsys = NULL; crm_info("Decoding hash value: (%s:%d)", char_value, value_len); if (strcasecmp(CRM_SYSTEM_DC, (char*)value) == 0) { *node = NULL; *subsys = (char*)crm_strdup(char_value); CRM_CHECK(*subsys != NULL, return FALSE); crm_info("Decoded value: (%s:%d)", *subsys, (int)strlen(*subsys)); return TRUE; } else if (decodeNVpair(char_value, '_', node, subsys)) { return TRUE; } crm_free(*node); crm_free(*subsys); *node = NULL; *subsys = NULL; return FALSE; } char * crm_itoa(int an_int) { int len = 32; char *buffer = NULL; crm_malloc0(buffer, (len+1)); if(buffer != NULL) { snprintf(buffer, len, "%d", an_int); } return buffer; } extern int LogToLoggingDaemon(int priority, const char * buf, int bstrlen, gboolean use_pri_str); gboolean crm_log_init(const char *entity) { /* const char *test = "Testing log daemon connection"; */ /* Redirect messages from glib functions to our handler */ /* cl_malloc_forced_for_glib(); */ g_log_set_handler(NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG | G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL, cl_glib_msg_handler, NULL); /* and for good measure... - this enum is a bit field (!) */ g_log_set_always_fatal((GLogLevelFlags)0); /*value out of range*/ cl_log_set_entity(entity); cl_log_set_facility(LOG_LOCAL7); cl_set_corerootdir(HA_COREDIR); cl_cdtocoredir(); crm_set_env_options(); CL_SIGNAL(DEBUG_INC, alter_debug); CL_SIGNAL(DEBUG_DEC, alter_debug); return TRUE; } /* returns the old value */ unsigned int set_crm_log_level(unsigned int level) { unsigned int old = crm_log_level; while(crm_log_level < 100 && crm_log_level < level) { alter_debug(DEBUG_INC); } while(crm_log_level > 0 && crm_log_level > level) { alter_debug(DEBUG_DEC); } return old; } unsigned int get_crm_log_level(void) { return crm_log_level; } void crm_log_message_adv(int level, const char *prefix, const HA_Message *msg) { if((int)crm_log_level >= level) { do_crm_log(level, NULL, NULL, "#========= %s message start ==========#", prefix?prefix:""); if(level > LOG_DEBUG) { cl_log_message(LOG_DEBUG, msg); } else { cl_log_message(level, msg); } } } void do_crm_log(int log_level, const char *file, const char *function, const char *fmt, ...) { int log_as = log_level; gboolean do_log = FALSE; if(log_level <= (int)crm_log_level) { do_log = TRUE; if(log_level > LOG_INFO) { log_as = LOG_DEBUG; } } if(do_log) { va_list ap; int nbytes; char buf[MAXLINE]; va_start(ap, fmt); nbytes=vsnprintf(buf, MAXLINE, fmt, ap); va_end(ap); log_level -= LOG_INFO; if(log_level > 1) { if(function == NULL) { cl_log(log_as, "debug%d: %s", log_level, buf); } else { cl_log(log_as, "debug%d: %s:%s %s", log_level, function, file?file:"", buf); } } else { if(function == NULL) { cl_log(log_as, "%s", buf); } else { cl_log(log_as, "%s:%s %s", function, file?file:"", buf); } } if(nbytes > MAXLINE) { cl_log(LOG_WARNING, "Log from %s() was truncated", crm_str(function)); } } } int compare_version(const char *version1, const char *version2) { int lpc = 0; char *step1 = NULL, *step2 = NULL; char *rest1 = NULL, *rest2 = NULL; if(version1 == NULL && version2 == NULL) { return 0; } else if(version1 == NULL) { return -1; } else if(version2 == NULL) { return 1; } rest1 = crm_strdup(version1); rest2 = crm_strdup(version2); while(1) { int cmp = 0; int step1_i = 0; int step2_i = 0; char *tmp1 = NULL, *tmp2 = NULL; decodeNVpair(rest1, '.', &step1, &tmp1); decodeNVpair(rest2, '.', &step2, &tmp2); if(step1 != NULL) { step1_i = crm_parse_int(step1, NULL); } if(step2 != NULL) { step2_i = crm_parse_int(step2, NULL); } if(step1_i < step2_i){ cmp = -1; } else if (step1_i > step2_i){ cmp = 1; } crm_debug_4("compare[%d (%d)]: %d(%s) %d(%s)", lpc++, cmp, step1_i, crm_str(step1), step2_i, crm_str(step2)); crm_free(rest1); crm_free(rest2); rest1 = tmp1; rest2 = tmp2; if(step1 == NULL && step2 == NULL) { break; } crm_free(step1); crm_free(step2); if(cmp < 0) { crm_debug_3("%s < %s", version1, version2); return -1; } else if(cmp > 0) { crm_debug_3("%s > %s", version1, version2); return 1; } } crm_debug_3("%s == %s", version1, version2); return 0; } gboolean do_stderr = FALSE; void alter_debug(int nsig) { CL_SIGNAL(DEBUG_INC, alter_debug); CL_SIGNAL(DEBUG_DEC, alter_debug); switch(nsig) { case DEBUG_INC: if (crm_log_level < 100) { crm_log_level++; } break; case DEBUG_DEC: if (crm_log_level > 0) { crm_log_level--; } break; default: fprintf(stderr, "Unknown signal %d\n", nsig); cl_log(LOG_ERR, "Unknown signal %d", nsig); break; } } void g_hash_destroy_str(gpointer data) { crm_free(data); } int crm_int_helper(const char *text, char **end_text) { int atoi_result = -1; char *local_end_text = NULL; errno = 0; if(text != NULL) { if(end_text != NULL) { atoi_result = (int)strtol(text, end_text, 10); } else { atoi_result = (int)strtol(text, &local_end_text, 10); } /* CRM_CHECK(errno != EINVAL); */ if(errno == EINVAL) { crm_err("Conversion of %s failed", text); atoi_result = -1; } else { if(errno == ERANGE) { crm_err("Conversion of %s was clipped", text); } if(end_text == NULL && local_end_text[0] != '\0') { crm_err("Characters left over after parsing " "\"%s\": \"%s\"", text, local_end_text); } } } return atoi_result; } int crm_parse_int(const char *text, const char *default_text) { int atoi_result = -1; if(text != NULL) { atoi_result = crm_int_helper(text, NULL); if(errno == 0) { return atoi_result; } } if(default_text != NULL) { atoi_result = crm_int_helper(default_text, NULL); if(errno == 0) { return atoi_result; } } else { crm_err("No default conversion value supplied"); } return -1; } gboolean safe_str_eq(const char *a, const char *b) { if(a == b) { return TRUE; } else if(a == NULL || b == NULL) { return FALSE; } else if(strcasecmp(a, b) == 0) { return TRUE; } return FALSE; } gboolean safe_str_neq(const char *a, const char *b) { if(a == b) { return FALSE; } else if(a==NULL || b==NULL) { return TRUE; } else if(strcasecmp(a, b) == 0) { return FALSE; } return TRUE; } char * crm_strdup(const char *a) { char *ret = NULL; CRM_CHECK(a != NULL, return NULL); if(a != NULL) { ret = cl_strdup(a); } else { crm_warn("Cannot dup NULL string"); } return ret; } static GHashTable *crm_uuid_cache = NULL; static GHashTable *crm_uname_cache = NULL; void unget_uuid(const char *uname) { if(crm_uuid_cache == NULL) { return; } g_hash_table_remove(crm_uuid_cache, uname); } const char * get_uuid(ll_cluster_t *hb, const char *uname) { cl_uuid_t uuid_raw; char *uuid_calc = NULL; const char *unknown = "00000000-0000-0000-0000-000000000000"; if(crm_uuid_cache == NULL) { crm_uuid_cache = g_hash_table_new_full( g_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); } CRM_CHECK(uname != NULL, return NULL); /* avoid blocking calls where possible */ uuid_calc = g_hash_table_lookup(crm_uuid_cache, uname); if(uuid_calc != NULL) { return uuid_calc; } if(hb->llc_ops->get_uuid_by_name(hb, uname, &uuid_raw) == HA_FAIL) { crm_err("get_uuid_by_name() call failed for host %s", uname); crm_free(uuid_calc); return NULL; } crm_malloc0(uuid_calc, 50); if(uuid_calc == NULL) { return NULL; } cl_uuid_unparse(&uuid_raw, uuid_calc); if(safe_str_eq(uuid_calc, unknown)) { crm_warn("Could not calculate UUID for %s", uname); crm_free(uuid_calc); return NULL; } g_hash_table_insert(crm_uuid_cache, crm_strdup(uname), uuid_calc); uuid_calc = g_hash_table_lookup(crm_uuid_cache, uname); return uuid_calc; } const char * get_uname(ll_cluster_t *hb, const char *uuid) { char *uname = NULL; if(crm_uuid_cache == NULL) { crm_uname_cache = g_hash_table_new_full( g_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); } CRM_CHECK(uuid != NULL, return NULL); /* avoid blocking calls where possible */ uname = g_hash_table_lookup(crm_uname_cache, uuid); if(uname != NULL) { return uname; } if(uuid != NULL) { cl_uuid_t uuid_raw; char *uuid_copy = crm_strdup(uuid); cl_uuid_parse(uuid_copy, &uuid_raw); if(hb->llc_ops->get_name_by_uuid( hb, &uuid_raw, uname, 256) == HA_FAIL) { crm_err("Could not calculate UUID for %s", uname); uname = NULL; crm_free(uuid_copy); } else { g_hash_table_insert( crm_uuid_cache, uuid_copy, crm_strdup(uname)); uname = g_hash_table_lookup(crm_uname_cache, uuid); } return uname; } return NULL; } void set_uuid(ll_cluster_t *hb,crm_data_t *node,const char *attr,const char *uname) { const char *uuid_calc = get_uuid(hb, uname); crm_xml_add(node, attr, uuid_calc); return; } #define ENV_PREFIX "HA_" void crm_set_env_options(void) { char *param_val = NULL; const char *param_name = NULL; /* apparently we're not allowed to free the result of getenv */ param_name = ENV_PREFIX "" KEY_DEBUGLEVEL; param_val = getenv(param_name); if(param_val != NULL) { int debug_level = crm_parse_int(param_val, NULL); if(debug_level > 0 && (debug_level+LOG_INFO) > (int)crm_log_level) { set_crm_log_level(LOG_INFO + debug_level); } crm_debug("%s = %s", param_name, param_val); param_val = NULL; } param_name = ENV_PREFIX "" KEY_FACILITY; param_val = getenv(param_name); crm_debug("%s = %s", param_name, param_val); if(param_val != NULL) { int facility = cl_syslogfac_str2int(param_val); if(facility > 0) { cl_log_set_facility(facility); } param_val = NULL; } param_name = ENV_PREFIX "" KEY_LOGFILE; param_val = getenv(param_name); crm_debug("%s = %s", param_name, param_val); if(param_val != NULL) { if(safe_str_eq("/dev/null", param_val)) { param_val = NULL; } cl_log_set_logfile(param_val); param_val = NULL; } param_name = ENV_PREFIX "" KEY_DBGFILE; param_val = getenv(param_name); crm_debug("%s = %s", param_name, param_val); if(param_val != NULL) { if(safe_str_eq("/dev/null", param_val)) { param_val = NULL; } cl_log_set_debugfile(param_val); param_val = NULL; } param_name = ENV_PREFIX "" KEY_LOGDAEMON; param_val = getenv(param_name); crm_debug("%s = %s", param_name, param_val); if(param_val != NULL) { int uselogd; cl_str_to_boolean(param_val, &uselogd); cl_log_set_uselogd(uselogd); if(uselogd) { cl_set_logging_wqueue_maxlen(500); cl_log_set_logd_channel_source(NULL, NULL); } param_val = NULL; } param_name = ENV_PREFIX "" KEY_CONNINTVAL; param_val = getenv(param_name); crm_debug("%s = %s", param_name, param_val); if(param_val != NULL) { int logdtime; logdtime = crm_get_msec(param_val); cl_log_set_logdtime(logdtime); param_val = NULL; } inherit_compress(); } gboolean crm_is_true(const char * s) { gboolean ret = FALSE; if(s != NULL) { cl_str_to_boolean(s, &ret); } return ret; } int crm_str_to_boolean(const char * s, int * ret) { if(s == NULL) { return -1; } else if (strcasecmp(s, "true") == 0 || strcasecmp(s, "on") == 0 || strcasecmp(s, "yes") == 0 || strcasecmp(s, "y") == 0 || strcasecmp(s, "1") == 0){ *ret = TRUE; return 1; } else if (strcasecmp(s, "false") == 0 || strcasecmp(s, "off") == 0 || strcasecmp(s, "no") == 0 || strcasecmp(s, "n") == 0 || strcasecmp(s, "0") == 0){ *ret = FALSE; return 1; } return -1; } #ifndef NUMCHARS # define NUMCHARS "0123456789." #endif #ifndef WHITESPACE # define WHITESPACE " \t\n\r\f" #endif long crm_get_msec(const char * input) { const char * cp = input; const char * units; long multiplier = 1000; long divisor = 1; long ret = -1; double dret; if(input == NULL) { return 0; } cp += strspn(cp, WHITESPACE); units = cp + strspn(cp, NUMCHARS); units += strspn(units, WHITESPACE); if (strchr(NUMCHARS, *cp) == NULL) { return ret; } if (strncasecmp(units, "ms", 2) == 0 || strncasecmp(units, "msec", 4) == 0) { multiplier = 1; divisor = 1; }else if (strncasecmp(units, "us", 2) == 0 || strncasecmp(units, "usec", 4) == 0) { multiplier = 1; divisor = 1000; }else if (strncasecmp(units, "s", 1) == 0 || strncasecmp(units, "sec", 3) == 0) { multiplier = 1000; divisor = 1; }else if (strncasecmp(units, "m", 1) == 0 || strncasecmp(units, "min", 3) == 0) { multiplier = 60*1000; divisor = 1; }else if (strncasecmp(units, "h", 1) == 0 || strncasecmp(units, "hr", 2) == 0) { multiplier = 60*60*1000; divisor = 1; }else if (*units != EOS && *units != '\n' && *units != '\r') { return ret; } dret = atof(cp); dret *= (double)multiplier; dret /= (double)divisor; dret += 0.5; ret = (long)dret; return(ret); } gboolean ccm_have_quorum(oc_ed_t event) { if(event==OC_EV_MS_NEW_MEMBERSHIP) { return TRUE; } return FALSE; } const char * ccm_event_name(oc_ed_t event) { if(event==OC_EV_MS_NEW_MEMBERSHIP) { return "NEW MEMBERSHIP"; } else if(event==OC_EV_MS_NOT_PRIMARY) { return "NOT PRIMARY"; } else if(event==OC_EV_MS_PRIMARY_RESTORED) { return "PRIMARY RESTORED"; } else if(event==OC_EV_MS_EVICTED) { return "EVICTED"; } else if(event==OC_EV_MS_INVALID) { return "INVALID"; } return "NO QUORUM MEMBERSHIP"; } const char * op_status2text(op_status_t status) { switch(status) { case LRM_OP_PENDING: return "pending"; break; case LRM_OP_DONE: return "complete"; break; case LRM_OP_ERROR: return "Error"; break; case LRM_OP_TIMEOUT: return "Timed Out"; break; case LRM_OP_NOTSUPPORTED: return "NOT SUPPORTED"; break; case LRM_OP_CANCELLED: return "Cancelled"; break; } CRM_CHECK(status >= LRM_OP_PENDING && status <= LRM_OP_CANCELLED, crm_err("Unknown status: %d", status)); return "UNKNOWN!"; } char * generate_op_key(const char *rsc_id, const char *op_type, int interval) { int len = 35; char *op_id = NULL; CRM_CHECK(rsc_id != NULL, return NULL); CRM_CHECK(op_type != NULL, return NULL); len += strlen(op_type); len += strlen(rsc_id); crm_malloc0(op_id, len); CRM_CHECK(op_id != NULL, return NULL); sprintf(op_id, "%s_%s_%d", rsc_id, op_type, interval); return op_id; } gboolean parse_op_key(const char *key, char **rsc_id, char **op_type, int *interval) { - char *interval_s = NULL; - char *key2 = NULL; - - if(decodeNVpair(key, '_', rsc_id, &key2) == FALSE) { - crm_err("Couldn't find '_' in: %s", key); - return FALSE; + char *mutable_key = NULL; + char *mutable_key_ptr = NULL; + int len = 0, offset = 0, ch = 0; + + CRM_CHECK(key != NULL, return FALSE); + + *interval = 0; + len = strlen(key); + offset = len-1; + + while(offset > 0 && isdigit(key[offset])) { + int digits = offset-len; + ch = key[offset] - '0'; + CRM_CHECK(ch < 10, return FALSE); + CRM_CHECK(ch >= 0, return FALSE); + while(digits > 1) { + digits--; + ch = ch * 10; + } + *interval += ch; + offset--; } - if(decodeNVpair(key2, '_', op_type, &interval_s) == FALSE) { - crm_err("Couldn't find '_' in: %s", key2); - return FALSE; + crm_info("Interval: %d", *interval); + CRM_CHECK(key[offset] == '_', return FALSE); + + mutable_key = crm_strdup(key); + mutable_key_ptr = mutable_key_ptr; + mutable_key[offset] = 0; + offset--; + + while(offset > 0 && key[offset] != '_') { + offset--; } - *interval = crm_parse_int(interval_s, NULL); + CRM_CHECK(key[offset] == '_', + crm_free(mutable_key); return FALSE); + + mutable_key_ptr = mutable_key+offset+1; + + crm_debug_3("Action: %s", mutable_key_ptr); + *op_type = crm_strdup(mutable_key_ptr); + + mutable_key[offset] = 0; + offset--; + + CRM_CHECK(mutable_key != mutable_key_ptr, + crm_free(mutable_key); return FALSE); + + crm_debug_3("Resource: %s", mutable_key); + *rsc_id = crm_strdup(mutable_key); + + crm_free(mutable_key); return TRUE; } char * generate_notify_key(const char *rsc_id, const char *notify_type, const char *op_type) { int len = 12; char *op_id = NULL; CRM_CHECK(rsc_id != NULL, return NULL); CRM_CHECK(op_type != NULL, return NULL); CRM_CHECK(notify_type != NULL, return NULL); len += strlen(op_type); len += strlen(rsc_id); len += strlen(notify_type); crm_malloc0(op_id, len); if(op_id != NULL) { sprintf(op_id, "%s_%s_notify_%s_0", rsc_id, notify_type, op_type); } return op_id; } char * generate_transition_magic_v202(const char *transition_key, int op_status) { int len = 80; char *fail_state = NULL; CRM_CHECK(transition_key != NULL, return NULL); len += strlen(transition_key); crm_malloc0(fail_state, len); if(fail_state != NULL) { snprintf(fail_state, len, "%d:%s", op_status,transition_key); } return fail_state; } char * generate_transition_magic(const char *transition_key, int op_status, int op_rc) { int len = 80; char *fail_state = NULL; CRM_CHECK(transition_key != NULL, return NULL); len += strlen(transition_key); crm_malloc0(fail_state, len); if(fail_state != NULL) { snprintf(fail_state, len, "%d:%d;%s", op_status, op_rc, transition_key); } return fail_state; } gboolean decode_transition_magic( const char *magic, char **uuid, int *transition_id, int *op_status, int *op_rc) { char *rc = NULL; char *key = NULL; char *magic2 = NULL; char *status = NULL; if(decodeNVpair(magic, ':', &status, &magic2) == FALSE) { crm_err("Couldn't find ':' in: %s", magic); return FALSE; } if(decodeNVpair(magic2, ';', &rc, &key) == FALSE) { crm_err("Couldn't find ';' in: %s", magic2); return FALSE; } CRM_CHECK(decode_transition_key(key, uuid, transition_id), return FALSE); *op_rc = crm_parse_int(rc, NULL); *op_status = crm_parse_int(status, NULL); crm_free(rc); crm_free(key); crm_free(magic2); crm_free(status); return TRUE; } char * generate_transition_key(int transition_id, const char *node) { int len = 40; char *fail_state = NULL; CRM_CHECK(node != NULL, return NULL); len += strlen(node); crm_malloc0(fail_state, len); if(fail_state != NULL) { snprintf(fail_state, len, "%d:%s", transition_id, node); } return fail_state; } gboolean decode_transition_key(const char *key, char **uuid, int *transition_id) { char *transition = NULL; if(decodeNVpair(key, ':', &transition, uuid) == FALSE) { crm_err("Couldn't find ':' in: %s", key); return FALSE; } *transition_id = crm_parse_int(transition, NULL); crm_free(transition); return TRUE; } void filter_action_parameters(crm_data_t *param_set, const char *version) { #if CRM_DEPRECATED_SINCE_2_0_5 const char *filter_205[] = { XML_ATTR_TE_TARGET_RC, XML_ATTR_LRM_PROBE, XML_RSC_ATTR_START, XML_RSC_ATTR_NOTIFY, XML_RSC_ATTR_UNIQUE, XML_RSC_ATTR_MANAGED, XML_RSC_ATTR_PRIORITY, XML_RSC_ATTR_MULTIPLE, XML_RSC_ATTR_STICKINESS, XML_RSC_ATTR_FAIL_STICKINESS, XML_RSC_ATTR_TARGET_ROLE, /* ignore clone fields */ XML_RSC_ATTR_INCARNATION, XML_RSC_ATTR_INCARNATION_MAX, XML_RSC_ATTR_INCARNATION_NODEMAX, XML_RSC_ATTR_MASTER_MAX, XML_RSC_ATTR_MASTER_NODEMAX, /* old field names */ "role", "crm_role", "te-target-rc", /* ignore notify fields */ "notify_stop_resource", "notify_stop_uname", "notify_start_resource", "notify_start_uname", "notify_active_resource", "notify_active_uname", "notify_inactive_resource", "notify_inactive_uname", "notify_promote_resource", "notify_promote_uname", "notify_demote_resource", "notify_demote_uname", "notify_master_resource", "notify_master_uname", "notify_slave_resource", "notify_slave_uname" }; #endif const char *attr_filter[] = { XML_ATTR_ID, XML_ATTR_CRM_VERSION, XML_LRM_ATTR_OP_DIGEST, }; gboolean do_delete = FALSE; int lpc = 0; static int meta_len = 0; if(meta_len == 0) { meta_len = strlen(CRM_META); } if(param_set == NULL) { return; } #if CRM_DEPRECATED_SINCE_2_0_5 if(version == NULL || compare_version("1.0.5", version)) { for(lpc = 0; lpc < DIMOF(filter_205); lpc++) { xml_remove_prop(param_set, filter_205[lpc]); } } #endif for(lpc = 0; lpc < DIMOF(attr_filter); lpc++) { xml_remove_prop(param_set, attr_filter[lpc]); } xml_prop_iter(param_set, prop_name, prop_value, do_delete = FALSE; if(strncasecmp(prop_name, CRM_META, meta_len) == 0) { do_delete = TRUE; } if(do_delete) { /* remove it */ xml_remove_prop(param_set, prop_name); /* unwind the counetr */ __counter--; } ); } gboolean crm_mem_stats(volatile cl_mem_stats_t *mem_stats) { volatile cl_mem_stats_t *active_stats = mem_stats; if(active_stats == NULL) { active_stats = cl_malloc_getstats(); } CRM_CHECK(active_stats != NULL, ;); #ifndef CRM_USE_MALLOC if(active_stats->numalloc > active_stats->numfree) { crm_warn("Potential memory leak detected:" " %lu alloc's vs. %lu free's (%lu)" " (%lu bytes not freed: req=%lu, alloc'd=%lu)", active_stats->numalloc, active_stats->numfree, active_stats->numalloc - active_stats->numfree, active_stats->nbytes_alloc, active_stats->nbytes_req, active_stats->mallocbytes); return TRUE; } else if(active_stats->numalloc < active_stats->numfree) { crm_debug("Process shrank: %lu alloc's vs. %lu free's (%lu)", active_stats->numalloc, active_stats->numfree, active_stats->numalloc - active_stats->numfree); } #endif return FALSE; } void crm_zero_mem_stats(volatile cl_mem_stats_t *stats) { if(stats == NULL) { crm_debug("Resetting global memory stats"); stats = cl_malloc_getstats(); } stats->numalloc = 0; stats->numfree = 0; stats->numrealloc = 0; stats->nbytes_req = 0; stats->nbytes_alloc = 0; stats->mallocbytes = 0; stats->arena = 0; } void crm_save_mem_stats(const char *location, cl_mem_stats_t *saved_stats) { volatile cl_mem_stats_t *stats = cl_malloc_getstats(); if(saved_stats == NULL) { return; } crm_debug_2("Saving memory stats: %s", location); *saved_stats = *stats; } void crm_xml_nbytes(crm_data_t *xml, long *bytes, long *allocs, long *frees) { crm_data_t *xml_copy = NULL; volatile cl_mem_stats_t *stats = cl_malloc_getstats(); if(xml == NULL) { *bytes = 0; *allocs = 0; *frees = 0; return; } *bytes = 0 - stats->nbytes_alloc; *allocs = 0 - stats->numalloc; *frees = 0 - stats->numfree; xml_copy = copy_xml(xml); *bytes += stats->nbytes_alloc; *allocs += stats->numalloc; *frees += stats->numfree; crm_debug_3("XML size: %ld bytes, %ld allocs, %ld frees", *bytes, *allocs, *frees); free_xml(xml_copy); } void crm_adjust_mem_stats(volatile cl_mem_stats_t *stats, long bytes, long allocs, long frees) { if(bytes == 0&& allocs == 0 && frees == 0) { return; } if(stats == NULL) { stats = cl_malloc_getstats(); } stats->nbytes_alloc -= bytes; stats->numalloc -= allocs; stats->numfree -= frees; crm_debug("Adjusted CIB Memory usage by: %10ld bytes, %5ld allocs, %5ld frees", bytes, allocs, frees); } cl_mem_stats_t *crm_running_stats = NULL; gboolean crm_diff_mem_stats(int log_level_up, int log_level_down, const char *location, volatile cl_mem_stats_t *stats, volatile cl_mem_stats_t *saved_stats) { long delta_allocs = 0; long delta_frees = 0; long delta_bytes = 0; long delta_req = 0; gboolean increase = TRUE; gboolean reset_on_change = (log_level_up == LOG_DEBUG); /* long delta_malloc = stats->mallocbytes - saved_stats->mallocbytes; */ return FALSE; if(stats == NULL && saved_stats == NULL) { crm_err("Comparision doesnt make sense"); return FALSE; } else if(stats == NULL) { stats = cl_malloc_getstats(); } else if(saved_stats == NULL) { saved_stats = cl_malloc_getstats(); } delta_allocs = stats->numalloc - saved_stats->numalloc; delta_frees = stats->numfree - saved_stats->numfree; delta_bytes = stats->nbytes_alloc - saved_stats->nbytes_alloc; delta_req = stats->nbytes_req - saved_stats->nbytes_req; if(delta_bytes == 0) { crm_debug_2("Memory usage constant at %s: %ld alloc's %ld free's", location, delta_allocs, delta_frees); return FALSE; } if(delta_bytes < 0) { increase = FALSE; reset_on_change = (log_level_down == LOG_DEBUG); } crm_log_maybe(increase?log_level_up:log_level_down, "Memory usage %s detected at %s:\t" " %10ld alloc's vs. %10ld free's (%5ld change" " %10ld bytes leaked)", increase?"increase":"decrease", location, delta_allocs, delta_frees, delta_allocs - delta_frees, delta_bytes); if(reset_on_change) { crm_info("Resetting %s stats", location); *stats = *saved_stats; if(crm_running_stats) { crm_adjust_mem_stats(crm_running_stats, delta_bytes, delta_allocs, delta_frees); } } return TRUE; } void crm_abort(const char *file, const char *function, int line, const char *assert_condition, gboolean do_fork) { int pid = 0; if(do_fork == FALSE) { do_crm_log(LOG_ERR, file, function, "Triggered fatal assert at %s:%d : %s", file, line, assert_condition); } else if(crm_log_level < LOG_DEBUG) { do_crm_log(LOG_ERR, file, function, "Triggered non-fatal assert at %s:%d : %s", file, line, assert_condition); return; } else { pid=fork(); } switch(pid) { case -1: crm_err("Cannot fork!"); return; default: /* Parent */ do_crm_log(LOG_ERR, file, function, "Forked child %d to record non-fatal assert at %s:%d : %s", pid, file, line, assert_condition); return; case 0: /* Child */ abort(); break; } } char * generate_series_filename( const char *directory, const char *series, int sequence, gboolean bzip) { int len = 40; char *filename = NULL; const char *ext = "raw"; CRM_CHECK(directory != NULL, return NULL); CRM_CHECK(series != NULL, return NULL); len += strlen(directory); len += strlen(series); crm_malloc0(filename, len); CRM_CHECK(filename != NULL, return NULL); if(bzip) { ext = "bz2"; } sprintf(filename, "%s/%s-%d.%s", directory, series, sequence, ext); return filename; } int get_last_sequence(const char *directory, const char *series) { FILE *file_strm = NULL; int start = 0, length = 0, read_len = 0; char *series_file = NULL; char *buffer = NULL; int seq = 0; int len = 36; CRM_CHECK(directory != NULL, return 0); CRM_CHECK(series != NULL, return 0); len += strlen(directory); len += strlen(series); crm_malloc0(series_file, len); CRM_CHECK(series_file != NULL, return 0); sprintf(series_file, "%s/%s.last", directory, series); file_strm = fopen(series_file, "r"); if(file_strm == NULL) { crm_debug("%s does not exist", series_file); crm_free(series_file); return 0; } /* see how big the file is */ start = ftell(file_strm); fseek(file_strm, 0L, SEEK_END); length = ftell(file_strm); fseek(file_strm, 0L, start); CRM_ASSERT(start == ftell(file_strm)); crm_debug_3("Reading %d bytes from file", length); crm_malloc0(buffer, (length+1)); read_len = fread(buffer, 1, length, file_strm); if(read_len != length) { crm_err("Calculated and read bytes differ: %d vs. %d", length, read_len); crm_free(buffer); buffer = NULL; } else if(length <= 0) { crm_info("%s was not valid", series_file); crm_free(buffer); buffer = NULL; } crm_free(series_file); seq = crm_parse_int(buffer, "0"); crm_free(buffer); fclose(file_strm); return seq; } void write_last_sequence( const char *directory, const char *series, int sequence, int max) { int rc = 0; int len = 36; char *buffer = NULL; FILE *file_strm = NULL; char *series_file = NULL; CRM_CHECK(directory != NULL, return); CRM_CHECK(series != NULL, return); if(max == 0) { return; } while(max > 0 && sequence > max) { sequence -= max; } buffer = crm_itoa(sequence); len += strlen(directory); len += strlen(series); crm_malloc0(series_file, len); CRM_CHECK(series_file != NULL, return); sprintf(series_file, "%s/%s.last", directory, series); file_strm = fopen(series_file, "w"); if(file_strm == NULL) { crm_err("%s does not exist", series_file); crm_free(series_file); return; } rc = fprintf(file_strm, "%s", buffer); if(rc < 0) { cl_perror("Cannot write output to %s", series_file); } fflush(file_strm); fclose(file_strm); crm_free(series_file); crm_free(buffer); } void crm_make_daemon(const char *name, gboolean daemonize, const char *pidfile) { long pid; const char *devnull = "/dev/null"; if(daemonize == FALSE) { return; } pid = fork(); if (pid < 0) { fprintf(stderr, "%s: could not start daemon\n", name); cl_perror("fork"); exit(LSB_EXIT_GENERIC); } else if (pid > 0) { exit(LSB_EXIT_OK); } if (cl_lock_pidfile(pidfile) < 0 ) { pid = cl_read_pidfile_no_checking(pidfile); crm_warn("%s: already running [pid %ld] (%s).\n", name, pid, pidfile); exit(LSB_EXIT_OK); } umask(022); close(FD_STDIN); (void)open(devnull, O_RDONLY); /* Stdin: fd 0 */ close(FD_STDOUT); (void)open(devnull, O_WRONLY); /* Stdout: fd 1 */ close(FD_STDERR); (void)open(devnull, O_WRONLY); /* Stderr: fd 2 */ } diff --git a/lib/crm/pengine/Makefile.am b/lib/crm/pengine/Makefile.am index 21a79e4d00..9e721b9d97 100644 --- a/lib/crm/pengine/Makefile.am +++ b/lib/crm/pengine/Makefile.am @@ -1,69 +1,69 @@ # # Copyright (C) 2004 Andrew Beekhof # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program 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 program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # MAINTAINERCLEANFILES = Makefile.in INCLUDES = -I$(top_builddir)/include -I$(top_srcdir)/include \ -I$(top_builddir)/libltdl -I$(top_srcdir)/libltdl \ -I$(top_builddir)/linux-ha -I$(top_srcdir)/linux-ha \ -I$(top_builddir) -I$(top_srcdir) hadir = $(sysconfdir)/ha.d halibdir = $(libdir)/@HB_PKG@ commmoddir = $(halibdir)/modules/comm havarlibdir = $(localstatedir)/lib/@HB_PKG@ pe_varlibdir = $(HA_VARLIBDIR)/$(HB_PKG)/pengine # sockets with path crmdir = $(havarlibdir)/crm apigid = @HA_APIGID@ crmuid = @HA_CCMUID@ COMMONLIBS = $(CRM_DEBUG_LIBS) \ $(top_builddir)/lib/clplumbing/libplumb.la \ $(top_builddir)/lib/crm/common/libcrmcommon.la \ $(GLIBLIB) \ $(CURSESLIBS) \ $(LIBRT) LIBRT = @LIBRT@ AM_CFLAGS = @CFLAGS@ $(CRM_DEBUG_FLAGS) ## libraries lib_LTLIBRARIES = libpe_rules.la libpe_status.la ## SOURCES -noinst_HEADERS = unpack.h utils.h pengine.h +noinst_HEADERS = unpack.h utils.h rule_files = rules.c common.c status_files = status.c unpack.c utils.c complex.c native.c group.c clone.c libpe_rules_la_LDFLAGS = -version-info 1:0:0 libpe_rules_la_SOURCES = $(rule_files) libpe_status_la_LDFLAGS = -version-info 1:0:0 libpe_status_la_SOURCES = $(rule_files) $(status_files) clean-generic: rm -f *.log *.debug *~ install-exec-local: uninstall-local: diff --git a/lib/crm/pengine/complex.c b/lib/crm/pengine/complex.c index 1f4cbb0265..a944958d73 100644 --- a/lib/crm/pengine/complex.c +++ b/lib/crm/pengine/complex.c @@ -1,332 +1,331 @@ /* $Id: complex.c,v 1.7 2006/08/14 16:32:21 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include void populate_hash(crm_data_t *nvpair_list, GHashTable *hash, const char **attrs, int attrs_length); resource_object_functions_t resource_class_functions[] = { { native_unpack, native_find_child, native_children, native_parameter, native_print, native_active, native_resource_state, native_free }, { group_unpack, group_find_child, group_children, native_parameter, group_print, group_active, group_resource_state, group_free }, { clone_unpack, clone_find_child, clone_children, native_parameter, clone_print, clone_active, clone_resource_state, clone_free }, { master_unpack, clone_find_child, clone_children, native_parameter, clone_print, clone_active, clone_resource_state, clone_free } }; int get_resource_type(const char *name) { if(safe_str_eq(name, XML_CIB_TAG_RESOURCE)) { return pe_native; } else if(safe_str_eq(name, XML_CIB_TAG_GROUP)) { return pe_group; } else if(safe_str_eq(name, XML_CIB_TAG_INCARNATION)) { return pe_clone; } else if(safe_str_eq(name, XML_CIB_TAG_MASTER)) { return pe_master; } return pe_unknown; } static void dup_attr(gpointer key, gpointer value, gpointer user_data) { add_hash_param(user_data, key, value); } gboolean common_unpack(crm_data_t * xml_obj, resource_t **rsc, resource_t *parent, pe_working_set_t *data_set) { const char *value = NULL; const char *id = crm_element_value(xml_obj, XML_ATTR_ID); crm_log_xml_debug_3(xml_obj, "Processing resource input..."); if(id == NULL) { pe_err("Must specify id tag in "); return FALSE; } else if(rsc == NULL) { pe_err("Nowhere to unpack resource into"); return FALSE; } crm_malloc0(*rsc, sizeof(resource_t)); if(*rsc == NULL) { return FALSE; } (*rsc)->xml = xml_obj; (*rsc)->parent = parent; (*rsc)->ops_xml = find_xml_node(xml_obj, "operations", FALSE); (*rsc)->variant = get_resource_type(crm_element_name(xml_obj)); if((*rsc)->variant == pe_unknown) { pe_err("Unknown resource type: %s", crm_element_name(xml_obj)); crm_free(*rsc); return FALSE; } (*rsc)->parameters = g_hash_table_new_full( g_str_hash,g_str_equal, g_hash_destroy_str,g_hash_destroy_str); (*rsc)->meta = g_hash_table_new_full( g_str_hash,g_str_equal, g_hash_destroy_str,g_hash_destroy_str); value = crm_element_value(xml_obj, XML_RSC_ATTR_INCARNATION); if(value) { (*rsc)->id = crm_concat(id, value, ':'); add_hash_param((*rsc)->meta, XML_RSC_ATTR_INCARNATION, value); } else { (*rsc)->id = crm_strdup(id); } if(parent) { (*rsc)->long_name = crm_concat(parent->long_name, (*rsc)->id, ':'); } else { (*rsc)->long_name = crm_strdup((*rsc)->id); } (*rsc)->fns = &resource_class_functions[(*rsc)->variant]; crm_debug_3("Unpacking resource..."); /* meta attributes */ xml_prop_iter( xml_obj, prop_name, prop_value, add_hash_param((*rsc)->meta, prop_name, prop_value); ); unpack_instance_attributes( xml_obj, XML_TAG_META_SETS, NULL, (*rsc)->meta, NULL, data_set->now); /* populate from the regular attributes until the GUI can create * meta attributes */ unpack_instance_attributes( xml_obj, XML_TAG_ATTR_SETS, NULL, (*rsc)->meta, NULL, data_set->now); if(parent != NULL) { g_hash_table_foreach(parent->meta, dup_attr, (*rsc)->meta); g_hash_table_foreach( parent->parameters, dup_attr, (*rsc)->parameters); } if((*rsc)->fns->unpack(*rsc, data_set) == FALSE) { return FALSE; } (*rsc)->runnable = TRUE; (*rsc)->provisional = TRUE; (*rsc)->starting = FALSE; (*rsc)->stopping = FALSE; - (*rsc)->candidate_colors = NULL; (*rsc)->rsc_cons = NULL; (*rsc)->actions = NULL; (*rsc)->failed = FALSE; (*rsc)->start_pending = FALSE; (*rsc)->globally_unique = TRUE; (*rsc)->role = RSC_ROLE_STOPPED; (*rsc)->next_role = RSC_ROLE_UNKNOWN; (*rsc)->is_managed = data_set->is_managed_default; (*rsc)->recovery_type = recovery_stop_start; (*rsc)->stickiness = data_set->default_resource_stickiness; (*rsc)->fail_stickiness = data_set->default_resource_fail_stickiness; value = g_hash_table_lookup((*rsc)->meta, XML_CIB_ATTR_PRIORITY); (*rsc)->priority = crm_parse_int(value, "0"); (*rsc)->effective_priority = (*rsc)->priority; value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_NOTIFY); (*rsc)->notify = crm_is_true(value); value = g_hash_table_lookup((*rsc)->meta, "is_managed"); if(value != NULL && safe_str_neq("default", value)) { cl_str_to_boolean(value, &((*rsc)->is_managed)); } crm_debug_2("Options for %s", (*rsc)->id); value = g_hash_table_lookup((*rsc)->meta, "globally_unique"); if(value != NULL) { cl_str_to_boolean(value, &((*rsc)->globally_unique)); } value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_RESTART); if(safe_str_eq(value, "restart")) { (*rsc)->restart_type = pe_restart_restart; crm_debug_2("\tDependancy restart handling: restart"); } else { (*rsc)->restart_type = pe_restart_ignore; crm_debug_2("\tDependancy restart handling: ignore"); } value = g_hash_table_lookup((*rsc)->meta, "multiple_active"); if(safe_str_eq(value, "stop_only")) { (*rsc)->recovery_type = recovery_stop_only; crm_debug_2("\tMultiple running resource recovery: stop only"); } else if(safe_str_eq(value, "block")) { (*rsc)->recovery_type = recovery_block; crm_debug_2("\tMultiple running resource recovery: block"); } else { (*rsc)->recovery_type = recovery_stop_start; crm_debug_2("\tMultiple running resource recovery: stop/start"); } value = g_hash_table_lookup((*rsc)->meta, "resource_stickiness"); if(value != NULL && safe_str_neq("default", value)) { (*rsc)->stickiness = char2score(value); } if((*rsc)->stickiness > 0) { crm_debug_2("\tPlacement: prefer current location%s", value == NULL?" (default)":""); } else if((*rsc)->stickiness < 0) { crm_warn("\tPlacement: always move from the current location%s", value == NULL?" (default)":""); } else { crm_debug_2("\tPlacement: optimal%s", value == NULL?" (default)":""); } value = g_hash_table_lookup( (*rsc)->meta, XML_RSC_ATTR_FAIL_STICKINESS); if(value != NULL) { (*rsc)->fail_stickiness = char2score(value); } crm_debug_2("\tNode score per failure: %d%s", (*rsc)->fail_stickiness, value == NULL?" (default)":""); value = g_hash_table_lookup( (*rsc)->meta, XML_RSC_ATTR_TARGET_ROLE); if(value != NULL && safe_str_neq("default", value)) { (*rsc)->next_role = text2role(value); if((*rsc)->next_role == RSC_ROLE_UNKNOWN) { crm_config_err("%s: Unknown value for " XML_RSC_ATTR_TARGET_ROLE": %s", (*rsc)->id, value); } } crm_debug_2("\tDesired next state: %s", (*rsc)->next_role!=RSC_ROLE_UNKNOWN?role2text((*rsc)->next_role):"default"); if((*rsc)->variant == pe_native && (*rsc)->next_role == RSC_ROLE_STOPPED) { crm_debug_2("Making sure %s doesn't get colored", (*rsc)->id); /* make sure it doesnt come up again */ resource_location(*rsc, NULL, -INFINITY, "target_role", data_set); } if((*rsc)->is_managed == FALSE) { crm_warn("Resource %s is currently not managed", (*rsc)->id); } else if((*rsc)->variant == pe_native && data_set->symmetric_cluster) { resource_location(*rsc, NULL, 0, "symmetric_default", data_set); } crm_debug_2("\tAction notification: %s", (*rsc)->notify?"required":"not required"); /* data_set->resources = g_list_append(data_set->resources, (*rsc)); */ return TRUE; } void common_free(resource_t *rsc) { if(rsc == NULL) { return; } crm_debug_5("Freeing %s", rsc->id); pe_free_shallow(rsc->rsc_cons); if(rsc->parameters != NULL) { g_hash_table_destroy(rsc->parameters); } if(rsc->meta != NULL) { g_hash_table_destroy(rsc->meta); } if(rsc->orphan) { free_xml(rsc->xml); } pe_free_shallow_adv(rsc->running_on, FALSE); pe_free_shallow_adv(rsc->known_on, FALSE); - pe_free_shallow_adv(rsc->candidate_colors, TRUE); pe_free_shallow_adv(rsc->rsc_location, FALSE); pe_free_shallow_adv(rsc->allowed_nodes, TRUE); crm_free(rsc->id); crm_free(rsc->long_name); crm_free(rsc->clone_name); + crm_free(rsc->allocated_to); crm_free(rsc->variant_opaque); crm_free(rsc); crm_debug_5("Resource freed"); } diff --git a/lib/crm/pengine/group.c b/lib/crm/pengine/group.c index aaeb83f0ce..4eae5f9750 100644 --- a/lib/crm/pengine/group.c +++ b/lib/crm/pengine/group.c @@ -1,262 +1,260 @@ /* $Id: group.c,v 1.6 2006/08/14 09:06:32 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include typedef struct group_variant_data_s { int num_children; GListPtr child_list; /* resource_t* */ resource_t *self; resource_t *first_child; resource_t *last_child; gboolean colocated; gboolean ordered; gboolean child_starting; gboolean child_stopping; } group_variant_data_t; #define get_group_variant_data(data, rsc) \ CRM_ASSERT(rsc != NULL); \ CRM_ASSERT(rsc->variant == pe_group); \ CRM_ASSERT(rsc->variant_opaque != NULL); \ data = (group_variant_data_t *)rsc->variant_opaque; \ -void group_assign_color(resource_t *rsc, color_t *group_color); - gboolean group_unpack(resource_t *rsc, pe_working_set_t *data_set) { resource_t *self = NULL; crm_data_t *xml_obj = rsc->xml; crm_data_t *xml_self = copy_xml(rsc->xml); group_variant_data_t *group_data = NULL; const char *group_ordered = g_hash_table_lookup( rsc->meta, XML_RSC_ATTR_ORDERED); const char *group_colocated = g_hash_table_lookup( rsc->meta, "collocated"); const char *clone_id = NULL; crm_debug_3("Processing resource %s...", rsc->id); crm_malloc0(group_data, sizeof(group_variant_data_t)); group_data->num_children = 0; group_data->self = NULL; group_data->child_list = NULL; group_data->first_child = NULL; group_data->last_child = NULL; rsc->variant_opaque = group_data; group_data->ordered = TRUE; group_data->colocated = TRUE; if(group_ordered != NULL) { cl_str_to_boolean(group_ordered, &(group_data->ordered)); } if(group_colocated != NULL) { cl_str_to_boolean(group_colocated, &(group_data->colocated)); } /* this is a bit of a hack - but simplifies everything else */ ha_msg_mod(xml_self, F_XML_TAGNAME, XML_CIB_TAG_RESOURCE); if(common_unpack(xml_self, &self, NULL, data_set)) { group_data->self = self; self->restart_type = pe_restart_restart; } else { crm_log_xml_err(xml_self, "Couldnt unpack dummy child"); return FALSE; } clone_id = crm_element_value(rsc->xml, XML_RSC_ATTR_INCARNATION); xml_child_iter_filter( xml_obj, xml_native_rsc, XML_CIB_TAG_RESOURCE, resource_t *new_rsc = NULL; crm_xml_add(xml_native_rsc, XML_RSC_ATTR_INCARNATION, clone_id); if(common_unpack(xml_native_rsc, &new_rsc, rsc, data_set) == FALSE) { pe_err("Failed unpacking resource %s", crm_element_value(xml_obj, XML_ATTR_ID)); if(new_rsc != NULL && new_rsc->fns != NULL) { new_rsc->fns->free(new_rsc); } } group_data->num_children++; group_data->child_list = g_list_append( group_data->child_list, new_rsc); if(group_data->first_child == NULL) { group_data->first_child = new_rsc; } group_data->last_child = new_rsc; print_resource(LOG_DEBUG_3, "Added", new_rsc, FALSE); ); if(group_data->num_children == 0) { #if 0 /* Bug #1287 */ crm_config_err("Group %s did not have any children", rsc->id); return FALSE; #else crm_config_warn("Group %s did not have any children", rsc->id); return TRUE; #endif } crm_debug_3("Added %d children to resource %s...", group_data->num_children, rsc->id); return TRUE; } resource_t * group_find_child(resource_t *rsc, const char *id) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); return pe_find_resource(group_data->child_list, id); } GListPtr group_children(resource_t *rsc) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); return group_data->child_list; } gboolean group_active(resource_t *rsc, gboolean all) { group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, gboolean child_active = child_rsc->fns->active(child_rsc, all); if(all == FALSE && child_active) { return TRUE; } else if(child_active == FALSE) { return FALSE; } ); if(all) { return TRUE; } else { return FALSE; } } void group_print( resource_t *rsc, const char *pre_text, long options, void *print_data) { const char *child_text = NULL; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); if(pre_text != NULL) { child_text = " "; } else { child_text = " "; } status_print("%sResource Group: %s", pre_text?pre_text:"", rsc->id); if(options & pe_print_html) { status_print("\n
    \n"); } else if((options & pe_print_log) == 0) { status_print("\n"); } slist_iter( child_rsc, resource_t, group_data->child_list, lpc, if(options & pe_print_html) { status_print("
  • \n"); } child_rsc->fns->print( child_rsc, child_text, options, print_data); if(options & pe_print_html) { status_print("
  • \n"); } ); if(options & pe_print_html) { status_print("
\n"); } } void group_free(resource_t *rsc) { group_variant_data_t *group_data = NULL; CRM_CHECK(rsc != NULL, return); get_group_variant_data(group_data, rsc); crm_debug_3("Freeing %s", rsc->id); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, crm_debug_3("Freeing child %s", child_rsc->id); child_rsc->fns->free(child_rsc); ); crm_debug_3("Freeing child list"); pe_free_shallow_adv(group_data->child_list, FALSE); if(group_data->self != NULL) { free_xml(group_data->self->xml); group_data->self->fns->free(group_data->self); } common_free(rsc); } enum rsc_role_e group_resource_state(resource_t *rsc) { enum rsc_role_e group_role = RSC_ROLE_UNKNOWN; group_variant_data_t *group_data = NULL; get_group_variant_data(group_data, rsc); slist_iter( child_rsc, resource_t, group_data->child_list, lpc, if(child_rsc->next_role > group_role) { group_role = rsc->next_role; } if(child_rsc->failed) { rsc->failed = TRUE; } ); return group_role; } diff --git a/lib/crm/pengine/native.c b/lib/crm/pengine/native.c index 9b2c6f1529..c3e2a46021 100644 --- a/lib/crm/pengine/native.c +++ b/lib/crm/pengine/native.c @@ -1,449 +1,449 @@ /* $Id: native.c,v 1.5 2006/07/12 15:41:46 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #define DELETE_THEN_REFRESH 1 typedef struct native_variant_data_s { /* GListPtr allowed_nodes; /\* node_t* *\/ */ } native_variant_data_t; gboolean DeleteRsc(resource_t *rsc, node_t *node, pe_working_set_t *data_set); #define get_native_variant_data(data, rsc) \ CRM_ASSERT(rsc->variant == pe_native); \ CRM_ASSERT(rsc->variant_opaque != NULL); \ data = (native_variant_data_t *)rsc->variant_opaque; void native_add_running(resource_t *rsc, node_t *node, pe_working_set_t *data_set) { CRM_CHECK(node != NULL, return); slist_iter( a_node, node_t, rsc->running_on, lpc, CRM_CHECK(a_node != NULL, return); if(safe_str_eq(a_node->details->id, node->details->id)) { return; } ); rsc->running_on = g_list_append(rsc->running_on, node); if(rsc->variant == pe_native) { node->details->running_rsc = g_list_append( node->details->running_rsc, rsc); } if(rsc->variant != pe_native) { } else if(rsc->is_managed == FALSE) { crm_info("resource %s isnt managed", rsc->id); resource_location(rsc, node, INFINITY, "not_managed_default", data_set); return; #if 0 } else if(rsc->failed) { crm_info("Skipping resource stickiness for failed resource %s", rsc->id); #endif } else if(rsc->stickiness > 0 || rsc->stickiness < 0) { resource_location(rsc, node, rsc->stickiness, "stickiness", data_set); crm_debug("Resource %s: preferring current location (node=%s, weight=%d)", rsc->id, node->details->uname, rsc->stickiness); } if(rsc->variant == pe_native && g_list_length(rsc->running_on) > 1) { const char *type = crm_element_value(rsc->xml, XML_ATTR_TYPE); const char *class = crm_element_value( rsc->xml, XML_AGENT_ATTR_CLASS); /* these are errors because hardly any gets it right * at the moment and this way the might notice */ pe_proc_err("Resource %s::%s:%s appears to be active on %d nodes.", class, type, rsc->id, g_list_length(rsc->running_on)); cl_log(LOG_ERR, "See %s for more information.", HAURL("v2/faq/resource_too_active")); if(rsc->recovery_type == recovery_stop_only) { crm_debug("Making sure %s doesn't come up again", rsc->id); /* make sure it doesnt come up again */ pe_free_shallow_adv(rsc->allowed_nodes, TRUE); rsc->allowed_nodes = node_list_dup( data_set->nodes, FALSE, FALSE); slist_iter( node, node_t, rsc->allowed_nodes, lpc, node->weight = -INFINITY; ); } else if(rsc->recovery_type == recovery_block) { rsc->is_managed = FALSE; } } else { crm_debug_2("Resource %s is active on: %s", rsc->id, node->details->uname); } if(rsc->parent != NULL) { native_add_running(rsc->parent, node, data_set); } } gboolean native_unpack(resource_t *rsc, pe_working_set_t *data_set) { native_variant_data_t *native_data = NULL; crm_debug_3("Processing resource %s...", rsc->id); crm_malloc0(native_data, sizeof(native_variant_data_t)); rsc->allowed_nodes = NULL; rsc->running_on = NULL; rsc->variant_opaque = native_data; return TRUE; } resource_t * native_find_child(resource_t *rsc, const char *id) { return NULL; } GListPtr native_children(resource_t *rsc) { return NULL; } static void hash_copy_field(gpointer key, gpointer value, gpointer user_data) { const char *name = key; const char *s_value = value; GHashTable *hash_copy = user_data; g_hash_table_insert(hash_copy, crm_strdup(name), crm_strdup(s_value)); } char * native_parameter( resource_t *rsc, node_t *node, gboolean create, const char *name, pe_working_set_t *data_set) { char *value_copy = NULL; const char *value = NULL; GHashTable *hash = rsc->parameters; GHashTable *local_hash = NULL; CRM_CHECK(rsc != NULL, return NULL); CRM_CHECK(name != NULL && strlen(name) != 0, return NULL); crm_debug_2("Looking up %s in %s", name, rsc->id); if(create) { if(node != NULL) { crm_debug_2("Creating hash with node %s", node->details->uname); } else { crm_debug_2("Creating default hash"); } local_hash = g_hash_table_new_full( g_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); g_hash_table_foreach( rsc->parameters, hash_copy_field, local_hash); unpack_instance_attributes( rsc->xml, XML_TAG_ATTR_SETS, node?node->details->attrs:NULL, local_hash, NULL, data_set->now); hash = local_hash; } value = g_hash_table_lookup(hash, name); if(value == NULL) { /* try meta attributes instead */ value = g_hash_table_lookup(rsc->meta, name); } if(value != NULL) { value_copy = crm_strdup(value); } if(local_hash != NULL) { g_hash_table_destroy(local_hash); } return value_copy; } gboolean native_active(resource_t *rsc, gboolean all) { slist_iter( a_node, node_t, rsc->running_on, lpc, if(a_node->details->online == FALSE) { crm_debug("Resource %s: node %s is offline", rsc->id, a_node->details->uname); } else if(a_node->details->unclean) { crm_debug("Resource %s: node %s is unclean", rsc->id, a_node->details->uname); } else { crm_debug("Resource %s active on %s", rsc->id, a_node->details->uname); return TRUE; } ); return FALSE; } struct print_data_s { long options; void *print_data; }; static void native_print_attr(gpointer key, gpointer value, gpointer user_data) { long options = ((struct print_data_s*)user_data)->options; void *print_data = ((struct print_data_s*)user_data)->print_data; status_print("Option: %s = %s\n", (char*)key, (char*)value); } void native_print( resource_t *rsc, const char *pre_text, long options, void *print_data) { node_t *node = NULL; const char *prov = NULL; const char *class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS); if(safe_str_eq(class, "ocf")) { prov = crm_element_value(rsc->xml, XML_AGENT_ATTR_PROVIDER); } if(rsc->running_on != NULL) { node = rsc->running_on->data; } if(options & pe_print_html) { if(rsc->is_managed == FALSE) { status_print(""); } else if(rsc->failed) { status_print(""); } else if(rsc->variant == pe_native && g_list_length(rsc->running_on) == 0) { status_print(""); } else if(g_list_length(rsc->running_on) > 1) { status_print(""); } else { status_print(""); } } if((options & pe_print_rsconly) || g_list_length(rsc->running_on) > 1) { const char *desc = NULL; desc = crm_element_value(rsc->xml, XML_ATTR_DESC); status_print("%s%s\t(%s%s%s:%s)%s%s", pre_text?pre_text:"", rsc->id, prov?prov:"", prov?"::":"", class, crm_element_value(rsc->xml, XML_ATTR_TYPE), desc?": ":"", desc?desc:""); } else { status_print("%s%s\t(%s%s%s:%s):\t%s %s%s%s", pre_text?pre_text:"", rsc->id, prov?prov:"", prov?"::":"", class, crm_element_value(rsc->xml, XML_ATTR_TYPE), (rsc->variant!=pe_native)?"":role2text(rsc->role), (rsc->variant!=pe_native)?"":node!=NULL?node->details->uname:"", rsc->is_managed?"":" (unmanaged)", rsc->failed?" FAILED":""); #if CURSES_ENABLED if(options & pe_print_ncurses) { move(-1, 0); } #endif } if(options & pe_print_html) { status_print(" "); } if((options & pe_print_rsconly)) { } else if(g_list_length(rsc->running_on) > 1) { if(options & pe_print_html) { status_print("
    \n"); } else if((options & pe_print_printf) || (options & pe_print_ncurses)) { status_print("["); } slist_iter(node, node_t, rsc->running_on, lpc, if(options & pe_print_html) { status_print("
  • \n%s", node->details->uname); } else if((options & pe_print_printf) || (options & pe_print_ncurses)) { status_print("\t%s", node->details->uname); } else if((options & pe_print_log)) { status_print("\t%d : %s", lpc, node->details->uname); } else { status_print("%s", node->details->uname); } if(options & pe_print_html) { status_print("
  • \n"); } ); if(options & pe_print_html) { status_print("
\n"); } else if((options & pe_print_printf) || (options & pe_print_ncurses)) { status_print(" ]"); } } if(options & pe_print_html) { status_print("
\n"); } else if((options & pe_print_printf) || (options & pe_print_ncurses)) { status_print("\n"); } if(options & pe_print_details) { struct print_data_s pdata; pdata.options = options; pdata.print_data = print_data; g_hash_table_foreach(rsc->parameters, native_print_attr, &pdata); } if(options & pe_print_dev) { status_print("%s\t(%s%svariant=%s, priority=%f)", pre_text, rsc->provisional?"provisional, ":"", rsc->runnable?"":"non-startable, ", crm_element_name(rsc->xml), (double)rsc->priority); - - status_print("%s\t%d candidate colors, %d allowed nodes," - " %d rsc_cons", - pre_text, g_list_length(rsc->candidate_colors), - g_list_length(rsc->allowed_nodes), - g_list_length(rsc->rsc_cons)); + status_print("%s\tAllowed Nodes", pre_text); + slist_iter(node, node_t, rsc->allowed_nodes, lpc, + status_print("%s\t * %s %d", + pre_text, + node->details->uname, + node->weight); + ); } if(options & pe_print_max_details) { status_print("%s\t=== Actions.\n", pre_text); slist_iter( action, action_t, rsc->actions, lpc, log_action(LOG_DEBUG_4, "\trsc action: ", action, FALSE); ); status_print("%s\t=== Allowed Nodes\n", pre_text); slist_iter( node, node_t, rsc->allowed_nodes, lpc, print_node("\t", node, FALSE); ); } } void native_free(resource_t *rsc) { crm_debug_4("Freeing Allowed Nodes"); - crm_free(rsc->color); common_free(rsc); } enum rsc_role_e native_resource_state(resource_t *rsc) { if(rsc->next_role != RSC_ROLE_UNKNOWN) { return rsc->next_role; } if(rsc->role != RSC_ROLE_UNKNOWN) { return rsc->role; } return RSC_ROLE_STOPPED; } gboolean DeleteRsc(resource_t *rsc, node_t *node, pe_working_set_t *data_set) { action_t *delete = NULL; action_t *refresh = NULL; if(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); #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_ordering_optional); #endif return TRUE; } diff --git a/lib/crm/pengine/pengine.h b/lib/crm/pengine/pengine.h deleted file mode 100644 index 49a0652288..0000000000 --- a/lib/crm/pengine/pengine.h +++ /dev/null @@ -1,246 +0,0 @@ -/* $Id: pengine.h,v 1.1 2006/06/07 12:46:56 andrew Exp $ */ -/* - * Copyright (C) 2004 Andrew Beekhof - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This software is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ -#ifndef PENGINE__H -#define PENGINE__H - -#include - -typedef struct rsc_to_node_s rsc_to_node_t; -typedef struct rsc_colocation_s rsc_colocation_t; -typedef struct lrm_agent_s lrm_agent_t; -typedef struct order_constraint_s order_constraint_t; -typedef struct action_s action_t; -typedef struct action_wrapper_s action_wrapper_t; - -#include -#include -#include -#include -#include -#include -#include - -#include - -#include - -enum con_strength { - pecs_ignore, - pecs_must, - pecs_must_not, - pecs_startstop -}; - - -enum pe_stop_fail { - pesf_block, - pesf_stonith, - pesf_ignore -}; - -enum pe_ordering { - pe_ordering_manditory, - pe_ordering_restart, - pe_ordering_recover, - pe_ordering_postnotify, - pe_ordering_optional -}; - - -struct color_shared_s { - int id; - int highest_priority; - GListPtr candidate_nodes; /* node_t* */ - GListPtr allocated_resources; /* resources_t* */ - node_t *chosen_node; - gboolean pending; - int num_resources; -}; - -struct color_s { - int id; - struct color_shared_s *details; - int local_weight; -}; - -struct rsc_colocation_s { - const char *id; - resource_t *rsc_lh; - resource_t *rsc_rh; - - const char *state_lh; - const char *state_rh; - - enum con_strength strength; -}; - -struct rsc_to_node_s { - const char *id; - resource_t *rsc_lh; - - enum rsc_role_e role_filter; - GListPtr node_list_rh; /* node_t* */ -}; - - -struct action_wrapper_s -{ - enum pe_ordering type; - action_t *action; -}; - - -struct action_s -{ - int id; - int priority; - resource_t *rsc; - void *rsc_opaque; - node_t *node; - const char *task; - - char *uuid; - crm_data_t *op_entry; - - gboolean pseudo; - gboolean runnable; - gboolean optional; - gboolean failure_is_fatal; - - enum rsc_start_requirement needs; - enum action_fail_response on_fail; - enum rsc_role_e fail_role; - - gboolean dumped; - gboolean processed; - - action_t *pre_notify; - action_t *pre_notified; - action_t *post_notify; - action_t *post_notified; - - int seen_count; - - GHashTable *meta; - GHashTable *extra; - GHashTable *notify_keys; /* do NOT free */ - - GListPtr actions_before; /* action_warpper_t* */ - GListPtr actions_after; /* action_warpper_t* */ -}; - -struct order_constraint_s -{ - int id; - enum pe_ordering type; - - void *lh_opaque; - resource_t *lh_rsc; - action_t *lh_action; - char *lh_action_task; - - void *rh_opaque; - resource_t *rh_rsc; - action_t *rh_action; - char *rh_action_task; - - /* (soon to be) variant specific */ -/* int lh_rsc_incarnation; */ -/* int rh_rsc_incarnation; */ -}; - -extern gboolean stage0(pe_working_set_t *data_set); -extern gboolean stage1(pe_working_set_t *data_set); -extern gboolean stage2(pe_working_set_t *data_set); -extern gboolean stage3(pe_working_set_t *data_set); -extern gboolean stage4(pe_working_set_t *data_set); -extern gboolean stage5(pe_working_set_t *data_set); -extern gboolean stage6(pe_working_set_t *data_set); -extern gboolean stage7(pe_working_set_t *data_set); -extern gboolean stage8(pe_working_set_t *data_set); - -extern gboolean summary(GListPtr resources); - -extern gboolean pe_msg_dispatch(IPC_Channel *sender, void *user_data); - -extern gboolean process_pe_message( - HA_Message *msg, crm_data_t *xml_data, IPC_Channel *sender); - -extern gboolean unpack_constraints( - crm_data_t *xml_constraints, pe_working_set_t *data_set); - -extern gboolean unpack_resources( - crm_data_t *xml_resources, pe_working_set_t *data_set); - -extern gboolean unpack_config(crm_data_t *config, pe_working_set_t *data_set); - -extern gboolean unpack_nodes(crm_data_t *xml_nodes, pe_working_set_t *data_set); - -extern gboolean unpack_status(crm_data_t *status, pe_working_set_t *data_set); - -extern gboolean apply_placement_constraints(pe_working_set_t *data_set); - -extern gboolean choose_node_from_list(color_t *color); - -extern gboolean update_action_states(GListPtr actions); - -extern gboolean shutdown_constraints( - node_t *node, action_t *shutdown_op, pe_working_set_t *data_set); - -extern gboolean stonith_constraints( - node_t *node, action_t *stonith_op, pe_working_set_t *data_set); - -extern gboolean custom_action_order( - resource_t *lh_rsc, char *lh_task, action_t *lh_action, - resource_t *rh_rsc, char *rh_task, action_t *rh_action, - enum pe_ordering type, pe_working_set_t *data_set); - -#define order_start_start(rsc1,rsc2, type) \ - custom_action_order(rsc1, start_key(rsc1), NULL, \ - rsc2, start_key(rsc2) ,NULL, \ - type, data_set) -#define order_stop_stop(rsc1, rsc2, type) \ - custom_action_order(rsc1, stop_key(rsc1), NULL, \ - rsc2, stop_key(rsc2) ,NULL, \ - type, data_set) - -#define order_restart(rsc1) \ - custom_action_order(rsc1, stop_key(rsc1), NULL, \ - rsc1, start_key(rsc1), NULL, \ - pe_ordering_restart, data_set) - -#define order_stop_start(rsc1, rsc2, type) \ - custom_action_order(rsc1, stop_key(rsc1), NULL, \ - rsc2, start_key(rsc2) ,NULL, \ - type, data_set) - -#define order_start_stop(rsc1, rsc2, type) \ - custom_action_order(rsc1, start_key(rsc1), NULL, \ - rsc2, stop_key(rsc2) ,NULL, \ - type, data_set) - -extern gboolean process_colored_constraints(resource_t *rsc); -extern void graph_element_from_action( - action_t *action, pe_working_set_t *data_set); -extern void order_actions(action_t *lh_action, action_t *rh_action, enum pe_ordering order); - -extern const char* transition_idle_timeout; - -#endif - diff --git a/lib/crm/pengine/status.c b/lib/crm/pengine/status.c index 0074d40cf1..8f2b64c039 100644 --- a/lib/crm/pengine/status.c +++ b/lib/crm/pengine/status.c @@ -1,281 +1,278 @@ /* $Id: status.c,v 1.8 2006/08/14 09:00:57 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include #include #include crm_data_t * do_calculations( pe_working_set_t *data_set, crm_data_t *xml_input, ha_time_t *now); unsigned int pengine_input_loglevel = LOG_INFO; #define PE_WORKING_DIR HA_VARLIBDIR"/heartbeat/pengine" #define MEMCHECK_STAGE_0 0 #define check_and_exit(stage) cleanup_calculations(data_set); \ crm_mem_stats(NULL); \ crm_err("Exiting: stage %d", stage); \ exit(1); /* * Unpack everything * At the end you'll have: * - A list of nodes * - A list of resources (each with any dependencies on other resources) * - A list of constraints between resources and nodes * - A list of constraints between start/stop actions * - A list of nodes that need to be stonith'd * - A list of nodes that need to be shutdown * - A list of the possible stop/start actions (without dependencies) */ gboolean cluster_status(pe_working_set_t *data_set) { crm_data_t * config = get_object_root( XML_CIB_TAG_CRMCONFIG, data_set->input); crm_data_t * cib_nodes = get_object_root( XML_CIB_TAG_NODES, data_set->input); crm_data_t * cib_resources = get_object_root( XML_CIB_TAG_RESOURCES, data_set->input); crm_data_t * cib_status = get_object_root( XML_CIB_TAG_STATUS, data_set->input); const char *value = crm_element_value( data_set->input, XML_ATTR_HAVE_QUORUM); crm_debug_3("Beginning unpack"); /* reset remaining global variables */ if(data_set->input == NULL) { return FALSE; } if(data_set->input != NULL && crm_element_value(data_set->input, XML_ATTR_DC_UUID) != NULL) { /* this should always be present */ data_set->dc_uuid = crm_element_value_copy( data_set->input, XML_ATTR_DC_UUID); } unpack_config(config, data_set); if(value != NULL) { cl_str_to_boolean(value, &data_set->have_quorum); } if(data_set->have_quorum == FALSE && data_set->no_quorum_policy != no_quorum_ignore) { crm_warn("We do not have quorum" " - fencing and resource management disabled"); } unpack_nodes(cib_nodes, data_set); unpack_resources(cib_resources, data_set); unpack_status(cib_status, data_set); return TRUE; } static void pe_free_resources(GListPtr resources) { resource_t *rsc = NULL; GListPtr iterator = resources; while(iterator != NULL) { iterator = iterator; rsc = (resource_t *)iterator->data; iterator = iterator->next; rsc->fns->free(rsc); } if(resources != NULL) { g_list_free(resources); } } static void pe_free_actions(GListPtr actions) { GListPtr iterator = actions; while(iterator != NULL) { pe_free_action(iterator->data); iterator = iterator->next; } if(actions != NULL) { g_list_free(actions); } } static void pe_free_nodes(GListPtr nodes) { GListPtr iterator = nodes; while(iterator != NULL) { node_t *node = (node_t*)iterator->data; struct node_shared_s *details = node->details; iterator = iterator->next; crm_debug_5("deleting node"); crm_debug_5("%s is being deleted", details->uname); print_node("delete", node, FALSE); if(details != NULL) { if(details->attrs != NULL) { g_hash_table_destroy(details->attrs); } pe_free_shallow_adv(details->running_rsc, FALSE); + pe_free_shallow_adv(details->allocated_rsc, FALSE); crm_free(details); } crm_free(node); } if(nodes != NULL) { g_list_free(nodes); } } void cleanup_calculations(pe_working_set_t *data_set) { if(data_set == NULL) { return; } if(data_set->config_hash != NULL) { g_hash_table_destroy(data_set->config_hash); } crm_free(data_set->dc_uuid); crm_free(data_set->transition_idle_timeout); crm_debug_3("deleting actions"); pe_free_actions(data_set->actions); crm_debug_3("deleting resources"); pe_free_resources(data_set->resources); crm_debug_3("deleting nodes"); pe_free_nodes(data_set->nodes); free_xml(data_set->graph); free_ha_date(data_set->now); free_xml(data_set->input); data_set->stonith_action = NULL; - CRM_CHECK(data_set->colors == NULL, ;); CRM_CHECK(data_set->ordering_constraints == NULL, ;); CRM_CHECK(data_set->placement_constraints == NULL, ;); } void set_working_set_defaults(pe_working_set_t *data_set) { data_set->input = NULL; data_set->now = NULL; data_set->graph = NULL; data_set->transition_idle_timeout = NULL; data_set->dc_uuid = NULL; data_set->dc_node = NULL; data_set->have_quorum = FALSE; data_set->stonith_enabled = FALSE; data_set->stonith_action = NULL; data_set->symmetric_cluster = TRUE; data_set->is_managed_default = TRUE; data_set->no_quorum_policy = no_quorum_freeze; data_set->remove_after_stop = FALSE; data_set->stop_action_orphans = TRUE; data_set->stop_rsc_orphans = TRUE; data_set->config_hash = NULL; data_set->nodes = NULL; data_set->resources = NULL; data_set->ordering_constraints = NULL; data_set->placement_constraints = NULL; - data_set->no_color = NULL; - data_set->colors = NULL; data_set->actions = NULL; data_set->num_synapse = 0; data_set->max_valid_nodes = 0; data_set->order_id = 1; data_set->action_id = 1; - data_set->color_id = 0; data_set->default_resource_stickiness = 0; data_set->default_resource_fail_stickiness = 0; } resource_t * pe_find_resource(GListPtr rsc_list, const char *id) { unsigned lpc = 0; resource_t *rsc = NULL; resource_t *child_rsc = NULL; if(id == NULL) { return NULL; } crm_debug_4("Looking for %s in %d objects", id, g_list_length(rsc_list)); for(lpc = 0; lpc < g_list_length(rsc_list); lpc++) { rsc = g_list_nth_data(rsc_list, lpc); if(rsc == NULL) { } else if(rsc->id && strcmp(rsc->id, id) == 0){ crm_debug_4("Found a match for %s", id); return rsc; } else if(rsc->long_name && strcmp(rsc->long_name, id) == 0) { crm_debug_4("Found a match for %s", id); return rsc; } else if(rsc->clone_name && strcmp(rsc->clone_name, id) == 0) { crm_debug_4("Found a match for %s", id); return rsc; } } for(lpc = 0; lpc < g_list_length(rsc_list); lpc++) { rsc = g_list_nth_data(rsc_list, lpc); child_rsc = rsc->fns->find_child(rsc, id); if(child_rsc != NULL) { return child_rsc; } } crm_debug_2("No match for %s", id); return NULL; } diff --git a/lib/crm/pengine/utils.c b/lib/crm/pengine/utils.c index 8d57d0df1d..ec362d983f 100644 --- a/lib/crm/pengine/utils.c +++ b/lib/crm/pengine/utils.c @@ -1,1273 +1,1279 @@ /* $Id: utils.c,v 1.11 2006/08/14 09:14:45 andrew Exp $ */ /* * Copyright (C) 2004 Andrew Beekhof * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include void print_str_str(gpointer key, gpointer value, gpointer user_data); gboolean ghash_free_str_str(gpointer key, gpointer value, gpointer user_data); void unpack_operation( action_t *action, crm_data_t *xml_obj, pe_working_set_t* data_set); void pe_free_shallow(GListPtr alist) { pe_free_shallow_adv(alist, TRUE); } void pe_free_shallow_adv(GListPtr alist, gboolean with_data) { GListPtr item; GListPtr item_next = alist; while(item_next != NULL) { item = item_next; item_next = item_next->next; if(with_data) { /* crm_debug_5("freeing %p", item->data); */ crm_free(item->data); } item->data = NULL; item->next = NULL; g_list_free(item); } } node_t * pe_find_node_id(GListPtr nodes, const char *id) { unsigned lpc = 0; node_t *node = NULL; for(lpc = 0; lpc < g_list_length(nodes); lpc++) { node = g_list_nth_data(nodes, lpc); if(safe_str_eq(node->details->id, id)) { return node; } } /* error */ return NULL; } node_t * node_copy(node_t *this_node) { node_t *new_node = NULL; CRM_CHECK(this_node != NULL, return NULL); crm_malloc0(new_node, sizeof(node_t)); CRM_CHECK(new_node != NULL, return NULL); crm_debug_5("Copying %p (%s) to %p", this_node, this_node->details->uname, new_node); new_node->weight = this_node->weight; new_node->fixed = this_node->fixed; new_node->details = this_node->details; return new_node; } /* are the contents of list1 and list2 equal * nodes with weight < 0 are ignored if filter == TRUE * * slow but linear * */ gboolean node_list_eq(GListPtr list1, GListPtr list2, gboolean filter) { node_t *other_node; GListPtr lhs = list1; GListPtr rhs = list2; slist_iter( node, node_t, lhs, lpc, if(node == NULL || (filter && node->weight < 0)) { continue; } other_node = (node_t*) pe_find_node_id(rhs, node->details->id); if(other_node == NULL || other_node->weight < 0) { return FALSE; } ); lhs = list2; rhs = list1; slist_iter( node, node_t, lhs, lpc, if(node == NULL || (filter && node->weight < 0)) { continue; } other_node = (node_t*) pe_find_node_id(rhs, node->details->id); if(other_node == NULL || other_node->weight < 0) { return FALSE; } ); return TRUE; } /* the intersection of list1 and list2 */ GListPtr node_list_and(GListPtr list1, GListPtr list2, gboolean filter) { GListPtr result = NULL; unsigned lpc = 0; for(lpc = 0; lpc < g_list_length(list1); lpc++) { node_t *node = (node_t*)g_list_nth_data(list1, lpc); node_t *other_node = pe_find_node_id(list2, node->details->id); node_t *new_node = NULL; if(other_node != NULL) { new_node = node_copy(node); } if(new_node != NULL) { crm_debug_4("%s: %d + %d", node->details->uname, other_node->weight, new_node->weight); new_node->weight = merge_weights( new_node->weight, other_node->weight); crm_debug_3("New node weight for %s: %d", new_node->details->uname, new_node->weight); if(filter && new_node->weight < 0) { crm_free(new_node); new_node = NULL; } } if(new_node != NULL) { result = g_list_append(result, new_node); } } return result; } /* list1 - list2 */ GListPtr node_list_minus(GListPtr list1, GListPtr list2, gboolean filter) { GListPtr result = NULL; slist_iter( node, node_t, list1, lpc, node_t *other_node = pe_find_node_id(list2, node->details->id); node_t *new_node = NULL; if(node == NULL || other_node != NULL || (filter && node->weight < 0)) { continue; } new_node = node_copy(node); result = g_list_append(result, new_node); ); crm_debug_3("Minus result len: %d", g_list_length(result)); return result; } /* list1 + list2 - (intersection of list1 and list2) */ GListPtr node_list_xor(GListPtr list1, GListPtr list2, gboolean filter) { GListPtr result = NULL; slist_iter( node, node_t, list1, lpc, node_t *new_node = NULL; node_t *other_node = (node_t*) pe_find_node_id(list2, node->details->id); if(node == NULL || other_node != NULL || (filter && node->weight < 0)) { continue; } new_node = node_copy(node); result = g_list_append(result, new_node); ); slist_iter( node, node_t, list2, lpc, node_t *new_node = NULL; node_t *other_node = (node_t*) pe_find_node_id(list1, node->details->id); if(node == NULL || other_node != NULL || (filter && node->weight < 0)) { continue; } new_node = node_copy(node); result = g_list_append(result, new_node); ); crm_debug_3("Xor result len: %d", g_list_length(result)); return result; } GListPtr node_list_or(GListPtr list1, GListPtr list2, gboolean filter) { node_t *other_node = NULL; GListPtr result = NULL; gboolean needs_filter = FALSE; result = node_list_dup(list1, FALSE, filter); slist_iter( node, node_t, list2, lpc, if(node == NULL) { continue; } other_node = (node_t*)pe_find_node_id( result, 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); if(filter && node->weight < 0) { needs_filter = TRUE; } } else if(filter == FALSE || node->weight >= 0) { node_t *new_node = node_copy(node); result = g_list_append(result, new_node); } ); /* not the neatest way, but the most expedient for now */ if(filter && needs_filter) { GListPtr old_result = result; result = node_list_dup(old_result, FALSE, filter); pe_free_shallow_adv(old_result, TRUE); } return result; } GListPtr node_list_dup(GListPtr list1, gboolean reset, gboolean filter) { GListPtr result = NULL; slist_iter( this_node, node_t, list1, lpc, node_t *new_node = NULL; if(filter && this_node->weight < 0) { continue; } new_node = node_copy(this_node); if(reset) { new_node->weight = 0; } if(new_node != NULL) { result = g_list_append(result, new_node); } ); return result; } gint sort_rsc_priority(gconstpointer a, gconstpointer b) { const resource_t *resource1 = (const resource_t*)a; const resource_t *resource2 = (const resource_t*)b; if(a == NULL && b == NULL) { return 0; } if(a == NULL) { return 1; } if(b == NULL) { return -1; } if(resource1->priority > resource2->priority) { return -1; } if(resource1->priority < resource2->priority) { return 1; } return 0; } action_t * custom_action(resource_t *rsc, char *key, const char *task, node_t *on_node, gboolean optional, gboolean save_action, pe_working_set_t *data_set) { action_t *action = NULL; GListPtr possible_matches = NULL; CRM_CHECK(key != NULL, return NULL); CRM_CHECK(task != NULL, return NULL); if(save_action && rsc != NULL) { possible_matches = find_actions(rsc->actions, key, on_node); } if(possible_matches != NULL) { crm_free(key); if(g_list_length(possible_matches) > 1) { pe_warn("Action %s for %s on %s exists %d times", task, rsc?rsc->id:"", on_node?on_node->details->uname:"", g_list_length(possible_matches)); } action = g_list_nth_data(possible_matches, 0); crm_debug_4("Found existing action (%d) %s for %s on %s", action->id, task, rsc?rsc->id:"", on_node?on_node->details->uname:""); } if(action == NULL) { if(save_action) { crm_debug_2("Creating%s action %d: %s for %s on %s", optional?"":" manditory", data_set->action_id, key, rsc?rsc->id:"", on_node?on_node->details->uname:""); } crm_malloc0(action, sizeof(action_t)); if(action != NULL) { if(save_action) { action->id = data_set->action_id++; } else { action->id = 0; } action->rsc = rsc; action->task = task; action->node = on_node; action->actions_before = NULL; action->actions_after = NULL; action->failure_is_fatal = TRUE; action->pseudo = FALSE; action->dumped = FALSE; action->runnable = TRUE; action->processed = FALSE; action->optional = optional; action->seen_count = 0; action->extra = g_hash_table_new_full( g_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); action->meta = g_hash_table_new_full( g_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); if(save_action) { data_set->actions = g_list_append( data_set->actions, action); } action->uuid = key; if(rsc != NULL) { action->op_entry = find_rsc_op_entry(rsc, key); unpack_operation( action, action->op_entry, data_set); if(save_action) { rsc->actions = g_list_append( rsc->actions, action); } } if(save_action) { crm_debug_4("Action %d created", action->id); } } } if(optional == FALSE && action->optional) { crm_debug_2("Action %d (%s) marked manditory", action->id, action->uuid); action->optional = FALSE; } if(rsc != NULL) { enum action_tasks a_task = text2task(action->task); int warn_level = LOG_DEBUG_3; if(save_action) { warn_level = LOG_WARNING; } if(action->node != NULL && action->op_entry != NULL) { unpack_instance_attributes( action->op_entry, XML_TAG_ATTR_SETS, action->node->details->attrs, action->extra, NULL, data_set->now); } if(action->node == NULL) { action->runnable = FALSE; } else if(rsc->is_managed == FALSE) { crm_log_maybe(warn_level, "Action %s %s is for %s (unmanaged)", action->uuid, task, rsc->id); action->optional = TRUE; /* action->runnable = FALSE; */ #if 0 } else if(action->node->details->unclean) { crm_log_maybe(warn_level, "Action %s on %s is unrunnable (unclean)", action->uuid, action->node?action->node->details->uname:""); action->runnable = FALSE; #endif } else if(action->node->details->online == FALSE) { action->runnable = FALSE; crm_log_maybe(warn_level, "Action %s on %s is unrunnable (offline)", action->uuid, action->node->details->uname); if(action->rsc->is_managed && save_action && a_task == stop_rsc) { crm_log_maybe(warn_level, "Marking node %s unclean", action->node->details->uname); action->node->details->unclean = TRUE; } } else if(action->needs == rsc_req_nothing) { crm_debug_3("Action %s doesnt require anything", action->uuid); action->runnable = TRUE; #if 0 /* * No point checking this * - if we dont have quorum we cant stonith anyway */ } else if(action->needs == rsc_req_stonith) { crm_debug_3("Action %s requires only stonith", action->uuid); action->runnable = TRUE; #endif } else if(data_set->have_quorum == FALSE && data_set->no_quorum_policy == no_quorum_stop) { action->runnable = FALSE; crm_debug("%s\t%s %s (cancelled : quorum)", action->node->details->uname, action->task, rsc->id); } else if(data_set->have_quorum == FALSE && data_set->no_quorum_policy == no_quorum_freeze) { crm_debug_3("Check resource is already active"); if(rsc->fns->active(rsc, TRUE) == FALSE) { action->runnable = FALSE; crm_debug("%s\t%s %s (cancelled : quorum freeze)", action->node->details->uname, action->task, rsc->id); } } else { crm_debug_3("Action %s is runnable", action->uuid); action->runnable = TRUE; } if(save_action) { switch(a_task) { case stop_rsc: rsc->stopping = TRUE; break; case start_rsc: rsc->starting = FALSE; if(action->runnable) { rsc->starting = TRUE; } break; default: break; } } } return action; } void unpack_operation( action_t *action, crm_data_t *xml_obj, pe_working_set_t* data_set) { int lpc = 0; const char *class = NULL; const char *value = NULL; const char *fields[] = { XML_LRM_ATTR_INTERVAL, "timeout", "start_delay", }; CRM_CHECK(action->rsc != NULL, return); if(xml_obj != NULL) { value = crm_element_value(xml_obj, "prereq"); } if(value == NULL && safe_str_eq(action->task, CRMD_ACTION_START)) { value = g_hash_table_lookup( action->rsc->meta, "start_prereq"); } if(value == NULL && safe_str_neq(action->task, CRMD_ACTION_START)) { /* todo: integrate stop as an option? */ action->needs = rsc_req_nothing; value = "nothing (default)"; } else if(safe_str_eq(value, "nothing")) { action->needs = rsc_req_nothing; } else if(safe_str_eq(value, "quorum")) { action->needs = rsc_req_quorum; } else if(safe_str_eq(value, "fencing")) { action->needs = rsc_req_stonith; } else if(data_set->no_quorum_policy == no_quorum_ignore) { action->needs = rsc_req_nothing; value = "nothing (default)"; } else if(data_set->no_quorum_policy == no_quorum_freeze && data_set->stonith_enabled) { action->needs = rsc_req_stonith; value = "fencing (default)"; } else { action->needs = rsc_req_quorum; value = "quorum (default)"; } class = g_hash_table_lookup(action->rsc->meta, "class"); if(safe_str_eq(class, "stonith")) { if(action->needs == rsc_req_stonith) { crm_config_err("Stonith resources (eg. %s) cannot require" " fencing to start", action->rsc->id); } action->needs = rsc_req_nothing; value = "nothing (fencing override)"; } crm_debug_3("\tAction %s requires: %s", action->task, value); value = NULL; if(xml_obj != NULL) { value = crm_element_value(xml_obj, "on_fail"); } if(value == NULL && safe_str_eq(action->task, CRMD_ACTION_STOP)) { value = g_hash_table_lookup( action->rsc->meta, "on_stopfail"); if(value != NULL) { #if CRM_DEPRECATED_SINCE_2_0_2 crm_config_err("The \"on_stopfail\" attribute used in" " %s has been deprecated since 2.0.2", action->rsc->id); #else crm_config_err("The \"on_stopfail\" attribute used in" " %s has been deprecated since 2.0.2" " and is now disabled", action->rsc->id); value = NULL; #endif crm_config_err("Please use specify the \"on_fail\"" " attribute on the \"stop\" operation" " instead"); } } if(value == NULL) { } else if(safe_str_eq(value, "block")) { action->on_fail = action_fail_block; } else if(safe_str_eq(value, "fence")) { action->on_fail = action_fail_fence; value = "node fencing"; } else if(safe_str_eq(value, "ignore")) { action->on_fail = action_fail_ignore; value = "ignore"; } else if(safe_str_eq(value, "migrate")) { action->on_fail = action_fail_migrate; value = "force migration"; } else if(safe_str_eq(value, "stop")) { action->fail_role = RSC_ROLE_STOPPED; value = "stop resource"; } else if(safe_str_eq(value, "restart") || safe_str_eq(value, "nothing")) { action->on_fail = action_fail_recover; value = "restart (and possibly migrate)"; } else { pe_err("Resource %s: Unknown failure type (%s)", action->rsc->id, value); value = NULL; } /* defaults */ if(value == NULL && safe_str_eq(action->task, CRMD_ACTION_STOP)) { if(data_set->stonith_enabled) { action->on_fail = action_fail_fence; value = "resource fence (default)"; } else { action->on_fail = action_fail_block; value = "resource block (default)"; } } else if(value == NULL) { action->on_fail = action_fail_recover; value = "restart (and possibly migrate) (default)"; } crm_debug_3("\t%s failure handling: %s", action->task, value); value = NULL; if(xml_obj != NULL) { value = crm_element_value(xml_obj, "role_after_failure"); } if(value != NULL && action->fail_role == RSC_ROLE_UNKNOWN) { action->fail_role = text2role(value); } /* defaults */ if(action->fail_role == RSC_ROLE_UNKNOWN) { if(safe_str_eq(action->task, CRMD_ACTION_PROMOTE)) { action->fail_role = RSC_ROLE_SLAVE; } else { action->fail_role = RSC_ROLE_STARTED; } } crm_debug_3("\t%s failure results in: %s", action->task, role2text(action->fail_role)); if(xml_obj != NULL) { xml_prop_iter(xml_obj, p_name, p_value, if(p_value != NULL) { g_hash_table_insert(action->meta, crm_strdup(p_name), crm_strdup(p_value)); } ); unpack_instance_attributes(xml_obj, XML_TAG_META_SETS, NULL, action->meta, NULL, data_set->now); unpack_instance_attributes(xml_obj, XML_TAG_ATTR_SETS, NULL, action->meta, NULL, data_set->now); } if(g_hash_table_lookup(action->meta, "timeout") == NULL) { g_hash_table_insert( action->meta, crm_strdup("timeout"), crm_strdup(pe_pref(data_set->config_hash, "default-action-timeout"))); } for(;lpc < DIMOF(fields); lpc++) { value = g_hash_table_lookup(action->meta, fields[lpc]); if(value != NULL) { char *tmp_ms = NULL; int tmp_i = crm_get_msec(value); if(tmp_i < 0) { tmp_i = 0; } tmp_ms = crm_itoa(tmp_i); g_hash_table_replace( action->meta, crm_strdup(fields[lpc]), tmp_ms); } } } crm_data_t * find_rsc_op_entry(resource_t *rsc, const char *key) { const char *name = NULL; const char *value = NULL; const char *interval = NULL; char *match_key = NULL; crm_data_t *op = NULL; xml_child_iter_filter( rsc->ops_xml, operation, "op", name = crm_element_value(operation, "name"); interval = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); value = crm_element_value(operation, "disabled"); if(crm_is_true(value)) { crm_debug_2("%s disabled", ID(operation)); continue; } match_key = generate_op_key( rsc->id, name, crm_get_msec(interval)); if(safe_str_eq(key, match_key)) { op = operation; } crm_free(match_key); if(op != NULL) { return op; } ); crm_debug_3("No match for %s", key); return op; } void print_node(const char *pre_text, node_t *node, gboolean details) { if(node == NULL) { crm_debug_4("%s%s: ", pre_text==NULL?"":pre_text, pre_text==NULL?"":": "); return; } crm_debug_4("%s%s%sNode %s: (weight=%d, fixed=%s)", pre_text==NULL?"":pre_text, pre_text==NULL?"":": ", node->details==NULL?"error ":node->details->online?"":"Unavailable/Unclean ", node->details->uname, node->weight, node->fixed?"True":"False"); if(details && node != NULL && node->details != NULL) { char *pe_mutable = crm_strdup("\t\t"); crm_debug_4("\t\t===Node Attributes"); g_hash_table_foreach(node->details->attrs, print_str_str, pe_mutable); crm_free(pe_mutable); crm_debug_4("\t\t=== Resources"); slist_iter( rsc, resource_t, node->details->running_rsc, lpc, print_resource(LOG_DEBUG_4, "\t\t", rsc, FALSE); ); } } /* * Used by the HashTable for-loop */ void print_str_str(gpointer key, gpointer value, gpointer user_data) { crm_debug_4("%s%s %s ==> %s", user_data==NULL?"":(char*)user_data, user_data==NULL?"":": ", (char*)key, (char*)value); } void print_resource( int log_level, const char *pre_text, resource_t *rsc, gboolean details) { long options = pe_print_log; if(rsc == NULL) { crm_log_maybe(log_level-1, "%s%s: ", pre_text==NULL?"":pre_text, pre_text==NULL?"":": "); return; } if(details) { options |= pe_print_details; } rsc->fns->print(rsc, pre_text, options, &log_level); } void log_action(unsigned int log_level, const char *pre_text, action_t *action, gboolean details) { const char *node_uname = NULL; const char *node_uuid = NULL; if(action == NULL) { crm_log_maybe(log_level, "%s%s: ", pre_text==NULL?"":pre_text, pre_text==NULL?"":": "); return; } if(action->pseudo) { node_uname = NULL; node_uuid = NULL; } else if(action->node != NULL) { node_uname = action->node->details->uname; node_uuid = action->node->details->id; } else { node_uname = ""; node_uuid = NULL; } switch(text2task(action->task)) { case stonith_node: case shutdown_crm: crm_log_maybe(log_level, "%s%s%sAction %d: %s%s%s%s%s%s", pre_text==NULL?"":pre_text, pre_text==NULL?"":": ", action->pseudo?"Pseduo ":action->optional?"Optional ":action->runnable?action->processed?"":"(Provisional) ":"!!Non-Startable!! ", action->id, action->uuid, node_uname?"\ton ":"", node_uname?node_uname:"", node_uuid?"\t\t(":"", node_uuid?node_uuid:"", node_uuid?")":""); break; default: crm_log_maybe(log_level, "%s%s%sAction %d: %s %s%s%s%s%s%s", pre_text==NULL?"":pre_text, pre_text==NULL?"":": ", action->optional?"Optional ":action->pseudo?"Pseduo ":action->runnable?action->processed?"":"(Provisional) ":"!!Non-Startable!! ", action->id, action->uuid, safe_val3("", action, rsc, id), node_uname?"\ton ":"", node_uname?node_uname:"", node_uuid?"\t\t(":"", node_uuid?node_uuid:"", node_uuid?")":""); break; } if(details) { crm_log_maybe(log_level+1, "\t\t====== Preceeding Actions"); slist_iter( other, action_wrapper_t, action->actions_before, lpc, log_action(log_level+1, "\t\t", other->action, FALSE); ); #if 1 crm_log_maybe(log_level+1, "\t\t====== Subsequent Actions"); slist_iter( other, action_wrapper_t, action->actions_after, lpc, log_action(log_level+1, "\t\t", other->action, FALSE); ); #endif crm_log_maybe(log_level+1, "\t\t====== End"); } else { crm_log_maybe(log_level, "\t\t(seen=%d, before=%d, after=%d)", action->seen_count, g_list_length(action->actions_before), g_list_length(action->actions_after)); } } void pe_free_action(action_t *action) { if(action == NULL) { return; } pe_free_shallow(action->actions_before);/* action_warpper_t* */ pe_free_shallow(action->actions_after); /* action_warpper_t* */ g_hash_table_destroy(action->extra); g_hash_table_destroy(action->meta); crm_free(action->uuid); crm_free(action); } GListPtr find_recurring_actions(GListPtr input, node_t *not_on_node) { const char *value = NULL; GListPtr result = NULL; CRM_CHECK(input != NULL, return NULL); slist_iter( action, action_t, input, lpc, value = g_hash_table_lookup(action->meta, XML_LRM_ATTR_INTERVAL); if(value == NULL) { /* skip */ } else if(safe_str_eq(value, "0")) { /* skip */ } else if(safe_str_eq(CRMD_ACTION_CANCEL, action->task)) { /* skip */ } else if(not_on_node == NULL) { crm_debug_5("(null) Found: %s", action->uuid); result = g_list_append(result, action); } else if(action->node == NULL) { /* skip */ } else if(action->node->details != not_on_node->details) { crm_debug_5("Found: %s", action->uuid); result = g_list_append(result, action); } ); return result; } GListPtr find_actions(GListPtr input, const char *key, node_t *on_node) { GListPtr result = NULL; CRM_CHECK(key != NULL, return NULL); slist_iter( action, action_t, input, lpc, crm_debug_5("Matching %s against %s", key, action->uuid); if(safe_str_neq(key, action->uuid)) { continue; } else if(on_node == NULL) { result = g_list_append(result, action); } else if(action->node == NULL) { /* skip */ crm_debug_2("While looking for %s action on %s, " "found an unallocated one. Assigning" " it to the requested node...", key, on_node->details->uname); action->node = on_node; result = g_list_append(result, action); } else if(safe_str_eq(on_node->details->id, action->node->details->id)) { result = g_list_append(result, action); } ); return result; } GListPtr find_actions_exact(GListPtr input, const char *key, node_t *on_node) { GListPtr result = NULL; CRM_CHECK(key != NULL, return NULL); slist_iter( action, action_t, input, lpc, crm_debug_5("Matching %s against %s", key, action->uuid); if(safe_str_neq(key, action->uuid)) { crm_debug_3("Key mismatch: %s vs. %s", key, action->uuid); continue; } else if(on_node == NULL || action->node == NULL) { crm_debug_3("on_node=%p, action->node=%p", on_node, action->node); continue; } else if(safe_str_eq(on_node->details->id, action->node->details->id)) { result = g_list_append(result, action); } crm_debug_2("Node mismatch: %s vs. %s", on_node->details->id, action->node->details->id); ); return result; } void set_id(crm_data_t * xml_obj, const char *prefix, int child) { int id_len = 0; gboolean use_prefix = TRUE; gboolean use_child = TRUE; char *new_id = NULL; const char *id = crm_element_value(xml_obj, XML_ATTR_ID); id_len = 1 + strlen(id); if(child > 999) { pe_err("Are you insane?!?" " The CRM does not support > 1000 children per resource"); return; } else if(child < 0) { use_child = FALSE; } else { id_len += 4; /* child */ } if(prefix == NULL || safe_str_eq(id, prefix)) { use_prefix = FALSE; } else { id_len += (1 + strlen(prefix)); } crm_malloc0(new_id, id_len); if(use_child) { snprintf(new_id, id_len, "%s%s%s:%d", use_prefix?prefix:"", use_prefix?":":"", id, child); } else { snprintf(new_id, id_len, "%s%s%s", use_prefix?prefix:"", use_prefix?":":"", id); } crm_xml_add(xml_obj, XML_ATTR_ID, new_id); crm_free(new_id); } static void resource_node_score(resource_t *rsc, node_t *node, int score, const char *tag) { node_t *match = NULL; crm_debug_2("Setting %s for %s on %s: %d", tag, rsc->id, node->details->uname, score); match = pe_find_node_id(rsc->allowed_nodes, node->details->id); if(match == NULL) { match = node_copy(node); match->weight = 0; rsc->allowed_nodes = g_list_append(rsc->allowed_nodes, match); } match->weight = merge_weights(match->weight, score); } void resource_location(resource_t *rsc, node_t *node, int score, const char *tag, pe_working_set_t *data_set) { CRM_CHECK(rsc->variant == pe_native, return); if(node != NULL) { resource_node_score(rsc, node, score, tag); } else if(data_set != NULL) { slist_iter( node, node_t, data_set->nodes, lpc, resource_node_score(rsc, node, score, tag); ); } else { slist_iter( node, node_t, rsc->allowed_nodes, lpc, resource_node_score(rsc, node, score, tag); ); } + + if(node == NULL && score == -INFINITY) { + rsc->provisional = FALSE; + crm_free(rsc->allocated_to); + rsc->allocated_to = NULL; + } } void order_actions( action_t *lh_action, action_t *rh_action, enum pe_ordering order) { action_wrapper_t *wrapper = NULL; GListPtr list = NULL; crm_debug_2("Ordering Action %s before %s", lh_action->uuid, rh_action->uuid); log_action(LOG_DEBUG_4, "LH (order_actions)", lh_action, FALSE); log_action(LOG_DEBUG_4, "RH (order_actions)", rh_action, FALSE); crm_malloc0(wrapper, sizeof(action_wrapper_t)); if(wrapper != NULL) { wrapper->action = rh_action; wrapper->type = order; list = lh_action->actions_after; list = g_list_append(list, wrapper); lh_action->actions_after = list; wrapper = NULL; } if(order != pe_ordering_recover) { crm_malloc0(wrapper, sizeof(action_wrapper_t)); if(wrapper != NULL) { wrapper->action = lh_action; wrapper->type = order; list = rh_action->actions_before; list = g_list_append(list, wrapper); rh_action->actions_before = list; } } } const char * get_interval(crm_data_t *xml_op) { const char *interval_s = NULL; interval_s = crm_element_value(xml_op, XML_LRM_ATTR_INTERVAL); #if CRM_DEPRECATED_SINCE_2_0_4 if(interval_s == NULL) { crm_data_t *params = NULL; params = find_xml_node(xml_op, XML_TAG_PARAMS, FALSE); if(params != NULL) { interval_s = crm_element_value( params, XML_LRM_ATTR_INTERVAL); } } #endif CRM_CHECK(interval_s != NULL, crm_err("Invalid rsc op: %s", ID(xml_op)); return "0"); return interval_s; } #define sort_return(an_int) crm_free(a_uuid); crm_free(b_uuid); return an_int gint sort_op_by_callid(gconstpointer a, gconstpointer b) { char *a_uuid = NULL; char *b_uuid = NULL; const char *a_task_id = cl_get_string(a, XML_LRM_ATTR_CALLID); const char *b_task_id = cl_get_string(b, XML_LRM_ATTR_CALLID); const char *a_key = cl_get_string(a, XML_ATTR_TRANSITION_MAGIC); const char *b_key = cl_get_string(b, XML_ATTR_TRANSITION_MAGIC); const char *a_xml_id = ID(a); const char *b_xml_id = ID(b); int a_id = -1; int b_id = -1; int a_rc = -1; int b_rc = -1; int a_status = -1; int b_status = -1; int a_call_id = -1; int b_call_id = -1; if(safe_str_eq(a_xml_id, b_xml_id)) { /* We have duplicate lrm_rsc_op entries in the status * section which is unliklely to be a good thing * - we can handle it easily enough, but we need to get * to the bottom of why its happening. */ pe_err("Duplicate lrm_rsc_op entries named %s", a_xml_id); sort_return(0); } CRM_CHECK(a_task_id != NULL && b_task_id != NULL, sort_return(0)); a_call_id = crm_parse_int(a_task_id, NULL); b_call_id = crm_parse_int(b_task_id, NULL); if(a_call_id == -1 && b_call_id == -1) { /* both are pending ops so it doesnt matter since * stops are never pending */ sort_return(0); } else if(a_call_id >= 0 && a_call_id < b_call_id) { crm_debug_4("%s (%d) < %s (%d) : call id", ID(a), a_call_id, ID(b), b_call_id); sort_return(-1); } else if(b_call_id >= 0 && a_call_id > b_call_id) { crm_debug_4("%s (%d) > %s (%d) : call id", ID(a), a_call_id, ID(b), b_call_id); sort_return(1); } crm_debug_5("%s (%d) == %s (%d) : continuing", ID(a), a_call_id, ID(b), b_call_id); /* now process pending ops */ CRM_CHECK(a_key != NULL && b_key != NULL, sort_return(0)); CRM_CHECK(decode_transition_magic( a_key,&a_uuid,&a_id,&a_status, &a_rc), sort_return(0)); CRM_CHECK(decode_transition_magic( b_key,&b_uuid,&b_id,&b_status, &b_rc), sort_return(0)); /* try and determin the relative age of the operation... * some pending operations (ie. a start) may have been supuerceeded * by a subsequent stop * * [a|b]_id == -1 means its a shutdown operation and _always_ comes last */ if(safe_str_neq(a_uuid, b_uuid) || a_id == b_id) { /* * some of the logic in here may be redundant... * * if the UUID from the TE doesnt match then one better * be a pending operation. * pending operations dont survive between elections and joins * because we query the LRM directly */ CRM_CHECK(a_call_id == -1 || b_call_id == -1, sort_return(0)); CRM_CHECK(a_call_id >= 0 || b_call_id >= 0, sort_return(0)); if(b_call_id == -1) { crm_debug_2("%s (%d) < %s (%d) : transition + call id", ID(a), a_call_id, ID(b), b_call_id); sort_return(-1); } if(a_call_id == -1) { crm_debug_2("%s (%d) > %s (%d) : transition + call id", ID(a), a_call_id, ID(b), b_call_id); sort_return(1); } } else if((a_id >= 0 && a_id < b_id) || b_id == -1) { crm_debug_3("%s (%d) < %s (%d) : transition", ID(a), a_id, ID(b), b_id); sort_return(-1); } else if((b_id >= 0 && a_id > b_id) || a_id == -1) { crm_debug_3("%s (%d) > %s (%d) : transition", ID(a), a_id, ID(b), b_id); sort_return(1); } /* we should never end up here */ crm_err("%s (%d:%d:%s) ?? %s (%d:%d:%s) : default", ID(a), a_call_id, a_id, a_uuid, ID(b), b_call_id, b_id, b_uuid); CRM_CHECK(FALSE, sort_return(0)); }