crmadmin.c

linux集群服务器软件代码包

/* $Id: crmadmin.c,v 1.29 2005/02/20 14:38:54 andrew Exp $ */

/* 
 * Copyright (C) 2004 Andrew Beekhof <[e-mail]>
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <sys/param.h>

#include <crm/crm.h>

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

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

#include <heartbeat.h>
#include <hb_api.h>
#include <clplumbing/uids.h>
#include <clplumbing/Gmain_timeout.h>

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

#include <crm/cib.h>

#include <getopt.h>
#include <crm/dmalloc_wrapper.h>

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

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

void usage(const char *cmd, int exit_status);
ll_cluster_t *do_init(void);
int do_work(ll_cluster_t * hb_cluster);

gboolean admin_msg_callback(IPC_Channel * source_data, void *private_data);
char *pluralSection(const char *a_section);
crm_data_t *handleCibMod(void);
int do_find_resource(const char *rsc, crm_data_t *xml_node);
int do_find_resource_list(crm_data_t *xml_node);
int do_find_node_list(crm_data_t *xml_node);
gboolean admin_message_timeout(gpointer data);
gboolean is_node_online(crm_data_t *node_state);

enum debug {
	debug_none,
	debug_dec,
	debug_inc
};

gboolean BE_VERBOSE = FALSE;
int expected_responses = 1;

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;
gboolean DO_OPTION        = FALSE;
enum debug DO_DEBUG       = debug_none;
const char *crmd_operation = NULL;

crm_data_t *msg_options = NULL;

const char *admin_verbose = XML_BOOLEAN_FALSE;
char *id = NULL;
char *this_msg_reference = NULL;
char *disconnect = NULL;
char *dest_node  = NULL;
char *rsc_name   = NULL;
char *crm_option = NULL;

int operation_status = 0;
const char *sys_to = NULL;
const char *crm_system_name = "crmadmin";

#define OPTARGS	"V?K:S:HE:DW:d:i:RNst:o:"

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

	static struct option long_options[] = {
		/* Top-level Options */
		{"verbose", 0, 0, 'V'},
		{"help", 0, 0, '?'},
		{"silent", 0, 0, 's'},
		{"reference", 1, 0, 0},
		{XML_ATTR_TIMEOUT, 1, 0, 't'},

		/* daemon options */
		{"kill", 1, 0, 'K'},  /* stop a node */
		{"die", 0, 0, 0},  /* kill a node, no respawn */
		{"crm_debug_inc", 1, 0, 'i'},
		{"crm_debug_dec", 1, 0, 'd'},
		{"status", 1, 0, 'S'},
		{"health", 0, 0, 'H'},
		{"election", 0, 0, 'E'},
		{"dc_lookup", 0, 0, 'D'},
		{"resources", 0, 0, 'R'},
		{"nodes", 0, 0, 'N'},
		{"whereis", 1, 0, 'W'},
		{"option", 1, 0, 'o'},

		{0, 0, 0, 0}
	};

	crm_system_name = basename(argv[0]);
	crm_log_level = 0;
	crm_log_init(crm_system_name);
	crm_log_level = 0;

	if(argc < 2) {
		usage(crm_system_name, LSB_EXIT_EINVAL);
	}
	
	while (1) {
		flag = getopt_long(argc, argv, OPTARGS,
				   long_options, &option_index);
		if (flag == -1)
			break;

		switch(flag) {
			case 0:
				printf("option %s", long_options[option_index].name);
				if (optarg)
					printf(" with arg %s", optarg);
				printf("\n");
			
				if (strcmp("reference",
					   long_options[option_index].name) == 0) {
					this_msg_reference =
						crm_strdup(optarg);

				} else if (strcmp("die",
						  long_options[option_index].name) == 0) {
					DO_RESET = TRUE;
					crmd_operation = CRM_OP_DIE;
					
				} else {
					printf( "?? Long option (--%s) is not yet properly supported ??\n",
						long_options[option_index].name);
					++argerr;
				}
				break;
			
/* a sample test for multiple instance
   if (digit_optind != 0 && digit_optind != this_option_optind)
   printf ("digits occur in two different argv-elements.\n");
   digit_optind = this_option_optind;
   printf ("option %c\n", c);
*/
			
			case 'V':
				BE_VERBOSE = TRUE;
				admin_verbose = XML_BOOLEAN_TRUE;
				cl_log_enable_stderr(TRUE);
				alter_debug(DEBUG_INC);
				break;
			case 't':
				message_timeout_ms = atoi(optarg);
				if(message_timeout_ms < 1) {
					message_timeout_ms = 30*1000;
				}
				break;
				
			case '?':
				usage(crm_system_name, LSB_EXIT_OK);
				break;
			case 'D':
				DO_WHOIS_DC = TRUE;
				break;
			case 'W':
				DO_RESOURCE = TRUE;
				crm_verbose("Option %c => %s", flag, optarg);
				rsc_name = crm_strdup(optarg);
				break;
			case 'K':
				DO_RESET = TRUE;
				crm_verbose("Option %c => %s", flag, optarg);
				dest_node = crm_strdup(optarg);
				crmd_operation = CRM_OP_LOCAL_SHUTDOWN;
				break;
			case 'o':
				DO_OPTION = TRUE;
				crm_verbose("Option %c => %s", flag, optarg);
				crm_option = crm_strdup(optarg);
				break;
			case 's':
				BE_SILENT = TRUE;
				break;
			case 'i':
				DO_DEBUG = debug_inc;
				crm_verbose("Option %c => %s", flag, optarg);
				dest_node = crm_strdup(optarg);
				break;
			case 'd':
				DO_DEBUG = debug_dec;
				crm_verbose("Option %c => %s", flag, optarg);
				dest_node = crm_strdup(optarg);
				break;
			case 'S':
				DO_HEALTH = TRUE;
				crm_verbose("Option %c => %s", flag, optarg);
				dest_node = crm_strdup(optarg);
				break;
			case 'E':
				DO_ELECT_DC = TRUE;
				break;
			case 'N':
				DO_NODE_LIST = TRUE;
				break;
			case 'R':
				DO_RESOURCE_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) {
		usage(crm_system_name, LSB_EXIT_GENERIC);
	}

	hb_cluster = do_init();
	if (hb_cluster != NULL) {
		int res = do_work(hb_cluster);
		if (res > 0) {
			/* wait for the reply by creating a mainloop and running it until
			 * the callbacks are invoked...
			 */
			mainloop = g_main_new(FALSE);
			crm_verbose("%s waiting for reply from the local CRM",
				 crm_system_name);

			message_timer_id = Gmain_timeout_add(
				message_timeout_ms, admin_message_timeout, NULL);
			
			g_main_run(mainloop);
			return_to_orig_privs();
			
		} else if(res == 0) {
			crm_verbose("%s: no reply expected",
				 crm_system_name);
			
		} else {
			crm_err("No message to send");
			operation_status = -1;
		}
	} else {
		crm_err("Init failed, could not perform requested operations");
		operation_status = -2;
	}

	crm_verbose("%s exiting normally", crm_system_name);
	return operation_status;
}



int
do_work(ll_cluster_t * hb_cluster)
{
	int ret = 1;
	/* construct the request */
	crm_data_t *msg_data = NULL;
	gboolean all_is_good = TRUE;
	
	msg_options = create_xml_node(NULL, XML_TAG_OPTIONS);
	set_xml_property_copy(msg_options, XML_ATTR_VERBOSE, admin_verbose);
	set_xml_property_copy(msg_options, XML_ATTR_TIMEOUT, "0");

	if (DO_HEALTH == TRUE) {
		crm_verbose("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;/* wait until timeout instead */
			}
			
			set_xml_property_copy(
				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 */

		sys_to = CRM_SYSTEM_CRMD;
		crmd_operation = CRM_OP_VOTE;
		
		set_xml_property_copy(
			msg_options, XML_ATTR_TIMEOUT, "0");
		
		dest_node = NULL;

		ret = 0; /* no return message */
		
	} else if(DO_WHOIS_DC) {
		sys_to = CRM_SYSTEM_DC;
		crmd_operation = CRM_OP_PING;
			
		set_xml_property_copy(
			msg_options, XML_ATTR_TIMEOUT, "0");

		dest_node = NULL;

	} else if(DO_RESOURCE || DO_RESOURCE_LIST || DO_NODE_LIST || DO_OPTION){
		cib_t *	the_cib = cib_new();
		crm_data_t *output = NULL;
		int call_options = cib_sync_call;
		
		enum cib_errors rc = the_cib->cmds->signon(
			the_cib, cib_command);

		if(rc != cib_ok) {
			return -1;
			
		} else if(DO_RESOURCE) {
			output = get_cib_copy(the_cib);
			do_find_resource(rsc_name, output);

		} else if(DO_RESOURCE_LIST) {
			output = get_cib_copy(the_cib);
			do_find_resource_list(output);
			
		} else if(DO_NODE_LIST) {
			output = get_cib_copy(the_cib);
			do_find_node_list(output);
			
		} else if(DO_OPTION) {
			char *name = NULL;
			char *value = NULL;
			crm_data_t *xml_option = NULL;
			crm_data_t *fragment = NULL;

			if(decodeNVpair(crm_option, '=', &name, &value)==FALSE){
				crm_err("%s needs to be of the form"
					" <name>=<value>", crm_option);
				return -1;
			}
			
			xml_option = create_xml_node(NULL, XML_CIB_TAG_NVPAIR);
			set_xml_property_copy(
				xml_option, XML_NVPAIR_ATTR_NAME, name);
			set_xml_property_copy(
				xml_option, XML_NVPAIR_ATTR_VALUE, value);
			
			fragment = create_cib_fragment(xml_option, NULL);

			free_xml(xml_option);
			crm_free(name);
			crm_free(value);
			
			rc = the_cib->cmds->modify(
				the_cib, XML_CIB_TAG_CRMCONFIG, fragment,
				NULL, call_options|cib_discard_reply);
			
			free_xml(fragment);
		}

		free_xml(output);
		the_cib->cmds->signoff(the_cib);
		return rc;
		
	} else if(DO_RESET) {
		/* tell dest_node to initiate the shutdown proceedure
		 *