crmadmin.c

linux集群服务器软件代码包

		 * if dest_node is NULL, the request will be sent to the
		 *   local node
		 */
		sys_to = CRM_SYSTEM_CRMD;
		set_xml_property_copy(
			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;				
	}
	
	{
		HA_Message *cmd = create_request(
			crmd_operation, msg_data, dest_node, sys_to,
			crm_system_name, admin_uuid);

		if(this_msg_reference != NULL) {
			ha_msg_mod(cmd, XML_ATTR_REFERENCE, this_msg_reference);
		}
		send_ipc_message(crmd_channel, cmd);
	}
	
	return ret;

}


ll_cluster_t *
do_init(void)
{
	int facility;
	ll_cluster_t *hb_cluster = NULL;

#ifdef USE_LIBXML
	/* docs say only do this once, but in their code they do it every time! */
	xmlInitParser (); 
#endif
	/* change the logging facility to the one used by heartbeat daemon */
	hb_cluster = ll_cluster_new("heartbeat");
	
	crm_verbose("Switching to Heartbeat logger");
	if (( facility =
	      hb_cluster->llc_ops->get_logfacility(hb_cluster)) > 0) {
		cl_log_set_facility(facility);
	}

	crm_malloc(admin_uuid, sizeof(char) * 11);
	if(admin_uuid != NULL) {
		snprintf(admin_uuid, 10, "%d", getpid());
		admin_uuid[10] = '\0';
	}
	
	init_client_ipc_comms(
		CRM_SYSTEM_CRMD, admin_msg_callback, NULL, &crmd_channel);

	if(crmd_channel != NULL) {
		send_hello_message(
			crmd_channel, admin_uuid, crm_system_name,"0", "1");

		return hb_cluster;
	} 
	return NULL;
}

gboolean
admin_msg_callback(IPC_Channel * server, void *private_data)
{
	int lpc = 0;
	IPC_Message *msg = NULL;
	ha_msg_input_t *new_input = NULL;
	gboolean hack_return_good = TRUE;
	static int received_responses = 0;
	char *filename;
	int filename_len = 0;
	const char *result = NULL;

	g_source_remove(message_timer_id);

	while (server->ch_status != IPC_DISCONNECT
	       && server->ops->is_message_pending(server) == TRUE) {
		if(new_input != NULL) {
			delete_ha_msg_input(new_input);
		}
		
		if (server->ops->recv(server, &msg) != IPC_OK) {
			perror("Receive failure:");
			return !hack_return_good;
		}

		if (msg == NULL) {
			crm_trace("No message this time");
			continue;
		}

		lpc++;
		new_input = new_ipc_msg_input(msg);
		msg->msg_done(msg);
		crm_log_message(LOG_MSG, new_input->msg);
		
		if (new_input->xml == NULL) {
			crm_info(
			       "XML in IPC message was not valid... "
			       "discarding.");
			continue;
		} else if (validate_crm_message(
				   new_input->msg, crm_system_name, admin_uuid,
				   XML_ATTR_RESPONSE) == FALSE) {
			crm_info(
			       "Message was not a CRM response. Discarding.");
			continue;
		}

		result = cl_get_string(new_input->msg, XML_ATTR_RESULT);
		if(result == NULL || strcmp(result, "ok") == 0) {
			result = "pass";
		} else {
			result = "fail";
		}
		
		received_responses++;

		if(DO_HEALTH) {
			const char *state = crm_element_value(
				new_input->xml, "crmd_state");

			printf("Status of %s@%s: %s (%s)\n",
			       crm_element_value(new_input->xml,XML_PING_ATTR_SYSFROM),
			       cl_get_string(new_input->msg, F_CRM_HOST_FROM),
			       state,
			       crm_element_value(new_input->xml,XML_PING_ATTR_STATUS));
			
			if(BE_SILENT && state != NULL) {
				fprintf(stderr, "%s\n", state);
			}
			
		} else if(DO_WHOIS_DC) {
			const char *dc = cl_get_string(
				new_input->msg, F_CRM_HOST_FROM);
			
			printf("Designated Controller is: %s\n", dc);
			if(BE_SILENT && dc != NULL) {
				fprintf(stderr, "%s\n", dc);
			}
		}
		
		if (this_msg_reference != NULL) {
			/* in testing mode... */
			/* 31 = "test-_.xml" + an_int_as_string + '\0' */
			filename_len = 31 + strlen(this_msg_reference);

			crm_malloc(filename, sizeof(char) * filename_len);
			if(filename != NULL) {
				sprintf(filename, "%s-%s_%d.xml",
					result, this_msg_reference,
					received_responses);
				
				filename[filename_len - 1] = '\0';
				if (0 > write_xml_file(new_input->xml, filename)) {
					crm_crit("Could not save response to"
						 " %s", filename);
				}
			}
		}
	}

	if (server->ch_status == IPC_DISCONNECT) {
		crm_verbose("admin_msg_callback: received HUP");
		return !hack_return_good;
	}

	if (received_responses >= expected_responses) {
		crm_verbose(
		       "Recieved expected number (%d) of messages from Heartbeat."
		       "  Exiting normally.", expected_responses);
		g_main_quit(mainloop);
		return !hack_return_good;
	}

	message_timer_id = Gmain_timeout_add(
		message_timeout_ms, admin_message_timeout, NULL);
	
	
	return hack_return_good;
}

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);
	g_main_quit(mainloop);
	return FALSE;
}


int
do_find_resource(const char *rsc, crm_data_t *xml_node)
{
	int found = 0;
	crm_data_t *nodestates = get_object_root(XML_CIB_TAG_STATUS, xml_node);
	const char *path2[] = {
		XML_CIB_TAG_LRM,
		XML_LRM_TAG_RESOURCES
	};

	xml_child_iter(
		nodestates, a_node, XML_CIB_TAG_STATE,
		crm_data_t *rscstates = NULL;

		if(is_node_online(a_node) == FALSE) {
			crm_devel("Skipping offline node: %s",
				crm_element_value(a_node, XML_ATTR_ID));
			continue;
		}
		
		rscstates = find_xml_node_nested(a_node, path2, DIMOF(path2));
		xml_child_iter(
			rscstates, rsc_state, XML_LRM_TAG_RESOURCE,
			const char *id = crm_element_value(rsc_state,XML_ATTR_ID);
			const char *target =
				crm_element_value(rsc_state,XML_LRM_ATTR_TARGET);
			const char *last_op =
				crm_element_value(rsc_state,XML_LRM_ATTR_LASTOP);
			const char *op_code =
				crm_element_value(rsc_state,XML_LRM_ATTR_OPSTATUS);
			
			crm_devel("checking %s:%s for %s", target, id, rsc);

			if(safe_str_neq(rsc, id)){
				crm_trace("no match");
				continue;
			}
			
			if(safe_str_eq("stop", last_op)) {
				crm_devel("resource %s is stopped on: %s\n",
					  rsc, target);
				
			} else if(safe_str_eq(op_code, "-1")) {
				crm_devel("resource %s is pending on: %s\n",
					  rsc, target);				

			} else if(safe_str_neq(op_code, "0")) {
				crm_devel("resource %s is failed on: %s\n",
					  rsc, target);				

			} else {
				crm_devel("resource %s is running on: %s\n",
					  rsc, target);				
				printf("resource %s is running on: %s\n",
				       rsc, target);
				if(BE_SILENT) {
					fprintf(stderr, "%s ", target);
				}
				found++;
			}
			);
		if(BE_SILENT) {
			fprintf(stderr, "\n");
		}
		);
	
	if(found == 0) {
		printf("resource %s is NOT running\n", rsc);
	}
					
	return found;
}

gboolean
is_node_online(crm_data_t *node_state) 
{
	const char *uname      = crm_element_value(node_state,XML_ATTR_UNAME);
	const char *join_state = crm_element_value(node_state,XML_CIB_ATTR_JOINSTATE);
	const char *crm_state  = crm_element_value(node_state,XML_CIB_ATTR_CRMDSTATE);
	const char *ha_state   = crm_element_value(node_state,XML_CIB_ATTR_HASTATE);
	const char *ccm_state  = crm_element_value(node_state,XML_CIB_ATTR_INCCM);

	if(safe_str_eq(join_state, CRMD_JOINSTATE_MEMBER)
	   && safe_str_eq(ha_state, ACTIVESTATUS)
	   && safe_str_eq(ccm_state, XML_BOOLEAN_YES)
	   && safe_str_eq(crm_state, ONLINESTATUS)) {
		crm_devel("Node %s is online", uname);
		return TRUE;
	}
	crm_devel("Node %s: %s %s %s", uname, join_state, ccm_state, crm_state);
	crm_devel("Node %s is offline", uname);
	return FALSE;
}


int
do_find_resource_list(crm_data_t *xml_node)
{
	int found = 0;
	crm_data_t *rscs = get_object_root(XML_CIB_TAG_RESOURCES, xml_node);

	xml_child_iter(
		rscs, rsc, XML_CIB_TAG_RESOURCE,
		printf("%s resource: %s (%s)\n",
		       crm_element_value(rsc, "class"),
		       crm_element_value(rsc, XML_ATTR_ID),
		       crm_element_value(rsc, XML_ATTR_TYPE));

		found++;
		);
	if(found == 0) {
		printf("NO resources configured\n");
	}
					
	return found;
}

int
do_find_node_list(crm_data_t *xml_node)
{
	int found = 0;
	crm_data_t *nodes = get_object_root(XML_CIB_TAG_NODES, xml_node);

	xml_child_iter(
		nodes, node, XML_CIB_TAG_NODE,	
		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;
}


void
usage(const char *cmd, int exit_status)
{
	FILE *stream;

	stream = exit_status ? stderr : stdout;

	fprintf(stream, "usage: %s [-?vs] [command] [command args]\n", cmd);

	fprintf(stream, "Options\n");
	fprintf(stream, "\t--%s (-%c)\t: "
		"turn on debug info. additional instances increase verbosity\n",
		"verbose", 'V');
	fprintf(stream, "\t--%s (-%c)\t: be very very quiet\n", "silent", 's');
	fprintf(stream, "\t--%s (-%c)\t: this help message\n", "help", '?');
	fprintf(stream, "\nCommands\n");
	fprintf(stream, "\t--%s (-%c) <node>\t: "
		"increment the CRMd debug level on <node>\n", CRM_OP_DEBUG_UP,'i');
	fprintf(stream, "\t--%s (-%c) <node>\t: "
		"decrement the CRMd debug level on <node>\n", CRM_OP_DEBUG_DOWN,'d');
	fprintf(stream, "\t--%s (-%c) <node>\t: "
		"shutdown the CRMd on <node>\n", "kill", 'K');
	fprintf(stream, "\t--%s (-%c) <node>\t: "
		"request the status of <node>\n", "status", 'S');
	fprintf(stream, "\t--%s (-%c)\t\t: "
		"request the status of all nodes\n", "health", 'H');
	fprintf(stream, "\t--%s (-%c) <node>\t: "
		"initiate an election from <node>\n", "election", 'E');
	fprintf(stream, "\t--%s (-%c)\t: "
		"request the uname of the DC\n", "dc_lookup", 'D');
	fprintf(stream, "\t--%s (-%c)\t\t: "
		"request the uname of all member nodes\n", "nodes", 'N');
	fprintf(stream, "\t--%s (-%c)\t: "
		"request the names of all resources\n", "resources", 'R');
	fprintf(stream, "\t--%s (-%c) <rsc>\t: "
		"request the location of <rsc>\n", "whereis", 'W');
/*	fprintf(stream, "\t--%s (-%c)\t\n", "disconnect", 'D'); */
	fflush(stream);

	exit(exit_status);
}