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 and 1.88.2.1

version 1.5, 2004/01/16 20:32:41

version 1.88.2.1, 2011/10/11 18:18:16

Line 1

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

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

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

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

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

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

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

// License.

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

// deal in the Software without restriction, including without limitation the

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

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

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

// sell copies of the Software, and to permit persons to whom the Software is

// to deal in the Software without restriction, including without limitation

// furnished to do so, subject to the following conditions:

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// and/or sell copies of the Software, and to permit persons to whom the

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// Software is furnished to do so, subject to the following conditions:

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// The above copyright notice and this permission notice shall be included

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// in all copies or substantial portions of the Software.

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

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

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

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

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

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

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

// 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 August 2003 KS */

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/PegasusVersion.h>

Line 63

Line 53

#include <iostream>

#include "InteropProvider.h"

#include <Pegasus/Common/String.h>

#include "InteropProviderUtils.h"

#include <Pegasus/Common/System.h>

#include "InteropConstants.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>

// ATTN: KS these are in header

//#include <Pegasus/Repository/CIMRepository.h>

//#include <Pegasus/Provider/CIMInstanceProvider.h>

//#include <Pegasus/Provider/CIMAssociationProvider.h>

//#include <Pegasus/Common/ResponseHandler.h>

#include <Pegasus/Common/XmlWriter.h>

#include <Pegasus/Common/StatisticalData.h>

#include <Pegasus/Common/StringConversion.h>

#include <Pegasus/Common/ArrayIterator.h>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

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

//#define CDEBUG(X)

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

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

* The following are constants representing property names for the classes

static const String PegasusInstanceIDGlobalPrefix = "PEG";

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

// Constants representing the class names processed

* 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.

The constants representing the class names we process

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

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

// Constructor for the InteropProvider control provider

static const CIMName CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME =

CIMName ("CIM_ObjectManagerCommunicationMechanism");

InteropProvider::InteropProvider(

static const CIMName CIM_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME =

CIMRepository * rep,

CIMName ("CIM_CIMXMLCommunicationMechanism");

ProviderRegistrationManager *provRegManager):

repository(rep),

providerRegistrationManager(provRegManager),

// Property Names for __Namespace Class

hostName(System::getHostName()),

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

providerInitialized(false),

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

updateProfileCache(0),

profileIds(Array<String>()),

conformingElements(Array<CIMNameArray>()),

// Property names for CIM_ObjectManager Class

elementNamespaces(Array<CIMNamespaceArray>())

static const CIMName OM_GATHERSTATISTICALDATA =

{

CIMName ("GatherStatisticalData");

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

ConfigManager *configManager = ConfigManager::getInstance();

// Property Names for ObjectManagerCommunicationMechanism Class

#ifdef PEGASUS_ENABLE_SLP

static const CIMName OM_COMMUNICATIONMECHANISM =

enableSLP = ConfigManager::parseBooleanValue(

CIMName ("CommunicationMechanism");

configManager->getCurrentValue("slp"));

static const CIMName OM_FUNCTIONALPROFILESSUPPORTED =

#else

CIMName ("FunctionalProfilesSupported");

enableSLP = false;

static const CIMName OM_FUNCTIONALPROFILEDESCRIPTIONS =

#endif

CIMName ("FunctionalProfileDescriptions");

static const CIMName OM_AUTHENTICATIONMECHANISMSSUPPORTED =

httpPort = configManager->getCurrentValue("httpPort");

CIMName ("AuthenticationMechanismsSupported");

if (httpPort.size() == 0)

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,

CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM = 4,

CIM_CIMXMLCOMMUNICATIONMECHANISM = 5

};

// #define __NAMESPACE 1

// #define CIM_NAMESPACE 2

// #define CIM_OBJECTMANAGER 3

// #define CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM 4

// #define CIM_CIMXMLCOMMUNICATIONMECHANISM 5

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

// Provider Utility Functions

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

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

Uint32 portNumberHttp = System::lookupPort(

WBEM_HTTP_SERVICE_NAME, WBEM_DEFAULT_HTTP_PORT);

char buffer[32];

Uint32 n;

const char *output = Uint32ToString(buffer, portNumberHttp, n);

httpPort.assign(output, n);

}

Boolean _validateProperties(const CIMInstance& instance)

httpsPort = configManager->getCurrentValue("httpsPort");

if (httpsPort.size() == 0)

{

return true;

Uint32 portNumberHttps = System::lookupPort(

WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);

char buffer[32];

Uint32 n;

const char *output = Uint32ToString(buffer, portNumberHttps, n);

httpsPort.assign(output, n);

}

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

optionally the value itself. Note processes only String

#ifndef PEGASUS_DISABLE_PERFINST

properties

try

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

{

Uint32 pos;

initProvider();

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

}

return(false);

catch(const Exception &)

// Get the property

CIMConstProperty theProperty = instance.getProperty(pos);

const CIMValue theValue = theProperty.getValue ();

// Required property must have a non-null value

if (theValue.getType() != CIMTYPE_STRING)

return(false);

if (theValue.isNull ())

return(false);

if (value != String::EMPTY)

{

if (theValue != value)

// Provider initialization may fail if the repository is not

return(false);

// populated

}

return(true);

#endif

PEG_METHOD_EXIT();

}

Boolean _validateRequiredProperty(const CIMInstance& instance,

const CIMName& propertyName,

const Uint16& value)

{

Uint32 pos;

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

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

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

CIMConstProperty theProperty = instance.getProperty(pos);

CIMInstance InteropProvider::localGetInstance(

CIMValue theValue = theProperty.getValue ();

const OperationContext & context,

const CIMObjectPath & instanceName,

// Required property must have a non-null value

const CIMPropertyList & propertyList)

if (theValue.getType() != CIMTYPE_UINT16)

return(false);

if (theValue.isNull ())

return(false);

if (theValue != value)

return(false);

return(true);

}

Boolean _validateRequiredProperty(const CIMObjectPath& objectPath,

const CIMName& propertyName,

const String value)

{

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

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

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

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

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

// Get CIM_IndicationService instance from IndicationService.

#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT

|| opClass == PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE

#endif

)

{

return(true);

AutoMutex mut(interopMut);

}

CIMInstance gotInstance = cimomHandle.getInstance(

}

context,

}

opNamespace,

}

instanceName,

return(true);

false,

propertyList);

PEG_METHOD_EXIT();

return gotInstance;

}

/* Query the repository for array of all namespacenames

TARGET_CLASS classEnum = translateClassInput(opClass);

CIMInstance retInstance;

Array<CIMNamespaceName> InteropProvider::_enumerateNameSpaces()

switch(classEnum)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

case PG_SOFTWAREIDENTITY:

"InteropProvider::_enumerateNameSpaces()");

Array<CIMNamespaceName> namespaceNames;

try

{

namespaceNames = _repository->enumerateNameSpaces();

retInstance = getSoftwareIdentityInstance(instanceName);

normalizeInstance(

retInstance, instanceName, false, false, propertyList);

}

catch(CIMException& e)

break;

case PG_NAMESPACE:

{

PEG_METHOD_EXIT();

retInstance = getNameSpaceInstance(instanceName);

throw e;

normalizeInstance(

retInstance, instanceName, false, false, propertyList);

}

catch(Exception& e)

break;

// ATTN: Implement getIntstance for all other classes. Currently

// this method calls localEnumerateInstances() to select instance

// which is too expensive.

default:

{

PEG_METHOD_EXIT();

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

throw e;

// instance name

}

CIMObjectPath ref;

ref.setHost(instanceName.getHost());

ref.setClassName(opClass);

ref.setNameSpace(opNamespace);

PEG_METHOD_EXIT();

// Enumerate instances for this class. Returns all instances

return(namespaceNames);

// Note that this returns paths setup and instances already

}

// filtered per the input criteria.

Array<CIMInstance> instances = localEnumerateInstances(

context,

ref,

propertyList);

ConstArrayIterator<CIMInstance> instancesIter(instances);

/* get the CIM_Namespace Class defintion from the repository or

// deliver a single instance if found.

from local static storage.

bool found = false;

@param namespace in which to look for the class.

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

@param name of class to get.

@return the CIMClass object

@Exceptions any repository exceptions if class not found.

CIMClass InteropProvider::_getClass(const CIMNamespaceName& nameSpace,

const CIMName& className)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

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

"InteropProvider::_getCIM_NamespaceClass()");

currentInstRef.setHost(instanceName.getHost());

CIMClass myClass;

currentInstRef.setNameSpace(instanceName.getNameSpace());

CDEBUG("Get Class from repository " << className.getString());

if(instanceName == currentInstRef)

if (myClass.isUninitialized())

{

try

{

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

retInstance = instancesIter[i];

found = true;

break;

}

catch(CIMException& e)

{

PEG_METHOD_EXIT();

throw e;

}

catch(Exception& e)

{

PEG_METHOD_EXIT();

throw e;

if (!found)

{

throw CIMObjectNotFoundException(instanceName.toString());

}

PEG_METHOD_EXIT();

return myClass;

}

return retInstance;

}

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

Array<CIMInstance> InteropProvider::getReferencedInstances(

return indicator which.

const Array<CIMInstance> &refs,

@param - Classname

const String targetRole,

@return - Uint32 indicating type

const OperationContext & context,

@Exceptions - throws CIMNotSupportedException if invalid class.

const CIMPropertyList & propertyList)

targetClass _verifyValidClassInput(const CIMName& className)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_verifyValidClassInput()");

"InteropProvider::getReferencedObjects");

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

if (className.equal(CIM_NAMESPACE_CLASSNAME))

Array<CIMInstance> referencedInstances;

Array<CIMInstance> classInstances;

CIMName prevClassName;

ConstArrayIterator<CIMInstance> refsIter(refs);

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

{

CIMInstance thisRef = refsIter[i];

CIMObjectPath thisTarget = getRequiredValue<CIMObjectPath>(

thisRef,

targetRole);

// 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 = thisTarget.getNameSpace();

CIMName opClass = thisTarget.getClassName();

if((opNamespace != PEGASUS_NAMESPACENAME_INTEROP &&

opClass != PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE)

// Get CIM_IndicationService instance from IndicationService.

#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT

|| opClass == PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE

#endif

)

{

PEG_METHOD_EXIT();

AutoMutex mut(interopMut);

return CIM_NAMESPACE;

CIMInstance gotInstance = cimomHandle.getInstance(

context,

opNamespace,

thisTarget,

false,

propertyList);

referencedInstances.append(gotInstance);

continue;

}

if (className.equal(CIM_OBJECTMANAGER_CLASSNAME))

TARGET_CLASS classEnum = translateClassInput(opClass);

CIMInstance retInstance;

switch(classEnum)

{

PEG_METHOD_EXIT();

case PG_SOFTWAREIDENTITY:

return CIM_OBJECTMANAGER;

}

if (className.equal(CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME))

{

PEG_METHOD_EXIT();

CIMInstance retInstance =

return CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM;

getSoftwareIdentityInstance(thisTarget);

normalizeInstance(

retInstance, thisTarget, false, false, propertyList);

retInstance.setPath(thisTarget);

referencedInstances.append(retInstance);

}

break;

if (className.equal(CIM_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME))

case PG_NAMESPACE:

{

PEG_METHOD_EXIT();

CIMInstance retInstance = getNameSpaceInstance(thisTarget);

return CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM;

normalizeInstance(

retInstance, thisTarget, false, false, propertyList);

retInstance.setPath(thisTarget);

referencedInstances.append(retInstance);

}

break;

// Last entry, reverse test and returnOK if CIM_Namespace

default:

if (!className.equal(CIM_NAMESPACE_CLASSNAME))

{

PEG_METHOD_EXIT();

if( opClass != prevClassName )

throw CIMNotSupportedException

{

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

CIMObjectPath ref;

ref.setHost(thisTarget.getHost());

ref.setClassName(thisTarget.getClassName());

ref.setNameSpace(thisTarget.getNameSpace());

classInstances = localEnumerateInstances(

context,

ref,

propertyList);

ArrayIterator<CIMInstance> instsIter(classInstances);

for(Uint32 n = 0; n < instsIter.size(); n++)

{

CIMObjectPath tmpInst = instsIter[n].getPath();

tmpInst.setHost(thisTarget.getHost());

tmpInst.setNameSpace(thisTarget.getNameSpace());

instsIter[n].setPath(tmpInst);

}

prevClassName = opClass;

PEG_METHOD_EXIT();

return CIM_NAMESPACE;

}

ConstArrayIterator<CIMInstance> instsConstIter(classInstances);

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

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

String _validateUserID(const OperationContext & context)

{

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

if(thisTarget == instsConstIter[j].getPath())

String userName;

try

{

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

referencedInstances.append(instsConstIter[j]);

userName = container.getUserName();

break;

}

catch (...)

{

userName = String::EMPTY;

}

return userName;

}

break;

void _buildInstanceCommonKeys(CIMInstance& instance)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstanceCommonKeys()");

String SystemCreationClassName = System::getSystemCreationClassName ();

if (SystemCreationClassName == String::EMPTY)

{

// This in place because global is often Empty

SystemCreationClassName = "CIM_ComputerSystem";

}

String SystemName = System::getHostName();

// Add property SystemCreationClassName

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

SystemCreationClassName)));

// Add property SystemName

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

SystemName)));

PEG_METHOD_EXIT();

}

CIMInstance _buildInstancCIMXMLCommunicationMechanism()

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstanceCIMXMLCommunicationMechanism()");

CIMInstance instance(CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME);

_buildInstanceCommonKeys(instance);

//CreationClassName

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME.getString() )));

String name = "PegasusCommunicationMechanism";

//Name, this CommunicationMechanism.

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_NAME,

name )));

// CommunicationMechanism Property

instance.addProperty(

(CIMProperty(OM_COMMUNICATIONMECHANISM,

Uint16(2) )));

// CommunicationMechanism Property

instance.addProperty(

(CIMProperty(OM_COMMUNICATIONMECHANISM,

Uint16(2) )));

PEG_METHOD_EXIT();

return(instance);

}

/* build instance of the CIMObjectManagerCommunicationClass

CIMInstance _buildInstancCIMObjectCommunicationMechanism()

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstanceCIMObjectCommunicationMechanism()");

CIMInstance instance(CIM_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME);

_buildInstanceCommonKeys(instance);

//CreationClassName - Class this instance created from.

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME.getString() )));

String name = "PegasusCIMXMLCommunicationMechanism";

//Name, this CommunicationMechanism. The use of this name is not

// clear right now

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_NAME,

name )));

// CommunicationMechanism Property. Set to 2, CIMXML for now.

instance.addProperty(

(CIMProperty(OM_COMMUNICATIONMECHANISM,

Uint16(2) )));

//Functional Profiles Supported Property.

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

CIMValue profileValue(profiles);

CIMValue profileDescriptionsValue(profileDescriptions);

instance.addProperty(

(CIMProperty(OM_FUNCTIONALPROFILESSUPPORTED,

profileValue )));

instance.addProperty(

(CIMProperty(OM_FUNCTIONALPROFILEDESCRIPTIONS,

profileDescriptionsValue )));

// Multiple OperationsSupported Property

instance.addProperty(

(CIMProperty(OM_MULTIPLEOPERATIONSSUPPORTED,

Boolean(false) )));

// AuthenticationMechanismsSupported Property

Array<Uint16> authentications;

Array<String> authenticationDescriptions;

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

CIMValue authenticationValue(authentications);

CIMValue authenticationDescriptionsValue(authenticationDescriptions);

instance.addProperty(

(CIMProperty(OM_AUTHENTICATIONMECHANISMSSUPPORTED,

authenticationValue )));

instance.addProperty(

(CIMProperty(OM_AUTHENTICATIONMECHANISMDESCRIPTIONS,

authenticationDescriptionsValue )));

//Version property

instance.addProperty(

(CIMProperty(OM_VERSION,

CIMXMLProtocolVersion )));

PEG_METHOD_EXIT();

return(instance);

return referencedInstances;

}

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

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

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

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

are defined (Trademark/etc followed by unique identification.

Temporarily we simply get

1. Prefix which is in Constants

2. Host Name

3. Current time

String _getObjectManagerName()

{

String objectManagerName = PegasusInstanceIDGlobalPrefix;

objectManagerName.append("_");

objectManagerName.append(System::getHostName());

objectManagerName.append(System::getCurrentASCIITime());

return (objectManagerName);

}

CIMInstance InteropProvider::_buildInstanceCIMObjectManager()

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

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

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

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

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

// case.

Array<CIMInstance> InteropProvider::localEnumerateInstances(

const OperationContext & context,

const CIMObjectPath & ref,

const CIMPropertyList& propertyList)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::_buildInstanceCIMObjectManager()");

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

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

TARGET_CLASS classEnum = translateClassInput(className);

if (!instanceOfCIMObjectManager.isUninitialized())

{

PEG_METHOD_EXIT();

return(instanceOfCIMObjectManager);

}

// Try to get persistent instance from repository

Array<CIMInstance> instances;

try

switch(classEnum)

{

instances = _repository->enumerateInstances(_operationNamespace,

case PG_OBJECTMANAGER:

CIM_OBJECTMANAGER_CLASSNAME );

}

catch(CIMException& e)

{

PEG_METHOD_EXIT();

instances.append(getObjectManagerInstance());

throw e;

break;

}

catch(Exception& e)

case PG_CIMXMLCOMMUNICATIONMECHANISM:

{

PEG_METHOD_EXIT();

instances = enumCIMXMLCommunicationMechanismInstances();

throw e;

break;

}

case PG_NAMESPACEINMANAGER:

if (instances.size() >= 1)

{

instanceOfCIMObjectManager = instances[0];

instances = enumNamespaceInManagerInstances();

PEG_METHOD_EXIT();

break;

return(instanceOfCIMObjectManager);

}

case PG_COMMMECHANISMFORMANAGER:

// Must build new instance and save it.

CIMInstance instance(CIM_OBJECTMANAGER_CLASSNAME);

instanceOfCIMObjectManager = instance;

_buildInstanceCommonKeys(instanceOfCIMObjectManager);

//CreationClassName -- This class.

instanceOfCIMObjectManager.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString() )));

//Name, this CIMObject Manager.

instanceOfCIMObjectManager.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_NAME,

_getObjectManagerName() )));

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

instanceOfCIMObjectManager.addProperty(

(CIMProperty(OM_GATHERSTATISTICALDATA,

Boolean(gatherStatData) )));

// write the instance to the repository

CIMObjectPath instancepath;

try

{

instancepath = _repository->createInstance(_operationNamespace,

instances = enumCommMechanismForManagerInstances();

instanceOfCIMObjectManager );

break;

}

catch(CIMException& e)

case PG_NAMESPACE:

{

PEG_METHOD_EXIT();

instances = enumNamespaceInstances();

throw e;

break;

}

catch(Exception& e)

case PG_REGISTEREDPROFILE:

{

PEG_METHOD_EXIT();

instances = enumRegisteredProfileInstances();

throw e;

break;

}

case PG_REGISTEREDSUBPROFILE:

PEG_METHOD_EXIT();

return(instanceOfCIMObjectManager);

}

/* generate one instance of the CIM_Namespace class with the

properties

@param namespace name to put into the class

@exceptions - exceptions carried forward from create instance

and addProperty.

/* Create an instance of the CIM_Namespace class which is based

on the following CIM MOF Specification

[Version ("2.6.0"), Description (

"Namespace provides a domain (in other words, a container), "

"in which the instances [of a class] are guaranteed to be "

"unique per the KEY qualifier definitions. It is named "

"relative to the CIM_ObjectManager implementation that "

"provides such a domain.") ]

class CIM_Namespace : CIM_ManagedElement {

[Propagated("CIM_ObjectManager.SystemCreationClassName"), Key,

MaxLen (256), Description (

"The scoping System's CreationClassName.") ]

string SystemCreationClassName;

[Propagated("CIM_ObjectManager.SystemName"), Key, MaxLen (256),

Description ("The scoping System's Name.") ]

string SystemName;

[Propagated ("CIM_ObjectManager.CreationClassName"), Key,

MaxLen (256), Description (

"The scoping ObjectManager's CreationClassName.") ]

string ObjectManagerCreationClassName;

[Propagated ("CIM_ObjectManager.Name"), Key, MaxLen (256),

Description ("The scoping ObjectManager's Name.") ]

string ObjectManagerName;

[Key, MaxLen (256), Description (

"CreationClassName indicates the name of the class or the "

"subclass used in the creation of an instance. When used "

"with the other key properties of this class, this property "

"allows all instances of this class and its subclasses to "

"be uniquely identified.") ]

string CreationClassName;

[Key, MaxLen (256), Description (

"A string to uniquely identify the Namespace within "

"the ObjectManager.") ]

string Name;

[Required, Write, Description (

"Enumeration indicating the organization/schema of the "

"Namespace's objects. For example, they may be instances "

"of classes of a specific CIM version."),

ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9",

"10", "200", "201", "202"},

Values {"Unknown", "Other", "CIM 1.0", "CIM 2.0",

"CIM 2.1", "CIM 2.2", "CIM 2.3", "CIM 2.4", "CIM 2.5",

"CIM 2.6", "CIM 2.7", "DMI Recast", "SNMP Recast",

"CMIP Recast"},

ModelCorrespondence {"CIM_Namespace.DescriptionOfClassInfo"} ]

uint16 ClassInfo;

[Write, Description (

"A string providing more detail (beyond the general "

"classification in ClassInfo) for the object hierarchy of "

"the Namespace."),

ModelCorrespondence {"CIM_Namespace.ClassInfo"} ]

string DescriptionOfClassInfo;

};

CIMInstance _buildInstanceCIMNamespace(const CIMNamespaceName & nameSpace)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

instances = enumRegisteredSubProfileInstances();

"InteropProvider::_buildInstanceCIMNamespace()");

break;

// Values for test

//String SystemCreationClassName = "creationclassname";

//String SystemName = "SystemNameValue";

String ObjectManagerName = "ObjectManagerNameValue";

String ClassInfo = "ClassInfo";

String DescriptionOfClassInfo = "DescriptionOfClassInfo";

CIMInstance instance(CIM_NAMESPACE_CLASSNAME);

/* The following moved to common create

// Add the properties

// SystemCreationClassName

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

SystemCreationClassName)));

// SystemName

instance.addProperty(

(CIMProperty(CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

SystemName)));

_buildInstanceCommonKeys(instance);

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

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

case PG_REFERENCEDPROFILE:

{

Boolean valid = true;

instances = enumReferencedProfileInstances();

CIMName propertyName;

break;

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

System::getSystemCreationClassName ()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME;

valid = false;

}

if (!_validateRequiredProperty(objectPath,

case PG_ELEMENTCONFORMSTOPROFILE:

CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME;

instances = enumElementConformsToProfileInstances(context,

valid = false;

ref.getNameSpace());

break;

}

if (!_validateRequiredProperty(objectPath,

case PG_ELEMENTCONFORMSTOPROFILE_RP_RP:

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString()))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME;

instances = enumElementConformsToProfileRPRPInstances(

valid = false;

context,

ref.getNameSpace());

break;

}

case PG_SUBPROFILEREQUIRESPROFILE:

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

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME,

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME;

instances = enumSubProfileRequiresProfileInstances();

valid = false;

break;

}

if (!_validateRequiredProperty(objectPath,

case PG_SOFTWAREIDENTITY:

CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME;

instances = enumSoftwareIdentityInstances();

valid = false;

break;

}

case PG_ELEMENTSOFTWAREIDENTITY:

if (!_validateRequiredProperty(objectPath,

CIM_NAMESPACE_PROPERTY_NAME,

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_NAME;

instances = enumElementSoftwareIdentityInstances();

valid = false;

break;

}

case PG_INSTALLEDSOFTWAREIDENTITY:

if (false)

{

throw CIMInvalidParameterException(

instances = enumInstalledSoftwareIdentityInstances(context);

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

break;

}

void _validateCIMNamespaceKeys(const CIMInstance& instance)

case PG_COMPUTERSYSTEM:

{

Boolean valid = true;

CIMName propertyName;

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,

System::getSystemCreationClassName ()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME;

instances.append(getComputerSystemInstance(context));

valid = false;

break;

}

case PG_HOSTEDOBJECTMANAGER:

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_SYSTEMNAME,

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME;

instances.append(getHostedObjectManagerInstance(context));

valid = false;

break;

}

case PG_HOSTEDACCESSPOINT:

if (!_validateRequiredProperty(instance,

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME,

CIM_OBJECTMANAGER_CLASSNAME.getString()))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME;

instances = enumHostedAccessPointInstances(context);

valid = false;

break;

}

//We don't support enumerate CIM_Namespace instances. PG_Namespace is

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

//supported.

if (!_validateRequiredProperty(instance,

case CIM_NAMESPACE:

CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME,

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME;

break;

valid = false;

}

if (!_validateRequiredProperty(instance,

case PG_PROVIDERPROFILECAPABILITIES:

CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,

System::getHostName()))

{

propertyName = CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME;

instances = enumProviderProfileCapabilityInstances(false);

valid = false;

break;

}

if (!_validateRequiredProperty(instance,

#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT

CIM_NAMESPACE_PROPERTY_NAME,

case PG_ELEMENTCAPABILITIES:

String::EMPTY))

{

propertyName = CIM_NAMESPACE_PROPERTY_NAME;

instances = enumElementCapabilityInstances(context);

valid = false;

break;

}

case PG_HOSTEDINDICATIONSERVICE:

if (false)

{

throw CIMInvalidParameterException(

instances = enumHostedIndicationServiceInstances(context);

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

break;

}

case PG_SERVICEAFFECTSELEMENT:

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

the object. This builds all components of the path

@param namespace name to build

@return CIMObjectPath containing namespace, class and keybinding

components of path

@exceptions - TBD

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

instances = enumServiceAffectsElementInstances(context);

"InteropProvider::_buildInstancePath()");

break;

}

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

#endif

//CIMNamespaceName thisNamespace = classReference.getNameSpace();

default:

CIMClass thisClass = _getClass(_operationNamespace, className);

// XmlWriter::printInstanceElement(instance);

CIMObjectPath ref = instance.buildPath(thisClass);

CDEBUG("Built path. path = " << ref.toString() );

PEG_METHOD_EXIT();

return(ref);

throw CIMNotSupportedException(className.getString() +

" not supported by Interop Provider enumerate");

}

// Filter and deliver the resulting instances

/* _isNamespace determines if the namespace in the second

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

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;

normalizeInstance(instances[i], ref, false,

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

false, propertyList);

{

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

{

return true;

}

return false;

}

Boolean _isChild(

PEG_METHOD_EXIT();

CIMNamespaceName& parentNamespaceName,

return instances;

CIMNamespaceName& namespaceName)

}

{

String parent = parentNamespaceName.getString();

String child = namespaceName.getString();

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

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

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

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

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

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

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

bool InteropProvider::validAssocClassForObject(

const OperationContext & context,

const CIMName & assocClass,

const CIMObjectPath & objectName,

const CIMNamespaceName & opNamespace,

String & originProperty,

String & targetProperty)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::validAssocClassForObject()");

TARGET_CLASS assocClassEnum = translateClassInput(assocClass);

TARGET_CLASS originClassEnum = NOCLASS;

CIMName originClass = objectName.getClassName();

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

{

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

// that has implemented a registered profile.

if(opNamespace != PEGASUS_NAMESPACENAME_INTEROP ||

(originClass != PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE &&

originClass != PEGASUS_CLASSNAME_PG_OBJECTMANAGER ))

{

return false;

}

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

// Search the cached conformingElements list for the originClass,

// returning false if it is not found

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

bool found = false;

{

return true;

}

return false;

}

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

// Overloaded functions to get key value with different params

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

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

PEGASUS_ASSERT(conformingElements.size() ==

Executes exception if the key not found

elementNamespaces.size());

@param object path we will search

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

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

CIMNameArray & elementList = conformingElements[i];

CIMNamespaceArray & namespaceList = elementNamespaces[i];

// find the correct key binding

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

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

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

{

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

CIMName & curElement = elementList[j];

if((curElement == originClass ||

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

opNamespace == namespaceList[j])

{

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

found = true;

break;

}

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

if(found)

break;

}

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

if(!found)

{

Uint32 pos;

PEG_METHOD_EXIT();

CIMValue propertyValue;

return false;

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

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

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

// for this operation

originClassEnum = translateClassInput(originClass);

}

Uint32 pos;

CIMName expectedTargetRole;

CIMValue propertyValue;

CIMName expectedOriginRole;

// [Key, MaxLen (256), Description (

Array<CIMName> propNames;

// "A string that uniquely identifies the Namespace "

String profileName;

// "within the ObjectManager.") ]

CIMPropertyList propertyList;

// string Name;

CIMInstance tmpInstance;

Uint32 index;

propNames.clear();

pos = namespaceInstance.findProperty(NAMESPACE_PROPERTYNAME);

if (pos == PEG_NOT_FOUND)

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

{

throw CIMPropertyNotFoundException

case PG_NAMESPACEINMANAGER:

(NAMESPACE_PROPERTYNAME.getString());

if(originClassEnum == PG_OBJECTMANAGER)

{

expectedTargetRole = PROPERTY_DEPENDENT;

expectedOriginRole = PROPERTY_ANTECEDENT;

}

else if(originClassEnum == PG_NAMESPACE)

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

if (propertyValue.getType() != CIMTYPE_STRING)

{

throw CIMInvalidParameterException("Invalid type for property: "

expectedTargetRole = PROPERTY_ANTECEDENT;

+ NAMESPACE_PROPERTYNAME.getString());

expectedOriginRole = PROPERTY_DEPENDENT;

}

break;

String cnsName;

case PG_COMMMECHANISMFORMANAGER:

propertyValue.get(cnsName);

if(originClassEnum == PG_OBJECTMANAGER)

childNamespaceName = CIMNamespaceName (cnsName);

{

expectedTargetRole = PROPERTY_DEPENDENT;

isRelativeName = !(childNamespaceName.isNull());

expectedOriginRole = PROPERTY_ANTECEDENT;

}

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

else if(originClassEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

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)

{

expectedTargetRole = PROPERTY_ANTECEDENT;

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

expectedOriginRole = PROPERTY_DEPENDENT;

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

}

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

break;

case PG_ELEMENTCONFORMSTOPROFILE:

if(originClass.equal(PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE))

{

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

expectedTargetRole =

isRelativeName = !(childNamespaceName.isNull());

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

expectedOriginRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

}

else

{

throw CIMInvalidParameterException("Invalid key property: ");

expectedTargetRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

expectedOriginRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

}

break;

case PG_ELEMENTCONFORMSTOPROFILE_RP_RP:

propNames.append(CIMName("RegisteredName"));

propertyList = CIMPropertyList(propNames);

try

{

tmpInstance = localGetInstance(

context,

objectName,

propertyList);

}

catch (CIMException &e)

{

PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL2,

"CIMException while getting instance of Registered Profile "

": %s",

(const char*)e.getMessage().getCString()));

}

if (!tmpInstance.isUninitialized())

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

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

index = tmpInstance.findProperty("RegisteredName");

// MUST exist

if (index != PEG_NOT_FOUND)

CIMNamespaceName fullNamespaceName;

if (isRelativeName)

{

if (!_isNamespace(namespaceNames, parentNamespaceName))

const CIMValue &tmpVal =

tmpInstance.getProperty(index).getValue();

if (!tmpVal.isNull())

{

throw CIMObjectNotFoundException("Parent namespace does not exist: "

tmpVal.get(profileName);

+ parentNamespaceName.getString());

}

// Create full namespace name by prepending parentNamespaceName

}

fullNamespaceName = CIMNamespaceName (parentNamespaceName.getString()

if (String::compareNoCase(profileName, String("SMI-S")) == 0)

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

{

expectedTargetRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

expectedOriginRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

}

else

{

fullNamespaceName = parentNamespaceName;

expectedTargetRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;

expectedOriginRole =

ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;

}

return(fullNamespaceName);

break;

case PG_SUBPROFILEREQUIRESPROFILE:

if(originClassEnum == PG_REGISTEREDPROFILE)

{

expectedTargetRole = PROPERTY_DEPENDENT;

expectedOriginRole = PROPERTY_ANTECEDENT;

}

else if(originClassEnum == PG_REGISTEREDSUBPROFILE)

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

{

// The following section is the Instance Operation processors

expectedTargetRole = PROPERTY_ANTECEDENT;

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

expectedOriginRole = PROPERTY_DEPENDENT;

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

String userName = _validateUserID(context);

CIMObjectPath newInstanceReference;

if ((classEnum == CIM_OBJECTMANAGER) ||

(classEnum == CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM)||

(classEnum == CIM_CIMXMLCOMMUNICATIONMECHANISM))

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

if (classEnum == CIM_NAMESPACE)

{

CDEBUG("Create Class from CIM_Namespace");

// Valid that keys are as required.

_validateCIMNamespaceKeys(myInstance);

String namespaceName;

newNamespaceName = _getKeyValue(myInstance, CIM_NAMESPACE_PROPERTY_NAME);

CIMInstance instance = _buildInstanceCIMNamespace(namespaceName);

newInstanceReference = _buildInstancePath(CIMNamespaceName(namespaceName),

CIM_NAMESPACE_CLASSNAME, instance);

}

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

{

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

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

break;

try

case PG_REFERENCEDPROFILE:

if (originClassEnum == PG_REGISTEREDSUBPROFILE)

{

_repository->createNameSpace(newNamespaceName);

expectedTargetRole = PROPERTY_ANTECEDENT;

expectedOriginRole = PROPERTY_DEPENDENT;

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + newNamespaceName.getString() +

" successfully created.");

// ATTN: Add standardlog entry here.

}

catch(CIMException& e)

else if (originClassEnum == PG_REGISTEREDPROFILE)

{

PEG_METHOD_EXIT();

if ((targetProperty.size() != 0) &&

throw e;

(originProperty.size() != 0) &&

String::equalNoCase(targetProperty, originProperty))

{

return false;

}

catch(Exception& e)

if (targetProperty.size() != 0)

{

PEG_METHOD_EXIT();

if (!(String::equalNoCase(targetProperty, "Antecedent") ||

throw e;

String::equalNoCase(targetProperty, "Dependent") ))

{

return false;

}

// begin processing the request

handler.processing();

handler.deliver(newInstanceReference);

// complete processing the request

handler.complete();

PEG_METHOD_EXIT();

return;

}

if (originProperty.size() != 0)

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

// deleteInstance

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

void InteropProvider::deleteInstance(

const OperationContext & context,

const CIMObjectPath & instanceName,

ResponseHandler & handler)

{

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

if (!(String::equalNoCase(originProperty, "Antecedent") ||

CDEBUG("deleteInstance" << instanceName.toString());

String::equalNoCase(originProperty, "Dependent") ))

CIMNamespaceName childNamespaceName;

CIMNamespaceName deleteNamespaceName;

Boolean isRelativeName;

// Verify that ClassName is correct and get value

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

String userName = _validateUserID(context);

Array<CIMNamespaceName> namespaceNames;

namespaceNames = _enumerateNameSpaces();

if ((classEnum == CIM_OBJECTMANAGER) ||

(classEnum == CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM)||

(classEnum == CIM_CIMXMLCOMMUNICATIONMECHANISM))

throw CIMNotSupportedException("Delete Not allowed");

if (classEnum == CIM_NAMESPACE)

{

// validate requred keys. Exception out if not valid

return false;

_validateCIMNamespaceKeys(instanceName);

deleteNamespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME);

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

}

else // Procesing for __namespace

}

if (String::equalNoCase(originProperty, "Antecedent") &&

targetProperty.size() == 0)

{

targetProperty = String("Dependent");

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

}

if (String::equalNoCase(originProperty, "Dependent") &&

// ATTN: KS Why THis???

targetProperty.size() == 0)

if (deleteNamespaceName.equal (ROOTNS))

{

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

targetProperty = String("Antecedent");

}

if (String::equalNoCase(targetProperty, "Antecedent") &&

_repository->deleteNameSpace(deleteNamespaceName);

originProperty.size() == 0)

{

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

originProperty = String("Dependent");

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

}

if (String::equalNoCase(targetProperty, "Dependent") &&

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

originProperty.size() == 0)

// getInstance

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

void InteropProvider::getInstance(

const OperationContext & context,

const CIMObjectPath & instanceName,

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList & properatyList,

InstanceResponseHandler & handler)

{

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

originProperty = String("Antecedent");

}

// Verify that ClassName is correct and get value

return true;

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

}

break;

String userName = _validateUserID(context);

case PG_ELEMENTSOFTWAREIDENTITY:

if(originClassEnum == PG_SOFTWAREIDENTITY)

// begin processing the request

handler.processing();

if (classEnum == CIM_OBJECTMANAGER)

{

CIMInstance instance = _buildInstanceCIMObjectManager();

expectedTargetRole = PROPERTY_DEPENDENT;

handler.deliver(instance);

expectedOriginRole = PROPERTY_ANTECEDENT;

handler.complete();

PEG_METHOD_EXIT();

return;

}

else if(originClassEnum == PG_REGISTEREDPROFILE ||

if (classEnum == CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM)

originClassEnum == PG_REGISTEREDSUBPROFILE)

{

CIMInstance instance = _buildInstancCIMObjectCommunicationMechanism();

expectedTargetRole = PROPERTY_ANTECEDENT;

handler.deliver(instance);

expectedOriginRole = PROPERTY_DEPENDENT;

handler.complete();

PEG_METHOD_EXIT();

return;

}

break;

case PG_INSTALLEDSOFTWAREIDENTITY:

if (classEnum == CIM_CIMXMLCOMMUNICATIONMECHANISM)

if(originClassEnum == PG_SOFTWAREIDENTITY)

{

CIMInstance instance = _buildInstancCIMXMLCommunicationMechanism();

expectedTargetRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM;

handler.deliver(instance);

expectedOriginRole =

handler.complete();

INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE;

PEG_METHOD_EXIT();

return;

}

else if(originClassEnum == PG_COMPUTERSYSTEM)

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

expectedTargetRole =

// get the namespace from the name value.

INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE;

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

expectedOriginRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM;

CIMNamespaceName namespaceName;

}

namespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME);

break;

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

case PG_HOSTEDACCESSPOINT:

if(originClassEnum == PG_COMPUTERSYSTEM)

if (!_isNamespace(namespaceNames, namespaceName))

{

throw CIMObjectNotFoundException("Namespace does not exist: "

expectedTargetRole = PROPERTY_DEPENDENT;

+ namespaceName.getString());

expectedOriginRole = PROPERTY_ANTECEDENT;

}

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

else if(originClassEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)

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

{

instance = _buildInstanceCIMNamespace(namespaceName);

expectedTargetRole = PROPERTY_ANTECEDENT;

expectedOriginRole = PROPERTY_DEPENDENT;

}

else // processing for __Namespace

case PG_HOSTEDOBJECTMANAGER:

if(originClassEnum == PG_COMPUTERSYSTEM)

{

CIMNamespaceName childNamespaceName;

expectedTargetRole = PROPERTY_DEPENDENT;

CIMNamespaceName getNamespaceName;

expectedOriginRole = PROPERTY_ANTECEDENT;

Boolean isRelativeName;

}

else if(originClassEnum == PG_OBJECTMANAGER)

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

getNamespaceName = _generateFullNamespaceName(

namespaceNames, parentNamespaceName,

childNamespaceName, isRelativeName);

// exception if not valid namespace

if (!_isNamespace(namespaceNames, getNamespaceName))

{

throw CIMObjectNotFoundException("Namespace deos not exist: "

expectedTargetRole = PROPERTY_ANTECEDENT;

+ getNamespaceName.getString());

expectedOriginRole = PROPERTY_DEPENDENT;

}

break;

#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT

case PG_HOSTEDINDICATIONSERVICE:

if(originClassEnum == PG_COMPUTERSYSTEM)

{

expectedTargetRole = PROPERTY_DEPENDENT;

expectedOriginRole = PROPERTY_ANTECEDENT;

}

break;

#endif

default:

break;

}

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

"Namespace = " + getNamespaceName.getString() +

" successfully found.");

//Set name of class

CIMInstance instance(__NAMESPACE_CLASSNAME);

// construct the instance

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

instance.addProperty(CIMProperty(NAMESPACE_PROPERTYNAME,

if(expectedTargetRole.isNull() ||

isRelativeName?childNamespaceName.getString():

expectedOriginRole.isNull())

parentNamespaceName.getString()));

{

//instance.setPath(instanceName);

}

handler.deliver(instance);

// complete processing the request

handler.complete();

PEG_METHOD_EXIT();

return ;

return false;

}

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

if(targetProperty.size() == 0)

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

targetProperty = expectedTargetRole.getString();

CDEBUG("EnumerateInstances");

// Verify that ClassName is correct and get value

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

String userName = _validateUserID(context);

// The following 3 classes deliver a single instance because

// that is all there is today.

if (classEnum == CIM_OBJECTMANAGER)

{

CIMInstance instance = _buildInstanceCIMObjectManager();

handler.deliver(instance);

handler.complete();

PEG_METHOD_EXIT();

return;

}

else if(!expectedTargetRole.equal(targetProperty))

if (classEnum == CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM)

{

CIMInstance instance = _buildInstancCIMObjectCommunicationMechanism();

handler.deliver(instance);

handler.complete();

PEG_METHOD_EXIT();

return;

return false;

}

if(originProperty.size() == 0)

if (classEnum == CIM_CIMXMLCOMMUNICATIONMECHANISM)

{

originProperty = expectedOriginRole.getString();

}

else if(!expectedOriginRole.equal(originProperty))

{

CIMInstance instance = _buildInstancCIMXMLCommunicationMechanism();

handler.deliver(instance);

handler.complete();

PEG_METHOD_EXIT();

return;

return false;

}

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

PEG_METHOD_EXIT();

CIMNamespaceName parentNamespaceName = ref.getNameSpace();

return true;

}

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

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

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

// begin processing the request

handler.processing();

Array<CIMNamespaceName> namespaceNames = _enumerateNameSpaces();

Array<CIMInstance> instanceArray;

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

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

// Build response objects based on class requested

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

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

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

CDEBUG("For namespace' " << namespaceNames[i].getString());

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

CDEBUG("Evaluate ClassEnum" << classEnum);

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

if (classEnum == CIM_NAMESPACE)

Array<CIMInstance> InteropProvider::localReferences(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & assocClass,

String & originProperty,

String & targetProperty,

const CIMPropertyList & propertyList,

const CIMName & targetClass)

{

CDEBUG("Evaluate CIM_Namespace" << classEnum);

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

// Create a valid CIM_Namespace Instance

"InteropProvider::localReferences()");

CIMInstance instance = _buildInstanceCIMNamespace(namespaceNames[i]);

instanceArray.append(instance);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

Array<CIMInstance> instances;

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

CIMName originClass = objectName.getClassName();

Array<CIMName> targetSubclasses;

CIMNamespaceName lastTargetNamespace;

CIMNamespaceName originNamespace(objectName.getNameSpace());

// Check that the association traversal request is valid

if (validAssocClassForObject(

context,

assocClass,

objectName,

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

}

else // the else covers __NAMESPACE

if(targetNamespace != lastTargetNamespace)

{

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

try

// the only property is name.

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

{

CIMInstance instance(__NAMESPACE_CLASSNAME);

targetSubclasses = repository->enumerateClassNames(

instance.addProperty(

targetNamespace, targetClass, 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());

}

catch(...)

{

// If an exception was thrown during enumeration,

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

}

handler.deliver(instanceArray);

// complete processing the request

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

handler.complete();

CIMName targetPathClass = targetPath.getClassName();

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

{

if(targetPathClass == targetSubclasses[j])

{

instances.append(currentInstance);

break;

}

else

{

instances.append(currentInstance);

}

PEG_METHOD_EXIT();

return instances;

}

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

// enumerateInstanceNames

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

void InteropProvider::enumerateInstanceNames(

const OperationContext & context,

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

const CIMObjectPath & classReference,

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

ObjectPathResponseHandler & handler)

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

CIMInstance InteropProvider::buildInstanceSkeleton(

const CIMNamespaceName & nameSpace,

const CIMName& className,

Boolean includeQualifiers,

CIMClass& returnedClass)

{

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::enumerateInstanceNames()");

"InteropProvider::_buildInstanceSkeleton()");

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

// operation namespace needed internally to get class.

returnedClass = repository->getClass(nameSpace,

_operationNamespace = classReference.getNameSpace();

className, false, true, true);

CIMInstance skeleton = returnedClass.buildInstance(

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

includeQualifiers, true, CIMPropertyList());

// begin processing the request

handler.processing();

// The following 3 classes deliver a single instance because

// that is all there is today.

if (classEnum == CIM_OBJECTMANAGER)

{

CIMInstance instance = _buildInstanceCIMObjectManager();

CIMObjectPath ref = _buildInstancePath(CIMNamespaceName(),

CIM_OBJECTMANAGER_CLASSNAME, instance);

handler.deliver(ref);

handler.complete();

PEG_METHOD_EXIT();

return;

}

if (classEnum == CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM)

{

CIMInstance instance = _buildInstancCIMObjectCommunicationMechanism();

CIMObjectPath ref = _buildInstancePath(CIMNamespaceName(),

CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME, instance);

handler.deliver(ref);

handler.complete();

PEG_METHOD_EXIT();

return;

return skeleton;

}

if (classEnum == CIM_CIMXMLCOMMUNICATIONMECHANISM)

CIMInstance InteropProvider::buildDependencyInstance(

const String & antecedentId,

const CIMName & antecedentClass,

const String & dependentId,

const CIMName & dependentClass,

const CIMClass & dependencyClass)

{

CIMInstance instance = _buildInstancCIMXMLCommunicationMechanism();

Array<CIMKeyBinding> dependentKeys;

CIMObjectPath ref = _buildInstancePath(CIMNamespaceName(),

CIM_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME, instance);

handler.deliver(ref);

handler.complete();

PEG_METHOD_EXIT();

return;

}

dependentKeys.append(CIMKeyBinding(

COMMON_PROPERTY_INSTANCEID,

dependentId,CIMKeyBinding::STRING));

String userName = _validateUserID(context);

return buildDependencyInstanceFromPaths(

buildDependencyReference(hostName, antecedentId, antecedentClass),

buildDependencyReference(hostName, dependentId, dependentClass),

dependencyClass);

}

// ATTN: Move this trace

void InteropProvider::initProvider()

CIMNamespaceName parentNamespaceName = classReference.getNameSpace();

{

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

if(providerInitialized)

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

return;

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

// Placed METHOD_ENTER trace statement after checking whether the

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

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

// interesting the first time it is successfully run.

PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,

"InteropProvider::initProvider()");

// Get list of all namespaces

AutoMutex lock(interopMut);

Array<CIMNamespaceName> namespaceNames = _enumerateNameSpaces();

if(!providerInitialized)

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

{

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

// Build the cimObjectPath for each namespace found

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

// Determine whether the CIMOM should be gathering statistical data

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

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)

{

CIMValue gatherDataVal = gatherDataProp.getValue();

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

if (!gatherDataVal.isNull())

CIMInstance instance = _buildInstanceCIMNamespace(namespaceNames[i]);

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

CIM_NAMESPACE_CLASSNAME, instance);

handler.deliver(ref);

PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,

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

}

else

{

Array<CIMKeyBinding> keyBindings;

Boolean gatherData;

// Build the __Namespace objectpath

gatherDataVal.get(gatherData);

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

if (gatherData == true)

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

{

keyBindings.clear();

StatisticalData* sd = StatisticalData::current();

keyBindings.append(CIMKeyBinding(NAMESPACE_PROPERTYNAME,

sd->setCopyGSD(true);

namespaceNames[i].getString().subString

}

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

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

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

}

handler.complete();

// Cache this class definition for use later.

profileCapabilitiesClass = repository->getClass(

PEGASUS_NAMESPACENAME_INTEROP,

PEGASUS_CLASSNAME_PG_PROVIDERPROFILECAPABILITIES,

false,

true,

false);

PEG_METHOD_EXIT();

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

}

// initialize namespaces.

initializeNamespaces();

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

// Now cache the Registration info used for ElementConformsToProfile

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

cacheProfileRegistrationInfo();

// Association Functions

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

void InteropProvider::associators(

providerInitialized = true;

const OperationContext & context,

}

const CIMObjectPath & objectName,

PEG_METHOD_EXIT();

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(

const OperationContext & context,

// Initialize the namespaces so that all namespaces with the

const CIMObjectPath & objectName,

// CIM_ElementConformsToProfile class also have the

const CIMName & associationClass,

// PG_ElementConformsToProfile class. Needed in order to implement

const CIMName & resultClass,

// the cross-namespace ElementConformsToProfile association in both

const String & role,

// directions.

const String & resultRole,

ObjectPathResponseHandler & handler)

void InteropProvider::initializeNamespaces()

{

Array<CIMNamespaceName> namespaceNames = repository->enumerateNameSpaces();

// get the PG_ElementConformstoProfile class without the qualifiers

// and then add just the required ASSOCIATION qualifier, so that

// resolveclass doesn't fail for the test/EmbeddedInstance/Dynamic

// namespace, which uses the CIM25 schema that doesn't include any

// of the new qualifiers added to this class in later versions of

// the CIMSchema.

CIMClass conformsClass = repository->getClass(

PEGASUS_NAMESPACENAME_INTEROP,

PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE,

true,

false);

conformsClass.addQualifier(

CIMQualifier(CIMName("ASSOCIATION"), CIMValue(true)));

CIMClass profileClass = repository->getClass(

PEGASUS_NAMESPACENAME_INTEROP,

PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE,

true,

false);

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

{

throw CIMNotSupportedException("AssociationProvider::associatorNames");

// Check if the PG_ElementConformsToProfile class is present

CIMNamespaceName & currentNamespace = namespaceNames[i];

CIMClass tmpCimClass;

CIMClass tmpPgClass;

CIMClass tmpPgProfileClass;

try

{

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

// second depends on the first

tmpCimClass = repository->getClass(

currentNamespace,

PEGASUS_CLASSNAME_CIM_ELEMENTCONFORMSTOPROFILE);

tmpPgClass = repository->getClass(

currentNamespace,

PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE);

}

catch(const Exception &)

void InteropProvider::references(

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

}

try

void InteropProvider::referenceNames(

const OperationContext & context,

const CIMObjectPath & objectName,

const CIMName & resultClass,

const String & role,

ObjectPathResponseHandler & handler)

{

throw CIMNotSupportedException("AssociationProvider::referenceNames");

tmpPgProfileClass = repository->getClass(

currentNamespace,

PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);

}

catch(const Exception &)

{

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

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

// an expected case

// TBD: Log trace message?

}

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

{

if(tmpPgClass.isUninitialized())

{

CIMClass newclass = conformsClass.clone();

CIMObjectPath newPath = conformsClass.getPath();

newPath.setNameSpace(currentNamespace);

newclass.setPath(newPath);

repository->createClass(

currentNamespace,

newclass);

}

if(tmpPgProfileClass.isUninitialized())

{

CIMClass newclass = profileClass.clone();

CIMObjectPath newPath = profileClass.getPath();

newPath.setNameSpace(currentNamespace);

newclass.setPath(newPath);

repository->createClass(

currentNamespace,

newclass);

}

PEGASUS_NAMESPACE_END

// END_OF_FILE

// END OF FILE

Legend:

Removed from v.1.5
changed lines
	Added in v.1.88.2.1

No CVS admin address has been configured