pegasus/src/Pegasus/ControlProviders/InteropProvider/ElementConformsToProfile.cpp - annotate

Return to ElementConformsToProfile.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ControlProviders / InteropProvider

1 martin 1.8 //%LICENSE////////////////////////////////////////////////////////////////
2 martin 1.9 //
3 martin 1.8 // Licensed to The Open Group (TOG) under one or more contributor license 4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with 5 // this work for additional information regarding copyright ownership. 6 // Each contributor licenses this file to you under the OpenPegasus Open 7 // Source License; you may not use this file except in compliance with the 8 // License.
9 martin 1.9 //
10 martin 1.8 // Permission is hereby granted, free of charge, to any person obtaining a 11 // copy of this software and associated documentation files (the "Software"), 12 // to deal in the Software without restriction, including without limitation 13 // the rights to use, copy, modify, merge, publish, distribute, sublicense, 14 // and/or sell copies of the Software, and to permit persons to whom the 15 // Software is furnished to do so, subject to the following conditions:
16 martin 1.9 //
17 martin 1.8 // The above copyright notice and this permission notice shall be included 18 // in all copies or substantial portions of the Software.
19 martin 1.9 //
20 martin 1.8 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 martin 1.9 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 martin 1.8 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 martin 1.9 //
28 martin 1.8 //////////////////////////////////////////////////////////////////////////
29 kumpf 1.4 //
30 s.manicka 1.5 //%////////////////////////////////////////////////////////////////////////////
31 a.dunfey 1.1 32 33 /////////////////////////////////////////////////////////////////////////////// 34 // Interop Provider - This provider services those classes from the 35 // DMTF Interop schema in an implementation compliant with the SMI-S v1.1 36 // Server Profile 37 // 38 // Please see PG_ServerProfile20.mof in the directory 39 // $(PEGASUS_ROOT)/Schemas/Pegasus/InterOp/VER20 for retails regarding the 40 // classes supported by this control provider. 41 //
42 kumpf 1.10 // Interop forces all creates to the PEGASUS_NAMESPACENAME_INTEROP 43 // namespace. There is a test on each operation that returns
44 a.dunfey 1.1 // the Invalid Class CIMDError 45 // This is a control provider and as such uses the Tracer functions 46 // for data and function traces. Since we do not expect high volume 47 // use we added a number of traces to help diagnostics. 48 /////////////////////////////////////////////////////////////////////////////// 49 50 #include "InteropProvider.h" 51 #include "InteropProviderUtils.h" 52 #include "InteropConstants.h" 53 54 PEGASUS_USING_STD;
55 a.dunfey 1.2 PEGASUS_NAMESPACE_BEGIN
56 a.dunfey 1.1 57 // 58 // Given the two references in the association, this function creates an 59 // instance of the PG_ElementConformsToProfile class. 60 // 61 CIMInstance buildElementConformsToProfile( 62 const CIMObjectPath & currentProfile, 63 const CIMObjectPath & currentElement, 64 const CIMClass & elementConformsClass) 65 { 66 Array<CIMName> elementPropArray; 67 elementPropArray.append( 68 ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD); 69 elementPropArray.append( 70 ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT); 71 CIMPropertyList elementPropList(elementPropArray); 72 73 CIMInstance tmpInstance = 74 elementConformsClass.buildInstance(false, false, 75 elementPropList); 76 setPropertyValue(tmpInstance, 77 a.dunfey 1.1 ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD, 78 currentProfile); 79 setPropertyValue(tmpInstance, 80 ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT, 81 currentElement); 82 tmpInstance.setPath(tmpInstance.buildPath( 83 elementConformsClass)); 84 return tmpInstance; 85 } 86
87 s.manicka 1.5 Array<CIMInstance> InteropProvider::enumElementConformsToProfileRPRPInstances(
88 kumpf 1.10 const OperationContext & opContext,
89 s.manicka 1.5 const CIMNamespaceName & opNamespace) 90 { 91 CIMClass elementConformsClass = repository->getClass( 92 PEGASUS_NAMESPACENAME_INTEROP, 93 PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE_RP_RP, 94 false, true, false); 95 96 Array<CIMInstance> instances; 97 CIMObjectPath smisVersionProfile, profRegProfile; 98 99 if (opNamespace == PEGASUS_NAMESPACENAME_INTEROP) 100 {
101 kumpf 1.10 //Add associations between the 1.2 SMIS-Version profile and all 102 //the version 1.2.0 profiles and subprofiles.
103 s.manicka 1.5 smisVersionProfile = buildDependencyReference( 104 hostName, 105 buildProfileInstanceId(SNIA_NAME, "SMI-S", SNIA_VER_120), 106 PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE); 107
108 kumpf 1.10 Array<CIMInstance> profileInstances =
109 s.manicka 1.5 enumRegisteredProfileInstances();
110 kumpf 1.10 Array<CIMInstance> subprofileInstances =
111 s.manicka 1.5 enumRegisteredSubProfileInstances(); 112 profileInstances.appendArray(subprofileInstances); 113 Array<CIMInstance> profilesForVersion = getProfilesForVersion(
114 venkat.puvvada 1.12 profileInstances, SNIA_NUM, 1, 2, 0);
115 s.manicka 1.5 for (Uint32 i = 0, n = profilesForVersion.size(); i < n; ++i) 116 { 117 instances.append(buildElementConformsToProfile( 118 smisVersionProfile,
119 kumpf 1.10 profilesForVersion[i].getPath(),
120 s.manicka 1.5 elementConformsClass)); 121 } 122 } 123 return instances; 124 } 125
126 a.dunfey 1.1 // 127 // Enumerates all of the ElementConformsToProfile association instances. 128 // 129 Array<CIMInstance> InteropProvider::enumElementConformsToProfileInstances( 130 const OperationContext & opContext, const CIMNamespaceName & opNamespace) 131 { 132 CIMClass elementConformsClass = repository->getClass( 133 PEGASUS_NAMESPACENAME_INTEROP, 134 PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE, 135 false, true, false); 136 137 AutoMutex holder(interopMut); 138 Array<CIMInstance> instances; 139 verifyCachedInfo(); 140 // Loop through the cached profile Id's and related info about its 141 // conforming elements.
142 kumpf 1.4 for (Uint32 i = 0, n = profileIds.size(); i < n; ++i)
143 a.dunfey 1.1 { 144 String & profileId = profileIds[i]; 145 Array<CIMName> & elementList = conformingElements[i]; 146 Array<CIMNamespaceName> & namespaceList = elementNamespaces[i]; 147 Array<CIMObjectPath> conformingElementPaths;
148 kumpf 1.4 for (Uint32 j = 0, m = elementList.size(); j < m; ++j)
149 a.dunfey 1.1 { 150 CIMName & currentElement = elementList[j]; 151 CIMNamespaceName & currentNamespace = namespaceList[j]; 152
153 kumpf 1.4 if (opNamespace == PEGASUS_NAMESPACENAME_INTEROP \|\|
154 a.dunfey 1.1 opNamespace == currentNamespace) 155 { 156 String currentElementStr(currentElement.getString());
157 kumpf 1.4 if (currentElementStr.find(PEGASUS_DYNAMIC) == 0)
158 a.dunfey 1.1 { 159 // If the provider profile registration did not provide a 160 // list of conforming elements (presumably because there is 161 // no such definite list), then the provider is required 162 // to provide instances of ElementConformsToProfile in the 163 // vendor namespace, so we do not generate instances.
164 kumpf 1.4 if (opNamespace != PEGASUS_NAMESPACENAME_INTEROP)
165 a.dunfey 1.1 { 166 continue; 167 } 168 CIMName subclassName( 169 currentElementStr.subString(PEGASUS_DYNAMIC_LEN)); 170 Array<CIMInstance> elementConformsInstances = 171 cimomHandle.enumerateInstances(opContext, 172 currentNamespace, subclassName, true, false, false, 173 true, CIMPropertyList()); 174 175 // Retrieve the Conforming Element
176 kumpf 1.4 for (Uint32 k = 0, x = elementConformsInstances.size();
177 a.dunfey 1.1 k < x; ++k) 178 { 179 CIMInstance & currentInstance = 180 elementConformsInstances[k]; 181
182 kumpf 1.4 // NOCHKSRC
183 a.dunfey 1.1 // Make sure that the current instance points to the 184 // current profile ID. 185 CIMObjectPath profilePath = 186 getRequiredValue<CIMObjectPath>( 187 elementConformsInstances[k], 188 ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD);
189 kumpf 1.4 // DOCHKSRC
190 a.dunfey 1.1 const Array<CIMKeyBinding> & keys = 191 profilePath.getKeyBindings();
192 kumpf 1.4 if (keys.size() != 1)
193 a.dunfey 1.1 continue;
194 kumpf 1.4 if (keys.size() == 1 && keys[0].getValue() == profileId)
195 a.dunfey 1.1 {
196 kumpf 1.4 // NOCHKSRC
197 a.dunfey 1.1 conformingElementPaths.append( 198 getRequiredValue<CIMObjectPath>( 199 currentInstance, 200 ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT));
201 kumpf 1.4 // DOCHKSRC
202 a.dunfey 1.1 } 203 } 204 } 205 else 206 { 207 // All of the instances of the current element in the 208 // corresponding namespace conform to the current profile. 209 Array<CIMObjectPath> paths = 210 cimomHandle.enumerateInstanceNames(opContext, 211 currentNamespace, currentElement); 212 // Set the namespace in the paths just in case
213 kumpf 1.4 for (Uint32 k = 0, x = paths.size();
214 a.dunfey 1.1 k < x; ++k) 215 { 216 CIMObjectPath & curPath = paths[k]; 217 curPath.setNameSpace(currentNamespace); 218 curPath.setHost(hostName); 219 } 220 conformingElementPaths.appendArray(paths); 221 } 222 } 223 } 224 225 // Create the object path for the RegisteredProfile using the given 226 // profileId. 227 CIMObjectPath profilePath = buildDependencyReference( 228 hostName, profileIds[i], PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE); 229 230 // Build all of the ElementConformsToProfile instances for the current 231 // profile.
232 kumpf 1.4 for (Uint32 k = 0, x = conformingElementPaths.size(); k < x; ++k)
233 a.dunfey 1.1 { 234 instances.append(buildElementConformsToProfile(profilePath, 235 conformingElementPaths[k], elementConformsClass)); 236 } 237 } 238 239 // Now add the default instance: the association between the Server Profile 240 // and the ObjectManager (if we're in the Interop namespace)
241 kumpf 1.4 if (opNamespace == PEGASUS_NAMESPACENAME_INTEROP)
242 a.dunfey 1.1 {
243 s.manicka 1.5 // Build up the Object Path for the server profile version 1.1.0 244 CIMObjectPath serverProfile = buildDependencyReference( 245 hostName,
246 a.dunfey 1.1 buildProfileInstanceId(SNIA_NAME, "Server", SNIA_VER_110), 247 PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE); 248 // Retrieve the Object Manager instance 249 CIMInstance objManager = getObjectManagerInstance(); 250
251 s.manicka 1.5 instances.append( 252 buildElementConformsToProfile( 253 serverProfile,
254 kumpf 1.10 objManager.getPath(),
255 s.manicka 1.5 elementConformsClass)); 256 257 // Build up the Object Path for the server profile ver 1.2.0 258 // and add the elementconformstoprofile association instance 259 serverProfile = buildDependencyReference( 260 hostName, 261 buildProfileInstanceId(SNIA_NAME, "Server", SNIA_VER_120), 262 PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE); 263 instances.append( 264 buildElementConformsToProfile( 265 serverProfile,
266 kumpf 1.10 objManager.getPath(),
267 s.manicka 1.5 elementConformsClass));
268 kumpf 1.10
269 a.dunfey 1.1 }
270 venkat.puvvada 1.14 271 #ifdef PEGASUS_ENABLE_DMTF_INDICATION_PROFILE_SUPPORT 272 // Now add the association between the Indication profile 273 // and IndicationService 274 if (opNamespace == PEGASUS_NAMESPACENAME_INTEROP) 275 { 276 CIMObjectPath serverProfile = buildDependencyReference( 277 hostName,
278 venkat.puvvada 1.15 buildProfileInstanceId(DMTF_NAME, "Indications", DMTF_VER_110),
279 venkat.puvvada 1.14 PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE); 280 // Retrieve the IndicationService instance 281 Array<CIMInstance> indService = 282 enumIndicationServiceInstances(OperationContext()); 283 284 instances.append( 285 buildElementConformsToProfile( 286 serverProfile, 287 indService[0].getPath(), 288 elementConformsClass)); 289 } 290 #endif 291
292 s.manicka 1.5 return instances; 293 } 294 295 //Method that filters the registered profile or registered subprofile instances
296 venkat.puvvada 1.12 //whose versions are greater or equal to the given version.
297 s.manicka 1.5 Array<CIMInstance> InteropProvider::getProfilesForVersion( 298 Array<CIMInstance>& profiles,
299 venkat.puvvada 1.12 Uint16 regOrg, 300 Uint32 majorVer, 301 Uint32 minorVer, 302 Uint32 updateVer)
303 s.manicka 1.5 {
304 venkat.puvvada 1.12 static const String SMISProfileName("SMI-S");
305 venkat.puvvada 1.13 static const String SNIAIndicationProfileName("Indication"); 306 static const String DMTFIndicationProfileName("Indications");
307 venkat.puvvada 1.12 static const String ServerProfileName("Server"); 308 static const String SoftwareProfileName("Software"); 309
310 s.manicka 1.5 Array<CIMInstance> instances; 311 instances.clear(); 312 for (Uint32 i = 0, n = profiles.size(); i < n; ++i) 313 { 314 String versionNumber; 315 String profileName;
316 dl.meetei 1.16 //Can use 0 here as registered organization value of 0 is 317 //ruled out(not specified in the CIM Schema 318 Uint16 regOrgNo = 0;
319 venkat.puvvada 1.12
320 s.manicka 1.5 Uint32 index = profiles[i].findProperty("RegisteredVersion"); 321 if (index != PEG_NOT_FOUND) 322 { 323 const CIMValue &tmpVal = profiles[i].getProperty(index).getValue(); 324 if (!tmpVal.isNull()) 325 { 326 tmpVal.get(versionNumber); 327 } 328 } 329 index = profiles[i].findProperty("RegisteredName"); 330 if (index != PEG_NOT_FOUND) 331 { 332 const CIMValue &tmpVal = profiles[i].getProperty(index).getValue(); 333 if (!tmpVal.isNull()) 334 { 335 tmpVal.get(profileName); 336 } 337 }
338 venkat.puvvada 1.12 index = profiles[i].findProperty("RegisteredOrganization"); 339 if (index != PEG_NOT_FOUND) 340 { 341 const CIMValue &tmpVal = profiles[i].getProperty(index).getValue(); 342 if (!tmpVal.isNull()) 343 { 344 tmpVal.get(regOrgNo); 345 } 346 }
347 a.dunfey 1.1
348 dl.meetei 1.16 if ( regOrgNo != 0 && regOrg == regOrgNo)
349 s.manicka 1.5 {
350 venkat.puvvada 1.12 if (profileName == ServerProfileName \|\|
351 venkat.puvvada 1.13 (regOrg == SNIA_NUM && 352 profileName == SNIAIndicationProfileName) \|\| 353 (regOrg == DMTF_NUM 354 && profileName == DMTFIndicationProfileName) \|\|
355 venkat.puvvada 1.12 profileName == SoftwareProfileName) 356 { 357 if (VersionUtil::isVersionGreaterOrEqual( 358 versionNumber, majorVer, minorVer, updateVer)) 359 { 360 instances.append(profiles[i]); 361 } 362 } 363 else if (profileName != SMISProfileName) 364 { 365 instances.append(profiles[i]); 366 }
367 s.manicka 1.5 } 368 }
369 a.dunfey 1.1 return instances; 370 } 371 372 373 typedef Array<String> StringArray; 374 375 void InteropProvider::verifyCachedInfo() 376 {
377 venkat.puvvada 1.6 if (!updateProfileCache.get()) 378 { 379 return; 380 } 381 // At present cache will be rebuilt in the following conditions. 382 // (1) When instances of PG_ProviderProfileCapabilities is created 383 // or deleted. 384 // (2) When Provider and ProviderCapabilities instances 385 // are created or Provider, ProviderModule and ProviderCapabilities 386 // instance are deleted. 387 // (3) When Provider or ProviderModule is disabled or enabled. 388 AutoMutex mtx(interopMut); 389 if (updateProfileCache.get()) 390 { 391 initializeNamespaces(); 392 cacheProfileRegistrationInfo(); 393 updateProfileCache--; 394 }
395 a.dunfey 1.1 } 396 397 // 398 // Function that determines in which namespaces a provider supports a given 399 // class. This information is needed to properly implement the 400 // ElementConformsToProfile association. 401 // 402 Array<String> findProviderNamespacesForElement( 403 const String & moduleName, const String & providerName, 404 const CIMName & elementClass, CIMRepository * repository, 405 Array<CIMInstance> & providerCapabilitiesInstances) 406 { 407 Array<CIMInstance> capabilities;
408 kumpf 1.4 if (providerCapabilitiesInstances.size() == 0)
409 a.dunfey 1.1 { 410 Array<CIMName> propList; 411 propList.append(PROVIDERCAPABILITIES_PROPERTY_PROVIDERMODULENAME); 412 propList.append(PROVIDERCAPABILITIES_PROPERTY_PROVIDERNAME); 413 propList.append(PROVIDERCAPABILITIES_PROPERTY_NAMESPACES); 414 propList.append(PROVIDERCAPABILITIES_PROPERTY_CLASSNAME); 415 capabilities = repository->enumerateInstancesForClass( 416 PEGASUS_NAMESPACENAME_INTEROP,
417 kumpf 1.11 PEGASUS_CLASSNAME_PROVIDERCAPABILITIES, false, false);
418 a.dunfey 1.1 } 419 else 420 { 421 capabilities = providerCapabilitiesInstances; 422 } 423
424 kumpf 1.4 for (Uint32 i = 0, n = capabilities.size(); i < n; ++i)
425 a.dunfey 1.1 { 426 CIMInstance & currentCapabilities = capabilities[i]; 427 Uint32 propIndex = currentCapabilities.findProperty( 428 PROVIDERCAPABILITIES_PROPERTY_PROVIDERMODULENAME); 429 PEGASUS_ASSERT(propIndex != PEG_NOT_FOUND); 430 String currentName; 431 currentCapabilities.getProperty(propIndex).getValue().get( 432 currentName);
433 kumpf 1.4 if (currentName == moduleName)
434 a.dunfey 1.1 { 435 propIndex = currentCapabilities.findProperty( 436 PROVIDERCAPABILITIES_PROPERTY_PROVIDERNAME); 437 PEGASUS_ASSERT(propIndex != PEG_NOT_FOUND); 438 currentCapabilities.getProperty(propIndex).getValue().get( 439 currentName);
440 kumpf 1.4 if (currentName == providerName)
441 a.dunfey 1.1 { 442 propIndex = currentCapabilities.findProperty( 443 PROVIDERCAPABILITIES_PROPERTY_CLASSNAME); 444 PEGASUS_ASSERT(propIndex != PEG_NOT_FOUND); 445 currentCapabilities.getProperty(propIndex).getValue().get( 446 currentName);
447 kumpf 1.4 if (elementClass.equal(CIMName(currentName)))
448 a.dunfey 1.1 { 449 propIndex = currentCapabilities.findProperty( 450 PROVIDERCAPABILITIES_PROPERTY_NAMESPACES); 451 PEGASUS_ASSERT(propIndex != PEG_NOT_FOUND); 452 Array<String> namespaces; 453 currentCapabilities.getProperty(propIndex).getValue().get( 454 namespaces); 455 return namespaces; 456 } 457 } 458 } 459 } 460 461 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_FOUND, 462 "Could not find provider capabilities registered for module " + 463 moduleName + ", provider " + providerName + ", and class " + 464 elementClass.getString()); 465 } 466 467 // 468 // Method that caches certain profile registration information. Specifically, 469 a.dunfey 1.1 // information pertaining to the ElementConformsToProfofile association 470 // implementation is kept here. 471 // 472 void InteropProvider::cacheProfileRegistrationInfo() 473 { 474 Array<CIMInstance> instances; 475 Array<CIMInstance> providerCapabilitiesInstances;
476 venkat.puvvada 1.6 477 // Clear existing cache 478 profileIds.clear(); 479 conformingElements.clear(); 480 elementNamespaces.clear(); 481
482 a.dunfey 1.1 // Retrieve all of the provider profile registration info 483 Array<CIMName> propList; 484 propList.append(CAPABILITIES_PROPERTY_PROVIDERMODULENAME); 485 propList.append(CAPABILITIES_PROPERTY_PROVIDERNAME); 486 propList.append(PROFILECAPABILITIES_PROPERTY_PROFILEVERSION); 487 propList.append(PROFILECAPABILITIES_PROPERTY_REGISTEREDPROFILE); 488 propList.append(PROFILECAPABILITIES_PROPERTY_OTHERREGISTEREDPROFILE); 489 propList.append(PROFILECAPABILITIES_PROPERTY_OTHERPROFILEORGANIZATION); 490 propList.append(PROFILECAPABILITIES_PROPERTY_CONFORMINGELEMENTS);
491 venkat.puvvada 1.6
492 kumpf 1.10 Array<CIMInstance> providerProfileInstances =
493 venkat.puvvada 1.6 enumProviderProfileCapabilityInstances( 494 true, 495 false, 496 false, 497 CIMPropertyList(propList)); 498
499 a.dunfey 1.1 CIMClass elementConformsClass = repository->getClass( 500 PEGASUS_NAMESPACENAME_INTEROP, 501 PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE, 502 false, true, false); 503 CIMClass registeredProfileClass = repository->getClass( 504 PEGASUS_NAMESPACENAME_INTEROP, 505 PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE, 506 false, true, false); 507 Array<CIMInstance> capabilities; 508 509 // Loop through the provider profile info to determine what profiles are 510 // supported by what providers, and to build the ElementConformsToProfile 511 // associations.
512 kumpf 1.4 for (Uint32 i = 0, n = providerProfileInstances.size(); i < n; ++i)
513 a.dunfey 1.1 { 514 CIMInstance & currentProfileInstance = providerProfileInstances[i]; 515 String moduleName = getRequiredValue<String>(currentProfileInstance, 516 CAPABILITIES_PROPERTY_PROVIDERMODULENAME); 517 String providerName = getRequiredValue<String>(currentProfileInstance, 518 CAPABILITIES_PROPERTY_PROVIDERNAME); 519 String profileName; 520 Uint16 profileOrganization = 0; 521 String profileVersion; 522 String organizationName; 523 Array<String> profileNames; // Not going to use this info 524 Array<String> profileVersions; // Not going to use this info 525 Array<Uint16> profileOrganizations; // Not going to use this info 526 Array<String> profileOrganizationNames; // Not going to use this info
527 venkat.puvvada 1.6 Array<String> providerModuleNames; // Not going to use this info 528 Array<String> providerNames; // Not going to use this info 529
530 a.dunfey 1.1 String profileId = extractProfileInfo(currentProfileInstance, 531 profileCapabilitiesClass, 532 registeredProfileClass, 533 profileName, 534 profileVersion, 535 profileOrganization, 536 organizationName, 537 profileNames, 538 profileVersions, 539 profileOrganizations, 540 profileOrganizationNames,
541 venkat.puvvada 1.6 providerModuleNames, 542 providerNames,
543 a.dunfey 1.1 true);
544 venkat.puvvada 1.6
545 a.dunfey 1.1 Uint32 propIndex = currentProfileInstance.findProperty( 546 PROFILECAPABILITIES_PROPERTY_CONFORMINGELEMENTS); 547 548 Array<CIMName> elementPropArray; 549 elementPropArray.append( 550 ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD); 551 elementPropArray.append( 552 ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT); 553 CIMPropertyList elementPropList(elementPropArray); 554 555 Array<CIMName> conformingElementsForProfile; 556 Array<CIMNamespaceName> elementNamespacesForProfile; 557 558 Array<String> elementClasses; 559 currentProfileInstance.getProperty(propIndex).getValue().get( 560 elementClasses);
561 kumpf 1.4 //if (propIndex == PEG_NOT_FOUND) 562 if (elementClasses.size() == 0)
563 a.dunfey 1.1 { 564 // Get the namespaces in which this provider operates and trim down 565 // the list of capabilities instaces to just those that are related 566 // to this one.
567 kumpf 1.4 if (capabilities.size() == 0)
568 a.dunfey 1.1 {
569 kumpf 1.7 Array<CIMName> capPropList; 570 capPropList.append(
571 a.dunfey 1.1 PROVIDERCAPABILITIES_PROPERTY_PROVIDERMODULENAME);
572 kumpf 1.7 capPropList.append(PROVIDERCAPABILITIES_PROPERTY_PROVIDERNAME); 573 capPropList.append(PROVIDERCAPABILITIES_PROPERTY_NAMESPACES); 574 capPropList.append(PROVIDERCAPABILITIES_PROPERTY_CLASSNAME);
575 a.dunfey 1.1 capabilities = repository->enumerateInstancesForClass( 576 PEGASUS_NAMESPACENAME_INTEROP,
577 kumpf 1.11 PEGASUS_CLASSNAME_PROVIDERCAPABILITIES, false, false);
578 a.dunfey 1.1 } 579 Array<CIMInstance> capabilitiesForProvider; 580 Array<CIMNamespaceName> namespacesForProvider; 581 Array<CIMNameArray> subclassesForNamespace;
582 kumpf 1.4 for (Uint32 j = 0, m = capabilities.size(); j < m; ++j)
583 a.dunfey 1.1 { 584 CIMInstance & currentInstance = capabilities[j]; 585 String curModuleName = getRequiredValue<String>( 586 currentInstance, CAPABILITIES_PROPERTY_PROVIDERMODULENAME); 587 String curProviderName = getRequiredValue<String>( 588 currentInstance, CAPABILITIES_PROPERTY_PROVIDERNAME);
589 kumpf 1.4 if (curModuleName == moduleName &&
590 a.dunfey 1.1 curProviderName == providerName) 591 { 592 CIMName currentClass(getRequiredValue<String>( 593 currentInstance, 594 PROVIDERCAPABILITIES_PROPERTY_CLASSNAME)); 595 capabilitiesForProvider.append(currentInstance); 596 StringArray curNamespaces = 597 getRequiredValue<StringArray>(currentInstance, 598 PROVIDERCAPABILITIES_PROPERTY_NAMESPACES); 599 Sint32 z = 0; 600 Sint32 y = curNamespaces.size(); 601 602 // If one of the namespaces is Interop, then continue 603 bool interopNamespaceFound = false;
604 kumpf 1.4 for (; z < y; ++z)
605 a.dunfey 1.1 {
606 kumpf 1.4 if (CIMNamespaceName(curNamespaces[z]) ==
607 a.dunfey 1.1 PEGASUS_NAMESPACENAME_INTEROP) 608 { 609 interopNamespaceFound = true; 610 break; 611 } 612 }
613 kumpf 1.4 if (interopNamespaceFound)
614 a.dunfey 1.1 continue; 615 616 // See if the current namespaces are already listed
617 kumpf 1.7 for (Sint32 w = 0; w < y; ++w)
618 a.dunfey 1.1 { 619 Sint32 foundIndex = -1;
620 kumpf 1.7 CIMNamespaceName curNamespace = curNamespaces[w];
621 a.dunfey 1.1 Uint32 k = 0; 622 Uint32 x = namespacesForProvider.size();
623 kumpf 1.4 for (; k < x; ++k)
624 a.dunfey 1.1 {
625 kumpf 1.4 if (curNamespace == namespacesForProvider[k])
626 a.dunfey 1.1 { 627 foundIndex = (Sint32)k; 628 break; 629 } 630 }
631 kumpf 1.4 if (foundIndex == -1)
632 a.dunfey 1.1 { 633 // Get all the subclasses of 634 // ElementConformsToProfile in the namespace and 635 // cache them. 636 foundIndex = namespacesForProvider.size();
637 kumpf 1.10 Array<CIMName> subClasses =
638 a.dunfey 1.1 repository->enumerateClassNames(curNamespace, 639 PEGASUS_CLASSNAME_CIM_ELEMENTCONFORMSTOPROFILE, 640 true); 641 subClasses.append( 642 PEGASUS_CLASSNAME_CIM_ELEMENTCONFORMSTOPROFILE 643 ); 644 namespacesForProvider.append(curNamespace); 645 subclassesForNamespace.append(subClasses); 646 } 647 648 // Now search to see if the current class is one of the 649 // subclasses in this namespace, and finally, if it is 650 // add it to the list 651 Array<CIMName> & subClasses = 652 subclassesForNamespace[foundIndex];
653 kumpf 1.4 for (k = 0, x = subClasses.size(); k < x; ++k)
654 a.dunfey 1.1 {
655 kumpf 1.4 if (subClasses[k] == currentClass)
656 a.dunfey 1.1 { 657 String dynamicElement = PEGASUS_DYNAMIC + 658 currentClass.getString(); 659 conformingElementsForProfile.append( 660 dynamicElement); 661 elementNamespacesForProfile.append( 662 curNamespace); 663 } 664 } 665 } 666 } 667 } 668 } 669 else 670 { 671 //Array<String> elementClasses; 672 //currentProfileInstance.getProperty(propIndex).getValue().get( 673 // elementClasses);
674 kumpf 1.4 for (Uint32 j = 0, m = elementClasses.size(); j < m; ++j)
675 a.dunfey 1.1 { 676 CIMName elementClass(elementClasses[j]); 677 Array<String> searchNamespaces = 678 findProviderNamespacesForElement( 679 moduleName, providerName, 680 elementClass, 681 repository, 682 providerCapabilitiesInstances); 683 Uint32 k = 0; 684 Uint32 x = searchNamespaces.size();
685 kumpf 1.4 for (; k < x; ++k)
686 a.dunfey 1.1 { 687 conformingElementsForProfile.append(elementClass); 688 elementNamespacesForProfile.append(searchNamespaces[k]); 689 } 690 } 691 } 692 693 Sint32 foundIndex = -1;
694 kumpf 1.4 for (Sint32 j = 0, m = profileIds.size(); j < m; ++j)
695 a.dunfey 1.1 {
696 kumpf 1.4 if (profileIds[j] == profileId)
697 a.dunfey 1.1 { 698 foundIndex = j; 699 break; 700 } 701 } 702
703 kumpf 1.4 if (foundIndex >= 0)
704 a.dunfey 1.1 { 705 // Append the results to already existing entries 706 conformingElements[foundIndex].appendArray( 707 conformingElementsForProfile); 708 elementNamespaces[foundIndex].appendArray( 709 elementNamespacesForProfile); 710 } 711 else 712 { 713 profileIds.append(profileId); 714 conformingElements.append(conformingElementsForProfile); 715 elementNamespaces.append(elementNamespacesForProfile); 716 } 717 } 718 } 719
720 a.dunfey 1.2 PEGASUS_NAMESPACE_END
721 a.dunfey 1.1 // END_OF_FILE

No CVS admin address has been configured