// // 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 = NOCLASS; CIMName originClass = objectName.getClassName(); // If the association class is PG_ElementConformsToProfile, we'll have to // do some special processing in case the origin instance for the operation // is managed by another provider. if(assocClassEnum == PG_ELEMENTCONFORMSTOPROFILE) { // Test if the origin is an element managed by another provider // that has implemented a registered profile. if(opNamespace != PEGASUS_NAMESPACENAME_INTEROP || (originClass != PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE && #ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT originClass != PEGASUS_CLASSNAME_CIM_INDICATIONSERVICE && #endif 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); try { tmpInstance = localGetInstance( context, objectName, propertyList); } catch (CIMException &e) { PEG_TRACE((TRC_CONTROLPROVIDER, Tracer::LEVEL2, "CIMException while getting instance of Registered Profile " ": %s", (const char*)e.getMessage().getCString())); } if (!tmpInstance.isUninitialized()) { 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; } else if (originClassEnum == CIM_INDICATIONSERVICE) { expectedTargetRole = PROPERTY_ANTECEDENT; expectedOriginRole = PROPERTY_DEPENDENT; } 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; }
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 _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); } } } }
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // //============================================================================== // // Author: Lyle Wilkinson, Hewlett-Packard Company <*****@*****.**> // // Modified By: // //%///////////////////////////////////////////////////////////////////////////// #include "IPInfo.h" PEGASUS_USING_PEGASUS; PEGASUS_USING_STD; static const CIMName CLASS_NAME = CIMName ("PG_IPRoute"); static const CIMNamespaceName NAMESPACE = CIMNamespaceName ("root/cimv2"); #define HeaderFormat "%-16s %-10s %-16s %-16s %-16s" //////////////////////////////////////////////////////////////////////////////// // Constructor for IP Route Info //////////////////////////////////////////////////////////////////////////////// IPRouteInfo::IPRouteInfo(CIMClient &client, Boolean enableDebug, ostream& outPrintWriter, ostream& errPrintWriter) { _enableDebug = enableDebug; try { Boolean deepInheritance = true;
void test01() { NameSpaceManager nsm; _nameSpaceNames.append(CIMNamespaceName("aa")); _nameSpaceNames.append(CIMNamespaceName("aa/bb")); _nameSpaceNames.append(CIMNamespaceName("aa/bb/cc")); _nameSpaceNames.append(CIMNamespaceName("/lmnop/qrstuv")); _nameSpaceNames.append(CIMNamespaceName("root")); _nameSpaceNames.append(CIMNamespaceName("xx")); _nameSpaceNames.append(CIMNamespaceName("xx/yy")); for (Uint32 j = 0; j < _nameSpaceNames.size(); j++) { // NOTE: The "root" namespace is created by CIMRepository, which is not // used by this test program. So the "root" namespace is not expected // to be created automatically in this case. //if (!_nameSpaceNames[j].equal(CIMNamespaceName("root"))) { // Create a namespace nsm.createNameSpace(_nameSpaceNames[j], true, true, String::EMPTY); } } Array<CIMNamespaceName> nameSpaceNames; nsm.getNameSpaceNames(nameSpaceNames); if (verbose) nsm.print(cout); PEGASUS_TEST_ASSERT(nameSpaceNames.size() == NUM_NAMESPACE_NAMES); BubbleSort(nameSpaceNames); for (Uint32 i = 0; i < NUM_NAMESPACE_NAMES; i++) { PEGASUS_TEST_ASSERT(_nameSpaceNames[i] == nameSpaceNames[i]); PEGASUS_TEST_ASSERT(nsm.nameSpaceExists(nameSpaceNames[i])); } nsm.deleteNameSpace(CIMNamespaceName("lmnop/qrstuv")); nsm.getNameSpaceNames(nameSpaceNames); PEGASUS_TEST_ASSERT(nameSpaceNames.size() == NUM_NAMESPACE_NAMES - 1); // Create and delete a class to test these functions nsm.createClass(CIMNamespaceName("aa/bb"), "MySuperClass", CIMName()); nsm.createClass(CIMNamespaceName("aa/bb"), "MyClass", "MySuperClass"); PEGASUS_TEST_ASSERT( nsm.getSuperClassName(CIMNamespaceName("aa/bb"), "MySuperClass") == CIMName()); PEGASUS_TEST_ASSERT( nsm.getSuperClassName(CIMNamespaceName("aa/bb"), "MyClass") == "MySuperClass"); nsm.deleteClass(CIMNamespaceName("aa/bb"), "MyClass"); nsm.deleteClass(CIMNamespaceName("aa/bb"), "MySuperClass"); for (Uint32 j = 0; j < _nameSpaceNames.size(); j++) { if (!_nameSpaceNames[j].equal(CIMNamespaceName("root")) && !_nameSpaceNames[j].equal(CIMNamespaceName("lmnop/qrstuv"))) { nsm.deleteNameSpace(CIMNamespaceName(_nameSpaceNames[j])); } } nsm.getNameSpaceNames(nameSpaceNames); // Only the root namespace should be left. PEGASUS_TEST_ASSERT(nameSpaceNames.size() == 1); PEGASUS_TEST_ASSERT(nameSpaceNames[0].equal(CIMNamespaceName("root"))); // confirm we can delete root nsm.deleteNameSpace(nameSpaceNames[0]); nsm.getNameSpaceNames(nameSpaceNames); PEGASUS_TEST_ASSERT(nameSpaceNames.size() == 0); }
// #include "RUEpProvider.h" PEGASUS_USING_STD; PEGASUS_USING_PEGASUS; //******************************************************** // Constants //******************************************************** // Namespace name static const CIMNamespaceName NAMESPACE = CIMNamespaceName("root/cimv2"); // Class names static const CIMName CLASS_CIM_PROTOCOL_ENDPOINT = CIMName( "CIM_ProtocolEndpoint"); static const CIMName CLASS_CIM_NEXT_HOP_ROUTE = CIMName("CIM_NextHopRoute"); static const CIMName CLASS_PG_ROUTE_USES_ENDPOINT = CIMName( "PG_RouteUsesEndpoint"); // Property names. static const CIMName PROPERTY_INSTANCE_ID = CIMName("InstanceID"); static const CIMName PROPERTY_DESTINATION_ADDRESS = CIMName( "DestinationAddress"); static const CIMName PROPERTY_DESTINATION_MASK = CIMName("DestinationMask"); static const CIMName PROPERTY_PREFIX_LENGTH = CIMName("PrefixLength"); static const CIMName PROPERTY_SUBNET_MASK = CIMName("SubnetMask"); static const CIMName PROPERTY_ADDRESS_TYPE = CIMName("AddressType"); static const CIMName PROPERTY_PROTOCOL_IF_TYPE = CIMName("ProtocolIFType"); static const CIMName PROPERTY_IPV4ADDRESS = CIMName("IPv4Address"); static const CIMName PROPERTY_IPV6ADDRESS = CIMName("IPv6Address");
CIMInstance UNIX_BGPServiceAttributes::getPartComponent() const { return CIMInstance(CIMName("CIM_Component")); }
int main() { cout << "Starting Server Profile Tests" << endl << endl; // Create a locally-connected client CIMClient client; try { client.connectLocal(); client.setTimeout(60000); // Set the timeout to one minute } catch(Exception &) { exitFailure(String("Could not connect to server")); } CIMName currentClass; try { currentClass = CIMName("CIM_ComputerSystem"); testInstanceClass(client, currentClass); currentClass = CIMName("CIM_ObjectManager"); testInstanceClass(client, currentClass); currentClass = CIMName("CIM_RegisteredSubProfile"); testInstanceClass(client, currentClass); currentClass = CIMName("CIM_RegisteredProfile"); testInstanceClass(client, currentClass); currentClass = CIMName("CIM_CIMXMLCommunicationMechanism"); testInstanceClass(client, currentClass); currentClass = CIMName("CIM_Namespace"); testInstanceClass(client, currentClass); currentClass = CIMName("CIM_SoftwareIdentity"); testInstanceClass(client, currentClass); currentClass = CIMName("CIM_HostedService"); testAssociationClass(client, currentClass); currentClass = CIMName("CIM_ElementConformsToProfile"); testAssociationClass(client, currentClass); currentClass = CIMName("CIM_SubprofileRequiresProfile"); testAssociationClass(client, currentClass); currentClass = CIMName("CIM_ReferencedProfile"); testAssociationClass(client, currentClass); currentClass = CIMName("CIM_ElementSoftwareIdentity"); testAssociationClass(client, currentClass); currentClass = CIMName("CIM_CommMechanismForManager"); testAssociationClass(client, currentClass); } catch(Exception & e) { exitFailure(String("Caught exception while testing class ") + currentClass.getString() + String(": ") + e.getMessage()); } catch(...) { exitFailure(String("Caught unknown exception while testing class ") + currentClass.getString()); } testDMTFProfileInstances(client); #ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT testIndicationProfileInstances(client); #endif //testAssociationTraversal(client); cout << endl << "Server Profile Tests complete" << endl; return 0; }
#include <Pegasus/Common/Config.h> #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/System.h> #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/InternalException.h> #include <Pegasus/Client/CIMClient.h> #include <Pegasus/Common/XmlWriter.h> #include <iostream> PEGASUS_USING_PEGASUS; PEGASUS_USING_STD; const CIMNamespaceName SOURCE_NAMESPACE = CIMNamespaceName( "root/SampleProvider"); const CIMName SAMPLE_CLASSNAME = CIMName("CWS_PlainFile"); Array<CIMObjectPath> objectNames; CIMInstance instance; CIMValue value; static Boolean verbose; void _enumerateInstanceNames(CIMClient & client) { try { objectNames = client.enumerateInstanceNames( SOURCE_NAMESPACE, SAMPLE_CLASSNAME); if (verbose)
void LifecycleIndicationProvider::createInstance( const OperationContext & context, const CIMObjectPath & instanceReference, const CIMInstance & instanceObject, ObjectPathResponseHandler & handler) { // cout << "LifecycleIndicationProvider::createInstance()" << endl; // Validate the class name if(!instanceObject.getClassName().equal( "Sample_LifecycleIndicationProviderClass")) { throw CIMNotSupportedException( instanceObject.getClassName().getString()); } // Find the key property Uint32 idIndex = instanceObject.findProperty("uniqueId"); if(idIndex == PEG_NOT_FOUND) { throw CIMInvalidParameterException("Missing key value"); } CIMInstance cimInstance = instanceObject.clone(); // Create the new instance name CIMValue idValue = instanceObject.getProperty(idIndex).getValue(); Array<CIMKeyBinding> keys; keys.append(CIMKeyBinding("uniqueId", idValue)); CIMObjectPath instanceName = CIMObjectPath( String(), CIMNamespaceName(), instanceObject.getClassName(), keys); cimInstance.setPath(instanceName); // Determine whether this instance already exists for(Uint32 i = 0, n = _instances.size(); i < n; i++) { if(instanceName == _instances[i].getPath()) { throw CIMObjectAlreadyExistsException(instanceName.toString()); } } // begin processing the request handler.processing(); // add the new instance to the array _instances.append(cimInstance); // deliver the new instance name handler.deliver(instanceName); // complete processing the request handler.complete(); // If there is at least one subscription active for the lifecycle indication // InstCreation_for_Sample_LifecycleIndicationProviderClass, then generate // that indication here, embedding the newly-created instance as // the SourceInstance property. See LifecycleIndicationProviderR.mof. if (_lifecycle_indications_enabled) { CIMInstance indicationInstance( CIMName( "InstCreation_for_Sample_LifecycleIndicationProviderClass")); CIMObjectPath path; path.setNameSpace("root/SampleProvider"); path.setClassName( "InstCreation_for_Sample_LifecycleIndicationProviderClass"); indicationInstance.setPath(path); char buffer[32]; sprintf(buffer, "%d", _nextUID++); indicationInstance.addProperty (CIMProperty ("IndicationIdentifier",String(buffer))); CIMDateTime currentDateTime = CIMDateTime::getCurrentDateTime (); indicationInstance.addProperty (CIMProperty ("IndicationTime", currentDateTime)); indicationInstance.addProperty (CIMProperty ("SourceInstance",CIMObject(cimInstance))); _indication_handler->deliver (indicationInstance); // cout << "LifecycleIndicationProvider::createInstance() sent " // "InstCreation_for_Sample_LifecycleIndicationProviderClass" // << endl; } }
void LifecycleIndicationProvider::deleteInstance( const OperationContext & context, const CIMObjectPath & instanceReference, ResponseHandler & handler) { // cout << "LifecycleIndicationProvider::deleteInstance()" << endl; CIMInstance localInstance; // convert a potential fully qualified reference into a local reference // (class name and keys only). CIMObjectPath localReference = CIMObjectPath( String(), CIMNamespaceName(), instanceReference.getClassName(), instanceReference.getKeyBindings()); // begin processing the request handler.processing(); // instance index corresponds to reference index for(Uint32 i = 0, n = _instances.size(); i < n; i++) { if(localReference == _instances[i].getPath()) { localInstance = _instances[i]; // remove instance from the array _instances.remove(i); break; } } // complete processing the request handler.complete(); // If there is at least one subscription active for the lifecycle indication // InstDeletion_for_Sample_LifecycleIndicationProviderClass, then generate // that indication here, embedding the just-deleted instance as the // SourceInstance property. See LifecycleIndicationProviderR.mof. if (_lifecycle_indications_enabled) { CIMInstance indicationInstance( CIMName( "InstDeletion_for_Sample_LifecycleIndicationProviderClass")); CIMObjectPath path; path.setNameSpace("root/SampleProvider"); path.setClassName( "InstDeletion_for_Sample_LifecycleIndicationProviderClass"); indicationInstance.setPath(path); char buffer[32]; sprintf(buffer, "%d", _nextUID++); indicationInstance.addProperty (CIMProperty ("IndicationIdentifier",String(buffer))); CIMDateTime currentDateTime = CIMDateTime::getCurrentDateTime (); indicationInstance.addProperty (CIMProperty ("IndicationTime", currentDateTime)); // Before we send the Lifecycle Indication for the delete of this // instance, change the "lastOp" property value to "deleteInstance". Uint32 ix = localInstance.findProperty(CIMName("lastOp")); if (ix != PEG_NOT_FOUND) { localInstance.removeProperty(ix); localInstance.addProperty( CIMProperty( CIMName("lastOp"), String("deleteInstance"))); } indicationInstance.addProperty (CIMProperty ("SourceInstance",CIMObject(localInstance))); _indication_handler->deliver (indicationInstance); // cout << "LifecycleIndicationProvider::deleteInstance() sent " // "InstDeletion_for_Sample_LifecycleIndicationProviderClass" // << endl; } }
void Test01(Uint32 mode) { String repositoryRoot; const char* tmpDir = getenv ("PEGASUS_TMP"); if (tmpDir == NULL) { repositoryRoot = "."; } else { repositoryRoot = tmpDir; } repositoryRoot.append("/repository"); FileSystem::removeDirectoryHier(repositoryRoot); CIMRepository r (repositoryRoot, mode); // Create a namespace: const CIMNamespaceName NAMESPACE = CIMNamespaceName ("zzz"); r.createNameSpace(NAMESPACE); // Create a qualifier (and read it back): CIMQualifierDecl q1(CIMName ("abstract"), false, CIMScope::CLASS); r.setQualifier(NAMESPACE, q1); CIMConstQualifierDecl q2 = r.getQualifier(NAMESPACE, CIMName ("abstract")); PEGASUS_TEST_ASSERT(q1.identical(q2)); // Create two simple classes: CIMClass class1(CIMName ("Class1")); class1.addQualifier( CIMQualifier(CIMName ("abstract"), true, CIMFlavor::DEFAULTS)); CIMClass class2(CIMName ("Class2"), CIMName ("Class1")); r.createClass(NAMESPACE, class1); r.createClass(NAMESPACE, class2); // Enumerate the class names: Array<CIMName> classNames = r.enumerateClassNames(NAMESPACE, CIMName(), true); BubbleSort(classNames); PEGASUS_TEST_ASSERT(classNames.size() == 2); PEGASUS_TEST_ASSERT(classNames[0] == "Class1"); PEGASUS_TEST_ASSERT(classNames[1] == "Class2"); // Get the classes and determine if they are identical with input CIMClass c1 = r.getClass(NAMESPACE, CIMName ("Class1"), true, true, false); CIMClass c2 = r.getClass(NAMESPACE, CIMName ("Class2"), true, true, false); PEGASUS_TEST_ASSERT(c1.identical(class1)); PEGASUS_TEST_ASSERT(c1.identical(class1)); Array<CIMClass> classes = r.enumerateClasses(NAMESPACE, CIMName (), true, true, true); // Attempt to delete Class1. It should fail since the class has // children. try { r.deleteClass(NAMESPACE, CIMName ("Class1")); } catch (CIMException& e) { PEGASUS_TEST_ASSERT(e.getCode() == CIM_ERR_CLASS_HAS_CHILDREN); } // Delete all classes created here: r.deleteClass(NAMESPACE, CIMName ("Class2")); r.deleteClass(NAMESPACE, CIMName ("Class1")); // Be sure the classes are really gone: try { CIMClass c1 = r.getClass( NAMESPACE, CIMName ("Class1"), true, true, true); PEGASUS_TEST_ASSERT(false); } catch (CIMException& e) { PEGASUS_TEST_ASSERT(e.getCode() == CIM_ERR_NOT_FOUND); } try { CIMClass c2 = r.getClass( NAMESPACE, CIMName ("Class2"), true, true, true); PEGASUS_TEST_ASSERT(false); } catch (CIMException& e) { PEGASUS_TEST_ASSERT(e.getCode() == CIM_ERR_NOT_FOUND); } FileSystem::removeDirectoryHier(repositoryRoot); }
void _testCMPIFilterOfAssociation(CIMClient& client) { try { Array<CIMObjectPath> personRefs; Uint32 numPersonInstances ; personRefs = client.enumerateInstanceNames(providerNamespace,CMPI_TEST_PERSON); numPersonInstances = personRefs.size(); CIMName resultClass; String role; String resultRole; cout<<"++++++++Filtering the NULL propery list+++"<<endl; for (Uint32 i = 0; i < numPersonInstances; ++i) { Array<CIMObject> resultObjects = client.associators( providerNamespace, personRefs[i], CMPI_TEST_RACING, resultClass, role, resultRole, false, false, CIMPropertyList()); Uint32 size = resultObjects.size(); for(Uint32 j = 0;j<size;j++) { Uint32 propCount = resultObjects[j].getPropertyCount(); Uint32 propNameCount = 0; if(propCount != 0) { String propName= resultObjects[j].getProperty(0).getName().getString(); if(verbose) { cout<<"Property Name of :"<<i<<":"<<propName<<endl; } if(propName == "vehiclename") { propNameCount++; } } if((size != 0)&&(propCount == 1) &&(propNameCount == 1)) { cout<<"Filter associator test on CMPI_TEST_RACING SUCCEEDED" <<":Filtering the ciminstance with a NULL property list" <<" returned all properties as expected"<<endl; } else { cout<<"Filter associator test on CMPI_TEST_RACING FAILED" <<":Filtering the ciminstance with a NULL property list" <<" did not return all properties as expected"<<endl; PEGASUS_TEST_ASSERT(false); } } } cout<<"++++++Filtering the empty propery list+++"<<endl; Array<CIMName> propList; for (Uint32 i = 0; i < numPersonInstances; ++i) { Array<CIMObject> resultObjects = client.associators( providerNamespace, personRefs[i], CMPI_TEST_RACING, resultClass, role, resultRole, false, false, CIMPropertyList(propList)); Uint32 size = resultObjects.size(); for(Uint32 j = 0;j<size;j++) { Uint32 propCount = resultObjects[j].getPropertyCount(); if((size != 0)&&(propCount == 0)) { cout<<"Filter associator test on CMPI_TEST_RACING SUCCEEDED" <<":Filtering the ciminstance with a empty property " <<"list returned zero properties as expected"<<endl; } else { cout<<"Filter associators test on CMPI_TEST_RACING FAILED" <<":Filtering the ciminstance with a empty property " <<"list returned some properties which is not expected" <<endl; PEGASUS_TEST_ASSERT(false); } } } cout<<"+++filtering the wrong properties ++++++"<<endl; Array<CIMName> propList1; propList1.append(CIMName(String("nam"))); for (Uint32 i = 0; i < numPersonInstances; ++i) { Array<CIMObject> resultObjects = client.associators( providerNamespace, personRefs[i], CMPI_TEST_RACING, resultClass, role, resultRole, false, false, CIMPropertyList(propList1)); Uint32 size = resultObjects.size(); for(Uint32 j = 0;j<size;j++) { Uint32 propCount = resultObjects[j].getPropertyCount(); if((size != 0)&&(propCount == 0)) { cout<<"Filter associators test on CMPI_TEST_RACING " <<"SUCCEEDED:Filtering the ciminstance with a wrong " <<"property list returned zero properties as " <<"expected"<<endl; } else { cout<<"Filter associators test on CMPI_TEST_RACING FAILED" <<":Filtering the ciminstance with a wrong property " <<"list returned some properties which is not" <<" expected"<<endl; PEGASUS_TEST_ASSERT(false); } } } cout<<"++++++++Filtering the mentioned propery list+++"<<endl; Array<CIMName> propArr; propArr.append(CIMName(String("vehiclename"))); for (Uint32 i = 0; i < numPersonInstances; ++i) { Array<CIMObject> resultObjects = client.associators( providerNamespace, personRefs[i], CMPI_TEST_RACING, resultClass, role, resultRole, false, false, CIMPropertyList( propArr)); Uint32 size = resultObjects.size(); for(Uint32 j = 0;j<size;j++) { Uint32 propCount = resultObjects[j].getPropertyCount(); Uint32 propNameCount = 0; if(propCount != 0) { String propName= resultObjects[j].getProperty(0).getName().getString(); if(verbose) { cout<<"Property Name of :"<<i<<":"<<propName<<endl; } if(propName == "vehiclename") { propNameCount++; } } if((size != 0)&&(propCount == 1) &&(propNameCount == 1)) { cout<<"Filter associators test on CMPI_TEST_RACING " <<"SUCCEEDED:Filtering the ciminstance with a " <<"mentioned property list returned all properties" <<" as expected"<<endl; } else { cout<<"Filter associators test on CMPI_TEST_RACING FAILED" <<":Filtering the ciminstance with a mentioned property" <<" list did not return properties as expected "<<endl; PEGASUS_TEST_ASSERT(false); } } } } catch(Exception& e) { cerr << "enumerateInstanceNames() failed." << endl; _errorExit(e.getMessage()); } }
// is considered a failure. If there is a failure, an error message is // displayed and the program terminates. #include <Pegasus/Client/CIMClient.h> #include <string.h> #include <Pegasus/Provider/CMPI/cmpidt.h> #include <Pegasus/Provider/CMPI/cmpift.h> #include <Pegasus/Provider/CMPI/cmpimacs.h> #include <Pegasus/Common/PegasusAssert.h> PEGASUS_USING_STD; PEGASUS_USING_PEGASUS; CIMNamespaceName providerNamespace; const CIMName CMPI_TEST_PERSON = CIMName ("CMPI_TEST_Person"); const CIMName CMPI_TEST_VEHICLE = CIMName ("CMPI_TEST_Vehicle"); const CIMName CMPI_TEST_RACING = CIMName ("CMPI_TEST_Racing"); Boolean verbose = false; // exepected results - number of returned objects expected for each test static const Uint32 resultArray_asso_P1[] = { 3, 3 }; static const Uint32 resultArray_asso_V1[] = { 3, 3 }; static const Uint32 resultArray_ref_P[] = { 3, 3, 3, 3 }; static const Uint32 resultArray_ref_V[] = { 3, 3, 3, 3 }; //////////////////////////////////////////////////////////////////////////// // _errorExit
int main(int argc, char** argv) { verbose = getenv("PEGASUS_TEST_VERBOSE"); String assocTablePath; const char* tmpDir = getenv ("PEGASUS_TMP"); if (tmpDir == NULL) { assocTablePath = "."; } else { assocTablePath = tmpDir; } assocTablePath.append("/associations.tbl"); // // create class association // AssocClassTable::append( assocTablePath, CIMName ("Lineage"), CIMName ("Person"), CIMName ("parent"), CIMName ("Person"), CIMName ("child")); // // delete class association // AssocClassTable::deleteAssociation( assocTablePath, CIMName ("Lineage")); // // create instance association // AssocInstTable::append( assocTablePath, "A.left=\"x.key=\\\"one\\\"\",right=\"y.key=\\\"two\\\"\"", CIMName ("A"), "X.key=\"one\"", CIMName ("X"), CIMName ("left"), "Y.key=\"two\"", CIMName ("Y"), CIMName ("right")); // // delete instance association // AssocInstTable::deleteAssociation( assocTablePath, CIMObjectPath ("A.left=\"x.key=\\\"one\\\"\",right=\"y.key=\\\"two\\\"\"")); cout << argv[0] << " +++++ passed all tests" << endl; return 0; }
int main(int, char** argv) { verbose = getenv("PEGASUS_TEST_VERBOSE") ? true : false; try { CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING); m1.addQualifier(CIMQualifier(CIMName ("stuff"), true)); m1.addQualifier(CIMQualifier(CIMName ("stuff2"), true)); m1.addParameter(CIMParameter(CIMName ("ipaddress"), CIMTYPE_STRING)); // Tests for Qualifiers PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuff")) != PEG_NOT_FOUND); PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuff2")) != PEG_NOT_FOUND); PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuff21")) == PEG_NOT_FOUND); PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuf")) == PEG_NOT_FOUND); PEGASUS_TEST_ASSERT(m1.getQualifierCount() == 2); PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuff")) != PEG_NOT_FOUND); PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuff2")) != PEG_NOT_FOUND); PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuff21")) == PEG_NOT_FOUND); PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuf")) == PEG_NOT_FOUND); Uint32 posQualifier; posQualifier = m1.findQualifier(CIMName ("stuff")); PEGASUS_TEST_ASSERT(posQualifier != PEG_NOT_FOUND); PEGASUS_TEST_ASSERT(posQualifier < m1.getQualifierCount()); m1.removeQualifier(posQualifier); PEGASUS_TEST_ASSERT(m1.getQualifierCount() == 1); PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuff")) == PEG_NOT_FOUND); PEGASUS_TEST_ASSERT( m1.findQualifier(CIMName ("stuff2")) != PEG_NOT_FOUND); // Tests for Parameters PEGASUS_TEST_ASSERT(m1.findParameter( CIMName ("ipaddress")) != PEG_NOT_FOUND); PEGASUS_TEST_ASSERT(m1.findParameter( CIMName ("noparam")) == PEG_NOT_FOUND); PEGASUS_TEST_ASSERT(m1.getParameterCount() == 1); CIMParameter cp = m1.getParameter( m1.findParameter(CIMName ("ipaddress"))); PEGASUS_TEST_ASSERT(cp.getName() == CIMName ("ipaddress")); m1.removeParameter (m1.findParameter ( CIMName (CIMName ("ipaddress")))); PEGASUS_TEST_ASSERT (m1.getParameterCount () == 0); m1.addParameter (CIMParameter (CIMName ("ipaddress"), CIMTYPE_STRING)); PEGASUS_TEST_ASSERT (m1.getParameterCount () == 1); // throws OutOfBounds try { m1.removeParameter (1); } catch (IndexOutOfBoundsException & oob) { if (verbose) { PEGASUS_STD (cout) << "Caught expected exception: " << oob.getMessage () << PEGASUS_STD (endl); } } CIMMethod m2(CIMName ("test"), CIMTYPE_STRING); m2.setName(CIMName ("getVersion")); PEGASUS_TEST_ASSERT(m2.getName() == CIMName ("getVersion")); m2.setType(CIMTYPE_STRING); PEGASUS_TEST_ASSERT(m2.getType() == CIMTYPE_STRING); m2.setClassOrigin(CIMName ("test")); PEGASUS_TEST_ASSERT(m2.getClassOrigin() == CIMName ("test")); m2.setPropagated(true); PEGASUS_TEST_ASSERT(m2.getPropagated() == true); const CIMMethod cm1(m1); PEGASUS_TEST_ASSERT(cm1.findQualifier( CIMName ("stuff21")) == PEG_NOT_FOUND); PEGASUS_TEST_ASSERT(cm1.findQualifier( CIMName ("stuf")) == PEG_NOT_FOUND); PEGASUS_TEST_ASSERT((cm1.getParameterCount() != 3)); PEGASUS_TEST_ASSERT(cm1.findParameter( CIMName ("ipaddress")) != PEG_NOT_FOUND); PEGASUS_TEST_ASSERT(cm1.findQualifier( CIMName ("stuff")) == PEG_NOT_FOUND); CIMQualifier q = m1.getQualifier(posQualifier); CIMConstParameter ccp = cm1.getParameter( cm1.findParameter(CIMName ("ipaddress"))); PEGASUS_TEST_ASSERT(cm1.getName() == CIMName ("getHostName")); PEGASUS_TEST_ASSERT(cm1.getType() == CIMTYPE_STRING); PEGASUS_TEST_ASSERT(!(cm1.getClassOrigin() == CIMName ("test"))); PEGASUS_TEST_ASSERT(!cm1.getPropagated() == true); PEGASUS_TEST_ASSERT(!m1.identical(m2)); // throws OutOfBounds try { CIMConstParameter p = cm1.getParameter(cm1.findParameter( CIMName ("ipaddress"))); } catch(IndexOutOfBoundsException&) { } // throws OutOfBounds try { CIMConstQualifier q1 = cm1.getQualifier(cm1.findQualifier( CIMName ("abstract"))); } catch(IndexOutOfBoundsException&) { } if (verbose) { XmlWriter::printMethodElement(m1); XmlWriter::printMethodElement(cm1); } Buffer out; XmlWriter::appendMethodElement(out, cm1); MofWriter::appendMethodElement(out, cm1); Boolean nullMethod = cm1.isUninitialized(); PEGASUS_TEST_ASSERT(!nullMethod); CIMMethod m3 = m2.clone(); m3 = cm1.clone(); CIMMethod m4; CIMMethod m5(m4); CIMConstMethod ccm1(CIMName ("getHostName"),CIMTYPE_STRING); PEGASUS_TEST_ASSERT(!(ccm1.getParameterCount() == 3)); PEGASUS_TEST_ASSERT(ccm1.getName() == CIMName ("getHostName")); PEGASUS_TEST_ASSERT(ccm1.getType() == CIMTYPE_STRING); PEGASUS_TEST_ASSERT(!(ccm1.getClassOrigin() == CIMName ("test"))); PEGASUS_TEST_ASSERT(!ccm1.getPropagated() == true); PEGASUS_TEST_ASSERT(!(ccm1.getParameterCount() == 3)); PEGASUS_TEST_ASSERT(ccm1.getQualifierCount() == 0); PEGASUS_TEST_ASSERT(ccm1.findQualifier( CIMName ("Stuff")) == PEG_NOT_FOUND); PEGASUS_TEST_ASSERT(ccm1.findParameter( CIMName ("ipaddress")) == PEG_NOT_FOUND); if (verbose) { XmlWriter::printMethodElement(m1); XmlWriter::printMethodElement(ccm1); } XmlWriter::appendMethodElement(out, ccm1); CIMConstMethod ccm2(ccm1); CIMConstMethod ccm3; ccm3 = ccm1.clone(); ccm1 = ccm3; PEGASUS_TEST_ASSERT(ccm1.identical(ccm3)); PEGASUS_TEST_ASSERT(ccm1.findQualifier( CIMName ("stuff")) == PEG_NOT_FOUND); PEGASUS_TEST_ASSERT(ccm1.findParameter( CIMName ("ipaddress")) == PEG_NOT_FOUND); nullMethod = ccm1.isUninitialized(); PEGASUS_TEST_ASSERT(!nullMethod); // throws OutOfBounds try { //CIMParameter p = m1.getParameter( // m1.findParameter(CIMName ("ipaddress"))); CIMConstParameter p = ccm1.getParameter(0); } catch(IndexOutOfBoundsException&) { } // throws OutOfBounds try { CIMConstQualifier q1 = ccm1.getQualifier(0); } catch(IndexOutOfBoundsException&) { } } catch(Exception& e) { cerr << "Exception: " << e.getMessage() << endl; } // Test for add second qualifier with same name. // Should do exception cout << argv[0] << " +++++ passed all tests" << endl; return 0; }
void UNIX_ApplicationSystemDependency::setScope(CIMName scope) { currentScope = CIMName(scope.getString()); }
#include <Pegasus/Common/CIMName.h> #include <Pegasus/Common/CIMInstance.h> #include <Pegasus/Common/CIMProperty.h> #include <Pegasus/Common/CIMValue.h> #include <Pegasus/Common/System.h> #include <Pegasus/Common/InternalException.h> #include <Pegasus/Common/AcceptLanguageList.h> #include <Pegasus/Common/ContentLanguageList.h> #include <Pegasus/Client/CIMClient.h> PEGASUS_USING_PEGASUS; PEGASUS_USING_STD; CIMNamespaceName providerNamespace; const CIMName CLASSNAME = CIMName ("TestCMPI_Broker"); Boolean verbose; Boolean useDefaultMsg; void _checkStringValue (CIMValue & theValue, const String & value, Boolean null = false) { PEGASUS_TEST_ASSERT (theValue.getType () == CIMTYPE_STRING); PEGASUS_TEST_ASSERT (!theValue.isArray ()); if (null) { PEGASUS_TEST_ASSERT (theValue.isNull ()); }
void RUEpProvider::_createAssociationInstances( Array<CIMInstance> nhrInst, Array<CIMInstance> ipifInst) { PEG_METHOD_ENTER(TRC_PROVIDERAGENT, "RUEpProvider::_createAssociationInstances()"); Uint16 nhrInstSize = nhrInst.size(); Uint16 ipifInstSize = ipifInst.size(); for (Uint16 i = 0; i < nhrInstSize; i++) // Routes loop. { CIMInstance _nhrInstRet, _ipifInstRet; CIMInstance _nhrInst = nhrInst[i]; CIMProperty _ipifAddress; CIMProperty _ipifSubnetMask_PrefixLength; CIMProperty _ipifProtocolIFType; CIMProperty _nhrInstanceID = _nhrInst.getProperty( _nhrInst.findProperty(PROPERTY_INSTANCE_ID)); CIMProperty _nhrAddrType; CIMProperty _nhrDestMask_PrefixLength; for (Uint16 j = 0; j<ipifInstSize; j++) // Interfaces loop. { CIMInstance _ipifInst = ipifInst[j]; _ipifProtocolIFType = _ipifInst.getProperty( _ipifInst.findProperty(PROPERTY_PROTOCOL_IF_TYPE)); Uint16 _pift; CIMValue _piftCIMValue = _ipifProtocolIFType.getValue(); if ((_piftCIMValue.getType() == CIMTYPE_UINT16) && (!_piftCIMValue.isNull ())) { _piftCIMValue.get(_pift); } else { throw CIMOperationFailedException( "Can't determine CIMValue::TYPE of ProtocolIFType:" + String(cimTypeToString(_piftCIMValue.getType()))); } if (_pift == 4096) // IPv4 address. { _ipifAddress = _ipifInst.getProperty( _ipifInst.findProperty( PROPERTY_IPV4ADDRESS)); _ipifSubnetMask_PrefixLength = _ipifInst.getProperty( _ipifInst.findProperty( PROPERTY_SUBNET_MASK)); } else { if (_pift == 4097) // IPv6 address. { _ipifAddress = _ipifInst.getProperty( _ipifInst.findProperty( PROPERTY_IPV6ADDRESS)); _ipifSubnetMask_PrefixLength = _ipifInst.getProperty( _ipifInst.findProperty( PROPERTY_IPV6ADDRESS)); } else { char buffer[22]; Uint32 sz; String _piftStr = Uint16ToString(buffer, _pift, sz); throw CIMOperationFailedException( "ProtocolIFType == " + _piftStr ); } } // In this implementation, we choose InstanceID to be // equal DestinationAddress. So, if Address of interface // and InstanceID of route doesn't match, check if SubnetMask // of interface and DestinationMask route does. if (!_nhrInstanceID.getValue().equal(_ipifAddress.getValue())) { _nhrAddrType = _nhrInst.getProperty( _nhrInst.findProperty( PROPERTY_ADDRESS_TYPE)); Uint16 _addrt; CIMValue _nhratCIMValue = _nhrAddrType.getValue(); if ((_nhratCIMValue.getType() == CIMTYPE_UINT16) && (!_nhratCIMValue.isNull())) { _nhratCIMValue.get(_addrt); } else { throw CIMOperationFailedException( "Can't determine CIMValue::TYPE of AddressType: " + String(cimTypeToString(_piftCIMValue.getType()))); } if (_addrt == 1) // IPv4 address. { _nhrDestMask_PrefixLength = _nhrInst.getProperty( _nhrInst.findProperty( PROPERTY_DESTINATION_MASK)); } else { if (_addrt == 2) // IPv6 address. { _nhrDestMask_PrefixLength = _nhrInst.getProperty( _nhrInst.findProperty( PROPERTY_PREFIX_LENGTH)); } else { char buffer[22]; Uint32 sz; String _addrtStr = Uint16ToString(buffer, _addrt, sz); throw CIMOperationFailedException( "Unknown AddressType = " + _addrtStr); } } // If SubnetMask of interface and DestinationMask route // doesn't match, these instances are unrelated. So, // proceed to the next pair. if (!_nhrDestMask_PrefixLength.getValue().equal( _ipifSubnetMask_PrefixLength.getValue())) { continue; } } // Build the CIMObjectPath from the instances matching CIMObjectPath _ipifObj = _ipifInst.getPath(); CIMObjectPath _nhrObj = _nhrInst.getPath(); CIMInstance assocInst(CLASS_PG_ROUTE_USES_ENDPOINT); assocInst.addProperty( CIMProperty( CIMName("Antecedent"), _ipifObj, 0, CLASS_CIM_PROTOCOL_ENDPOINT)); assocInst.addProperty( CIMProperty( CIMName("Dependent"), _nhrObj, 0, CLASS_CIM_NEXT_HOP_ROUTE)); // Build CIMObjectPath from keybindings Array<CIMKeyBinding> keyBindings; CIMKeyBinding _ipifBinding( CIMName("Antecedent"), _ipifObj.toString(), CIMKeyBinding::REFERENCE); CIMKeyBinding _nhrBinding( CIMName("Dependent"), _nhrObj.toString(), CIMKeyBinding::REFERENCE); keyBindings.append (_ipifBinding); keyBindings.append (_nhrBinding); CIMObjectPath path( String::EMPTY, CIMNamespaceName(), CLASS_PG_ROUTE_USES_ENDPOINT, keyBindings); assocInst.setPath(path); _AssociationInstances.append(assocInst); break; } // Interfaces loop end. } // Routes loop end. PEG_METHOD_EXIT(); }
// l10n - note: ignoring indication language void snmpIndicationHandler::handleIndication( const OperationContext& context, const String nameSpace, CIMInstance& indication, CIMInstance& handler, CIMInstance& subscription, ContentLanguages & contentLanguages) { Array<String> propOIDs; Array<String> propTYPEs; Array<String> propVALUEs; CIMProperty prop; CIMQualifier trapQualifier; Uint32 qualifierPos; String propValue; String mapstr1; String mapstr2; PEG_METHOD_ENTER (TRC_IND_HANDLER, "snmpIndicationHandler::handleIndication"); try { CIMClass indicationClass = _repository->getClass( nameSpace, indication.getClassName(), false, true, false, CIMPropertyList()); Uint32 propertyCount = indication.getPropertyCount(); for (Uint32 i=0; i < propertyCount; i++) { prop = indication.getProperty(i); if (!prop.isUninitialized()) { CIMName propName = prop.getName(); Uint32 propPos = indicationClass.findProperty(propName); if (propPos != PEG_NOT_FOUND) { CIMProperty trapProp = indicationClass.getProperty(propPos); qualifierPos = trapProp.findQualifier(CIMName ("MappingStrings")); if (qualifierPos != PEG_NOT_FOUND) { trapQualifier = trapProp.getQualifier(qualifierPos); mapstr1.clear(); mapstr1 = trapQualifier.getValue().toString(); if ((mapstr1.find("OID.IETF") != PEG_NOT_FOUND) && (mapstr1.find("DataType.IETF") != PEG_NOT_FOUND)) { if (mapstr1.subString(0, 8) == "OID.IETF") { mapstr1 = mapstr1.subString(mapstr1.find("SNMP.")+5); if (mapstr1.find("|") != PEG_NOT_FOUND) { mapstr2.clear(); mapstr2 = mapstr1.subString(0, mapstr1.find("DataType.IETF")-1); propOIDs.append(mapstr2); propValue.clear(); propValue = prop.getValue().toString(); propVALUEs.append(propValue); mapstr2 = mapstr1.subString(mapstr1.find("|")+2); mapstr2 = mapstr2.subString(0, mapstr2.size()-1); propTYPEs.append(mapstr2); } } } } } } } // 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 #ifdef HPUX_EMANATE static snmpDeliverTrap_emanate emanateTrap; #else static snmpDeliverTrap_stub emanateTrap; #endif 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")); if ((targetHostPos != PEG_NOT_FOUND) && (targetHostFormatPos != PEG_NOT_FOUND) && (snmpVersionPos != PEG_NOT_FOUND) && (indicationClass.findQualifier(CIMName ("MappingStrings")) != PEG_NOT_FOUND)) { // properties from the handler instance String targetHost; String otherTargetHostFormat = String(); String securityName = String(); String engineID = String(); Uint16 targetHostFormat = 0; Uint16 snmpVersion = 0; Uint32 portNumber; String trapOid; // // Get snmpTrapOid from context // try { SnmpTrapOidContainer trapContainer = context.get (SnmpTrapOidContainer::NAME); trapOid = trapContainer.getSnmpTrapOid(); } catch (Exception& e) { // get trapOid from indication Class Uint32 pos = indicationClass.findQualifier(CIMName ("MappingStrings")); if (pos != PEG_NOT_FOUND) { trapOid = indicationClass.getQualifier(pos).getValue().toString(); trapOid = trapOid.subString(11, PEG_NOT_FOUND); if ((String::compare(trapOid, "SNMP.", 5)) == 0) { trapOid = trapOid.subString(5, (trapOid.size()-6)); } else { PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4, "Invalid MappingStrings Value " + trapOid); PEG_METHOD_EXIT(); // l10n // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "Invalid MappingStrings Value"); throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, MessageLoaderParms("Handler.snmpIndicationHandler.snmpIndicationHandler.INVALID_MS_VALUE", "Invalid MappingStrings Value")); } } else { PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4, "Qualifier MappingStrings can not be found."); PEG_METHOD_EXIT(); //L10N_ TODO DONE //throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "Qualifier MappingStrings can not be found"); 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); } emanateTrap.deliverTrap( trapOid, securityName, targetHost, targetHostFormat, otherTargetHostFormat, portNumber, snmpVersion, engineID, propOIDs, propTYPEs, propVALUEs); } else { PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4, "Invalid IndicationHandlerSNMPMapper instance."); PEG_METHOD_EXIT(); // l10n // throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, // "Invalid IndicationHandlerSNMPMapper instance"); throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED, MessageLoaderParms("Handler.snmpIndicationHandler.snmpIndicationHandler.INVALID_SNMP_INSTANCE", "Invalid IndicationHandlerSNMPMapper instance")); } } catch (CIMException & c) { PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4, c.getMessage()); PEG_METHOD_EXIT(); throw PEGASUS_CIM_EXCEPTION (CIM_ERR_FAILED, c.getMessage()); } catch (Exception& e) { PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4, e.getMessage()); PEG_METHOD_EXIT(); throw PEGASUS_CIM_EXCEPTION (CIM_ERR_FAILED, e.getMessage()); } catch (...) { PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4, "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.")); } }
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; }
// // List of all the CIM Operations // // Note: The following tables contain all the existing CIM Operations. // Any new CIM Operations created must be included in one of these tables, // otherwise no CIM requests will have authorization to execute those // new operations. // // // List of read only CIM Operations // static const CIMName READ_OPERATIONS [] = { CIMName("GetClass"), CIMName("GetInstance"), CIMName("EnumerateClassNames"), CIMName("References"), CIMName("ReferenceNames"), CIMName("AssociatorNames"), CIMName("Associators"), CIMName("EnumerateInstanceNames"), CIMName("GetQualifier"), CIMName("EnumerateQualifiers"), CIMName("EnumerateClasses"), CIMName("EnumerateInstances"), CIMName("ExecQuery"), CIMName("GetProperty") };
void UNIX_CLPSettingData::setScope(CIMName scope) { currentScope = CIMName(scope.getString()); }
CIMInstance UNIX_BGPPeerGroupService::getDependent() const { return CIMInstance(CIMName("CIM_Dependency")); }
PEGASUS_NAMESPACE_BEGIN /****************************************************************************** ** ** Option Structure object. Initialization and any other ** used Function Definitions ** ******************************************************************************/ // Constructor - Instantiate the variables of the Option structure OptionStruct::OptionStruct(): isXmlOutput(false), deepInheritance(false), localOnly(true), includeQualifiersRequested(false), notIncludeQualifiersRequested(false), includeQualifiers(false), includeClassOrigin(false), verboseTest(false), summary(false), delay(0), trace(0), debug(false), sort(false), expectedCount(0), executeCountTest(false), repeat(0), time(false), termCondition(0), connectionTimeout(0), interactive(false), setRtnHostNames(false) { // Initialize the option structure values location = String(); #ifdef PEGASUS_HAS_SSL ssl = false; clientCert = String(); clientKey = String(); #endif nameSpace = String(); cimCmd = "unknown"; targetObjectName = CIMObjectPath(); outputFormatType = OUTPUT_MOF; user = String(); password = String(); assocClass = CIMName(); resultClass = CIMName(); role = String::EMPTY; resultRole = String(); propertyList.clear(); propertyName = String(); methodName = CIMName("unknown"); queryLanguage = "WQL"; rtnHostSubstituteName = String(); }
void CIMQualifierList::resolve( DeclContext* declContext, const CIMNamespaceName & nameSpace, CIMScope scope, // Scope of the entity being resolved. Boolean isInstancePart, CIMQualifierList& inheritedQualifiers, Boolean propagateQualifiers) { _keyIndex = PEGASUS_ORDEREDSET_INDEX_UNKNOWN; PEG_METHOD_ENTER(TRC_OBJECTRESOLUTION, "CIMQualifierList::resolve()"); // For each qualifier in the qualifiers array, the following // is checked: // // 1. Whether it is declared (can be obtained from the declContext). // // 2. Whether it has the same type as the declaration. // // 3. Whether the qualifier is valid for the given scope. // // 4. Whether the qualifier can be overriden (the flavor is // ENABLEOVERRIDE on the corresponding reference qualifier). // // 5. Whether the qualifier should be propagated to the subclass. // // If the qualifier should be overriden, then it is injected into the // qualifiers array (from the inheritedQualifiers array). for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++) { CIMQualifier q = _qualifiers[i]; //---------------------------------------------------------------------- // 1. Check to see if it's declared. //---------------------------------------------------------------------- // set this back to CIMConstQualifierDecl CIMQualifierDecl qd = declContext->lookupQualifierDecl( nameSpace, q.getName()); if (qd.isUninitialized()) { PEG_METHOD_EXIT(); throw UndeclaredQualifier(q.getName().getString ()); } //---------------------------------------------------------------------- // 2. Check the type and isArray. Must be the same: //---------------------------------------------------------------------- if (!(q.getType() == qd.getType() && q.isArray() == qd.isArray())) { PEG_METHOD_EXIT(); throw BadQualifierType(q.getName().getString ()); } //---------------------------------------------------------------------- // 3. If the qualifier is the EmbeddedInstance qualifier, then check // that the class specified by the qualifier exists in the namespace. //---------------------------------------------------------------------- if (q.getName().equal(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE)) { String className; q.getValue().get(className); CIMClass classDef = declContext->lookupClass(nameSpace, CIMName(className)); if (classDef.isUninitialized()) { String embeddedInstType("EmbeddedInstance(\""); embeddedInstType = embeddedInstType + className + "\")"; PEG_METHOD_EXIT(); throw BadQualifierType(embeddedInstType); } } //---------------------------------------------------------------------- // 4. Check the scope: Must be legal for this qualifier //---------------------------------------------------------------------- // ATTN: These lines throw a bogus exception if the qualifier has // a valid scope (such as Scope::ASSOCIATION) which is not Scope::CLASS // ks Mar 2002. Reinstalled 23 March 2002 to test. if (!(qd.getScope().hasScope (scope))) { PEG_METHOD_EXIT(); throw BadQualifierScope (qd.getName().getString (), scope.toString ()); } //---------------------------------------------------------------------- // Resolve the qualifierflavor. Since Flavors are a combination of // inheritance and input characteristics, resolve the inherited // characteristics against those provided with the creation. If // there is a superclass the flavor is resolved against that // superclass. If not, it is resolved against the declaration. If // the flavor is disableoverride and tosubclass the resolved // qualifier value must be identical to the original //---------------------------------------------------------------------- // Test for Qualifier found in SuperClass. If found and qualifier // is not overridable. // Abstract (not Overridable and restricted) can be found in subclasses // Can have nonabstracts below abstracts. That is function of // nottosubclass Association (notOverridable and tosubclass) can be // found in subclasses but cannot be changed. No non-associatons below // associations. In other words once a class becomes an association, // no subclass can override that definition apparently // Throw exception if DisableOverride and tosubclass and different // value. Gets the source from superclass if qualifier exists or from // declaraction. // If we do not throw the exception, resolve the flavor from the // inheritance point and resolve against current input. // Diableoverride is defined in the CIM Spec to mean that the value // cannot change. // The other characteristics including the flavor can change // apparently. Thus, we need only confirm that the value is the same // (2.2 pp 33). Strange since we would think that override implies // that you cannot override any of the characteristics (value, type, // flavor, etc.) This also leaves the question of NULL or no values. // The implication is that we must move the value from the superclass // or declaration. Uint32 index = inheritedQualifiers.find(q.getName()); if (index == PEG_NOT_FOUND) { // Qualifier does not exist in superclass /* If from declaration, we can override the default value. However, we need some way to get the value if we have a Null. if (!qd.getFlavor().hasFlavor(CIMFlavor::OVERRIDABLE) && qd.getFlavor().hasFlavor(CIMFlavor::TOSUBCLASS)) { //throw BadQualifierOverride(q.getName()); } */ // Do not allow change from disable override to enable override. if ((!qd.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE)) && (q.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))) { PEG_METHOD_EXIT(); throw BadQualifierOverride(q.getName().getString ()); } Resolver::resolveQualifierFlavor( q, CIMFlavor (qd.getFlavor ()), false); } else // qualifier exists in superclass { ////// Make Const again CIMQualifier iq = inheritedQualifiers.getQualifier(index); // don't allow change override to notoverride. if (!(iq.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE)) && q.getFlavor ().hasFlavor (CIMFlavor::OVERRIDABLE)) { PEG_METHOD_EXIT(); throw BadQualifierOverride(q.getName().getString ()); } if (!(iq.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE)) && iq.getFlavor ().hasFlavor(CIMFlavor::TOSUBCLASS)) { // test if values the same. CIMValue qv = q.getValue(); CIMValue iqv = iq.getValue(); if (!(qv == iqv)) { PEG_METHOD_EXIT(); throw BadQualifierOverride(q.getName().getString()); } } Resolver::resolveQualifierFlavor( q, CIMFlavor(iq.getFlavor()), true); } } // end of this objects qualifier loop //-------------------------------------------------------------------------- // Propagate qualifiers to subclass or to instance that do not have // already have those qualifiers: //-------------------------------------------------------------------------- if (propagateQualifiers) { for (Uint32 i = 0, n = inheritedQualifiers.getCount(); i < n; i++) { CIMQualifier iq = inheritedQualifiers.getQualifier(i); if (isInstancePart) { if (!(iq.getFlavor().hasFlavor(CIMFlavor::TOINSTANCE))) continue; } else { if (!(iq.getFlavor().hasFlavor(CIMFlavor::TOSUBCLASS))) continue; } // If the qualifiers list does not already contain this qualifier, // then propagate it (and set the propagated flag to true). Else // we keep current value. Note we have already eliminated any // possibility that a nonoverridable qualifier can be in the list. if (find(iq.getName()) != PEG_NOT_FOUND) continue; CIMQualifier q = iq.clone(); q.setPropagated(true); _qualifiers.insert(0, q); } } PEG_METHOD_EXIT(); }
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 UNIX_BGPIPRoute::setScope(CIMName scope) { currentScope = CIMName(scope.getString()); }
CIMInstance UNIX_CardOnCard::getPartComponent() const { return CIMInstance(CIMName("CIM_Component")); }
// // Initialize the namespaces so that all namespaces with the // CIM_ElementConformsToProfile class also have the // PG_ElementConformsToProfile class. Needed in order to implement // the cross-namespace ElementConformsToProfile association in both // directions. // void InteropProvider::initializeNamespaces() { Array<CIMNamespaceName> namespaceNames = repository->enumerateNameSpaces(); // get the PG_ElementConformstoProfile class without the qualifiers // and then add just the required ASSOCIATION qualifier, so that // resolveclass doesn't fail for the test/EmbeddedInstance/Dynamic // namespace, which uses the CIM25 schema that doesn't include any // of the new qualifiers added to this class in later versions of // the CIMSchema. CIMClass conformsClass = repository->getClass( PEGASUS_NAMESPACENAME_INTEROP, PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE, true, false); conformsClass.addQualifier( CIMQualifier(CIMName("ASSOCIATION"), CIMValue(true))); CIMClass profileClass = repository->getClass( PEGASUS_NAMESPACENAME_INTEROP, PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE, true, false); for(Uint32 i = 0, n = namespaceNames.size(); i < n; ++i) { // Check if the PG_ElementConformsToProfile class is present CIMNamespaceName & currentNamespace = namespaceNames[i]; CIMClass tmpCimClass; CIMClass tmpPgClass; CIMClass tmpPgProfileClass; try { // Look for these classes in the same try-block since the // second depends on the first tmpCimClass = repository->getClass( currentNamespace, PEGASUS_CLASSNAME_CIM_ELEMENTCONFORMSTOPROFILE); tmpPgClass = repository->getClass( currentNamespace, PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE); } catch(const Exception &) { } try { tmpPgProfileClass = repository->getClass( currentNamespace, PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE); } catch(const Exception &) { // Note: if any of the above three classes aren't found, // an exception will be thrown, which we can ignore since it's // an expected case // TBD: Log trace message? } // If the CIM_ElementConformsToProfile class is present, but // the PG_ElementConformsToProfile or PG_RegisteredProfile // class is not, then add it to that namespace. // // Note that we don't have to check for the // CIM_RegisteredProfile class because if the // CIM_ElementConformsToProfile class is present, the // CIM_RegisteredProfile class must also be present. if(!tmpCimClass.isUninitialized()) { if(tmpPgClass.isUninitialized()) { CIMClass newclass = conformsClass.clone(); CIMObjectPath newPath = conformsClass.getPath(); newPath.setNameSpace(currentNamespace); newclass.setPath(newPath); repository->createClass( currentNamespace, newclass); } if(tmpPgProfileClass.isUninitialized()) { CIMClass newclass = profileClass.clone(); CIMObjectPath newPath = profileClass.getPath(); newPath.setNameSpace(currentNamespace); newclass.setPath(newPath); repository->createClass( currentNamespace, newclass); } } } }