client_lib.c

linux集群服务器软件代码包

	}
	ret = pi->nextif->value;

	pi->nextif = pi->nextif->next;
	return(ret);
}

/*
 * Clean up after a ifwalk (throw away interface list)
 */
static int
end_ifwalk(ll_cluster_t* ci)
{
	llc_private_t*	pi = ci->ll_cluster_private;
	ClearLog();
	if (!ISOURS(ci)) {
		ha_api_log(LOG_ERR, "end_ifwalk: bad cinfo");
		return HA_FAIL;
	}
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}
	zap_iflist(pi);
	return HA_OK;
}

/*
 * Return the input file descriptor associated with this object.
 */
static int
get_inputfd(ll_cluster_t* ci)
{
	llc_private_t* pi;
	ClearLog();
	if (!ISOURS(ci)) {
		ha_api_log(LOG_ERR, "get_inputfd: bad cinfo");
		return(-1);
	}
	pi = (llc_private_t*)ci->ll_cluster_private;
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return -1;
	}
	return pi->chan->ops->get_recv_select_fd(pi->chan);
}
/*
 * Return the IPC channel associated with this object.
 */
static IPC_Channel*
get_ipcchan(ll_cluster_t* ci)
{
	llc_private_t* pi;
	ClearLog();
	if (!ISOURS(ci)) {
		ha_api_log(LOG_ERR, "get_ipcchan: bad cinfo");
		return NULL;
	}
	pi = (llc_private_t*)ci->ll_cluster_private;
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return NULL;
	}
	return pi->chan;
}


/*
 * Return TRUE (1) if there is a message ready to read.
 */
static int

msgready(ll_cluster_t*ci )
{
	llc_private_t* pi;

	ClearLog();
	if (!ISOURS(ci)) {
		ha_api_log(LOG_ERR, "msgready: bad cinfo");
		return 0;
	}
	pi = (llc_private_t*)ci->ll_cluster_private;

	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return 0;
	}
	if (pi->firstQdmsg) {
		return 1;
	}

	return pi->chan->ops->is_message_pending(pi->chan);
}

/*
 * Set message filter mode
 */
static int
setfmode(ll_cluster_t* lcl, unsigned mode)
{
	unsigned	filtermask;
	llc_private_t* pi;

	ClearLog();
	if (!ISOURS(lcl)) {
		ha_api_log(LOG_ERR, "setfmode: bad cinfo");
		return HA_FAIL;
	}
	pi = (llc_private_t*)lcl->ll_cluster_private;
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}
	switch(mode) {

		case LLC_FILTER_DEFAULT:
			filtermask = DEFAULTREATMENT;
			break;
		case LLC_FILTER_PMODE:
			filtermask = (KEEPIT|DUPLICATE|DROPIT);
			break;
		case LLC_FILTER_ALLHB:
			filtermask = (KEEPIT|DUPLICATE|DROPIT|NOCHANGE);
			break;
		case LLC_FILTER_RAW:
			filtermask = ALLTREATMENTS;
			break;
		default:
			return(HA_FAIL);
	}
	return(hb_api_setfilter(lcl, filtermask));
	
}

/*
 * Send a message to the cluster.
 */

static int
sendclustermsg(ll_cluster_t* lcl, struct ha_msg* msg)
{
	llc_private_t* pi;
	ClearLog();
	if (!ISOURS(lcl)) {
		ha_api_log(LOG_ERR, "sendclustermsg: bad cinfo");
		return HA_FAIL;
	}

	pi = (llc_private_t*)lcl->ll_cluster_private;

	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}

	if (pi->iscasual) {
		ha_api_log(LOG_ERR, "sendclustermsg: casual client");
		return HA_FAIL;
	}

	return(msg2ipcchan(msg, pi->chan));
}

/*
 * Send a message to a specific node in the cluster.
 */
static int
sendnodemsg(ll_cluster_t* lcl, struct ha_msg* msg
,			const char * nodename)
{
	llc_private_t* pi;
	ClearLog();
	if (!ISOURS(lcl)) {
		ha_api_log(LOG_ERR, "sendnodemsg: bad cinfo");
		return HA_FAIL;
	}
	pi = (llc_private_t*)lcl->ll_cluster_private;
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}
	if (pi->iscasual) {
		ha_api_log(LOG_ERR, "sendnodemsg: casual client");
		return HA_FAIL;
	}
	if (*nodename == EOS) {
		ha_api_log(LOG_ERR, "sendnodemsg: bad nodename");
		return HA_FAIL;
	}
	if (ha_msg_mod(msg, F_TO, nodename) != HA_OK) {
		ha_api_log(LOG_ERR, "sendnodemsg: cannot set F_TO field");
		return(HA_FAIL);
	}
	return(msg2ipcchan(msg, pi->chan));
}

static int
sendnodemsg_byuuid(ll_cluster_t* lcl, struct ha_msg* msg,
		   uuid_t uuid)
{
	llc_private_t* pi;
	ClearLog();
	if (!ISOURS(lcl)) {
		ha_api_log(LOG_ERR, "sendnodemsg_byuuid: bad cinfo");
		return HA_FAIL;
	}
	pi = (llc_private_t*)lcl->ll_cluster_private;
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}
	if (pi->iscasual) {
		ha_api_log(LOG_ERR, "sendnodemsg_byuuid: casual client");
		return HA_FAIL;
	}
	if (!uuid){
		ha_api_log(LOG_ERR, "uuid is NULL");
		return HA_FAIL;
	}
	if (cl_msg_moduuid(msg, F_TOUUID, uuid) != HA_OK) {
		ha_api_log(LOG_ERR, "sendnodemsg_byuuid: "
			   "cannot set F_TOUUID field");
		return(HA_FAIL);
	}
	return(msg2ipcchan(msg, pi->chan));	
}


static int
get_uuid(llc_private_t* pi, const char* nodename, uuid_t uuid)
{
	struct ha_msg*		request;
	struct ha_msg*		reply;
	const char *		result;
	uuid_t			tmp;
	
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}

	if ((request = hb_api_boilerplate(API_GETUUID)) == NULL) {
		ha_api_log(LOG_ERR, "get_uuid: can't create msg");
		return HA_FAIL;
	}
	if (ha_msg_add(request, F_QUERYNAME, nodename) != HA_OK) {
		ha_api_log(LOG_ERR, "get_uuid: cannot add field");
		ZAPMSG(request);
		return HA_FAIL;
	}

	/* Send message */
	if (msg2ipcchan(request, pi->chan) != HA_OK) {
		ZAPMSG(request);
		ha_api_perror("Can't send message to IPC Channel");
		return HA_FAIL;
	}
	ZAPMSG(request);
	
	if ((reply=read_api_msg(pi)) != NULL
	    && 	(result = ha_msg_value(reply, F_APIRESULT)) != NULL
	    &&	(strcmp(result, API_OK) == 0)
	    &&	(cl_get_uuid(reply, F_QUERYUUID, tmp)) == HA_OK){
		
		uuid_copy(uuid, tmp);
		ZAPMSG(reply);
		
		return HA_OK;
		
	}
	
	if (reply != NULL) {
		ZAPMSG(reply);
	}
	
	return HA_FAIL;
}

static int
get_uuid_by_name(ll_cluster_t* ci, const char* nodename, uuid_t uuid)
{
	llc_private_t* pi;
	ClearLog();
	if (!ISOURS(ci)) {
		ha_api_log(LOG_ERR, "get_nodeID_from_name: bad cinfo");
		return HA_FAIL;
	}
	pi = (llc_private_t*)ci->ll_cluster_private;
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}	
	
	if(!uuid || !nodename){
		ha_api_log(LOG_ERR, "get_uuid_by_name: uuid or nodename is NULL");
		return HA_FAIL;
	}
	return get_uuid(pi, nodename, uuid);
}



static int
get_name(llc_private_t* pi, const uuid_t uuid, char* name, int maxnamlen)
{
	struct ha_msg*		request;
	struct ha_msg*		reply;
	const char *		result;
	const char *		tmp;
	
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}
	
	if ((request = hb_api_boilerplate(API_GETNAME)) == NULL) {
		ha_api_log(LOG_ERR, "get_name: can't create msg");
		return HA_FAIL;
	}
	if (ha_msg_adduuid(request, F_QUERYUUID, uuid) != HA_OK) {
		ha_api_log(LOG_ERR, "get_uuid: cannot add field");
		ZAPMSG(request);
		return HA_FAIL;
	}
	
	/* Send message */
	if (msg2ipcchan(request, pi->chan) != HA_OK) {
		ZAPMSG(request);
		ha_api_perror("Can't send message to IPC Channel");
		return HA_FAIL;
	}
	ZAPMSG(request);
	
	if ((reply=read_api_msg(pi)) != NULL
	    && 	(result = ha_msg_value(reply, F_APIRESULT)) != NULL
	    &&	(strcmp(result, API_OK) == 0)
	    &&	(tmp =  ha_msg_value(reply, F_QUERYNAME)) != NULL){
		
		strncpy(name, tmp, maxnamlen -1 );
		name[maxnamlen-1] = 0;
		ZAPMSG(reply);
		
		return HA_OK;		
	}
	
	if (reply != NULL) {
		ZAPMSG(reply);
	}
	
	return HA_FAIL;
}


static int
get_name_by_uuid(ll_cluster_t* ci, uuid_t uuid, 
		 char* nodename, size_t  maxnamlen){
	
	llc_private_t* pi;
	ClearLog();
	if (!ISOURS(ci)) {
		ha_api_log(LOG_ERR, "get_nodeID_from_name: bad cinfo");
		return HA_FAIL;
	}
	pi = (llc_private_t*)ci->ll_cluster_private;
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}	
	
	if(!uuid || !nodename || maxnamlen <= 0){
		ha_api_log(LOG_ERR, "get_name_by_uuid: bad paramter");
		return HA_FAIL;
	}
	return get_name(pi, uuid, nodename, maxnamlen);
}


/* Add order sequence number field */
STATIC  void
add_order_seq(llc_private_t* pi, struct ha_msg* msg)
{
        order_seq_t *	order_seq = &pi->order_seq_head;
        const char *	to_node;
        char		seq[32];

	to_node = ha_msg_value(msg, F_TO);
	if (to_node != NULL){
		for (order_seq = pi->order_seq_head.next; order_seq != NULL
		;	order_seq = order_seq->next){
			if (strcmp(order_seq->to_node, to_node) == 0)
				break;
		}
	}
	if (order_seq == NULL && to_node != NULL){
		order_seq = (order_seq_t *) ha_malloc(sizeof(order_seq_t));
		if (order_seq == NULL){
			ha_api_log(LOG_ERR
			,	"add_order_seq: order_seq_t malloc failed!");
			return;
            	}
		strncpy(order_seq->to_node, to_node, HOSTLENG);
		order_seq->seqno = 1;
		order_seq->next = pi->order_seq_head.next;
		pi->order_seq_head.next = order_seq;
        }
        sprintf(seq, "%lx", order_seq->seqno);
        order_seq->seqno++;
        ha_msg_mod(msg, F_ORDERSEQ, seq);
}

/*
 * Send an ordered message to the cluster.
 */

static int
send_ordered_clustermsg(ll_cluster_t* lcl, struct ha_msg* msg)
{
	llc_private_t* pi;
	ClearLog();
	if (!ISOURS(lcl)) {
		ha_api_log(LOG_ERR, "%s: bad cinfo", __FUNCTION__);
		return HA_FAIL;
	}

	pi = (llc_private_t*)lcl->ll_cluster_private;

	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}

	if (pi->iscasual) {
		ha_api_log(LOG_ERR, "%s: casual client", __FUNCTION__);
		return HA_FAIL;
	}

	add_order_seq(pi, msg);

	return(msg2ipcchan(msg, pi->chan));
}

static int
send_ordered_nodemsg(ll_cluster_t* lcl, struct ha_msg* msg
,			const char * nodename)
{
	llc_private_t* pi;
	ClearLog();
	if (!ISOURS(lcl)) {
		ha_api_log(LOG_ERR, "sendnodemsg: bad cinfo");
		return HA_FAIL;
	}
	pi = (llc_private_t*)lcl->ll_cluster_private;
	if (!pi->SignedOn) {
		ha_api_log(LOG_ERR, "not signed on");
		return HA_FAIL;
	}
	if (pi->iscasual) {
		ha_api_log(LOG_ERR, "sendnodemsg: casual client");
		return HA_FAIL;
	}
	if (*nodename == EOS) {
		ha_api_log(LOG_ERR, "sendnodemsg: bad nodename");
		return HA_FAIL;
	}
	if (ha_msg_mod(msg, F_TO, nodename) != HA_OK) {
		ha_api_log(LOG_ERR, "sendnodemsg: cannot set F_TO field");
		return(HA_FAIL);
	}
	add_order_seq(pi, msg);
	return(msg2ipcchan(msg, pi->chan));
}

static char	APILogBuf[MAXLINE] = "";
size_t		BufLen = 0;

static void
ClearLog(void)
{
        memset(APILogBuf, 0, sizeof(APILogBuf));
	APILogBuf[0] = EOS;
	BufLen = 1;
}

static const char *
APIError(ll_cluster_t* lcl)
{
	return(APILogBuf);
}

static void
ha_api_log(int priority, const char * fmt, ...)
{
	size_t	len;
        va_list ap;
        char buf[MAXLINE];
 
        va_start(ap, fmt);
        vsnprintf(buf, sizeof(buf), fmt, ap);
        va_end(ap);
	len = strlen(buf);

	if ((BufLen + len) >= sizeof(APILogBuf)) {
		ClearLog();
	}
		
	if (APILogBuf[0] != EOS && APILogBuf[BufLen-1] != '\n') {
		strncat(APILogBuf, "\n", sizeof(APILogBuf)-BufLen-1);
		BufLen++;
	}

	strncat(APILogBuf, buf, sizeof(APILogBuf)-BufLen-1);
	BufLen += len;
}

static void
ha_api_perror(const char * fmt, ...)
{
	const char *	err;

	va_list ap;
	char buf[MAXLINE];

	err = strerror(errno);
	va_start(ap, fmt);
	vsnprintf(buf, MAXLINE, fmt, ap);
	va_end(ap);

	ha_api_log(LOG_ERR, "%s: %s", buf, err);

}

/*
 *	Our vector of member functions...
 */
static struct llc_ops heartbeat_ops = {
	signon:			hb_api_signon,		
	signoff:		hb_api_signoff,		
	delete:			hb_api_delete,		
	set_msg_callback:	set_msg_callback,	
	set_nstatus_callback:	set_nstatus_callback,	
	set_ifstatus_callback:	set_ifstatus_callback,	
	set_cstatus_callback:	set_cstatus_callback,	
	init_nodewalk:		init_nodewalk,		
	nextnode:		nextnode,		
	end_nodewalk:		end_nodewalk,		
	node_status:		get_nodestatus,		
	node_type:		get_nodetype,		
	init_ifwalk:		init_ifwalk,		
	nextif:			nextif,			
	end_ifwalk:		end_ifwalk,		
	if_status:		get_ifstatus,		
	client_status:		get_clientstatus,	
	get_uuid_by_name:	get_uuid_by_name,
	get_name_by_uuid:	get_name_by_uuid,
	sendclustermsg:		sendclustermsg,		
	sendnodemsg:		sendnodemsg,		
	sendnodemsg_byuuid:	sendnodemsg_byuuid,	
	send_ordered_clustermsg:send_ordered_clustermsg,
	send_ordered_nodemsg:	send_ordered_nodemsg,	
	inputfd:		get_inputfd,		
	ipcchan:		get_ipcchan,		
	msgready:		msgready,		
	setmsgsignal:		hb_api_setsignal,	
	rcvmsg:			rcvmsg,			
	readmsg:		read_msg_w_callbacks,	
	setfmode:		setfmode,		
	get_parameter:		get_parameter,		
	get_deadtime:		get_deadtime,		
	get_keepalive:		get_keepalive,		
	get_mynodeid:		get_mynodeid,		
	get_logfacility:	get_logfacility,	
	get_resources:		get_resources,		
	errmsg:			APIError,		
};



/*
 * Create a new heartbeat API object
 */
static ll_cluster_t*
h