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