version 1.2, 2003/08/18 14:14:40
|
version 1.72, 2008/02/20 14:00:31
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%2006//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM, |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// The Open Group, Tivoli Systems |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
|
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation, The Open Group. |
|
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; Symantec Corporation; The Open Group. |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy | // Permission is hereby granted, free of charge, to any person obtaining a copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | // 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 |
|
// | // |
//%//////////////////////////////////////////////////////////////////////////// | //%//////////////////////////////////////////////////////////////////////////// |
| |
|
|
/////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////// |
// Namespace Provider |
// Interop Provider - This provider services those classes from the |
// |
// DMTF Interop schema in an implementation compliant with the SMI-S v1.1 |
// This provider answers to the "false" class __namespace. This is the |
// Server Profile |
// deprecated version of manipulation in the DMTF WBEM model. This function |
// |
// is defined in the CIM Operations over HTTP docuement. However, while |
// Please see PG_ServerProfile20.mof in the directory |
// the function exists, no class was ever defined in the CIM model for |
// $(PEGASUS_ROOT)/Schemas/Pegasus/InterOp/VER20 for retails regarding the |
// __nemaspace. Therefore each implementation is free to provide its own |
// classes supported by this control provider. |
// class definition. |
// |
|
// Interop forces all creates to the PEGASUS_NAMESPACENAME_INTEROP |
|
// namespace. There is a test on each operation that returns |
|
// the Invalid Class CIMDError |
|
// This is a control provider and as such uses the Tracer functions |
|
// for data and function traces. Since we do not expect high volume |
|
// use we added a number of traces to help diagnostics. |
/////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////// |
| |
/* STATUS: In process but running 12 August 2003 KS */ |
|
|
|
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
#include <Pegasus/Common/PegasusVersion.h> | #include <Pegasus/Common/PegasusVersion.h> |
| |
|
|
#include <iostream> | #include <iostream> |
| |
#include "InteropProvider.h" | #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> |
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
|
|
PEGASUS_NAMESPACE_BEGIN | 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) |
|
| |
/** |
/***************************************************************************** |
* Specification for CIM Operations over HTTP |
|
* |
|
* Version 1.0 |
|
* |
|
* 2.5. Namespace Manipulation |
|
* There are no intrinsic methods defined specifically for the |
|
* purpose of manipulating CIM Namespaces. However, the modelling |
|
* of a CIM Namespace using the class __Namespace, together with |
|
* the requirement that the root Namespace MUST be supported by |
|
* all CIM Servers, implies that all Namespace operations can be |
|
* supported. |
|
* | * |
* For example: |
* The following are constants representing property names for the classes |
|
* 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. |
* | * |
* Enumeration of all child Namespaces of a particular Namespace |
*****************************************************************************/ |
* is realized by calling the intrinsic method |
|
* EnumerateInstanceNames against the parent Namespace, |
|
* specifying a value for the ClassName parameter of __Namespace. |
|
* |
|
* Creation of a child Namespace is realized by calling the |
|
* intrinsic method CreateInstance against the parent Namespace, |
|
* specifying a value for the NewInstance parameter which defines |
|
* a valid instance of the class __Namespace and whose Name |
|
* property is the desired name of the new Namespace. |
|
* |
|
*/ |
|
| |
/** |
// |
The constants representing the class names we process |
// Constructor for the InteropProvider control provider |
*/ |
// |
static const CIMName __NAMESPACE_CLASSNAME = CIMName ("__Namespace"); |
InteropProvider::InteropProvider(CIMRepository * rep) : repository(rep), |
static const CIMName CIM_NAMESPACE_CLASSNAME = CIMName ("CIM_Namespace"); |
hostName(System::getHostName()), providerInitialized(false), |
static const CIMName CIM_OBJECTMANAGER_CLASSNAME = CIMName ("CIM_ObjectManager"); |
profileIds(Array<String>()), conformingElements(Array<CIMNameArray>()), |
static const CIMName CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM_CLASSNAME = |
elementNamespaces(Array<CIMNamespaceArray>()) |
CIMName ("CIM_ObjectManagerCommunicationMechanism"); |
|
static const CIMName CIM_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME = |
|
CIMName ("CIM_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 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"; |
|
|
|
|
|
// Defines to serve as the ENUM for class selection |
|
#define __NAMESPACE 1 |
|
#define CIM_NAMESPACE 2 |
|
#define CIM_OBJECTMANAGER 3 |
|
#define CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM 4 |
|
#define CIM_CIMXMLCOMMUNICATIONMECHANISM 5 |
|
|
|
// 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"); |
|
|
|
|
|
//*************************************************************** |
|
// 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 _testKeys(const CIMObjectPath& path) |
|
{ |
|
return true; |
|
} |
|
Boolean _testKeys(const CIMInstance& instance) |
|
{ |
|
return true; |
|
} |
|
|
|
|
|
/* Query the repository for array of all namespacenames |
|
*/ |
|
Array<CIMNamespaceName> InteropProvider::_enumerateNameSpaces() |
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,"InteropProvider::InteropProvider"); |
"InteropProvider::_enumerateNameSpaces()"); |
|
Array<CIMNamespaceName> namespaceNames; |
|
_repository->read_lock(); |
|
| |
|
#ifndef PEGASUS_DISABLE_PERFINST |
try | try |
{ | { |
namespaceNames = _repository->enumerateNameSpaces(); |
initProvider(); |
} | } |
catch(CIMException& e) |
catch(const Exception &) |
{ | { |
_repository->read_unlock(); |
// Provider initialization may fail if the repository is not |
PEG_METHOD_EXIT(); |
// populated |
throw e; |
|
} | } |
catch(Exception& e) |
#endif |
{ |
|
_repository->read_unlock(); |
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
|
} | } |
| |
_repository->read_unlock(); |
// |
|
// 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. |
|
// |
|
CIMInstance InteropProvider::localGetInstance( |
|
const OperationContext & context, |
|
const CIMObjectPath & instanceName, |
|
const CIMPropertyList & propertyList) |
|
{ |
|
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localGetInstance"); |
|
|
|
PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
|
"%s getInstance. instanceName= %s , PropertyList= %s", |
|
thisProvider, |
|
(const char *)instanceName.toString().getCString(), |
|
(const char *)propertyListToString(propertyList).getCString())); |
|
|
|
// 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); |
|
CIMInstance gotInstance = cimomHandle.getInstance( |
|
context, |
|
opNamespace, |
|
instanceName, |
|
false, |
|
false, |
|
false, |
|
propertyList); |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return(namespaceNames); |
return gotInstance; |
} | } |
| |
/* get the CIM_Namespace Class defintion from the repository or |
// Create reference from host, namespace, class components of |
from local static storage. |
// instance name |
@param namespace in which to look for the class. |
CIMObjectPath ref; |
@param name of class to get. |
ref.setHost(instanceName.getHost()); |
@return the CIMClass object |
ref.setClassName(opClass); |
@Exceptions any repository exceptions if class not found. |
ref.setNameSpace(opNamespace); |
*/ |
|
CIMClass InteropProvider::_getClass(const CIMNamespaceName& nameSpace, |
// Enumerate instances for this class. Returns all instances |
const CIMName& className) |
// Note that this returns paths setup and instances already |
{ |
// filtered per the input criteria. |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
Array<CIMInstance> instances = localEnumerateInstances( |
"InteropProvider::_getCIM_NamespaceClass()"); |
context, |
CIMClass myClass; |
ref, |
CDEBUG("Get Class from repository " << className.getString()); |
propertyList); |
if (myClass.isUninitialized()) |
|
|
// deliver a single instance if found. |
|
CIMInstance retInstance; |
|
|
|
bool found = false; |
|
for(Uint32 i = 0, n = instances.size(); i < n; i++) |
{ | { |
_repository->read_lock(); |
CIMObjectPath currentInstRef = instances[i].getPath(); |
try |
currentInstRef.setHost(instanceName.getHost()); |
|
currentInstRef.setNameSpace(instanceName.getNameSpace()); |
|
if(instanceName == currentInstRef) |
{ | { |
myClass = _repository->getClass(_operationNamespace, className ); |
retInstance = instances[i]; |
|
found = true; |
|
break; |
} | } |
catch(CIMException& e) |
|
{ |
|
_repository->read_unlock(); |
|
PEG_METHOD_EXIT(); |
|
throw e; |
|
} | } |
catch(Exception& e) |
|
|
if(!found) |
{ | { |
_repository->read_unlock(); |
cout << "Coule not find instance: " << instanceName.toString() << endl; |
PEG_METHOD_EXIT(); |
|
throw e; |
|
} |
|
_repository->read_unlock(); |
|
} | } |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return myClass; |
return retInstance; |
} | } |
| |
| |
/* Verify that this is one of the legal classnames and |
// |
return indicator which. |
// Local version of enumerateInstances to be used by other functions in the |
@param - Classname |
// provider. Note that this delivers instances as a group rather than one |
@return - Uint32 indicating type |
// at a time. This design point may need to be revisited if this provider |
@Exceptions - throws CIMNotSupportedException if invalid class. |
// is used in environments such that returning segmented responses would have |
*/ |
// significant performance advantages. For now, that doesn't seem to be the |
Uint32 _verifyValidClassInput(const CIMName& className) |
// case. |
|
// |
|
Array<CIMInstance> InteropProvider::localEnumerateInstances( |
|
const OperationContext & context, |
|
const CIMObjectPath & ref, |
|
const CIMPropertyList& propertyList) |
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::_verifyValidClassInput()"); |
"InteropProvider::localEnumerateInstances()"); |
// Verify that ClassName == __Namespace or CIM_Namespace |
const CIMName & className = ref.getClassName(); |
// ATTN: KS Check to determine if equal is case independent |
PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
CDEBUG("Class Name Input = " << className.getString()); |
"%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 (className.equal(__NAMESPACE_CLASSNAME)) |
Array<CIMInstance> instances; |
|
switch(classEnum) |
{ | { |
PEG_METHOD_EXIT(); |
case PG_OBJECTMANAGER: |
return __NAMESPACE; |
{ |
|
instances.append(getObjectManagerInstance()); |
|
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; |
} | } |
|
case PG_COMMMECHANISMFORMANAGER: |
if (className.equal(CIM_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME)) |
|
{ | { |
PEG_METHOD_EXIT(); |
instances = enumCommMechanismForManagerInstances(); |
return CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM; |
break; |
} | } |
|
case PG_NAMESPACE: |
// Last entry, reverse test and returnOK if CIM_Namespace |
|
if (!className.equal(CIM_NAMESPACE_CLASSNAME)) |
|
{ | { |
PEG_METHOD_EXIT(); |
instances = enumNamespaceInstances(); |
throw CIMNotSupportedException |
break; |
(className.getString() + " not supported by Interop Provider"); |
|
} | } |
|
case PG_REGISTEREDPROFILE: |
|
{ |
PEG_METHOD_EXIT(); |
instances = enumRegisteredProfileInstances(); |
return CIM_NAMESPACE; |
break; |
} | } |
|
case PG_REGISTEREDSUBPROFILE: |
/* 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 |
} |
|
case PG_REFERENCEDPROFILE: |
{ | { |
IdentityContainer container = context.get(IdentityContainer::NAME); |
instances = enumReferencedProfileInstances(); |
userName = container.getUserName(); |
break; |
} | } |
catch (...) |
case PG_ELEMENTCONFORMSTOPROFILE: |
{ | { |
userName = String::EMPTY; |
instances = enumElementConformsToProfileInstances(context, |
|
ref.getNameSpace()); |
|
break; |
} | } |
return userName; |
case PG_ELEMENTCONFORMSTOPROFILE_RP_RP: |
|
{ |
|
instances = enumElementConformsToProfileRPRPInstances( |
|
context, |
|
ref.getNameSpace()); |
|
break; |
} | } |
|
case PG_SUBPROFILEREQUIRESPROFILE: |
/* 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; |
|
}; |
|
|
|
*/ |
|
void _buildInstanceCommonKeys(CIMInstance& instance) |
|
{ | { |
|
instances = enumSubProfileRequiresProfileInstances(); |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
break; |
"InteropProvider::_buildInstanceCommonKeys()"); |
|
String SystemCreationClassName = System::getSystemCreationClassName (); |
|
if (SystemCreationClassName == String::EMPTY) |
|
{ |
|
SystemCreationClassName = "CIM_ComputerSystem"; |
|
} |
|
|
|
String SystemName = System::getHostName(); |
|
|
|
instance.addProperty( |
|
(CIMProperty(CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME, |
|
SystemCreationClassName))); |
|
// SystemName |
|
instance.addProperty( |
|
(CIMProperty(CIM_NAMESPACE_PROPERTY_SYSTEMNAME, |
|
SystemName))); |
|
PEG_METHOD_EXIT(); |
|
} | } |
|
case PG_SOFTWAREIDENTITY: |
CIMInstance _buildInstancCIMXMLCommunicationMechanism() |
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
instances = enumSoftwareIdentityInstances(); |
"InteropProvider::_buildInstanceCIMXMLCommunicationMechanism()"); |
break; |
|
|
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); |
|
} | } |
|
case PG_ELEMENTSOFTWAREIDENTITY: |
|
|
CIMInstance _buildInstancCIMObjectCommunicationMechanism() |
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
instances = enumElementSoftwareIdentityInstances(); |
"InteropProvider::_buildInstanceCIMObjectCommunicationMechanism()"); |
break; |
|
|
CIMInstance instance(CIM_CIMXMLCOMMUNICATIONMECHANISM_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) ))); |
|
|
|
//Functional Profiles Supported Property. |
|
Array<Uint16> profiles; |
|
Array<String> profileDescriptions; |
|
CIMValue profileValue(profiles); |
|
CIMValue profileDescriptionsValue(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"); |
|
|
|
instance.addProperty( |
|
(CIMProperty(OM_FUNCTIONALPROFILESSUPPORTED, |
|
profileValue ))); |
|
instance.addProperty( |
|
(CIMProperty(OM_FUNCTIONALPROFILEDESCRIPTIONS, |
|
profileDescriptionsValue ))); |
|
|
|
// Multiple OperationsSupported Property |
|
instance.addProperty( |
|
(CIMProperty(OM_MULTIPLEOPERATIONSSUPPORTED, |
|
Boolean(false) ))); |
|
// AuthenticationMechanismsSupported |
|
|
|
Array<Uint16> authentications; |
|
Array<String> authenticationDescriptions; |
|
CIMValue authenticationValue(authentications); |
|
CIMValue authenticationDescriptionsValue(authenticationDescriptions); |
|
profiles.append(3); profileDescriptions.append("Basic"); |
|
|
|
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); |
|
} | } |
|
case PG_INSTALLEDSOFTWAREIDENTITY: |
String _getObjectManagerName() |
|
{ | { |
return ("PEG_123456789"); |
instances = enumInstalledSoftwareIdentityInstances(); |
|
break; |
} | } |
|
case PG_COMPUTERSYSTEM: |
CIMInstance _buildInstanceCIMObjectManager() |
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
instances.append(getComputerSystemInstance()); |
"InteropProvider::_buildInstanceCIMObjectManager()"); |
break; |
|
|
CIMInstance instance(CIM_OBJECTMANAGER_CLASSNAME); |
|
|
|
_buildInstanceCommonKeys(instance); |
|
|
|
//CreationClassName |
|
instance.addProperty( |
|
(CIMProperty(CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME, |
|
CIM_OBJECTMANAGER_CLASSNAME.getString() ))); |
|
//Name, this CIMObject Manager. |
|
instance.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 |
|
instance.addProperty( |
|
(CIMProperty(OM_GATHERSTATISTICALDATA, |
|
Boolean(gatherStatData) ))); |
|
PEG_METHOD_EXIT(); |
|
return(instance); |
|
} | } |
|
case PG_HOSTEDOBJECTMANAGER: |
/* 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. |
|
*/ |
|
CIMInstance _buildInstanceCIMNamespace(const CIMNamespaceName & nameSpace) |
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
instances.append(getHostedObjectManagerInstance()); |
"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); |
|
} | } |
/* given a namespace name, class and instance build the instance path for a |
case PG_HOSTEDACCESSPOINT: |
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 = enumHostedAccessPointInstances(); |
"InteropProvider::_buildInstancePath()"); |
break; |
|
} |
// get the class CIM_Namespace class to use in building path |
default: |
//CIMNamespaceName thisNamespace = classReference.getNameSpace(); |
|
CIMClass thisClass = _getClass(_operationNamespace, className); |
|
|
|
// XmlWriter::printInstanceElement(instance); |
|
|
|
CIMObjectPath ref = instance.buildPath(thisClass); |
|
|
|
CDEBUG("Built path. path = " << ref.toString() ); |
|
PEG_METHOD_EXIT(); | 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; |
|
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; |
|
CIMValue propertyValue; |
|
|
|
pos = instance.findProperty(keyName); |
|
if (pos == PEG_NOT_FOUND) |
|
{ | { |
throw CIMPropertyNotFoundException |
PEG_METHOD_EXIT(); |
(NAMESPACE_PROPERTYNAME.getString()); |
return false; |
} | } |
|
|
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) |
|
{ |
|
case PG_NAMESPACEINMANAGER: |
|
if(originClassEnum == PG_OBJECTMANAGER) |
{ | { |
throw CIMPropertyNotFoundException |
expectedTargetRole = PROPERTY_DEPENDENT; |
(NAMESPACE_PROPERTYNAME.getString()); |
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 | 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); |
|
tmpInstance = localGetInstance( |
|
context, |
|
objectName, |
|
propertyList); |
|
index = tmpInstance.findProperty("RegisteredName"); |
|
if (index != PEG_NOT_FOUND) |
|
{ |
|
const CIMValue &tmpVal = |
|
tmpInstance.getProperty(index).getValue(); |
|
if (!tmpVal.isNull()) |
|
{ |
|
tmpVal.get(profileName); |
|
} |
|
} |
|
if (String::compareNoCase(profileName, String("SMI-S")) == 0) |
|
{ |
|
expectedTargetRole = |
|
ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT; |
|
expectedOriginRole = |
|
ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD; |
} | } |
|
else |
|
{ |
|
expectedTargetRole = |
|
ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD; |
|
expectedOriginRole = |
|
ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT; |
} | } |
|
break; |
/* generate the full namespace name from the parent and child |
case PG_SUBPROFILEREQUIRESPROFILE: |
components |
if(originClassEnum == PG_REGISTEREDPROFILE) |
@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 |
expectedTargetRole = PROPERTY_DEPENDENT; |
// MUST exist |
expectedOriginRole = PROPERTY_ANTECEDENT; |
// |
} |
CIMNamespaceName fullNamespaceName; |
else if(originClassEnum == PG_REGISTEREDSUBPROFILE) |
|
|
if (isRelativeName) |
|
{ | { |
if (!_isNamespace(namespaceNames, parentNamespaceName)) |
expectedTargetRole = PROPERTY_ANTECEDENT; |
|
expectedOriginRole = PROPERTY_DEPENDENT; |
|
} |
|
break; |
|
case PG_REFERENCEDPROFILE: |
|
if (originClassEnum == PG_REGISTEREDSUBPROFILE) |
{ | { |
throw CIMObjectNotFoundException("Parent namespace does not exist: " |
expectedTargetRole = PROPERTY_ANTECEDENT; |
+ parentNamespaceName.getString()); |
expectedOriginRole = PROPERTY_DEPENDENT; |
} | } |
// Create full namespace name by prepending parentNamespaceName |
else if (originClassEnum == PG_REGISTEREDPROFILE) |
fullNamespaceName = CIMNamespaceName (parentNamespaceName.getString() |
{ |
+ "/" + childNamespaceName.getString()); |
if ((targetProperty.size() != 0) && |
|
(originProperty.size() != 0) && |
|
String::equalNoCase(targetProperty, originProperty)) |
|
{ |
|
return false; |
} | } |
else |
if (targetProperty.size() != 0) |
|
{ |
|
if (!(String::equalNoCase(targetProperty, "Antecedent") || |
|
String::equalNoCase(targetProperty, "Dependent") )) |
{ | { |
fullNamespaceName = parentNamespaceName; |
return false; |
} | } |
return(fullNamespaceName); |
|
|
|
} | } |
|
if (originProperty.size() != 0) |
//*************************************************************************** |
{ |
// The following section is the Instance Operation processors |
if (!(String::equalNoCase(originProperty, "Antecedent") || |
//*************************************************************************** |
String::equalNoCase(originProperty, "Dependent") )) |
// createInstance |
{ |
//*************************************************************************** |
return false; |
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 |
|
Uint32 classEnum = _verifyValidClassInput(instanceReference.getClassName()); |
|
|
|
String userName = _validateUserID(context); |
|
CIMObjectPath newInstanceReference; |
|
|
|
if (classEnum == CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM) |
|
throw CIMNotSupportedException("InteropProvider::createInstance"); |
|
|
|
if (classEnum == CIM_CIMXMLCOMMUNICATIONMECHANISM) |
|
throw CIMNotSupportedException("InteropProvider::createInstance"); |
|
|
|
if (classEnum == CIM_NAMESPACE) |
|
{ |
|
CDEBUG("Create Class from CIM_Namespace"); |
|
Boolean isGood = _testKeys(instanceReference); |
|
String namespaceName; |
|
newNamespaceName = _getKeyValue(myInstance, CIM_NAMESPACE_PROPERTY_NAME); |
|
// ATTN: KS TBD |
|
//Array<CIMKeyBinding> keyBindings; |
|
//keyBindings = _buildKeyBindings(); |
|
//newInstanceReference.set(String::EMPTY, namespaceName, |
|
// CIM_NAMESPACE_CLASSNAME, keyBindings); |
|
//CDEBUG("Create namespace = " << newNamespaceName); |
|
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 |
} |
try |
if (String::equalNoCase(originProperty, "Antecedent") && |
|
targetProperty.size() == 0) |
{ | { |
_repository->createNameSpace(newNamespaceName); |
targetProperty = String("Dependent"); |
|
|
PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
|
"Namespace = " + newNamespaceName.getString() + |
|
" successfully created."); |
|
// ATTN: Add standardlog entry here. |
|
} | } |
catch(CIMException& e) |
if (String::equalNoCase(originProperty, "Dependent") && |
|
targetProperty.size() == 0) |
{ | { |
_repository->write_unlock(); |
targetProperty = String("Antecedent"); |
PEG_METHOD_EXIT(); |
|
throw e; |
|
} | } |
catch(Exception& e) |
if (String::equalNoCase(targetProperty, "Antecedent") && |
|
originProperty.size() == 0) |
{ | { |
_repository->write_unlock(); |
originProperty = String("Dependent"); |
PEG_METHOD_EXIT(); |
|
throw e; |
|
} | } |
|
if (String::equalNoCase(targetProperty, "Dependent") && |
_repository->write_unlock(); |
originProperty.size() == 0) |
|
{ |
// begin processing the request |
originProperty = String("Antecedent"); |
handler.processing(); |
|
|
|
|
|
handler.deliver(newInstanceReference); |
|
|
|
// complete processing the request |
|
handler.complete(); |
|
|
|
PEG_METHOD_EXIT(); |
|
return; |
|
} | } |
|
return true; |
//*************************************************************************** |
} |
// deleteInstance |
break; |
//*************************************************************************** |
case PG_ELEMENTSOFTWAREIDENTITY: |
void InteropProvider::deleteInstance( |
if(originClassEnum == PG_SOFTWAREIDENTITY) |
const OperationContext & context, |
|
const CIMObjectPath & instanceName, |
|
ResponseHandler & handler) |
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::deleteInstance"); |
expectedTargetRole = PROPERTY_DEPENDENT; |
CDEBUG("deleteInstance" << instanceName.toString()); |
expectedOriginRole = PROPERTY_ANTECEDENT; |
CIMNamespaceName childNamespaceName; |
} |
CIMNamespaceName deleteNamespaceName; |
else if(originClassEnum == PG_REGISTEREDPROFILE || |
Boolean isRelativeName; |
originClassEnum == PG_REGISTEREDSUBPROFILE) |
|
|
// Verify that ClassName is correct and get value |
|
Uint32 classEnum = _verifyValidClassInput(instanceName.getClassName()); |
|
|
|
String userName = _validateUserID(context); |
|
|
|
Array<CIMNamespaceName> namespaceNames; |
|
namespaceNames = _enumerateNameSpaces(); |
|
|
|
if (classEnum == CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM) |
|
throw CIMNotSupportedException("InteropProvider::createInstance"); |
|
|
|
if (classEnum == CIM_CIMXMLCOMMUNICATIONMECHANISM) |
|
throw CIMNotSupportedException("InteropProvider::createInstance"); |
|
|
|
if (classEnum == CIM_NAMESPACE) |
|
{ | { |
_testKeys(instanceName); |
expectedTargetRole = PROPERTY_ANTECEDENT; |
deleteNamespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME); |
expectedOriginRole = PROPERTY_DEPENDENT; |
CDEBUG("Delete namespace = " << deleteNamespaceName ); |
|
} | } |
else // Procesing for __namespace |
break; |
|
case PG_INSTALLEDSOFTWAREIDENTITY: |
|
if(originClassEnum == PG_SOFTWAREIDENTITY) |
{ | { |
|
expectedTargetRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM; |
_getKeyValue(instanceName, childNamespaceName, isRelativeName); |
expectedOriginRole = |
CIMNamespaceName parentNamespaceName = instanceName.getNameSpace(); |
INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE; |
|
|
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); |
|
} | } |
|
else if(originClassEnum == PG_COMPUTERSYSTEM) |
// ATTN: KS Why THis??? |
|
if (deleteNamespaceName.equal (ROOTNS)) |
|
{ | { |
throw CIMNotSupportedException("root namespace cannot be deleted."); |
expectedTargetRole = |
|
INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE; |
|
expectedOriginRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM; |
} | } |
|
break; |
_repository->deleteNameSpace(deleteNamespaceName); |
case PG_HOSTEDACCESSPOINT: |
|
if(originClassEnum == PG_COMPUTERSYSTEM) |
PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
{ |
"Namespace = " + deleteNamespaceName.getString() + |
expectedTargetRole = PROPERTY_DEPENDENT; |
" successfully deleted."); |
expectedOriginRole = PROPERTY_ANTECEDENT; |
// ATTN: Log entry for deletion. |
|
handler.processing(); |
|
|
|
// complete processing the request |
|
handler.complete(); |
|
|
|
PEG_METHOD_EXIT(); |
|
return ; |
|
} | } |
|
else if(originClassEnum == PG_CIMXMLCOMMUNICATIONMECHANISM) |
//*************************************************************************** |
|
// 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"); |
expectedTargetRole = PROPERTY_ANTECEDENT; |
|
expectedOriginRole = PROPERTY_DEPENDENT; |
// Verify that ClassName is correct and get value |
} |
Uint32 classEnum = _verifyValidClassInput(instanceName.getClassName()); |
case PG_HOSTEDOBJECTMANAGER: |
|
if(originClassEnum == PG_COMPUTERSYSTEM) |
String userName = _validateUserID(context); |
|
|
|
// 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_OBJECTMANAGER) |
if (classEnum == CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM) |
|
{ | { |
CIMInstance instance = _buildInstancCIMObjectCommunicationMechanism(); |
expectedTargetRole = PROPERTY_ANTECEDENT; |
handler.deliver(instance); |
expectedOriginRole = PROPERTY_DEPENDENT; |
handler.complete(); |
} |
PEG_METHOD_EXIT(); |
break; |
return; |
default: |
|
break; |
} | } |
| |
|
// |
if (classEnum == CIM_CIMXMLCOMMUNICATIONMECHANISM) |
// 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()) |
{ | { |
CIMInstance instance = _buildInstancCIMXMLCommunicationMechanism(); |
|
handler.deliver(instance); |
|
handler.complete(); |
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return; |
return false; |
|
|
} | } |
| |
// Get List of namespaces |
if(targetProperty.size() == 0) |
Array<CIMNamespaceName> namespaceNames; |
|
namespaceNames = _enumerateNameSpaces(); |
|
CIMInstance instance; |
|
|
|
|
|
if (classEnum == CIM_NAMESPACE) |
|
{ | { |
// Not clear what we have to take into account here. |
targetProperty = expectedTargetRole.getString(); |
// 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 |
else if(!expectedTargetRole.equal(targetProperty)) |
{ | { |
CIMNamespaceName childNamespaceName; |
PEG_METHOD_EXIT(); |
CIMNamespaceName getNamespaceName; |
return false; |
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()); |
|
|
|
|
|
getNamespaceName = _generateFullNamespaceName( |
|
namespaceNames, parentNamespaceName, |
|
childNamespaceName, isRelativeName); |
|
| |
// exception if not valid namespace |
if(originProperty.size() == 0) |
if (!_isNamespace(namespaceNames, getNamespaceName)) |
|
{ | { |
throw CIMObjectNotFoundException("Namespace deos not exist: " |
originProperty = expectedOriginRole.getString(); |
+ getNamespaceName.getString()); |
|
} | } |
PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
else if(!expectedOriginRole.equal(originProperty)) |
"Namespace = " + getNamespaceName.getString() + |
{ |
" successfully found."); |
PEG_METHOD_EXIT(); |
|
return false; |
//Set name of class |
|
CIMInstance instance(__NAMESPACE_CLASSNAME); |
|
|
|
// |
|
// construct the instance |
|
// |
|
instance.addProperty(CIMProperty(NAMESPACE_PROPERTYNAME, |
|
isRelativeName?childNamespaceName.getString(): |
|
parentNamespaceName.getString())); |
|
//instance.setPath(instanceName); |
|
} | } |
| |
handler.deliver(instance); |
|
|
|
// complete processing the request |
|
handler.complete(); |
|
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return ; |
return true; |
} | } |
| |
//*************************************************************************** |
// |
// enumerateInstances |
// Local version of the references operation. It validates the input |
//*************************************************************************** |
// parameters, setting the origin and target property values if not set |
void InteropProvider::enumerateInstances( |
// 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 OperationContext & context, |
const CIMObjectPath & ref, |
const CIMObjectPath & objectName, |
const Boolean includeQualifiers, |
const CIMName & assocClass, |
const Boolean includeClassOrigin, |
String & originProperty, |
|
String & targetProperty, |
const CIMPropertyList& propertyList, | const CIMPropertyList& propertyList, |
InstanceResponseHandler & handler) |
const CIMName & targetClass) |
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::enumerateInstances()"); |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
CDEBUG("EnumerateInstances"); |
"InteropProvider::localReferences()"); |
// Verify that ClassName is correct and get value |
|
Uint32 classEnum = _verifyValidClassInput(ref.getClassName()); |
Array<CIMInstance> instances; |
|
CIMName originClass = objectName.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; |
|
} |
|
| |
if (classEnum == CIM_OBJECTMANAGERCOMMUNICATIONMECHANISM) |
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()) |
{ | { |
CIMInstance instance = _buildInstancCIMObjectCommunicationMechanism(); |
targetNamespace = originNamespace; |
handler.deliver(instance); |
targetPath.setNameSpace(targetNamespace); |
handler.complete(); |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} | } |
|
if(targetNamespace != lastTargetNamespace) |
|
|
if (classEnum == CIM_CIMXMLCOMMUNICATIONMECHANISM) |
|
{ | { |
CIMInstance instance = _buildInstancCIMXMLCommunicationMechanism(); |
try |
handler.deliver(instance); |
{ |
handler.complete(); |
targetSubclasses = repository->enumerateClassNames( |
PEG_METHOD_EXIT(); |
targetNamespace, targetClass, true); |
return; |
} |
|
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; |
} | } |
| |
// ATTN: Fix this up. should not be here. |
// Try to find the targetPath's class in the search space |
CIMNamespaceName parentNamespaceName = ref.getNameSpace(); |
CIMName targetPathClass = targetPath.getClassName(); |
|
for(Uint32 j = 0, m = targetSubclasses.size(); j < m; ++j) |
// 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."); |
|
// Build response objects based on class requested |
|
for (Uint32 i = 0; i < namespaceNames.size(); i++) |
|
{ | { |
CDEBUG("For namespace' " << namespaceNames[i].getString()); |
if(targetPathClass == targetSubclasses[j]) |
CDEBUG("Evaluate ClassEnum" << classEnum); |
|
if (classEnum == CIM_NAMESPACE) |
|
{ | { |
CDEBUG("Evaluate CIM_Namespace" << classEnum); |
instances.append(currentInstance); |
// Create a valid CIM_Namespace Instance |
break; |
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 |
else |
// the only property is name. |
|
if (_isChild(parentNamespaceName, namespaceNames[i])) |
|
{ | { |
CIMInstance instance(__NAMESPACE_CLASSNAME); |
instances.append(currentInstance); |
instance.addProperty( |
} |
(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(); | 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, |
|
CIMClass& returnedClass) |
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | 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(true,true, |
Uint32 classEnum = _verifyValidClassInput(classReference.getClassName()); |
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(); | 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(); |
|
|
|
PEG_METHOD_EXIT(); |
|
} | } |
| |
|
// Cache this class definition for use later. |
|
profileCapabilitiesClass = repository->getClass( |
|
PEGASUS_NAMESPACENAME_INTEROP, |
|
PEGASUS_CLASSNAME_PG_PROVIDERPROFILECAPABILITIES, |
|
false, true, false); |
| |
//************************************************************** |
providerClassifications.append(Uint16(5)); // "Instrumentation" |
//************************************************************** |
|
// Association Functions |
|
//************************************************************** |
|
//************************************************************** |
|
| |
void InteropProvider::associators( |
// |
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, |
// |
const Boolean includeQualifiers, |
Array<CIMNamespaceName> namespaceNames = |
const Boolean includeClassOrigin, |
repository->enumerateNameSpaces(); |
const CIMPropertyList & propertyList, |
// get the PG_ElementConformstoProfile class without the qualifiers |
ObjectResponseHandler & handler) |
// 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) |
|
{ |
|
// Check if the PG_ElementConformsToProfile class is present |
|
CIMNamespaceName & currentNamespace = namespaceNames[i]; |
|
CIMClass tmpCimClass; |
|
CIMClass tmpPgClass; |
|
CIMClass tmpPgProfileClass; |
|
try |
{ | { |
throw CIMNotSupportedException("AssociationProvider::associators"); |
// 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::associatorNames( |
|
const OperationContext & context, |
|
const CIMObjectPath & objectName, |
|
const CIMName & associationClass, |
|
const CIMName & resultClass, |
|
const String & role, |
|
const String & resultRole, |
|
ObjectPathResponseHandler & handler) |
|
{ | { |
throw CIMNotSupportedException("AssociationProvider::associatorNames"); |
|
} | } |
|
try |
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"); |
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? |
} | } |
| |
void InteropProvider::referenceNames( |
// If the CIM_ElementConformsToProfile class is present, but |
const OperationContext & context, |
// the PG_ElementConformsToProfile or PG_RegisteredProfile |
const CIMObjectPath & objectName, |
// class is not, then add it to that namespace. |
const CIMName & resultClass, |
// |
const String & role, |
// Note that we don't have to check for the |
ObjectPathResponseHandler & handler) |
// CIM_RegisteredProfile class because if the |
|
// CIM_ElementConformsToProfile class is present, the |
|
// CIM_RegisteredProfile class must also be present. |
|
if(!tmpCimClass.isUninitialized()) |
{ | { |
throw CIMNotSupportedException("AssociationProvider::referenceNames"); |
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); |
|
} |
|
} |
|
} |
|
|
|
// Now cache the Registration info used for ElementConformsToProfile |
|
cacheProfileRegistrationInfo(); |
|
|
|
providerInitialized = true; |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
// END_OF_FILE |
// END OF FILE |