utils.c

linux集群服务器软件代码包

			break;
		case A_CIB_INVOKE:
			actionAsText = "A_CIB_INVOKE";
			break;
		case O_CIB_RESTART:
			actionAsText = "O_CIB_RESTART";
			break;
		case A_CIB_START:
			actionAsText = "A_CIB_START";
			break;
		case A_CIB_STOP:
			actionAsText = "A_CIB_STOP";
			break;
		case A_TE_INVOKE:
			actionAsText = "A_TE_INVOKE";
			break;
		case O_TE_RESTART:
			actionAsText = "O_TE_RESTART";
			break;
		case A_TE_START:
			actionAsText = "A_TE_START";
			break;
		case A_TE_STOP:
			actionAsText = "A_TE_STOP";
			break;
		case A_TE_CANCEL:
			actionAsText = "A_TE_CANCEL";
			break;
		case A_PE_INVOKE:
			actionAsText = "A_PE_INVOKE";
			break;
		case O_PE_RESTART:
			actionAsText = "O_PE_RESTART";
			break;
		case A_PE_START:
			actionAsText = "A_PE_START";
			break;
		case A_PE_STOP:
			actionAsText = "A_PE_STOP";
			break;
		case A_NODE_BLOCK:
			actionAsText = "A_NODE_BLOCK";
			break;
		case A_UPDATE_NODESTATUS:
			actionAsText = "A_UPDATE_NODESTATUS";
			break;
		case A_LOG:
			actionAsText = "A_LOG   ";
			break;
		case A_ERROR:
			actionAsText = "A_ERROR ";
			break;
		case A_WARN:
			actionAsText = "A_WARN  ";
			break;
	}

	if(actionAsText == NULL) {
		crm_err("Action %.16llx is unknown", action);
		actionAsText = "<UNKNOWN_ACTION>";
	}
	
	return actionAsText;
}

void
fsa_dump_actions(long long action, const char *text)
{
	int log_level = LOG_DEV;
	
	if(is_set(action, A_READCONFIG)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_READCONFIG) %s", A_READCONFIG, text);
	}
	if(is_set(action, A_STARTUP)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_STARTUP) %s", A_STARTUP, text);
	}
	if(is_set(action, A_STARTED)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_STARTED) %s", A_STARTED, text);
	}
	if(is_set(action, A_HA_CONNECT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CONNECT) %s", A_HA_CONNECT, text);
	}
	if(is_set(action, A_HA_DISCONNECT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DISCONNECT) %s",
			  A_HA_DISCONNECT, text);
	}
	if(is_set(action, A_LRM_CONNECT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_LRM_CONNECT) %s",
			  A_LRM_CONNECT, text);
	}
	if(is_set(action, A_LRM_EVENT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_LRM_EVENT) %s",
			  A_LRM_EVENT, text);
	}
	if(is_set(action, A_LRM_INVOKE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_LRM_INVOKE) %s",
			  A_LRM_INVOKE, text);
	}
	if(is_set(action, A_LRM_DISCONNECT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_LRM_DISCONNECT) %s",
			  A_LRM_DISCONNECT, text);
	}
	if(is_set(action, A_DC_TIMER_STOP)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_TIMER_STOP) %s",
			  A_DC_TIMER_STOP, text);
	}
	if(is_set(action, A_DC_TIMER_START)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_TIMER_START) %s",
			  A_DC_TIMER_START, text);
	}
	if(is_set(action, A_INTEGRATE_TIMER_START)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_INTEGRATE_TIMER_START) %s",
			  A_INTEGRATE_TIMER_START, text);
	}
	if(is_set(action, A_INTEGRATE_TIMER_STOP)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_INTEGRATE_TIMER_STOP) %s",
			  A_INTEGRATE_TIMER_STOP, text);
	}
	if(is_set(action, A_FINALIZE_TIMER_START)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_FINALIZE_TIMER_START) %s",
			  A_FINALIZE_TIMER_START, text);
	}
	if(is_set(action, A_FINALIZE_TIMER_STOP)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_FINALIZE_TIMER_STOP) %s",
			  A_FINALIZE_TIMER_STOP, text);
	}
	if(is_set(action, A_ELECTION_COUNT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_ELECTION_COUNT) %s",
			  A_ELECTION_COUNT, text);
	}
	if(is_set(action, A_ELECTION_VOTE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_ELECTION_VOTE) %s",
			  A_ELECTION_VOTE, text);
	}
	if(is_set(action, A_CL_JOIN_ANNOUNCE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CL_JOIN_ANNOUNCE) %s",
			  A_CL_JOIN_ANNOUNCE, text);
	}
	if(is_set(action, A_CL_JOIN_REQUEST)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CL_JOIN_REQUEST) %s",
			  A_CL_JOIN_REQUEST, text);
	}
	if(is_set(action, A_CL_JOIN_RESULT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CL_JOIN_RESULT) %s",
			  A_CL_JOIN_RESULT, text);
	}
	if(is_set(action, A_DC_JOIN_OFFER_ALL)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_JOIN_OFFER_ALL) %s",
			  A_DC_JOIN_OFFER_ALL, text);
	}
	if(is_set(action, A_DC_JOIN_OFFER_ONE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_JOIN_OFFER_ONE) %s",
			  A_DC_JOIN_OFFER_ONE, text);
	}
	if(is_set(action, A_DC_JOIN_PROCESS_REQ)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_JOIN_PROCESS_REQ) %s",
			  A_DC_JOIN_PROCESS_REQ, text);
	}
	if(is_set(action, A_DC_JOIN_PROCESS_ACK)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_JOIN_PROCESS_ACK) %s",
			  A_DC_JOIN_PROCESS_ACK, text);
	}
	if(is_set(action, A_DC_JOIN_FINALIZE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_JOIN_FINALIZE) %s",
			  A_DC_JOIN_FINALIZE, text);
	}
	if(is_set(action, A_MSG_PROCESS)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_MSG_PROCESS) %s",
			  A_MSG_PROCESS, text);
	}
	if(is_set(action, A_MSG_ROUTE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_MSG_ROUTE) %s",
			  A_MSG_ROUTE, text);
	}
	if(is_set(action, A_RECOVER)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_RECOVER) %s",
			  A_RECOVER, text);
	}
	if(is_set(action, A_DC_RELEASE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_RELEASE) %s",
			  A_DC_RELEASE, text);
	}
	if(is_set(action, A_DC_RELEASED)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_RELEASED) %s",
			  A_DC_RELEASED, text);
	}
	if(is_set(action, A_DC_TAKEOVER)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_DC_TAKEOVER) %s",
			  A_DC_TAKEOVER, text);
	}
	if(is_set(action, A_SHUTDOWN)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_SHUTDOWN) %s", A_SHUTDOWN, text);
	}
	if(is_set(action, A_SHUTDOWN_REQ)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_SHUTDOWN_REQ) %s",
			  A_SHUTDOWN_REQ, text);
	}
	if(is_set(action, A_STOP)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_STOP  ) %s", A_STOP  , text);
	}
	if(is_set(action, A_EXIT_0)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_EXIT_0) %s", A_EXIT_0, text);
	}
	if(is_set(action, A_EXIT_1)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_EXIT_1) %s", A_EXIT_1, text);
	}
	if(is_set(action, A_CCM_CONNECT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CCM_CONNECT) %s",
			  A_CCM_CONNECT, text);
	}
	if(is_set(action, A_CCM_DISCONNECT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CCM_DISCONNECT) %s",
			  A_CCM_DISCONNECT, text);
	}
	if(is_set(action, A_CCM_EVENT)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CCM_EVENT) %s",
			  A_CCM_EVENT, text);
	}
	if(is_set(action, A_CCM_UPDATE_CACHE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CCM_UPDATE_CACHE) %s",
			  A_CCM_UPDATE_CACHE, text);
	}
	if(is_set(action, A_CIB_BUMPGEN)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CIB_BUMPGEN) %s",
			  A_CIB_BUMPGEN, text);
	}
	if(is_set(action, A_CIB_INVOKE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CIB_INVOKE) %s",
			  A_CIB_INVOKE, text);
	}
	if(is_set(action, A_CIB_START)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CIB_START) %s",
			  A_CIB_START, text);
	}
	if(is_set(action, A_CIB_STOP)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_CIB_STOP) %s", A_CIB_STOP, text);
	}
	if(is_set(action, A_TE_INVOKE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_TE_INVOKE) %s", A_TE_INVOKE, text);
	}
	if(is_set(action, A_TE_START)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_TE_START) %s",
			  A_TE_START, text);
	}
	if(is_set(action, A_TE_STOP)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_TE_STOP) %s", A_TE_STOP, text);
	}
	if(is_set(action, A_TE_CANCEL)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_TE_CANCEL) %s",
			  A_TE_CANCEL, text);
	}
	if(is_set(action, A_PE_INVOKE)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_PE_INVOKE) %s",
			  A_PE_INVOKE, text);
	}
	if(is_set(action, A_PE_START)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_PE_START) %s", A_PE_START, text);
	}
	if(is_set(action, A_PE_STOP)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_PE_STOP) %s", A_PE_STOP, text);
	}
	if(is_set(action, A_NODE_BLOCK)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_NODE_BLOCK) %s",
			  A_NODE_BLOCK, text);
	}
	if(is_set(action, A_UPDATE_NODESTATUS)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_UPDATE_NODESTATUS) %s",
			  A_UPDATE_NODESTATUS, text);
	}
	if(is_set(action, A_LOG)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_LOG   ) %s", A_LOG, text);
	}
	if(is_set(action, A_ERROR)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_ERROR ) %s", A_ERROR, text);
	}
	if(is_set(action, A_WARN)) {
		do_crm_log(log_level, __FUNCTION__, NULL, 
			   "Action %.16llx (A_WARN  ) %s", A_WARN, text);
	}
}


void
create_node_entry(const char *uuid, const char *uname, const char *type)
{
	
	/* make sure a node entry exists for the new node
	 *
	 * this will add anyone except the first ever node in the cluster
	 *   since it will also be the DC which doesnt go through the
	 *   join process (with itself).  We can include a special case
	 *   later if desired.
	 */
	crm_data_t *tmp1 = create_xml_node(NULL, XML_CIB_TAG_NODE);

	crm_devel("Creating node entry for %s", uname);
	set_uuid(fsa_cluster_conn, tmp1, XML_ATTR_UUID, uname);
	
	set_xml_property_copy(tmp1, XML_ATTR_UNAME, uname);
	set_xml_property_copy(tmp1, XML_ATTR_TYPE, type);
	
	update_local_cib(create_cib_fragment(tmp1, NULL));
	free_xml(tmp1);
	
}




struct crmd_ccm_data_s *
copy_ccm_data(const struct crmd_ccm_data_s *ccm_input) 
{
	const oc_ev_membership_t *oc_in =
		(const oc_ev_membership_t *)ccm_input->oc;
	struct crmd_ccm_data_s *ccm_input_copy = NULL;

	crm_malloc(ccm_input_copy, sizeof(struct crmd_ccm_data_s));

	ccm_input_copy->oc = copy_ccm_oc_data(oc_in);
	ccm_input_copy->event = ccm_input->event;
	
	return ccm_input_copy;
}

oc_ev_membership_t *
copy_ccm_oc_data(const oc_ev_membership_t *oc_in) 
{
	int lpc = 0;
	int size = 0;
	int offset = 0;
	int num_nodes = 0;
	oc_ev_membership_t *oc_copy = NULL;

	if(oc_in->m_n_member > 0
	   && num_nodes < oc_in->m_n_member + oc_in->m_memb_idx) {
		num_nodes = oc_in->m_n_member + oc_in->m_memb_idx;
		crm_devel("Updated ccm nodes to %d - 1", num_nodes);
	}
	if(oc_in->m_n_in > 0
	   && num_nodes < oc_in->m_n_in + oc_in->m_in_idx) {
		num_nodes = oc_in->m_n_in + oc_in->m_in_idx;
		crm_devel("Updated ccm nodes to %d - 2", num_nodes);
	}
	if(oc_in->m_n_out > 0
	   && num_nodes < oc_in->m_n_out + oc_in->m_out_idx) {
		num_nodes = oc_in->m_n_out + oc_in->m_out_idx;
		crm_devel("Updated ccm nodes to %d - 3", num_nodes);
	}

	/* why 2*??
	 * ccm code does it like this so i guess its right...
	 */
	size = sizeof(oc_ev_membership_t)
		+ sizeof(int)
		+ 2*num_nodes*sizeof(oc_node_t);

	crm_devel("Copying %d ccm nodes", num_nodes);
	
	crm_malloc(oc_copy, size);

	oc_copy->m_instance = oc_in->m_instance;
	oc_copy->m_n_member = oc_in->m_n_member;
	oc_copy->m_memb_idx = oc_in->m_memb_idx;
	oc_copy->m_n_out    = oc_in->m_n_out;
	oc_copy->m_out_idx  = oc_in->m_out_idx;
	oc_copy->m_n_in     = oc_in->m_n_in;
	oc_copy->m_in_idx   = oc_in->m_in_idx;

	crm_devel("instance=%d, nodes=%d (idx=%d), new=%d (idx=%d), lost=%d (idx=%d)",
		  oc_in->m_instance,
		  oc_in->m_n_member,
		  oc_in->m_memb_idx,
		  oc_in->m_n_in,
		  oc_in->m_in_idx,
		  oc_in->m_n_out,
		  oc_in->m_out_idx);

	offset = oc_in->m_memb_idx;
	for(lpc = 0; lpc < oc_in->m_n_member; lpc++) {
		oc_node_t a_node      = oc_in->m_array[lpc+offset];
		oc_node_t *a_node_copy = &(oc_copy->m_array[lpc+offset]);
		crm_devel("Copying ccm member node %d", lpc);
		copy_ccm_node(a_node, a_node_copy);
		
	}

	offset = oc_in->m_in_idx;
	for(lpc = 0; lpc < oc_in->m_n_in; lpc++) {
		oc_node_t a_node      = oc_in->m_array[lpc+offset];
		oc_node_t *a_node_copy = &(oc_copy->m_array[lpc+offset]);
		crm_devel("Copying ccm new node %d", lpc);
		copy_ccm_node(a_node, a_node_copy);
		
	}

	offset = oc_in->m_out_idx;
	for(lpc = 0; lpc < oc_in->m_n_out; lpc++) {
		oc_node_t a_node      = oc_in->m_array[lpc+offset];
		oc_node_t *a_node_copy = &(oc_copy->m_array[lpc+offset]);
		crm_devel("Copying ccm lost node %d", lpc);
		copy_ccm_node(a_node, a_node_copy);
	}
	
	return oc_copy;
}


void
copy_ccm_node(oc_node_t a_node, oc_node_t *a_node_copy)
{
	crm_devel("Copying ccm node: id=%d, born=%d, uname=%s",
		  a_node.node_id, a_node.node_born_on,
		  a_node.node_uname);
	
	a_node_copy->node_id      = a_node.node_id;
	a_node_copy->node_born_on = a_node.node_born_on;	
	a_node_copy->node_uname   = NULL;
	
	if(a_node.node_uname != NULL) {
			a_node_copy->node_uname =
				crm_strdup(a_node.node_uname);
	} else {
		crm_err("Node Id %d had a NULL uname!",
			a_node.node_id);
	}
	
	crm_devel("Copied ccm node: id=%d, born=%d, uname=%s",
		  a_node_copy->node_id, a_node_copy->node_born_on,
		  a_node_copy->node_uname);
}


lrm_op_t *
copy_lrm_op(const lrm_op_t *op)
{
	lrm_op_t *op_copy = NULL;
	crm_malloc(op_copy, sizeof(lrm_op_t));

	op_copy->op_type = crm_strdup(op->op_type);
 	/* input fields */
/* 	GHashTable*		params; */
	op_copy->params    = NULL;
	op_copy->timeout   = op->timeout;
	op_copy->interval  = op->interval; 
	op_copy->target_rc = op->target_rc; 

	/* in the CRM, this is always an int */
	if(op->user_data != NULL) {
		op_copy->user_data = crm_strdup(op->user_data); 
	}
	
	/* output fields */
	op_copy->op_status = op->op_status; 
	op_copy->rc        = op->rc; 
	op_copy->call_id   = op->call_id; 
	op_copy->output    = NULL;
	if(op->output!= NULL) {
		op_copy->output    = crm_strdup(op->output);
	}
	op_copy->rsc_id    = crm_strdup(op->rsc_id);
	op_copy->app_name  = crm_strdup(op->app_name);

	/*please notice the client needs release the memory of rsc.*/
	CRM_DEV_ASSERT(op->rsc != NULL);
	op_copy->rsc = copy_lrm_rsc(op->rsc);
	if(op_copy->rsc == NULL) {
		crm_err("Op callback for %s did not contain a resource",
			crm_str(op_copy->rsc_id));
	} else {
		crm_devel("Copied op callback for %s",crm_str(op_copy->rsc_id));
	}
	

	return op_copy;
}


lrm_rsc_t *
copy_lrm_rsc(const lrm_rsc_t *rsc)
{
	lrm_rsc_t *rsc_copy = NULL;

	if(rsc == NULL) {
		return NULL;
	}
	
	crm_malloc(rsc_copy, sizeof(lrm_rsc_t));

	rsc_copy->id       = crm_strdup(rsc->id);
	rsc_copy->type     = crm_strdup(rsc->type);
	rsc_copy->class    = NULL;
	rsc_copy->provider = NULL;

	if(rsc->class != NULL) {
		rsc_copy->class    = crm_strdup(rsc->class);
	}
	if(rsc->provider != NULL) {
		rsc_copy->provider = crm_strdup(rsc->provider);
	}
/* 	GHashTable* 	params; */
	rsc_copy->params = NULL;
	rsc_copy->ops    = NULL;

	return rsc_copy;
}


crm_data_t*
create_node_state(const char *uuid,
		  const char *uname,
		  const char *ha_state,
		  const char *ccm_state,
		  const char *crmd_state,
		  const char *join_state,
		  const char *exp_state)
{
	crm_data_t *node_state = create_xml_node(NULL, XML_CIB_TAG_STATE);

	crm_devel("Creating node state entry for %s", uname);
	set_uuid(fsa_cluster_conn, node_state, XML_ATTR_UUID, uname);
	set_xml_property_copy(node_state, XML_ATTR_UNAME, uname);

	set_xml_property_copy(
		node_state, XML_CIB_ATTR_HASTATE, ha_state);

	set_xml_property_copy(
		node_state, XML_CIB_ATTR_INCCM, ccm_state);

	set_xml_property_copy(
		node_state, XML_CIB_ATTR_CRMDSTATE, crmd_state);

	set_xml_property_copy(
		node_state, XML_CIB_ATTR_JOINSTATE, join_state);
	
	set_xml_property_copy(
		node_state, XML_CIB_ATTR_EXPSTATE, exp_state);

	crm_xml_devel(node_state, "created");

	return node_state;
}