/* -*- linux-c -*-
*
* Copyright (C) Copyright Nokia Siemens Networks 2010
* (C) Copyright Ulrich Kleber 2011
*
* This program 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. This
* file and program are licensed under a BSD style license. See
* the Copying file included with the OpenHPI distribution for
* full licensing terms.
*
* Authors:
* Ulrich Kleber <ulikleber@users.sourceforge.net>
*
* Log:
* Start from hpidomain.c
* This routine controls the handlers loaded by OpenHPI daemons
* using the OpenHPI extensions as described in ohpi.c
*
* Changes:
* 03/02/2011 ulikleber Refactoring to use glib for option parsing and
* introduce common options for all clients
*
*/
#include "oh_clients.h"
#define OH_SVN_REV "$Revision: 7133 $"
#define OHHANDLER_HELP \
"Command list \n" \
" List the handlers loaded in specified domain \n\n" \
"Command info <handler-id> \n" \
" Display info about handler <handler-id> \n\n" \
"Command destroy <handler-id> \n" \
" Unload handler <handler-id> and delete its config \n\n" \
"Command getnext <handler-id> \n" \
" Find next valid handler id from <handler-id> \n\n" \
"Command find <resource-id> \n" \
" Find the right handler for a resource id \n\n" \
"Command retry <handler-id> \n" \
" Retry loading of handler <handler-id> \n\n" \
"Command create plugin <name> <params> \n" \
" Create handler with the specified parameters. \n" \
" Pairs of strings in commandline like in openhpi.conf. \n" \
" Keyword plugin to select type of handler. \n" \
" Entity root and other complex strings must be \n" \
" enclosed in \". \n" \
" Example: \n" \
" ohhandler create plugin libsimulator " \
"entity_root \"{SYSTEM_CHASSIS,1}\" name sim\n"
/********************************************/
/* Function prototypes */
/********************************************/
static SaErrorT exechandlercreate(int, char **, int);
static SaErrorT exechandlerdestroy(oHpiHandlerIdT);
static SaErrorT exechandlerinfo(oHpiHandlerIdT);
static SaErrorT exechandlergetnext(oHpiHandlerIdT);
static SaErrorT exechandlerfind(SaHpiResourceIdT);
static SaErrorT exechandlerretry(oHpiHandlerIdT);
static SaErrorT exechandlerlist(void);
/********************************************/
/* Globals */
/********************************************/
static oHpiCommonOptionsT copt;
SaHpiSessionIdT sessionid;
/********************************************/
/* Main */
/********************************************/
int
main(int argc, char **argv)
{
SaErrorT rv = SA_OK;
oHpiHandlerIdT handlerid = 0;
SaHpiResourceIdT resid = 0;
SaHpiBoolT printusage = FALSE;
int i=1;
GOptionContext *context;
enum cmdT {eUndefined,
eHandlerCreate,
eHandlerDestroy,
eHandlerInfo,
eHandlerGetNext,
eHandlerFind,
eHandlerRetry,
eHandlerList} cmd=eUndefined;
/* Print version strings */
oh_prog_version(argv[0]);
/* Parsing options */
static char usetext[]="command [specific arguments] - "
"Control openhpi plugin instances (handlers).\n "
OH_SVN_REV "\n\n" OHHANDLER_HELP ;
OHC_PREPARE_REVISION(usetext);
context = g_option_context_new (usetext);
if (!ohc_option_parse(&argc, argv,
context, &copt,
OHC_ALL_OPTIONS
- OHC_ENTITY_PATH_OPTION // not applicable
- OHC_VERBOSE_OPTION )) { // no verbose mode
printusage = TRUE;
}
g_option_context_free (context);
/* Parse ohparam specific commands */
while (i<argc && !printusage && cmd!=eHandlerCreate) {
if (strcmp(argv[i],"create")==0) {
cmd=eHandlerCreate;
// exechandlercreate will do the remaining reading of
// parameters itself
rv = exechandlercreate (argc, argv, ++i);
if (rv == SA_OK) return 0;
if (rv != SA_ERR_HPI_INVALID_PARAMS) return 1;
printusage = TRUE;
}
else if (strcmp(argv[i],"destroy")==0) {
cmd=eHandlerDestroy;
if (++i<argc) handlerid = atoi(argv[i]);
else printusage = TRUE;
}
else if (strcmp(argv[i],"info")==0) {
cmd=eHandlerInfo;
if (++i<argc) handlerid = atoi(argv[i]);
else printusage = TRUE;
}
else if (strcmp(argv[i],"getnext")==0) {
cmd=eHandlerGetNext;
if (++i<argc) handlerid = atoi(argv[i]);
else printusage = TRUE;
}
else if (strcmp(argv[i],"find")==0) {
cmd=eHandlerFind;
if (++i<argc) resid = atoi(argv[i]);
else printusage = TRUE;
}
else if (strcmp(argv[i],"retry")==0) {
cmd=eHandlerRetry;
if (++i<argc) handlerid = atoi(argv[i]);
else printusage = TRUE;
}
else if (strcmp(argv[i],"list")==0) {
cmd=eHandlerList;
if (++i<argc) printusage = TRUE;
}
else printusage = TRUE;
i++;
}
if (cmd == eHandlerCreate) {
rv = exechandlercreate (argc, argv, i);
if (rv == SA_OK) return 0;
if (rv == SA_ERR_HPI_INVALID_PARAMS)
printusage = TRUE;
else return 1;
}
if (printusage == TRUE || cmd == eUndefined)
{
printf("\n");
printf("Usage: %s [Option...] command [specific arguments]\n\n",
argv[0]);
printf(OHHANDLER_HELP"\n");
printf(" Options: \n");
printf(" -h, --help Show help options \n");
printf(" -D, --domain=nn Select domain id nn \n");
printf(" -X, --debug Display debug messages \n");
printf(" -N, --host=\"host<:port>\" Open session to the domain served by the daemon \n");
printf(" at the specified URL (host:port) \n");
printf(" This option overrides the OPENHPI_DAEMON_HOST and \n");
printf(" OPENHPI_DAEMON_PORT environment variables. \n");
printf(" -C, --cfgfile=\"file\" Use passed file as client configuration file \n");
printf(" This option overrides the OPENHPICLIENT_CONF \n");
printf(" environment variable. \n\n");
return 1;
}
rv = ohc_session_open_by_option ( &copt, &sessionid);
if (rv != SA_OK) return rv;
switch (cmd){
case eHandlerCreate: break; //already done
case eHandlerDestroy:
rv = exechandlerdestroy ( handlerid );
break;
case eHandlerInfo:
rv = exechandlerinfo ( handlerid );
break;
case eHandlerGetNext:
rv = exechandlergetnext ( handlerid );
break;
case eHandlerFind:
rv = exechandlerfind ( resid );
break;
case eHandlerRetry:
rv = exechandlerretry ( handlerid );
break;
case eHandlerList:
rv = exechandlerlist ( );
break;
case eUndefined: break; //already done
}
if (copt.debug) {
DBG("Internal processing returns %s", oh_lookup_error(rv));
DBG("Calling saHpiSessionClose for session %u",sessionid);
}
rv = saHpiSessionClose(sessionid);
if (copt.debug) {
DBG("saHpiSessionClose returns %s", oh_lookup_error(rv));
}
return 0;
}
/********************************************/
/* exechandlercreate */
/********************************************/
static SaErrorT exechandlercreate (int argc, char **argv, int i)
{
SaErrorT rv = SA_OK;
oHpiHandlerIdT handlerid = 0;
GHashTable * createparams = g_hash_table_new_full (
g_str_hash, g_str_equal, g_free, g_free);
SaHpiBoolT pluginnamegiven = SAHPI_FALSE;
if (copt.debug) DBG ("createhandler started\n");
while (i<argc){
if (strcmp(argv[i],"-f")==0) {
CRIT("input from file not implemented yet");
return (SA_OK);
}
else if (++i<argc) {
if (strcmp(argv[i-1],"plugin")==0) pluginnamegiven = SAHPI_TRUE;
g_hash_table_insert( createparams,
g_strdup( argv[i-1] ),
g_strdup( argv[i] ));
if (copt.debug) DBG ("Pair of arguments: %s - %s\n",
g_strdup( argv[i-1] ),
g_strdup( argv[i] ));
}
else // parameters not in pairs
return (SA_ERR_HPI_INVALID_PARAMS);
i++;
}
if (!pluginnamegiven) {
CRIT("You must enter a valid plugin name");
return (SA_ERR_HPI_INVALID_PARAMS);
}
rv = ohc_session_open_by_option ( &copt, &sessionid);
if (rv != SA_OK) return rv;
if (copt.debug) DBG("Calling oHpiHandlerCreate!");
rv = oHpiHandlerCreate(sessionid, createparams, &handlerid );
if ( rv != SA_OK ) {
CRIT("oHpiHandlerCreate returned %s", oh_lookup_error(rv));
saHpiSessionClose(sessionid);
return(rv);
}
printf("Handler %u successfully created!\n", handlerid);
rv = saHpiSessionClose(sessionid);
return(SA_OK);
}
/********************************************/
/* exechandlerdestroy */
/********************************************/
static SaErrorT exechandlerdestroy(oHpiHandlerIdT handlerid)
{
SaErrorT rv = SA_OK;
if (copt.debug) DBG("Go and unload handler %u in domain %u",
handlerid, copt.domainid);
rv = oHpiHandlerDestroy ( sessionid, handlerid );
if (copt.debug) DBG("oHpiHandlerDestroy returned %s", oh_lookup_error(rv));
if (rv==SA_OK) {
printf("Handler %u successfully unloaded.\n\n", handlerid);
return rv;
}
else if (rv==SA_ERR_HPI_NOT_PRESENT) {
if (copt.domainid==SAHPI_UNSPECIFIED_DOMAIN_ID)
CRIT("Handler %u is not existing in default domain.",
handlerid);
else CRIT("Handler %u is not existing in domain %u.",
handlerid, copt.domainid);
return rv;
}
else CRIT("\nHandler %u couldn't be unloaded, Returncode %s",
handlerid, oh_lookup_error(rv));
return rv;
}
/********************************************/
/* exechandlerinfo */
/********************************************/
// function to print from hash table
static void print_pair (gpointer key, gpointer value, gpointer user_data)
{
// we already printed the pluginname and entity-root
if (strcmp((gchar *)key, "plugin")==0) return;
if (strcmp((gchar *)key, "entity_root")==0) return;
printf (" %s %s\n", (gchar *)key, (gchar *)value);
}
static
SaErrorT exechandlerinfo(oHpiHandlerIdT handlerid)
{
oHpiHandlerInfoT handlerinfo;
SaErrorT rv = SA_OK;
GHashTable *handlerconfig = g_hash_table_new_full(
g_str_hash, g_str_equal,
g_free, g_free );
if (copt.debug) DBG("Go and display handler info for %u", handlerid);
rv = oHpiHandlerInfo ( sessionid, handlerid, &handlerinfo, handlerconfig );
if (rv==SA_ERR_HPI_NOT_PRESENT) {
if (copt.domainid==SAHPI_UNSPECIFIED_DOMAIN_ID)
CRIT("Handler %u is not existing in default domain.",
handlerid);
else CRIT("Handler %u is not existing in domain %u.",
handlerid, copt.domainid);
g_hash_table_destroy(handlerconfig);
return SA_OK;
}
else if (rv!=SA_OK) {
CRIT("oHpiHandlerInfo returned %s", oh_lookup_error(rv));
g_hash_table_destroy(handlerconfig);
return rv;
}
if (copt.domainid==SAHPI_UNSPECIFIED_DOMAIN_ID)
printf("\n\nInfo for handler %u in default domain:\n\n",handlerid);
else printf("\n\nInfo for handler %u in domain %u:\n\n",handlerid, copt.domainid);
printf("Plugin name: %s\n",(const char *)handlerinfo.plugin_name);
printf("Root ");
oh_print_ep (&(handlerinfo.entity_root),0);
printf("Failed attempts to load handler: %u\n",handlerinfo.load_failed);
printf("\nHandler configuration:\n");
printf (" plugin %s\n", (const char *)handlerinfo.plugin_name);
printf (" entity_root \"%s\"\n",(const char *) g_hash_table_lookup(handlerconfig, "entity_root"));
g_hash_table_foreach(handlerconfig, print_pair, NULL);
printf("\n\n");
g_hash_table_destroy(handlerconfig);
return rv;
}
/********************************************/
/* exechandlergetnext */
/********************************************/
static SaErrorT exechandlergetnext(oHpiHandlerIdT handlerid)
{
SaErrorT rv = SA_OK;
oHpiHandlerIdT nexthandlerid;
if (copt.debug) DBG("Go and get next handler from %u in domain %u",
handlerid, copt.domainid);
rv = oHpiHandlerGetNext ( sessionid, handlerid, &nexthandlerid );
if (copt.debug) DBG("oHpiHandlerGetNext returned %s", oh_lookup_error(rv));
if (rv==SA_OK) {
printf("Next Handler found from %u is %u.\n\n",
handlerid, nexthandlerid);
}
else if (rv==SA_ERR_HPI_NOT_PRESENT) {
if (copt.domainid==SAHPI_UNSPECIFIED_DOMAIN_ID)
printf("No next Handler found from %u in default domain.\n",
handlerid);
else printf("No next Handler found from %u in domain %u.\n",
handlerid, copt.domainid);
}
else printf("\noHpiHandlerGetNext returned %s\n", oh_lookup_error(rv));
return rv;
}
/********************************************/
/* exechandlerfind */
/********************************************/
static SaErrorT exechandlerfind(SaHpiResourceIdT resid)
{
SaErrorT rv = SA_OK;
oHpiHandlerIdT handlerid;
if (copt.debug) DBG("Go and find handler for resource %u in domain "
"%u using session %u",
resid, copt.domainid, sessionid);
rv = oHpiHandlerFind ( sessionid, resid, &handlerid );
if (copt.debug) DBG("oHpiHandlerFind returned %s", oh_lookup_error(rv));
if (rv==SA_OK) {
printf("Handler found for resource %u: Handler-id %u.\n\n",
resid, handlerid);
}
else if (rv==SA_ERR_HPI_NOT_PRESENT) {
if (copt.domainid==SAHPI_UNSPECIFIED_DOMAIN_ID)
printf("No Handler found for resource %u in default domain.\n",
resid);
else printf("No Handler found for resource %u in domain %u.\n",
resid, copt.domainid);
}
else printf("\noHpiHandlerFind returned %s\n", oh_lookup_error(rv));
return rv;
}
/********************************************/
/* exechandlerretry */
/********************************************/
static SaErrorT exechandlerretry(oHpiHandlerIdT handlerid)
{
SaErrorT rv = SA_OK;
if (copt.debug) DBG("Go and retry loading handler %u in domain %u",
handlerid, copt.domainid);
rv = oHpiHandlerRetry ( sessionid, handlerid );
if (rv!=SA_OK) {
CRIT("oHpiHandlerRetry returned %s", oh_lookup_error(rv));
return rv;
}
if (copt.domainid==SAHPI_UNSPECIFIED_DOMAIN_ID)
printf("\nHandler %u in default domain successfully re-loaded.\n",
handlerid);
else printf("\nHandler %u in domain %u successfully re-loaded.\n",
handlerid, copt.domainid);
return rv;
}
/********************************************/
/* exechandlerlist */
/********************************************/
static SaErrorT exechandlerlist()
{
SaErrorT rv = SA_OK;
oHpiHandlerIdT handlerid = 0;
oHpiHandlerIdT nexthandlerid;
oHpiHandlerInfoT handlerinfo;
GHashTable *config = 0;
if (copt.domainid==SAHPI_UNSPECIFIED_DOMAIN_ID)
printf("Handlers defined in default domain:\n");
else printf("Handlers defined in Domain %u:\n",copt.domainid);
while (rv==SA_OK) {
rv = oHpiHandlerGetNext ( sessionid, handlerid, &nexthandlerid );
if (copt.debug) DBG("oHpiHandlerGetNext (%u) returned %s",
handlerid, oh_lookup_error(rv));
if (rv==SA_OK) {
//display info for that handler
config = g_hash_table_new_full(
g_str_hash, g_str_equal,
g_free, g_free );
rv = oHpiHandlerInfo ( sessionid, nexthandlerid, &handlerinfo, config );
if (rv!=SA_OK) {
printf("oHpiHandlerInfo for handler %u returned %s\n",
nexthandlerid, oh_lookup_error(rv));
rv = SA_OK;
}
else {
printf("Handler %u: %s, ",
nexthandlerid, (const char *)handlerinfo.plugin_name);
oh_print_ep (&(handlerinfo.entity_root),0);
}
g_hash_table_destroy(config);
}
else if (rv!=SA_ERR_HPI_NOT_PRESENT) {
printf("Error: oHpiHandlerGetNext (%u) returned %s\n",
handlerid, oh_lookup_error(rv));
}
handlerid = nexthandlerid;
}
printf("\n");
if (rv==SA_ERR_HPI_NOT_PRESENT) return SA_OK;
return rv;
}
/* end ohhandler.c */