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; }
static void _inject_object_path( CIMInstance& instance, const CIMObjectPath& objectPath, const char* tag) { Array<CIMKeyBinding> bindings; bindings.append(CIMKeyBinding("Tag", tag, CIMKeyBinding::STRING)); bindings.append(CIMKeyBinding( "CreationClassName", "Benchmark2", CIMKeyBinding::STRING)); instance.setPath(CIMObjectPath( objectPath.getHost(), objectPath.getNameSpace(), "Benchmark2", bindings)); }
void testAssociationsHostName( CIMClient & client) { Array<CIMObjectPath> objPaths = client.enumerateInstanceNames( CIMNamespaceName("test/TestProvider"), CIMName("TST_Person")); PEGASUS_TEST_ASSERT(objPaths.size() > 0); Array<CIMObject> objects = client.associators( CIMNamespaceName("test/TestProvider"), objPaths[0]); PEGASUS_TEST_ASSERT(objects.size() > 0); CIMObjectPath path = objects[0].getPath(); String pathHN = path.getHost(); PEGASUS_TEST_ASSERT(String::equal(pathHN,"hugo")); }
void CIMClientRep::compareObjectPathtoCurrentConnection(const CIMObjectPath& obj) { String ObjHost = obj.getHost(); // test if a host is given at all, if not everything is fine and we leave it at that if (ObjHost==String::EMPTY) { return; } MessageLoaderParms typeMismatchMessage; // splitting the port from hostname as we have to compare both separate int i = ObjHost.find(":"); String ObjPort = String::EMPTY; // only if there is a ":" we should split a port address from hostname string if (i > 0) { ObjPort = ObjHost.subString(i+1); ObjHost.remove(i); // lets see who we are really connected to // should stand in UInt32 _connectPortNumber and String _connectHost; // comparing the stuff // first the easy part, comparing the ports Uint32 objectport = strtoul((const char*) ObjPort.getCString(), NULL, 0); // if port in object path does not equal port of connection throw a TypeMismatch Exception if (objectport != _connectPortNumber) { typeMismatchMessage = MessageLoaderParms("Client.CIMClientRep.TYPEMISMATCH_PORTMISMATCH", "Failed validation of CIM object path: port of CIMClient connection($0) and port of object path($1) not equal", _connectPortNumber, objectport); throw TypeMismatchException(typeMismatchMessage); } } }
CIMObjectPath ObjectNormalizer::processInstanceObjectPath( const CIMObjectPath& cimObjectPath) const { // pre-check if (!_enableNormalization || _cimClass.isUninitialized()) { // do nothing return cimObjectPath; } /* // ATTN: moving similar logic to the response handlers because this // type of error should be checked regardless with or without // normalization enabled. if (cimObjectPath.getClassName().isNull()) { throw CIMException(CIM_ERR_FAILED, "uninitialized object path"); } */ /* // ATTN: The following code is currently redundant because the CIMName // object validates legal names when it is constructed. It is included // here for completeness. // check class name if (!CIMName(cimObjectPath.getClassName()).legal()) { MessageLoaderParms message( "Common.ObjectNormalizer.INVALID_CLASS_NAME", "Invalid class name: $0", cimObjectPath.getClassName().getString()); throw CIMException(CIM_ERR_FAILED, message); } */ // check class type if (!_cimClass.getClassName().equal(cimObjectPath.getClassName())) { MessageLoaderParms message( "Common.ObjectNormalizer.INVALID_CLASS_TYPE", "Invalid class type: $0", cimObjectPath.getClassName().getString()); throw CIMException(CIM_ERR_FAILED, message); } CIMObjectPath normalizedObjectPath( cimObjectPath.getHost(), cimObjectPath.getNameSpace(), cimObjectPath.getClassName()); Array<CIMKeyBinding> normalizedKeys; Array<CIMKeyBinding> referenceKeys = _cimClass.getPath().getKeyBindings(); Array<CIMKeyBinding> cimKeys = cimObjectPath.getKeyBindings(); for (Uint32 i = 0, n = referenceKeys.size(); i < n; i++) { CIMKeyBinding key; // override the value from the specified object for (Uint32 j = 0, m = cimKeys.size(); j < m; j++) { if (referenceKeys[i].getName().equal(cimKeys[j].getName())) { // check type if (referenceKeys[i].getType() != cimKeys[j].getType()) { MessageLoaderParms message( "Common.ObjectNormalizer.INVALID_KEY_TYPE", "Invalid key type: $0", referenceKeys[i].getName().getString()); throw CIMException(CIM_ERR_FAILED, message); } key = CIMKeyBinding(referenceKeys[i].getName(), cimKeys[j].getValue(), referenceKeys[i].getType()); break; } } // key not found if (key.getName().isNull()) { MessageLoaderParms message( "Common.ObjectNormalizer.MISSING_KEY", "Missing key: $0", referenceKeys[i].getName().getString()); throw CIMException(CIM_ERR_FAILED, message); } normalizedKeys.append(key); } normalizedObjectPath.setKeyBindings(normalizedKeys); return normalizedObjectPath; }
// // Local version of the references operation. It validates the input // parameters, setting the origin and target property values if not set // already, and then performs an enumeration on the association class. It then // filters the results of that enumeration to see if one of the reference // properties matches the objectName parameter passed into the method. If so, // then it is added to the array of association instances to be returned. // Array<CIMInstance> InteropProvider::localReferences( const OperationContext & context, const CIMObjectPath & objectName, const CIMName & assocClass, String & originProperty, String & targetProperty, const CIMPropertyList & propertyList, const CIMName & targetClass) { PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localReferences()"); Array<CIMInstance> instances; CIMName originClass = objectName.getClassName(); Array<CIMName> targetSubclasses; CIMNamespaceName lastTargetNamespace; CIMNamespaceName originNamespace(objectName.getNameSpace()); // Check that the association traversal request is valid if (validAssocClassForObject( context, assocClass, objectName, originNamespace, originProperty, targetProperty)) { // retrieve all of the association class instances Array<CIMInstance> localInstances = localEnumerateInstances(context, CIMObjectPath(hostName, originNamespace, assocClass)); // Filter the association class instances based on the origin instance // and other input parameters. for(Uint32 i = 0, n = localInstances.size(); i < n; ++i) { CIMInstance & currentInstance = localInstances[i]; CIMObjectPath originPath = getRequiredValue<CIMObjectPath>( currentInstance, originProperty); originPath.setNameSpace(objectName.getNameSpace()); originPath.setHost(objectName.getHost()); // Only include instances where the origin instance is present in // the association. if(originPath.identical(objectName)) { if(!targetClass.isNull()) { // Have to check if the target reference is of the // targetClass type. We first must determine all the // possible subclasses of the targetClass in the target // namespace. CIMObjectPath targetPath = getRequiredValue<CIMObjectPath>( currentInstance, targetProperty); CIMNamespaceName targetNamespace( targetPath.getNameSpace()); if(targetNamespace.isNull()) { targetNamespace = originNamespace; targetPath.setNameSpace(targetNamespace); } if(targetNamespace != lastTargetNamespace) { try { targetSubclasses = repository->enumerateClassNames( targetNamespace, targetClass, true); } catch(...) { // If an exception was thrown during enumeration, // then the base class didn't exist in the // namespace, so the target instance retrieved // must not match the targetClass parameter. continue; } targetSubclasses.append(targetClass); lastTargetNamespace = targetNamespace; } // Try to find the targetPath's class in the search space CIMName targetPathClass = targetPath.getClassName(); for(Uint32 j = 0, m = targetSubclasses.size(); j < m; ++j) { if(targetPathClass == targetSubclasses[j]) { instances.append(currentInstance); break; } } } else { instances.append(currentInstance); } } } } PEG_METHOD_EXIT(); return instances; }
// // Local version of getInstance to be used by other functions in the the // provider. Returns a single instance. Note that it always returns an // instance. If none was found, it is uninialitized. // CIMInstance InteropProvider::localGetInstance( const OperationContext & context, const CIMObjectPath & instanceName, const CIMPropertyList & propertyList) { PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localGetInstance"); PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4, "%s getInstance. instanceName= %s , PropertyList= %s", thisProvider, (const char *)instanceName.toString().getCString(), (const char *)propertyListToString(propertyList).getCString())); // Test if we're looking for something outside of our namespace. This will // happen during associators calls from PG_RegisteredProfile instances // through the PG_ElementConformsToProfile association CIMNamespaceName opNamespace = instanceName.getNameSpace(); CIMName opClass = instanceName.getClassName(); if(opNamespace != PEGASUS_NAMESPACENAME_INTEROP && opClass != PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE // Get CIM_IndicationService instance from IndicationService. #ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT || opClass == PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE #endif ) { AutoMutex mut(interopMut); CIMInstance gotInstance = cimomHandle.getInstance( context, opNamespace, instanceName, false, false, false, propertyList); PEG_METHOD_EXIT(); return gotInstance; } // Create reference from host, namespace, class components of // instance name CIMObjectPath ref; ref.setHost(instanceName.getHost()); ref.setClassName(opClass); ref.setNameSpace(opNamespace); // Enumerate instances for this class. Returns all instances // Note that this returns paths setup and instances already // filtered per the input criteria. Array<CIMInstance> instances = localEnumerateInstances( context, ref, propertyList); // deliver a single instance if found. CIMInstance retInstance; bool found = false; for(Uint32 i = 0, n = instances.size(); i < n; i++) { CIMObjectPath currentInstRef = instances[i].getPath(); currentInstRef.setHost(instanceName.getHost()); currentInstRef.setNameSpace(instanceName.getNameSpace()); if(instanceName == currentInstRef) { retInstance = instances[i]; found = true; break; } } if(!found) { cout << "Coule not find instance: " << instanceName.toString() << endl; } PEG_METHOD_EXIT(); return retInstance; }
void testInstanceClass(CIMClient & client, const CIMName & className) { cout << "Testing Instance Class " << (const char *)className.getString().getCString() << "..."; Array<CIMInstance> instances = testAnyClass(client, className); for(unsigned int i = 0, n = instances.size(); i < n; ++i) { CIMInstance currentInstance = instances[i]; CIMObjectPath currentPath = currentInstance.getPath(); if(currentPath.getNameSpace().isNull()) currentPath.setNameSpace(interopNamespace); // // Now test association traversal // Note that the "TestAssociationClass" method does a very good job // of testing association traversal between references contained in // instances of the supplied association class. Therefore, all we // really have to do here is make sure that the results of the // associators, associatorNames, references, and referenceNames // operations are consistent. // Boolean failure = false; try { Array<CIMObject> associatorsResults = client.associators( currentPath.getNameSpace(), currentPath); Array<CIMObjectPath> associatorNamesResults = client.associatorNames( currentPath.getNameSpace(), currentPath); Array<CIMObject> referencesResults = client.references( currentPath.getNameSpace(), currentPath); Array<CIMObjectPath> referenceNamesResults = client.referenceNames( currentPath.getNameSpace(), currentPath); Uint32 numResults = associatorsResults.size(); if(numResults != associatorNamesResults.size() || numResults != referencesResults.size() || numResults != referenceNamesResults.size()) { failure = true; } else { // Check that the results for the references and referenceNames // operations are consistent. unsigned int j = 0; for(j = 0; j < numResults; ++j) { CIMObjectPath currentReferenceName = referenceNamesResults[j]; Boolean found = false; for(unsigned int k = 0; k < numResults; ++k) { if(currentReferenceName == referencesResults[k].getPath()) { found = true; break; } } if(!found) { failure = true; break; } } // Check that that results for the associatorNames call is // consistent with the associators call and the references // call. for(j = 0; j < numResults; ++j) { CIMObjectPath currentAssociatorName = associatorNamesResults[j]; Boolean found = false; unsigned int k = 0; for(k = 0; k < numResults; ++k) { if(currentAssociatorName == associatorsResults[k].getPath()) { found = true; break; } } if(!found) { failure = true; break; } found = false; for(k = 0; k < numResults; ++k) { CIMObject referenceInstance = referencesResults[k]; for(unsigned int x = 0, m = referenceInstance.getPropertyCount(); x < m; ++x) { CIMProperty currentProp = referenceInstance.getProperty(x); if(currentProp.getType() == CIMTYPE_REFERENCE) { CIMObjectPath currentRef; currentProp.getValue().get(currentRef); currentRef.setHost( currentAssociatorName.getHost()); if(currentRef == currentAssociatorName) { found = true; break; } } } if(found) break; } if(!found) { failure = true; break; } } } if(failure) { exitFailure( String("Association Operations returned inconsistent ") + String("results for instance ") + currentPath.toString()); } } catch(CIMException & e) { exitFailure(String("Caught exception while performing ") + String("association operations on instance ") + currentPath.toString() + String(": ") + e.getMessage()); } } cout << "Test Complete" << endl; }
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(); }
void testAssociationClass(CIMClient & client, const CIMName & className) { cout << "Testing Association Class " << (const char *)className.getString().getCString() << "..."; Array<CIMInstance> instances = testAnyClass(client, className); for(unsigned int i = 0, n = instances.size(); i < n; ++i) { // // Now make sure that the references are valid and that association // traversal between them is working properly. // CIMObjectPath referenceA; CIMObjectPath referenceB; CIMInstance currentInstance = instances[i]; CIMObjectPath currentInstanceName = currentInstance.getPath(); if(currentInstanceName.getNameSpace().isNull()) currentInstanceName.setNameSpace(interopNamespace); for(unsigned int j = 0, m = currentInstance.getPropertyCount(); j < m; ++j) { CIMProperty currentProp = currentInstance.getProperty(j); if(currentProp.getValue().getType() == CIMTYPE_REFERENCE) { if(referenceA.getKeyBindings().size() == 0) { currentProp.getValue().get(referenceA); } else { currentProp.getValue().get(referenceB); break; } } } if(referenceA.getKeyBindings().size() == 0 || referenceB.getKeyBindings().size() == 0) { exitFailure( String("Could not find reference properties for ") + String("association: ") + currentInstanceName.toString()); } try { client.getInstance(referenceA.getNameSpace(), referenceA); client.getInstance(referenceB.getNameSpace(), referenceB); } catch(CIMException &) { exitFailure(String("Could not get instances for association : ") + currentInstanceName.toString()); } Boolean associationFailure = false; try { Array<CIMObjectPath> results = client.associatorNames( referenceA.getNameSpace(), referenceA, className); Boolean found = false; for(unsigned int j = 0, m = results.size(); j < m; ++j) { CIMObjectPath result = results[j]; result.setHost(referenceB.getHost()); result.setNameSpace(referenceB.getNameSpace()); if(result == referenceB) { found = true; break; } } if(found) { results = client.associatorNames(referenceB.getNameSpace(), referenceB, className); for(unsigned int j = 0, m = results.size(); j < m; ++j) { CIMObjectPath result = results[j]; result.setHost(referenceA.getHost()); result.setNameSpace(referenceA.getNameSpace()); if(result == referenceA) { found = true; break; } } } if(!found) { associationFailure = true; } } catch(CIMException & e) { cout << "Exception: " << e.getMessage() << endl; associationFailure = true; } if(associationFailure) { exitFailure(String("Association traversal failed between ") + String("instances of association: ") + currentInstanceName.toString()); } Boolean referencesFailure = false; try { Array<CIMObjectPath> results = client.referenceNames( referenceA.getNameSpace(), referenceA, className); Boolean found = false; for(unsigned int j = 0, m = results.size(); j < m; ++j) { CIMObjectPath currentPath = results[j]; if(currentPath.getNameSpace().isNull()) currentPath.setNameSpace(interopNamespace); if(currentPath.getHost().size() != 0) currentPath.setHost(String::EMPTY); if(currentPath == currentInstanceName) { found = true; break; } } if(found) { results = client.referenceNames(referenceB.getNameSpace(), referenceB, className); for(unsigned int j = 0, m = results.size(); j < m; ++j) { CIMObjectPath currentPath = results[j]; if(currentPath.getNameSpace().isNull()) currentPath.setNameSpace(interopNamespace); if(currentPath.getHost().size() != 0) currentPath.setHost(String::EMPTY); if(currentPath == currentInstanceName) { found = true; break; } } } if(!found) { referencesFailure = true; } } catch(CIMException &) { referencesFailure = true; } if(referencesFailure) { exitFailure(String("References operation failed for ") + String("instances of association: ") + currentInstanceName.toString()); } } cout << "Test Complete" << endl; }
Array<CIMInstance> InteropProvider::getReferencedInstances( const Array<CIMInstance> &refs, const String &targetRole, const OperationContext & context, const CIMPropertyList & propertyList) { PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::getReferencedObjects"); Array<CIMInstance> referencedInstances; Array<CIMInstance> classInstances; CIMName prevClassName; ConstArrayIterator<CIMInstance> refsIter(refs); for(Uint32 i = 0; i < refsIter.size(); i++) { CIMInstance thisRef = refsIter[i]; CIMObjectPath thisTarget = getRequiredValue<CIMObjectPath>( thisRef, targetRole); // Test if we're looking for something outside of our namespace. This // will happen during associators calls from PG_RegisteredProfile // instances through the PG_ElementConformsToProfile association CIMNamespaceName opNamespace = thisTarget.getNameSpace(); CIMName opClass = thisTarget.getClassName(); if((opNamespace != PEGASUS_NAMESPACENAME_INTEROP && opClass != PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE) // Get CIM_IndicationService instance from IndicationService. #ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT || opClass == PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE #endif ) { AutoMutex mut(interopMut); CIMInstance gotInstance = cimomHandle.getInstance( context, opNamespace, thisTarget, false, false, false, propertyList); referencedInstances.append(gotInstance); continue; } TARGET_CLASS classEnum = translateClassInput(opClass); CIMInstance retInstance; switch(classEnum) { case PG_SOFTWAREIDENTITY: { CIMInstance retInstance = getSoftwareIdentityInstance(thisTarget); normalizeInstance( retInstance, thisTarget, false, false, propertyList); retInstance.setPath(thisTarget); referencedInstances.append(retInstance); } break; case PG_NAMESPACE: { CIMInstance retInstance = getNameSpaceInstance(thisTarget); normalizeInstance( retInstance, thisTarget, false, false, propertyList); retInstance.setPath(thisTarget); referencedInstances.append(retInstance); } break; default: { if( opClass != prevClassName ) { CIMObjectPath ref; ref.setHost(thisTarget.getHost()); ref.setClassName(thisTarget.getClassName()); ref.setNameSpace(thisTarget.getNameSpace()); classInstances = localEnumerateInstances( context, ref, propertyList); ArrayIterator<CIMInstance> instsIter(classInstances); for(Uint32 n = 0; n < instsIter.size(); n++) { CIMObjectPath tmpInst = instsIter[n].getPath(); tmpInst.setHost(thisTarget.getHost()); tmpInst.setNameSpace(thisTarget.getNameSpace()); instsIter[n].setPath(tmpInst); } prevClassName = opClass; } ConstArrayIterator<CIMInstance> instsConstIter(classInstances); for(Uint32 j = 0; j < instsConstIter.size(); j++) { if(thisTarget == instsConstIter[j].getPath()) { referencedInstances.append(instsConstIter[j]); break; } } } break; } } PEG_METHOD_EXIT(); return referencedInstances; }
// // Local version of getInstance to be used by other functions in the the // provider. Returns a single instance. Note that it always returns an // instance. If none was found, it is uninialitized. // CIMInstance InteropProvider::localGetInstance( const OperationContext & context, const CIMObjectPath & instanceName, const CIMPropertyList & propertyList) { PEG_METHOD_ENTER(TRC_CONTROLPROVIDER, "InteropProvider::localGetInstance"); PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL4, "%s getInstance. instanceName= %s , PropertyList= %s", thisProvider, (const char *)instanceName.toString().getCString(), (const char *)propertyList.toString().getCString())); // Test if we're looking for something outside of our namespace. This will // happen during associators calls from PG_RegisteredProfile instances // through the PG_ElementConformsToProfile association CIMNamespaceName opNamespace = instanceName.getNameSpace(); CIMName opClass = instanceName.getClassName(); if((opNamespace != PEGASUS_NAMESPACENAME_INTEROP && opClass != PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE) // Get CIM_IndicationService instance from IndicationService. #ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT || opClass == PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE #endif ) { AutoMutex mut(interopMut); CIMInstance gotInstance = cimomHandle.getInstance( context, opNamespace, instanceName, false, false, false, propertyList); PEG_METHOD_EXIT(); return gotInstance; } TARGET_CLASS classEnum = translateClassInput(opClass); CIMInstance retInstance; switch(classEnum) { case PG_SOFTWAREIDENTITY: { retInstance = getSoftwareIdentityInstance(instanceName); normalizeInstance( retInstance, instanceName, false, false, propertyList); } break; case PG_NAMESPACE: { retInstance = getNameSpaceInstance(instanceName); normalizeInstance( retInstance, instanceName, false, false, propertyList); } break; // ATTN: Implement getIntstance for all other classes. Currently // this method calls localEnumerateInstances() to select instance // which is too expensive. default: { // Create reference from host, namespace, class components of // instance name CIMObjectPath ref; ref.setHost(instanceName.getHost()); ref.setClassName(opClass); ref.setNameSpace(opNamespace); // Enumerate instances for this class. Returns all instances // Note that this returns paths setup and instances already // filtered per the input criteria. Array<CIMInstance> instances = localEnumerateInstances( context, ref, propertyList); ConstArrayIterator<CIMInstance> instancesIter(instances); // deliver a single instance if found. bool found = false; for(Uint32 i = 0; i < instancesIter.size(); i++) { CIMObjectPath currentInstRef = instancesIter[i].getPath(); currentInstRef.setHost(instanceName.getHost()); currentInstRef.setNameSpace(instanceName.getNameSpace()); if(instanceName == currentInstRef) { retInstance = instancesIter[i]; found = true; break; } } if (!found) { PEG_METHOD_EXIT(); throw CIMObjectNotFoundException(instanceName.toString()); } } } PEG_METHOD_EXIT(); return retInstance; }
void MCCA_TestAssocProvider::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) { CDEBUG("MCCA_TestAssocProvider::associators() called."); // create a new CIMInstance based on class with name className CIMInstance constructedInstance = CIMInstance(testClassName); CIMObjectPath targetObjectPath = CIMObjectPath(); Array<CIMKeyBinding> keyBindings = Array<CIMKeyBinding>(); Uint32 sourceKey = 0; CDEBUG("Initialisation ended."); handler.processing(); CDEBUG("handler.processing started."); // we do ignore role, resultRole, includeQualifiers, includeClassOrigin, // propertyList CDEBUG("Next building object path."); ///////////////////////////////////////////////////////////////////// // BUILD OBJECTPATH ///////////////////////////////////////////////////////////////////// // preparing object path first targetObjectPath.setHost("localhost:5988"); targetObjectPath.setClassName(testClassName); CDEBUG("Host and classname set, host=" << objectName.getHost()); // determine if source namespace is namespace A or B // and build respective target namespace ... if (objectName.getNameSpace().equal(nameSpaceA)) { targetObjectPath.setNameSpace(nameSpaceB); } if (objectName.getNameSpace().equal(nameSpaceB)) { targetObjectPath.setNameSpace(nameSpaceA); } CDEBUG("NameSpace set."); // determine key of source object so we can create target object Array<CIMKeyBinding> sourceKeyBindings = objectName.getKeyBindings(); CDEBUG("Determining sourceKey."); // only one keyvalue, so we take that first one String keyValueString = String(sourceKeyBindings[0].getValue()); CDEBUG("keyValueString=" << keyValueString); sourceKey = strtoul((const char*) keyValueString.getCString(), NULL, 0); CDEBUG("sourceKey=" << sourceKey); CIMKeyBinding testClassKey = CIMKeyBinding(CIMName("theKey"), CIMValue(sourceKey) ); CDEBUG("Created new KeyBinding testClassKey."); // testClassKey.setValue(keyValueString); CDEBUG("sourceKey = string(set keybinding),int(sourceKey)" << testClassKey.getValue() << "," << sourceKey); keyBindings.append(testClassKey); CDEBUG("Appended(testClassKey)."); targetObjectPath.setKeyBindings(keyBindings); ///////////////////////////////////////////////////////////////////// // ADD PROPERTIES ///////////////////////////////////////////////////////////////////// // add properties to the CIMInstance object constructedInstance.addProperty( CIMProperty( CIMName("theKey"), sourceKey)); constructedInstance.addProperty( CIMProperty( CIMName("theData"), 20+sourceKey)); char buffer[100]; sprintf(buffer,"ABC-%u",20*sourceKey+sourceKey); constructedInstance.addProperty(CIMProperty(CIMName ("theString"), String(buffer))); CDEBUG("Added properties to the CIMInstance object"); CIMObject cimObject(constructedInstance); cimObject.setPath (targetObjectPath); // lets deliver all instances of CIMObjectpaths I do think are okay handler.deliver(cimObject); // complete processing the request handler.complete(); CDEBUG("Association call conmplete."); }
void ConfigSettingProvider::enumerateInstances( const OperationContext & context, const CIMObjectPath & ref, const Boolean includeQualifiers, const Boolean includeClassOrigin, const CIMPropertyList& propertyList, InstanceResponseHandler & handler) { PEG_METHOD_ENTER(TRC_CONFIG, "ConfigSettingProvider::enumerateInstances()"); Array<CIMInstance> instanceArray; Array<String> propertyNames; // // check if the class name requested is PG_ConfigSetting // if (!ref.getClassName().equal (PG_CONFIG_SETTING)) { PEG_METHOD_EXIT(); throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, ref.getClassName().getString()); } // begin processing the request handler.processing(); try { _configManager->getAllPropertyNames(propertyNames, false); for (Uint32 i = 0; i < propertyNames.size(); i++) { Array<String> propertyInfo; CIMInstance instance(PG_CONFIG_SETTING); propertyInfo.clear(); _configManager->getPropertyInfo( propertyNames[i], propertyInfo); Array<CIMKeyBinding> keyBindings; keyBindings.append(CIMKeyBinding(PROPERTY_NAME, propertyInfo[0], CIMKeyBinding::STRING)); CIMObjectPath instanceName(ref.getHost(), ref.getNameSpace(), PG_CONFIG_SETTING, keyBindings); // construct the instance instance.addProperty(CIMProperty(PROPERTY_NAME, propertyInfo[0])); instance.addProperty(CIMProperty(DEFAULT_VALUE, propertyInfo[1])); instance.addProperty(CIMProperty(CURRENT_VALUE, propertyInfo[2])); instance.addProperty(CIMProperty(PLANNED_VALUE, propertyInfo[3])); instance.addProperty(CIMProperty(DYNAMIC_PROPERTY, Boolean(propertyInfo[4]=="true"?true:false))); if (propertyInfo.size() > 6) { instance.addProperty( CIMProperty(DESCRIPTION, propertyInfo[6])); } instance.setPath(instanceName); instanceArray.append(instance); } } catch(Exception& e) { PEG_METHOD_EXIT(); throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, e.getMessage()); } handler.deliver(instanceArray); // complete processing the request handler.complete(); PEG_METHOD_EXIT(); }