const CIMPropertyList WQLSelectStatementRep::getSelectPropertyList(
const CIMObjectPath& inClassName) const
{
//
// Check for "*"
//
if (_allProperties)
{
//
// Return null CIMPropertyList for all properties
//
return CIMPropertyList ();
}
CIMName className = inClassName.getClassName();
if (className.isNull())
{
//
// If the caller passed in an empty className, then the FROM class is
// to be used
//
className = _className;
}
//
// Check if inClassName is the FROM class
//
if (!(className == _className))
{
//
// Check for NULL Query Context
//
if (_ctx == NULL)
{
MessageLoaderParms parms
("WQL.WQLSelectStatementRep.QUERY_CONTEXT_IS_NULL",
"Trying to process a query with a NULL Query Context.");
throw QueryRuntimeException(parms);
}
//
// Check if inClassName is a subclass of the FROM class
//
if (!_ctx->isSubClass(_className,className))
{
MessageLoaderParms parms
("WQL.WQLSelectStatementRep.CLASS_NOT_FROM_LIST_CLASS",
"Class $0 does not match the FROM class or any of its "
"subclasses.",
className.getString());
throw QueryRuntimeException(parms);
}
}
//
// Return CIMPropertyList for properties referenced in the projection
// list (SELECT clause)
//
return CIMPropertyList (_selectPropertyNames);
}
CIMPropertyList WQLSelectStatementRep::getPropertyList(
const CIMObjectPath& inClassName)
{
if(_ctx == NULL){
MessageLoaderParms parms(
"WQL.WQLSelectStatementRep.QUERY_CONTEXT_IS_NULL",
"Trying to process a query with a NULL Query Context.");
throw QueryRuntimeException(parms);
}
if(_allProperties)
return CIMPropertyList();
CIMName className = inClassName.getClassName();
if (className.isNull())
{
// If the caller passed in an empty className, then the
// FROM class is to be used.
className = _className;
}
// check if inClassName is the From class
if(!(className == _className)){
// check if inClassName is a subclass of the From class
if(!_ctx->isSubClass(_className,className)){
MessageLoaderParms parms(
"WQL.WQLSelectStatementRep.CLASS_NOT_FROM_LIST_CLASS",
"Class $0 does not match the FROM class or any of its"
" subclasses.",
className.getString());
throw QueryRuntimeException(parms);
}
}
Array<CIMName> names =
getWherePropertyList(inClassName).getPropertyNameArray();
Array<CIMName> selectList =
getSelectPropertyList(inClassName).getPropertyNameArray();
// check for duplicates and remove them
for(Uint32 i = 0; i < names.size(); i++){
for(Uint32 j = 0; j < selectList.size(); j++){
if(names[i] == selectList[j])
selectList.remove(j);
}
}
names.appendArray(selectList);
CIMPropertyList list = CIMPropertyList();
list.set(names);
return list;
}
// Constructor
testEnumSequence::testEnumSequence(CIMClient& client, const char*nameSpace):
_nameSpace(nameSpace),
_className(),
_cimObjectName(),
_deepInheritance(true),
_includeClassOrigin(false),
_operationTimeout(25),
_continueOnError(false),
_maxObjectCount(100),
_filterQueryLanguage(""),
_filterQuery(""),
_role(""),
_resultRole(""),
_assocClass(CIMName()),
_resultClass(CIMName()),
_cimPropertyList(CIMPropertyList()),
_client(client),
_expectGoodReturn(true),
_expectedCIMExceptionCode(CIM_ERR_SUCCESS),
_expectedCIMExceptionMessage(""),
_returnedCIMExceptionCode(CIM_ERR_SUCCESS),
_testName("unknown"),
_operationName("unknown")
{}
CIMClass* mbGetClass(const CMPIBroker *mb, const CIMObjectPath &cop) {
DDD(cout<<"--- mbGetClass()"<<endl);
mb=CM_BROKER;
CMPI_Broker *xBroker=(CMPI_Broker*)mb;
String clsId=cop.getNameSpace().getString()+":"+cop.getClassName().getString();
CIMClass *ccp;
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
if (xBroker->clsCache) {
if (xBroker->clsCache->lookup(clsId,ccp)) return ccp;
}
else xBroker->clsCache=new ClassCache();
try {
CIMClass cc=CM_CIMOM(mb)->getClass(
OperationContext(),
cop.getNameSpace(),
cop.getClassName(),
(bool)0,
(bool)1,
(bool)0,
CIMPropertyList());
ccp=new CIMClass(cc);
xBroker->clsCache->insert(clsId,ccp);
return ccp;
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbGetClass - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
}
return NULL;
}
Array<CIMObjectPath> PG_TestPropertyTypes::_enumerateInstanceNames(
const OperationContext& context,
const CIMObjectPath& classReference)
{
Array<CIMObjectPath> instanceNames;
// get class definition from repository
CIMClass cimclass = _cimom.getClass(
context,
classReference.getNameSpace(),
classReference.getClassName(),
false,
true,
true,
CIMPropertyList());
// convert instances to references;
for (Uint32 i = 0; i < _instances.size(); i++)
{
CIMObjectPath tempRef = _instances[i].buildPath(cimclass);
// ensure references are fully qualified
tempRef.setHost(classReference.getHost());
tempRef.setNameSpace(classReference.getNameSpace());
instanceNames.append(tempRef);
}
return instanceNames;
}
PEGASUS_NAMESPACE_BEGIN
const CIMPropertyList FQLQueryExpressionRep::getPropertyList() const
{
PEGASUS_ASSERT(false);
return CIMPropertyList();
}
/*
Build an instance of the test class
*/
CIMInstance buildInstance(CIMClient& client, String& instanceId)
{
CIMClass cl = client.getClass(PROVIDERNS, TEST_CLASS);
CIMInstance inst = cl.buildInstance(false, false, CIMPropertyList());
setPropertyValue(inst, "Id", CIMValue(instanceId));
return inst;
}
void testClearMethod()
{
// Test with a variety of object types in the From ResponseData
// Build the class
CIMClass CIMclass1 = buildClass();
// Build a CIM Instance. NOTE: key is defaulted in class
CIMInstance CIMInst1 = CIMclass1.buildInstance(true, true,
CIMPropertyList());
// Clone the instance and change key
CIMInstance CIMInst2 = CIMInst1.clone();
setPropertyValue(CIMInst2, "id", 2);
CIMInstance CIMInst3 = CIMInst1.clone();
setPropertyValue(CIMInst3, "id", 3);
CIMInstance CIMInst4 = CIMInst1.clone();
setPropertyValue(CIMInst4, "id", 4);
// build CIMInstance array
Array<CIMInstance> CIMInstArray;
CIMInstArray.append(CIMInst1);
CIMInstArray.append(CIMInst2);
CIMInstArray.append(CIMInst3);
CIMInstArray.append(CIMInst4);
// Create CIMReponseData object
CIMResponseData crd = CIMResponseData(CIMResponseData::RESP_INSTANCES);
// Append an array of CIMInstances
crd.appendInstances(CIMInstArray);
PEGASUS_TEST_ASSERT(crd.size() == 4);
// Build SCMO instances
SCMOClass SCMO_CSClass(CIMclass1);
VCOUT << "Creating SCMOInstance from CIMInstance" << endl;
SCMOInstance SCMO_CSInstance3(SCMO_CSClass,CIMInst3);
SCMOInstance SCMO_CSInstance4(SCMO_CSClass,CIMInst4);
// Create array of 2 SCMO Instances
Array<SCMOInstance> SCMOInstArray;
SCMOInstArray.append(SCMO_CSInstance3);
SCMOInstArray.append(SCMO_CSInstance4);
crd.appendSCMO(SCMOInstArray);
PEGASUS_TEST_ASSERT(crd.size() == 6);
crd.clear();
PEGASUS_TEST_ASSERT(crd.size() == 0);
}
static Array<CIMInstance> _getDestinationQueues(CIMClient &client)
{
return client.enumerateInstances(
"root/PG_Internal",
"PG_ListenerDestinationQueue",
false,
false,
false,
false,
CIMPropertyList());
}
/////////////////////////////////////////////////////////////////////////////
// WMIInstanceProvider::getProperty
//
// ///////////////////////////////////////////////////////////////////////////
CIMValue WMIInstanceProvider::getProperty(
const String& nameSpace,
const String& userName,
const String& password,
const CIMObjectPath& instanceName,
const String& propertyName)
{
CIMInstance cimInstance;
Array<CIMName> propertyNames;
PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMIInstanceProvider::getProperty()");
setup(nameSpace,userName,password);
if (!m_bInitialized)
{
throw CIMException(CIM_ERR_FAILED, "[getProperty] m_bInitialized");
}
CIMName propName = propertyName;
propertyNames.append(propName);
CIMPropertyList propertyList = CIMPropertyList(propertyNames);
// get the relevant CIMInstance object
cimInstance = getCIMInstance(nameSpace,
userName,
password,
instanceName,
propertyList);
// now fetch the property
Uint32 pos = cimInstance.findProperty(propName);
if (PEG_NOT_FOUND == pos)
{
throw CIMException(CIM_ERR_NO_SUCH_PROPERTY,
"[getProperty] findproperty");
}
CIMProperty property = cimInstance.getProperty(pos);
// and return the value
CIMValue value = property.getValue();
PEG_METHOD_EXIT();
return value;
}
CIMClass compilerDeclContext::lookupClass(const CIMNamespaceName &nameSpace,
const CIMName &className) const
{
const CIMClass *pTheClass;
if (_ot != compilerCommonDefs::USE_REPOSITORY) {
if ( (pTheClass =_findClassInMemory(className)) )
return *pTheClass;
}
if (_repository && _ot != compilerCommonDefs::IGNORE_REPOSITORY) {
return _repository->_getClass(
nameSpace, className, false, true, true, CIMPropertyList());
}
return CIMClass();
}
//
// Builds an instance of the class named className. Gets Class defintion and
// fills in the correct properties from the class. This requires a repository
// getClass request for each instance built. The skeleton is built by
// creating the instance and copying qualifiers and properties from
// the class. Finally the instance is cloned to separate it from the
// original objects.
// NOTE: This is very inefficient for anything larger than a few instances.
// We should separate the get from the createSkeleton.
// @param className CIMName of the class for which the instance is to be built
// @return CIMInstance of this class with properties complete.
// @exception passes on any exceptions received from the repository request.
//
CIMInstance InteropProvider::buildInstanceSkeleton(
const CIMNamespaceName & nameSpace,
const CIMName& className,
Boolean includeQualifiers,
CIMClass& returnedClass)
{
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
"InteropProvider::_buildInstanceSkeleton()");
// get class with lo = false, qualifier = true classorig = true
returnedClass = repository->getClass(nameSpace,
className, false, true, true);
CIMInstance skeleton = returnedClass.buildInstance(
includeQualifiers, true, CIMPropertyList());
PEG_METHOD_EXIT();
return skeleton;
}
void PG_TestPropertyTypes::enumerateInstances(
const OperationContext& context,
const CIMObjectPath& ref,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList& propertyList,
InstanceResponseHandler& handler)
{
// ensure the Namespace is valid
if (!ref.getNameSpace().equal ("test/static"))
{
throw CIMException(CIM_ERR_INVALID_NAMESPACE);
}
// ensure the class existing in the specified namespace
if (!ref.getClassName().equal ("PG_TestPropertyTypes"))
{
throw CIMException(CIM_ERR_INVALID_CLASS);
}
// begin processing the request
handler.processing();
// NOTE: It would be much more efficient to remember the instance names
// get class definition from repository
CIMClass cimclass = _cimom.getClass(
context,
ref.getNameSpace(),
ref.getClassName(),
false,
true,
true,
CIMPropertyList());
for (Uint32 i = 0; i < _instances.size(); i++)
{
handler.deliver(_instances[i]);
}
// complete processing the request
handler.complete();
}
SCMOClass CIMServer::_scmoClassCache_GetClass(
const CIMNamespaceName& nameSpace,
const CIMName& className)
{
CIMClass cc;
PEG_METHOD_ENTER(TRC_SERVER, "CIMServer::_scmoClassCache_GetClass()");
try
{
cc = _cimserver->_repository->getClass(
nameSpace,
className,
false, // localOnly
true, // includeQualifiers
true, // includeClassOrigin
CIMPropertyList());
}
catch (Exception& e)
{
PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2,
"The class '%s' in the name space '%s' was not found. "
"The repository throws the following exception: %s",
(const char*)className.getString().getCString(),
(const char*)nameSpace.getString().getCString(),
(const char*)e.getMessage().getCString()));
// Return a empty class.
PEG_METHOD_EXIT();
return SCMOClass("","");
}
if (cc.isUninitialized())
{
// The requested class was not found !
// Return a empty class.
PEG_METHOD_EXIT();
return SCMOClass("","");
}
PEG_METHOD_EXIT();
return SCMOClass(cc,(const char*)nameSpace.getString().getCString());
}
/*****************************************************************************
*
* Implementation of InstanceProvider enumerateInstanceNames method
*
*****************************************************************************/
void InteropProvider::enumerateInstanceNames(
const OperationContext & context,
const CIMObjectPath & classReference,
ObjectPathResponseHandler & handler)
{
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
"InteropProvider::enumerateInstanceNames()");
initProvider();
PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4,
"%s enumerateInstanceNames. classReference= %s",
thisProvider,
(const char *) classReference.toString().getCString()));
// test for legal namespace for this provider. Exception if not
// namespaceSupported(classReference);
// NOTE: Above is commented out because the routing tables will always
// do the right thing and that's the only way requests get here.
// begin processing the request
handler.processing();
// Utilize the local enumeration method to retrieve the instances and
// extract the instance names.
Array<CIMInstance> instances = localEnumerateInstances(
context,
classReference,
CIMPropertyList());
for (Uint32 i = 0 ; i < instances.size() ; i++)
{
handler.deliver(instances[i].getPath());
}
handler.complete();
PEG_METHOD_EXIT();
}
/*****************************************************************************
*
* Implementation of AssociationProvider associatorNames method
*
*****************************************************************************/
void InteropProvider::associatorNames(
const OperationContext & context,
const CIMObjectPath & objectName,
const CIMName & associationClass,
const CIMName & resultClass,
const String & role,
const String & resultRole,
ObjectPathResponseHandler & handler)
{
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
"InteropProvider::associatorNames()");
initProvider();
PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4,
"%s associatorNames.objectName= %s, assocClass= %s resultClass= %s "
"role= %s resultRole = %s",
thisProvider,
(const char *)objectName.toString().getCString(),
(const char *)associationClass.getString().getCString(),
(const char *)resultClass.getString().getCString(),
(const char *)role.getCString(),
(const char *)resultRole.getCString()));
handler.processing();
String originRole = role;
String targetRole = resultRole;
Uint32 numIterations = 1;
//
// The localReferences call retrieves instances of the desired association
// class and sets the originRole and targetRole properties if currently
// empty.
//
if (associationClass.equal(PEGASUS_CLASSNAME_PG_REFERENCEDPROFILE))
{
if (originRole.size() == 0 && targetRole.size() == 0)
{
originRole = String("Antecedent");
targetRole = String("Dependent");
numIterations = 2;
}
}
for (Uint32 i = 0; i < numIterations; ++i)
{
Array<CIMInstance> refs = localReferences(
context,
objectName,
associationClass,
originRole,
targetRole,
CIMPropertyList(),
resultClass);
for (Uint32 j = 0, n = refs.size(); j < n; ++j)
{
CIMInstance & currentRef = refs[j];
CIMObjectPath currentTarget = getRequiredValue<CIMObjectPath>(
currentRef,
targetRole);
handler.deliver(currentTarget);
}
if (numIterations == 2)
{
originRole = String("Dependent");
targetRole = String("Antecedent");
}
}
handler.complete();
PEG_METHOD_EXIT();
}
//
// Class that determines whether or not the origin class in an association
// 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.
//
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 ))
{
//
// Search the cached conformingElements list for the originClass,
// returning false if it is not found
//
bool found = false;
PEGASUS_ASSERT(conformingElements.size() ==
elementNamespaces.size());
for(Uint32 i = 0, n = conformingElements.size(); i < n; ++i)
{
CIMNameArray & elementList = conformingElements[i];
CIMNamespaceArray & namespaceList = elementNamespaces[i];
PEGASUS_ASSERT(elementList.size() == namespaceList.size());
for(Uint32 j = 0, m = elementList.size(); j < m; ++j)
{
CIMName & curElement = elementList[j];
if((curElement == originClass ||
curElement.getString().find(PEGASUS_DYNAMIC) == 0) &&
opNamespace == namespaceList[j])
{
found = true;
break;
}
}
if(found)
break;
}
if(!found)
{
PEG_METHOD_EXIT();
return false;
}
}
}
else
{
// Otherwise, just get the enum value representing the origin class
// for this operation
originClassEnum = translateClassInput(originClass);
}
CIMName expectedTargetRole;
CIMName expectedOriginRole;
Array<CIMName> propNames;
String profileName;
CIMPropertyList propertyList;
CIMInstance tmpInstance;
Uint32 index;
propNames.clear();
//
// 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)
{
expectedTargetRole = PROPERTY_DEPENDENT;
expectedOriginRole = PROPERTY_ANTECEDENT;
}
else if(originClassEnum == PG_NAMESPACE)
{
expectedTargetRole = PROPERTY_ANTECEDENT;
expectedOriginRole = PROPERTY_DEPENDENT;
}
break;
case PG_COMMMECHANISMFORMANAGER:
if(originClassEnum == PG_OBJECTMANAGER)
{
expectedTargetRole = PROPERTY_DEPENDENT;
expectedOriginRole = PROPERTY_ANTECEDENT;
}
else if(originClassEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)
{
expectedTargetRole = PROPERTY_ANTECEDENT;
expectedOriginRole = PROPERTY_DEPENDENT;
}
break;
case PG_ELEMENTCONFORMSTOPROFILE:
if(originClass.equal(PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE))
{
expectedTargetRole =
ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT;
expectedOriginRole =
ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD;
}
else
{
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);
if (!tmpInstance.isUninitialized())
{
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;
case PG_SUBPROFILEREQUIRESPROFILE:
if(originClassEnum == PG_REGISTEREDPROFILE)
{
expectedTargetRole = PROPERTY_DEPENDENT;
expectedOriginRole = PROPERTY_ANTECEDENT;
}
else if(originClassEnum == PG_REGISTEREDSUBPROFILE)
{
expectedTargetRole = PROPERTY_ANTECEDENT;
expectedOriginRole = PROPERTY_DEPENDENT;
}
break;
case PG_REFERENCEDPROFILE:
if (originClassEnum == PG_REGISTEREDSUBPROFILE)
{
expectedTargetRole = PROPERTY_ANTECEDENT;
expectedOriginRole = PROPERTY_DEPENDENT;
}
else if (originClassEnum == PG_REGISTEREDPROFILE)
{
if ((targetProperty.size() != 0) &&
(originProperty.size() != 0) &&
String::equalNoCase(targetProperty, originProperty))
{
return false;
}
if (targetProperty.size() != 0)
{
if (!(String::equalNoCase(targetProperty, "Antecedent") ||
String::equalNoCase(targetProperty, "Dependent") ))
{
return false;
}
}
if (originProperty.size() != 0)
{
if (!(String::equalNoCase(originProperty, "Antecedent") ||
String::equalNoCase(originProperty, "Dependent") ))
{
return false;
}
}
if (String::equalNoCase(originProperty, "Antecedent") &&
targetProperty.size() == 0)
{
targetProperty = String("Dependent");
}
if (String::equalNoCase(originProperty, "Dependent") &&
targetProperty.size() == 0)
{
targetProperty = String("Antecedent");
}
if (String::equalNoCase(targetProperty, "Antecedent") &&
originProperty.size() == 0)
{
originProperty = String("Dependent");
}
if (String::equalNoCase(targetProperty, "Dependent") &&
originProperty.size() == 0)
{
originProperty = String("Antecedent");
}
return true;
}
break;
case PG_ELEMENTSOFTWAREIDENTITY:
if(originClassEnum == PG_SOFTWAREIDENTITY)
{
expectedTargetRole = PROPERTY_DEPENDENT;
expectedOriginRole = PROPERTY_ANTECEDENT;
}
else if(originClassEnum == PG_REGISTEREDPROFILE ||
originClassEnum == PG_REGISTEREDSUBPROFILE)
{
expectedTargetRole = PROPERTY_ANTECEDENT;
expectedOriginRole = PROPERTY_DEPENDENT;
}
break;
case PG_INSTALLEDSOFTWAREIDENTITY:
if(originClassEnum == PG_SOFTWAREIDENTITY)
{
expectedTargetRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM;
expectedOriginRole =
INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE;
}
else if(originClassEnum == PG_COMPUTERSYSTEM)
{
expectedTargetRole =
INSTALLEDSOFTWAREIDENTITY_PROPERTY_INSTALLEDSOFTWARE;
expectedOriginRole = INSTALLEDSOFTWAREIDENTITY_PROPERTY_SYSTEM;
}
break;
case PG_HOSTEDACCESSPOINT:
if(originClassEnum == PG_COMPUTERSYSTEM)
{
expectedTargetRole = PROPERTY_DEPENDENT;
expectedOriginRole = PROPERTY_ANTECEDENT;
}
else if(originClassEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)
{
expectedTargetRole = PROPERTY_ANTECEDENT;
expectedOriginRole = PROPERTY_DEPENDENT;
}
case PG_HOSTEDOBJECTMANAGER:
if(originClassEnum == PG_COMPUTERSYSTEM)
{
expectedTargetRole = PROPERTY_DEPENDENT;
expectedOriginRole = PROPERTY_ANTECEDENT;
}
else if(originClassEnum == PG_OBJECTMANAGER)
{
expectedTargetRole = PROPERTY_ANTECEDENT;
expectedOriginRole = PROPERTY_DEPENDENT;
}
break;
#ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT
case PG_HOSTEDINDICATIONSERVICE:
if(originClassEnum == PG_COMPUTERSYSTEM)
{
expectedTargetRole = PROPERTY_DEPENDENT;
expectedOriginRole = PROPERTY_ANTECEDENT;
}
break;
#endif
default:
break;
}
//
// 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())
{
PEG_METHOD_EXIT();
return false;
}
if(targetProperty.size() == 0)
{
targetProperty = expectedTargetRole.getString();
}
else if(!expectedTargetRole.equal(targetProperty))
{
PEG_METHOD_EXIT();
return false;
}
if(originProperty.size() == 0)
{
originProperty = expectedOriginRole.getString();
}
else if(!expectedOriginRole.equal(originProperty))
{
PEG_METHOD_EXIT();
return false;
}
PEG_METHOD_EXIT();
return true;
}
int main(int argc, char** argv)
{
#ifdef PEGASUS_HAS_SSL
try
{
String host = System::getHostName();
Uint32 port = System::lookupPort(WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);
//
// Note that these files are separate from the client.pem which represents the client's truststore.
//
const char* pegasusHome = getenv("PEGASUS_HOME");
String certPath = FileSystem::getAbsolutePath(pegasusHome, "clientkeystore/client_cert.pem");
String keyPath = FileSystem::getAbsolutePath(pegasusHome, "clientkeystore/client_key.pem");
PEGASUS_STD(cerr) << "certPath is " << certPath << "\n";
PEGASUS_STD(cerr) << "keyPath is " << keyPath << "\n";
String randPath = String::EMPTY;
#ifdef PEGASUS_SSL_RANDOMFILE
randPath = FileSystem::getAbsolutePath(pegasusHome, PEGASUS_SSLCLIENT_RANDOMFILE);
#endif
CIMClient client;
client.connect(
host,
port,
SSLContext("", certPath, keyPath, NULL, randPath),
String::EMPTY,
String::EMPTY);
//
// Do a generic call. We have to do this call to test whether or not we get 401'ed.
//
CIMClass cimClass = client.getClass(
CIMNamespaceName("root/cimv2"),
CIMName ("CIM_ManagedElement"),
true,
false,
false,
CIMPropertyList());
client.disconnect();
} catch (Exception& e)
{
PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);
PEGASUS_STD(cerr) << "Root cause could be PEGASUS_HAS_SSL is defined but enableHttpsConnection=false" << PEGASUS_STD(endl);
exit(1);
}
PEGASUS_STD(cout) << "+++++ passed all tests" << PEGASUS_STD(endl);
return 0;
#endif
//
// This returns a false positive result.
// But we should never get here since this test is only run if PEGASUS_HAS_SSL is defined.
//
return 0;
}
/*
Execute a defined query and return the instances found
*/
void testEnumerate(
CIMClient& client,
const String& query,
Uint32 testCount,
CIMStatusCode expectedError = CIM_ERR_SUCCESS)
{
Array<CIMInstance> pulledInstances;
Boolean endOfSequence = false;
CIMEnumerationContext enumerationContext;
try
{
pulledInstances = client.openEnumerateInstances(
enumerationContext,
endOfSequence,
PROVIDERNS,
TEST_CLASS,
true,
false,
CIMPropertyList(),
"DMTF:FQL",
query,
30,
false,
10);
if (expectedError != CIM_ERR_SUCCESS)
{
cout << "ERROR. Error code expected but good response receied."
<< endl;
}
}
catch (CIMException& e)
{
if (e.getCode() == expectedError)
{
VCOUT << "Error caught correctly. " << e.getCode() << endl;
return;
}
else
{
cout << "Error Rtn expected but Incorrect code received"
<< " Query " << query << endl;
exit(1);
}
}
while (!endOfSequence)
{
Array<CIMInstance> cimInstancesPulled = client.pullInstancesWithPath(
enumerationContext,
endOfSequence,
10);
pulledInstances.appendArray(cimInstancesPulled);
}
if (testCount != pulledInstances.size())
{
cout << "Incorrect Count returned. Expected " << testCount
<< " Received " << pulledInstances.size()
<< " Query " << query
<< endl;
exit(1);
}
else
{
return;
}
}
static void
_test2 (CIMClient & client)
{
Uint32 exceptions = 0;
CIMObjectPath instanceName;
Array < CIMKeyBinding > keyBindings;
keyBindings.append (CIMKeyBinding ("ElementNameName",
"TestCMPI_ExecQuery",
CIMKeyBinding::STRING));
instanceName.setNameSpace (providerNamespace);
instanceName.setClassName ("TestCMPI_ExecQuery");
instanceName.setKeyBindings (keyBindings);
/* Call the unsupported functions of the provider. */
try
{
CIMInstance instance (client.getInstance (providerNamespace,
instanceName));
} catch (const CIMException &)
{
exceptions ++;
}
try
{
client.deleteInstance (providerNamespace, instanceName);
} catch (const CIMException & )
{
exceptions ++;
}
CIMClass thisClass = client.getClass(
providerNamespace,
"TestCMPI_ExecQuery",
false,
true,
true,
CIMPropertyList());
Array<CIMName> propertyNameList;
propertyNameList.append(CIMName("ElementName"));
CIMPropertyList myPropertyList(propertyNameList);
// create the instance with the defined properties
CIMInstance newInstance = thisClass.buildInstance(true, true, myPropertyList);
newInstance.getProperty(0).setValue(CIMValue(String("TestCMPI_execQuery") ));
try
{
CIMObjectPath objectPath (client.createInstance (providerNamespace,
newInstance));
} catch (const CIMException &)
{
exceptions ++;
}
try
{
client.modifyInstance (providerNamespace, newInstance);
} catch (const CIMException &)
{
exceptions ++;
}
try
{
Array < CIMInstance > instances =
client.enumerateInstances (providerNamespace,
CIMName ("TestCMPI_ExecQuery"));
} catch (const CIMException &)
{
exceptions ++;
}
try
{
Array < CIMObjectPath > objectPaths =
client.enumerateInstanceNames (providerNamespace,
CIMName ("TestCMPI_ExecQuery"));
} catch (const CIMException &)
{
exceptions ++;
}
PEGASUS_TEST_ASSERT(exceptions == 6);
}
void _test3(CIMClient & client)
{
static const String NAMESPACE("test/TestProvider");
static const String CLASSNAME("cmpiPerf_TestClassA");
cout<<"enumerate instance request with empty prop list"<<endl;
{
try
{
Array<CIMName> propNames;
Array < CIMInstance > instances =
client.enumerateInstances(
NAMESPACE,
CLASSNAME,
true,
true,
false,
false,
CIMPropertyList(propNames) );
for(Uint32 i=0;i<instances.size();i++)
{
Uint32 propertyCount = instances[i].getPropertyCount();
if (verbose)
{
XmlWriter::printInstanceElement(instances[i]);
}
if(propertyCount == 0)
{
cout<<"Filter enumerateInstances test on "
<<"cmpiPerf_TestClassA SUCCEEDED :Filtering "
<<"the ciminstance with a empty property list "
<<"returned zero properties as expected"<<endl;
}
else
{
cout<<"Filter enumerateInstances test on "
<<"cmpiPerf_TestClassA FAILED:Filtering the"
<<"ciminstance with a empty property list returned "
<<"some properties which is not expected"<<endl;
//PEGASUS_TEST_ASSERT(false);
}
}
}catch (const CIMException &e)
{
cout << "CIMException(" << e.getCode() << "): " <<
e.getMessage() << endl;
}
}
cout<<"++++++++property list with wrong prop names"
<<" filtered output++++++++"<<endl;
{
try
{
Array<CIMName> propNames;
propNames.append(CIMName(String("theK")));
Array < CIMInstance > instances =
client.enumerateInstances(
NAMESPACE,
CLASSNAME,
true,
true,
false,
false,
CIMPropertyList(propNames) );
for(Uint32 i=0;i<instances.size();i++)
{
Uint32 propertyCount = instances[i].getPropertyCount();
if (verbose)
{
XmlWriter::printInstanceElement(instances[i]);
}
if(propertyCount == 0)
{
cout<<"Filter enumerateInstances test on "
<<"cmpiPerf_TestClassA SUCCEEDED :Filtering "
<<"the ciminstance with a wrong property list "
<<"returned zero properties as expected"<<endl;
}
else
{
cout<<"Filter enumerateInstances test on "
<<"cmpiPerf_TestClassA FAILED:Filtering the"
<<"ciminstance with a wrong property list returned "
<<" some properties which is not expected"<<endl;
PEGASUS_TEST_ASSERT(false);
}
}
}catch (const CIMException &e)
{
cout << "CIMException(" << e.getCode() << "): " <<
e.getMessage() << endl;
}
}
cout<<"++++++++property list with mentioned property names"
<<" filtered output++++++++"<<endl;
{
try
{
Array<CIMName> propNames;
propNames.append(CIMName(String("theKey")));
Array < CIMInstance > instances =
client.enumerateInstances (
NAMESPACE,
CLASSNAME,
true,
true,
false,
false,
CIMPropertyList(propNames) );
for(Uint32 i=0;i<instances.size();i++)
{
Uint32 propertyCount = instances[i].getPropertyCount();
Uint32 propNameCount = 0;
if (verbose)
{
XmlWriter::printInstanceElement(instances[i]);
}
for(Uint32 j=0;j<propertyCount;j++)
{
String propName=
instances[i].getProperty(j).getName().getString();
if((propName == "theKey") )
{
propNameCount++;
}
}
if((propertyCount == 1)&&(propNameCount == 1))
{
cout<<"Filter enumerateInstances test on "
<<"cmpiPerf_TestClassA SUCCEEDED :Filtering "
<<"the ciminstance with a mentioned property list "
<<"returned all properties as expected"<<endl;
}
else
{
cout<<"Filter enumerateInstances test on "
<<"cmpiPerf_TestClassA FAILED:Filtering the "
<<"ciminstance with a mentioned property list did "
<<"not return all properties as expected"<<endl;
PEGASUS_TEST_ASSERT(false);
}
}
}catch (const CIMException &e)
{
cout << "CIMException(" << e.getCode() << "): " <<
e.getMessage() << endl;
}
}
cout<<"++++++++NULL proplist filtered output++++++++"<<endl;
{
try
{
Array < CIMInstance > instances =
client.enumerateInstances(
NAMESPACE,
CLASSNAME,
true,
true,
false,
false,
CIMPropertyList());
for(Uint32 i=0;i<instances.size();i++)
{
Uint32 propertyCount = instances[i].getPropertyCount();
if (verbose)
{
XmlWriter::printInstanceElement(instances[i]);
cout<<"i::"<<i<<endl;
}
if(propertyCount == 24)
{
cout<<"Filter enumerateInstances test on "
<<"cmpiPerf_TestClassA SUCCEEDED :Filtering "
<<"the ciminstance with a NULL property list "
<<"returned all properties as expected"<<endl;
}
else
{
cout<<"Filter enumerateInstances test on "
<<"cmpiPerf_TestClassA FAILED:Filtering the "
<<"ciminstance with a NULL property list did not "
<<"return all properties as expected"<<endl;
PEGASUS_TEST_ASSERT(false);
}
}
}catch (const CIMException &e)
{
cout << "CIMException(" << e.getCode() << "): " <<
e.getMessage() << endl;
}
}
}
void _test4(CIMClient & client)
{
static const String NAMESPACE("test/TestProvider");
static const String CLASSNAME("cmpiPerf_TestClassA");
Array<CIMObjectPath> cimInstanceNames =
client.enumerateInstanceNames(
NAMESPACE,
CLASSNAME);
cout<<"+++++++++empty property list filtered output++++++"<<endl;
{
Array<CIMName> propNames;
for (Uint32 i = 0, n = cimInstanceNames.size(); i < n; i++)
{
CIMInstance cimInstance=client.getInstance(
NAMESPACE,
cimInstanceNames[i],
true,
false,
false,
CIMPropertyList(propNames));
if (verbose)
{
XmlWriter::printInstanceElement(cimInstance);
}
Uint32 propertyCount = cimInstance.getPropertyCount();
if(propertyCount == 0)
{
cout<<"Filter getInstance test on "
<<"cmpiPerf_TestClassA SUCCEEDED :Filtering "
<<"the ciminstance with a empty property list "
<<"returned zero properties as expected"<<endl;
}
else
{
cout<<"Filter getInstance test on cmpiPerf_TestClassA"
<<" FAILED:Filtering the ciminstance with a empty "
<<"property list returned some properties "
<<"which is not expected"<<endl;
PEGASUS_TEST_ASSERT(false);
}
}
}
cout<<"+++++++++wrong property list filtered output++++++"<<endl;
{
Array<CIMName> propNames;
propNames.append(CIMName(String("theK")));
for (Uint32 i = 0, n = cimInstanceNames.size(); i < n; i++)
{
CIMInstance cimInstance=client.getInstance(
NAMESPACE,
cimInstanceNames[i],
true,
false,
false,
CIMPropertyList(propNames));
if (verbose)
{
XmlWriter::printInstanceElement(cimInstance);
}
Uint32 propertyCount = cimInstance.getPropertyCount();
if(propertyCount == 0)
{
cout<<"Filter getInstance test on "
<<"cmpiPerf_TestClassA SUCCEEDED :Filtering "
<<"the ciminstance with a wrong property list "
<<"returned zero properties as expected"<<endl;
}
else
{
cout<<"Filter getInstance test on cmpiPerf_TestClassA"
<<" FAILED:Filtering the ciminstance with a wrong "
<<"property list returned some properties "
<<"which is not expected"<<endl;
PEGASUS_TEST_ASSERT(false);
}
}
}
cout<<"+++++++++NULL property list filtered output++++++"<<endl;
{
for (Uint32 i = 0, n = cimInstanceNames.size(); i < n; i++)
{
CIMInstance cimInstance=client.getInstance(
NAMESPACE,
cimInstanceNames[i],
true,
false,
false,
CIMPropertyList());
if (verbose)
{
XmlWriter::printInstanceElement(cimInstance);
}
Uint32 propertyCount = cimInstance.getPropertyCount();
if(propertyCount == 24)
{
cout<<"Filter getInstance test on "
<<"cmpiPerf_TestClassA SUCCEEDED :Filtering "
<<"the ciminstance with a NULL property list "
<<"returned all properties as expected"<<endl;
}
else
{
cout<<"Filter getInstance test on cmpiPerf_TestClassA"
<<" FAILED:Filtering the ciminstance with a NULL "
<<"property list did not return all properties "
<<"as expected"<<endl;
PEGASUS_TEST_ASSERT(false);
}
}
}
cout<<"+++++++++mentioned property list filtered output++++++"<<endl;
{
Array<CIMName> propNames;
propNames.append(CIMName(String("RequestedState")));
propNames.append(CIMName(String("theKey")));
for (Uint32 i = 0, n = cimInstanceNames.size(); i < n; i++)
{
CIMInstance cimInstance=client.getInstance(
NAMESPACE,
cimInstanceNames[i],
true,
false,
false,
CIMPropertyList(propNames));
if (verbose)
{
XmlWriter::printInstanceElement(cimInstance);
}
Uint32 propertyCount = cimInstance.getPropertyCount();
Uint32 propNameCount = 0;
for(Uint32 j=0;j<propertyCount;j++)
{
String propName=
cimInstance.getProperty(j).getName().
getString();
if((propName == "RequestedState")||(propName == "theKey"))
{
propNameCount++;
}
}
if((propertyCount == 2) && (propNameCount == 2))
{
cout<<"Filter getInstance test on "
<<"cmpiPerf_TestClassA SUCCEEDED :Filtering "
<<"the ciminstance with a mentioned property list "
<<"returned all properties as expected"<<endl;
}
else
{
cout<<"Filter getInstance test on cmpiPerf_TestClassA"
<<" FAILED:Filtering the ciminstance with a mentioned "
<<"property list did not return all properties "
<<"as expected"<<endl;
PEGASUS_TEST_ASSERT(false);
}
}
}
}
//
// Enumerates all of the ElementConformsToProfile association instances.
//
Array<CIMInstance> InteropProvider::enumElementConformsToProfileInstances(
const OperationContext & opContext, const CIMNamespaceName & opNamespace)
{
CIMClass elementConformsClass = repository->getClass(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE,
false, true, false);
AutoMutex holder(interopMut);
Array<CIMInstance> instances;
verifyCachedInfo();
// Loop through the cached profile Id's and related info about its
// conforming elements.
for (Uint32 i = 0, n = profileIds.size(); i < n; ++i)
{
String & profileId = profileIds[i];
Array<CIMName> & elementList = conformingElements[i];
Array<CIMNamespaceName> & namespaceList = elementNamespaces[i];
Array<CIMObjectPath> conformingElementPaths;
for (Uint32 j = 0, m = elementList.size(); j < m; ++j)
{
CIMName & currentElement = elementList[j];
CIMNamespaceName & currentNamespace = namespaceList[j];
if (opNamespace == PEGASUS_NAMESPACENAME_INTEROP ||
opNamespace == currentNamespace)
{
String currentElementStr(currentElement.getString());
if (currentElementStr.find(PEGASUS_DYNAMIC) == 0)
{
// If the provider profile registration did not provide a
// list of conforming elements (presumably because there is
// no such definite list), then the provider is required
// to provide instances of ElementConformsToProfile in the
// vendor namespace, so we do not generate instances.
if (opNamespace != PEGASUS_NAMESPACENAME_INTEROP)
{
continue;
}
CIMName subclassName(
currentElementStr.subString(PEGASUS_DYNAMIC_LEN));
Array<CIMInstance> elementConformsInstances =
cimomHandle.enumerateInstances(opContext,
currentNamespace, subclassName, true, false, false,
true, CIMPropertyList());
// Retrieve the Conforming Element
for (Uint32 k = 0, x = elementConformsInstances.size();
k < x; ++k)
{
CIMInstance & currentInstance =
elementConformsInstances[k];
// NOCHKSRC
// Make sure that the current instance points to the
// current profile ID.
CIMObjectPath profilePath =
getRequiredValue<CIMObjectPath>(
elementConformsInstances[k],
ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD);
// DOCHKSRC
const Array<CIMKeyBinding> & keys =
profilePath.getKeyBindings();
if (keys.size() != 1)
continue;
if (keys.size() == 1 && keys[0].getValue() == profileId)
{
// NOCHKSRC
conformingElementPaths.append(
getRequiredValue<CIMObjectPath>(
currentInstance,
ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT));
// DOCHKSRC
}
}
}
else
{
// All of the instances of the current element in the
// corresponding namespace conform to the current profile.
Array<CIMObjectPath> paths =
cimomHandle.enumerateInstanceNames(opContext,
currentNamespace, currentElement);
// Set the namespace in the paths just in case
for (Uint32 k = 0, x = paths.size();
k < x; ++k)
{
CIMObjectPath & curPath = paths[k];
curPath.setNameSpace(currentNamespace);
curPath.setHost(hostName);
}
conformingElementPaths.appendArray(paths);
}
}
}
// Create the object path for the RegisteredProfile using the given
// profileId.
CIMObjectPath profilePath = buildDependencyReference(
hostName, profileIds[i], PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);
// Build all of the ElementConformsToProfile instances for the current
// profile.
for (Uint32 k = 0, x = conformingElementPaths.size(); k < x; ++k)
{
instances.append(buildElementConformsToProfile(profilePath,
conformingElementPaths[k], elementConformsClass));
}
}
// Now add the default instance: the association between the Server Profile
// and the ObjectManager (if we're in the Interop namespace)
if (opNamespace == PEGASUS_NAMESPACENAME_INTEROP)
{
// Build up the Object Path for the server profile version 1.1.0
CIMObjectPath serverProfile = buildDependencyReference(
hostName,
buildProfileInstanceId(SNIA_NAME, "Server", SNIA_VER_110),
PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);
// Retrieve the Object Manager instance
CIMInstance objManager = getObjectManagerInstance();
instances.append(
buildElementConformsToProfile(
serverProfile,
objManager.getPath(),
elementConformsClass));
// Build up the Object Path for the server profile ver 1.2.0
// and add the elementconformstoprofile association instance
serverProfile = buildDependencyReference(
hostName,
buildProfileInstanceId(SNIA_NAME, "Server", SNIA_VER_120),
PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);
instances.append(
buildElementConformsToProfile(
serverProfile,
objManager.getPath(),
elementConformsClass));
}
return instances;
}
void PG_TestPropertyTypes::getInstance(
const OperationContext& context,
const CIMObjectPath& instanceReference,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList& propertyList,
InstanceResponseHandler& handler)
{
// synchronously get references
//Get extra instance created for testing negative realValues.
Array<CIMObjectPath> references =
_enumerateInstanceNames(context, instanceReference);
// ensure the InstanceId key is valid
Array<CIMKeyBinding> keys = instanceReference.getKeyBindings();
Uint32 i;
for (i=0; i<keys.size() && !keys[i].getName().equal("InstanceId"); i++);
if (i==keys.size())
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
// ensure the Namespace is valid
if (!instanceReference.getNameSpace().equal ("test/static"))
{
throw CIMException(CIM_ERR_INVALID_NAMESPACE);
}
// ensure the class existing in the specified namespace
if (!instanceReference.getClassName().equal ("PG_TestPropertyTypes"))
{
throw CIMException(CIM_ERR_INVALID_CLASS);
}
Boolean testRealValue = false;
// ensure the request object exists
Uint32 index = findObjectPath(references, instanceReference);
if (index == PEG_NOT_FOUND)
{
CIMClass cimclass = _cimom.getClass(
context,
instanceReference.getNameSpace(),
instanceReference.getClassName(),
false,
true,
true,
CIMPropertyList());
CIMObjectPath tempRef = realValueTestInstance.buildPath(cimclass);
tempRef.setHost(instanceReference.getHost());
tempRef.setNameSpace(instanceReference.getNameSpace());
if (instanceReference != tempRef)
{
throw CIMException(CIM_ERR_NOT_FOUND);
}
testRealValue = true;
}
// begin processing the request
handler.processing();
if (testRealValue)
{
handler.deliver(realValueTestInstance);
}
else
{
// instance index corresponds to reference index
handler.deliver(_instances[index]);
}
// complete processing the request
handler.complete();
}
PEGASUS_NAMESPACE_BEGIN
/*****************************************************************************
*
* Implementation of AssociationProvider associators method
*
*****************************************************************************/
void InteropProvider::associators(
const OperationContext & context,
const CIMObjectPath & objectName,
const CIMName & associationClass,
const CIMName & resultClass,
const String & role,
const String & resultRole,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList & propertyList,
ObjectResponseHandler & handler)
{
PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
"InteropProvider::associators()");
initProvider();
PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4,
"%s associators. objectName= %s, assocClass= %s resultClass= %s "
"role= %s resultRole %s, includeQualifiers= %s, "
"includeClassOrigin= %s, PropertyList= %s",
thisProvider,
(const char *)objectName.toString().getCString(),
(const char *)associationClass.getString().getCString(),
(const char *)resultClass.getString().getCString(),
(const char *)role.getCString(),
(const char *)resultRole.getCString(),
boolToString(includeQualifiers),
boolToString(includeClassOrigin),
(const char *)propertyListToString(propertyList).getCString()));
handler.processing();
String originRole = role;
String targetRole = resultRole;
Uint32 numIterations = 1;
//
// The localReferences call retrieves instances of the desired association
// class and sets the originRole and targetRole properties if currently
// empty.
//
if (associationClass.equal(PEGASUS_CLASSNAME_PG_REFERENCEDPROFILE))
{
if (originRole.size() == 0 && targetRole.size() == 0)
{
originRole = String("Antecedent");
targetRole = String("Dependent");
numIterations = 2;
}
}
for (Uint32 i = 0; i < numIterations; ++i)
{
Array<CIMInstance> refs = localReferences(
context,
objectName,
associationClass,
originRole,
targetRole,
CIMPropertyList(),
resultClass);
if( refs.size() )
{
Array<CIMInstance> refObjs =
getReferencedInstances(refs,targetRole,context,propertyList);
ConstArrayIterator<CIMInstance> refsIterator(refObjs);
for(Uint32 i = 0; i < refsIterator.size(); i++)
{
handler.deliver(refsIterator[i]);
}
}
if (numIterations == 2)
{
originRole = String("Dependent");
targetRole = String("Antecedent");
}
}
handler.complete();
PEG_METHOD_EXIT();
}
int main()
{
String host;
#ifdef PEGASUS_HAS_SSL
host = System::getHostName();
Uint32 port = System::lookupPort(
WBEM_HTTPS_SERVICE_NAME, WBEM_DEFAULT_HTTPS_PORT);
const char* pegasusHome = getenv("PEGASUS_HOME");
String cipherSuite;
String trustStorePath;
String certPath;
String keyPath;
String randPath;
# ifdef PEGASUS_SSL_RANDOMFILE
randPath = FileSystem::getAbsolutePath(
pegasusHome, PEGASUS_SSLCLIENT_RANDOMFILE);
# endif
CIMClient *cc = new CIMClient ();
SSLContext *sslContext = 0;
cipherSuite = "LOW";
try
{
sslContext = new SSLContext (trustStorePath, certPath, keyPath,
String::EMPTY, 0, randPath, cipherSuite);
if (sslContext)
{
cc->connect (host, port, *sslContext, "", "");
//
// Do a generic call. We have to do this call to test whether or
// not we get 401'ed.
//
PEGASUS_TEST_ASSERT(0);
cc->disconnect();
}
}
catch(Exception &e)
{
cout << "SSLCipherTest: "<< e.getMessage() << endl;
cout << "Test passed. Connecting with cipher list as " << cipherSuite
<< " failed " << endl;
}
cipherSuite = "HIGH";
try
{
sslContext = new SSLContext (trustStorePath, certPath, keyPath,
String::EMPTY, 0, randPath, cipherSuite);
if (sslContext)
{
cc->connect (host, port, *sslContext, "", "");
//
// Do a generic call. We have to do this call to test whether or
// not we get 401'ed.
//
CIMClass cimClass = cc->getClass(CIMNamespaceName("root/cimv2"),
CIMName ("CIM_ManagedElement"), true, false, false,
CIMPropertyList());
cc->disconnect();
}
}
catch(Exception &e)
{
cerr << "SSLCipherTest Error: "<< e.getMessage() << endl;
PEGASUS_TEST_ASSERT(0);
}
cout << "Test passed. Connected with cipher suite as " << cipherSuite
<< endl;
cout << "+++++ passed all tests" << endl;
return 0;
#endif
//
// This returns a false positive result.
// But we should never get here since this test is only run if
// PEGASUS_HAS_SSL is defined.
//
return 0;
}
// l10n - note: ignoring indication language
void snmpIndicationHandler::handleIndication(
const OperationContext& context,
const String nameSpace,
CIMInstance& indication,
CIMInstance& handler,
CIMInstance& subscription,
ContentLanguageList & contentLanguages)
{
Array<String> propOIDs;
Array<String> propTYPEs;
Array<String> propVALUEs;
Array<String> mapStr;
PEG_METHOD_ENTER(TRC_IND_HANDLER,
"snmpIndicationHandler::handleIndication");
try
{
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"snmpIndicationHandler %s:%s.%s processing %s Indication",
(const char*)(nameSpace.getCString()),
(const char*)(handler.getClassName().getString().getCString()),
(const char*)(handler.getProperty(
handler.findProperty(PEGASUS_PROPERTYNAME_NAME)).
getValue().toString().getCString()),
(const char*)(indication.getClassName().getString().
getCString())));
CIMClass indicationClass = _repository->getClass(
nameSpace, indication.getClassName(), false, true,
false, CIMPropertyList());
Uint32 propertyCount = indication.getPropertyCount();
for (Uint32 i=0; i < propertyCount; i++)
{
CIMProperty prop = indication.getProperty(i);
Uint32 propDeclPos = indicationClass.findProperty(prop.getName());
if (propDeclPos != PEG_NOT_FOUND)
{
CIMProperty propDecl = indicationClass.getProperty(propDeclPos);
Uint32 qualifierPos =
propDecl.findQualifier(CIMName("MappingStrings"));
if (qualifierPos != PEG_NOT_FOUND)
{
//
// We are looking for following fields:
// MappingStrings {"OID.IETF | SNMP." oidStr,
// "DataType.IETF |" dataType}
// oidStr is the object identifier (e.g. "1.3.6.1.2.1.5..."
// dataType is either Integer, or OctetString,
// or OID
// Following is one example:
// MappingStrings {"OID.IETF | SNMP.1.3.6.6.3.1.1.5.2",
// "DataType.IETF | Integer"}
//
propDecl.getQualifier(qualifierPos).getValue().get(
mapStr);
String oidStr, dataType;
String mapStr1, mapStr2;
Boolean isValidAuthority = false;
Boolean isValidDataType = false;
for (Uint32 j=0; j < mapStr.size(); j++)
{
Uint32 barPos = mapStr[j].find("|");
if (barPos != PEG_NOT_FOUND)
{
mapStr1 = mapStr[j].subString(0, barPos);
mapStr2 = mapStr[j].subString(barPos + 1);
_trimWhitespace(mapStr1);
_trimWhitespace(mapStr2);
if ((mapStr1 == "OID.IETF") &&
(String::compare(mapStr2,
String("SNMP."), 5) == 0))
{
isValidAuthority = true;
oidStr = mapStr2.subString(5);
}
else if (mapStr1 == "DataType.IETF")
{
isValidDataType = true;
dataType = mapStr2;
}
if (isValidAuthority && isValidDataType)
{
propOIDs.append(oidStr);
propTYPEs.append(dataType);
propVALUEs.append(prop.getValue().toString());
break;
}
}
}
}
}
}
// Collected complete data in arrays and ready to send the trap.
// trap destination and SNMP type are defined in handlerInstance
// and passing this instance as it is to deliverTrap() call
Uint32 targetHostPos = handler.findProperty(CIMName("TargetHost"));
Uint32 targetHostFormatPos =
handler.findProperty(CIMName("TargetHostFormat"));
Uint32 otherTargetHostFormatPos =
handler.findProperty(CIMName("OtherTargetHostFormat"));
Uint32 portNumberPos = handler.findProperty(CIMName("PortNumber"));
Uint32 snmpVersionPos = handler.findProperty(CIMName("SNMPVersion"));
Uint32 securityNamePos =
handler.findProperty(CIMName("SNMPSecurityName"));
Uint32 engineIDPos = handler.findProperty(CIMName("SNMPEngineID"));
Uint32 snmpSecLevelPos =
handler.findProperty(CIMName("SNMPSecurityLevel"));
Uint32 snmpSecAuthProtoPos =
handler.findProperty(CIMName("SNMPSecurityAuthProtocol"));
Uint32 snmpSecAuthKeyPos =
handler.findProperty(CIMName("SNMPSecurityAuthKey"));
Uint32 snmpSecPrivProtoPos =
handler.findProperty(CIMName("SNMPSecurityPrivProtocol"));
Uint32 snmpSecPrivKeyPos =
handler.findProperty(CIMName("SNMPSecurityPrivKey"));
if (targetHostPos == PEG_NOT_FOUND)
{
PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,
"Target host is not set for IndicationHandlerSNMPMapper %s"
" Indication.",
(const char*)(indication.getClassName().getString().
getCString())));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"INVALID_SNMP_INSTANCE",
"Invalid IndicationHandlerSNMPMapper instance"));
}
if (targetHostFormatPos == PEG_NOT_FOUND)
{
PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,
"Target host format is not set for IndicationHandlerSNMPMapper"
" %s Indication.",
(const char*)(indication.getClassName().getString().
getCString())));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"INVALID_SNMP_INSTANCE",
"Invalid IndicationHandlerSNMPMapper instance"));
}
if (snmpVersionPos == PEG_NOT_FOUND)
{
PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,
"SNMP Version is not set for IndicationHandlerSNMPMapper %s"
" Indication.",
(const char*)(indication.getClassName().getString().
getCString())));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"INVALID_SNMP_INSTANCE",
"Invalid IndicationHandlerSNMPMapper instance"));
}
else
{
// properties from the handler instance
String targetHost;
String otherTargetHostFormat = String();
String securityName = String();
String engineID = String();
Uint16 targetHostFormat = 0;
Uint16 snmpVersion = 0;
Uint32 portNumber;
Uint8 snmpSecLevel = 1; // noAuthnoPriv
Uint8 snmpSecAuthProto = 0;
Array<Uint8> snmpSecAuthKey;// no key
Uint8 snmpSecPrivProto = 0;
Array<Uint8> snmpSecPrivKey ;// no key
String trapOid;
Boolean trapOidAvailable = false;
//
// Get snmpTrapOid from context
//
if (context.contains(SnmpTrapOidContainer::NAME))
{
SnmpTrapOidContainer trapContainer =
context.get(SnmpTrapOidContainer::NAME);
trapOid = trapContainer.getSnmpTrapOid();
trapOidAvailable = true;
}
else
{
// get trapOid from indication Class
Uint32 pos =
indicationClass.findQualifier(CIMName("MappingStrings"));
if (pos != PEG_NOT_FOUND)
{
Array<String> classMapStr;
indicationClass.getQualifier(pos).getValue().
get(classMapStr);
for (Uint32 i=0; i < classMapStr.size(); i++)
{
Uint32 barPos = classMapStr[i].find("|");
if (barPos != PEG_NOT_FOUND)
{
String authorityName =
classMapStr[i].subString(0, barPos);
String oidStr = classMapStr[i].subString(
barPos+1, PEG_NOT_FOUND);
_trimWhitespace(authorityName);
_trimWhitespace(oidStr);
if ((authorityName == "OID.IETF") &&
(String::compare(oidStr,
String("SNMP."), 5) == 0))
{
trapOid = oidStr.subString(5);
trapOidAvailable = true;
break;
}
}
}
if (!trapOidAvailable)
{
PEG_TRACE((
TRC_IND_HANDLER,
Tracer::LEVEL1,
"No MappingStrings for snmp trap is specified "
"for class: %s",
(const char*)
indication.getClassName().getString().getCString()
));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(
CIM_ERR_FAILED,
MessageLoaderParms(
"Handler.snmpIndicationHandler."
"snmpIndicationHandler.NO_MS_FOR_SNMP_TRAP",
"No MappingStrings for snmp trap is specified "
"for class: $0",
indication.getClassName().getString()));
}
}
else
{
PEG_TRACE_CSTRING(TRC_IND_HANDLER, Tracer::LEVEL1,
"Qualifier MappingStrings can not be found.");
PEG_METHOD_EXIT();
MessageLoaderParms parms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"QUALIFIER_MAPPINGS_NOT_FOUND",
"Qualifier MappingStrings can not be found");
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);
}
}
handler.getProperty(targetHostPos).getValue().get(targetHost);
handler.getProperty(targetHostFormatPos).getValue().get(
targetHostFormat);
if (otherTargetHostFormatPos != PEG_NOT_FOUND)
{
handler.getProperty(otherTargetHostFormatPos).getValue().get(
otherTargetHostFormat);
}
if (portNumberPos != PEG_NOT_FOUND)
{
handler.getProperty(portNumberPos).getValue().get(portNumber);
}
else
{
// default port
portNumber = SNMP_TRAP_DEFAULT_PORT;
}
handler.getProperty(snmpVersionPos).getValue().get(snmpVersion);
if (securityNamePos != PEG_NOT_FOUND)
{
handler.getProperty(securityNamePos).getValue().get(
securityName);
}
if (engineIDPos != PEG_NOT_FOUND)
{
handler.getProperty(engineIDPos).getValue().get(engineID);
}
if(snmpVersion == 5) // SNMPv3 Trap
{
//fetch the security data
if(snmpSecLevelPos != PEG_NOT_FOUND)
{
handler.getProperty(snmpSecLevelPos).getValue(). \
get(snmpSecLevel);
}
if(snmpSecAuthProtoPos != PEG_NOT_FOUND)
{
handler.getProperty(snmpSecAuthProtoPos).getValue(). \
get(snmpSecAuthProto);
}
if(snmpSecAuthKeyPos != PEG_NOT_FOUND)
{
handler.getProperty(snmpSecAuthKeyPos).getValue(). \
get(snmpSecAuthKey);
}
if(snmpSecPrivProtoPos != PEG_NOT_FOUND)
{
handler.getProperty(snmpSecPrivProtoPos).getValue(). \
get(snmpSecPrivProto);
}
if(snmpSecPrivKeyPos!= PEG_NOT_FOUND)
{
handler.getProperty(snmpSecPrivKeyPos).getValue(). \
get(snmpSecPrivKey);
}
}
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"snmpIndicationHandler sending %s Indication trap %s to target"
" host %s target port %d",
(const char*)(indication.getClassName().getString().
getCString()),
(const char*)(trapOid.getCString()),
(const char*)(targetHost.getCString()),portNumber));
_snmpTrapSender->deliverTrap(
trapOid,
securityName,
targetHost,
targetHostFormat,
otherTargetHostFormat,
portNumber,
snmpVersion,
engineID,
snmpSecLevel,
snmpSecAuthProto,
snmpSecAuthKey,
snmpSecPrivProto,
snmpSecPrivKey,
propOIDs,
propTYPEs,
propVALUEs);
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"%s Indication trap %s sent to target host %s target port %d "
"successfully",
(const char*)(indication.getClassName().getString().getCString()),
(const char*)(trapOid.getCString()),
(const char*)(targetHost.getCString()),portNumber));
}
}
catch (CIMException& c)
{
PEG_TRACE((TRC_IND_HANDLER, Tracer::LEVEL1, "CIMException %s",
(const char*)c.getMessage().getCString()));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, c.getMessage());
}
catch (Exception& e)
{
PEG_TRACE((TRC_IND_HANDLER, Tracer::LEVEL1, "Exception %s",
(const char*)e.getMessage().getCString()));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, e.getMessage());
}
catch (...)
{
PEG_TRACE_CSTRING(TRC_IND_HANDLER, Tracer::LEVEL1,
"Failed to deliver trap.");
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"FAILED_TO_DELIVER_TRAP",
"Failed to deliver trap."));
}
PEG_METHOD_EXIT();
}
void testReferences(
CIMClient& client,
const String& query,
CIMObjectPath targetPath,
Uint32 testCount,
CIMStatusCode expectedError = CIM_ERR_SUCCESS)
{
Array<CIMInstance> pulledInstances;
Boolean endOfSequence = false;
CIMEnumerationContext enumerationContext;
//CIMObjectPath assoc = CIMObjectPath("TEST_CLASS.Id=\"Mike"\")
try
{
pulledInstances = client.openReferenceInstances(
enumerationContext,
endOfSequence,
PROVIDERNS,
targetPath,
CIMName(),
String(),
false,
CIMPropertyList(),
"DMTF:FQL",
query,
30,
false,
10);
if (expectedError != CIM_ERR_SUCCESS)
{
cout << "ERROR. Error code expected but good response receied."
<< endl;
}
}
catch (CIMException& e)
{
if (e.getCode() == expectedError)
{
VCOUT << "Error caught correctly. " << e.getCode() << endl;
return;
}
else
{
cout << "Error Rtn expected but Incorrect code received"
<< " Query " << query << " Expected " << expectedError
<< " received " << e.getCode()
<< " msg " << e.getMessage() << endl;
exit(1);
}
}
while (!endOfSequence)
{
Array<CIMInstance> cimInstancesPulled = client.pullInstancesWithPath(
enumerationContext,
endOfSequence,
10);
pulledInstances.appendArray(cimInstancesPulled);
}
VCOUT << "pullAssociators " << targetPath.toString()
<< " returned " << pulledInstances.size() << " instances."
<< endl;
if (testCount != pulledInstances.size())
{
cout << "Incorrect Count returned. Expected " << testCount
<< " Received " << pulledInstances.size()
<< " Query " << query
<< endl;
exit(1);
}
else
{
return;
}
}
//
// Method that caches certain profile registration information. Specifically,
// information pertaining to the ElementConformsToProfofile association
// implementation is kept here.
//
void InteropProvider::cacheProfileRegistrationInfo()
{
Array<CIMInstance> instances;
Array<CIMInstance> providerCapabilitiesInstances;
// Clear existing cache
profileIds.clear();
conformingElements.clear();
elementNamespaces.clear();
// Retrieve all of the provider profile registration info
Array<CIMName> propList;
propList.append(CAPABILITIES_PROPERTY_PROVIDERMODULENAME);
propList.append(CAPABILITIES_PROPERTY_PROVIDERNAME);
propList.append(PROFILECAPABILITIES_PROPERTY_PROFILEVERSION);
propList.append(PROFILECAPABILITIES_PROPERTY_REGISTEREDPROFILE);
propList.append(PROFILECAPABILITIES_PROPERTY_OTHERREGISTEREDPROFILE);
propList.append(PROFILECAPABILITIES_PROPERTY_OTHERPROFILEORGANIZATION);
propList.append(PROFILECAPABILITIES_PROPERTY_CONFORMINGELEMENTS);
Array<CIMInstance> providerProfileInstances =
enumProviderProfileCapabilityInstances(
true,
false,
false,
false,
CIMPropertyList(propList));
CIMClass elementConformsClass = repository->getClass(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE,
false, true, false);
CIMClass registeredProfileClass = repository->getClass(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE,
false, true, false);
Array<CIMInstance> capabilities;
// Loop through the provider profile info to determine what profiles are
// supported by what providers, and to build the ElementConformsToProfile
// associations.
for (Uint32 i = 0, n = providerProfileInstances.size(); i < n; ++i)
{
CIMInstance & currentProfileInstance = providerProfileInstances[i];
String moduleName = getRequiredValue<String>(currentProfileInstance,
CAPABILITIES_PROPERTY_PROVIDERMODULENAME);
String providerName = getRequiredValue<String>(currentProfileInstance,
CAPABILITIES_PROPERTY_PROVIDERNAME);
String profileName;
Uint16 profileOrganization = 0;
String profileVersion;
String organizationName;
Array<String> profileNames; // Not going to use this info
Array<String> profileVersions; // Not going to use this info
Array<Uint16> profileOrganizations; // Not going to use this info
Array<String> profileOrganizationNames; // Not going to use this info
Array<String> providerModuleNames; // Not going to use this info
Array<String> providerNames; // Not going to use this info
String profileId = extractProfileInfo(currentProfileInstance,
profileCapabilitiesClass,
registeredProfileClass,
profileName,
profileVersion,
profileOrganization,
organizationName,
profileNames,
profileVersions,
profileOrganizations,
profileOrganizationNames,
providerModuleNames,
providerNames,
true);
Uint32 propIndex = currentProfileInstance.findProperty(
PROFILECAPABILITIES_PROPERTY_CONFORMINGELEMENTS);
Array<CIMName> elementPropArray;
elementPropArray.append(
ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD);
elementPropArray.append(
ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT);
CIMPropertyList elementPropList(elementPropArray);
Array<CIMName> conformingElementsForProfile;
Array<CIMNamespaceName> elementNamespacesForProfile;
Array<String> elementClasses;
currentProfileInstance.getProperty(propIndex).getValue().get(
elementClasses);
//if (propIndex == PEG_NOT_FOUND)
if (elementClasses.size() == 0)
{
// Get the namespaces in which this provider operates and trim down
// the list of capabilities instaces to just those that are related
// to this one.
if (capabilities.size() == 0)
{
Array<CIMName> capPropList;
capPropList.append(
PROVIDERCAPABILITIES_PROPERTY_PROVIDERMODULENAME);
capPropList.append(PROVIDERCAPABILITIES_PROPERTY_PROVIDERNAME);
capPropList.append(PROVIDERCAPABILITIES_PROPERTY_NAMESPACES);
capPropList.append(PROVIDERCAPABILITIES_PROPERTY_CLASSNAME);
capabilities = repository->enumerateInstancesForClass(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PROVIDERCAPABILITIES, false, false,
false);
}
Array<CIMInstance> capabilitiesForProvider;
Array<CIMNamespaceName> namespacesForProvider;
Array<CIMNameArray> subclassesForNamespace;
for (Uint32 j = 0, m = capabilities.size(); j < m; ++j)
{
CIMInstance & currentInstance = capabilities[j];
String curModuleName = getRequiredValue<String>(
currentInstance, CAPABILITIES_PROPERTY_PROVIDERMODULENAME);
String curProviderName = getRequiredValue<String>(
currentInstance, CAPABILITIES_PROPERTY_PROVIDERNAME);
if (curModuleName == moduleName &&
curProviderName == providerName)
{
CIMName currentClass(getRequiredValue<String>(
currentInstance,
PROVIDERCAPABILITIES_PROPERTY_CLASSNAME));
capabilitiesForProvider.append(currentInstance);
StringArray curNamespaces =
getRequiredValue<StringArray>(currentInstance,
PROVIDERCAPABILITIES_PROPERTY_NAMESPACES);
Sint32 z = 0;
Sint32 y = curNamespaces.size();
// If one of the namespaces is Interop, then continue
bool interopNamespaceFound = false;
for (; z < y; ++z)
{
if (CIMNamespaceName(curNamespaces[z]) ==
PEGASUS_NAMESPACENAME_INTEROP)
{
interopNamespaceFound = true;
break;
}
}
if (interopNamespaceFound)
continue;
// See if the current namespaces are already listed
for (Sint32 w = 0; w < y; ++w)
{
Sint32 foundIndex = -1;
CIMNamespaceName curNamespace = curNamespaces[w];
Uint32 k = 0;
Uint32 x = namespacesForProvider.size();
for (; k < x; ++k)
{
if (curNamespace == namespacesForProvider[k])
{
foundIndex = (Sint32)k;
break;
}
}
if (foundIndex == -1)
{
// Get all the subclasses of
// ElementConformsToProfile in the namespace and
// cache them.
foundIndex = namespacesForProvider.size();
Array<CIMName> subClasses =
repository->enumerateClassNames(curNamespace,
PEGASUS_CLASSNAME_CIM_ELEMENTCONFORMSTOPROFILE,
true);
subClasses.append(
PEGASUS_CLASSNAME_CIM_ELEMENTCONFORMSTOPROFILE
);
namespacesForProvider.append(curNamespace);
subclassesForNamespace.append(subClasses);
}
// Now search to see if the current class is one of the
// subclasses in this namespace, and finally, if it is
// add it to the list
Array<CIMName> & subClasses =
subclassesForNamespace[foundIndex];
for (k = 0, x = subClasses.size(); k < x; ++k)
{
if (subClasses[k] == currentClass)
{
String dynamicElement = PEGASUS_DYNAMIC +
currentClass.getString();
conformingElementsForProfile.append(
dynamicElement);
elementNamespacesForProfile.append(
curNamespace);
}
}
}
}
}
}
else
{
//Array<String> elementClasses;
//currentProfileInstance.getProperty(propIndex).getValue().get(
// elementClasses);
for (Uint32 j = 0, m = elementClasses.size(); j < m; ++j)
{
CIMName elementClass(elementClasses[j]);
Array<String> searchNamespaces =
findProviderNamespacesForElement(
moduleName, providerName,
elementClass,
repository,
providerCapabilitiesInstances);
Uint32 k = 0;
Uint32 x = searchNamespaces.size();
for (; k < x; ++k)
{
conformingElementsForProfile.append(elementClass);
elementNamespacesForProfile.append(searchNamespaces[k]);
}
}
}
Sint32 foundIndex = -1;
for (Sint32 j = 0, m = profileIds.size(); j < m; ++j)
{
if (profileIds[j] == profileId)
{
foundIndex = j;
break;
}
}
if (foundIndex >= 0)
{
// Append the results to already existing entries
conformingElements[foundIndex].appendArray(
conformingElementsForProfile);
elementNamespaces[foundIndex].appendArray(
elementNamespacesForProfile);
}
else
{
profileIds.append(profileId);
conformingElements.append(conformingElementsForProfile);
elementNamespaces.append(elementNamespacesForProfile);
}
}
}
//
// Test of the Instance creation and instance filtering
//
void test04()
{
if (verbose)
{
cout << "Test04 - Create instance from Class. " << endl;
}
const CIMNamespaceName NAMESPACE = CIMNamespaceName("/zzz");
// Create and populate a declaration context:
SimpleDeclContext* context = new SimpleDeclContext;
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("counter"), false,
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("classcounter"), false,
CIMScope::CLASS));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("min"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("max"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(NAMESPACE,
CIMQualifierDecl(CIMName("Description"), String(),
CIMScope::PROPERTY));
CIMClass class1(CIMName("MyClass"));
class1
.addProperty(CIMProperty(CIMName("count"), Uint32(55))
.addQualifier(CIMQualifier(CIMName("counter"), true))
.addQualifier(CIMQualifier(CIMName("min"), String("0")))
.addQualifier(CIMQualifier(CIMName("max"), String("1"))))
.addProperty(CIMProperty(CIMName("message"), String("Hello"))
.addQualifier(CIMQualifier(CIMName("description"),
String("My Message"))))
.addProperty(CIMProperty(CIMName("ratio"), Real32(1.5)));
Resolver::resolveClass(class1, context, NAMESPACE);
context->addClass(NAMESPACE, class1);
if (verbose)
{
XmlWriter::printClassElement(class1);
}
//
// Create instance with qualifiers, classorigin, and Null propertyList
//
{
CIMInstance newInstance;
newInstance = class1.buildInstance(true, true, CIMPropertyList());
if (verbose)
{
XmlWriter::printInstanceElement(newInstance);
}
assert(newInstance.getPropertyCount() == class1.getPropertyCount());
assert(newInstance.getQualifierCount() == class1.getQualifierCount());
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") != PEG_NOT_FOUND);
}
//
// Test with include qualifiers false. Should be no qualifiers in result
//
{
CIMInstance newInstance =
class1.buildInstance(false, true, CIMPropertyList());
assert(newInstance.getQualifierCount() == 0);
assert(newInstance.getPropertyCount() == class1.getPropertyCount());
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") != PEG_NOT_FOUND);
}
//
// Test with empty property list. Should have no properties.
//
{
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
assert(newInstance.getQualifierCount() == 0);
assert(newInstance.getPropertyCount() == 0);
}
//
// Test with a property that exists in property list.
//
{
Array<CIMName> pl1Array;
pl1Array.append("ratio");
CIMPropertyList pl1(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
if (verbose)
{
cout << "Test with one property in new instance" << endl;
XmlWriter::printInstanceElement(newInstance);
}
assert(newInstance.getPropertyCount() == 1);
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") == PEG_NOT_FOUND);
assert(newInstance.getQualifierCount() == 0);
}
//
// Test with a property that does/does not exist in property list
//
{
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
pl1.clear();
pl1Array.append("blob");
pl1Array.append("ratio");
pl1.set(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
assert(newInstance.getPropertyCount() == 1);
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("blob") == PEG_NOT_FOUND);
assert(newInstance.findProperty("message") == PEG_NOT_FOUND);
assert(newInstance.getQualifierCount() == 0);
}
///////////////////////////////////////////////////////////////////////
//
// Instance Filtering function tests
//
///////////////////////////////////////////////////////////////////////
// build instance as starting point for tests.
CIMInstance tstInstance =
class1.buildInstance(true, true, CIMPropertyList());
//
// Test complete copy, no change
//
{
if (verbose)
{
cout << "Test1" << endl;
}
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, CIMPropertyList());
assert(tstInstance.identical(filterInstance));
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, ratio
//
{
if (verbose)
{
cout << "Test2" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("ratio");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(_propertyIdentical("ratio", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, message
//
{
if (verbose)
{
cout << "Test3" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("message");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("message") != PEG_NOT_FOUND);
assert(_propertyIdentical("message", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, count
//
{
if (verbose)
{
cout << "Test4" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("count");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("count") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to no properties
//
{
if (verbose)
{
cout << "Test5a" << endl;
}
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
assert(filterInstance.getPropertyCount() == 0);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to two properties
//
{
if (verbose)
{
cout << "Test5b" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("count");
pl1Array.append("message");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
assert(filterInstance.getPropertyCount() == 2);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.findProperty("message") != PEG_NOT_FOUND);
assert(_propertyIdentical("message", filterInstance, tstInstance));
assert(filterInstance.findProperty("count") != PEG_NOT_FOUND);
assert(_propertyIdentical("count", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to no qualifiers and all properties.
//
{
if (verbose)
{
cout << "Test6" << endl;
}
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(false, true, CIMPropertyList());
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
for (Uint32 i = 0; i < filterInstance.getPropertyCount() ; i++)
{
CIMConstProperty p = filterInstance.getProperty(i);
assert(p.getQualifierCount() == 0);
}
}
//
// Filter to no qualifiers and no properties.
//
{
if (verbose)
{
cout << "Test6a" << endl;
}
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(false, true, pl1);
assert(filterInstance.getPropertyCount() == 0);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
}
//
// Test Class Origin Filter
//
{
if (verbose)
{
cout << "Test7 Class Origin" << endl;
}
// Create a subclass to do classOrigin testing
CIMClass mySubClass(CIMName("subclass"));
mySubClass.setSuperClassName(CIMName("MyClass"));
Resolver::resolveClass(mySubClass, context, NAMESPACE);
context->addClass(NAMESPACE, mySubClass);
// build instance
CIMInstance filterInstance =
mySubClass.buildInstance(true, true, CIMPropertyList());
filterInstance.filter(false, true, CIMPropertyList());
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
for (Uint32 i = 0 ; i < filterInstance.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance.getProperty(i);
assert(!(p.getClassOrigin() == CIMName()));
}
filterInstance.filter(false, false, CIMPropertyList());
for (Uint32 i = 0 ; i < filterInstance.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance.getProperty(i);
assert(p.getClassOrigin() == CIMName());
}
CIMInstance filterInstance2 =
mySubClass.buildInstance(true, false, CIMPropertyList());
for (Uint32 i = 0 ; i < filterInstance2.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance2.getProperty(i);
assert(p.getClassOrigin() == CIMName());
}
}
delete context;
}