Return to
CIMSubCommand.cpp
CVS log
Up to [Pegasus] / pegasus / src / Clients / cimsub
|
Return to
CIMSubCommand.cpp
CVS log
|
Up to [Pegasus] / pegasus / src / Clients / cimsub
|
|
File: [Pegasus] / pegasus / src / Clients / cimsub / CIMSubCommand.cpp
(download)
Revision: 1.21, Thu Apr 25 12:00:18 2013 UTC (11 years, 2 months ago) by dl.meetei Branch: MAIN CVS Tags: TASK-TASK_PEP362_RestfulService_branch-root, TASK-TASK_PEP362_RestfulService_branch-merged_out_from_trunk, TASK-TASK_PEP362_RestfulService_branch-merged_in_to_trunk, TASK-TASK_PEP362_RestfulService_branch-merged_in_from_branch, TASK-TASK_PEP362_RestfulService_branch-branch, TASK-PEP362_RestfulService-root, TASK-PEP362_RestfulService-merged_out_to_branch, TASK-PEP362_RestfulService-merged_out_from_trunk, TASK-PEP362_RestfulService-merged_in_to_trunk, TASK-PEP362_RestfulService-merged_in_from_branch, TASK-PEP362_RestfulService-branch, RELEASE_2_13_0-RC2, RELEASE_2_13_0-RC1, RELEASE_2_13_0-FC, RELEASE_2_13_0, RELEASE_2_13-root, RELEASE_2_13-branch, CIMRS_WORK_20130824 Changes since 1.20: +2 -2 lines BUG#: 9628 TITLE: PEGASUS_ASSERT used in places where PEGASUS_UNREACHABLE should be used DESCRIPTION: |
//%LICENSE////////////////////////////////////////////////////////////////
//
// Licensed to The Open Group (TOG) under one or more contributor license
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
// this work for additional information regarding copyright ownership.
// Each contributor licenses this file to you under the OpenPegasus Open
// Source License; you may not use this file except in compliance with the
// License.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//////////////////////////////////////////////////////////////////////////
//
//%/////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <fstream>
#include <Pegasus/Common/Config.h>
#include <Pegasus/Common/Constants.h>
#include <Pegasus/Common/System.h>
#include <Pegasus/Client/CIMClient.h>
#include <Pegasus/Common/Exception.h>
#include <Pegasus/Common/PegasusVersion.h>
#include <Pegasus/Common/AutoPtr.h>
#include <Pegasus/Common/HostAddress.h>
#include <Pegasus/Common/CIMNameCast.h>
#include <Pegasus/Common/StringConversion.h>
#ifdef PEGASUS_OS_ZOS
#include <Pegasus/General/SetFileDescriptorToEBCDICEncoding.h>
#endif
#ifdef PEGASUS_OS_PASE
#include <ILEWrapper/ILEUtilities.h>
#endif
#include <Pegasus/getoopt/getoopt.h>
#include <Clients/cliutils/CommandException.h>
#include <Clients/cliutils/CsvStringParse.h>
#include "CIMSubCommand.h"
PEGASUS_NAMESPACE_BEGIN
/**
* The CLI message resource name
*/
static const char MSG_PATH [] = "pegasus/pegasusCLI";
/**
The command name.
*/
const char COMMAND_NAME[] = "cimsub";
/**
The default subscription namespace
*/
static const CIMNamespaceName _DEFAULT_SUBSCRIPTION_NAMESPACE =
PEGASUS_NAMESPACENAME_INTEROP;
/**
The Description of the Command.
*/
static const char DESCRIPTION[] = "Cimsub Command Line \
Interface is used to manage CIM Indication Subscriptions.";
/**
The usage string for this command. This string is displayed
when an error occurs in parsing or validating the command line.
*/
static const char USAGE[] = "Usage: ";
/*
These constants represent the operation modes supported by the CLI.
Any new operation should be added here.
*/
/**
This constant signifies that an operation option has not been recorded
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_UNINITIALIZED = 0;
/**
This constant represents a disable subscription operation
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_DISABLE = 1;
/**
This constant represents a enable subscription operation
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_ENABLE = 2;
/**
This constant represents a list operation
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_LIST = 3;
/**
This constant represents a remove operation
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_REMOVE = 4;
/**
This constant represents a help operation
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_HELP = 5;
/**
This constant represents a verbose list operation
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_VERBOSE = 6;
/**
This constant represents a version display operation
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_VERSION = 7;
/**
This constant represents a create operation
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_CREATE= 8;
/**
This constant represents a Batch file execution operation
*/
const Uint32 CIMSubCommand::OPERATION_TYPE_BATCH = 9;
/**
The constants representing the messages.
*/
static const char CIMOM_NOT_RUNNING[] =
"The CIM server may not be running.";
static const char CIMOM_NOT_RUNNING_KEY[] =
"Clients.cimsub.CIMSubCommand.CIMOM_NOT_RUNNING";
static const char SUBSCRIPTION_NOT_FOUND_FAILURE[] =
"The requested subscription could not be found.";
static const char SUBSCRIPTION_NOT_FOUND_KEY[] =
"Clients.cimsub.CIMSubCommand."
"SUBSCRIPTION_NOT_FOUND_FAILURE_KEY";
static const char HANDLER_NOT_FOUND_FAILURE[] =
"The requested handler could not be found.";
static const char HANDLER_NOT_FOUND_KEY[] =
"Clients.cimsub.CIMSubCommand."
"HANDLER_NOT_FOUND_FAILURE_KEY";
static const char FILTER_NOT_FOUND_FAILURE[] =
"The requested filter could not be found.";
static const char FILTER_NOT_FOUND_KEY[] =
"Clients.cimsub.CIMSubCommand."
"FILTER_NOT_FOUND_FAILURE_KEY";
static const char SUBSCRIPTION_ALREADY_DISABLED[] =
"The subscription is already disabled.";
static const char SUBSCRIPTION_ALREADY_DISABLED_KEY[] =
"Clients.cimsub.CIMSubCommand.SUBSCRIPTION_ALREADY_DISABLED";
static const char SUBSCRIPTION_ALREADY_ENABLED[] =
"The subscription is already enabled.";
static const char SUBSCRIPTION_ALREADY_ENABLED_KEY[] =
"Clients.cimsub.CIMSubCommand.SUBSCRIPTION_ALREADY_ENABLED";
static const char REQUIRED_OPTION_MISSING[] =
"Required option missing.";
static const char REQUIRED_OPTION_MISSING_KEY[] =
"Clients.cimsub.CIMSubCommand.REQUIRED_OPTION_MISSING";
static const char ERR_USAGE_KEY[] =
"Clients.cimsub.CIMSubCommand.ERR_USAGE";
static const char ERR_USAGE[] =
"Use '--help' to obtain command syntax.";
static const char LONG_HELP[] = "help";
static const char LONG_VERSION[] = "version";
/**
The option character used to specify disable a specified subscription
*/
static const char OPTION_DISABLE = 'd';
/**
The option character used to specify remove a specified subscription
*/
static const char OPTION_REMOVE = 'r';
/**
The option character used to specify the Filter Name of a subscription
*/
static const char OPTION_FILTER = 'F';
/**
The option character used to specify the Query of a Filter
*/
static const char OPTION_QUERY = 'Q';
/**
The option character used to specify the Query language of a Filter
*/
static const char OPTION_QUERYLANGUAGE = 'L';
/**
The option character used to specify the Source Namespace of a Filter
*/
static const char OPTION_SOURCENAMESPACE = 'N';
/**
The option character used to specify enable a specified subscription.
*/
static const char OPTION_ENABLE = 'e';
/**
The option character used to specify the Handler Name of a subscription
*/
static const char OPTION_HANDLER = 'H';
/**
The option character used to specify the Destination of a
CIM_IndicationHandlerCIMXML Handler
*/
static const char OPTION_DESTINATION = 'D';
/**
The option character used to specify the mailto of a
PG_ListenerDestinationEmail Handler
*/
static const char OPTION_MAILTO = 'M';
/**
The option character used to specify the mailcc of a
PG_ListenerDestinationEmail Handler
*/
static const char OPTION_MAILCC = 'C';
/**
The option character used to specify the mail subject of a
PG_ListenerDestinationEmail Handler
*/
static const char OPTION_MAILSUBJECT = 'S';
/**
The option character used to specify the snmp target host of a
PG_IndicationHandlerSNMPMapper Handler
*/
static const char OPTION_SNMPTARGETHOST = 'T';
/**
The option character used to specify the snmp port number of a
PG_IndicationHandlerSNMPMapper Handler
*/
static const char OPTION_SNMPPORTNUMBER = 'P';
/**
The option character used to specify the snmp version of a
PG_IndicationHandlerSNMPMapper Handler
*/
static const char OPTION_SNMPVERSION = 'V';
/**
The option character used to specify the snmp security name host of a
PG_IndicationHandlerSNMPMapper Handler
*/
static const char OPTION_SNMPSECURITYNAME = 'U';
/**
The option character used to specify the snmp engine id of a
PG_IndicationHandlerSNMPMapper Handler
*/
static const char OPTION_SNMPENGINEID = 'E';
/**
The option character used to specify creation
*/
static const char OPTION_CREATE = 'c';
/**
The option character used to specify listing
*/
static const char OPTION_LIST = 'l';
/**
The option charcter used to specify a file for batch file execution
*/
static const char OPTION_BATCH = 'b';
/**
The option argument character used to specify subscriptions
*/
static String ARG_SUBSCRIPTIONS = "s";
/**
The option argument character used to specify filters
*/
static String ARG_FILTERS = "f";
/**
The option argument character used to specify handlers
*/
static String ARG_HANDLERS = "h";
/**
The option argument character used to specify handlers, filters,
and subscriptions
*/
static String ARG_ALL = "a";
/**
The option character used to specify namespace of subscription
*/
static const char OPTION_NAMESPACE = 'n';
/**
The option character used to display verbose info.
*/
static const char OPTION_VERBOSE = 'v';
static const char DELIMITER_NAMESPACE = ':';
static const char DELIMITER_HANDLER_CLASS = '.';
/**
List output header values
*/
const Uint32 TITLE_SEPERATOR_LEN = 2;
static const Uint32 RC_CONNECTION_FAILED = 2;
static const Uint32 RC_CONNECTION_TIMEOUT = 3;
static const Uint32 RC_ACCESS_DENIED = 4;
static const Uint32 RC_NAMESPACE_NONEXISTENT = 5;
static const Uint32 RC_OBJECT_NOT_FOUND = 6;
static const Uint32 RC_OPERATION_NOT_SUPPORTED = 7;
//
// List column header constants
//
const Uint32 _HANDLER_LIST_NAME_COLUMN = 0;
const Uint32 _HANDLER_LIST_DESTINATION_COLUMN = 1;
const Uint32 _FILTER_LIST_NAME_COLUMN = 0;
const Uint32 _FILTER_LIST_QUERY_COLUMN = 1;
const Uint32 _FILTER_LIST_QUERYLANGUAGE_COLUMN = 2;
const Uint32 _SUBSCRIPTION_LIST_NS_COLUMN = 0;
const Uint32 _SUBSCRIPTION_LIST_FILTER_COLUMN = 1;
const Uint32 _SUBSCRIPTION_LIST_HANDLER_COLUMN = 2;
const Uint32 _SUBSCRIPTION_LIST_STATE_COLUMN = 3;
//
// Handler persistence display values
//
const String _PERSISTENTENCE_OTHER_STRING = "Other";
const String _PERSISTENTENCE_PERMANENT_STRING = "Permanent";
const String _PERSISTENTENCE_TRANSIENT_STRING = "Transient";
const String _PERSISTENTENCE_UNKNOWN_STRING = "Unknown";
//
// Subscription state display values
//
const String _SUBSCRIPTION_STATE_UNKNOWN_STRING = "Unknown";
const String _SUBSCRIPTION_STATE_OTHER_STRING = "Other";
const String _SUBSCRIPTION_STATE_ENABLED_STRING = "Enabled";
const String _SUBSCRIPTION_STATE_ENABLED_DEGRADED_STRING = "Enabled Degraded";
const String _SUBSCRIPTION_STATE_DISABLED_STRING = "Disabled";
const String _SUBSCRIPTION_STATE_NOT_SUPPORTED_STRING = "Not Supported";
//
// SNMP version display values
//
const String _SNMP_VERSION_SNMPV1_TRAP_STRING = "SNMPv1 Trap";
const String _SNMP_VERSION_SNMPV2C_TRAP_STRING = "SNMPv2C Trap";
const String _SNMP_VERSION_PEGASUS_RESERVED_STRING = "Pegasus Reserved";
/**
Constructs a CIMSubCommand and initializes instance variables.
*/
CIMSubCommand::CIMSubCommand()
{
/**
Initialize the instance variables.
*/
_operationType = OPERATION_TYPE_UNINITIALIZED;
_verbose = false;
_handlerSNMPPortNumber = 162;
_filterQueryLanguage = "CIM:CQL";
_isBatchNamespace = false;
_filterNSFlag =false;
/**
Build the usage string for the config command.
*/
usage.reserveCapacity(200);
usage.append(DESCRIPTION);
usage.append("\n\n");
usage.append(USAGE);
/*
cimsub -cf [fnamespace:]filtername -Q query
[-L querylanuage] [-N sourcenamespace]
*/
usage.append(COMMAND_NAME);
usage.append(" -").append(OPTION_CREATE);
usage.append(" ").append(ARG_FILTERS);
usage.append(" [fnamespace:]filtername");
usage.append(" -").append(OPTION_QUERY).append(" query");
usage.append(" [-").append(OPTION_QUERYLANGUAGE);
usage.append(" querylanguage]\n");
usage.append(" [-").append(OPTION_SOURCENAMESPACE);
usage.append(" sourcenamespace(s)] \n");
/*
cimsub -ch [hnamespace:][hclassname.]handlername [-D destination ]|
[-T mailto [-C mailcc] -S mailsubject] |
[-T snmptargethost [-P snmpportnumber] -V snmpversion
[-S snmpsecurityname] [-E snmpengineid]]
*/
usage.append(" ");
usage.append(COMMAND_NAME);
usage.append(" -").append(OPTION_CREATE);
usage.append(" ").append(ARG_HANDLERS);
usage.append(" [hnamespace:][hclassname.]handlername");
usage.append(" [-").append(OPTION_DESTINATION);
usage.append(" destination]| \n");
usage.append(" [-").append(OPTION_MAILTO);
usage.append(" mailto");
usage.append(" [-").append(OPTION_MAILCC).append(" mailcc]");
usage.append(" -").append(OPTION_MAILSUBJECT).append(" mailsubject]| \n");
usage.append(" [-").append(OPTION_SNMPTARGETHOST);
usage.append(" snmptargethost");
usage.append(" [-").append(OPTION_SNMPPORTNUMBER);
usage.append(" snmpportnumber]");
usage.append(" -").append(OPTION_SNMPVERSION).append(" snmpversion] \n");
usage.append(" [-").append(OPTION_SNMPSECURITYNAME);
usage.append(" snmpsecurityname]");
usage.append(" [-").append(OPTION_SNMPENGINEID);
usage.append(" snmpengineid]] \n");
/*
cimsub -cs [-n namespace] -F [fnamespace:]filtername
-H [hnamespace:][hclassname.]handlername
*/
usage.append(" ");
usage.append(COMMAND_NAME);
usage.append(" -").append(OPTION_CREATE);
usage.append(" ").append(ARG_SUBSCRIPTIONS);
usage.append(" [-").append(OPTION_NAMESPACE).append(" namespace]");
usage.append(" -").append(OPTION_FILTER).append
(" [fnamespace:]filtername \n");
usage.append(" -").append(OPTION_HANDLER).append
(" [hnamespace:][hclassname.]handlername \n");
usage.append(" ");
usage.append(COMMAND_NAME);
usage.append(" -").append(OPTION_LIST);
usage.append(" ").append(ARG_SUBSCRIPTIONS).append("|");
usage.append(ARG_FILTERS).append("|");
usage.append(ARG_HANDLERS);
usage.append(" [-").append(OPTION_VERBOSE).append("]");
usage.append(" [-").append(OPTION_NAMESPACE).append(" namespace]");
usage.append(" [-").append(OPTION_FILTER).append
(" [fnamespace:]filtername] \n");
usage.append(" [-").append(OPTION_HANDLER).append
(" [hnamespace:][hclassname.]handlername] \n");
usage.append(" ");
usage.append(COMMAND_NAME);
usage.append(" -").append(OPTION_ENABLE);
usage.append(" [-").append(OPTION_NAMESPACE).append(" namespace]");
usage.append(" -").append(OPTION_FILTER).append
(" [fnamespace:]filtername \n");
usage.append(" -").append(OPTION_HANDLER).append
(" [hnamespace:][hclassname.]handlername \n");
usage.append(" ");
usage.append(COMMAND_NAME);
usage.append(" -").append(OPTION_DISABLE);
usage.append(" [-").append(OPTION_NAMESPACE).append(" namespace]");
usage.append(" -").append(OPTION_FILTER).append
(" [fnamespace:]filtername\n");
usage.append(" -").append(OPTION_HANDLER).append
(" [hnamespace:][hclassname.]handlername \n");
usage.append(" ");
usage.append(COMMAND_NAME);
usage.append(" -").append(OPTION_REMOVE);
usage.append(" ").append (ARG_SUBSCRIPTIONS).append("|");
usage.append(ARG_FILTERS).append("|");
usage.append(ARG_HANDLERS).append("|");
usage.append(ARG_ALL);
usage.append(" [-").append(OPTION_NAMESPACE).append(" namespace]");
usage.append(" [-").append(OPTION_FILTER).append
(" [fnamespace:]filtername] \n");
usage.append(" [-").append(OPTION_HANDLER).append
(" [hnamespace:][hclassname.]handlername]\n");
usage.append(" ");
usage.append(COMMAND_NAME);
usage.append(" -").append(OPTION_BATCH);
usage.append(" ").append("batchfile");
usage.append(" [-").append(OPTION_NAMESPACE).append(" namespace]\n");
usage.append(" ");
usage.append(COMMAND_NAME);
usage.append(" --").append(LONG_HELP).append("\n");
usage.append(" ");
usage.append(COMMAND_NAME);
usage.append(" --").append(LONG_VERSION).append("\n");
usage.append("Options : \n");
usage.append(" -c - Create specified subscription, filter, \n"
" handler(CIM_ListenerDestinationCIMXML, \n"
" if hclassname is not specified)\n");
usage.append(" -l - List and display information\n");
usage.append(" -e - Enable specified subscription\n");
usage.append(" (set SubscriptionState to Enabled) \n");
usage.append(" -d - Disable specified subscription \n");
usage.append(" (set SubscriptionState to Disabled) \n");
usage.append(" -r - Remove specified subscription, handler,"
" filter \n");
usage.append(" -b filename\n");
usage.append(" - Execute cimsub batch file. Filename is path"
" to the batch file \n");
usage.append(" -v - Include verbose information \n");
usage.append(" -F - Specify Filter Name of subscription for"
" the operation\n");
usage.append(" -Q - Specify Query Expression of a Filter \n");
usage.append(" -L - Specify Query Language of a Filter \n");
usage.append(" -N - To Use SourceNamespaces property,Specify");
usage.append(" multiple SourceNamespaces\n");
usage.append(" with coma separated or append comma to");
usage.append(" the single SourceNamespace.\n");
usage.append(" By default SourceNamespace property is ");
usage.append(" populated if the single\n");
usage.append(" SourceNamespace is specified.\n");
usage.append(" -H - Specify Handler Name of subscription for"
" the operation\n");
usage.append(" -D - Specify Destination of a "
"CIM_IndicationHandlerCIMXML Handler.\n"
" Required option for "
"CIM_IndicationHandlerCIMXML or \n"
" CIM_ListenerDestinationCIMXML Handler\n");
usage.append(" -M - Specify Mailto of a "
" PG_ListenerDestinationEmail Handler\n");
usage.append(" -C - Specify Mailcc of a "
"PG_ListenerDestinationEmail Handler\n");
usage.append(" -S - Specify Subject of a "
"PG_ListenerDestinationEmail Handler\n");
usage.append(" -T - Specify Target Host of "
"PG_IndicationHandlerSNMPMapper Handler.\n"
" Required option for SNMPMapper handler\n");
usage.append(" -U - Specify Security Name of "
"PG_IndicationHandlerSNMPMapper Handler\n");
usage.append(" -P - Specify Port Number of a "
"PG_IndicationHandlerSNMPMapper Handler\n"
" (default 162) \n");
usage.append(" -V - Specify SNMPVersion of a "
"PG_IndicationHandlerSNMPMapper Handler\n"
" 2 : SNMPv1 Trap\n"
" 3 : SNMPv2C Trap\n"
" 4 : SNMPv2C Inform\n"
" 5 : SNMPv3 Trap\n"
" 6 : SNMPv3 Inform\n"
" Required option for SNMPMapper Handler");
usage.append("\n");
usage.append(" -E - Specify Engine ID of a "
"PG_IndicationHandlerSNMPMapper Handler\n");
usage.append(" -n - Specify namespace of subscription\n");
usage.append(" (interop namespace, if not specified)\n");
usage.append(" --help - Display this help message\n");
usage.append(" --version - Display CIM Server version\n");
usage.append("\n");
usage.append("Usage note: The cimsub command requires that the CIM Server"
" is running.\n");
usage.append("\n");
usage.append("Batch File Format\n");
usage.append("-----------------\n\n");
usage.append("A cimsub batch file contains multiple cimsub ");
usage.append("commands, one per line.");
usage.append("Lines\nthat start with the '#' character and blank lines");
usage.append(" are ignored.The Execution\n");
usage.append("of Batch file will stop when it encounters any syntax error");
usage.append(" or an exception\nin the command.\n\n");
usage.append("The namespace option (-n) when used with batch execution");
usage.append(" (-b) uses the\n");
usage.append("namespace to populate the namespace values of filter, ");
usage.append("handler and\nsubscription. Any namespace specified for ");
usage.append("any or all of these is specified\ninside the batch");
usage.append("command, they will be overridden.\n");
#ifdef PEGASUS_HAS_ICU
MessageLoaderParms menuparms(
"Clients.cimsub.CIMSubCommand.MENU.STANDARD",
usage);
menuparms.msg_src_path = MSG_PATH;
usage = MessageLoader::getMessage(menuparms);
#endif
setUsage(usage);
}
/**
Parses the command line, validates the options, and sets instance
variables based on the option arguments.
*/
void CIMSubCommand::setCommand(
ostream& outPrintWriter,
ostream& errPrintWriter,
Uint32 argc,
char* argv[])
{
Uint32 i = 0;
Uint64 c = 0;
//char c;
String badOptionString;
String optString;
String filterNameString;
String handlerNameString;
Boolean filterSet = false;
Boolean handlerSet = false;
Boolean filterQuerySet = false;
Boolean filterQueryLanguageSet = false;
Boolean filterSourceNamespaceSet = false;
Boolean handlerDestinationSet = false;
Boolean handlerMailToSet = false;
Boolean handlerMailCcSet = false;
Boolean handlerMailSubjectSet = false;
Boolean handlerSnmpTargetHostSet = false;
Boolean handlerSnmpPortNumberSet = false;
Boolean handlerSnmpVersionSet = false;
Boolean handlerSnmpSecurityNameSet = false;
Boolean handlerSnmpEngineIdSet = false;
//
// Construct optString
//
optString.append(OPTION_CREATE);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_LIST);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_DISABLE);
optString.append(OPTION_ENABLE);
optString.append(OPTION_REMOVE);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_VERBOSE);
optString.append(OPTION_FILTER);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_HANDLER);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_NAMESPACE);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_QUERY);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_QUERYLANGUAGE);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_SOURCENAMESPACE);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_DESTINATION);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_MAILTO); //OPTION_MAILTO & OPTION_SNMPTARGETHOST
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_MAILCC);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_MAILSUBJECT);
//OPTION_MAILSUBJECT & OPTION_SNMPSECURITYNAME
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_SNMPTARGETHOST);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_SNMPSECURITYNAME);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_SNMPPORTNUMBER);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_SNMPVERSION);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_SNMPENGINEID);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
optString.append(OPTION_BATCH);
optString.append(getoopt::GETOPT_ARGUMENT_DESIGNATOR);
//
// Initialize and parse options
//
getoopt options("");
options.addFlagspec(optString);
options.addLongFlagspec(LONG_HELP,getoopt::NOARG);
options.addLongFlagspec(LONG_VERSION,getoopt::NOARG);
options.parse(argc, argv);
if (options.hasErrors())
{
throw CommandFormatException(options.getErrorStrings()[0]);
}
_operationType = OPERATION_TYPE_UNINITIALIZED;
//
// Get options and arguments from the command line
//
for (i = options.first(); i < options.last(); i++)
{
if (options[i].getType () == Optarg::LONGFLAG)
{
if (options[i].getopt() == LONG_HELP)
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
//
// More than one operation option was found
//
throw UnexpectedOptionException(LONG_HELP);
}
_operationType = OPERATION_TYPE_HELP;
}
else if (options[i].getopt() == LONG_VERSION)
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
//
// More than one operation option was found
//
throw UnexpectedOptionException(LONG_VERSION);
}
_operationType = OPERATION_TYPE_VERSION;
}
}
else if (options [i].getType() == Optarg::REGULAR)
{
if (options.isSet(OPTION_CREATE))
{
if(ARG_FILTERS == _operationArg)
{
if(filterSet)
{
throw UnexpectedArgumentException(options[i].Value());
}
filterNameString = options[i].Value();
filterSet = true;
}
else if(ARG_HANDLERS == _operationArg)
{
if(handlerSet)
{
throw UnexpectedArgumentException(options[i].Value());
}
handlerNameString = options[i].Value();
handlerSet = true;
}
else
{
//
// The cimsub command has no non-option argument
// options except "c"
//
throw UnexpectedArgumentException(options[i].Value());
}
}
else
{
//
// The cimsub command has no non-option argument
// options except "c"
//
throw UnexpectedArgumentException(options[i].Value());
}
}
else
{
c = options[i].getopt()[0];
switch (c)
{
case OPTION_DISABLE:
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
//
// More than one operation option was found
//
throw UnexpectedOptionException(OPTION_DISABLE);
}
if (options.isSet(OPTION_DISABLE) > 1)
{
//
// More than one disable subscription option was found
//
throw DuplicateOptionException(OPTION_DISABLE);
}
_operationType = OPERATION_TYPE_DISABLE;
break;
}
case OPTION_ENABLE:
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
//
// More than one operation option was found
//
throw UnexpectedOptionException (OPTION_ENABLE);
}
if (options.isSet(OPTION_ENABLE) > 1)
{
//
// More than one enable option was found
//
throw DuplicateOptionException (OPTION_ENABLE);
}
_operationType = OPERATION_TYPE_ENABLE;
break;
}
case OPTION_LIST:
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
//
// More than one operation option was found
//
throw UnexpectedOptionException(OPTION_LIST);
}
if (options.isSet(OPTION_LIST) > 1)
{
//
// More than one list option was found
//
throw DuplicateOptionException (OPTION_LIST);
}
_operationType = OPERATION_TYPE_LIST;
_operationArg = options[i].Value();
break;
}
case OPTION_CREATE:
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
//
// More than one operation option was found
//
throw UnexpectedOptionException(OPTION_LIST);
}
if (options.isSet(OPTION_CREATE) > 1)
{
//
// More than two create option was found
//
throw DuplicateOptionException (OPTION_CREATE);
}
_operationType = OPERATION_TYPE_CREATE;
_operationArg = options[i].Value();
break;
}
case OPTION_REMOVE:
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
//
// More than one operation option was found
//
throw UnexpectedOptionException(OPTION_REMOVE);
}
if (options.isSet(OPTION_REMOVE) > 1)
{
//
// More than one remove option was found
//
throw DuplicateOptionException(OPTION_REMOVE);
}
_operationType = OPERATION_TYPE_REMOVE;
_operationArg = options[i].Value();
break;
}
case OPTION_VERBOSE:
{
if (_operationType != OPERATION_TYPE_LIST)
{
//
// Unexpected verbose option was found
//
throw UnexpectedOptionException(OPTION_VERBOSE);
}
if (options.isSet(OPTION_VERBOSE) > 1)
{
//
// More than one verbose option was found
//
throw DuplicateOptionException(OPTION_VERBOSE);
}
_verbose = true;
break;
}
case OPTION_FILTER:
{
if ((_operationType == OPERATION_TYPE_HELP) ||
(_operationType == OPERATION_TYPE_VERSION) ||
(_operationType == OPERATION_TYPE_CREATE
&& ARG_SUBSCRIPTIONS!= _operationArg))
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_FILTER);
}
if (options.isSet(OPTION_FILTER) > 1)
{
//
// More than one filter option was found
//
throw DuplicateOptionException(OPTION_FILTER);
}
filterNameString = options[i].Value();
filterSet = true;
break;
}
case OPTION_HANDLER:
{
if ((_operationType == OPERATION_TYPE_HELP) ||
(_operationType == OPERATION_TYPE_VERSION) ||
(_operationType == OPERATION_TYPE_CREATE
&& ARG_SUBSCRIPTIONS!= _operationArg))
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_HANDLER);
}
if (options.isSet(OPTION_HANDLER) > 1)
{
//
// More than one handler option was found
//
throw DuplicateOptionException(OPTION_HANDLER);
}
handlerNameString = options[i].Value();
handlerSet = true;
break;
}
case OPTION_NAMESPACE:
{
if ((_operationType == OPERATION_TYPE_HELP) ||
(_operationType == OPERATION_TYPE_VERSION) ||
(_operationType == OPERATION_TYPE_CREATE
&& ARG_SUBSCRIPTIONS!= _operationArg))
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_NAMESPACE);
}
if (options.isSet(OPTION_NAMESPACE) > 1)
{
//
// More than one namespace option was found
//
throw DuplicateOptionException(OPTION_NAMESPACE);
}
if (_operationType == OPERATION_TYPE_BATCH )
{
_batchNamespace = options[i].Value();
_isBatchNamespace = true;
}
else
{
String nsNameValue = options[i].Value();
_subscriptionNamespace = nsNameValue;
}
break;
}
case OPTION_BATCH:
{
if (_operationType != OPERATION_TYPE_UNINITIALIZED)
{
// More than one operation option was found
throw UnexpectedOptionException(OPTION_BATCH);
}
if (options.isSet(OPTION_BATCH) > 1)
{
throw DuplicateOptionException(OPTION_BATCH);
}
_operationType = OPERATION_TYPE_BATCH;
_batchFileName = options[i].Value();
break;
}
case OPTION_QUERY:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_FILTERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_QUERY);
}
if (options.isSet(OPTION_QUERY) > 1)
{
//
// More than one query option was found
//
throw DuplicateOptionException(OPTION_QUERY);
}
String filterQueryValue = options[i].Value();
_filterQuery = filterQueryValue;
filterQuerySet = true;
break;
}
case OPTION_QUERYLANGUAGE:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_FILTERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_QUERYLANGUAGE);
}
if (options.isSet(OPTION_QUERYLANGUAGE) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_QUERYLANGUAGE);
}
String filterQueryLanguageValue = options[i].Value();
_filterQueryLanguage = filterQueryLanguageValue;
filterQueryLanguageSet = true;
break;
}
case OPTION_SOURCENAMESPACE:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_FILTERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_SOURCENAMESPACE);
}
if (options.isSet(OPTION_SOURCENAMESPACE) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_SOURCENAMESPACE);
}
_filterNSFlag = false;
String filterSourceNamespaceValue = options[i].Value();
String filterNS = filterSourceNamespaceValue;
Boolean sourceNamespacesProperty = false;
csvStringParse strSNS (filterNS, ',');
while (strSNS.more())
{
_filterSourceNamespaces.append(strSNS.next());
}
if ( _filterSourceNamespaces.size() > 1 ||
filterNS[filterNS.size()-1] == ',')
{
sourceNamespacesProperty = true;
}
_filterNSFlag = sourceNamespacesProperty;
filterSourceNamespaceSet = true;
break;
}
case OPTION_DESTINATION:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_HANDLERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_DESTINATION);
}
if (options.isSet(OPTION_DESTINATION) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_DESTINATION);
}
String handlerDestinationValue = options[i].Value();
_handlerDestination = handlerDestinationValue;
handlerDestinationSet = true;
break;
}
case OPTION_MAILCC:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_HANDLERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_MAILCC);
}
if (options.isSet(OPTION_MAILCC) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_MAILCC);
}
String handlerMailCcValue = options[i].Value();
_handlerMailCc = handlerMailCcValue;
handlerMailCcSet = true;
break;
}
case OPTION_MAILTO: //OPTION_MAILTO && OPTION_SNMPTARGETHOST
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_HANDLERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_MAILTO);
}
if (options.isSet(OPTION_MAILTO) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_MAILTO);
}
String tmpValue = options[i].Value();
_handlerMailTo= tmpValue;
handlerMailToSet = true;
_handlerSNMPTartgetHost = tmpValue;
handlerSnmpTargetHostSet = true;
break;
}
case OPTION_MAILSUBJECT:
{
//OPTION_MAILSUBJECT && OPTION_SNMPSECURITYNAME
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_HANDLERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_MAILSUBJECT);
}
if (options.isSet(OPTION_MAILSUBJECT) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_MAILSUBJECT);
}
String tmpValue = options[i].Value();
_handlerMailSubject = tmpValue;
handlerMailSubjectSet = true;
_handlerSNMPSecurityName = tmpValue;
handlerSnmpSecurityNameSet = true;
break;
}
case OPTION_SNMPTARGETHOST:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_HANDLERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_SNMPTARGETHOST);
}
if (options.isSet(OPTION_SNMPTARGETHOST) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_SNMPTARGETHOST);
}
String tmpValue = options[i].Value();
_handlerSNMPTartgetHost = tmpValue;
handlerSnmpTargetHostSet = true;
break;
}
case OPTION_SNMPSECURITYNAME:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_HANDLERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(
OPTION_SNMPSECURITYNAME);
}
if (options.isSet(OPTION_SNMPSECURITYNAME) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_SNMPSECURITYNAME);
}
String tmpValue = options[i].Value();
_handlerSNMPSecurityName = tmpValue;
handlerSnmpSecurityNameSet = true;
break;
}
case OPTION_SNMPPORTNUMBER:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_HANDLERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_SNMPPORTNUMBER);
}
if (options.isSet(OPTION_SNMPPORTNUMBER) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_SNMPPORTNUMBER);
}
String handlerPortNumberValue = options[i].Value();
for( Uint32 i = 0; i < handlerPortNumberValue.size(); i++)
{
if(!isdigit(handlerPortNumberValue[i]))
{
throw InvalidOptionArgumentException(
handlerPortNumberValue,
OPTION_SNMPPORTNUMBER);
}
}
StringConversion::stringToUnsignedInteger(
handlerPortNumberValue.getCString(),
_handlerSNMPPortNumber);
handlerSnmpPortNumberSet = true;
break;
}
case OPTION_SNMPVERSION:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_HANDLERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_SNMPVERSION);
}
if (options.isSet(OPTION_SNMPVERSION) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_SNMPVERSION);
}
String handlerSnmpVersionValue = options[i].Value();
for( Uint32 i = 0; i < handlerSnmpVersionValue.size(); i++)
{
if(!isdigit(handlerSnmpVersionValue[i]))
{
throw InvalidOptionArgumentException(
handlerSnmpVersionValue,
OPTION_SNMPPORTNUMBER);
}
}
StringConversion::stringToUnsignedInteger(
handlerSnmpVersionValue.getCString(),
_handlerSNMPVersion);
handlerSnmpVersionSet = true;
break;
}
case OPTION_SNMPENGINEID:
{
if (_operationType != OPERATION_TYPE_CREATE
|| ARG_HANDLERS != _operationArg)
{
//
// Help and version take no options.
//
throw UnexpectedOptionException(OPTION_SNMPENGINEID);
}
if (options.isSet(OPTION_SNMPENGINEID) > 1)
{
//
// More than one query language option was found
//
throw DuplicateOptionException(OPTION_SNMPENGINEID);
}
String handlerSnmpEngineIdValue = options[i].Value();
_handlerSNMPEngineID = handlerSnmpEngineIdValue;
handlerSnmpEngineIdSet = true;
break;
}
default:
{
throw UnexpectedOptionException (c);
}
}
}
}
//
// Some more validations
//
if (_operationType == OPERATION_TYPE_UNINITIALIZED)
{
//
// No operation type was specified
// Show the usage
//
throw CommandFormatException(localizeMessage(
MSG_PATH, REQUIRED_OPTION_MISSING_KEY, REQUIRED_OPTION_MISSING));
}
if (_operationType == OPERATION_TYPE_LIST)
{
if (_operationArg == ARG_FILTERS)
{
if (handlerSet)
{
//
// Wrong option for this operation
// was found
//
throw UnexpectedOptionException(OPTION_HANDLER);
}
}
else if (_operationArg == ARG_HANDLERS)
{
if (filterSet)
{
//
// Wrong option for this operation was found
//
throw UnexpectedOptionException
(OPTION_FILTER);
}
}
else if (_operationArg != ARG_SUBSCRIPTIONS)
{
//
// A wrong option argument for this
// operation was found
//
throw InvalidOptionArgumentException(
_operationArg, OPTION_LIST);
}
}
if (_operationType == OPERATION_TYPE_DISABLE)
{
if (!filterSet)
{
throw MissingOptionException(OPTION_FILTER);
}
if (!handlerSet)
{
throw MissingOptionException(OPTION_HANDLER);
}
}
if (_operationType == OPERATION_TYPE_ENABLE)
{
if (!filterSet)
{
throw MissingOptionException(OPTION_FILTER);
}
if (!handlerSet)
{
throw MissingOptionException(OPTION_HANDLER);
}
}
if (_operationType == OPERATION_TYPE_REMOVE)
{
if (_operationArg == ARG_FILTERS)
{
if (handlerSet)
{
//
// Wrong option for this
// operation was found
//
throw UnexpectedOptionException(
OPTION_HANDLER);
}
}
else
{
if (_operationArg == ARG_HANDLERS)
{
if (filterSet)
{
//
// Wrong option for this operation was found
//
throw UnexpectedOptionException(OPTION_FILTER);
}
}
else
{
if ((_operationArg != ARG_SUBSCRIPTIONS) &&
(_operationArg != ARG_ALL))
{
//
// A wrong option argument for this operation
// was found
//
throw InvalidOptionArgumentException
(_operationArg, OPTION_REMOVE);
}
}
}
if ((_operationArg == ARG_SUBSCRIPTIONS) ||
(_operationArg == ARG_ALL) ||
(_operationArg == ARG_FILTERS))
{
if (!filterSet)
{
throw MissingOptionException(OPTION_FILTER);
}
}
if ((_operationArg == ARG_SUBSCRIPTIONS) ||
(_operationArg == ARG_ALL) ||
(_operationArg == ARG_HANDLERS))
{
if (!handlerSet)
{
throw MissingOptionException(OPTION_HANDLER);
}
}
}
if (_operationType == OPERATION_TYPE_CREATE)
{
if(ARG_FILTERS == _operationArg)
{
if (!filterQuerySet)
{
throw MissingOptionException(OPTION_QUERY);
}
if (!filterSet)
{
throw CommandFormatException(
localizeMessage(
MSG_PATH,
REQUIRED_OPTION_MISSING_KEY,
REQUIRED_OPTION_MISSING)
);
}
}
else if(ARG_HANDLERS == _operationArg)
{
if (!handlerSet)
{
throw CommandFormatException(
localizeMessage(
MSG_PATH,
REQUIRED_OPTION_MISSING_KEY,
REQUIRED_OPTION_MISSING)
);
}
String handlerName;
String handlerNamespace;
_handlerCreationClass =
PEGASUS_CLASSNAME_LSTNRDST_CIMXML.getString();
_parseHandlerName(handlerNameString, handlerName, handlerNamespace,
_handlerCreationClass);
CIMName handlerCreationClass(_handlerCreationClass);
if(handlerCreationClass != PEGASUS_CLASSNAME_LSTNRDST_CIMXML &&
handlerCreationClass != PEGASUS_CLASSNAME_INDHANDLER_CIMXML &&
handlerCreationClass != PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG &&
handlerCreationClass != PEGASUS_CLASSNAME_LSTNRDST_EMAIL &&
handlerCreationClass != PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
throw UnexpectedArgumentException(handlerNameString);
}
if (handlerDestinationSet)
{
if (handlerCreationClass != PEGASUS_CLASSNAME_LSTNRDST_CIMXML &&
handlerCreationClass != PEGASUS_CLASSNAME_INDHANDLER_CIMXML)
{
//
// Wrong option for this operation was found
//
throw UnexpectedOptionException(OPTION_DESTINATION);
}
}
else if (handlerCreationClass ==
PEGASUS_CLASSNAME_LSTNRDST_CIMXML ||
handlerCreationClass == PEGASUS_CLASSNAME_INDHANDLER_CIMXML)
{
throw MissingOptionException(OPTION_DESTINATION);
}
if (
handlerMailToSet ||
handlerSnmpTargetHostSet)
{
if (
handlerCreationClass != PEGASUS_CLASSNAME_LSTNRDST_EMAIL &&
handlerCreationClass != PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
//
// Wrong option for this operation was found
//
throw UnexpectedOptionException(OPTION_SNMPTARGETHOST);
}
}
else if(
handlerCreationClass == PEGASUS_CLASSNAME_LSTNRDST_EMAIL ||
handlerCreationClass == PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
throw MissingOptionException(OPTION_SNMPTARGETHOST);
}
if (handlerMailCcSet)
{
if (handlerCreationClass != PEGASUS_CLASSNAME_LSTNRDST_EMAIL)
{
//
// Wrong option for this operation was found
//
throw UnexpectedOptionException(OPTION_MAILCC);
}
}
if (
handlerMailSubjectSet ||
handlerSnmpSecurityNameSet)
{
if (
handlerCreationClass != PEGASUS_CLASSNAME_LSTNRDST_EMAIL &&
handlerCreationClass != PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
//
// Wrong option for this operation was found
//
throw UnexpectedOptionException(OPTION_SNMPSECURITYNAME);
}
}
else if(handlerCreationClass == PEGASUS_CLASSNAME_LSTNRDST_EMAIL)
{
throw MissingOptionException(OPTION_MAILSUBJECT);
}
if (handlerSnmpPortNumberSet)
{
if (handlerCreationClass != PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
//
// Wrong option for this operation was found
//
throw UnexpectedOptionException(OPTION_SNMPPORTNUMBER);
}
}
if (handlerSnmpVersionSet)
{
if (handlerCreationClass != PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
//
// Wrong option for this operation was found
//
throw UnexpectedOptionException(OPTION_SNMPVERSION);
}
}
else if (handlerCreationClass == PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
throw MissingOptionException(OPTION_SNMPVERSION);
}
if (handlerSnmpEngineIdSet)
{
if (handlerCreationClass != PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
//
// Wrong option for this operation was found
//
throw UnexpectedOptionException(OPTION_SNMPENGINEID);
}
}
}
else if(ARG_SUBSCRIPTIONS== _operationArg)
{
if (!handlerSet)
{
throw MissingOptionException(OPTION_HANDLER);
}
if (!filterSet)
{
throw MissingOptionException(OPTION_FILTER);
}
}
else
{
//
// A wrong option argument for this operation
// was found
//
throw InvalidOptionArgumentException
(_operationArg, OPTION_CREATE);
}
}
if (filterSet)
{
_parseFilterName(filterNameString, _filterName, _filterNamespace);
}
if (handlerSet)
{
_parseHandlerName(handlerNameString, _handlerName, _handlerNamespace,
_handlerCreationClass);
}
}
/**
Executes the command and writes the results to the PrintWriters.
*/
Uint32 CIMSubCommand::execute(
ostream& outPrintWriter,
ostream& errPrintWriter)
{
Array<CIMNamespaceName> namespaceNames;
//
// The CIM Client reference
//
if (_operationType == OPERATION_TYPE_UNINITIALIZED)
{
//
// The command was not initialized
//
return 1;
}
else if (_operationType == OPERATION_TYPE_HELP)
{
errPrintWriter << usage << endl;
return (RC_SUCCESS);
}
else if (_operationType == OPERATION_TYPE_VERSION)
{
errPrintWriter << "Version " << PEGASUS_PRODUCT_VERSION << endl;
return (RC_SUCCESS);
}
try
{
// Construct the CIMClient and set to request server messages
// in the default language of this client process.
_client.reset(new CIMClient);
_client->setRequestDefaultLanguages();
}
catch (Exception & e)
{
errPrintWriter << e.getMessage() << endl;
return (RC_ERROR);
}
try
{
//
// Open connection with CIMSever
//
_client->connectLocal();
}
catch (const Exception&)
{
errPrintWriter << localizeMessage(MSG_PATH,
CIMOM_NOT_RUNNING_KEY,
CIMOM_NOT_RUNNING) << endl;
return (RC_CONNECTION_FAILED);
}
//
// Perform the requested operation
//
try
{
CIMNamespaceName subscriptionNS;
CIMNamespaceName filterNS = CIMNamespaceName();
CIMNamespaceName handlerNS = CIMNamespaceName();
if (_subscriptionNamespace != String::EMPTY)
{
subscriptionNS = _subscriptionNamespace;
if(OPERATION_TYPE_LIST == _operationType &&
_operationArg != ARG_SUBSCRIPTIONS)
{
filterNS = subscriptionNS;
handlerNS = subscriptionNS;
}
}
if (_filterNamespace != String::EMPTY)
{
filterNS = _filterNamespace;
}
if (_handlerNamespace != String::EMPTY)
{
handlerNS = _handlerNamespace;
}
switch (_operationType)
{
case OPERATION_TYPE_ENABLE:
return(_findAndModifyState(STATE_ENABLED,
subscriptionNS, _filterName, filterNS,
_handlerName, handlerNS, _handlerCreationClass,
outPrintWriter));
case OPERATION_TYPE_DISABLE:
return (_findAndModifyState(STATE_DISABLED,
subscriptionNS, _filterName, filterNS,
_handlerName, handlerNS, _handlerCreationClass,
outPrintWriter));
case OPERATION_TYPE_LIST:
if (_operationArg == ARG_SUBSCRIPTIONS)
{
if (subscriptionNS.isNull())
{
_getAllNamespaces(namespaceNames);
}
else
{
namespaceNames.append(subscriptionNS);
}
_listSubscriptions(namespaceNames, _filterName,
filterNS, _handlerName, handlerNS,
_handlerCreationClass, _verbose, outPrintWriter,
errPrintWriter);
}
else if (_operationArg == ARG_FILTERS)
{
if (filterNS.isNull())
{
_getAllNamespaces(namespaceNames);
}
else
{
namespaceNames.append(filterNS);
}
_listFilters(_filterName, _verbose,
namespaceNames, outPrintWriter,
errPrintWriter);
}
else if (_operationArg == ARG_HANDLERS)
{
if (handlerNS.isNull())
{
_getAllNamespaces(namespaceNames);
}
else
{
namespaceNames.append(handlerNS);
}
_listHandlers(_handlerName, namespaceNames,
_handlerCreationClass, _verbose,
outPrintWriter, errPrintWriter);
}
break;
case OPERATION_TYPE_REMOVE:
if ((_operationArg == ARG_SUBSCRIPTIONS) || (_operationArg ==
ARG_ALL))
{
Boolean removeAll = false;
if (_operationArg == ARG_ALL)
{
removeAll = true;
}
return _removeSubscription(subscriptionNS,
_filterName, filterNS, _handlerName, handlerNS,
_handlerCreationClass, removeAll, outPrintWriter,
errPrintWriter);
}
else if (_operationArg == ARG_FILTERS)
{
return (_removeFilter(_filterName, filterNS,
outPrintWriter, errPrintWriter));
}
else
{
PEGASUS_ASSERT (_operationArg == ARG_HANDLERS);
return _removeHandler(_handlerName,
handlerNS, _handlerCreationClass, outPrintWriter,
errPrintWriter);
}
break;
case OPERATION_TYPE_CREATE:
if ((_operationArg == ARG_SUBSCRIPTIONS) )
{
return _createSubscription(subscriptionNS,
_filterName, filterNS, _handlerName, handlerNS,
_handlerCreationClass, outPrintWriter,
errPrintWriter);
}
else if (_operationArg == ARG_FILTERS)
{
return (_createFilter(_filterName, filterNS,
_filterQuery,_filterQueryLanguage,_filterSourceNamespaces,
outPrintWriter, errPrintWriter));
}
else
{
PEGASUS_ASSERT (_operationArg == ARG_HANDLERS);
CIMName handlerClass(_handlerCreationClass);
if (handlerClass == PEGASUS_CLASSNAME_LSTNRDST_CIMXML
|| handlerClass == PEGASUS_CLASSNAME_INDHANDLER_CIMXML)
{
return _createCimXmlHandler(_handlerName,
handlerNS, _handlerCreationClass, _handlerDestination,
outPrintWriter, errPrintWriter);
}
else if (handlerClass == PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG)
{
return _createSystemLogHandler(_handlerName,
handlerNS, _handlerCreationClass,
outPrintWriter, errPrintWriter);
}
else if (handlerClass == PEGASUS_CLASSNAME_LSTNRDST_EMAIL)
{
Array<String> mailToList;
Array<String> mailCcList;
{
csvStringParse strl(_handlerMailTo, ',');
while(strl.more())
{
mailToList.append(strl.next());
}
}
{
csvStringParse strl(_handlerMailCc, ',');
while(strl.more())
{
mailCcList.append(strl.next());
}
}
return _createEmailHandler(_handlerName,
handlerNS, _handlerCreationClass,
mailToList,
mailCcList,
_handlerMailSubject,
outPrintWriter, errPrintWriter);
}
else if(handlerClass == PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
return _createSnmpMapperHandler(_handlerName,
handlerNS, _handlerCreationClass,
_handlerSNMPTartgetHost,
_handlerSNMPPortNumber,
_handlerSNMPVersion,
_handlerSNMPSecurityName,
_handlerSNMPEngineID,
outPrintWriter, errPrintWriter);
}
else
{
PEGASUS_UNREACHABLE(PEGASUS_ASSERT(0);)
}
}
break;
case OPERATION_TYPE_BATCH:
{
ifstream batchFile(_batchFileName.getCString());
char buffer[1024];
char* argv[128];
String tempString;
Uint32 argc = 0;
String bLine;
if (!batchFile)
{
throw CannotOpenFile(_batchFileName);
}
// parsing batch file line by line
while (batchFile.getline(buffer, sizeof(buffer)))
{
bLine = buffer;
Uint32 start = 0;
// ignore whitespaces
while (((bLine[start]) == ' ') &&
(start < bLine.size()))
{
start++;
}
// ignore comment and empty line
if (bLine[start] != '#' && bLine[start] != '\000')
{
String batchLine = bLine.subString(start,bLine.size());
csvStringParse BatchCmd(batchLine,' ');
while (BatchCmd.more())
{
tempString = BatchCmd.next();
if( tempString.size() != 0 )
{
argv[argc] = strdup(tempString.getCString());
argc++;
}
}
try
{
// get all options
setCommand(outPrintWriter,errPrintWriter,argc,argv);
}
catch(CommandFormatException& e)
{
errPrintWriter << e.getMessage()<<"\n";
}
catch(CIMException& e)
{
errPrintWriter << e.getMessage()<<"\n";
}
catch(...)
{
}
try
{
// execute the command
execute(outPrintWriter,errPrintWriter);
}
catch(CIMException& e)
{
errPrintWriter << e.getMessage()<<"\n";
}
catch(...)
{
}
for (Uint32 ac = 0; ac < argc ;ac++ )
{
free(argv[ac]);
}
argc = 0;
if (_verbose)
{
_verbose = false;
}
// reset values before next command
_subscriptionNamespace.clear();
_filterNamespace.clear();
_handlerNamespace.clear();
_filterName.clear();
_handlerName.clear();
outPrintWriter << "\n";
}
}
_isBatchNamespace = false;
break;
}
default:
PEGASUS_UNREACHABLE(PEGASUS_ASSERT(0);)
break;
}
}
catch (CIMException& e)
{
CIMStatusCode code = e.getCode();
if (code == CIM_ERR_NOT_FOUND)
{
errPrintWriter << e.getMessage() << endl;
return RC_OBJECT_NOT_FOUND;
}
else if (code == CIM_ERR_INVALID_NAMESPACE)
{
errPrintWriter << e.getMessage() << endl;
return RC_NAMESPACE_NONEXISTENT;
}
else if (code == CIM_ERR_NOT_SUPPORTED)
{
errPrintWriter << e.getMessage() << endl;
return RC_OPERATION_NOT_SUPPORTED;
}
else if (code == CIM_ERR_ACCESS_DENIED)
{
errPrintWriter << e.getMessage() << endl;
return RC_ACCESS_DENIED;
}
else
{
errPrintWriter << e.getMessage() << endl;
}
return (RC_ERROR);
}
catch (ConnectionTimeoutException& e)
{
errPrintWriter << e.getMessage() << endl;
return (RC_CONNECTION_TIMEOUT);
}
catch (Exception& e)
{
errPrintWriter << e.getMessage() << endl;
return (RC_ERROR);
}
return (RC_SUCCESS);
}
//
// parse the filter option string
//
void CIMSubCommand::_parseFilterName(
const String& filterNameString,
String& filterName,
String& filterNamespace)
{
Uint32 nsDelimiterIndex = filterNameString.find(
DELIMITER_NAMESPACE);
if (nsDelimiterIndex == PEG_NOT_FOUND)
{
filterName = filterNameString;
filterNamespace.clear();
}
else
{
if((nsDelimiterIndex == 0 ) ||
((nsDelimiterIndex + 1) ==
filterNameString.size()))
{
// Invalid - either no name or no class
throw InvalidOptionArgumentException(
filterNameString, OPTION_FILTER);
}
// Parse the filter namespace and filter name
filterNamespace = filterNameString.subString(0,
nsDelimiterIndex);
filterName = filterNameString.subString(
nsDelimiterIndex+1);
}
}
//
// parse the handler option string
//
void CIMSubCommand::_parseHandlerName(
const String& handlerString,
String& handlerName,
String& handlerNamespace,
String& handlerCreationClass)
{
Uint32 nsDelimiterIndex = handlerString.find (
DELIMITER_NAMESPACE);
if (nsDelimiterIndex == PEG_NOT_FOUND)
{
//
// handler namespace was not found
//
handlerNamespace.clear();
//
// Check for handler class
//
Uint32 classDelimiterIndex = handlerString.find (
DELIMITER_HANDLER_CLASS);
if (classDelimiterIndex == PEG_NOT_FOUND)
{
handlerName = handlerString;
}
else
{
//
// Parse creation class and handler name
//
if ((classDelimiterIndex == 0) ||
((classDelimiterIndex + 1) ==
handlerString.size()))
{
// Invalid - either no name or no class
throw InvalidOptionArgumentException(
handlerString, OPTION_HANDLER);
}
handlerCreationClass =
handlerString.subString (0,
classDelimiterIndex);
handlerName = handlerString.subString(
classDelimiterIndex+1);
}
}
else
{
//
// handler namespace was found
//
// Parse the handler namespace and handler name
handlerNamespace = handlerString.subString(0,
nsDelimiterIndex);
if ((nsDelimiterIndex == 0) ||
((nsDelimiterIndex + 1) ==
handlerString.size()))
{
// Invalid - either no name or no class
throw InvalidOptionArgumentException(
handlerString, OPTION_HANDLER);
}
Uint32 classDelimiterIndex = handlerString.find (
DELIMITER_HANDLER_CLASS);
if (classDelimiterIndex == PEG_NOT_FOUND)
{
// No creation class specified, just the handler name
handlerName = handlerString.subString(nsDelimiterIndex+1);
}
else
{
if ((nsDelimiterIndex + 1 ) == classDelimiterIndex)
{
// Invalid - no class
throw InvalidOptionArgumentException(
handlerString, OPTION_HANDLER);
}
if ((classDelimiterIndex + 1) ==
handlerString.size())
{
// Invalid - no name
throw InvalidOptionArgumentException(
handlerString, OPTION_HANDLER);
}
// Parse the handler class and name
Uint32 slen = classDelimiterIndex - nsDelimiterIndex - 1;
handlerCreationClass =
handlerString.subString(nsDelimiterIndex+1, slen);
handlerName = handlerString.subString(classDelimiterIndex+1);
}
}
}
Uint32 CIMSubCommand::_createSubscription(
const CIMNamespaceName& subscriptionNamespace,
const String& filterName,
const CIMNamespaceName& filterNamespace,
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
Array<CIMObjectPath> allSubPathFound;
CIMNamespaceName filterNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
CIMNamespaceName handlerNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
CIMNamespaceName subscriptionNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
CIMObjectPath filterPath;
CIMObjectPath handlerPath;
String handlerCreationCls = handlerCreationClass;
if (_isBatchNamespace )
{
subscriptionNS = _batchNamespace;
}
else if (!subscriptionNamespace.isNull())
{
subscriptionNS = subscriptionNamespace;
}
if (_isBatchNamespace )
{
filterNS = _batchNamespace;
}
else if (!filterNamespace.isNull())
{
filterNS = filterNamespace;
}
if (_isBatchNamespace )
{
handlerNS = _batchNamespace;
}
else if (!handlerNamespace.isNull())
{
handlerNS = handlerNamespace;
}
if (handlerCreationCls == String::EMPTY)
{
handlerCreationCls = PEGASUS_CLASSNAME_LSTNRDST_CIMXML.getString();
}
if (!_findFilter(filterName, filterNS, errPrintWriter, filterPath))
{
outPrintWriter << localizeMessage(MSG_PATH,
FILTER_NOT_FOUND_KEY,
FILTER_NOT_FOUND_FAILURE) << endl;
return (RC_OBJECT_NOT_FOUND);
}
filterPath.setNameSpace(filterNS);
if (!_findHandler(handlerName, handlerNS, handlerCreationCls,
errPrintWriter, handlerPath))
{
outPrintWriter << localizeMessage(MSG_PATH,
HANDLER_NOT_FOUND_KEY,
HANDLER_NOT_FOUND_FAILURE) << endl;
return RC_OBJECT_NOT_FOUND;
}
handlerPath.setNameSpace(handlerNS);
CIMInstance subscriptionInstance (PEGASUS_CLASSNAME_INDSUBSCRIPTION);
subscriptionInstance.addProperty (CIMProperty (CIMName ("Filter"),
filterPath, 0, PEGASUS_CLASSNAME_INDFILTER));
subscriptionInstance.addProperty (CIMProperty (CIMName ("Handler"),
handlerPath, 0, PEGASUS_CLASSNAME_INDHANDLER_CIMXML));
subscriptionInstance.addProperty (CIMProperty
(CIMName ("SubscriptionState"), CIMValue ((Uint16) 2)));
_client->createInstance (subscriptionNS,
subscriptionInstance);
return (RC_SUCCESS);
}
//
// remove an existing subscription instance
//
Uint32 CIMSubCommand::_removeSubscription(
const CIMNamespaceName& subscriptionNamespace,
const String& filterName,
const CIMNamespaceName& filterNamespace,
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
const Boolean removeAll,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
Array<CIMObjectPath> allSubPathFound;
CIMNamespaceName filterNS;
CIMNamespaceName handlerNS;
CIMNamespaceName subscriptionNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
if (_isBatchNamespace )
{
subscriptionNS = _batchNamespace;
}
else if (!subscriptionNamespace.isNull())
{
subscriptionNS = subscriptionNamespace;
}
if (_isBatchNamespace )
{
filterNS = _batchNamespace;
}
else if (!filterNamespace.isNull())
{
filterNS = filterNamespace;
}
if (_isBatchNamespace )
{
handlerNS = _batchNamespace;
}
else if (!handlerNamespace.isNull())
{
handlerNS = handlerNamespace;
}
if (_findSubscription(subscriptionNS, filterName, filterNS,
handlerName, handlerNS, handlerCreationClass, allSubPathFound))
{
for(Uint32 i = 0;i<allSubPathFound.size();i++)
{
CIMObjectPath subPathFound = allSubPathFound[i];
if (!removeAll)
{
try
{
_client->deleteInstance(subscriptionNS, subPathFound);
}
catch(const Exception& e)
{
errPrintWriter << e.getMessage() << endl;
}
}
else
{
// Delete subscription, filter and handler
CIMObjectPath filterRef, handlerRef;
//
// Get the subscription Filter and Handler ObjectPaths
//
Array<CIMKeyBinding> keys = subPathFound.getKeyBindings();
for( Uint32 j=0; j < keys.size(); j++)
{
if (keys[j].getName().equal(
PEGASUS_PROPERTYNAME_FILTER))
{
filterRef = keys[j].getValue();
}
if (keys[j].getName().equal(
PEGASUS_PROPERTYNAME_HANDLER))
{
handlerRef = keys[j].getValue();
}
}
try
{
_client->deleteInstance(subscriptionNS, subPathFound);
}
catch(const Exception& e)
{
errPrintWriter << e.getMessage() << endl;
}
try
{
CIMNamespaceName tmpFilterNS = filterNS;
if(tmpFilterNS.isNull())
{
tmpFilterNS = filterRef.getNameSpace();
}
_client->deleteInstance(tmpFilterNS, filterRef);
}
catch(const Exception& e)
{
errPrintWriter << e.getMessage() << endl;
}
try
{
CIMNamespaceName tmpFilterNS = handlerNS;
if(tmpFilterNS.isNull())
{
tmpFilterNS = handlerRef.getNameSpace();
}
_client->deleteInstance(tmpFilterNS, handlerRef);
}
catch(const Exception& e)
{
errPrintWriter << e.getMessage() << endl;
}
}
}
return (RC_SUCCESS);
}
else
{
outPrintWriter << localizeMessage(MSG_PATH,
SUBSCRIPTION_NOT_FOUND_KEY,
SUBSCRIPTION_NOT_FOUND_FAILURE) << endl;
return (RC_OBJECT_NOT_FOUND);
}
}
//
// create an specify filter instance
//
Uint32 CIMSubCommand::_createFilter
(
const String& filterName,
const CIMNamespaceName& filterNamespace,
const String& filterQuery,
const String& filterQueryLanguage,
const Array<String>& filterSourceNamespaces,
ostream& outPrintWriter,
ostream& errPrintWriter
)
{
CIMObjectPath filterPath;
CIMNamespaceName filterNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
Array<String> sourceNamespaces;
sourceNamespaces = filterSourceNamespaces;
String queryLang = "CIM:CQL";
if (_isBatchNamespace )
{
filterNS = _batchNamespace;
}
else if (!filterNamespace.isNull())
{
filterNS = filterNamespace;
}
if (sourceNamespaces.size() == 0)
{
sourceNamespaces.append(filterNS.getString());
}
if (filterQueryLanguage != String::EMPTY)
{
queryLang = filterQueryLanguage;
}
CIMInstance filterInstance (PEGASUS_CLASSNAME_INDFILTER);
filterInstance.addProperty (CIMProperty (CIMName ("Name"), filterName));
filterInstance.addProperty (CIMProperty (CIMName ("Query"), filterQuery));
filterInstance.addProperty (CIMProperty (CIMName ("QueryLanguage"),
filterQueryLanguage));
if (_filterNSFlag == false && sourceNamespaces.size() == 1)
{
filterInstance.addProperty (
CIMProperty (CIMName ("SourceNamespace"),sourceNamespaces[0]));
}
else
{
filterInstance.addProperty (
CIMProperty (CIMName ("SourceNamespaces"),sourceNamespaces));
}
_client->createInstance(filterNS, filterInstance);
return (RC_SUCCESS);
}
//
// remove an existing filter instance
//
Uint32 CIMSubCommand::_removeFilter
(
const String& filterName,
const CIMNamespaceName& filterNamespace,
ostream& outPrintWriter,
ostream& errPrintWriter
)
{
CIMObjectPath filterPath;
CIMNamespaceName filterNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
if (_isBatchNamespace )
{
filterNS = _batchNamespace;
}
else if (!filterNamespace.isNull())
{
filterNS = filterNamespace;
}
if (_findFilter(filterName, filterNS, errPrintWriter, filterPath))
{
_client->deleteInstance(filterNS, filterPath);
return (RC_SUCCESS);
}
else
{
outPrintWriter << localizeMessage(MSG_PATH,
FILTER_NOT_FOUND_KEY,
FILTER_NOT_FOUND_FAILURE) << endl;
return (RC_OBJECT_NOT_FOUND);
}
}
//
// find a filter
//
Boolean CIMSubCommand::_findFilter(
const String& filterName,
const CIMNamespaceName& filterNamespace,
ostream& errPrintWriter,
CIMObjectPath& filterPath)
{
Array<CIMObjectPath> filterPaths;
Boolean status = false;
try
{
filterPaths = _client->enumerateInstanceNames(
filterNamespace,
PEGASUS_CLASSNAME_INDFILTER);
}
catch (CIMException& e)
{
if (e.getCode() == CIM_ERR_INVALID_CLASS)
{
return false;
}
else
{
throw;
}
}
Uint32 filterCount = filterPaths.size();
if (filterCount > 0)
{
// find matching indication filter
for (Uint32 i = 0; i < filterCount; i++)
{
CIMObjectPath fPath = filterPaths[i];
Array<CIMKeyBinding> keys = fPath.getKeyBindings();
for(Uint32 j=0; j < keys.size(); j++)
{
String filterNameValue;
if(keys[j].getName().equal(PEGASUS_PROPERTYNAME_NAME))
{
filterNameValue = keys[j].getValue();
}
if (filterNameValue == filterName)
{
status = true;
filterPath = fPath;
break;
}
}
}
}
return status;
}
//// create a specify CIMXML handler instance
//
Uint32 CIMSubCommand::_createCimXmlHandler(
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
const String& handlerDestination,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
CIMObjectPath handlerPath;
CIMNamespaceName handlerNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
CIMName creationClass = PEGASUS_CLASSNAME_LSTNRDST_CIMXML;
if (_isBatchNamespace )
{
handlerNS = _batchNamespace;
}
else if (!handlerNamespace.isNull())
{
handlerNS = handlerNamespace;
}
if (handlerCreationClass != String::EMPTY)
{
creationClass = handlerCreationClass;
}
CIMInstance handlerInstance(creationClass);
handlerInstance.addProperty(CIMProperty(CIMName("Name"), handlerName));
handlerInstance.addProperty(CIMProperty(
CIMName("Destination"),
handlerDestination));
_client->createInstance(
handlerNS,
handlerInstance);
return (RC_SUCCESS);
}
//// create a specify Syslog handler instance
//
Uint32 CIMSubCommand::_createSystemLogHandler(
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
CIMObjectPath handlerPath;
CIMNamespaceName handlerNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
CIMName creationClass = PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG;
if (_isBatchNamespace )
{
handlerNS = _batchNamespace;
}
else if (!handlerNamespace.isNull())
{
handlerNS = handlerNamespace;
}
if (handlerCreationClass != String::EMPTY)
{
creationClass = handlerCreationClass;
}
CIMInstance handlerInstance(creationClass);
handlerInstance.addProperty(CIMProperty(CIMName("Name"), handlerName));
_client->createInstance(
handlerNS,
handlerInstance);
return (RC_SUCCESS);
}
//// create a specify Email handler instance
//
Uint32 CIMSubCommand::_createEmailHandler(
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
const Array<String>& mailTo,
const Array<String>& mailCc,
const String& mailSubject,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
CIMObjectPath handlerPath;
CIMNamespaceName handlerNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
CIMName creationClass = PEGASUS_CLASSNAME_LSTNRDST_EMAIL;
if (_isBatchNamespace )
{
handlerNS = _batchNamespace;
}
else if (!handlerNamespace.isNull())
{
handlerNS = handlerNamespace;
}
if (handlerCreationClass != String::EMPTY)
{
creationClass = handlerCreationClass;
}
CIMInstance handlerInstance(creationClass);
handlerInstance.addProperty(CIMProperty(CIMName("Name"), handlerName));
handlerInstance.addProperty(CIMProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_MAILTO,
mailTo));
handlerInstance.addProperty(CIMProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_MAILCC,
mailCc));
handlerInstance.addProperty(CIMProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_MAILSUBJECT,
mailSubject));
_client->createInstance(
handlerNS,
handlerInstance);
return (RC_SUCCESS);
}
//// create a specify Snmp Mapper handler instance
//
Uint32 CIMSubCommand::_createSnmpMapperHandler(
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
const String& targetHost,
Uint32 snmpPort,
Uint32 snmpVersion,
const String& securityName,
const String& engineId,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
CIMObjectPath handlerPath;
CIMNamespaceName handlerNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
CIMName creationClass = PEGASUS_CLASSNAME_INDHANDLER_SNMP;
Uint16 targetHostFormat = 2; //Host Name
if (_isBatchNamespace )
{
handlerNS = _batchNamespace;
}
else if (!handlerNamespace.isNull())
{
handlerNS = handlerNamespace;
}
if (handlerCreationClass != String::EMPTY)
{
creationClass = handlerCreationClass;
}
CIMInstance handlerInstance(creationClass);
handlerInstance.addProperty(CIMProperty(CIMName("Name"), handlerName));
{
HostAddress tgtHost;
tgtHost.setHostAddress(targetHost);
if (tgtHost.getAddressType() == HostAddress::AT_IPV4)
{
targetHostFormat = 3; //Ipv4
}
else if(tgtHost.getAddressType() == HostAddress::AT_IPV6)
{
targetHostFormat = 4; //Ipv6
}
}
handlerInstance.addProperty(CIMProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_TARGETHOST,
targetHost));
handlerInstance.addProperty(CIMProperty(
"TargetHostFormat",
(Uint16)targetHostFormat));
handlerInstance.addProperty(CIMProperty(
"PortNumber",
snmpPort));
handlerInstance.addProperty(CIMProperty(
"SNMPVersion",
(Uint16)snmpVersion));
if (securityName != String::EMPTY)
{
handlerInstance.addProperty(CIMProperty(
"SNMPSecurityName",
securityName));
}
if (engineId != String::EMPTY)
{
handlerInstance.addProperty(CIMProperty(
"SNMPEngineID",
engineId));
}
_client->createInstance(
handlerNS,
handlerInstance);
return (RC_SUCCESS);
}
//// remove an existing handler instance
//
Uint32 CIMSubCommand::_removeHandler(
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
CIMObjectPath handlerPath;
CIMNamespaceName handlerNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
if (_isBatchNamespace )
{
handlerNS = _batchNamespace;
}
else if (!handlerNamespace.isNull())
{
handlerNS = handlerNamespace;
}
if (_findHandler(handlerName, handlerNS, handlerCreationClass,
errPrintWriter, handlerPath))
{
_client->deleteInstance(handlerNS, handlerPath);
return (RC_SUCCESS);
}
else
{
outPrintWriter << localizeMessage(MSG_PATH,
HANDLER_NOT_FOUND_KEY,
HANDLER_NOT_FOUND_FAILURE) << endl;
return RC_OBJECT_NOT_FOUND;
}
}
//
// find a matching handler
//
Boolean CIMSubCommand::_findHandler(
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
ostream& errPrintWriter,
CIMObjectPath& handlerPath)
{
Array<CIMObjectPath> handlerPaths;
String handlerCC = PEGASUS_CLASSNAME_LSTNRDST_CIMXML.getString();
Boolean status = false;
if (handlerCreationClass != String::EMPTY)
{
handlerCC = handlerCreationClass;
}
try
{
handlerPaths = _client->enumerateInstanceNames(
handlerNamespace,
handlerCC);
}
catch (CIMException& e)
{
if (e.getCode() == CIM_ERR_INVALID_CLASS)
{
return false;
}
else
{
throw;
}
}
Uint32 handlerCount = handlerPaths.size();
if (handlerCount > 0)
{
// find matching indication handler
for (Uint32 i = 0; i < handlerCount; i++)
{
Boolean nameFound = false;
CIMObjectPath hPath = handlerPaths[i];
Array<CIMKeyBinding> keys = hPath.getKeyBindings();
for( Uint32 j=0; j < keys.size(); j++)
{
if (keys[j].getName().equal(PEGASUS_PROPERTYNAME_NAME))
{
String handlerNameValue = keys[j].getValue();
if (handlerNameValue == handlerName )
{
nameFound = true;
break;
}
}
}
if (nameFound)
{
status = true;
handlerPath = hPath;
break;
}
}
}
return status;
}
//
// Modify a subscription state
//
void CIMSubCommand::_modifySubscriptionState(
const CIMNamespaceName& subscriptionNS,
const CIMObjectPath& targetPath,
const Uint16 newState,
ostream& outPrintWriter)
{
Boolean alreadySet = false;
CIMInstance targetInstance = _client->getInstance(subscriptionNS,
targetPath);
Uint32 pos = targetInstance.findProperty (
PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE);
if (pos != PEG_NOT_FOUND)
{
Uint16 subscriptionState;
if (targetInstance.getProperty(pos).getValue().isNull())
{
subscriptionState = STATE_UNKNOWN;
}
else
{
targetInstance.getProperty(pos).getValue().get
(subscriptionState);
if (subscriptionState == newState)
{
if (newState == STATE_ENABLED )
{
outPrintWriter << localizeMessage(MSG_PATH,
SUBSCRIPTION_ALREADY_ENABLED_KEY,
SUBSCRIPTION_ALREADY_ENABLED) << endl;
}
else
{
outPrintWriter << localizeMessage(MSG_PATH,
SUBSCRIPTION_ALREADY_DISABLED_KEY,
SUBSCRIPTION_ALREADY_DISABLED) << endl;
}
alreadySet = true;
}
}
if (!alreadySet)
{
targetInstance.getProperty(pos).setValue(newState);
Array <CIMName> propertyNames;
propertyNames.append(PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE);
CIMPropertyList properties(propertyNames);
targetInstance.setPath(targetPath);
_client->modifyInstance(subscriptionNS, targetInstance, false,
properties);
}
}
}
//
// find a subscription
//
Boolean CIMSubCommand::_findSubscription(
const CIMNamespaceName& subscriptionNamespace,
const String& filterName,
const CIMNamespaceName& filterNamespace,
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCC,
Array<CIMObjectPath>& subscriptionFound)
{
Array<CIMObjectPath> subscriptionPaths;
String handlerCreationClass;
if (handlerCC != String::EMPTY)
{
handlerCreationClass = handlerCC;
}
try
{
subscriptionPaths = _client->enumerateInstanceNames(
subscriptionNamespace, PEGASUS_CLASSNAME_INDSUBSCRIPTION);
}
catch (CIMException& e)
{
if (e.getCode() == CIM_ERR_INVALID_CLASS)
{
return false;
}
else
{
throw;
}
}
Uint32 subscriptionCount = subscriptionPaths.size();
if (subscriptionCount > 0)
{
String handlerNameString, filterNameString;
CIMNamespaceName handlerNS, filterNS;
// Search the indication subscriptions instances
for (Uint32 i = 0; i < subscriptionCount; i++)
{
CIMObjectPath subPath = subscriptionPaths[i];
CIMObjectPath filterRef;
if (_filterMatches(subPath, subscriptionNamespace,
filterName, filterNamespace, filterNS, filterRef))
{
CIMObjectPath handlerRef;
if(_handlerMatches(subPath, subscriptionNamespace,
handlerName, handlerNamespace, handlerCreationClass,
handlerNS, handlerRef))
{
subscriptionFound.append(subPath);
}
}
}
}
return subscriptionFound.size() > 0;
}
//
// Find a subscription and modify it's state
//
Uint32 CIMSubCommand::_findAndModifyState(
const Uint16 newState,
const CIMNamespaceName& subscriptionNamespace,
const String& filterName,
const CIMNamespaceName& filterNamespace,
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
ostream& outPrintWriter)
{
Array<CIMObjectPath> allSubscriptionFound;
CIMNamespaceName filterNS;
CIMNamespaceName handlerNS;
CIMNamespaceName subscriptionNS = _DEFAULT_SUBSCRIPTION_NAMESPACE;
if (_isBatchNamespace )
{
subscriptionNS = _batchNamespace;
}
else if (!subscriptionNamespace.isNull())
{
subscriptionNS = subscriptionNamespace;
}
if (_isBatchNamespace )
{
filterNS = _batchNamespace;
}
else if (!filterNamespace.isNull())
{
filterNS = filterNamespace;
}
else
{
filterNS = subscriptionNS;
}
if (_isBatchNamespace )
{
handlerNS = _batchNamespace;
}
else if (!handlerNamespace.isNull())
{
handlerNS = handlerNamespace;
}
else
{
handlerNS = subscriptionNS;
}
// Find subscriptions in the namespace specified by the user
if (_findSubscription(subscriptionNS, filterName, filterNS,
handlerName, handlerNS, handlerCreationClass, allSubscriptionFound))
{
for(Uint32 i = 0;i<allSubscriptionFound.size();i++)
{
_modifySubscriptionState(
subscriptionNS,
allSubscriptionFound[i],
newState,
outPrintWriter);
}
return(RC_SUCCESS);
}
else
{
outPrintWriter << localizeMessage(MSG_PATH,
SUBSCRIPTION_NOT_FOUND_KEY,
SUBSCRIPTION_NOT_FOUND_FAILURE) << endl;
return(RC_OBJECT_NOT_FOUND);
}
}
//
// Get the name from a CIMObjectPath
//
String CIMSubCommand::_getNameInKey(const CIMObjectPath& r)
{
String nameValue;
Array<CIMKeyBinding> keys = r.getKeyBindings();
for (Uint32 j=0; j < keys.size(); j++)
{
if (keys[j].getName().equal(PEGASUS_PROPERTYNAME_NAME))
{
nameValue = keys[j].getValue();
}
}
return (nameValue);
}
//
// Get all namespaces
//
//
void CIMSubCommand::_getAllNamespaces(
Array<CIMNamespaceName>& namespaceNames)
{
Array<CIMObjectPath> instanceNames = _client->enumerateInstanceNames(
PEGASUS_VIRTUAL_TOPLEVEL_NAMESPACE,
PEGASUS_CLASSNAME___NAMESPACE);
// for all new elements in the output array
for (Uint32 i = 0; i < instanceNames.size(); i++)
{
Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();
for (Uint32 j=0; j < keys.size(); j++)
{
if (keys[j].getName().equal(PEGASUS_PROPERTYNAME_NAME))
{
namespaceNames.append(keys[j].getValue());
}
}
}
}
//
// get a list of all Handlers in the specified namespace(s)
//
void CIMSubCommand::_listHandlers(
const String& handlerName,
const Array<CIMNamespaceName>& namespaceNames,
const String& handlerCreationClass,
const Boolean verbose,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
Array <Uint32> maxColumnWidth;
Array <ListColumnEntry> listOutputTable;
Array<String> handlersFound;
Array<String> destinationsFound;
Array<CIMInstance> instancesFound;
Array<Uint32> handlerTypesFound;
const String handlerTitle = "HANDLER";
const String destinationTitle = "DESTINATION";
if (!verbose)
{
handlersFound.append(handlerTitle);
maxColumnWidth.append(handlerTitle.size());
destinationsFound.append(destinationTitle);
maxColumnWidth.append(destinationTitle.size());
}
listOutputTable.append(handlersFound);
listOutputTable.append(destinationsFound);
//
// Find handlers in namespaces
//
if (_isBatchNamespace )
{
_getHandlerList(
handlerName,
_batchNamespace,
handlerCreationClass,
verbose,
instancesFound,
handlerTypesFound,
maxColumnWidth,
listOutputTable,
outPrintWriter,
errPrintWriter);
}
else
{
for (Uint32 i = 0 ; i < namespaceNames.size() ; i++)
{
_getHandlerList(
handlerName,
namespaceNames[i],
handlerCreationClass,
verbose,
instancesFound,
handlerTypesFound,
maxColumnWidth,
listOutputTable,
outPrintWriter,
errPrintWriter);
}
}
if (verbose)
{
if (listOutputTable[_HANDLER_LIST_NAME_COLUMN].size() > 0 )
{
_printHandlersVerbose(instancesFound, handlerTypesFound,
listOutputTable, outPrintWriter);
}
}
else
{
if (listOutputTable[_HANDLER_LIST_NAME_COLUMN].size() > 1 )
{
_printColumns(maxColumnWidth, listOutputTable, outPrintWriter);
}
}
}
//
// get a list of all handlers in a specified namespace
//
void CIMSubCommand::_getHandlerList(
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
const Boolean verbose,
Array<CIMInstance>& instancesFound,
Array<Uint32>& handlerTypesFound,
Array <Uint32>& maxColumnWidth,
Array <ListColumnEntry>& listOutputTable,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
Array<CIMObjectPath> handlerPaths;
try
{
handlerPaths = _client->enumerateInstanceNames(
handlerNamespace,
PEGASUS_CLASSNAME_LSTNRDST);
}
catch(CIMException& e)
{
if (e.getCode() == CIM_ERR_INVALID_CLASS)
{
return;
}
else
{
throw;
}
}
Uint32 handlerCount = handlerPaths.size();
if (handlerCount > 0)
{
String handlerNameValue;
String destination;
String creationClassValue;
// List all the indication handlers
for (Uint32 i = 0; i < handlerCount; i++)
{
Boolean isMatch = true;
CIMObjectPath handlerPath;
CIMObjectPath hPath = handlerPaths[i];
Array<CIMKeyBinding> keys = hPath.getKeyBindings();
for(Uint32 j=0; j < keys.size(); j++)
{
if(keys[j].getName().equal(PEGASUS_PROPERTYNAME_NAME))
{
handlerNameValue = keys[j].getValue();
}
if(keys[j].getName().equal(
PEGASUS_PROPERTYNAME_CREATIONCLASSNAME))
{
creationClassValue = keys[j].getValue();
}
}
if (handlerName != String::EMPTY)
{
if (handlerNameValue == handlerName)
{
if (handlerCreationClass != String::EMPTY)
{
if (handlerCreationClass !=
creationClassValue)
{
isMatch = false;
}
}
}
else
{
isMatch = false;
}
}
if (isMatch)
{
handlerPath = hPath;
CIMInstance handlerInstance = _client->getInstance(
handlerNamespace, handlerPath);
Uint32 handlerType = _HANDLER_CIMXML;
_getHandlerDestination(handlerInstance, creationClassValue,
handlerType, destination);
String handlerString = handlerNamespace.getString();
handlerString.append(DELIMITER_NAMESPACE);
handlerString.append(creationClassValue);
handlerString.append(DELIMITER_HANDLER_CLASS);
handlerString.append(handlerNameValue);
listOutputTable[_HANDLER_LIST_NAME_COLUMN].append(
handlerString);
listOutputTable[_HANDLER_LIST_DESTINATION_COLUMN].append(
destination);
handlerTypesFound.append(handlerType);
if (verbose)
{
instancesFound.append(handlerInstance);
}
else
{
if (handlerString.size() >
maxColumnWidth[_HANDLER_LIST_NAME_COLUMN])
{
maxColumnWidth[_HANDLER_LIST_NAME_COLUMN] =
handlerString.size();
}
if (destination.size() >
maxColumnWidth[_HANDLER_LIST_DESTINATION_COLUMN])
{
maxColumnWidth[_HANDLER_LIST_DESTINATION_COLUMN] =
destination.size();
}
}
}
}
}
}
//
// print a verbose list of Handlers
//
void CIMSubCommand::_printHandlersVerbose(
const Array<CIMInstance>& instancesFound,
const Array<Uint32>& handlerTypesFound,
const Array <ListColumnEntry>& listOutputTable,
ostream& outPrintWriter)
{
Uint32 maxEntries = listOutputTable[_HANDLER_LIST_NAME_COLUMN].size();
Array <Uint32> indexes;
for (Uint32 i = 0; i < maxEntries; i++)
{
indexes.append (i);
}
_bubbleIndexSort (listOutputTable[_HANDLER_LIST_NAME_COLUMN], 0, indexes);
for (Uint32 i = 0; i < maxEntries; i++)
{
Uint32 pos;
CIMInstance handlerInstance = instancesFound[indexes[i]];
outPrintWriter << "Handler: " <<
(listOutputTable[_HANDLER_LIST_NAME_COLUMN])[indexes[i]] << endl;
switch (handlerTypesFound[indexes[i]])
{
case _HANDLER_SNMP:
{
String targetHost;
pos = handlerInstance.findProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_TARGETHOST);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get
(targetHost);
}
outPrintWriter << "TargetHost: " << targetHost
<< endl;
outPrintWriter << "SNMPVersion: " <<
_getSnmpVersion(handlerInstance) << endl;
break;
}
case _HANDLER_EMAIL:
{
String mailCc;
String mailTo;
String mailSubject;
_getEmailInfo(handlerInstance, mailCc,
mailTo, mailSubject );
outPrintWriter << "MailTo: " <<
mailTo << endl;
if (mailCc.size() > 0 )
{
outPrintWriter << "MailCc: " <<
mailCc << endl;
}
if (mailSubject.size() > 0 )
{
outPrintWriter << "MailSubject: " <<
mailSubject << endl;
}
break;
}
case _HANDLER_SYSLOG:
{
break;
}
case _HANDLER_CIMXML:
{
outPrintWriter << "Destination: " <<
(listOutputTable[_HANDLER_LIST_DESTINATION_COLUMN])
[indexes[i]]
<< endl;
}
}
outPrintWriter << "PersistenceType: " <<
_getPersistenceType(handlerInstance) << endl;
outPrintWriter << "-----------------------------------------"
<< endl;
}
}
//
// get a list of all filters in the specified namespace(s)
//
void CIMSubCommand::_listFilters(
const String& filterName,
const Boolean verbose,
const Array<CIMNamespaceName>& namespaceNames,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
Array <Uint32> maxColumnWidth;
Array <ListColumnEntry> listOutputTable;
Array<String> filtersFound;
Array<String> querysFound;
Array<String> queryLangsFound;
Array<String> filterSourceNamespaces;
const String filterTitle = "FILTER";
const String queryTitle = "QUERY";
if (!verbose)
{
filtersFound.append(filterTitle);
maxColumnWidth.append(filterTitle.size());
querysFound.append(queryTitle);
maxColumnWidth.append(queryTitle.size());
}
listOutputTable.append(filtersFound);
listOutputTable.append(querysFound);
// Find filters in namespaces
if (_isBatchNamespace )
{
_getFilterList(
filterName,
_batchNamespace,
verbose,
maxColumnWidth,
listOutputTable,
queryLangsFound,
filterSourceNamespaces,
outPrintWriter,
errPrintWriter);
}
else
{
for (Uint32 i = 0 ; i < namespaceNames.size(); i++)
{
_getFilterList(
filterName,
namespaceNames[i],
verbose,
maxColumnWidth,
listOutputTable,
queryLangsFound,
filterSourceNamespaces,
outPrintWriter,
errPrintWriter);
}
}
if (verbose)
{
if (listOutputTable[_FILTER_LIST_NAME_COLUMN].size() > 0)
{
_printFiltersVerbose(
listOutputTable,
queryLangsFound,
filterSourceNamespaces,
outPrintWriter);
}
}
else
{
if (listOutputTable[_FILTER_LIST_NAME_COLUMN].size() > 1)
{
_printColumns(maxColumnWidth, listOutputTable, outPrintWriter);
}
}
}
//
// get a list of all filters in the specified namespace(s)
//
void CIMSubCommand::_printFiltersVerbose(
const Array <ListColumnEntry>& listOutputTable,
const Array <String>& queryLangs,
const Array<String>& filterSourceNamespaces,
ostream& outPrintWriter)
{
Uint32 maxEntries = listOutputTable[_FILTER_LIST_NAME_COLUMN].size();
Array <Uint32> indexes;
for (Uint32 i = 0; i < maxEntries; i++)
{
indexes.append(i);
}
_bubbleIndexSort (listOutputTable[_FILTER_LIST_NAME_COLUMN], 0, indexes);
for (Uint32 i = 0; i < maxEntries; i++)
{
outPrintWriter << "Filter: " <<
(listOutputTable[_FILTER_LIST_NAME_COLUMN])[indexes[i]] << endl;
outPrintWriter << "Query: " <<
(listOutputTable[_FILTER_LIST_QUERY_COLUMN])[indexes[i]] << endl;
outPrintWriter << "Query Language: " <<
queryLangs[indexes[i]] << endl;
outPrintWriter << "Source Namespace: ";
for (Uint32 j = 0; j < filterSourceNamespaces.size(); j++)
{
if ( j < filterSourceNamespaces.size() - 1)
{
outPrintWriter<< filterSourceNamespaces[j]<<",";
}
else
{
outPrintWriter<< filterSourceNamespaces[j]<<endl;
}
}
outPrintWriter <<
"-----------------------------------------" << endl;
}
}
//
// get a list of all filters in the specified namespace
//
void CIMSubCommand::_getFilterList(
const String& filterName,
const CIMNamespaceName& filterNamespace,
const Boolean verbose,
Array <Uint32>& maxColumnWidth,
Array <ListColumnEntry>& listOutputTable,
Array <String>& queryLangsFound,
Array<String>& filterSourceNamespaces,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
Array<CIMObjectPath> filterPaths;
try
{
filterPaths = _client->enumerateInstanceNames(
filterNamespace,
PEGASUS_CLASSNAME_INDFILTER);
}
catch(CIMException& e)
{
if (e.getCode() == CIM_ERR_INVALID_CLASS)
{
return;
}
else
{
throw;
}
}
Uint32 filterCount = filterPaths.size();
if (filterCount > 0)
{
CIMObjectPath filterPath;
String filterNameValue;
// List all the indication filters
for (Uint32 i = 0; i < filterCount; i++)
{
Boolean isMatch = true;
CIMObjectPath fPath = filterPaths[i];
Array<CIMKeyBinding> keys = fPath.getKeyBindings();
for(Uint32 j=0; j < keys.size(); j++)
{
if(keys[j].getName().equal(PEGASUS_PROPERTYNAME_NAME))
{
filterNameValue = keys[j].getValue();
filterPath = fPath;
if (filterName != String::EMPTY)
{
if (filterNameValue == filterName)
{
break;
}
else
{
isMatch = false;
break;
}
}
else
{
break;
}
}
}
if (isMatch)
{
String queryString,queryLanguageString;
String filterString = filterNamespace.getString();
String sourceNamespaceString = filterNamespace.getString();
filterString.append(DELIMITER_NAMESPACE);
filterString.append(filterNameValue);
_getFilterInfo(
filterNamespace,
filterPath,
queryString,
queryLanguageString,
filterSourceNamespaces);
listOutputTable[_FILTER_LIST_NAME_COLUMN].append(filterString);
listOutputTable[_FILTER_LIST_QUERY_COLUMN].append(queryString);
if (verbose)
{
queryLangsFound.append(queryLanguageString);
}
else
{
if (filterString.size () >
maxColumnWidth[_FILTER_LIST_NAME_COLUMN])
{
maxColumnWidth[_FILTER_LIST_NAME_COLUMN] =
filterString.size();
}
if (queryString.size() >
maxColumnWidth[_FILTER_LIST_QUERY_COLUMN])
{
maxColumnWidth[_FILTER_LIST_QUERY_COLUMN] =
queryString.size();
}
}
}
}
}
}
//
// get the query string for a filter
//
void CIMSubCommand::_getFilterInfo(
const CIMNamespaceName& filterNamespace,
const CIMObjectPath& filterPath,
String& queryString,
String& queryLangString,
Array<String>& filterSourceNamespaces)
{
String query;
String filterSourceNamespace;
queryString = "\"";
CIMInstance filterInstance = _client->getInstance(
filterNamespace, filterPath);
Uint32 pos = filterInstance.findProperty(
PEGASUS_PROPERTYNAME_QUERY);
if (pos != PEG_NOT_FOUND)
{
filterInstance.getProperty(pos).getValue().get(query);
queryString.append(query);
}
queryString.append("\"");
pos = filterInstance.findProperty(
PEGASUS_PROPERTYNAME_QUERYLANGUAGE);
if (pos != PEG_NOT_FOUND)
{
filterInstance.getProperty(pos).getValue().get(queryLangString);
}
pos = filterInstance.findProperty(
CIMNameCast("SourceNamespace"));
if (pos != PEG_NOT_FOUND)
{
filterInstance.getProperty(pos).getValue().get(filterSourceNamespace);
filterSourceNamespaces.append(filterSourceNamespace);
}
pos = filterInstance.findProperty(
CIMNameCast("SourceNamespaces"));
if (pos != PEG_NOT_FOUND)
{
filterSourceNamespaces.clear();
filterInstance.getProperty(pos).getValue().get(
filterSourceNamespaces);
}
if (filterSourceNamespaces.size() == 0)
{
filterSourceNamespaces.append(filterSourceNamespace);
}
}
//
// list all subscriptions is the specified namespace(s)
//
void CIMSubCommand::_listSubscriptions(
const Array<CIMNamespaceName>& namespaceNames,
const String& filterName,
const CIMNamespaceName& filterNamespace,
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
const Boolean verbose,
ostream& outPrintWriter,
ostream& errPrintWriter)
{
Array <Uint32> maxColumnWidth;
Array <ListColumnEntry> listOutputTable;
Array<String> namespacesFound;
Array<String> filtersFound;
Array<String> handlersFound;
Array<String> statesFound;
Array<CIMInstance> handlerInstancesFound;
Array<Uint32> handlerTypesFound;
Array<String> querysFound;
const String namespaceTitle = "NAMESPACE";
const String filterTitle = "FILTER";
const String handlerTitle = "HANDLER";
const String stateTitle = "STATE";
if (!verbose)
{
namespacesFound.append(namespaceTitle);
maxColumnWidth.append(namespaceTitle.size());
filtersFound.append(filterTitle);
maxColumnWidth.append(filterTitle.size());
handlersFound.append(handlerTitle);
maxColumnWidth.append(handlerTitle.size());
statesFound.append(stateTitle);
maxColumnWidth.append(stateTitle.size());
}
listOutputTable.append(namespacesFound);
listOutputTable.append(filtersFound);
listOutputTable.append(handlersFound);
listOutputTable.append(statesFound);
if (_isBatchNamespace)
{
_getSubscriptionList(
_batchNamespace,
filterName,
_batchNamespace,
handlerName,
_batchNamespace,
handlerCreationClass,
verbose,
handlerInstancesFound,
handlerTypesFound,
querysFound,
maxColumnWidth,
listOutputTable);
}
else
{
for (Uint32 i = 0 ; i < namespaceNames.size() ; i++)
{
_getSubscriptionList(
namespaceNames[i],
filterName,
filterNamespace,
handlerName,
handlerNamespace,
handlerCreationClass,
verbose,
handlerInstancesFound,
handlerTypesFound,
querysFound,
maxColumnWidth,
listOutputTable);
}
}
if (verbose)
{
if (listOutputTable[_SUBSCRIPTION_LIST_NS_COLUMN].size() > 0)
{
_printSubscriptionsVerbose(handlerInstancesFound,
handlerTypesFound, querysFound, listOutputTable,
outPrintWriter);
}
}
else
{
if (listOutputTable[_SUBSCRIPTION_LIST_NS_COLUMN].size() > 1)
{
_printColumns(maxColumnWidth, listOutputTable, outPrintWriter);
}
}
}
//
// get a list of subscriptions in the specifed namespace
//
void CIMSubCommand::_getSubscriptionList(
const CIMNamespaceName& subscriptionNSIn,
const String& filterName,
const CIMNamespaceName& filterNSIn,
const String& handlerName,
const CIMNamespaceName& handlerNSIn,
const String& handlerCCIn,
const Boolean verbose,
Array<CIMInstance>& handlerInstancesFound,
Array<Uint32>& handlerTypesFound,
Array<String>& querysFound,
Array <Uint32>& maxColumnWidth,
Array <ListColumnEntry>& listOutputTable
)
{
Array<CIMObjectPath> subscriptionPaths;
String query;
String destination;
CIMNamespaceName filterNamespace;
CIMNamespaceName handlerNamespace;
CIMNamespaceName subscriptionNamespace = _DEFAULT_SUBSCRIPTION_NAMESPACE;
String handlerCreationClass;
if (!subscriptionNSIn.isNull())
{
subscriptionNamespace = subscriptionNSIn;
}
if (!filterNSIn.isNull())
{
filterNamespace = filterNSIn;
}
if (!handlerNSIn.isNull())
{
handlerNamespace = handlerNSIn;
}
if (handlerCCIn != String::EMPTY)
{
handlerCreationClass = handlerCCIn;
}
try
{
subscriptionPaths = _client->enumerateInstanceNames(
subscriptionNamespace,
PEGASUS_CLASSNAME_INDSUBSCRIPTION);
}
catch(CIMException& e)
{
if (e.getCode() == CIM_ERR_INVALID_CLASS)
{
return;
}
else
{
throw;
}
}
Uint32 subscriptionCount = subscriptionPaths.size();
if (subscriptionCount > 0)
{
String handlerNameString, filterNameString;
CIMObjectPath handlerPath, filterPath;
CIMNamespaceName handlerNS, filterNS;
// List all the indication subscriptions
for (Uint32 i = 0; i < subscriptionCount; i++)
{
CIMObjectPath subPath = subscriptionPaths[i];
CIMObjectPath filterRef, handlerRef;
Boolean filterMatch = true;
Boolean handlerMatch = true;
String creationClassName;
//
// Get the subscription Filter
//
filterMatch = _filterMatches(subPath, subscriptionNamespace,
filterName, filterNamespace, filterNS, filterRef);
if (filterMatch)
{
filterNameString = _getNameInKey(filterRef);
handlerMatch = _handlerMatches(subPath, subscriptionNamespace,
handlerName, handlerNamespace, handlerCreationClass,
handlerNS, handlerRef);
if (handlerMatch)
{
handlerNameString = _getNameInKey(handlerRef);
}
}
if ((filterMatch) && (handlerMatch))
{
// Get the destination for this handler.
CIMInstance handlerInstance = _client->getInstance(
handlerNS, handlerRef);
Uint32 handlerType;
_getHandlerDestination(handlerInstance, creationClassName,
handlerType, destination);
String handlerString = handlerNS.getString();
handlerString.append(DELIMITER_NAMESPACE);
handlerString.append(creationClassName);
handlerString.append(DELIMITER_HANDLER_CLASS);
handlerString.append(handlerNameString);
String statusValue = _getSubscriptionState(
subscriptionNamespace, subPath);
// Save for columnar listing
listOutputTable[_SUBSCRIPTION_LIST_NS_COLUMN].append
(subscriptionNamespace.getString());
String filterString = filterNS.getString();
filterString.append(DELIMITER_NAMESPACE);
filterString.append(filterNameString);
listOutputTable[_SUBSCRIPTION_LIST_FILTER_COLUMN].append
(filterString);
listOutputTable[_SUBSCRIPTION_LIST_HANDLER_COLUMN].append
(handlerString);
listOutputTable[_SUBSCRIPTION_LIST_STATE_COLUMN].append
(statusValue);
if (verbose)
{
String queryString, queryLangString, sourceNamespace;
Array <String> sourceNamespaces;
handlerInstancesFound.append (handlerInstance);
handlerTypesFound.append (handlerType);
_getFilterInfo(filterNS, filterRef, queryString,
queryLangString,sourceNamespaces);
querysFound.append(queryString);
}
else
{
if (subscriptionNamespace.getString().size() >
maxColumnWidth[_SUBSCRIPTION_LIST_NS_COLUMN])
{
maxColumnWidth[_SUBSCRIPTION_LIST_NS_COLUMN] =
subscriptionNamespace.getString().size();
}
if (filterString.size() >
maxColumnWidth[_SUBSCRIPTION_LIST_FILTER_COLUMN])
{
maxColumnWidth[_SUBSCRIPTION_LIST_FILTER_COLUMN] =
filterString.size();
}
if (handlerString.size() >
maxColumnWidth[_SUBSCRIPTION_LIST_HANDLER_COLUMN])
{
maxColumnWidth[_SUBSCRIPTION_LIST_HANDLER_COLUMN] =
handlerString.size();
}
if (statusValue.size() >
maxColumnWidth[_SUBSCRIPTION_LIST_STATE_COLUMN])
{
maxColumnWidth[_SUBSCRIPTION_LIST_STATE_COLUMN] =
statusValue.size();
}
}
}
}
}
}
//
// get the handler destination and type
//
void CIMSubCommand::_getHandlerDestination(
const CIMInstance& handlerInstance,
String& creationClassName,
Uint32& handlerTypeFound,
String& destination)
{
Uint32 pos;
pos = handlerInstance.findProperty(
PEGASUS_PROPERTYNAME_CREATIONCLASSNAME);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get
(creationClassName);
}
handlerTypeFound = _HANDLER_CIMXML;
destination = String::EMPTY;
if (handlerInstance.getClassName() ==
PEGASUS_CLASSNAME_INDHANDLER_SNMP)
{
handlerTypeFound = _HANDLER_SNMP;
String targetHost;
pos = handlerInstance.findProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_TARGETHOST);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get
(targetHost);
}
destination = targetHost;
}
else
{
if (handlerInstance.getClassName() ==
PEGASUS_CLASSNAME_LSTNRDST_EMAIL)
{
handlerTypeFound = _HANDLER_EMAIL;
Array <String> mailTo;
pos = handlerInstance.findProperty
(PEGASUS_PROPERTYNAME_LSTNRDST_MAILTO);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get
(mailTo);
}
for (Uint32 eIndex=0; eIndex < mailTo.size();
eIndex++)
{
destination.append (mailTo[eIndex]);
destination.append (" ");
}
}
else
{
if (creationClassName ==
PEGASUS_CLASSNAME_LSTNRDST_SYSTEM_LOG)
{
handlerTypeFound = _HANDLER_SYSLOG;
}
else
{
pos = handlerInstance.findProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty (pos).getValue ().get
(destination);
}
}
}
}
}
//
// print a verbose list of subscriptions
//
void CIMSubCommand::_printSubscriptionsVerbose(
const Array<CIMInstance>& handlerInstancesFound,
const Array<Uint32>& handlerTypesFound,
const Array<String>& querysFound,
const Array<ListColumnEntry>& listOutputTable,
ostream& outPrintWriter)
{
Uint32 maxEntries = listOutputTable[_SUBSCRIPTION_LIST_NS_COLUMN].size();
Array <Uint32> indexes;
for (Uint32 i = 0; i < maxEntries; i++)
{
indexes.append (i);
}
_bubbleIndexSort(listOutputTable[_SUBSCRIPTION_LIST_HANDLER_COLUMN], 0,
indexes);
_bubbleIndexSort(listOutputTable[_SUBSCRIPTION_LIST_FILTER_COLUMN], 0,
indexes);
_bubbleIndexSort(listOutputTable[_SUBSCRIPTION_LIST_NS_COLUMN], 0, indexes);
for (Uint32 i = 0; i < maxEntries; i++)
{
outPrintWriter << "Namespace: " <<
(listOutputTable[_SUBSCRIPTION_LIST_NS_COLUMN])[indexes[i]] << endl;
outPrintWriter << "Filter: " <<
(listOutputTable[_SUBSCRIPTION_LIST_FILTER_COLUMN])[indexes[i]]
<< endl;
outPrintWriter << "Handler: " <<
(listOutputTable[_SUBSCRIPTION_LIST_HANDLER_COLUMN])[indexes[i]]
<< endl;
outPrintWriter << "Query: " << querysFound[indexes[i]]
<< endl;
CIMInstance handlerInstance = handlerInstancesFound[indexes[i]];
switch (handlerTypesFound[indexes[i]])
{
case _HANDLER_SNMP:
{
String targetHost;
Uint32 pos = handlerInstance.findProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_TARGETHOST);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get
(targetHost);
}
outPrintWriter << "TargetHost: " << targetHost
<< endl;
outPrintWriter << "SNMPVersion: " <<
_getSnmpVersion(handlerInstance) << endl;
break;
}
case _HANDLER_EMAIL:
{
String mailCc;
String mailTo;
String mailSubject;
_getEmailInfo(handlerInstance, mailCc,
mailTo, mailSubject );
outPrintWriter << "MailTo: " <<
mailTo << endl;
if (mailCc.size() > 0 )
{
outPrintWriter << "MailCc: " <<
mailCc << endl;
}
if (mailSubject.size() > 0 )
{
outPrintWriter << "MailSubject: " <<
mailSubject << endl;
}
break;
}
case _HANDLER_SYSLOG:
{
break;
}
case _HANDLER_CIMXML:
{
String destination;
Uint32 pos = handlerInstance.findProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get
(destination);
}
outPrintWriter << "Destination: " << destination << endl;
}
}
outPrintWriter << "SubscriptionState: " <<
(listOutputTable[_SUBSCRIPTION_LIST_STATE_COLUMN])[indexes[i]] <<
endl;
outPrintWriter <<
"-----------------------------------------" << endl;
}
}
//
// check a subscription for a filter match
//
Boolean CIMSubCommand::_filterMatches(
const CIMObjectPath& subPath,
const CIMNamespaceName& subscriptionNS,
const String& filterName,
const CIMNamespaceName& filterNamespace,
CIMNamespaceName& filterNS,
CIMObjectPath& filterRef)
{
Boolean filterMatch = false;
String filterNameString;
//
// Get the subscription Filter
//
Array<CIMKeyBinding> keys = subPath.getKeyBindings();
for( Uint32 j=0; j < keys.size(); j++)
{
if (keys[j].getName().equal(PEGASUS_PROPERTYNAME_FILTER))
{
filterRef = keys[j].getValue();
}
}
filterNameString = _getNameInKey(filterRef);
CIMNamespaceName instanceNS = filterRef.getNameSpace();
if (filterName != String::EMPTY)
{
if (filterNameString == filterName)
{
if (!filterNamespace.isNull())
{
//
// If the Filter reference property value includes
// namespace, check if it is the namespace of the Filter.
// If the Filter reference property value does not
// include namespace, check if the current subscription
// namespace is the namespace of the Filter.
//
if(instanceNS.isNull()
|| filterNamespace == instanceNS)
{
filterNS = filterNamespace;
filterMatch = true;
}
}
else
{
// No namespace was specified and the filter name matches
filterMatch = true;
if (instanceNS.isNull())
{
filterNS = subscriptionNS;
}
else
{
filterNS = instanceNS;
}
}
}
else
{
// The filter name does not match
filterMatch = false;
}
}
else
{
filterMatch = true;
// No filter name was specified.
// Use the filter namespace if specified in the reference.
//
if (instanceNS.isNull())
{
filterNS = subscriptionNS;
}
else
{
filterNS = instanceNS;
}
}
return filterMatch;
}
//
// check a subscription for a handler match
//
Boolean CIMSubCommand::_handlerMatches(
const CIMObjectPath& subPath,
const CIMNamespaceName& subscriptionNS,
const String& handlerName,
const CIMNamespaceName& handlerNamespace,
const String& handlerCreationClass,
CIMNamespaceName& handlerNS,
CIMObjectPath& handlerRef)
{
Boolean handlerMatch = false;
String handlerNameString;
String creationClassName;
//
// Get the subscription Handler
//
Array<CIMKeyBinding> keys = subPath.getKeyBindings();
for( Uint32 j=0; j < keys.size(); j++)
{
if (keys[j].getName().equal(PEGASUS_PROPERTYNAME_HANDLER))
{
handlerRef = keys[j].getValue();
}
}
handlerNameString = _getNameInKey(handlerRef);
if (handlerName != String::EMPTY)
{
CIMNamespaceName instanceNS = handlerRef.getNameSpace();
if (handlerNameString == handlerName)
{
if (!handlerNamespace.isNull())
{
//
// If the Handler reference property value includes
// namespace, check if it is the namespace of the Handler.
// If the Handler reference property value does not
// include namespace, check if the current subscription
// namespace is the namespace of the Handler.
//
if(instanceNS.isNull()
|| handlerNamespace == instanceNS)
{
handlerNS = handlerNamespace;
handlerMatch = true;
}
}
else
{
// Handler namespace is not set and handler name matches
handlerMatch = true;
if (instanceNS.isNull())
{
handlerNS = subscriptionNS;
}
else
{
handlerNS = instanceNS;
}
}
}
else
{
// Handler name does not match
handlerMatch = false;
}
if (handlerMatch)
{
if(handlerCreationClass != String::EMPTY)
{
CIMInstance handlerInstance = _client->getInstance(
handlerNS, handlerRef);
Uint32 pos = handlerInstance.findProperty(
PEGASUS_PROPERTYNAME_CREATIONCLASSNAME);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get
(creationClassName);
}
if (handlerCreationClass != creationClassName)
{
handlerMatch = false;
}
}
}
}
else
{
handlerMatch = true;
//
// The handler was not specified.
// Use the handler namespace if specified in the reference.
//
CIMNamespaceName instanceNS = handlerRef.getNameSpace();
if (!instanceNS.isNull())
{
handlerNS = instanceNS;
}
else
{
handlerNS = subscriptionNS;
}
}
return handlerMatch;
}
//
// Get the subscription state string from a subscription instance
//
void CIMSubCommand::_getEmailInfo(
const CIMInstance& handlerInstance,
String& ccString,
String& toString,
String& subjectString)
{
Array <String> mailCc, mailTo;
subjectString = String::EMPTY;
mailTo.append(String::EMPTY);
Uint32 pos =
handlerInstance.findProperty(PEGASUS_PROPERTYNAME_LSTNRDST_MAILTO);
if( pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get(mailTo);
}
for (Uint32 eIndex=0; eIndex < mailTo.size();
eIndex++)
{
toString.append(mailTo[eIndex]);
toString.append(" ");
}
pos = handlerInstance.findProperty(PEGASUS_PROPERTYNAME_LSTNRDST_MAILCC);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get(mailCc);
}
if (mailCc.size() > 0)
{
for (Uint32 eIndex=0; eIndex < mailCc.size();
eIndex++)
{
ccString.append (mailCc[eIndex]);
ccString.append (" ");
}
}
pos = handlerInstance.findProperty(
PEGASUS_PROPERTYNAME_LSTNRDST_MAILSUBJECT);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get(subjectString);
}
}
//
// Get the persistence value from the handler instance
//
String CIMSubCommand::_getPersistenceType(const CIMInstance& handlerInstance)
{
Uint16 persistenceType = 1;
Uint32 pos =
handlerInstance.findProperty(PEGASUS_PROPERTYNAME_PERSISTENCETYPE);
if (pos != PEG_NOT_FOUND)
{
handlerInstance.getProperty(pos).getValue().get(persistenceType);
}
String persistenceString;
switch (persistenceType)
{
case PERSISTENCE_OTHER:
{
persistenceString = _PERSISTENTENCE_OTHER_STRING;
break;
}
case PERSISTENCE_PERMANENT:
{
persistenceString = _PERSISTENTENCE_PERMANENT_STRING;
break;
}
case PERSISTENCE_TRANSIENT:
{
persistenceString = _PERSISTENTENCE_TRANSIENT_STRING;
break;
}
default:
persistenceString = _PERSISTENTENCE_UNKNOWN_STRING;
}
return persistenceString;
}
//
// Get the subscription state string from a subscription instance
//
String CIMSubCommand::_getSubscriptionState(
const CIMNamespaceName& subscriptionNamespace,
const CIMObjectPath& subPath)
{
CIMInstance subInstance = _client->getInstance(subscriptionNamespace,
subPath);
Uint32 pos = subInstance.findProperty(
PEGASUS_PROPERTYNAME_SUBSCRIPTION_STATE);
Uint16 subscriptionState = STATE_UNKNOWN;
if (pos != PEG_NOT_FOUND)
{
if (!subInstance.getProperty(pos).getValue().isNull() )
{
subInstance.getProperty(pos).getValue().get(subscriptionState);
}
}
String statusString;
switch (subscriptionState)
{
case STATE_UNKNOWN:
{
statusString = _SUBSCRIPTION_STATE_UNKNOWN_STRING;
break;
}
case STATE_OTHER:
{
statusString = _SUBSCRIPTION_STATE_UNKNOWN_STRING;
break;
}
case STATE_ENABLED:
{
statusString = _SUBSCRIPTION_STATE_ENABLED_STRING;
break;
}
case STATE_ENABLEDDEGRADED:
{
statusString = _SUBSCRIPTION_STATE_ENABLED_DEGRADED_STRING;
break;
}
case STATE_DISABLED:
{
statusString = _SUBSCRIPTION_STATE_DISABLED_STRING;
break;
}
default:
statusString = _SUBSCRIPTION_STATE_NOT_SUPPORTED_STRING;
}
return statusString;
}
//
// Get the SNMP version string from a handler instance
//
String CIMSubCommand::_getSnmpVersion (const CIMInstance& handlerInstance)
{
Uint16 snmpVersion = 0;
Uint32 pos = handlerInstance.findProperty(PEGASUS_PROPERTYNAME_SNMPVERSION);
if (pos != PEG_NOT_FOUND)
{
if (!handlerInstance.getProperty(pos).getValue().isNull() )
{
handlerInstance.getProperty(pos).getValue().get(snmpVersion);
}
}
String snmpVersionString;
switch (snmpVersion)
{
case SNMPV1_TRAP:
snmpVersionString = _SNMP_VERSION_SNMPV1_TRAP_STRING;
break;
case SNMPV2C_TRAP:
snmpVersionString = _SNMP_VERSION_SNMPV2C_TRAP_STRING;
break;
default:
snmpVersionString = _SNMP_VERSION_PEGASUS_RESERVED_STRING;
}
return snmpVersionString;
}
//
// print data in a columnar form
//
void CIMSubCommand::_printColumns(
const Array <Uint32>& maxColumnWidth,
const Array <ListColumnEntry>& listOutputTable,
ostream& outPrintWriter)
{
Uint32 maxColumns = maxColumnWidth.size();
Uint32 maxEntries = listOutputTable[0].size();
Array <Uint32> indexes;
for (Uint32 i = 0; i < maxEntries; i++)
{
indexes.append(i);
}
for (int column = maxColumns-1; column >= 0; column--)
{
_bubbleIndexSort(listOutputTable[column], 1, indexes);
}
for (Uint32 i = 0; i < maxEntries; i++)
{
for (Uint32 column = 0; column < maxColumns-1; column++)
{
Uint32 outputItemSize =
(listOutputTable[column])[indexes[i]].size();
Uint32 fillerLen = maxColumnWidth[column] + TITLE_SEPERATOR_LEN -
outputItemSize;
outPrintWriter << (listOutputTable[column])[indexes[i]];
for (Uint32 j = 0; j < fillerLen; j++)
{
outPrintWriter << ' ';
}
}
outPrintWriter << (listOutputTable[maxColumns-1])[indexes[i]] << endl;
}
}
//
// Sort a string array by indexes
//
void CIMSubCommand::_bubbleIndexSort(
const Array<String>& x,
const Uint32 startIndex,
Array<Uint32>& index)
{
Uint32 n = x.size();
if (n < 3)
return;
for (Uint32 i = startIndex; i < (n-1); i++)
{
for (Uint32 j = startIndex; j < (n-1); j++)
{
if (String::compareNoCase(x[index[j]],
x[index[j+1]]) > 0)
{
Uint32 t = index[j];
index[j] = index[j+1];
index[j+1] = t;
}
}
}
}
PEGASUS_NAMESPACE_END
//
// exclude main from the Pegasus Namespace
//
PEGASUS_USING_PEGASUS;
PEGASUS_USING_STD;
///////////////////////////////////////////////////////////////////////////////
/**
Parses the command line, and execute the command.
@param args the string array containing the command line arguments
*/
///////////////////////////////////////////////////////////////////////////////
int main (int argc, char* argv[])
{
AutoPtr<CIMSubCommand> command;
Uint32 retCode;
#ifdef PEGASUS_OS_PASE
Uint32 ret = 0;
ret = umeCheckCmdAuthorities(COMMAND_NAME, true);
if (ret)
{
return Command::RC_ERROR;
}
#endif
#ifdef PEGASUS_OS_ZOS
// for z/OS set stdout and stderr to EBCDIC
setEBCDICEncoding(STDOUT_FILENO);
setEBCDICEncoding(STDERR_FILENO);
#endif
MessageLoader::_useProcessLocale = true;
MessageLoader::setPegasusMsgHomeRelative(argv[0]);
command.reset(new CIMSubCommand());
try
{
command->setCommand (cout, cerr, argc, argv);
}
catch (CommandFormatException& cfe)
{
cerr << COMMAND_NAME << ": " << cfe.getMessage() << endl;
MessageLoaderParms parms(ERR_USAGE_KEY,ERR_USAGE);
parms.msg_src_path = MSG_PATH;
cerr << COMMAND_NAME <<
": " << MessageLoader::getMessage(parms) << endl;
exit (Command::RC_ERROR);
}
retCode = command->execute(cout, cerr);
return (retCode);
}
| No CVS admin address has been configured |
Powered by ViewCVS 0.9.2 |