No OneTemporary
Actions

Size

25 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/daemons/pacemakerd/pacemakerd.c b/daemons/pacemakerd/pacemakerd.c
	index 510152cd9f..5f28ed5645 100644
	--- a/daemons/pacemakerd/pacemakerd.c
	+++ b/daemons/pacemakerd/pacemakerd.c
	@@ -1,489 +1,486 @@
	/*
	* Copyright 2010-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 "pacemakerd.h"

	#if SUPPORT_COROSYNC
	#include "pcmkd_corosync.h"
	#endif

	#include <pwd.h>
	#include <errno.h>
	#include <unistd.h>
	#include <stdio.h>
	#include <stdbool.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <sys/time.h>
	#include <sys/resource.h>

	#include <crm/crm.h> /* indirectly: CRM_EX_* */
	#include <crm/common/mainloop.h>
	#include <crm/common/xml.h>
	#include <crm/common/cmdline_internal.h>
	#include <crm/common/ipc_pacemakerd.h>
	#include <crm/common/output_internal.h>
	#include <crm/cluster/internal.h>
	#include <crm/cluster.h>

	#define SUMMARY "pacemakerd - primary Pacemaker daemon that launches and monitors all subsidiary Pacemaker daemons"

	struct {
	gboolean features;
	gboolean foreground;
	gboolean shutdown;
	gboolean standby;
	} options;

	static pcmk__output_t *out = NULL;

	static pcmk__supported_format_t formats[] = {
	PCMK__SUPPORTED_FORMAT_NONE,
	PCMK__SUPPORTED_FORMAT_TEXT,
	PCMK__SUPPORTED_FORMAT_XML,
	{ NULL, NULL, NULL }
	};

	PCMK__OUTPUT_ARGS("features")
	static int
	pacemakerd_features(pcmk__output_t *out, va_list args) {
	out->info(out, "Pacemaker %s (Build: %s)\n Supporting v%s: %s", PACEMAKER_VERSION,
	BUILD_VERSION, CRM_FEATURE_SET, CRM_FEATURES);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("features")
	static int
	pacemakerd_features_xml(pcmk__output_t *out, va_list args) {
	gchar **feature_list = g_strsplit(CRM_FEATURES, " ", 0);

	pcmk__output_xml_create_parent(out, PCMK_XE_PACEMAKERD,
	PCMK_XA_VERSION, PACEMAKER_VERSION,
	PCMK_XA_BUILD, BUILD_VERSION,
	PCMK_XA_FEATURE_SET, CRM_FEATURE_SET,
	NULL);
	out->begin_list(out, NULL, NULL, PCMK_XE_FEATURES);

	for (char *s = feature_list; s != NULL; s++) {
	pcmk__output_create_xml_text_node(out, PCMK_XE_FEATURE, *s);
	}

	out->end_list(out);

	pcmk__output_xml_pop_parent(out);

	g_strfreev(feature_list);
	return pcmk_rc_ok;
	}

	static pcmk__message_entry_t fmt_functions[] = {
	{ "features", "default", pacemakerd_features },
	{ "features", "xml", pacemakerd_features_xml },

	{ NULL, NULL, NULL }
	};

	static gboolean
	pid_cb(const gchar option_name, const gchar optarg, gpointer data, GError **err) {
	return TRUE;
	}

	static gboolean
	standby_cb(const gchar option_name, const gchar optarg, gpointer data, GError **err) {
	options.standby = TRUE;
	pcmk__set_env_option(PCMK__ENV_NODE_START_STATE, PCMK_VALUE_STANDBY, false);
	return TRUE;
	}

	static GOptionEntry entries[] = {
	{ "features", 'F', 0, G_OPTION_ARG_NONE, &options.features,
	"Display full version and list of features Pacemaker was built with",
	NULL },
	{ "foreground", 'f', 0, G_OPTION_ARG_NONE, &options.foreground,
	"(Ignored) Pacemaker always runs in the foreground",
	NULL },
	{ "pid-file", 'p', 0, G_OPTION_ARG_CALLBACK, pid_cb,
	"(Ignored) Daemon pid file location",
	"FILE" },
	{ "shutdown", 'S', 0, G_OPTION_ARG_NONE, &options.shutdown,
	"Instruct Pacemaker to shutdown on this machine",
	NULL },
	{ "standby", 's', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, standby_cb,
	"Start node in standby state",
	NULL },

	{ NULL }
	};

	static void
	pcmk_ignore(int nsig)
	{
	crm_info("Ignoring signal %s (%d)", strsignal(nsig), nsig);
	}

	static void
	pcmk_sigquit(int nsig)
	{
	pcmk__panic(__func__);
	}

	static void
	pacemakerd_chown(const char *path, uid_t uid, gid_t gid)
	{
	int rc = chown(path, uid, gid);

	if (rc < 0) {
	crm_warn("Cannot change the ownership of %s to user %s and gid %d: %s",
	path, CRM_DAEMON_USER, gid, pcmk_rc_str(errno));
	}
	}

	static void
	create_pcmk_dirs(void)
	{
	uid_t pcmk_uid = 0;
	gid_t pcmk_gid = 0;

	const char *dirs[] = {
	CRM_PACEMAKER_DIR, // core/blackbox/scheduler/CIB files
	CRM_CORE_DIR, // core files
	CRM_BLACKBOX_DIR, // blackbox dumps
	PE_STATE_DIR, // scheduler inputs
	CRM_CONFIG_DIR, // the Cluster Information Base (CIB)
	// Don't build CRM_RSCTMP_DIR, pacemaker-execd will do it
	NULL
	};

	if (pcmk_daemon_user(&pcmk_uid, &pcmk_gid) < 0) {
	crm_err("Cluster user %s does not exist, aborting Pacemaker startup",
	CRM_DAEMON_USER);
	crm_exit(CRM_EX_NOUSER);
	}

	// Used by some resource agents
	if ((mkdir(CRM_STATE_DIR, 0750) < 0) && (errno != EEXIST)) {
	crm_warn("Could not create directory " CRM_STATE_DIR ": %s",
	pcmk_rc_str(errno));
	} else {
	pacemakerd_chown(CRM_STATE_DIR, pcmk_uid, pcmk_gid);
	}

	for (int i = 0; dirs[i] != NULL; ++i) {
	int rc = pcmk__build_path(dirs[i], 0750);

	if (rc != pcmk_rc_ok) {
	crm_warn("Could not create directory %s: %s",
	dirs[i], pcmk_rc_str(rc));
	} else {
	pacemakerd_chown(dirs[i], pcmk_uid, pcmk_gid);
	}
	}
	}

	static void
	remove_core_file_limit(void)
	{
	struct rlimit cores;

	// Get current limits
	if (getrlimit(RLIMIT_CORE, &cores) < 0) {
	crm_notice("Unable to check system core file limits "
	"(consider ensuring the size is unlimited): %s",
	strerror(errno));
	return;
	}

	// Check whether core dumps are disabled
	if (cores.rlim_max == 0) {
	if (geteuid() != 0) { // Yes, and there's nothing we can do about it
	crm_notice("Core dumps are disabled (consider enabling them)");
	return;
	}
	cores.rlim_max = RLIM_INFINITY; // Yes, but we're root, so enable them
	}

	// Raise soft limit to hard limit (if not already done)
	if (cores.rlim_cur != cores.rlim_max) {
	cores.rlim_cur = cores.rlim_max;
	if (setrlimit(RLIMIT_CORE, &cores) < 0) {
	crm_notice("Unable to raise system limit on core file size "
	"(consider doing so manually): %s",
	strerror(errno));
	return;
	}
	}

	if (cores.rlim_cur == RLIM_INFINITY) {
	crm_trace("Core file size is unlimited");
	} else {
	crm_trace("Core file size is limited to %llu bytes",
	(unsigned long long) cores.rlim_cur);
	}
	}

	static void
	pacemakerd_event_cb(pcmk_ipc_api_t *pacemakerd_api,
	enum pcmk_ipc_event event_type, crm_exit_t status,
	void event_data, void user_data)
	{
	pcmk_pacemakerd_api_reply_t *reply = event_data;

	switch (event_type) {
	case pcmk_ipc_event_reply:
	break;

	default:
	return;
	}

	if (status != CRM_EX_OK) {
	out->err(out, "Bad reply from pacemakerd: %s", crm_exit_str(status));
	return;
	}

	if (reply->reply_type != pcmk_pacemakerd_reply_shutdown) {
	out->err(out, "Unknown reply type %d from pacemakerd",
	reply->reply_type);
	}
	}

	static GOptionContext *
	build_arg_context(pcmk__common_args_t args, GOptionGroup *group) {
	GOptionContext *context = NULL;

	context = pcmk__build_arg_context(args, "text (default), xml", group, NULL);
	pcmk__add_main_args(context, entries);
	return context;
	}

	int
	main(int argc, char **argv)
	{
	int rc = pcmk_rc_ok;
	crm_exit_t exit_code = CRM_EX_OK;

	GError *error = NULL;

	GOptionGroup *output_group = NULL;
	pcmk__common_args_t *args = pcmk__new_common_args(SUMMARY);
	gchar **processed_args = pcmk__cmdline_preproc(argv, "p");
	GOptionContext *context = build_arg_context(args, &output_group);

	bool old_instance_connected = false;

	pcmk_ipc_api_t *old_instance = NULL;
	qb_ipcs_service_t *ipcs = NULL;

	subdaemon_check_progress = time(NULL);

	setenv("LC_ALL", "C", 1); // Ensure logs are in a common language

	crm_log_preinit(NULL, argc, argv);
	mainloop_add_signal(SIGHUP, pcmk_ignore);
	mainloop_add_signal(SIGQUIT, pcmk_sigquit);

	pcmk__register_formats(output_group, formats);
	if (!g_option_context_parse_strv(context, &processed_args, &error)) {
	exit_code = CRM_EX_USAGE;
	goto done;
	}

	rc = pcmk__output_new(&out, args->output_ty, args->output_dest, argv);
	if ((rc != pcmk_rc_ok) \|\| (out == NULL)) {
	exit_code = CRM_EX_ERROR;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code, "Error creating output format %s: %s",
	args->output_ty, pcmk_rc_str(rc));
	goto done;
	}

	pcmk__register_messages(out, fmt_functions);

	if (options.features) {
	out->message(out, "features");
	exit_code = CRM_EX_OK;
	goto done;
	}

	if (args->version) {
	out->version(out, false);
	goto done;
	}

	- // @COMPAT Drop at 3.0.0; likely last used in 1.1.24
	- pcmk__set_env_option(PCMK__ENV_MCP, PCMK_VALUE_TRUE, true);
	-
	if (options.shutdown) {
	pcmk__cli_init_logging("pacemakerd", args->verbosity);
	} else {
	crm_log_init(NULL, LOG_INFO, TRUE, FALSE, argc, argv, FALSE);
	}

	crm_debug("Checking for existing Pacemaker instance");

	rc = pcmk_new_ipc_api(&old_instance, pcmk_ipc_pacemakerd);
	if (old_instance == NULL) {
	out->err(out, "Could not check for existing pacemakerd: %s", pcmk_rc_str(rc));
	exit_code = pcmk_rc2exitc(rc);
	goto done;
	}

	pcmk_register_ipc_callback(old_instance, pacemakerd_event_cb, NULL);
	rc = pcmk__connect_ipc(old_instance, pcmk_ipc_dispatch_sync, 2);
	if (rc != pcmk_rc_ok) {
	crm_debug("No existing %s instance found: %s",
	pcmk_ipc_name(old_instance, true), pcmk_rc_str(rc));
	}
	old_instance_connected = pcmk_ipc_is_connected(old_instance);

	if (options.shutdown) {
	if (old_instance_connected) {
	rc = pcmk_pacemakerd_api_shutdown(old_instance, crm_system_name);
	pcmk_dispatch_ipc(old_instance);

	exit_code = pcmk_rc2exitc(rc);

	if (exit_code != CRM_EX_OK) {
	pcmk_free_ipc_api(old_instance);
	goto done;
	}

	/* We get the ACK immediately, and the response right after that,
	* but it might take a while for pacemakerd to get around to
	* shutting down. Wait for that to happen (with 30-minute timeout).
	*/
	for (int i = 0; i < 900; i++) {
	if (!pcmk_ipc_is_connected(old_instance)) {
	exit_code = CRM_EX_OK;
	pcmk_free_ipc_api(old_instance);
	goto done;
	}

	sleep(2);
	}

	exit_code = CRM_EX_TIMEOUT;
	pcmk_free_ipc_api(old_instance);
	goto done;

	} else {
	out->err(out, "Could not request shutdown "
	"of existing Pacemaker instance: %s", pcmk_rc_str(rc));
	pcmk_free_ipc_api(old_instance);
	exit_code = CRM_EX_DISCONNECT;
	goto done;
	}

	} else if (old_instance_connected) {
	pcmk_free_ipc_api(old_instance);
	crm_err("Aborting start-up because active Pacemaker instance found");
	exit_code = CRM_EX_FATAL;
	goto done;
	}

	pcmk_free_ipc_api(old_instance);

	/* Don't allow any accidental output after this point. */
	if (out != NULL) {
	out->finish(out, exit_code, true, NULL);
	pcmk__output_free(out);
	out = NULL;
	}

	#ifdef SUPPORT_COROSYNC
	if (pacemakerd_read_config() == FALSE) {
	crm_exit(CRM_EX_UNAVAILABLE);
	}
	#endif

	// OCF shell functions and cluster-glue need facility under different name
	{
	const char *facility = pcmk__env_option(PCMK__ENV_LOGFACILITY);

	if (!pcmk__str_eq(facility, PCMK_VALUE_NONE,
	pcmk__str_casei\|pcmk__str_null_matches)) {
	pcmk__set_env_option("LOGFACILITY", facility, true);
	}
	}

	crm_notice("Starting Pacemaker %s " QB_XS " build=%s features:%s",
	PACEMAKER_VERSION, BUILD_VERSION, CRM_FEATURES);
	mainloop = g_main_loop_new(NULL, FALSE);

	remove_core_file_limit();
	create_pcmk_dirs();
	pcmk__serve_pacemakerd_ipc(&ipcs, &pacemakerd_ipc_callbacks);

	#ifdef SUPPORT_COROSYNC
	/* Allows us to block shutdown */
	if (!cluster_connect_cfg()) {
	exit_code = CRM_EX_PROTOCOL;
	goto done;
	}
	#endif

	if (pcmk__locate_sbd() > 0) {
	running_with_sbd = TRUE;
	}

	switch (find_and_track_existing_processes()) {
	case pcmk_rc_ok:
	break;
	case pcmk_rc_ipc_unauthorized:
	exit_code = CRM_EX_CANTCREAT;
	goto done;
	default:
	exit_code = CRM_EX_FATAL;
	goto done;
	};

	mainloop_add_signal(SIGTERM, pcmk_shutdown);
	mainloop_add_signal(SIGINT, pcmk_shutdown);

	if ((running_with_sbd) && pcmk__get_sbd_sync_resource_startup()) {
	crm_notice("Waiting for startup-trigger from SBD.");
	pacemakerd_state = PCMK__VALUE_WAIT_FOR_PING;
	startup_trigger = mainloop_add_trigger(G_PRIORITY_HIGH, init_children_processes, NULL);
	} else {
	if (running_with_sbd) {
	crm_warn("Enabling SBD_SYNC_RESOURCE_STARTUP would (if supported "
	"by your SBD version) improve reliability of "
	"interworking between SBD & pacemaker.");
	}
	pacemakerd_state = PCMK__VALUE_STARTING_DAEMONS;
	init_children_processes(NULL);
	}

	crm_notice("Pacemaker daemon successfully started and accepting connections");
	g_main_loop_run(mainloop);

	if (ipcs) {
	crm_trace("Closing IPC server");
	mainloop_del_ipc_server(ipcs);
	ipcs = NULL;
	}

	g_main_loop_unref(mainloop);
	#ifdef SUPPORT_COROSYNC
	cluster_disconnect_cfg();
	#endif

	done:
	g_strfreev(processed_args);
	pcmk__free_arg_context(context);

	pcmk__output_and_clear_error(&error, out);

	if (out != NULL) {
	out->finish(out, exit_code, true, NULL);
	pcmk__output_free(out);
	}
	pcmk__unregister_formats();
	crm_exit(exit_code);
	}
	diff --git a/include/crm/common/options_internal.h b/include/crm/common/options_internal.h
	index a0202ab6f1..f4bd8c7fd5 100644
	--- a/include/crm/common/options_internal.h
	+++ b/include/crm/common/options_internal.h
	@@ -1,262 +1,259 @@
	/*
	* 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__CRM_COMMON_OPTIONS_INTERNAL__H
	#define PCMK__CRM_COMMON_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()
	#include <crm/common/output_internal.h> // pcmk__output_t

	_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
	*/

	/*!
	* \internal
	* \enum pcmk__opt_flags
	* \brief Option flags
	*/
	enum pcmk__opt_flags {
	pcmk__opt_none = 0U, //!< No additional information

	/*!
	* \brief In CIB manager metadata
	*
	* \deprecated This flag will be removed with CIB manager metadata
	*/
	pcmk__opt_based = (1U << 0),

	/*!
	* \brief In controller metadata
	*
	* \deprecated This flag will be removed with controller metadata
	*/
	pcmk__opt_controld = (1U << 1),

	/*!
	* \brief In scheduler metadata
	*
	* \deprecated This flag will be removed with scheduler metadata
	*/
	pcmk__opt_schedulerd = (1U << 2),

	pcmk__opt_advanced = (1U << 3), //!< Advanced use only
	pcmk__opt_generated = (1U << 4), //!< Generated by Pacemaker
	pcmk__opt_deprecated = (1U << 5), //!< Option is deprecated
	pcmk__opt_fencing = (1U << 6), //!< Common fencing resource parameter
	pcmk__opt_primitive = (1U << 7), //!< Primitive resource meta-attribute
	};

	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 );

	uint32_t flags; //!< Group of <tt>enum pcmk__opt_flags</tt>

	const char *description_short;
	const char *description_long;

	} pcmk__cluster_option_t;

	const char pcmk__cluster_option(GHashTable options, const char *name);

	int pcmk__output_cluster_options(pcmk__output_t out, const char name,
	const char desc_short, const char desc_long,
	uint32_t filter, bool all);
	int pcmk__output_fencing_params(pcmk__output_t out, const char name,
	const char desc_short, const char desc_long,
	bool all);
	int pcmk__output_primitive_meta(pcmk__output_t out, const char name,
	const char desc_short, const char desc_long,
	bool all);

	int pcmk__daemon_metadata(pcmk__output_t out, const char name,
	const char short_desc, const char long_desc,
	enum pcmk__opt_flags filter);

	void pcmk__validate_cluster_options(GHashTable *options);

	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_placement_strategy(const char *value);

	// from watchdog.c
	long pcmk__get_sbd_watchdog_timeout(void);
	bool pcmk__get_sbd_sync_resource_startup(void);
	long pcmk__auto_stonith_watchdog_timeout(void);
	bool pcmk__valid_stonith_watchdog_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_REMOTE_ADDRESS "remote_address"
	#define PCMK__ENV_REMOTE_SCHEMA_DIRECTORY "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 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_CLONE "clone"
	#define PCMK__META_CONTAINER "container"
	#define PCMK__META_DIGESTS_ALL "digests-all"
	#define PCMK__META_DIGESTS_SECURE "digests-secure"
	#define PCMK__META_INTERNAL_RSC "internal_rsc"
	#define PCMK__META_MIGRATE_SOURCE "migrate_source"
	#define PCMK__META_MIGRATE_TARGET "migrate_target"
	#define PCMK__META_ON_NODE "on_node"
	#define PCMK__META_ON_NODE_UUID "on_node_uuid"
	#define PCMK__META_OP_NO_WAIT "op_no_wait"
	#define PCMK__META_OP_TARGET_RC "op_target_rc"
	#define PCMK__META_PHYSICAL_HOST "physical-host"
	#define PCMK__META_STONITH_ACTION "stonith_action"

	/* @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 meta-attribute since 2.1.0
	#define PCMK__META_CAN_FAIL "can_fail"

	// @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
	#define PCMK__VALUE_ATTRD "attrd"
	#define PCMK__VALUE_BOLD "bold"
	#define PCMK__VALUE_BROADCAST "broadcast"
	#define PCMK__VALUE_CIB "cib"
	#define PCMK__VALUE_CIB_DIFF_NOTIFY "cib_diff_notify"
	#define PCMK__VALUE_CIB_NOTIFY "cib_notify"
	#define PCMK__VALUE_CIB_POST_NOTIFY "cib_post_notify"
	#define PCMK__VALUE_CIB_PRE_NOTIFY "cib_pre_notify"
	#define PCMK__VALUE_CIB_UPDATE_CONFIRMATION "cib_update_confirmation"
	#define PCMK__VALUE_CLUSTER "cluster"
	#define PCMK__VALUE_CRMD "crmd"
	#define PCMK__VALUE_EN "en"
	#define PCMK__VALUE_EPOCH "epoch"
	#define PCMK__VALUE_HEALTH_RED "health_red"
	#define PCMK__VALUE_HEALTH_YELLOW "health_yellow"
	#define PCMK__VALUE_INIT "init"
	#define PCMK__VALUE_LOCAL "local"
	#define PCMK__VALUE_LRMD "lrmd"
	#define PCMK__VALUE_MAINT "maint"
	#define PCMK__VALUE_OUTPUT "output"
	#define PCMK__VALUE_PASSWORD "password"
	#define PCMK__VALUE_PING "ping"
	#define PCMK__VALUE_PRIMITIVE "primitive"
	#define PCMK__VALUE_REFRESH "refresh"
	#define PCMK__VALUE_REQUEST "request"
	#define PCMK__VALUE_RESPONSE "response"
	#define PCMK__VALUE_RSC_FAILED "rsc-failed"
	#define PCMK__VALUE_RSC_FAILURE_IGNORED "rsc-failure-ignored"
	#define PCMK__VALUE_RSC_MANAGED "rsc-managed"
	#define PCMK__VALUE_RSC_MULTIPLE "rsc-multiple"
	#define PCMK__VALUE_RSC_OK "rsc-ok"
	#define PCMK__VALUE_RUNNING "running"
	#define PCMK__VALUE_SHUTDOWN_COMPLETE "shutdown_complete"
	#define PCMK__VALUE_SHUTTING_DOWN "shutting_down"
	#define PCMK__VALUE_ST_ASYNC_TIMEOUT_VALUE "st-async-timeout-value"
	#define PCMK__VALUE_ST_NOTIFY "st_notify"
	#define PCMK__VALUE_ST_NOTIFY_DISCONNECT "st_notify_disconnect"
	#define PCMK__VALUE_ST_NOTIFY_FENCE "st_notify_fence"
	#define PCMK__VALUE_ST_NOTIFY_HISTORY "st_notify_history"
	#define PCMK__VALUE_ST_NOTIFY_HISTORY_SYNCED "st_notify_history_synced"
	#define PCMK__VALUE_STARTING_DAEMONS "starting_daemons"
	#define PCMK__VALUE_STONITH_NG "stonith-ng"
	#define PCMK__VALUE_WAIT_FOR_PING "wait_for_ping"
	#define PCMK__VALUE_WARNING "warning"

	/* @COMPAT Deprecated since 2.1.7 (used with PCMK__XA_ORDERING attribute of
	* resource sets)
	*/
	#define PCMK__VALUE_GROUP "group"

	// @COMPAT Drop when daemon metadata commands are dropped
	#define PCMK__VALUE_TIME "time"

	#endif // PCMK__OPTIONS_INTERNAL__H

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 21, 4:40 PM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1664976
Default Alt Text: (25 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions