1 karl 1.39 //%2006////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.17 // 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 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.17 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.18 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.39 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 schuur 1.1 //
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 mark.hamzy 1.40 //
|
21 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 // 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 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33 #include "JMPIProviderManager.h"
34
35 #include "JMPIImpl.h"
36
37 #include <Pegasus/Common/CIMMessage.h>
38 #include <Pegasus/Common/OperationContext.h>
39 #include <Pegasus/Common/Tracer.h>
40 #include <Pegasus/Common/StatisticalData.h>
41 #include <Pegasus/Common/MessageLoader.h> //l10n
|
42 kumpf 1.10 #include <Pegasus/Common/Constants.h>
|
43 marek 1.54 #include <Pegasus/Common/FileSystem.h>
|
44 kumpf 1.56 #include <Pegasus/Common/ArrayInternal.h>
|
45 schuur 1.1
46 #include <Pegasus/Config/ConfigManager.h>
47
48 #include <Pegasus/ProviderManager2/ProviderName.h>
49 #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h>
|
50 konrad.r 1.22 #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h>
|
51 schuur 1.1
52 PEGASUS_USING_STD;
53 PEGASUS_NAMESPACE_BEGIN
54
|
55 marek 1.68 // request->localOnly is replaced with JMPI_LOCALONLY for
56 // getInstance () and enumerateInstances ()
|
57 mark.hamzy 1.30 #define JMPI_LOCALONLY false
|
58 mark.hamzy 1.36
|
59 mark.hamzy 1.32 /* Fix for 4092 */
|
60 marek 1.68 // request->includeQualifiers is replaced with JMPI_INCLUDE_QUALIFIERS
61 // for getInstance (), setInstance (), enumerateInstances (), associators ()
62 // and references ()
|
63 mark.hamzy 1.32 #define JMPI_INCLUDE_QUALIFIERS false
|
64 mark.hamzy 1.23
65 #include "Convert.h"
|
66 schuur 1.1
|
67 mark.hamzy 1.23 void JMPIProviderManager::debugPrintMethodPointers (JNIEnv *env, jclass jc)
68 {
|
69 thilo.boehm 1.69 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
70 "JMPIProviderManager::debugPrintMethodPointers");
71
|
72 mark.hamzy 1.35 static const char *methodNames[][3] = {
|
73 marek 1.68 // CIMProvider
74 {"snia 2.0",
75 "initialize",
76 "(Lorg/pegasus/jmpi/CIMOMHandle;)V"},
77 {"snia 2.0",
78 "cleanup",
79 "()V"},
|
80 mark.hamzy 1.24 // InstanceProvider
|
81 marek 1.68 {"snia 2.0",
82 "enumInstances",
83 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;"
84 "Z)Ljava/util/Vector;"},
85 {"pegasus 2.4",
86 "enumInstances",
87 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;"
88 "Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;"},
|
89 mark.hamzy 1.35 /* Begin Fix for 4189 */
|
90 marek 1.68 {"pegasus 2.5",
91 "enumerateInstances",
92 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;"
93 "ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
|
94 mark.hamzy 1.35 /* End Fix for 4189 */
|
95 marek 1.68 {"snia 2.0",
96 "enumInstances",
97 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)"
98 "Ljava/util/Vector;"},
99 {"pegasus 2.4",
100 "enumerateInstanceNames",
101 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)"
102 "[Lorg/pegasus/jmpi/CIMObjectPath;"},
103 {"pegasus 2.5",
104 "enumerateInstanceNames",
105 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)"
106 "Ljava/util/Vector;"},
107 {"snia 2.0",
108 "getInstance",
109 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)"
110 "Lorg/pegasus/jmpi/CIMInstance;"},
111 {"pegasus 2.4",
112 "getInstance",
113 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;"
114 "Lorg/pegasus/jmpi/CIMClass;)Lorg/pegasus/jmpi/CIMInstance;"},
|
115 mark.hamzy 1.35 /* Begin Fix for 4238 */
|
116 marek 1.68 {"pegasus 2.5",
117 "getInstance",
118 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;"
119 "ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;"},
|
120 mark.hamzy 1.35 /* End Fix for 4238 */
|
121 marek 1.68 {"snia 2.0",
122 "createInstance",
123 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)"
124 "Lorg/pegasus/jmpi/CIMObjectPath;"},
125 {"snia 2.0",
126 "setInstance",
127 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"},
128 {"pegasus 2.4",
129 "setInstance",
130 "(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V"},
131 {"snia 2.0",
132 "deleteInstance",
133 "(Lorg/pegasus/jmpi/CIMObjectPath;)V"},
134 {"snia 2.0",
135 "execQuery",
136 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
137 "ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},
138 {"pegasus 2.4",
139 "execQuery",
140 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
141 "Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)"
142 marek 1.68 "[Lorg/pegasus/jmpi/CIMInstance;"},
143 {"pegasus 2.5",
144 "execQuery",
145 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;"
146 "Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},
|
147 mark.hamzy 1.24 // MethodProvider
|
148 marek 1.68 {"snia 2.0",
149 "invokeMethod",
150 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
151 "Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"},
152 {"pegasus 2.4",
153 "invokeMethod",
154 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
155 "[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)"
156 "Lorg/pegasus/jmpi/CIMValue;"},
|
157 mark.hamzy 1.24 // PropertyProvider
|
158 marek 1.68 {"snia 2.0",
159 "getPropertyValue",
160 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)"
161 "Lorg/pegasus/jmpi/CIMValue;"},
162 {"snia 2.0",
163 "setPropertyValue",
164 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
165 "Lorg/pegasus/jmpi/CIMValue;)V"},
|
166 mark.hamzy 1.24 // AssociatorProvider
|
167 marek 1.68 {"snia 2.0",
168 "associators",
169 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;"
170 "Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;"
171 "ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
172 {"pegasus 2.4",
173 "associators",
174 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
175 "Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
176 {"snia 2.0",
177 "associatorNames",
178 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;"
179 "Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)"
180 "Ljava/util/Vector;"},
181 {"pegasus 2.4",
182 "associatorNames",
183 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
184 "Ljava/lang/String;)Ljava/util/Vector;"},
185 {"snia 2.0",
186 "references",
187 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;"
188 marek 1.68 "Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
189 {"pegasus 2.4",
190 "references",
191 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
192 "ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
193 {"snia 2.0",
194 "referenceNames",
195 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;"
196 "Ljava/lang/String;)Ljava/util/Vector;"},
197 {"pegasus 2.4",
198 "referenceNames",
199 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)"
200 "Ljava/util/Vector;"},
|
201 mark.hamzy 1.24 // CIMProviderRouter
202 // EventProvider
|
203 marek 1.68 {"snia 2.0",
204 "activateFilter",
205 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
206 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},
207 {"snia 2.0",
208 "deActivateFilter",
209 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
210 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},
|
211 mark.hamzy 1.24 // IndicationHandler
212 // ProviderAdapter
213 // JMPI_TestPropertyTypes
|
214 marek 1.68 {"JMPI_TestPropertyTypes",
215 "findObjectPath",
216 "(Lorg/pegasus/jmpi/CIMObjectPath;)I"},
217 {"JMPI_TestPropertyTypes",
218 "testPropertyTypesValue",
219 "(Lorg/pegasus/jmpi/CIMInstance;)V"}
|
220 mark.hamzy 1.23 };
221
222 if (!env)
223 {
|
224 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
225 "No JNI environment specified. (JNIEnv==NULL)");
226 PEG_METHOD_EXIT();
|
227 mark.hamzy 1.23 return;
228 }
229 if (!jc)
230 {
|
231 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
232 "No Java class specified. (jc==NULL)");
233 PEG_METHOD_EXIT();
|
234 mark.hamzy 1.23 return;
235 }
236
237 for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++)
238 {
|
239 mark.hamzy 1.35 jmethodID id = env->GetMethodID(jc,methodNames[i][1], methodNames[i][2]);
|
240 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
241 thilo.boehm 1.70 "Method: %s, %s, id = %p",
242 methodNames[i][0],methodNames[i][1],id));
|
243 thilo.boehm 1.69
|
244 mark.hamzy 1.23 env->ExceptionClear();
245 }
|
246 mark.hamzy 1.29
247 env->ExceptionClear();
|
248 thilo.boehm 1.69 PEG_METHOD_EXIT();
249 return;
|
250 mark.hamzy 1.29 }
251
|
252 thilo.boehm 1.69 void debugIntrospectJavaObject (JNIEnv *env, jobject jInst)
|
253 mark.hamzy 1.29 {
|
254 thilo.boehm 1.69 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
255 "JMPIProviderManager::debugIntrospectJavaObject");
256
|
257 mark.hamzy 1.29 jclass jInstClass = env->GetObjectClass(jInst);
258 jclass jInstSuperClass = env->GetSuperclass(jInstClass);
|
259 marek 1.68 jmethodID jmidGetDeclaredMethods = env->GetMethodID(
260 jInstClass,
261 "getDeclaredMethods",
262 "()[Ljava/lang/reflect/Method;");
|
263 mark.hamzy 1.29
264 if (!jmidGetDeclaredMethods)
265 {
266 env->ExceptionClear();
|
267 marek 1.68 jmidGetDeclaredMethods = env->GetMethodID(
268 jInstSuperClass,
269 "getDeclaredMethods",
270 "()[Ljava/lang/reflect/Method;");
|
271 mark.hamzy 1.29 }
272
273 if (jmidGetDeclaredMethods)
274 {
|
275 marek 1.68 jobjectArray jarrayDeclaredMethods = (jobjectArray)env->CallObjectMethod(
276 jInstClass,
277 jmidGetDeclaredMethods);
|
278 mark.hamzy 1.29
279 if (jarrayDeclaredMethods)
280 {
|
281 marek 1.68 for (int i=0,iLen=env->GetArrayLength(jarrayDeclaredMethods);
282 i < iLen;
283 i++)
|
284 mark.hamzy 1.29 {
285 JMPIjvm::checkException(env);
286
|
287 marek 1.68 jobject jDeclaredMethod = env->GetObjectArrayElement(
288 jarrayDeclaredMethods,
289 i);
290 jclass jDeclaredMethodClass = env->GetObjectClass(jDeclaredMethod);
|
291 mark.hamzy 1.29
292 JMPIjvm::checkException(env);
293
|
294 marek 1.68 jmethodID jmidToString = env->GetMethodID(
295 jDeclaredMethodClass,
296 "toString",
297 "()Ljava/lang/String;");
298 jstring jstringResult = (jstring)env->CallObjectMethod(
299 jDeclaredMethod,
300 jmidToString);
301 const char *pszResult = env->GetStringUTFChars(jstringResult, 0);
|
302 mark.hamzy 1.29
|
303 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
304 thilo.boehm 1.69 "Introspect java object: %s",pszResult));
|
305 mark.hamzy 1.29
306 env->ReleaseStringUTFChars (jstringResult, pszResult);
307 }
308 }
309 }
310
311 env->ExceptionClear();
|
312 thilo.boehm 1.69 PEG_METHOD_EXIT();
313 return;
|
314 mark.hamzy 1.29 }
315
|
316 thilo.boehm 1.69 void debugDumpJavaObject (JNIEnv *env, jobject jInst)
|
317 mark.hamzy 1.29 {
|
318 thilo.boehm 1.69 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
319 "JMPIProviderManager::debugDumpJavaObject");
|
320 marek 1.68 jclass jInstClass = env->GetObjectClass(jInst);
321 jclass jInstSuperClass = env->GetSuperclass(jInstClass);
322 jmethodID jmidToString1 = env->GetMethodID(
323 jInstClass,
324 "toString",
325 "()Ljava/lang/String;");
326 jmethodID jmidToString2 = env->GetMethodID(
327 jInstSuperClass,
328 "toString",
329 "()Ljava/lang/String;");
|
330 mark.hamzy 1.29 if (!jmidToString1 || !jmidToString2)
331 {
|
332 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
333 "No class or super class description.");
|
334 mark.hamzy 1.29 env->ExceptionClear();
|
335 thilo.boehm 1.69 PEG_METHOD_EXIT();
|
336 mark.hamzy 1.29 return;
337 }
|
338 marek 1.68 jstring jstringResult1 = (jstring)env->CallObjectMethod(
339 jInstClass,
340 jmidToString1);
341 jstring jstringResult2 = (jstring)env->CallObjectMethod(
342 jInstSuperClass,
343 jmidToString2);
344 jstring jstringResult3 = (jstring)env->CallObjectMethod(
345 jInst,
346 jmidToString1);
|
347 mark.hamzy 1.29 const char *pszResult1 = env->GetStringUTFChars(jstringResult1, 0);
348 const char *pszResult2 = env->GetStringUTFChars(jstringResult2, 0);
349 const char *pszResult3 = env->GetStringUTFChars(jstringResult3, 0);
350
|
351 marek 1.68 jmethodID jmidCInst = env->GetMethodID(
352 env->GetObjectClass(jInst),
353 JMPIjvm::jv.instanceMethodNames[22].methodName,
354 JMPIjvm::jv.instanceMethodNames[22].signature);
355
|
356 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
|
357 thilo.boehm 1.70 "Dumping class %p:\n "
358 " jInstSuperClass = %p\n"
359 " jClassShouldBe = %p\n"
360 " jmidCInst = %p\n"
|
361 thilo.boehm 1.69 " pszResult1 = %s\n"
362 " pszResult2 = %s\n"
363 " pszResult3 = %s",
364 jInstClass,jInstSuperClass,JMPIjvm::jv.classRefs[18],jmidCInst,
365 pszResult1,pszResult2,pszResult3 ));
|
366 mark.hamzy 1.29
367 env->ReleaseStringUTFChars (jstringResult1, pszResult1);
368 env->ReleaseStringUTFChars (jstringResult2, pszResult2);
369 env->ReleaseStringUTFChars (jstringResult3, pszResult3);
370
371 env->ExceptionClear();
|
372 thilo.boehm 1.69 PEG_METHOD_EXIT();
373 return;
|
374 mark.hamzy 1.23 }
|
375 schuur 1.1
|
376 marek 1.68 bool JMPIProviderManager::getInterfaceType(
377 ProviderIdContainer pidc,
378 String& interfaceType,
379 String& interfaceVersion)
|
380 mark.hamzy 1.43 {
|
381 thilo.boehm 1.69 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
382 "JMPIProviderManager::getInterfaceType");
383
|
384 mark.hamzy 1.43 CIMInstance ciProviderModule = pidc.getModule ();
385 Uint32 idx;
386 bool fRet = true;
387
388 idx = ciProviderModule.findProperty ("InterfaceType");
389
390 if (idx != PEG_NOT_FOUND)
391 {
392 CIMValue itValue;
393
394 itValue = ciProviderModule.getProperty (idx).getValue ();
395
396 itValue.get (interfaceType);
397
|
398 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
399 "interfaceType = %s",(const char*)interfaceType.getCString()));
|
400 mark.hamzy 1.43 }
401 else
402 {
|
403 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
|
404 thilo.boehm 1.69 "inferfaceType not found.");
|
405 mark.hamzy 1.43 fRet = false;
406 }
407
408 idx = ciProviderModule.findProperty ("InterfaceVersion");
409
410 if (idx != PEG_NOT_FOUND)
411 {
412 CIMValue itValue;
413
414 itValue = ciProviderModule.getProperty (idx).getValue ();
415
416 itValue.get (interfaceVersion);
417
|
418 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
419 "interfaceVersion = %s",(const char*)interfaceVersion.getCString()));
|
420 mark.hamzy 1.43 }
421 else
422 {
|
423 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
|
424 thilo.boehm 1.69 "inferfaceVersion not found.");
|
425 mark.hamzy 1.43 fRet = false;
426 }
|
427 thilo.boehm 1.69 PEG_METHOD_EXIT();
|
428 mark.hamzy 1.43 return fRet;
429 }
430
431 bool JMPIProviderManager::interfaceIsUsed (JNIEnv *env,
432 jobject jObject,
433 String searchInterfaceName)
434 {
435 jobjectArray jInterfaces = 0;
436 jsize jInterfacesLength = 0;
437 bool fFound = false;
438
439 if (!jObject)
440 {
441 return false;
442 }
443
|
444 marek 1.68 jInterfaces = (jobjectArray)env->CallObjectMethod(
445 env->GetObjectClass (jObject),
446 JMPIjvm::jv.ClassGetInterfaces);
|
447 mark.hamzy 1.43
448 if (!jInterfaces)
449 {
450 return false;
451 }
452
453 jInterfacesLength = env->GetArrayLength (jInterfaces);
454
455 for (jsize i = 0; !fFound && i < jInterfacesLength; i++)
456 {
457 jobject jInterface = env->GetObjectArrayElement (jInterfaces, i);
458
459 if (jInterface)
460 {
|
461 marek 1.68 jstring jInterfaceName = (jstring)env->CallObjectMethod(
462 jInterface,
463 JMPIjvm::jv.ClassGetName);
|
464 mark.hamzy 1.43
465 if (jInterfaceName)
466 {
|
467 marek 1.68 const char *pszInterfaceName = env->GetStringUTFChars(
468 jInterfaceName,
469 0);
|
470 mark.hamzy 1.43 String interfaceName = pszInterfaceName;
471
472 if (String::equal (interfaceName, searchInterfaceName))
473 {
474 fFound = true;
475 }
476
477 env->ReleaseStringUTFChars (jInterfaceName, pszInterfaceName);
478 }
479 }
480 }
481
482 return fFound;
483 }
484
|
485 schuur 1.1 JMPIProviderManager::IndProvTab JMPIProviderManager::provTab;
|
486 mark.hamzy 1.44 Mutex JMPIProviderManager::mutexProvTab;
|
487 schuur 1.1 JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab;
|
488 mark.hamzy 1.44 Mutex JMPIProviderManager::mutexSelxTab;
|
489 schuur 1.1 JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg;
|
490 mark.hamzy 1.44 Mutex JMPIProviderManager::mutexProvReg;
|
491 schuur 1.1
|
492 mark.hamzy 1.57 JMPIProviderManager::JMPIProviderManager()
|
493 schuur 1.1 {
|
494 carolann.graves 1.21 _subscriptionInitComplete = false;
|
495 schuur 1.1 }
496
497 JMPIProviderManager::~JMPIProviderManager(void)
498 {
499 }
500
|
501 schuur 1.12 Boolean JMPIProviderManager::insertProvider(const ProviderName & name,
|
502 schuur 1.1 const String &ns, const String &cn)
503 {
|
504 thilo.boehm 1.69 PEG_METHOD_ENTER( TRC_PROVIDERMANAGER,
505 "JMPIProviderManager::insertProvider");
506
|
507 dmitry.mikulin 1.64 String key(ns + String("::") + cn);
|
508 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
509 "insertProvider: %s",(const char*)key.getCString()));
|
510 mark.hamzy 1.23
|
511 mark.hamzy 1.44 Boolean ret = false;
512
513 {
514 AutoMutex lock (mutexProvReg);
515
516 ret = provReg.insert(key,name);
517 }
518
|
519 thilo.boehm 1.69 PEG_METHOD_EXIT();
|
520 mark.hamzy 1.44 return ret;
|
521 schuur 1.1 }
|
522 mark.hamzy 1.23
|
523 schuur 1.1 Message * JMPIProviderManager::processMessage(Message * request) throw()
524 {
|
525 marek 1.68 PEG_METHOD_ENTER(
526 TRC_PROVIDERMANAGER,
527 "JMPIProviderManager::processMessage()");
|
528 schuur 1.1
529 Message * response = 0;
|
530 mark.hamzy 1.23
|
531 schuur 1.1 // pass the request message to a handler method based on message type
532 switch(request->getType())
533 {
534 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
535 response = handleGetInstanceRequest(request);
|
536 mark.hamzy 1.25 break;
|
537 schuur 1.1
538 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
539 response = handleEnumerateInstancesRequest(request);
|
540 mark.hamzy 1.25 break;
|
541 schuur 1.1
542 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
543 response = handleEnumerateInstanceNamesRequest(request);
|
544 mark.hamzy 1.25 break;
|
545 schuur 1.1
546 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
547 response = handleCreateInstanceRequest(request);
|
548 mark.hamzy 1.25 break;
|
549 schuur 1.1
550 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
551 response = handleModifyInstanceRequest(request);
|
552 mark.hamzy 1.25 break;
|
553 schuur 1.1
554 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
555 response = handleDeleteInstanceRequest(request);
|
556 mark.hamzy 1.25 break;
|
557 schuur 1.1
|
558 mark.hamzy 1.25 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
559 response = handleExecQueryRequest(request);
|
560 schuur 1.1 break;
561
562 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
563 response = handleAssociatorsRequest(request);
|
564 mark.hamzy 1.25 break;
|
565 schuur 1.1
566 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
567 response = handleAssociatorNamesRequest(request);
|
568 mark.hamzy 1.25 break;
|
569 schuur 1.1
570 case CIM_REFERENCES_REQUEST_MESSAGE:
571 response = handleReferencesRequest(request);
|
572 mark.hamzy 1.25 break;
|
573 schuur 1.1
574 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
575 response = handleReferenceNamesRequest(request);
|
576 mark.hamzy 1.25 break;
|
577 schuur 1.1
|
578 mark.hamzy 1.26 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
579 response = handleGetPropertyRequest(request);
580 break;
581
582 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
583 response = handleSetPropertyRequest(request);
584 break;
585
|
586 schuur 1.11 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
|
587 schuur 1.1 response = handleInvokeMethodRequest(request);
|
588 mark.hamzy 1.25 break;
|
589 schuur 1.1
|
590 schuur 1.12 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
|
591 schuur 1.1 response = handleCreateSubscriptionRequest(request);
|
592 mark.hamzy 1.25 break;
|
593 schuur 1.1
|
594 mark.hamzy 1.25 /* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
|
595 schuur 1.1 response = handleModifySubscriptionRequest(request);
596 break;
|
597 schuur 1.12 */
|
598 schuur 1.1 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
599 response = handleDeleteSubscriptionRequest(request);
|
600 mark.hamzy 1.25 break;
|
601 schuur 1.1
|
602 mark.hamzy 1.26 /* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
|
603 kumpf 1.7 response = handleExportIndicationRequest(request);
|
604 schuur 1.1 break;
|
605 schuur 1.12 */
|
606 schuur 1.1 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
607 response = handleDisableModuleRequest(request);
|
608 mark.hamzy 1.25 break;
|
609 schuur 1.1
610 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
611 response = handleEnableModuleRequest(request);
|
612 mark.hamzy 1.25 break;
|
613 schuur 1.1
614 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
615 response = handleStopAllProvidersRequest(request);
|
616 mark.hamzy 1.25 break;
|
617 schuur 1.1
|
618 carolann.graves 1.21 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
619 response = handleSubscriptionInitCompleteRequest (request);
|
620 mark.hamzy 1.25 break;
|
621 carolann.graves 1.21
|
622 schuur 1.1 default:
|
623 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
624 thilo.boehm 1.69 "Unsupported Request %d",
|
625 marek 1.61 request->getType()
626 ));
|
627 mark.hamzy 1.25
|
628 schuur 1.1 response = handleUnsupportedRequest(request);
629 break;
630 }
631
632 PEG_METHOD_EXIT();
633
634 return(response);
635 }
636
|
637 kumpf 1.6 Boolean JMPIProviderManager::hasActiveProviders()
638 {
639 return providerManager.hasActiveProviders();
640 }
641
642 void JMPIProviderManager::unloadIdleProviders()
|
643 schuur 1.1 {
|
644 kumpf 1.6 providerManager.unloadIdleProviders();
|
645 schuur 1.1 }
646
647 #define STRDUPA(s,o) \
648 if (s) { \
649 o=(const char*)alloca(strlen(s)); \
650 strcpy((char*)(o),(s)); \
651 } \
652 else o=NULL;
653
654 #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)
655
656
|
657 kumpf 1.55 #define HandlerIntroBase(type,type1,message,request,response,handler) \
|
658 schuur 1.1 CIM##type##RequestMessage * request = \
|
659 marek 1.68 dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *> \
660 (message)); \
|
661 schuur 1.1 PEGASUS_ASSERT(request != 0); \
662 CIM##type##ResponseMessage * response = \
|
663 kumpf 1.55 dynamic_cast<CIM##type##ResponseMessage*>(request->buildResponse()); \
|
664 schuur 1.1 PEGASUS_ASSERT(response != 0); \
|
665 kumpf 1.42 type1##ResponseHandler handler(request, response, _responseChunkCallback);
|
666 schuur 1.1
667 #define HandlerIntroInd(type,message,request,response,handler) \
|
668 kumpf 1.55 HandlerIntroBase(type,Operation,message,request,response,handler)
|
669 schuur 1.1
|
670 kumpf 1.4 #define HandlerIntroInit(type,message,request,response,handler) \
|
671 kumpf 1.55 HandlerIntroBase(type,Operation,message,request,response,handler)
|
672 kumpf 1.4
|
673 kumpf 1.55 #define HandlerIntro(type,message,request,response,handler) \
674 HandlerIntroBase(type,type,message,request,response,handler)
|
675 schuur 1.1
676 #define HandlerCatch(handler) \
677 catch(CIMException & e) \
|
678 marek 1.71 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, \
|
679 schuur 1.1 "Exception: " + e.getMessage()); \
|
680 marek 1.68 handler.setStatus(e.getCode(), e.getContentLanguages(), \
681 e.getMessage()); \
|
682 schuur 1.1 } \
683 catch(Exception & e) \
|
684 marek 1.71 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, \
|
685 schuur 1.1 "Exception: " + e.getMessage()); \
|
686 marek 1.68 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), \
687 e.getMessage()); \
|
688 schuur 1.1 } \
689 catch(...) \
|
690 marek 1.71 { PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, \
|
691 schuur 1.1 "Exception: Unknown"); \
692 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
693 }
694
|
695 schuur 1.13 static jobjectArray getList(JvmVector *jv, JNIEnv *env, CIMPropertyList &list)
696 {
697 Uint32 s=list.size();
698 jobjectArray pl=NULL;
699 if (s) {
700 jstring initial=env->NewString(NULL,0);
|
701 mark.hamzy 1.23 pl=(jobjectArray)env->NewObjectArray(s,jv->StringClassRef,initial);
|
702 schuur 1.13 for (Uint32 i=0; i<s; i++) {
703 env->SetObjectArrayElement
704 (pl,i,env->NewStringUTF(list[i].getString().getCString()));
705 }
706 }
707 return pl;
708 }
|
709 schuur 1.1
|
710 marek 1.68 Message * JMPIProviderManager::handleGetInstanceRequest(
711 const Message * message) throw()
|
712 schuur 1.1 {
|
713 marek 1.68 PEG_METHOD_ENTER(
714 TRC_PROVIDERMANAGER,
715 "JMPIProviderManager::handleGetInstanceRequest");
|
716 schuur 1.1
|
717 kumpf 1.55 HandlerIntro(GetInstance,message,request,response,handler);
|
718 schuur 1.1
|
719 mark.hamzy 1.25 typedef enum {
720 METHOD_UNKNOWN = 0,
|
721 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
722 METHOD_INSTANCEPROVIDER,
723 METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2
|
724 mark.hamzy 1.25 } METHOD_VERSION;
725 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
726 JNIEnv *env = NULL;
|
727 schuur 1.13
|
728 marek 1.68 try
729 {
|
730 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
731 thilo.boehm 1.69 "handleGetInstanceRequest: "
732 "name space = %s class name = %s",
733 (const char*)request->nameSpace.getString().getCString(),
734 (const char*)request->
735 instanceName.getClassName().getString().getCString()
736 ));
|
737 mark.hamzy 1.23
|
738 schuur 1.1 // make target object path
|
739 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
740 System::getHostName(),
741 request->nameSpace,
742 request->instanceName.getClassName(),
743 request->instanceName.getKeyBindings());
|
744 schuur 1.1
745 // resolve provider name
|
746 kumpf 1.2 ProviderName name = _resolveProviderName(
747 request->operationContext.get(ProviderIdContainer::NAME));
|
748 schuur 1.1
749 // get cached or load new provider module
|
750 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
751 name.getPhysicalName(),
752 name.getLogicalName());
|
753 schuur 1.1 OperationContext context;
754
|
755 marek 1.68 context.insert(
756 request->operationContext.get(IdentityContainer::NAME));
757 context.insert(
758 request->operationContext.get(AcceptLanguageListContainer::NAME));
759 context.insert(
760 request->operationContext.get(ContentLanguageListContainer::NAME));
|
761 mark.hamzy 1.43
|
762 mark.hamzy 1.23 // forward request
|
763 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
764 schuur 1.1
|
765 thilo.boehm 1.69 PEG_TRACE(( TRC_PROVIDERMANAGER, Tracer::LEVEL3,
766 "handleGetInstanceRequest:Calling provider instance: %s" ,
767 (const char*)pr.getName().getCString()));
|
768 schuur 1.1
|
769 mark.hamzy 1.25 JvmVector *jv = 0;
770
771 env = JMPIjvm::attachThread(&jv);
772
|
773 mark.hamzy 1.37 if (!env)
774 {
|
775 marek 1.71 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
776 thilo.boehm 1.69 "handleGetInstanceRequest:"
777 "Could not initialize the JVM (Java Virtual Machine) "
778 "runtime environment.");
779
|
780 mark.hamzy 1.37 PEG_METHOD_EXIT();
781
|
782 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
783 CIM_ERR_FAILED,
784 MessageLoaderParms(
|
785 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
786 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
787 "runtime environment."));
|
788 mark.hamzy 1.37 }
789
|
790 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
791
|
792 mark.hamzy 1.43 jmethodID id = NULL;
793 String interfaceType;
794 String interfaceVersion;
795
|
796 marek 1.68 getInterfaceType(
797 request->operationContext.get(ProviderIdContainer::NAME),
798 interfaceType,
799 interfaceVersion);
|
800 mark.hamzy 1.43
801 if (interfaceType == "JMPI")
802 {
|
803 marek 1.68 id = env->GetMethodID(
804 (jclass)pr.jProviderClass,
805 "getInstance",
806 "(Lorg/pegasus/jmpi/CIMObjectPath;"
807 "Lorg/pegasus/jmpi/CIMClass;Z)"
808 "Lorg/pegasus/jmpi/CIMInstance;");
|
809 mark.hamzy 1.25
|
810 mark.hamzy 1.43 if (id != NULL)
811 {
812 eMethodFound = METHOD_INSTANCEPROVIDER;
|
813 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
814 thilo.boehm 1.69 "handleGetInstanceRequest: "
815 "Found METHOD_INSTANCEPROVIDER.");
|
816 mark.hamzy 1.43 }
817
818 if (id == NULL)
819 {
820 env->ExceptionClear();
|
821 mark.hamzy 1.25
|
822 marek 1.68 id = env->GetMethodID(
823 (jclass)pr.jProviderClass,
824 "getInstance",
825 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ["
826 "Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)"
827 "Lorg/pegasus/jmpi/CIMInstance;");
|
828 mark.hamzy 1.43
829 if (id != NULL)
830 {
831 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
|
832 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
833 thilo.boehm 1.69 "handleGetInstanceRequest: "
834 "Found METHOD_CIMINSTANCEPROVIDER.");
|
835 mark.hamzy 1.43 }
836 }
|
837 mark.hamzy 1.34 }
|
838 mark.hamzy 1.43 else if (interfaceType == "JMPIExperimental")
|
839 mark.hamzy 1.34 {
|
840 marek 1.68 id = env->GetMethodID(
841 (jclass)pr.jProviderClass,
842 "getInstance",
843 "(Lorg/pegasus/jmpi/OperationContext;"
844 "Lorg/pegasus/jmpi/CIMObjectPath;"
845 "Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)"
846 "Lorg/pegasus/jmpi/CIMInstance;");
|
847 mark.hamzy 1.34
|
848 mark.hamzy 1.43 if (id != NULL)
849 {
850 eMethodFound = METHOD_INSTANCEPROVIDER2;
|
851 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
852 "handleGetInstanceRequest: "
853 "Found METHOD_INSTANCEPROVIDER2.");
|
854 mark.hamzy 1.43 }
855 /* Fix for 4238 */
|
856 mark.hamzy 1.25 }
857
858 if (id == NULL)
859 {
|
860 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
861 thilo.boehm 1.69 "handleGetInstanceRequest: No method provider found!");
|
862 mark.hamzy 1.43
863 PEG_METHOD_EXIT();
|
864 mark.hamzy 1.25
|
865 kumpf 1.65 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
866 MessageLoaderParms(
867 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
868 "Could not find a method for the provider based on "
869 "InterfaceType."));
|
870 mark.hamzy 1.25 }
871
|
872 schuur 1.1 JMPIjvm::checkException(env);
|
873 mark.hamzy 1.23
|
874 mark.hamzy 1.25 switch (eMethodFound)
875 {
|
876 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER:
|
877 mark.hamzy 1.25 {
|
878 marek 1.68 jlong jopRef=DEBUG_ConvertCToJava(CIMObjectPath*,jlong,objectPath);
879 jobject jop=env->NewObject(
880 jv->CIMObjectPathClassRef,
881 jv->CIMObjectPathNewJ,
882 jopRef);
|
883 mark.hamzy 1.25
884 JMPIjvm::checkException(env);
885
|
886 mark.hamzy 1.40 CIMClass cls;
887
888 try
889 {
|
890 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
891 "handleGetInstanceRequest: "
892 "enter(METHOD_CIMINSTANCEPROVIDER): "
893 "cimom_handle->getClass(%s).",
894 (const char*)request->
895 instanceName.getClassName().getString().getCString()
896 ));
|
897 marek 1.68
|
898 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
899
|
900 marek 1.68 cls = pr._cimom_handle->getClass(
901 context,
902 request->nameSpace,
903 request->instanceName.getClassName(),
904 false,
905 true,
906 true,
907 CIMPropertyList());
908
|
909 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
910 "handleGetInstanceRequest: "
911 "exit(METHOD_CIMINSTANCEPROVIDER): "
912 "cimom_handle->getClass(%s).",
913 (const char*)request->
914 instanceName.getClassName().getString().getCString()
915 ));
916
|
917 mark.hamzy 1.40 }
918 catch (CIMException e)
919 {
|
920 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
921 thilo.boehm 1.69 "handleGetInstanceRequest: "
922 "Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) "
923 "during cimom_handle->getClass(%s): %s ",
924 (const char*)request->
925 instanceName.getClassName().getString().getCString(),
926 (const char*)e.getMessage().getCString()
927 ));
928
929 PEG_METHOD_EXIT();
|
930 mark.hamzy 1.40 throw;
931 }
932
|
933 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
934
935 JMPIjvm::checkException(env);
|
936 mark.hamzy 1.25
|
937 marek 1.68 jlong jcimClassRef = DEBUG_ConvertCToJava(
938 CIMClass*,
939 jlong,
940 pcls);
941 jobject jcimClass = env->NewObject(
942 jv->CIMClassClassRef,
943 jv->CIMClassNewJ,
944 jcimClassRef);
|
945 mark.hamzy 1.25
946 JMPIjvm::checkException(env);
|
947 mark.hamzy 1.23
|
948 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
949 schuur 1.1
|
950 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
951
|
952 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
953 id,
954 jop,
|
955 mark.hamzy 1.36 JMPI_LOCALONLY,
956 JMPI_INCLUDE_QUALIFIERS,
|
957 mark.hamzy 1.29 request->includeClassOrigin,
958 jPropertyList,
959 jcimClass);
|
960 mark.hamzy 1.23
|
961 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
962 mark.hamzy 1.23
|
963 mark.hamzy 1.25 handler.processing();
|
964 schuur 1.1
|
965 mark.hamzy 1.29 if (jciRet) {
|
966 marek 1.68 jlong jciRetRef = env->CallLongMethod(
967 jciRet,
968 JMPIjvm::jv.CIMInstanceCInst);
969 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
970 jlong,
971 CIMInstance*,
972 jciRetRef);
|
973 schuur 1.13
|
974 mark.hamzy 1.29 handler.deliver(*ciRet);
|
975 mark.hamzy 1.25 }
976 handler.complete();
977 break;
|
978 mark.hamzy 1.23 }
|
979 schuur 1.13
|
980 mark.hamzy 1.34 /* Fix for 4238 */
|
981 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
|
982 mark.hamzy 1.34 {
|
983 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
984 OperationContext*,
985 jlong,
986 &request->operationContext);
987 jobject joc = env->NewObject(
988 jv->OperationContextClassRef,
989 jv->OperationContextNewJ,
990 jocRef);
991
992 jlong jopRef = DEBUG_ConvertCToJava(
993 CIMObjectPath*,
994 jlong,
995 objectPath);
996 jobject jop = env->NewObject(
997 jv->CIMObjectPathClassRef,
998 jv->CIMObjectPathNewJ,
999 jopRef);
|
1000 mark.hamzy 1.34
1001 JMPIjvm::checkException(env);
1002
|
1003 mark.hamzy 1.40 CIMClass cls;
1004
1005 try
1006 {
|
1007 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1008 "handleGetInstanceRequest: "
1009 "enter(METHOD_INSTANCEPROVIDER2): "
1010 "cimom_handle->getClass(%s).",
1011 (const char*)request->
1012 instanceName.getClassName().getString().getCString()
1013 ));
1014
|
1015 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
1016
|
1017 marek 1.68 cls = pr._cimom_handle->getClass(
1018 context,
1019 request->nameSpace,
1020 request->instanceName.getClassName(),
1021 false,
1022 true,
1023 true,
1024 CIMPropertyList());
|
1025 thilo.boehm 1.69
1026 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1027 "handleGetInstanceRequest: "
1028 "exit(METHOD_INSTANCEPROVIDER2): "
1029 "cimom_handle->getClass(%s).",
1030 (const char*)request->
1031 instanceName.getClassName().getString().getCString()
1032 ));
|
1033 mark.hamzy 1.40 }
1034 catch (CIMException e)
1035 {
|
1036 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1037 thilo.boehm 1.69 "handleGetInstanceRequest: "
1038 "Caught CIMExcetion (METHOD_INSTANCEPROVIDER2) "
1039 "during cimom_handle->getClass(%s): %s ",
1040 (const char*)request->
1041 instanceName.getClassName().getString().getCString(),
1042 (const char*)e.getMessage().getCString()
1043 ));
1044 PEG_METHOD_EXIT();
|
1045 mark.hamzy 1.40 throw;
1046 }
1047
|
1048 mark.hamzy 1.34 CIMClass *pcls = new CIMClass (cls);
1049
1050 JMPIjvm::checkException(env);
1051
|
1052 marek 1.68 jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
1053 jobject jcimClass = env->NewObject(
1054 jv->CIMClassClassRef,
1055 jv->CIMClassNewJ,
1056 jcimClassRef);
|
1057 mark.hamzy 1.34
1058 JMPIjvm::checkException(env);
1059
1060 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
1061 kumpf 1.55
1062 StatProviderTimeMeasurement providerTime(response);
1063
|
1064 marek 1.68 jobject jciRet = env->CallObjectMethod(
1065 (jobject)pr.jProvider,
1066 id,
1067 joc,
1068 jop,
1069 jcimClass,
1070 JMPI_INCLUDE_QUALIFIERS,
1071 request->includeClassOrigin,
1072 jPropertyList);
|
1073 mark.hamzy 1.34
1074 JMPIjvm::checkException(env);
1075
|
1076 mark.hamzy 1.43 if (joc)
1077 {
|
1078 marek 1.68 env->CallVoidMethod(
1079 joc,
1080 JMPIjvm::jv.OperationContextUnassociate);
|
1081 mark.hamzy 1.43
1082 JMPIjvm::checkException(env);
1083 }
1084
|
1085 mark.hamzy 1.34 handler.processing();
1086
1087 if (jciRet) {
|
1088 marek 1.68 jlong jciRetRef = env->CallLongMethod(
1089 jciRet,
1090 JMPIjvm::jv.CIMInstanceCInst);
1091 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
1092 jlong,
1093 CIMInstance*,
1094 jciRetRef);
|
1095 mark.hamzy 1.34
1096 handler.deliver(*ciRet);
1097 }
1098 handler.complete();
1099 break;
1100 }
1101 /* Fix for 4238 */
1102
|
1103 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
1104 mark.hamzy 1.25 {
|
1105 marek 1.68 jlong jopRef = DEBUG_ConvertCToJava(
1106 CIMObjectPath*,
1107 jlong,
1108 objectPath);
1109 jobject jop = env->NewObject(
1110 jv->CIMObjectPathClassRef,
1111 jv->CIMObjectPathNewJ,jopRef);
|
1112 mark.hamzy 1.25
1113 JMPIjvm::checkException(env);
1114
|
1115 mark.hamzy 1.40 CIMClass cls;
1116
1117 try
1118 {
|
1119 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1120 "handleGetInstanceRequest: "
1121 "enter(METHOD_INSTANCEPROVIDER): "
1122 "cimom_handle->getClass(%s).",
1123 (const char*)request->
1124 instanceName.getClassName().getString().getCString()
1125 ));
1126
|
1127 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
1128
|
1129 marek 1.68 cls = pr._cimom_handle->getClass(
1130 context,
1131 request->nameSpace,
1132 request->instanceName.getClassName(),
1133 false,
1134 true,
1135 true,
1136 CIMPropertyList());
|
1137 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1138 "handleGetInstanceRequest: "
1139 "exit(METHOD_INSTANCEPROVIDER): "
1140 "cimom_handle->getClass(%s).",
1141 (const char*)request->
1142 instanceName.getClassName().getString().getCString()
1143 ));
|
1144 mark.hamzy 1.40 }
1145 catch (CIMException e)
1146 {
|
1147 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1148 thilo.boehm 1.69 "handleGetInstanceRequest: "
1149 "Caught CIMExcetion (METHOD_INSTANCEPROVIDER) "
1150 "during cimom_handle->getClass(%s): %s ",
1151 (const char*)request->
1152 instanceName.getClassName().getString().getCString(),
1153 (const char*)e.getMessage().getCString()
1154 ));
1155
1156 PEG_METHOD_EXIT();
|
1157 mark.hamzy 1.40 throw;
1158 }
1159
|
1160 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
1161 mark.hamzy 1.25
|
1162 mark.hamzy 1.27 JMPIjvm::checkException(env);
1163
|
1164 marek 1.68 jlong jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
1165 jobject jcimClass = env->NewObject(
1166 jv->CIMClassClassRef,
1167 jv->CIMClassNewJ,
1168 jcimClassRef);
|
1169 mark.hamzy 1.25
1170 JMPIjvm::checkException(env);
1171
|
1172 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
1173
|
1174 mark.hamzy 1.30 // Modified for Bugzilla# 3679
|
1175 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
1176 id,
1177 jop,
1178 jcimClass,
|
1179 mark.hamzy 1.30 JMPI_LOCALONLY);
|
1180 mark.hamzy 1.25
1181 JMPIjvm::checkException(env);
1182
1183 handler.processing();
|
1184 schuur 1.13
|
1185 mark.hamzy 1.29 if (jciRet) {
|
1186 marek 1.68 jlong jciRetRef = env->CallLongMethod(
1187 jciRet,
1188 JMPIjvm::jv.CIMInstanceCInst);
1189 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
1190 jlong,
1191 CIMInstance*,
1192 jciRetRef);
|
1193 schuur 1.13
|
1194 mark.hamzy 1.29 handler.deliver(*ciRet);
|
1195 mark.hamzy 1.25 }
1196 handler.complete();
1197 break;
1198 }
|
1199 mark.hamzy 1.23
|
1200 mark.hamzy 1.25 case METHOD_UNKNOWN:
1201 {
|
1202 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1203 thilo.boehm 1.69 "handleGetInstanceRequest: Unknown method provider!");
|
1204 mark.hamzy 1.25 break;
1205 }
|
1206 schuur 1.1 }
|
1207 schuur 1.13 }
|
1208 schuur 1.1 HandlerCatch(handler);
|
1209 schuur 1.13
|
1210 schuur 1.1 if (env) JMPIjvm::detachThread();
|
1211 schuur 1.13
|
1212 schuur 1.1 PEG_METHOD_EXIT();
1213
1214 return(response);
1215 }
1216
|
1217 marek 1.68 Message * JMPIProviderManager::handleEnumerateInstancesRequest(
1218 const Message * message) throw()
|
1219 schuur 1.1 {
|
1220 marek 1.68 PEG_METHOD_ENTER(
1221 TRC_PROVIDERMANAGER,
1222 "JMPIProviderManager::handleEnumerateInstanceRequest");
|
1223 mark.hamzy 1.23
|
1224 kumpf 1.55 HandlerIntro(EnumerateInstances,message,request,response,handler);
|
1225 schuur 1.1
|
1226 mark.hamzy 1.25 typedef enum {
1227 METHOD_UNKNOWN = 0,
|
1228 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
1229 METHOD_CIMINSTANCEPROVIDER2,
1230 METHOD_INSTANCEPROVIDER,
1231 METHOD_INSTANCEPROVIDER2,
|
1232 mark.hamzy 1.25 } METHOD_VERSION;
1233 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1234 JNIEnv *env = NULL;
|
1235 schuur 1.13
|
1236 marek 1.68 try
1237 {
|
1238 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
1239 "handleEnumerateInstanceRequest: "
1240 "name space = %s class name = %s",
1241 (const char*)request->nameSpace.getString().getCString(),
1242 (const char*)request->className.getString().getCString()
1243 ));
|
1244 mark.hamzy 1.23
|
1245 schuur 1.1 // make target object path
|
1246 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1247 request->nameSpace,
1248 request->className);
|
1249 schuur 1.1
1250 // resolve provider name
|
1251 kumpf 1.2 ProviderName name = _resolveProviderName(
1252 request->operationContext.get(ProviderIdContainer::NAME));
|
1253 schuur 1.1
1254 // get cached or load new provider module
|
1255 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
1256 name.getPhysicalName(),
1257 name.getLogicalName(),
1258 String::EMPTY);
|
1259 schuur 1.1
|
1260 schuur 1.12 // convert arguments
|
1261 schuur 1.1 OperationContext context;
1262
|
1263 marek 1.68 context.insert(
1264 request->operationContext.get(IdentityContainer::NAME));
1265 context.insert(
1266 request->operationContext.get(AcceptLanguageListContainer::NAME));
1267 context.insert(
1268 request->operationContext.get(ContentLanguageListContainer::NAME));
|
1269 schuur 1.1
1270 // forward request
|
1271 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1272 schuur 1.1
|
1273 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
1274 "handleEnumerateInstanceRequest: "
1275 "Calling provider: %s", (const char*)pr.getName().getCString()));
|
1276 schuur 1.12
|
1277 mark.hamzy 1.25 JvmVector *jv = 0;
1278
1279 env = JMPIjvm::attachThread(&jv);
1280
|
1281 mark.hamzy 1.37 if (!env)
1282 {
|
1283 marek 1.71 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1284 thilo.boehm 1.69 "handleEnumerateInstanceRequest: "
1285 "Could not initialize the JVM (Java Virtual Machine) "
1286 "runtime environment.");
1287
|
1288 mark.hamzy 1.37 PEG_METHOD_EXIT();
1289
|
1290 kumpf 1.65 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
1291 MessageLoaderParms(
1292 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
1293 "Could not initialize the JVM (Java Virtual Machine) "
1294 "runtime environment."));
|
1295 mark.hamzy 1.37 }
1296
|
1297 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
1298
|
1299 mark.hamzy 1.43 jmethodID id = NULL;
1300 String interfaceType;
1301 String interfaceVersion;
1302
|
1303 marek 1.68 getInterfaceType(
1304 request->operationContext.get (ProviderIdContainer::NAME),
1305 interfaceType,
1306 interfaceVersion);
|
1307 mark.hamzy 1.43
1308 if (interfaceType == "JMPI")
1309 {
|
1310 marek 1.68 id = env->GetMethodID(
1311 (jclass)pr.jProviderClass,
1312 "enumInstances",
1313 "(Lorg/pegasus/jmpi/CIMObjectPath;Z"
1314 "Lorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;");
|
1315 mark.hamzy 1.25
|
1316 mark.hamzy 1.43 if (id != NULL)
1317 {
1318 eMethodFound = METHOD_INSTANCEPROVIDER;
|
1319 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1320 "handleEnumerateInstances: Found METHOD_INSTANCEPROVIDER.");
|
1321 mark.hamzy 1.43 }
1322
1323 if (id == NULL)
1324 {
1325 env->ExceptionClear();
|
1326 mark.hamzy 1.25
|
1327 marek 1.68 id = env->GetMethodID(
1328 (jclass)pr.jProviderClass,
1329 "enumerateInstances",
1330 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ["
1331 "Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)["
1332 "Lorg/pegasus/jmpi/CIMInstance;");
|
1333 mark.hamzy 1.43
1334 if (id != NULL)
1335 {
1336 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
|
1337 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1338 "handleEnumerateInstances: "
1339 "Found METHOD_CIMINSTANCEPROVIDER.");
|
1340 mark.hamzy 1.43 }
1341 }
1342 }
1343 else if (interfaceType == "JMPIExperimental")
|
1344 mark.hamzy 1.25 {
|
1345 marek 1.68 id = env->GetMethodID(
1346 (jclass)pr.jProviderClass,
1347 "enumerateInstances",
1348 "(Lorg/pegasus/jmpi/OperationContext;"
1349 "Lorg/pegasus/jmpi/CIMObjectPath;"
1350 "Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)"
1351 "Ljava/util/Vector;");
|
1352 mark.hamzy 1.33
|
1353 mark.hamzy 1.43 if (id != NULL)
1354 {
1355 eMethodFound = METHOD_INSTANCEPROVIDER2;
|
1356 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1357 "handleEnumerateInstances: "
1358 "Found METHOD_INSTANCEPROVIDER2.");
|
1359 mark.hamzy 1.43 }
1360 if (id == NULL)
1361 {
1362 env->ExceptionClear();
|
1363 marek 1.68 id = env->GetMethodID(
1364 (jclass)pr.jProviderClass,
1365 "enumerateInstances",
1366 "(Lorg/pegasus/jmpi/OperationContext;"
1367 "Lorg/pegasus/jmpi/CIMObjectPath;"
1368 "Lorg/pegasus/jmpi/CIMClass;ZZ["
1369 "Ljava/lang/String;)["
1370 "Lorg/pegasus/jmpi/CIMInstance;");
|
1371 mark.hamzy 1.43
1372 if (id != NULL)
1373 {
1374 eMethodFound = METHOD_CIMINSTANCEPROVIDER2;
|
1375 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1376 "handleEnumerateInstances: "
1377 "Found METHOD_CIMINSTANCEPROVIDER2.");
|
1378 mark.hamzy 1.43 }
1379 }
|
1380 mark.hamzy 1.25 }
1381
1382 if (id == NULL)
1383 {
|
1384 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1385 thilo.boehm 1.69 "handleEnumerateInstances: No method provider found!");
|
1386 mark.hamzy 1.43
1387 PEG_METHOD_EXIT();
|
1388 schuur 1.1
|
1389 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
1390 CIM_ERR_FAILED,
1391 MessageLoaderParms(
|
1392 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
1393 marek 1.68 "Could not find a method for the provider based on "
1394 "InterfaceType."));
|
1395 mark.hamzy 1.25 }
|
1396 schuur 1.12
1397 JMPIjvm::checkException(env);
|
1398 mark.hamzy 1.23
|
1399 mark.hamzy 1.25 switch (eMethodFound)
1400 {
|
1401 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER:
|
1402 mark.hamzy 1.25 {
|
1403 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
1404 CIMObjectPath*,
1405 jlong,
1406 objectPath);
1407 jobject jcop = env->NewObject(
1408 jv->CIMObjectPathClassRef,
1409 jv->CIMObjectPathNewJ,
1410 jcopRef);
|
1411 mark.hamzy 1.23
|
1412 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
1413 schuur 1.1
|
1414 mark.hamzy 1.40 CIMClass cls;
1415
1416 try
1417 {
|
1418 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1419 "handleEnumerateInstances: "
1420 "enter(METHOD_CIMINSTANCEPROVIDER): "
1421 "cimom_handle->getClass(%s).",
1422 (const char*)request->className.getString().getCString()
1423 ));
1424
|
1425 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
1426
1427 cls = pr._cimom_handle->getClass(context,
1428 request->nameSpace,
1429 request->className,
1430 false,
1431 true,
1432 true,
1433 CIMPropertyList());
|
1434 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1435 "handleEnumerateInstances: "
1436 "exit(METHOD_CIMINSTANCEPROVIDER): "
1437 "cimom_handle->getClass(%s).",
1438 (const char*)request->className.getString().getCString()
1439 ));
1440
|
1441 mark.hamzy 1.40 }
1442 catch (CIMException e)
1443 {
|
1444 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1445 thilo.boehm 1.69 "handleEnumerateInstances: "
1446 "Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) "
1447 "during cimom_handle->getClass(%s): %s ",
1448 (const char*)request->className.getString().getCString(),
1449 (const char*)e.getMessage().getCString()
1450 ));
1451
1452 PEG_METHOD_EXIT();
|
1453 mark.hamzy 1.40 throw;
1454 }
1455
|
1456 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
1457
|
1458 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
1459 schuur 1.1
|
1460 mark.hamzy 1.59 jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
|
1461 marek 1.68 jobject jcc = env->NewObject(
1462 jv->CIMClassClassRef,
1463 jv->CIMClassNewJ,
1464 jccRef);
|
1465 schuur 1.13
|
1466 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1467 schuur 1.1
|
1468 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
1469 kumpf 1.55
1470 StatProviderTimeMeasurement providerTime(response);
1471
|
1472 marek 1.68 jobjectArray jAr = (jobjectArray)env->CallObjectMethod(
1473 (jobject)pr.jProvider,
1474 id,
1475 jcop,
1476 JMPI_LOCALONLY,
1477 JMPI_INCLUDE_QUALIFIERS,
1478 request->includeClassOrigin,
1479 jPropertyList,
1480 jcc);
|
1481 mark.hamzy 1.25
|
1482 mark.hamzy 1.23 JMPIjvm::checkException(env);
1483
1484 handler.processing();
|
1485 mark.hamzy 1.25 if (jAr) {
1486 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
1487 mark.hamzy 1.23 JMPIjvm::checkException(env);
1488
|
1489 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jAr,i);
1490
|
1491 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1492 schuur 1.13
|
1493 marek 1.68 jlong jciRetRef = env->CallLongMethod(
1494 jciRet,
1495 JMPIjvm::jv.CIMInstanceCInst);
1496 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
1497 jlong,
1498 CIMInstance*,
1499 jciRetRef);
|
1500 schuur 1.13
|
1501 mark.hamzy 1.36 /* Fix for 4237 */
|
1502 mark.hamzy 1.40 CIMClass cls;
1503
1504 try
1505 {
|
1506 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1507 "handleEnumerateInstances: "
1508 "enter: cimom_handle->getClass(%s).",
1509 (const char*)ciRet->
1510 getClassName().getString().getCString()
1511 ));
1512
|
1513 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
1514
1515 cls = pr._cimom_handle->getClass(context,
1516 request->nameSpace,
1517 ciRet->getClassName(),
1518 false,
1519 true,
1520 true,
1521 CIMPropertyList());
|
1522 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1523 "handleEnumerateInstances: "
1524 "exit: cimom_handle->getClass(%s).",
1525 (const char*)ciRet->
1526 getClassName().getString().getCString()
1527 ));
1528
|
1529 mark.hamzy 1.40 }
1530 catch (CIMException e)
1531 {
|
1532 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1533 thilo.boehm 1.69 "handleEnumerateInstances: "
1534 "Caught CIMExcetion "
1535 "during cimom_handle->getClass(%s): %s ",
1536 (const char*)ciRet->
1537 getClassName().getString().getCString(),
1538 (const char*)e.getMessage().getCString()
1539 ));
1540
1541 PEG_METHOD_EXIT();
|
1542 mark.hamzy 1.40 throw;
1543 }
1544
|
1545 mark.hamzy 1.36 const CIMObjectPath& op = ciRet->getPath();
1546 CIMObjectPath iop = ciRet->buildPath(cls);
1547
|
1548 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1549 schuur 1.13
|
1550 mark.hamzy 1.29 handler.deliver(*ciRet);
|
1551 mark.hamzy 1.23 }
1552 }
1553 handler.complete();
|
1554 mark.hamzy 1.25 break;
|
1555 schuur 1.13 }
|
1556 mark.hamzy 1.25
|
1557 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER2:
1558 {
|
1559 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
1560 OperationContext*,
1561 jlong,
1562 &request->operationContext);
1563 jobject joc = env->NewObject(
1564 jv->OperationContextClassRef,
1565 jv->OperationContextNewJ,
1566 jocRef);
1567
1568 jlong jcopRef = DEBUG_ConvertCToJava(
1569 CIMObjectPath*,
1570 jlong,
1571 objectPath);
1572 jobject jcop = env->NewObject(
1573 jv->CIMObjectPathClassRef,
1574 jv->CIMObjectPathNewJ,
1575 jcopRef);
|
1576 mark.hamzy 1.43
1577 JMPIjvm::checkException(env);
1578
1579 CIMClass cls;
1580
1581 try
1582 {
|
1583 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1584 "handleEnumerateInstances: "
1585 "enter(METHOD_CIMINSTANCEPROVIDER2): "
1586 "cimom_handle->getClass(%s).",
1587 (const char*)request->className.getString().getCString()
1588 ));
1589
|
1590 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
1591
1592 cls = pr._cimom_handle->getClass(context,
1593 request->nameSpace,
1594 request->className,
1595 false,
1596 true,
1597 true,
1598 CIMPropertyList());
|
1599 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1600 "handleEnumerateInstances: "
1601 "exit(METHOD_CIMINSTANCEPROVIDER2): "
1602 "cimom_handle->getClass(%s).",
1603 (const char*)request->className.getString().getCString()
1604 ));
|
1605 mark.hamzy 1.43 }
1606 catch (CIMException e)
1607 {
|
1608 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1609 thilo.boehm 1.69 "handleEnumerateInstances: "
1610 "Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) "
1611 "during cimom_handle->getClass(%s): %s ",
1612 (const char*)request->className.getString().getCString(),
1613 (const char*)e.getMessage().getCString()
1614 ));
1615
1616 PEG_METHOD_EXIT();
|
1617 mark.hamzy 1.43 throw;
1618 }
1619
1620 CIMClass *pcls = new CIMClass (cls);
1621
1622 JMPIjvm::checkException(env);
1623
|
1624 mark.hamzy 1.59 jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
|
1625 marek 1.68 jobject jcc = env->NewObject(
1626 jv->CIMClassClassRef,
1627 jv->CIMClassNewJ,
1628 jccRef);
|
1629 mark.hamzy 1.43
1630 JMPIjvm::checkException(env);
1631
1632 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
1633 kumpf 1.55
1634 StatProviderTimeMeasurement providerTime(response);
1635
|
1636 marek 1.68 jobjectArray jAr = (jobjectArray)env->CallObjectMethod(
1637 (jobject)pr.jProvider,
1638 id,
1639 joc,
1640 jcop,
1641 jcc,
1642 JMPI_INCLUDE_QUALIFIERS,
1643 request->includeClassOrigin,
1644 jPropertyList);
|
1645 mark.hamzy 1.43
1646 JMPIjvm::checkException(env);
1647
1648 if (joc)
1649 {
|
1650 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
1651 mark.hamzy 1.43
1652 JMPIjvm::checkException(env);
1653 }
1654
1655 handler.processing();
1656 if (jAr) {
1657 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1658 JMPIjvm::checkException(env);
1659
1660 jobject jciRet = env->GetObjectArrayElement(jAr,i);
1661
1662 JMPIjvm::checkException(env);
1663
|
1664 marek 1.68 jlong jciRetRef = env->CallLongMethod(
1665 jciRet,
1666 JMPIjvm::jv.CIMInstanceCInst);
1667 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
1668 jlong,
1669 CIMInstance*,
1670 jciRetRef);
|
1671 mark.hamzy 1.43
1672 /* Fix for 4237 */
1673 CIMClass cls;
1674
1675 try
1676 {
|
1677 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1678 "handleEnumerateInstancesRequest: "
1679 "enter: cimom_handle->getClass(%s).",
1680 (const char*)ciRet->
1681 getClassName().getString().getCString()
1682 ));
1683
|
1684 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
1685
1686 cls = pr._cimom_handle->getClass(context,
1687 request->nameSpace,
1688 ciRet->getClassName(),
1689 false,
1690 true,
1691 true,
1692 CIMPropertyList());
|
1693 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1694 "handleEnumerateInstancesRequest: "
1695 "exit: cimom_handle->getClass(%s).",
1696 (const char*)ciRet->
1697 getClassName().getString().getCString()
1698 ));
|
1699 mark.hamzy 1.43 }
1700 catch (CIMException e)
1701 {
|
1702 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1703 thilo.boehm 1.69 "handleEnumerateInstancesRequest: "
1704 "Caught CIMExcetion "
1705 "cimom_handle->getClass(%s): %s ",
1706 (const char*)ciRet->
1707 getClassName().getString().getCString(),
1708 (const char*)e.getMessage().getCString()
1709 ));
1710
1711 PEG_METHOD_EXIT();
|
1712 mark.hamzy 1.43 throw;
1713 }
1714
1715 const CIMObjectPath& op = ciRet->getPath();
1716 CIMObjectPath iop = ciRet->buildPath(cls);
1717
1718 JMPIjvm::checkException(env);
1719
1720 handler.deliver(*ciRet);
1721 }
1722 }
1723 handler.complete();
1724 break;
1725 }
1726
|
1727 mark.hamzy 1.33 /* Fix for 4189 */
|
1728 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
|
1729 mark.hamzy 1.33 {
|
1730 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
1731 OperationContext*,
1732 jlong,
1733 &request->operationContext);
1734 jobject joc = env->NewObject(
1735 jv->OperationContextClassRef,
1736 jv->OperationContextNewJ,
1737 jocRef);
1738
1739 jlong jcopRef = DEBUG_ConvertCToJava(
1740 CIMObjectPath*,
1741 jlong,
1742 objectPath);
1743 jobject jcop = env->NewObject(
1744 jv->CIMObjectPathClassRef,
1745 jv->CIMObjectPathNewJ,
1746 jcopRef);
|
1747 mark.hamzy 1.33
1748 JMPIjvm::checkException(env);
1749
|
1750 mark.hamzy 1.40 CIMClass cls;
1751
1752 try
1753 {
|
1754 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1755 "handleEnumerateInstancesRequest: "
1756 "enter(METHOD_INSTANCEPROVIDER2): "
1757 "cimom_handle->getClass(%s).",
1758 (const char*)request->className.getString().getCString()
1759 ));
1760
|
1761 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
1762
1763 cls = pr._cimom_handle->getClass (context,
1764 request->nameSpace,
1765 request->className,
1766 false,
1767 true,
1768 true,
1769 CIMPropertyList());
|
1770 thilo.boehm 1.69
1771 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1772 "handleEnumerateInstancesRequest: "
1773 "enter(METHOD_INSTANCEPROVIDER2): "
1774 "cimom_handle->getClass(%s).",
1775 (const char*)request->className.getString().getCString()
1776 ));
1777
|
1778 mark.hamzy 1.40 }
1779 catch (CIMException e)
1780 {
|
1781 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1782 thilo.boehm 1.69 "handleEnumerateInstancesRequest: "
1783 "Caught CIMExcetion(METHOD_INSTANCEPROVIDER2) "
1784 "during cimom_handle->getClass(%s): %s ",
1785 (const char*)request->className.getString().getCString(),
1786 (const char*)e.getMessage().getCString()
1787 ));
1788
1789 PEG_METHOD_EXIT();
|
1790 mark.hamzy 1.40 throw;
1791 }
1792
|
1793 mark.hamzy 1.33 CIMClass *pcls = new CIMClass (cls);
1794
1795 JMPIjvm::checkException(env);
1796
|
1797 mark.hamzy 1.59 jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
|
1798 marek 1.68 jobject jcc = env->NewObject(
1799 jv->CIMClassClassRef,
1800 jv->CIMClassNewJ,
1801 jccRef);
|
1802 mark.hamzy 1.33
1803 JMPIjvm::checkException(env);
1804
1805 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
1806 kumpf 1.55
1807 StatProviderTimeMeasurement providerTime(response);
1808
|
1809 marek 1.68 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1810 id,
1811 joc,
1812 jcop,
1813 jcc,
1814 JMPI_INCLUDE_QUALIFIERS,
1815 request->includeClassOrigin,
1816 jPropertyList);
|
1817 mark.hamzy 1.33
1818 JMPIjvm::checkException(env);
1819
|
1820 mark.hamzy 1.43 if (joc)
1821 {
|
1822 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
1823 mark.hamzy 1.43
1824 JMPIjvm::checkException(env);
1825 }
1826
|
1827 mark.hamzy 1.33 handler.processing();
1828 if (jVec) {
|
1829 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
1830 i<m;
1831 i++)
1832 {
|
1833 mark.hamzy 1.33 JMPIjvm::checkException(env);
1834
|
1835 marek 1.68 jobject jciRet = env->CallObjectMethod(
1836 jVec,
1837 JMPIjvm::jv.VectorElementAt,
1838 i);
|
1839 mark.hamzy 1.33
1840 JMPIjvm::checkException(env);
1841
|
1842 marek 1.68 jlong jciRetRef = env->CallLongMethod(
1843 jciRet,
1844 JMPIjvm::jv.CIMInstanceCInst);
1845 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
1846 jlong,
1847 CIMInstance*,
1848 jciRetRef);
|
1849 mark.hamzy 1.33
1850 /* Fix for 4237 */
|
1851 mark.hamzy 1.40 CIMClass cls;
1852
1853 try
1854 {
|
1855 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1856 "handleEnumerateInstancesRequest: "
1857 "enter: cimom_handle->getClass(%s).",
1858 (const char*)ciRet->
1859 getClassName().getString().getCString()
1860 ));
1861
|
1862 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
1863
1864 cls = pr._cimom_handle->getClass(context,
1865 request->nameSpace,
1866 ciRet->getClassName(),
1867 false,
1868 true,
1869 true,
1870 CIMPropertyList());
|
1871 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1872 "handleEnumerateInstancesRequest: "
1873 "exit: cimom_handle->getClass(%s).",
1874 (const char*)ciRet->
1875 getClassName().getString().getCString()
1876 ));
|
1877 mark.hamzy 1.40 }
1878 catch (CIMException e)
1879 {
|
1880 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1881 thilo.boehm 1.69 "handleEnumerateInstancesRequest: "
1882 "Caught CIMExcetion "
1883 "cimom_handle->getClass(%s): %s ",
1884 (const char*)ciRet->
1885 getClassName().getString().getCString(),
1886 (const char*)e.getMessage().getCString()
1887 ));
1888
1889 PEG_METHOD_EXIT();
|
1890 mark.hamzy 1.40 throw;
1891 }
1892
|
1893 mark.hamzy 1.33 const CIMObjectPath& op = ciRet->getPath();
1894 CIMObjectPath iop = ciRet->buildPath(cls);
1895
1896 JMPIjvm::checkException(env);
1897
1898 iop.setNameSpace(op.getNameSpace());
1899
1900 ciRet->setPath(iop);
1901 /* Fix for 4237*/
1902
1903 handler.deliver(*ciRet);
1904 }
1905 }
1906 handler.complete();
1907 break;
1908 }
1909 /* Fix for 4189 */
1910
|
1911 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
1912 mark.hamzy 1.25 {
|
1913 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
1914 CIMObjectPath*,
1915 jlong,
1916 objectPath);
1917 jobject jcop = env->NewObject(
1918 jv->CIMObjectPathClassRef,
1919 jv->CIMObjectPathNewJ,
1920 jcopRef);
|
1921 mark.hamzy 1.25
1922 JMPIjvm::checkException(env);
1923
|
1924 mark.hamzy 1.40 CIMClass cls;
1925
1926 try
1927 {
|
1928 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1929 "handleEnumerateInstancesRequest: "
1930 "enter(METHOD_INSTANCEPROVIDER): "
1931 "cimom_handle->getClass(%s).",
1932 (const char*)request->className.getString().getCString()
1933 ));
1934
|
1935 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
1936
1937 cls = pr._cimom_handle->getClass(context,
1938 request->nameSpace,
1939 request->className,
1940 false,
1941 true,
1942 true,
1943 CIMPropertyList());
|
1944 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1945 "handleEnumerateInstancesRequest: "
1946 "exit(METHOD_INSTANCEPROVIDER): "
1947 "cimom_handle->getClass(%s).",
1948 (const char*)request->className.getString().getCString()
1949 ));
|
1950 mark.hamzy 1.40 }
1951 catch (CIMException e)
1952 {
|
1953 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
1954 thilo.boehm 1.69 "handleEnumerateInstancesRequest: "
1955 "Caught CIMExcetion(METHOD_INSTANCEPROVIDER) "
1956 "during cimom_handle->getClass(%s): %s ",
1957 (const char*)request->className.getString().getCString(),
1958 (const char*)e.getMessage().getCString()
1959 ));
1960
1961 PEG_METHOD_EXIT();
|
1962 mark.hamzy 1.40 throw;
1963 }
1964
|
1965 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
1966
|
1967 mark.hamzy 1.25 JMPIjvm::checkException(env);
1968
|
1969 mark.hamzy 1.59 jlong jccRef = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
|
1970 marek 1.68 jobject jcc = env->NewObject(
1971 jv->CIMClassClassRef,
1972 jv->CIMClassNewJ,
1973 jccRef);
|
1974 mark.hamzy 1.25
1975 JMPIjvm::checkException(env);
1976
|
1977 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
1978
|
1979 mark.hamzy 1.30 // Modified for Bugzilla# 3679
|
1980 mark.hamzy 1.25 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1981 id,
|
1982 mark.hamzy 1.29 jcop,
|
1983 mark.hamzy 1.33 request->deepInheritance,
|
1984 mark.hamzy 1.29 jcc,
|
1985 mark.hamzy 1.30 JMPI_LOCALONLY);
|
1986 mark.hamzy 1.25
|
1987 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1988 schuur 1.12
|
1989 mark.hamzy 1.23 handler.processing();
|
1990 mark.hamzy 1.25 if (jVec) {
|
1991 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
1992 i<m;
1993 i++)
1994 {
|
1995 mark.hamzy 1.23 JMPIjvm::checkException(env);
1996
|
1997 marek 1.68 jobject jciRet = env->CallObjectMethod(
1998 jVec,
1999 JMPIjvm::jv.VectorElementAt,
2000 i);
|
2001 mark.hamzy 1.29
|
2002 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2003 schuur 1.12
|
2004 marek 1.68 jlong jciRetRef = env->CallLongMethod(
2005 jciRet,
2006 JMPIjvm::jv.CIMInstanceCInst);
2007 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
2008 jlong,
2009 CIMInstance*,
2010 jciRetRef);
|
2011 schuur 1.12
|
2012 mark.hamzy 1.33 /* Fix for 4237 */
|
2013 mark.hamzy 1.40 CIMClass cls;
2014
2015 try
2016 {
|
2017 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2018 "handleEnumerateInstancesRequest: "
2019 "enter: cimom_handle->getClass(%s).",
2020 (const char*)ciRet->
2021 getClassName().getString().getCString()
2022 ));
2023
|
2024 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
2025
2026 cls = pr._cimom_handle->getClass(context,
2027 request->nameSpace,
2028 ciRet->getClassName(),
2029 false,
2030 true,
2031 true,
2032 CIMPropertyList());
|
2033 thilo.boehm 1.69
2034 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2035 "handleEnumerateInstancesRequest: "
2036 "exit: cimom_handle->getClass(%s).",
2037 (const char*)ciRet->
2038 getClassName().getString().getCString()
2039 ));
|
2040 mark.hamzy 1.40 }
2041 catch (CIMException e)
2042 {
|
2043 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2044 thilo.boehm 1.69 "handleEnumerateInstancesRequest: "
2045 "Caught CIMExcetion "
2046 "during cimom_handle->getClass(%s): %s ",
2047 (const char*)ciRet->
2048 getClassName().getString().getCString(),
2049 (const char*)e.getMessage().getCString()
2050 ));
2051
2052 PEG_METHOD_EXIT();
|
2053 mark.hamzy 1.40 throw;
2054 }
2055
|
2056 mark.hamzy 1.33 const CIMObjectPath& op = ciRet->getPath();
2057 CIMObjectPath iop = ciRet->buildPath(cls);
2058
2059 JMPIjvm::checkException(env);
2060
2061 iop.setNameSpace(op.getNameSpace());
2062
2063 ciRet->setPath(iop);
2064 /* Fix for 4237*/
2065
|
2066 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2067 mark.hamzy 1.23 }
2068 }
2069 handler.complete();
|
2070 mark.hamzy 1.25 break;
2071 }
2072
2073 case METHOD_UNKNOWN:
2074 {
|
2075 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2076 thilo.boehm 1.69 "handleEnumerateInstancesRequest: Unknown method provider!");
|
2077 mark.hamzy 1.25 break;
2078 }
|
2079 schuur 1.1 }
2080 }
2081 HandlerCatch(handler);
|
2082 schuur 1.12
|
2083 schuur 1.11 if (env) JMPIjvm::detachThread();
|
2084 schuur 1.12
|
2085 schuur 1.1 PEG_METHOD_EXIT();
2086
2087 return(response);
2088 }
2089
|
2090 marek 1.68 Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(
2091 const Message * message) throw()
|
2092 schuur 1.1 {
|
2093 marek 1.68 PEG_METHOD_ENTER(
2094 TRC_PROVIDERMANAGER,
2095 "JMPIProviderManager::handleEnumerateInstanceNamesRequest");
|
2096 schuur 1.1
|
2097 kumpf 1.55 HandlerIntro(EnumerateInstanceNames,message,request,response, handler);
|
2098 mark.hamzy 1.23
|
2099 mark.hamzy 1.25 typedef enum {
2100 METHOD_UNKNOWN = 0,
|
2101 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
2102 METHOD_CIMINSTANCEPROVIDER2,
2103 METHOD_INSTANCEPROVIDER,
2104 METHOD_INSTANCEPROVIDER2,
|
2105 mark.hamzy 1.25 } METHOD_VERSION;
2106 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2107 JNIEnv *env = NULL;
|
2108 schuur 1.13
|
2109 schuur 1.1 try {
|
2110 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
2111 thilo.boehm 1.69 "handleEnumerateInstanceNamesRequest: "
2112 "name space = %s class name = %s",
2113 (const char*)request->nameSpace.getString().getCString(),
2114 (const char*)request->className.getString().getCString()));
|
2115 mark.hamzy 1.23
|
2116 mark.hamzy 1.25 // make target object path
|
2117 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2118 request->nameSpace,
2119 request->className);
|
2120 schuur 1.1
2121 // resolve provider name
|
2122 kumpf 1.2 ProviderName name = _resolveProviderName(
2123 request->operationContext.get(ProviderIdContainer::NAME));
|
2124 schuur 1.1
2125 // get cached or load new provider module
|
2126 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
2127 name.getPhysicalName(),
2128 name.getLogicalName());
|
2129 schuur 1.1
2130 // convert arguments
2131 OperationContext context;
2132
|
2133 marek 1.68 context.insert(
2134 request->operationContext.get(IdentityContainer::NAME));
2135 context.insert(
2136 request->operationContext.get(AcceptLanguageListContainer::NAME));
2137 context.insert(
2138 request->operationContext.get(ContentLanguageListContainer::NAME));
|
2139 schuur 1.1
|
2140 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
2141 schuur 1.1
|
2142 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
2143 "handleEnumerateInstanceNamesRequest: "
2144 "Calling provider: %s",(const char*)pr.getName().getCString()));
|
2145 schuur 1.1
|
2146 mark.hamzy 1.25 JvmVector *jv = 0;
|
2147 schuur 1.12
|
2148 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
2149 schuur 1.1
|
2150 mark.hamzy 1.37 if (!env)
2151 {
|
2152 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
2153 "handleEnumerateInstanceNamesRequest: "
2154 "Could not initialize the JVM (Java Virtual Machine) "
2155 "runtime environment.");
2156
|
2157 mark.hamzy 1.37 PEG_METHOD_EXIT();
2158
|
2159 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
2160 CIM_ERR_FAILED,
2161 MessageLoaderParms(
|
2162 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
2163 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
2164 "runtime environment."));
|
2165 mark.hamzy 1.37 }
2166
|
2167 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
2168 schuur 1.12
|
2169 mark.hamzy 1.43 jmethodID id = NULL;
2170 String interfaceType;
2171 String interfaceVersion;
2172
|
2173 marek 1.68 getInterfaceType(
2174 request->operationContext.get(ProviderIdContainer::NAME),
2175 interfaceType,
2176 interfaceVersion);
|
2177 mark.hamzy 1.43
2178 if (interfaceType == "JMPI")
2179 {
|
2180 marek 1.68 id = env->GetMethodID(
2181 (jclass)pr.jProviderClass,
2182 "enumInstances",
2183 "(Lorg/pegasus/jmpi/CIMObjectPath;"
2184 "ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
|
2185 mark.hamzy 1.43
2186 if (id != NULL)
2187 {
2188 eMethodFound = METHOD_INSTANCEPROVIDER;
|
2189 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2190 "handleEnumerateInstanceNamesRequest: "
2191 "Found METHOD_INSTANCEPROVIDER.");
|
2192 mark.hamzy 1.43 }
|
2193 mark.hamzy 1.23
|
2194 mark.hamzy 1.43 if (id == NULL)
2195 {
2196 env->ExceptionClear();
|
2197 schuur 1.1
|
2198 marek 1.68 id = env->GetMethodID(
2199 (jclass)pr.jProviderClass,
2200 "enumerateInstanceNames",
2201 "(Lorg/pegasus/jmpi/CIMObjectPath;"
2202 "Lorg/pegasus/jmpi/CIMClass;)["
2203 "Lorg/pegasus/jmpi/CIMObjectPath;");
|
2204 mark.hamzy 1.43
2205 if (id != NULL)
2206 {
2207 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
|
2208 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2209 "handleEnumerateInstanceNamesRequest: "
2210 "Found METHOD_CIMINSTANCEPROVIDER.");
|
2211 mark.hamzy 1.43 }
2212 }
2213 }
2214 else if (interfaceType == "JMPIExperimental")
|
2215 mark.hamzy 1.25 {
|
2216 marek 1.68 id = env->GetMethodID(
2217 (jclass)pr.jProviderClass,
2218 "enumerateInstanceNames",
2219 "(Lorg/pegasus/jmpi/OperationContext;"
2220 "Lorg/pegasus/jmpi/CIMObjectPath;"
2221 "Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
|
2222 schuur 1.1
|
2223 mark.hamzy 1.43 if (id != NULL)
2224 {
2225 eMethodFound = METHOD_INSTANCEPROVIDER2;
|
2226 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2227 "handleEnumerateInstanceNamesRequest: "
2228 "Found METHOD_INSTANCEPROVIDER2.");
|
2229 mark.hamzy 1.43 }
|
2230 schuur 1.1
|
2231 mark.hamzy 1.43 if (id == NULL)
2232 {
2233 env->ExceptionClear();
|
2234 schuur 1.13
|
2235 marek 1.68 id = env->GetMethodID(
2236 (jclass)pr.jProviderClass,
2237 "enumerateInstanceNames",
2238 "(Lorg/pegasus/jmpi/OperationContext;"
2239 "Lorg/pegasus/jmpi/CIMObjectPath;"
2240 "Lorg/pegasus/jmpi/CIMClass;)"
2241 "[Lorg/pegasus/jmpi/CIMObjectPath;");
|
2242 mark.hamzy 1.43
2243 if (id != NULL)
2244 {
2245 eMethodFound = METHOD_CIMINSTANCEPROVIDER2;
|
2246 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2247 "handleEnumerateInstanceNamesRequest: "
2248 "Found METHOD_CIMINSTANCEPROVIDER2.");
|
2249 mark.hamzy 1.43 }
2250 }
|
2251 mark.hamzy 1.23 }
|
2252 mark.hamzy 1.25
|
2253 mark.hamzy 1.36 if (id == NULL)
2254 {
|
2255 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2256 thilo.boehm 1.69 "handleEnumerateInstanceNamesRequest: "
2257 "No method provider found!");
|
2258 mark.hamzy 1.36
|
2259 mark.hamzy 1.43 PEG_METHOD_EXIT();
|
2260 mark.hamzy 1.36
|
2261 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
2262 CIM_ERR_FAILED,
2263 MessageLoaderParms(
|
2264 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
2265 marek 1.68 "Could not find a method for the provider based on "
2266 "InterfaceType."));
|
2267 mark.hamzy 1.36 }
2268
|
2269 schuur 1.1 JMPIjvm::checkException(env);
2270
|
2271 mark.hamzy 1.25 switch (eMethodFound)
2272 {
|
2273 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER:
|
2274 mark.hamzy 1.25 {
|
2275 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
2276 CIMObjectPath*,
2277 jlong,
2278 objectPath);
2279 jobject jcop = env->NewObject(
2280 jv->CIMObjectPathClassRef,
2281 jv->CIMObjectPathNewJ,
2282 jcopRef);
|
2283 mark.hamzy 1.25
2284 JMPIjvm::checkException(env);
2285
|
2286 mark.hamzy 1.40 CIMClass cls;
2287
2288 try
2289 {
|
2290 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2291 "handleEnumerateInstanceNamesRequest: "
2292 "enter(METHOD_CIMINSTANCEPROVIDER): "
2293 "cimom_handle->getClass(%s).",
2294 (const char*)request->className.getString().getCString()
2295 ));
2296
|
2297 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
2298
2299 cls = pr._cimom_handle->getClass(context,
2300 request->nameSpace,
2301 request->className,
2302 false,
2303 true,
2304 true,
2305 CIMPropertyList());
|
2306 thilo.boehm 1.69
2307 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2308 "handleEnumerateInstanceNamesRequest: "
2309 "exit(METHOD_CIMINSTANCEPROVIDER): "
2310 "cimom_handle->getClass(%s).",
2311 (const char*)request->className.getString().getCString()
2312 ));
2313
|
2314 mark.hamzy 1.40 }
2315 catch (CIMException e)
2316 {
|
2317 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2318 thilo.boehm 1.69 "handleEnumerateInstanceNamesRequest: "
2319 "Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) "
2320 "during cimom_handle->getClass(%s): %s ",
2321 (const char*)request->className.getString().getCString(),
2322 (const char*)e.getMessage().getCString()
2323 ));
2324
2325 PEG_METHOD_EXIT();
|
2326 mark.hamzy 1.40 throw;
2327 }
2328
|
2329 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
2330 mark.hamzy 1.25
2331 JMPIjvm::checkException(env);
2332
|
2333 marek 1.68 jlong jcimClassRef = DEBUG_ConvertCToJava(
2334 CIMClass*,
2335 jlong,
2336 pcls);
2337 jobject jcimClass = env->NewObject(
2338 jv->CIMClassClassRef,
2339 jv->CIMClassNewJ,
2340 jcimClassRef);
|
2341 mark.hamzy 1.25
2342 JMPIjvm::checkException(env);
2343
|
2344 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
2345
|
2346 marek 1.68 jobjectArray jAr = (jobjectArray)env->CallObjectMethod(
2347 (jobject)pr.jProvider,
2348 id,
2349 jcop,
2350 jcimClass);
|
2351 mark.hamzy 1.25
|
2352 mark.hamzy 1.23 JMPIjvm::checkException(env);
2353
2354 handler.processing();
|
2355 mark.hamzy 1.25 if (jAr) {
2356 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
2357 mark.hamzy 1.23 JMPIjvm::checkException(env);
2358
|
2359 mark.hamzy 1.29 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
2360
|
2361 mark.hamzy 1.23 JMPIjvm::checkException(env);
2362
|
2363 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
2364 jcopRet,
2365 JMPIjvm::jv.CIMObjectPathCInst);
2366 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
2367 jlong,
2368 CIMObjectPath*,
2369 jcopRetRef);
|
2370 schuur 1.13
|
2371 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2372 schuur 1.13
|
2373 mark.hamzy 1.29 handler.deliver(*copRet);
|
2374 mark.hamzy 1.23 }
2375 }
2376 handler.complete();
|
2377 mark.hamzy 1.25 break;
|
2378 schuur 1.13 }
|
2379 mark.hamzy 1.25
|
2380 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER2:
|
2381 mark.hamzy 1.36 {
|
2382 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
2383 OperationContext*,
2384 jlong,
2385 &request->operationContext);
2386 jobject joc = env->NewObject(
2387 jv->OperationContextClassRef,
2388 jv->OperationContextNewJ,
2389 jocRef);
2390
2391 jlong jcopRef = DEBUG_ConvertCToJava(
2392 CIMObjectPath*,
2393 jlong,
2394 objectPath);
2395 jobject jcop = env->NewObject(
2396 jv->CIMObjectPathClassRef,
2397 jv->CIMObjectPathNewJ,
2398 jcopRef);
|
2399 mark.hamzy 1.36
2400 JMPIjvm::checkException(env);
2401
|
2402 mark.hamzy 1.40 CIMClass cls;
2403
2404 try
2405 {
|
2406 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2407 "handleEnumerateInstanceNamesRequest: "
2408 "enter(METHOD_CIMINSTANCEPROVIDER2): "
2409 "cimom_handle->getClass(%s).",
2410 (const char*)request->className.getString().getCString()
2411 ));
2412
|
2413 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
2414
2415 cls = pr._cimom_handle->getClass(context,
2416 request->nameSpace,
2417 request->className,
2418 false,
2419 true,
2420 true,
2421 CIMPropertyList());
|
2422 thilo.boehm 1.69
2423 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2424 "handleEnumerateInstanceNamesRequest: "
2425 "exit(METHOD_CIMINSTANCEPROVIDER2): "
2426 "cimom_handle->getClass(%s).",
2427 (const char*)request->className.getString().getCString()
2428 ));
2429
|
2430 mark.hamzy 1.40 }
2431 catch (CIMException e)
2432 {
|
2433 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2434 thilo.boehm 1.69 "handleEnumerateInstanceNamesRequest: "
2435 "Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER2) "
2436 "during cimom_handle->getClass(%s): %s ",
2437 (const char*)request->className.getString().getCString(),
2438 (const char*)e.getMessage().getCString()
2439 ));
2440
2441 PEG_METHOD_EXIT();
|
2442 mark.hamzy 1.40 throw;
2443 }
2444
|
2445 mark.hamzy 1.36 CIMClass *pcls = new CIMClass (cls);
2446
2447 JMPIjvm::checkException(env);
2448
|
2449 marek 1.68 jlong jcimClassRef = DEBUG_ConvertCToJava(CIMClass*, jlong, pcls);
2450 jobject jcimClass = env->NewObject(
2451 jv->CIMClassClassRef,
2452 jv->CIMClassNewJ,
2453 jcimClassRef);
|
2454 mark.hamzy 1.36
2455 JMPIjvm::checkException(env);
2456
|
2457 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
2458
|
2459 marek 1.68 jobjectArray jAr = (jobjectArray)env->CallObjectMethod(
2460 (jobject)pr.jProvider,
2461 id,
2462 joc,
2463 jcop,
2464 jcimClass);
|
2465 mark.hamzy 1.36
2466 JMPIjvm::checkException(env);
2467
|
2468 mark.hamzy 1.43 if (joc)
2469 {
|
2470 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
2471 mark.hamzy 1.43
2472 JMPIjvm::checkException(env);
2473 }
2474
|
2475 mark.hamzy 1.36 handler.processing();
|
2476 mark.hamzy 1.43 if (jAr) {
2477 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
2478 mark.hamzy 1.36 JMPIjvm::checkException(env);
2479
|
2480 mark.hamzy 1.43 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
2481 mark.hamzy 1.36
2482 JMPIjvm::checkException(env);
2483
|
2484 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
2485 jcopRet,
2486 JMPIjvm::jv.CIMObjectPathCInst);
2487 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
2488 jlong,
2489 CIMObjectPath*,
2490 jcopRetRef);
|
2491 mark.hamzy 1.36
2492 JMPIjvm::checkException(env);
2493
2494 handler.deliver(*copRet);
2495 }
2496 }
2497 handler.complete();
2498 break;
2499 }
2500
|
2501 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
|
2502 mark.hamzy 1.25 {
|
2503 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
2504 OperationContext*,
2505 jlong,
2506 &request->operationContext);
2507 jobject joc = env->NewObject(
2508 jv->OperationContextClassRef,
2509 jv->OperationContextNewJ,
2510 jocRef);
2511
2512 jlong jcopRef = DEBUG_ConvertCToJava(
2513 CIMObjectPath*,
2514 jlong,
2515 objectPath);
2516 jobject jcop = env->NewObject(
2517 jv->CIMObjectPathClassRef,
2518 jv->CIMObjectPathNewJ,
2519 jcopRef);
|
2520 mark.hamzy 1.25
2521 JMPIjvm::checkException(env);
2522
|
2523 mark.hamzy 1.40 CIMClass cls;
2524
2525 try
2526 {
|
2527 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2528 "handleEnumerateInstanceNamesRequest: "
2529 "enter(METHOD_INSTANCEPROVIDER2): "
2530 "cimom_handle->getClass(%s).",
2531 (const char*)request->className.getString().getCString()
2532 ));
2533
|
2534 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
2535
2536 cls = pr._cimom_handle->getClass(context,
2537 request->nameSpace,
2538 request->className,
2539 false,
2540 true,
2541 true,
2542 CIMPropertyList());
|
2543 thilo.boehm 1.69
2544 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2545 "handleEnumerateInstanceNamesRequest: "
2546 "exit(METHOD_INSTANCEPROVIDER2): "
2547 "cimom_handle->getClass(%s).",
2548 (const char*)request->className.getString().getCString()
2549 ));
2550
|
2551 mark.hamzy 1.40 }
2552 catch (CIMException e)
2553 {
|
2554 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2555 thilo.boehm 1.69 "handleEnumerateInstanceNamesRequest: "
2556 "Caught CIMExcetion(METHOD_INSTANCEPROVIDER2) "
2557 "during cimom_handle->getClass(%s): %s ",
2558 (const char*)request->className.getString().getCString(),
2559 (const char*)e.getMessage().getCString()
2560 ));
2561
2562 PEG_METHOD_EXIT();
|
2563 mark.hamzy 1.40 throw;
2564 }
2565
|
2566 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
2567 mark.hamzy 1.25
2568 JMPIjvm::checkException(env);
2569
|
2570 marek 1.68 jlong jcimClassRef = DEBUG_ConvertCToJava(
2571 CIMClass*,
2572 jlong,
2573 pcls);
2574 jobject jcimClass = env->NewObject(
2575 jv->CIMClassClassRef,
2576 jv->CIMClassNewJ,
2577 jcimClassRef);
|
2578 mark.hamzy 1.25
2579 JMPIjvm::checkException(env);
2580
|
2581 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
2582
|
2583 mark.hamzy 1.25 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
2584 id,
|
2585 mark.hamzy 1.43 joc,
|
2586 mark.hamzy 1.29 jcop,
2587 jcimClass);
|
2588 mark.hamzy 1.25
|
2589 mark.hamzy 1.23 JMPIjvm::checkException(env);
2590
|
2591 mark.hamzy 1.43 if (joc)
2592 {
|
2593 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
2594 mark.hamzy 1.43
2595 JMPIjvm::checkException(env);
2596 }
2597
|
2598 mark.hamzy 1.23 handler.processing();
|
2599 mark.hamzy 1.25 if (jVec) {
|
2600 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
2601 i<m;
2602 i++)
2603 {
|
2604 mark.hamzy 1.23 JMPIjvm::checkException(env);
2605
|
2606 marek 1.68 jobject jcopRet = env->CallObjectMethod(
2607 jVec,
2608 JMPIjvm::jv.VectorElementAt,
2609 i);
|
2610 mark.hamzy 1.29
|
2611 mark.hamzy 1.23 JMPIjvm::checkException(env);
2612
|
2613 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
2614 jcopRet,
2615 JMPIjvm::jv.CIMObjectPathCInst);
2616 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
2617 jlong,
2618 CIMObjectPath*,
2619 jcopRetRef);
|
2620 schuur 1.13
|
2621 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2622 schuur 1.13
|
2623 mark.hamzy 1.29 handler.deliver(*copRet);
|
2624 mark.hamzy 1.23 }
2625 }
2626 handler.complete();
|
2627 mark.hamzy 1.25 break;
2628 }
2629
|
2630 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
2631 mark.hamzy 1.25 {
|
2632 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
2633 CIMObjectPath*,
2634 jlong,
2635 objectPath);
2636 jobject jcop = env->NewObject(
2637 jv->CIMObjectPathClassRef,
2638 jv->CIMObjectPathNewJ,
2639 jcopRef);
|
2640 mark.hamzy 1.23
|
2641 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
2642 schuur 1.1
|
2643 mark.hamzy 1.43 CIMClass cls;
|
2644 schuur 1.1
|
2645 mark.hamzy 1.43 try
2646 {
|
2647 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2648 "handleEnumerateInstanceNamesRequest: "
2649 "exit(METHOD_INSTANCEPROVIDER): "
2650 "cimom_handle->getClass(%s).",
2651 (const char*)request->className.getString().getCString()
2652 ));
2653
|
2654 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
2655
2656 cls = pr._cimom_handle->getClass(context,
2657 request->nameSpace,
2658 request->className,
2659 false,
2660 true,
2661 true,
2662 CIMPropertyList());
|
2663 thilo.boehm 1.69
2664 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2665 "handleEnumerateInstanceNamesRequest: "
2666 "exit(METHOD_INSTANCEPROVIDER): "
2667 "cimom_handle->getClass(%s).",
2668 (const char*)request->className.getString().getCString()
2669 ));
|
2670 mark.hamzy 1.43 }
2671 catch (CIMException e)
2672 {
|
2673 marek 1.71 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2674 thilo.boehm 1.69 "handleEnumerateInstanceNamesRequest: "
2675 "Caught CIMExcetion(METHOD_INSTANCEPROVIDER) "
2676 "during cimom_handle->getClass(%s): %s ",
2677 (const char*)request->className.getString().getCString(),
2678 (const char*)e.getMessage().getCString()
2679 ));
2680
2681 PEG_METHOD_EXIT();
|
2682 mark.hamzy 1.43 throw;
2683 }
2684
2685 CIMClass *pcls = new CIMClass (cls);
2686
2687 JMPIjvm::checkException(env);
2688
|
2689 marek 1.68 jlong jcimClassRef = DEBUG_ConvertCToJava(
2690 CIMClass*,
2691 jlong,
2692 pcls);
2693 jobject jcimClass = env->NewObject(
2694 jv->CIMClassClassRef,
2695 jv->CIMClassNewJ,
2696 jcimClassRef);
|
2697 mark.hamzy 1.43
2698 JMPIjvm::checkException(env);
2699
|
2700 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
2701
|
2702 mark.hamzy 1.43 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
2703 id,
2704 jcop,
2705 true,
2706 jcimClass);
2707
2708 JMPIjvm::checkException(env);
2709
2710 handler.processing();
2711 if (jVec) {
|
2712 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
2713 i<m;
2714 i++)
2715 {
|
2716 mark.hamzy 1.43 JMPIjvm::checkException(env);
2717
|
2718 marek 1.68 jobject jcopRet = env->CallObjectMethod(
2719 jVec,
2720 JMPIjvm::jv.VectorElementAt,
2721 i);
|
2722 mark.hamzy 1.43
2723 JMPIjvm::checkException(env);
2724
|
2725 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
2726 jcopRet,
2727 JMPIjvm::jv.CIMObjectPathCInst);
2728 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
2729 jlong,
2730 CIMObjectPath*,
2731 jcopRetRef);
|
2732 mark.hamzy 1.43
2733 JMPIjvm::checkException(env);
2734
2735 handler.deliver(*copRet);
2736 }
2737 }
2738 handler.complete();
2739 break;
2740 }
2741
2742 case METHOD_UNKNOWN:
2743 {
|
2744 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2745 thilo.boehm 1.69 "handleEnumerateInstanceNamesRequest: "
2746 "Unknown method provider!");
|
2747 mark.hamzy 1.43 break;
2748 }
2749 }
2750 }
2751 HandlerCatch(handler);
2752
2753 if (env) JMPIjvm::detachThread();
2754
2755 PEG_METHOD_EXIT();
2756
|
2757 schuur 1.1 return(response);
2758 }
2759
|
2760 marek 1.68 Message * JMPIProviderManager::handleCreateInstanceRequest(
2761 const Message * message) throw()
|
2762 schuur 1.1 {
|
2763 marek 1.68 PEG_METHOD_ENTER(
2764 TRC_PROVIDERMANAGER,
2765 "JMPIProviderManager::handleCreateInstanceRequest");
|
2766 mark.hamzy 1.23
|
2767 kumpf 1.55 HandlerIntro(CreateInstance,message,request,response,handler);
|
2768 schuur 1.1
|
2769 mark.hamzy 1.25 typedef enum {
2770 METHOD_UNKNOWN = 0,
|
2771 mark.hamzy 1.43 METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER
2772 METHOD_INSTANCEPROVIDER2 // same as METHOD_CIMINSTANCEPROVIDER2
|
2773 mark.hamzy 1.25 } METHOD_VERSION;
2774 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2775 JNIEnv *env = NULL;
2776
|
2777 schuur 1.1 try {
|
2778 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
2779 "handleCreateInstanceRequest: "
2780 "name space = %s class name = %s",
2781 (const char*)request->nameSpace.getString().getCString(),
2782 (const char*)request->
2783 newInstance.getPath().getClassName().getString().getCString()
2784 ));
|
2785 mark.hamzy 1.23
|
2786 schuur 1.1 // make target object path
|
2787 marek 1.68 CIMObjectPath *objectPath =
2788 new CIMObjectPath(
2789 System::getHostName(),
2790 request->nameSpace,
2791 request->newInstance.getPath().getClassName(),
2792 request->newInstance.getPath().getKeyBindings());
|
2793 schuur 1.1
2794 // resolve provider name
|
2795 kumpf 1.2 ProviderName name = _resolveProviderName(
2796 request->operationContext.get(ProviderIdContainer::NAME));
|
2797 schuur 1.1
2798 // get cached or load new provider module
|
2799 marek 1.68 JMPIProvider::OpProviderHolder ph =
2800 providerManager.getProvider(
2801 name.getPhysicalName(),
2802 name.getLogicalName(),
2803 String::EMPTY);
|
2804 schuur 1.1
2805 // forward request
|
2806 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
2807 schuur 1.1
|
2808 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
2809 "handleCreateInstanceRequest: "
2810 "Calling provider: %s", (const char*)pr.getName().getCString()));
|
2811 schuur 1.12
|
2812 mark.hamzy 1.25 JvmVector *jv = 0;
2813
2814 env = JMPIjvm::attachThread(&jv);
2815
|
2816 mark.hamzy 1.37 if (!env)
2817 {
|
2818 marek 1.71 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2819 thilo.boehm 1.69 "handleCreateInstanceRequest: "
2820 "Could not initialize the JVM (Java Virtual Machine) "
2821 "runtime environment.");
2822
|
2823 mark.hamzy 1.37 PEG_METHOD_EXIT();
2824
|
2825 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
2826 CIM_ERR_FAILED,
2827 MessageLoaderParms(
|
2828 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
2829 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
2830 "runtime environment."));
|
2831 mark.hamzy 1.37 }
2832
|
2833 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
2834
|
2835 mark.hamzy 1.43 jmethodID id = NULL;
2836 String interfaceType;
2837 String interfaceVersion;
2838
|
2839 marek 1.68 getInterfaceType(
2840 request->operationContext.get(
2841 ProviderIdContainer::NAME),
2842 interfaceType,
2843 interfaceVersion);
|
2844 mark.hamzy 1.43
2845 if (interfaceType == "JMPI")
2846 {
|
2847 marek 1.68 id = env->GetMethodID(
2848 (jclass)pr.jProviderClass,
2849 "createInstance",
2850 "(Lorg/pegasus/jmpi/CIMObjectPath;"
2851 "Lorg/pegasus/jmpi/CIMInstance;)"
2852 "Lorg/pegasus/jmpi/CIMObjectPath;");
|
2853 mark.hamzy 1.43
2854 if (id != NULL)
2855 {
2856 eMethodFound = METHOD_INSTANCEPROVIDER;
|
2857 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2858 "handleCreateInstanceRequest: "
2859 "Found METHOD_INSTANCEPROVIDER.");
|
2860 mark.hamzy 1.43 }
2861 }
2862 else if (interfaceType == "JMPIExperimental")
2863 {
|
2864 marek 1.68 id = env->GetMethodID(
2865 (jclass)pr.jProviderClass,
2866 "createInstance",
2867 "(Lorg/pegasus/jmpi/OperationContext;"
2868 "Lorg/pegasus/jmpi/CIMObjectPath;"
2869 "Lorg/pegasus/jmpi/CIMInstance;)"
2870 "Lorg/pegasus/jmpi/CIMObjectPath;");
|
2871 mark.hamzy 1.25
|
2872 mark.hamzy 1.43 if (id != NULL)
2873 {
2874 eMethodFound = METHOD_INSTANCEPROVIDER2;
|
2875 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2876 "handleCreateInstanceRequest: "
2877 "Found METHOD_INSTANCEPROVIDER2.");
|
2878 mark.hamzy 1.43 }
2879 }
|
2880 schuur 1.1
|
2881 mark.hamzy 1.43 if (id == NULL)
|
2882 mark.hamzy 1.25 {
|
2883 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
2884 thilo.boehm 1.69 "handleCreateInstanceRequest: No method provider found!");
|
2885 mark.hamzy 1.43
2886 PEG_METHOD_EXIT();
2887
|
2888 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
2889 CIM_ERR_FAILED,
2890 MessageLoaderParms(
|
2891 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
2892 marek 1.68 "Could not find a method for the provider based on "
2893 "InterfaceType."));
|
2894 mark.hamzy 1.25 }
|
2895 mark.hamzy 1.23
2896 JMPIjvm::checkException(env);
2897
|
2898 mark.hamzy 1.25 switch (eMethodFound)
2899 {
|
2900 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
2901 {
|
2902 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
2903 CIMObjectPath*,
2904 jlong,
2905 objectPath);
2906 jobject jcop = env->NewObject(
2907 jv->CIMObjectPathClassRef,
2908 jv->CIMObjectPathNewJ,
2909 jcopRef);
|
2910 mark.hamzy 1.43
2911 JMPIjvm::checkException(env);
2912
2913 CIMInstance *ci = new CIMInstance (request->newInstance);
|
2914 marek 1.68 jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
2915 jobject jci = env->NewObject(
2916 jv->CIMInstanceClassRef,
2917 jv->CIMInstanceNewJ,
2918 jciRef);
|
2919 mark.hamzy 1.43
2920 JMPIjvm::checkException(env);
2921
|
2922 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2923 "handleCreateInstanceRequest: "
|
2924 thilo.boehm 1.70 "id = %p, jcop = %p, jci = %p",
2925 id,jcop,jci));
|
2926 mark.hamzy 1.43
|
2927 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
2928
|
2929 mark.hamzy 1.43 jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,
2930 id,
2931 jcop,
2932 jci);
2933
2934 JMPIjvm::checkException(env);
2935
2936 handler.processing();
2937
2938 if (jcopRet) {
|
2939 marek 1.68 jlong jCopRetRef = env->CallLongMethod(
2940 jcopRet,
2941 JMPIjvm::jv.CIMObjectPathCInst);
2942 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
2943 jlong,
2944 CIMObjectPath*,
2945 jCopRetRef);
|
2946 mark.hamzy 1.43
2947 handler.deliver(*copRet);
2948 }
2949 handler.complete();
2950 break;
2951 }
2952
2953 case METHOD_INSTANCEPROVIDER2:
|
2954 mark.hamzy 1.25 {
|
2955 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
2956 OperationContext*,
2957 jlong,
2958 &request->operationContext);
2959 jobject joc = env->NewObject(
2960 jv->OperationContextClassRef,
2961 jv->OperationContextNewJ,
2962 jocRef);
2963
2964 jlong jcopRef = DEBUG_ConvertCToJava(
2965 CIMObjectPath*,
2966 jlong,
2967 objectPath);
2968 jobject jcop = env->NewObject(
2969 jv->CIMObjectPathClassRef,
2970 jv->CIMObjectPathNewJ,
2971 jcopRef);
|
2972 mark.hamzy 1.25
2973 JMPIjvm::checkException(env);
2974
|
2975 marek 1.68 CIMInstance *ci = new CIMInstance (request->newInstance);
2976 jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
2977 jobject jci = env->NewObject(
2978 jv->CIMInstanceClassRef,
2979 jv->CIMInstanceNewJ,
2980 jciRef);
|
2981 mark.hamzy 1.25
2982 JMPIjvm::checkException(env);
|
2983 schuur 1.1
|
2984 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2985 "handleCreateInstanceRequest: "
|
2986 thilo.boehm 1.70 "id = %p, jcop = %p, jci = %p",
2987 id,jcop,jci));
|
2988 schuur 1.1
|
2989 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
2990
|
2991 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,
2992 id,
|
2993 mark.hamzy 1.43 joc,
|
2994 mark.hamzy 1.29 jcop,
2995 jci);
|
2996 schuur 1.1
|
2997 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
2998 schuur 1.1
|
2999 mark.hamzy 1.43 if (joc)
3000 {
|
3001 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
3002 mark.hamzy 1.43
3003 JMPIjvm::checkException(env);
3004 }
3005
|
3006 mark.hamzy 1.25 handler.processing();
|
3007 mark.hamzy 1.23
|
3008 mark.hamzy 1.29 if (jcopRet) {
|
3009 marek 1.68 jlong jCopRetRef = env->CallLongMethod(
3010 jcopRet,
3011 JMPIjvm::jv.CIMObjectPathCInst);
3012 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
3013 jlong,
3014 CIMObjectPath*,
3015 jCopRetRef);
|
3016 mark.hamzy 1.23
|
3017 mark.hamzy 1.29 handler.deliver(*copRet);
|
3018 mark.hamzy 1.25 }
3019 handler.complete();
3020 break;
3021 }
|
3022 mark.hamzy 1.23
|
3023 mark.hamzy 1.25 case METHOD_UNKNOWN:
3024 {
|
3025 marek 1.71 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
3026 thilo.boehm 1.69 "handleCreateInstanceRequest: Unknown method provider!");
|
3027 mark.hamzy 1.25 break;
3028 }
|
3029 schuur 1.1 }
3030 }
3031 HandlerCatch(handler);
|
3032 mark.hamzy 1.23
|
3033 schuur 1.1 if (env) JMPIjvm::detachThread();
|
3034 mark.hamzy 1.23
|
3035 schuur 1.1 PEG_METHOD_EXIT();
3036
3037 return(response);
3038 }
3039
|
3040 marek 1.68 Message * JMPIProviderManager::handleModifyInstanceRequest(
3041 const Message * message) throw()
|
3042 schuur 1.1 {
|
3043 marek 1.68 PEG_METHOD_ENTER(
3044 TRC_PROVIDERMANAGER,
3045 "JMPIProviderManager::handleModifyInstanceRequest");
|
3046 schuur 1.1
|
3047 kumpf 1.55 HandlerIntro(ModifyInstance,message,request,response,handler);
|
3048 mark.hamzy 1.23
|
3049 mark.hamzy 1.25 typedef enum {
3050 METHOD_UNKNOWN = 0,
|
3051 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
3052 METHOD_INSTANCEPROVIDER,
3053 METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2
|
3054 mark.hamzy 1.25 } METHOD_VERSION;
3055 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3056 JNIEnv *env = NULL;
|
3057 schuur 1.13
|
3058 schuur 1.1 try {
|
3059 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
3060 "handleModifyInstanceRequest: "
3061 "name space = %s class name = %s",
3062 (const char*)request->nameSpace.getString().getCString(),
3063 (const char*)request->modifiedInstance.getPath().getClassName()
3064 .getString().getCString()
3065 ));
|
3066 mark.hamzy 1.23
|
3067 schuur 1.1 // make target object path
|
3068 marek 1.68 CIMObjectPath *objectPath =
3069 new CIMObjectPath(
3070 System::getHostName(),
3071 request->nameSpace,
3072 request->modifiedInstance.getPath().getClassName(),
3073 request->modifiedInstance.getPath ().getKeyBindings());
|
3074 schuur 1.1
3075 // resolve provider name
|
3076 kumpf 1.2 ProviderName name = _resolveProviderName(
3077 request->operationContext.get(ProviderIdContainer::NAME));
|
3078 schuur 1.1
|
3079 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3080 "handleModifyInstanceRequest: "
3081 "provider name physical = %s, logical = %s",
3082 (const char*)name.getPhysicalName().getCString(),
3083 (const char*)name.getLogicalName().getCString()
3084 ));
|
3085 mark.hamzy 1.23
|
3086 schuur 1.1 // get cached or load new provider module
|
3087 marek 1.68 JMPIProvider::OpProviderHolder ph =
3088 providerManager.getProvider(
3089 name.getPhysicalName(),
3090 name.getLogicalName(),
3091 String::EMPTY);
|
3092 schuur 1.1
3093 // forward request
|
3094 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
3095 mark.hamzy 1.23
|
3096 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
3097 "handleModifyInstanceRequest: "
3098 "Calling provider: %s", (const char*)pr.getName().getCString()));
|
3099 mark.hamzy 1.25
3100 JvmVector *jv = 0;
3101
3102 env = JMPIjvm::attachThread(&jv);
3103
|
3104 mark.hamzy 1.37 if (!env)
3105 {
|
3106 marek 1.71 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL1,
|
3107 thilo.boehm 1.69 "handleModifyInstanceRequest: "
3108 "Could not initialize the JVM (Java Virtual Machine) "
3109 "runtime environment.");
3110
|
3111 mark.hamzy 1.37 PEG_METHOD_EXIT();
3112
|
3113 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
3114 CIM_ERR_FAILED,
3115 MessageLoaderParms(
|
3116 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
3117 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
3118 "runtime environment."));
|
3119 mark.hamzy 1.37 }
3120
|
3121 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
3122 mark.hamzy 1.23
|
3123 mark.hamzy 1.43 jmethodID id = NULL;
3124 String interfaceType;
3125 String interfaceVersion;
3126
|
3127 marek 1.68 getInterfaceType(
3128 request->operationContext.get(
3129 ProviderIdContainer::NAME),
3130 interfaceType,
3131 interfaceVersion);
|
3132 mark.hamzy 1.43
3133 if (interfaceType == "JMPI")
3134 {
|
3135 marek 1.68 id = env->GetMethodID(
3136 (jclass)pr.jProviderClass,
3137 "setInstance",
3138 "(Lorg/pegasus/jmpi/CIMObjectPath;"
3139 "Lorg/pegasus/jmpi/CIMInstance;)V");
|
3140 mark.hamzy 1.43
3141 if (id != NULL)
3142 {
3143 eMethodFound = METHOD_INSTANCEPROVIDER;
|
3144 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3145 "handleModifyInstanceRequest: "
3146 "Found METHOD_INSTANCEPROVIDER.");
|
3147 mark.hamzy 1.43 }
|
3148 mark.hamzy 1.25
|
3149 mark.hamzy 1.43 if (id == NULL)
3150 {
3151 env->ExceptionClear();
|
3152 mark.hamzy 1.25
|
3153 marek 1.68 id = env->GetMethodID(
3154 (jclass)pr.jProviderClass,
3155 "setInstance",
3156 "(Lorg/pegasus/jmpi/CIMObjectPath;"
3157 "Z[Ljava/lang/String)V");
|
3158 mark.hamzy 1.43
3159 if (id != NULL)
3160 {
3161 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
|
3162 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3163 "handleModifyInstanceRequest: "
3164 "Found METHOD_CIMINSTANCEPROVIDER.");
|
3165 mark.hamzy 1.43 }
3166 }
3167 }
3168 else if (interfaceType == "JMPIExperimental")
|
3169 mark.hamzy 1.25 {
|
3170 marek 1.68 id = env->GetMethodID(
3171 (jclass)pr.jProviderClass,
3172 "setInstance",
3173 "(Lorg/pegasus/jmpi/OperationContext;"
3174 "Lorg/pegasus/jmpi/CIMObjectPath;"
3175 "Lorg/pegasus/jmpi/CIMInstance;)V");
|
3176 mark.hamzy 1.43
3177 if (id != NULL)
3178 {
3179 eMethodFound = METHOD_INSTANCEPROVIDER2;
|
3180 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3181 "handleModifyInstanceRequest: "
3182 "Found METHOD_INSTANCEPROVIDER2.");
|
3183 mark.hamzy 1.43 }
|
3184 mark.hamzy 1.25 }
3185
3186 if (id == NULL)
3187 {
|
3188 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3189 "handleModifyInstanceRequest: No method provider found!");
|
3190 mark.hamzy 1.25
|
3191 mark.hamzy 1.43 PEG_METHOD_EXIT();
|
3192 schuur 1.1
|
3193 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
3194 CIM_ERR_FAILED,
3195 MessageLoaderParms(
|
3196 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
3197 marek 1.68 "Could not find a method for the provider based on "
3198 "InterfaceType."));
|
3199 mark.hamzy 1.25 }
|
3200 schuur 1.1
|
3201 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3202 schuur 1.1
|
3203 mark.hamzy 1.25 switch (eMethodFound)
3204 {
|
3205 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
3206 {
|
3207 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
3208 OperationContext*,
3209 jlong,
3210 &request->operationContext);
3211
3212 jobject joc = env->NewObject(
3213 jv->OperationContextClassRef,
3214 jv->OperationContextNewJ,
3215 jocRef);
3216
3217 jlong jcopRef = DEBUG_ConvertCToJava(
3218 CIMObjectPath*,
3219 jlong,
3220 objectPath);
3221 jobject jcop = env->NewObject(
3222 jv->CIMObjectPathClassRef,
3223 jv->CIMObjectPathNewJ,
3224 jcopRef);
|
3225 mark.hamzy 1.43
3226 JMPIjvm::checkException(env);
3227
|
3228 marek 1.68 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
3229 jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
3230 jobject jci = env->NewObject(
3231 jv->CIMInstanceClassRef,
3232 jv->CIMInstanceNewJ,
3233 jciRef);
|
3234 mark.hamzy 1.43
3235 JMPIjvm::checkException(env);
3236
3237 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
3238
|
3239 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
3240
|
3241 mark.hamzy 1.43 env->CallVoidMethod((jobject)pr.jProvider,
3242 id,
3243 joc,
3244 jcop,
3245 jci);
3246
3247 JMPIjvm::checkException(env);
3248
3249 if (joc)
3250 {
|
3251 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
3252 mark.hamzy 1.43
3253 JMPIjvm::checkException(env);
3254 }
3255 break;
3256 }
3257
3258 case METHOD_CIMINSTANCEPROVIDER:
|
3259 mark.hamzy 1.25 {
|
3260 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
3261 CIMObjectPath*,
3262 jlong,
3263 objectPath);
3264 jobject jcop = env->NewObject(
3265 jv->CIMObjectPathClassRef,
3266 jv->CIMObjectPathNewJ,
3267 jcopRef);
|
3268 mark.hamzy 1.25
3269 JMPIjvm::checkException(env);
3270
|
3271 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
|
3272 marek 1.68 jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
3273 jobject jci = env->NewObject(
3274 jv->CIMInstanceClassRef,
3275 jv->CIMInstanceNewJ,
3276 jciRef);
|
3277 mark.hamzy 1.25
3278 JMPIjvm::checkException(env);
|
3279 schuur 1.1
|
3280 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
3281 schuur 1.1
|
3282 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
3283
|
3284 mark.hamzy 1.25 env->CallVoidMethod((jobject)pr.jProvider,
3285 id,
|
3286 mark.hamzy 1.29 jcop,
3287 jci,
|
3288 mark.hamzy 1.36 JMPI_INCLUDE_QUALIFIERS,
|
3289 mark.hamzy 1.25 jPropertyList);
|
3290 schuur 1.1
|
3291 mark.hamzy 1.25 JMPIjvm::checkException(env);
3292 break;
|
3293 schuur 1.13 }
|
3294 schuur 1.1
|
3295 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
3296 mark.hamzy 1.25 {
|
3297 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
3298 CIMObjectPath*,
3299 jlong,
3300 objectPath);
3301 jobject jcop = env->NewObject(
3302 jv->CIMObjectPathClassRef,
3303 jv->CIMObjectPathNewJ,
3304 jcopRef);
|
3305 mark.hamzy 1.25
3306 JMPIjvm::checkException(env);
3307
|
3308 marek 1.68 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
3309 jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
3310 jobject jci = env->NewObject(
3311 jv->CIMInstanceClassRef,
3312 jv->CIMInstanceNewJ,
3313 jciRef);
|
3314 mark.hamzy 1.25
3315 JMPIjvm::checkException(env);
3316
|
3317 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
3318
|
3319 mark.hamzy 1.25 env->CallVoidMethod((jobject)pr.jProvider,
3320 id,
|
3321 mark.hamzy 1.29 jcop,
3322 jci);
|
3323 mark.hamzy 1.25
3324 JMPIjvm::checkException(env);
3325 break;
3326 }
|
3327 mark.hamzy 1.23
|
3328 mark.hamzy 1.25 case METHOD_UNKNOWN:
3329 {
|
3330 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3331 "handleModifyInstanceRequest: Unknown method provider!");
|
3332 mark.hamzy 1.25 break;
3333 }
3334 }
|
3335 schuur 1.1 }
3336 HandlerCatch(handler);
|
3337 mark.hamzy 1.23
|
3338 schuur 1.1 if (env) JMPIjvm::detachThread();
|
3339 mark.hamzy 1.23
|
3340 schuur 1.1 PEG_METHOD_EXIT();
3341
3342 return(response);
3343 }
3344
|
3345 marek 1.68 Message * JMPIProviderManager::handleDeleteInstanceRequest(
3346 const Message * message) throw()
|
3347 schuur 1.1 {
|
3348 marek 1.68 PEG_METHOD_ENTER(
3349 TRC_PROVIDERMANAGER,
3350 "JMPIProviderManager::handleDeleteInstanceRequest");
|
3351 mark.hamzy 1.23
|
3352 kumpf 1.55 HandlerIntro(DeleteInstance,message,request,response,handler);
|
3353 schuur 1.1
|
3354 mark.hamzy 1.25 typedef enum {
3355 METHOD_UNKNOWN = 0,
|
3356 mark.hamzy 1.43 METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER
3357 METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2
|
3358 mark.hamzy 1.25 } METHOD_VERSION;
3359 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3360 JNIEnv *env = NULL;
3361
|
3362 schuur 1.1 try {
|
3363 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
3364 "handleDeleteInstanceRequest: "
3365 "name space = %s class name = %s",
3366 (const char*)request->nameSpace.getString().getCString(),
3367 (const char*)request->
3368 instanceName.getClassName().getString().getCString()
3369 ));
|
3370 mark.hamzy 1.23
|
3371 schuur 1.1 // make target object path
|
3372 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
3373 System::getHostName(),
3374 request->nameSpace,
3375 request->instanceName.getClassName(),
3376 request->instanceName.getKeyBindings());
|
3377 schuur 1.1
3378 // resolve provider name
|
3379 kumpf 1.2 ProviderName name = _resolveProviderName(
3380 request->operationContext.get(ProviderIdContainer::NAME));
|
3381 schuur 1.1
3382 // get cached or load new provider module
|
3383 marek 1.68 JMPIProvider::OpProviderHolder ph =
3384 providerManager.getProvider(
3385 name.getPhysicalName(),
3386 name.getLogicalName(),
3387 String::EMPTY);
|
3388 schuur 1.1
3389 // forward request
|
3390 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
3391 schuur 1.1
|
3392 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
3393 "handleDeleteInstanceRequest: "
3394 "Calling provider: %s", (const char*)pr.getName().getCString()));
|
3395 schuur 1.1
|
3396 mark.hamzy 1.25 JvmVector *jv = 0;
3397
3398 env = JMPIjvm::attachThread(&jv);
3399
|
3400 mark.hamzy 1.37 if (!env)
3401 {
|
3402 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3403 "handleDeleteInstanceRequest: "
3404 "Could not initialize the JVM (Java Virtual Machine) "
3405 "runtime environment.");
3406
|
3407 mark.hamzy 1.37 PEG_METHOD_EXIT();
3408
|
3409 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
3410 CIM_ERR_FAILED,
3411 MessageLoaderParms(
|
3412 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
3413 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
3414 "runtime environment."));
|
3415 mark.hamzy 1.37 }
3416
|
3417 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
3418
|
3419 mark.hamzy 1.43 jmethodID id = NULL;
3420 String interfaceType;
3421 String interfaceVersion;
3422
|
3423 marek 1.68 getInterfaceType(
3424 request->operationContext.get(ProviderIdContainer::NAME),
3425 interfaceType,
3426 interfaceVersion);
|
3427 mark.hamzy 1.43
3428 if (interfaceType == "JMPI")
3429 {
3430 id = env->GetMethodID((jclass)pr.jProviderClass,
3431 "deleteInstance",
3432 "(Lorg/pegasus/jmpi/CIMObjectPath;)V");
3433
3434 if (id != NULL)
3435 {
3436 eMethodFound = METHOD_INSTANCEPROVIDER;
|
3437 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3438 "handleDeleteInstanceRequest: "
3439 "Found METHOD_INSTANCEPROVIDER.");
|
3440 mark.hamzy 1.43 }
3441 }
3442 else if (interfaceType == "JMPIExperimental")
3443 {
|
3444 marek 1.68 id = env->GetMethodID(
3445 (jclass)pr.jProviderClass,
3446 "deleteInstance",
3447 "(Lorg/pegasus/jmpi/OperationContext;"
3448 "Lorg/pegasus/jmpi/CIMObjectPath;)V");
|
3449 mark.hamzy 1.25
|
3450 mark.hamzy 1.43 if (id != NULL)
3451 {
3452 eMethodFound = METHOD_INSTANCEPROVIDER2;
|
3453 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3454 "handleDeleteInstanceRequest: "
3455 "Found METHOD_INSTANCEPROVIDER2.");
|
3456 mark.hamzy 1.43 }
3457 }
|
3458 schuur 1.1
|
3459 mark.hamzy 1.43 if (id == NULL)
|
3460 mark.hamzy 1.25 {
|
3461 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3462 "handleDeleteInstanceRequest: No method provider found!");
|
3463 mark.hamzy 1.43
3464 PEG_METHOD_EXIT();
3465
|
3466 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
3467 CIM_ERR_FAILED,
3468 MessageLoaderParms(
|
3469 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
3470 marek 1.68 "Could not find a method for the provider based on "
3471 "InterfaceType."));
|
3472 mark.hamzy 1.25 }
|
3473 mark.hamzy 1.23
3474 JMPIjvm::checkException(env);
|
3475 schuur 1.1
|
3476 mark.hamzy 1.25 switch (eMethodFound)
3477 {
|
3478 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
3479 {
|
3480 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
3481 OperationContext*,
3482 jlong,
3483 &request->operationContext);
3484 jobject joc = env->NewObject(
3485 jv->OperationContextClassRef,
3486 jv->OperationContextNewJ,
3487 jocRef);
3488
3489 jlong jcopRef = DEBUG_ConvertCToJava(
3490 CIMObjectPath*,
3491 jlong,
3492 objectPath);
3493 jobject jcop = env->NewObject(
3494 jv->CIMObjectPathClassRef,
3495 jv->CIMObjectPathNewJ,
3496 jcopRef);
|
3497 mark.hamzy 1.43
3498 JMPIjvm::checkException(env);
3499
|
3500 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
3501
|
3502 mark.hamzy 1.43 env->CallVoidMethod((jobject)pr.jProvider,
3503 id,
3504 joc,
3505 jcop);
3506
3507 JMPIjvm::checkException(env);
3508
3509 if (joc)
3510 {
|
3511 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
3512 mark.hamzy 1.43
3513 JMPIjvm::checkException(env);
3514 }
3515 break;
3516 }
3517
3518 case METHOD_INSTANCEPROVIDER:
|
3519 mark.hamzy 1.25 {
|
3520 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
3521 CIMObjectPath*,
3522 jlong,
3523 objectPath);
3524 jobject jcop = env->NewObject(
3525 jv->CIMObjectPathClassRef,
3526 jv->CIMObjectPathNewJ,
3527 jcopRef);
|
3528 mark.hamzy 1.25
3529 JMPIjvm::checkException(env);
3530
|
3531 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
3532
|
3533 mark.hamzy 1.36 env->CallVoidMethod((jobject)pr.jProvider,
3534 id,
3535 jcop);
|
3536 mark.hamzy 1.25
3537 JMPIjvm::checkException(env);
3538 break;
3539 }
3540
3541 case METHOD_UNKNOWN:
3542 {
|
3543 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3544 "handleDeleteInstanceRequest: Unknown method provider!");
|
3545 mark.hamzy 1.25 break;
3546 }
3547 }
3548 }
3549 HandlerCatch(handler);
3550
3551 if (env) JMPIjvm::detachThread();
3552
3553 PEG_METHOD_EXIT();
3554
3555 return(response);
3556 }
3557
|
3558 marek 1.68 Message * JMPIProviderManager::handleExecQueryRequest(
3559 const Message * message) throw()
|
3560 mark.hamzy 1.25 {
|
3561 marek 1.68 PEG_METHOD_ENTER(
3562 TRC_PROVIDERMANAGER,
3563 "JMPIProviderManager::handleExecQueryRequest");
|
3564 mark.hamzy 1.25
|
3565 kumpf 1.55 HandlerIntro(ExecQuery,message,request,response,handler);
|
3566 mark.hamzy 1.25
3567 typedef enum {
3568 METHOD_UNKNOWN = 0,
|
3569 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
3570 METHOD_CIMINSTANCEPROVIDER2,
3571 METHOD_INSTANCEPROVIDER,
3572 METHOD_INSTANCEPROVIDER2,
|
3573 mark.hamzy 1.25 } METHOD_VERSION;
3574 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3575 JNIEnv *env = NULL;
3576
3577 try {
|
3578 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
3579 "handleExecQueryRequest: "
3580 "name space = %s class name = %s",
3581 (const char*)request->nameSpace.getString().getCString(),
3582 (const char*)request->className.getString().getCString()
3583 ));
|
3584 mark.hamzy 1.25
3585 // make target object path
|
3586 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3587 request->nameSpace,
3588 request->className);
|
3589 mark.hamzy 1.25
3590 // resolve provider name
3591 ProviderName name = _resolveProviderName(
3592 request->operationContext.get(ProviderIdContainer::NAME));
3593
3594 // get cached or load new provider module
|
3595 marek 1.68 JMPIProvider::OpProviderHolder ph =
3596 providerManager.getProvider(
3597 name.getPhysicalName(),
3598 name.getLogicalName(),
3599 String::EMPTY);
|
3600 mark.hamzy 1.25
3601 // convert arguments
3602 OperationContext context;
3603
|
3604 marek 1.68 context.insert(
3605 request->operationContext.get(IdentityContainer::NAME));
3606 context.insert(
3607 request->operationContext.get(AcceptLanguageListContainer::NAME));
3608 context.insert(
3609 request->operationContext.get(ContentLanguageListContainer::NAME));
|
3610 mark.hamzy 1.25
3611 // forward request
3612 JMPIProvider &pr = ph.GetProvider();
3613
|
3614 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
3615 "handleExecQueryRequest: "
3616 "Calling provider: %s, queryLanguage: %s, query: %s",
3617 (const char*)pr.getName().getCString(),
3618 (const char*)request->queryLanguage.getCString(),
3619 (const char*)request->query.getCString()
3620 ));
|
3621 mark.hamzy 1.25
3622 JvmVector *jv = 0;
3623
3624 env = JMPIjvm::attachThread(&jv);
3625
|
3626 mark.hamzy 1.37 if (!env)
3627 {
|
3628 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3629 "handleExecQueryRequest: "
3630 "Could not initialize the JVM (Java Virtual Machine) "
3631 "runtime environment.");
3632
|
3633 mark.hamzy 1.37 PEG_METHOD_EXIT();
3634
|
3635 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
3636 CIM_ERR_FAILED,
3637 MessageLoaderParms(
|
3638 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
3639 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
3640 "runtime environment."));
|
3641 mark.hamzy 1.37 }
3642
|
3643 mark.hamzy 1.23 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
3644 schuur 1.1
|
3645 mark.hamzy 1.43 jmethodID id = NULL;
3646 String interfaceType;
3647 String interfaceVersion;
3648
|
3649 marek 1.68 getInterfaceType(
3650 request->operationContext.get(
3651 ProviderIdContainer::NAME),
3652 interfaceType,
3653 interfaceVersion);
|
3654 mark.hamzy 1.43
3655 if (interfaceType == "JMPI")
3656 {
|
3657 marek 1.68 id = env->GetMethodID(
3658 (jclass)pr.jProviderClass,
3659 "execQuery",
3660 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
3661 "ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
|
3662 mark.hamzy 1.43
3663 if (id != NULL)
3664 {
3665 eMethodFound = METHOD_INSTANCEPROVIDER;
|
3666 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3667 "handleExecQueryRequest: Found METHOD_INSTANCEPROVIDER.");
|
3668 mark.hamzy 1.43 }
|
3669 mark.hamzy 1.25
|
3670 mark.hamzy 1.43 if (id == NULL)
3671 {
3672 env->ExceptionClear();
|
3673 mark.hamzy 1.25
|
3674 marek 1.68 id = env->GetMethodID(
3675 (jclass)pr.jProviderClass,
3676 "execQuery",
3677 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
3678 "Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)"
3679 "[Lorg/pegasus/jmpi/CIMInstance;");
|
3680 mark.hamzy 1.43
3681 if (id != NULL)
3682 {
3683 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
|
3684 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3685 "handleExecQueryRequest: "
3686 "Found METHOD_CIMINSTANCEPROVIDER.");
|
3687 mark.hamzy 1.43 }
3688 }
3689 }
3690 else if (interfaceType == "JMPIExperimental")
|
3691 mark.hamzy 1.25 {
|
3692 marek 1.68 id = env->GetMethodID(
3693 (jclass)pr.jProviderClass,
3694 "execQuery",
3695 "(Lorg/pegasus/jmpi/OperationContext;"
3696 "Lorg/pegasus/jmpi/CIMObjectPath;"
3697 "Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;"
3698 "Ljava/lang/String;)Ljava/util/Vector;");
|
3699 mark.hamzy 1.25
|
3700 mark.hamzy 1.43 if (id != NULL)
3701 {
3702 eMethodFound = METHOD_INSTANCEPROVIDER2;
|
3703 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3704 "handleExecQueryRequest: Found METHOD_INSTANCEPROVIDER2.");
|
3705 mark.hamzy 1.43 }
|
3706 mark.hamzy 1.25
|
3707 mark.hamzy 1.43 if (id == NULL)
3708 {
3709 env->ExceptionClear();
|
3710 mark.hamzy 1.25
|
3711 marek 1.68 id = env->GetMethodID(
3712 (jclass)pr.jProviderClass,
3713 "execQuery",
3714 "(Lorg/pegasus/jmpi/OperationContext;"
3715 "Lorg/pegasus/jmpi/CIMObjectPath;"
3716 "Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;"
3717 "Ljava/lang/String;)"
3718 "[Lorg/pegasus/jmpi/CIMInstance;");
|
3719 mark.hamzy 1.43
3720 if (id != NULL)
3721 {
3722 eMethodFound = METHOD_CIMINSTANCEPROVIDER2;
|
3723 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3724 "handleExecQueryRequest: "
3725 "Found METHOD_CIMINSTANCEPROVIDER2.");
|
3726 mark.hamzy 1.43 }
3727 }
|
3728 mark.hamzy 1.25 }
3729
3730 if (id == NULL)
3731 {
|
3732 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3733 "handleExecQueryRequest: No method provider found!");
|
3734 mark.hamzy 1.36
|
3735 mark.hamzy 1.43 PEG_METHOD_EXIT();
|
3736 mark.hamzy 1.36
|
3737 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
3738 CIM_ERR_FAILED,
3739 MessageLoaderParms(
|
3740 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
3741 marek 1.68 "Could not find a method for the provider based on "
3742 "InterfaceType."));
|
3743 mark.hamzy 1.25 }
3744
|
3745 schuur 1.1 JMPIjvm::checkException(env);
3746
|
3747 mark.hamzy 1.25 switch (eMethodFound)
3748 {
|
3749 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER:
|
3750 mark.hamzy 1.25 {
|
3751 marek 1.68 jlong jcopref = DEBUG_ConvertCToJava(
3752 CIMObjectPath*,
3753 jlong,
3754 objectPath);
3755 jobject jcop = env->NewObject(
3756 jv->CIMObjectPathClassRef,
3757 jv->CIMObjectPathNewJ,
3758 jcopref);
|
3759 mark.hamzy 1.25
3760 JMPIjvm::checkException(env);
3761
|
3762 marek 1.68 jstring jqueryLanguage = env->NewStringUTF(
3763 request->queryLanguage.getCString());
3764 jstring jquery = env->NewStringUTF(
3765 request->query.getCString());
|
3766 mark.hamzy 1.25
|
3767 mark.hamzy 1.40 CIMClass cls;
3768
3769 try
3770 {
|
3771 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3772 "handleExecQueryRequest: "
3773 "enter(METHOD_CIMINSTANCEPROVIDER): "
3774 "cimom_handle->getClass(%s).",
3775 (const char*)request->className.getString().getCString()
3776 ));
3777
|
3778 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
3779
3780 cls = pr._cimom_handle->getClass(context,
3781 request->nameSpace,
3782 request->className,
3783 false,
3784 true,
3785 true,
3786 CIMPropertyList());
|
3787 thilo.boehm 1.69
3788 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3789 "handleExecQueryRequest: "
3790 "exit(METHOD_CIMINSTANCEPROVIDER): "
3791 "cimom_handle->getClass(%s).",
3792 (const char*)request->className.getString().getCString()
3793 ));
3794
|
3795 mark.hamzy 1.40 }
3796 catch (CIMException e)
3797 {
|
3798 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3799 "handleExecQueryRequest: "
3800 "Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER) "
3801 "during cimom_handle->getClass(%s): %s ",
3802 (const char*)request->className.getString().getCString(),
3803 (const char*)e.getMessage().getCString()
3804 ));
3805
3806 PEG_METHOD_EXIT();
|
3807 mark.hamzy 1.40 throw;
3808 }
3809
|
3810 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
3811
|
3812 mark.hamzy 1.25 JMPIjvm::checkException(env);
3813
|
3814 mark.hamzy 1.59 jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
|
3815 mark.hamzy 1.25
|
3816 marek 1.68 jobject jCc=env->NewObject(
3817 jv->CIMClassClassRef,
3818 jv->CIMClassNewJ,
3819 jcls);
|
3820 mark.hamzy 1.25
3821 JMPIjvm::checkException(env);
3822
|
3823 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
3824
|
3825 marek 1.68 jobjectArray jAr = (jobjectArray)env->CallObjectMethod(
3826 (jobject)pr.jProvider,
3827 id,
3828 jcop,
3829 jquery,
3830 jqueryLanguage,
3831 jCc);
|
3832 mark.hamzy 1.23
|
3833 mark.hamzy 1.25 JMPIjvm::checkException(env);
3834
3835 handler.processing();
3836 if (jAr) {
3837 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
3838 JMPIjvm::checkException(env);
3839
|
3840 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jAr,i);
3841
|
3842 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
3843 mark.hamzy 1.23
|
3844 marek 1.68 jlong jciRetRef = env->CallLongMethod(
3845 jciRet,
3846 JMPIjvm::jv.CIMInstanceCInst);
3847 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
3848 jlong,
3849 CIMInstance*,
3850 jciRetRef);
|
3851 mark.hamzy 1.25
3852 JMPIjvm::checkException(env);
3853
|
3854 mark.hamzy 1.29 handler.deliver(*ciRet);
|
3855 mark.hamzy 1.25 }
3856 }
3857 handler.complete();
3858 break;
3859 }
3860
|
3861 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER2:
|
3862 mark.hamzy 1.36 {
|
3863 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
3864 OperationContext*,
3865 jlong,
3866 &request->operationContext);
3867 jobject joc = env->NewObject(
3868 jv->OperationContextClassRef,
3869 jv->OperationContextNewJ,
3870 jocRef);
3871
3872 jlong jcopref = DEBUG_ConvertCToJava(
3873 CIMObjectPath*,
3874 jlong,
3875 objectPath);
3876 jobject jcop = env->NewObject(
3877 jv->CIMObjectPathClassRef,
3878 jv->CIMObjectPathNewJ,
3879 jcopref);
|
3880 mark.hamzy 1.36
3881 JMPIjvm::checkException(env);
3882
|
3883 marek 1.68 jstring jqueryLanguage = env->NewStringUTF(
3884 request->queryLanguage.getCString());
3885 jstring jquery = env->NewStringUTF(
3886 request->query.getCString());
|
3887 mark.hamzy 1.36
|
3888 mark.hamzy 1.40 CIMClass cls;
3889
3890 try
3891 {
|
3892 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3893 "handleExecQueryRequest: "
3894 "enter(METHOD_CIMINSTANCEPROVIDER2): "
3895 "cimom_handle->getClass(%s).",
3896 (const char*)request->className.getString().getCString()
3897 ));
3898
|
3899 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
3900
3901 cls = pr._cimom_handle->getClass(context,
3902 request->nameSpace,
3903 request->className,
3904 false,
3905 true,
3906 true,
3907 CIMPropertyList());
|
3908 thilo.boehm 1.69
3909 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
3910 "handleExecQueryRequest: "
3911 "exit(METHOD_CIMINSTANCEPROVIDER2): "
3912 "cimom_handle->getClass(%s).",
3913 (const char*)request->className.getString().getCString()
3914 ));
3915
|
3916 mark.hamzy 1.40 }
3917 catch (CIMException e)
3918 {
|
3919 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
3920 "handleExecQueryRequest: "
3921 "Caught CIMExcetion(METHOD_CIMINSTANCEPROVIDER2) "
3922 "during cimom_handle->getClass(%s): %s ",
3923 (const char*)request->className.getString().getCString(),
3924 (const char*)e.getMessage().getCString()
3925 ));
3926
3927 PEG_METHOD_EXIT();
|
3928 mark.hamzy 1.40 throw;
3929 }
3930
|
3931 mark.hamzy 1.36 CIMClass *pcls = new CIMClass (cls);
3932
3933 JMPIjvm::checkException(env);
3934
|
3935 mark.hamzy 1.59 jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
|
3936 mark.hamzy 1.36
|
3937 marek 1.68 jobject jCc=env->NewObject(
3938 jv->CIMClassClassRef,
3939 jv->CIMClassNewJ,
3940 jcls);
|
3941 mark.hamzy 1.36
3942 JMPIjvm::checkException(env);
3943
|
3944 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
3945
|
3946 marek 1.68 jobjectArray jAr = (jobjectArray)env->CallObjectMethod(
3947 (jobject)pr.jProvider,
3948 id,
3949 joc,
3950 jcop,
3951 jquery,
3952 jqueryLanguage,
3953 jCc);
|
3954 mark.hamzy 1.36
3955 JMPIjvm::checkException(env);
3956
|
3957 mark.hamzy 1.43 if (joc)
3958 {
|
3959 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
3960 mark.hamzy 1.43
3961 JMPIjvm::checkException(env);
3962 }
3963
3964 handler.processing();
3965 if (jAr) {
3966 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
3967 JMPIjvm::checkException(env);
3968
3969 jobject jciRet = env->GetObjectArrayElement(jAr,i);
3970
3971 JMPIjvm::checkException(env);
3972
|
3973 marek 1.68 jlong jciRetRef = env->CallLongMethod(
3974 jciRet,
3975 JMPIjvm::jv.CIMInstanceCInst);
3976 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
3977 jlong,
3978 CIMInstance*,
3979 jciRetRef);
|
3980 mark.hamzy 1.43
3981 JMPIjvm::checkException(env);
3982
3983 handler.deliver(*ciRet);
3984 }
3985 }
3986 handler.complete();
3987 break;
3988 }
3989
3990 case METHOD_INSTANCEPROVIDER2:
3991 {
|
3992 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
3993 OperationContext*,
3994 jlong,
3995 &request->operationContext);
3996 jobject joc = env->NewObject(
3997 jv->OperationContextClassRef,
3998 jv->OperationContextNewJ,
3999 jocRef);
4000
4001 jlong jcopref = DEBUG_ConvertCToJava(
4002 CIMObjectPath*,
4003 jlong,
4004 objectPath);
4005 jobject jcop = env->NewObject(
4006 jv->CIMObjectPathClassRef,
4007 jv->CIMObjectPathNewJ,
4008 jcopref);
|
4009 mark.hamzy 1.43
4010 JMPIjvm::checkException(env);
4011
|
4012 marek 1.68 jstring jqueryLanguage = env->NewStringUTF(
4013 request->queryLanguage.getCString());
4014 jstring jquery = env->NewStringUTF(
4015 request->query.getCString());
|
4016 mark.hamzy 1.43
4017 CIMClass cls;
4018
4019 try
4020 {
|
4021 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4022 "handleExecQueryRequest: "
4023 "enter(METHOD_INSTANCEPROVIDER2): "
4024 "cimom_handle->getClass(%s).",
4025 (const char*)request->className.getString().getCString()
4026 ));
4027
|
4028 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
4029
4030 cls = pr._cimom_handle->getClass(context,
4031 request->nameSpace,
4032 request->className,
4033 false,
4034 true,
4035 true,
4036 CIMPropertyList());
|
4037 thilo.boehm 1.69
4038 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4039 "handleExecQueryRequest: "
4040 "exit(METHOD_INSTANCEPROVIDER2): "
4041 "cimom_handle->getClass(%s).",
4042 (const char*)request->className.getString().getCString()
4043 ));
4044
|
4045 mark.hamzy 1.43 }
4046 catch (CIMException e)
4047 {
|
4048 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4049 "handleExecQueryRequest: "
4050 "Caught CIMExcetion(METHOD_INSTANCEPROVIDER2) "
4051 "during cimom_handle->getClass(%s): %s ",
4052 (const char*)request->className.getString().getCString(),
4053 (const char*)e.getMessage().getCString()
4054 ));
4055
4056 PEG_METHOD_EXIT();
|
4057 mark.hamzy 1.43 throw;
4058 }
4059
4060 CIMClass *pcls = new CIMClass (cls);
4061
|
4062 mark.hamzy 1.59 jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
|
4063 mark.hamzy 1.43
|
4064 marek 1.68 jobject jCc=env->NewObject(
4065 jv->CIMClassClassRef,
4066 jv->CIMClassNewJ,
4067 jcls);
|
4068 mark.hamzy 1.43
4069 JMPIjvm::checkException(env);
4070
|
4071 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
4072
|
4073 mark.hamzy 1.51 jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider,
4074 id,
4075 joc,
4076 jcop,
4077 jCc,
4078 jquery,
4079 jqueryLanguage);
|
4080 mark.hamzy 1.43
4081 JMPIjvm::checkException(env);
4082
4083 if (joc)
4084 {
|
4085 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
4086 mark.hamzy 1.43
4087 JMPIjvm::checkException(env);
4088 }
4089
|
4090 mark.hamzy 1.36 handler.processing();
|
4091 mark.hamzy 1.51 if (jVec)
4092 {
|
4093 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
4094 i < m;
4095 i++)
|
4096 mark.hamzy 1.51 {
|
4097 mark.hamzy 1.36 JMPIjvm::checkException(env);
4098
|
4099 marek 1.68 jobject jciRet = env->CallObjectMethod(
4100 jVec,
4101 JMPIjvm::jv.VectorElementAt,
4102 i);
|
4103 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
4104 thilo.boehm 1.70 "handleExecQueryRequest: jciRet = %p",jciRet));
|
4105 mark.hamzy 1.36
4106 JMPIjvm::checkException(env);
4107
|
4108 marek 1.68 jlong jciRetRef = env->CallLongMethod(
4109 jciRet,
4110 JMPIjvm::jv.CIMInstanceCInst);
4111 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
4112 jlong,
4113 CIMInstance*,
4114 jciRetRef);
|
4115 mark.hamzy 1.36
4116 JMPIjvm::checkException(env);
4117
4118 handler.deliver(*ciRet);
4119 }
4120 }
|
4121 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4122 "handleExecQueryRequest: done!");
4123
|
4124 mark.hamzy 1.36 handler.complete();
4125 break;
4126 }
4127
|
4128 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
4129 mark.hamzy 1.25 {
|
4130 marek 1.68 jlong jcopref = DEBUG_ConvertCToJava(
4131 CIMObjectPath*,
4132 jlong,
4133 objectPath);
4134 jobject jcop = env->NewObject(
4135 jv->CIMObjectPathClassRef,
4136 jv->CIMObjectPathNewJ,
4137 jcopref);
|
4138 mark.hamzy 1.25
4139 JMPIjvm::checkException(env);
4140
|
4141 marek 1.68 jstring jqueryLanguage = env->NewStringUTF(
4142 request->queryLanguage.getCString());
4143 jstring jquery = env->NewStringUTF(
4144 request->query.getCString());
|
4145 mark.hamzy 1.25
|
4146 mark.hamzy 1.40 CIMClass cls;
4147
4148 try
4149 {
|
4150 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4151 "handleExecQueryRequest: "
4152 "enter(METHOD_INSTANCEPROVIDER): "
4153 "cimom_handle->getClass(%s).",
4154 (const char*)request->className.getString().getCString()
4155 ));
4156
|
4157 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
4158
4159 cls = pr._cimom_handle->getClass(context,
4160 request->nameSpace,
4161 request->className,
4162 false,
4163 true,
4164 true,
4165 CIMPropertyList());
|
4166 thilo.boehm 1.69
4167 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4168 "handleExecQueryRequest: "
4169 "exit(METHOD_INSTANCEPROVIDER): "
4170 "cimom_handle->getClass(%s).",
4171 (const char*)request->className.getString().getCString()
4172 ));
4173
|
4174 mark.hamzy 1.40 }
4175 catch (CIMException e)
4176 {
|
4177 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4178 "handleExecQueryRequest: "
4179 "Caught CIMExcetion(METHOD_INSTANCEPROVIDER) "
4180 "during cimom_handle->getClass(%s): %s ",
4181 (const char*)request->className.getString().getCString(),
4182 (const char*)e.getMessage().getCString()
4183 ));
4184
4185 PEG_METHOD_EXIT();
|
4186 mark.hamzy 1.40 throw;
4187 }
4188
|
4189 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
4190
|
4191 mark.hamzy 1.25 JMPIjvm::checkException(env);
4192
|
4193 mark.hamzy 1.59 jlong jcls = DEBUG_ConvertCToJava (CIMClass*, jlong, pcls);
|
4194 mark.hamzy 1.25
|
4195 marek 1.68 jobject jCc=env->NewObject(
4196 jv->CIMClassClassRef,
4197 jv->CIMClassNewJ,
4198 jcls);
|
4199 mark.hamzy 1.25
4200 JMPIjvm::checkException(env);
4201
|
4202 mark.hamzy 1.59 jlong jql = 0; // @BUG - how to convert?
|
4203 mark.hamzy 1.25
|
4204 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
4205
|
4206 marek 1.68 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
4207 id,
4208 jcop,
4209 jquery,
4210 jql,
4211 jCc);
|
4212 mark.hamzy 1.25
4213 JMPIjvm::checkException(env);
4214
4215 handler.processing();
4216 if (jVec) {
|
4217 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
4218 i<m;
4219 i++)
4220 {
|
4221 mark.hamzy 1.25 JMPIjvm::checkException(env);
4222
|
4223 marek 1.68 jobject jciRet = env->CallObjectMethod(
4224 jVec,
4225 JMPIjvm::jv.VectorElementAt,
4226 i);
|
4227 mark.hamzy 1.29
|
4228 mark.hamzy 1.25 JMPIjvm::checkException(env);
4229
|
4230 marek 1.68 jlong jciRetRef = env->CallLongMethod(
4231 jciRet,
4232 JMPIjvm::jv.CIMInstanceCInst);
4233 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
4234 jlong,
4235 CIMInstance*,
4236 jciRetRef);
|
4237 mark.hamzy 1.25
4238 JMPIjvm::checkException(env);
4239
|
4240 mark.hamzy 1.29 handler.deliver(*ciRet);
|
4241 mark.hamzy 1.25 }
4242 }
4243 handler.complete();
4244 break;
4245 }
4246
4247 case METHOD_UNKNOWN:
4248 {
|
4249 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4250 "handleExecQueryRequest: Unknown method provider!");
|
4251 mark.hamzy 1.25 break;
4252 }
4253 }
|
4254 schuur 1.1 }
4255 HandlerCatch(handler);
|
4256 mark.hamzy 1.23
|
4257 schuur 1.1 if (env) JMPIjvm::detachThread();
|
4258 mark.hamzy 1.23
|
4259 schuur 1.1 PEG_METHOD_EXIT();
4260
4261 return(response);
4262 }
4263
|
4264 marek 1.68 Message * JMPIProviderManager::handleAssociatorsRequest(
4265 const Message * message) throw()
|
4266 schuur 1.1 {
|
4267 marek 1.68 PEG_METHOD_ENTER(
4268 TRC_PROVIDERMANAGER,
4269 "JMPIProviderManager::handleAssociatorsRequest");
|
4270 mark.hamzy 1.23
|
4271 kumpf 1.55 HandlerIntro(Associators,message,request,response,handler);
|
4272 schuur 1.1
|
4273 mark.hamzy 1.24 typedef enum {
4274 METHOD_UNKNOWN = 0,
|
4275 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
4276 METHOD_CIMASSOCIATORPROVIDER2,
4277 METHOD_ASSOCIATORPROVIDER,
4278 METHOD_ASSOCIATORPROVIDER2,
|
4279 mark.hamzy 1.24 } METHOD_VERSION;
4280 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
4281 JNIEnv *env = NULL;
|
4282 schuur 1.13
|
4283 marek 1.68 try
4284 {
|
4285 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
4286 "handleAssociatorsRequest: "
4287 "name space = %s class name = %s",
4288 (const char*)request->nameSpace.getString().getCString(),
4289 (const char*)request->
4290 objectName.getClassName().getString().getCString()
4291 ));
|
4292 mark.hamzy 1.23
|
4293 schuur 1.1 // make target object path
|
4294 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
4295 System::getHostName(),
4296 request->nameSpace,
4297 request->objectName.getClassName(),
4298 request->objectName.getKeyBindings());
4299 CIMObjectPath *assocPath = new CIMObjectPath(
4300 System::getHostName(),
4301 request->nameSpace,
4302 request->assocClass.getString());
|
4303 schuur 1.1
4304 // resolve provider name
|
4305 kumpf 1.2 ProviderName name = _resolveProviderName(
4306 request->operationContext.get(ProviderIdContainer::NAME));
|
4307 schuur 1.1
4308 // get cached or load new provider module
|
4309 marek 1.68 JMPIProvider::OpProviderHolder ph =
4310 providerManager.getProvider(
4311 name.getPhysicalName(),
4312 name.getLogicalName(),
4313 String::EMPTY);
|
4314 schuur 1.1
|
4315 mark.hamzy 1.24 // convert arguments
|
4316 schuur 1.1 OperationContext context;
4317
|
4318 marek 1.68 context.insert(
4319 request->operationContext.get(IdentityContainer::NAME));
4320 context.insert(
4321 request->operationContext.get(AcceptLanguageListContainer::NAME));
4322 context.insert(
4323 request->operationContext.get(ContentLanguageListContainer::NAME));
|
4324 schuur 1.1
4325 // forward request
|
4326 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
4327
|
4328 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
4329 "handleAssociatorsRequest: "
4330 "Calling provider: %s, role: %s, aCls: %s",
4331 (const char*)pr.getName().getCString(),
4332 (const char*)request->role.getCString(),
4333 (const char*)request->assocClass.getString().getCString()
4334 ));
|
4335 schuur 1.1
|
4336 mark.hamzy 1.24 JvmVector *jv = 0;
|
4337 schuur 1.1
|
4338 mark.hamzy 1.24 env = JMPIjvm::attachThread(&jv);
|
4339 schuur 1.1
|
4340 mark.hamzy 1.37 if (!env)
4341 {
|
4342 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4343 "handleAssociatorsRequest: "
4344 "Could not initialize the JVM (Java Virtual Machine) "
4345 "runtime environment.");
4346
|
4347 mark.hamzy 1.37 PEG_METHOD_EXIT();
4348
|
4349 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
4350 CIM_ERR_FAILED,
4351 MessageLoaderParms(
|
4352 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
4353 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
4354 "runtime environment."));
|
4355 mark.hamzy 1.37 }
4356
|
4357 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
4358
|
4359 mark.hamzy 1.43 jmethodID id = NULL;
4360 String interfaceType;
4361 String interfaceVersion;
4362
|
4363 marek 1.68 getInterfaceType(
4364 request->operationContext.get(
4365 ProviderIdContainer::NAME),
4366 interfaceType,
4367 interfaceVersion);
|
4368 mark.hamzy 1.43
4369 if (interfaceType == "JMPI")
4370 {
|
4371 marek 1.68 id = env->GetMethodID(
4372 (jclass)pr.jProviderClass,
4373 "associators",
4374 "(Lorg/pegasus/jmpi/CIMObjectPath;"
4375 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
4376 "Ljava/lang/String;Ljava/lang/String;"
4377 "ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
4378 mark.hamzy 1.24
|
4379 mark.hamzy 1.43 if (id != NULL)
4380 {
4381 eMethodFound = METHOD_ASSOCIATORPROVIDER;
|
4382 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4383 "handleAssociatorsRequest: "
4384 "Found METHOD_ASSOCIATORPROVIDER.");
|
4385 mark.hamzy 1.43 }
4386
4387 if (id == NULL)
4388 {
4389 env->ExceptionClear();
|
4390 mark.hamzy 1.24
|
4391 marek 1.68 id = env->GetMethodID(
4392 (jclass)pr.jProviderClass,
4393 "associators",
4394 "(Lorg/pegasus/jmpi/CIMObjectPath;"
4395 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
4396 "Ljava/lang/String;Ljava/lang/String;"
4397 "ZZ[Ljava/lang/String;)"
4398 "[Lorg/pegasus/jmpi/CIMInstance;");
|
4399 mark.hamzy 1.43
4400 if (id != NULL)
4401 {
4402 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
|
4403 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4404 "handleAssociatorsRequest: "
4405 "Found METHOD_ASSOCIATORPROVIDER.");
|
4406 mark.hamzy 1.43 }
4407 }
4408 }
4409 else if (interfaceType == "JMPIExperimental")
|
4410 mark.hamzy 1.24 {
|
4411 marek 1.68 id = env->GetMethodID(
4412 (jclass)pr.jProviderClass,
4413 "associators",
4414 "(Lorg/pegasus/jmpi/OperationContext;"
4415 "Lorg/pegasus/jmpi/CIMObjectPath;"
4416 "Lorg/pegasus/jmpi/CIMObjectPath;"
4417 "Ljava/lang/String;Ljava/lang/String;"
4418 "Ljava/lang/String;ZZ[Ljava/lang/String;)"
4419 "Ljava/util/Vector;");
|
4420 schuur 1.12
|
4421 mark.hamzy 1.43 if (id != NULL)
4422 {
4423 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
|
4424 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4425 "handleAssociatorsRequest: "
4426 "Found METHOD_ASSOCIATORPROVIDER2.");
|
4427 mark.hamzy 1.43 }
|
4428 mark.hamzy 1.24
|
4429 mark.hamzy 1.43 if (id == NULL)
4430 {
4431 env->ExceptionClear();
|
4432 marek 1.68 id = env->GetMethodID(
4433 (jclass)pr.jProviderClass,
4434 "associators",
4435 "(Lorg/pegasus/jmpi/OperationContext;"
4436 "Lorg/pegasus/jmpi/CIMObjectPath;"
4437 "Lorg/pegasus/jmpi/CIMObjectPath;"
4438 "Ljava/lang/String;Ljava/lang/String;"
4439 "Ljava/lang/String;ZZ[Ljava/lang/String;"
4440 ")[Lorg/pegasus/jmpi/CIMInstance;");
|
4441 mark.hamzy 1.43
4442 if (id != NULL)
4443 {
4444 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
|
4445 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4446 "handleAssociatorsRequest: "
4447 "Found METHOD_CIMASSOCIATORPROVIDER2.");
|
4448 mark.hamzy 1.43 }
4449 }
|
4450 mark.hamzy 1.24 }
4451
4452 if (id == NULL)
4453 {
|
4454 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4455 "handleAssociatorsRequest: No method found!");
|
4456 mark.hamzy 1.43
4457 PEG_METHOD_EXIT();
4458
|
4459 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
4460 CIM_ERR_FAILED,
4461 MessageLoaderParms(
|
4462 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
4463 marek 1.68 "Could not find a method for the provider based on "
4464 "InterfaceType."));
|
4465 mark.hamzy 1.23 }
|
4466 mark.hamzy 1.24
|
4467 schuur 1.1 JMPIjvm::checkException(env);
4468
|
4469 mark.hamzy 1.24 switch (eMethodFound)
4470 {
|
4471 mark.hamzy 1.43 case METHOD_CIMASSOCIATORPROVIDER:
|
4472 mark.hamzy 1.24 {
|
4473 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
4474 CIMObjectPath*,
4475 jlong,
4476 assocPath);
4477 jobject jAssociationName = env->NewObject(
4478 jv->CIMObjectPathClassRef,
4479 jv->CIMObjectPathNewJ,
4480 jAssociationNameRef);
|
4481 mark.hamzy 1.25
4482 JMPIjvm::checkException(env);
4483
|
4484 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
4485 CIMObjectPath*,
4486 jlong,
4487 objectPath);
4488 jobject jPathName = env->NewObject(
4489 jv->CIMObjectPathClassRef,
4490 jv->CIMObjectPathNewJ,
4491 jPathNameRef);
|
4492 mark.hamzy 1.43
4493 JMPIjvm::checkException(env);
4494
|
4495 marek 1.68 jstring jResultClass =
4496 env->NewStringUTF(
4497 request->resultClass.getString().getCString());
4498 jstring jRole =
4499 env->NewStringUTF(
4500 request->role.getCString());
4501 jstring jResultRole =
4502 env->NewStringUTF(
4503 request->resultRole.getCString());
|
4504 mark.hamzy 1.25
4505 JMPIjvm::checkException(env);
4506
4507 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
4508
|
4509 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
4510 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4511 "handleAssociatorsRequest: assocName = %s ",
4512 (const char*)assocPath->toString().getCString()));
4513 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4514 "handleAssociatorsRequest: pathName = %s ",
4515 (const char*)objectPath->toString().getCString()));
4516 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4517 "handleAssociatorsRequest: resultClass = %s ",
4518 (const char*)request->resultClass.getString().getCString()));
4519 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4520 "handleAssociatorsRequest: role = %s ",
4521 (const char*)request->role.getCString()));
4522 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4523 "handleAssociatorsRequest: resultRole = %s ",
4524 (const char*)request->resultRole.getCString()));
4525 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4526 "handleAssociatorsRequest: includeQualifiers = false");
4527 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4528 "handleAssociatorsRequest: includeClassOrigin = false");
|
4529 mark.hamzy 1.29 #endif
4530
|
4531 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
4532
|
4533 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
4534 (jobject)pr.jProvider,
4535 id,
4536 jAssociationName,
4537 jPathName,
4538 jResultClass,
4539 jRole,
4540 jResultRole,
4541 JMPI_INCLUDE_QUALIFIERS,
4542 request->includeClassOrigin,
4543 jPropertyList);
|
4544 mark.hamzy 1.25
|
4545 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4546 schuur 1.13
|
4547 mark.hamzy 1.23 handler.processing();
|
4548 mark.hamzy 1.45 if (jAr) {
4549 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4550 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4551 schuur 1.1
|
4552 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
4553 mark.hamzy 1.24
|
4554 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4555 schuur 1.13
|
4556 marek 1.68 jlong jciRetRef = env->CallLongMethod(
4557 jciRet,
4558 JMPIjvm::jv.CIMInstanceCInst);
|
4559 schuur 1.13
|
4560 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4561 schuur 1.13
|
4562 marek 1.68 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
4563 jlong,
4564 CIMInstance*,
4565 jciRetRef);
4566 CIMClass cls;
|
4567 mark.hamzy 1.40
4568 try
4569 {
|
4570 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4571 "handleAssociatorsRequest: "
4572 "enter(METHOD_CIMASSOCIATORPROVIDER): "
4573 "cimom_handle->getClass(%s).",
4574 (const char*)ciRet->
4575 getClassName().getString().getCString()
4576 ));
4577
|
4578 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
4579
4580 cls = pr._cimom_handle->getClass(context,
4581 request->nameSpace,
4582 ciRet->getClassName(),
4583 false,
4584 true,
4585 true,
4586 CIMPropertyList());
|
4587 thilo.boehm 1.69
4588 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4589 "handleAssociatorsRequest: "
4590 "exit(METHOD_CIMASSOCIATORPROVIDER): "
4591 "cimom_handle->getClass(%s).",
4592 (const char*)ciRet->
4593 getClassName().getString().getCString()
4594 ));
4595
|
4596 mark.hamzy 1.40 }
4597 catch (CIMException e)
4598 {
|
4599 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4600 "handleAssociatorsRequest: "
4601 "Caught CIMExcetion(METHOD_CIMASSOCIATORPROVIDER) "
4602 "during cimom_handle->getClass(%s): %s ",
4603 (const char*)ciRet->
4604 getClassName().getString().getCString(),
4605 (const char*)e.getMessage().getCString()
4606 ));
4607
4608 PEG_METHOD_EXIT();
|
4609 mark.hamzy 1.40 throw;
4610 }
4611
|
4612 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
4613 CIMObjectPath iop = ciRet->buildPath(cls);
|
4614 mark.hamzy 1.24
|
4615 mark.hamzy 1.27 JMPIjvm::checkException(env);
4616
|
4617 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
4618 mark.hamzy 1.29 ciRet->setPath(iop);
|
4619 schuur 1.13
|
4620 mark.hamzy 1.29 handler.deliver(*ciRet);
|
4621 mark.hamzy 1.23 }
4622 }
|
4623 mark.hamzy 1.24 handler.complete();
4624 break;
|
4625 mark.hamzy 1.23 }
|
4626 mark.hamzy 1.24
|
4627 mark.hamzy 1.43 case METHOD_CIMASSOCIATORPROVIDER2:
|
4628 mark.hamzy 1.24 {
|
4629 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
4630 OperationContext*,
4631 jlong,
4632 &request->operationContext);
4633 jobject joc = env->NewObject(
4634 jv->OperationContextClassRef,
4635 jv->OperationContextNewJ,
4636 jocRef);
4637
4638 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
4639 CIMObjectPath*,
4640 jlong,
4641 assocPath);
4642 jobject jAssociationName = env->NewObject(
4643 jv->CIMObjectPathClassRef,
4644 jv->CIMObjectPathNewJ,
4645 jAssociationNameRef);
|
4646 mark.hamzy 1.25
4647 JMPIjvm::checkException(env);
4648
|
4649 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
4650 CIMObjectPath*,
4651 jlong,
4652 objectPath);
4653 jobject jPathName = env->NewObject(
4654 jv->CIMObjectPathClassRef,
4655 jv->CIMObjectPathNewJ,
4656 jPathNameRef);
|
4657 mark.hamzy 1.24
4658 JMPIjvm::checkException(env);
4659
|
4660 marek 1.68 jstring jResultClass =
4661 env->NewStringUTF(
4662 request->resultClass.getString().getCString());
4663 jstring jRole =
4664 env->NewStringUTF(request->role.getCString());
4665 jstring jResultRole =
4666 env->NewStringUTF(request->resultRole.getCString());
|
4667 mark.hamzy 1.25
4668 JMPIjvm::checkException(env);
4669
4670 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
4671
|
4672 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
4673 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4674 "handleAssociatorsRequest: assocName = %s ",
4675 (const char*)assocPath->toString().getCString()));
4676 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4677 "handleAssociatorsRequest: pathName = %s ",
4678 (const char*)objectPath->toString().getCString()));
4679 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4680 "handleAssociatorsRequest: resultClass = %s ",
4681 (const char*)request->resultClass.getString().getCString()));
4682 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4683 "handleAssociatorsRequest: role = %s ",
4684 (const char*)request->role.getCString()));
4685 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4686 "handleAssociatorsRequest: resultRole = %s ",
4687 (const char*)request->resultRole.getCString()));
4688 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4689 "handleAssociatorsRequest: includeQualifiers = false");
4690 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4691 "handleAssociatorsRequest: includeClassOrigin = false");
|
4692 mark.hamzy 1.29 #endif
4693
|
4694 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
4695
|
4696 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
4697 (jobject)pr.jProvider,
4698 id,
4699 joc,
4700 jAssociationName,
4701 jPathName,
4702 jResultClass,
4703 jRole,
4704 jResultRole,
4705 JMPI_INCLUDE_QUALIFIERS,
4706 request->includeClassOrigin,
4707 jPropertyList);
|
4708 mark.hamzy 1.25
|
4709 mark.hamzy 1.23 JMPIjvm::checkException(env);
4710
|
4711 mark.hamzy 1.43 if (joc)
4712 {
|
4713 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
4714 mark.hamzy 1.43
4715 JMPIjvm::checkException(env);
4716 }
4717
|
4718 mark.hamzy 1.23 handler.processing();
|
4719 mark.hamzy 1.45 if (jAr) {
4720 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4721 mark.hamzy 1.43 JMPIjvm::checkException(env);
4722
|
4723 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
4724 mark.hamzy 1.43
|
4725 mark.hamzy 1.23 JMPIjvm::checkException(env);
4726
|
4727 marek 1.68 jlong jciRetRef = env->CallLongMethod(
4728 jciRet,
4729 JMPIjvm::jv.CIMInstanceCInst);
|
4730 mark.hamzy 1.24
|
4731 mark.hamzy 1.23 JMPIjvm::checkException(env);
4732
|
4733 marek 1.68 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
4734 jlong,
4735 CIMInstance*,
4736 jciRetRef);
4737 CIMClass cls;
|
4738 mark.hamzy 1.40
4739 try
4740 {
|
4741 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4742 "handleAssociatorsRequest: "
4743 "enter(METHOD_CIMASSOCIATORPROVIDER2): "
4744 "cimom_handle->getClass(%s).",
4745 (const char*)ciRet->
4746 getClassName().getString().getCString()
4747 ));
4748
|
4749 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
4750
4751 cls = pr._cimom_handle->getClass(context,
4752 request->nameSpace,
4753 ciRet->getClassName(),
4754 false,
4755 true,
4756 true,
4757 CIMPropertyList());
|
4758 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4759 "handleAssociatorsRequest: "
4760 "exit(METHOD_CIMASSOCIATORPROVIDER2): "
4761 "cimom_handle->getClass(%s).",
4762 (const char*)ciRet->
4763 getClassName().getString().getCString()
4764 ));
|
4765 mark.hamzy 1.40 }
4766 catch (CIMException e)
4767 {
|
4768 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4769 "handleAssociatorsRequest: "
4770 "Caught CIMExcetion(METHOD_CIMASSOCIATORPROVIDER2) "
4771 "during cimom_handle->getClass(%s): %s ",
4772 (const char*)ciRet->
4773 getClassName().getString().getCString(),
4774 (const char*)e.getMessage().getCString()
4775 ));
4776
4777 PEG_METHOD_EXIT();
|
4778 mark.hamzy 1.40 throw;
4779 }
4780
|
4781 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
4782 CIMObjectPath iop = ciRet->buildPath(cls);
|
4783 mark.hamzy 1.24
|
4784 mark.hamzy 1.27 JMPIjvm::checkException(env);
4785
|
4786 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
4787 mark.hamzy 1.29 ciRet->setPath(iop);
|
4788 schuur 1.13
|
4789 mark.hamzy 1.29 handler.deliver(*ciRet);
|
4790 mark.hamzy 1.23 }
4791 }
|
4792 mark.hamzy 1.24 handler.complete();
4793 break;
4794 }
4795
|
4796 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
4797 mark.hamzy 1.24 {
|
4798 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
4799 OperationContext*,
4800 jlong,
4801 &request->operationContext);
4802 jobject joc = env->NewObject(
4803 jv->OperationContextClassRef,
4804 jv->OperationContextNewJ,
4805 jocRef);
4806
4807 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
4808 CIMObjectPath*,
4809 jlong,
4810 assocPath);
4811 jobject jAssociationName = env->NewObject(
4812 jv->CIMObjectPathClassRef,
4813 jv->CIMObjectPathNewJ,
4814 jAssociationNameRef);
|
4815 schuur 1.13
|
4816 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4817 schuur 1.1
|
4818 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
4819 CIMObjectPath*,
4820 jlong,
4821 objectPath);
4822 jobject jPathName = env->NewObject(
4823 jv->CIMObjectPathClassRef,
4824 jv->CIMObjectPathNewJ,
4825 jPathNameRef);
|
4826 w.white 1.31
|
4827 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4828 schuur 1.13
|
4829 marek 1.68 jstring jResultClass =
4830 env->NewStringUTF(
4831 request->resultClass.getString().getCString());
4832 jstring jRole =
4833 env->NewStringUTF(request->role.getCString());
4834 jstring jResultRole =
4835 env->NewStringUTF(request->resultRole.getCString());
|
4836 mark.hamzy 1.23
|
4837 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4838 schuur 1.1
|
4839 mark.hamzy 1.43 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
4840 schuur 1.13
|
4841 mark.hamzy 1.43 #ifdef PEGASUS_DEBUG
|
4842 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4843 "handleAssociatorsRequest: assocName = %s ",
4844 (const char*)assocPath->toString().getCString()));
4845 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4846 "handleAssociatorsRequest: pathName = %s ",
4847 (const char*)objectPath->toString().getCString()));
4848 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4849 "handleAssociatorsRequest: resultClass = %s ",
4850 (const char*)request->resultClass.getString().getCString()));
4851 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4852 "handleAssociatorsRequest: role = %s ",
4853 (const char*)request->role.getCString()));
4854 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4855 "handleAssociatorsRequest: resultRole = %s ",
4856 (const char*)request->resultRole.getCString()));
4857 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4858 "handleAssociatorsRequest: includeQualifiers = false");
4859 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4860 "handleAssociatorsRequest: includeClassOrigin = false");
|
4861 mark.hamzy 1.43 #endif
|
4862 schuur 1.1
|
4863 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
4864
|
4865 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
4866 (jobject)pr.jProvider,
4867 id,
4868 joc,
4869 jAssociationName,
4870 jPathName,
4871 jResultClass,
4872 jRole,
4873 jResultRole,
4874 JMPI_INCLUDE_QUALIFIERS,
4875 request->includeClassOrigin,
4876 jPropertyList);
|
4877 mark.hamzy 1.23
|
4878 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4879 mark.hamzy 1.23
|
4880 mark.hamzy 1.43 if (joc)
4881 {
|
4882 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
4883 schuur 1.1
|
4884 mark.hamzy 1.43 JMPIjvm::checkException(env);
4885 }
|
4886 schuur 1.1
|
4887 mark.hamzy 1.43 handler.processing();
4888 if (jVec) {
|
4889 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
4890 i<m;
4891 i++)
4892 {
|
4893 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4894 schuur 1.1
|
4895 marek 1.68 jobject jciRet = env->CallObjectMethod(
4896 jVec,
4897 JMPIjvm::jv.VectorElementAt,
4898 i);
|
4899 schuur 1.1
|
4900 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4901 schuur 1.1
|
4902 marek 1.68 jlong jciRetRef = env->CallLongMethod(
4903 jciRet,
4904 JMPIjvm::jv.CIMInstanceCInst);
|
4905 schuur 1.1
|
4906 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4907 mark.hamzy 1.24
|
4908 marek 1.68 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
4909 jlong,
4910 CIMInstance*,
4911 jciRetRef);
4912 CIMClass cls;
|
4913 schuur 1.1
|
4914 mark.hamzy 1.43 try
4915 {
|
4916 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4917 "handleAssociatorsRequest: "
4918 "enter(METHOD_ASSOCIATORPROVIDER2): "
4919 "cimom_handle->getClass(%s).",
4920 (const char*)ciRet->
4921 getClassName().getString().getCString()
4922 ));
4923
|
4924 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
4925
|
4926 marek 1.68 cls = pr._cimom_handle->getClass(
4927 context,
4928 request->nameSpace,
4929 ciRet->getClassName(),
4930 false,
4931 true,
4932 true,
4933 CIMPropertyList());
|
4934 thilo.boehm 1.69
4935 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
4936 "handleAssociatorsRequest: "
4937 "exit(METHOD_ASSOCIATORPROVIDER2): "
4938 "cimom_handle->getClass(%s).",
4939 (const char*)ciRet->
4940 getClassName().getString().getCString()
4941 ));
4942
|
4943 mark.hamzy 1.43 }
4944 catch (CIMException e)
4945 {
|
4946 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4947 "handleAssociatorsRequest: "
4948 "Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER2) "
4949 "during cimom_handle->getClass(%s): %s ",
4950 (const char*)ciRet->
4951 getClassName().getString().getCString(),
4952 (const char*)e.getMessage().getCString()
4953 ));
4954
4955 PEG_METHOD_EXIT();
|
4956 mark.hamzy 1.43 throw;
4957 }
4958
4959 const CIMObjectPath& op = ciRet->getPath();
4960 CIMObjectPath iop = ciRet->buildPath(cls);
4961
4962 JMPIjvm::checkException(env);
4963
4964 iop.setNameSpace(op.getNameSpace());
4965 ciRet->setPath(iop);
4966
4967 handler.deliver(*ciRet);
4968 }
4969 }
4970 handler.complete();
4971 break;
4972 }
4973
4974 case METHOD_ASSOCIATORPROVIDER:
4975 {
|
4976 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
4977 CIMObjectPath*,
4978 jlong,
4979 assocPath);
4980 jobject jAssociationName = env->NewObject(
4981 jv->CIMObjectPathClassRef,
4982 jv->CIMObjectPathNewJ,
4983 jAssociationNameRef);
|
4984 mark.hamzy 1.43
4985 JMPIjvm::checkException(env);
4986
|
4987 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
4988 CIMObjectPath*,
4989 jlong,
4990 objectPath);
4991 jobject jPathName = env->NewObject(
4992 jv->CIMObjectPathClassRef,
4993 jv->CIMObjectPathNewJ,
4994 jPathNameRef);
|
4995 mark.hamzy 1.43
4996 JMPIjvm::checkException(env);
4997
|
4998 marek 1.68 jstring jResultClass =
4999 env->NewStringUTF(
5000 request->resultClass.getString().getCString());
5001 jstring jRole =
5002 env->NewStringUTF(request->role.getCString());
5003 jstring jResultRole =
5004 env->NewStringUTF(request->resultRole.getCString());
|
5005 mark.hamzy 1.43
5006 JMPIjvm::checkException(env);
5007
5008 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
5009
5010 #ifdef PEGASUS_DEBUG
|
5011 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5012 "handleAssociatorsRequest: assocName = %s ",
5013 (const char*)assocPath->toString().getCString()));
5014 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5015 "handleAssociatorsRequest: pathName = %s ",
5016 (const char*)objectPath->toString().getCString()));
5017 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5018 "handleAssociatorsRequest: resultClass = %s ",
5019 (const char*)request->resultClass.getString().getCString()));
5020 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5021 "handleAssociatorsRequest: role = %s ",
5022 (const char*)request->role.getCString()));
5023 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5024 "handleAssociatorsRequest: resultRole = %s ",
5025 (const char*)request->resultRole.getCString()));
5026 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5027 "handleAssociatorsRequest: includeQualifiers = false");
5028 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5029 "handleAssociatorsRequest: includeClassOrigin = false");
|
5030 mark.hamzy 1.43 #endif
5031
|
5032 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
5033
|
5034 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
5035 (jobject)pr.jProvider,
5036 id,
5037 jAssociationName,
5038 jPathName,
5039 jResultClass,
5040 jRole,
5041 jResultRole,
5042 JMPI_INCLUDE_QUALIFIERS,
5043 request->includeClassOrigin,
5044 jPropertyList);
|
5045 mark.hamzy 1.43
5046 JMPIjvm::checkException(env);
5047
5048 handler.processing();
5049 if (jVec) {
|
5050 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
5051 i<m;
5052 i++)
5053 {
|
5054 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5055 marek 1.68 jobject jciRet = env->CallObjectMethod(
5056 jVec,
5057 JMPIjvm::jv.VectorElementAt,
5058 i);
|
5059 mark.hamzy 1.43
5060 JMPIjvm::checkException(env);
5061
|
5062 marek 1.68 jlong jciRetRef = env->CallLongMethod(
5063 jciRet,
5064 JMPIjvm::jv.CIMInstanceCInst);
5065 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
5066 jlong,
5067 CIMInstance*,
5068 jciRetRef);
5069 CIMClass cls;
|
5070 mark.hamzy 1.43
5071 try
5072 {
|
5073 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5074 "handleAssociatorsRequest: "
5075 "enter(METHOD_ASSOCIATORPROVIDER): "
5076 "cimom_handle->getClass(%s).",
5077 (const char*)ciRet->
5078 getClassName().getString().getCString()
5079 ));
5080
|
5081 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
5082
5083 cls = pr._cimom_handle->getClass(context,
5084 request->nameSpace,
5085 ciRet->getClassName(),
5086 false,
5087 true,
5088 true,
5089 CIMPropertyList());
|
5090 thilo.boehm 1.69
5091 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5092 "handleAssociatorsRequest: "
5093 "exit(METHOD_ASSOCIATORPROVIDER): "
5094 "cimom_handle->getClass(%s).",
5095 (const char*)ciRet->
5096 getClassName().getString().getCString()
5097 ));
|
5098 mark.hamzy 1.43 }
5099 catch (CIMException e)
5100 {
|
5101 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
5102 "handleAssociatorsRequest: "
5103 "Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER) "
5104 "during cimom_handle->getClass(%s): %s ",
5105 (const char*)ciRet->
5106 getClassName().getString().getCString(),
5107 (const char*)e.getMessage().getCString()
5108 ));
5109
5110 PEG_METHOD_EXIT();
|
5111 mark.hamzy 1.43 throw;
5112 }
5113
|
5114 marek 1.68 const CIMObjectPath& op = ciRet->getPath();
5115 CIMObjectPath iop = ciRet->buildPath(cls);
|
5116 mark.hamzy 1.43
5117 JMPIjvm::checkException(env);
5118
5119 iop.setNameSpace(op.getNameSpace());
5120 ciRet->setPath(iop);
5121
5122 handler.deliver(*ciRet);
5123 }
5124 }
5125 handler.complete();
5126 break;
5127 }
5128
5129 case METHOD_UNKNOWN:
5130 {
|
5131 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
5132 "handleAssociatorsRequest: Unknown method provider!");
|
5133 mark.hamzy 1.43 break;
5134 }
5135 }
5136 }
5137 HandlerCatch(handler);
5138
5139 if (env) JMPIjvm::detachThread();
5140
5141 PEG_METHOD_EXIT();
5142
5143 return(response);
5144 }
5145
|
5146 marek 1.68 Message * JMPIProviderManager::handleAssociatorNamesRequest(
5147 const Message * message) throw()
|
5148 mark.hamzy 1.43 {
|
5149 marek 1.68 PEG_METHOD_ENTER(
5150 TRC_PROVIDERMANAGER,
5151 "JMPIProviderManager::handleAssociatorNamesRequest");
|
5152 mark.hamzy 1.43
|
5153 kumpf 1.55 HandlerIntro(AssociatorNames,message,request,response,handler);
|
5154 mark.hamzy 1.43
5155 typedef enum {
5156 METHOD_UNKNOWN = 0,
5157 METHOD_CIMASSOCIATORPROVIDER,
5158 METHOD_CIMASSOCIATORPROVIDER2,
5159 METHOD_ASSOCIATORPROVIDER,
5160 METHOD_ASSOCIATORPROVIDER2
5161 } METHOD_VERSION;
5162 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
5163 JNIEnv *env = NULL;
5164
|
5165 marek 1.68 try
5166 {
|
5167 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
5168 "handleAssociatorNamesRequest: "
5169 "name space = %s class name = %s",
5170 (const char*)request->nameSpace.getString().getCString(),
5171 (const char*)request->
5172 objectName.getClassName().getString().getCString()
5173 ));
|
5174 mark.hamzy 1.43
5175 // make target object path
|
5176 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
5177 System::getHostName(),
5178 request->nameSpace,
5179 request->objectName.getClassName(),
5180 request->objectName.getKeyBindings());
5181 CIMObjectPath *assocPath = new CIMObjectPath(
5182 System::getHostName(),
5183 request->nameSpace,
5184 request->assocClass.getString());
|
5185 mark.hamzy 1.43
5186 // resolve provider name
5187 ProviderName name = _resolveProviderName(
5188 request->operationContext.get(ProviderIdContainer::NAME));
5189
5190 // get cached or load new provider module
|
5191 marek 1.68 JMPIProvider::OpProviderHolder ph =
5192 providerManager.getProvider(
5193 name.getPhysicalName(),
5194 name.getLogicalName(),
5195 String::EMPTY);
|
5196 mark.hamzy 1.43
5197 // forward request
5198 JMPIProvider &pr = ph.GetProvider();
5199
|
5200 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
5201 "handleAssociatorNamesRequest: "
5202 "Calling provider: %s, role: %s, aCls: %s",
5203 (const char*)pr.getName().getCString(),
5204 (const char*)request->role.getCString(),
5205 (const char*)request->assocClass.getString().getCString()
5206 ));
|
5207 mark.hamzy 1.43
5208 JvmVector *jv = 0;
5209
5210 env = JMPIjvm::attachThread(&jv);
5211
5212 if (!env)
5213 {
|
5214 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
5215 "handleAssociatorNamesRequest: "
5216 "Could not initialize the JVM (Java Virtual Machine) "
5217 "runtime environment.");
5218
|
5219 mark.hamzy 1.43 PEG_METHOD_EXIT();
|
5220 mark.hamzy 1.37
|
5221 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
5222 CIM_ERR_FAILED,
5223 MessageLoaderParms(
|
5224 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
5225 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
5226 "runtime environment."));
|
5227 mark.hamzy 1.37 }
5228
|
5229 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
5230
|
5231 mark.hamzy 1.43 jmethodID id = NULL;
5232 String interfaceType;
5233 String interfaceVersion;
5234
|
5235 marek 1.68 getInterfaceType(
5236 request->operationContext.get(ProviderIdContainer::NAME),
5237 interfaceType,
5238 interfaceVersion);
|
5239 mark.hamzy 1.43
5240 if (interfaceType == "JMPI")
5241 {
|
5242 marek 1.68 id = env->GetMethodID(
5243 (jclass)pr.jProviderClass,
5244 "associatorNames",
5245 "(Lorg/pegasus/jmpi/CIMObjectPath;"
5246 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
5247 "Ljava/lang/String;Ljava/lang/String;)"
5248 "Ljava/util/Vector;");
|
5249 mark.hamzy 1.43
5250 if (id != NULL)
5251 {
5252 eMethodFound = METHOD_ASSOCIATORPROVIDER;
|
5253 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5254 "handleAssociatorNamesRequest: "
5255 "Found METHOD_ASSOCIATORPROVIDER.");
|
5256 mark.hamzy 1.43 }
|
5257 mark.hamzy 1.24
|
5258 mark.hamzy 1.43 if (id == NULL)
5259 {
5260 env->ExceptionClear();
|
5261 marek 1.68 id = env->GetMethodID(
5262 (jclass)pr.jProviderClass,
5263 "associatorNames",
5264 "(Lorg/pegasus/jmpi/CIMObjectPath;"
5265 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
5266 "Ljava/lang/String;Ljava/lang/String;)"
5267 "[Lorg/pegasus/jmpi/CIMObjectPath;");
|
5268 mark.hamzy 1.43
5269 if (id != NULL)
5270 {
5271 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
|
5272 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5273 "handleAssociatorNamesRequest: "
5274 "Found METHOD_CIMASSOCIATORPROVIDER.");
|
5275 mark.hamzy 1.43 }
5276 }
5277 }
5278 else if (interfaceType == "JMPIExperimental")
|
5279 mark.hamzy 1.24 {
|
5280 marek 1.68 id = env->GetMethodID(
5281 (jclass)pr.jProviderClass,
5282 "associatorNames",
5283 "(Lorg/pegasus/jmpi/OperationContext;"
5284 "Lorg/pegasus/jmpi/CIMObjectPath;"
5285 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
5286 "Ljava/lang/String;Ljava/lang/String;)"
5287 "Ljava/util/Vector;");
|
5288 mark.hamzy 1.24
|
5289 mark.hamzy 1.43 if (id != NULL)
5290 {
5291 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
|
5292 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5293 "handleAssociatorNamesRequest: "
5294 "Found METHOD_ASSOCIATORPROVIDER2.");
|
5295 mark.hamzy 1.43 }
|
5296 mark.hamzy 1.24
|
5297 mark.hamzy 1.43 if (id == NULL)
5298 {
5299 env->ExceptionClear();
|
5300 mark.hamzy 1.24
|
5301 marek 1.68 id = env->GetMethodID(
5302 (jclass)pr.jProviderClass,
5303 "associatorNames",
5304 "(Lorg/pegasus/jmpi/OperationContext;"
5305 "Lorg/pegasus/jmpi/CIMObjectPath;"
5306 "Lorg/pegasus/jmpi/CIMObjectPath;"
5307 "Ljava/lang/String;Ljava/lang/String;"
5308 "Ljava/lang/String;)["
5309 "Lorg/pegasus/jmpi/CIMObjectPath;");
|
5310 mark.hamzy 1.43
5311 if (id != NULL)
5312 {
5313 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
|
5314 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5315 "handleAssociatorNamesRequest: "
5316 "Found METHOD_CIMASSOCIATORPROVIDER2.");
|
5317 mark.hamzy 1.43 }
5318 }
|
5319 mark.hamzy 1.24 }
|
5320 schuur 1.13
|
5321 mark.hamzy 1.24 if (id == NULL)
5322 {
|
5323 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
5324 "handleAssociatorNames: No method found!");
|
5325 mark.hamzy 1.43
5326 PEG_METHOD_EXIT();
5327
|
5328 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
5329 CIM_ERR_FAILED,
5330 MessageLoaderParms(
|
5331 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
5332 marek 1.68 "Could not find a method for the provider based on "
5333 "InterfaceType."));
|
5334 mark.hamzy 1.23 }
|
5335 mark.hamzy 1.24
|
5336 schuur 1.1 JMPIjvm::checkException(env);
5337
|
5338 mark.hamzy 1.24 switch (eMethodFound)
5339 {
|
5340 mark.hamzy 1.43 case METHOD_CIMASSOCIATORPROVIDER:
5341 {
|
5342 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
5343 CIMObjectPath*,
5344 jlong,
5345 assocPath);
5346 jobject jAssociationName = env->NewObject(
5347 jv->CIMObjectPathClassRef,
5348 jv->CIMObjectPathNewJ,
5349 jAssociationNameRef);
|
5350 mark.hamzy 1.43
5351 JMPIjvm::checkException(env);
5352
|
5353 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
5354 CIMObjectPath*,
5355 jlong,
5356 objectPath);
5357 jobject jPathName = env->NewObject(
5358 jv->CIMObjectPathClassRef,
5359 jv->CIMObjectPathNewJ,
5360 jPathNameRef);
|
5361 mark.hamzy 1.43
5362 JMPIjvm::checkException(env);
5363
|
5364 marek 1.68 jstring jResultClass =
5365 env->NewStringUTF(
5366 request->resultClass.getString().getCString());
5367 jstring jRole =
5368 env->NewStringUTF(request->role.getCString());
5369 jstring jResultRole =
5370 env->NewStringUTF(request->resultRole.getCString());
|
5371 mark.hamzy 1.43
5372 JMPIjvm::checkException(env);
5373
5374 #ifdef PEGASUS_DEBUG
|
5375 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5376 "handleAssociatorNamesRequest: assocName = %s ",
5377 (const char*)assocPath->toString().getCString()));
5378 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5379 "handleAssociatorNamesRequest: resultClass = %s ",
5380 (const char*)request->resultClass.getString().getCString()));
5381 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5382 "handleAssociatorNamesRequest: role = %s ",
5383 (const char*)request->role.getCString()));
5384 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5385 "handleAssociatorNamesRequest: resultRole = %s ",
5386 (const char*)request->resultRole.getCString()));
|
5387 mark.hamzy 1.43 #endif
5388
|
5389 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
5390
|
5391 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
5392 (jobject)pr.jProvider,
5393 id,
5394 jAssociationName,
5395 jPathName,
5396 jResultClass,
5397 jRole,
5398 jResultRole);
|
5399 mark.hamzy 1.43
5400 JMPIjvm::checkException(env);
5401
5402 handler.processing();
|
5403 mark.hamzy 1.45 if (jAr) {
5404 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
5405 mark.hamzy 1.43 JMPIjvm::checkException(env);
5406
|
5407 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
5408 mark.hamzy 1.43
5409 JMPIjvm::checkException(env);
5410
|
5411 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
5412 jcopRet,
5413 JMPIjvm::jv.CIMObjectPathCInst);
5414 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
5415 jlong,
5416 CIMObjectPath*,
5417 jcopRetRef);
|
5418 mark.hamzy 1.43
5419 JMPIjvm::checkException(env);
5420
5421 handler.deliver(*copRet);
5422 }
5423 }
5424 handler.complete();
5425 break;
5426 }
5427
5428 case METHOD_CIMASSOCIATORPROVIDER2:
|
5429 mark.hamzy 1.24 {
|
5430 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
5431 OperationContext*,
5432 jlong,
5433 &request->operationContext);
5434 jobject joc = env->NewObject(
5435 jv->OperationContextClassRef,
5436 jv->OperationContextNewJ,
5437 jocRef);
5438 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
5439 CIMObjectPath*,
5440 jlong,
5441 assocPath);
5442 jobject jAssociationName = env->NewObject(
5443 jv->CIMObjectPathClassRef,
5444 jv->CIMObjectPathNewJ,
5445 jAssociationNameRef);
|
5446 mark.hamzy 1.25
5447 JMPIjvm::checkException(env);
5448
|
5449 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
5450 CIMObjectPath*,
5451 jlong,
5452 objectPath);
5453 jobject jPathName = env->NewObject(
5454 jv->CIMObjectPathClassRef,
5455 jv->CIMObjectPathNewJ,
5456 jPathNameRef);
|
5457 mark.hamzy 1.43
5458 JMPIjvm::checkException(env);
5459
|
5460 marek 1.68 jstring jResultClass =
5461 env->NewStringUTF(
5462 request->resultClass.getString().getCString());
5463 jstring jRole =
5464 env->NewStringUTF(request->role.getCString());
5465 jstring jResultRole =
5466 env->NewStringUTF(request->resultRole.getCString());
|
5467 mark.hamzy 1.25
5468 JMPIjvm::checkException(env);
5469
|
5470 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
5471 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5472 "handleAssociatorNamesRequest: assocName = %s ",
5473 (const char*)assocPath->toString().getCString()));
5474 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5475 "handleAssociatorNamesRequest: resultClass = %s ",
5476 (const char*)request->resultClass.getString().getCString()));
5477 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5478 "handleAssociatorNamesRequest: role = %s ",
5479 (const char*)request->role.getCString()));
5480 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5481 "handleAssociatorNamesRequest: resultRole = %s ",
5482 (const char*)request->resultRole.getCString()));
|
5483 mark.hamzy 1.29 #endif
5484
|
5485 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
5486
|
5487 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
5488 (jobject)pr.jProvider,
5489 id,
5490 joc,
5491 jAssociationName,
5492 jPathName,
5493 jResultClass,
5494 jRole,
5495 jResultRole);
|
5496 mark.hamzy 1.25
|
5497 mark.hamzy 1.23 JMPIjvm::checkException(env);
5498
|
5499 mark.hamzy 1.43 if (joc)
5500 {
|
5501 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
5502 mark.hamzy 1.43
5503 JMPIjvm::checkException(env);
5504 }
5505
|
5506 mark.hamzy 1.23 handler.processing();
|
5507 mark.hamzy 1.45 if (jAr) {
5508 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
5509 mark.hamzy 1.23 JMPIjvm::checkException(env);
5510
|
5511 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
5512 mark.hamzy 1.24
|
5513 mark.hamzy 1.23 JMPIjvm::checkException(env);
5514
|
5515 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
5516 jcopRet,
5517 JMPIjvm::jv.CIMObjectPathCInst);
5518 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
5519 jlong,
5520 CIMObjectPath*,
5521 jcopRetRef);
|
5522 mark.hamzy 1.23
5523 JMPIjvm::checkException(env);
5524
|
5525 mark.hamzy 1.29 handler.deliver(*copRet);
|
5526 mark.hamzy 1.23 }
5527 }
5528 handler.complete();
|
5529 mark.hamzy 1.24 break;
|
5530 mark.hamzy 1.23 }
|
5531 mark.hamzy 1.24
|
5532 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
5533 {
|
5534 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
5535 CIMObjectPath*,
5536 jlong,
5537 assocPath);
5538 jobject jAssociationName = env->NewObject(
5539 jv->CIMObjectPathClassRef,
5540 jv->CIMObjectPathNewJ,
5541 jAssociationNameRef);
|
5542 mark.hamzy 1.43
5543 JMPIjvm::checkException(env);
5544
|
5545 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
5546 CIMObjectPath*,
5547 jlong,
5548 objectPath);
5549 jobject jPathName = env->NewObject(
5550 jv->CIMObjectPathClassRef,
5551 jv->CIMObjectPathNewJ,
5552 jPathNameRef);
|
5553 mark.hamzy 1.43
5554 JMPIjvm::checkException(env);
5555
|
5556 marek 1.68 jstring jResultClass =
5557 env->NewStringUTF(
5558 request->resultClass.getString().getCString());
5559 jstring jRole =
5560 env->NewStringUTF(request->role.getCString());
5561 jstring jResultRole =
5562 env->NewStringUTF(request->resultRole.getCString());
|
5563 mark.hamzy 1.43
5564 JMPIjvm::checkException(env);
5565
5566 #ifdef PEGASUS_DEBUG
|
5567 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5568 "handleAssociatorNamesRequest: assocName = %s ",
5569 (const char*)assocPath->toString().getCString()));
5570 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5571 "handleAssociatorNamesRequest: pathName = %s ",
5572 (const char*)objectPath->toString().getCString()));
5573 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5574 "handleAssociatorNamesRequest: resultClass = %s ",
5575 (const char*)request->resultClass.getString().getCString()));
5576 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5577 "handleAssociatorNamesRequest: role = %s ",
5578 (const char*)request->role.getCString()));
5579 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5580 "handleAssociatorNamesRequest: resultRole = %s ",
5581 (const char*)request->resultRole.getCString()));
|
5582 mark.hamzy 1.43 #endif
5583
|
5584 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
5585
|
5586 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
5587 (jobject)pr.jProvider,
5588 id,
5589 jAssociationName,
5590 jPathName,
5591 jResultClass,
5592 jRole,
5593 jResultRole);
|
5594 mark.hamzy 1.43
5595 JMPIjvm::checkException(env);
5596
5597 handler.processing();
5598 if (jVec) {
|
5599 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
5600 i<m; i++)
5601 {
|
5602 mark.hamzy 1.43 JMPIjvm::checkException(env);
5603
|
5604 marek 1.68 jobject jcopRet = env->CallObjectMethod(
5605 jVec,
5606 JMPIjvm::jv.VectorElementAt,
5607 i);
|
5608 mark.hamzy 1.43
5609 JMPIjvm::checkException(env);
5610
|
5611 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
5612 jcopRet,
5613 JMPIjvm::jv.CIMObjectPathCInst);
5614 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
5615 jlong,
5616 CIMObjectPath*,
5617 jcopRetRef);
|
5618 mark.hamzy 1.43
5619 JMPIjvm::checkException(env);
5620
5621 handler.deliver(*copRet);
5622 }
5623 }
5624 handler.complete();
5625 break;
5626 }
5627
5628 case METHOD_ASSOCIATORPROVIDER2:
|
5629 mark.hamzy 1.24 {
|
5630 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
5631 OperationContext*,
5632 jlong,
5633 &request->operationContext);
5634 jobject joc = env->NewObject(
5635 jv->OperationContextClassRef,
5636 jv->OperationContextNewJ,
5637 jocRef);
5638
5639 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
5640 CIMObjectPath*,
5641 jlong,
5642 assocPath);
5643 jobject jAssociationName = env->NewObject(
5644 jv->CIMObjectPathClassRef,
5645 jv->CIMObjectPathNewJ,
5646 jAssociationNameRef);
|
5647 mark.hamzy 1.25
5648 JMPIjvm::checkException(env);
5649
|
5650 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
5651 CIMObjectPath*,
5652 jlong,
5653 objectPath);
5654 jobject jPathName = env->NewObject(
5655 jv->CIMObjectPathClassRef,
5656 jv->CIMObjectPathNewJ,
5657 jPathNameRef);
|
5658 mark.hamzy 1.24
5659 JMPIjvm::checkException(env);
5660
|
5661 marek 1.68 jstring jResultClass =
5662 env->NewStringUTF(
5663 request->resultClass.getString().getCString());
5664 jstring jRole =
5665 env->NewStringUTF(request->role.getCString());
5666 jstring jResultRole =
5667 env->NewStringUTF(request->resultRole.getCString());
|
5668 mark.hamzy 1.25
5669 JMPIjvm::checkException(env);
5670
|
5671 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
5672 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5673 "handleAssociatorNamesRequest: assocName = %s ",
5674 (const char*)assocPath->toString().getCString()));
5675 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5676 "handleAssociatorNamesRequest: pathName = %s ",
5677 (const char*)objectPath->toString().getCString()));
5678 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5679 "handleAssociatorNamesRequest: resultClass = %s ",
5680 (const char*)request->resultClass.getString().getCString()));
5681 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5682 "handleAssociatorNamesRequest: role = %s ",
5683 (const char*)request->role.getCString()));
5684 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5685 "handleAssociatorNamesRequest: resultRole = %s ",
5686 (const char*)request->resultRole.getCString()));
|
5687 mark.hamzy 1.29 #endif
5688
|
5689 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
5690
|
5691 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
5692 (jobject)pr.jProvider,
5693 id,
5694 joc,
5695 jAssociationName,
5696 jPathName,
5697 jResultClass,
5698 jRole,
5699 jResultRole);
|
5700 mark.hamzy 1.25
|
5701 mark.hamzy 1.23 JMPIjvm::checkException(env);
5702
|
5703 mark.hamzy 1.43 if (joc)
5704 {
|
5705 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
5706 mark.hamzy 1.43
5707 JMPIjvm::checkException(env);
5708 }
5709
|
5710 mark.hamzy 1.23 handler.processing();
|
5711 mark.hamzy 1.24 if (jVec) {
|
5712 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
5713 i<m; i++)
5714 {
|
5715 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
5716 schuur 1.13
|
5717 marek 1.68 jobject jcopRet = env->CallObjectMethod(
5718 jVec,
5719 JMPIjvm::jv.VectorElementAt,
5720 i);
|
5721 mark.hamzy 1.24
|
5722 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
5723 schuur 1.13
|
5724 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
5725 jcopRet,
5726 JMPIjvm::jv.CIMObjectPathCInst);
5727 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
5728 jlong,
5729 CIMObjectPath*,
5730 jcopRetRef);
|
5731 schuur 1.1
|
5732 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
5733 schuur 1.1
|
5734 mark.hamzy 1.29 handler.deliver(*copRet);
|
5735 mark.hamzy 1.23 }
5736 }
5737 handler.complete();
|
5738 mark.hamzy 1.24 break;
5739 }
5740
5741 case METHOD_UNKNOWN:
5742 {
|
5743 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
5744 "handleAssociatorNamesRequest: Unknown method provider!");
|
5745 mark.hamzy 1.24 break;
5746 }
|
5747 mark.hamzy 1.23 }
|
5748 schuur 1.1 }
5749 HandlerCatch(handler);
|
5750 schuur 1.12
|
5751 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
|
5752 schuur 1.12
|
5753 schuur 1.1 PEG_METHOD_EXIT();
5754
5755 return(response);
5756 }
5757
|
5758 marek 1.68 Message * JMPIProviderManager::handleReferencesRequest(
5759 const Message * message) throw()
|
5760 schuur 1.1 {
|
5761 marek 1.68 PEG_METHOD_ENTER(
5762 TRC_PROVIDERMANAGER,
5763 "JMPIProviderManager::handleReferencesRequest");
|
5764 mark.hamzy 1.23
|
5765 kumpf 1.55 HandlerIntro(References,message,request,response,handler);
|
5766 schuur 1.1
|
5767 mark.hamzy 1.24 typedef enum {
5768 METHOD_UNKNOWN = 0,
|
5769 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
5770 METHOD_CIMASSOCIATORPROVIDER2,
5771 METHOD_ASSOCIATORPROVIDER,
5772 METHOD_ASSOCIATORPROVIDER2,
|
5773 mark.hamzy 1.24 } METHOD_VERSION;
5774 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
5775 JNIEnv *env = NULL;
|
5776 schuur 1.13
|
5777 marek 1.68 try
5778 {
|
5779 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
5780 "handleReferencesRequest: "
5781 "name space = %s class name = %s",
5782 (const char*)request->nameSpace.getString().getCString(),
5783 (const char*)request->
5784 objectName.getClassName().getString().getCString()
5785 ));
|
5786 mark.hamzy 1.23
|
5787 schuur 1.1 // make target object path
|
5788 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
5789 System::getHostName(),
5790 request->nameSpace,
5791 request->objectName.getClassName(),
5792 request->objectName.getKeyBindings());
5793 CIMObjectPath *resultPath = new CIMObjectPath(
5794 System::getHostName(),
5795 request->nameSpace,
5796 request->resultClass.getString());
|
5797 schuur 1.1
5798 // resolve provider name
|
5799 kumpf 1.2 ProviderName name = _resolveProviderName(
5800 request->operationContext.get(ProviderIdContainer::NAME));
|
5801 schuur 1.1
|
5802 mark.hamzy 1.43 // get cached or load new provider module
|
5803 marek 1.68 JMPIProvider::OpProviderHolder ph =
5804 providerManager.getProvider(
5805 name.getPhysicalName(),
5806 name.getLogicalName(),
5807 String::EMPTY);
|
5808 mark.hamzy 1.43
5809 // convert arguments
5810 OperationContext context;
5811
|
5812 marek 1.68 context.insert(
5813 request->operationContext.get(IdentityContainer::NAME));
5814 context.insert(
5815 request->operationContext.get(AcceptLanguageListContainer::NAME));
5816 context.insert(
5817 request->operationContext.get(ContentLanguageListContainer::NAME));
|
5818 mark.hamzy 1.43
5819 // forward request
5820 JMPIProvider &pr = ph.GetProvider();
5821
|
5822 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
5823 "handleReferencesRequest: "
5824 "Calling provider: %s, role: %s, refCls: %s",
5825 (const char*)pr.getName().getCString(),
5826 (const char*)request->role.getCString(),
5827 (const char*)request->resultClass.getString().getCString()
5828 ));
|
5829 mark.hamzy 1.43
5830 JvmVector *jv = 0;
5831
5832 env = JMPIjvm::attachThread(&jv);
5833
5834 if (!env)
5835 {
|
5836 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
5837 "handleReferencesRequest: "
5838 "Could not initialize the JVM (Java Virtual Machine) "
5839 "runtime environment.");
5840
|
5841 mark.hamzy 1.43 PEG_METHOD_EXIT();
5842
|
5843 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
5844 CIM_ERR_FAILED,
5845 MessageLoaderParms(
|
5846 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
5847 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
5848 "runtime environment."));
|
5849 mark.hamzy 1.43 }
5850
5851 JMPIProvider::pm_service_op_lock op_lock(&pr);
5852
5853 jmethodID id = NULL;
5854 String interfaceType;
5855 String interfaceVersion;
5856
|
5857 marek 1.68 getInterfaceType(
5858 request->operationContext.get(ProviderIdContainer::NAME),
5859 interfaceType,
5860 interfaceVersion);
|
5861 mark.hamzy 1.43
5862 if (interfaceType == "JMPI")
5863 {
|
5864 marek 1.68 id = env->GetMethodID(
5865 (jclass)pr.jProviderClass,
5866 "references",
5867 "(Lorg/pegasus/jmpi/CIMObjectPath;"
5868 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
5869 "ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
5870 mark.hamzy 1.43
5871 if (id != NULL)
5872 {
5873 eMethodFound = METHOD_ASSOCIATORPROVIDER;
|
5874 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5875 "handleReferencesRequest: "
5876 "Found METHOD_ASSOCIATORPROVIDER.");
|
5877 mark.hamzy 1.43 }
5878
5879 if (id == NULL)
5880 {
5881 env->ExceptionClear();
|
5882 marek 1.68 id = env->GetMethodID(
5883 (jclass)pr.jProviderClass,
5884 "references",
5885 "(Lorg/pegasus/jmpi/CIMObjectPath;"
5886 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
5887 "ZZ[Ljava/lang/String;)"
5888 "[Lorg/pegasus/jmpi/CIMInstance;");
|
5889 mark.hamzy 1.43
5890 if (id != NULL)
5891 {
5892 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
|
5893 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5894 "handleReferencesRequest: "
5895 "Found METHOD_CIMASSOCIATORPROVIDER.");
|
5896 mark.hamzy 1.43 }
5897 }
5898 }
5899 else if (interfaceType == "JMPIExperimental")
5900 {
|
5901 marek 1.68 id = env->GetMethodID(
5902 (jclass)pr.jProviderClass,
5903 "references",
5904 "(Lorg/pegasus/jmpi/OperationContext;"
5905 "Lorg/pegasus/jmpi/CIMObjectPath;"
5906 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
5907 "ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
5908 mark.hamzy 1.43
5909 if (id != NULL)
5910 {
5911 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
|
5912 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5913 "handleReferencesRequest: "
5914 "Found METHOD_ASSOCIATORPROVIDER2.");
|
5915 mark.hamzy 1.43 }
5916
5917 if (id == NULL)
5918 {
5919 env->ExceptionClear();
|
5920 marek 1.68 id = env->GetMethodID(
5921 (jclass)pr.jProviderClass,
5922 "references",
5923 "(Lorg/pegasus/jmpi/OperationContext;"
5924 "Lorg/pegasus/jmpi/CIMObjectPath;"
5925 "Lorg/pegasus/jmpi/CIMObjectPath;"
5926 "Ljava/lang/String;ZZ[Ljava/lang/String;)"
5927 "[Lorg/pegasus/jmpi/CIMInstance;");
|
5928 mark.hamzy 1.43
5929 if (id != NULL)
5930 {
5931 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
|
5932 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5933 "handleReferencesRequest: "
5934 "Found METHOD_CIMASSOCIATORPROVIDER2.");
|
5935 mark.hamzy 1.43 }
5936 }
5937 }
5938
5939 if (id == NULL)
5940 {
|
5941 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
5942 "handleReferencesRequest: No method provider found!");
|
5943 mark.hamzy 1.43
5944 PEG_METHOD_EXIT();
5945
|
5946 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
5947 CIM_ERR_FAILED,
5948 MessageLoaderParms(
|
5949 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
5950 marek 1.68 "Could not find a method for the provider based on "
5951 "InterfaceType."));
|
5952 mark.hamzy 1.43 }
5953
5954 JMPIjvm::checkException(env);
5955
5956 switch (eMethodFound)
5957 {
5958 case METHOD_CIMASSOCIATORPROVIDER:
5959 {
|
5960 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
5961 CIMObjectPath*,
5962 jlong,
5963 resultPath);
5964 jobject jAssociationName = env->NewObject(
5965 jv->CIMObjectPathClassRef,
5966 jv->CIMObjectPathNewJ,
5967 jAssociationNameRef);
|
5968 mark.hamzy 1.43
5969 JMPIjvm::checkException(env);
5970
|
5971 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
5972 CIMObjectPath*,
5973 jlong,
5974 objectPath);
5975 jobject jPathName = env->NewObject(
5976 jv->CIMObjectPathClassRef,
5977 jv->CIMObjectPathNewJ,
5978 jPathNameRef);
|
5979 mark.hamzy 1.43
5980 JMPIjvm::checkException(env);
5981
5982 jstring jRole = env->NewStringUTF(request->role.getCString());
5983
5984 JMPIjvm::checkException(env);
5985
5986 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
5987
5988 #ifdef PEGASUS_DEBUG
|
5989 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5990 "handleReferencesRequest: assocName = %s ",
5991 (const char*)resultPath->toString().getCString()));
5992 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5993 "handleReferencesRequest: role = %s ",
5994 (const char*)request->role.getCString()));
5995 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5996 "handleReferencesRequest: includeQualifiers = false");
5997 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
5998 "handleReferencesRequest: includeClassOrigin = false");
|
5999 mark.hamzy 1.43 #endif
6000
|
6001 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6002
|
6003 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
6004 (jobject)pr.jProvider,
6005 id,
6006 jAssociationName,
6007 jPathName,
6008 jRole,
6009 JMPI_INCLUDE_QUALIFIERS,
6010 request->includeClassOrigin,
6011 jPropertyList);
|
6012 mark.hamzy 1.43
6013 JMPIjvm::checkException(env);
6014
6015 handler.processing();
|
6016 mark.hamzy 1.45 if (jAr) {
6017 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
6018 mark.hamzy 1.43 JMPIjvm::checkException(env);
6019
|
6020 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
6021 mark.hamzy 1.43
6022 JMPIjvm::checkException(env);
6023
|
6024 marek 1.68 jlong jciRetRef = env->CallLongMethod(
6025 jciRet,
6026 JMPIjvm::jv.CIMInstanceCInst);
|
6027 mark.hamzy 1.43
6028 JMPIjvm::checkException(env);
6029
|
6030 marek 1.68 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
6031 jlong,
6032 CIMInstance*,
6033 jciRetRef);
6034 CIMClass cls;
|
6035 mark.hamzy 1.43
6036 try
6037 {
|
6038 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6039 "handleReferencesRequest: "
6040 "enter(METHOD_CIMASSOCIATORPROVIDER): "
6041 "cimom_handle->getClass(%s).",
6042 (const char*)ciRet->
6043 getClassName().getString().getCString()
6044 ));
6045
|
6046 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
6047
6048 cls = pr._cimom_handle->getClass(context,
6049 request->nameSpace,
6050 ciRet->getClassName(),
6051 false,
6052 true,
6053 true,
6054 CIMPropertyList());
|
6055 thilo.boehm 1.69
6056 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6057 "handleReferencesRequest: "
6058 "exit(METHOD_CIMASSOCIATORPROVIDER): "
6059 "cimom_handle->getClass(%s).",
6060 (const char*)ciRet->
6061 getClassName().getString().getCString()
6062 ));
|
6063 mark.hamzy 1.43 }
6064 catch (CIMException e)
6065 {
|
6066 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6067 "handleReferencesRequest: "
6068 "Caught CIMExcetion(METHOD_CIMASSOCIATORPROVIDER) "
6069 "during cimom_handle->getClass(%s): %s ",
6070 (const char*)ciRet->
6071 getClassName().getString().getCString(),
6072 (const char*)e.getMessage().getCString()
6073 ));
6074
6075 PEG_METHOD_EXIT();
|
6076 mark.hamzy 1.43 throw;
6077 }
6078
6079 const CIMObjectPath& op = ciRet->getPath();
6080 CIMObjectPath iop = ciRet->buildPath(cls);
6081
6082 JMPIjvm::checkException(env);
6083
6084 iop.setNameSpace(op.getNameSpace());
6085 ciRet->setPath(iop);
6086
6087 handler.deliver(*ciRet);
6088 }
6089 }
6090 handler.complete();
6091 break;
6092 }
6093
6094 case METHOD_CIMASSOCIATORPROVIDER2:
6095 {
|
6096 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
6097 OperationContext*,
6098 jlong,
6099 &request->operationContext);
6100 jobject joc = env->NewObject(
6101 jv->OperationContextClassRef,
6102 jv->OperationContextNewJ,
6103 jocRef);
6104
6105 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6106 CIMObjectPath*,
6107 jlong,
6108 resultPath);
6109 jobject jAssociationName = env->NewObject(
6110 jv->CIMObjectPathClassRef,
6111 jv->CIMObjectPathNewJ,
6112 jAssociationNameRef);
|
6113 mark.hamzy 1.43
6114 JMPIjvm::checkException(env);
6115
|
6116 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6117 CIMObjectPath*,
6118 jlong,
6119 objectPath);
6120 jobject jPathName = env->NewObject(
6121 jv->CIMObjectPathClassRef,
6122 jv->CIMObjectPathNewJ,
6123 jPathNameRef);
|
6124 mark.hamzy 1.43
6125 JMPIjvm::checkException(env);
6126
6127 jstring jRole = env->NewStringUTF(request->role.getCString());
6128
6129 JMPIjvm::checkException(env);
6130
6131 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
6132 schuur 1.1
|
6133 mark.hamzy 1.43 #ifdef PEGASUS_DEBUG
|
6134 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6135 "handleReferencesRequest: assocName = %s ",
6136 (const char*)resultPath->toString().getCString()));
6137 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6138 "handleReferencesRequest: role = %s ",
6139 (const char*)request->role.getCString()));
6140 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6141 "handleReferencesRequest: includeQualifiers = false");
6142 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6143 "handleReferencesRequest: includeClassOrigin = false");
|
6144 mark.hamzy 1.43 #endif
|
6145 schuur 1.1
|
6146 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6147
|
6148 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
6149 (jobject)pr.jProvider,
6150 id,
6151 joc,
6152 jAssociationName,
6153 jPathName,
6154 jRole,
6155 JMPI_INCLUDE_QUALIFIERS,
6156 request->includeClassOrigin,
6157 jPropertyList);
|
6158 schuur 1.1
|
6159 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6160 mark.hamzy 1.24
|
6161 mark.hamzy 1.43 if (joc)
6162 {
|
6163 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
6164 schuur 1.1
|
6165 mark.hamzy 1.43 JMPIjvm::checkException(env);
6166 }
|
6167 schuur 1.1
|
6168 mark.hamzy 1.43 handler.processing();
|
6169 mark.hamzy 1.45 if (jAr) {
6170 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
6171 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6172 schuur 1.1
|
6173 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
6174 mark.hamzy 1.37
|
6175 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6176 mark.hamzy 1.37
|
6177 marek 1.68 jlong jciRetRef = env->CallLongMethod(
6178 jciRet,
6179 JMPIjvm::jv.CIMInstanceCInst);
|
6180 mark.hamzy 1.37
|
6181 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6182 schuur 1.1
|
6183 marek 1.68 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
6184 jlong,
6185 CIMInstance*,
6186 jciRetRef);
|
6187 mark.hamzy 1.43 CIMClass cls;
|
6188 schuur 1.1
|
6189 mark.hamzy 1.43 try
6190 {
|
6191 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6192 "handleReferencesRequest: "
6193 "enter(METHOD_CIMASSOCIATORPROVIDER2): "
6194 "cimom_handle->getClass(%s).",
6195 (const char*)ciRet->
6196 getClassName().getString().getCString()
6197 ));
6198
|
6199 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
|
6200 mark.hamzy 1.24
|
6201 mark.hamzy 1.43 cls = pr._cimom_handle->getClass(context,
6202 request->nameSpace,
6203 ciRet->getClassName(),
6204 false,
6205 true,
6206 true,
6207 CIMPropertyList());
|
6208 thilo.boehm 1.69
6209 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6210 "handleReferencesRequest: "
6211 "exit(METHOD_CIMASSOCIATORPROVIDER2): "
6212 "cimom_handle->getClass(%s).",
6213 (const char*)ciRet->
6214 getClassName().getString().getCString()
6215 ));
|
6216 mark.hamzy 1.43 }
6217 catch (CIMException e)
6218 {
|
6219 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6220 "handleReferencesRequest: "
6221 "Caught CIMExcetion(METHOD_CIMASSOCIATORPROVIDER2) "
6222 "during cimom_handle->getClass(%s): %s ",
6223 (const char*)ciRet->
6224 getClassName().getString().getCString(),
6225 (const char*)e.getMessage().getCString()
6226 ));
6227
6228 PEG_METHOD_EXIT();
|
6229 mark.hamzy 1.43 throw;
6230 }
|
6231 mark.hamzy 1.24
|
6232 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
6233 CIMObjectPath iop = ciRet->buildPath(cls);
|
6234 mark.hamzy 1.24
|
6235 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6236 mark.hamzy 1.24
|
6237 mark.hamzy 1.43 iop.setNameSpace(op.getNameSpace());
6238 ciRet->setPath(iop);
|
6239 mark.hamzy 1.24
|
6240 mark.hamzy 1.43 handler.deliver(*ciRet);
6241 }
|
6242 mark.hamzy 1.24 }
|
6243 mark.hamzy 1.43 handler.complete();
6244 break;
|
6245 mark.hamzy 1.24 }
|
6246 schuur 1.12
|
6247 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
|
6248 mark.hamzy 1.24 {
|
6249 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6250 CIMObjectPath*,
6251 jlong,
6252 resultPath);
6253 jobject jAssociationName = env->NewObject(
6254 jv->CIMObjectPathClassRef,
6255 jv->CIMObjectPathNewJ,
6256 jAssociationNameRef);
|
6257 mark.hamzy 1.24
|
6258 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6259 schuur 1.1
|
6260 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6261 CIMObjectPath*,
6262 jlong,
6263 objectPath);
6264 jobject jPathName = env->NewObject(
6265 jv->CIMObjectPathClassRef,
6266 jv->CIMObjectPathNewJ,
6267 jPathNameRef);
|
6268 mark.hamzy 1.25
6269 JMPIjvm::checkException(env);
6270
6271 jstring jRole = env->NewStringUTF(request->role.getCString());
6272
6273 JMPIjvm::checkException(env);
6274
6275 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
6276
|
6277 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
6278 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6279 "handleReferencesRequest: assocName = %s ",
6280 (const char*)resultPath->toString().getCString()));
6281 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6282 "handleReferencesRequest: pathName = %s ",
6283 (const char*)objectPath->toString().getCString()));
6284 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6285 "handleReferencesRequest: role = %s ",
6286 (const char*)request->role.getCString()));
6287 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6288 "handleReferencesRequest: includeQualifiers = false");
6289 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6290 "handleReferencesRequest: includeClassOrigin = false");
|
6291 mark.hamzy 1.29 #endif
|
6292 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6293
|
6294 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
6295 (jobject)pr.jProvider,
6296 id,
6297 jAssociationName,
6298 jPathName,
6299 jRole,
6300 JMPI_INCLUDE_QUALIFIERS,
6301 request->includeClassOrigin,
6302 jPropertyList);
|
6303 mark.hamzy 1.25
|
6304 mark.hamzy 1.23 JMPIjvm::checkException(env);
6305
6306 handler.processing();
6307 if (jVec) {
|
6308 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
6309 i<m; i++)
6310 {
|
6311 mark.hamzy 1.23 JMPIjvm::checkException(env);
6312
|
6313 marek 1.68 jobject jciRet = env->CallObjectMethod(
6314 jVec,
6315 JMPIjvm::jv.VectorElementAt,
6316 i);
|
6317 mark.hamzy 1.24
|
6318 mark.hamzy 1.23 JMPIjvm::checkException(env);
6319
|
6320 marek 1.68 jlong jciRetRef = env->CallLongMethod(
6321 jciRet,
6322 JMPIjvm::jv.CIMInstanceCInst);
6323 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
6324 jlong,
6325 CIMInstance*,
6326 jciRetRef);
6327 CIMClass cls;
|
6328 mark.hamzy 1.40
6329 try
6330 {
|
6331 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6332 "handleReferencesRequest: "
6333 "enter(METHOD_ASSOCIATORPROVIDER): "
6334 "cimom_handle->getClass(%s).",
6335 (const char*)ciRet->
6336 getClassName().getString().getCString()
6337 ));
6338
|
6339 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
6340
6341 cls = pr._cimom_handle->getClass(context,
6342 request->nameSpace,
6343 ciRet->getClassName(),
6344 false,
6345 true,
6346 true,
6347 CIMPropertyList());
|
6348 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6349 "handleReferencesRequest: "
6350 "exit(METHOD_ASSOCIATORPROVIDER): "
6351 "cimom_handle->getClass(%s).",
6352 (const char*)ciRet->
6353 getClassName().getString().getCString()
6354 ));
|
6355 mark.hamzy 1.40 }
6356 catch (CIMException e)
6357 {
|
6358 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6359 "handleReferencesRequest: "
6360 "Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER) "
6361 "during cimom_handle->getClass(%s): %s ",
6362 (const char*)ciRet->
6363 getClassName().getString().getCString(),
6364 (const char*)e.getMessage().getCString()
6365 ));
6366
6367 PEG_METHOD_EXIT();
|
6368 mark.hamzy 1.40 throw;
6369 }
6370
|
6371 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
6372 CIMObjectPath iop = ciRet->buildPath(cls);
|
6373 mark.hamzy 1.24
|
6374 mark.hamzy 1.27 JMPIjvm::checkException(env);
6375
|
6376 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
6377 mark.hamzy 1.29 ciRet->setPath(iop);
|
6378 schuur 1.13
|
6379 mark.hamzy 1.29 handler.deliver(*ciRet);
|
6380 mark.hamzy 1.23 }
6381 }
6382 handler.complete();
|
6383 mark.hamzy 1.24 break;
|
6384 mark.hamzy 1.23 }
|
6385 schuur 1.1
|
6386 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
6387 mark.hamzy 1.24 {
|
6388 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
6389 OperationContext*,
6390 jlong,
6391 &request->operationContext);
6392 jobject joc = env->NewObject(
6393 jv->OperationContextClassRef,
6394 jv->OperationContextNewJ,
6395 jocRef);
6396
6397 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6398 CIMObjectPath*,
6399 jlong,
6400 resultPath);
6401 jobject jAssociationName = env->NewObject(
6402 jv->CIMObjectPathClassRef,
6403 jv->CIMObjectPathNewJ,
6404 jAssociationNameRef);
|
6405 mark.hamzy 1.25
6406 JMPIjvm::checkException(env);
6407
|
6408 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6409 CIMObjectPath*,
6410 jlong,
6411 objectPath);
6412 jobject jPathName = env->NewObject(
6413 jv->CIMObjectPathClassRef,
6414 jv->CIMObjectPathNewJ,
6415 jPathNameRef);
|
6416 mark.hamzy 1.24
6417 JMPIjvm::checkException(env);
6418
|
6419 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
6420
6421 JMPIjvm::checkException(env);
6422
6423 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
6424
|
6425 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
6426 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6427 "handleReferencesRequest: assocName = %s ",
6428 (const char*)resultPath->toString().getCString()));
6429 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6430 "handleReferencesRequest: pathName = %s ",
6431 (const char*)objectPath->toString().getCString()));
6432 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6433 "handleReferencesRequest: role = %s ",
6434 (const char*)request->role.getCString()));
6435 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6436 "handleReferencesRequest: includeQualifiers = false");
6437 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6438 "handleReferencesRequest: includeClassOrigin = false");
|
6439 mark.hamzy 1.29 #endif
6440
|
6441 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6442
|
6443 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
6444 (jobject)pr.jProvider,
6445 id,
6446 joc,
6447 jAssociationName,
6448 jPathName,
6449 jRole,
6450 JMPI_INCLUDE_QUALIFIERS,
6451 request->includeClassOrigin,
6452 jPropertyList);
|
6453 mark.hamzy 1.25
|
6454 mark.hamzy 1.24 JMPIjvm::checkException(env);
6455
|
6456 mark.hamzy 1.43 if (joc)
6457 {
|
6458 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
6459 mark.hamzy 1.43
6460 JMPIjvm::checkException(env);
6461 }
6462
|
6463 mark.hamzy 1.24 handler.processing();
6464 if (jVec) {
|
6465 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
6466 i<m; i++)
6467 {
|
6468 mark.hamzy 1.24 JMPIjvm::checkException(env);
6469
|
6470 marek 1.68 jobject jciRet = env->CallObjectMethod(
6471 jVec,
6472 JMPIjvm::jv.VectorElementAt,
6473 i);
|
6474 mark.hamzy 1.24
6475 JMPIjvm::checkException(env);
6476
|
6477 marek 1.68 jlong jciRetRef = env->CallLongMethod(
6478 jciRet,
6479 JMPIjvm::jv.CIMInstanceCInst);
6480 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
6481 jlong,
6482 CIMInstance*,
6483 jciRetRef);
6484 CIMClass cls;
|
6485 mark.hamzy 1.40
6486 try
6487 {
|
6488 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6489 "handleReferencesRequest: "
6490 "enter(METHOD_ASSOCIATORPROVIDER2): "
6491 "cimom_handle->getClass(%s).",
6492 (const char*)ciRet->
6493 getClassName().getString().getCString()
6494 ));
6495
|
6496 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
6497
6498 cls = pr._cimom_handle->getClass(context,
6499 request->nameSpace,
6500 ciRet->getClassName(),
6501 false,
6502 true,
6503 true,
6504 CIMPropertyList());
|
6505 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6506 "handleReferencesRequest: "
6507 "exit(METHOD_ASSOCIATORPROVIDER2): "
6508 "cimom_handle->getClass(%s).",
6509 (const char*)ciRet->
6510 getClassName().getString().getCString()
6511 ));
6512
|
6513 mark.hamzy 1.40 }
6514 catch (CIMException e)
6515 {
|
6516 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6517 "handleReferencesRequest: "
6518 "Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER2) "
6519 "during cimom_handle->getClass(%s): %s ",
6520 (const char*)ciRet->
6521 getClassName().getString().getCString(),
6522 (const char*)e.getMessage().getCString()
6523 ));
6524
6525 PEG_METHOD_EXIT();
|
6526 mark.hamzy 1.40 throw;
6527 }
6528
|
6529 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
6530 CIMObjectPath iop = ciRet->buildPath(cls);
|
6531 schuur 1.1
|
6532 mark.hamzy 1.27 JMPIjvm::checkException(env);
6533
|
6534 mark.hamzy 1.24 iop.setNameSpace(op.getNameSpace());
|
6535 mark.hamzy 1.29 ciRet->setPath(iop);
|
6536 schuur 1.12
|
6537 mark.hamzy 1.29 handler.deliver(*ciRet);
|
6538 mark.hamzy 1.24 }
6539 }
6540 handler.complete();
6541 break;
6542 }
|
6543 mark.hamzy 1.23
|
6544 mark.hamzy 1.24 case METHOD_UNKNOWN:
6545 {
|
6546 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6547 "handleReferencesRequest: Unknown method provider!");
|
6548 mark.hamzy 1.24 break;
6549 }
|
6550 mark.hamzy 1.23 }
|
6551 schuur 1.1 }
6552 HandlerCatch(handler);
|
6553 schuur 1.12
6554 if (env) JMPIjvm::detachThread();
6555
|
6556 schuur 1.1 PEG_METHOD_EXIT();
6557
6558 return(response);
6559 }
6560
|
6561 marek 1.68 Message * JMPIProviderManager::handleReferenceNamesRequest(
6562 const Message * message) throw()
|
6563 schuur 1.1 {
|
6564 marek 1.68 PEG_METHOD_ENTER(
6565 TRC_PROVIDERMANAGER,
6566 "JMPIProviderManager::handleReferenceNamesRequest");
|
6567 mark.hamzy 1.23
|
6568 kumpf 1.55 HandlerIntro(ReferenceNames,message,request,response,handler);
|
6569 schuur 1.1
|
6570 mark.hamzy 1.24 typedef enum {
6571 METHOD_UNKNOWN = 0,
|
6572 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
6573 METHOD_CIMASSOCIATORPROVIDER2,
6574 METHOD_ASSOCIATORPROVIDER,
6575 METHOD_ASSOCIATORPROVIDER2,
|
6576 mark.hamzy 1.24 } METHOD_VERSION;
6577 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
6578 JNIEnv *env = NULL;
|
6579 schuur 1.13
|
6580 marek 1.68 try
6581 {
|
6582 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
6583 "handleReferenceNamesRequest: "
6584 "name space = %s class name = %s",
6585 (const char*)request->nameSpace.getString().getCString(),
6586 (const char*)request->
6587 objectName.getClassName().getString().getCString()
6588 ));
|
6589 mark.hamzy 1.23
|
6590 schuur 1.1 // make target object path
|
6591 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
6592 System::getHostName(),
6593 request->nameSpace,
6594 request->objectName.getClassName(),
6595 request->objectName.getKeyBindings());
6596 CIMObjectPath *resultPath = new CIMObjectPath(
6597 System::getHostName(),
6598 request->nameSpace,
6599 request->resultClass.getString());
|
6600 schuur 1.1
6601 // resolve provider name
|
6602 kumpf 1.2 ProviderName name = _resolveProviderName(
6603 request->operationContext.get(ProviderIdContainer::NAME));
|
6604 schuur 1.1
6605 // get cached or load new provider module
|
6606 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
6607 name.getPhysicalName(),
6608 name.getLogicalName(),
6609 String::EMPTY);
|
6610 schuur 1.1
|
6611 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
6612 schuur 1.1
|
6613 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
6614 "handleReferenceNamesRequest: "
6615 "Calling provider: %s, role: %s, refCls: %s",
6616 (const char*)pr.getName().getCString(),
6617 (const char*)request->role.getCString(),
6618 (const char*)request->resultClass.getString().getCString()
6619 ));
|
6620 schuur 1.12
|
6621 mark.hamzy 1.24 JvmVector *jv = 0;
6622
6623 env = JMPIjvm::attachThread(&jv);
|
6624 schuur 1.1
|
6625 mark.hamzy 1.37 if (!env)
6626 {
|
6627 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6628 "handleReferenceNamesRequest: "
6629 "Could not initialize the JVM (Java Virtual Machine) "
6630 "runtime environment.");
6631
|
6632 mark.hamzy 1.37 PEG_METHOD_EXIT();
6633
|
6634 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
6635 CIM_ERR_FAILED,
6636 MessageLoaderParms(
|
6637 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
6638 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
6639 "runtime environment."));
|
6640 mark.hamzy 1.37 }
6641
|
6642 mark.hamzy 1.43 JMPIProvider::pm_service_op_lock op_lock(&pr);
6643
6644 jmethodID id = NULL;
6645 String interfaceType;
6646 String interfaceVersion;
6647
|
6648 marek 1.68 getInterfaceType(
6649 request->operationContext.get(ProviderIdContainer::NAME),
6650 interfaceType,
6651 interfaceVersion);
|
6652 mark.hamzy 1.43
6653 if (interfaceType == "JMPI")
6654 {
|
6655 marek 1.68 id = env->GetMethodID(
6656 (jclass)pr.jProviderClass,
6657 "referenceNames",
6658 "(Lorg/pegasus/jmpi/CIMObjectPath;"
6659 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)"
6660 "Ljava/util/Vector;");
|
6661 mark.hamzy 1.43
6662 if (id != NULL)
6663 {
6664 eMethodFound = METHOD_ASSOCIATORPROVIDER;
|
6665 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6666 "handleReferencesRequest: "
6667 "Found METHOD_ASSOCIATORPROVIDER.");
|
6668 mark.hamzy 1.43 }
6669
6670 if (id == NULL)
6671 {
6672 env->ExceptionClear();
6673
|
6674 marek 1.68 id = env->GetMethodID(
6675 (jclass)pr.jProviderClass,
6676 "referenceNames",
6677 "(Lorg/pegasus/jmpi/CIMObjectPath;"
6678 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
6679 ")[Lorg/pegasus/jmpi/CIMObjectPath;");
|
6680 mark.hamzy 1.43
6681 if (id != NULL)
6682 {
6683 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
|
6684 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6685 "handleReferenceNamesRequest: "
6686 "Found METHOD_CIMASSOCIATORPROVIDER.");
|
6687 mark.hamzy 1.43 }
6688 }
6689 }
6690 else if (interfaceType == "JMPIExperimental")
6691 {
|
6692 marek 1.68 id = env->GetMethodID(
6693 (jclass)pr.jProviderClass,
6694 "referenceNames",
6695 "(Lorg/pegasus/jmpi/OperationContext;"
6696 "Lorg/pegasus/jmpi/CIMObjectPath;"
6697 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
6698 ")Ljava/util/Vector;");
|
6699 mark.hamzy 1.43
6700 if (id != NULL)
6701 {
6702 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
|
6703 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6704 "handleReferenceNamesRequest: "
6705 "Found METHOD_ASSOCIATORPROVIDER2.");
|
6706 mark.hamzy 1.43 }
6707
6708 if (id == NULL)
6709 {
6710 env->ExceptionClear();
|
6711 marek 1.68 id = env->GetMethodID(
6712 (jclass)pr.jProviderClass,
6713 "referenceNames",
6714 "(Lorg/pegasus/jmpi/OperationContext;"
6715 "Lorg/pegasus/jmpi/CIMObjectPath;"
6716 "Lorg/pegasus/jmpi/CIMObjectPath;"
6717 "Ljava/lang/String;)"
6718 "[Lorg/pegasus/jmpi/CIMObjectPath;");
|
6719 mark.hamzy 1.43
6720 if (id != NULL)
6721 {
6722 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
|
6723 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6724 "handleReferenceNamesRequest: "
6725 "Found METHOD_CIMASSOCIATORPROVIDER2.");
|
6726 mark.hamzy 1.43 }
6727 }
6728 }
6729
6730 if (id == NULL)
6731 {
|
6732 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6733 "handleReferenceNames: No method found!");
|
6734 mark.hamzy 1.43
6735 PEG_METHOD_EXIT();
6736
|
6737 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
6738 CIM_ERR_FAILED,
6739 MessageLoaderParms(
|
6740 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
6741 marek 1.68 "Could not find a method for the provider based on "
6742 "InterfaceType."));
|
6743 mark.hamzy 1.43 }
6744
6745 JMPIjvm::checkException(env);
6746
6747 switch (eMethodFound)
6748 {
6749 case METHOD_CIMASSOCIATORPROVIDER:
6750 {
|
6751 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6752 CIMObjectPath*,
6753 jlong,
6754 resultPath);
6755 jobject jAssociationName = env->NewObject(
6756 jv->CIMObjectPathClassRef,
6757 jv->CIMObjectPathNewJ,
6758 jAssociationNameRef);
|
6759 mark.hamzy 1.43
6760 JMPIjvm::checkException(env);
6761
|
6762 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6763 CIMObjectPath*,
6764 jlong,
6765 objectPath);
6766 jobject jPathName = env->NewObject(
6767 jv->CIMObjectPathClassRef,
6768 jv->CIMObjectPathNewJ,
6769 jPathNameRef);
|
6770 mark.hamzy 1.43
6771 JMPIjvm::checkException(env);
6772
6773 jstring jRole = env->NewStringUTF(request->role.getCString());
6774
6775 JMPIjvm::checkException(env);
6776
6777 #ifdef PEGASUS_DEBUG
|
6778 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6779 "handleReferenceNamesRequest: assocName = %s ",
6780 (const char*)objectPath->toString().getCString()));
6781 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6782 "handleReferenceNamesRequest: role = %s ",
6783 (const char*)request->role.getCString()));
|
6784 mark.hamzy 1.43 #endif
6785
|
6786 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6787
|
6788 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
6789 (jobject)pr.jProvider,
6790 id,
6791 jPathName,
6792 jAssociationName,
6793 jRole);
|
6794 mark.hamzy 1.43
6795 JMPIjvm::checkException(env);
6796
6797 handler.processing();
|
6798 mark.hamzy 1.45 if (jAr) {
6799 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
6800 mark.hamzy 1.43 JMPIjvm::checkException(env);
6801
|
6802 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
6803 mark.hamzy 1.43
6804 JMPIjvm::checkException(env);
6805
|
6806 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
6807 jcopRet,
6808 JMPIjvm::jv.CIMObjectPathCInst);
|
6809 mark.hamzy 1.43
6810 JMPIjvm::checkException(env);
6811
|
6812 marek 1.68 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
6813 jlong,
6814 CIMObjectPath*,
6815 jcopRetRef);
|
6816 mark.hamzy 1.43
6817 handler.deliver(*copRet);
6818 }
6819 }
6820 handler.complete();
6821 break;
6822 }
6823
6824 case METHOD_CIMASSOCIATORPROVIDER2:
6825 {
|
6826 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
6827 OperationContext*,
6828 jlong,
6829 &request->operationContext);
6830 jobject joc = env->NewObject(
6831 jv->OperationContextClassRef,
6832 jv->OperationContextNewJ,
6833 jocRef);
6834
6835 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6836 CIMObjectPath*,
6837 jlong,
6838 resultPath);
6839 jobject jAssociationName = env->NewObject(
6840 jv->CIMObjectPathClassRef,
6841 jv->CIMObjectPathNewJ,
6842 jAssociationNameRef);
|
6843 mark.hamzy 1.43
6844 JMPIjvm::checkException(env);
6845
|
6846 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6847 CIMObjectPath*,
6848 jlong,
6849 objectPath);
6850 jobject jPathName = env->NewObject(
6851 jv->CIMObjectPathClassRef,
6852 jv->CIMObjectPathNewJ,
6853 jPathNameRef);
|
6854 mark.hamzy 1.43
6855 JMPIjvm::checkException(env);
6856
6857 jstring jRole = env->NewStringUTF(request->role.getCString());
6858
6859 JMPIjvm::checkException(env);
6860
6861 #ifdef PEGASUS_DEBUG
|
6862 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6863 "handleReferenceNamesRequest: assocName = %s ",
6864 (const char*)objectPath->toString().getCString()));
6865 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6866 "handleReferenceNamesRequest: role = %s ",
6867 (const char*)request->role.getCString()));
|
6868 mark.hamzy 1.43 #endif
6869
|
6870 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6871
|
6872 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
6873 (jobject)pr.jProvider,
6874 id,
6875 joc,
6876 jPathName,
6877 jAssociationName,
6878 jRole);
|
6879 mark.hamzy 1.43
6880 JMPIjvm::checkException(env);
6881
6882 if (joc)
6883 {
|
6884 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
6885 mark.hamzy 1.43
6886 JMPIjvm::checkException(env);
6887 }
6888
6889 handler.processing();
|
6890 mark.hamzy 1.45 if (jAr) {
6891 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
6892 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6893 schuur 1.1
|
6894 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
6895 schuur 1.1
|
6896 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6897 mark.hamzy 1.24
|
6898 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
6899 jcopRet,
6900 JMPIjvm::jv.CIMObjectPathCInst);
|
6901 mark.hamzy 1.24
|
6902 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6903 mark.hamzy 1.24
|
6904 marek 1.68 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
6905 jlong,
6906 CIMObjectPath*,
6907 jcopRetRef);
|
6908 mark.hamzy 1.24
|
6909 mark.hamzy 1.43 handler.deliver(*copRet);
6910 }
|
6911 mark.hamzy 1.24 }
|
6912 mark.hamzy 1.43 handler.complete();
6913 break;
|
6914 mark.hamzy 1.24 }
|
6915 schuur 1.11
|
6916 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
|
6917 mark.hamzy 1.24 {
|
6918 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6919 CIMObjectPath*,
6920 jlong,
6921 resultPath);
6922 jobject jAssociationName = env->NewObject(
6923 jv->CIMObjectPathClassRef,
6924 jv->CIMObjectPathNewJ,
6925 jAssociationNameRef);
|
6926 mark.hamzy 1.24
|
6927 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6928 schuur 1.1
|
6929 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6930 CIMObjectPath*,
6931 jlong,
6932 objectPath);
6933 jobject jPathName = env->NewObject(
6934 jv->CIMObjectPathClassRef,
6935 jv->CIMObjectPathNewJ,
6936 jPathNameRef);
|
6937 mark.hamzy 1.25
6938 JMPIjvm::checkException(env);
6939
6940 jstring jRole = env->NewStringUTF(request->role.getCString());
6941
6942 JMPIjvm::checkException(env);
6943
|
6944 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
6945 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6946 "handleReferenceNamesRequest: assocName = %s ",
6947 (const char*)objectPath->toString().getCString()));
6948 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6949 "handleReferenceNamesRequest: pathName = %s ",
6950 (const char*)resultPath->toString().getCString()));
6951 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6952 "handleReferenceNamesRequest: role = %s ",
6953 (const char*)request->role.getCString()));
|
6954 mark.hamzy 1.29 #endif
6955
|
6956 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6957
|
6958 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
6959 (jobject)pr.jProvider,
6960 id,
6961 jAssociationName,
6962 jPathName,
6963 jRole);
|
6964 mark.hamzy 1.25
|
6965 mark.hamzy 1.23 JMPIjvm::checkException(env);
6966
6967 handler.processing();
6968 if (jVec) {
|
6969 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
6970 i<m; i++)
6971 {
|
6972 mark.hamzy 1.23 JMPIjvm::checkException(env);
6973
|
6974 marek 1.68 jobject jcopRet = env->CallObjectMethod(
6975 jVec,
6976 JMPIjvm::jv.VectorElementAt,
6977 i);
|
6978 mark.hamzy 1.24
|
6979 mark.hamzy 1.23 JMPIjvm::checkException(env);
6980
|
6981 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
6982 jcopRet,
6983 JMPIjvm::jv.CIMObjectPathCInst);
|
6984 mark.hamzy 1.23
6985 JMPIjvm::checkException(env);
6986
|
6987 marek 1.68 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
6988 jlong,
6989 CIMObjectPath*,
6990 jcopRetRef);
|
6991 mark.hamzy 1.24
|
6992 mark.hamzy 1.29 handler.deliver(*copRet);
|
6993 mark.hamzy 1.23 }
6994 }
6995 handler.complete();
|
6996 mark.hamzy 1.24 break;
|
6997 mark.hamzy 1.23 }
|
6998 mark.hamzy 1.24
|
6999 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
7000 mark.hamzy 1.24 {
|
7001 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
7002 OperationContext*,
7003 jlong,
7004 &request->operationContext);
7005 jobject joc = env->NewObject(
7006 jv->OperationContextClassRef,
7007 jv->OperationContextNewJ,
7008 jocRef);
7009
7010 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
7011 CIMObjectPath*,
7012 jlong,
7013 resultPath);
7014 jobject jAssociationName = env->NewObject(
7015 jv->CIMObjectPathClassRef,
7016 jv->CIMObjectPathNewJ,
7017 jAssociationNameRef);
|
7018 mark.hamzy 1.25
7019 JMPIjvm::checkException(env);
7020
|
7021 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
7022 CIMObjectPath*,
7023 jlong,
7024 objectPath);
7025 jobject jPathName = env->NewObject(
7026 jv->CIMObjectPathClassRef,
7027 jv->CIMObjectPathNewJ,
7028 jPathNameRef);
|
7029 mark.hamzy 1.24
7030 JMPIjvm::checkException(env);
7031
|
7032 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
7033
7034 JMPIjvm::checkException(env);
7035
|
7036 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
7037 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7038 "handleReferenceNamesRequest: assocName = %s ",
7039 (const char*)objectPath->toString().getCString()));
7040 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7041 "handleReferenceNamesRequest: pathName = %s ",
7042 (const char*)resultPath->toString().getCString()));
7043 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7044 "handleReferenceNamesRequest: role = %s ",
7045 (const char*)request->role.getCString()));
|
7046 mark.hamzy 1.29 #endif
7047
|
7048 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
7049
|
7050 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
7051 (jobject)pr.jProvider,
7052 id,
7053 joc,
7054 jAssociationName,
7055 jPathName,
7056 jRole);
|
7057 mark.hamzy 1.25
|
7058 mark.hamzy 1.23 JMPIjvm::checkException(env);
7059
|
7060 mark.hamzy 1.43 if (joc)
7061 {
|
7062 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
7063 mark.hamzy 1.43
7064 JMPIjvm::checkException(env);
7065 }
7066
|
7067 mark.hamzy 1.23 handler.processing();
|
7068 mark.hamzy 1.24 if (jVec) {
|
7069 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
7070 i<m; i++)
7071 {
|
7072 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
7073 marek 1.68 jobject jcopRet = env->CallObjectMethod(
7074 jVec,
7075 JMPIjvm::jv.VectorElementAt,
7076 i);
7077 JMPIjvm::checkException(env);
7078 jlong jcopRetRef = env->CallLongMethod(
7079 jcopRet,
7080 JMPIjvm::jv.CIMObjectPathCInst);
7081 JMPIjvm::checkException(env);
7082 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
7083 jlong,
7084 CIMObjectPath*,
7085 jcopRetRef);
|
7086 mark.hamzy 1.29 handler.deliver(*copRet);
|
7087 mark.hamzy 1.23 }
7088 }
7089 handler.complete();
|
7090 mark.hamzy 1.24 break;
7091 }
7092
7093 case METHOD_UNKNOWN:
7094 {
|
7095 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7096 "handleReferenceNamesRequest: Unknown method provider!");
|
7097 mark.hamzy 1.24 break;
7098 }
|
7099 mark.hamzy 1.23 }
|
7100 schuur 1.1 }
7101 HandlerCatch(handler);
|
7102 schuur 1.11
7103 if (env) JMPIjvm::detachThread();
7104
|
7105 schuur 1.1 PEG_METHOD_EXIT();
7106
7107 return(response);
7108 }
7109
|
7110 marek 1.68 Message * JMPIProviderManager::handleGetPropertyRequest(
7111 const Message * message) throw()
|
7112 mark.hamzy 1.26 {
|
7113 marek 1.68 PEG_METHOD_ENTER(
7114 TRC_PROVIDERMANAGER,
7115 "JMPIProviderManager::handleGetPropertyRequest");
|
7116 mark.hamzy 1.26
|
7117 kumpf 1.55 HandlerIntro(GetProperty,message,request,response,handler);
|
7118 mark.hamzy 1.26
7119 typedef enum {
7120 METHOD_UNKNOWN = 0,
|
7121 mark.hamzy 1.43 METHOD_PROPERTYPROVIDER,
7122 METHOD_PROPERTYPROVIDER2,
|
7123 mark.hamzy 1.26 } METHOD_VERSION;
7124 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
7125 JNIEnv *env = NULL;
7126
7127 try {
|
7128 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
7129 "handleGetPropertyRequest: "
7130 "name space = %s class name = %s",
7131 (const char*)request->nameSpace.getString().getCString(),
7132 (const char*)request->
7133 instanceName.getClassName().getString().getCString()
7134 ));
|
7135 mark.hamzy 1.26
7136 // make target object path
|
7137 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
7138 System::getHostName(),
7139 request->nameSpace,
7140 request->instanceName.getClassName(),
7141 request->instanceName.getKeyBindings());
|
7142 mark.hamzy 1.26
7143 // resolve provider name
7144 ProviderName name = _resolveProviderName(
7145 request->operationContext.get(ProviderIdContainer::NAME));
7146
7147 // get cached or load new provider module
|
7148 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
7149 name.getPhysicalName(),
7150 name.getLogicalName(),
7151 String::EMPTY);
|
7152 mark.hamzy 1.26
7153 // forward request
7154 JMPIProvider &pr = ph.GetProvider();
7155
|
7156 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
7157 "handleReferenceNamesRequest: "
7158 "Calling provider: %s",
7159 (const char*)pr.getName().getCString()
7160 ));
|
7161 mark.hamzy 1.26
7162 JvmVector *jv = 0;
7163
7164 env = JMPIjvm::attachThread(&jv);
7165
|
7166 mark.hamzy 1.37 if (!env)
7167 {
|
7168 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7169 "handleReferenceNamesRequest: "
7170 "Could not initialize the JVM (Java Virtual Machine) "
7171 "runtime environment.");
7172
|
7173 mark.hamzy 1.37 PEG_METHOD_EXIT();
7174
|
7175 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7176 CIM_ERR_FAILED,
7177 MessageLoaderParms(
|
7178 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
7179 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
7180 "runtime environment."));
|
7181 mark.hamzy 1.37 }
7182
|
7183 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
7184
|
7185 mark.hamzy 1.43 jmethodID id = NULL;
7186 String interfaceType;
7187 String interfaceVersion;
7188
|
7189 marek 1.68 getInterfaceType(
7190 request->operationContext.get(ProviderIdContainer::NAME),
7191 interfaceType,
7192 interfaceVersion);
|
7193 mark.hamzy 1.43
7194 if (interfaceType == "JMPI")
7195 {
|
7196 marek 1.68 id = env->GetMethodID(
7197 (jclass)pr.jProviderClass,
7198 "getPropertyValue",
7199 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7200 "Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
|
7201 mark.hamzy 1.26
|
7202 mark.hamzy 1.43 if (id != NULL)
7203 {
7204 eMethodFound = METHOD_PROPERTYPROVIDER;
|
7205 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7206 "handleGetPropertyRequest: "
7207 "Found METHOD_PROPERTYPROVIDER.");
|
7208 mark.hamzy 1.43 }
7209 }
7210 else if (interfaceType == "JMPIExperimental")
7211 {
|
7212 marek 1.68 id = env->GetMethodID(
7213 (jclass)pr.jProviderClass,
7214 "getPropertyValue",
7215 "(Lorg/pegasus/jmpi/OperationContext;"
7216 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7217 "Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
|
7218 mark.hamzy 1.26
|
7219 mark.hamzy 1.43 if (id != NULL)
7220 {
7221 eMethodFound = METHOD_PROPERTYPROVIDER2;
|
7222 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7223 "handleGetPropertyRequest: "
7224 "Found METHOD_PROPERTYPROVIDER2.");
|
7225 mark.hamzy 1.43 }
|
7226 mark.hamzy 1.26 }
7227
7228 if (id == NULL)
7229 {
|
7230 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7231 "handleGetPropertyRequest: No method provider found!");
|
7232 mark.hamzy 1.43
7233 PEG_METHOD_EXIT();
7234
|
7235 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7236 CIM_ERR_FAILED,
7237 MessageLoaderParms(
|
7238 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
7239 marek 1.68 "Could not find a method for the provider based on "
7240 "InterfaceType."));
|
7241 mark.hamzy 1.26 }
7242
7243 JMPIjvm::checkException(env);
7244
7245 switch (eMethodFound)
7246 {
|
7247 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER:
|
7248 mark.hamzy 1.26 {
|
7249 marek 1.68 jlong jcopref = DEBUG_ConvertCToJava(
7250 CIMObjectPath*,
7251 jlong,
7252 objectPath);
7253 jobject jcop = env->NewObject(
7254 jv->CIMObjectPathClassRef,
7255 jv->CIMObjectPathNewJ,
7256 jcopref);
|
7257 mark.hamzy 1.26
7258 JMPIjvm::checkException(env);
7259
|
7260 marek 1.68 jstring joclass =
7261 env->NewStringUTF(
7262 request->instanceName.getClassName().getString().getCString());
|
7263 mark.hamzy 1.26
7264 JMPIjvm::checkException(env);
7265
|
7266 marek 1.68 jstring jpName =
7267 env->NewStringUTF(
7268 request->propertyName.getString().getCString());
|
7269 mark.hamzy 1.26
7270 JMPIjvm::checkException(env);
7271
|
7272 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
|
7273 mark.hamzy 1.26
|
7274 mark.hamzy 1.29 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
7275 id,
7276 jcop,
7277 joclass,
7278 jpName);
|
7279 mark.hamzy 1.26
7280 JMPIjvm::checkException(env);
7281
7282 handler.processing();
7283
|
7284 mark.hamzy 1.29 if (jvalRet)
|
7285 mark.hamzy 1.26 {
|
7286 marek 1.68 jlong jvalRetRef = env->CallLongMethod(
7287 jvalRet,
7288 JMPIjvm::jv.CIMValueCInst);
7289 CIMValue *valRet = DEBUG_ConvertJavaToC(
7290 jlong,
7291 CIMValue*,
7292 jvalRetRef);
|
7293 mark.hamzy 1.26
7294 JMPIjvm::checkException(env);
7295
|
7296 mark.hamzy 1.29 handler.deliver(*valRet);
|
7297 mark.hamzy 1.26 }
7298 handler.complete();
7299 break;
7300 }
7301
|
7302 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER2:
7303 {
|
7304 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
7305 OperationContext*,
7306 jlong,
7307 &request->operationContext);
7308 jobject joc = env->NewObject(
7309 jv->OperationContextClassRef,
7310 jv->OperationContextNewJ,
7311 jocRef);
|
7312 mark.hamzy 1.43
|
7313 marek 1.68 jlong jcopref = DEBUG_ConvertCToJava(
7314 CIMObjectPath*,
7315 jlong,
7316 objectPath);
7317 jobject jcop = env->NewObject(
7318 jv->CIMObjectPathClassRef,
7319 jv->CIMObjectPathNewJ,
7320 jcopref);
|
7321 mark.hamzy 1.43
7322 JMPIjvm::checkException(env);
7323
|
7324 marek 1.68 jstring joclass = env->NewStringUTF(
7325 request->instanceName.getClassName().getString().getCString());
|
7326 mark.hamzy 1.43
7327 JMPIjvm::checkException(env);
7328
|
7329 marek 1.68 jstring jpName = env->NewStringUTF(
7330 request->propertyName.getString().getCString());
|
7331 mark.hamzy 1.43
7332 JMPIjvm::checkException(env);
7333
|
7334 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
|
7335 mark.hamzy 1.43
7336 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
7337 id,
7338 joc,
7339 jcop,
7340 joclass,
7341 jpName);
7342
7343 JMPIjvm::checkException(env);
7344
7345 if (joc)
7346 {
|
7347 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
7348 mark.hamzy 1.43
7349 JMPIjvm::checkException(env);
7350 }
7351
7352 handler.processing();
7353
7354 if (jvalRet)
7355 {
|
7356 marek 1.68 jlong jvalRetRef = env->CallLongMethod(
7357 jvalRet,
7358 JMPIjvm::jv.CIMValueCInst);
7359 CIMValue *valRet = DEBUG_ConvertJavaToC(
7360 jlong,
7361 CIMValue*,
7362 jvalRetRef);
|
7363 mark.hamzy 1.43
7364 JMPIjvm::checkException(env);
7365
7366 handler.deliver(*valRet);
7367 }
7368 handler.complete();
7369 break;
7370 }
7371
|
7372 mark.hamzy 1.26 case METHOD_UNKNOWN:
7373 {
|
7374 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7375 "handleGetPropertyRequest: Unknown method provider!");
|
7376 mark.hamzy 1.26 break;
7377 }
7378 }
7379 }
7380 HandlerCatch(handler);
7381
7382 if (env) JMPIjvm::detachThread();
7383
7384 PEG_METHOD_EXIT();
7385
7386 return(response);
7387 }
7388
|
7389 marek 1.68 Message * JMPIProviderManager::handleSetPropertyRequest(
7390 const Message * message) throw()
|
7391 mark.hamzy 1.26 {
|
7392 marek 1.68 PEG_METHOD_ENTER(
7393 TRC_PROVIDERMANAGER,
7394 "JMPIProviderManager::handleSetPropertyRequest");
|
7395 mark.hamzy 1.26
|
7396 kumpf 1.55 HandlerIntro(SetProperty,message,request,response,handler);
|
7397 mark.hamzy 1.26
7398 typedef enum {
7399 METHOD_UNKNOWN = 0,
|
7400 mark.hamzy 1.43 METHOD_PROPERTYPROVIDER,
7401 METHOD_PROPERTYPROVIDER2,
|
7402 mark.hamzy 1.26 } METHOD_VERSION;
7403 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
7404 JNIEnv *env = NULL;
7405
|
7406 marek 1.68 try
7407 {
|
7408 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
7409 "handleSetPropertyRequest: "
7410 "name space = %s class name = %s",
7411 (const char*)request->nameSpace.getString().getCString(),
7412 (const char*)request->
7413 instanceName.getClassName().getString().getCString()
7414 ));
|
7415 mark.hamzy 1.26
7416 // make target object path
|
7417 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
7418 System::getHostName(),
7419 request->nameSpace,
7420 request->instanceName.getClassName(),
7421 request->instanceName.getKeyBindings());
|
7422 mark.hamzy 1.26
7423 // resolve provider name
7424 ProviderName name = _resolveProviderName(
7425 request->operationContext.get(ProviderIdContainer::NAME));
7426
7427 // get cached or load new provider module
|
7428 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
7429 name.getPhysicalName(),
7430 name.getLogicalName(),
7431 String::EMPTY);
|
7432 mark.hamzy 1.26
7433 // forward request
7434 JMPIProvider &pr = ph.GetProvider();
7435
|
7436 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
7437 "handleSetPropertyRequest: "
7438 "Calling provider. setPropertyValue: %s",
7439 (const char*)pr.getName().getCString()));
|
7440 mark.hamzy 1.26
7441 JvmVector *jv = 0;
7442
7443 env = JMPIjvm::attachThread(&jv);
7444
|
7445 mark.hamzy 1.37 if (!env)
7446 {
|
7447 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7448 "Could not initialize the JVM (Java Virtual Machine) "
7449 "runtime environment.");
7450
|
7451 mark.hamzy 1.37 PEG_METHOD_EXIT();
7452
|
7453 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7454 CIM_ERR_FAILED,
7455 MessageLoaderParms(
|
7456 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
7457 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
7458 "runtime environment."));
|
7459 mark.hamzy 1.37 }
7460
|
7461 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
7462
|
7463 mark.hamzy 1.43 jmethodID id = NULL;
7464 String interfaceType;
7465 String interfaceVersion;
7466
|
7467 marek 1.68 getInterfaceType(
7468 request->operationContext.get(ProviderIdContainer::NAME),
7469 interfaceType,
7470 interfaceVersion);
|
7471 mark.hamzy 1.43
7472 if (interfaceType == "JMPI")
7473 {
|
7474 marek 1.68 id = env->GetMethodID(
7475 (jclass)pr.jProviderClass,
7476 "setPropertyValue",
7477 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7478 "Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
|
7479 mark.hamzy 1.26
|
7480 mark.hamzy 1.43 if (id != NULL)
7481 {
7482 eMethodFound = METHOD_PROPERTYPROVIDER;
|
7483 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7484 "handleSetPropertyRequest: "
7485 "Found METHOD_PROPERTYPROVIDER.");
|
7486 mark.hamzy 1.43 }
7487 }
7488 else if (interfaceType == "JMPIExperimental")
7489 {
|
7490 marek 1.68 id = env->GetMethodID(
7491 (jclass)pr.jProviderClass,
7492 "setPropertyValue",
7493 "(Lorg/pegasus/jmpi/OperationContext;"
7494 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7495 "Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
|
7496 mark.hamzy 1.26
|
7497 mark.hamzy 1.43 if (id != NULL)
7498 {
7499 eMethodFound = METHOD_PROPERTYPROVIDER2;
|
7500 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7501 "handleSetPropertyRequest: "
7502 "Found METHOD_PROPERTYPROVIDER2.");
|
7503 mark.hamzy 1.43 }
|
7504 mark.hamzy 1.26 }
7505
7506 if (id == NULL)
7507 {
|
7508 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7509 "handleSetPropertyRequest: No method provider found!");
|
7510 mark.hamzy 1.43
7511 PEG_METHOD_EXIT();
7512
|
7513 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7514 CIM_ERR_FAILED,
7515 MessageLoaderParms(
|
7516 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
7517 marek 1.68 "Could not find a method for the provider based on "
7518 "InterfaceType."));
|
7519 mark.hamzy 1.26 }
7520
7521 JMPIjvm::checkException(env);
7522
7523 switch (eMethodFound)
7524 {
|
7525 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER:
7526 {
|
7527 marek 1.68 jlong jcopref = DEBUG_ConvertCToJava(
7528 CIMObjectPath*,
7529 jlong,
7530 objectPath);
7531 jobject jcop = env->NewObject(
7532 jv->CIMObjectPathClassRef,
7533 jv->CIMObjectPathNewJ,
7534 jcopref);
|
7535 mark.hamzy 1.43
7536 JMPIjvm::checkException(env);
7537
|
7538 marek 1.68 jstring joclass =
7539 env->NewStringUTF(
7540 request->instanceName.getClassName().getString().getCString());
|
7541 mark.hamzy 1.43
7542 JMPIjvm::checkException(env);
7543
|
7544 marek 1.68 jstring jpName =
7545 env->NewStringUTF(
7546 request->propertyName.getString().getCString());
|
7547 mark.hamzy 1.43
7548 JMPIjvm::checkException(env);
7549
7550 CIMValue *val = new CIMValue (request->newValue);
7551
7552 JMPIjvm::checkException(env);
7553
|
7554 marek 1.68 jlong jvalref = DEBUG_ConvertCToJava(CIMValue*, jlong, val);
7555 jobject jval = env->NewObject(
7556 jv->CIMValueClassRef,
7557 jv->CIMValueNewJ,
7558 jvalref);
|
7559 mark.hamzy 1.43
7560 JMPIjvm::checkException(env);
7561
|
7562 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
|
7563 mark.hamzy 1.43
7564 env->CallVoidMethod ((jobject)pr.jProvider,
7565 id,
7566 jcop,
7567 joclass,
7568 jpName,
7569 jval);
7570
7571 JMPIjvm::checkException(env);
7572 break;
7573 }
7574
7575 case METHOD_PROPERTYPROVIDER2:
|
7576 mark.hamzy 1.26 {
|
7577 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
7578 OperationContext*,
7579 jlong,
7580 &request->operationContext);
7581 jobject joc = env->NewObject(
7582 jv->OperationContextClassRef,
7583 jv->OperationContextNewJ,
7584 jocRef);
7585
7586 jlong jcopref = DEBUG_ConvertCToJava(
7587 CIMObjectPath*,
7588 jlong,
7589 objectPath);
7590 jobject jcop = env->NewObject(
7591 jv->CIMObjectPathClassRef,
7592 jv->CIMObjectPathNewJ,
7593 jcopref);
|
7594 mark.hamzy 1.26
7595 JMPIjvm::checkException(env);
7596
|
7597 marek 1.68 jstring joclass =
7598 env->NewStringUTF(
7599 request->instanceName.getClassName().getString().getCString());
|
7600 mark.hamzy 1.26
7601 JMPIjvm::checkException(env);
7602
|
7603 marek 1.68 jstring jpName =
7604 env->NewStringUTF(
7605 request->propertyName.getString().getCString());
|
7606 mark.hamzy 1.26
7607 JMPIjvm::checkException(env);
7608
|
7609 mark.hamzy 1.27 CIMValue *val = new CIMValue (request->newValue);
|
7610 mark.hamzy 1.26
7611 JMPIjvm::checkException(env);
7612
|
7613 marek 1.68 jlong jvalref = DEBUG_ConvertCToJava (CIMValue*, jlong, val);
7614 jobject jval = env->NewObject(
7615 jv->CIMValueClassRef,
7616 jv->CIMValueNewJ,
7617 jvalref);
|
7618 mark.hamzy 1.26
7619 JMPIjvm::checkException(env);
7620
|
7621 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
|
7622 mark.hamzy 1.26
7623 env->CallVoidMethod ((jobject)pr.jProvider,
7624 id,
|
7625 mark.hamzy 1.43 joc,
|
7626 mark.hamzy 1.26 jcop,
7627 joclass,
7628 jpName,
7629 jval);
7630
7631 JMPIjvm::checkException(env);
7632
|
7633 mark.hamzy 1.43 if (joc)
7634 {
|
7635 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
7636 mark.hamzy 1.43
7637 JMPIjvm::checkException(env);
7638 }
|
7639 mark.hamzy 1.26 break;
7640 }
7641
7642 case METHOD_UNKNOWN:
7643 {
|
7644 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7645 "handleSetPropertyRequest: Unknown method provider!");
|
7646 mark.hamzy 1.26 break;
7647 }
7648 }
7649 }
7650 HandlerCatch(handler);
7651
7652 if (env) JMPIjvm::detachThread();
7653
7654 PEG_METHOD_EXIT();
7655
7656 return(response);
7657 }
7658
|
7659 marek 1.68 Message * JMPIProviderManager::handleInvokeMethodRequest(
7660 const Message * message) throw()
|
7661 schuur 1.1 {
|
7662 marek 1.68 PEG_METHOD_ENTER(
7663 TRC_PROVIDERMANAGER,
7664 "JMPIProviderManager::handleInvokeMethodRequest");
|
7665 mark.hamzy 1.23
|
7666 kumpf 1.55 HandlerIntro(InvokeMethod,message,request,response,handler);
|
7667 schuur 1.1
|
7668 mark.hamzy 1.25 typedef enum {
7669 METHOD_UNKNOWN = 0,
|
7670 mark.hamzy 1.43 METHOD_CIMMETHODPROVIDER,
7671 METHOD_CIMMETHODPROVIDER2,
7672 METHOD_METHODPROVIDER,
7673 METHOD_METHODPROVIDER2,
|
7674 mark.hamzy 1.25 } METHOD_VERSION;
7675 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
7676 JNIEnv *env = NULL;
|
7677 schuur 1.13
|
7678 schuur 1.1 try {
|
7679 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
7680 "handleInvokeMethodRequest: "
7681 "name space = %s class name = %s",
7682 (const char*)request->nameSpace.getString().getCString(),
7683 (const char*)request->
7684 instanceName.getClassName().getString().getCString()
7685 ));
|
7686 mark.hamzy 1.23
|
7687 schuur 1.1 // make target object path
|
7688 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
7689 System::getHostName(),
7690 request->nameSpace,
7691 request->instanceName.getClassName(),
7692 request->instanceName.getKeyBindings());
|
7693 schuur 1.1
7694 // resolve provider name
|
7695 kumpf 1.2 ProviderName name = _resolveProviderName(
7696 request->operationContext.get(ProviderIdContainer::NAME));
|
7697 schuur 1.1
7698 // get cached or load new provider module
|
7699 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
7700 name.getPhysicalName(),
7701 name.getLogicalName(),
7702 String::EMPTY);
|
7703 schuur 1.1
|
7704 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
7705 schuur 1.1
|
7706 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
7707 "handleInvokeMethodRequest: "
7708 "Calling provider: %s",
7709 (const char*)pr.getName().getCString()
7710 ));
|
7711 schuur 1.11
|
7712 mark.hamzy 1.25 JvmVector *jv = 0;
|
7713 mark.hamzy 1.23
|
7714 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
7715 schuur 1.11
|
7716 mark.hamzy 1.37 if (!env)
7717 {
|
7718 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7719 "handleInvokeMethodRequest: "
7720 "Could not initialize the JVM (Java Virtual Machine) "
7721 "runtime environment.");
7722
|
7723 mark.hamzy 1.43 PEG_METHOD_EXIT();
7724
|
7725 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7726 CIM_ERR_FAILED,
7727 MessageLoaderParms(
|
7728 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
7729 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
7730 "runtime environment."));
|
7731 mark.hamzy 1.43 }
7732
7733 JMPIProvider::pm_service_op_lock op_lock(&pr);
7734
7735 jmethodID id = NULL;
7736 String interfaceType;
7737 String interfaceVersion;
7738
|
7739 marek 1.68 getInterfaceType(
7740 request->operationContext.get(ProviderIdContainer::NAME),
7741 interfaceType,
7742 interfaceVersion);
|
7743 mark.hamzy 1.43
7744 if (interfaceType == "JMPI")
7745 {
|
7746 marek 1.68 id = env->GetMethodID(
7747 (jclass)pr.jProviderClass,
7748 "invokeMethod",
7749 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7750 "Ljava/util/Vector;Ljava/util/Vector;)"
7751 "Lorg/pegasus/jmpi/CIMValue;");
|
7752 mark.hamzy 1.43
7753 if (id != NULL)
7754 {
7755 eMethodFound = METHOD_METHODPROVIDER;
|
7756 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7757 "handleInvokeMethodRequest: "
7758 "Found METHOD_PROPERTYPROVIDER.");
|
7759 mark.hamzy 1.43 }
7760
7761 if (id == NULL)
7762 {
7763 env->ExceptionClear();
|
7764 marek 1.68 id = env->GetMethodID(
7765 (jclass)pr.jProviderClass,
7766 "invokeMethod",
7767 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7768 "[Lorg/pegasus/jmpi/CIMArgument;"
7769 "[Lorg/pegasus/jmpi/CIMArgument;)"
7770 "Lorg/pegasus/jmpi/CIMValue;");
|
7771 mark.hamzy 1.43
7772 if (id != NULL)
7773 {
7774 eMethodFound = METHOD_CIMMETHODPROVIDER;
|
7775 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7776 "handleInvokeMethodRequest: "
7777 "Found METHOD_CIMMETHODPROVIDER.");
|
7778 mark.hamzy 1.43 }
7779 }
7780 }
7781 else if (interfaceType == "JMPIExperimental")
7782 {
|
7783 marek 1.68 id = env->GetMethodID(
7784 (jclass)pr.jProviderClass,
7785 "invokeMethod",
7786 "(Lorg/pegasus/jmpi/OperationContext;"
7787 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7788 "Ljava/util/Vector;Ljava/util/Vector;)"
7789 "Lorg/pegasus/jmpi/CIMValue;");
|
7790 mark.hamzy 1.43
7791 if (id != NULL)
7792 {
7793 eMethodFound = METHOD_METHODPROVIDER2;
|
7794 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7795 "handleInvokeMethodRequest: "
7796 "Found METHOD_METHODPROVIDER2.");
|
7797 mark.hamzy 1.43 }
7798
7799 if (id == NULL)
7800 {
7801 env->ExceptionClear();
7802
|
7803 marek 1.68 id = env->GetMethodID(
7804 (jclass)pr.jProviderClass,
7805 "invokeMethod",
7806 "(Lorg/pegasus/jmpi/OperationContext;"
7807 "Lorg/pegasus/jmpi/CIMObjectPath;"
7808 "Ljava/lang/String;"
7809 "[Lorg/pegasus/jmpi/CIMArgument;["
7810 "Lorg/pegasus/jmpi/CIMArgument;)"
7811 "Lorg/pegasus/jmpi/CIMValue;");
|
7812 mark.hamzy 1.43
7813 if (id != NULL)
7814 {
7815 eMethodFound = METHOD_CIMMETHODPROVIDER2;
|
7816 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7817 "handleInvokeMethodRequest: "
7818 "Found METHOD_CIMMETHODPROVIDER2.");
|
7819 mark.hamzy 1.43 }
7820 }
7821 }
7822
7823 if (id == NULL)
7824 {
|
7825 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7826 "handleInvokeMethod: No method provider found!");
|
7827 mark.hamzy 1.43
7828 PEG_METHOD_EXIT();
7829
|
7830 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7831 CIM_ERR_FAILED,
7832 MessageLoaderParms(
|
7833 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
7834 marek 1.68 "Could not find a method for the provider based on "
7835 "InterfaceType."));
|
7836 mark.hamzy 1.43 }
7837
7838 JMPIjvm::checkException(env);
7839
7840 switch (eMethodFound)
7841 {
7842 case METHOD_CIMMETHODPROVIDER:
7843 {
|
7844 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
7845 CIMObjectPath*,
7846 jlong,
7847 objectPath);
7848 jobject jcop = env->NewObject(
7849 jv->CIMObjectPathClassRef,
7850 jv->CIMObjectPathNewJ,
7851 jcopRef);
|
7852 mark.hamzy 1.43
7853 JMPIjvm::checkException(env);
7854
|
7855 marek 1.68 jstring jMethod =
7856 env->NewStringUTF(
7857 request->methodName.getString().getCString());
|
7858 mark.hamzy 1.43
7859 JMPIjvm::checkException(env);
7860
7861 Uint32 m=request->inParameters.size();
7862
|
7863 marek 1.68 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(
7864 m,
7865 jv->CIMArgumentClassRef,
7866 NULL);
|
7867 mark.hamzy 1.43
7868 for (Uint32 i=0; i<m; i++) {
|
7869 marek 1.68 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
7870 jlong jArgRef = DEBUG_ConvertCToJava(CIMParamValue*, jlong, parm);
7871 jobject jArg = env->NewObject(
7872 jv->CIMArgumentClassRef,
7873 jv->CIMArgumentNewJ,
7874 jArgRef);
|
7875 mark.hamzy 1.43
7876 env->SetObjectArrayElement(jArIn,i,jArg);
7877 }
7878
|
7879 marek 1.68 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(
7880 24,
7881 jv->CIMArgumentClassRef,
7882 NULL);
|
7883 mark.hamzy 1.43
|
7884 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
7885
|
7886 mark.hamzy 1.43 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
7887 id,
7888 jcop,
7889 jMethod,
7890 jArIn,
7891 jArOut);
7892 JMPIjvm::checkException(env);
|
7893 mark.hamzy 1.37
|
7894 mark.hamzy 1.43 handler.processing();
|
7895 mark.hamzy 1.37
|
7896 marek 1.68 jlong jValueRetRef = env->CallLongMethod(
7897 jValueRet,
7898 JMPIjvm::jv.CIMValueCInst);
7899 CIMValue *valueRet = DEBUG_ConvertJavaToC(
7900 jlong,
7901 CIMValue*,
7902 jValueRetRef);
|
7903 schuur 1.11
|
7904 mark.hamzy 1.43 handler.deliver(*valueRet);
|
7905 schuur 1.1
|
7906 mark.hamzy 1.43 for (int i=0; i<24; i++) {
7907 jobject jArg = env->GetObjectArrayElement(jArOut,i);
|
7908 mark.hamzy 1.25
|
7909 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
7910 mark.hamzy 1.25
|
7911 mark.hamzy 1.43 if (jArg==NULL)
7912 break;
|
7913 mark.hamzy 1.25
|
7914 marek 1.68 jlong jpRef = env->CallLongMethod(
7915 jArg,
7916 JMPIjvm::jv.CIMArgumentCInst);
7917 CIMParamValue *p = DEBUG_ConvertJavaToC(
7918 jlong,
7919 CIMParamValue*,
7920 jpRef);
|
7921 mark.hamzy 1.25
|
7922 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
7923 mark.hamzy 1.25
|
7924 mark.hamzy 1.43 handler.deliverParamValue(*p);
|
7925 mark.hamzy 1.25 }
|
7926 mark.hamzy 1.43
7927 handler.complete();
7928 break;
|
7929 mark.hamzy 1.23 }
|
7930 mark.hamzy 1.25
|
7931 mark.hamzy 1.43 case METHOD_CIMMETHODPROVIDER2:
7932 {
|
7933 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
7934 OperationContext*,
7935 jlong,
7936 &request->operationContext);
7937 jobject joc = env->NewObject(
7938 jv->OperationContextClassRef,
7939 jv->OperationContextNewJ,
7940 jocRef);
7941
7942 jlong jcopRef = DEBUG_ConvertCToJava(
7943 CIMObjectPath*,
7944 jlong,
7945 objectPath);
7946 jobject jcop = env->NewObject(
7947 jv->CIMObjectPathClassRef,
7948 jv->CIMObjectPathNewJ,
7949 jcopRef);
|
7950 mark.hamzy 1.25
7951 JMPIjvm::checkException(env);
7952
|
7953 marek 1.68 jstring jMethod =
7954 env->NewStringUTF(request->methodName.getString().getCString());
|
7955 mark.hamzy 1.29
|
7956 mark.hamzy 1.23 JMPIjvm::checkException(env);
7957
|
7958 mark.hamzy 1.25 Uint32 m=request->inParameters.size();
7959
|
7960 marek 1.68 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(
7961 m,
7962 jv->CIMArgumentClassRef,
7963 NULL);
|
7964 mark.hamzy 1.29
|
7965 mark.hamzy 1.25 for (Uint32 i=0; i<m; i++) {
|
7966 marek 1.68 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
7967 jlong jArgRef = DEBUG_ConvertCToJava(CIMParamValue*, jlong, parm);
7968 jobject jArg = env->NewObject(
7969 jv->CIMArgumentClassRef,
7970 jv->CIMArgumentNewJ,
7971 jArgRef);
|
7972 mark.hamzy 1.23
|
7973 mark.hamzy 1.25 env->SetObjectArrayElement(jArIn,i,jArg);
7974 }
|
7975 mark.hamzy 1.23
|
7976 marek 1.68 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(
7977 24,
7978 jv->CIMArgumentClassRef,
7979 NULL);
|
7980 mark.hamzy 1.23
|
7981 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
7982
|
7983 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
7984 id,
|
7985 mark.hamzy 1.43 joc,
|
7986 mark.hamzy 1.29 jcop,
7987 jMethod,
7988 jArIn,
7989 jArOut);
|
7990 mark.hamzy 1.23 JMPIjvm::checkException(env);
7991
|
7992 mark.hamzy 1.43 if (joc)
7993 {
|
7994 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
7995 mark.hamzy 1.43
7996 JMPIjvm::checkException(env);
7997 }
7998
|
7999 mark.hamzy 1.23 handler.processing();
8000
|
8001 marek 1.68 jlong jValueRetRef = env->CallLongMethod(
8002 jValueRet,
8003 JMPIjvm::jv.CIMValueCInst);
8004 CIMValue *valueRet = DEBUG_ConvertJavaToC(
8005 jlong,
8006 CIMValue*,
8007 jValueRetRef);
|
8008 mark.hamzy 1.23
|
8009 mark.hamzy 1.29 handler.deliver(*valueRet);
|
8010 schuur 1.13
|
8011 mark.hamzy 1.25 for (int i=0; i<24; i++) {
|
8012 mark.hamzy 1.29 jobject jArg = env->GetObjectArrayElement(jArOut,i);
8013
|
8014 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
8015 schuur 1.13
|
8016 mark.hamzy 1.29 if (jArg==NULL)
8017 break;
|
8018 schuur 1.13
|
8019 marek 1.68 jlong jpRef = env->CallLongMethod(
8020 jArg,
8021 JMPIjvm::jv.CIMArgumentCInst);
8022 CIMParamValue *p = DEBUG_ConvertJavaToC(
8023 jlong,
8024 CIMParamValue*,
8025 jpRef);
|
8026 schuur 1.13
|
8027 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
8028 schuur 1.1
|
8029 mark.hamzy 1.25 handler.deliverParamValue(*p);
|
8030 mark.hamzy 1.23 }
|
8031 schuur 1.1
|
8032 mark.hamzy 1.23 handler.complete();
|
8033 mark.hamzy 1.25 break;
|
8034 mark.hamzy 1.23 }
|
8035 schuur 1.11
|
8036 mark.hamzy 1.43 case METHOD_METHODPROVIDER:
8037 {
|
8038 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
8039 CIMObjectPath*,
8040 jlong,
8041 objectPath);
8042 jobject jcop = env->NewObject(
8043 jv->CIMObjectPathClassRef,
8044 jv->CIMObjectPathNewJ,
8045 jcopRef);
|
8046 mark.hamzy 1.43
8047 JMPIjvm::checkException(env);
8048
|
8049 marek 1.68 jstring jMethod = env->NewStringUTF(
8050 request->methodName.getString().getCString());
|
8051 mark.hamzy 1.43
8052 JMPIjvm::checkException(env);
8053
8054 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
8055
8056 JMPIjvm::checkException(env);
8057
8058 for (int i=0,m=request->inParameters.size(); i<m; i++)
8059 {
|
8060 marek 1.68 const CIMParamValue &parm = request->inParameters[i];
8061 const CIMValue v = parm.getValue();
8062 CIMProperty *p = new CIMProperty(
8063 parm.getParameterName(),
8064 v,
8065 v.getArraySize());
8066 jlong jpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, p);
8067 jobject jp = env->NewObject(
8068 jv->CIMPropertyClassRef,
8069 jv->CIMPropertyNewJ,
8070 jpRef);
|
8071 mark.hamzy 1.43
8072 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
8073 }
8074
8075 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
8076 JMPIjvm::checkException(env);
8077
|
8078 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8079
|
8080 mark.hamzy 1.43 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
8081 id,
8082 jcop,
8083 jMethod,
8084 jVecIn,
8085 jVecOut);
8086 JMPIjvm::checkException(env);
8087
8088 handler.processing();
8089
|
8090 marek 1.68 jlong jValueRetRef = env->CallLongMethod(
8091 jValueRet,
8092 JMPIjvm::jv.CIMValueCInst);
8093 CIMValue *valueRet = DEBUG_ConvertJavaToC(
8094 jlong,
8095 CIMValue*,
8096 jValueRetRef);
|
8097 mark.hamzy 1.43
8098 handler.deliver(*valueRet);
8099
|
8100 marek 1.68 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize);
8101 i<m;
8102 i++)
|
8103 mark.hamzy 1.43 {
8104 JMPIjvm::checkException(env);
8105
|
8106 marek 1.68 jobject jProp = env->CallObjectMethod(
8107 jVecOut,
8108 JMPIjvm::jv.VectorElementAt,
8109 i);
|
8110 mark.hamzy 1.43
8111 JMPIjvm::checkException(env);
8112
|
8113 marek 1.68 jlong jpRef = env->CallLongMethod(
8114 jProp,
8115 JMPIjvm::jv.CIMPropertyCInst);
8116 CIMProperty *p = DEBUG_ConvertJavaToC(
8117 jlong,
8118 CIMProperty*,
8119 jpRef);
|
8120 mark.hamzy 1.43
8121 JMPIjvm::checkException(env);
8122
|
8123 marek 1.68 handler.deliverParamValue(
8124 CIMParamValue(p->getName().getString(),
8125 p->getValue()));
|
8126 mark.hamzy 1.43 }
8127
8128 handler.complete();
8129 break;
8130 }
8131
8132 case METHOD_METHODPROVIDER2:
|
8133 mark.hamzy 1.25 {
|
8134 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
8135 OperationContext*,
8136 jlong,
8137 &request->operationContext);
8138 jobject joc = env->NewObject(
8139 jv->OperationContextClassRef,
8140 jv->OperationContextNewJ,
8141 jocRef);
8142
8143 jlong jcopRef = DEBUG_ConvertCToJava(
8144 CIMObjectPath*,
8145 jlong,
8146 objectPath);
8147 jobject jcop = env->NewObject(
8148 jv->CIMObjectPathClassRef,
8149 jv->CIMObjectPathNewJ,
8150 jcopRef);
|
8151 mark.hamzy 1.25
8152 JMPIjvm::checkException(env);
8153
|
8154 marek 1.68 jstring jMethod = env->NewStringUTF(
8155 request->methodName.getString().getCString());
|
8156 mark.hamzy 1.29
|
8157 mark.hamzy 1.25 JMPIjvm::checkException(env);
8158
|
8159 mark.hamzy 1.29 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
8160
|
8161 mark.hamzy 1.25 JMPIjvm::checkException(env);
8162
|
8163 mark.hamzy 1.29 for (int i=0,m=request->inParameters.size(); i<m; i++)
8164 {
8165 const CIMParamValue &parm = request->inParameters[i];
8166 const CIMValue v = parm.getValue();
|
8167 marek 1.68 CIMProperty *p = new CIMProperty(
8168 parm.getParameterName(),
8169 v,
8170 v.getArraySize());
8171 jlong jpRef = DEBUG_ConvertCToJava(CIMProperty*, jlong, p);
8172 jobject jp = env->NewObject(
8173 jv->CIMPropertyClassRef,
8174 jv->CIMPropertyNewJ,
8175 jpRef);
|
8176 mark.hamzy 1.23
|
8177 mark.hamzy 1.29 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
|
8178 mark.hamzy 1.25 }
|
8179 mark.hamzy 1.23
|
8180 mark.hamzy 1.25 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
8181 JMPIjvm::checkException(env);
|
8182 mark.hamzy 1.23
|
8183 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8184
|
8185 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
8186 id,
|
8187 mark.hamzy 1.43 joc,
|
8188 mark.hamzy 1.29 jcop,
8189 jMethod,
8190 jVecIn,
8191 jVecOut);
|
8192 mark.hamzy 1.23 JMPIjvm::checkException(env);
8193
|
8194 mark.hamzy 1.43 if (joc)
8195 {
|
8196 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
8197 mark.hamzy 1.43
8198 JMPIjvm::checkException(env);
8199 }
8200
|
8201 mark.hamzy 1.23 handler.processing();
|
8202 schuur 1.1
|
8203 marek 1.68 jlong jValueRetRef = env->CallLongMethod(
8204 jValueRet,
8205 JMPIjvm::jv.CIMValueCInst);
8206 CIMValue *valueRet = DEBUG_ConvertJavaToC(
8207 jlong,
8208 CIMValue*,
8209 jValueRetRef);
|
8210 mark.hamzy 1.23
|
8211 mark.hamzy 1.29 handler.deliver(*valueRet);
|
8212 mark.hamzy 1.23
|
8213 marek 1.68 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize);
8214 i<m;
8215 i++)
|
8216 mark.hamzy 1.29 {
|
8217 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
8218 schuur 1.13
|
8219 marek 1.68 jobject jProp = env->CallObjectMethod(
8220 jVecOut,
8221 JMPIjvm::jv.VectorElementAt,
8222 i);
|
8223 mark.hamzy 1.29
|
8224 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8225 schuur 1.13
|
8226 marek 1.68 jlong jpRef = env->CallLongMethod(
8227 jProp,
8228 JMPIjvm::jv.CIMPropertyCInst);
8229 CIMProperty *p = DEBUG_ConvertJavaToC(
8230 jlong,
8231 CIMProperty*,
8232 jpRef);
|
8233 schuur 1.13
|
8234 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
8235 schuur 1.13
|
8236 marek 1.68 handler.deliverParamValue(
8237 CIMParamValue(p->getName().getString(),
8238 p->getValue()));
|
8239 mark.hamzy 1.25 }
8240
8241 handler.complete();
8242 break;
8243 }
|
8244 mark.hamzy 1.23
|
8245 mark.hamzy 1.25 case METHOD_UNKNOWN:
8246 {
|
8247 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8248 "handleInvokeMethodRequest: Unknown method provider!");
|
8249 mark.hamzy 1.25 break;
8250 }
|
8251 mark.hamzy 1.23 }
|
8252 schuur 1.1 }
8253 HandlerCatch(handler);
|
8254 schuur 1.11
8255 if (env) JMPIjvm::detachThread();
8256
|
8257 schuur 1.1 PEG_METHOD_EXIT();
8258
|
8259 schuur 1.11 return(response);
|
8260 schuur 1.1 }
|
8261 mark.hamzy 1.23
|
8262 marek 1.68 int LocateIndicationProviderNames(
8263 const CIMInstance& pInstance,
8264 const CIMInstance& pmInstance,
8265 String& providerName,
8266 String& location)
|
8267 schuur 1.1 {
8268 Uint32 pos = pInstance.findProperty(CIMName ("Name"));
8269 pInstance.getProperty(pos).getValue().get(providerName);
8270
8271 pos = pmInstance.findProperty(CIMName ("Location"));
8272 pmInstance.getProperty(pos).getValue().get(location);
8273 return 0;
8274 }
8275
|
8276 mark.hamzy 1.52 WQLSelectStatement *
8277 newSelectExp (String& query,
8278 String& queryLanguage)
|
8279 mark.hamzy 1.44 {
|
8280 mark.hamzy 1.52 WQLSelectStatement *stmt = new WQLSelectStatement (queryLanguage, query);
|
8281 mark.hamzy 1.44
|
8282 mark.hamzy 1.52 try
|
8283 mark.hamzy 1.44 {
|
8284 mark.hamzy 1.52 WQLParser::parse (query, *stmt);
|
8285 mark.hamzy 1.44 }
|
8286 mark.hamzy 1.52 catch (const Exception &e)
|
8287 mark.hamzy 1.44 {
|
8288 mark.hamzy 1.52 cerr << "Error: newSelectExp caught: " << e.getMessage () << endl;
|
8289 mark.hamzy 1.44 }
8290
|
8291 mark.hamzy 1.52 return stmt;
|
8292 mark.hamzy 1.44 }
8293
|
8294 marek 1.68 Message * JMPIProviderManager::handleCreateSubscriptionRequest(
8295 const Message * message) throw()
|
8296 schuur 1.1 {
|
8297 marek 1.68 PEG_METHOD_ENTER(
8298 TRC_PROVIDERMANAGER,
8299 "JMPIProviderManager::handleCreateSubscriptionRequest");
|
8300 schuur 1.1
|
8301 mark.hamzy 1.23 HandlerIntroInd(CreateSubscription,message,request,response,handler);
8302
|
8303 mark.hamzy 1.25 typedef enum {
8304 METHOD_UNKNOWN = 0,
|
8305 mark.hamzy 1.43 METHOD_EVENTPROVIDER,
8306 METHOD_EVENTPROVIDER2,
|
8307 mark.hamzy 1.25 } METHOD_VERSION;
|
8308 mark.hamzy 1.44 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
8309 JNIEnv *env = NULL;
|
8310 mark.hamzy 1.25
|
8311 schuur 1.1 try {
|
8312 mark.hamzy 1.44 String fileName,
8313 providerName,
|
8314 mark.hamzy 1.25 providerLocation;
8315 CIMInstance req_provider,
8316 req_providerModule;
|
8317 marek 1.68 ProviderIdContainer pidc =
8318 (ProviderIdContainer) request->operationContext.get(
8319 ProviderIdContainer::NAME);
|
8320 mark.hamzy 1.25
|
8321 marek 1.68 req_provider = pidc.getProvider ();
|
8322 mark.hamzy 1.44 req_providerModule = pidc.getModule ();
|
8323 mark.hamzy 1.25
|
8324 marek 1.68 LocateIndicationProviderNames(
8325 req_provider,
8326 req_providerModule,
8327 providerName,
8328 providerLocation);
8329
8330 fileName = resolveFileName(providerLocation);
8331
|
8332 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
8333 "handleCreateSubscriptionRequest: "
8334 "name space = %s provider name = %s provider filename = %s",
|
8335 thilo.boehm 1.70 (const char*)request->nameSpace.getString().getCString(),
8336 (const char*)providerName.getCString(),
8337 (const char*)fileName.getCString()
|
8338 thilo.boehm 1.69 ));
|
8339 schuur 1.1
8340 // get cached or load new provider module
|
8341 marek 1.68 JMPIProvider::OpProviderHolder ph =
8342 providerManager.getProvider(
8343 fileName,
8344 providerName,
8345 String::EMPTY);
|
8346 schuur 1.1
|
8347 carolann.graves 1.21 //
8348 // Save the provider instance from the request
8349 //
8350 ph.GetProvider ().setProviderInstance (req_provider);
8351
|
8352 mark.hamzy 1.44 JMPIProvider &pr = ph.GetProvider ();
|
8353 mark.hamzy 1.25
|
8354 mark.hamzy 1.44 //
8355 // Increment count of current subscriptions for this provider
8356 //
8357 pr.testIfZeroAndIncrementSubscriptions ();
|
8358 schuur 1.1
|
8359 marek 1.68 SubscriptionFilterConditionContainer sub_cntr =
8360 request->operationContext.get(
8361 SubscriptionFilterConditionContainer::NAME);
8362 indProvRecord *prec = NULL;
8363 bool fNewPrec = false;
|
8364 schuur 1.1
|
8365 mark.hamzy 1.25 {
|
8366 mark.hamzy 1.44 AutoMutex lock (mutexProvTab);
8367
8368 provTab.lookup (providerName, prec);
|
8369 schuur 1.12
|
8370 mark.hamzy 1.44 if (!prec)
8371 {
8372 fNewPrec = true;
|
8373 schuur 1.1
|
8374 mark.hamzy 1.44 prec = new indProvRecord ();
|
8375 schuur 1.1
|
8376 mark.hamzy 1.44 // convert arguments
8377 prec->ctx = new OperationContext ();
|
8378 schuur 1.12
|
8379 marek 1.68 prec->ctx->insert(
8380 request->operationContext.get(
8381 IdentityContainer::NAME));
8382 prec->ctx->insert(
8383 request->operationContext.get(
8384 AcceptLanguageListContainer::NAME));
8385 prec->ctx->insert(
8386 request->operationContext.get(
8387 ContentLanguageListContainer::NAME));
8388 prec->ctx->insert(
8389 request->operationContext.get(
8390 SubscriptionInstanceContainer::NAME));
8391 prec->ctx->insert(
8392 request->operationContext.get(
8393 SubscriptionFilterConditionContainer::NAME));
|
8394 konrad.r 1.22
|
8395 mark.hamzy 1.44 prec->enabled = true;
|
8396 konrad.r 1.22
|
8397 marek 1.68 prec->handler = new EnableIndicationsResponseHandler(
8398 0,
8399 0,
8400 req_provider,
8401 _indicationCallback,
8402 _responseChunkCallback);
8403
|
8404 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
8405 marek 1.68 "handleCreateSubscriptionRequest: "
|
8406 thilo.boehm 1.69 "Adding %s to provTab.",
8407 (const char*)providerName.getCString()));
|
8408 schuur 1.1
|
8409 mark.hamzy 1.44 provTab.insert (providerName, prec);
8410 }
8411 }
|
8412 schuur 1.1
|
8413 mark.hamzy 1.44 {
8414 AutoMutex lock (prec->mutex);
|
8415 schuur 1.1
|
8416 mark.hamzy 1.44 prec->count++;
|
8417 schuur 1.1 }
8418
|
8419 mark.hamzy 1.44 // Add a selection record for JNI CIMOMHandle deliverEvent calls
8420 indSelectRecord *srec = new indSelectRecord ();
|
8421 mark.hamzy 1.29
8422 {
|
8423 mark.hamzy 1.44 srec->query = request->query;
8424 srec->queryLanguage = sub_cntr.getQueryLanguage ();
8425 srec->propertyList = request->propertyList;
8426
|
8427 marek 1.68 CIMOMHandleQueryContext *qContext =
8428 new CIMOMHandleQueryContext(
8429 CIMNamespaceName(
8430 request->nameSpace.getString()),
8431 *pr._cimom_handle);
|
8432 mark.hamzy 1.44 srec->qContext = qContext;
8433
|
8434 marek 1.68 CIMObjectPath sPath = request->subscriptionInstance.getPath();
|
8435 dave.sudlik 1.62 Array<CIMKeyBinding> kb;
|
8436 mark.hamzy 1.44
|
8437 dave.sudlik 1.62 // Technically we only need Name and Handler for uniqueness
8438 kb = sPath.getKeyBindings ();
8439
8440 // Add an entry for every provider.
8441 kb.append (CIMKeyBinding ("Provider",
8442 pr.getName (),
8443 CIMKeyBinding::STRING));
8444
8445 sPath.setKeyBindings (kb);
|
8446 mark.hamzy 1.29
|
8447 mark.hamzy 1.44 AutoMutex lock (mutexSelxTab);
|
8448 mark.hamzy 1.29
|
8449 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8450 "handleCreateSubscriptionRequest: "
8451 "Adding %s to selxTab.",
8452 (const char*)sPath.toString().getCString()));
|
8453 mark.hamzy 1.44
8454 selxTab.insert (sPath.toString (), srec);
8455
|
8456 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8457 "handleCreateSubscriptionRequest: "
|
8458 thilo.boehm 1.70 "For selxTab %s , srec = %p, qContext = %p",
|
8459 thilo.boehm 1.69 (const char*)sPath.toString().getCString(),
|
8460 thilo.boehm 1.70 srec,qContext));
|
8461 schuur 1.1 }
8462
|
8463 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
8464 "handleCreateSubscriptionRequest: Calling provider: %s",
8465 (const char*)pr.getName().getCString()));
|
8466 mark.hamzy 1.44
|
8467 mark.hamzy 1.25 JvmVector *jv = 0;
8468
8469 env = JMPIjvm::attachThread(&jv);
8470
|
8471 mark.hamzy 1.37 if (!env)
8472 {
|
8473 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8474 "handleCreateSubscriptionRequest: "
8475 "Could not initialize the JVM (Java Virtual Machine) "
8476 "runtime environment.");
8477
|
8478 mark.hamzy 1.37 PEG_METHOD_EXIT();
8479
|
8480 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
8481 CIM_ERR_FAILED,
8482 MessageLoaderParms(
|
8483 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
8484 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
8485 "runtime environment."));
|
8486 mark.hamzy 1.37 }
8487
|
8488 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
8489
|
8490 mark.hamzy 1.43 jmethodID id = NULL;
8491 String interfaceType;
8492 String interfaceVersion;
8493
|
8494 mark.hamzy 1.44 getInterfaceType (pidc,
|
8495 mark.hamzy 1.43 interfaceType,
8496 interfaceVersion);
8497
8498 if (interfaceType == "JMPI")
8499 {
|
8500 marek 1.68 id = env->GetMethodID(
8501 (jclass)pr.jProviderClass,
8502 "activateFilter",
8503 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
8504 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
8505 mark.hamzy 1.43
8506 if (id != NULL)
8507 {
8508 eMethodFound = METHOD_EVENTPROVIDER;
|
8509 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8510 "handleCreateSubscriptionRequest: "
8511 "Found METHOD_EVENTPROVIDER.");
|
8512 mark.hamzy 1.43 }
8513 }
8514 else if (interfaceType == "JMPIExperimental")
8515 {
|
8516 marek 1.68 id = env->GetMethodID(
8517 (jclass)pr.jProviderClass,
8518 "activateFilter",
8519 "(Lorg/pegasus/jmpi/OperationContext;"
8520 "Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
8521 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
8522 mark.hamzy 1.25
|
8523 mark.hamzy 1.43 if (id != NULL)
8524 {
8525 eMethodFound = METHOD_EVENTPROVIDER2;
|
8526 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8527 "handleCreateSubscriptionRequest: "
8528 "Found METHOD_EVENTPROVIDER2.");
|
8529 mark.hamzy 1.43 }
8530 }
|
8531 schuur 1.12
|
8532 mark.hamzy 1.43 if (id == NULL)
|
8533 mark.hamzy 1.25 {
|
8534 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8535 "handleCreateSubscriptionRequest: No method provider found!");
|
8536 mark.hamzy 1.43
8537 PEG_METHOD_EXIT();
8538
|
8539 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
8540 CIM_ERR_FAILED,
8541 MessageLoaderParms(
|
8542 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
8543 marek 1.68 "Could not find a method for the provider based on"
8544 " InterfaceType."));
|
8545 mark.hamzy 1.25 }
|
8546 mark.hamzy 1.23
8547 JMPIjvm::checkException(env);
8548
|
8549 mark.hamzy 1.25 switch (eMethodFound)
8550 {
|
8551 mark.hamzy 1.43 case METHOD_EVENTPROVIDER:
8552 {
|
8553 marek 1.68 WQLSelectStatement *stmt = newSelectExp(
8554 srec->query,
8555 srec->queryLanguage);
8556 jlong jStmtRef = DEBUG_ConvertCToJava(
8557 WQLSelectStatement *,
8558 jlong,
8559 stmt);
8560 jobject jSelectExp = env->NewObject(
8561 jv->SelectExpClassRef,
8562 jv->SelectExpNewJ,
8563 jStmtRef);
|
8564 mark.hamzy 1.43
8565 JMPIjvm::checkException(env);
8566
|
8567 marek 1.68 jstring jType = env->NewStringUTF(
8568 request->nameSpace.getString().getCString());
|
8569 mark.hamzy 1.43
8570 JMPIjvm::checkException(env);
8571
|
8572 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
8573 request->nameSpace,
8574 request->classNames[0]);
|
8575 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
8576 jobject jcop = env->NewObject(
8577 jv->CIMObjectPathClassRef,
8578 jv->CIMObjectPathNewJ,jcopRef);
|
8579 mark.hamzy 1.43
8580 JMPIjvm::checkException(env);
8581
|
8582 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8583
|
8584 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
8585 id,
|
8586 mark.hamzy 1.52 jSelectExp,
|
8587 mark.hamzy 1.44 jType,
8588 jcop,
8589 (jboolean)fNewPrec);
|
8590 mark.hamzy 1.43
8591 JMPIjvm::checkException(env);
8592 break;
8593 }
8594
8595 case METHOD_EVENTPROVIDER2:
|
8596 mark.hamzy 1.25 {
|
8597 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
8598 OperationContext*,
8599 jlong,
8600 &request->operationContext);
8601 jobject joc = env->NewObject(
8602 jv->OperationContextClassRef,
8603 jv->OperationContextNewJ,jocRef);
8604
8605 WQLSelectStatement *stmt = newSelectExp(srec->query,
8606 srec->queryLanguage);
8607 jlong jStmtRef = DEBUG_ConvertCToJava(
8608 WQLSelectStatement *,
8609 jlong,
8610 stmt);
8611 jobject jSelectExp = env->NewObject(
8612 jv->SelectExpClassRef,
8613 jv->SelectExpNewJ,
8614 jStmtRef);
|
8615 mark.hamzy 1.25
8616 JMPIjvm::checkException(env);
8617
|
8618 marek 1.68 jstring jType = env->NewStringUTF(
8619 request->nameSpace.getString().getCString());
|
8620 schuur 1.12
|
8621 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8622 schuur 1.1
|
8623 marek 1.68 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
8624 request->nameSpace,
8625 request->classNames[0]);
8626 jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
8627 jobject jcop = env->NewObject(
8628 jv->CIMObjectPathClassRef,
8629 jv->CIMObjectPathNewJ,jcopRef);
|
8630 schuur 1.1
|
8631 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8632 schuur 1.1
|
8633 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8634
|
8635 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
8636 id,
8637 joc,
|
8638 mark.hamzy 1.52 jSelectExp,
|
8639 mark.hamzy 1.44 jType,
8640 jcop,
8641 (jboolean)fNewPrec);
|
8642 schuur 1.12
|
8643 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8644 schuur 1.1
|
8645 mark.hamzy 1.43 if (joc)
8646 {
|
8647 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
8648 mark.hamzy 1.43
8649 JMPIjvm::checkException(env);
8650 }
|
8651 mark.hamzy 1.25 break;
|
8652 carolann.graves 1.21 }
8653
|
8654 mark.hamzy 1.25 case METHOD_UNKNOWN:
8655 {
|
8656 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8657 "handleCreateSubscriptionRequest: Unknown method provider!");
|
8658 mark.hamzy 1.25 break;
8659 }
8660 }
|
8661 schuur 1.1 }
8662 HandlerCatch(handler);
|
8663 schuur 1.12
|
8664 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
8665
|
8666 schuur 1.1 PEG_METHOD_EXIT();
8667
8668 return(response);
8669 }
8670
|
8671 marek 1.68 Message * JMPIProviderManager::handleDeleteSubscriptionRequest(
8672 const Message * message) throw()
|
8673 schuur 1.1 {
|
8674 marek 1.68 PEG_METHOD_ENTER(
8675 TRC_PROVIDERMANAGER,
8676 "JMPIProviderManager::handleDeleteSubscriptionRequest");
|
8677 schuur 1.1
|
8678 mark.hamzy 1.23 HandlerIntroInd(DeleteSubscription,message,request,response,handler);
8679
|
8680 mark.hamzy 1.25 typedef enum {
8681 METHOD_UNKNOWN = 0,
|
8682 mark.hamzy 1.43 METHOD_EVENTPROVIDER,
8683 METHOD_EVENTPROVIDER2,
|
8684 mark.hamzy 1.25 } METHOD_VERSION;
|
8685 mark.hamzy 1.44 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
8686 JNIEnv *env = NULL;
8687 bool fFreePrec = false;
8688 indProvRecord *prec = NULL;
8689 indSelectRecord *srec = NULL;
|
8690 mark.hamzy 1.25
|
8691 schuur 1.1 try {
|
8692 mark.hamzy 1.44 String fileName,
8693 providerName,
|
8694 mark.hamzy 1.25 providerLocation;
8695 CIMInstance req_provider,
8696 req_providerModule;
|
8697 marek 1.68 ProviderIdContainer pidc = (ProviderIdContainer)
8698 request->operationContext.get(
8699 ProviderIdContainer::NAME);
|
8700 mark.hamzy 1.25
|
8701 mark.hamzy 1.44 req_provider = pidc.getProvider ();
8702 req_providerModule = pidc.getModule ();
8703
8704 LocateIndicationProviderNames (req_provider,
8705 req_providerModule,
8706 providerName,
8707 providerLocation);
8708
8709 fileName = resolveFileName (providerLocation);
8710
|
8711 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
8712 "handleDeleteSubscriptionRequest: "
8713 "name space = %s provider name = %s provider filename = %s",
8714 (const char*)request->nameSpace.getString().getCString(),
|
8715 thilo.boehm 1.70 (const char*)providerName.getCString(),
8716 (const char*)fileName.getCString()
|
8717 thilo.boehm 1.69 ));
|
8718 se.gupta 1.9
|
8719 mark.hamzy 1.44 // get cached or load new provider module
|
8720 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
8721 fileName,
8722 providerName,
8723 String::EMPTY);
|
8724 schuur 1.1
|
8725 mark.hamzy 1.44 JMPIProvider &pr = ph.GetProvider ();
8726
8727 {
8728 AutoMutex lock (mutexProvTab);
8729
8730 provTab.lookup (providerName, prec);
8731 }
|
8732 schuur 1.1
|
8733 mark.hamzy 1.44 {
8734 AutoMutex lock (prec->mutex);
|
8735 mark.hamzy 1.23
|
8736 mark.hamzy 1.44 if (--prec->count <= 0)
8737 {
|
8738 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8739 "handleDeleteSubscriptionRequest: "
8740 "Removing %s from provTab.",
8741 (const char*)providerName.getCString()));
|
8742 schuur 1.1
|
8743 mark.hamzy 1.44 provTab.remove (providerName);
|
8744 schuur 1.1
|
8745 mark.hamzy 1.44 fFreePrec = true;
8746 }
8747 }
|
8748 mark.hamzy 1.25
8749 {
|
8750 marek 1.68 CIMObjectPath sPath = request->subscriptionInstance.getPath();
|
8751 dave.sudlik 1.62 Array<CIMKeyBinding> kb;
8752
8753 // Technically we only need Name and Handler for uniqueness
8754 kb = sPath.getKeyBindings ();
|
8755 mark.hamzy 1.44
|
8756 dave.sudlik 1.62 // Add an entry for every provider.
8757 kb.append (CIMKeyBinding ("Provider",
8758 pr.getName (),
8759 CIMKeyBinding::STRING));
8760
8761 sPath.setKeyBindings (kb);
|
8762 schuur 1.1
|
8763 mark.hamzy 1.44 String sPathString = sPath.toString ();
|
8764 mark.hamzy 1.25
|
8765 mark.hamzy 1.44 AutoMutex lock (mutexSelxTab);
|
8766 schuur 1.1
|
8767 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8768 "handleDeleteSubscriptionRequest: "
8769 "Removing %s from selxTab.",
8770 (const char*)sPathString.getCString()));
|
8771 konrad.r 1.22
|
8772 dave.sudlik 1.62 if (!selxTab.lookup (sPathString, srec))
8773 {
8774 PEGASUS_ASSERT(0);
8775 }
|
8776 schuur 1.1
|
8777 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8778 "handleDeleteSubscriptionRequest: "
|
8779 thilo.boehm 1.70 "For selxTab %s , srec = %p, qContext = %p",
|
8780 thilo.boehm 1.69 (const char*)sPathString.getCString(),
|
8781 thilo.boehm 1.70 srec,srec->qContext));
|
8782 schuur 1.1
|
8783 mark.hamzy 1.44 selxTab.remove (sPathString);
8784 }
|
8785 schuur 1.1
|
8786 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
8787 "handleDeleteSubscriptionRequest: "
8788 "Calling provider: %s",
8789 (const char*)pr.getName().getCString()));
|
8790 schuur 1.1
|
8791 mark.hamzy 1.25 JvmVector *jv = 0;
8792
8793 env = JMPIjvm::attachThread(&jv);
8794
|
8795 mark.hamzy 1.37 if (!env)
8796 {
|
8797 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8798 "handleDeleteSubscriptionRequest: "
8799 "Could not initialize the JVM (Java Virtual Machine) "
8800 "runtime environment.");
8801
|
8802 mark.hamzy 1.37 PEG_METHOD_EXIT();
8803
|
8804 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
8805 CIM_ERR_FAILED,
8806 MessageLoaderParms(
|
8807 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
8808 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
8809 "runtime environment."));
|
8810 mark.hamzy 1.37 }
8811
|
8812 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
8813
|
8814 mark.hamzy 1.43 jmethodID id = NULL;
8815 String interfaceType;
8816 String interfaceVersion;
8817
|
8818 marek 1.68 getInterfaceType(
8819 request->operationContext.get(ProviderIdContainer::NAME),
8820 interfaceType,
8821 interfaceVersion);
|
8822 mark.hamzy 1.43
8823 if (interfaceType == "JMPI")
8824 {
|
8825 marek 1.68 id = env->GetMethodID(
8826 (jclass)pr.jProviderClass,
8827 "deActivateFilter",
8828 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
8829 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
8830 mark.hamzy 1.43
8831 if (id != NULL)
8832 {
8833 eMethodFound = METHOD_EVENTPROVIDER;
|
8834 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8835 "handleDeleteSubscriptionRequest: "
8836 "Found METHOD_EVENTPROVIDER.");
|
8837 mark.hamzy 1.43 }
8838 }
8839 else if (interfaceType == "JMPIExperimental")
8840 {
|
8841 marek 1.68 id = env->GetMethodID(
8842 (jclass)pr.jProviderClass,
8843 "deActivateFilter",
8844 "(Lorg/pegasus/jmpi/OperationContext;"
8845 "Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
8846 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
8847 mark.hamzy 1.25
|
8848 mark.hamzy 1.43 if (id != NULL)
8849 {
8850 eMethodFound = METHOD_EVENTPROVIDER2;
|
8851 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8852 "handleDeleteSubscriptionRequest: "
8853 "Found METHOD_EVENTPROVIDER2.");
|
8854 mark.hamzy 1.43 }
8855 }
|
8856 schuur 1.12
|
8857 mark.hamzy 1.43 if (id == NULL)
|
8858 mark.hamzy 1.25 {
|
8859 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8860 "handleDeleteSubscriptionRequest: No method provider found!");
|
8861 mark.hamzy 1.43
8862 PEG_METHOD_EXIT();
8863
|
8864 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
8865 CIM_ERR_FAILED,
8866 MessageLoaderParms(
|
8867 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
8868 marek 1.68 "Could not find a method for the provider based on"
8869 " InterfaceType."));
|
8870 mark.hamzy 1.25 }
|
8871 mark.hamzy 1.23
8872 JMPIjvm::checkException(env);
8873
|
8874 mark.hamzy 1.25 switch (eMethodFound)
8875 {
|
8876 mark.hamzy 1.43 case METHOD_EVENTPROVIDER:
8877 {
|
8878 marek 1.68 WQLSelectStatement *stmt = newSelectExp(
8879 srec->query,
8880 srec->queryLanguage);
8881 jlong jStmtRef = DEBUG_ConvertCToJava(
8882 WQLSelectStatement *,
8883 jlong,
8884 stmt);
8885 jobject jSelectExp = env->NewObject(
8886 jv->SelectExpClassRef,
8887 jv->SelectExpNewJ,jStmtRef);
|
8888 mark.hamzy 1.43
8889 JMPIjvm::checkException(env);
8890
|
8891 marek 1.68 jstring jType = env->NewStringUTF(
8892 request->nameSpace.getString().getCString());
|
8893 mark.hamzy 1.43
8894 JMPIjvm::checkException(env);
8895
|
8896 marek 1.68 CIMObjectPath *cop = new CIMObjectPath(
8897 System::getHostName(),
8898 request->nameSpace,
8899 request->classNames[0]);
8900 jlong jcopRef = DEBUG_ConvertCToJava(CIMObjectPath*, jlong, cop);
8901 jobject jcop = env->NewObject(
8902 jv->CIMObjectPathClassRef,
8903 jv->CIMObjectPathNewJ,jcopRef);
|
8904 mark.hamzy 1.43
8905 JMPIjvm::checkException(env);
8906
|
8907 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8908
|
8909 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
8910 id,
|
8911 mark.hamzy 1.52 jSelectExp,
|
8912 mark.hamzy 1.44 jType,
8913 jcop,
8914 (jboolean)fFreePrec);
|
8915 mark.hamzy 1.43
8916 JMPIjvm::checkException(env);
8917 break;
8918 }
8919
8920 case METHOD_EVENTPROVIDER2:
|
8921 mark.hamzy 1.25 {
|
8922 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
8923 OperationContext*,
8924 jlong,
8925 &request->operationContext);
8926 jobject joc = env->NewObject(
8927 jv->OperationContextClassRef,
8928 jv->OperationContextNewJ,jocRef);
|
8929 mark.hamzy 1.43
|
8930 mark.hamzy 1.52 WQLSelectStatement *stmt = newSelectExp (srec->query,
8931 srec->queryLanguage);
|
8932 marek 1.68 jlong jStmtRef = DEBUG_ConvertCToJava(
8933 WQLSelectStatement *,
8934 jlong,
8935 stmt);
8936 jobject jSelectExp = env->NewObject(
8937 jv->SelectExpClassRef,
8938 jv->SelectExpNewJ,
8939 jStmtRef);
|
8940 mark.hamzy 1.25
8941 JMPIjvm::checkException(env);
8942
|
8943 marek 1.68 jstring jType = env->NewStringUTF(
8944 request->nameSpace.getString().getCString());
|
8945 schuur 1.12
|
8946 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8947 schuur 1.12
|
8948 marek 1.68 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
8949 request->nameSpace,
8950 request->classNames[0]);
8951 jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
8952 jobject jcop = env->NewObject(
8953 jv->CIMObjectPathClassRef,
8954 jv->CIMObjectPathNewJ,jcopRef);
|
8955 schuur 1.1
|
8956 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8957 schuur 1.1
|
8958 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8959
|
8960 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
8961 id,
8962 joc,
|
8963 mark.hamzy 1.52 jSelectExp,
|
8964 mark.hamzy 1.44 jType,
8965 jcop,
8966 (jboolean)fFreePrec);
|
8967 schuur 1.1
|
8968 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8969 schuur 1.1
|
8970 mark.hamzy 1.43 if (joc)
8971 {
|
8972 marek 1.68 env->CallVoidMethod(
8973 joc,
8974 JMPIjvm::jv.OperationContextUnassociate);
|
8975 mark.hamzy 1.43
8976 JMPIjvm::checkException(env);
8977 }
|
8978 mark.hamzy 1.25 break;
8979 }
|
8980 schuur 1.12
|
8981 mark.hamzy 1.25 case METHOD_UNKNOWN:
8982 {
|
8983 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8984 "handleDeleteSubscriptionRequest: Unknown method provider!");
|
8985 mark.hamzy 1.25 break;
8986 }
8987 }
|
8988 mark.hamzy 1.44
8989 //
8990 // Decrement count of current subscriptions for this provider
8991 //
8992 pr.decrementSubscriptionsAndTestIfZero ();
|
8993 schuur 1.1 }
8994 HandlerCatch(handler);
|
8995 schuur 1.12
|
8996 mark.hamzy 1.44 if (srec)
8997 {
8998 delete srec->qContext;
8999 }
9000 delete srec;
9001
9002 if (fFreePrec)
9003 {
9004 delete prec->ctx;
9005 delete prec->handler;
9006 delete prec;
9007 }
9008
|
9009 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
9010
|
9011 schuur 1.1 PEG_METHOD_EXIT();
9012
9013 return(response);
9014 }
9015
|
9016 marek 1.68 Message * JMPIProviderManager::handleDisableModuleRequest(
9017 const Message * message) throw()
|
9018 schuur 1.1 {
|
9019 marek 1.68 PEG_METHOD_ENTER(
9020 TRC_PROVIDERMANAGER,
9021 "JMPIProviderManager::handleDisableModuleRequest");
|
9022 schuur 1.1
9023 CIMDisableModuleRequestMessage * request =
|
9024 marek 1.68 dynamic_cast<CIMDisableModuleRequestMessage *>
9025 (const_cast<Message *>(message));
|
9026 schuur 1.1
9027 PEGASUS_ASSERT(request != 0);
9028
9029 // get provider module name
9030 String moduleName;
9031 CIMInstance mInstance = request->providerModule;
9032 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
9033
9034 if(pos != PEG_NOT_FOUND)
9035 {
9036 mInstance.getProperty(pos).getValue().get(moduleName);
9037 }
9038
9039 Boolean disableProviderOnly = request->disableProviderOnly;
9040
9041 Array<Uint16> operationalStatus;
|
9042 kumpf 1.2 // Assume success.
|
9043 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
9044 schuur 1.1
|
9045 kumpf 1.2 //
|
9046 schuur 1.1 // Unload providers
|
9047 kumpf 1.2 //
|
9048 schuur 1.1 Array<CIMInstance> _pInstances = request->providers;
9049
|
9050 kumpf 1.67 CIMDisableModuleResponseMessage* response =
9051 dynamic_cast<CIMDisableModuleResponseMessage*>(
9052 request->buildResponse());
|
9053 schuur 1.1 PEGASUS_ASSERT(response != 0);
|
9054 kumpf 1.67 response->operationalStatus = operationalStatus;
|
9055 schuur 1.1
9056 PEG_METHOD_EXIT();
9057
9058 return(response);
9059 }
9060
|
9061 marek 1.68 Message * JMPIProviderManager::handleEnableModuleRequest(
9062 const Message * message) throw()
|
9063 schuur 1.1 {
|
9064 marek 1.68 PEG_METHOD_ENTER(
9065 TRC_PROVIDERMANAGER,
9066 "JMPIProviderManager::handleEnableModuleRequest");
|
9067 schuur 1.1
9068 CIMEnableModuleRequestMessage * request =
|
9069 marek 1.68 dynamic_cast<CIMEnableModuleRequestMessage *>
9070 (const_cast<Message *>(message));
|
9071 schuur 1.1
9072 PEGASUS_ASSERT(request != 0);
9073
9074 Array<Uint16> operationalStatus;
|
9075 kumpf 1.67 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
9076 schuur 1.1
|
9077 kumpf 1.67 CIMEnableModuleResponseMessage* response =
9078 dynamic_cast<CIMEnableModuleResponseMessage*>(
9079 request->buildResponse());
|
9080 schuur 1.1 PEGASUS_ASSERT(response != 0);
|
9081 kumpf 1.67 response->operationalStatus = operationalStatus;
|
9082 schuur 1.1
9083 PEG_METHOD_EXIT();
9084
9085 return(response);
9086 }
9087
|
9088 marek 1.68 Message * JMPIProviderManager::handleStopAllProvidersRequest(
9089 const Message * message) throw()
|
9090 schuur 1.1 {
|
9091 marek 1.68 PEG_METHOD_ENTER(
9092 TRC_PROVIDERMANAGER,
9093 "JMPIProviderManager::handleStopAllProvidersRequest");
|
9094 schuur 1.1
9095 CIMStopAllProvidersRequestMessage * request =
|
9096 marek 1.68 dynamic_cast<CIMStopAllProvidersRequestMessage *>
9097 (const_cast<Message *>(message));
|
9098 schuur 1.1
9099 PEGASUS_ASSERT(request != 0);
9100
|
9101 kumpf 1.67 CIMStopAllProvidersResponseMessage* response =
9102 dynamic_cast<CIMStopAllProvidersResponseMessage*>(
9103 request->buildResponse());
|
9104 schuur 1.1 PEGASUS_ASSERT(response != 0);
9105
9106 // tell the provider manager to shutdown all the providers
9107 providerManager.shutdownAllProviders();
9108
9109 PEG_METHOD_EXIT();
9110
9111 return(response);
9112 }
9113
|
9114 marek 1.68 Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest(
9115 const Message * message)
|
9116 carolann.graves 1.21 {
9117 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
9118 "JMPIProviderManager::handleSubscriptionInitCompleteRequest");
9119
9120 CIMSubscriptionInitCompleteRequestMessage * request =
9121 dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
9122 (const_cast <Message *> (message));
9123
9124 PEGASUS_ASSERT (request != 0);
9125
9126 CIMSubscriptionInitCompleteResponseMessage * response =
9127 dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
9128 (request->buildResponse ());
9129
9130 PEGASUS_ASSERT (response != 0);
9131
9132 //
9133 // Set indicator
9134 //
9135 _subscriptionInitComplete = true;
9136
9137 carolann.graves 1.21 //
9138 // For each provider that has at least one subscription, call
9139 // provider's enableIndications method
9140 //
9141 Array <JMPIProvider *> enableProviders;
|
9142 mark.hamzy 1.44
|
9143 carolann.graves 1.21 enableProviders = providerManager.getIndicationProvidersToEnable ();
9144
9145 Uint32 numProviders = enableProviders.size ();
|
9146 mark.hamzy 1.44
|
9147 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
9148 "handleSubscriptionInitCompleteRequest: numProviders = %d ",
9149 numProviders));
|
9150 carolann.graves 1.21
9151 PEG_METHOD_EXIT ();
9152 return (response);
9153 }
9154
|
9155 marek 1.68 Message * JMPIProviderManager::handleUnsupportedRequest(
9156 const Message * message) throw()
|
9157 schuur 1.1 {
|
9158 marek 1.68 PEG_METHOD_ENTER(
9159 TRC_PROVIDERMANAGER,
9160 "JMPIProviderManager::handleUnsupportedRequest");
|
9161 mark.hamzy 1.23
|
9162 konrad.r 1.16 CIMRequestMessage* request =
9163 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
9164 PEGASUS_ASSERT(request != 0 );
9165
9166 CIMResponseMessage* response = request->buildResponse();
9167 response->cimException =
9168 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
|
9169 schuur 1.1
9170 PEG_METHOD_EXIT();
|
9171 konrad.r 1.16 return response;
|
9172 schuur 1.1 }
9173
|
9174 kumpf 1.2 ProviderName JMPIProviderManager::_resolveProviderName(
9175 const ProviderIdContainer & providerId)
|
9176 schuur 1.1 {
|
9177 kumpf 1.2 String providerName;
9178 String fileName;
|
9179 dmitry.mikulin 1.63 String moduleName;
|
9180 kumpf 1.2 CIMValue genericValue;
9181
|
9182 dmitry.mikulin 1.63 genericValue = providerId.getModule().getProperty(
9183 providerId.getModule().findProperty("Name")).getValue();
9184 genericValue.get(moduleName);
9185
|
9186 kumpf 1.2 genericValue = providerId.getProvider().getProperty(
9187 providerId.getProvider().findProperty("Name")).getValue();
9188 genericValue.get(providerName);
9189
9190 genericValue = providerId.getModule().getProperty(
9191 providerId.getModule().findProperty("Location")).getValue();
9192 genericValue.get(fileName);
9193 fileName = resolveFileName(fileName);
9194
|
9195 dmitry.mikulin 1.63 return ProviderName(moduleName, providerName, fileName);
|
9196 schuur 1.1 }
9197
9198 String JMPIProviderManager::resolveFileName(String fileName)
9199 {
|
9200 marek 1.68 String name = ConfigManager::getHomedPath(
9201 ConfigManager::getInstance()->getCurrentValue("providerDir"));
|
9202 marek 1.54 // physfilename = everything up to the delimiter pointing at class start
9203 // in case there is no delimiter anymore, it takes the entire filename
9204 String physfilename = fileName.subString(0, fileName.find(":"));
9205 // look in all(multiple) homed pathes for the physical file
9206 name = FileSystem::getAbsoluteFileName(name, physfilename);
9207 // construct back the fully specified jar:<classname> provider name
9208 name = FileSystem::extractFilePath(name) + fileName;
|
9209 schuur 1.1 return name;
9210 }
9211
9212 PEGASUS_NAMESPACE_END
|
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI