No OneTemporary
Actions

Size

36 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/msg_xml.h b/include/crm/msg_xml.h
	index d0cdf6cd3d..af3f33e883 100644
	--- a/include/crm/msg_xml.h
	+++ b/include/crm/msg_xml.h
	@@ -1,424 +1,425 @@
	/*
	* Copyright 2004-2020 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#ifndef XML_TAGS__H
	# define XML_TAGS__H

	#ifdef __cplusplus
	extern "C" {
	#endif

	# ifndef F_ORIG
	# define F_ORIG "src"
	# endif

	# ifndef F_SEQ
	# define F_SEQ "seq"
	# endif

	# ifndef F_SUBTYPE
	# define F_SUBTYPE "subt"
	# endif

	# ifndef F_TYPE
	# define F_TYPE "t"
	# endif

	# ifndef F_CLIENTNAME
	# define F_CLIENTNAME "cn"
	# endif

	# ifndef F_XML_TAGNAME
	# define F_XML_TAGNAME "__name__"
	# endif

	# ifndef T_CRM
	# define T_CRM "crmd"
	# endif

	# ifndef T_ATTRD
	# define T_ATTRD "attrd"
	# endif

	# define CIB_OPTIONS_FIRST "cib-bootstrap-options"

	# define F_CRM_DATA "crm_xml"
	# define F_CRM_TASK "crm_task"
	# define F_CRM_HOST_TO "crm_host_to"
	# define F_CRM_MSG_TYPE F_SUBTYPE
	# define F_CRM_SYS_TO "crm_sys_to"
	# define F_CRM_SYS_FROM "crm_sys_from"
	# define F_CRM_HOST_FROM F_ORIG
	# define F_CRM_REFERENCE XML_ATTR_REFERENCE
	# define F_CRM_VERSION XML_ATTR_VERSION
	# define F_CRM_ORIGIN "origin"
	# define F_CRM_USER "crm_user"
	# define F_CRM_JOIN_ID "join_id"
	# define F_CRM_DC_LEAVING "dc-leaving"
	# define F_CRM_ELECTION_ID "election-id"
	# define F_CRM_ELECTION_AGE_S "election-age-sec"
	# define F_CRM_ELECTION_AGE_US "election-age-nano-sec"
	# define F_CRM_ELECTION_OWNER "election-owner"
	# define F_CRM_TGRAPH "crm-tgraph-file"
	# define F_CRM_TGRAPH_INPUT "crm-tgraph-in"

	# define F_CRM_THROTTLE_MODE "crm-limit-mode"
	# define F_CRM_THROTTLE_MAX "crm-limit-max"

	/---- Common tags/attrs /
	# define XML_DIFF_MARKER "__crm_diff_marker__"
	# define XML_TAG_CIB "cib"
	# define XML_TAG_FAILED "failed"

	# define XML_ATTR_CRM_VERSION "crm_feature_set"
	# define XML_ATTR_DIGEST "digest"
	# define XML_ATTR_VALIDATION "validate-with"
	# define XML_ATTR_RA_VERSION "ra-version"

	# define XML_ATTR_QUORUM_PANIC "no-quorum-panic"
	# define XML_ATTR_HAVE_QUORUM "have-quorum"
	# define XML_ATTR_HAVE_WATCHDOG "have-watchdog"
	# define XML_ATTR_GENERATION "epoch"
	# define XML_ATTR_GENERATION_ADMIN "admin_epoch"
	# define XML_ATTR_NUMUPDATES "num_updates"
	# define XML_ATTR_TIMEOUT "timeout"
	# define XML_ATTR_ORIGIN "crm-debug-origin"
	# define XML_ATTR_TSTAMP "crm-timestamp"
	# define XML_CIB_ATTR_WRITTEN "cib-last-written"
	# define XML_ATTR_VERSION "version"
	# define XML_ATTR_DESC "description"
	# define XML_ATTR_ID "id"
	# define XML_ATTR_IDREF "id-ref"
	# define XML_ATTR_ID_LONG "long-id"
	# define XML_ATTR_TYPE "type"
	# define XML_ATTR_VERBOSE "verbose"
	# define XML_ATTR_OP "op"
	# define XML_ATTR_DC_UUID "dc-uuid"
	# define XML_ATTR_UPDATE_ORIG "update-origin"
	# define XML_ATTR_UPDATE_CLIENT "update-client"
	# define XML_ATTR_UPDATE_USER "update-user"

	# define XML_BOOLEAN_TRUE "true"
	# define XML_BOOLEAN_FALSE "false"
	# define XML_BOOLEAN_YES XML_BOOLEAN_TRUE
	# define XML_BOOLEAN_NO XML_BOOLEAN_FALSE

	# define XML_TAG_OPTIONS "options"

	/---- top level tags/attrs /
	# define XML_ATTR_REQUEST "request"
	# define XML_ATTR_RESPONSE "response"

	# define XML_ATTR_UNAME "uname"
	# define XML_ATTR_UUID "id"
	# define XML_ATTR_REFERENCE "reference"

	# define XML_CRM_TAG_PING "ping_response"
	# define XML_PING_ATTR_STATUS "result"
	# define XML_PING_ATTR_SYSFROM "crm_subsystem"
	# define XML_PING_ATTR_CRMDSTATE "crmd_state"

	# define XML_TAG_FRAGMENT "cib_fragment"

	# define XML_FAIL_TAG_CIB "failed_update"

	# define XML_FAILCIB_ATTR_ID "id"
	# define XML_FAILCIB_ATTR_OBJTYPE "object_type"
	# define XML_FAILCIB_ATTR_OP "operation"
	# define XML_FAILCIB_ATTR_REASON "reason"

	/---- CIB specific tags/attrs /
	# define XML_CIB_TAG_SECTION_ALL "all"
	# define XML_CIB_TAG_CONFIGURATION "configuration"
	# define XML_CIB_TAG_STATUS "status"
	# define XML_CIB_TAG_RESOURCES "resources"
	# define XML_CIB_TAG_NODES "nodes"
	# define XML_CIB_TAG_DOMAINS "domains"
	# define XML_CIB_TAG_CONSTRAINTS "constraints"
	# define XML_CIB_TAG_CRMCONFIG "crm_config"
	# define XML_CIB_TAG_OPCONFIG "op_defaults"
	# define XML_CIB_TAG_RSCCONFIG "rsc_defaults"
	# define XML_CIB_TAG_ACLS "acls"
	# define XML_CIB_TAG_ALERTS "alerts"
	# define XML_CIB_TAG_ALERT "alert"
	# define XML_CIB_TAG_ALERT_RECIPIENT "recipient"
	# define XML_CIB_TAG_ALERT_SELECT "select"
	# define XML_CIB_TAG_ALERT_ATTRIBUTES "select_attributes"
	# define XML_CIB_TAG_ALERT_FENCING "select_fencing"
	# define XML_CIB_TAG_ALERT_NODES "select_nodes"
	# define XML_CIB_TAG_ALERT_RESOURCES "select_resources"
	# define XML_CIB_TAG_ALERT_ATTR "attribute"

	# define XML_CIB_TAG_STATE "node_state"
	# define XML_CIB_TAG_NODE "node"
	# define XML_CIB_TAG_NVPAIR "nvpair"

	# define XML_CIB_TAG_PROPSET "cluster_property_set"
	# define XML_TAG_ATTR_SETS "instance_attributes"
	# define XML_TAG_META_SETS "meta_attributes"
	# define XML_TAG_ATTRS "attributes"
	# define XML_TAG_RSC_VER_ATTRS "rsc_versioned_attrs"
	# define XML_TAG_OP_VER_ATTRS "op_versioned_attrs"
	# define XML_TAG_OP_VER_META "op_versioned_meta"
	# define XML_TAG_PARAMS "parameters"
	# define XML_TAG_PARAM "param"
	# define XML_TAG_UTILIZATION "utilization"

	# define XML_TAG_RESOURCE_REF "resource_ref"
	# define XML_CIB_TAG_RESOURCE "primitive"
	# define XML_CIB_TAG_GROUP "group"
	# define XML_CIB_TAG_INCARNATION "clone"
	# define XML_CIB_TAG_MASTER "master" // deprecated since 2.0.0
	# define XML_CIB_TAG_CONTAINER "bundle"

	# define XML_CIB_TAG_RSC_TEMPLATE "template"

	# define XML_RSC_ATTR_TARGET "container-attribute-target"
	# define XML_RSC_ATTR_RESTART "restart-type"
	# define XML_RSC_ATTR_ORDERED "ordered"
	# define XML_RSC_ATTR_INTERLEAVE "interleave"
	# define XML_RSC_ATTR_INCARNATION "clone"
	# define XML_RSC_ATTR_INCARNATION_MAX "clone-max"
	# define XML_RSC_ATTR_INCARNATION_MIN "clone-min"
	# define XML_RSC_ATTR_INCARNATION_NODEMAX "clone-node-max"
	# define XML_RSC_ATTR_PROMOTABLE "promotable"
	# define XML_RSC_ATTR_PROMOTED_MAX "promoted-max"
	# define XML_RSC_ATTR_PROMOTED_NODEMAX "promoted-node-max"
	# define XML_RSC_ATTR_MASTER_MAX "master-max" // deprecated since 2.0.0
	# define XML_RSC_ATTR_MASTER_NODEMAX "master-node-max" // deprecated since 2.0.0
	# define XML_RSC_ATTR_MANAGED "is-managed"
	# define XML_RSC_ATTR_TARGET_ROLE "target-role"
	# define XML_RSC_ATTR_UNIQUE "globally-unique"
	# define XML_RSC_ATTR_NOTIFY "notify"
	# define XML_RSC_ATTR_STICKINESS "resource-stickiness"
	# define XML_RSC_ATTR_FAIL_STICKINESS "migration-threshold"
	# define XML_RSC_ATTR_FAIL_TIMEOUT "failure-timeout"
	# define XML_RSC_ATTR_MULTIPLE "multiple-active"
	# define XML_RSC_ATTR_REQUIRES "requires"
	# define XML_RSC_ATTR_PROVIDES "provides"
	# define XML_RSC_ATTR_CONTAINER "container"
	# define XML_RSC_ATTR_INTERNAL_RSC "internal_rsc"
	# define XML_RSC_ATTR_MAINTENANCE "maintenance"
	# define XML_RSC_ATTR_REMOTE_NODE "remote-node"
	# define XML_RSC_ATTR_CLEAR_OP "clear_failure_op"
	# define XML_RSC_ATTR_CLEAR_INTERVAL "clear_failure_interval"
	# define XML_RSC_ATTR_REMOTE_RA_ADDR "addr"
	# define XML_RSC_ATTR_REMOTE_RA_SERVER "server"
	# define XML_RSC_ATTR_REMOTE_RA_PORT "port"

	# define XML_REMOTE_ATTR_RECONNECT_INTERVAL "reconnect_interval"

	# define XML_OP_ATTR_ON_FAIL "on-fail"
	# define XML_OP_ATTR_START_DELAY "start-delay"
	# define XML_OP_ATTR_ALLOW_MIGRATE "allow-migrate"
	# define XML_OP_ATTR_ORIGIN "interval-origin"
	# define XML_OP_ATTR_PENDING "record-pending"
	# define XML_OP_ATTR_DIGESTS_ALL "digests-all"
	# define XML_OP_ATTR_DIGESTS_SECURE "digests-secure"

	# define XML_CIB_TAG_LRM "lrm"
	# define XML_LRM_TAG_RESOURCES "lrm_resources"
	# define XML_LRM_TAG_RESOURCE "lrm_resource"
	# define XML_LRM_TAG_RSC_OP "lrm_rsc_op"
	# define XML_AGENT_ATTR_CLASS "class"
	# define XML_AGENT_ATTR_PROVIDER "provider"

	# define XML_CIB_ATTR_REPLACE "replace"
	# define XML_CIB_ATTR_SOURCE "source"

	# define XML_CIB_ATTR_PRIORITY "priority"
	# define XML_CIB_ATTR_SOURCE "source"

	# define XML_NODE_JOIN_STATE "join"
	# define XML_NODE_EXPECTED "expected"
	# define XML_NODE_IN_CLUSTER "in_ccm"
	# define XML_NODE_IS_PEER "crmd"
	# define XML_NODE_IS_REMOTE "remote_node"
	# define XML_NODE_IS_FENCED "node_fenced"
	# define XML_NODE_IS_MAINTENANCE "node_in_maintenance"

	# define XML_CIB_ATTR_SHUTDOWN "shutdown"

	/* Aside from being an old name for the executor, LRM is a misnomer here because
	* the controller and scheduler use these to track actions, which are not always
	* executor operations.
	*/

	// XML attribute that takes interval specification (user-facing configuration)
	# define XML_LRM_ATTR_INTERVAL "interval"

	// XML attribute that takes interval in milliseconds (daemon APIs)
	// (identical value as above, but different constant allows clearer code intent)
	# define XML_LRM_ATTR_INTERVAL_MS XML_LRM_ATTR_INTERVAL

	# define XML_LRM_ATTR_TASK "operation"
	# define XML_LRM_ATTR_TASK_KEY "operation_key"
	# define XML_LRM_ATTR_TARGET "on_node"
	# define XML_LRM_ATTR_TARGET_UUID "on_node_uuid"
	/*! Actions to be executed on Pacemaker Remote nodes are routed through the
	* controller on the cluster node hosting the remote connection. That cluster
	* node is considered the router node for the action.
	*/
	# define XML_LRM_ATTR_ROUTER_NODE "router_node"
	# define XML_LRM_ATTR_RSCID "rsc-id"
	# define XML_LRM_ATTR_OPSTATUS "op-status"
	# define XML_LRM_ATTR_RC "rc-code"
	# define XML_LRM_ATTR_CALLID "call-id"
	# define XML_LRM_ATTR_OP_DIGEST "op-digest"
	# define XML_LRM_ATTR_OP_RESTART "op-force-restart"
	# define XML_LRM_ATTR_OP_SECURE "op-secure-params"
	# define XML_LRM_ATTR_RESTART_DIGEST "op-restart-digest"
	# define XML_LRM_ATTR_SECURE_DIGEST "op-secure-digest"
	# define XML_LRM_ATTR_EXIT_REASON "exit-reason"

	# define XML_RSC_OP_LAST_CHANGE "last-rc-change"
	# define XML_RSC_OP_LAST_RUN "last-run" // deprecated since 2.0.3
	# define XML_RSC_OP_T_EXEC "exec-time"
	# define XML_RSC_OP_T_QUEUE "queue-time"

	# define XML_LRM_ATTR_MIGRATE_SOURCE "migrate_source"
	# define XML_LRM_ATTR_MIGRATE_TARGET "migrate_target"

	# define XML_TAG_GRAPH "transition_graph"
	# define XML_GRAPH_TAG_RSC_OP "rsc_op"
	# define XML_GRAPH_TAG_PSEUDO_EVENT "pseudo_event"
	# define XML_GRAPH_TAG_CRM_EVENT "crm_event"
	# define XML_GRAPH_TAG_DOWNED "downed"
	# define XML_GRAPH_TAG_MAINTENANCE "maintenance"

	# define XML_TAG_RULE "rule"
	# define XML_RULE_ATTR_SCORE "score"
	# define XML_RULE_ATTR_SCORE_ATTRIBUTE "score-attribute"
	# define XML_RULE_ATTR_ROLE "role"
	# define XML_RULE_ATTR_BOOLEAN_OP "boolean-op"

	# define XML_TAG_EXPRESSION "expression"
	# define XML_EXPR_ATTR_ATTRIBUTE "attribute"
	# define XML_EXPR_ATTR_OPERATION "operation"
	# define XML_EXPR_ATTR_VALUE "value"
	# define XML_EXPR_ATTR_TYPE "type"
	# define XML_EXPR_ATTR_VALUE_SOURCE "value-source"

	# define XML_CONS_TAG_RSC_DEPEND "rsc_colocation"
	# define XML_CONS_TAG_RSC_ORDER "rsc_order"
	# define XML_CONS_TAG_RSC_LOCATION "rsc_location"
	# define XML_CONS_TAG_RSC_TICKET "rsc_ticket"
	# define XML_CONS_TAG_RSC_SET "resource_set"
	# define XML_CONS_ATTR_SYMMETRICAL "symmetrical"

	# define XML_LOCATION_ATTR_DISCOVERY "resource-discovery"

	# define XML_COLOC_ATTR_SOURCE "rsc"
	# define XML_COLOC_ATTR_SOURCE_ROLE "rsc-role"
	# define XML_COLOC_ATTR_TARGET "with-rsc"
	# define XML_COLOC_ATTR_TARGET_ROLE "with-rsc-role"
	# define XML_COLOC_ATTR_NODE_ATTR "node-attribute"
	# define XML_COLOC_ATTR_SOURCE_INSTANCE "rsc-instance"
	# define XML_COLOC_ATTR_TARGET_INSTANCE "with-rsc-instance"

	# define XML_LOC_ATTR_SOURCE "rsc"
	# define XML_LOC_ATTR_SOURCE_PATTERN "rsc-pattern"

	# define XML_ORDER_ATTR_FIRST "first"
	# define XML_ORDER_ATTR_THEN "then"
	# define XML_ORDER_ATTR_FIRST_ACTION "first-action"
	# define XML_ORDER_ATTR_THEN_ACTION "then-action"
	# define XML_ORDER_ATTR_FIRST_INSTANCE "first-instance"
	# define XML_ORDER_ATTR_THEN_INSTANCE "then-instance"
	# define XML_ORDER_ATTR_KIND "kind"

	# define XML_TICKET_ATTR_TICKET "ticket"
	# define XML_TICKET_ATTR_LOSS_POLICY "loss-policy"

	# define XML_NVPAIR_ATTR_NAME "name"
	# define XML_NVPAIR_ATTR_VALUE "value"

	# define XML_NODE_ATTR_RSC_DISCOVERY "resource-discovery-enabled"

	# define XML_CONFIG_ATTR_DC_DEADTIME "dc-deadtime"
	# define XML_CONFIG_ATTR_ELECTION_FAIL "election-timeout"
	# define XML_CONFIG_ATTR_FORCE_QUIT "shutdown-escalation"
	# define XML_CONFIG_ATTR_RECHECK "cluster-recheck-interval"
	# define XML_CONFIG_ATTR_FENCE_REACTION "fence-reaction"
	# define XML_CONFIG_ATTR_SHUTDOWN_LOCK "shutdown-lock"
	# define XML_CONFIG_ATTR_SHUTDOWN_LOCK_LIMIT "shutdown-lock-limit"
	+# define XML_CONFIG_ATTR_PRIORITY_FENCING_DELAY "priority-fencing-delay"

	# define XML_ALERT_ATTR_PATH "path"
	# define XML_ALERT_ATTR_TIMEOUT "timeout"
	# define XML_ALERT_ATTR_TSTAMP_FORMAT "timestamp-format"
	# define XML_ALERT_ATTR_REC_VALUE "value"

	# define XML_CIB_TAG_GENERATION_TUPPLE "generation_tuple"

	# define XML_ATTR_TRANSITION_MAGIC "transition-magic"
	# define XML_ATTR_TRANSITION_KEY "transition-key"

	# define XML_ATTR_TE_NOWAIT "op_no_wait"
	# define XML_ATTR_TE_TARGET_RC "op_target_rc"
	# define XML_TAG_TRANSIENT_NODEATTRS "transient_attributes"

	# define XML_TAG_DIFF_ADDED "diff-added"
	# define XML_TAG_DIFF_REMOVED "diff-removed"

	# define XML_ACL_TAG_USER "acl_target"
	# define XML_ACL_TAG_USERv1 "acl_user"
	# define XML_ACL_TAG_GROUP "acl_group"
	# define XML_ACL_TAG_ROLE "acl_role"
	# define XML_ACL_TAG_PERMISSION "acl_permission"
	# define XML_ACL_TAG_ROLE_REF "role"
	# define XML_ACL_TAG_ROLE_REFv1 "role_ref"
	# define XML_ACL_ATTR_KIND "kind"
	# define XML_ACL_TAG_READ "read"
	# define XML_ACL_TAG_WRITE "write"
	# define XML_ACL_TAG_DENY "deny"
	# define XML_ACL_ATTR_REF "reference"
	# define XML_ACL_ATTR_REFv1 "ref"
	# define XML_ACL_ATTR_TAG "object-type"
	# define XML_ACL_ATTR_TAGv1 "tag"
	# define XML_ACL_ATTR_XPATH "xpath"
	# define XML_ACL_ATTR_ATTRIBUTE "attribute"

	# define XML_CIB_TAG_TICKETS "tickets"
	# define XML_CIB_TAG_TICKET_STATE "ticket_state"

	# define XML_CIB_TAG_TAGS "tags"
	# define XML_CIB_TAG_TAG "tag"
	# define XML_CIB_TAG_OBJ_REF "obj_ref"

	# define XML_TAG_FENCING_TOPOLOGY "fencing-topology"
	# define XML_TAG_FENCING_LEVEL "fencing-level"
	# define XML_ATTR_STONITH_INDEX "index"
	# define XML_ATTR_STONITH_TARGET "target"
	# define XML_ATTR_STONITH_TARGET_VALUE "target-value"
	# define XML_ATTR_STONITH_TARGET_PATTERN "target-pattern"
	# define XML_ATTR_STONITH_TARGET_ATTRIBUTE "target-attribute"
	# define XML_ATTR_STONITH_DEVICES "devices"

	# define XML_TAG_DIFF "diff"
	# define XML_DIFF_VERSION "version"
	# define XML_DIFF_VSOURCE "source"
	# define XML_DIFF_VTARGET "target"
	# define XML_DIFF_CHANGE "change"
	# define XML_DIFF_LIST "change-list"
	# define XML_DIFF_ATTR "change-attr"
	# define XML_DIFF_RESULT "change-result"
	# define XML_DIFF_OP "operation"
	# define XML_DIFF_PATH "path"
	# define XML_DIFF_POSITION "position"

	# include <crm/common/xml.h>

	# define ID(x) crm_element_value(x, XML_ATTR_ID)
	# define TYPE(x) crm_element_name(x)

	#ifdef __cplusplus
	}
	#endif

	#endif
	diff --git a/lib/pengine/common.c b/lib/pengine/common.c
	index b642d40074..b9a622d42c 100644
	--- a/lib/pengine/common.c
	+++ b/lib/pengine/common.c
	@@ -1,585 +1,602 @@
	/*
	* Copyright 2004-2020 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>
	#include <crm/crm.h>
	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>
	#include <crm/common/util.h>

	#include <glib.h>

	#include <crm/pengine/internal.h>

	gboolean was_processing_error = FALSE;
	gboolean was_processing_warning = FALSE;

	static bool
	check_health(const char *value)
	{
	return safe_str_eq(value, "none")
	\|\| safe_str_eq(value, "custom")
	\|\| safe_str_eq(value, "only-green")
	\|\| safe_str_eq(value, "progressive")
	\|\| safe_str_eq(value, "migrate-on-red");
	}

	static bool
	check_stonith_action(const char *value)
	{
	return safe_str_eq(value, "reboot")
	\|\| safe_str_eq(value, "poweroff")
	\|\| safe_str_eq(value, "off");
	}

	static bool
	check_placement_strategy(const char *value)
	{
	return safe_str_eq(value, "default")
	\|\| safe_str_eq(value, "utilization")
	\|\| safe_str_eq(value, "minimal")
	\|\| safe_str_eq(value, "balanced");
	}

	static pcmk__cluster_option_t pe_opts[] = {
	/* name, old name, type, allowed values,
	* default value, validator,
	* short description,
	* long description
	*/
	{
	"no-quorum-policy", NULL, "enum", "stop, freeze, ignore, suicide",
	"stop", pcmk__valid_quorum,
	"What to do when the cluster does not have quorum",
	NULL
	},
	{
	"symmetric-cluster", NULL, "boolean", NULL,
	"true", pcmk__valid_boolean,
	"Whether resources can run on any node by default",
	NULL
	},
	{
	"maintenance-mode", NULL, "boolean", NULL,
	"false", pcmk__valid_boolean,
	"Whether the cluster should refrain from monitoring, starting, "
	"and stopping resources",
	NULL
	},
	{
	"start-failure-is-fatal", NULL, "boolean", NULL,
	"true", pcmk__valid_boolean,
	"Whether a start failure should prevent a resource from being "
	"recovered on the same node",
	"When true, the cluster will immediately ban a resource from a node "
	"if it fails to start there. When false, the cluster will instead "
	"check the resource's fail count against its migration-threshold."
	},
	{
	"enable-startup-probes", NULL, "boolean", NULL,
	"true", pcmk__valid_boolean,
	"Whether the cluster should check for active resources during start-up",
	NULL
	},
	{
	XML_CONFIG_ATTR_SHUTDOWN_LOCK, NULL, "boolean", NULL,
	"false", pcmk__valid_boolean,
	"Whether to lock resources to a cleanly shut down node",
	"When true, resources active on a node when it is cleanly shut down "
	"are kept \"locked\" to that node (not allowed to run elsewhere) "
	"until they start again on that node after it rejoins (or for at "
	"most shutdown-lock-limit, if set). Stonith resources and "
	"Pacemaker Remote connections are never locked. Clone and bundle "
	"instances and the master role of promotable clones are currently "
	"never locked, though support could be added in a future release."
	},
	{
	XML_CONFIG_ATTR_SHUTDOWN_LOCK_LIMIT, NULL, "time", NULL,
	"0", pcmk__valid_interval_spec,
	"Do not lock resources to a cleanly shut down node longer than this",
	"If shutdown-lock is true and this is set to a nonzero time duration, "
	"shutdown locks will expire after this much time has passed since "
	"the shutdown was initiated, even if the node has not rejoined."
	},

	// Fencing-related options
	{
	"stonith-enabled", NULL, "boolean", NULL,
	"true", pcmk__valid_boolean,
	"* Advanced Use Only * "
	"Whether nodes may be fenced as part of recovery",
	"If false, unresponsive nodes are immediately assumed to be harmless, "
	"and resources that were active on them may be recovered "
	"elsewhere. This can result in a \"split-brain\" situation, "
	"potentially leading to data loss and/or service unavailability."
	},
	{
	"stonith-action", NULL, "enum", "reboot, off, poweroff",
	"reboot", check_stonith_action,
	"Action to send to fence device when a node needs to be fenced "
	"(\"poweroff\" is a deprecated alias for \"off\")",
	NULL
	},
	{
	"stonith-timeout", NULL, "time", NULL,
	"60s", pcmk__valid_interval_spec,
	"* Advanced Use Only * Unused by Pacemaker",
	"This value is not used by Pacemaker, but is kept for backward "
	"compatibility, and certain legacy fence agents might use it."
	},
	{
	XML_ATTR_HAVE_WATCHDOG, NULL, "boolean", NULL,
	"false", pcmk__valid_boolean,
	"Whether watchdog integration is enabled",
	"This is set automatically by the cluster according to whether SBD "
	"is detected to be in use. User-configured values are ignored."
	},
	{
	"concurrent-fencing", NULL, "boolean", NULL,
	#ifdef DEFAULT_CONCURRENT_FENCING_TRUE
	"true",
	#else
	"false",
	#endif
	pcmk__valid_boolean,
	"Allow performing fencing operations in parallel",
	NULL
	},
	{
	"startup-fencing", NULL, "boolean", NULL,
	"true", pcmk__valid_boolean,
	"* Advanced Use Only * Whether to fence unseen nodes at start-up",
	"Setting this to false may lead to a \"split-brain\" situation,"
	"potentially leading to data loss and/or service unavailability."
	},
	+ {
	+ XML_CONFIG_ATTR_PRIORITY_FENCING_DELAY, NULL, "time", NULL,
	+ NULL, pcmk__valid_interval_spec,
	+ "Enforced fencing delay targeting the lost nodes with the highest total resource priority",
	+ "Enforce specified delay for the fencings that are targeting the lost "
	+ "nodes with the highest total resource priority in case we don't "
	+ "have the majority of the nodes in our cluster partition, so that "
	+ "the more significant nodes potentially win any fencing match, "
	+ "which is especially meaningful under split-brain of 2-node "
	+ "cluster. A promoted resource instance takes the base priority + 1 "
	+ "on calculation if the base priority is not 0. If all the nodes "
	+ "have equal priority, then any pcmk_delay_base/max configured for "
	+ "the corresponding fencing resources will be applied. Otherwise as "
	+ "long as it's set, even if to 0, it takes precedence over any "
	+ "configured pcmk_delay_base/max. By default, priority fencing "
	+ "delay is disabled."
	+ },

	{
	"cluster-delay", NULL, "time", NULL,
	"60s", pcmk__valid_interval_spec,
	"Maximum time for node-to-node communication",
	"The node elected Designated Controller (DC) will consider an action "
	"failed if it does not get a response from the node executing the "
	"action within this time (after considering the action's own "
	"timeout). The \"correct\" value will depend on the speed and "
	"load of your network and cluster nodes."
	},
	{
	"batch-limit", NULL, "integer", NULL,
	"0", pcmk__valid_number,
	"Maximum number of jobs that the cluster may execute in parallel "
	"across all nodes",
	"The \"correct\" value will depend on the speed and load of your "
	"network and cluster nodes. If set to 0, the cluster will "
	"impose a dynamically calculated limit when any node has a "
	"high load."
	},
	{
	"migration-limit", NULL, "integer", NULL,
	"-1", pcmk__valid_number,
	"The number of live migration actions that the cluster is allowed "
	"to execute in parallel on a node (-1 means no limit)"
	},

	/* Orphans and stopping */
	{
	"stop-all-resources", NULL, "boolean", NULL,
	"false", pcmk__valid_boolean,
	"Whether the cluster should stop all active resources",
	NULL
	},
	{
	"stop-orphan-resources", NULL, "boolean", NULL,
	"true", pcmk__valid_boolean,
	"Whether to stop resources that were removed from the configuration",
	NULL
	},
	{
	"stop-orphan-actions", NULL, "boolean", NULL,
	"true", pcmk__valid_boolean,
	"Whether to cancel recurring actions removed from the configuration",
	NULL
	},
	{
	"remove-after-stop", NULL, "boolean", NULL,
	"false", pcmk__valid_boolean,
	"* Advanced Use Only * Whether to remove stopped resources from "
	"the executor",
	"Values other than default are poorly tested and potentially dangerous."
	},

	/* Storing inputs */
	{
	"pe-error-series-max", NULL, "integer", NULL,
	"-1", pcmk__valid_number,
	"The number of scheduler inputs resulting in errors to save",
	"Zero to disable, -1 to store unlimited."
	},
	{
	"pe-warn-series-max", NULL, "integer", NULL,
	"5000", pcmk__valid_number,
	"The number of scheduler inputs resulting in warnings to save",
	"Zero to disable, -1 to store unlimited."
	},
	{
	"pe-input-series-max", NULL, "integer", NULL,
	"4000", pcmk__valid_number,
	"The number of scheduler inputs without errors or warnings to save",
	"Zero to disable, -1 to store unlimited."
	},

	/* Node health */
	{
	"node-health-strategy", NULL, "enum",
	"none, migrate-on-red, only-green, progressive, custom",
	"none", check_health,
	"How cluster should react to node health attributes",
	"Requires external entities to create node attributes (named with "
	"the prefix \"#health\") with values \"red\", \"yellow\" or "
	"\"green\"."
	},
	{
	"node-health-base", NULL, "integer", NULL,
	"0", pcmk__valid_number,
	"Base health score assigned to a node",
	"Only used when node-health-strategy is set to progressive."
	},
	{
	"node-health-green", NULL, "integer", NULL,
	"0", pcmk__valid_number,
	"The score to use for a node health attribute whose value is \"green\"",
	"Only used when node-health-strategy is set to custom or progressive."
	},
	{
	"node-health-yellow", NULL, "integer", NULL,
	"0", pcmk__valid_number,
	"The score to use for a node health attribute whose value is \"yellow\"",
	"Only used when node-health-strategy is set to custom or progressive."
	},
	{
	"node-health-red", NULL, "integer", NULL,
	"-INFINITY", pcmk__valid_number,
	"The score to use for a node health attribute whose value is \"red\"",
	"Only used when node-health-strategy is set to custom or progressive."
	},

	/Placement Strategy/
	{
	"placement-strategy", NULL, "enum",
	"default, utilization, minimal, balanced",
	"default", check_placement_strategy,
	"How the cluster should allocate resources to nodes",
	NULL
	},
	};

	void
	pe_metadata(void)
	{
	pcmk__print_option_metadata("pacemaker-schedulerd", "1.0",
	"Pacemaker scheduler options",
	"Cluster options used by Pacemaker's scheduler"
	" (formerly called pengine)",
	pe_opts, DIMOF(pe_opts));
	}

	void
	verify_pe_options(GHashTable * options)
	{
	pcmk__validate_cluster_options(options, pe_opts, DIMOF(pe_opts));
	}

	const char *
	pe_pref(GHashTable * options, const char *name)
	{
	return pcmk__cluster_option(options, pe_opts, DIMOF(pe_opts), name);
	}

	const char *
	fail2text(enum action_fail_response fail)
	{
	const char *result = "<unknown>";

	switch (fail) {
	case action_fail_ignore:
	result = "ignore";
	break;
	case action_fail_block:
	result = "block";
	break;
	case action_fail_recover:
	result = "recover";
	break;
	case action_fail_migrate:
	result = "migrate";
	break;
	case action_fail_stop:
	result = "stop";
	break;
	case action_fail_fence:
	result = "fence";
	break;
	case action_fail_standby:
	result = "standby";
	break;
	case action_fail_restart_container:
	result = "restart-container";
	break;
	case action_fail_reset_remote:
	result = "reset-remote";
	break;
	}
	return result;
	}

	enum action_tasks
	text2task(const char *task)
	{
	if (safe_str_eq(task, CRMD_ACTION_STOP)) {
	return stop_rsc;
	} else if (safe_str_eq(task, CRMD_ACTION_STOPPED)) {
	return stopped_rsc;
	} else if (safe_str_eq(task, CRMD_ACTION_START)) {
	return start_rsc;
	} else if (safe_str_eq(task, CRMD_ACTION_STARTED)) {
	return started_rsc;
	} else if (safe_str_eq(task, CRM_OP_SHUTDOWN)) {
	return shutdown_crm;
	} else if (safe_str_eq(task, CRM_OP_FENCE)) {
	return stonith_node;
	} else if (safe_str_eq(task, CRMD_ACTION_STATUS)) {
	return monitor_rsc;
	} else if (safe_str_eq(task, CRMD_ACTION_NOTIFY)) {
	return action_notify;
	} else if (safe_str_eq(task, CRMD_ACTION_NOTIFIED)) {
	return action_notified;
	} else if (safe_str_eq(task, CRMD_ACTION_PROMOTE)) {
	return action_promote;
	} else if (safe_str_eq(task, CRMD_ACTION_DEMOTE)) {
	return action_demote;
	} else if (safe_str_eq(task, CRMD_ACTION_PROMOTED)) {
	return action_promoted;
	} else if (safe_str_eq(task, CRMD_ACTION_DEMOTED)) {
	return action_demoted;
	}
	#if SUPPORT_TRACING
	if (safe_str_eq(task, CRMD_ACTION_CANCEL)) {
	return no_action;
	} else if (safe_str_eq(task, CRMD_ACTION_DELETE)) {
	return no_action;
	} else if (safe_str_eq(task, CRMD_ACTION_STATUS)) {
	return no_action;
	} else if (safe_str_eq(task, CRM_OP_PROBED)) {
	return no_action;
	} else if (safe_str_eq(task, CRM_OP_LRM_REFRESH)) {
	return no_action;
	} else if (safe_str_eq(task, CRMD_ACTION_MIGRATE)) {
	return no_action;
	} else if (safe_str_eq(task, CRMD_ACTION_MIGRATED)) {
	return no_action;
	}
	crm_trace("Unsupported action: %s", task);
	#endif

	return no_action;
	}

	const char *
	task2text(enum action_tasks task)
	{
	const char *result = "<unknown>";

	switch (task) {
	case no_action:
	result = "no_action";
	break;
	case stop_rsc:
	result = CRMD_ACTION_STOP;
	break;
	case stopped_rsc:
	result = CRMD_ACTION_STOPPED;
	break;
	case start_rsc:
	result = CRMD_ACTION_START;
	break;
	case started_rsc:
	result = CRMD_ACTION_STARTED;
	break;
	case shutdown_crm:
	result = CRM_OP_SHUTDOWN;
	break;
	case stonith_node:
	result = CRM_OP_FENCE;
	break;
	case monitor_rsc:
	result = CRMD_ACTION_STATUS;
	break;
	case action_notify:
	result = CRMD_ACTION_NOTIFY;
	break;
	case action_notified:
	result = CRMD_ACTION_NOTIFIED;
	break;
	case action_promote:
	result = CRMD_ACTION_PROMOTE;
	break;
	case action_promoted:
	result = CRMD_ACTION_PROMOTED;
	break;
	case action_demote:
	result = CRMD_ACTION_DEMOTE;
	break;
	case action_demoted:
	result = CRMD_ACTION_DEMOTED;
	break;
	}

	return result;
	}

	const char *
	role2text(enum rsc_role_e role)
	{
	switch (role) {
	case RSC_ROLE_UNKNOWN:
	return RSC_ROLE_UNKNOWN_S;
	case RSC_ROLE_STOPPED:
	return RSC_ROLE_STOPPED_S;
	case RSC_ROLE_STARTED:
	return RSC_ROLE_STARTED_S;
	case RSC_ROLE_SLAVE:
	return RSC_ROLE_SLAVE_S;
	case RSC_ROLE_MASTER:
	return RSC_ROLE_MASTER_S;
	}
	CRM_CHECK(role >= RSC_ROLE_UNKNOWN, return RSC_ROLE_UNKNOWN_S);
	CRM_CHECK(role < RSC_ROLE_MAX, return RSC_ROLE_UNKNOWN_S);
	// coverity[dead_error_line]
	return RSC_ROLE_UNKNOWN_S;
	}

	enum rsc_role_e
	text2role(const char *role)
	{
	CRM_ASSERT(role != NULL);
	if (safe_str_eq(role, RSC_ROLE_STOPPED_S)) {
	return RSC_ROLE_STOPPED;
	} else if (safe_str_eq(role, RSC_ROLE_STARTED_S)) {
	return RSC_ROLE_STARTED;
	} else if (safe_str_eq(role, RSC_ROLE_SLAVE_S)) {
	return RSC_ROLE_SLAVE;
	} else if (safe_str_eq(role, RSC_ROLE_MASTER_S)) {
	return RSC_ROLE_MASTER;
	} else if (safe_str_eq(role, RSC_ROLE_UNKNOWN_S)) {
	return RSC_ROLE_UNKNOWN;
	}
	crm_err("Unknown role: %s", role);
	return RSC_ROLE_UNKNOWN;
	}

	int
	merge_weights(int w1, int w2)
	{
	int result = w1 + w2;

	if (w1 <= -INFINITY \|\| w2 <= -INFINITY) {
	if (w1 >= INFINITY \|\| w2 >= INFINITY) {
	crm_trace("-INFINITY + INFINITY == -INFINITY");
	}
	return -INFINITY;

	} else if (w1 >= INFINITY \|\| w2 >= INFINITY) {
	return INFINITY;
	}

	/* detect wrap-around */
	if (result > 0) {
	if (w1 <= 0 && w2 < 0) {
	result = -INFINITY;
	}

	} else if (w1 > 0 && w2 > 0) {
	result = INFINITY;
	}

	/* detect +/- INFINITY */
	if (result >= INFINITY) {
	result = INFINITY;

	} else if (result <= -INFINITY) {
	result = -INFINITY;
	}

	crm_trace("%d + %d = %d", w1, w2, result);
	return result;
	}

	void
	add_hash_param(GHashTable * hash, const char name, const char value)
	{
	CRM_CHECK(hash != NULL, return);

	crm_trace("adding: name=%s value=%s", crm_str(name), crm_str(value));
	if (name == NULL \|\| value == NULL) {
	return;

	} else if (safe_str_eq(value, "#default")) {
	return;

	} else if (g_hash_table_lookup(hash, name) == NULL) {
	g_hash_table_insert(hash, strdup(name), strdup(value));
	}
	}

	const char *
	pe_node_attribute_calculated(const pe_node_t node, const char name,
	const pe_resource_t *rsc)
	{
	const char *source;

	if(node == NULL) {
	return NULL;

	} else if(rsc == NULL) {
	return g_hash_table_lookup(node->details->attrs, name);
	}

	source = g_hash_table_lookup(rsc->meta, XML_RSC_ATTR_TARGET);
	if(source == NULL \|\| safe_str_eq("host", source) == FALSE) {
	return g_hash_table_lookup(node->details->attrs, name);
	}

	/* Use attributes set for the containers location
	* instead of for the container itself
	*
	* Useful when the container is using the host's local
	* storage
	*/

	CRM_ASSERT(node->details->remote_rsc);
	CRM_ASSERT(node->details->remote_rsc->container);

	if(node->details->remote_rsc->container->running_on) {
	pe_node_t *host = node->details->remote_rsc->container->running_on->data;
	pe_rsc_trace(rsc, "%s: Looking for %s on the container host %s", rsc->id, name, host->details->uname);
	return g_hash_table_lookup(host->details->attrs, name);
	}

	pe_rsc_trace(rsc, "%s: Not looking for %s on the container host: %s is inactive",
	rsc->id, name, node->details->remote_rsc->container->id);
	return NULL;
	}

	const char *
	pe_node_attribute_raw(pe_node_t node, const char name)
	{
	if(node == NULL) {
	return NULL;
	}
	return g_hash_table_lookup(node->details->attrs, name);
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 21, 6:18 PM (23 h, 14 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1665179
Default Alt Text: (36 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions