nw_rpc100s.c

linux集群服务器软件代码包

/* $Id: nw_rpc100s.c,v 1.19 2005/02/18 07:32:09 zhaokai Exp $ */
/*
 *	Stonith module for Night/Ware RPC100S 
 *
 *      Original code from baytech.c by
 *	Copyright (c) 2000 Alan Robertson <[e-mail]>
 *
 *      Modifications for NW RPC100S
 *	Copyright (c) 2000 Computer Generation Incorporated
 *               Eric Z. Ayers <[e-mail]>
 *
 *      Mangled by Zhaokai <[e-mail]>, IBM, 2005
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#define	DEVICE	"NW RPC100S Power Switch"
#include "stonith_plugin_common.h"

#define PIL_PLUGIN              nw_rpc100s
#define PIL_PLUGIN_S            "nw_rpc100s"
#define PIL_PLUGINLICENSE 	LICENSE_LGPL
#define PIL_PLUGINLICENSEURL 	URL_LGPL
#define MAX_CFGLINE		256
#include <pils/plugin.h>

static StonithPlugin *	nw_rpc100s_new(void);
static void		nw_rpc100s_destroy(StonithPlugin *);
static int		nw_rpc100s_set_config(StonithPlugin *, StonithNVpair *);
static const char**	nw_rpc100s_get_confignames(StonithPlugin *);
static const char *	nw_rpc100s_getinfo(StonithPlugin * s, int InfoType);
static int		nw_rpc100s_status(StonithPlugin * );
static int		nw_rpc100s_reset_req(StonithPlugin * s, int request, const char * host);
static char **		nw_rpc100s_hostlist(StonithPlugin  *);

static struct stonith_ops nw_rpc100sOps ={
	nw_rpc100s_new,			/* Create new STONITH object		*/
	nw_rpc100s_destroy,		/* Destroy STONITH object		*/
	nw_rpc100s_getinfo,		/* Return STONITH info string		*/
	nw_rpc100s_get_confignames,	/* Return STONITH info string		*/
	nw_rpc100s_set_config,		/* Get configuration from NVpairs	*/
	nw_rpc100s_status,		/* Return STONITH device status		*/
	nw_rpc100s_reset_req,		/* Request a reset 			*/
	nw_rpc100s_hostlist,		/* Return list of supported hosts 	*/
};

PIL_PLUGIN_BOILERPLATE2("1.0", Debug)
static const PILPluginImports*  PluginImports;
static PILPlugin*               OurPlugin;
static PILInterface*		OurInterface;
static StonithImports*		OurImports;
static void*			interfprivate;

#include "stonith_signal.h"

#define DOESNT_USE_STONITHKILLCOMM
#define DOESNT_USE_STONITHSCANLINE
#include "stonith_expect_helpers.h"

PIL_rc
PIL_PLUGIN_INIT(PILPlugin*us, const PILPluginImports* imports);

PIL_rc
PIL_PLUGIN_INIT(PILPlugin*us, const PILPluginImports* imports)
{
	/* Force the compiler to do a little type checking */
	(void)(PILPluginInitFun)PIL_PLUGIN_INIT;

	PluginImports = imports;
	OurPlugin = us;

	/* Register ourself as a plugin */
	imports->register_plugin(us, &OurPIExports);  

	/*  Register our interface implementation */
 	return imports->register_interface(us, PIL_PLUGINTYPE_S
	,	PIL_PLUGIN_S
	,	&nw_rpc100sOps
	,	NULL		/*close */
	,	&OurInterface
	,	(void*)&OurImports
	,	&interfprivate); 
}

/*
   The Nightware RPS-100S is manufactured by:
   
      Micro Energetics Corp
      [phone]
      http://www.nightware.com/

   Thank you to David Hicks of Micro Energetics Corp. for providing
   a demo unit to write this software.
      
   This switch has a very simple protocol, 
   You issue a command and it  gives a response.
   Sample commands are conveniently documented on a sticker on the
      bottom of the device.
      
   The switch accepts a single command of the form

   //0,yyy,zzz[/m][/h]<CR>
   
     Where yyy is the wait time before activiting the relay.
           zzz is the relay time.

     The default is that the relay is in a default state of ON, which
     means that  usually yyy is the number of seconds to wait
     before shutting off the power  and zzz is the number of seconds the
     power remains off.  There is a dip switch to change the default
     state to 'OFF'.  Don't set this switch. It will screw up this code. 

     An asterisk can be used for zzz to specify an infinite switch time.
     The /m /and /h command options will convert the specified wait and
     switch times to either minutewes or hours. 
   
   A response is either
    <cr><lf>OK<cr><lf>
       or
    <cr><lf>Invalid Entry<cr><lf>


   As far as THIS software is concerned, we have to implement 4 commands:

   status     -->    //0,0,BOGUS; # Not a real command, this is just a
                                  #   probe to see if switch is alive
   open(on)   -->    //0,0,0;     # turn power to default state (on)
   close(off) -->    //0,0,*;     # leave power off indefinitely
   reboot     -->    //0,0,10;    # immediately turn power off for 10 seconds.

   and expect the response 'OK' to confirm that the unit is operational.
*/



struct pluginDevice {
	StonithPlugin   sp;
	const char *	pluginid;

	char *	idinfo;  /* ??? What's this for Alan ??? */
	char *	unitid;  /* ??? What's this for Alan ??? */

	int	fd;      /* FD open to the serial port */

	int	config;  /* 0 if not configured, 
				    1 if configured with nw_rpc100s_set_config_file() 
				    or nw_rpc100s_set_config_info()
				 */
	char *	device;  /* Serial device name to use to communicate 
                            to this RPS10
			 */

	char *  node;    /* Name of the node that this is controlling */

};

/* This string is used to identify this type of object in the config file */
static const char * pluginid = "NW_RPC100S";
static const char * NOTrpcid = "OBJECT DESTROYED: (NW RPC100S)";

#ifndef DEBUG
#define DEBUG 0
#endif
static int gbl_debug = DEBUG;

/*
 *	Different expect strings that we get from the NW_RPC100S
 *	Remote Power Controllers...
 */

static struct Etoken NWtokOK[] =	{ {"OK", 0, 0}, {NULL,0,0}};
static struct Etoken NWtokInvalidEntry[] = { {"Invalid Entry", 0, 0}, {NULL,0,0}};
/* Accept either a CR/NL or an NL/CR */
static struct Etoken NWtokCRNL[] =	{ {"\n\r",0,0},{"\r\n",0,0},{NULL,0,0}};

static int	RPCConnect(struct pluginDevice * ctx);
static int	RPCDisconnect(struct pluginDevice * ctx);

static int	RPCReset(struct pluginDevice*, int unitnum, const char * rebootid);
#if defined(ST_POWERON) 
static int	RPCOn(struct pluginDevice*, int unitnum, const char * rebootid);
#endif
#if defined(ST_POWEROFF) 
static int	RPCOff(struct pluginDevice*, int unitnum, const char * rebootid);
#endif
static int	RPCNametoOutlet ( struct pluginDevice * ctx, const char * host );

static int RPC_parse_config_info(struct pluginDevice* ctx, const char * info);


#define        SENDCMD(cmd, timeout)              {			\
		int return_val = RPCSendCommand(ctx, cmd, timeout);     \
		if (return_val != S_OK)  return return_val;		\
	}

/*
 * RPCSendCommand - send a command to the specified outlet
 */
static int
RPCSendCommand (struct pluginDevice *ctx, const char *command, int timeout)
{
	char            writebuf[64]; /* All commands are short.
					 They should be WAY LESS
					 than 64 chars long!
				      */
	int		return_val;  /* system call result */
	fd_set          rfds, wfds, xfds;
				     /*  list of FDs for select() */
	struct timeval 	tv;	     /*  */

	FD_ZERO(&rfds);
	FD_ZERO(&wfds);
	FD_ZERO(&xfds);

	snprintf (writebuf, sizeof(writebuf), "%s\r", command);

	if (gbl_debug) printf ("Sending %s\n", writebuf);

	/* Make sure the serial port won't block on us. use select()  */
	FD_SET(ctx->fd, &wfds);
	FD_SET(ctx->fd, &xfds);
	
	tv.tv_sec = timeout;
	tv.tv_usec = 0;
	
	return_val = select(ctx->fd+1, NULL, &wfds,&xfds, &tv);
	if (return_val == 0) {
		/* timeout waiting on serial port */
		LOG(PIL_CRIT, "%s: Timeout writing to %s",
			pluginid, ctx->device);
		return S_TIMEOUT;
	} else if ((return_val == -1) || FD_ISSET(ctx->fd, &xfds)) {
		/* an error occured */
		LOG(PIL_CRIT, "%s: Error before writing to %s: %s",
			pluginid, ctx->device, strerror(errno));		
		return S_OOPS;
	}

	/* send the command */
	if (write(ctx->fd, writebuf, strlen(writebuf)) != 
			(int)strlen(writebuf)) {
		LOG(PIL_CRIT, "%s: Error writing to  %s : %s",
			pluginid, ctx->device, strerror(errno));
		return S_OOPS;
	}

	/* suceeded! */
	return S_OK;

}  /* end RPCSendCommand() */

/* 
 * RPCReset - Reset (power-cycle) the given outlet number
 *
 * This device can only control one power outlet - unitnum is ignored.
 *
 */
static int
RPCReset(struct pluginDevice* ctx, int unitnum, const char * rebootid)
{

	if (gbl_debug) {
		printf ("Calling RPCReset (%s)\n", pluginid);
	}
	
	if (ctx->fd < 0) {
		LOG(PIL_CRIT, "%s: device %s is not open!", pluginid, 
		       ctx->device);
		return S_OOPS;
	}

	/* send the "toggle power" command */
	SENDCMD("//0,0,10;\r\n", 12);

	/* Expect "OK" */
	EXPECT(ctx->fd, NWtokOK, 5);
	if (gbl_debug) {
		printf ("Got OK\n");
	}
	EXPECT(ctx->fd, NWtokCRNL, 2);
	if (gbl_debug) {
		printf ("Got NL\n");
	}
	
	return(S_OK);

} /* end RPCReset() */


#if defined(ST_POWERON) 
/* 
 * RPCOn - Turn OFF the given outlet number 
 */
static int
RPCOn(struct pluginDevice* ctx, int unitnum, const char * host)
{

	if (ctx->fd < 0) {
		LOG(PIL_CRIT, "%s: device %s is not open!", pluginid, 
		       ctx->device);
		return S_OOPS;
	}

	/* send the "On" command */
	SENDCMD("//0,0,0;\r\n", 10);

	/* Expect "OK" */
	EXPECT(ctx->fd, NWtokOK, 5);
	EXPECT(ctx->fd, NWtokCRNL, 2);

	return(S_OK);

} /* end RPCOn() */
#endif


#if defined(ST_POWEROFF) 
/* 
 * RPCOff - Turn Off the given outlet number 
 */
static int
RPCOff(struct pluginDevice* ctx, int unitnum, const char * host)
{

	if (ctx->fd < 0) {
		LOG(PIL_CRIT, "%s: device %s is not open!", pluginid, 
		       ctx->device);
		return S_OOPS;
	}

	/* send the "Off" command */
	SENDCMD("//0,0,*;\r\n", 10);

	/* Expect "OK" */
	EXPECT(ctx->fd, NWtokOK, 5);
	EXPECT(ctx->fd, NWtokCRNL, 2);

	return(S_OK);

} /* end RPCOff() */
#endif


/*
 * nw_rpc100s_status - API entry point to probe the status of the stonith device 
 *           (basically just "is it reachable and functional?", not the
 *            status of the individual outlets)
 * 
 * Returns:
 *    S_OOPS - some error occured
 *    S_OK   - if the stonith device is reachable and online.
 */
static int
nw_rpc100s_status(StonithPlugin  *s)
{
	struct pluginDevice*	ctx;
	
	if (gbl_debug) {
		printf ("Calling nw_rpc100s_status (%s)\n", pluginid);
	}
	
	ERRIFNOTCONFIGED(s,S_OOPS);

	ctx = (struct pluginDevice*) s;
	if (RPCConnect(ctx) != S_OK) {
		return(S_OOPS);
	}

	/* The "connect" really does enough work to see if the 
	   controller is alive...  It verifies that it is returning 
	   RPS-10 Ready 
	*/

	return(RPCDisconnect(ctx));
}

/*
 * nw_rpc100s_hostlist - API entry point to return the list of hosts 
 *                 for the devices on this NW_RPC100S unit
 * 
 *               This type of device is configured from the config file,
 *                 so we don't actually have to connect to figure this
 *                 out, just peruse the 'ctx' structure.
 * Returns:
 *     NULL on error
 *     a malloced array, terminated with a NULL,
 *         of null-terminated malloc'ed strings.
 */
static char **
nw_rpc100s_hostlist(StonithPlugin  *s)
{
	char **		ret = NULL;	/* list to return */
	struct pluginDevice*	ctx;

	if (gbl_debug) {
		printf ("Calling nw_rpc100s_hostlist (%s)\n", pluginid);
	}
	
	ERRIFNOTCONFIGED(s,NULL);

	ctx = (struct pluginDevice*) s;

	ret = (char **)MALLOC(2*sizeof(char*));
	if (ret == NULL) {
		LOG(PIL_CRIT, "out of memory");
	} else {
		ret[1]=NULL;