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.22 and 1.71

version 1.22, 2002/06/01 00:57:06

version 1.71, 2004/07/27 16:17:56

Line 1

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

//%2003////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Company, L. P., IBM Corp., The Open Group, Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

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

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

Line 28

Line 30

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

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Seema Gupta (gseema@in.ibm.com) for PEP135

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

Line 37

Line 40

#include <Pegasus/Common/XmlWriter.h>

#include <Pegasus/Common/Constants.h>

#include <Pegasus/Common/CIMMessage.h>

#include <Pegasus/Common/OperationContext.h>

#include <Pegasus/Common/OperationContextInternal.h>

#include <Pegasus/Common/System.h>

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

#include <Pegasus/Common/Constants.h>

PEGASUS_NAMESPACE_BEGIN

/**

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 Vendor property for PG_ProviderModule class

static const char _PROPERTY_VENDOR [] = "Vendor";

/**

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";

/**

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

static const char _PROPERTY_PROVIDERTYPE [] = "ProviderType";

/**

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 _MODULE_OK = 2;

static const Uint16 _MODULE_STOPPING = 9;

static const Uint16 _MODULE_STOPPED = 10;

ProviderRegistrationProvider::ProviderRegistrationProvider(

ProviderRegistrationManager * providerRegistrationManager)

Line 169

Line 70

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

if(_client_handle == NULL)

ThrowUninitializedHandle();

throw UninitializedObjectException();

}

ProviderRegistrationProvider::~ProviderRegistrationProvider(void)

Line 200

Line 101

void ProviderRegistrationProvider::getInstance(

const OperationContext & context,

const CIMObjectPath & instanceReference,

const Uint32 flags,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

ResponseHandler<CIMInstance> & handler)

InstanceResponseHandler & handler)

{

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

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

PEGASUS_NAMESPACENAME_INTEROP))

{

throw CIMException (CIM_ERR_NOT_SUPPORTED, instanceReference.getNameSpace());

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, PEGASUS_CLASSNAME_PROVIDER) &&

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

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

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_NOT_SUPPORTED, className);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

className.getString());

}

// begin processing the request

Line 228

Line 132

try

{

instance = _providerRegistrationManager->getInstance(instanceReference);

instance = _providerRegistrationManager->getInstance(instanceReference,

includeQualifiers,

includeClassOrigin,

propertyList);

}

catch(CIMException& e)

{

Line 245

Line 152

void ProviderRegistrationProvider::enumerateInstances(

const OperationContext & context,

const CIMObjectPath & classReference,

const Uint32 flags,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

ResponseHandler<CIMInstance> & handler)

InstanceResponseHandler & handler)

{

if(!String::equalNoCase(classReference.getNameSpace(),

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

PEGASUS_NAMESPACENAME_INTEROP))

{

throw CIMException (CIM_ERR_NOT_SUPPORTED, classReference.getNameSpace());

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, PEGASUS_CLASSNAME_PROVIDER) &&

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

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

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_NOT_SUPPORTED, className);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

className.getString());

}

// begin processing the request

Line 272

Line 182

try

{

enumInstances = _providerRegistrationManager->enumerateInstances(classReference);

enumInstances =

_providerRegistrationManager->enumerateInstances(classReference,

includeQualifiers,

includeClassOrigin,

propertyList);

}

catch(CIMException& e)

{

Line 289

Line 203

void ProviderRegistrationProvider::enumerateInstanceNames(

const OperationContext & context,

const CIMObjectPath & classReference,

ResponseHandler<CIMObjectPath> & handler)

ObjectPathResponseHandler & handler)

{

if(!String::equalNoCase(classReference.getNameSpace(),

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

PEGASUS_NAMESPACENAME_INTEROP))

{

throw CIMException (CIM_ERR_NOT_SUPPORTED, classReference.getNameSpace());

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, PEGASUS_CLASSNAME_PROVIDER) &&

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

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

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_NOT_SUPPORTED, className);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

className.getString());

}

// begin processing the request

Line 336

Line 252

const OperationContext & context,

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(CONTEXT_IDENTITY);

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

userName = container.getUserName();

}

catch (...)

Line 354

Line 270

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

{

throw CIMException (CIM_ERR_ACCESS_DENIED,

//l10n

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

//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(!String::equalNoCase(instanceReference.getNameSpace(),

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

PEGASUS_NAMESPACENAME_INTEROP))

{

throw CIMException (CIM_ERR_NOT_SUPPORTED, instanceReference.getNameSpace());

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

PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))

(PEGASUS_CLASSNAME_PROVIDERCAPABILITIES))

{

throw CIMException (CIM_ERR_NOT_SUPPORTED, instanceReference.getClassName());

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

instanceReference.getClassName().getString());

}

Line 379

Line 300

if (propertyList.isNull())

{

throw CIMException (CIM_ERR_NOT_SUPPORTED,

//l10n

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

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED, MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.CAN_ONLY_MODIFY_ERR",

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

}

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, propertyArray[i]);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

propertyArray[i].getString());

}

Line 400

Line 326

try

{

_providerRegistrationManager->modifyInstance(instanceReference,

instanceObject, flags, propertyArray);

instanceObject,

includeQualifiers,

propertyArray);

}

catch(CIMException& e)

{

Line 416

Line 344

const OperationContext & context,

const CIMObjectPath & instanceReference,

const CIMInstance & instanceObject,

ResponseHandler<CIMObjectPath> & handler)

ObjectPathResponseHandler & handler)

{

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

String userName;

try

{

IdentityContainer container = context.get(CONTEXT_IDENTITY);

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

userName = container.getUserName();

}

catch (...)

Line 432

Line 360

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

{

throw CIMException (CIM_ERR_ACCESS_DENIED,

//l10n

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

//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."));

}

String className = instanceReference.getClassName();

CIMName className = instanceReference.getClassName();

String nameSpace = instanceReference.getNameSpace();

CIMNamespaceName nameSpace = instanceReference.getNameSpace();

CIMObjectPath returnReference;

CIMInstance instance = instanceObject;

if(!String::equalNoCase(nameSpace, PEGASUS_NAMESPACENAME_INTEROP))

if(!nameSpace.equal (PEGASUS_NAMESPACENAME_INTEROP))

{

throw CIMException (CIM_ERR_NOT_SUPPORTED, nameSpace);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

nameSpace.getString());

}

// ensure the class existing in the specified namespace

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

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

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

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_NOT_SUPPORTED, className);

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

className.getString());

}

// Check all required properties are set

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

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)

{

//l10n 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_NAME_IN_PG_PROVIDERMODULE",

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

}

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

{

//l10n 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_VENDOR_IN_PG_PROVIDERMODULE",

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

}

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

{

//l10n 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_VERSION_IN_PG_PROVIDERMODULE",

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

}

Uint32 ifcTypeIndex =

instanceObject.findProperty(_PROPERTY_INTERFACETYPE);

if (ifcTypeIndex == PEG_NOT_FOUND)

{

//l10n 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_INTERFACETYPE_IN_PG_PROVIDERMODULE",

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

}

String ifcTypeString;

instanceObject.getProperty(ifcTypeIndex).getValue().

get(ifcTypeString);

if (ifcTypeString != "C++Default"

#ifdef ENABLE_CMPI_PROVIDER_MANAGER

&& ifcTypeString != "CMPI"

#endif

)

{

//l10n 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.UNSUPPORTED_INTERFACETYPE_VALUE",

"Unsupported InterfaceType value: \"$0\"",ifcTypeString));

}

Uint32 ifcVersionIndex =

instanceObject.findProperty(_PROPERTY_INTERFACEVERSION);

if (ifcVersionIndex == PEG_NOT_FOUND)

{

//l10n 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_INTERFACEVERSION_IN_PG_PROVIDERMODULE",

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

}

String ifcVersionString;

instanceObject.getProperty(ifcVersionIndex).getValue().

get(ifcVersionString);

if (

#ifdef ENABLE_CMPI_PROVIDER_MANAGER

(ifcTypeString == "CMPI" &&

ifcVersionString != "2.0.0") ||

#endif

(ifcTypeString == "C++Default" &&

ifcVersionString != "2.1.0" &&

ifcVersionString != "2.2.0" &&

ifcVersionString != "2.3.0"))

{

//l10n 485

//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_INTERFACEVERSION_VALUE",

"Unsupported InterfaceVersion value: \"$0\"",ifcVersionString));

}

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

{

//l10n 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_LOCATION_IN_PG_PROVIDERMODULE",

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

}

if (instanceObject.findProperty(_PROPERTY_OPERATIONALSTATUS) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_FAILED,

Array<Uint16> _operationalStatus;

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

_operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_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_VENDOR))

if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_FAILED,

//l10n 485

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

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERMODULENAME_IN_PG_PROVIDERCAPABILITIES",

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

}

if (!instanceObject.existsProperty(_PROPERTY_VERSION))

if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_FAILED,

//l10n 485

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

//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 ProviderName which is required property in PG_ProviderCapabilities class."));

}

if (!instanceObject.existsProperty(_PROPERTY_INTERFACETYPE))

if (instanceObject.findProperty(_PROPERTY_CAPABILITYID) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_FAILED,

//l10n 485

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

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSINGCAPABILITYID_IN_PG_PROVIDERCAPABILITIES",

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

}

if (!instanceObject.existsProperty(_PROPERTY_INTERFACEVERSION))

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

{

throw CIMException (CIM_ERR_FAILED,

//l10n 485

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

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_CLASSNAME_IN_PG_PROVIDERCAPABILITIES",

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

}

if (!instanceObject.existsProperty(_PROPERTY_LOCATION))

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

{

throw CIMException (CIM_ERR_FAILED,

//l10n 485

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

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_NAMESPACES_IN_PG_PROVIDERCAPABILITIES",

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

}

if (!instanceObject.existsProperty(_PROPERTY_OPERATIONALSTATUS))

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

{

Array<Uint16> _operationalStatus;

//l10n 485

_operationalStatus.append(_MODULE_OK);

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

instance.addProperty (CIMProperty

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

(_PROPERTY_OPERATIONALSTATUS, _operationalStatus));

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERTYPE_IN_PG_PROVIDERCAPABILITIES",

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

}

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

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_FAILED,

//L10N_ TODO DONE

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

//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_FAILED,

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

}

if (!instanceObject.existsProperty(_PROPERTY_CAPABILITYID))

if (instanceObject.findProperty(_PROPERTY_PROVIDERNAME) ==

PEG_NOT_FOUND)

{

throw CIMException (CIM_ERR_FAILED,

//L10N_ TODO DONE

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

//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_FAILED,

//L10N_ TODO DONE

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

//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_FAILED,

//L10N_ TODO DONE

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

//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_FAILED,

//L10N_ TODO DONE

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

//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 // PEGASUS_CLASSNAME_PROVIDER

Line 558

Line 665

// 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_FAILED,

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

}

if (!instanceObject.existsProperty(_PROPERTY_PROVIDERMODULENAME))

{

throw CIMException (CIM_ERR_FAILED,

//l10n 485

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

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_REQUIRED_PROPERTY",

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

}

if (instanceObject.findProperty(_PROPERTY_PROVIDERMODULENAME) ==

PEG_NOT_FOUND)

{

//l10n 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

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

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.MISSING_PROVIDERMODULENAME_IN_PG_PROVIDER",

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

}

Line 594

Line 710

void ProviderRegistrationProvider::deleteInstance(

const OperationContext & context,

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(CONTEXT_IDENTITY);

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

userName = container.getUserName();

}

catch (...)

Line 610

Line 726

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

{

throw CIMException (CIM_ERR_ACCESS_DENIED,

//l10n

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

//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());

}

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

PEGASUS_NAMESPACENAME_INTEROP))

// 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 (...)

{

throw CIMException (CIM_ERR_NOT_SUPPORTED, instanceReference.getNameSpace());

; // Leave AcceptLanguages empty

}

String className = instanceReference.getClassName();

CIMName className = instanceReference.getClassName();

// ensure the class existing in the specified namespace

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

if(!className.equal (PEGASUS_CLASSNAME_PROVIDER) &&

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

!className.equal (PEGASUS_CLASSNAME_PROVIDERCAPABILITIES) &&

!String::equalNoCase(className, PEGASUS_CLASSNAME_PROVIDERMODULE))

!className.equal (PEGASUS_CLASSNAME_CONSUMERCAPABILITIES) &&

!className.equal (PEGASUS_CLASSNAME_PROVIDERMODULE))

{

throw CIMException(CIM_ERR_NOT_SUPPORTED, className);

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 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

//"key ProviderModuleName was not found");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.PROVIDERMODULENAME_KEY_NOT_FOUND",

"key ProviderModuleName was not found"));

}

// disable the provider

try

{

Sint16 ret_value = _disableModule(instanceReference, moduleName, true, al);

// if the provider disable failed

// l10n

if (ret_value == -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."));

}

// The provider disable failed since there are pending requests

if (ret_value == -2)

{

//L10N TODO

// throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

//"disable the provider failed: Provider is busy.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_FAILED_PROVIDER_BUSY",

"disable the provider failed: Provider is busy."));

}

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 485

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

//"key Name was not found");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",

"key Name was not found"));

}

// disable the provider module

try

{

Sint16 ret_value = _disableModule(instanceReference, moduleName, false, al);

// if the provider module disable failed

// l10n

if (ret_value == -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."));

}

// The provider module disable failed since there are pending requests

if (ret_value == -2)

{

//L10N TODO

//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,

// "disable the provider module failed: Provider is busy.");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.DISABLE_PROVIDER_MODULE_FAILED_PROVIDER_BUSY",

"disable the provider module failed: Provider is busy."));

}

catch(CIMException& e)

{

throw (e);

}

try

{

_providerRegistrationManager->deleteInstance(instanceReference);

Line 650

Line 927

void ProviderRegistrationProvider::invokeMethod(

const OperationContext & context,

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(CONTEXT_IDENTITY);

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

userName = container.getUserName();

}

catch (...)

Line 669

Line 945

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

{

throw CIMException (CIM_ERR_ACCESS_DENIED,

//l10n

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

//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."));

}

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

{

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

objectReference.getNameSpace().getString());

}

if(!String::equalNoCase(objectReference.getNameSpace(),

PEGASUS_NAMESPACENAME_INTEROP))

// 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 (...)

{

throw CIMException (CIM_ERR_NOT_SUPPORTED, objectReference.getNameSpace());

; // Leave AcceptLanguages empty

}

String moduleName;

Boolean moduleFound = false;

// get module name from reference

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

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

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

{

if(String::equalNoCase(keys[i].getName(), _PROPERTY_PROVIDERMODULE_NAME))

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

{

moduleName = keys[i].getValue();

moduleFound = true;

Line 697

Line 992

// if _PROPERTY_PROVIDERMODULE_NAME key not found

if( !moduleFound)

{

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,

//l10n 485

"key Name was not found");

throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED,MessageLoaderParms(

"ControlProviders.ProviderRegistrationProvider.ProviderRegistrationProvider.NAME_KEY_NOT_FOUND",

"key Name was not found"));

}

// get module status

Array<Uint16> _OperationalStatus =

_providerRegistrationManager->getProviderModuleStatus( moduleName);

handler.processing();

Sint16 ret_value;

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

try

{

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

if(methodName.equal(_STOP_PROVIDER))

{

// retValue equals 1 if module is already disabled

// disable module

if (_OperationalStatus[i] == _MODULE_STOPPED ||

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

_OperationalStatus[i] == _MODULE_STOPPING)

}

else if(methodName.equal(_START_PROVIDER))

{

// enable module

ret_value = _enableModule(objectReference, moduleName, al);

}

else

{

ret_value = 1;

throw PEGASUS_CIM_EXCEPTION(CIM_ERR_METHOD_NOT_AVAILABLE, String::EMPTY);

}

catch(CIMException& e)

{

throw (e);

}

CIMValue retValue(ret_value);

handler.deliver(retValue);

handler.complete();

return;

}

CIMInstance mInstance;

// get provider manager service

CIMInstance instance;

MessageQueueService * ProviderRegistrationProvider::_getProviderManagerService()

Array<CIMInstance> instances;

{

String _moduleName;

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

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

// get module instance

return(_service);

mInstance = _providerRegistrationManager->getInstance(objectReference);

}

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

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

CIMObjectPath providerRef(objectReference.getHost(),

objectReference.getNameSpace(),

PEGASUS_CLASSNAME_PROVIDER,

objectReference.getKeyBindings());

Array<CIMInstance> namedInstances;

namedInstances = _providerRegistrationManager->enumerateInstances(providerRef);

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

{

instance = namedInstances[i];

instance.getProperty(instance.findProperty

(_PROPERTY_PROVIDERMODULENAME)).getValue().get(_moduleName);

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

{

instances.append(instance);

if(this == &handle)

{

return(*this);

}

return(*this);

}

Array<Uint16> ProviderRegistrationProvider::_sendDisableMessageToProviderManager(

// get provider manager service

CIMDisableModuleRequestMessage * disable_req)

{

MessageQueueService * _service = _getProviderManagerService();

Uint32 _queueId = _service->getQueueId();

if (_service != NULL)

{

// create CIMDisableModuleRequestMessage

CIMDisableModuleRequestMessage * disable_req =

new CIMDisableModuleRequestMessage(

XmlWriter::getNextMessageId (),

mInstance,

instances,

QueueIdStack(_service->getQueueId()));

Array<Uint16> _opStatus =

_sendDisableMessageToProviderManager(disable_req);

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

{

if (_opStatus[i] == _MODULE_STOPPED)

{

// module was disabled successfully

ret_value = 0;

CIMValue retValue(ret_value);

handler.deliver(retValue);

handler.complete();

// send termination message to subscription service

_sendTerminationMessageToSubscription(objectReference, moduleName);

return;

}

// disable failed

ret_value = -1;

CIMValue retValue(ret_value);

handler.deliver(retValue);

handler.complete();

return;

}

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

{

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 provider manager service

MessageQueueService * _service = _getProviderManagerService();

if (_service != NULL)

{

// create CIMEnableModuleRequestMessage

CIMEnableModuleRequestMessage * enable_req =

new CIMEnableModuleRequestMessage(

XmlWriter::getNextMessageId (),

moduleName,

QueueIdStack(_service->getQueueId()));

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 CIMException(CIM_ERR_METHOD_NOT_AVAILABLE);

}

// get provider manager service

MessageQueueService * ProviderRegistrationProvider::_getProviderManagerService()

{

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

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

return(_service);

}

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

{

if(this == &handle)

{

return(*this);

}

return(*this);

}

Array<Uint16> ProviderRegistrationProvider::_sendDisableMessageToProviderManager(

CIMDisableModuleRequestMessage * disable_req)

{

MessageQueueService * _service = _getProviderManagerService();

Uint32 _queueId = _service->getQueueId();

callback_data *cb_data = new callback_data(this);

Line 907

Line 1071

asyncRequest);

CIMDisableModuleResponseMessage * response =

reinterpret_cast<CIMDisableModuleResponseMessage *>(

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

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

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

{

CIMException e = response->cimException;

Line 948

Line 1112

asyncRequest);

CIMEnableModuleResponseMessage * response =

reinterpret_cast<CIMEnableModuleResponseMessage *>(

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

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

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

{

CIMException e = response->cimException;

Line 969

Line 1133

// send termination message to subscription service

void ProviderRegistrationProvider::_sendTerminationMessageToSubscription(

const CIMObjectPath & ref, const String & moduleName)

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());

// get all registered providers

Array<CIMObjectPath> instanceNames =

Array<CIMInstance> enumInstances =

_providerRegistrationManager->enumerateInstanceNames(reference);

_providerRegistrationManager->enumerateInstances(reference);

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

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

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

{

instance = enumInstances[i];

// get provider module name

// get provider module name from reference

instance.getProperty(instance.findProperty

(_PROPERTY_PROVIDERMODULENAME)).getValue().get(_moduleName);

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

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

{

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

{

_moduleName = keys[j].getValue();

}

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

{

reference.setKeyBindings(keys);

instance = _providerRegistrationManager->getInstance(reference);

// if the provider is indication provider

if (_isIndicationProvider(moduleName, instance))

{

instances.append(instance);

}

else

{

instance = _providerRegistrationManager->getInstance(ref);

// if the provider is indication provider

if (_isIndicationProvider(moduleName, instance))

{

instances.append(instance);

}

Line 1014

Line 1208

instances,

QueueIdStack(_service->getQueueId()));

// l10n

termination_req->operationContext.set(AcceptLanguageListContainer(al));

// create request envelope

AsyncLegacyOperationStart * asyncRequest =

AsyncLegacyOperationStart asyncRequest

new AsyncLegacyOperationStart (

(_service->get_next_xid(),

_service->get_next_xid(),

NULL,

_queueId,

termination_req,

_queueId);

if( false == _controller->ClientSendForget(

AutoPtr <AsyncReply> asyncReply

*_client_handle,

(_controller->ClientSendWait (* _client_handle, _queueId,

_queueId,

&asyncRequest));

asyncRequest))

AutoPtr <CIMNotifyProviderTerminationResponseMessage> response

(reinterpret_cast <CIMNotifyProviderTerminationResponseMessage *>

((dynamic_cast <AsyncLegacyOperationResult *>

(asyncReply.get ()))->get_result ()));

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

{

delete asyncRequest;

CIMException e = response->cimException;

throw CIMException(CIM_ERR_NOT_FOUND);

throw (e);

}

Line 1045

Line 1247

return(_service);

}

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

// return 1 if module is already disabled, return -2 if module can not be

// disabled since there are pending requests, otherwise, return -1

Sint16 ProviderRegistrationProvider::_disableModule(

const CIMObjectPath & objectReference,

const String & moduleName,

Boolean disableProviderOnly,

const AcceptLanguages & al) // l10n

{

// get module status

Array<Uint16> _OperationalStatus =

_providerRegistrationManager->getProviderModuleStatus( moduleName);

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

{

// retValue equals 1 if module is already disabled

if (_OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPED ||

_OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPING)

{

return (1);

}

CIMInstance instance;

Array<CIMInstance> instances;

CIMInstance mInstance;

String _moduleName;

Uint16 providers;

CIMObjectPath providerRef;

Boolean indProvider = false;

Array<Boolean> indicationProviders;

// 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))

{

_moduleName = keys[j].getValue();

}

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

{

providerRef.setKeyBindings(keys);

instance = _providerRegistrationManager->getInstance

(providerRef);

if (_isIndicationProvider(moduleName, instance))

{

indProvider = true;

indicationProviders.append(true);

}

else

{

indicationProviders.append(false);

}

instances.append(instance);

}

else

{

instance = _providerRegistrationManager->getInstance(objectReference);

if (_isIndicationProvider(moduleName, instance))

{

indProvider = true;

indicationProviders.append(true);

}

else

{

indicationProviders.append(false);

}

instances.append(instance);

}

// get provider manager service

MessageQueueService * _service = _getProviderManagerService();

if (_service != NULL)

{

// create CIMDisableModuleRequestMessage

CIMDisableModuleRequestMessage * disable_req =

new CIMDisableModuleRequestMessage(

XmlWriter::getNextMessageId (),

mInstance,

instances,

disableProviderOnly,

indicationProviders,

QueueIdStack(_service->getQueueId()));

// l10n

disable_req->operationContext.set(AcceptLanguageListContainer(al));;

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] == CIM_MSE_OPSTATUS_VALUE_STOPPED)

{

if (indProvider)

{

// send termination message to subscription service

_sendTerminationMessageToSubscription(objectReference,

moduleName, false, al);

}

return (0);

}

// module is not disabled since there are pending

// requests for the providers in the module

if (_opStatus[i] == CIM_MSE_OPSTATUS_VALUE_OK)

{

return (-2);

}

else // disable provider

{

if (indProvider)

{

_sendTerminationMessageToSubscription(objectReference,

moduleName, true, al);

}

return (0);

}

// disable failed

return (-1);

}

// enable provider module

// return 0 if module is enabled successfully,

// return 1 if module is already enabled,

// return 2 if module can not be enabled since module is stopping,

// otherwise, return -1

Sint16 ProviderRegistrationProvider::_enableModule(

const CIMObjectPath & moduleRef,

const String & moduleName,

const AcceptLanguages & al)

{

// get module status

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] == CIM_MSE_OPSTATUS_VALUE_OK)

{

return (1);

}

// retValue equals 2 if module is stopping

// at this stage, module can not be started

if (_OperationalStatus[i] == CIM_MSE_OPSTATUS_VALUE_STOPPING)

{

return (2);

}

// get module instance

CIMInstance mInstance =

_providerRegistrationManager->getInstance(moduleRef);

// get provider manager service

MessageQueueService * _service = _getProviderManagerService();

Boolean enabled = false;

if (_service != NULL)

{

// create CIMEnableModuleRequestMessage

CIMEnableModuleRequestMessage * enable_req =

new CIMEnableModuleRequestMessage(

XmlWriter::getNextMessageId (),

mInstance,

QueueIdStack(_service->getQueueId()));

// l10n

enable_req->operationContext.set(AcceptLanguageListContainer(al));;

Array<Uint16> _opStatus;

_opStatus = _sendEnableMessageToProviderManager(enable_req);

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

{

// module is enabled successfully

if (_opStatus[i] == CIM_MSE_OPSTATUS_VALUE_OK)

{

enabled = true;

}

if (enabled)

{

// Since module is enabled, need get updated module instance

CIMInstance updatedModuleInstance =

_providerRegistrationManager->getInstance(moduleRef);

// module is enabled, initialize providers as necessary

_providerRegistrationManager->initializeProviders(

updatedModuleInstance);

// The module is enabled, need to send enable message to

// subscription service if the provider is an indication provider

CIMObjectPath providerRef = CIMObjectPath(String::EMPTY,

moduleRef.getNameSpace(),

PEGASUS_CLASSNAME_PROVIDER,

Array<CIMKeyBinding>());

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

// moduleName

Array<CIMObjectPath> instanceNames =

_providerRegistrationManager->enumerateInstanceNames(providerRef);

CIMInstance pInstance;

String _moduleName;

String _providerName;

Array<CIMInstance> capInstances;

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

{

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

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

{

// get provider module name from reference

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

{

_moduleName = keys[j].getValue();

}

// get provider name from reference

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

{

_providerName = keys[j].getValue();

}

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

{

providerRef.setKeyBindings(keys);

pInstance = _providerRegistrationManager->getInstance

(providerRef);

// get all the indication capability instances which belongs

// to this provider

capInstances = _getIndicationCapInstances(

moduleName, pInstance, providerRef);

// if there are indication capability instances

if (capInstances.size() != 0)

{

_sendEnableMessageToSubscription(updatedModuleInstance,

pInstance,

capInstances,

al);

}

return (0);

}

// enable failed

return (-1);

}

// send enable message to indication service

void ProviderRegistrationProvider::_sendEnableMessageToSubscription(

const CIMInstance & mInstance,

const CIMInstance & pInstance,

const Array<CIMInstance> & capInstances,

const AcceptLanguages & al)

{

// get indication server queueId

MessageQueueService * _service = _getIndicationService();

if (_service != NULL)

{

Uint32 _queueId = _service->getQueueId();

CIMNotifyProviderEnableRequestMessage * enable_req =

new CIMNotifyProviderEnableRequestMessage (

XmlWriter::getNextMessageId (),

capInstances,

QueueIdStack(_service->getQueueId()));

enable_req->operationContext.set(AcceptLanguageListContainer(al));

enable_req->operationContext.insert(ProviderIdContainer(mInstance,pInstance));

// create request envelope

AsyncLegacyOperationStart * asyncRequest =

new AsyncLegacyOperationStart (

_service->get_next_xid(),

NULL,

_queueId,

enable_req,

_queueId);

AsyncReply * asyncReply =

_controller->ClientSendWait(*_client_handle,

_queueId,

asyncRequest);

CIMNotifyProviderEnableResponseMessage * response =

reinterpret_cast<CIMNotifyProviderEnableResponseMessage *>(

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

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

{

CIMException e = response->cimException;

delete asyncRequest;

delete asyncReply;

delete response;

throw (e);

}

delete asyncRequest;

delete asyncReply;

delete response;

}

// If provider is an indication provider, return true,

// otherwise, return false

Boolean ProviderRegistrationProvider::_isIndicationProvider(

const String & moduleName,

const CIMInstance & instance)

{

// get provider name

String providerName;

Uint32 pos = instance.findProperty(_PROPERTY_PROVIDER_NAME);

if (pos != PEG_NOT_FOUND)

{

instance.getProperty(pos).getValue().get(providerName);

}

return (_providerRegistrationManager->isIndicationProvider(

moduleName, providerName));

}

// get all the capability instances whose provider type is indication

Array<CIMInstance> ProviderRegistrationProvider::_getIndicationCapInstances(

const String & moduleName,

const CIMInstance & instance,

const CIMObjectPath & providerRef)

{

// get provider name

String providerName;

Uint32 pos = instance.findProperty(CIMName (_PROPERTY_PROVIDER_NAME));

if (pos != PEG_NOT_FOUND)

{

instance.getProperty(pos).getValue().get(providerName);

}

CIMObjectPath capabilityRef;

capabilityRef = CIMObjectPath(providerRef.getHost(),

providerRef.getNameSpace(),

PEGASUS_CLASSNAME_CAPABILITIESREGISTRATION,

providerRef.getKeyBindings());

// get all Capabilities instances

Array<CIMObjectPath> instanceNames =

_providerRegistrationManager->enumerateInstanceNames(capabilityRef);

String _moduleName, _providerName;

CIMInstance capInstance;

Array<Uint16> providerTypes;

Array<CIMInstance> indCapInstances = 0;

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

{

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

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

{

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

{

_moduleName = keys[j].getValue();

}

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

{

_providerName = keys[j].getValue();

}

// if capability instance has same module name as moduleName

// and same provider name as providerName, get provider type

if(String::equal(_moduleName, moduleName) &&

String::equal(_providerName, providerName))

{

capInstance = _providerRegistrationManager->getInstance

(instanceNames[i]);

Uint32 pos = capInstance.findProperty(CIMName (_PROPERTY_PROVIDERTYPE));

if (pos != PEG_NOT_FOUND)

{

capInstance.getProperty(pos).getValue().get(providerTypes);

for (Uint32 k=0; k < providerTypes.size(); k++)

{

// if provider type of the instance is indication,

// append the instance

if (providerTypes[k] == _INDICATION_PROVIDER)

{

indCapInstances.append(capInstance);

}

return (indCapInstances);

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.22
changed lines
	Added in v.1.71

No CVS admin address has been configured