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.5.2.8 and 1.66.4.1

version 1.5.2.8, 2004/02/21 00:12:56

version 1.66.4.1, 2007/04/04 11:04:46

Line 1

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

//%2006////////////////////////////////////////////////////////////////////////

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

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

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

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec 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 22

Line 28

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

// Author: Karl Schopmeyer (k.schopmeyer@opengroup.org)

// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Karl Schopmeyer - Add Cim_Namespace capabilities.

// Karl Schopmeyer - Temp added objectmanager and communication classes

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

///////////////////////////////////////////////////////////////////////////////

// Interop Provider - This provider services those classes from the

// DMTF Interop schema association with the CIMOM itself

// DMTF Interop schema in an implementation compliant with the SMI-S v1.1

// Server Profile

// This provider services the following classes:

// Please see PG_ServerProfile20.mof in the directory

// CIMObjectManager

// $(PEGASUS_ROOT)/Schemas/Pegasus/InterOp/VER20 for retails regarding the

// CIM_ObjectManagerCommunicationMechanism

// classes supported by this control provider.

// CIM_CIMXMLCommunicationMechanism

// CIM_ProtocolAdapter

// Interop forces all creates to the PEGASUS_NAMESPACENAME_INTEROP

// CIM_Namespace

// namespace. There is a test on each operation that returns

// the Invalid Class CIMDError

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

// This is a control provider and as such uses the Tracer functions

// including:

// for data and function traces. Since we do not expect high volume

// CIM_NamespaceInManager

// use we added a number of traces to help diagnostics.

// ...

// CIM Version: Interop Provider was written for CIM 2.7 adn 2.8.

// Note: all 2.8 functions are controlled by a flag and can be

// disabled.

///////////////////////////////////////////////////////////////////////////////

/* STATUS: In process but running 12 feburary 2004 KS */

/* TODO: 12 Feb 2004

Add the association functions

UUID generation should become a system function since it will be used

by many providers, etc. as part of id generation.

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/PegasusVersion.h>

Line 68

Line 53

#include <iostream>

#include "InteropProvider.h"

#include "Guid.h"

#include "InteropProviderUtils.h"

#include <Pegasus/Common/String.h>

#include "InteropConstants.h"

#include <Pegasus/Common/System.h>

#include <Pegasus/Common/ArrayInternal.h>

#include <Pegasus/Common/CIMName.h>

#include <Pegasus/Common/CIMType.h>

#include <Pegasus/Common/CIMInstance.h>

#include <Pegasus/Common/CIMObjectPath.h>

#include <Pegasus/Common/InternalException.h>

#include <Pegasus/Common/CIMStatusCode.h>

#include <Pegasus/Common/Tracer.h>

#include <Pegasus/Common/OperationContext.h>

#include <Pegasus/Config/ConfigManager.h>

#include <Pegasus/Common/XmlWriter.h>

#include <Pegasus/Config/ConfigManager.h>

#include <sstream>

#include <string>

#include <stdlib.h>

//The following include is needed for UUID Generator

#if defined(PEGASUS_OS_TYPE_WINDOWS)

#include <objbase.h>

#endif

PEGASUS_USING_STD;

#include <Pegasus/Common/StatisticalData.h>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

#define CDEBUG(X)

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

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

//#define CDEBUG(X) Logger::put (Logger::DEBUG_LOG, "Linux_ProcessorProvider", Logger::INFORMATION, "$0", X)

* The following are constants representing property names for the classes

//#define CDEBUG(X) {std::stringstream ss; std::string r;ss << X;ss>>r; PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, r)}

* managed by the Interop Provider. Where multiple classes have properties of

* the same name, there will be a common CIMName object defined, and a macro

* defined that points to the common CIMName object, but whose macro name

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

* reflects the class in which the property is used.

// Constants representing the class names processed

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

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

// Constructor for the InteropProvider control provider

// The following should be moved to somewhere like constants.

static const String PegasusInstanceIDGlobalPrefix = "PEG";

InteropProvider::InteropProvider(CIMRepository * rep) : repository(rep),

hostName(System::getHostName()), providerInitialized(false),

/**

profileIds(Array<String>()), conformingElements(Array<CIMNameArray>()),

The constants representing the class names we process

elementNamespaces(Array<CIMNamespaceArray>())

static const CIMName __NAMESPACE_CLASSNAME = CIMName ("__Namespace");

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

static const CIMName CIM_OBJECTMANAGER_CLASSNAME = CIMName ("CIM_ObjectManager");

static const CIMName CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME =

CIMName ("CIM_ObjectManagerCommunicationMechanism");

//static const CIMName CIM_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME =

// CIMName ("CIM_CIMXMLCommunicationMechanism");

static const CIMName PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME =

CIMName ("PG_CIMXMLCommunicationMechanism");

// Property Names for __Namespace Class

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

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

// Property Names for ObjectManagerCommunicationMechanism Class

static const CIMName OM_COMMUNICATIONMECHANISM =

CIMName ("CommunicationMechanism");

static const CIMName OM_FUNCTIONALPROFILESSUPPORTED =

CIMName ("FunctionalProfilesSupported");

static const CIMName OM_FUNCTIONALPROFILEDESCRIPTIONS =

CIMName ("FunctionalProfileDescriptions");

static const CIMName OM_AUTHENTICATIONMECHANISMSSUPPORTED =

CIMName ("AuthenticationMechanismsSupported");

static const CIMName OM_AUTHENTICATIONMECHANISMDESCRIPTIONS =

CIMName ("AuthenticationMechanismDescriptions");

static const CIMName OM_MULTIPLEOPERATIONSSUPPORTED =

CIMName ("MultipleOperationsSupported");

static const CIMName OM_VERSION =

CIMName ("Version");

// Property Names for CIMXML CommunicationMechanism

static const CIMName CIMVALIDATED =

CIMName ("CIMValidated");

static const String CIMXMLProtocolVersion = "1.0";

// Property names for CIM_Namespace Class

static const CIMName CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME =

CIMName ("SystemCreationClassName");

static const CIMName CIM_NAMESPACE_PROPERTY_SYSTEMNAME =

CIMName ("SystemName");

static const CIMName CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME =

CIMName ("ObjectManagerCreationClassName");

static const CIMName CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME =

CIMName ("ObjectManagerName");

static const CIMName CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME =

CIMName ("CreationClassName");

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

static const CIMName CIM_NAMESPACE_PROPERTY_CLASSINFO =

CIMName ("ClassInfo");

static const CIMName CIM_NAMESPACE_PROPERTY_DESCRIPTIONOFCLASSINFO =

CIMName ("DescriptionOfClassInfo");

// Defines to serve as the ENUM for class selection for instance

// operations.

enum targetClass{

__NAMESPACE = 1,

CIM_NAMESPACE = 2,

CIM_OBJECTMANAGER = 3,

PG_CIMXMLCOMMUNICATIONMECHANISM = 4

};

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

// Provider Utility Functions

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

/** get Host IP address from host name. If the

host name is not provided, uses internal function.

If everything fails, gets the definition normally

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

NOTE: This code should not be in slpprovider. This

should be in the Interop classes but for the moment

it is not.

String _getHostAddress(String hostName)

{

// set default address

String ipAddress("127.0.0.1");

if (hostName == String::EMPTY)

hostName = System::getHostName();

struct hostent * phostent;

struct in_addr inaddr;

if ((phostent = ::gethostbyname((const char *)hostName.getCString())) != NULL)

{

::memcpy( &inaddr, phostent->h_addr,4);

ipAddress = ::inet_ntoa( inaddr );

}

return ipAddress;

}

Array<String> _getFunctionalProfiles(Array<Uint16> profiles)

{

Array<String> profileDescriptions;

profiles.append(2); profileDescriptions.append("Basic Read");

profiles.append(3); profileDescriptions.append("Basic Write");

profiles.append(4); profileDescriptions.append("Schema Manipulation");

profiles.append(5); profileDescriptions.append("Instance Manipulation");

profiles.append(6); profileDescriptions.append("Association Traversal");

profiles.append(8); profileDescriptions.append("Qualifier Declaration");

profiles.append(9); profileDescriptions.append("Indications");

return(profileDescriptions);

}

/* get the prefix that will be part of the cimom identification

This can be either the default PEG or if the environment

variable PEGASUS_TRADEMARK_PREFIX is defined this is used.

NOTE: getting from the environment variable is a hack until

we can come up with a better source.

@return String containing the unique name for the CIMOM ID

String getTrademarkCIMOMIDPrefix()

{

char * trademark;

trademark = getenv("PEGASUS_TRADEMARK_PREFIX");

return((trademark)? trademark : PegasusInstanceIDGlobalPrefix);

}

/** Builds the UUID string for this CIMOM.

**/

String getUUIDString()

{

return(Guid::getGuid());

}

/* Test the keys in the CIM_Namespace for valid values

This includes all of the keys above the name key.

THis is a dummy for now.

ATTN: KS Extend and finish this function.

Boolean _validateProperties(const CIMObjectPath& path)

{

return true;

}

Boolean _validateProperties(const CIMInstance& instance)

{

return true;

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

}

/* validate that the property exists, is string type and

#ifndef PEGASUS_DISABLE_PERFINST

optionally the value itself. Note processes only String

try

properties

@param - Instance to search for property.

@param - Property Name

@value - String value. If not String::EMPTY, compare to

value in the property

@return - ture if passes all tests

Boolean _validateRequiredProperty(const CIMInstance& instance,

const CIMName& propertyName,

const String& value)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_validateRequiredProperty()");

Uint32 pos;

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

return(false);

// Get the property

CIMConstProperty theProperty = instance.getProperty(pos);

const CIMValue theValue = theProperty.getValue ();

String valueField;

theValue.get(valueField);

// Required property must have a non-null value

if ((theValue.getType() != CIMTYPE_STRING) || (theValue.isNull()))

{

PEG_METHOD_EXIT();

initProvider();

return(false);

}

if ((value == String::EMPTY) || (valueField == value))

catch(const Exception & e)

{

PEG_METHOD_EXIT();

// Provider initialization may fail if the repository is not

return(true);

// populated

}

PEG_METHOD_EXIT();

return(false);

}

#endif

Boolean _validateRequiredProperty(const CIMInstance& instance,

const CIMName& propertyName,

const Uint16& value)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_validateRequiredProperty()");

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, "Validate "

+ propertyName.getString());

Uint32 pos;

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

{

PEG_METHOD_EXIT();

return(false);

}

// Get the property

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

// provider. Returns a single instance. Note that it always returns an

CIMConstProperty theProperty = instance.getProperty(pos);

// instance. If none was found, it is uninialitized.

CIMValue theValue = theProperty.getValue ();

// Required property must have a non-null value

if ((theValue.getType() != CIMTYPE_UINT16)

CIMInstance InteropProvider::localGetInstance(

|| (theValue.isNull()) )

const OperationContext & context,

{

const CIMObjectPath & instanceName,

PEG_METHOD_EXIT();

const CIMPropertyList & propertyList)

return(false);

}

PEG_METHOD_EXIT();

return(true);

}

Boolean _validateRequiredProperty(const CIMObjectPath& objectPath,

const CIMName& propertyName,

const String value)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

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

"InteropProvider::_validateRequiedProperty()");

Array<CIMKeyBinding> kbArray = objectPath.getKeyBindings();

// find the correct key binding

PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4,

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

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

{

thisProvider,

if (kbArray[i].getName() == propertyName)

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

{

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

if (value != String::EMPTY)

// Test if we're looking for something outside of our namespace. This will

// happen during associators calls from PG_RegisteredProfile instances

// through the PG_ElementConformsToProfile association

CIMNamespaceName opNamespace = instanceName.getNameSpace();

CIMName opClass = instanceName.getClassName();

if(opNamespace != PEGASUS_NAMESPACENAME_INTEROP &&

opClass != PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE)

{

AutoMutex mut(interopMut);

return cimomHandle.getInstance(context, opNamespace,

instanceName, false, false, false, propertyList);

}

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

// instance name

CIMObjectPath ref;

ref.setHost(instanceName.getHost());

ref.setClassName(opClass);

ref.setNameSpace(opNamespace);

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

propertyList);

// deliver a single instance if found.

CIMInstance retInstance;

bool found = false;

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

{

if (value !=kbArray[i].getValue())

CIMObjectPath currentInstRef = instances[i].getPath();

currentInstRef.setHost(instanceName.getHost());

currentInstRef.setNameSpace(instanceName.getNameSpace());

if(instanceName == currentInstRef)

{

PEG_METHOD_EXIT();

retInstance = instances[i];

return(true);

found = true;

}

break;

}

PEG_METHOD_EXIT();

return(true);

}

/* Query the repository for array of all namespacenames

if(!found)

@return Array<CIMNamespaceName> with all namespaces

@exception Passes all exception that repository may generate.

Array<CIMNamespaceName> InteropProvider::_enumerateNameSpaces()

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

cout << "Coule not find instance: " << instanceName.toString() << endl;

"InteropProvider::_enumerateNameSpaces()");

}

Array<CIMNamespaceName> namespaceNames;

namespaceNames = _repository->enumerateNameSpaces();

PEG_METHOD_EXIT();

return(namespaceNames);

return retInstance;

}

/* get a class defintion. Gets the class defined by

the parameters. Generates exception of class not defined.

@param namespace in which to look for the class.

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

@param name of class to get.

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

@return the CIMClass object

// at a time. This design point may need to be revisited if this provider

@Exceptions any repository exceptions if class not found.

// is used in environments such that returning segmented responses would have

// significant performance advantages. For now, that doesn't seem to be the

CIMClass InteropProvider::_getClass(const CIMNamespaceName& nameSpace,

// case.

const CIMName& className)

Array<CIMInstance> InteropProvider::localEnumerateInstances(

const OperationContext & context,

const CIMObjectPath & ref,

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_getClass");

"InteropProvider::localEnumerateInstances()");

const CIMName & className = ref.getClassName();

PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4,

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

thisProvider,

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

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

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

// Verify that ClassName is correct and get its enum value

PEG_METHOD_EXIT();

TARGET_CLASS classEnum = translateClassInput(className);

return myClass;

}

/* Verify that this is one of the legal classnames and

Array<CIMInstance> instances;

return indicator which.

switch(classEnum)

@param - Classname

@return - Uint32 indicating type

@Exceptions - throws CIMNotSupportedException if invalid class.

targetClass _verifyValidClassInput(const CIMName& className)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

case PG_OBJECTMANAGER:

"InteropProvider::_verifyValidClassInput()");

CDEBUG("Class Name Input = " << className.getString());

if (className.equal(CIM_NAMESPACE_CLASSNAME))

{

PEG_METHOD_EXIT();

instances.append(getObjectManagerInstance());

return CIM_NAMESPACE;

break;

}

case PG_CIMXMLCOMMUNICATIONMECHANISM:

if (className.equal(CIM_OBJECTMANAGER_CLASSNAME))

{

PEG_METHOD_EXIT();

instances = enumCIMXMLCommunicationMechanismInstances();

return CIM_OBJECTMANAGER;

break;

}

case PG_NAMESPACEINMANAGER:

/******

if (className.equal(CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME))

{

PEG_METHOD_EXIT();

instances = enumNamespaceInManagerInstances();

return CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM;

break;

}

if (className.equal(CIM_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME))

case PG_COMMMECHANISMFORMANAGER:

{

PEG_METHOD_EXIT();

instances = enumCommMechanismForManagerInstances();

return CIM_CIMXMLCOMMUNICATIONMECHANISM;

break;

}

*****/

case PG_NAMESPACE:

if (className.equal(PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME))

{

PEG_METHOD_EXIT();

instances = enumNamespaceInstances();

return PG_CIMXMLCOMMUNICATIONMECHANISM;

break;

}

// Last entry, reverse test and returnOK if CIM_Namespace

case PG_REGISTEREDPROFILE:

if (!className.equal(CIM_NAMESPACE_CLASSNAME))

{

CDEBUG("Invalid Class received " << className.getString());

instances = enumRegisteredProfileInstances();

PEG_METHOD_EXIT();

break;

throw CIMNotSupportedException

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

}

case PG_REGISTEREDSUBPROFILE:

PEG_METHOD_EXIT();

return CIM_NAMESPACE;

}

/* validate the authorization of the user name against the namespace.

String _validateUserID(const OperationContext & context)

{

//ATTN-DME-P3-20020522: ADD AUTHORIZATION CHECK TO __NAMESPACE PROVIDER

instances = enumRegisteredSubProfileInstances();

String userName;

break;

try

{

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

userName = container.getUserName();

}

catch (...)

case PG_REFERENCEDPROFILE:

{

userName = String::EMPTY;

instances = enumReferencedProfileInstances();

break;

}

return userName;

case PG_ELEMENTCONFORMSTOPROFILE:

}

/* set the value of a property defined by property name in the instance provided

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

{

Uint32 pos;

instances = enumElementConformsToProfileInstances(context,

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

ref.getNameSpace());

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

break;

}

case PG_SUBPROFILEREQUIRESPROFILE:

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

{

Uint32 pos;

instances = enumSubProfileRequiresProfileInstances();

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

break;

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

}

case PG_SOFTWAREIDENTITY:

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

{

Uint32 pos;

instances = enumSoftwareIdentityInstances();

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

break;

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

}

case PG_ELEMENTSOFTWAREIDENTITY:

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

{

Uint32 pos;

instances = enumElementSoftwareIdentityInstances();

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

break;

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

}

case PG_INSTALLEDSOFTWAREIDENTITY:

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

{

Uint32 pos;

instances = enumInstalledSoftwareIdentityInstances();

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

break;

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

}

/* add the correct values to the common keys defined for all of the classes. This is

case PG_COMPUTERSYSTEM:

systemcreationclassname and systemname

Note that if the properties do not exist, we simply ignore them.

void _fixInstanceCommonKeys(CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

instances.append(getComputerSystemInstance());

"InteropProvider::_fixInstanceCommonKeys()");

break;

String SystemCreationClassName = System::getSystemCreationClassName ();

if (SystemCreationClassName == String::EMPTY)

{

//Attn: Get this globally. For now This in place because global is often Empty

SystemCreationClassName = "CIM_ComputerSystem";

}

_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,SystemCreationClassName);

// Add property SystemName

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

PEG_METHOD_EXIT();

}

case PG_HOSTEDOBJECTMANAGER:

/** Add the keys common to a number of the Interop instances to the provided

instance. This includes SystemCreationClassName and System Name

@param instance of CIMInstance to which these are to be added.

void _buildInstanceCommonKeys(CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

instances.append(getHostedObjectManagerInstance());

"InteropProvider::_buildInstanceCommonKeys()");

break;

String SystemCreationClassName = System::getSystemCreationClassName ();

if (SystemCreationClassName == String::EMPTY)

{

//Attn: Get this globally. For now This in place because global is often Empty

SystemCreationClassName = "CIM_ComputerSystem";

}

// Add property SystemCreationClassName

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

SystemCreationClassName)));

// Add property SystemName

String SystemName = System::getHostName();

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

SystemName)));

PEG_METHOD_EXIT();

}

case PG_HOSTEDACCESSPOINT:

/** builds one instance of the CIM_ObjectManager class filling in the

correct properties

@return CIMInstance of this class with properties complete.

CIMInstance InteropProvider::_buildInstanceSkeleton(const CIMName& className)

{

CIMClass myClass;

instances = enumHostedAccessPointInstances();

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

break;

"InteropProvider::_buildInstanceSkeleton()");

CIMInstance skeleton(className);

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

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

return(skeleton.clone());

}

default:

/* build a single instance of the cimxmlcommunicationmechanism class

using the parameter provided as the name property

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

@return CIMInstance of the class

CIMInstance InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism(

const String& namespaceType,

const String& IPAddress,

const Boolean& includeQualifiers,

const Boolean& includeClassOrigin,

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism()");

CIMInstance instance = _buildInstanceSkeleton(PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME);

_fixInstanceCommonKeys(instance);

//CreationClassName

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

//Name, this CommunicationMechanism.

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

// CommunicationMechanism Property

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

//Functional Profiles Supported Property.

Array<Uint16> profiles;

Array<String> profileDescriptions = _getFunctionalProfiles(profiles);

// Set functional profiles in instance

_setPropertyValue(instance, OM_FUNCTIONALPROFILESSUPPORTED, profiles);

_setPropertyValue(instance, OM_FUNCTIONALPROFILEDESCRIPTIONS, profileDescriptions);

// Multiple OperationsSupported Property

_setPropertyValue(instance, OM_MULTIPLEOPERATIONSSUPPORTED, false);

// AuthenticationMechanismsSupported Property

Array<Uint16> authentications;

Array<String> authenticationDescriptions;

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

_setPropertyValue(instance, OM_AUTHENTICATIONMECHANISMSSUPPORTED, authentications);

_setPropertyValue(instance, OM_AUTHENTICATIONMECHANISMDESCRIPTIONS, authenticationDescriptions);

_setPropertyValue(instance, OM_VERSION, CIMXMLProtocolVersion);

_setPropertyValue(instance, "namespaceType", namespaceType);

_setPropertyValue(instance, "IPAddress", IPAddress);

PEG_METHOD_EXIT();

return(instance);

throw CIMNotSupportedException(className.getString() +

" not supported by Interop Provider enumerate");

}

Array<CIMInstance> InteropProvider::_buildInstancesPGCIMXMLCommunicationMechanism(

// Filter and deliver the resulting instances

const Boolean includeQualifiers,

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

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

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

CDEBUG("building pgcimxmlinstances");

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;

if (enableHttpConnection)

{

CDEBUG("building pgcimxmlinstances 1");

normalizeInstance(instances[i], ref, false,

CIMInstance instance = _buildInstancePGCIMXMLCommunicationMechanism(

false, propertyList);

"http", IPAddress,

includeQualifiers,

includeClassOrigin,

propertyList);

instances.append(instance);

}

if (enableHttpsConnection)

PEG_METHOD_EXIT();

{

return instances;

CDEBUG("building pgcimxmlinstances 2");

CIMInstance instance = _buildInstancePGCIMXMLCommunicationMechanism(

"https", IPAddress,

includeQualifiers,

includeClassOrigin,

propertyList);

instances.append(instance);

}

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

// Class that determines whether or not the origin class in an association

restarts. We will save it in the instance database to achieve this.

// operation is valid for the given association class, and also determines

2. It must be unique. We cannot create duplicate CIMOM names

// the origin and target "roles". These values generally correspond to the

3. It is based on the DMTF description of how unique InstanceIds

// role and resultRole parameter of an associators/associatorNames operation.

are defined (Trademark/etc followed by unique identification.

Use the Global constant PegasusInstanceIDGlobalPrefix as the

bool InteropProvider::validAssocClassForObject(

prefix allowing this to be changed.

const CIMName & assocClass, const CIMName & originClass,

const CIMNamespaceName & opNamespace,

String buildObjectManagerName()

String & originProperty, String & targetProperty)

{

return(getTrademarkCIMOMIDPrefix() + ":" + getUUIDString());

}

/** build an instance of the CIM_ObjectManager class filling out

the required properties

@param includeQualifiers Boolean

@param includeClassOrigin Boolean

@param propertylist CIMPropertyList

@return CIMInstance with a single built instance of the class

@exception repository instances if exception to enumerateInstances

for this class.

CIMInstance InteropProvider::_buildInstanceCIMObjectManager(

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstanceCIMObjectManager()");

"InteropProvider::validAssocClassForObject()");

TARGET_CLASS assocClassEnum = translateClassInput(assocClass);

// If there is already an instance of this class, use it.

TARGET_CLASS originClassEnum;

if (!instanceOfCIMObjectManager.isUninitialized())

// If the association class is PG_ElementConformsToProfile, we'll have to

// do some special processing in case the origin instance for the operation

// is managed by another provider.

if(assocClassEnum == PG_ELEMENTCONFORMSTOPROFILE)

{

PEG_METHOD_EXIT();

// Test if the origin is an element managed by another provider

return(instanceOfCIMObjectManager);

// that has implemented a registered profile.

}

if(opNamespace != PEGASUS_NAMESPACENAME_INTEROP ||

(originClass != PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE &&

// Try to get persistent instance from repository

originClass != PEGASUS_CLASSNAME_PG_OBJECTMANAGER))

Array<CIMInstance> instances;

instances = _repository->enumerateInstances(_operationNamespace,

CIM_OBJECTMANAGER_CLASSNAME, true, false, includeQualifiers,

includeClassOrigin, propertyList);

// ATTN: KS How do we really account for multiple instances of

// this class and determine which one is really us.

if (instances.size() >= 1)

{

instanceOfCIMObjectManager = instances[0];

PEG_METHOD_EXIT();

return(instanceOfCIMObjectManager);

}

// Repository empty. Must build new instance and save it.

// Search the cached conformingElements list for the originClass,

// returning false if it is not found

CIMInstance instance = _buildInstanceSkeleton(CIM_OBJECTMANAGER_CLASSNAME);

bool found = false;

_fixInstanceCommonKeys(instance);

instanceOfCIMObjectManager = instance;

//_buildInstanceCommonKeys(instanceOfCIMObjectManager);

PEGASUS_ASSERT(conformingElements.size() ==

elementNamespaces.size());

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

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

_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

String description;

char * envDescription;

envDescription = getenv("PEGASUS_CIMOM_DESCRIPTION");

if (envDescription)

description = envDescription;

else

description = "Pegasus " + String(PEGASUS_NAME) + "Version " + String(PEGASUS_VERSION);

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

//Property GatherStatisticalData. Note that today we do not

// have a dynamic activation for this value.

#ifdef PEGASUS_HAS_PERFINST

Boolean gatherStatData = true;

#else

Boolean gatherStatData = false;

#endif

_setPropertyValue(instance, OM_GATHERSTATISTICALDATA, Boolean(gatherStatData));

// write the instance to the repository

CIMObjectPath instancepath;

try

{

instancepath = _repository->createInstance(_operationNamespace,

CIMNameArray & elementList = conformingElements[i];

instanceOfCIMObjectManager );

CIMNamespaceArray & namespaceList = elementNamespaces[i];

}

PEGASUS_ASSERT(elementList.size() == namespaceList.size());

catch(CIMException& e)

for(Uint32 j = 0, m = elementList.size(); j < m; ++j)

{

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

CIMName & curElement = elementList[j];

PEG_METHOD_EXIT();

if((curElement == originClass ||

throw e;

curElement.getString().find(PEGASUS_DYNAMIC) == 0) &&

}

opNamespace == namespaceList[j])

catch(Exception& e)

{

PEG_METHOD_EXIT();

found = true;

throw e;

break;

}

PEG_METHOD_EXIT();

return(instanceOfCIMObjectManager);

}

if(found)

/* generate one instance of the CIM_Namespace class with the

break;

properties

@param namespace name to put into the class

@exceptions - exceptions carried forward from create instance

and addProperty.

CIMInstance _buildInstanceCIMNamespace(const CIMNamespaceName & nameSpace)

{

CDEBUG("_buildInstnaceCIMNamespace enter");

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstanceCIMNamespace()");

String ObjectManagerName = "ObjectManagerNameValue";

String ClassInfo = "ClassInfo";

String DescriptionOfClassInfo = "DescriptionOfClassInfo";

CIMInstance instance(CIM_NAMESPACE_CLASSNAME);

_buildInstanceCommonKeys(instance);

CDEBUG("_buildInstnaceCIMNamespace add properties");

//ObjectManagerCreationClassName

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString())));

//ObjectManagerName

// This is the one we have to sort out ATTN: TBD KS P0

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME,

ObjectManagerName)));

//CreationClassName

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

CIM_NAMESPACE_CLASSNAME.getString() )));

//Name

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_NAME,

nameSpace.getString() )));

// ATTN: KS 16 Jan 2004 We are not supplying this property right now because we do

// not know what to put into it.

//ClassInfo

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_CLASSINFO,

ClassInfo)));

//DescriptionofClassInfo

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_DESCRIPTIONOFCLASSINFO,

DescriptionOfClassInfo)));

PEG_METHOD_EXIT();

return(instance);

}

void _validateCIMNamespaceKeys(const CIMObjectPath& objectPath)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_validateCIMNamespaceKeys");

Boolean valid = true;

if(!found)

CIMName propertyName;

return false;

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

System::getSystemCreationClassName ()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME;

valid = false;

}

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME;

valid = false;

}

if (!_validateRequiredProperty(objectPath,

else

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString()))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME;

// Otherwise, just get the enum value representing the origin class

valid = false;

// for this operation

originClassEnum = translateClassInput(originClass);

}

// ATTN: This one still a problem. We have to get the name first

CIMName expectedTargetRole;

if (!_validateRequiredProperty(objectPath,

CIMName expectedOriginRole;

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME,

String::EMPTY))

// Set the target and origin role values. Note that if these values are

// not set following the switch block, that implies that the origin class

// is not valid for the supplied association class.

switch(assocClassEnum)

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME;

case PG_NAMESPACEINMANAGER:

valid = false;

if(originClassEnum == PG_OBJECTMANAGER)

}

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME;

expectedTargetRole = PROPERTY_DEPENDENT;

valid = false;

expectedOriginRole = PROPERTY_ANTECEDENT;

}

else if(originClassEnum == PG_NAMESPACE)

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_NAME,

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_NAME;

expectedTargetRole = PROPERTY_ANTECEDENT;

valid = false;

expectedOriginRole = PROPERTY_DEPENDENT;

}

break;

if (false)

case PG_COMMMECHANISMFORMANAGER:

if(originClassEnum == PG_OBJECTMANAGER)

{

PEG_METHOD_EXIT();

expectedTargetRole = PROPERTY_DEPENDENT;

throw CIMInvalidParameterException(

expectedOriginRole = PROPERTY_ANTECEDENT;

"Invalid key property: " + propertyName.getString());

}

PEG_METHOD_EXIT();

else if(originClassEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

}

void _validateCIMNamespaceKeys(const CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

expectedTargetRole = PROPERTY_ANTECEDENT;

"InteropProvider::_validateCIMNamespaceKeys");

expectedOriginRole = PROPERTY_DEPENDENT;

Boolean valid = true;

CIMName propertyName;

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

System::getSystemCreationClassName ()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME;

valid = false;

}

break;

if (!_validateRequiredProperty(instance,

case PG_ELEMENTCONFORMSTOPROFILE:

CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

if(originClass.equal(PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE))

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME;

expectedTargetRole =

valid = false;

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

expectedOriginRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

}

else

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString()))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME;

expectedTargetRole =

valid = false;

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

expectedOriginRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

}

break;

// ATTN: This one still a problem. We have to get the name first

case PG_SUBPROFILEREQUIRESPROFILE:

if (!_validateRequiredProperty(instance,

if(originClassEnum == PG_REGISTEREDPROFILE)

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME,

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME;

expectedTargetRole = PROPERTY_DEPENDENT;

valid = false;

expectedOriginRole = PROPERTY_ANTECEDENT;

}

if (!_validateRequiredProperty(instance,

else if(originClassEnum == PG_REGISTEREDSUBPROFILE)

CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME;

expectedTargetRole = PROPERTY_ANTECEDENT;

valid = false;

expectedOriginRole = PROPERTY_DEPENDENT;

}

break;

if (!_validateRequiredProperty(instance,

case PG_ELEMENTSOFTWAREIDENTITY:

CIM_NAMESPACE_PROPERTY_NAME,

if(originClassEnum == PG_SOFTWAREIDENTITY)

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_NAME;

expectedTargetRole = PROPERTY_DEPENDENT;

valid = false;

expectedOriginRole = PROPERTY_ANTECEDENT;

}

else if(originClassEnum == PG_REGISTEREDPROFILE ||

if (false)

originClassEnum == PG_REGISTEREDSUBPROFILE)

{

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

expectedTargetRole = PROPERTY_ANTECEDENT;

"Invalid CIM_Namespace Key Property " + propertyName.getString());

expectedOriginRole = PROPERTY_DEPENDENT;

PEG_METHOD_EXIT();

throw CIMInvalidParameterException(

"Invalid CIM_Namespace key property: " + propertyName.getString());

}

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, "CIM_Namespace Keys Valid");

PEG_METHOD_EXIT();

}

break;

/* Given a namespace name, class and instance build the instance path for a

case PG_INSTALLEDSOFTWAREIDENTITY:

the object. This builds all components of the path

if(originClassEnum == PG_SOFTWAREIDENTITY)

@param namespace name to build

@return CIMObjectPath containing namespace, class and keybinding

components of path

@exceptions - Passes repository exceptions.

// ATTN: KS Build path from instance and instance from class. Not sure

// we want to always do this. Consider change to build keys directly

CIMObjectPath InteropProvider::_buildInstancePath(const CIMNamespaceName& name,

const CIMName className,

const CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

expectedTargetRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM;

"InteropProvider::_buildInstancePath");

expectedOriginRole =

INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE;

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

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

CIMClass thisClass = _getClass(_operationNamespace, className);

// XmlWriter::printInstanceElement(instance);

CIMObjectPath ref = instance.buildPath(thisClass);

PEG_METHOD_EXIT();

return(ref);

}

else if(originClassEnum == PG_COMPUTERSYSTEM)

/* _isNamespace determines if the namespace in the second

parameter is in the array in the first parameter.

@param array of possible namespaces

@param canidate namespace

@return - true if found

Boolean _isNamespace(

Array<CIMNamespaceName>& namespaceNames,

CIMNamespaceName& namespaceName)

{

Boolean found = false;

expectedTargetRole =

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

INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE;

{

expectedOriginRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM;

if(namespaceNames[i].equal ( namespaceName ))

return true;

}

return false;

}

break;

Boolean _isChild(

case PG_HOSTEDACCESSPOINT:

CIMNamespaceName& parentNamespaceName,

if(originClassEnum == PG_COMPUTERSYSTEM)

CIMNamespaceName& namespaceName)

{

String parent = parentNamespaceName.getString();

expectedTargetRole = PROPERTY_DEPENDENT;

String child = namespaceName.getString();

expectedOriginRole = PROPERTY_ANTECEDENT;

// If length of namespace name is shorter than or equal to the

// length of parent namespace name, cannot be a child

if (child.size () <= parent.size ())

return false;

// Compare prefix substring of namespace name with parent namespace name

else if (String::equalNoCase (child.subString (0, parent.size ()), parent))

return true;

return false;

}

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

else if(originClassEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

// Overloaded functions to get key value with different params

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

/* find the name key in the keybindings and return the value.

Executes exception if the key not found

@param object path we will search

@param keyName - Name of the key to find.

@return value of name property

@exceptions CIMInvalidParameterException

String _getKeyValue(const CIMObjectPath& instanceName, const CIMName& keyName)

{

Array<CIMKeyBinding> kbArray = instanceName.getKeyBindings();

expectedTargetRole = PROPERTY_ANTECEDENT;

expectedOriginRole = PROPERTY_DEPENDENT;

// find the correct key binding

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

{

if (kbArray[i].getName() == keyName)

return (kbArray[i].getValue());

}

throw CIMInvalidParameterException("Invalid key property: " + keyName.getString());

}

case PG_HOSTEDOBJECTMANAGER:

String _getKeyValue(const CIMInstance& instance, const CIMName& keyName)

if(originClassEnum == PG_COMPUTERSYSTEM)

{

Uint32 pos;

expectedTargetRole = PROPERTY_DEPENDENT;

CIMValue propertyValue;

expectedOriginRole = PROPERTY_ANTECEDENT;

pos = instance.findProperty(keyName);

if (pos == PEG_NOT_FOUND)

throw CIMPropertyNotFoundException

(NAMESPACE_PROPERTYNAME.getString());

propertyValue = instance.getProperty(pos).getValue();

if (propertyValue.getType() != CIMTYPE_STRING)

throw CIMInvalidParameterException("Invalid type for property: "

+ NAMESPACE_PROPERTYNAME.getString());

String name;

propertyValue.get(name);

return(name);

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

}

else if(originClassEnum == PG_OBJECTMANAGER)

/* gets the key value for the __Namespace property "name"

from the instance provided. Sets childNamespaceName and

isRelativeName fields

This overload called if instance provided.

void _getKeyValue (

const CIMInstance& namespaceInstance,

CIMNamespaceName& childNamespaceName,

Boolean& isRelativeName)

{

//Validate key property

expectedTargetRole = PROPERTY_ANTECEDENT;

expectedOriginRole = PROPERTY_DEPENDENT;

Uint32 pos;

CIMValue propertyValue;

pos = namespaceInstance.findProperty(NAMESPACE_PROPERTYNAME);

if (pos == PEG_NOT_FOUND)

{

throw CIMPropertyNotFoundException

(NAMESPACE_PROPERTYNAME.getString());

}

break;

propertyValue = namespaceInstance.getProperty(pos).getValue();

default:

if (propertyValue.getType() != CIMTYPE_STRING)

break;

throw CIMInvalidParameterException("Invalid type for property: "

+ NAMESPACE_PROPERTYNAME.getString());

String cnsName;

propertyValue.get(cnsName);

childNamespaceName = CIMNamespaceName (cnsName);

isRelativeName = !(childNamespaceName.isNull());

}

/* gets the key value for the __Namespace property "name"

from the instance provided. Sets childNamespaceName and

isRelativeName fields

This overload called if object path provided.

void _getKeyValue (

const CIMObjectPath& instanceName,

CIMNamespaceName& childNamespaceName,

Boolean& isRelativeName)

{

Array<CIMKeyBinding> kbArray = instanceName.getKeyBindings();

if ((kbArray.size() == 1) &&

(kbArray[0].getName() == NAMESPACE_PROPERTYNAME))

// The rest of this method checks to see if target role and origin roles

// were found for the association and origin class combination and, if

// found, checks against the input target and origin roles if provided.

// Failure for any of these tests points to an invalid association

// traversal request.

if(expectedTargetRole.isNull() ||

expectedOriginRole.isNull())

{

childNamespaceName = CIMNamespaceName (kbArray[0].getValue());

PEG_METHOD_EXIT();

isRelativeName = !(childNamespaceName.isNull());

return false;

}

else

throw CIMInvalidParameterException("Invalid key property: ");

}

/* generate the full namespace name from the parent and child

if(targetProperty.size() == 0)

components

@param namespaceNames - List of all namespaces

@param parentNamespaceName

@param childNamespaceName

@param Boolean isrelative

@return full namespacename created from parent + child

Note that if isrelative is true, parent is tested for validty

CIMNamespaceName _generateFullNamespaceName(

Array<CIMNamespaceName>& namespaceNames,

CIMNamespaceName& parentNamespaceName,

CIMNamespaceName& childNamespaceName,

Boolean isRelativeName)

{

// If isRelativeName is true, then the parentNamespace

targetProperty = expectedTargetRole.getString();

// MUST exist

CIMNamespaceName fullNamespaceName;

if (isRelativeName)

{

if (!_isNamespace(namespaceNames, parentNamespaceName))

{

throw CIMObjectNotFoundException("Parent namespace does not exist: "

+ parentNamespaceName.getString());

}

// Create full namespace name by prepending parentNamespaceName

fullNamespaceName = CIMNamespaceName (parentNamespaceName.getString()

+ "/" + childNamespaceName.getString());

}

else

else if(!expectedTargetRole.equal(targetProperty))

{

fullNamespaceName = parentNamespaceName;

PEG_METHOD_EXIT();

}

return false;

return(fullNamespaceName);

}

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

if(originProperty.size() == 0)

// The following section is the Instance Operation processors

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

// createInstance

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

void InteropProvider::createInstance(

const OperationContext & context,

const CIMObjectPath & instanceReference,

const CIMInstance& myInstance,

ObjectPathResponseHandler & handler)

{

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

CIMNamespaceName childNamespaceName;

CIMNamespaceName newNamespaceName;

Boolean isRelativeName;

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

// operation namespace needed internally to get class.

_operationNamespace = instanceReference.getNameSpace();

// Verify that ClassName is correct and get value

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

CDEBUG("Class Validated");

String userName = _validateUserID(context);

CIMObjectPath newInstanceReference;

CDEBUG("UserIDValidated");

if ((classEnum == CIM_OBJECTMANAGER) ||

(classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM))

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

CDEBUG("CreateInstance: No test for CIM_NamepsaceClass");

if (classEnum == CIM_NAMESPACE)

{

CDEBUG("Create Class from CIM_Namespace");

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

_validateCIMNamespaceKeys(myInstance);

CDEBUG("_validateCIMNamespaceKeys passed");

String namespaceName;

newNamespaceName = _getKeyValue(myInstance, CIM_NAMESPACE_PROPERTY_NAME);

CDEBUG("CreateInstance: rtn form _getKeyValue ");

CIMInstance instance = _buildInstanceCIMNamespace(namespaceName);

CDEBUG("CreateInstance:Rtn from _BuildInstanceCIMNamespace for namespace= " << namespaceName);

newInstanceReference = _buildInstancePath(CIMNamespaceName(namespaceName),

CIM_NAMESPACE_CLASSNAME, instance);

CDEBUG("CreateInstance:Go to common create functions");

}

else // Process the __Namespace request to get namespace name value

{

CDEBUG("CreateInstance: Fell through to __Namespace processing");

_getKeyValue(myInstance, childNamespaceName, isRelativeName);

CIMNamespaceName parentNamespaceName = instanceReference.getNameSpace();

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"childNamespaceName = " + childNamespaceName.getString() +

", isRelativeName = " +

(isRelativeName?String("true"):String("false")) +

", parentNamespaceName = " + parentNamespaceName.getString());

CDEBUG("__Namespace Process. parent= " << parentNamespaceName.getString() );

Array<CIMNamespaceName> namespaceNames;

namespaceNames = _enumerateNameSpaces();

newNamespaceName = _generateFullNamespaceName(

namespaceNames, parentNamespaceName,

childNamespaceName, isRelativeName);

// return key (i.e., CIMObjectPath) for newly created namespace

Array<CIMKeyBinding> keyBindings;

keyBindings.append(CIMKeyBinding(NAMESPACE_PROPERTYNAME,

isRelativeName?childNamespaceName.getString():

parentNamespaceName.getString(),

CIMKeyBinding::STRING));

//Add namespace class and keybindings

newInstanceReference.set(String::EMPTY, parentNamespaceName,

__NAMESPACE_CLASSNAME, keyBindings);

}

// Create the new namespace

try

{

CDEBUG("Create namespace " << newNamespaceName.getString());

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + newNamespaceName.getString() +

" to be created.");

_repository->createNameSpace(newNamespaceName);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + newNamespaceName.getString() +

" successfully created.");

// ATTN: Add standardlog entry here.

}

catch(CIMException& e)

{

PEG_METHOD_EXIT();

originProperty = expectedOriginRole.getString();

throw e;

}

catch(Exception& e)

else if(!expectedOriginRole.equal(originProperty))

{

PEG_METHOD_EXIT();

throw e;

return false;

}

// begin processing the request

handler.processing();

handler.deliver(newInstanceReference);

// complete processing the request

handler.complete();

PEG_METHOD_EXIT();

return;

return true;

}

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

// deleteInstance

// Local version of the references operation. It validates the input

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

// parameters, setting the origin and target property values if not set

void InteropProvider::deleteInstance(

// already, and then performs an enumeration on the association class. It then

// filters the results of that enumeration to see if one of the reference

// properties matches the objectName parameter passed into the method. If so,

// then it is added to the array of association instances to be returned.

Array<CIMInstance> InteropProvider::localReferences(

const OperationContext & context,

const CIMObjectPath & instanceName,

const CIMObjectPath & objectName,

ResponseHandler & handler)

const CIMName & assocClass,

String & originProperty,

String & targetProperty,

const CIMPropertyList & propertyList,

const CIMName & targetClass)

{

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

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::localReferences()");

CIMNamespaceName childNamespaceName;

CIMNamespaceName deleteNamespaceName;

Boolean isRelativeName;

_operationNamespace = instanceName.getNameSpace();

handler.processing();

// Verify that ClassName is correct and get value

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

String userName = _validateUserID(context);

if ((classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM))

Array<CIMInstance> instances;

throw CIMNotSupportedException("Delete Not allowed");

CIMName originClass = objectName.getClassName();

// Delete the instance since it may be in persistent storage

Array<CIMName> targetSubclasses;

if ((classEnum == CIM_OBJECTMANAGER))

CIMNamespaceName lastTargetNamespace;

CIMNamespaceName originNamespace(objectName.getNameSpace());

// Check that the association traversal request is valid

if(validAssocClassForObject(assocClass, objectName.getClassName(),

originNamespace, originProperty, targetProperty))

{

// retrieve all of the association class instances

Array<CIMInstance> localInstances = localEnumerateInstances(context,

CIMObjectPath(hostName, originNamespace,

assocClass));

// Filter the association class instances based on the origin instance

// and other input parameters.

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

{

CIMInstance & currentInstance = localInstances[i];

CIMObjectPath originPath = getRequiredValue<CIMObjectPath>(

currentInstance, originProperty);

originPath.setNameSpace(objectName.getNameSpace());

originPath.setHost(objectName.getHost());

// Only include instances where the origin instance is present in

// the association.

if(originPath.identical(objectName))

{

if(!targetClass.isNull())

{

// Have to check if the target reference is of the

// targetClass type. We first must determine all the

// possible subclasses of the targetClass in the target

// namespace.

CIMObjectPath targetPath = getRequiredValue<CIMObjectPath>(

currentInstance, targetProperty);

CIMNamespaceName targetNamespace(

targetPath.getNameSpace());

if(targetNamespace.isNull())

{

targetNamespace = originNamespace;

targetPath.setNameSpace(targetNamespace);

}

if(targetNamespace != lastTargetNamespace)

{

CIMInstance instance;

try

{

instance = _repository->getInstance(_operationNamespace, instanceName);

targetSubclasses = repository->enumerateClassNames(

targetNamespace, targetClass, true);

// If instance found, then delete it.

_repository->deleteInstance(_operationNamespace,instanceName);

PEG_METHOD_EXIT();

handler.complete();

return;

}

catch(CIMException& e)

catch(...)

{

PEG_METHOD_EXIT();

// If an exception was thrown during enumeration,

throw e;

// then the base class didn't exist in the

// namespace, so the target instance retrieved

// must not match the targetClass parameter.

continue;

}

targetSubclasses.append(targetClass);

lastTargetNamespace = targetNamespace;

}

Array<CIMNamespaceName> namespaceNames;

// Try to find the targetPath's class in the search space

namespaceNames = _enumerateNameSpaces();

CIMName targetPathClass = targetPath.getClassName();

if (classEnum == CIM_NAMESPACE)

for(Uint32 j = 0, m = targetSubclasses.size(); j < m; ++j)

{

// validate requred keys. Exception out if not valid

if(targetPathClass == targetSubclasses[j])

_validateCIMNamespaceKeys(instanceName);

deleteNamespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME);

CDEBUG("Delete namespace = " << deleteNamespaceName );

}

else // Procesing for __namespace

{

instances.append(currentInstance);

CIMNamespaceName childNamespaceName;

break;

CIMNamespaceName deleteNamespaceName;

Boolean isRelativeName;

_getKeyValue(instanceName, childNamespaceName, isRelativeName);

CIMNamespaceName parentNamespaceName = instanceName.getNameSpace();

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"childNamespaceName = " + childNamespaceName.getString() +

(isRelativeName?String("true"):String("false")) +

", parentNamespaceName = " + parentNamespaceName.getString());

// begin processing the request

deleteNamespaceName = _generateFullNamespaceName(

namespaceNames, parentNamespaceName,

childNamespaceName, isRelativeName);

}

// ATTN: KS Why THis???

if (deleteNamespaceName.equal (ROOTNS))

{

throw CIMNotSupportedException("root namespace cannot be deleted.");

}

_repository->deleteNameSpace(deleteNamespaceName);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + deleteNamespaceName.getString() +

" successfully deleted.");

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

"Interop Provider Delete Namespace: $0",

deleteNamespaceName.getString());

handler.processing();

// complete processing the request

handler.complete();

PEG_METHOD_EXIT();

return ;

}

else

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

// getInstance

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

void InteropProvider::getInstance(

const OperationContext & context,

const CIMObjectPath & instanceName,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

InstanceResponseHandler & handler)

{

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

// Verify that ClassName is correct and get value

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

String userName = _validateUserID(context);

// begin processing the request

handler.processing();

if (classEnum == CIM_OBJECTMANAGER)

{

CIMInstance instance = _buildInstanceCIMObjectManager(includeQualifiers,

instances.append(currentInstance);

includeClassOrigin, propertyList);

handler.deliver(instance);

handler.complete();

PEG_METHOD_EXIT();

return;

}

if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

{

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

Array <CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(

includeQualifiers,

includeClassOrigin, propertyList);

handler.deliver(instances[0]);

handler.complete();

PEG_METHOD_EXIT();

return;

}

// Get List of namespaces

Array<CIMNamespaceName> namespaceNames;

namespaceNames = _enumerateNameSpaces();

CIMInstance instance;

if (classEnum == CIM_NAMESPACE)

{

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

// 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 (!_isNamespace(namespaceNames, namespaceName))

{

throw CIMObjectNotFoundException("Namespace does not exist: "

+ namespaceName.getString());

}

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

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

instance = _buildInstanceCIMNamespace(namespaceName);

}

else // processing for __Namespace

{

CIMNamespaceName childNamespaceName;

CIMNamespaceName getNamespaceName;

Boolean isRelativeName;

_getKeyValue(instanceName, childNamespaceName, isRelativeName);

CIMNamespaceName parentNamespaceName = instanceName.getNameSpace();

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"childNamespaceName = " + childNamespaceName.getString() +

(isRelativeName?String("true"):String("false")) +

", parentNamespaceName = " + parentNamespaceName.getString());

PEG_METHOD_EXIT();

getNamespaceName = _generateFullNamespaceName(

return instances;

namespaceNames, parentNamespaceName,

childNamespaceName, isRelativeName);

// exception if not valid namespace

if (!_isNamespace(namespaceNames, getNamespaceName))

{

throw CIMObjectNotFoundException("Namespace deos not exist: "

+ getNamespaceName.getString());

}

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + getNamespaceName.getString() +

" successfully found.");

//Set name of class

CIMInstance instance(__NAMESPACE_CLASSNAME);

// construct the instance

// Builds an instance of the class named className. Gets Class defintion and

// fills in the correct properties from the class. This requires a repository

// getClass request for each instance built. The skeleton is built by

// creating the instance and copying qualifiers and properties from

// the class. Finally the instance is cloned to separate it from the

// original objects.

// NOTE: This is very inefficient for anything larger than a few instances.

// We should separate the get from the createSkeleton.

// @param className CIMName of the class for which the instance is to be built

// @return CIMInstance of this class with properties complete.

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

instance.addProperty(CIMProperty(NAMESPACE_PROPERTYNAME,

CIMInstance InteropProvider::buildInstanceSkeleton(

isRelativeName?childNamespaceName.getString():

const CIMNamespaceName & nameSpace,

parentNamespaceName.getString()));

const CIMName& className,

//instance.setPath(instanceName);

CIMClass& returnedClass)

}

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

handler.deliver(instance);

"InteropProvider::_buildInstanceSkeleton()");

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

// complete processing the request

returnedClass = repository->getClass(nameSpace,

handler.complete();

className, false, true, true);

CIMInstance skeleton = returnedClass.buildInstance(true,true,

CIMPropertyList());

PEG_METHOD_EXIT();

return ;

return skeleton;

}

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

// enumerateInstances

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

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

// Verify that ClassName is correct and get value

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

CIMInstance InteropProvider::buildDependencyInstance(

const String & antecedentId,

const CIMName & antecedentClass,

const String & dependentId,

const CIMName & dependentClass,

const CIMClass & dependencyClass)

{

Array<CIMKeyBinding> dependentKeys;

// operation namespace needed internally to get class.

dependentKeys.append(CIMKeyBinding(

_operationNamespace = ref.getNameSpace();

COMMON_PROPERTY_INSTANCEID,

//String userName = _validateUserID(context);

dependentId,CIMKeyBinding::STRING));

// The following 3 classes deliver a single instance because

return buildDependencyInstanceFromPaths(

// that is all there is today.

buildDependencyReference(hostName, antecedentId, antecedentClass),

if (classEnum == CIM_OBJECTMANAGER)

buildDependencyReference(hostName, dependentId, dependentClass),

{

dependencyClass);

CIMInstance instance = _buildInstanceCIMObjectManager(includeQualifiers,

includeClassOrigin,

propertyList);

handler.deliver(instance);

handler.complete();

PEG_METHOD_EXIT();

return;

}

if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

void InteropProvider::initProvider()

{

Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(includeQualifiers,

if(providerInitialized)

includeClassOrigin, propertyList);

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

handler.deliver(instances);

handler.complete();

PEG_METHOD_EXIT();

return;

}

// Placed METHOD_ENTER trace statement after checking whether the

// provider is initialized because this method will be called for every

// ATTN: Fix this up. should not be here.

// operation through the InteropProvider, and this method is only

CIMNamespaceName parentNamespaceName = ref.getNameSpace();

// interesting the first time it is successfully run.

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

// ATTN KS Fix this so references both types of namespace

"InteropProvider::initProvider()");

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"parentNamespaceName = " + parentNamespaceName.getString());

// begin processing the request

handler.processing();

Array<CIMNamespaceName> namespaceNames = _enumerateNameSpaces();

AutoMutex lock(interopMut);

if(!providerInitialized)

{

// Initialize the object manager instance for the CIM Server, and

// retrieve the object manager's name property. This is retrieved once

// and stored for use in constructing other instances requiring its

// value.

CIMInstance objectManager = getObjectManagerInstance();

objectManager.getProperty(objectManager.findProperty(

OM_PROPERTY_NAME)).getValue().get(objectManagerName);

Array<CIMInstance> instanceArray;

CDEBUG("Found " << namespaceNames.size() << " namespaces.");

// Determine whether the CIMOM should be gathering statistical data

// Build response objects based on class requested

// based on the GatherStatisticalData property in the object manager.

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

Uint32 gatherDataIndex = objectManager.findProperty(

OM_PROPERTY_GATHERSTATISTICALDATA);

if(gatherDataIndex != PEG_NOT_FOUND)

{

if (classEnum == CIM_NAMESPACE)

CIMConstProperty gatherDataProp =

objectManager.getProperty(gatherDataIndex);

if (gatherDataProp.getType() == CIMTYPE_BOOLEAN)

{

CDEBUG("Evaluate CIM_Namespace" << classEnum);

CIMValue gatherDataVal = gatherDataProp.getValue();

// Create a valid CIM_Namespace Instance

if (!gatherDataVal.isNull())

CIMInstance instance = _buildInstanceCIMNamespace(namespaceNames[i]);

instanceArray.append(instance);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + namespaceNames[i].getString());

}

else // the else covers __NAMESPACE

{

// Build the instances. For now simply build the __Namespace instances

Boolean gatherData;

// the only property is name.

gatherDataVal.get(gatherData);

if (_isChild(parentNamespaceName, namespaceNames[i]))

if (gatherData == true)

{

CIMInstance instance(__NAMESPACE_CLASSNAME);

StatisticalData* sd = StatisticalData::current();

instance.addProperty(

sd->setCopyGSD(true);

(CIMProperty(NAMESPACE_PROPERTYNAME,

namespaceNames[i].getString().subString

(parentNamespaceName.getString().size()+1,

namespaceNames[i].getString().size()-

parentNamespaceName.getString().size()-1))));

instanceArray.append(instance);

//instance.setPath(instanceName);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"childNamespace = " + namespaceNames[i].getString());

}

handler.deliver(instanceArray);

// complete processing the request

handler.complete();

PEG_METHOD_EXIT();

}

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

// Cache this class definition for use later.

// enumerateInstanceNames

profileCapabilitiesClass = repository->getClass(

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

PEGASUS_NAMESPACENAME_INTEROP,

PEGASUS_CLASSNAME_PG_PROVIDERPROFILECAPABILITIES,

void InteropProvider::enumerateInstanceNames(

false, true, false);

const OperationContext & context,

const CIMObjectPath & classReference,

ObjectPathResponseHandler & handler)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::enumerateInstanceNames()");

// operation namespace needed internally to get class.

_operationNamespace = classReference.getNameSpace();

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

providerClassifications.append(Uint16(5)); // "Instrumentation"

String userName = _validateUserID(context);

// begin processing the request

// Initialize the namespaces so that all namespaces with the

handler.processing();

// CIM_ElementConformsToProfile class also have the

// PG_ElementConformsToProfile class. Needed in order to implement

// The following 3 classes deliver a single instance because

// the cross-namespace ElementConformsToProfile association in both

// that is all there is today.

// directions.

if (classEnum == CIM_OBJECTMANAGER)

{

Array<CIMNamespaceName> namespaceNames =

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

repository->enumerateNameSpaces();

CIMObjectPath ref = _buildInstancePath(CIMNamespaceName(),

CIMClass conformsClass = repository->getClass(

CIM_OBJECTMANAGER_CLASSNAME, instance);

PEGASUS_NAMESPACENAME_INTEROP,

handler.deliver(ref);

PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE);

handler.complete();

CIMClass profileClass = repository->getClass(

PEG_METHOD_EXIT();

PEGASUS_NAMESPACENAME_INTEROP,

return;

PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);

}

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

if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

{

Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(true,

// Check if the PG_ElementConformsToProfile class is present

true, CIMPropertyList());

CIMNamespaceName & currentNamespace = namespaceNames[i];

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

CIMClass tmpCimClass;

CIMClass tmpPgClass;

CIMClass tmpPgProfileClass;

try

{

CIMObjectPath ref = _buildInstancePath(CIMNamespaceName(),

// Look for these classes in the same try-block since the

PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME, instances[i]);

// second depends on the first

handler.deliver(ref);

tmpCimClass = repository->getClass(currentNamespace,

PEGASUS_CLASSNAME_CIM_ELEMENTCONFORMSTOPROFILE);

tmpPgClass = repository->getClass(currentNamespace,

PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE);

}

handler.complete();

catch(const Exception &)

PEG_METHOD_EXIT();

{

return;

}

try

// ATTN: Move this trace

CIMNamespaceName parentNamespaceName = classReference.getNameSpace();

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"parentNamespaceName = " + parentNamespaceName.getString());

CDEBUG("Enumerate Instance Names. ns = " << parentNamespaceName.getString());

// Get list of all namespaces

Array<CIMNamespaceName> namespaceNames = _enumerateNameSpaces();

// Build the cimObjectPath for each namespace found

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

{

if (classEnum == CIM_NAMESPACE)

tmpPgProfileClass = repository->getClass(currentNamespace,

PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);

}

catch(const Exception &)

{

// Note: if any of the above three classes aren't found,

CDEBUG("Calling BuildInstancePath for "<< namespaceNames[i].getString() );

// an exception will be thrown, which we can ignore since it's

CIMInstance instance = _buildInstanceCIMNamespace(namespaceNames[i]);

// an expected case

CIMObjectPath ref = _buildInstancePath(CIMNamespaceName(namespaceNames[i]),

// TBD: Log trace message?

CIM_NAMESPACE_CLASSNAME, instance);

handler.deliver(ref);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"namespace = " + namespaceNames[i].getString());

}

else

// If the CIM_ElementConformsToProfile class is present, but

// the PG_ElementConformsToProfile or PG_RegisteredProfile

// class is not, then add it to that namespace.

// Note that we don't have to check for the

// CIM_RegisteredProfile class because if the

// CIM_ElementConformsToProfile class is present, the

// CIM_RegisteredProfile class must also be present.

if(!tmpCimClass.isUninitialized())

{

Array<CIMKeyBinding> keyBindings;

if(tmpPgClass.isUninitialized())

// Build the __Namespace objectpath

// Note that for the moment, the only property is name.

if (_isChild(parentNamespaceName, namespaceNames[i]))

{

keyBindings.clear();

CIMObjectPath newPath = conformsClass.getPath();

keyBindings.append(CIMKeyBinding(NAMESPACE_PROPERTYNAME,

newPath.setNameSpace(currentNamespace);

namespaceNames[i].getString().subString

conformsClass.setPath(newPath);

(parentNamespaceName.getString().size()+1,

repository->createClass(currentNamespace,

namespaceNames[i].getString().size()-

conformsClass);

parentNamespaceName.getString().size()-1),

CIMKeyBinding::STRING));

CIMObjectPath ref(String::EMPTY, parentNamespaceName,

__NAMESPACE_CLASSNAME, keyBindings);

handler.deliver(ref);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"childNamespace = " + namespaceNames[i].getString());

}

if(tmpPgProfileClass.isUninitialized())

{

CIMObjectPath newPath = conformsClass.getPath();

newPath.setNameSpace(currentNamespace);

conformsClass.setPath(newPath);

repository->createClass(currentNamespace,

profileClass);

}

handler.complete();

PEG_METHOD_EXIT();

}

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

// Association Functions

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

void InteropProvider::associators(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & associationClass,

const CIMName & resultClass,

const String & role,

const String & resultRole,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

ObjectResponseHandler & handler)

{

throw CIMNotSupportedException("AssociationProvider::associators");

}

void InteropProvider::associatorNames(

// Now cache the Registration info used for ElementConformsToProfile

const OperationContext & context,

cacheProfileRegistrationInfo();

const CIMObjectPath & objectName,

const CIMName & associationClass,

const CIMName & resultClass,

const String & role,

const String & resultRole,

ObjectPathResponseHandler & handler)

{

throw CIMNotSupportedException("AssociationProvider::associatorNames");

}

void InteropProvider::references(

providerInitialized = true;

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & resultClass,

const String & role,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & propertyList,

ObjectResponseHandler & handler)

{

throw CIMNotSupportedException("AssociationProvider::references");

}

void InteropProvider::referenceNames(

PEG_METHOD_EXIT();

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & resultClass,

const String & role,

ObjectPathResponseHandler & handler)

{

throw CIMNotSupportedException("AssociationProvider::referenceNames");

}

PEGASUS_NAMESPACE_END

// END_OF_FILE

// END OF FILE

Legend:

Removed from v.1.5.2.8
changed lines
	Added in v.1.66.4.1

No CVS admin address has been configured