subsystems.c

在LINUX下实现HA的源代码

	size = strlen(options);
	size += strlen(centry->command);
	size += 2; /*  ' ' + \0 */
	
	cmd_with_options = cl_malloc((1+size)*sizeof(char));
	sprintf(cmd_with_options, "%s %s", centry->command, options);
	cmd_with_options[size] = 0;
	

	cl_log(LOG_INFO, "Executing \"%s\" (pid %d)",
	       cmd_with_options, (int) getpid());

	if(CL_SIGINTERRUPT(SIGALRM, 0) < 0) {
		cl_perror("Cannot set interrupt for child process %s",
			  cmd_with_options);
	}else{
		const char *	devnull = "/dev/null";
		unsigned int	j;
		struct rlimit		oflimits;
		CL_SIGNAL(SIGCHLD, SIG_DFL);
		alarm(0);
		CL_IGNORE_SIG(SIGALRM);

		/* A precautionary measure */
		getrlimit(RLIMIT_NOFILE, &oflimits);
		for (j=0; j < oflimits.rlim_cur; ++j) {
			close(j);
		}
		(void)devnull;
		
		(void)open(devnull, O_RDONLY);	/* Stdin:  fd 0 */
		(void)open(devnull, O_WRONLY);	/* Stdout: fd 1 */
		(void)open(devnull, O_WRONLY);	/* Stderr: fd 2 */

		(void)execl("/bin/sh", "sh", "-c", cmd_with_options, (const char *)NULL);

		/* Should not happen */
		cl_perror("Cannot exec %s", cmd_with_options);
	}
	/* Suppress respawning */
	exit(100);

	/*  never reached */
	return TRUE;
}


/*	 A_LRM_CONNECT	*/
enum crmd_fsa_input
do_lrm_control(long long action,
		enum crmd_fsa_cause cause,
		enum crmd_fsa_state cur_state,
		enum crmd_fsa_input current_input,
		void *data)
{
	enum crmd_fsa_input failed = I_NULL;/* I_FAIL; */
	int ret = HA_OK;
	FNIN();

	if(action & A_LRM_DISCONNECT) {
		fsa_lrm_conn->lrm_ops->signoff(fsa_lrm_conn);
	}

	if(action & A_LRM_CONNECT) {
	
		CRM_DEBUG("LRM: connect...");
		fsa_lrm_conn = ll_lrm_new("lrm");	
		if(NULL == fsa_lrm_conn) {
			return failed;
		}
		
		CRM_DEBUG("LRM: sigon...");
		ret = fsa_lrm_conn->lrm_ops->signon(fsa_lrm_conn,
						    "crmd");
		
		if(ret != HA_OK) {
			cl_log(LOG_ERR, "Failed to sign on to the LRM");
			return failed;
		}
		
		CRM_DEBUG("LRM: set_lrm_callback...");
		ret = fsa_lrm_conn->lrm_ops->set_lrm_callback(fsa_lrm_conn,
							      lrm_op_callback,
							      lrm_monitor_callback);
		
		if(ret != HA_OK) {
			cl_log(LOG_ERR, "Failed to set LRM callbacks");
			return failed;
		}

		/* TODO: create a destroy handler that causes
		 * some recovery to happen
		 */
		G_main_add_fd(G_PRIORITY_LOW,
			      fsa_lrm_conn->lrm_ops->inputfd(fsa_lrm_conn),
			      FALSE,
			      lrm_dispatch, fsa_lrm_conn,
			      default_ipc_input_destroy);
	}	

	if(action & ~(A_LRM_CONNECT|A_LRM_DISCONNECT)) {
		cl_log(LOG_ERR, "Unexpected action %s in %s",
		       fsa_action2string(action), __FUNCTION__);
	}
		
	
	FNRET(I_NULL);
}

gboolean lrm_dispatch(int fd, gpointer user_data)
{
	ll_lrm_t *lrm = (ll_lrm_t*)user_data;
	lrm->lrm_ops->rcvmsg(lrm, FALSE);
	return TRUE;
}

xmlNodePtr
do_lrm_query(void)
{
	GList* lrm_list = NULL;
	GList* element = NULL;
	GList* op_list = NULL;
	GList* node = NULL;
	xmlNodePtr rsc_list = NULL;
	xmlNodePtr data = create_xml_node(NULL, "lrm");
	xmlNodePtr agent_list = create_xml_node(data, "lrm_agents");
	state_flag_t cur_state = 0;
	const char *this_op = NULL;
		
	
	lrm_list = fsa_lrm_conn->lrm_ops->get_ra_supported(fsa_lrm_conn);
	if (NULL != lrm_list) {
		GList* element = g_list_first(lrm_list);
		while (NULL != element) {
			char *rsc_type = (char*)element->data;
			
			xmlNodePtr agent =
				create_xml_node(agent_list, "lrm_agent");
			
			set_xml_property_copy(agent, "class",   rsc_type);

			/* we dont have these yet */
			set_xml_property_copy(agent, "type",    NULL);
			set_xml_property_copy(agent, "version", NULL);
			
			element = g_list_next(element);
		}
	}
	
	g_list_free(lrm_list);
	lrm_list = fsa_lrm_conn->lrm_ops->get_all_rscs(fsa_lrm_conn);

	rsc_list = create_xml_node(data, "lrm_resources");

	if (NULL != lrm_list) {
		element = g_list_first(lrm_list);
	}
	
	while (NULL != element) {
		lrm_rsc_t *the_rsc = (lrm_rsc_t*)element->data;
		
/* 				const char*	ra_type; */
/* 				GHashTable* 	params; */
		
		xmlNodePtr xml_rsc = create_xml_node(rsc_list, "rsc_state");
		
		set_xml_property_copy(xml_rsc, "id",     the_rsc->id);
		set_xml_property_copy(xml_rsc, "rsc_id", the_rsc->name);
		set_xml_property_copy(xml_rsc, "node_id",fsa_our_uname);
		
		CRM_DEBUG("get_cur_state...");
		
		op_list = the_rsc->ops->get_cur_state(the_rsc,
							     &cur_state);
		CRM_DEBUG2("\tcurrent state:%s\n",
			   cur_state==LRM_RSC_IDLE?"Idel":"Busy");
		
		node = g_list_first(op_list);
		
		while(NULL != node){
			lrm_op_t* op = (lrm_op_t*)node->data;
			this_op = op->op_type;
			if(this_op == NULL
			   || strcmp(this_op, "status") != 0){
				
				const char *status_text = "<unknown>";
				switch(op->status) {
					case LRM_OP_DONE:
						status_text = "done";
						break;
					case LRM_OP_CANCELLED:
						status_text = "cancelled";
						break;
					case LRM_OP_TIMEOUT:
						status_text = "timeout";
						break;
					case LRM_OP_NOTSUPPORTED:
						status_text = "not suported";
						break;
					case LRM_OP_ERROR:
						status_text = "error";
						break;
				}
				
				
				set_xml_property_copy(xml_rsc,
						      "op_result",
						      status_text);
				
				set_xml_property_copy(xml_rsc,
						      "rsc_op",
						      this_op);
				
				/*  we only want the last one */
				break;
			}
			
			node = g_list_next(node);
		}
		
		element = g_list_next(element);
	}

	if (NULL != lrm_list) {
		g_list_free(lrm_list);
	}
	
	return data;
}


/*	 A_LRM_INVOKE	*/
enum crmd_fsa_input
do_lrm_invoke(long long action,
	     enum crmd_fsa_cause cause,
	     enum crmd_fsa_state cur_state,
	     enum crmd_fsa_input current_input,
	     void *data)
{
	enum crmd_fsa_input next_input = I_NULL;
	xmlNodePtr fragment, tmp1;
	xmlNodePtr msg = NULL;
	rsc_id_t rid;
	lrm_rsc_t *rsc = NULL;
	lrm_mon_t* mon = NULL;
	lrm_op_t* op = NULL;
	const char *operation = NULL;
	const char *id_from_cib = NULL;
	const char *crm_op = NULL;
	const char *rsc_path[] = 
		{
			"msg_data",
			"rsc_op",
			"resource",
			"instance_attributes",
			"parameters"
		};
		
	
	FNIN();


	if(action & A_UPDATE_NODESTATUS) {

		xmlNodePtr data = do_lrm_query();
		set_xml_property_copy(data, "replace_lrm", "true");

		tmp1 = create_xml_node(NULL, XML_CIB_TAG_STATE);
		set_xml_property_copy(tmp1, XML_ATTR_ID, fsa_our_uname);
		fragment = create_cib_fragment(tmp1, NULL);

		set_xml_property_copy(data, "replace_lrm", "true");
		add_node_copy(tmp1, data);

		send_request(NULL, fragment, CRM_OPERATION_UPDATE,
			     NULL, CRM_SYSTEM_DC);

		free_xml(fragment);
		free_xml(tmp1);
		free_xml(data);

		FNRET(next_input);
	}
	

	
	cl_log(LOG_ERR, "Action %s (%.16llx) not supported\n",
	       fsa_action2string(action), action);


	msg = (xmlNodePtr)data;
	operation = get_xml_attr_nested(msg,
						    rsc_path,
						    DIMOF(rsc_path) -3,
						    "operation", TRUE);

	id_from_cib = get_xml_attr_nested(msg,
						      rsc_path,
						      DIMOF(rsc_path) -2,
						      "id",
						      TRUE);
	/*  only the first 16 chars are used by the LRM */
	strncpy(rid, id_from_cib, 16);
	
	crm_op = get_xml_attr(msg, XML_TAG_OPTIONS, "operation", TRUE);

	rsc = fsa_lrm_conn->lrm_ops->get_rsc(
		fsa_lrm_conn, rid);
	
	if(crm_op != NULL && strcmp(crm_op, "lrm_query") == 0) {

		xmlNodePtr data, tmp1, tmp2, reply;

		tmp1 = create_xml_node(NULL, XML_CIB_TAG_STATE);
		set_xml_property_copy(tmp1, XML_ATTR_ID, fsa_our_uname);
		
		data = create_cib_fragment(tmp1, NULL);

		tmp2 = do_lrm_query();
		add_node_copy(tmp1, tmp2);

		reply = create_reply(msg, data);

		relay_message(reply, TRUE);

		free_xml(data);
		free_xml(reply);
		free_xml(tmp2);
		free_xml(tmp1);

	} else if(operation != NULL && strcmp(operation, "monitor") == 0) {
		if(rsc == NULL) {
			cl_log(LOG_ERR, "Could not find resource to monitor");
			FNRET(I_FAIL);
		}
		
		mon = g_new(lrm_mon_t, 1);
		mon->op_type = "status";
		mon->params = NULL;
		mon->timeout = 0;
		mon->user_data = rsc;
		mon->mode = LRM_MONITOR_SET;
		mon->interval = 2;
		mon->target = 1;
		rsc->ops->set_monitor(rsc,mon);
		mon = g_new(lrm_mon_t, 1);

	} else if(operation != NULL) {
		if(rsc == NULL) {
			/*  add it to the list */
			CRM_DEBUG("add_rsc...");
			fsa_lrm_conn->lrm_ops->add_rsc(
				fsa_lrm_conn, rid,
				get_xml_attr_nested(msg, 
						    rsc_path,
						    DIMOF(rsc_path) -2,
						    "class", TRUE),
				get_xml_attr_nested(msg, 
						    rsc_path,
						    DIMOF(rsc_path) -2,
						    "type", TRUE),
				NULL);
			
			rsc = fsa_lrm_conn->lrm_ops->get_rsc(
				fsa_lrm_conn, rid);
		}

		if(rsc == NULL) {
			cl_log(LOG_ERR, "Could not add resource to LRM");
			FNRET(I_FAIL);
		}
		
		/*  now do the op */
		CRM_DEBUG2("performing op %s...", operation);
		op = g_new(lrm_op_t, 1);
		op->op_type = operation;
		op->params = xml2list(msg, rsc_path, DIMOF(rsc_path));
		op->timeout = 0;
		op->user_data = rsc;
		rsc->ops->perform_op(rsc, op);
	}

	FNRET(next_input);
}

GHashTable *
xml2list(xmlNodePtr parent, const char**attr_path, int depth)
{
	xmlNodePtr node_iter = NULL;

	GHashTable   *nvpair_hash =
		g_hash_table_new(&g_str_hash, &g_str_equal);

	xmlNodePtr nvpair_list =
		find_xml_node_nested(parent, attr_path, depth);
	
	if(nvpair_list != NULL){
		node_iter = nvpair_list->children;
		while(node_iter != NULL) {
			
			const char *key = xmlGetProp(node_iter, "name");
			const char *value = xmlGetProp(node_iter, "value");
			
			CRM_DEBUG3("Added %s=%s", key, value);
			
			g_hash_table_insert (nvpair_hash,
					     cl_strdup(key),
					     cl_strdup(value));
			
			node_iter = node_iter->next;
		}
	}
	
	return nvpair_hash;
}


void
do_update_resource(lrm_rsc_t *rsc, int status, int rc, const char *op_type)
{
/*
<status>
    <nodes_status id=uname>
        <lrm>
	   <lrm_resources>
	       <lrm_resource id=>
	   </...>
*/
	xmlNodePtr update, iter;
	xmlNodePtr fragment, tmp1;
	char *tmp = NULL;
	
	update = create_xml_node(NULL, "node_state");
	set_xml_property_copy(update, XML_ATTR_ID, fsa_our_uname);
	iter = create_xml_node(update, "lrm");
	iter = create_xml_node(iter, "lrm_resources");
	iter = create_xml_node(iter, "lrm_resource");
	
	set_xml_property_copy(iter, XML_ATTR_ID, rsc->id);
	set_xml_property_copy(iter, "last_op", op_type);
	
	tmp = crm_itoa(status);
	set_xml_property_copy(iter, "op_status", tmp);
	cl_free(tmp);
	
	tmp = crm_itoa(rc);
	set_xml_property_copy(iter, "op_code", tmp);
	cl_free(tmp);

	
	
	tmp1 = create_xml_node(NULL, XML_CIB_TAG_STATE);
	set_xml_property_copy(tmp1, XML_ATTR_ID, fsa_our_uname);
	add_node_copy(tmp1, update);

	fragment = create_cib_fragment(tmp1, NULL);

	send_request(NULL, fragment, CRM_OPERATION_UPDATE,
		     NULL, CRM_SYSTEM_DCIB);

	free_xml(fragment);
	free_xml(update);
	free_xml(tmp1);
}

enum crmd_fsa_input
do_lrm_event(long long action,
	     enum crmd_fsa_cause cause,
	     enum crmd_fsa_state cur_state,
	     enum crmd_fsa_input cur_input,
	     void *data)
{
	FNIN();
	if(cause == C_LRM_MONITOR_CALLBACK) {
		lrm_mon_t* monitor = (lrm_mon_t*)data;
		lrm_rsc_t* rsc = monitor->rsc;
		

		switch(monitor->status) {
			case LRM_OP_DONE:
				CRM_DEBUG("An LRM monitor operation passed");
				FNRET(I_NULL);
				break;

			case LRM_OP_CANCELLED:
			case LRM_OP_TIMEOUT:
			case LRM_OP_NOTSUPPORTED:
			case LRM_OP_ERROR:
				cl_log(LOG_ERR,
				       "An LRM monitor operation failed"
				       " or was aborted");

				do_update_resource(rsc,
						   monitor->status,
						   monitor->rc,
						   monitor->op_type);
				break;
		}	

	} else if(cause == C_LRM_OP_CALLBACK) {
		lrm_op_t* op = (lrm_op_t*)data;
		lrm_rsc_t* rsc = op->rsc;

		switch(op->status) {
			case LRM_OP_CANCELLED:
			case LRM_OP_TIMEOUT:
			case LRM_OP_NOTSUPPORTED:
			case LRM_OP_ERROR:
				cl_log(LOG_ERR,
				       "An LRM operation failed"
				       " or was aborted");
				/*  keep going */
			case LRM_OP_DONE:

				do_update_resource(rsc,
						   op->status,
						   op->rc,
						   op->op_type);

				break;
		}
		
	} else {

		FNRET(I_FAIL);
	}
	
	FNRET(I_NULL);
}