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