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

Return to InteropProvider.cpp CVS log

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

Diff for /pegasus/src/Pegasus/ControlProviders/InteropProvider/InteropProvider.cpp between version 1.36 and 1.46

version 1.36, 2005/05/24 10:42:51

version 1.46, 2005/06/05 23:35:20

Line 50

// CIM_ObjectManagerCommunicationMechanism

// CIM_CIMXMLCommunicationMechanism

// CIM_ProtocolAdapter (Note: Removed because deprecated class in cim 2.9)

// CIM_Namespace (Effective Pegasus 2.4 we use PG_Namespace which

// CIM_Namespace (Effective Pegasus 2.4 we use PG_Namespace.

// is a subclass of CIM_Namespace with additional properties for

// shared namespaces.

// PG_Namespace - Pegasus particular subclass of CIM_Namespace that

// add the parameters for shared namespaces

// PG_CIMXMLCommunicationMechanism - Pegasus subclass of

// CIM_CIMXMLCommunicationMechanism that adds support for passing

// additional communication parameters (ie. port, https vs. http, etc.)

// It also services the Interop associations tied to these classes

// including:

Line 71

Line 76

3. Review the key parameters on create, etc. to be sort out which are

required from user and which we can supply. I think we are asking too

much of the user right now.

4. Review deletion of _buildObjectPath, _reference, etc.

#include <Pegasus/Common/Config.h>

Line 115

Line 121

#define CDEBUG(X)

#define LDEBUG()

//#define CDEBUG(X) PEGASUS_STD(cout) << "InteropProvider " << X << PEGASUS_STD(endl)

//#define CDEBUG(X) PEGASUS_STD(cout) << "InteropProvider (" << __LINE__ << ") " << X << PEGASUS_STD(endl)

//#define LDEBUG(X) Logger::put (Logger::DEBUG_LOG, "InteropProvider", Logger::TRACE, "$0", X)

//**************************************************************************

Line 131

Line 137

/**

The constants representing the class names we process

// ATTN DELETE: static const CIMName __NAMESPACE_CLASSNAME = CIMName ("__Namespace");

static const CIMName CIM_NAMESPACE_CLASSNAME = CIMName ("CIM_Namespace");

static const CIMName PG_NAMESPACE_CLASSNAME = CIMName ("PG_Namespace");

Line 145

Line 150

static const CIMName CIM_NAMESPACEINMANAGER_CLASSNAME =

CIMName ("CIM_NamespaceInManager");

// Property Names for __Namespace Class

// Property Names for CIM_Namespace Class

static const CIMName NAMESPACE_PROPERTYNAME = CIMName ("Name");

// Root Namespace Name for test.

static const CIMNamespaceName ROOTNS = CIMNamespaceName ("root");

// Property names for CIM_ObjectManager Class

static const CIMName OM_GATHERSTATISTICALDATA =

CIMName ("GatherStatisticalData");

// Property for the slp template.

static const CIMName OM_DESCRIPTIONPROPERTY =

CIMName("Description");

Line 213

Line 221

// operations.

enum targetClass{

//__NAMESPACE = 1,

PG_NAMESPACE = 1,

CIM_OBJECTMANAGER = 2,

PG_CIMXMLCOMMUNICATIONMECHANISM = 3,

Line 228

Line 235

};

String _showPathArray(Array<CIMObjectPath>& p)

{

String rtn;

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

{

if (i > 0)

rtn.append(" ");

rtn.append(p[i].toString());

}

return(rtn);

}

void _printInstance(String& message, CIMInstance& instance)

{

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s %s\npath: %s\n %s",thisProvider, message.getCString(),

(instance.getPath().toString().getCString()),

( ( CIMObject) instance).toString().getCString());

}

//*************************************************************

// Constructor

//**********************************************************

Line 238

Line 265

//***********************************************

// This is a tempory fix untill there is a method created for the InteropProvider to

// do it's inaliaztion work. This fix sets StatisticalData::CopyGSD, enabling the

// do it's inalization work. This fix sets StatisticalData::CopyGSD, enabling the

//statistical gathering function.

Array<CIMInstance> instance = repository->enumerateInstances(CIMNamespaceName("root/cimv2"), CIMName ("CIM_ObjectManager"));

if(instance.size() > 0)

Boolean InstancesExists = true;

Array<CIMInstance> instance;

try

{

instance = repository->enumerateInstances(CIMNamespaceName("root/cimv2"),

CIMName ("CIM_ObjectManager"));

}

catch(Exception e)

{

InstancesExists = false;

}

/* When Bug 3696 is fixed the following try block will replace the try block above. But for

now if no instances of the CIM_ObjectManager class are found in the root/cimv2 name space

the root/PG_InterOp name space will be checked

if(!InstancesExists)

{

try

{

instance = repository->enumerateInstances(CIMNamespaceName("root/PG_InterOp"),

CIMName ("CIM_ObjectManager"));

}

catch(Exception e)

{

InstancesExists = false;

}

if(instance.size() > 0 && InstancesExists)

{

Boolean output = false;

Uint32 pos;

Line 268

Line 325

PEG_METHOD_EXIT();

}

//***************************************************************

// Provider Utility Functions

//***************************************************************

Line 291

Line 346

return(tmp);

}

/* set the hostname and namespace fields into the cimobjectpath

of the defined instance

void _setCompleteInstancePath(CIMInstance& instance,

const CIMObjectPath& inputPath)

{

CIMObjectPath p = instance.getPath();

p.setHost(inputPath.getHost());

p.setNameSpace(inputPath.getNameSpace());

instance.setPath(p);

}

/* complete the instance by setting the complete path into the instance

and executing the instance filter to set the qualifiers, classorigin and

propertylist in accordance with the input. Note that this can only remove

characteristics, except for the path completion so that it expects instances

with qualifiers included, class origin included and a complete property

list.

void _finishInstance(CIMInstance& instance, const CIMObjectPath& path, Boolean includeQualifiers,

Boolean includeClassOrigin, const CIMPropertyList& propertyList)

{

_setCompleteInstancePath( instance, path);

instance.filter(includeQualifiers,

includeClassOrigin,

propertyList );

}

static String _showPropertyList(const CIMPropertyList& pl)

{

if (pl.isNull())

Line 355

Line 442

used for localhost (127.0.0.1).

@param hostName String with the name of the host

@return String with the IP address to be used

@param namespaceType - Uint32 representing the

NOTE: This code should not be in slpprovider. This

access protocol for this request. This is exactly

should be in the Interop classes but for the moment

the definition in the PG_CIMXMLCommunicationMechanism

it is not.

mof for the property namespaceAccessProtocol.

@return String with the IP address to be used. This must

be the complete address sufficient to access the

IP address. Therefore, it includes the port number.

String _getHostAddress(String hostName)

String _getHostAddress(String & hostName, Uint32 namespaceType)

{

String ipAddress;

Line 372

Line 462

// set default address if everything else failed

ipAddress = String("127.0.0.1");

}

// Question: is there a case where we leave off the port number.

// Code to get the property service_location_tcp ( which is equivalent to "IP address:5988")

// Need to tie these two together.

Uint32 portNumber;

/********************** Drop this

ConfigManager* configManager = ConfigManager::getInstance();

Boolean enableHttpConnection = String::equal(

configManager->getCurrentValue("enableHttpConnection"), "true");

Boolean enableHttpsConnection = String::equal(

configManager->getCurrentValue("enableHttpsConnection"), "true");

***********************/

// ATTN: The following is incorrect and must be modified as part

// of bug 1857 and possibly other bug reports. KS. This is 2.5 mustfix.

// Match the protocol and port number from internal information.

if (namespaceType == 3)

portNumber = System::lookupPort(WBEM_HTTPS_SERVICE_NAME,

WBEM_DEFAULT_HTTPS_PORT);

else if (namespaceType == 2)

{

portNumber = System::lookupPort(WBEM_HTTP_SERVICE_NAME,

WBEM_DEFAULT_HTTP_PORT);

}

else

portNumber = 0;

// convert portNumber to ascii

char buffer[32];

sprintf(buffer, ":%u", portNumber);

if (portNumber != 0)

ipAddress.append(buffer);

// now fillout the serviceIDAttribute from the object manager instance name property.

// This is a key field so must have a value.

//String strUUID = _getPropertyValue( instance_ObjMgr, namePropertyName, "DefaultEmptyUUID");

return ipAddress;

}

Line 557

Line 684

@return the CIMClass object

@Exceptions any repository exceptions if class not found.

CIMClass InteropProvider::_getClass(const CIMNamespaceName& nameSpace,

CIMClass InteropProvider::_getClass(const CIMObjectPath& objectPath,

const CIMName& className)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_getClass");

CIMClass myClass = _repository->getClass(nameSpace, className,

CIMClass myClass = _repository->getClass(objectPath.getNameSpace(), className,

false,true,true);

PEG_METHOD_EXIT();

return myClass;

Line 646

Line 773

@param value String value to set into property

void _setPropertyValue(CIMInstance& instance, const CIMName propertyName, const String& value)

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const String& value)

{

Uint32 pos;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

instance.getProperty(pos).setValue(CIMValue(value));

}

void _setPropertyValue(CIMInstance& instance, const CIMName propertyName, const Boolean& value)

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const Boolean& value)

{

Uint32 pos;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

instance.getProperty(pos).setValue(CIMValue(value));

}

void _setPropertyValue(CIMInstance& instance, const CIMName propertyName, const Uint16& value)

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const Uint16& value)

{

Uint32 pos;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

instance.getProperty(pos).setValue(CIMValue(value));

}

void _setPropertyValue(CIMInstance& instance, const CIMName propertyName, const Array<String>& value)

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const Array<String>& value)

{

Uint32 pos;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

instance.getProperty(pos).setValue(CIMValue(value));

}

void _setPropertyValue(CIMInstance& instance, const CIMName propertyName, const Array<Uint16>& value)

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const Array<Uint16>& value)

{

Uint32 pos;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

instance.getProperty(pos).setValue(CIMValue(value));

}

void _setPropertyValue(CIMInstance& instance, const CIMName propertyName, const CIMObjectPath& value)

void _setPropertyValue(CIMInstance& instance, const CIMName& propertyName, const CIMObjectPath& value)

{

Uint32 pos;

if ((pos = instance.findProperty(propertyName)) != PEG_NOT_FOUND)

Line 698

Line 825

"InteropProvider::_fixInstanceCommonKeys()");

String SystemCreationClassName = System::getSystemCreationClassName ();

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,SystemCreationClassName);

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

SystemCreationClassName);

// Add property SystemName

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMNAME,System::getFullyQualifiedHostName());

System::getFullyQualifiedHostName());

PEG_METHOD_EXIT();

}

Line 718

Line 846

@return CIMInstance of this class with properties complete.

@exception passes on any exceptions received from the repository request.

CIMInstance InteropProvider::_buildInstanceSkeleton(const CIMName& className)

CIMInstance InteropProvider::_buildInstanceSkeleton(const CIMObjectPath & objectPath,

const CIMName& className,

CIMClass& returnedClass)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstanceSkeleton()");

CIMClass myClass;

// get class with lo = false, qualifier = true classorig = true

CIMClass myClass = _repository->getClass(objectPath.getNameSpace(),

CIMInstance skeleton(className);

className, false, true, true);

myClass = _repository->getClass(_operationNamespace, className, false, true, true);

returnedClass = myClass;

CIMInstance skeleton = myClass.buildInstance(true,true,CIMPropertyList());

// copy the qualifiers

for (Uint32 i = 0 ; i < myClass.getQualifierCount() ; i++)

skeleton.addQualifier(myClass.getQualifier(i));

// copy the properties

for (Uint32 i = 0 ; i < myClass.getPropertyCount() ; i++)

skeleton.addProperty(myClass.getProperty(i));

PEG_METHOD_EXIT();

return(skeleton.clone());

return(skeleton);

}

/* build a single instance of the cimxmlcommunicationmechanism class

using the parameter provided as the name property

using the parameter provided as the name property.

Builds the complete instance and sets the path into it.

@parm name String representing the name to be used for this object.

@return CIMInstance of the class

CIMInstance InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism(

const CIMObjectPath& objectPath,

const String& namespaceType,

const String& IPAddress,

const Uint16& accessProtocol,

const Boolean& includeQualifiers,

const String& IPAddress)

const Boolean& includeClassOrigin,

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism()");

CIMClass targetClass;

CIMInstance instance = _buildInstanceSkeleton(PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME);

CIMInstance instance = _buildInstanceSkeleton(objectPath,

PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME,

targetClass);

_fixInstanceCommonKeys(instance);

//CreationClassName

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME.getString());

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME.getString());

//Name, this CommunicationMechanism. We need to make it unique. To do this

// we simply append the commtype to the classname since we have max of two right

// now.

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME, (String("PEGASUSCOMM") + namespaceType));

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME,

(String("PEGASUSCOMM") + namespaceType));

// CommunicationMechanism Property - Force to 2.

_setPropertyValue(instance, OM_COMMUNICATIONMECHANISM, Uint16(2));

Line 785

Line 912

Array<Uint16> authentications;

Array<String> authenticationDescriptions;

// Note that we have fixed authentication here.

//TODO - get from system.

authentications.append(3); authenticationDescriptions.append("Basic");

_setPropertyValue(instance, OM_AUTHENTICATIONMECHANISMSSUPPORTED, authentications);

Line 797

Line 924

// Obsolete function

_setPropertyValue(instance, "namespaceType", namespaceType);

_setPropertyValue(instance, "namespaceAccessProtocol", accessProtocol);

_setPropertyValue(instance, "IPAddress", IPAddress);

// build the instance path and set into instance

instance.setPath(instance.buildPath(targetClass));

PEG_METHOD_EXIT();

return(instance);

}

Array<CIMInstance> InteropProvider::_buildInstancesPGCIMXMLCommunicationMechanism(

const Boolean includeQualifiers,

const CIMObjectPath& objectPath)

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstancesPGCIMXMLCommunicationMechanism");

// This is a temporary hack to get the multiple connections.

// This is based on the configmanager being the source of what

// protocols are available, http and https.

ConfigManager* configManager = ConfigManager::getInstance();

Boolean enableHttpConnection = String::equal(

configManager->getCurrentValue("enableHttpConnection"), "true");

Boolean enableHttpsConnection = String::equal(

configManager->getCurrentValue("enableHttpsConnection"), "true");

String IPAddress = _getHostAddress(System::getHostName());

Array<CIMInstance> instances;

Uint32 namespaceAccessProtocol;

String namespaceType;

// for each type, create the instance if that type is defined.

String hostName = System::getHostName();

if (enableHttpConnection)

{

CDEBUG("building pgcimxmlinstances 1");

namespaceAccessProtocol = 2;

CIMInstance instance = _buildInstancePGCIMXMLCommunicationMechanism(

namespaceType = "http";

"http", IPAddress,

CIMInstance instance =

includeQualifiers,

_buildInstancePGCIMXMLCommunicationMechanism(

includeClassOrigin,

objectPath,

propertyList);

namespaceType,

namespaceAccessProtocol,

_getHostAddress(hostName, namespaceAccessProtocol));

instances.append(instance);

}

if (enableHttpsConnection)

{

CDEBUG("building pgcimxmlinstances 2");

namespaceAccessProtocol = 3;

CIMInstance instance = _buildInstancePGCIMXMLCommunicationMechanism(

namespaceType = "https";

"https", IPAddress,

CIMInstance instance =

includeQualifiers,

_buildInstancePGCIMXMLCommunicationMechanism(

includeClassOrigin,

objectPath,

propertyList);

namespaceType,

namespaceAccessProtocol,

_getHostAddress(hostName, namespaceAccessProtocol));

instances.append(instance);

}

PEG_METHOD_EXIT();

return(instances);

}

/* Gets the value for the CIMObjectManager name. This is a key

property with the following characteristics.

1. It is persistent. This must be persistent through CIMOM

Line 868

Line 1012

this is used so infrequently, waste of space.

Boolean InteropProvider::_getInstanceFromRepositoryCIMObjectManager(

const CIMObjectPath& objectPath,

CIMInstance& rtnInstance,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

Line 875

Line 1020

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_getInstanceCIMObjectManager");

// Try to get persistent instance from repository

Array<CIMInstance> instances;

try

{

instances = _repository->enumerateInstances(_operationNamespace,

instances = _repository->enumerateInstances(

objectPath.getNameSpace(),

CIM_OBJECTMANAGER_CLASSNAME, true, false, includeQualifiers,

includeClassOrigin, propertyList);

CDEBUG("_getInstancefrom... " << instances.size());

if (instances.size() >= 1)

{

// set this instance into global variable.

Line 895

Line 1041

// but we will still continue to use the first entry.

if (instances.size() > 1)

{

Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,

Logger::put(Logger::ERROR_LOG,

"Error. Multiple definitons of : $0", CIM_OBJECTMANAGER_CLASSNAME.getString());

System::CIMSERVER, Logger::INFORMATION,

"Error. Multiple definitons of : $0",

CIM_OBJECTMANAGER_CLASSNAME.getString());

}

CDEBUG("getInstanceFromRepository returning true");

return(true);

}

else

{

CDEBUG("getInstanceFromRepository returning false");

return(false);

}

catch(const CIMException&)

{

Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,

"Error. Cannot access $0 in repository", CIM_OBJECTMANAGER_CLASSNAME.getString());

"Error. Cannot access $0 in repository",

CIM_OBJECTMANAGER_CLASSNAME.getString());

PEG_METHOD_EXIT();

throw;

}

catch(const Exception&)

{

Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,

"Error. Cannot access $0 in repository", CIM_OBJECTMANAGER_CLASSNAME.getString());

"Error. Cannot access $0 in repository",

CIM_OBJECTMANAGER_CLASSNAME.getString());

PEG_METHOD_EXIT();

throw;

}

Line 935

Line 1083

for this class.

CIMInstance InteropProvider::_getInstanceCIMObjectManager(

const CIMObjectPath& objectPath,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

Line 944

Line 1093

// Try to get the current object. If true then it is already created.

CIMInstance instance;

if (!_getInstanceFromRepositoryCIMObjectManager(instance, includeQualifiers,includeClassOrigin,propertyList))

if (!_getInstanceFromRepositoryCIMObjectManager(objectPath,

instance, includeQualifiers,includeClassOrigin,propertyList))

{

// No instance in the repository. Build new instance and save it.

CDEBUG("Creating New instance of CIMOBjectManager");

CIMClass targetClass;

instance = _buildInstanceSkeleton(CIM_OBJECTMANAGER_CLASSNAME);

instance = _buildInstanceSkeleton(objectPath, CIM_OBJECTMANAGER_CLASSNAME,

targetClass);

_fixInstanceCommonKeys(instance);

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,CIM_OBJECTMANAGER_CLASSNAME.getString());

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString());

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME,buildObjectManagerName());

_setPropertyValue(instance, CIMName("ElementName"), String("Pegasus"));

//Description property this object manager instance

// default is Pegasus CIM_Server Version.

// default is Pegasus CIM_Server Version. Get from

// Provided undocumented option to get this from the environment.

// fields defined in PegasusVersion.

// This should probably be removed or documented.

// TODO. Add as an alternative the capability to get this

// from config parameters.

String description;

// If PEGASUS_CIMOM_DESCRIPTION is non-zero length, use it.

char * envDescription;

// Otherwise build form the components below.

envDescription = getenv("PEGASUS_CIMOM_DESCRIPTION");

String description = (String(PEGASUS_CIMOM_DESCRIPTION).size() != 0) ?

description = (envDescription) ? envDescription :

String(PEGASUS_CIMOM_DESCRIPTION)

String(PEGASUS_CIMOM_GENERIC_NAME) + " " +

String(PEGASUS_PRODUCT_NAME) + " Version " +

String(PEGASUS_PRODUCT_VERSION);

String(PEGASUS_PRODUCT_VERSION) + " " +

String(PEGASUS_PRODUCT_STATUS);

_setPropertyValue(instance, CIMName("Description"), description);

Line 993

Line 1148

// write instance to the repository

CIMObjectPath instancePath;

// Add the instance path to this if necessary ATTN ATTN:

try

{

CDEBUG("Create Instance for CIM_ObjectManager");

instancePath = _repository->createInstance(objectPath.getNameSpace(),

instancePath = _repository->createInstance(_operationNamespace,

instance );

}

catch(const CIMException&)

{

// ATTN: KS generate log error if this not possible

// TODO ATTN: KS generate log error if this not possible

PEG_METHOD_EXIT();

throw;

}

Line 1014

Line 1168

}

instance.setPath(instancePath);

}

instance.filter(includeQualifiers, includeClassOrigin, propertyList);

PEG_METHOD_EXIT();

return(instance);

}

/** Get the instances of CIM_Namespace. Gets all instances of the namespace from

the repository namespace management functions

the repository namespace management functions. Builds instances that

Pegasus 2.4 - This now gets CIM_Namespace and its subclass PG_Namespace

match all of the request attributes.

Array<CIMInstance> InteropProvider::_getInstancesCIMNamespace(const Boolean& includeQualifiers,

Array<CIMInstance> InteropProvider::_getInstancesCIMNamespace(

const Boolean& includeClassOrigin,

const CIMObjectPath& objectPath)

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_getInstancesCIMNamespace()");

CDEBUG("_getinstancesPGNamespace");

Array<CIMNamespaceName> namespaceNames = _enumerateNameSpaces();

CDEBUG("_getInstancesCIMNamespace. count = " << namespaceNames.size());

Array<CIMInstance> instanceArray;

// We build instances of PG namespace since that is the leaf class

// Build instances of PG namespace since that is the leaf class

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

{

instanceArray.append( _buildInstancePGNamespace(namespaceNames[i]));

instanceArray.append( _buildInstancePGNamespace(objectPath, namespaceNames[i]));

}

CDEBUG("Build this many PG_Namespace Instances. count= " << instanceArray.size());

PEG_METHOD_EXIT();

return(instanceArray);

}

Line 1049

Line 1198

for the instance required.

ATTN: Note that this is incorrect. We are supplying the namespace name and need to supply

the objectpath

@param TBD

@param objectPath CIMObjectPath from request

@param nameSpace CIMNamespaceName for instance to get

@return CIMInstance with the found instance or CIMInstance() if nothing found.

CIMInstance InteropProvider::_getInstanceCIMNamespace(const CIMNamespaceName & nameSpace)

CIMInstance InteropProvider::_getInstanceCIMNamespace(const CIMObjectPath& objectPath)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_getInstancesCIMNamespace()");

Array<CIMInstance> instances = _getInstancesCIMNamespace(true, true, CIMPropertyList());

Array<CIMInstance> instances = _getInstancesCIMNamespace(objectPath);

CIMNamespaceName nameSpace = objectPath.getNameSpace();

// search the instances for one with the name property value = input parameter.

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

{

Line 1072

Line 1223

CIMInstance nullInstance;

return(nullInstance);

}

/* build the full instances set of of the association class NamespacInManager.

CIMObjectPath InteropProvider::_buildReference(const CIMInstance& instance, const CIMName& className)

NOTE: THe input object path is not really use at this point.

{

return(_buildObjectPath(_operationNamespace,className, instance));

Array<CIMInstance> InteropProvider::_buildInstancesNamespaceInManager(

}

const CIMObjectPath& objectPath)

Array<CIMInstance> InteropProvider::_buildInstancesNamespaceInManager()

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstancesNamespaceInManager");

Array<CIMInstance> namespaceInstances = _getInstancesCIMNamespace(false,

Array<CIMInstance> namespaceInstances = _getInstancesCIMNamespace(objectPath);

false, CIMPropertyList());

CIMInstance instanceObjMgr = _getInstanceCIMObjectManager(objectPath,

true, true, CIMPropertyList());

CIMInstance instanceObjMgr = _getInstanceCIMObjectManager( true, true, CIMPropertyList());

CIMObjectPath refObjMgr = instanceObjMgr.getPath();

CIMObjectPath refObjMgr = _buildReference(instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME);

refObjMgr.setHost(objectPath.getHost());

refObjMgr.setNameSpace(objectPath.getNameSpace());

Array<CIMInstance> assocInstances;

CIMClass targetClass;

CIMInstance instanceskel = _buildInstanceSkeleton(objectPath,

CIM_NAMESPACEINMANAGER_CLASSNAME,

targetClass);

// Build and instance for each namespace instance.

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

{

CIMInstance instance = _buildInstanceSkeleton(CIM_NAMESPACEINMANAGER_CLASSNAME);

CIMInstance instance = instanceskel.clone();

_setPropertyValue(instance, CIMName("Antecedent"), refObjMgr);

//ATTNATTN: this is weak qualifier.

_setPropertyValue(instance, CIMName("Dependent"), _buildReference(namespaceInstances[i],

CIMObjectPath temp = namespaceInstances[i].getPath();

CIM_NAMESPACEINMANAGER_CLASSNAME));

temp.setHost(objectPath.getHost());

temp.setNameSpace(objectPath.getNameSpace());

_setPropertyValue(instance, CIMName("Dependent"), temp);

instance.setPath(instance.buildPath(targetClass));

assocInstances.append(instance);

}

PEG_METHOD_EXIT();

return(assocInstances);

}

/* build the instances of the defined association.

Array<CIMInstance> InteropProvider::_buildInstancesCommMechanismForManager()

Array<CIMInstance> InteropProvider::_buildInstancesCommMechanismForManager(

const CIMObjectPath& objectPath)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstancesCommMechanismForManager");

Array<CIMInstance> commInstances = _buildInstancesPGCIMXMLCommunicationMechanism(true,

Array<CIMInstance> commInstances = _buildInstancesPGCIMXMLCommunicationMechanism(

true, CIMPropertyList());

objectPath);

CIMInstance instanceObjMgr = _getInstanceCIMObjectManager( true, true, CIMPropertyList());

CIMInstance instanceObjMgr = _getInstanceCIMObjectManager(objectPath,

true, true, CIMPropertyList());

CIMObjectPath refObjMgr = _buildReference(instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME);

CIMObjectPath refObjMgr = instanceObjMgr.getPath();

Array<CIMInstance> assocInstances;

CIMClass targetClass;

CIMInstance instanceskel = _buildInstanceSkeleton(objectPath,

CIM_NAMESPACEINMANAGER_CLASSNAME, targetClass);

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

{

CIMInstance instance = instanceskel.clone();

CIMInstance instance = _buildInstanceSkeleton(CIM_COMMMECHANISMFORMANAGER_CLASSNAME);

_setPropertyValue(instance,CIMName("Antecedent"), refObjMgr);

//ATTNATTN: this is weak qualifier.

_setPropertyValue(instance,CIMName("Dependent"), _buildReference(commInstances[i],CIM_COMMMECHANISMFORMANAGER_CLASSNAME));

_setPropertyValue(instance, CIMName("Dependent"), commInstances[i].getPath());

instance.setPath(instance.buildPath(targetClass));

assocInstances.append(instance);

}

Line 1138

Line 1305

/* generate one instance of the CIM_Namespace class with the

properties

NOTE: CIM 2.4 - Changed to build PG namespace

@param objectPath

@param namespace name to put into the class

@exceptions - exceptions carried forward from create instance

and addProperty.

CIMInstance InteropProvider::_buildInstancePGNamespace(const CIMNamespaceName & nameSpace)

CIMInstance InteropProvider::_buildInstancePGNamespace(const CIMObjectPath& objectPath,

CIMNamespaceName& nameSpace)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstancePGNamespace");

Line 1153

Line 1322

// interop or more generally somewhere within the system for common access.

String ObjectManagerName = "ObjectManagerNameValue";

CIMInstance instance = _buildInstanceSkeleton(PG_NAMESPACE_CLASSNAME);

CIMClass targetClass;

CIMInstance instance = _buildInstanceSkeleton(objectPath, PG_NAMESPACE_CLASSNAME,

targetClass);

_fixInstanceCommonKeys(instance);

Line 1232

Line 1403

_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_PARENTNAMESPACE, parent);

_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_NAME, name);

instance.setPath(instance.buildPath(targetClass));

PEG_METHOD_EXIT();

return(instance);

}

void _validateCIMNamespaceKeys(const CIMObjectPath& objectPath)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

Line 1327

Line 1500

}

else

{

_setPropertyValue(instance, propertyName, value);

}

Line 1475

Line 1647

/** builds complete object path from instance and classinfo by building the full path

with host and namespace names included.

CIMObjectPath InteropProvider::_buildObjectPath(const CIMNamespaceName& name,

CIMObjectPath InteropProvider::_buildObjectPath(const CIMObjectPath& objectPath,

const CIMName& className,

const CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildObjectPath");

CIMObjectPath objectPath;

CIMObjectPath rtnObjectPath;

objectPath = _buildInstancePath(name,className,instance);

rtnObjectPath = _buildInstancePath(objectPath,className,instance);

objectPath.setHost(System::getHostName());

rtnObjectPath.setHost(objectPath.getHost());

objectPath.setNameSpace(name);

rtnObjectPath.setNameSpace(objectPath.getNameSpace());

PEG_METHOD_EXIT();

return(objectPath);

return(rtnObjectPath);

}

/* Given a class and instance build the instance path for a

Line 1501

Line 1673

@exceptions - Passes repository exceptions.

CIMObjectPath InteropProvider::_buildInstancePath(const CIMNamespaceName& name,

CIMObjectPath InteropProvider::_buildInstancePath(const CIMObjectPath& objectPath,

const CIMName& className,

const CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstancePath");

// get the class CIM_Namespace class to use in building path

// get the class to use in building path

// Exception out if Class does not exist in this namespace

// Exception if Class does not exist in this namespace

CIMClass thisClass = _getClass(name, className);

CIMClass thisClass = _getClass(objectPath, className);

CIMObjectPath ref = instance.buildPath(thisClass);

Line 1560

Line 1732

String name;

propertyValue.get(name);

return(name);

//ATTN: KS Returns String whereas below returns CIMNamespaceName.

}

/** Test for valid CIMReferences from an association instance. If there is a role

property, tests if there is a match for this role and the target object.

Confirms that this role and this reference exist in the target instance.

@param target - The target path for the association. Localization assumed.

@param instance - The association class instance we are searching for references

@param role - The role we require. I there is no role, this is String::EMPTY

@return - returns Boolean true if target is found in a reference that is

the same role

Boolean _isInstanceValidReference(const CIMObjectPath& target,

const CIMInstance& instance,

const String& role)

{

// Test if role parameter is valid property.

Uint32 pos;

if (role != String::EMPTY)

{

// Test if property with this role exists.

if ((pos = instance.findProperty(role)) == PEG_NOT_FOUND)

throw CIMException(CIM_ERR_INVALID_PARAMETER);

// Check to be sure this is a reference property

// This test may not be necessary. Combine it into the loop.

if (instance.getProperty(pos).getType() != CIMTYPE_REFERENCE)

throw CIMException(CIM_ERR_INVALID_PARAMETER);

}

//Search instance for all reference properties

for (Uint32 j = 0; j < instance.getPropertyCount() ; j++)

{

const CIMConstProperty p = instance.getProperty(j);

if (p.getType() == CIMTYPE_REFERENCE)

{

// If there is no role or the role is the same as this property name

CIMValue v = p.getValue();

CIMObjectPath path;

v.get(path);

// if no role or role ==this role and target = this path, rtn true.

if ((role == String::EMPTY) || (role == p.getName().getString()))

{

if (target.identical(path))

return(true);

}

return( false );

}

/** Filters the input of instances (which contain path info)

using the assocClassName, assocRole, ResultClassName and

resultRole. Removes any instances from the list that

do not match the filters.

@instances Array<CIMInstance to filter.

* TODO - Shouldn't we remove rather than copy??? faster.

* TODO - why extra check for no resultClass??

Array<CIMObject> _filterReferenceInstances(Array<CIMInstance>& instances,

const CIMObjectPath& targetobjectName,

const CIMName& resultClass,

const String& resultRole)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"_filterReferenceInstances()");

CIMObjectPath targetReference = CIMObjectPath(

String(),

CIMNamespaceName(),

targetobjectName.getClassName(),

targetobjectName.getKeyBindings());

Array<CIMObject> rtnObjects;

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

{

if (resultClass.isNull() || resultClass.equal(instances[i].getClassName()))

{

// if this association instance has this role in targetReference, true

if (_isInstanceValidReference(targetobjectName, instances[i], resultRole))

{

rtnObjects.append(instances[i]);

}

PEG_METHOD_EXIT();

return( rtnObjects );

}

//***************************************************************************

// The following section is the Instance Operation processors

//***************************************************************************

Line 1582

Line 1839

(const char *) instanceReference.toString().getCString());

handler.processing();

CIMNamespaceName newNamespaceName;

CDEBUG("CreateInstance " << instanceReference.toString());

// operation namespace needed internally to get class.

_operationNamespace = instanceReference.getNameSpace();

// KS_TEMP _operationNamespace = instanceReference.getNameSpace();

// Verify that ClassName is correct and get value

targetClass classEnum = _verifyValidClassInput(instanceReference.getClassName());

Line 1594

Line 1849

String userName = _validateUserID(context);

CIMObjectPath newInstanceReference;

if ((classEnum == CIM_OBJECTMANAGER) ||

CIMNamespaceName newNamespaceName;

(classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM))

throw CIMNotSupportedException("InteropProvider, Create Not allowed");

if (classEnum == PG_NAMESPACE)

{

#ifdef PEGASUS_OS_OS400

MessageLoaderParms mparms("ControlProviders.InteropProvider.CREATE_INSTANCE_NOT_ALLOWED",

MessageLoaderParms mparms(

"ControlProviders.InteropProvider.CREATE_INSTANCE_NOT_ALLOWED",

"Create instance operation not allowed by Interop Provider for class $0.",

PG_NAMESPACE_CLASSNAME.getString());

throw CIMNotSupportedException(mparms);

Line 1613

Line 1866

// Validate that keys are as required. Does its own exception.

newNamespaceName = _getKeyValue(myInstance, CIM_NAMESPACE_PROPERTY_NAME);

newInstanceReference = _buildInstancePath(_operationNamespace,

newInstanceReference = _buildInstancePath(instanceReference,

PG_NAMESPACE_CLASSNAME, localInstance);

#endif

}

else if ((classEnum == CIM_OBJECTMANAGER) ||

(classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM))

{

PEG_METHOD_EXIT();

throw CIMNotSupportedException("InteropProvider, Create Not allowed");

}

else // Invalid class for the create functions.

{

PEGASUS_ASSERT(false);

Line 1677

Line 1937

"Namespace = " + newNamespaceName.getString() +

" successfully created.");

Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

"Create Namespace: Shareable = $0, Updates allows: $1, Parent: $2",

"Create Namespace: Shareable = $0, Updates allowed: $1, Parent: $2",

newNamespaceName.getString(), shareable? "true" : "false", shareable? "true" : "false", parent );

newNamespaceName.getString(), shareable?

"true" : "false", shareable? "true" : "false", parent );

}

catch(const CIMException&)

Line 1718

Line 1979

thisProvider,

(const char *) instanceName.toString().getCString());

_operationNamespace = instanceName.getNameSpace();

// KS_TEMP _operationNamespace = instanceName.getNameSpace();

handler.processing();

// Verify that ClassName is correct and get value

targetClass classEnum = _verifyValidClassInput(instanceName.getClassName());

Line 1730

Line 1991

{

try

{

_repository->deleteInstance(_operationNamespace,instanceName);

_repository->deleteInstance(instanceName.getNameSpace(),instanceName);

}

catch(const CIMException&)

{

Line 1742

Line 2003

{

CIMNamespaceName deleteNamespaceName;

#ifdef PEGASUS_OS_OS400

MessageLoaderParms mparms("ControlProviders.InteropProvider.DELETE_INSTANCE_NOT_ALLOWED",

MessageLoaderParms mparms(

"ControlProviders.InteropProvider.DELETE_INSTANCE_NOT_ALLOWED",

"Delete instance operation not allowed by Interop Provider for class $0.",

PG_NAMESPACE_CLASSNAME.getString());

throw CIMNotSupportedException(mparms);

Line 1776

Line 2038

throw CIMNotSupportedException("Delete Not allowed for " + instanceName.getClassName().getString());

}

handler.processing();

handler.complete();

PEG_METHOD_EXIT();

return ;

}

//***************************************************************************

/** Local version of getInstance to be used by other functions in the

// getInstance

the provider. Returns a single instance. Note that it always

//***************************************************************************

returns an instance. If none was found, it is unitinialitized.

void InteropProvider::getInstance(

CIMInstance InteropProvider::localGetInstance(

const OperationContext & context,

const CIMObjectPath & instanceName,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

const CIMPropertyList & propertyList)

InstanceResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::getInstance");

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localGetInstance");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s getInstance. instanceName= %s , includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

Line 1804

Line 2064

(const char *)_showBool(includeQualifiers).getCString(),

(const char*) _showBool(includeClassOrigin).getCString(),

(const char *)_showPropertyList(propertyList).getCString());

// Verify that ClassName is correct and get value

targetClass classEnum = _verifyValidClassInput(instanceName.getClassName());

_operationNamespace = instanceName.getNameSpace();

String userName = _validateUserID(context);

// begin processing the request

handler.processing();

if (classEnum == CIM_OBJECTMANAGER)

{

CIMInstance instance = _getInstanceCIMObjectManager(includeQualifiers,

includeClassOrigin, propertyList);

handler.deliver(instance);

handler.complete();

PEG_METHOD_EXIT();

return;

}

if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

// create reference from host, namespace, class components of

{

// instance name

// ATTN: test for correct instance KS: Priority 1

CIMObjectPath ref;

Array <CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(

ref.setHost(instanceName.getHost());

ref.setClassName(instanceName.getClassName());

ref.setNameSpace(instanceName.getNameSpace());

// Enumerate instances for this class. Returns all instances

// Note that this returns paths setup and instances already

// filtered per the input criteria.

Array<CIMInstance> instances = localEnumerateInstances(

context,

ref,

includeQualifiers,

includeClassOrigin, propertyList);

includeClassOrigin,

handler.deliver(instances[0]);

propertyList);

handler.complete();

PEG_METHOD_EXIT();

return;

}

if (classEnum == CIM_NAMESPACEINMANAGER)

{

handler.complete();

PEG_METHOD_EXIT();

return;

}

// Get List of namespaces

Array<CIMNamespaceName> namespaceNames;

namespaceNames = _enumerateNameSpaces();

CIMInstance instance;

if (classEnum == PG_NAMESPACE)

// deliver a single instance if found.

CIMInstance rtnInstance;

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

{

// Not clear what we have to take into account here.

if (instanceName == instances[i].getPath())

// get the namespace from the name value.

// should check the other keys to see if valid.

CIMNamespaceName namespaceName;

namespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME);

// ATTN: Why this CIMNamespaceName parentNamespaceName = instanceName.getNameSpace();

if (!Contains(namespaceNames, namespaceName))

{

throw CIMObjectNotFoundException("Namespace does not exist: "

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

+ namespaceName.getString());

"%s getInstance return instance number %u\npath: %s\n %s\n",thisProvider, i,

(instances[i].getPath().toString().getCString()),

( ( CIMObject) instances[i]).toString().getCString());

rtnInstance = instances[i];

break;

// TODO Add test for duplicates somewhere.

}

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + namespaceName.getString() + " successfully found.");

instance = _getInstanceCIMNamespace(namespaceName);

}

else // processing for __Namespace

PEG_METHOD_EXIT();

{

return(rtnInstance);

PEGASUS_ASSERT(false);

}

//***************************************************************************

// getInstance

//***************************************************************************

void InteropProvider::getInstance(

const OperationContext & context,

const CIMObjectPath & instanceName,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

InstanceResponseHandler & handler)

{

handler.processing();

handler.deliver(instance);

CIMInstance myInstance = localGetInstance(

context,

instanceName,

includeQualifiers,

includeClassOrigin,

propertyList);

// complete processing the request

if (!myInstance.isUninitialized())

handler.complete();

handler.deliver(myInstance);

PEG_METHOD_EXIT();

handler.complete();

return ;

}

//***************************************************************************

//*****************************************************************************************

// enumerateInstances

// localEnumerateInstances

//***************************************************************************

// EnumerateInstances equivalent to external but returns instances

void InteropProvider::enumerateInstances(

// Used by other operations to build instances for processing

// Note that this delivers instances as a group rather than incrementally.

// This technique should only be used for small groups of instances.

//****************************************************************************************

Array<CIMInstance> InteropProvider::localEnumerateInstances(

const OperationContext & context,

const CIMObjectPath & ref,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList,

const CIMPropertyList& propertyList)

InstanceResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::enumerateInstances()");

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localEnumerateInstances()");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s enumerateInstances. ref= %s, includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

"%s enumerateInstances. referenc= %s , includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

thisProvider,

(const char *) ref.toString().getCString(),

(const char *) _showBool(includeQualifiers).getCString(),

(const char *) _showBool(includeClassOrigin).getCString(),

(const char *) _showPropertyList(propertyList).getCString());

// Verify that ClassName is correct and get value

targetClass classEnum = _verifyValidClassInput(ref.getClassName());

// operation namespace needed internally to get class.

_operationNamespace = ref.getNameSpace();

CDEBUG("Namespace = " << _operationNamespace.getString());

//String userName = _validateUserID(context);

// The following 3 classes deliver a single instance because

Array<CIMInstance> instances;

// that is all there is today.

if (classEnum == CIM_OBJECTMANAGER)

{

CIMInstance instance = _getInstanceCIMObjectManager(includeQualifiers,

CIMInstance instance = _getInstanceCIMObjectManager(

ref,

includeQualifiers,

includeClassOrigin,

propertyList);

//Array<Sint8> tmp;

instances.append(instance);

///XmlWriter::appendInstanceElement(tmp, instance);

//tmp.append('\0');

//Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,

// "Instance - XML content: $0", tmp.getData());

///XmlWriter::printInstanceElement(instance);

handler.deliver(instance);

//handler.complete();

//PEG_METHOD_EXIT();

//return;

}

else if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

{

Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(includeQualifiers,

instances = _buildInstancesPGCIMXMLCommunicationMechanism(

includeClassOrigin, propertyList);

ref);

CDEBUG("Build instances of PGCIMXML. count= " << instances.size());

handler.deliver(instances);

//handler.complete();

//PEG_METHOD_EXIT();

//return;

}

else if (classEnum == CIM_NAMESPACEINMANAGER)

{

//handler.complete();

instances = _buildInstancesNamespaceInManager(ref);

//PEG_METHOD_EXIT();

//return;

}

else if (classEnum == PG_NAMESPACE)

else if (classEnum == CIM_NAMESPACEINMANAGER)

{

Array<CIMInstance> instances = _getInstancesCIMNamespace(includeQualifiers,

instances = _buildInstancesCommMechanismForManager(ref);

includeClassOrigin, propertyList);

}

handler.deliver(instances);

else if (classEnum == PG_NAMESPACE)

//handler.complete();

{

//PEG_METHOD_EXIT();

instances = _getInstancesCIMNamespace(ref);

//return;

}

else

{

PEG_METHOD_EXIT();

throw CIMNotSupportedException

("EnumerateInstance for " + ref.getClassName().getString() + " not supported");

(ref.getClassName().getString() + " not supported by Interop Provider");

}

// Filter and deliver the resulting instances

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

{

_finishInstance(instances[i],

ref,

includeQualifiers,

includeClassOrigin,

propertyList );

// Debug Trace of the Instances generated

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s enumerateInstances return instance number %u\npath: %s\n %s\n",thisProvider, i,

(instances[i].getPath().toString().getCString()),

( ( CIMObject) instances[i]).toString().getCString());

//****/

}

return(instances);

PEG_METHOD_EXIT();

}

//***************************************************************************

// enumerateInstances - External Operation call

// Delivers instances back through response handler.

//***************************************************************************

void InteropProvider::enumerateInstances(

const OperationContext & context,

const CIMObjectPath & ref,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList,

InstanceResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::enumerateInstances()");

handler.processing();

// Call the internal enumerateInstances to generate instances of defined

// class. This expects the instances to be returned complete including

// complete path.

Array<CIMInstance> instances = localEnumerateInstances(

context,

ref,

includeQualifiers,

includeClassOrigin,

propertyList);

handler.deliver(instances);

handler.complete();

PEG_METHOD_EXIT();

Line 1975

Line 2268

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::modifyInstanceManagerInstance");

// the only allowed modification is this one property, statistical data

if (modifiedIns.findProperty(OM_GATHERSTATISTICALDATA) != PEG_NOT_FOUND)

{

// the following is a temporary hack to set the value of the statistics

Line 1983

Line 2278

// and call the internal method to set it each time this object is

// built.

#ifndef PEGASUS_DISABLE_PERFINST

Boolean statisticsFlag = _getPropertyValue(modifiedIns, OM_GATHERSTATISTICALDATA, false);

Boolean statisticsFlag = _getPropertyValue(modifiedIns,

OM_GATHERSTATISTICALDATA, false);

CIMInstance instance;

instance = _getInstanceCIMObjectManager(true, true, CIMPropertyList());

instance = _getInstanceCIMObjectManager(instanceReference,

true, true, CIMPropertyList());

if (statisticsFlag != _getPropertyValue(instance, OM_GATHERSTATISTICALDATA, false))

{

Line 1994

Line 2291

// Modify the object on disk

try

{

_repository->modifyInstance(_operationNamespace,

_repository->modifyInstance(instanceReference.getNameSpace(),

instance );

}

catch(const CIMException&)

Line 2020

Line 2317

}

PEG_METHOD_EXIT();

// ATTN Expand this defintion to be more precise since it allows only mod of

// ATTN Expand this definition to be more precise since it allows only mod of

// one property and that property MUST be in the instance to be modifiable.

throw CIMNotSupportedException

(OM_GATHERSTATISTICALDATA.getString() + " modify operation not supported by Interop Provider");

(OM_GATHERSTATISTICALDATA.getString() +

" modify operation not supported by Interop Provider");

}

//***************************************************************************

// modifyInstance

//***************************************************************************

void InteropProvider::modifyInstance(const OperationContext & context,

const CIMObjectPath & instanceReference,

const CIMInstance& modifiedIns,

Line 2035

Line 2335

const CIMPropertyList& propertyList,

ResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::modifyInstance");

Line 2047

Line 2346

(const char *) _showPropertyList(propertyList).getCString());

// ATTN: KS 31 August 2004. This must test for privileged user.

_operationNamespace = instanceReference.getNameSpace();

CIMName className = instanceReference.getClassName();

targetClass classEnum = _verifyValidClassInput(instanceReference.getClassName());

targetClass classEnum = _verifyValidClassInput(className);

String userName = _validateUserID(context);

// begin processing the request

Line 2072

Line 2371

else if (classEnum == PG_NAMESPACE)

{

#ifdef PEGASUS_OS_OS400

MessageLoaderParms mparms("ControlProviders.InteropProvider.MODIFY_INSTANCE_NOT_ALLOWED",

MessageLoaderParms mparms(

"ControlProviders.InteropProvider.MODIFY_INSTANCE_NOT_ALLOWED",

"Modify instance operation not allowed by Interop Provider for class $0.",

PG_NAMESPACE_CLASSNAME.getString());

throw CIMNotSupportedException(mparms);

Line 2085

Line 2385

}

else

{

PEGASUS_ASSERT(false); // should never get here.

PEG_METHOD_EXIT();

throw CIMNotSupportedException(

className.getString() + " not supported by Interop Provider");

}

handler.complete();

Line 2094

Line 2396

}

//***************************************************************************

// enumerateInstanceNames

//***************************************************************************

void InteropProvider::enumerateInstanceNames(

const OperationContext & context,

const CIMObjectPath & classReference,

Line 2104

Line 2409

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::enumerateInstanceNames()");

// operation namespace needed internally to get class.

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

_operationNamespace = classReference.getNameSpace();

"%s enumerateInstanceNames. classReference= %s",

thisProvider,

(const char *) classReference.toString().getCString());

targetClass classEnum = _verifyValidClassInput(classReference.getClassName());

targetClass classEnum =

_verifyValidClassInput(classReference.getClassName());

String userName = _validateUserID(context);

// begin processing the request

handler.processing();

// Deliver a single instance because there should only be one instance.

Boolean includeQualifiers = true;

if (classEnum == CIM_OBJECTMANAGER)

Boolean includeClassOrigin = true;

{

CIMInstance instance = _getInstanceCIMObjectManager( true, true, CIMPropertyList());

CIMObjectPath ref = _buildInstancePath(_operationNamespace,

CIM_OBJECTMANAGER_CLASSNAME, instance);

handler.deliver(ref);

handler.complete();

PEG_METHOD_EXIT();

return;

}

// Deliver all possible instances of this class

Array<CIMInstance> instances = localEnumerateInstances(

if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

context,

{

classReference,

Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(true,

includeQualifiers,

true, CIMPropertyList());

includeClassOrigin,

CIMPropertyList());

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

{

CIMObjectPath ref = _buildInstancePath(_operationNamespace,

handler.deliver(instances[i].getPath());

PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME, instances[i]);

handler.deliver(ref);

}

handler.complete();

PEG_METHOD_EXIT();

return;

}

if (classEnum == CIM_NAMESPACEINMANAGER)

{

handler.complete();

PEG_METHOD_EXIT();

return;

}

if (classEnum == PG_NAMESPACE)

//**************************************************************

// Association Functions

//**************************************************************

/** _filterInstancesToTargetPaths - Filters one associaton and returns references that represent the result of

filtering on resultclass and role. Any reference that matches the resultclass and role

and not the target is returned

@param assocInstance - The association instance being processed.

@param targetObjectPath - The original target. This is required since this is the one reference

we don't want.

@resultClass - The resultClass we want to filter on

@resultRole - The result role we want to filter on

@return - returns the CIMObjectPaths that represent the other side of the association that pass

the resultClass and resultRole filters.

// TODO convert the CIMOBjectPath back to const.

Array<CIMObjectPath> _filterAssocInstanceToTargetPaths(const CIMObject& assocInstance,

const CIMObjectPath& targetObjectPath,

const CIMName resultClass,

const String resultRole)

{

Array<CIMInstance> instances = _getInstancesCIMNamespace(false,

Array<CIMObjectPath> returnPaths;

false, CIMPropertyList());

// get all reference properties except for target.

CDEBUG("EvalNames. Found instances. Count= " << instances.size());

for (Uint32 i = 0 ; i < assocInstance.getPropertyCount() ; i++)

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

{

CIMObjectPath ref = _buildInstancePath(_operationNamespace,

CIMConstProperty p = assocInstance.getProperty(i);

CIM_NAMESPACE_CLASSNAME, instances[i]);

handler.deliver(ref);

}

handler.complete();

if (p.getType() == CIMTYPE_REFERENCE)

PEG_METHOD_EXIT();

{

return;

CIMValue v = p.getValue();

}

CIMObjectPath path;

v.get(path);

if (classEnum == CIM_COMMMECHANISMFORMANAGERINST)

if (!targetObjectPath.identical(path))

{

Array<CIMInstance> instances = _buildInstancesCommMechanismForManager();

if (resultClass.isNull() || resultClass == path.getClassName())

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

{

CIMObjectPath ref = _buildObjectPath(_operationNamespace,

if (resultRole == String::EMPTY || p.getName().getString() == resultRole)

CIM_COMMMECHANISMFORMANAGER_CLASSNAME, instances[i]);

{

handler.deliver(ref);

returnPaths.append(path);

}

if (classEnum == CIM_NAMESPACEINMANAGERINST)

{

Array<CIMInstance> instances = _buildInstancesNamespaceInManager();

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

{

CIMObjectPath ref = _buildObjectPath(_operationNamespace,

CIM_NAMESPACEINMANAGER_CLASSNAME, instances[i]);

handler.deliver(ref);

}

CDEBUG("_filterAssoc PathsReturned. Count = " << returnPaths.size()

// ATTN: Exception response because of error

<< "\n" << _showPathArray(returnPaths));

PEG_METHOD_EXIT();

return( returnPaths );

}

//**************************************************************

// Association Functions

// Associators Operation Call

//**************************************************************

Line 2214

Line 2515

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::associatorNames()");

//throw CIMNotSupportedException("AssociationProvider::associators");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s associatorNames. objectName= %s , assocClass= %s resultClass= %s role= %s resultRole %includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

thisProvider,

(const char *)objectName.toString().getCString(),

(const char *)associationClass.getString().getCString(),

(const char *)resultClass.getString().getCString(),

(const char *)role.getCString(),

(const char *)resultRole.getCString(),

(const char *)_showBool(includeQualifiers).getCString(),

(const char*) _showBool(includeClassOrigin).getCString(),

(const char *)_showPropertyList(propertyList).getCString());

handler.processing();

// Get references for this object. Note that this

// uses the associationClass as resultClass.

Array<CIMObject> referenceObjects = localReferences(

context,

objectName,

associationClass,

role,

includeQualifiers,

includeClassOrigin,

propertyList);

// Note that Result Class is not always there. We need to account for

// both case where it exists and where it does not exist.

// enumerate all reference instances of the resultClass (i.e. the association)

// create path for resultClass

// for each reference object, get all non-target references

Array<CIMObjectPath> resultPaths;

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

{

// get Other references from each reference object.

Array<CIMObjectPath> tempPath =

_filterAssocInstanceToTargetPaths(

referenceObjects[i],

objectName,

resultClass,

resultRole);

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

{

resultPaths.append(tempPath[i]);

}

// get the instance using getInstance.

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

{

CIMInstance thisInstance = localGetInstance(context, resultPaths[i],

includeQualifiers,

includeClassOrigin, propertyList);

if (!thisInstance.isUninitialized())

{

handler.deliver(thisInstance);

}

handler.processing();

handler.complete();

PEG_METHOD_EXIT();

}

//**************************************************************

// AssociatorNames Operation Function

//**************************************************************

void InteropProvider::associatorNames(

const OperationContext & context,

const CIMObjectPath & objectName,

Line 2229

Line 2593

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::associatorNames()");

//throw CIMNotSupportedException("AssociationProvider::associatorNames");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s associatorNames. objectName= %s , assocClass= %s resultClass= %s role= %s resultRole",

thisProvider,

(const char *)objectName.toString().getCString(),

(const char *)associationClass.getString().getCString(),

(const char *)resultClass.getString().getCString(),

(const char *)role.getCString(),

(const char *)resultRole.getCString());

handler.processing();

// Get references for this object. Note that this

// uses the associationClass as resultClass.

Array<CIMObject> referenceObjects = localReferences(

context,

objectName,

associationClass,

role,

false,

CIMPropertyList());

// Note that Result Class is not always there. We need to account for

// both case where it exists and where it does not exist.

// enumerate all reference instances of the resultClass (i.e. the association)

// create path for resultClass

// for each reference object, get all non-target references

Array<CIMObjectPath> resultPaths;

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

{

// get Other references from each association object.

Array<CIMObjectPath> tempPath =

_filterAssocInstanceToTargetPaths(referenceObjects[i],

objectName, resultClass, resultRole);

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

{

resultPaths.append(tempPath[i]);

}

handler.deliver(resultPaths);

handler.processing();

handler.complete();

PEG_METHOD_EXIT();

}

Array<CIMObject> InteropProvider::localReferences(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & resultClass,

const String & role,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::references()");

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"%s references. objectName= %s , resultClass= %s role= %s includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

thisProvider,

(const char *)objectName.toString().getCString(),

(const char *)resultClass.getString().getCString(),

(const char *)role.getCString(),

(const char *)_showBool(includeQualifiers).getCString(),

(const char*) _showBool(includeClassOrigin).getCString(),

(const char *)_showPropertyList(propertyList).getCString());

Array<CIMInstance> rtnInstances;

// operation namespace needed internally to get class.

String userName = _validateUserID(context);

// determine if valid class result class

CIMName targetAssocClassName = resultClass;

targetAssocClass classEnum = _verifyValidAssocClassInput(targetAssocClassName);

// resultClass should NEVER be NULL in Pegasus.

assert(!resultClass.isNull());

// enumerate all reference instances of the resultClass (i.e. the association)

CIMObjectPath classReference(objectName.getHost(), objectName.getNameSpace(),

resultClass);

Array<CIMInstance> assocInstances =

localEnumerateInstances(context,

classReference,

true, true, CIMPropertyList());

Array<CIMObject> rtnObjects = _filterReferenceInstances(

assocInstances, objectName, resultClass, role);

PEG_METHOD_EXIT();

return(rtnObjects);

}

void InteropProvider::references(

const OperationContext & context,

const CIMObjectPath & objectName,

Line 2243

Line 2704

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::references()");

//throw CIMNotSupportedException("AssociationProvider::references");

}

void _filterAssocInstances(Array<CIMInstance>& instances,

Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

CIMName assocClassName,

"%s references. objectName= %s , resultClass= %s role= %s includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s",

String assocRole,

thisProvider,

CIMName resultClassName = CIMName(),

(const char *)objectName.toString().getCString(),

String resultRole = String::EMPTY)

(const char *)resultClass.getString().getCString(),

{

(const char *)role.getCString(),

return;

(const char *)_showBool(includeQualifiers).getCString(),

}

(const char*) _showBool(includeClassOrigin).getCString(),

(const char *)_showPropertyList(propertyList).getCString());

handler.processing();

Array<CIMObject> rtnObjects =

localReferences(context,

objectName,

resultClass,

role,

includeQualifiers,

includeClassOrigin,

propertyList);

handler.deliver(rtnObjects);

handler.complete();

PEG_METHOD_EXIT();

}

void InteropProvider::referenceNames(

const OperationContext & context,

const CIMObjectPath & objectName,

Line 2267

Line 2741

CDEBUG("::referenceNames(): object= " << objectName.toString() << " result Class= " << resultClass.getString());

// operation namespace needed internally to get class.

_operationNamespace = objectName.getNameSpace();

String userName = _validateUserID(context);

// begin processing the request

handler.processing();

// determine if valid class result class

Array<CIMObject> rtnObjects =

localReferences(context,

CIMName targetAssocClassName = resultClass;

objectName,

resultClass,

CIMName targetClassName = objectName.getClassName();

role,

true,

targetAssocClass classEnum = _verifyValidAssocClassInput(targetAssocClassName);

true,

CIMPropertyList());

Array<CIMInstance> assocInstances;

if (classEnum == CIM_COMMMECHANISMFORMANAGERASSOC)

assocInstances = _buildInstancesCommMechanismForManager();

if (classEnum == CIM_NAMESPACEINMANAGERASSOC)

assocInstances = _buildInstancesNamespaceInManager();

_filterAssocInstances(assocInstances, resultClass, role);

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

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

{

CIMObjectPath ref = _buildObjectPath(_operationNamespace,

CIMObjectPath ref = rtnObjects[i].getPath();

targetAssocClassName, assocInstances[i]);

CDEBUG("referenceNames returns: " << ref.toString());

handler.deliver(ref);

}

Line 2301

Line 2765

handler.complete();

PEG_METHOD_EXIT();

// Convert the instances to referenceNames response

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.36
changed lines
	Added in v.1.46

No CVS admin address has been configured