version 1.10, 2004/09/01 21:03:01
|
version 1.36, 2005/05/24 10:42:51
|
|
|
//%2003//////////////////////////////////////////////////////////////////////// |
//%2005//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Company, L. P., IBM Corp., 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.; | // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; |
// IBM Corp.; EMC Corporation, The Open Group. | // 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. |
// | // |
// 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 |
|
|
// (carolann_graves@hp.com) | // (carolann_graves@hp.com) |
// Karl Schopmeyer - Created Cim_Namespace capabilities. | // Karl Schopmeyer - Created Cim_Namespace capabilities. |
// Karl Schopmeyer - added objectmanager and communication classes | // Karl Schopmeyer - added objectmanager and communication classes |
|
// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3194 |
|
// David Dillard, VERITAS Software Corp. |
|
// (david.dillard@veritas.com) |
|
// Aruran, IBM (ashanmug@in.ibm.com) for Bug# 3659 |
// | // |
//%//////////////////////////////////////////////////////////////////////////// | //%//////////////////////////////////////////////////////////////////////////// |
| |
|
|
// CIMObjectManager | // CIMObjectManager |
// CIM_ObjectManagerCommunicationMechanism | // CIM_ObjectManagerCommunicationMechanism |
// CIM_CIMXMLCommunicationMechanism | // CIM_CIMXMLCommunicationMechanism |
// CIM_ProtocolAdapter |
// CIM_ProtocolAdapter (Note: Removed because deprecated class in cim 2.9) |
// CIM_Namespace (Effective Pegasus 2.4 we use PG_Namespace which | // CIM_Namespace (Effective Pegasus 2.4 we use PG_Namespace which |
// is a subclass of CIM_Namespace with additional properties for | // is a subclass of CIM_Namespace with additional properties for |
// shared namespaces. | // shared namespaces. |
|
|
// including: | // including: |
// CIM_NamespaceInManager | // CIM_NamespaceInManager |
// ... | // ... |
|
// This is a control provider and as such uses the Tracer functions |
// CIM Version: Interop Provider was written for CIM 2.7 adn 2.8. |
// for data and function traces. Since we do not expect high volume |
// Note: all 2.8 functions are controlled by a flag and can be |
// use we added a number of traces to help diagnostics. |
// disabled. |
|
/////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////// |
|
/* TODO LIST: |
|
1. Finish the association functions |
| |
/* TODO: 12 Feb 2004 |
2. UUID generation should become a system function since it will be used |
Add the association functions |
|
UUID generation should become a system function since it will be used |
|
by many providers, etc. as part of id generation. | by many providers, etc. as part of id generation. |
|
|
|
3. Review the key parameters on create, etc. to be sort out which are |
|
required from user and which we can supply. I think we are asking too |
|
much of the user right now. |
*/ | */ |
| |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
|
|
#include <Pegasus/Common/StatisticalData.h> | #include <Pegasus/Common/StatisticalData.h> |
#include <Pegasus/Common/HashTable.h> | #include <Pegasus/Common/HashTable.h> |
| |
//#include <sstream> |
|
//#include <string> |
|
| |
#include <stdlib.h> | #include <stdlib.h> |
| |
|
|
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
#define CDEBUG(X) | #define CDEBUG(X) |
|
#define LDEBUG() |
//#define CDEBUG(X) PEGASUS_STD(cout) << "InteropProvider " << X << PEGASUS_STD(endl) | //#define CDEBUG(X) PEGASUS_STD(cout) << "InteropProvider " << X << PEGASUS_STD(endl) |
//#define CDEBUG(X) Logger::put (Logger::DEBUG_LOG, "InteropProvider", Logger::INFORMATION, "$0", X) |
//#define LDEBUG(X) Logger::put (Logger::DEBUG_LOG, "InteropProvider", Logger::TRACE, "$0", X) |
//#define CDEBUG(X) {std::stringstream ss; std::string r;ss << X;ss>>r; PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, r)} |
|
|
|
| |
//************************************************************************** | //************************************************************************** |
// | // |
|
|
static const CIMName OM_DESCRIPTIONPROPERTY = | static const CIMName OM_DESCRIPTIONPROPERTY = |
CIMName("Description"); | CIMName("Description"); |
| |
|
|
// Property Names for ObjectManagerCommunicationMechanism Class | // Property Names for ObjectManagerCommunicationMechanism Class |
static const CIMName OM_COMMUNICATIONMECHANISM = | static const CIMName OM_COMMUNICATIONMECHANISM = |
CIMName ("CommunicationMechanism"); | CIMName ("CommunicationMechanism"); |
|
|
CIMName ("IsShareable"); | CIMName ("IsShareable"); |
static const CIMName PG_NAMESPACE_PROPERTY_PARENTNAMESPACE = | static const CIMName PG_NAMESPACE_PROPERTY_PARENTNAMESPACE = |
CIMName ("ParentNamespace"); | CIMName ("ParentNamespace"); |
|
static const CIMName PG_NAMESPACE_PROPERTY_NAME = |
|
CIMName ("Name"); |
| |
// Defines to serve as the ENUM for class selection for instance | // Defines to serve as the ENUM for class selection for instance |
// operations. | // operations. |
|
|
//__NAMESPACE = 1, | //__NAMESPACE = 1, |
PG_NAMESPACE = 1, | PG_NAMESPACE = 1, |
CIM_OBJECTMANAGER = 2, | CIM_OBJECTMANAGER = 2, |
PG_CIMXMLCOMMUNICATIONMECHANISM = 3 |
PG_CIMXMLCOMMUNICATIONMECHANISM = 3, |
|
CIM_NAMESPACEINMANAGERINST =4, |
|
CIM_COMMMECHANISMFORMANAGERINST=5, |
|
CIM_NAMESPACEINMANAGER=6 |
}; | }; |
| |
enum targetAssocClass{ | enum targetAssocClass{ |
CIM_NAMESPACEINMANAGER =1, |
CIM_NAMESPACEINMANAGERASSOC = 1, |
CIM_COMMMECHANISMFORMANAGER=2 |
CIM_COMMMECHANISMFORMANAGERASSOC=2 |
}; | }; |
| |
|
|
|
//************************************************************* |
|
// Constructor |
|
//********************************************************** |
|
InteropProvider::InteropProvider(CIMRepository* repository) |
|
{ |
|
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,"InteropProvider::InteropProvider"); |
|
_repository = repository; |
|
|
|
//*********************************************** |
|
// This is a tempory fix untill there is a method created for the InteropProvider to |
|
// do it's inaliaztion work. This fix sets StatisticalData::CopyGSD, enabling the |
|
//statistical gathering function. |
|
Array<CIMInstance> instance = repository->enumerateInstances(CIMNamespaceName("root/cimv2"), CIMName ("CIM_ObjectManager")); |
|
|
|
if(instance.size() > 0) |
|
{ |
|
Boolean output = false; |
|
Uint32 pos; |
|
if ((pos = instance[0].findProperty(CIMName("GatherStatisticalData"))) != PEG_NOT_FOUND) |
|
{ |
|
CIMConstProperty p1 = instance[0].getProperty(pos); |
|
if (p1.getType() == CIMTYPE_BOOLEAN) |
|
{ |
|
CIMValue v1 = p1.getValue(); |
|
if (!v1.isNull()) |
|
{ |
|
v1.get(output); |
|
if (v1 == true) |
|
{ |
|
StatisticalData* sd = StatisticalData::current(); |
|
sd->setCopyGSD(true); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
//******************************************* end of temporary fix |
|
PEG_METHOD_EXIT(); |
|
} |
|
|
|
|
|
|
//*************************************************************** | //*************************************************************** |
// Provider Utility Functions | // Provider Utility Functions |
//*************************************************************** | //*************************************************************** |
/* |
|
void _removeQualifiers(CIMProperty& p) |
|
{ |
|
| |
Uint32 count; |
String _showBool(Boolean x) |
while((count = p.getQualifierCount()) > 0) |
|
p.removeQualifier(count - 1); |
|
} |
|
void _removeQualifiers(CIMInstance& cimInstance) |
|
{ | { |
// remove qualifiers of the class |
return(x? "true" : "false"); |
Uint32 count; |
} |
while((count = cimInstance.getQualifierCount()) > 0) |
|
cimInstance.removeQualifier(count - 1); |
|
| |
// remove qualifiers from the properties |
static String _toStringPropertyList(const CIMPropertyList& pl) |
for (Uint32 i = 0; i < cimInstance.getPropertyCount(); i++) |
{ |
|
String tmp; |
|
for (Uint32 i = 0; i < pl.size() ; i++) |
{ | { |
_removeQualifiers(cimInstance.getProperty(i)); |
if (i > 0) |
|
tmp.append(", "); |
|
tmp.append(pl[i].getString()); |
} | } |
|
return(tmp); |
|
} |
|
|
|
static String _showPropertyList(const CIMPropertyList& pl) |
|
{ |
|
if (pl.isNull()) |
|
return("NULL"); |
|
|
|
String tmp; |
|
|
|
tmp.append((pl.size() == 0) ? "Empty" : _toStringPropertyList(pl)); |
|
return(tmp); |
} | } |
*/ |
|
| |
/** get one string property from an instance. Note that these functions simply | /** get one string property from an instance. Note that these functions simply |
return the default value if the property cannot be found or is of the wrong | return the default value if the property cannot be found or is of the wrong |
|
|
} | } |
return(output); | return(output); |
} | } |
|
|
/** get Host IP address from host name. If the | /** get Host IP address from host name. If the |
host name is not provided, uses internal function. | host name is not provided, uses internal function. |
If everything fails, gets the definition normally | If everything fails, gets the definition normally |
|
|
*/ | */ |
String _getHostAddress(String hostName) | String _getHostAddress(String hostName) |
{ | { |
// set default address |
String ipAddress; |
String ipAddress("127.0.0.1"); |
|
| |
if (hostName == String::EMPTY) | if (hostName == String::EMPTY) |
hostName = System::getHostName(); | hostName = System::getHostName(); |
| |
struct hostent * phostent; |
if ((ipAddress = System::getHostIP(hostName)) == String::EMPTY) |
struct in_addr inaddr; |
|
|
|
if ((phostent = ::gethostbyname((const char *)hostName.getCString())) != NULL) |
|
{ | { |
::memcpy( &inaddr, phostent->h_addr,4); |
// set default address if everything else failed |
ipAddress = ::inet_ntoa( inaddr ); |
ipAddress = String("127.0.0.1"); |
} | } |
return ipAddress; | return ipAddress; |
} | } |
| |
Array<String> _getFunctionalProfiles(Array<Uint16> profiles) |
Array<String> _getFunctionalProfiles(Array<Uint16> & profiles) |
{ | { |
Array<String> profileDescriptions; | Array<String> profileDescriptions; |
profiles.append(2); profileDescriptions.append("Basic Read"); | profiles.append(2); profileDescriptions.append("Basic Read"); |
|
|
{ | { |
return true; | return true; |
} | } |
|
|
Boolean _validateProperties(const CIMInstance& instance) | Boolean _validateProperties(const CIMInstance& instance) |
{ | { |
return true; | return true; |
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return(true); | return(true); |
} | } |
|
|
Boolean _validateRequiredProperty(const CIMObjectPath& objectPath, | Boolean _validateRequiredProperty(const CIMObjectPath& objectPath, |
const CIMName& propertyName, | const CIMName& propertyName, |
const String value) | const String value) |
|
|
@return - Uint32 indicating type | @return - Uint32 indicating type |
@Exceptions - throws CIMNotSupportedException if invalid class. | @Exceptions - throws CIMNotSupportedException if invalid class. |
*/ | */ |
targetClass _verifyValidClassInput(const CIMName& className) |
static targetClass _verifyValidClassInput(const CIMName& className) |
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::_verifyValidClassInput"); | "InteropProvider::_verifyValidClassInput"); |
|
|
if (className.equal(PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME)) | if (className.equal(PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME)) |
return PG_CIMXMLCOMMUNICATIONMECHANISM; | return PG_CIMXMLCOMMUNICATIONMECHANISM; |
| |
|
if (className.equal(CIM_NAMESPACEINMANAGER_CLASSNAME)) |
|
return CIM_NAMESPACEINMANAGER; |
|
|
// Last entry, reverse test and return OK if PG_Namespace | // Last entry, reverse test and return OK if PG_Namespace |
// Note: Changed to PG_Namespace for CIM 2.4 | // Note: Changed to PG_Namespace for CIM 2.4 |
if (!className.equal(PG_NAMESPACE_CLASSNAME)) | if (!className.equal(PG_NAMESPACE_CLASSNAME)) |
|
|
return PG_NAMESPACE; | return PG_NAMESPACE; |
} | } |
| |
targetAssocClass _verifyValidAssocClassInput(const CIMName& className) |
static targetAssocClass _verifyValidAssocClassInput(const CIMName& className) |
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::_verifyValidAssocClassInput"); | "InteropProvider::_verifyValidAssocClassInput"); |
if (className.equal(CIM_NAMESPACEINMANAGER_CLASSNAME)) | if (className.equal(CIM_NAMESPACEINMANAGER_CLASSNAME)) |
return CIM_NAMESPACEINMANAGER; |
return CIM_NAMESPACEINMANAGERASSOC; |
|
|
// Last entry, reverse test and return OK if CIM_CommMech.... | // Last entry, reverse test and return OK if CIM_CommMech.... |
if (!className.equal(CIM_COMMMECHANISMFORMANAGER_CLASSNAME)) | if (!className.equal(CIM_COMMMECHANISMFORMANAGER_CLASSNAME)) |
throw CIMNotSupportedException | throw CIMNotSupportedException |
(className.getString() + " not supported by Interop Provider"); | (className.getString() + " not supported by Interop Provider"); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return CIM_COMMMECHANISMFORMANAGER; |
return CIM_COMMMECHANISMFORMANAGERASSOC; |
} | } |
| |
|
|
/* validate the authorization of the user name against the namespace. | /* validate the authorization of the user name against the namespace. |
*/ | */ |
String _validateUserID(const OperationContext & context) | String _validateUserID(const OperationContext & context) |
|
|
return userName; | return userName; |
} | } |
| |
/** set the value of a property defined by property name in the instance provided. |
/** Set the value of a property defined by property name in the instance provided. |
Sets a String into the value field unless the property name cannot be found. | Sets a String into the value field unless the property name cannot be found. |
If the property cannot be found, it simply returns. | If the property cannot be found, it simply returns. |
ATTN: This function does not pass an error back if property not found. | ATTN: This function does not pass an error back if property not found. |
|
|
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::_fixInstanceCommonKeys()"); | "InteropProvider::_fixInstanceCommonKeys()"); |
String SystemCreationClassName = System::getSystemCreationClassName (); | String SystemCreationClassName = System::getSystemCreationClassName (); |
if (SystemCreationClassName == String::EMPTY) |
|
{ |
|
//Attn: Get this globally. For now This in place because global is often Empty |
|
SystemCreationClassName = "CIM_ComputerSystem"; |
|
} |
|
| |
_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,SystemCreationClassName); | _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,SystemCreationClassName); |
| |
// Add property SystemName | // Add property SystemName |
| |
_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMNAME,System::getHostName()); |
_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMNAME,System::getFullyQualifiedHostName()); |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
} | } |
| |
|
|
/** builds one instance of the class named className. Gets Class defintion and f | /** builds one instance of the class named className. Gets Class defintion and f |
fills in the correct properties from the class. This requires a repository | fills in the correct properties from the class. This requires a repository |
getclass request for each instance built. The skeleton is built by | getclass request for each instance built. The skeleton is built by |
|
|
//CreationClassName | //CreationClassName |
_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME.getString()); | _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME.getString()); |
| |
//Name, this CommunicationMechanism. |
//Name, this CommunicationMechanism. We need to make it unique. To do this |
_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME, PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME.getString()); |
// we simply append the commtype to the classname since we have max of two right |
|
// now. |
|
_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME, (String("PEGASUSCOMM") + namespaceType)); |
| |
// CommunicationMechanism Property |
// CommunicationMechanism Property - Force to 2. |
_setPropertyValue(instance, OM_COMMUNICATIONMECHANISM, Uint16(2)); | _setPropertyValue(instance, OM_COMMUNICATIONMECHANISM, Uint16(2)); |
| |
//Functional Profiles Supported Property. | //Functional Profiles Supported Property. |
|
|
Array<Uint16> authentications; | Array<Uint16> authentications; |
Array<String> authenticationDescriptions; | Array<String> authenticationDescriptions; |
| |
|
// Note that we have fixed authentication here. |
authentications.append(3); authenticationDescriptions.append("Basic"); | authentications.append(3); authenticationDescriptions.append("Basic"); |
| |
_setPropertyValue(instance, OM_AUTHENTICATIONMECHANISMSSUPPORTED, authentications); | _setPropertyValue(instance, OM_AUTHENTICATIONMECHANISMSSUPPORTED, authentications); |
|
|
| |
_setPropertyValue(instance, OM_VERSION, CIMXMLProtocolVersion); | _setPropertyValue(instance, OM_VERSION, CIMXMLProtocolVersion); |
| |
|
// Obsolete function |
_setPropertyValue(instance, "namespaceType", namespaceType); | _setPropertyValue(instance, "namespaceType", namespaceType); |
| |
_setPropertyValue(instance, "IPAddress", IPAddress); | _setPropertyValue(instance, "IPAddress", IPAddress); |
|
|
ATTN: Probably should get rid of the local parameter since | ATTN: Probably should get rid of the local parameter since |
this is used so infrequently, waste of space. | this is used so infrequently, waste of space. |
*/ | */ |
Boolean InteropProvider::_getInstanceCIMObjectManager( |
Boolean InteropProvider::_getInstanceFromRepositoryCIMObjectManager( |
|
CIMInstance& rtnInstance, |
const Boolean includeQualifiers, | const Boolean includeQualifiers, |
const Boolean includeClassOrigin, | const Boolean includeClassOrigin, |
const CIMPropertyList& propertyList) | const CIMPropertyList& propertyList) |
{ | { |
|
|
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::_getInstanceCIMObjectManager"); | "InteropProvider::_getInstanceCIMObjectManager"); |
// If there is already an instance of this class local use it. |
|
if (!instanceOfCIMObjectManager.isUninitialized()) |
|
{ |
|
PEG_METHOD_EXIT(); |
|
return(true); |
|
} |
|
// Try to get persistent instance from repository | // Try to get persistent instance from repository |
Array<CIMInstance> instances; | Array<CIMInstance> instances; |
try | try |
|
|
CIM_OBJECTMANAGER_CLASSNAME, true, false, includeQualifiers, | CIM_OBJECTMANAGER_CLASSNAME, true, false, includeQualifiers, |
includeClassOrigin, propertyList); | includeClassOrigin, propertyList); |
| |
CDEBUG("_buildInstanceCIMOBJMGR Found Instance in repository " << instances.size() ); |
CDEBUG("_getInstancefrom... " << instances.size()); |
|
|
if (instances.size() >= 1) | if (instances.size() >= 1) |
{ | { |
// set this instance into global variable. | // set this instance into global variable. |
instanceOfCIMObjectManager = instances[0]; |
rtnInstance = instances[0]; |
| |
// log entry if there is more than one instance. | // log entry if there is more than one instance. |
// Some day we may support multiple entries to see other CIMOMs but | // Some day we may support multiple entries to see other CIMOMs but |
|
|
Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION, | Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION, |
"Error. Multiple definitons of : $0", CIM_OBJECTMANAGER_CLASSNAME.getString()); | "Error. Multiple definitons of : $0", CIM_OBJECTMANAGER_CLASSNAME.getString()); |
} | } |
|
CDEBUG("getInstanceFromRepository returning true"); |
return(true); | return(true); |
} | } |
else | else |
|
{ |
|
CDEBUG("getInstanceFromRepository returning false"); |
return(false); | return(false); |
} | } |
catch(CIMException& e) |
} |
|
catch(const CIMException&) |
{ | { |
Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION, | Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION, |
"Error. Cannot access $0 in repository", CIM_OBJECTMANAGER_CLASSNAME.getString()); | "Error. Cannot access $0 in repository", CIM_OBJECTMANAGER_CLASSNAME.getString()); |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
throw; |
} | } |
catch(Exception& e) |
catch(const Exception&) |
{ | { |
Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION, | Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION, |
"Error. Cannot access $0 in repository", CIM_OBJECTMANAGER_CLASSNAME.getString()); | "Error. Cannot access $0 in repository", CIM_OBJECTMANAGER_CLASSNAME.getString()); |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
throw; |
} | } |
} | } |
| |
|
|
/** build an instance of the CIM_ObjectManager class filling out | /** build an instance of the CIM_ObjectManager class filling out |
the required properties |
the required properties if one does not already exist in the |
|
repository. This function will either return an instance |
|
or throw an exception. |
@param includeQualifiers Boolean | @param includeQualifiers Boolean |
@param includeClassOrigin Boolean | @param includeClassOrigin Boolean |
@param propertylist CIMPropertyList | @param propertylist CIMPropertyList |
|
|
@exception repository instances if exception to enumerateInstances | @exception repository instances if exception to enumerateInstances |
for this class. | for this class. |
*/ | */ |
CIMInstance InteropProvider::_buildInstanceCIMObjectManager( |
CIMInstance InteropProvider::_getInstanceCIMObjectManager( |
const Boolean includeQualifiers, | const Boolean includeQualifiers, |
const Boolean includeClassOrigin, | const Boolean includeClassOrigin, |
const CIMPropertyList& propertyList) | const CIMPropertyList& propertyList) |
|
|
"InteropProvider::_buildInstanceCIMObjectManager"); | "InteropProvider::_buildInstanceCIMObjectManager"); |
| |
// Try to get the current object. If true then it is already created. | // Try to get the current object. If true then it is already created. |
if (_getInstanceCIMObjectManager(includeQualifiers,includeClassOrigin,propertyList)) |
CIMInstance instance; |
|
if (!_getInstanceFromRepositoryCIMObjectManager(instance, includeQualifiers,includeClassOrigin,propertyList)) |
{ | { |
PEG_METHOD_EXIT(); |
|
return(instanceOfCIMObjectManager); |
|
} |
|
// | // |
// No instance in the repository. Build new instance and save it. | // No instance in the repository. Build new instance and save it. |
// | // |
CIMInstance instance = _buildInstanceSkeleton(CIM_OBJECTMANAGER_CLASSNAME); |
CDEBUG("Creating New instance of CIMOBjectManager"); |
|
instance = _buildInstanceSkeleton(CIM_OBJECTMANAGER_CLASSNAME); |
| |
_fixInstanceCommonKeys(instance); | _fixInstanceCommonKeys(instance); |
| |
_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,CIM_OBJECTMANAGER_CLASSNAME.getString()); | _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,CIM_OBJECTMANAGER_CLASSNAME.getString()); |
|
|
_setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME,buildObjectManagerName()); | _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME,buildObjectManagerName()); |
|
|
_setPropertyValue(instance, CIMName("ElementName"), String("Pegasus")); | _setPropertyValue(instance, CIMName("ElementName"), String("Pegasus")); |
| |
// | // |
|
|
char * envDescription; | char * envDescription; |
envDescription = getenv("PEGASUS_CIMOM_DESCRIPTION"); | envDescription = getenv("PEGASUS_CIMOM_DESCRIPTION"); |
| |
description = (envDescription) ? |
description = (envDescription) ? envDescription : |
envDescription : |
String(PEGASUS_PRODUCT_NAME) + " Version " + |
"Pegasus " + String(PEGASUS_NAME) + "Version " + String(PEGASUS_VERSION); |
String(PEGASUS_PRODUCT_VERSION); |
| |
_setPropertyValue(instance, CIMName("Description"), description); | _setPropertyValue(instance, CIMName("Description"), description); |
| |
|
|
// gathering function dynamically. We simply get the correct value | // gathering function dynamically. We simply get the correct value |
// and call the internal method to set it each time this object is | // and call the internal method to set it each time this object is |
// built. | // built. |
#ifdef PEGASUS_HAS_PERFINST |
#ifndef PEGASUS_DISABLE_PERFINST |
StatisticalData* sd = StatisticalData::current(); | StatisticalData* sd = StatisticalData::current(); |
sd->setCopyGSD(gatherStatDataFlag); | sd->setCopyGSD(gatherStatDataFlag); |
#endif | #endif |
| |
// write the instance to the repository |
// write instance to the repository |
CIMObjectPath instancePath; | CIMObjectPath instancePath; |
// Add the instance path to this if necessary ATTN ATTN: | // Add the instance path to this if necessary ATTN ATTN: |
try | try |
{ | { |
|
CDEBUG("Create Instance for CIM_ObjectManager"); |
instancePath = _repository->createInstance(_operationNamespace, | instancePath = _repository->createInstance(_operationNamespace, |
instance ); | instance ); |
} | } |
catch(CIMException& e) |
catch(const CIMException&) |
{ | { |
// ATTN: KS generate log error if this not possible | // ATTN: KS generate log error if this not possible |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
throw; |
} | } |
catch(Exception& e) |
catch(const Exception&) |
{ | { |
// ATTN: Generate log error. | // ATTN: Generate log error. |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
throw; |
} | } |
instance.setPath(instancePath); | instance.setPath(instancePath); |
CDEBUG("CIMObjectMgr path = " << instancePath.toString()); |
} |
// Save this instance for other requests |
instance.filter(includeQualifiers, includeClassOrigin, propertyList); |
instanceOfCIMObjectManager = instance; |
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return(instanceOfCIMObjectManager); |
return(instance); |
} | } |
| |
/** Get the instances of CIM_Namespace. Gets all instances of the namespace from | /** Get the instances of CIM_Namespace. Gets all instances of the namespace from |
|
|
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::_getInstancesCIMNamespace()"); | "InteropProvider::_getInstancesCIMNamespace()"); |
| |
CDEBUG("_getinstanceCIMNamespace Gets ONE only from Namespace=" << nameSpace.getString()); |
|
Array<CIMInstance> instances = _getInstancesCIMNamespace(true, true, CIMPropertyList()); | Array<CIMInstance> instances = _getInstancesCIMNamespace(true, true, CIMPropertyList()); |
| |
// search the instances for one with the name property value = input parameter. | // search the instances for one with the name property value = input parameter. |
|
|
Array<CIMInstance> namespaceInstances = _getInstancesCIMNamespace(false, | Array<CIMInstance> namespaceInstances = _getInstancesCIMNamespace(false, |
false, CIMPropertyList()); | false, CIMPropertyList()); |
| |
CIMInstance instanceObjMgr = _buildInstanceCIMObjectManager( true, true, CIMPropertyList()); |
CIMInstance instanceObjMgr = _getInstanceCIMObjectManager( true, true, CIMPropertyList()); |
| |
CIMObjectPath refObjMgr = _buildReference(instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME); | CIMObjectPath refObjMgr = _buildReference(instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME); |
| |
|
|
{ | { |
CIMInstance instance = _buildInstanceSkeleton(CIM_NAMESPACEINMANAGER_CLASSNAME); | CIMInstance instance = _buildInstanceSkeleton(CIM_NAMESPACEINMANAGER_CLASSNAME); |
| |
_setPropertyValue(instance, CIMName("Antecdent"), refObjMgr); |
_setPropertyValue(instance, CIMName("Antecedent"), refObjMgr); |
//ATTNATTN: this is weak qualifier. | //ATTNATTN: this is weak qualifier. |
_setPropertyValue(instance, CIMName("Dependent"), _buildReference(namespaceInstances[i], | _setPropertyValue(instance, CIMName("Dependent"), _buildReference(namespaceInstances[i], |
CIM_NAMESPACEINMANAGER_CLASSNAME)); | CIM_NAMESPACEINMANAGER_CLASSNAME)); |
|
|
Array<CIMInstance> commInstances = _buildInstancesPGCIMXMLCommunicationMechanism(true, | Array<CIMInstance> commInstances = _buildInstancesPGCIMXMLCommunicationMechanism(true, |
true, CIMPropertyList()); | true, CIMPropertyList()); |
| |
CIMInstance instanceObjMgr = _buildInstanceCIMObjectManager( true, true, CIMPropertyList()); |
CIMInstance instanceObjMgr = _getInstanceCIMObjectManager( true, true, CIMPropertyList()); |
| |
CIMObjectPath refObjMgr = _buildReference(instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME); | CIMObjectPath refObjMgr = _buildReference(instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME); |
Array<CIMInstance> assocInstances; | Array<CIMInstance> assocInstances; |
|
|
| |
CIMInstance instance = _buildInstanceSkeleton(CIM_COMMMECHANISMFORMANAGER_CLASSNAME); | CIMInstance instance = _buildInstanceSkeleton(CIM_COMMMECHANISMFORMANAGER_CLASSNAME); |
| |
_setPropertyValue(instance,CIMName("Antecdent"), refObjMgr); |
_setPropertyValue(instance,CIMName("Antecedent"), refObjMgr); |
//ATTNATTN: this is weak qualifier. | //ATTNATTN: this is weak qualifier. |
_setPropertyValue(instance,CIMName("Dependent"), _buildReference(commInstances[i],CIM_COMMMECHANISMFORMANAGER_CLASSNAME)); | _setPropertyValue(instance,CIMName("Dependent"), _buildReference(commInstances[i],CIM_COMMMECHANISMFORMANAGER_CLASSNAME)); |
assocInstances.append(instance); | assocInstances.append(instance); |
|
|
// Everything above was commmon to CIM Namespace. The following is PG_Namespace Properties | // Everything above was commmon to CIM Namespace. The following is PG_Namespace Properties |
// | // |
// ATTN: KS Get the correct values for these entities from repository interface. | // ATTN: KS Get the correct values for these entities from repository interface. |
CDEBUG("_buildPGNS Instance get namespace attributes for namespace= " << nameSpace.getString()); |
|
CIMRepository::NameSpaceAttributes attributes; | CIMRepository::NameSpaceAttributes attributes; |
_repository->getNameSpaceAttributes(nameSpace.getString(), attributes); | _repository->getNameSpaceAttributes(nameSpace.getString(), attributes); |
String parent=""; | String parent=""; |
|
String name = ""; |
Boolean shareable=false; | Boolean shareable=false; |
Boolean updatesAllowed=true; | Boolean updatesAllowed=true; |
for (CIMRepository::NameSpaceAttributes::Iterator i = attributes.start(); i; i++) | for (CIMRepository::NameSpaceAttributes::Iterator i = attributes.start(); i; i++) |
{ | { |
String key=i.key(); | String key=i.key(); |
String value = i.value(); | String value = i.value(); |
CDEBUG("Show Attributes. key= " << key << " value= " << value); |
|
if (String::equalNoCase(key,"shareable")) | if (String::equalNoCase(key,"shareable")) |
|
{ |
if (String::equalNoCase(value,"true")) | if (String::equalNoCase(value,"true")) |
shareable=true; | shareable=true; |
|
} |
else if (String::equalNoCase(key,"updatesAllowed")) | else if (String::equalNoCase(key,"updatesAllowed")) |
|
{ |
if (String::equalNoCase(value,"false")) | if (String::equalNoCase(value,"false")) |
updatesAllowed=false; | updatesAllowed=false; |
|
} |
// Test to be sure we are returning proper namespace name | // Test to be sure we are returning proper namespace name |
else if (String::equalNoCase(key,"name")) | else if (String::equalNoCase(key,"name")) |
{ | { |
|
|
"Namespace attribute rtnd error for key " + key + "expected " + | "Namespace attribute rtnd error for key " + key + "expected " + |
nameSpace.getString()+ value + " in " + String(thisProvider)); | nameSpace.getString()+ value + " in " + String(thisProvider)); |
} | } |
|
|
|
name = value; |
} | } |
else if (String::equalNoCase(key,"parent")) | else if (String::equalNoCase(key,"parent")) |
|
{ |
parent=value; | parent=value; |
|
} |
else | else |
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
|
_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_SCHEMAUPDATESALLOWED, updatesAllowed); | _setPropertyValue(instance, PG_NAMESPACE_PROPERTY_SCHEMAUPDATESALLOWED, updatesAllowed); |
_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_ISSHAREABLE, shareable); | _setPropertyValue(instance, PG_NAMESPACE_PROPERTY_ISSHAREABLE, shareable); |
_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_PARENTNAMESPACE, parent); | _setPropertyValue(instance, PG_NAMESPACE_PROPERTY_PARENTNAMESPACE, parent); |
|
_setPropertyValue(instance, PG_NAMESPACE_PROPERTY_NAME, name); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return(instance); | return(instance); |
} | } |
|
|
void _validateCIMNamespaceKeys(const CIMObjectPath& objectPath) | void _validateCIMNamespaceKeys(const CIMObjectPath& objectPath) |
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
|
|
} | } |
if (!_validateRequiredProperty(objectPath, | if (!_validateRequiredProperty(objectPath, |
CIM_NAMESPACE_PROPERTY_SYSTEMNAME, | CIM_NAMESPACE_PROPERTY_SYSTEMNAME, |
System::getHostName())) |
System::getFullyQualifiedHostName())) |
{ | { |
propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME; | propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME; |
valid = false; | valid = false; |
|
|
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
} | } |
| |
|
/** completes a property in the defined instance either |
|
by adding the complete property if it does not exist |
|
or by adding the value if the property does exist. |
|
Used to make sure that key properties for things |
|
like systemcreationclass are included in the |
|
creation of new instances and that the |
|
values are logical for the CIMOM. |
|
*/ |
|
Boolean _completeProperty(CIMInstance& instance, |
|
const CIMName& propertyName, |
|
const String& value) |
|
{ |
|
|
|
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
|
"InteropProvider::_completeProperty()"); |
|
|
|
Uint32 pos; |
|
|
|
if (!_validateRequiredProperty(instance, |
|
propertyName, |
|
value)) |
|
{ |
|
if ((pos = instance.findProperty (propertyName)) == PEG_NOT_FOUND) |
|
{ |
|
// Add the property. Should be from the class. |
|
PEG_METHOD_EXIT(); |
|
return(false); |
|
} |
|
else |
|
{ |
|
// |
|
_setPropertyValue(instance, propertyName, value); |
|
} |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
return(true); |
|
} |
|
Boolean _completeCIMNamespaceKeys(CIMInstance& instance) |
|
{ |
|
|
|
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
|
"InteropProvider::_completeCIMNamespaceKeys"); |
|
|
|
Boolean valid = true; |
|
CIMName propertyName; |
|
|
|
if (!_completeProperty(instance, |
|
CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME, |
|
System::getSystemCreationClassName ())) |
|
{ |
|
|
|
propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME; |
|
valid = false; |
|
} |
|
|
|
if (!_completeProperty(instance, |
|
CIM_NAMESPACE_PROPERTY_SYSTEMNAME, |
|
System::getFullyQualifiedHostName())) |
|
{ |
|
propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME; |
|
valid = false; |
|
} |
|
|
|
if (!_completeProperty(instance, |
|
CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME, |
|
CIM_OBJECTMANAGER_CLASSNAME.getString())) |
|
{ |
|
propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERCREATIONCLASSNAME; |
|
valid = false; |
|
} |
|
|
|
if (!_completeProperty(instance, |
|
CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME, |
|
String::EMPTY)) |
|
{ |
|
propertyName = CIM_NAMESPACE_PROPERTY_OBJECTMANAGERNAME; |
|
valid = false; |
|
} |
|
if (!_completeProperty(instance, |
|
CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME, |
|
System::getHostName())) |
|
{ |
|
propertyName = CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME; |
|
valid = false; |
|
} |
|
|
|
if (!_completeProperty(instance, |
|
CIM_NAMESPACE_PROPERTY_NAME, |
|
String::EMPTY)) |
|
{ |
|
propertyName = CIM_NAMESPACE_PROPERTY_NAME; |
|
valid = false; |
|
} |
|
|
|
if (!valid) |
|
{ |
|
PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
|
"Invalid CIM_Namespace Key Property " + propertyName.getString()); |
|
PEG_METHOD_EXIT(); |
|
throw CIMInvalidParameterException( |
|
"Invalid CIM_Namespace key property: " + propertyName.getString()); |
|
} |
|
PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, "CIM_Namespace Keys Valid"); |
|
PEG_METHOD_EXIT(); |
|
return(valid); |
|
} |
|
|
|
|
void _validateCIMNamespaceKeys(const CIMInstance& instance) | void _validateCIMNamespaceKeys(const CIMInstance& instance) |
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
|
|
| |
if (!_validateRequiredProperty(instance, | if (!_validateRequiredProperty(instance, |
CIM_NAMESPACE_PROPERTY_SYSTEMNAME, | CIM_NAMESPACE_PROPERTY_SYSTEMNAME, |
System::getHostName())) |
System::getFullyQualifiedHostName ())) |
{ | { |
propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME; | propertyName = CIM_NAMESPACE_PROPERTY_SYSTEMNAME; |
valid = false; | valid = false; |
|
|
/** builds complete object path from instance and classinfo by building the full path | /** builds complete object path from instance and classinfo by building the full path |
with host and namespace names included. | with host and namespace names included. |
*/ | */ |
|
|
CIMObjectPath InteropProvider::_buildObjectPath(const CIMNamespaceName& name, | CIMObjectPath InteropProvider::_buildObjectPath(const CIMNamespaceName& name, |
const CIMName& className, | const CIMName& className, |
const CIMInstance& instance) | const CIMInstance& instance) |
|
|
"InteropProvider::_buildInstancePath"); | "InteropProvider::_buildInstancePath"); |
| |
// get the class CIM_Namespace class to use in building path | // get the class CIM_Namespace class to use in building path |
|
|
// Exception out if Class does not exist in this namespace | // Exception out if Class does not exist in this namespace |
CIMClass thisClass = _getClass(name, className); | CIMClass thisClass = _getClass(name, className); |
| |
// XmlWriter::printInstanceElement(instance); |
|
CIMObjectPath ref = instance.buildPath(thisClass); | CIMObjectPath ref = instance.buildPath(thisClass); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
return(ref); | return(ref); |
} | } |
| |
/* _isNamespace determines if the namespace in the second |
|
parameter is in the array in the first parameter. |
|
@param array of possible namespaces |
|
@param canidate namespace |
|
@return - true if found |
|
*/ |
|
Boolean _isNamespace( |
|
Array<CIMNamespaceName>& namespaceNames, |
|
CIMNamespaceName& namespaceName) |
|
|
|
{ |
|
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
|
"InteropProvider::_isNamespace"); |
|
|
|
Boolean found = false; |
|
for(Uint32 i = 0; i < namespaceNames.size(); i++) |
|
{ |
|
if(namespaceNames[i].equal ( namespaceName )) |
|
return true; |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
return false; |
|
} |
|
|
|
//************************************************************** | //************************************************************** |
// Overloaded functions to get key value with different params | // Overloaded functions to get key value with different params |
//************************************************************** | //************************************************************** |
|
|
//ATTN: KS Returns String whereas below returns CIMNamespaceName. | //ATTN: KS Returns String whereas below returns CIMNamespaceName. |
} | } |
| |
/* 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 |
|
|
|
Uint32 pos; |
|
CIMValue propertyValue; |
|
|
|
pos = namespaceInstance.findProperty(NAMESPACE_PROPERTYNAME); |
|
if (pos == PEG_NOT_FOUND) |
|
{ |
|
throw CIMPropertyNotFoundException |
|
(NAMESPACE_PROPERTYNAME.getString()); |
|
} |
|
|
|
propertyValue = namespaceInstance.getProperty(pos).getValue(); |
|
if (propertyValue.getType() != CIMTYPE_STRING) |
|
throw CIMInvalidParameterException("Invalid type for property: " |
|
+ NAMESPACE_PROPERTYNAME.getString()); |
|
|
|
String cnsName; |
|
propertyValue.get(cnsName); |
|
childNamespaceName = CIMNamespaceName (cnsName); |
|
|
|
isRelativeName = !(childNamespaceName.isNull()); |
|
} |
|
/* gets the key value for the __Namespace property "name" |
|
from the instance provided. Sets childNamespaceName and |
|
isRelativeName fields |
|
This overload called if object path provided. |
|
*/ |
|
|
|
void _getKeyValue ( |
|
const CIMObjectPath& instanceName, |
|
CIMNamespaceName& childNamespaceName, |
|
Boolean& isRelativeName) |
|
{ |
|
|
|
Array<CIMKeyBinding> kbArray = instanceName.getKeyBindings(); |
|
|
|
if ((kbArray.size() == 1) && |
|
(kbArray[0].getName() == NAMESPACE_PROPERTYNAME)) |
|
{ |
|
childNamespaceName = CIMNamespaceName (kbArray[0].getValue()); |
|
isRelativeName = !(childNamespaceName.isNull()); |
|
} |
|
else |
|
throw CIMInvalidParameterException("Invalid key property: "); |
|
} |
|
|
|
/* 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 |
|
*/ |
|
/********************DELETE THIS********* |
|
CIMNamespaceName _generateFullNamespaceName( |
|
Array<CIMNamespaceName>& namespaceNames, |
|
CIMNamespaceName& parentNamespaceName, |
|
CIMNamespaceName& childNamespaceName, |
|
Boolean isRelativeName) |
|
|
|
{ |
|
// If isRelativeName is true, then the parentNamespace |
|
// MUST exist |
|
// |
|
CIMNamespaceName fullNamespaceName; |
|
|
|
if (isRelativeName) |
|
{ |
|
if (!_isNamespace(namespaceNames, parentNamespaceName)) |
|
{ |
|
throw CIMObjectNotFoundException("Parent namespace does not exist: " |
|
+ parentNamespaceName.getString()); |
|
} |
|
// Create full namespace name by prepending parentNamespaceName |
|
fullNamespaceName = CIMNamespaceName (parentNamespaceName.getString() |
|
+ "/" + childNamespaceName.getString()); |
|
} |
|
else |
|
{ |
|
fullNamespaceName = parentNamespaceName; |
|
} |
|
return(fullNamespaceName); |
|
|
|
} |
|
***************************************DELETE END**************/ |
|
|
|
//*************************************************************************** | //*************************************************************************** |
// The following section is the Instance Operation processors | // The following section is the Instance Operation processors |
//*************************************************************************** | //*************************************************************************** |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::createInstance()"); | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::createInstance()"); |
| |
|
Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
|
"%s createInstance. InstanceReference= %s", |
|
thisProvider, |
|
(const char *) instanceReference.toString().getCString()); |
|
|
|
handler.processing(); |
CIMNamespaceName newNamespaceName; | CIMNamespaceName newNamespaceName; |
|
|
CDEBUG("CreateInstance " << instanceReference.toString()); | CDEBUG("CreateInstance " << instanceReference.toString()); |
// operation namespace needed internally to get class. | // operation namespace needed internally to get class. |
_operationNamespace = instanceReference.getNameSpace(); | _operationNamespace = instanceReference.getNameSpace(); |
| |
// Verify that ClassName is correct and get value | // Verify that ClassName is correct and get value |
targetClass classEnum = _verifyValidClassInput(instanceReference.getClassName()); | targetClass classEnum = _verifyValidClassInput(instanceReference.getClassName()); |
CDEBUG("Class Validated"); |
|
String userName = _validateUserID(context); | String userName = _validateUserID(context); |
CIMObjectPath newInstanceReference; | CIMObjectPath newInstanceReference; |
CDEBUG("UserIDValidated"); |
|
if ((classEnum == CIM_OBJECTMANAGER) || | if ((classEnum == CIM_OBJECTMANAGER) || |
(classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)) | (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)) |
throw CIMNotSupportedException("InteropProvider, Create Not allowed"); | throw CIMNotSupportedException("InteropProvider, Create Not allowed"); |
| |
CDEBUG("CreateInstance: Now test for CIM_NamepsaceClass"); |
|
if (classEnum == PG_NAMESPACE) | if (classEnum == PG_NAMESPACE) |
{ | { |
|
#ifdef PEGASUS_OS_OS400 |
|
MessageLoaderParms mparms("ControlProviders.InteropProvider.CREATE_INSTANCE_NOT_ALLOWED", |
|
"Create instance operation not allowed by Interop Provider for class $0.", |
|
PG_NAMESPACE_CLASSNAME.getString()); |
|
throw CIMNotSupportedException(mparms); |
|
#else |
|
// Create local instance to complete any keys. |
|
CIMInstance localInstance = myInstance.clone(); |
|
|
|
_completeCIMNamespaceKeys(localInstance); |
// Validate that keys are as required. Does its own exception. | // Validate that keys are as required. Does its own exception. |
_validateCIMNamespaceKeys(myInstance); |
newNamespaceName = _getKeyValue(myInstance, CIM_NAMESPACE_PROPERTY_NAME); |
CDEBUG("Getting key value"); |
|
String newNamespaceName = _getKeyValue(myInstance, CIM_NAMESPACE_PROPERTY_NAME); |
newInstanceReference = _buildInstancePath(_operationNamespace, |
CDEBUG("Key value= " << newNamespaceName); |
PG_NAMESPACE_CLASSNAME, localInstance); |
CIMInstance instance = _buildInstancePGNamespace(newNamespaceName); |
#endif |
CDEBUG("CreateInstance:Rtn from _BuildInstanceCIMNamespace for namespace= " << newNamespaceName); |
|
newInstanceReference = _buildInstancePath(CIMNamespaceName(newNamespaceName), |
|
CIM_NAMESPACE_CLASSNAME, instance); |
|
CDEBUG("CreateInstance:Go to common create functions"); |
|
} | } |
| |
else // Process the __Namespace request to get namespace name value |
else // Invalid class for the create functions. |
{ | { |
PEGASUS_ASSERT(false); | PEGASUS_ASSERT(false); |
} | } |
|
|
// Create the new namespace | // Create the new namespace |
try | try |
{ | { |
CDEBUG("Create namespace " << newNamespaceName.getString()); |
|
PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
"Namespace = " + newNamespaceName.getString() + | "Namespace = " + newNamespaceName.getString() + |
" to be created."); | " to be created."); |
Boolean updatesAllowed = false; | Boolean updatesAllowed = false; |
Boolean shareable = false; | Boolean shareable = false; |
String parent = String::EMPTY; | String parent = String::EMPTY; |
|
|
CIMRepository::NameSpaceAttributes attributes; | CIMRepository::NameSpaceAttributes attributes; |
// optional property. Set false if not found. | // optional property. Set false if not found. |
// ATTN: Should set to class default. | // ATTN: Should set to class default. |
|
|
if (parent != String::EMPTY) | if (parent != String::EMPTY) |
attributes.insert("parent",parent); | attributes.insert("parent",parent); |
} | } |
CDEBUG("Create New namespace " << newNamespaceName); |
|
_repository->createNameSpace(newNamespaceName, attributes); | _repository->createNameSpace(newNamespaceName, attributes); |
| |
PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, | PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
"Namespace = " + newNamespaceName.getString() + | "Namespace = " + newNamespaceName.getString() + |
" successfully created."); | " successfully created."); |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"Create Namespace: Shareable = $0, Updates allows: $1, Parent: $2", | "Create Namespace: Shareable = $0, Updates allows: $1, Parent: $2", |
newNamespaceName.getString(), shareable? "true" : "false", shareable? "true" : "false", parent ); | newNamespaceName.getString(), shareable? "true" : "false", shareable? "true" : "false", parent ); |
|
|
} | } |
catch(CIMException& e) |
catch(const CIMException&) |
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
throw; |
} | } |
catch(Exception& e) |
catch(const Exception&) |
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
throw; |
} | } |
| |
// begin processing the request | // begin processing the request |
handler.processing(); |
|
|
|
| |
handler.deliver(newInstanceReference); | handler.deliver(newInstanceReference); |
| |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::deleteInstance"); | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::deleteInstance"); |
| |
CIMNamespaceName childNamespaceName; |
Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
CIMNamespaceName deleteNamespaceName; |
"%s deleteInstance. instanceName= %s", |
|
thisProvider, |
|
(const char *) instanceName.toString().getCString()); |
| |
_operationNamespace = instanceName.getNameSpace(); | _operationNamespace = instanceName.getNameSpace(); |
handler.processing(); | handler.processing(); |
|
|
| |
String userName = _validateUserID(context); | String userName = _validateUserID(context); |
| |
|
|
if ((classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)) |
|
throw CIMNotSupportedException("Delete Not allowed"); |
|
|
|
// Delete the instance since it may be in persistent storage | // Delete the instance since it may be in persistent storage |
if ((classEnum == CIM_OBJECTMANAGER)) | if ((classEnum == CIM_OBJECTMANAGER)) |
{ | { |
CIMInstance instance; |
|
try | try |
{ | { |
instance = _repository->getInstance(_operationNamespace, instanceName); |
|
|
|
// If instance found, then delete it. |
|
_repository->deleteInstance(_operationNamespace,instanceName); | _repository->deleteInstance(_operationNamespace,instanceName); |
|
|
PEG_METHOD_EXIT(); |
|
handler.complete(); |
|
return; |
|
} | } |
catch(CIMException& e) |
catch(const CIMException&) |
{ | { |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
throw; |
} | } |
} | } |
|
else if (classEnum == PG_NAMESPACE) |
Array<CIMNamespaceName> namespaceNames; |
|
namespaceNames = _enumerateNameSpaces(); |
|
if (classEnum == PG_NAMESPACE) |
|
{ | { |
|
CIMNamespaceName deleteNamespaceName; |
|
#ifdef PEGASUS_OS_OS400 |
|
MessageLoaderParms mparms("ControlProviders.InteropProvider.DELETE_INSTANCE_NOT_ALLOWED", |
|
"Delete instance operation not allowed by Interop Provider for class $0.", |
|
PG_NAMESPACE_CLASSNAME.getString()); |
|
throw CIMNotSupportedException(mparms); |
|
#else |
// validate requred keys. Exception out if not valid | // validate requred keys. Exception out if not valid |
_validateCIMNamespaceKeys(instanceName); | _validateCIMNamespaceKeys(instanceName); |
| |
deleteNamespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME); | deleteNamespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME); |
CDEBUG("Delete namespace = " << deleteNamespaceName ); |
#endif |
} |
|
|
Array<CIMNamespaceName> namespaceNames; |
|
namespaceNames = _enumerateNameSpaces(); |
| |
// ATTN: KS Why THis??? |
|
if (deleteNamespaceName.equal (ROOTNS)) | if (deleteNamespaceName.equal (ROOTNS)) |
{ | { |
throw CIMNotSupportedException("root namespace cannot be deleted."); | throw CIMNotSupportedException("root namespace cannot be deleted."); |
|
|
"Namespace = " + deleteNamespaceName.getString() + | "Namespace = " + deleteNamespaceName.getString() + |
" successfully deleted."); | " successfully deleted."); |
| |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"Interop Provider Delete Namespace: $0", | "Interop Provider Delete Namespace: $0", |
deleteNamespaceName.getString()); | deleteNamespaceName.getString()); |
|
} |
|
else |
|
{ |
|
throw CIMNotSupportedException("Delete Not allowed for " + instanceName.getClassName().getString()); |
|
} |
| |
handler.processing(); | handler.processing(); |
| |
// complete processing the request |
|
handler.complete(); | handler.complete(); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::getInstance"); | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::getInstance"); |
| |
|
Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
|
"%s getInstance. instanceName= %s , includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s", |
|
thisProvider, |
|
(const char *)instanceName.toString().getCString(), |
|
(const char *)_showBool(includeQualifiers).getCString(), |
|
(const char*) _showBool(includeClassOrigin).getCString(), |
|
(const char *)_showPropertyList(propertyList).getCString()); |
// Verify that ClassName is correct and get value | // Verify that ClassName is correct and get value |
targetClass classEnum = _verifyValidClassInput(instanceName.getClassName()); | targetClass classEnum = _verifyValidClassInput(instanceName.getClassName()); |
| |
|
_operationNamespace = instanceName.getNameSpace(); |
String userName = _validateUserID(context); | String userName = _validateUserID(context); |
|
|
// begin processing the request | // begin processing the request |
handler.processing(); | handler.processing(); |
if (classEnum == CIM_OBJECTMANAGER) | if (classEnum == CIM_OBJECTMANAGER) |
{ | { |
CIMInstance instance = _buildInstanceCIMObjectManager(includeQualifiers, |
CIMInstance instance = _getInstanceCIMObjectManager(includeQualifiers, |
includeClassOrigin, propertyList); | includeClassOrigin, propertyList); |
handler.deliver(instance); | handler.deliver(instance); |
handler.complete(); | handler.complete(); |
|
|
return; | return; |
} | } |
| |
|
if (classEnum == CIM_NAMESPACEINMANAGER) |
|
{ |
|
handler.complete(); |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
|
|
// Get List of namespaces | // Get List of namespaces |
Array<CIMNamespaceName> namespaceNames; | Array<CIMNamespaceName> namespaceNames; |
namespaceNames = _enumerateNameSpaces(); | namespaceNames = _enumerateNameSpaces(); |
|
|
namespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME); | namespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME); |
| |
// ATTN: Why this CIMNamespaceName parentNamespaceName = instanceName.getNameSpace(); | // ATTN: Why this CIMNamespaceName parentNamespaceName = instanceName.getNameSpace(); |
if (!_isNamespace(namespaceNames, namespaceName)) |
if (!Contains(namespaceNames, namespaceName)) |
{ | { |
throw CIMObjectNotFoundException("Namespace does not exist: " | throw CIMObjectNotFoundException("Namespace does not exist: " |
+ namespaceName.getString()); | + namespaceName.getString()); |
|
|
InstanceResponseHandler & handler) | InstanceResponseHandler & handler) |
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::enumerateInstances()"); | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::enumerateInstances()"); |
// Verify that ClassName is correct and get value |
|
| |
|
Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
|
"%s enumerateInstances. ref= %s, includeQualifiers= %s, includeClassOrigin= %s, PropertyList= %s", |
|
thisProvider, |
|
(const char *) ref.toString().getCString(), |
|
(const char *) _showBool(includeQualifiers).getCString(), |
|
(const char *) _showBool(includeClassOrigin).getCString(), |
|
(const char *) _showPropertyList(propertyList).getCString()); |
|
|
|
// Verify that ClassName is correct and get value |
targetClass classEnum = _verifyValidClassInput(ref.getClassName()); | targetClass classEnum = _verifyValidClassInput(ref.getClassName()); |
| |
// operation namespace needed internally to get class. | // operation namespace needed internally to get class. |
_operationNamespace = ref.getNameSpace(); | _operationNamespace = ref.getNameSpace(); |
|
CDEBUG("Namespace = " << _operationNamespace.getString()); |
//String userName = _validateUserID(context); | //String userName = _validateUserID(context); |
| |
// The following 3 classes deliver a single instance because | // The following 3 classes deliver a single instance because |
// that is all there is today. | // that is all there is today. |
if (classEnum == CIM_OBJECTMANAGER) | if (classEnum == CIM_OBJECTMANAGER) |
{ | { |
CIMInstance instance = _buildInstanceCIMObjectManager(includeQualifiers, |
CIMInstance instance = _getInstanceCIMObjectManager(includeQualifiers, |
includeClassOrigin, | includeClassOrigin, |
propertyList); | propertyList); |
| |
|
|
// "Instance - XML content: $0", tmp.getData()); | // "Instance - XML content: $0", tmp.getData()); |
///XmlWriter::printInstanceElement(instance); | ///XmlWriter::printInstanceElement(instance); |
handler.deliver(instance); | handler.deliver(instance); |
handler.complete(); |
//handler.complete(); |
PEG_METHOD_EXIT(); |
//PEG_METHOD_EXIT(); |
return; |
//return; |
} | } |
| |
if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM) |
else if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM) |
{ | { |
Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(includeQualifiers, | Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(includeQualifiers, |
includeClassOrigin, propertyList); | includeClassOrigin, propertyList); |
CDEBUG("Build instances of PGCIMXML. count= " << instances.size()); | CDEBUG("Build instances of PGCIMXML. count= " << instances.size()); |
handler.deliver(instances); | handler.deliver(instances); |
handler.complete(); |
//handler.complete(); |
PEG_METHOD_EXIT(); |
//PEG_METHOD_EXIT(); |
return; |
//return; |
} | } |
| |
|
else if (classEnum == CIM_NAMESPACEINMANAGER) |
|
{ |
|
//handler.complete(); |
|
//PEG_METHOD_EXIT(); |
|
//return; |
|
} |
| |
if (classEnum == PG_NAMESPACE) |
else if (classEnum == PG_NAMESPACE) |
{ | { |
Array<CIMInstance> instances = _getInstancesCIMNamespace(includeQualifiers, | Array<CIMInstance> instances = _getInstancesCIMNamespace(includeQualifiers, |
includeClassOrigin, propertyList); | includeClassOrigin, propertyList); |
| |
handler.deliver(instances); | handler.deliver(instances); |
handler.complete(); |
//handler.complete(); |
PEG_METHOD_EXIT(); |
//PEG_METHOD_EXIT(); |
return; |
//return; |
|
} |
|
else |
|
{ |
|
throw CIMNotSupportedException |
|
("EnumerateInstance for " + ref.getClassName().getString() + " not supported"); |
} | } |
| |
/// ATTN: exception response because of error |
|
handler.complete(); | handler.complete(); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
|
|
// the only allowed modification is this one property, statistical data | // the only allowed modification is this one property, statistical data |
if (modifiedIns.findProperty(OM_GATHERSTATISTICALDATA) != PEG_NOT_FOUND) | if (modifiedIns.findProperty(OM_GATHERSTATISTICALDATA) != PEG_NOT_FOUND) |
{ | { |
// ATTN: This one is a problem KS rethink this. |
|
// the following is a temporary hack to set the value of the statistics | // the following is a temporary hack to set the value of the statistics |
// gathering function dynamically. We simply get the value from input | // gathering function dynamically. We simply get the value from input |
// and call the internal method to set it each time this object is | // and call the internal method to set it each time this object is |
// built. | // built. |
#ifdef PEGASUS_HAS_PERFINST |
#ifndef PEGASUS_DISABLE_PERFINST |
StatisticalData* sd = StatisticalData::current(); |
|
Boolean statisticsFlag = _getPropertyValue(modifiedIns, OM_GATHERSTATISTICALDATA, false); | Boolean statisticsFlag = _getPropertyValue(modifiedIns, OM_GATHERSTATISTICALDATA, false); |
sd->setCopyGSD(statisticsFlag); |
CIMInstance instance; |
if ( ! _getInstanceCIMObjectManager(false, false, CIMPropertyList())) |
instance = _getInstanceCIMObjectManager(true, true, CIMPropertyList()); |
{ |
|
_buildInstanceCIMObjectManager(true, true, CIMPropertyList()); |
|
} |
|
| |
// ATTN: Think we need to clone here to avoid any issues of overwriting. |
if (statisticsFlag != _getPropertyValue(instance, OM_GATHERSTATISTICALDATA, false)) |
_setPropertyValue(instanceOfCIMObjectManager, OM_GATHERSTATISTICALDATA, statisticsFlag); |
{ |
CIMObjectPath instancePath; |
// set the changed property into the |
// Add the instance path to this if necessary ATTN ATTN: |
_setPropertyValue(instance, OM_GATHERSTATISTICALDATA, statisticsFlag); |
|
// Modify the object on disk |
try | try |
{ | { |
_repository->modifyInstance(_operationNamespace, | _repository->modifyInstance(_operationNamespace, |
instanceOfCIMObjectManager ); |
instance ); |
} | } |
catch(CIMException& e) |
catch(const CIMException&) |
{ | { |
// ATTN: KS generate log error if this not possible | // ATTN: KS generate log error if this not possible |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
throw; |
} | } |
catch(Exception& e) |
catch(const Exception&) |
{ | { |
// ATTN: Generate log error. | // ATTN: Generate log error. |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw e; |
throw; |
} | } |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::INFORMATION, |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
"Interop Provider Set Statistics gathering in CIM_ObjectManager: $0", | "Interop Provider Set Statistics gathering in CIM_ObjectManager: $0", |
(statisticsFlag? "true" : "false")); | (statisticsFlag? "true" : "false")); |
// update the object on disk. |
StatisticalData* sd = StatisticalData::current(); |
// We do not really deliver anything but simply do normal return |
sd->setCopyGSD(statisticsFlag); |
|
} |
return; | return; |
#endif | #endif |
| |
} | } |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
// ATTN Expand this defintion to be more precise. |
// ATTN Expand this defintion to be more precise since it allows only mod of |
|
// one property and that property MUST be in the instance to be modifiable. |
throw CIMNotSupportedException | throw CIMNotSupportedException |
(OM_GATHERSTATISTICALDATA.getString() + " modify operation not supported by Interop Provider"); | (OM_GATHERSTATISTICALDATA.getString() + " modify operation not supported by Interop Provider"); |
} | } |
|
|
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::modifyInstance"); | "InteropProvider::modifyInstance"); |
| |
// operation namespace needed internally to get class. |
Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4, |
|
"%s modifyInstance. instanceReference= %s, includeQualifiers= %s, PropertyList= %s", |
|
thisProvider, |
|
(const char *) instanceReference.toString().getCString(), |
|
(const char *) _showBool(includeQualifiers).getCString(), |
|
(const char *) _showPropertyList(propertyList).getCString()); |
| |
// ATTN: KS 31 August 2004. This must test for privileged user. | // ATTN: KS 31 August 2004. This must test for privileged user. |
_operationNamespace = instanceReference.getNameSpace(); | _operationNamespace = instanceReference.getNameSpace(); |
|
|
} | } |
else if (classEnum == PG_NAMESPACE) | else if (classEnum == PG_NAMESPACE) |
{ | { |
|
#ifdef PEGASUS_OS_OS400 |
|
MessageLoaderParms mparms("ControlProviders.InteropProvider.MODIFY_INSTANCE_NOT_ALLOWED", |
|
"Modify instance operation not allowed by Interop Provider for class $0.", |
|
PG_NAMESPACE_CLASSNAME.getString()); |
|
throw CIMNotSupportedException(mparms); |
|
#else |
// for the moment allow modification of the statistics property only | // for the moment allow modification of the statistics property only |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
throw CIMNotSupportedException | throw CIMNotSupportedException |
(className.getString() + " not supported by Interop Provider"); | (className.getString() + " not supported by Interop Provider"); |
|
#endif |
} | } |
else | else |
{ | { |
|
|
targetClass classEnum = _verifyValidClassInput(classReference.getClassName()); | targetClass classEnum = _verifyValidClassInput(classReference.getClassName()); |
| |
String userName = _validateUserID(context); | String userName = _validateUserID(context); |
|
|
// begin processing the request | // begin processing the request |
handler.processing(); | handler.processing(); |
| |
// The following 3 classes deliver a single instance because |
// Deliver a single instance because there should only be one instance. |
// that is all there is today. |
|
if (classEnum == CIM_OBJECTMANAGER) | if (classEnum == CIM_OBJECTMANAGER) |
{ | { |
CIMInstance instance = _buildInstanceCIMObjectManager( true, true, CIMPropertyList()); |
CIMInstance instance = _getInstanceCIMObjectManager( true, true, CIMPropertyList()); |
CIMObjectPath ref = _buildInstancePath(_operationNamespace, | CIMObjectPath ref = _buildInstancePath(_operationNamespace, |
CIM_OBJECTMANAGER_CLASSNAME, instance); | CIM_OBJECTMANAGER_CLASSNAME, instance); |
handler.deliver(ref); | handler.deliver(ref); |
|
|
return; | return; |
} | } |
| |
|
// Deliver all possible instances of this class |
if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM) | if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM) |
{ | { |
Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(true, | Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(true, |
|
|
return; | return; |
} | } |
| |
|
if (classEnum == CIM_NAMESPACEINMANAGER) |
|
{ |
|
handler.complete(); |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
|
|
if (classEnum == PG_NAMESPACE) | if (classEnum == PG_NAMESPACE) |
{ | { |
Array<CIMInstance> instances = _getInstancesCIMNamespace(false, | Array<CIMInstance> instances = _getInstancesCIMNamespace(false, |
|
|
return; | return; |
} | } |
| |
|
if (classEnum == CIM_COMMMECHANISMFORMANAGERINST) |
|
{ |
|
Array<CIMInstance> instances = _buildInstancesCommMechanismForManager(); |
|
for (Uint32 i = 0 ; i < instances.size() ; i++ ) |
|
{ |
|
CIMObjectPath ref = _buildObjectPath(_operationNamespace, |
|
CIM_COMMMECHANISMFORMANAGER_CLASSNAME, instances[i]); |
|
handler.deliver(ref); |
|
} |
|
} |
|
|
|
if (classEnum == CIM_NAMESPACEINMANAGERINST) |
|
{ |
|
Array<CIMInstance> instances = _buildInstancesNamespaceInManager(); |
|
for (Uint32 i = 0 ; i < instances.size() ; i++ ) |
|
{ |
|
CIMObjectPath ref = _buildObjectPath(_operationNamespace, |
|
CIM_NAMESPACEINMANAGER_CLASSNAME, instances[i]); |
|
handler.deliver(ref); |
|
} |
|
} |
|
|
|
|
// ATTN: Exception response because of error | // ATTN: Exception response because of error |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
} | } |
| |
|
|
//************************************************************** | //************************************************************** |
//************************************************************** | //************************************************************** |
// Association Functions | // Association Functions |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::associatorNames()"); | "InteropProvider::associatorNames()"); |
throw CIMNotSupportedException("AssociationProvider::associators"); |
//throw CIMNotSupportedException("AssociationProvider::associators"); |
} | } |
| |
void InteropProvider::associatorNames( | void InteropProvider::associatorNames( |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::associatorNames()"); | "InteropProvider::associatorNames()"); |
throw CIMNotSupportedException("AssociationProvider::associatorNames"); |
//throw CIMNotSupportedException("AssociationProvider::associatorNames"); |
} | } |
| |
void InteropProvider::references( | void InteropProvider::references( |
|
|
{ | { |
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, | PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, |
"InteropProvider::references()"); | "InteropProvider::references()"); |
throw CIMNotSupportedException("AssociationProvider::references"); |
//throw CIMNotSupportedException("AssociationProvider::references"); |
} | } |
| |
void _filterAssocInstances(Array<CIMInstance>& instances, | void _filterAssocInstances(Array<CIMInstance>& instances, |
|
|
{ | { |
return; | return; |
} | } |
|
|
void InteropProvider::referenceNames( | void InteropProvider::referenceNames( |
const OperationContext & context, | const OperationContext & context, |
const CIMObjectPath & objectName, | const CIMObjectPath & objectName, |
|
|
| |
targetAssocClass classEnum = _verifyValidAssocClassInput(targetAssocClassName); | targetAssocClass classEnum = _verifyValidAssocClassInput(targetAssocClassName); |
| |
|
|
Array<CIMInstance> assocInstances; | Array<CIMInstance> assocInstances; |
| |
if (classEnum == CIM_COMMMECHANISMFORMANAGER) |
if (classEnum == CIM_COMMMECHANISMFORMANAGERASSOC) |
assocInstances = _buildInstancesCommMechanismForManager(); | assocInstances = _buildInstancesCommMechanismForManager(); |
| |
if (classEnum == CIM_NAMESPACEINMANAGER) |
if (classEnum == CIM_NAMESPACEINMANAGERASSOC) |
assocInstances = _buildInstancesNamespaceInManager(); | assocInstances = _buildInstancesNamespaceInManager(); |
| |
_filterAssocInstances(assocInstances, resultClass, role); | _filterAssocInstances(assocInstances, resultClass, role); |
|
|
targetAssocClassName, assocInstances[i]); | targetAssocClassName, assocInstances[i]); |
CDEBUG("referenceNames returns: " << ref.toString()); | CDEBUG("referenceNames returns: " << ref.toString()); |
handler.deliver(ref); | handler.deliver(ref); |
|
|
} | } |
|
|
handler.complete(); | handler.complete(); |
| |
PEG_METHOD_EXIT(); | PEG_METHOD_EXIT(); |
// Convert the instances to referenceNames response | // Convert the instances to referenceNames response |
|
|
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |