No OneTemporary
Actions

Size

38 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/common/options_internal.h b/include/crm/common/options_internal.h
	index 61964f19e0..ff6f6cbf68 100644
	--- a/include/crm/common/options_internal.h
	+++ b/include/crm/common/options_internal.h
	@@ -1,172 +1,172 @@
	/*
	* Copyright 2006-2024 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 PCMK__OPTIONS_INTERNAL__H
	# define PCMK__OPTIONS_INTERNAL__H

	# ifndef PCMK__CONFIG_H
	# define PCMK__CONFIG_H
	# include <config.h> // _Noreturn
	# endif

	# include <glib.h> // GHashTable
	# include <stdbool.h> // bool

	#include <crm/common/util.h> // pcmk_parse_interval_spec()

	_Noreturn void pcmk__cli_help(char cmd);


	/*
	* Environment variable option handling
	*/

	const char pcmk__env_option(const char option);
	void pcmk__set_env_option(const char option, const char value, bool compat);
	bool pcmk__env_option_enabled(const char daemon, const char option);


	/*
	* Cluster option handling
	*/

	typedef struct pcmk__cluster_option_s {
	const char *name;
	const char *alt_name;
	const char *type;
	const char *values;
	const char *default_value;

	bool (is_valid)(const char );

	const char *description_short;
	const char *description_long;

	} pcmk__cluster_option_t;

	const char pcmk__cluster_option(GHashTable options,
	const pcmk__cluster_option_t *option_list,
	int len, const char *name);

	gchar pcmk__format_option_metadata(const char name, const char *desc_short,
	const char *desc_long,
	pcmk__cluster_option_t *option_list,
	int len);

	void pcmk__validate_cluster_options(GHashTable *options,
	pcmk__cluster_option_t *option_list,
	int len);

	bool pcmk__valid_interval_spec(const char *value);
	bool pcmk__valid_boolean(const char *value);
	bool pcmk__valid_int(const char *value);
	bool pcmk__valid_positive_int(const char *value);
	bool pcmk__valid_no_quorum_policy(const char *value);
	bool pcmk__valid_percentage(const char *value);
	bool pcmk__valid_script(const char *value);

	// from watchdog.c
	long pcmk__get_sbd_timeout(void);
	bool pcmk__get_sbd_sync_resource_startup(void);
	long pcmk__auto_watchdog_timeout(void);
	bool pcmk__valid_sbd_timeout(const char *value);

	// Constants for environment variable names
	#define PCMK__ENV_AUTHKEY_LOCATION "authkey_location"
	#define PCMK__ENV_BLACKBOX "blackbox"
	#define PCMK__ENV_CALLGRIND_ENABLED "callgrind_enabled"
	#define PCMK__ENV_CLUSTER_TYPE "cluster_type"
	#define PCMK__ENV_DEBUG "debug"
	#define PCMK__ENV_DH_MAX_BITS "dh_max_bits"
	#define PCMK__ENV_DH_MIN_BITS "dh_min_bits"
	#define PCMK__ENV_FAIL_FAST "fail_fast"
	#define PCMK__ENV_IPC_BUFFER "ipc_buffer"
	#define PCMK__ENV_IPC_TYPE "ipc_type"
	#define PCMK__ENV_LOGFACILITY "logfacility"
	#define PCMK__ENV_LOGFILE "logfile"
	#define PCMK__ENV_LOGFILE_MODE "logfile_mode"
	#define PCMK__ENV_LOGPRIORITY "logpriority"
	#define PCMK__ENV_NODE_ACTION_LIMIT "node_action_limit"
	#define PCMK__ENV_NODE_START_STATE "node_start_state"
	#define PCMK__ENV_PANIC_ACTION "panic_action"
	-#define PCMK__ENV_PHYSICAL_HOST "physical_host"
	#define PCMK__ENV_REMOTE_ADDRESS "remote_address"
	#define PCMK__ENV_REMOTE_SCHEMA_DIR "remote_schema_directory"
	#define PCMK__ENV_REMOTE_PID1 "remote_pid1"
	#define PCMK__ENV_REMOTE_PORT "remote_port"
	#define PCMK__ENV_RESPAWNED "respawned"
	#define PCMK__ENV_SCHEMA_DIRECTORY "schema_directory"
	#define PCMK__ENV_SERVICE "service"
	#define PCMK__ENV_STDERR "stderr"
	#define PCMK__ENV_TLS_PRIORITIES "tls_priorities"
	#define PCMK__ENV_TRACE_BLACKBOX "trace_blackbox"
	#define PCMK__ENV_TRACE_FILES "trace_files"
	#define PCMK__ENV_TRACE_FORMATS "trace_formats"
	#define PCMK__ENV_TRACE_FUNCTIONS "trace_functions"
	#define PCMK__ENV_TRACE_TAGS "trace_tags"
	#define PCMK__ENV_VALGRIND_ENABLED "valgrind_enabled"

	// @COMPAT Drop at 3.0.0; default is plenty
	#define PCMK__ENV_CIB_TIMEOUT "cib_timeout"

	// @COMPAT Drop at 3.0.0; likely last used in 1.1.24
	#define PCMK__ENV_MCP "mcp"

	// @COMPAT Drop at 3.0.0; added unused in 1.1.9
	#define PCMK__ENV_QUORUM_TYPE "quorum_type"

	/* @COMPAT Drop at 3.0.0; added to debug shutdown issues when Pacemaker is
	* managed by systemd, but no longer useful.
	*/
	#define PCMK__ENV_SHUTDOWN_DELAY "shutdown_delay"

	// @COMPAT Deprecated since 2.1.0
	#define PCMK__OPT_REMOVE_AFTER_STOP "remove-after-stop"

	// Constants for meta-attribute names
	#define PCMK__META_ALLOW_UNHEALTHY_NODES "allow-unhealthy-nodes"
	#define PCMK__META_CLONE_INSTANCE_NUM "clone"
	#define PCMK__META_CONTAINER "container"
	#define PCMK__META_INTERNAL_RSC "internal_rsc"
	+#define PCMK__META_PHYSICAL_HOST "physical-host"

	/* @TODO Plug these in. Currently, they're never set. These are op attrs for use
	* with https://projects.clusterlabs.org/T382.
	*/
	#define PCMK__META_CLEAR_FAILURE_OP "clear_failure_op"
	#define PCMK__META_CLEAR_FAILURE_INTERVAL "clear_failure_interval"

	// @COMPAT Deprecated alias for PCMK__META_PROMOTED_MAX since 2.0.0
	#define PCMK__META_PROMOTED_MAX_LEGACY "master-max"

	// @COMPAT Deprecated alias for PCMK__META_PROMOTED_NODE_MAX since 2.0.0
	#define PCMK__META_PROMOTED_NODE_MAX_LEGACY "master-node-max"

	// @COMPAT Deprecated meta-attribute since 2.0.0
	#define PCMK__META_RESTART_TYPE "restart-type"

	// @COMPAT Deprecated meta-attribute since 2.0.0
	#define PCMK__META_ROLE_AFTER_FAILURE "role_after_failure"

	// Constants for enumerated values for various options
	#define PCMK__VALUE_CLUSTER "cluster"
	#define PCMK__VALUE_CUSTOM "custom"
	#define PCMK__VALUE_FENCING "fencing"
	#define PCMK__VALUE_GREEN "green"
	#define PCMK__VALUE_LOCAL "local"
	#define PCMK__VALUE_MIGRATE_ON_RED "migrate-on-red"
	#define PCMK__VALUE_NONE "none"
	#define PCMK__VALUE_NOTHING "nothing"
	#define PCMK__VALUE_ONLY_GREEN "only-green"
	#define PCMK__VALUE_PROGRESSIVE "progressive"
	#define PCMK__VALUE_QUORUM "quorum"
	#define PCMK__VALUE_RED "red"
	#define PCMK__VALUE_UNFENCING "unfencing"
	#define PCMK__VALUE_YELLOW "yellow"

	#endif // PCMK__OPTIONS_INTERNAL__H
	diff --git a/lib/common/attrs.c b/lib/common/attrs.c
	index 35dd833f5c..52c64b3a84 100644
	--- a/lib/common/attrs.c
	+++ b/lib/common/attrs.c
	@@ -1,98 +1,98 @@
	/*
	* Copyright 2011-2024 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 _GNU_SOURCE
	# define _GNU_SOURCE
	#endif

	#include <crm_internal.h>

	#include <stdio.h>

	#include <crm/msg_xml.h>
	#include <crm/common/attrd_internal.h>

	#define OCF_RESKEY_PREFIX "OCF_RESKEY_"
	#define LRM_TARGET_ENV OCF_RESKEY_PREFIX CRM_META "_" XML_LRM_ATTR_TARGET

	/*!
	* \internal
	* \brief Get the node name that should be used to set node attributes
	*
	* If given NULL, "auto", or "localhost" as an argument, check the environment
	* to detect the node name that should be used to set node attributes. (The
	* caller might not know the correct name, for example if the target is part of
	* a bundle with container-attribute-target set to "host".)
	*
	* \param[in] name NULL, "auto" or "localhost" to check environment variables,
	* or anything else to return NULL
	*
	* \return Node name that should be used for node attributes based on the
	* environment if known, otherwise NULL
	*/
	const char *
	pcmk__node_attr_target(const char *name)
	{
	if (name == NULL \|\| pcmk__strcase_any_of(name, "auto", "localhost", NULL)) {
	char buf[128] = OCF_RESKEY_PREFIX;
	size_t offset = sizeof(OCF_RESKEY_PREFIX) - 1;
	char *target_var = crm_meta_name(PCMK_META_CONTAINER_ATTR_TARGET);
	- char *phys_var = crm_meta_name(PCMK__ENV_PHYSICAL_HOST);
	+ char *phys_var = crm_meta_name(PCMK__META_PHYSICAL_HOST);
	const char *target = NULL;
	const char *host_physical = NULL;

	snprintf(buf + offset, sizeof(buf) - offset, "%s", target_var);
	target = getenv(buf);

	snprintf(buf + offset, sizeof(buf) - offset, "%s", phys_var);
	host_physical = getenv(buf);

	// It is important to use the name by which the scheduler knows us
	if (host_physical && pcmk__str_eq(target, "host", pcmk__str_casei)) {
	name = host_physical;

	} else {
	const char *host_pcmk = getenv(LRM_TARGET_ENV);

	if (host_pcmk) {
	name = host_pcmk;
	}
	}
	free(target_var);
	free(phys_var);

	// TODO? Call get_local_node_name() if name == NULL
	// (currently would require linkage against libcrmcluster)
	return name;
	} else {
	return NULL;
	}
	}

	/*!
	* \brief Return the name of the node attribute used as a promotion score
	*
	* \param[in] rsc_id Resource ID that promotion score is for (or NULL to
	* check the OCF_RESOURCE_INSTANCE environment variable)
	*
	* \return Newly allocated string with the node attribute name (or NULL on
	* error, including no ID or environment variable specified)
	* \note It is the caller's responsibility to free() the result.
	*/
	char *
	pcmk_promotion_score_name(const char *rsc_id)
	{
	if (pcmk__str_empty(rsc_id)) {
	rsc_id = getenv("OCF_RESOURCE_INSTANCE");
	if (pcmk__str_empty(rsc_id)) {
	return NULL;
	}
	}
	return crm_strdup_printf("master-%s", rsc_id);
	}
	diff --git a/lib/pacemaker/pcmk_sched_remote.c b/lib/pacemaker/pcmk_sched_remote.c
	index a7b2143ecf..5c55d70ab6 100644
	--- a/lib/pacemaker/pcmk_sched_remote.c
	+++ b/lib/pacemaker/pcmk_sched_remote.c
	@@ -1,731 +1,731 @@
	/*
	* Copyright 2004-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <sys/param.h>

	#include <crm/crm.h>
	#include <crm/cib.h>
	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>
	#include <crm/common/xml_internal.h>

	#include <glib.h>

	#include <crm/pengine/status.h>
	#include <pacemaker-internal.h>
	#include "libpacemaker_private.h"

	enum remote_connection_state {
	remote_state_unknown = 0,
	remote_state_alive = 1,
	remote_state_resting = 2,
	remote_state_failed = 3,
	remote_state_stopped = 4
	};

	static const char *
	state2text(enum remote_connection_state state)
	{
	switch (state) {
	case remote_state_unknown:
	return "unknown";
	case remote_state_alive:
	return "alive";
	case remote_state_resting:
	return "resting";
	case remote_state_failed:
	return "failed";
	case remote_state_stopped:
	return "stopped";
	}

	return "impossible";
	}

	/* We always use pcmk__ar_guest_allowed with these convenience functions to
	* exempt internally generated constraints from the prohibition of user
	* constraints involving remote connection resources.
	*
	* The start ordering additionally uses pcmk__ar_unrunnable_first_blocks so that
	* the specified action is not runnable if the start is not runnable.
	*/

	static inline void
	order_start_then_action(pcmk_resource_t first_rsc, pcmk_action_t then_action,
	uint32_t extra)
	{
	if ((first_rsc != NULL) && (then_action != NULL)) {
	pcmk__new_ordering(first_rsc, start_key(first_rsc), NULL,
	then_action->rsc, NULL, then_action,
	pcmk__ar_guest_allowed
	\|pcmk__ar_unrunnable_first_blocks
	\|extra,
	first_rsc->cluster);
	}
	}

	static inline void
	order_action_then_stop(pcmk_action_t first_action, pcmk_resource_t then_rsc,
	uint32_t extra)
	{
	if ((first_action != NULL) && (then_rsc != NULL)) {
	pcmk__new_ordering(first_action->rsc, NULL, first_action,
	then_rsc, stop_key(then_rsc), NULL,
	pcmk__ar_guest_allowed\|extra, then_rsc->cluster);
	}
	}

	static enum remote_connection_state
	get_remote_node_state(const pcmk_node_t *node)
	{
	const pcmk_resource_t *remote_rsc = NULL;
	const pcmk_node_t *cluster_node = NULL;

	CRM_ASSERT(node != NULL);

	remote_rsc = node->details->remote_rsc;
	CRM_ASSERT(remote_rsc != NULL);

	cluster_node = pe__current_node(remote_rsc);

	/* If the cluster node the remote connection resource resides on
	* is unclean or went offline, we can't process any operations
	* on that remote node until after it starts elsewhere.
	*/
	if ((remote_rsc->next_role == pcmk_role_stopped)
	\|\| (remote_rsc->allocated_to == NULL)) {

	// The connection resource is not going to run anywhere

	if ((cluster_node != NULL) && cluster_node->details->unclean) {
	/* The remote connection is failed because its resource is on a
	* failed node and can't be recovered elsewhere, so we must fence.
	*/
	return remote_state_failed;
	}

	if (!pcmk_is_set(remote_rsc->flags, pcmk_rsc_failed)) {
	/* Connection resource is cleanly stopped */
	return remote_state_stopped;
	}

	/* Connection resource is failed */

	if ((remote_rsc->next_role == pcmk_role_stopped)
	&& remote_rsc->remote_reconnect_ms
	&& node->details->remote_was_fenced
	&& !pe__shutdown_requested(node)) {

	/* We won't know whether the connection is recoverable until the
	* reconnect interval expires and we reattempt connection.
	*/
	return remote_state_unknown;
	}

	/* The remote connection is in a failed state. If there are any
	* resources known to be active on it (stop) or in an unknown state
	* (probe), we must assume the worst and fence it.
	*/
	return remote_state_failed;

	} else if (cluster_node == NULL) {
	/* Connection is recoverable but not currently running anywhere, so see
	* if we can recover it first
	*/
	return remote_state_unknown;

	} else if (cluster_node->details->unclean
	\|\| !(cluster_node->details->online)) {
	// Connection is running on a dead node, see if we can recover it first
	return remote_state_resting;

	} else if (pcmk__list_of_multiple(remote_rsc->running_on)
	&& (remote_rsc->partial_migration_source != NULL)
	&& (remote_rsc->partial_migration_target != NULL)) {
	/* We're in the middle of migrating a connection resource, so wait until
	* after the migration completes before performing any actions.
	*/
	return remote_state_resting;

	}
	return remote_state_alive;
	}

	/*!
	* \internal
	* \brief Order actions on remote node relative to actions for the connection
	*
	* \param[in,out] action An action scheduled on a Pacemaker Remote node
	*/
	static void
	apply_remote_ordering(pcmk_action_t *action)
	{
	pcmk_resource_t *remote_rsc = NULL;
	enum action_tasks task = text2task(action->task);
	enum remote_connection_state state = get_remote_node_state(action->node);

	uint32_t order_opts = pcmk__ar_none;

	if (action->rsc == NULL) {
	return;
	}

	CRM_ASSERT(pe__is_guest_or_remote_node(action->node));

	remote_rsc = action->node->details->remote_rsc;
	CRM_ASSERT(remote_rsc != NULL);

	crm_trace("Order %s action %s relative to %s%s (state: %s)",
	action->task, action->uuid,
	pcmk_is_set(remote_rsc->flags, pcmk_rsc_failed)? "failed " : "",
	remote_rsc->id, state2text(state));

	if (pcmk__strcase_any_of(action->task, PCMK_ACTION_MIGRATE_TO,
	PCMK_ACTION_MIGRATE_FROM, NULL)) {
	/* Migration ops map to pcmk_action_unspecified, but we need to apply
	* the same ordering as for stop or demote (see get_router_node()).
	*/
	task = pcmk_action_stop;
	}

	switch (task) {
	case pcmk_action_start:
	case pcmk_action_promote:
	order_opts = pcmk__ar_none;

	if (state == remote_state_failed) {
	/* Force recovery, by making this action required */
	pe__set_order_flags(order_opts, pcmk__ar_first_implies_then);
	}

	/* Ensure connection is up before running this action */
	order_start_then_action(remote_rsc, action, order_opts);
	break;

	case pcmk_action_stop:
	if (state == remote_state_alive) {
	order_action_then_stop(action, remote_rsc,
	pcmk__ar_then_implies_first);

	} else if (state == remote_state_failed) {
	/* The resource is active on the node, but since we don't have a
	* valid connection, the only way to stop the resource is by
	* fencing the node. There is no need to order the stop relative
	* to the remote connection, since the stop will become implied
	* by the fencing.
	*/
	pe_fence_node(remote_rsc->cluster, action->node,
	"resources are active but "
	"connection is unrecoverable",
	FALSE);

	} else if (remote_rsc->next_role == pcmk_role_stopped) {
	/* State must be remote_state_unknown or remote_state_stopped.
	* Since the connection is not coming back up in this
	* transition, stop this resource first.
	*/
	order_action_then_stop(action, remote_rsc,
	pcmk__ar_then_implies_first);

	} else {
	/* The connection is going to be started somewhere else, so
	* stop this resource after that completes.
	*/
	order_start_then_action(remote_rsc, action, pcmk__ar_none);
	}
	break;

	case pcmk_action_demote:
	/* Only order this demote relative to the connection start if the
	* connection isn't being torn down. Otherwise, the demote would be
	* blocked because the connection start would not be allowed.
	*/
	if ((state == remote_state_resting)
	\|\| (state == remote_state_unknown)) {

	order_start_then_action(remote_rsc, action, pcmk__ar_none);
	} /* Otherwise we can rely on the stop ordering */
	break;

	default:
	/* Wait for the connection resource to be up */
	if (pcmk__action_is_recurring(action)) {
	/* In case we ever get the recovery logic wrong, force
	* recurring monitors to be restarted, even if just
	* the connection was re-established
	*/
	order_start_then_action(remote_rsc, action,
	pcmk__ar_first_implies_then);

	} else {
	pcmk_node_t *cluster_node = pe__current_node(remote_rsc);

	if ((task == pcmk_action_monitor) && (state == remote_state_failed)) {
	/* We would only be here if we do not know the state of the
	* resource on the remote node. Since we have no way to find
	* out, it is necessary to fence the node.
	*/
	pe_fence_node(remote_rsc->cluster, action->node,
	"resources are in unknown state "
	"and connection is unrecoverable", FALSE);
	}

	if ((cluster_node != NULL) && (state == remote_state_stopped)) {
	/* The connection is currently up, but is going down
	* permanently. Make sure we check services are actually
	* stopped _before_ we let the connection get closed.
	*/
	order_action_then_stop(action, remote_rsc,
	pcmk__ar_unrunnable_first_blocks);

	} else {
	order_start_then_action(remote_rsc, action, pcmk__ar_none);
	}
	}
	break;
	}
	}

	static void
	apply_container_ordering(pcmk_action_t *action)
	{
	/* VMs are also classified as containers for these purposes... in
	* that they both involve a 'thing' running on a real or remote
	* cluster node.
	*
	* This allows us to be smarter about the type and extent of
	* recovery actions required in various scenarios
	*/
	pcmk_resource_t *remote_rsc = NULL;
	pcmk_resource_t *container = NULL;
	enum action_tasks task = text2task(action->task);

	CRM_ASSERT(action->rsc != NULL);
	CRM_ASSERT(action->node != NULL);
	CRM_ASSERT(pe__is_guest_or_remote_node(action->node));

	remote_rsc = action->node->details->remote_rsc;
	CRM_ASSERT(remote_rsc != NULL);

	container = remote_rsc->container;
	CRM_ASSERT(container != NULL);

	if (pcmk_is_set(container->flags, pcmk_rsc_failed)) {
	pe_fence_node(action->rsc->cluster, action->node, "container failed",
	FALSE);
	}

	crm_trace("Order %s action %s relative to %s%s for %s%s",
	action->task, action->uuid,
	pcmk_is_set(remote_rsc->flags, pcmk_rsc_failed)? "failed " : "",
	remote_rsc->id,
	pcmk_is_set(container->flags, pcmk_rsc_failed)? "failed " : "",
	container->id);

	if (pcmk__strcase_any_of(action->task, PCMK_ACTION_MIGRATE_TO,
	PCMK_ACTION_MIGRATE_FROM, NULL)) {
	/* Migration ops map to pcmk_action_unspecified, but we need to apply
	* the same ordering as for stop or demote (see get_router_node()).
	*/
	task = pcmk_action_stop;
	}

	switch (task) {
	case pcmk_action_start:
	case pcmk_action_promote:
	// Force resource recovery if the container is recovered
	order_start_then_action(container, action,
	pcmk__ar_first_implies_then);

	// Wait for the connection resource to be up, too
	order_start_then_action(remote_rsc, action, pcmk__ar_none);
	break;

	case pcmk_action_stop:
	case pcmk_action_demote:
	if (pcmk_is_set(container->flags, pcmk_rsc_failed)) {
	/* When the container representing a guest node fails, any stop
	* or demote actions for resources running on the guest node
	* are implied by the container stopping. This is similar to
	* how fencing operations work for cluster nodes and remote
	* nodes.
	*/
	} else {
	/* Ensure the operation happens before the connection is brought
	* down.
	*
	* If we really wanted to, we could order these after the
	* connection start, IFF the container's current role was
	* stopped (otherwise we re-introduce an ordering loop when the
	* connection is restarting).
	*/
	order_action_then_stop(action, remote_rsc, pcmk__ar_none);
	}
	break;

	default:
	/* Wait for the connection resource to be up */
	if (pcmk__action_is_recurring(action)) {
	/* In case we ever get the recovery logic wrong, force
	* recurring monitors to be restarted, even if just
	* the connection was re-established
	*/
	if (task != pcmk_action_unspecified) {
	order_start_then_action(remote_rsc, action,
	pcmk__ar_first_implies_then);
	}
	} else {
	order_start_then_action(remote_rsc, action, pcmk__ar_none);
	}
	break;
	}
	}

	/*!
	* \internal
	* \brief Order all relevant actions relative to remote connection actions
	*
	* \param[in,out] scheduler Scheduler data
	*/
	void
	pcmk__order_remote_connection_actions(pcmk_scheduler_t *scheduler)
	{
	if (!pcmk_is_set(scheduler->flags, pcmk_sched_have_remote_nodes)) {
	return;
	}

	crm_trace("Creating remote connection orderings");

	for (GList *iter = scheduler->actions; iter != NULL; iter = iter->next) {
	pcmk_action_t *action = iter->data;
	pcmk_resource_t *remote = NULL;

	// We are only interested in resource actions
	if (action->rsc == NULL) {
	continue;
	}

	/* Special case: If we are clearing the failcount of an actual
	* remote connection resource, then make sure this happens before
	* any start of the resource in this transition.
	*/
	if (action->rsc->is_remote_node &&
	pcmk__str_eq(action->task, PCMK_ACTION_CLEAR_FAILCOUNT,
	pcmk__str_none)) {

	pcmk__new_ordering(action->rsc, NULL, action, action->rsc,
	pcmk__op_key(action->rsc->id, PCMK_ACTION_START,
	0),
	NULL, pcmk__ar_ordered, scheduler);

	continue;
	}

	// We are only interested in actions assigned to a node
	if (action->node == NULL) {
	continue;
	}

	if (!pe__is_guest_or_remote_node(action->node)) {
	continue;
	}

	/* We are only interested in real actions.
	*
	* @TODO This is probably wrong; pseudo-actions might be converted to
	* real actions and vice versa later in update_actions() at the end of
	* pcmk__apply_orderings().
	*/
	if (pcmk_is_set(action->flags, pcmk_action_pseudo)) {
	continue;
	}

	remote = action->node->details->remote_rsc;
	if (remote == NULL) {
	// Orphaned
	continue;
	}

	/* Another special case: if a resource is moving to a Pacemaker Remote
	* node, order the stop on the original node after any start of the
	* remote connection. This ensures that if the connection fails to
	* start, we leave the resource running on the original node.
	*/
	if (pcmk__str_eq(action->task, PCMK_ACTION_START, pcmk__str_none)) {
	for (GList *item = action->rsc->actions; item != NULL;
	item = item->next) {
	pcmk_action_t *rsc_action = item->data;

	if (!pe__same_node(rsc_action->node, action->node)
	&& pcmk__str_eq(rsc_action->task, PCMK_ACTION_STOP,
	pcmk__str_none)) {
	pcmk__new_ordering(remote, start_key(remote), NULL,
	action->rsc, NULL, rsc_action,
	pcmk__ar_ordered, scheduler);
	}
	}
	}

	/* The action occurs across a remote connection, so create
	* ordering constraints that guarantee the action occurs while the node
	* is active (after start, before stop ... things like that).
	*
	* This is somewhat brittle in that we need to make sure the results of
	* this ordering are compatible with the result of get_router_node().
	* It would probably be better to add XML_LRM_ATTR_ROUTER_NODE as part
	* of this logic rather than create_graph_action().
	*/
	if (remote->container) {
	crm_trace("Container ordering for %s", action->uuid);
	apply_container_ordering(action);

	} else {
	crm_trace("Remote ordering for %s", action->uuid);
	apply_remote_ordering(action);
	}
	}
	}

	/*!
	* \internal
	* \brief Check whether a node is a failed remote node
	*
	* \param[in] node Node to check
	*
	* \return true if \p node is a failed remote node, false otherwise
	*/
	bool
	pcmk__is_failed_remote_node(const pcmk_node_t *node)
	{
	return pe__is_remote_node(node) && (node->details->remote_rsc != NULL)
	&& (get_remote_node_state(node) == remote_state_failed);
	}

	/*!
	* \internal
	* \brief Check whether a given resource corresponds to a given node as guest
	*
	* \param[in] rsc Resource to check
	* \param[in] node Node to check
	*
	* \return true if \p node is a guest node and \p rsc is its containing
	* resource, otherwise false
	*/
	bool
	pcmk__rsc_corresponds_to_guest(const pcmk_resource_t *rsc,
	const pcmk_node_t *node)
	{
	return (rsc != NULL) && (rsc->fillers != NULL) && (node != NULL)
	&& (node->details->remote_rsc != NULL)
	&& (node->details->remote_rsc->container == rsc);
	}

	/*!
	* \internal
	* \brief Get proper connection host that a remote action must be routed through
	*
	* A remote connection resource might be starting, stopping, or migrating in the
	* same transition that an action needs to be executed on its Pacemaker Remote
	* node. Determine the proper node that the remote action should be routed
	* through.
	*
	* \param[in] action (Potentially remote) action to route
	*
	* \return Connection host that action should be routed through if remote,
	* otherwise NULL
	*/
	pcmk_node_t *
	pcmk__connection_host_for_action(const pcmk_action_t *action)
	{
	pcmk_node_t *began_on = NULL;
	pcmk_node_t *ended_on = NULL;
	bool partial_migration = false;
	const char *task = action->task;

	if (pcmk__str_eq(task, PCMK_ACTION_STONITH, pcmk__str_none)
	\|\| !pe__is_guest_or_remote_node(action->node)) {
	return NULL;
	}

	CRM_ASSERT(action->node->details->remote_rsc != NULL);

	began_on = pe__current_node(action->node->details->remote_rsc);
	ended_on = action->node->details->remote_rsc->allocated_to;
	if (action->node->details->remote_rsc
	&& (action->node->details->remote_rsc->container == NULL)
	&& action->node->details->remote_rsc->partial_migration_target) {
	partial_migration = true;
	}

	if (began_on == NULL) {
	crm_trace("Routing %s for %s through remote connection's "
	"next node %s (starting)%s",
	action->task, (action->rsc? action->rsc->id : "no resource"),
	(ended_on? ended_on->details->uname : "none"),
	partial_migration? " (partial migration)" : "");
	return ended_on;
	}

	if (ended_on == NULL) {
	crm_trace("Routing %s for %s through remote connection's "
	"current node %s (stopping)%s",
	action->task, (action->rsc? action->rsc->id : "no resource"),
	(began_on? began_on->details->uname : "none"),
	partial_migration? " (partial migration)" : "");
	return began_on;
	}

	if (pe__same_node(began_on, ended_on)) {
	crm_trace("Routing %s for %s through remote connection's "
	"current node %s (not moving)%s",
	action->task, (action->rsc? action->rsc->id : "no resource"),
	(began_on? began_on->details->uname : "none"),
	partial_migration? " (partial migration)" : "");
	return began_on;
	}

	/* If we get here, the remote connection is moving during this transition.
	* This means some actions for resources behind the connection will get
	* routed through the cluster node the connection resource is currently on,
	* and others are routed through the cluster node the connection will end up
	* on.
	*/

	if (pcmk__str_eq(task, PCMK_ACTION_NOTIFY, pcmk__str_none)) {
	task = g_hash_table_lookup(action->meta, "notify_operation");
	}

	/*
	* Stop, demote, and migration actions must occur before the connection can
	* move (these actions are required before the remote resource can stop). In
	* this case, we know these actions have to be routed through the initial
	* cluster node the connection resource lived on before the move takes
	* place.
	*
	* The exception is a partial migration of a (non-guest) remote connection
	* resource; in that case, all actions (even these) will be ordered after
	* the connection's pseudo-start on the migration target, so the target is
	* the router node.
	*/
	if (pcmk__strcase_any_of(task, PCMK_ACTION_CANCEL, PCMK_ACTION_STOP,
	PCMK_ACTION_DEMOTE, PCMK_ACTION_MIGRATE_FROM,
	PCMK_ACTION_MIGRATE_TO, NULL)
	&& !partial_migration) {
	crm_trace("Routing %s for %s through remote connection's "
	"current node %s (moving)%s",
	action->task, (action->rsc? action->rsc->id : "no resource"),
	(began_on? began_on->details->uname : "none"),
	partial_migration? " (partial migration)" : "");
	return began_on;
	}

	/* Everything else (start, promote, monitor, probe, refresh,
	* clear failcount, delete, ...) must occur after the connection starts on
	* the node it is moving to.
	*/
	crm_trace("Routing %s for %s through remote connection's "
	"next node %s (moving)%s",
	action->task, (action->rsc? action->rsc->id : "no resource"),
	(ended_on? ended_on->details->uname : "none"),
	partial_migration? " (partial migration)" : "");
	return ended_on;
	}

	/*!
	* \internal
	* \brief Replace remote connection's addr="#uname" with actual address
	*
	* REMOTE_CONTAINER_HACK: If a given resource is a remote connection resource
	* with its "addr" parameter set to "#uname", pull the actual value from the
	* parameters evaluated without a node (which was put there earlier in
	* pcmk__create_graph() when the bundle's expand() method was called).
	*
	* \param[in,out] rsc Resource to check
	* \param[in,out] params Resource parameters evaluated per node
	*/
	void
	pcmk__substitute_remote_addr(pcmk_resource_t rsc, GHashTable params)
	{
	const char *remote_addr = g_hash_table_lookup(params,
	XML_RSC_ATTR_REMOTE_RA_ADDR);

	if (pcmk__str_eq(remote_addr, "#uname", pcmk__str_none)) {
	GHashTable *base = pe_rsc_params(rsc, NULL, rsc->cluster);

	remote_addr = g_hash_table_lookup(base, XML_RSC_ATTR_REMOTE_RA_ADDR);
	if (remote_addr != NULL) {
	g_hash_table_insert(params, strdup(XML_RSC_ATTR_REMOTE_RA_ADDR),
	strdup(remote_addr));
	}
	}
	}

	/*!
	* \brief Add special bundle meta-attributes to XML
	*
	* If a given action will be executed on a guest node (including a bundle),
	- * add the special bundle meta-attribute "container-attribute-target" and
	- * environment variable "physical_host" as XML attributes (using meta-attribute
	- * naming).
	+ * add the special bundle meta-attribute \c PCMK_META_CONTAINER_ATTR_TARGET and
	+ * environment variable \c PCMK__META_PHYSICAL_HOST as XML attributes (using
	+ * meta-attribute naming).
	*
	* \param[in,out] args_xml XML to add attributes to
	* \param[in] action Action to check
	*/
	void
	pcmk__add_bundle_meta_to_xml(xmlNode args_xml, const pcmk_action_t action)
	{
	const pcmk_node_t *guest = action->node;
	const pcmk_node_t *host = NULL;
	enum action_tasks task;

	if (!pe__is_guest_node(guest)) {
	return;
	}

	task = text2task(action->task);
	if ((task == pcmk_action_notify) \|\| (task == pcmk_action_notified)) {
	task = text2task(g_hash_table_lookup(action->meta, "notify_operation"));
	}

	switch (task) {
	case pcmk_action_stop:
	case pcmk_action_stopped:
	case pcmk_action_demote:
	case pcmk_action_demoted:
	// "Down" actions take place on guest's current host
	host = pe__current_node(guest->details->remote_rsc->container);
	break;

	case pcmk_action_start:
	case pcmk_action_started:
	case pcmk_action_monitor:
	case pcmk_action_promote:
	case pcmk_action_promoted:
	// "Up" actions take place on guest's next host
	host = guest->details->remote_rsc->container->allocated_to;
	break;

	default:
	break;
	}

	if (host != NULL) {
	gpointer target = g_hash_table_lookup(action->rsc->meta,
	PCMK_META_CONTAINER_ATTR_TARGET);

	hash2metafield((gpointer) PCMK_META_CONTAINER_ATTR_TARGET,
	target,
	(gpointer) args_xml);
	- hash2metafield((gpointer) PCMK__ENV_PHYSICAL_HOST,
	+ hash2metafield((gpointer) PCMK__META_PHYSICAL_HOST,
	(gpointer) host->details->uname,
	(gpointer) args_xml);
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 21, 7:21 PM (12 h, 30 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1665511
Default Alt Text: (38 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions