clientlib.c

linux集群服务器软件代码包

			"lrm_get_rsc_provider_supported: can not send msg to lrmd");
		return NULL;
	}
	ha_msg_del(msg);
	/* get the return message */
	ret = msgfromIPC_noauth(ch_cmd);
	if (NULL == ret) {
		client_log(LOG_ERR,
			"lrm_get_rsc_provider_supported: can not recieve ret msg");
		return NULL;
	}
	/* get the rc of the message */
	if (HA_OK != get_rc_from_msg(ret)) {
		ha_msg_del(ret);
		client_log(LOG_ERR,
			"lrm_get_rsc_provider_supported: rc from msg is fail");
		return NULL;
	}
	/* get the ra provider list from message */
	provider_list = ha_msg_value_str_list(ret,F_LRM_RPROVIDERS);

	ha_msg_del(ret);
	client_log(LOG_INFO, "lrm_get_rsc_provider_supported: end.");

	return provider_list;
}
	
/*
 * lrm_get_all_type_metadatas():
 * For OCF RAs, they may have more than one providers so they may have more than
 * one metadata. The hash table is not suitable for this. Fix Me
 */
static GHashTable*
lrm_get_all_type_metadata (ll_lrm_t* lrm, const char* rclass)
{
	GHashTable* metas = g_hash_table_new(g_str_hash, g_str_equal);
	GList* types = lrm_get_rsc_type_supported (lrm, rclass);
	GList* node = NULL;
        const char* meta;

	client_log(LOG_INFO,"lrm_get_all_type_metadatas: start.");
	for (node = g_list_first(types); NULL!=node; node=g_list_next(node)) {
		meta = lrm_get_rsc_type_metadata(lrm,rclass,node->data,NULL);
		if (NULL == meta) {
			continue;
		}
		g_hash_table_insert(metas, node->data,strdup(meta));
	}
	g_list_free(types);
	
	client_log(LOG_INFO,"lrm_get_all_type_metadatas: end.");
	return metas;
}

static char*
lrm_get_rsc_type_metadata (ll_lrm_t* lrm, const char* rclass, const char* rtype,
				const char* provider)
{
	struct ha_msg* msg;
	struct ha_msg* ret;
	const char* tmp = NULL;
	char* metadata = NULL;
	size_t len;
	/* check whether the channel to lrmd is available */
	client_log(LOG_INFO, "lrm_get_rsc_type_metadata: start.");
	if (NULL == ch_cmd)
	{
		client_log(LOG_ERR,
			"lrm_get_rsc_type_metadata: ch_mod is null.");
		return NULL;
	}
	/* create the get ra type message */
	msg = create_lrm_msg(GETRSCMETA);
	if (NULL == msg ) {
		client_log(LOG_ERR,
			"lrm_get_rsc_type_metadata: can not create msg");
		return NULL;
	}
	
	if (HA_OK != ha_msg_add(msg, F_LRM_RCLASS, rclass)
	||  HA_OK != ha_msg_add(msg, F_LRM_RTYPE, rtype)){
		ha_msg_del(msg);
		client_log(LOG_ERR,
			"lrm_get_rsc_type_metadata: can not add fields");
		return NULL;
	}

	if( provider ) {
		if (HA_OK != ha_msg_add(msg, F_LRM_RPROVIDER, provider)) {
			client_log(LOG_ERR,
			"lrm_get_rsc_type_metadata: can not add provider");
			ha_msg_del(msg);
			return NULL;
		}
	}

	/* send the msg to lrmd */
	if (HA_OK != msg2ipcchan(msg,ch_cmd)) {
		ha_msg_del(msg);
		client_log(LOG_ERR,
			"lrm_get_rsc_type_supported: can not send msg to lrmd");
		return NULL;
	}
	ha_msg_del(msg);
	/* get the return message */
	ret = msgfromIPC_noauth(ch_cmd);
	if (NULL == ret) {
		client_log(LOG_ERR,
			"lrm_get_rsc_type_supported: can not recieve ret msg");
		return NULL;
	}
	/* get the rc of the message */
	if (HA_OK != get_rc_from_msg(ret)) {
		ha_msg_del(ret);
		client_log(LOG_ERR,
			"lrm_get_rsc_type_supported: rc from msg is fail");
		return NULL;
	}

	/* get the metadata from message */
	tmp = cl_get_binary(ret, F_LRM_METADATA, &len);
	if (NULL!=tmp) {
		metadata = g_strndup(tmp, len);
	}
	ha_msg_del(ret);

	client_log(LOG_INFO, "lrm_get_rsc_type_supported: end.");

	return metadata;
}

static GList*
lrm_get_all_rscs (ll_lrm_t* lrm)
{
	struct ha_msg* msg = NULL;
	struct ha_msg* ret = NULL;
	GList* rid_list = NULL;

	client_log(LOG_INFO, "lrm_get_all_rscs: start.");

	/* check whether the channel to lrmd is available */
	if (NULL == ch_cmd) {
		client_log(LOG_ERR, "lrm_get_all_rscs: ch_mod is null.");
		return NULL;
	}
	/* create the msg of get all resource */
	msg = create_lrm_msg(GETALLRCSES);
	if ( NULL == msg) {
		client_log(LOG_ERR,
			"lrm_get_all_rscs: can not create types msg");
		return NULL;
	}
	/* send the msg to lrmd */
	if (HA_OK != msg2ipcchan(msg,ch_cmd)) {
		ha_msg_del(msg);
		client_log(LOG_ERR,
			"lrm_get_all_rscs: can not send msg to lrmd");
		return NULL;
	}
	ha_msg_del(msg);
	/* get the return msg */
	ret = msgfromIPC_noauth(ch_cmd);
	if (NULL == ret) {
		client_log(LOG_ERR,
			"lrm_get_all_rscs: can not recieve ret msg");
		return NULL;
	}
	/* get the rc of msg */
	if (HA_OK != get_rc_from_msg(ret)) {
		ha_msg_del(ret);
		client_log(LOG_ERR,
			"lrm_get_all_rscs: rc from msg is fail");
		return NULL;
	}
	/* get the rsc_id list from msg */
	rid_list = ha_msg_value_str_list(ret,F_LRM_RID);

	ha_msg_del(ret);
	client_log(LOG_INFO, "lrm_get_all_rscs: end.");
	/* return the id list */
	return rid_list;

}

static lrm_rsc_t*
lrm_get_rsc (ll_lrm_t* lrm, const char* rsc_id)
{
	struct ha_msg* msg = NULL;
	struct ha_msg* ret = NULL;
	lrm_rsc_t* rsc     = NULL;

	client_log(LOG_INFO, "lrm_get_rsc: start.");

	/* check whether the rsc_id is available */
	if (RID_LEN <= strlen(rsc_id))	{
		client_log(LOG_ERR, "lrm_get_rsc: rsc_id is too long.");
		return NULL;
	}

	/* check whether the channel to lrmd is available */
	if (NULL == ch_cmd)	{
		client_log(LOG_ERR, "lrm_get_rsc: ch_mod is null.");
		return NULL;
	}
	/* create the msg of get resource */
	msg = create_lrm_rsc_msg(rsc_id, GETRSC);
	if ( NULL == msg) {
		client_log(LOG_ERR, "lrm_get_rsc: can not create types msg");
		return NULL;
	}
	/* send the msg to lrmd */
	if (HA_OK != msg2ipcchan(msg,ch_cmd)) {
		ha_msg_del(msg);
		client_log(LOG_ERR, "lrm_get_rsc: can not send msg to lrmd");
		return NULL;
	}
	ha_msg_del(msg);
	/* get the return msg from lrmd */
	ret = msgfromIPC_noauth(ch_cmd);
	if (NULL == ret) {
		client_log(LOG_ERR, "lrm_get_rsc: can not recieve ret msg");
		return NULL;
	}
	/* get the rc of return message */
	if (HA_OK != get_rc_from_msg(ret)) {
		ha_msg_del(ret);
		client_log(LOG_ERR, "lrm_get_rsc: rc from msg is fail");
		return NULL;
	}
	/* create a new resource structure */
	rsc = g_new(lrm_rsc_t, 1);

	/* fill the field of resource with the data from msg */
	rsc->id = g_strdup(ha_msg_value(ret, F_LRM_RID));
	rsc->type = g_strdup(ha_msg_value(ret, F_LRM_RTYPE));
	rsc->class = g_strdup(ha_msg_value(ret, F_LRM_RCLASS));
	rsc->provider = g_strdup(ha_msg_value(ret, F_LRM_RPROVIDER));
	rsc->params = ha_msg_value_str_table(ret,F_LRM_PARAM);

	rsc->ops = &rsc_ops_instance;
	ha_msg_del(ret);
	client_log(LOG_INFO, "lrm_get_rsc: end.");
	/* return the new resource */
	return rsc;
}

static int
lrm_add_rsc (ll_lrm_t* lrm, const char* rsc_id, const char* class
, 	     const char* type, const char* provider, GHashTable* parameter)
{
	struct ha_msg* msg;
	client_log(LOG_INFO, "lrm_add_rsc: start.");

	/* check whether the rsc_id is available */
	if (NULL == rsc_id || RID_LEN <= strlen(rsc_id))	{
		client_log(LOG_ERR, "lrm_add_rsc: parameter rsc_id wrong.");
		return HA_FAIL;
	}

	/* check whether the channel to lrmd is available */
	if (NULL == ch_cmd)	{
		client_log(LOG_ERR, "lrm_add_rsc: ch_mod is null.");
		return HA_FAIL;
	}

	/* create the message of add resource */
	msg = create_lrm_addrsc_msg(rsc_id, class, type, provider, parameter);
	if ( NULL == msg) {
		client_log(LOG_ERR, "lrm_add_rsc: can not create types msg");
		return HA_FAIL;
	}
	/* send to lrmd */
	if (HA_OK != msg2ipcchan(msg,ch_cmd)) {
		ha_msg_del(msg);
		client_log(LOG_ERR, "lrm_add_rsc: can not send msg to lrmd");
		return HA_FAIL;
	}
	ha_msg_del(msg);
	/* check the result */
	if (HA_OK != get_rc_from_ch(ch_cmd)) {
		client_log(LOG_ERR, "lrm_add_rsc: rc is fail");
		return HA_FAIL;
	}
	client_log(LOG_INFO, "lrm_add_rsc: end.");

	return HA_OK;
}

static int
lrm_delete_rsc (ll_lrm_t* lrm, const char* rsc_id)
{
	struct ha_msg* msg = NULL;

	client_log(LOG_INFO, "lrm_delete_rsc: start.");

	/* check whether the rsc_id is available */
	if (NULL == rsc_id || RID_LEN <= strlen(rsc_id))	{
		client_log(LOG_ERR, "lrm_delete_rsc: parameter rsc_id wrong.");
		return HA_FAIL;
	}


	/* check whether the channel to lrmd is available */
	if (NULL == ch_cmd)	{
		client_log(LOG_ERR, "lrm_delete_rsc: ch_mod is null.");
		return HA_FAIL;
	}

	/* create the msg of del resource */
	msg = create_lrm_rsc_msg(rsc_id, DELRSC);
	if ( NULL == msg) {
		client_log(LOG_ERR,
			"lrm_delete_rsc: can not create types msg");
		return HA_FAIL;
	}
	/* send the msg to lrmd */
	if (HA_OK != msg2ipcchan(msg,ch_cmd)) {
		ha_msg_del(msg);
		client_log(LOG_ERR,
			"lrm_delete_rsc: can not send msg to lrmd");
		return HA_FAIL;
	}
	ha_msg_del(msg);
	/* check the response of the msg */
	if (HA_OK != get_rc_from_ch(ch_cmd)) {
		client_log(LOG_ERR, "lrm_delete_rsc: rc from msg is fail");
		return HA_FAIL;
	}

	client_log(LOG_INFO, "lrm_delete_rsc: end.");

	return HA_OK;
}

static int
lrm_inputfd (ll_lrm_t* lrm)
{
	client_log(LOG_INFO, "lrm_inputfd: start.");

	if (NULL == ch_cbk) {
		client_log(LOG_ERR,
			"lrm_inputfd: callback channel is null.");
		return -1;
	}

	client_log(LOG_INFO, "lrm_inputfd: end.");
	return ch_cbk->ops->get_recv_select_fd(ch_cbk);
}

static gboolean
lrm_msgready (ll_lrm_t* lrm)
{
	client_log(LOG_INFO, "lrm_msgready: start.");
	if (NULL == ch_cbk) {
		client_log(LOG_ERR,
			"lrm_msgready: callback channel is null.");
		return FALSE;
	}
	client_log(LOG_INFO, "lrm_msgready: end.");
	return ch_cbk->ops->is_message_pending(ch_cbk);
}

static int
lrm_rcvmsg (ll_lrm_t* lrm, int blocking)
{
	struct ha_msg* msg = NULL;
	lrm_op_t* op = NULL;
	int msg_count = 0;

	client_log(LOG_INFO, "lrm_rcvmsg: start.");

	/* if it is not blocking mode and no message in the channel, return */
	if ((!lrm_msgready(lrm)) && (!blocking)) {
		client_log(LOG_INFO,
			"lrm_rcvmsg: no message and non-block.");
		return msg_count;
	}
	/* wait until message ready */
	if (!lrm_msgready(lrm)) {
		ch_cbk->ops->waitin(ch_cbk);
	}
	while (lrm_msgready(lrm)) {
		/* get the message */
		msg = msgfromIPC_noauth(ch_cbk);
		if (msg == NULL) {
			client_log(LOG_ERR,
				"lrm_rcvmsg: recieve a null msg.");
			return msg_count;
		}
		msg_count++;

		op = msg_to_op(msg);
		if (NULL!=op && NULL!=op_done_callback) {
			op->rsc = lrm_get_rsc( NULL, op->rsc_id );
			(*op_done_callback)(op);
		}
		ha_msg_del(msg);
	}
	client_log(LOG_INFO, "lrm_rcvmsg: end.");

	return msg_count;
}

/* following are the functions for rsc_ops */
static int
rsc_perform_op (lrm_rsc_t* rsc, lrm_op_t* op)
{
	int rc = 0;
	struct ha_msg* msg = NULL;

	client_log(LOG_INFO, "rsc_perform_op: start.");


	/* check whether the channel to lrmd is available */
	if (NULL == ch_cmd
	||  NULL == rsc
	||  NULL == rsc->id
	||  NULL == op
	||  NULL == op->op_type) {
		client_log(LOG_ERR,
			"rsc_perform_op: parameter wrong.");
		return HA_FAIL;
	}
	/* create the msg of perform op */
	op->rsc_id = rsc->id;
	msg = op_to_msg(op);
	if ( NULL == msg) {
		client_log(LOG_ERR, "rsc_perform_op: can not create msg");
		return HA_FAIL;
	}
	/* send it to lrmd */
	if (HA_OK != msg2ipcchan(msg,ch_cmd)) {
		ha_msg_del(msg);
		client_log(LOG_ERR,
			"rsc_perform_op: can not send msg to lrmd");
		return HA_FAIL;
	}
	ha_msg_del(msg);

	/* check return code, the return code is the call_id of the op */
	rc = get_rc_from_ch(ch_cmd);
	op->rsc_id = NULL;
	client_log(LOG_INFO, "rsc_perform_op: end.");
	return rc;
}

static int
rsc_cancel_op (lrm_rsc_t* rsc, int call_id)
{
	int rc;
	struct ha_msg* msg = NULL;

	client_log(LOG_INFO, "rsc_cancel_op: start.");
	/* check whether the channel to lrmd is available */
	if (NULL == ch_cmd)	{
		client_log(LOG_ERR, "rsc_cancel_op: ch_mod is null.");
		return HA_FAIL;
	}
	/* check parameter */
	if (NULL == rsc) {
		client_log(LOG_ERR, "rsc_cancel_op: rsc is null.");
		return HA_FAIL;
	}
	/* create the msg of flush ops */
	msg = create_lrm_rsc_msg(rsc->id,CANCELOP);
	if (NULL == msg) {
		client_log(LOG_ERR, "rsc_cancel_op: can not create msg");
		return HA_FAIL;