No OneTemporary
Actions

Size

30 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/compatibility.h b/include/crm/compatibility.h
	index 8098976b1b..055fb9ecb0 100644
	--- a/include/crm/compatibility.h
	+++ b/include/crm/compatibility.h
	@@ -1,202 +1,204 @@
	/*
	* Copyright (C) 2012-2018 Andrew Beekhof <andrew@beekhof.net>
	*
	* This source code is licensed under the GNU General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/
	#ifndef CRM_COMPATIBILITY__H
	# define CRM_COMPATIBILITY__H

	#include <crm/msg_xml.h>

	/* Heartbeat-specific definitions. Support for heartbeat has been removed
	* entirely, so any code branches relying on these should be deleted.
	*/
	#define ACTIVESTATUS "active"
	#define DEADSTATUS "dead"
	#define PINGSTATUS "ping"
	#define JOINSTATUS "join"
	#define LEAVESTATUS "leave"
	#define NORMALNODE "normal"
	#define CRM_NODE_EVICTED "evicted"
	#define CRM_LEGACY_CONFIG_DIR "/var/lib/heartbeat/crm"
	#define HA_VARLIBHBDIR "/var/lib/heartbeat"
	#define pcmk_cluster_heartbeat 0x0004

	/* Corosync-version-1-specific definitions */

	/* Support for corosync version 1 has been removed entirely, so any code
	* branches relying on these should be deleted.
	*/
	#define PCMK_SERVICE_ID 9
	#define CRM_SERVICE PCMK_SERVICE_ID
	#define XML_ATTR_EXPECTED_VOTES "expected-quorum-votes"
	#define crm_class_members 1
	#define crm_class_notify 2
	#define crm_class_nodeid 3
	#define crm_class_rmpeer 4
	#define crm_class_quorum 5
	#define pcmk_cluster_classic_ais 0x0010
	#define pcmk_cluster_cman 0x0040
	static int ais_fd_sync = -1;

	// These are always true now
	#define CS_USES_LIBQB 1
	#define HAVE_CMAP 1
	#define SUPPORT_CS_QUORUM 1
	#define SUPPORT_AIS 1
	#define AIS_COROSYNC 1

	// These are always false now
	#define HAVE_CONFDB 0
	#define SUPPORT_CMAN 0
	#define SUPPORT_PLUGIN 0
	#define SUPPORT_STONITH_CONFIG 0
	#define is_classic_ais_cluster() 0
	#define is_cman_cluster() 0

	// These have newer names
	#define is_openais_cluster() is_corosync_cluster()
	#if SUPPORT_COROSYNC
	#define SUPPORT_CS
	#endif

	/* Isolation-specific definitions. Support for the resource isolation feature
	* has been removed * entirely, so any code branches relying on these should be
	* deleted.
	*/
	#define XML_RSC_ATTR_ISOLATION_INSTANCE "isolation-instance"
	#define XML_RSC_ATTR_ISOLATION_WRAPPER "isolation-wrapper"
	#define XML_RSC_ATTR_ISOLATION_HOST "isolation-host"
	#define XML_RSC_ATTR_ISOLATION "isolation"

	/* Schema-related definitions */

	// This has been renamed
	#define CRM_DTD_DIRECTORY CRM_SCHEMA_DIRECTORY

	/* Exit-code-related definitions */

	#define DAEMON_RESPAWN_STOP CRM_EX_FATAL
	#define pcmk_err_panic CRM_EX_PANIC

	// Deprecated symbols that were removed
	#define APPNAME_LEN 256
	#define CRM_NODE_ACTIVE CRM_NODE_MEMBER
	#define CRM_OP_DIE "die_no_respawn"
	#define CRM_OP_RETRIVE_CIB "retrieve_cib"
	#define CRM_OP_HBEAT "dc_beat"
	#define CRM_OP_ABORT "abort"
	+#define CRM_OP_DEBUG_UP "debug_inc"
	+#define CRM_OP_DEBUG_DOWN "debug_dec"
	#define CRM_OP_EVENTCC "event_cc"
	#define CRM_OP_TEABORT "te_abort"
	#define CRM_OP_TEABORTED "te_abort_confirmed"
	#define CRM_OP_TE_HALT "te_halt"
	#define CRM_OP_TECOMPLETE "te_complete"
	#define CRM_OP_TETIMEOUT "te_timeout"
	#define CRM_OP_TRANSITION "transition"
	#define CRM_OP_NODES_PROBED "probe_nodes_complete"
	#define DOT_ALL_FSA_INPUTS 1
	#define DOT_FSA_ACTIONS 1
	#define F_LRMD_CANCEL_CALLID "lrmd_cancel_callid"
	#define F_LRMD_RSC_METADATA "lrmd_rsc_metadata_res"
	#define F_LRMD_IPC_PROXY_NODE "lrmd_ipc_proxy_node"
	#define LOG_DEBUG_2 LOG_TRACE
	#define LOG_DEBUG_3 LOG_TRACE
	#define LOG_DEBUG_4 LOG_TRACE
	#define LOG_DEBUG_5 LOG_TRACE
	#define LOG_DEBUG_6 LOG_TRACE
	#define LRMD_OP_RSC_CHK_REG "lrmd_rsc_check_register"
	#define MAX_IPC_FAIL 5
	#define MSG_LOG 1
	#define PE_OBJ_T_NATIVE "native"
	#define PE_OBJ_T_GROUP "group"
	#define PE_OBJ_T_INCARNATION "clone"
	#define PE_OBJ_T_MASTER "master"
	#define SOCKET_LEN 1024
	#define XML_ATTR_TAGNAME F_XML_TAGNAME
	#define XML_ATTR_FILTER_TYPE "type-filter"
	#define XML_ATTR_FILTER_ID "id-filter"
	#define XML_ATTR_FILTER_PRIORITY "priority-filter"
	#define XML_ATTR_DC "is_dc"
	#define XML_MSG_TAG "crm_message"
	#define XML_MSG_TAG_DATA "msg_data"
	#define XML_FAIL_TAG_RESOURCE "failed_resource"
	#define XML_FAILRES_ATTR_RESID "resource_id"
	#define XML_FAILRES_ATTR_REASON "reason"
	#define XML_FAILRES_ATTR_RESSTATUS "resource_status"
	#define XML_ATTR_RESULT "result"
	#define XML_ATTR_SECTION "section"
	#define XML_CIB_TAG_DOMAIN "domain"
	#define XML_CIB_TAG_CONSTRAINT "constraint"
	#define XML_RSC_ATTR_STATE "clone-state"
	#define XML_RSC_ATTR_PRIORITY "priority"
	#define XML_OP_ATTR_DEPENDENT "dependent-on"
	#define XML_LRM_TAG_AGENTS "lrm_agents"
	#define XML_LRM_TAG_AGENT "lrm_agent"
	#define XML_LRM_TAG_ATTRIBUTES "attributes"
	#define XML_CIB_ATTR_HEALTH "health"
	#define XML_CIB_ATTR_WEIGHT "weight"
	#define XML_CIB_ATTR_CLEAR "clear_on"
	#define XML_CIB_ATTR_STONITH "stonith"
	#define XML_CIB_ATTR_STANDBY "standby"
	#define XML_RULE_ATTR_SCORE_MANGLED "score-attribute-mangled"
	#define XML_RULE_ATTR_RESULT "result"
	#define XML_NODE_ATTR_STATE "state"
	#define XML_ATTR_LRM_PROBE "lrm-is-probe"
	#define XML_ATTR_TE_ALLOWFAIL "op_allow_fail"
	#define add_cib_op_callback(cib, id, flag, data, fn) do { \
	cib->cmds->register_callback(cib, id, 120, flag, data, #fn, fn); \
	} while(0)
	#define cib_default_options = cib_none
	#define n_object_classes 3
	#define pe_rsc_munging 0x00000800ULL
	#define pe_rsc_try_reload 0x00001000ULL
	#define pe_rsc_shutdown 0x00020000ULL
	#define pe_rsc_migrating 0x00400000ULL
	#define pe_rsc_unexpectedly_running 0x02000000ULL
	#define pe_rsc_have_unfencing 0x80000000ULL

	/* Clone terminology definitions */

	// These can no longer be used in a switch together
	#define pe_master pe_clone

	static inline enum pe_obj_types
	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)
	\|\| safe_str_eq(name, XML_CIB_TAG_MASTER)) {
	return pe_clone;

	} else if (safe_str_eq(name, XML_CIB_TAG_CONTAINER)) {
	return pe_container;
	}

	return pe_unknown;
	}

	static inline const char *
	get_resource_typename(enum pe_obj_types type)
	{
	switch (type) {
	case pe_native:
	return XML_CIB_TAG_RESOURCE;
	case pe_group:
	return XML_CIB_TAG_GROUP;
	case pe_clone:
	return XML_CIB_TAG_INCARNATION;
	case pe_container:
	return XML_CIB_TAG_CONTAINER;
	case pe_unknown:
	return "unknown";
	}
	return "<unknown>";
	}

	#endif
	diff --git a/include/crm/crm.h b/include/crm/crm.h
	index fcae562a80..9884b3a05d 100644
	--- a/include/crm/crm.h
	+++ b/include/crm/crm.h
	@@ -1,206 +1,203 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2 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 Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/
	#ifndef CRM__H
	# define CRM__H

	/**
	* \file
	* \brief A dumping ground
	* \ingroup core
	*/

	# include <crm_config.h>
	# include <stdlib.h>
	# include <glib.h>
	# include <stdbool.h>

	# include <string.h>

	# include <libxml/tree.h>

	# define CRM_FEATURE_SET "3.1.0"

	# define EOS '\0'
	# define DIMOF(a) ((int) (sizeof(a)/sizeof(a[0])) )

	# ifndef MAX_NAME
	# define MAX_NAME 256
	# endif

	# ifndef __GNUC__
	# define __builtin_expect(expr, result) (expr)
	# endif

	/* Some handy macros used by the Linux kernel */
	# define __likely(expr) __builtin_expect(expr, 1)
	# define __unlikely(expr) __builtin_expect(expr, 0)

	# define CRM_META "CRM_meta"

	extern char *crm_system_name;

	/* INDENT-OFF */

	// Used for some internal IPC timeouts (maybe should be configurable option)
	# define MAX_IPC_DELAY 120

	/* This header defines INFINITY, but it might be defined elsewhere as well
	* (e.g. math.h), so undefine it first. This, of course, complicates any attempt
	* to use the other definition in any code that includes this header.
	*
	* @TODO: Rename our constant (which will break API backward compatibility).
	*/
	# undef INFINITY

	# define INFINITY_S "INFINITY"
	# define MINUS_INFINITY_S "-INFINITY"

	# define INFINITY 1000000

	/* Sub-systems */
	# define CRM_SYSTEM_DC "dc"
	# define CRM_SYSTEM_DCIB "dcib"
	/* The master CIB */
	# define CRM_SYSTEM_CIB "cib"
	# define CRM_SYSTEM_CRMD "crmd"
	# define CRM_SYSTEM_LRMD "lrmd"
	# define CRM_SYSTEM_PENGINE "pengine"
	# define CRM_SYSTEM_TENGINE "tengine"
	# define CRM_SYSTEM_STONITHD "stonithd"
	# define CRM_SYSTEM_MCP "pacemakerd"

	// Names of internally generated node attributes
	# define CRM_ATTR_UNAME "#uname"
	# define CRM_ATTR_ID "#id"
	# define CRM_ATTR_KIND "#kind"
	# define CRM_ATTR_ROLE "#role"
	# define CRM_ATTR_IS_DC "#is_dc"
	# define CRM_ATTR_CLUSTER_NAME "#cluster-name"
	# define CRM_ATTR_SITE_NAME "#site-name"
	# define CRM_ATTR_UNFENCED "#node-unfenced"
	# define CRM_ATTR_DIGESTS_ALL "#digests-all"
	# define CRM_ATTR_DIGESTS_SECURE "#digests-secure"
	# define CRM_ATTR_RA_VERSION "#ra-version"
	# define CRM_ATTR_PROTOCOL "#attrd-protocol"

	/* Valid operations */
	# define CRM_OP_NOOP "noop"
	# define CRM_OP_JOIN_ANNOUNCE "join_announce"
	# define CRM_OP_JOIN_OFFER "join_offer"
	# define CRM_OP_JOIN_REQUEST "join_request"
	# define CRM_OP_JOIN_ACKNAK "join_ack_nack"
	# define CRM_OP_JOIN_CONFIRM "join_confirm"
	# define CRM_OP_PING "ping"
	# define CRM_OP_THROTTLE "throttle"
	# define CRM_OP_VOTE "vote"
	# define CRM_OP_NOVOTE "no-vote"
	# define CRM_OP_HELLO "hello"
	# define CRM_OP_PECALC "pe_calc"
	# define CRM_OP_QUIT "quit"
	# define CRM_OP_LOCAL_SHUTDOWN "start_shutdown"
	# define CRM_OP_SHUTDOWN_REQ "req_shutdown"
	# define CRM_OP_SHUTDOWN "do_shutdown"
	# define CRM_OP_FENCE "stonith"
	# define CRM_OP_REGISTER "register"
	# define CRM_OP_IPC_FWD "ipc_fwd"
	# define CRM_OP_INVOKE_LRM "lrm_invoke"
	# define CRM_OP_LRM_REFRESH "lrm_refresh" /* Deprecated */
	# define CRM_OP_LRM_QUERY "lrm_query"
	# define CRM_OP_LRM_DELETE "lrm_delete"
	# define CRM_OP_LRM_FAIL "lrm_fail"
	# define CRM_OP_PROBED "probe_complete"
	# define CRM_OP_REPROBE "probe_again"
	# define CRM_OP_CLEAR_FAILCOUNT "clear_failcount"
	# define CRM_OP_REMOTE_STATE "remote_state"
	# define CRM_OP_RELAXED_SET "one-or-more"
	# define CRM_OP_RELAXED_CLONE "clone-one-or-more"
	# define CRM_OP_RM_NODE_CACHE "rm_node_cache"
	# define CRM_OP_MAINTENANCE_NODES "maintenance_nodes"

	-# define CRM_OP_DEBUG_UP "debug_inc" /* unused since 1.1.8 */
	-# define CRM_OP_DEBUG_DOWN "debug_dec" /* unused since 1.1.8 */
	-
	/* Possible cluster membership states */
	# define CRMD_JOINSTATE_DOWN "down"
	# define CRMD_JOINSTATE_PENDING "pending"
	# define CRMD_JOINSTATE_MEMBER "member"
	# define CRMD_JOINSTATE_NACK "banned"

	# define CRMD_ACTION_DELETE "delete"
	# define CRMD_ACTION_CANCEL "cancel"

	# define CRMD_ACTION_RELOAD "reload"
	# define CRMD_ACTION_MIGRATE "migrate_to"
	# define CRMD_ACTION_MIGRATED "migrate_from"

	# define CRMD_ACTION_START "start"
	# define CRMD_ACTION_STARTED "running"

	# define CRMD_ACTION_STOP "stop"
	# define CRMD_ACTION_STOPPED "stopped"

	# define CRMD_ACTION_PROMOTE "promote"
	# define CRMD_ACTION_PROMOTED "promoted"
	# define CRMD_ACTION_DEMOTE "demote"
	# define CRMD_ACTION_DEMOTED "demoted"

	# define CRMD_ACTION_NOTIFY "notify"
	# define CRMD_ACTION_NOTIFIED "notified"

	# define CRMD_ACTION_STATUS "monitor"
	# define CRMD_ACTION_METADATA "meta-data"
	# define CRMD_METADATA_CALL_TIMEOUT 30000

	/* short names */
	# define RSC_DELETE CRMD_ACTION_DELETE
	# define RSC_CANCEL CRMD_ACTION_CANCEL

	# define RSC_MIGRATE CRMD_ACTION_MIGRATE
	# define RSC_MIGRATED CRMD_ACTION_MIGRATED

	# define RSC_START CRMD_ACTION_START
	# define RSC_STARTED CRMD_ACTION_STARTED

	# define RSC_STOP CRMD_ACTION_STOP
	# define RSC_STOPPED CRMD_ACTION_STOPPED

	# define RSC_PROMOTE CRMD_ACTION_PROMOTE
	# define RSC_PROMOTED CRMD_ACTION_PROMOTED
	# define RSC_DEMOTE CRMD_ACTION_DEMOTE
	# define RSC_DEMOTED CRMD_ACTION_DEMOTED

	# define RSC_NOTIFY CRMD_ACTION_NOTIFY
	# define RSC_NOTIFIED CRMD_ACTION_NOTIFIED

	# define RSC_STATUS CRMD_ACTION_STATUS
	# define RSC_METADATA CRMD_ACTION_METADATA
	/* INDENT-ON */

	typedef GList *GListPtr;

	# include <crm/common/logging.h>
	# include <crm/common/util.h>

	static inline const char crm_action_str(const char task, int interval) {
	if(safe_str_eq(task, RSC_STATUS) && !interval) {
	return "probe";
	}
	return task;
	}

	#endif
	diff --git a/tools/crmadmin.c b/tools/crmadmin.c
	index eb19014a99..58e2f6dceb 100644
	--- a/tools/crmadmin.c
	+++ b/tools/crmadmin.c
	@@ -1,547 +1,506 @@

	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* 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 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <crm_internal.h>

	#include <sys/param.h>

	#include <stdio.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <libgen.h>

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

	#include <crm/common/mainloop.h>

	#include <crm/cib.h>

	int message_timer_id = -1;
	int message_timeout_ms = 30 * 1000;

	GMainLoop *mainloop = NULL;
	crm_ipc_t *crmd_channel = NULL;
	char *admin_uuid = NULL;

	gboolean do_init(void);
	int do_work(void);
	void crmadmin_ipc_connection_destroy(gpointer user_data);

	int admin_msg_callback(const char *buffer, ssize_t length, gpointer userdata);
	char pluralSection(const char a_section);
	xmlNode *handleCibMod(void);
	int do_find_node_list(xmlNode * xml_node);
	gboolean admin_message_timeout(gpointer data);

	-enum debug {
	- debug_none,
	- debug_dec,
	- debug_inc
	-};
	-
	gboolean BE_VERBOSE = FALSE;
	int expected_responses = 1;

	gboolean BASH_EXPORT = FALSE;
	gboolean DO_HEALTH = FALSE;
	gboolean DO_RESET = FALSE;
	gboolean DO_RESOURCE = FALSE;
	gboolean DO_ELECT_DC = FALSE;
	gboolean DO_WHOIS_DC = FALSE;
	gboolean DO_NODE_LIST = FALSE;
	gboolean BE_SILENT = FALSE;
	gboolean DO_RESOURCE_LIST = FALSE;
	-enum debug DO_DEBUG = debug_none;
	const char *crmd_operation = NULL;

	xmlNode *msg_options = NULL;

	const char *standby_on_off = "on";
	const char *admin_verbose = XML_BOOLEAN_FALSE;
	char *id = NULL;
	char *disconnect = NULL;
	char *dest_node = NULL;
	char *rsc_name = NULL;
	char *crm_option = NULL;

	crm_exit_t exit_code = CRM_EX_OK;
	const char *sys_to = NULL;

	/* INDENT-OFF */
	static struct crm_option long_options[] = {
	/* Top-level Options */
	{"help", 0, 0, '?', "\tThis text"},
	{"version", 0, 0, '$', "\tVersion information" },
	{"quiet", 0, 0, 'q', "\tDisplay only the essential query information"},
	{"verbose", 0, 0, 'V', "\tIncrease debug output"},

	{"-spacer-", 1, 0, '-', "\nCommands:"},
	/* daemon options */
	- {"debug_inc", 1, 0, 'i', "Increase the crmd's debug level on the specified host"},
	- {"debug_dec", 1, 0, 'd', "Decrease the crmd's debug level on the specified host"},
	{"status", 1, 0, 'S', "Display the status of the specified node." },
	{"-spacer-", 1, 0, '-', "\n\tResult is the node's internal FSM state which can be useful for debugging\n"},
	{"dc_lookup", 0, 0, 'D', "Display the uname of the node co-ordinating the cluster."},
	{"-spacer-", 1, 0, '-', "\n\tThis is an internal detail and is rarely useful to administrators except when deciding on which node to examine the logs.\n"},
	{"nodes", 0, 0, 'N', "\tDisplay the uname of all member nodes"},
	{"election", 0, 0, 'E', "(Advanced) Start an election for the cluster co-ordinator"},
	{"kill", 1, 0, 'K', "(Advanced) Shut down the crmd (not the rest of the clusterstack ) on the specified node"},
	{"health", 0, 0, 'H', NULL, 1},

	{"-spacer-", 1, 0, '-', "\nAdditional Options:"},
	{XML_ATTR_TIMEOUT, 1, 0, 't', "Time (in milliseconds) to wait before declaring the operation failed"},
	{"bash-export", 0, 0, 'B', "Create Bash export entries of the form 'export uname=uuid'\n"},

	{"-spacer-", 1, 0, '-', "Notes:"},
	- {"-spacer-", 1, 0, '-', " The -i,-d,-K and -E commands are rarely used and may be removed in future versions."},
	+ {"-spacer-", 1, 0, '-', " The -K and -E commands are rarely used and may be removed in future versions."},

	{0, 0, 0, 0}
	};
	/* INDENT-ON */

	int
	main(int argc, char **argv)
	{
	int option_index = 0;
	int argerr = 0;
	int flag;

	crm_log_cli_init("crmadmin");
	crm_set_options(NULL, "command [options]", long_options,
	"Development tool for performing some crmd-specific commands."
	"\n Likely to be replaced by crm_node in the future");
	if (argc < 2) {
	crm_help('?', CRM_EX_USAGE);
	}

	while (1) {
	flag = crm_get_option(argc, argv, &option_index);
	if (flag == -1)
	break;

	switch (flag) {
	case 'V':
	BE_VERBOSE = TRUE;
	admin_verbose = XML_BOOLEAN_TRUE;
	crm_bump_log_level(argc, argv);
	break;
	case 't':
	message_timeout_ms = atoi(optarg);
	if (message_timeout_ms < 1) {
	message_timeout_ms = 30 * 1000;
	}
	break;

	case '$':
	case '?':
	crm_help(flag, CRM_EX_OK);
	break;
	case 'D':
	DO_WHOIS_DC = TRUE;
	break;
	case 'B':
	BASH_EXPORT = TRUE;
	break;
	case 'K':
	DO_RESET = TRUE;
	crm_trace("Option %c => %s", flag, optarg);
	dest_node = strdup(optarg);
	crmd_operation = CRM_OP_LOCAL_SHUTDOWN;
	break;
	case 'q':
	BE_SILENT = TRUE;
	break;
	- case 'i':
	- DO_DEBUG = debug_inc;
	- crm_trace("Option %c => %s", flag, optarg);
	- dest_node = strdup(optarg);
	- break;
	- case 'd':
	- DO_DEBUG = debug_dec;
	- crm_trace("Option %c => %s", flag, optarg);
	- dest_node = strdup(optarg);
	- break;
	case 'S':
	DO_HEALTH = TRUE;
	crm_trace("Option %c => %s", flag, optarg);
	dest_node = strdup(optarg);
	break;
	case 'E':
	DO_ELECT_DC = TRUE;
	break;
	case 'N':
	DO_NODE_LIST = TRUE;
	break;
	case 'H':
	DO_HEALTH = TRUE;
	break;
	default:
	printf("Argument code 0%o (%c) is not (?yet?) supported\n", flag, 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_help('?', CRM_EX_USAGE);
	}

	if (do_init()) {
	int res = 0;

	res = do_work();
	if (res > 0) {
	/* wait for the reply by creating a mainloop and running it until
	* the callbacks are invoked...
	*/
	mainloop = g_main_loop_new(NULL, FALSE);
	crm_trace("Waiting for %d replies from the local CRM", expected_responses);

	message_timer_id = g_timeout_add(message_timeout_ms, admin_message_timeout, NULL);

	g_main_loop_run(mainloop);

	} else if (res < 0) {
	crm_err("No message to send");
	exit_code = CRM_EX_ERROR;
	}
	} else {
	crm_warn("Init failed, could not perform requested operations");
	exit_code = CRM_EX_UNAVAILABLE;
	}

	crm_trace("%s exiting normally", crm_system_name);
	return exit_code;
	}

	int
	do_work(void)
	{
	int ret = 1;

	/* construct the request */
	xmlNode *msg_data = NULL;
	gboolean all_is_good = TRUE;

	msg_options = create_xml_node(NULL, XML_TAG_OPTIONS);
	crm_xml_add(msg_options, XML_ATTR_VERBOSE, admin_verbose);
	crm_xml_add(msg_options, XML_ATTR_TIMEOUT, "0");

	if (DO_HEALTH == TRUE) {
	crm_trace("Querying the system");

	sys_to = CRM_SYSTEM_DC;

	if (dest_node != NULL) {
	sys_to = CRM_SYSTEM_CRMD;
	crmd_operation = CRM_OP_PING;

	if (BE_VERBOSE) {
	expected_responses = 1;
	}

	crm_xml_add(msg_options, XML_ATTR_TIMEOUT, "0");

	} else {
	crm_info("Cluster-wide health not available yet");
	all_is_good = FALSE;
	}

	} else if (DO_ELECT_DC) {
	/* tell the local node to initiate an election */

	dest_node = NULL;
	sys_to = CRM_SYSTEM_CRMD;
	crmd_operation = CRM_OP_VOTE;

	crm_xml_add(msg_options, XML_ATTR_TIMEOUT, "0");
	ret = 0; /* no return message */

	} else if (DO_WHOIS_DC) {
	dest_node = NULL;
	sys_to = CRM_SYSTEM_DC;
	crmd_operation = CRM_OP_PING;
	crm_xml_add(msg_options, XML_ATTR_TIMEOUT, "0");

	} else if (DO_NODE_LIST) {

	cib_t *the_cib = cib_new();
	xmlNode *output = NULL;

	int rc = the_cib->cmds->signon(the_cib, crm_system_name, cib_command);

	if (rc != pcmk_ok) {
	return -1;
	}

	rc = the_cib->cmds->query(the_cib, NULL, &output, cib_scope_local \| cib_sync_call);
	if(rc == pcmk_ok) {
	do_find_node_list(output);

	free_xml(output);
	}
	the_cib->cmds->signoff(the_cib);
	crm_exit(crm_errno2exit(rc));

	} else if (DO_RESET) {
	/* tell dest_node to initiate the shutdown procedure
	*
	* if dest_node is NULL, the request will be sent to the
	* local node
	*/
	sys_to = CRM_SYSTEM_CRMD;
	crm_xml_add(msg_options, XML_ATTR_TIMEOUT, "0");

	ret = 0; /* no return message */

	- } else if (DO_DEBUG == debug_inc) {
	- /* tell dest_node to increase its debug level
	- *
	- * if dest_node is NULL, the request will be sent to the
	- * local node
	- */
	- sys_to = CRM_SYSTEM_CRMD;
	- crmd_operation = CRM_OP_DEBUG_UP;
	-
	- ret = 0; /* no return message */
	-
	- } else if (DO_DEBUG == debug_dec) {
	- /* tell dest_node to increase its debug level
	- *
	- * if dest_node is NULL, the request will be sent to the
	- * local node
	- */
	- sys_to = CRM_SYSTEM_CRMD;
	- crmd_operation = CRM_OP_DEBUG_DOWN;
	-
	- ret = 0; /* no return message */
	-
	} else {
	crm_err("Unknown options");
	all_is_good = FALSE;
	}

	if (all_is_good == FALSE) {
	crm_err("Creation of request failed. No message to send");
	return -1;
	}

	/* send it */
	if (crmd_channel == NULL) {
	crm_err("The IPC connection is not valid, cannot send anything");
	return -1;
	}

	if (sys_to == NULL) {
	if (dest_node != NULL) {
	sys_to = CRM_SYSTEM_CRMD;
	} else {
	sys_to = CRM_SYSTEM_DC;
	}
	}

	{
	xmlNode *cmd = create_request(crmd_operation, msg_data, dest_node, sys_to,
	crm_system_name, admin_uuid);

	crm_ipc_send(crmd_channel, cmd, 0, 0, NULL);
	free_xml(cmd);
	}

	return ret;
	}

	void
	crmadmin_ipc_connection_destroy(gpointer user_data)
	{
	crm_err("Connection to CRMd was terminated");
	if (mainloop) {
	g_main_loop_quit(mainloop);
	} else {
	crm_exit(CRM_EX_DISCONNECT);
	}
	}

	struct ipc_client_callbacks crm_callbacks = {
	.dispatch = admin_msg_callback,
	.destroy = crmadmin_ipc_connection_destroy
	};

	gboolean
	do_init(void)
	{
	mainloop_io_t *source =
	mainloop_add_ipc_client(CRM_SYSTEM_CRMD, G_PRIORITY_DEFAULT, 0, NULL, &crm_callbacks);

	admin_uuid = crm_getpid_s();

	crmd_channel = mainloop_get_ipc_client(source);

	if (DO_RESOURCE \|\| DO_RESOURCE_LIST \|\| DO_NODE_LIST) {
	return TRUE;

	} else if (crmd_channel != NULL) {
	xmlNode *xml = create_hello_message(admin_uuid, crm_system_name, "0", "1");

	crm_ipc_send(crmd_channel, xml, 0, 0, NULL);
	return TRUE;
	}
	return FALSE;
	}

	static bool
	validate_crm_message(xmlNode * msg, const char sys, const char uuid, const char *msg_type)
	{
	const char *type = NULL;
	const char *crm_msg_reference = NULL;

	if (msg == NULL) {
	return FALSE;
	}

	type = crm_element_value(msg, F_CRM_MSG_TYPE);
	crm_msg_reference = crm_element_value(msg, XML_ATTR_REFERENCE);

	if (type == NULL) {
	crm_info("No message type defined.");
	return FALSE;

	} else if (msg_type != NULL && strcasecmp(msg_type, type) != 0) {
	crm_info("Expecting a (%s) message but received a (%s).", msg_type, type);
	return FALSE;
	}

	if (crm_msg_reference == NULL) {
	crm_info("No message crm_msg_reference defined.");
	return FALSE;
	}

	return TRUE;
	}

	int
	admin_msg_callback(const char *buffer, ssize_t length, gpointer userdata)
	{
	static int received_responses = 0;
	xmlNode *xml = string2xml(buffer);

	received_responses++;
	g_source_remove(message_timer_id);

	crm_log_xml_trace(xml, "ipc");

	if (xml == NULL) {
	crm_info("XML in IPC message was not valid... " "discarding.");

	} else if (validate_crm_message(xml, crm_system_name, admin_uuid, XML_ATTR_RESPONSE) == FALSE) {
	crm_trace("Message was not a CRM response. Discarding.");

	} else if (DO_HEALTH) {
	xmlNode *data = get_message_xml(xml, F_CRM_DATA);
	const char *state = crm_element_value(data, "crmd_state");

	printf("Status of %s@%s: %s (%s)\n",
	crm_element_value(data, XML_PING_ATTR_SYSFROM),
	crm_element_value(xml, F_CRM_HOST_FROM),
	state, crm_element_value(data, XML_PING_ATTR_STATUS));

	if (BE_SILENT && state != NULL) {
	fprintf(stderr, "%s\n", state);
	}

	} else if (DO_WHOIS_DC) {
	const char *dc = crm_element_value(xml, F_CRM_HOST_FROM);

	printf("Designated Controller is: %s\n", dc);
	if (BE_SILENT && dc != NULL) {
	fprintf(stderr, "%s\n", dc);
	}
	crm_exit(CRM_EX_OK);
	}

	free_xml(xml);

	if (received_responses >= expected_responses) {
	crm_trace("Received expected number (%d) of replies, exiting normally",
	expected_responses);
	crm_exit(CRM_EX_OK);
	}

	message_timer_id = g_timeout_add(message_timeout_ms, admin_message_timeout, NULL);
	return 0;
	}

	gboolean
	admin_message_timeout(gpointer data)
	{
	fprintf(stderr, "No messages received in %d seconds.. aborting\n",
	(int)message_timeout_ms / 1000);
	crm_err("No messages received in %d seconds", (int)message_timeout_ms / 1000);
	exit_code = CRM_EX_TIMEOUT;
	g_main_loop_quit(mainloop);
	return FALSE;
	}

	int
	do_find_node_list(xmlNode * xml_node)
	{
	int found = 0;
	xmlNode *node = NULL;
	xmlNode *nodes = get_object_root(XML_CIB_TAG_NODES, xml_node);

	for (node = __xml_first_child(nodes); node != NULL; node = __xml_next(node)) {
	if (crm_str_eq((const char *)node->name, XML_CIB_TAG_NODE, TRUE)) {

	if (BASH_EXPORT) {
	printf("export %s=%s\n",
	crm_element_value(node, XML_ATTR_UNAME),
	crm_element_value(node, XML_ATTR_ID));
	} else {
	printf("%s node: %s (%s)\n",
	crm_element_value(node, XML_ATTR_TYPE),
	crm_element_value(node, XML_ATTR_UNAME),
	crm_element_value(node, XML_ATTR_ID));
	}
	found++;
	}
	}

	if (found == 0) {
	printf("NO nodes configured\n");
	}

	return found;
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 4:46 PM (13 h, 54 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1018936
Default Alt Text: (30 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions