pegasus/src/Pegasus/ControlProviders/ProviderRegistrationProvider/ProviderRegistrationProvider.cpp - diff

Return to ProviderRegistrationProvider.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ControlProviders / ProviderRegistrationProvider

Diff for /pegasus/src/Pegasus/ControlProviders/ProviderRegistrationProvider/ProviderRegistrationProvider.cpp between version 1.4 and 1.49

version 1.4, 2002/04/20 21:15:26

version 1.49, 2003/08/19 18:06:57

Line 1

//%/////////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 25

Line 26

// Modified By: Chip Vincent (cvincent@us.ibm.com)

// Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

//%/////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/PegasusVersion.h>

#include "ProviderRegistrationProvider.h"

PEGASUS_NAMESPACE_BEGIN

#include <Pegasus/Common/PegasusVersion.h>

#include <Pegasus/Common/XmlWriter.h>

/**

#include <Pegasus/Common/Constants.h>

The name of the PG_Provider class

#include <Pegasus/Common/CIMMessage.h>

#include <Pegasus/Common/OperationContext.h>

static const char _CLASS_PG_PROVIDER [] = "PG_Provider";

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/MessageLoader.h> //l10n

/**

The name of the provider capabilities class

static const char _CLASS_PROVIDER_CAPABILITIES [] = "PG_ProviderCapabilities";

/**

The name of the provider module class

static const char _CLASS_PROVIDER_MODULE [] = "PG_ProviderModule";

/**

The name of the operational status property

static const char _PROPERTY_OPERATIONALSTATUS [] = "OperationalStatus";

/**

The name of the name property for PG_Provider class

static const char _PROPERTY_PROVIDER_NAME [] = "Name";

/**

The name of the Name property for PG_ProviderModule class

static const char _PROPERTY_PROVIDERMODULE_NAME [] = "Name";

/**

The name of the Version property for PG_ProviderModule class

static const char _PROPERTY_VERSION [] = "Version";

/**

The name of the interface type property for PG_ProviderModule class

static const char _PROPERTY_INTERFACETYPE [] = "InterfaceType";

/**

The name of the interface version property for PG_ProviderModule class

static const char _PROPERTY_INTERFACEVERSION [] = "InterfaceVersion";

/**

PEGASUS_NAMESPACE_BEGIN

The name of the location property for PG_ProviderModule class

static const char _PROPERTY_LOCATION [] = "Location";

/**

The name of the CapabilityID property for provider capabilities class

static const char _PROPERTY_CAPABILITYID [] = "CapabilityID";

static const CIMName _PROPERTY_CAPABILITYID = CIMName ("CapabilityID");

/**

The name of the provider module name property for provider capabilities class

static const char _PROPERTY_PROVIDERMODULENAME [] = "ProviderModuleName";

/**

The name of the provider name property for provider capabilities class

static const char _PROPERTY_PROVIDERNAME [] = "ProviderName";

/**

The name of the classname property for provider capabilities class

static const char _PROPERTY_CLASSNAME [] = "ClassName";

/**

The name of the Namespace property for provider capabilities class

static const char _PROPERTY_NAMESPACES [] = "Namespaces";

/**

The name of the provider type property for provider capabilities class

Module status

static const char _PROPERTY_PROVIDERTYPE [] = "ProviderType";

static const Uint16 _MODULE_OK = 2;

/**

The name of the supported properties property for provider capabilities class

static const char _PROPERTY_SUPPORTEDPROPERTIES [] = "SupportedProperties";

/**

The name of the supported methods property for provider capabilities class

static const char _PROPERTY_SUPPORTEDMETHODS [] = "SupportedMethods";

/**

Registered instance provider type

static const Uint16 _INSTANCE_PROVIDER = 2;

/**

Registered association provider type

static const Uint16 _ASSOCIATION_PROVIDER = 3;

/**

Registered indication provider type

static const Uint16 _INDICATION_PROVIDER = 4;

/**

Registered method provider type

static const Uint16 _METHOD_PROVIDER = 5;

/**

stopping provider method

static const char _STOP_PROVIDER[] = "Stop";

static const CIMName _STOP_PROVIDER = CIMName ("Stop");

/**

starting provider method

static const char _START_PROVIDER[] = "Start";

static const CIMName _START_PROVIDER = CIMName ("Start");

/**

Provider status

static const Uint16 _PROVIDER_OK = 2;

static const Uint16 _MODULE_STOPPING = 9;

static const Uint16 _PROVIDER_STOPPED = 10;

static const Uint16 _MODULE_STOPPED = 10;

ProviderRegistrationProvider::ProviderRegistrationProvider(

ProviderRegistrationManager * providerRegistrationManager)

:_id(peg_credential_types::PROVIDER)

{

_providerRegistrationManager = providerRegistrationManager;

_controller = &(ModuleController::get_client_handle(_id, &_client_handle));

if(_client_handle == NULL)

throw UninitializedObjectException();

}

ProviderRegistrationProvider::~ProviderRegistrationProvider(void)

{

if (_providerRegistrationManager)

{

delete _providerRegistrationManager;

}

if (_client_handle)

{

delete _client_handle;

}

void ProviderRegistrationProvider::initialize(CIMOMHandle & cimom)

Line 184

Line 108

// get registered provider

void ProviderRegistrationProvider::getInstance(

const OperationContext & context,

const CIMReference & instanceReference,

const CIMObjectPath & instanceReference,

const Uint32 flags,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

ResponseHandler<CIMInstance> & handler)

InstanceResponseHandler & handler)

{

if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))

{

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

instanceReference.getNameSpace().getString());

}

// ensure the class existing in the specified namespace

String className = instanceReference.getClassName();

CIMName className = instanceReference.getClassName();

if(!String::equalNoCase(className, _CLASS_PG_PROVIDER) &&

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

!String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, _CLASS_PROVIDER_MODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_INVALID_CLASS);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

className.getString());

}

// begin processing the request

Line 223

Line 156

// get all registered providers

void ProviderRegistrationProvider::enumerateInstances(

const OperationContext & context,

const CIMReference & classReference,

const CIMObjectPath & classReference,

const Uint32 flags,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

ResponseHandler<CIMInstance> & handler)

InstanceResponseHandler & handler)

{

if(!classReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))

{

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

classReference.getNameSpace().getString());

}

// ensure the class existing in the specified namespace

String className = classReference.getClassName();

CIMName className = classReference.getClassName();

if(!String::equalNoCase(className, _CLASS_PG_PROVIDER) &&

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

!String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, _CLASS_PROVIDER_MODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_INVALID_CLASS);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

className.getString());

}

// begin processing the request

handler.processing();

Array<CIMNamedInstance> enumInstances;

Array<CIMInstance> enumInstances;

try

{

Line 252

Line 194

throw (e);

}

// ATTN: remove when CIMNamedInstance removed.

handler.deliver(enumInstances);

for(Uint32 i = 0, n = enumInstances.size(); i < n; i++)

{

handler.deliver(enumInstances[i].getInstance());

}

// complete processing the request

handler.complete();

Line 265

Line 203

// get all registered provider names

void ProviderRegistrationProvider::enumerateInstanceNames(

const OperationContext & context,

const CIMReference & classReference,

const CIMObjectPath & classReference,

ResponseHandler<CIMReference> & handler)

ObjectPathResponseHandler & handler)

{

if(!classReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))

{

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

classReference.getNameSpace().getString());

}

// ensure the class existing in the specified namespace

String className = classReference.getClassName();

CIMName className = classReference.getClassName();

if(!String::equalNoCase(className, _CLASS_PG_PROVIDER) &&

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

!String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, _CLASS_PROVIDER_MODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_INVALID_CLASS);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

className.getString());

}

// begin processing the request

handler.processing();

Array<CIMReference> enumInstanceNames;

Array<CIMObjectPath> enumInstanceNames;

// get all instance names from repository

try

Line 305

Line 251

// SupportedProperties, and property of SupportedMethods

void ProviderRegistrationProvider::modifyInstance(

const OperationContext & context,

const CIMReference & instanceReference,

const CIMObjectPath & instanceReference,

const CIMInstance & instanceObject,

const Uint32 flags,

const Boolean includeQualifiers,

const CIMPropertyList & propertyList,

ResponseHandler<CIMInstance> & handler)

ResponseHandler & handler)

{

// get userName and only privileged user can execute this operation

String userName;

try

{

IdentityContainer container = context.get(IdentityContainer::NAME);

userName = container.getUserName();

}

catch (...)

{

userName = String::EMPTY;

}

if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,

//"You must have superuser privilege to modify the registration.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_MODIFY_REGISTRATION",

"You must have superuser privilege to modify the registration."));

}

if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))

{

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

instanceReference.getNameSpace().getString());

}

// only support to modify the instance of PG_ProviderCapabilities

if (!String::equalNoCase(instanceReference.getClassName(),

if (!instanceReference.getClassName().equal

_CLASS_PROVIDER_CAPABILITIES))

(PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))

{

throw CIMException (CIM_ERR_NOT_SUPPORTED);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

instanceReference.getClassName().getString());

}

Line 326

Line 301

if (propertyList.isNull())

{

throw CIMException (CIM_ERR_NOT_SUPPORTED);

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

//"Only can modify Namespaces, SupportedProperties, and SupportedMethods.");

String s1 = "Namespaces";

String s2 = "SupportedProperties";

String s3 = "SupportedMethods";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED, MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.CAN_ONLY_MODIFY_ERR",

"Only can modify $0, $1, and $2.",

s1, s2, s3));

}

Array<String> propertyArray = propertyList.getPropertyNameArray();

Array<CIMName> propertyArray = propertyList.getPropertyNameArray();

for (Uint32 i=0; i<propertyArray.size(); i++)

{

if (!String::equalNoCase(propertyArray[i], _PROPERTY_NAMESPACES) &&

if (!propertyArray[i].equal (_PROPERTY_NAMESPACES) &&

!String::equalNoCase(propertyArray[i], _PROPERTY_SUPPORTEDPROPERTIES) &&

!propertyArray[i].equal (_PROPERTY_SUPPORTEDPROPERTIES) &&

!String::equalNoCase(propertyArray[i], _PROPERTY_SUPPORTEDMETHODS))

!propertyArray[i].equal (_PROPERTY_SUPPORTEDMETHODS))

{

throw CIMException (CIM_ERR_NOT_SUPPORTED);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

propertyArray[i].getString());

}

Line 346

Line 331

try

{

_providerRegistrationManager->modifyInstance(instanceReference,

instanceObject, flags, propertyArray);

instanceObject, includeQualifiers, propertyArray);

}

catch(CIMException& e)

{

Line 360

Line 345

// register a provider

void ProviderRegistrationProvider::createInstance(

const OperationContext & context,

const CIMReference & instanceReference,

const CIMObjectPath & instanceReference,

const CIMInstance & instanceObject,

ResponseHandler<CIMReference> & handler)

ObjectPathResponseHandler & handler)

{

String className = instanceReference.getClassName();

// get userName and only privileged user can execute this operation

String nameSpace = instanceReference.getNameSpace();

String PG_ProviderModule_Name = "PG_ProviderModule"; //l10n

String PG_ProviderCapabilities_Name = "PG_ProviderCapabilities"; //l10n

String PG_Provider_Name = "PG_Provider";

String userName;

try

{

IdentityContainer container = context.get(IdentityContainer::NAME);

userName = container.getUserName();

}

catch (...)

{

userName = String::EMPTY;

}

CIMReference returnReference;

if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,

//"You must have superuser privilege to register providers.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED, MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_REGISTER_PROVIDERS",

"You must have superuser privilege to register providers."));

}

CIMName className = instanceReference.getClassName();

CIMNamespaceName nameSpace = instanceReference.getNameSpace();

CIMObjectPath returnReference;

CIMInstance instance = instanceObject;

if(!nameSpace.equal (PEGASUS_NAMESPACENAME_INTEROP))

{

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

nameSpace.getString());

}

// ensure the class existing in the specified namespace

if(!String::equalNoCase(className, _CLASS_PG_PROVIDER) &&

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

!String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, _CLASS_PROVIDER_MODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_INVALID_CLASS);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

className.getString());

}

// Check all required properties are set

if(String::equalNoCase(className, _CLASS_PROVIDER_MODULE))

if (className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

// Name, Version, InterfaceType, InterfaceVersion, and Location

// properties must be set

// OperationalStatus property needs to be set. If not, set to default

if (!instanceObject.existsProperty(_PROPERTY_PROVIDERMODULE_NAME))

if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULE_NAME) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing Name which is required property in PG_ProviderModule class.");

String missing = "Name";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));

}

if (instanceObject.findProperty(_PROPERTY_VENDOR) == PEG_NOT_FOUND)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing Vendor which is required property in PG_ProviderModule class.");

String missing = "Vendor";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));

}

if (instanceObject.findProperty(_PROPERTY_VERSION) == PEG_NOT_FOUND)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing Version which is required property in PG_ProviderModule class.");

String missing = "Version";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));

}

Uint32 ifcTypeIndex =

instanceObject.findProperty(_PROPERTY_INTERFACETYPE);

if (ifcTypeIndex == PEG_NOT_FOUND)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing InterfaceType which is required property in PG_ProviderModule class.");

String missing = "InterfaceType";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));

}

String ifcTypeString;

instanceObject.getProperty(ifcTypeIndex).getValue().

get(ifcTypeString);

if(ifcTypeString != "C++Default" && ifcTypeString != "CMPI" )

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

//"Unsupported InterfaceType value: \"" + ifcTypeString + "\"");

String unsupported = "InterfaceType";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_VALUE",

"Unsupported $0 value: \"$1\"",unsupported,ifcTypeString));

}

Uint32 ifcVersionIndex =

instanceObject.findProperty(_PROPERTY_INTERFACEVERSION);

if (ifcVersionIndex == PEG_NOT_FOUND)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing InterfaceVersion which is required property in PG_ProviderModule class.");

String missing = "InterfaceVersion";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));

}

String ifcVersionString;

instanceObject.getProperty(ifcVersionIndex).getValue().

get(ifcVersionString);

if ((ifcVersionString != "2.1.0") &&

(ifcVersionString != "2.2.0") &&

(ifcVersionString != "2.3.0"))

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

//"Unsupported InterfaceVersion value: \"" + ifcVersionString +

// "\"");

String unsupported = "InterfaceVersion";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_VALUE",

"Unsupported $0 value: \"$1\"",unsupported,ifcVersionString));

}

if (instanceObject.findProperty(_PROPERTY_LOCATION) == PEG_NOT_FOUND)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing Location which is required property in PG_ProviderModule class.");

String missing = "Location";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderModule_Name));

}

if (!instanceObject.existsProperty(_PROPERTY_VERSION))

if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

Array<Uint16> _operationalStatus;

_operationalStatus.append(_MODULE_OK);

instance.addProperty (CIMProperty

(_PROPERTY_OPERATIONALSTATUS, _operationalStatus));

}

else if (className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))

{

// ProviderModuleName, ProviderName, InstanceID, ClassName,

// Namespaces, and ProviderType properties must be set

if (!instanceObject.existsProperty(_PROPERTY_INTERFACETYPE))

if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing ProviderModuleName which is required property in PG_ProviderCapabilities class.");

String missing = "ProviderModuleName";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));

}

if (!instanceObject.existsProperty(_PROPERTY_INTERFACEVERSION))

if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing ProviderName which is required property in PG_ProviderCapabilities class.");

String missing = "ProviderName";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));

}

if (!instanceObject.existsProperty(_PROPERTY_LOCATION))

if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing CapabilityID which is required property in PG_ProviderCapabilities class.");

String missing = "CapabilityID";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));

}

if (!instanceObject.existsProperty(_PROPERTY_OPERATIONALSTATUS))

if (instanceObject.findProperty(_PROPERTY_CLASSNAME) == PEG_NOT_FOUND)

{

Array<Uint16> _operationalStatus;

//l10n

_operationalStatus.append(_PROVIDER_OK);

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

instance.addProperty (CIMProperty

//"Missing ClassName which is required property in PG_ProviderCapabilities class.");

(_PROPERTY_OPERATIONALSTATUS, _operationalStatus));

String missing = "ClassName";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));

}

if (instanceObject.findProperty(_PROPERTY_NAMESPACES) == PEG_NOT_FOUND)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing Namespaces which is required property in PG_ProviderCapabilities class.");

String missing = "Namespaces";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));

}

else if(String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES))

if (instanceObject.findProperty(_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing ProviderType which is required property in PG_ProviderCapabilities class.");

String missing = "ProviderType";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_ProviderCapabilities_Name));

}

else if (className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES))

{

// ProviderModuleName, ProviderName, InstanceID, ClassName,

// ProviderModuleName, ProviderName, CapabilityID, ProviderType,

// Namespaces, and ProviderType properties must be set

// and Destinations properties must be set

if (!instanceObject.existsProperty(_PROPERTY_PROVIDERMODULENAME))

if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//L10N_ TODO DONE

}

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing ProviderModuleName which is required property in PG_ConsumerCapabilities class.");

MessageLoaderParms parms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDER_MODULE_NAME_WHICH_IS_REQUIRED",

"Missing ProviderModuleName which is required property in PG_ConsumerCapabilities class.");

if (!instanceObject.existsProperty(_PROPERTY_PROVIDERNAME))

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

}

if (!instanceObject.existsProperty(_PROPERTY_CAPABILITYID))

if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//L10N_ TODO DONE

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing ProviderName which is required property in PG_ConsumerCapabilities class.");

MessageLoaderParms parms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDER_NAME_WHICH_IS_REQUIRED",

"Missing ProviderName which is required property in PG_ConsumerCapabilities class.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);

}

if (!instanceObject.existsProperty(_PROPERTY_CLASSNAME))

if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//L10N_ TODO DONE

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing CapabilityID which is required property in PG_ConsumerCapabilities class.");

MessageLoaderParms parms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_CAPABILITY_ID_WHICH_IS_REQUIRED",

"Missing CapabilityID which is required property in PG_ConsumerCapabilities class.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);

}

if (!instanceObject.existsProperty(_PROPERTY_NAMESPACES))

if (instanceObject.findProperty(_PROPERTY_PROVIDERTYPE) == PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//L10N_ TODO DONE

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing ProviderType which is required property in PG_ConsumerCapabilities class.");

MessageLoaderParms parms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDER_TYPE_WHICH_IS_REQUIRED",

"Missing ProviderType which is required property in PG_ConsumerCapabilities class.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);

}

if (!instanceObject.existsProperty(_PROPERTY_PROVIDERTYPE))

if (instanceObject.findProperty(_PROPERTY_INDICATIONDESTINATIONS) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//L10N_ TODO DONE

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing Destinations which is required property in PG_ConsumerCapabilities class.");

MessageLoaderParms parms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_DESTINATIONS_TYPE_WHICH_IS_REQUIRED",

"Missing Destinations which is required property in PG_ConsumerCapabilities class.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);

}

else // _CLASS_PG_PROVIDER

else // PEGASUS_CLASSNAME_PROVIDER

{

// Name and ProviderModuleName properties must be set

if (!instanceObject.existsProperty(_PROPERTY_PROVIDER_NAME))

if (instanceObject.findProperty(_PROPERTY_PROVIDER_NAME) == PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

}

if (!instanceObject.existsProperty(_PROPERTY_PROVIDERMODULENAME))

{

throw CIMException (CIM_ERR_INVALID_PARAMETER);

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing Name which is required property in PG_Provider class.");

String missing = "Name";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_Provider_Name));

}

if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==

PEG_NOT_FOUND)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"Missing ProviderModuleName which is required property in PG_Provider class.");

String missing = "ProviderModuleName";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

"Missing $0 which is required property in $1 class.",missing,PG_Provider_Name));

}

Line 497

Line 719

// Unregister a provider

void ProviderRegistrationProvider::deleteInstance(

const OperationContext & context,

const CIMReference & instanceReference,

const CIMObjectPath & instanceReference,

ResponseHandler<CIMInstance> & handler)

ResponseHandler & handler)

{

// get userName and only privileged user can execute this operation

String userName;

try

{

IdentityContainer container = context.get(IdentityContainer::NAME);

userName = container.getUserName();

}

catch (...)

{

userName = String::EMPTY;

}

if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,

//"You must have superuser privilege to unregister providers.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_UNREGISTER_PROVIDERS",

"You must have superuser privilege to unregister providers."));

}

if(!instanceReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))

{

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

instanceReference.getNameSpace().getString());

}

// l10n

// Get the client's list of preferred languages for the response

AcceptLanguages al = AcceptLanguages::EMPTY;

try

{

AcceptLanguageListContainer al_container =

(AcceptLanguageListContainer)context.get(AcceptLanguageListContainer::NAME);

al = al_container.getLanguages();

}

catch (...)

{

String className = instanceReference.getClassName();

; // Leave AcceptLanguages empty

}

CIMName className = instanceReference.getClassName();

// ensure the class existing in the specified namespace

if(!String::equalNoCase(className, _CLASS_PG_PROVIDER) &&

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

!String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, _CLASS_PROVIDER_MODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_INVALID_CLASS);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

className.getString());

}

// begin processing the request

handler.processing();

String moduleName;

Boolean moduleFound = false;

Array<CIMKeyBinding> keys = instanceReference.getKeyBindings();

// disable provider before delete provider

// registration if the class is PG_Provider

if (className.equal (PEGASUS_CLASSNAME_PROVIDER))

{

// get module name from reference

for(Uint32 i=0; i<keys.size() ; i++)

{

if(keys[i].getName().equal (_PROPERTY_PROVIDERMODULENAME))

{

moduleName = keys[i].getValue();

moduleFound = true;

}

// if _PROPERTY_PROVIDERMODULENAME key not found

if( !moduleFound)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

//"key ProviderModuleName was not found");

String sub = "ProviderModuleName";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.KEY_NOT_FOUND",

"key $0 was not found",sub));

}

// disable the provider

try

{

// if the provider disable failed

// l10n

if (_disableModule(instanceReference, moduleName, true, al) == -1)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"disable the provider failed.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_FAILED",

"disable the provider failed."));

}

catch(CIMException&)

{

throw;

}

// disable provider module before remove provider registration

// if the class is PG_ProviderModule

if (className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

// get module name from reference

for(Uint32 i=0; i<keys.size() ; i++)

{

if(keys[i].getName().equal (_PROPERTY_PROVIDERMODULE_NAME))

{

moduleName = keys[i].getValue();

moduleFound = true;

}

// if _PROPERTY_PROVIDERMODULE_NAME key not found

if( !moduleFound)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

//"key Name was not found");

String sub = "Name";

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.KEY_NOT_FOUND",

"key $0 was not found",sub));

}

// disable the provider module

try

{

// if the provider module disable failed

// l10n

if (_disableModule(instanceReference, moduleName, false, al) == -1)

{

//l10n

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"disable the provider module failed.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_MODULE_FAILED",

"disable the provider module failed."));

}

catch(CIMException& e)

{

throw (e);

}

try

{

_providerRegistrationManager->deleteInstance(instanceReference);

Line 529

Line 909

// Block a provider, unblock a provider, and stop a provider

void ProviderRegistrationProvider::invokeMethod(

const OperationContext & context,

const CIMReference & objectReference,

const CIMObjectPath & objectReference,

const String & methodName,

const CIMName & methodName,

const Array<CIMParamValue> & inParameters,

Array<CIMParamValue> & outParameters,

MethodResultResponseHandler & handler)

ResponseHandler<CIMValue> & handler)

{

// get userName and only privileged user can execute this operation

String userName;

try

{

IdentityContainer container = context.get(IdentityContainer::NAME);

userName = container.getUserName();

}

catch (...)

{

userName = String::EMPTY;

}

if ((userName != String::EMPTY) && !System::isPrivilegedUser(userName))

{

// ATTN-YZ-20020411: Add code to send message to provider manager to

//l10n

// execute the stop and start methods

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,

//"You must have superuser privilege to disable or enable providers.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.SUPERUSER_PRIVILEGE_REQUIRED_DISABLE_ENABLE_PROVIDERS",

"You must have superuser privilege to disable or enable providers."));

}

throw CIMException (CIM_ERR_NOT_SUPPORTED);

if(!objectReference.getNameSpace().equal (PEGASUS_NAMESPACENAME_INTEROP))

{

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

objectReference.getNameSpace().getString());

}

/* ATTN-YZ-P1-20020301: Modify this function because schema is changed

String className = objectReference.getClassName();

// ensure the class existing in the specified namespace

// l10n

if(!String::equalNoCase(className, _CLASS_PG_PROVIDER) &&

// Get the client's list of preferred languages for the response

!String::equalNoCase(className, _CLASS_PROVIDER_CAPABILITIES) &&

AcceptLanguages al = AcceptLanguages::EMPTY;

!String::equalNoCase(className, _CLASS_PROVIDER_MODULE))

try

{

AcceptLanguageListContainer al_container =

(AcceptLanguageListContainer)context.get(AcceptLanguageListContainer::NAME);

al = al_container.getLanguages();

}

catch (...)

{

throw CIMException(CIM_ERR_INVALID_CLASS);

; // Leave AcceptLanguages empty

}

handler.processing();

String moduleName;

Uint32 retValue;

Boolean moduleFound = false;

String providerName;

// get provider name from reference

// get module name from reference

Array<KeyBinding> keys = objectReference.getKeyBindings();

Array<CIMKeyBinding> keys = objectReference.getKeyBindings();

Uint32 i;

for(Uint32 i=0; i<keys.size() ; i++)

for(i=0; i<keys.size() ; i++)

{

if(String::equal(keys[i].getName(), "Name"))

if(keys[i].getName().equal (_PROPERTY_PROVIDERMODULE_NAME))

{

providerName = keys[i].getValue();

moduleName = keys[i].getValue();

moduleFound = true;

}

// if Name key not found

// if _PROPERTY_PROVIDERMODULE_NAME key not found

if(i > keys.size())

if( !moduleFound)

{

// ATTN: may need diff exception

//l10n

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

String sub = "Name";

"key Name was not found");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.KEY_NOT_FOUND",

"key $0 was not found",sub));

}

CIMReference newInstancereference("", "",

handler.processing();

objectReference.getClassName(),

objectReference.getKeyBindings());

if(String::equalNoCase(methodName, _STOP_PROVIDER))

{

Boolean force = false;

Sint16 ret_value;

Uint32 timeoutValue = 0;

String forceStr = String::EMPTY;

String timeoutStr = String::EMPTY;

// Get the input parameter values

if(methodName.equal(_STOP_PROVIDER))

// ATTN: Currently the server only returns String values even

// though the types of the parameters are not defined

// as String type.

for (Uint32 i = 0; i < inParameters.size(); i++)

{

String parmName = inParameters[i].getParameter().getName();

// disable module

if (String::equalNoCase(parmName, "force"))

try

{

// l10n

// get the force parameter

ret_value = _disableModule(objectReference, moduleName, false, al);

}

inParameters[i].getValue().get(forceStr);

catch(CIMException& e)

if (String::equalNoCase(forceStr, "TRUE"))

{

force = true;

throw (e);

}

CIMValue retValue(ret_value);

handler.deliver(retValue);

handler.complete();

return;

}

else

else if(methodName.equal(_START_PROVIDER))

{

if (String::equalNoCase(parmName, "timeout"))

{

// get the timeout value

// get module status

inParameters[i].getValue().get(timeoutStr);

Array<Uint16> _OperationalStatus =

_providerRegistrationManager->getProviderModuleStatus( moduleName);

for (Uint32 i = 0; i<_OperationalStatus.size(); i++)

{

// retValue equals 1 if module is already enabled

if (_OperationalStatus[i] == _MODULE_OK)

{

ret_value = 1;

CIMValue retValue(ret_value);

handler.deliver(retValue);

handler.complete();

return;

}

// retValue equals 2 if module is stopping

// at this stage, module can not be started

if (_OperationalStatus[i] == _MODULE_STOPPING)

{

ret_value = 2;

CIMValue retValue(ret_value);

handler.deliver(retValue);

handler.complete();

return;

}

// get module instance

CIMInstance mInstance =

_providerRegistrationManager->getInstance(objectReference);

// convert the timeout string to integer

// get provider manager service

if (timeoutStr != String::EMPTY)

MessageQueueService * _service = _getProviderManagerService();

if (_service != NULL)

{

char* tmp = timeoutStr.allocateCString();

// create CIMEnableModuleRequestMessage

timeoutValue = strtol(tmp, (char **)0, 10);

CIMEnableModuleRequestMessage * enable_req =

delete [] tmp;

new CIMEnableModuleRequestMessage(

XmlWriter::getNextMessageId (),

mInstance,

QueueIdStack(_service->getQueueId()));

// l10n

enable_req->acceptLanguages = al;

Array<Uint16> _opStatus;

_opStatus = _sendEnableMessageToProviderManager(enable_req);

for (Uint32 i = 0; i<_opStatus.size(); i++)

{

if (_opStatus[i] == _MODULE_OK)

{

// module was enabled successfully

ret_value = 0;

CIMValue retValue(ret_value);

handler.deliver(retValue);

handler.complete();

return;

}

// enable failed

ret_value = -1;

CIMValue retValue(ret_value);

handler.deliver(retValue);

handler.complete();

return;

}

else

{

throw PEGASUS_CIM_EXCEPTION( CIM_ERR_INVALID_PARAMETER,

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE, String::EMPTY);

"Input parameters are not valid.");

}

// get provider manager service

MessageQueueService * ProviderRegistrationProvider::_getProviderManagerService()

{

MessageQueue * queue = MessageQueue::lookup(PEGASUS_QUEUENAME_PROVIDERMANAGER_CPP);

MessageQueueService * _service = dynamic_cast<MessageQueueService *>(queue);

return(_service);

}

// change provider status to be stopping

ProviderRegistrationProvider & ProviderRegistrationProvider::operator=(const ProviderRegistrationProvider & handle)

// do not accept any new requests

// ATTN: Change this to send a message

//retValue = _cimom.getProviderManager()->stoppingProvider(providerName);

if ( retValue ) // return value is 1 -- provider not found

{

// ATTN: throw exception

if(this == &handle)

// throw();

{

return(*this);

}

// ATTN: need a way to find if there are any outstanding requests

return(*this);

// if there are outstanding requests, wait periodically until

}

// all requests are processed or timeout expires

// Uint32 requestCount = getOutstandingRequestCount(providerName);

Array<Uint16> ProviderRegistrationProvider::_sendDisableMessageToProviderManager(

CIMDisableModuleRequestMessage * disable_req)

{

MessageQueueService * _service = _getProviderManagerService();

Uint32 _queueId = _service->getQueueId();

Uint32 waitTime = 1000; // one second wait interval

callback_data *cb_data = new callback_data(this);

// ATTN: for testing purpose, set requestCount = 3

// create request envelope

Uint32 requestCount = 3;

AsyncLegacyOperationStart * asyncRequest =

new AsyncLegacyOperationStart (

_service->get_next_xid(),

NULL,

_queueId,

disable_req,

_queueId);

while (requestCount > 0 && timeoutValue > 0)

AsyncReply * asyncReply = _controller->ClientSendWait(*_client_handle,

_queueId,

asyncRequest);

CIMDisableModuleResponseMessage * response =

reinterpret_cast<CIMDisableModuleResponseMessage *>(

(static_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());

if (response->cimException.getCode() != CIM_ERR_SUCCESS)

{

CIMException e = response->cimException;

delete asyncRequest;

delete asyncReply;

delete response;

throw (e);

}

// any outstanding requests given a grace period to complete;

Array<Uint16> operationalStatus = response->operationalStatus;

System::sleep(waitTime);

// ATTN:

delete asyncRequest;

// requestCount = getOutstandingRequestCount(providerName);

delete asyncReply;

delete response;

return(operationalStatus);

}

Array<Uint16> ProviderRegistrationProvider::_sendEnableMessageToProviderManager(

CIMEnableModuleRequestMessage * enable_req)

{

MessageQueueService * _service = _getProviderManagerService();

Uint32 _queueId = _service->getQueueId();

callback_data *cb_data = new callback_data(this);

// create request envelope

AsyncLegacyOperationStart * asyncRequest =

new AsyncLegacyOperationStart (

_service->get_next_xid(),

NULL,

_queueId,

enable_req,

_queueId);

AsyncReply * asyncReply = _controller->ClientSendWait(*_client_handle,

_queueId,

asyncRequest);

CIMEnableModuleResponseMessage * response =

reinterpret_cast<CIMEnableModuleResponseMessage *>(

(static_cast<AsyncLegacyOperationResult *>(asyncReply))->get_result());

if (response->cimException.getCode() != CIM_ERR_SUCCESS)

{

CIMException e = response->cimException;

delete asyncRequest;

delete asyncReply;

delete response;

throw (e);

}

Array<Uint16> operationalStatus = response->operationalStatus;

// ATTN: for testing purpose

delete asyncRequest;

requestCount--;

delete asyncReply;

delete response;

timeoutValue = timeoutValue - waitTime;

return(operationalStatus);

}

// If no more requests or force stop option is specified, proceed

// send termination message to subscription service

// to stop the provider

void ProviderRegistrationProvider::_sendTerminationMessageToSubscription(

if (requestCount == 0 || force)

const CIMObjectPath & ref, const String & moduleName,

const Boolean disableProviderOnly,

const AcceptLanguages & al)

{

CIMInstance instance;

String _moduleName;

Array<CIMInstance> instances;

if (!disableProviderOnly)

{

CIMObjectPath reference("", PEGASUS_NAMESPACENAME_INTEROP,

PEGASUS_CLASSNAME_PROVIDER, ref.getKeyBindings());

Array<CIMObjectPath> instanceNames =

_providerRegistrationManager->enumerateInstanceNames(reference);

// find all the instances which have same module name as moduleName

for (Uint32 i = 0, n=instanceNames.size(); i < n; i++)

{

// get provider module name from reference

Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();

for(Uint32 j=0; j < keys.size(); j++)

{

if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))

{

// change provider status to be stopped

_moduleName = keys[j].getValue();

// ATTN: Change this to send a message

}

//retValue = _cimom.getProviderManager()->providerStopped(providerName);

}

// stop the provider

if (String::equalNoCase(moduleName, _moduleName))

// ATTN: Change this to send a message

//retValue = _cimom.getProviderManager()->stopProvider(providerName);

// ATTN: Update repository, but if a provider can not set property

// AutomaticallyStarted = FALSE, do not need update repository

if(retValue == 0)

{

// update repository

reference.setKeyBindings(keys);

//_cimom.getRepository()->setProperty(objectReference.getNameSpace(),

instance = _providerRegistrationManager->getInstance(reference);

// newInstancereference, "OperationalStatus", _PROVIDER_STOPPED);

instances.append(instance);

}

else

{

// if there are still outstanding requests after the grace period

instance = _providerRegistrationManager->getInstance(ref);

// and force stop option is not specified, change provider status to be OK

instances.append(instance);

// ATTN: Change this to send a message

}

//_cimom.getProviderManager()->startProvider(providerName);

// get indication server queueId

MessageQueueService * _service = _getIndicationService();

if (_service != NULL)

{

Uint32 _queueId = _service->getQueueId();

//ATTN: inform the client that provider not stopped

CIMNotifyProviderTerminationRequestMessage * termination_req =

//throw ();

new CIMNotifyProviderTerminationRequestMessage(

XmlWriter::getNextMessageId (),

instances,

QueueIdStack(_service->getQueueId()));

// l10n

termination_req->acceptLanguages = al;

// create request envelope

AsyncLegacyOperationStart * asyncRequest =

new AsyncLegacyOperationStart (

_service->get_next_xid(),

NULL,

_queueId,

termination_req,

_queueId);

if( false == _controller->ClientSendForget(

*_client_handle,

_queueId,

asyncRequest))

{

delete asyncRequest;

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_FOUND, String::EMPTY);

}

else if(String::equalNoCase(methodName, _START_PROVIDER))

}

// get indication service

MessageQueueService * ProviderRegistrationProvider::_getIndicationService()

{

// ATTN: Send a message to the ProviderManager

MessageQueue * queue = MessageQueue::lookup(

//retValue = _cimom.getProviderManager()->startProvider(providerName);

PEGASUS_QUEUENAME_INDICATIONSERVICE);

if(retValue == 0)

MessageQueueService * _service =

dynamic_cast<MessageQueueService *>(queue);

return(_service);

}

// disable provider module, return 0 if module is disabled successfully,

// return 1 if module is already disabled, otherwise, return -1

Sint16 ProviderRegistrationProvider::_disableModule(

const CIMObjectPath & objectReference,

const String & moduleName,

Boolean disableProviderOnly,

const AcceptLanguages & al) // l10n

{

// update repository

// ATTN: Do we really need to do this? If we do, should we do it

// get module status

// through the ProviderRegistrationManager instead of directly

// accessing the repository?

Array<Uint16> _OperationalStatus =

//_cimom.getRepository()->setProperty(objectReference.getNameSpace(),

_providerRegistrationManager->getProviderModuleStatus( moduleName);

// newInstancereference, "OperationalStatus", _PROVIDER_OK);

for (Uint32 i = 0; i<_OperationalStatus.size(); i++)

{

// retValue equals 1 if module is already disabled

if (_OperationalStatus[i] == _MODULE_STOPPED ||

_OperationalStatus[i] == _MODULE_STOPPING)

{

return (1);

}

else

}

CIMInstance instance;

Array<CIMInstance> instances;

CIMInstance mInstance;

String _moduleName;

Uint16 providers;

CIMObjectPath providerRef;

// disable a provider module or delete a provider module

if (!disableProviderOnly)

{

providerRef = CIMObjectPath(objectReference.getHost(),

objectReference.getNameSpace(),

PEGASUS_CLASSNAME_PROVIDER,

objectReference.getKeyBindings());

// get module instance

mInstance =

_providerRegistrationManager->getInstance(objectReference);

}

else // disable a provider

{

// get module instance

Array <CIMKeyBinding> moduleKeyBindings;

moduleKeyBindings.append (CIMKeyBinding

(_PROPERTY_PROVIDERMODULE_NAME, moduleName,

CIMKeyBinding::STRING));

CIMObjectPath moduleRef(objectReference.getHost(),

objectReference.getNameSpace(),

PEGASUS_CLASSNAME_PROVIDERMODULE,

moduleKeyBindings);

mInstance =

_providerRegistrationManager->getInstance(moduleRef);

}

if (!disableProviderOnly)

{

// get all provider instances which have same module name as

// moduleName

Array<CIMObjectPath> instanceNames =

_providerRegistrationManager->enumerateInstanceNames(providerRef);

for(Uint32 i = 0, n=instanceNames.size(); i < n; i++)

{

// get provider module name from reference

Array<CIMKeyBinding> keys = instanceNames[i].getKeyBindings();

for(Uint32 j=0; j < keys.size(); j++)

{

if(keys[j].getName().equal (_PROPERTY_PROVIDERMODULENAME))

{

// ATTN: need new exception

_moduleName = keys[j].getValue();

// throw();

}

if (String::equalNoCase(_moduleName, moduleName))

{

providerRef.setKeyBindings(keys);

instance = _providerRegistrationManager->getInstance

(providerRef);

instances.append(instance);

}

else

{

throw CIMException(CIM_ERR_METHOD_NOT_AVAILABLE);

instances.append(_providerRegistrationManager->getInstance

(objectReference));

}

CIMValue cimValue_output(retValue);

// get provider manager service

MessageQueueService * _service = _getProviderManagerService();

handler.deliver(cimValue_output);

if (_service != NULL)

{

// create CIMDisableModuleRequestMessage

CIMDisableModuleRequestMessage * disable_req =

new CIMDisableModuleRequestMessage(

XmlWriter::getNextMessageId (),

mInstance,

instances,

disableProviderOnly,

QueueIdStack(_service->getQueueId()));

// l10n

disable_req->acceptLanguages = al;

handler.complete();

Array<Uint16> _opStatus =

_sendDisableMessageToProviderManager(disable_req);

if (!disableProviderOnly) // disable provider module

{

for (Uint32 i = 0; i<_opStatus.size(); i++)

{

// module was disabled successfully

if (_opStatus[i] == _MODULE_STOPPED)

{

// send termination message to subscription service

_sendTerminationMessageToSubscription(objectReference,

moduleName, false, al);

return (0);

}

else // disable provider

{

_sendTerminationMessageToSubscription(objectReference,

moduleName, true, al);

return (0);

}

// disable failed

return (-1);

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.4
changed lines
	Added in v.1.49

No CVS admin address has been configured