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 handler.deliver(*ciRet);
6089 }
6090 }
6091 handler.complete();
6092 break;
6093 }
6094
6095 case METHOD_CIMASSOCIATORPROVIDER2:
6096 {
|
6097 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
6098 OperationContext*,
6099 jlong,
6100 &request->operationContext);
6101 jobject joc = env->NewObject(
6102 jv->OperationContextClassRef,
6103 jv->OperationContextNewJ,
6104 jocRef);
6105
6106 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6107 CIMObjectPath*,
6108 jlong,
6109 resultPath);
6110 jobject jAssociationName = env->NewObject(
6111 jv->CIMObjectPathClassRef,
6112 jv->CIMObjectPathNewJ,
6113 jAssociationNameRef);
|
6114 mark.hamzy 1.43
6115 JMPIjvm::checkException(env);
6116
|
6117 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6118 CIMObjectPath*,
6119 jlong,
6120 objectPath);
6121 jobject jPathName = env->NewObject(
6122 jv->CIMObjectPathClassRef,
6123 jv->CIMObjectPathNewJ,
6124 jPathNameRef);
|
6125 mark.hamzy 1.43
6126 JMPIjvm::checkException(env);
6127
6128 jstring jRole = env->NewStringUTF(request->role.getCString());
6129
6130 JMPIjvm::checkException(env);
6131
6132 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
6133 schuur 1.1
|
6134 mark.hamzy 1.43 #ifdef PEGASUS_DEBUG
|
6135 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6136 "handleReferencesRequest: assocName = %s ",
6137 (const char*)resultPath->toString().getCString()));
6138 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6139 "handleReferencesRequest: role = %s ",
6140 (const char*)request->role.getCString()));
6141 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6142 "handleReferencesRequest: includeQualifiers = false");
6143 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6144 "handleReferencesRequest: includeClassOrigin = false");
|
6145 mark.hamzy 1.43 #endif
|
6146 schuur 1.1
|
6147 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6148
|
6149 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
6150 (jobject)pr.jProvider,
6151 id,
6152 joc,
6153 jAssociationName,
6154 jPathName,
6155 jRole,
6156 JMPI_INCLUDE_QUALIFIERS,
6157 request->includeClassOrigin,
6158 jPropertyList);
|
6159 schuur 1.1
|
6160 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6161 mark.hamzy 1.24
|
6162 mark.hamzy 1.43 if (joc)
6163 {
|
6164 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
6165 schuur 1.1
|
6166 mark.hamzy 1.43 JMPIjvm::checkException(env);
6167 }
|
6168 schuur 1.1
|
6169 mark.hamzy 1.43 handler.processing();
|
6170 mark.hamzy 1.45 if (jAr) {
6171 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
6172 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6173 schuur 1.1
|
6174 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
6175 mark.hamzy 1.37
|
6176 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6177 mark.hamzy 1.37
|
6178 marek 1.68 jlong jciRetRef = env->CallLongMethod(
6179 jciRet,
6180 JMPIjvm::jv.CIMInstanceCInst);
|
6181 mark.hamzy 1.37
|
6182 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6183 schuur 1.1
|
6184 marek 1.68 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
6185 jlong,
6186 CIMInstance*,
6187 jciRetRef);
|
6188 mark.hamzy 1.43 CIMClass cls;
|
6189 schuur 1.1
|
6190 mark.hamzy 1.43 try
6191 {
|
6192 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6193 "handleReferencesRequest: "
6194 "enter(METHOD_CIMASSOCIATORPROVIDER2): "
6195 "cimom_handle->getClass(%s).",
6196 (const char*)ciRet->
6197 getClassName().getString().getCString()
6198 ));
6199
|
6200 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
|
6201 mark.hamzy 1.24
|
6202 mark.hamzy 1.43 cls = pr._cimom_handle->getClass(context,
6203 request->nameSpace,
6204 ciRet->getClassName(),
6205 false,
6206 true,
6207 true,
6208 CIMPropertyList());
|
6209 thilo.boehm 1.69
6210 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6211 "handleReferencesRequest: "
6212 "exit(METHOD_CIMASSOCIATORPROVIDER2): "
6213 "cimom_handle->getClass(%s).",
6214 (const char*)ciRet->
6215 getClassName().getString().getCString()
6216 ));
|
6217 mark.hamzy 1.43 }
6218 catch (CIMException e)
6219 {
|
6220 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6221 "handleReferencesRequest: "
6222 "Caught CIMExcetion(METHOD_CIMASSOCIATORPROVIDER2) "
6223 "during cimom_handle->getClass(%s): %s ",
6224 (const char*)ciRet->
6225 getClassName().getString().getCString(),
6226 (const char*)e.getMessage().getCString()
6227 ));
6228
6229 PEG_METHOD_EXIT();
|
6230 mark.hamzy 1.43 throw;
6231 }
|
6232 mark.hamzy 1.24
|
6233 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
6234 CIMObjectPath iop = ciRet->buildPath(cls);
|
6235 mark.hamzy 1.24
|
6236 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6237 mark.hamzy 1.24
|
6238 mark.hamzy 1.43 iop.setNameSpace(op.getNameSpace());
6239 ciRet->setPath(iop);
|
6240 mark.hamzy 1.24
|
6241 mark.hamzy 1.43 handler.deliver(*ciRet);
6242 }
|
6243 mark.hamzy 1.24 }
|
6244 mark.hamzy 1.43 handler.complete();
6245 break;
|
6246 mark.hamzy 1.24 }
|
6247 schuur 1.12
|
6248 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
|
6249 mark.hamzy 1.24 {
|
6250 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6251 CIMObjectPath*,
6252 jlong,
6253 resultPath);
6254 jobject jAssociationName = env->NewObject(
6255 jv->CIMObjectPathClassRef,
6256 jv->CIMObjectPathNewJ,
6257 jAssociationNameRef);
|
6258 mark.hamzy 1.24
|
6259 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6260 schuur 1.1
|
6261 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6262 CIMObjectPath*,
6263 jlong,
6264 objectPath);
6265 jobject jPathName = env->NewObject(
6266 jv->CIMObjectPathClassRef,
6267 jv->CIMObjectPathNewJ,
6268 jPathNameRef);
|
6269 mark.hamzy 1.25
6270 JMPIjvm::checkException(env);
6271
6272 jstring jRole = env->NewStringUTF(request->role.getCString());
6273
6274 JMPIjvm::checkException(env);
6275
6276 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
6277
|
6278 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
6279 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6280 "handleReferencesRequest: assocName = %s ",
6281 (const char*)resultPath->toString().getCString()));
6282 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6283 "handleReferencesRequest: pathName = %s ",
6284 (const char*)objectPath->toString().getCString()));
6285 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6286 "handleReferencesRequest: role = %s ",
6287 (const char*)request->role.getCString()));
6288 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6289 "handleReferencesRequest: includeQualifiers = false");
6290 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6291 "handleReferencesRequest: includeClassOrigin = false");
|
6292 mark.hamzy 1.29 #endif
|
6293 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6294
|
6295 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
6296 (jobject)pr.jProvider,
6297 id,
6298 jAssociationName,
6299 jPathName,
6300 jRole,
6301 JMPI_INCLUDE_QUALIFIERS,
6302 request->includeClassOrigin,
6303 jPropertyList);
|
6304 mark.hamzy 1.25
|
6305 mark.hamzy 1.23 JMPIjvm::checkException(env);
6306
6307 handler.processing();
6308 if (jVec) {
|
6309 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
6310 i<m; i++)
6311 {
|
6312 mark.hamzy 1.23 JMPIjvm::checkException(env);
6313
|
6314 marek 1.68 jobject jciRet = env->CallObjectMethod(
6315 jVec,
6316 JMPIjvm::jv.VectorElementAt,
6317 i);
|
6318 mark.hamzy 1.24
|
6319 mark.hamzy 1.23 JMPIjvm::checkException(env);
6320
|
6321 marek 1.68 jlong jciRetRef = env->CallLongMethod(
6322 jciRet,
6323 JMPIjvm::jv.CIMInstanceCInst);
6324 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
6325 jlong,
6326 CIMInstance*,
6327 jciRetRef);
6328 CIMClass cls;
|
6329 mark.hamzy 1.40
6330 try
6331 {
|
6332 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6333 "handleReferencesRequest: "
6334 "enter(METHOD_ASSOCIATORPROVIDER): "
6335 "cimom_handle->getClass(%s).",
6336 (const char*)ciRet->
6337 getClassName().getString().getCString()
6338 ));
6339
|
6340 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
6341
6342 cls = pr._cimom_handle->getClass(context,
6343 request->nameSpace,
6344 ciRet->getClassName(),
6345 false,
6346 true,
6347 true,
6348 CIMPropertyList());
|
6349 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6350 "handleReferencesRequest: "
6351 "exit(METHOD_ASSOCIATORPROVIDER): "
6352 "cimom_handle->getClass(%s).",
6353 (const char*)ciRet->
6354 getClassName().getString().getCString()
6355 ));
|
6356 mark.hamzy 1.40 }
6357 catch (CIMException e)
6358 {
|
6359 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6360 "handleReferencesRequest: "
6361 "Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER) "
6362 "during cimom_handle->getClass(%s): %s ",
6363 (const char*)ciRet->
6364 getClassName().getString().getCString(),
6365 (const char*)e.getMessage().getCString()
6366 ));
6367
6368 PEG_METHOD_EXIT();
|
6369 mark.hamzy 1.40 throw;
6370 }
6371
|
6372 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
6373 CIMObjectPath iop = ciRet->buildPath(cls);
|
6374 mark.hamzy 1.24
|
6375 mark.hamzy 1.27 JMPIjvm::checkException(env);
6376
|
6377 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
6378 mark.hamzy 1.29 ciRet->setPath(iop);
|
6379 schuur 1.13
|
6380 mark.hamzy 1.29 handler.deliver(*ciRet);
|
6381 mark.hamzy 1.23 }
6382 }
6383 handler.complete();
|
6384 mark.hamzy 1.24 break;
|
6385 mark.hamzy 1.23 }
|
6386 schuur 1.1
|
6387 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
6388 mark.hamzy 1.24 {
|
6389 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
6390 OperationContext*,
6391 jlong,
6392 &request->operationContext);
6393 jobject joc = env->NewObject(
6394 jv->OperationContextClassRef,
6395 jv->OperationContextNewJ,
6396 jocRef);
6397
6398 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6399 CIMObjectPath*,
6400 jlong,
6401 resultPath);
6402 jobject jAssociationName = env->NewObject(
6403 jv->CIMObjectPathClassRef,
6404 jv->CIMObjectPathNewJ,
6405 jAssociationNameRef);
|
6406 mark.hamzy 1.25
6407 JMPIjvm::checkException(env);
6408
|
6409 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6410 CIMObjectPath*,
6411 jlong,
6412 objectPath);
6413 jobject jPathName = env->NewObject(
6414 jv->CIMObjectPathClassRef,
6415 jv->CIMObjectPathNewJ,
6416 jPathNameRef);
|
6417 mark.hamzy 1.24
6418 JMPIjvm::checkException(env);
6419
|
6420 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
6421
6422 JMPIjvm::checkException(env);
6423
6424 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
6425
|
6426 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
6427 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6428 "handleReferencesRequest: assocName = %s ",
6429 (const char*)resultPath->toString().getCString()));
6430 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6431 "handleReferencesRequest: pathName = %s ",
6432 (const char*)objectPath->toString().getCString()));
6433 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6434 "handleReferencesRequest: role = %s ",
6435 (const char*)request->role.getCString()));
6436 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6437 "handleReferencesRequest: includeQualifiers = false");
6438 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6439 "handleReferencesRequest: includeClassOrigin = false");
|
6440 mark.hamzy 1.29 #endif
6441
|
6442 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6443
|
6444 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
6445 (jobject)pr.jProvider,
6446 id,
6447 joc,
6448 jAssociationName,
6449 jPathName,
6450 jRole,
6451 JMPI_INCLUDE_QUALIFIERS,
6452 request->includeClassOrigin,
6453 jPropertyList);
|
6454 mark.hamzy 1.25
|
6455 mark.hamzy 1.24 JMPIjvm::checkException(env);
6456
|
6457 mark.hamzy 1.43 if (joc)
6458 {
|
6459 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
6460 mark.hamzy 1.43
6461 JMPIjvm::checkException(env);
6462 }
6463
|
6464 mark.hamzy 1.24 handler.processing();
6465 if (jVec) {
|
6466 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
6467 i<m; i++)
6468 {
|
6469 mark.hamzy 1.24 JMPIjvm::checkException(env);
6470
|
6471 marek 1.68 jobject jciRet = env->CallObjectMethod(
6472 jVec,
6473 JMPIjvm::jv.VectorElementAt,
6474 i);
|
6475 mark.hamzy 1.24
6476 JMPIjvm::checkException(env);
6477
|
6478 marek 1.68 jlong jciRetRef = env->CallLongMethod(
6479 jciRet,
6480 JMPIjvm::jv.CIMInstanceCInst);
6481 CIMInstance *ciRet = DEBUG_ConvertJavaToC(
6482 jlong,
6483 CIMInstance*,
6484 jciRetRef);
6485 CIMClass cls;
|
6486 mark.hamzy 1.40
6487 try
6488 {
|
6489 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6490 "handleReferencesRequest: "
6491 "enter(METHOD_ASSOCIATORPROVIDER2): "
6492 "cimom_handle->getClass(%s).",
6493 (const char*)ciRet->
6494 getClassName().getString().getCString()
6495 ));
6496
|
6497 mark.hamzy 1.40 AutoMutex lock (pr._cimomMutex);
6498
6499 cls = pr._cimom_handle->getClass(context,
6500 request->nameSpace,
6501 ciRet->getClassName(),
6502 false,
6503 true,
6504 true,
6505 CIMPropertyList());
|
6506 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6507 "handleReferencesRequest: "
6508 "exit(METHOD_ASSOCIATORPROVIDER2): "
6509 "cimom_handle->getClass(%s).",
6510 (const char*)ciRet->
6511 getClassName().getString().getCString()
6512 ));
6513
|
6514 mark.hamzy 1.40 }
6515 catch (CIMException e)
6516 {
|
6517 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6518 "handleReferencesRequest: "
6519 "Caught CIMExcetion(METHOD_ASSOCIATORPROVIDER2) "
6520 "during cimom_handle->getClass(%s): %s ",
6521 (const char*)ciRet->
6522 getClassName().getString().getCString(),
6523 (const char*)e.getMessage().getCString()
6524 ));
6525
6526 PEG_METHOD_EXIT();
|
6527 mark.hamzy 1.40 throw;
6528 }
6529
|
6530 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
6531 CIMObjectPath iop = ciRet->buildPath(cls);
|
6532 schuur 1.1
|
6533 mark.hamzy 1.27 JMPIjvm::checkException(env);
6534
|
6535 mark.hamzy 1.24 iop.setNameSpace(op.getNameSpace());
|
6536 mark.hamzy 1.29 ciRet->setPath(iop);
|
6537 schuur 1.12
|
6538 mark.hamzy 1.29 handler.deliver(*ciRet);
|
6539 mark.hamzy 1.24 }
6540 }
6541 handler.complete();
6542 break;
6543 }
|
6544 mark.hamzy 1.23
|
6545 mark.hamzy 1.24 case METHOD_UNKNOWN:
6546 {
|
6547 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6548 "handleReferencesRequest: Unknown method provider!");
|
6549 mark.hamzy 1.24 break;
6550 }
|
6551 mark.hamzy 1.23 }
|
6552 schuur 1.1 }
6553 HandlerCatch(handler);
|
6554 schuur 1.12
6555 if (env) JMPIjvm::detachThread();
6556
|
6557 schuur 1.1 PEG_METHOD_EXIT();
6558
6559 return(response);
6560 }
6561
|
6562 marek 1.68 Message * JMPIProviderManager::handleReferenceNamesRequest(
6563 const Message * message) throw()
|
6564 schuur 1.1 {
|
6565 marek 1.68 PEG_METHOD_ENTER(
6566 TRC_PROVIDERMANAGER,
6567 "JMPIProviderManager::handleReferenceNamesRequest");
|
6568 mark.hamzy 1.23
|
6569 kumpf 1.55 HandlerIntro(ReferenceNames,message,request,response,handler);
|
6570 schuur 1.1
|
6571 mark.hamzy 1.24 typedef enum {
6572 METHOD_UNKNOWN = 0,
|
6573 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
6574 METHOD_CIMASSOCIATORPROVIDER2,
6575 METHOD_ASSOCIATORPROVIDER,
6576 METHOD_ASSOCIATORPROVIDER2,
|
6577 mark.hamzy 1.24 } METHOD_VERSION;
6578 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
6579 JNIEnv *env = NULL;
|
6580 schuur 1.13
|
6581 marek 1.68 try
6582 {
|
6583 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
6584 "handleReferenceNamesRequest: "
|
6585 kumpf 1.77 "name space = %s class name = %s",
|
6586 thilo.boehm 1.69 (const char*)request->nameSpace.getString().getCString(),
6587 (const char*)request->
6588 objectName.getClassName().getString().getCString()
6589 ));
|
6590 mark.hamzy 1.23
|
6591 schuur 1.1 // make target object path
|
6592 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
6593 System::getHostName(),
6594 request->nameSpace,
6595 request->objectName.getClassName(),
6596 request->objectName.getKeyBindings());
6597 CIMObjectPath *resultPath = new CIMObjectPath(
6598 System::getHostName(),
6599 request->nameSpace,
6600 request->resultClass.getString());
|
6601 schuur 1.1
6602 // resolve provider name
|
6603 kumpf 1.2 ProviderName name = _resolveProviderName(
6604 request->operationContext.get(ProviderIdContainer::NAME));
|
6605 schuur 1.1
6606 // get cached or load new provider module
|
6607 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
6608 name.getPhysicalName(),
6609 name.getLogicalName(),
6610 String::EMPTY);
|
6611 schuur 1.1
|
6612 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
6613 schuur 1.1
|
6614 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
6615 "handleReferenceNamesRequest: "
|
6616 kumpf 1.77 "Calling provider: %s, role: %s, refCls: %s",
|
6617 thilo.boehm 1.69 (const char*)pr.getName().getCString(),
6618 (const char*)request->role.getCString(),
6619 (const char*)request->resultClass.getString().getCString()
6620 ));
|
6621 schuur 1.12
|
6622 mark.hamzy 1.24 JvmVector *jv = 0;
6623
6624 env = JMPIjvm::attachThread(&jv);
|
6625 schuur 1.1
|
6626 mark.hamzy 1.37 if (!env)
6627 {
|
6628 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6629 "handleReferenceNamesRequest: "
6630 "Could not initialize the JVM (Java Virtual Machine) "
6631 "runtime environment.");
6632
|
6633 mark.hamzy 1.37 PEG_METHOD_EXIT();
6634
|
6635 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
6636 CIM_ERR_FAILED,
6637 MessageLoaderParms(
|
6638 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
6639 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
6640 "runtime environment."));
|
6641 mark.hamzy 1.37 }
6642
|
6643 mark.hamzy 1.43 JMPIProvider::pm_service_op_lock op_lock(&pr);
6644
6645 jmethodID id = NULL;
6646 String interfaceType;
6647 String interfaceVersion;
6648
|
6649 marek 1.68 getInterfaceType(
6650 request->operationContext.get(ProviderIdContainer::NAME),
6651 interfaceType,
6652 interfaceVersion);
|
6653 mark.hamzy 1.43
6654 if (interfaceType == "JMPI")
6655 {
|
6656 marek 1.68 id = env->GetMethodID(
6657 (jclass)pr.jProviderClass,
6658 "referenceNames",
6659 "(Lorg/pegasus/jmpi/CIMObjectPath;"
6660 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)"
6661 "Ljava/util/Vector;");
|
6662 mark.hamzy 1.43
6663 if (id != NULL)
6664 {
6665 eMethodFound = METHOD_ASSOCIATORPROVIDER;
|
6666 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6667 "handleReferencesRequest: "
6668 "Found METHOD_ASSOCIATORPROVIDER.");
|
6669 mark.hamzy 1.43 }
6670
6671 if (id == NULL)
6672 {
6673 env->ExceptionClear();
6674
|
6675 marek 1.68 id = env->GetMethodID(
6676 (jclass)pr.jProviderClass,
6677 "referenceNames",
6678 "(Lorg/pegasus/jmpi/CIMObjectPath;"
6679 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
6680 ")[Lorg/pegasus/jmpi/CIMObjectPath;");
|
6681 mark.hamzy 1.43
6682 if (id != NULL)
6683 {
6684 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
|
6685 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6686 "handleReferenceNamesRequest: "
6687 "Found METHOD_CIMASSOCIATORPROVIDER.");
|
6688 mark.hamzy 1.43 }
6689 }
6690 }
6691 else if (interfaceType == "JMPIExperimental")
6692 {
|
6693 marek 1.68 id = env->GetMethodID(
6694 (jclass)pr.jProviderClass,
6695 "referenceNames",
6696 "(Lorg/pegasus/jmpi/OperationContext;"
6697 "Lorg/pegasus/jmpi/CIMObjectPath;"
6698 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
6699 ")Ljava/util/Vector;");
|
6700 mark.hamzy 1.43
6701 if (id != NULL)
6702 {
6703 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
|
6704 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6705 "handleReferenceNamesRequest: "
6706 "Found METHOD_ASSOCIATORPROVIDER2.");
|
6707 mark.hamzy 1.43 }
6708
6709 if (id == NULL)
6710 {
6711 env->ExceptionClear();
|
6712 marek 1.68 id = env->GetMethodID(
6713 (jclass)pr.jProviderClass,
6714 "referenceNames",
6715 "(Lorg/pegasus/jmpi/OperationContext;"
6716 "Lorg/pegasus/jmpi/CIMObjectPath;"
6717 "Lorg/pegasus/jmpi/CIMObjectPath;"
|
6718 kumpf 1.77 "Ljava/lang/String;)"
|
6719 marek 1.68 "[Lorg/pegasus/jmpi/CIMObjectPath;");
|
6720 mark.hamzy 1.43
6721 if (id != NULL)
6722 {
6723 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
|
6724 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6725 "handleReferenceNamesRequest: "
6726 "Found METHOD_CIMASSOCIATORPROVIDER2.");
|
6727 mark.hamzy 1.43 }
6728 }
6729 }
6730
6731 if (id == NULL)
6732 {
|
6733 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
6734 "handleReferenceNames: No method found!");
|
6735 mark.hamzy 1.43
6736 PEG_METHOD_EXIT();
6737
|
6738 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
6739 CIM_ERR_FAILED,
6740 MessageLoaderParms(
|
6741 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
6742 marek 1.68 "Could not find a method for the provider based on "
6743 "InterfaceType."));
|
6744 mark.hamzy 1.43 }
6745
6746 JMPIjvm::checkException(env);
6747
6748 switch (eMethodFound)
6749 {
6750 case METHOD_CIMASSOCIATORPROVIDER:
6751 {
|
6752 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6753 CIMObjectPath*,
6754 jlong,
6755 resultPath);
6756 jobject jAssociationName = env->NewObject(
6757 jv->CIMObjectPathClassRef,
6758 jv->CIMObjectPathNewJ,
6759 jAssociationNameRef);
|
6760 mark.hamzy 1.43
6761 JMPIjvm::checkException(env);
6762
|
6763 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6764 CIMObjectPath*,
6765 jlong,
6766 objectPath);
6767 jobject jPathName = env->NewObject(
6768 jv->CIMObjectPathClassRef,
6769 jv->CIMObjectPathNewJ,
6770 jPathNameRef);
|
6771 mark.hamzy 1.43
6772 JMPIjvm::checkException(env);
6773
6774 jstring jRole = env->NewStringUTF(request->role.getCString());
6775
6776 JMPIjvm::checkException(env);
6777
6778 #ifdef PEGASUS_DEBUG
|
6779 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6780 "handleReferenceNamesRequest: assocName = %s ",
6781 (const char*)objectPath->toString().getCString()));
6782 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6783 "handleReferenceNamesRequest: role = %s ",
6784 (const char*)request->role.getCString()));
|
6785 mark.hamzy 1.43 #endif
6786
|
6787 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6788
|
6789 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
6790 (jobject)pr.jProvider,
6791 id,
6792 jPathName,
6793 jAssociationName,
6794 jRole);
|
6795 mark.hamzy 1.43
6796 JMPIjvm::checkException(env);
6797
6798 handler.processing();
|
6799 mark.hamzy 1.45 if (jAr) {
6800 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
6801 mark.hamzy 1.43 JMPIjvm::checkException(env);
6802
|
6803 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
6804 mark.hamzy 1.43
6805 JMPIjvm::checkException(env);
6806
|
6807 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
6808 jcopRet,
6809 JMPIjvm::jv.CIMObjectPathCInst);
|
6810 mark.hamzy 1.43
6811 JMPIjvm::checkException(env);
6812
|
6813 marek 1.68 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
6814 jlong,
6815 CIMObjectPath*,
6816 jcopRetRef);
|
6817 mark.hamzy 1.43
6818 handler.deliver(*copRet);
6819 }
6820 }
6821 handler.complete();
6822 break;
6823 }
6824
6825 case METHOD_CIMASSOCIATORPROVIDER2:
6826 {
|
6827 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
6828 OperationContext*,
6829 jlong,
6830 &request->operationContext);
6831 jobject joc = env->NewObject(
6832 jv->OperationContextClassRef,
6833 jv->OperationContextNewJ,
6834 jocRef);
6835
6836 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6837 CIMObjectPath*,
6838 jlong,
6839 resultPath);
6840 jobject jAssociationName = env->NewObject(
6841 jv->CIMObjectPathClassRef,
6842 jv->CIMObjectPathNewJ,
6843 jAssociationNameRef);
|
6844 mark.hamzy 1.43
6845 JMPIjvm::checkException(env);
6846
|
6847 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6848 CIMObjectPath*,
6849 jlong,
6850 objectPath);
6851 jobject jPathName = env->NewObject(
6852 jv->CIMObjectPathClassRef,
6853 jv->CIMObjectPathNewJ,
6854 jPathNameRef);
|
6855 mark.hamzy 1.43
6856 JMPIjvm::checkException(env);
6857
6858 jstring jRole = env->NewStringUTF(request->role.getCString());
6859
6860 JMPIjvm::checkException(env);
6861
6862 #ifdef PEGASUS_DEBUG
|
6863 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6864 "handleReferenceNamesRequest: assocName = %s ",
6865 (const char*)objectPath->toString().getCString()));
6866 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6867 "handleReferenceNamesRequest: role = %s ",
6868 (const char*)request->role.getCString()));
|
6869 mark.hamzy 1.43 #endif
6870
|
6871 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6872
|
6873 marek 1.68 jobjectArray jAr=(jobjectArray)env->CallObjectMethod(
6874 (jobject)pr.jProvider,
6875 id,
6876 joc,
6877 jPathName,
6878 jAssociationName,
6879 jRole);
|
6880 mark.hamzy 1.43
6881 JMPIjvm::checkException(env);
6882
6883 if (joc)
6884 {
|
6885 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
6886 mark.hamzy 1.43
6887 JMPIjvm::checkException(env);
6888 }
6889
6890 handler.processing();
|
6891 mark.hamzy 1.45 if (jAr) {
6892 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
6893 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6894 schuur 1.1
|
6895 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
6896 schuur 1.1
|
6897 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6898 mark.hamzy 1.24
|
6899 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
6900 jcopRet,
6901 JMPIjvm::jv.CIMObjectPathCInst);
|
6902 mark.hamzy 1.24
|
6903 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6904 mark.hamzy 1.24
|
6905 marek 1.68 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
6906 jlong,
6907 CIMObjectPath*,
6908 jcopRetRef);
|
6909 mark.hamzy 1.24
|
6910 mark.hamzy 1.43 handler.deliver(*copRet);
6911 }
|
6912 mark.hamzy 1.24 }
|
6913 mark.hamzy 1.43 handler.complete();
6914 break;
|
6915 mark.hamzy 1.24 }
|
6916 schuur 1.11
|
6917 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
|
6918 mark.hamzy 1.24 {
|
6919 marek 1.68 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
6920 CIMObjectPath*,
6921 jlong,
6922 resultPath);
6923 jobject jAssociationName = env->NewObject(
6924 jv->CIMObjectPathClassRef,
6925 jv->CIMObjectPathNewJ,
6926 jAssociationNameRef);
|
6927 mark.hamzy 1.24
|
6928 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6929 schuur 1.1
|
6930 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
6931 CIMObjectPath*,
6932 jlong,
6933 objectPath);
6934 jobject jPathName = env->NewObject(
6935 jv->CIMObjectPathClassRef,
6936 jv->CIMObjectPathNewJ,
6937 jPathNameRef);
|
6938 mark.hamzy 1.25
6939 JMPIjvm::checkException(env);
6940
6941 jstring jRole = env->NewStringUTF(request->role.getCString());
6942
6943 JMPIjvm::checkException(env);
6944
|
6945 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
6946 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6947 "handleReferenceNamesRequest: assocName = %s ",
6948 (const char*)objectPath->toString().getCString()));
6949 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6950 "handleReferenceNamesRequest: pathName = %s ",
6951 (const char*)resultPath->toString().getCString()));
6952 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
6953 "handleReferenceNamesRequest: role = %s ",
6954 (const char*)request->role.getCString()));
|
6955 mark.hamzy 1.29 #endif
6956
|
6957 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
6958
|
6959 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
6960 (jobject)pr.jProvider,
6961 id,
6962 jAssociationName,
6963 jPathName,
6964 jRole);
|
6965 mark.hamzy 1.25
|
6966 mark.hamzy 1.23 JMPIjvm::checkException(env);
6967
6968 handler.processing();
6969 if (jVec) {
|
6970 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
6971 i<m; i++)
6972 {
|
6973 mark.hamzy 1.23 JMPIjvm::checkException(env);
6974
|
6975 marek 1.68 jobject jcopRet = env->CallObjectMethod(
6976 jVec,
6977 JMPIjvm::jv.VectorElementAt,
6978 i);
|
6979 mark.hamzy 1.24
|
6980 mark.hamzy 1.23 JMPIjvm::checkException(env);
6981
|
6982 marek 1.68 jlong jcopRetRef = env->CallLongMethod(
6983 jcopRet,
6984 JMPIjvm::jv.CIMObjectPathCInst);
|
6985 mark.hamzy 1.23
6986 JMPIjvm::checkException(env);
6987
|
6988 marek 1.68 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
6989 jlong,
6990 CIMObjectPath*,
6991 jcopRetRef);
|
6992 mark.hamzy 1.24
|
6993 mark.hamzy 1.29 handler.deliver(*copRet);
|
6994 mark.hamzy 1.23 }
6995 }
6996 handler.complete();
|
6997 mark.hamzy 1.24 break;
|
6998 mark.hamzy 1.23 }
|
6999 mark.hamzy 1.24
|
7000 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
7001 mark.hamzy 1.24 {
|
7002 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
7003 OperationContext*,
7004 jlong,
7005 &request->operationContext);
7006 jobject joc = env->NewObject(
7007 jv->OperationContextClassRef,
7008 jv->OperationContextNewJ,
7009 jocRef);
7010
7011 jlong jAssociationNameRef = DEBUG_ConvertCToJava(
7012 CIMObjectPath*,
7013 jlong,
7014 resultPath);
7015 jobject jAssociationName = env->NewObject(
7016 jv->CIMObjectPathClassRef,
7017 jv->CIMObjectPathNewJ,
7018 jAssociationNameRef);
|
7019 mark.hamzy 1.25
7020 JMPIjvm::checkException(env);
7021
|
7022 marek 1.68 jlong jPathNameRef = DEBUG_ConvertCToJava(
7023 CIMObjectPath*,
7024 jlong,
7025 objectPath);
7026 jobject jPathName = env->NewObject(
7027 jv->CIMObjectPathClassRef,
7028 jv->CIMObjectPathNewJ,
7029 jPathNameRef);
|
7030 mark.hamzy 1.24
7031 JMPIjvm::checkException(env);
7032
|
7033 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
7034
7035 JMPIjvm::checkException(env);
7036
|
7037 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
|
7038 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7039 "handleReferenceNamesRequest: assocName = %s ",
7040 (const char*)objectPath->toString().getCString()));
7041 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7042 "handleReferenceNamesRequest: pathName = %s ",
7043 (const char*)resultPath->toString().getCString()));
7044 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7045 "handleReferenceNamesRequest: role = %s ",
7046 (const char*)request->role.getCString()));
|
7047 mark.hamzy 1.29 #endif
7048
|
7049 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
7050
|
7051 marek 1.68 jobjectArray jVec=(jobjectArray)env->CallObjectMethod(
7052 (jobject)pr.jProvider,
7053 id,
7054 joc,
7055 jAssociationName,
7056 jPathName,
7057 jRole);
|
7058 mark.hamzy 1.25
|
7059 mark.hamzy 1.23 JMPIjvm::checkException(env);
7060
|
7061 mark.hamzy 1.43 if (joc)
7062 {
|
7063 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
7064 mark.hamzy 1.43
7065 JMPIjvm::checkException(env);
7066 }
7067
|
7068 mark.hamzy 1.23 handler.processing();
|
7069 mark.hamzy 1.24 if (jVec) {
|
7070 marek 1.68 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);
7071 i<m; i++)
7072 {
|
7073 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
7074 marek 1.68 jobject jcopRet = env->CallObjectMethod(
7075 jVec,
7076 JMPIjvm::jv.VectorElementAt,
7077 i);
7078 JMPIjvm::checkException(env);
7079 jlong jcopRetRef = env->CallLongMethod(
7080 jcopRet,
7081 JMPIjvm::jv.CIMObjectPathCInst);
7082 JMPIjvm::checkException(env);
7083 CIMObjectPath *copRet = DEBUG_ConvertJavaToC(
7084 jlong,
7085 CIMObjectPath*,
7086 jcopRetRef);
|
7087 mark.hamzy 1.29 handler.deliver(*copRet);
|
7088 mark.hamzy 1.23 }
7089 }
7090 handler.complete();
|
7091 mark.hamzy 1.24 break;
7092 }
7093
7094 case METHOD_UNKNOWN:
7095 {
|
7096 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7097 "handleReferenceNamesRequest: Unknown method provider!");
|
7098 mark.hamzy 1.24 break;
7099 }
|
7100 mark.hamzy 1.23 }
|
7101 schuur 1.1 }
7102 HandlerCatch(handler);
|
7103 schuur 1.11
7104 if (env) JMPIjvm::detachThread();
7105
|
7106 schuur 1.1 PEG_METHOD_EXIT();
7107
7108 return(response);
7109 }
7110
|
7111 marek 1.68 Message * JMPIProviderManager::handleGetPropertyRequest(
7112 const Message * message) throw()
|
7113 mark.hamzy 1.26 {
|
7114 marek 1.68 PEG_METHOD_ENTER(
7115 TRC_PROVIDERMANAGER,
7116 "JMPIProviderManager::handleGetPropertyRequest");
|
7117 mark.hamzy 1.26
|
7118 kumpf 1.55 HandlerIntro(GetProperty,message,request,response,handler);
|
7119 mark.hamzy 1.26
7120 typedef enum {
7121 METHOD_UNKNOWN = 0,
|
7122 mark.hamzy 1.43 METHOD_PROPERTYPROVIDER,
7123 METHOD_PROPERTYPROVIDER2,
|
7124 mark.hamzy 1.26 } METHOD_VERSION;
7125 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
7126 JNIEnv *env = NULL;
7127
7128 try {
|
7129 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
7130 "handleGetPropertyRequest: "
|
7131 kumpf 1.77 "name space = %s class name = %s",
|
7132 thilo.boehm 1.69 (const char*)request->nameSpace.getString().getCString(),
7133 (const char*)request->
7134 instanceName.getClassName().getString().getCString()
7135 ));
|
7136 mark.hamzy 1.26
7137 // make target object path
|
7138 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
7139 System::getHostName(),
7140 request->nameSpace,
7141 request->instanceName.getClassName(),
7142 request->instanceName.getKeyBindings());
|
7143 mark.hamzy 1.26
7144 // resolve provider name
7145 ProviderName name = _resolveProviderName(
7146 request->operationContext.get(ProviderIdContainer::NAME));
7147
7148 // get cached or load new provider module
|
7149 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
7150 name.getPhysicalName(),
7151 name.getLogicalName(),
7152 String::EMPTY);
|
7153 mark.hamzy 1.26
7154 // forward request
7155 JMPIProvider &pr = ph.GetProvider();
7156
|
7157 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
7158 "handleReferenceNamesRequest: "
|
7159 kumpf 1.77 "Calling provider: %s",
|
7160 thilo.boehm 1.69 (const char*)pr.getName().getCString()
7161 ));
|
7162 mark.hamzy 1.26
7163 JvmVector *jv = 0;
7164
7165 env = JMPIjvm::attachThread(&jv);
7166
|
7167 mark.hamzy 1.37 if (!env)
7168 {
|
7169 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7170 "handleReferenceNamesRequest: "
7171 "Could not initialize the JVM (Java Virtual Machine) "
7172 "runtime environment.");
7173
|
7174 mark.hamzy 1.37 PEG_METHOD_EXIT();
7175
|
7176 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7177 CIM_ERR_FAILED,
7178 MessageLoaderParms(
|
7179 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
7180 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
7181 "runtime environment."));
|
7182 mark.hamzy 1.37 }
7183
|
7184 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
7185
|
7186 mark.hamzy 1.43 jmethodID id = NULL;
7187 String interfaceType;
7188 String interfaceVersion;
7189
|
7190 marek 1.68 getInterfaceType(
7191 request->operationContext.get(ProviderIdContainer::NAME),
7192 interfaceType,
7193 interfaceVersion);
|
7194 mark.hamzy 1.43
7195 if (interfaceType == "JMPI")
7196 {
|
7197 marek 1.68 id = env->GetMethodID(
7198 (jclass)pr.jProviderClass,
7199 "getPropertyValue",
7200 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7201 "Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
|
7202 mark.hamzy 1.26
|
7203 mark.hamzy 1.43 if (id != NULL)
7204 {
7205 eMethodFound = METHOD_PROPERTYPROVIDER;
|
7206 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7207 "handleGetPropertyRequest: "
7208 "Found METHOD_PROPERTYPROVIDER.");
|
7209 mark.hamzy 1.43 }
7210 }
7211 else if (interfaceType == "JMPIExperimental")
7212 {
|
7213 marek 1.68 id = env->GetMethodID(
7214 (jclass)pr.jProviderClass,
7215 "getPropertyValue",
7216 "(Lorg/pegasus/jmpi/OperationContext;"
7217 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7218 "Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
|
7219 mark.hamzy 1.26
|
7220 mark.hamzy 1.43 if (id != NULL)
7221 {
7222 eMethodFound = METHOD_PROPERTYPROVIDER2;
|
7223 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7224 "handleGetPropertyRequest: "
7225 "Found METHOD_PROPERTYPROVIDER2.");
|
7226 mark.hamzy 1.43 }
|
7227 mark.hamzy 1.26 }
7228
7229 if (id == NULL)
7230 {
|
7231 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7232 "handleGetPropertyRequest: No method provider found!");
|
7233 mark.hamzy 1.43
7234 PEG_METHOD_EXIT();
7235
|
7236 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7237 CIM_ERR_FAILED,
7238 MessageLoaderParms(
|
7239 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
7240 marek 1.68 "Could not find a method for the provider based on "
7241 "InterfaceType."));
|
7242 mark.hamzy 1.26 }
7243
7244 JMPIjvm::checkException(env);
7245
7246 switch (eMethodFound)
7247 {
|
7248 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER:
|
7249 mark.hamzy 1.26 {
|
7250 marek 1.68 jlong jcopref = DEBUG_ConvertCToJava(
7251 CIMObjectPath*,
7252 jlong,
7253 objectPath);
7254 jobject jcop = env->NewObject(
7255 jv->CIMObjectPathClassRef,
7256 jv->CIMObjectPathNewJ,
7257 jcopref);
|
7258 mark.hamzy 1.26
7259 JMPIjvm::checkException(env);
7260
|
7261 kumpf 1.77 jstring joclass =
|
7262 marek 1.68 env->NewStringUTF(
7263 request->instanceName.getClassName().getString().getCString());
|
7264 mark.hamzy 1.26
7265 JMPIjvm::checkException(env);
7266
|
7267 marek 1.68 jstring jpName =
7268 env->NewStringUTF(
7269 request->propertyName.getString().getCString());
|
7270 mark.hamzy 1.26
7271 JMPIjvm::checkException(env);
7272
|
7273 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
|
7274 mark.hamzy 1.26
|
7275 mark.hamzy 1.29 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
7276 id,
7277 jcop,
7278 joclass,
7279 jpName);
|
7280 mark.hamzy 1.26
7281 JMPIjvm::checkException(env);
7282
7283 handler.processing();
7284
|
7285 mark.hamzy 1.29 if (jvalRet)
|
7286 mark.hamzy 1.26 {
|
7287 marek 1.68 jlong jvalRetRef = env->CallLongMethod(
7288 jvalRet,
7289 JMPIjvm::jv.CIMValueCInst);
7290 CIMValue *valRet = DEBUG_ConvertJavaToC(
7291 jlong,
7292 CIMValue*,
7293 jvalRetRef);
|
7294 mark.hamzy 1.26
7295 JMPIjvm::checkException(env);
7296
|
7297 mark.hamzy 1.29 handler.deliver(*valRet);
|
7298 mark.hamzy 1.26 }
7299 handler.complete();
7300 break;
7301 }
7302
|
7303 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER2:
7304 {
|
7305 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
7306 OperationContext*,
7307 jlong,
7308 &request->operationContext);
7309 jobject joc = env->NewObject(
7310 jv->OperationContextClassRef,
7311 jv->OperationContextNewJ,
7312 jocRef);
|
7313 mark.hamzy 1.43
|
7314 marek 1.68 jlong jcopref = DEBUG_ConvertCToJava(
7315 CIMObjectPath*,
7316 jlong,
7317 objectPath);
7318 jobject jcop = env->NewObject(
7319 jv->CIMObjectPathClassRef,
7320 jv->CIMObjectPathNewJ,
7321 jcopref);
|
7322 mark.hamzy 1.43
7323 JMPIjvm::checkException(env);
7324
|
7325 marek 1.68 jstring joclass = env->NewStringUTF(
7326 request->instanceName.getClassName().getString().getCString());
|
7327 mark.hamzy 1.43
7328 JMPIjvm::checkException(env);
7329
|
7330 marek 1.68 jstring jpName = env->NewStringUTF(
7331 request->propertyName.getString().getCString());
|
7332 mark.hamzy 1.43
7333 JMPIjvm::checkException(env);
7334
|
7335 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
|
7336 mark.hamzy 1.43
7337 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
7338 id,
7339 joc,
7340 jcop,
7341 joclass,
7342 jpName);
7343
7344 JMPIjvm::checkException(env);
7345
7346 if (joc)
7347 {
|
7348 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
7349 mark.hamzy 1.43
7350 JMPIjvm::checkException(env);
7351 }
7352
7353 handler.processing();
7354
7355 if (jvalRet)
7356 {
|
7357 marek 1.68 jlong jvalRetRef = env->CallLongMethod(
7358 jvalRet,
7359 JMPIjvm::jv.CIMValueCInst);
7360 CIMValue *valRet = DEBUG_ConvertJavaToC(
7361 jlong,
7362 CIMValue*,
7363 jvalRetRef);
|
7364 mark.hamzy 1.43
7365 JMPIjvm::checkException(env);
7366
7367 handler.deliver(*valRet);
7368 }
7369 handler.complete();
7370 break;
7371 }
7372
|
7373 mark.hamzy 1.26 case METHOD_UNKNOWN:
7374 {
|
7375 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7376 "handleGetPropertyRequest: Unknown method provider!");
|
7377 mark.hamzy 1.26 break;
7378 }
7379 }
7380 }
7381 HandlerCatch(handler);
7382
7383 if (env) JMPIjvm::detachThread();
7384
7385 PEG_METHOD_EXIT();
7386
7387 return(response);
7388 }
7389
|
7390 marek 1.68 Message * JMPIProviderManager::handleSetPropertyRequest(
7391 const Message * message) throw()
|
7392 mark.hamzy 1.26 {
|
7393 marek 1.68 PEG_METHOD_ENTER(
7394 TRC_PROVIDERMANAGER,
7395 "JMPIProviderManager::handleSetPropertyRequest");
|
7396 mark.hamzy 1.26
|
7397 kumpf 1.55 HandlerIntro(SetProperty,message,request,response,handler);
|
7398 mark.hamzy 1.26
7399 typedef enum {
7400 METHOD_UNKNOWN = 0,
|
7401 mark.hamzy 1.43 METHOD_PROPERTYPROVIDER,
7402 METHOD_PROPERTYPROVIDER2,
|
7403 mark.hamzy 1.26 } METHOD_VERSION;
7404 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
7405 JNIEnv *env = NULL;
7406
|
7407 kumpf 1.77 try
|
7408 marek 1.68 {
|
7409 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
7410 "handleSetPropertyRequest: "
|
7411 kumpf 1.77 "name space = %s class name = %s",
|
7412 thilo.boehm 1.69 (const char*)request->nameSpace.getString().getCString(),
7413 (const char*)request->
7414 instanceName.getClassName().getString().getCString()
7415 ));
|
7416 mark.hamzy 1.26
7417 // make target object path
|
7418 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
7419 System::getHostName(),
7420 request->nameSpace,
7421 request->instanceName.getClassName(),
7422 request->instanceName.getKeyBindings());
|
7423 mark.hamzy 1.26
7424 // resolve provider name
7425 ProviderName name = _resolveProviderName(
7426 request->operationContext.get(ProviderIdContainer::NAME));
7427
7428 // get cached or load new provider module
|
7429 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
7430 name.getPhysicalName(),
7431 name.getLogicalName(),
7432 String::EMPTY);
|
7433 mark.hamzy 1.26
7434 // forward request
7435 JMPIProvider &pr = ph.GetProvider();
7436
|
7437 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
7438 "handleSetPropertyRequest: "
|
7439 kumpf 1.77 "Calling provider. setPropertyValue: %s",
|
7440 thilo.boehm 1.69 (const char*)pr.getName().getCString()));
|
7441 mark.hamzy 1.26
7442 JvmVector *jv = 0;
7443
7444 env = JMPIjvm::attachThread(&jv);
7445
|
7446 mark.hamzy 1.37 if (!env)
7447 {
|
7448 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7449 "Could not initialize the JVM (Java Virtual Machine) "
7450 "runtime environment.");
7451
|
7452 mark.hamzy 1.37 PEG_METHOD_EXIT();
7453
|
7454 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7455 CIM_ERR_FAILED,
7456 MessageLoaderParms(
|
7457 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
7458 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
7459 "runtime environment."));
|
7460 mark.hamzy 1.37 }
7461
|
7462 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
7463
|
7464 mark.hamzy 1.43 jmethodID id = NULL;
7465 String interfaceType;
7466 String interfaceVersion;
7467
|
7468 marek 1.68 getInterfaceType(
7469 request->operationContext.get(ProviderIdContainer::NAME),
7470 interfaceType,
7471 interfaceVersion);
|
7472 mark.hamzy 1.43
7473 if (interfaceType == "JMPI")
7474 {
|
7475 marek 1.68 id = env->GetMethodID(
7476 (jclass)pr.jProviderClass,
7477 "setPropertyValue",
7478 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7479 "Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
|
7480 mark.hamzy 1.26
|
7481 mark.hamzy 1.43 if (id != NULL)
7482 {
7483 eMethodFound = METHOD_PROPERTYPROVIDER;
|
7484 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7485 "handleSetPropertyRequest: "
7486 "Found METHOD_PROPERTYPROVIDER.");
|
7487 mark.hamzy 1.43 }
7488 }
7489 else if (interfaceType == "JMPIExperimental")
7490 {
|
7491 marek 1.68 id = env->GetMethodID(
7492 (jclass)pr.jProviderClass,
7493 "setPropertyValue",
7494 "(Lorg/pegasus/jmpi/OperationContext;"
7495 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7496 "Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
|
7497 mark.hamzy 1.26
|
7498 mark.hamzy 1.43 if (id != NULL)
7499 {
7500 eMethodFound = METHOD_PROPERTYPROVIDER2;
|
7501 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7502 "handleSetPropertyRequest: "
7503 "Found METHOD_PROPERTYPROVIDER2.");
|
7504 mark.hamzy 1.43 }
|
7505 mark.hamzy 1.26 }
7506
7507 if (id == NULL)
7508 {
|
7509 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7510 "handleSetPropertyRequest: No method provider found!");
|
7511 mark.hamzy 1.43
7512 PEG_METHOD_EXIT();
7513
|
7514 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7515 CIM_ERR_FAILED,
7516 MessageLoaderParms(
|
7517 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
7518 marek 1.68 "Could not find a method for the provider based on "
7519 "InterfaceType."));
|
7520 mark.hamzy 1.26 }
7521
7522 JMPIjvm::checkException(env);
7523
7524 switch (eMethodFound)
7525 {
|
7526 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER:
7527 {
|
7528 marek 1.68 jlong jcopref = DEBUG_ConvertCToJava(
7529 CIMObjectPath*,
|
7530 kumpf 1.77 jlong,
|
7531 marek 1.68 objectPath);
7532 jobject jcop = env->NewObject(
7533 jv->CIMObjectPathClassRef,
7534 jv->CIMObjectPathNewJ,
7535 jcopref);
|
7536 mark.hamzy 1.43
7537 JMPIjvm::checkException(env);
7538
|
7539 marek 1.68 jstring joclass =
7540 env->NewStringUTF(
7541 request->instanceName.getClassName().getString().getCString());
|
7542 mark.hamzy 1.43
7543 JMPIjvm::checkException(env);
7544
|
7545 kumpf 1.77 jstring jpName =
|
7546 marek 1.68 env->NewStringUTF(
7547 request->propertyName.getString().getCString());
|
7548 mark.hamzy 1.43
7549 JMPIjvm::checkException(env);
7550
7551 CIMValue *val = new CIMValue (request->newValue);
7552
7553 JMPIjvm::checkException(env);
7554
|
7555 marek 1.68 jlong jvalref = DEBUG_ConvertCToJava(CIMValue*, jlong, val);
7556 jobject jval = env->NewObject(
7557 jv->CIMValueClassRef,
7558 jv->CIMValueNewJ,
7559 jvalref);
|
7560 mark.hamzy 1.43
7561 JMPIjvm::checkException(env);
7562
|
7563 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
|
7564 mark.hamzy 1.43
7565 env->CallVoidMethod ((jobject)pr.jProvider,
7566 id,
7567 jcop,
7568 joclass,
7569 jpName,
7570 jval);
7571
7572 JMPIjvm::checkException(env);
7573 break;
7574 }
7575
7576 case METHOD_PROPERTYPROVIDER2:
|
7577 mark.hamzy 1.26 {
|
7578 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
7579 OperationContext*,
7580 jlong,
7581 &request->operationContext);
7582 jobject joc = env->NewObject(
7583 jv->OperationContextClassRef,
7584 jv->OperationContextNewJ,
7585 jocRef);
7586
7587 jlong jcopref = DEBUG_ConvertCToJava(
7588 CIMObjectPath*,
7589 jlong,
7590 objectPath);
7591 jobject jcop = env->NewObject(
7592 jv->CIMObjectPathClassRef,
7593 jv->CIMObjectPathNewJ,
7594 jcopref);
|
7595 mark.hamzy 1.26
7596 JMPIjvm::checkException(env);
7597
|
7598 kumpf 1.77 jstring joclass =
|
7599 marek 1.68 env->NewStringUTF(
7600 request->instanceName.getClassName().getString().getCString());
|
7601 mark.hamzy 1.26
7602 JMPIjvm::checkException(env);
7603
|
7604 kumpf 1.77 jstring jpName =
|
7605 marek 1.68 env->NewStringUTF(
7606 request->propertyName.getString().getCString());
|
7607 mark.hamzy 1.26
7608 JMPIjvm::checkException(env);
7609
|
7610 mark.hamzy 1.27 CIMValue *val = new CIMValue (request->newValue);
|
7611 mark.hamzy 1.26
7612 JMPIjvm::checkException(env);
7613
|
7614 marek 1.68 jlong jvalref = DEBUG_ConvertCToJava (CIMValue*, jlong, val);
7615 jobject jval = env->NewObject(
7616 jv->CIMValueClassRef,
7617 jv->CIMValueNewJ,
7618 jvalref);
|
7619 mark.hamzy 1.26
7620 JMPIjvm::checkException(env);
7621
|
7622 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
|
7623 mark.hamzy 1.26
7624 env->CallVoidMethod ((jobject)pr.jProvider,
7625 id,
|
7626 mark.hamzy 1.43 joc,
|
7627 mark.hamzy 1.26 jcop,
7628 joclass,
7629 jpName,
7630 jval);
7631
7632 JMPIjvm::checkException(env);
7633
|
7634 mark.hamzy 1.43 if (joc)
7635 {
|
7636 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
7637 mark.hamzy 1.43
7638 JMPIjvm::checkException(env);
7639 }
|
7640 mark.hamzy 1.26 break;
7641 }
7642
7643 case METHOD_UNKNOWN:
7644 {
|
7645 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7646 "handleSetPropertyRequest: Unknown method provider!");
|
7647 mark.hamzy 1.26 break;
7648 }
7649 }
7650 }
7651 HandlerCatch(handler);
7652
7653 if (env) JMPIjvm::detachThread();
7654
7655 PEG_METHOD_EXIT();
7656
7657 return(response);
7658 }
7659
|
7660 marek 1.68 Message * JMPIProviderManager::handleInvokeMethodRequest(
7661 const Message * message) throw()
|
7662 schuur 1.1 {
|
7663 marek 1.68 PEG_METHOD_ENTER(
7664 TRC_PROVIDERMANAGER,
7665 "JMPIProviderManager::handleInvokeMethodRequest");
|
7666 mark.hamzy 1.23
|
7667 kumpf 1.55 HandlerIntro(InvokeMethod,message,request,response,handler);
|
7668 schuur 1.1
|
7669 mark.hamzy 1.25 typedef enum {
7670 METHOD_UNKNOWN = 0,
|
7671 mark.hamzy 1.43 METHOD_CIMMETHODPROVIDER,
7672 METHOD_CIMMETHODPROVIDER2,
7673 METHOD_METHODPROVIDER,
7674 METHOD_METHODPROVIDER2,
|
7675 mark.hamzy 1.25 } METHOD_VERSION;
7676 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
7677 JNIEnv *env = NULL;
|
7678 schuur 1.13
|
7679 schuur 1.1 try {
|
7680 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
7681 "handleInvokeMethodRequest: "
|
7682 kumpf 1.77 "name space = %s class name = %s",
|
7683 thilo.boehm 1.69 (const char*)request->nameSpace.getString().getCString(),
7684 (const char*)request->
7685 instanceName.getClassName().getString().getCString()
7686 ));
|
7687 mark.hamzy 1.23
|
7688 schuur 1.1 // make target object path
|
7689 marek 1.68 CIMObjectPath *objectPath = new CIMObjectPath(
7690 System::getHostName(),
7691 request->nameSpace,
7692 request->instanceName.getClassName(),
7693 request->instanceName.getKeyBindings());
|
7694 schuur 1.1
7695 // resolve provider name
|
7696 kumpf 1.2 ProviderName name = _resolveProviderName(
7697 request->operationContext.get(ProviderIdContainer::NAME));
|
7698 schuur 1.1
7699 // get cached or load new provider module
|
7700 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
7701 name.getPhysicalName(),
7702 name.getLogicalName(),
7703 String::EMPTY);
|
7704 schuur 1.1
|
7705 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
7706 schuur 1.1
|
7707 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
7708 "handleInvokeMethodRequest: "
|
7709 kumpf 1.77 "Calling provider: %s",
|
7710 thilo.boehm 1.69 (const char*)pr.getName().getCString()
7711 ));
|
7712 schuur 1.11
|
7713 mark.hamzy 1.25 JvmVector *jv = 0;
|
7714 mark.hamzy 1.23
|
7715 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
7716 schuur 1.11
|
7717 mark.hamzy 1.37 if (!env)
7718 {
|
7719 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7720 "handleInvokeMethodRequest: "
7721 "Could not initialize the JVM (Java Virtual Machine) "
7722 "runtime environment.");
7723
|
7724 mark.hamzy 1.43 PEG_METHOD_EXIT();
7725
|
7726 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7727 CIM_ERR_FAILED,
7728 MessageLoaderParms(
|
7729 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
7730 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
7731 "runtime environment."));
|
7732 mark.hamzy 1.43 }
7733
7734 JMPIProvider::pm_service_op_lock op_lock(&pr);
7735
7736 jmethodID id = NULL;
7737 String interfaceType;
7738 String interfaceVersion;
7739
|
7740 marek 1.68 getInterfaceType(
7741 request->operationContext.get(ProviderIdContainer::NAME),
7742 interfaceType,
7743 interfaceVersion);
|
7744 mark.hamzy 1.43
7745 if (interfaceType == "JMPI")
7746 {
|
7747 marek 1.68 id = env->GetMethodID(
7748 (jclass)pr.jProviderClass,
7749 "invokeMethod",
7750 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7751 "Ljava/util/Vector;Ljava/util/Vector;)"
7752 "Lorg/pegasus/jmpi/CIMValue;");
|
7753 mark.hamzy 1.43
7754 if (id != NULL)
7755 {
7756 eMethodFound = METHOD_METHODPROVIDER;
|
7757 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7758 "handleInvokeMethodRequest: "
7759 "Found METHOD_PROPERTYPROVIDER.");
|
7760 mark.hamzy 1.43 }
7761
7762 if (id == NULL)
7763 {
7764 env->ExceptionClear();
|
7765 marek 1.68 id = env->GetMethodID(
7766 (jclass)pr.jProviderClass,
7767 "invokeMethod",
7768 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7769 "[Lorg/pegasus/jmpi/CIMArgument;"
7770 "[Lorg/pegasus/jmpi/CIMArgument;)"
7771 "Lorg/pegasus/jmpi/CIMValue;");
|
7772 mark.hamzy 1.43
7773 if (id != NULL)
7774 {
7775 eMethodFound = METHOD_CIMMETHODPROVIDER;
|
7776 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7777 "handleInvokeMethodRequest: "
7778 "Found METHOD_CIMMETHODPROVIDER.");
|
7779 mark.hamzy 1.43 }
7780 }
7781 }
7782 else if (interfaceType == "JMPIExperimental")
7783 {
|
7784 marek 1.68 id = env->GetMethodID(
7785 (jclass)pr.jProviderClass,
7786 "invokeMethod",
7787 "(Lorg/pegasus/jmpi/OperationContext;"
7788 "Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
7789 "Ljava/util/Vector;Ljava/util/Vector;)"
7790 "Lorg/pegasus/jmpi/CIMValue;");
|
7791 mark.hamzy 1.43
7792 if (id != NULL)
7793 {
7794 eMethodFound = METHOD_METHODPROVIDER2;
|
7795 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7796 "handleInvokeMethodRequest: "
7797 "Found METHOD_METHODPROVIDER2.");
|
7798 mark.hamzy 1.43 }
7799
7800 if (id == NULL)
7801 {
7802 env->ExceptionClear();
7803
|
7804 marek 1.68 id = env->GetMethodID(
7805 (jclass)pr.jProviderClass,
7806 "invokeMethod",
7807 "(Lorg/pegasus/jmpi/OperationContext;"
7808 "Lorg/pegasus/jmpi/CIMObjectPath;"
7809 "Ljava/lang/String;"
7810 "[Lorg/pegasus/jmpi/CIMArgument;["
7811 "Lorg/pegasus/jmpi/CIMArgument;)"
7812 "Lorg/pegasus/jmpi/CIMValue;");
|
7813 mark.hamzy 1.43
7814 if (id != NULL)
7815 {
7816 eMethodFound = METHOD_CIMMETHODPROVIDER2;
|
7817 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
7818 "handleInvokeMethodRequest: "
7819 "Found METHOD_CIMMETHODPROVIDER2.");
|
7820 mark.hamzy 1.43 }
7821 }
7822 }
7823
7824 if (id == NULL)
7825 {
|
7826 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7827 "handleInvokeMethod: No method provider found!");
|
7828 mark.hamzy 1.43
7829 PEG_METHOD_EXIT();
7830
|
7831 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
7832 CIM_ERR_FAILED,
7833 MessageLoaderParms(
|
7834 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
7835 marek 1.68 "Could not find a method for the provider based on "
7836 "InterfaceType."));
|
7837 mark.hamzy 1.43 }
7838
7839 JMPIjvm::checkException(env);
7840
7841 switch (eMethodFound)
7842 {
7843 case METHOD_CIMMETHODPROVIDER:
7844 {
|
7845 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
7846 CIMObjectPath*,
7847 jlong,
7848 objectPath);
7849 jobject jcop = env->NewObject(
7850 jv->CIMObjectPathClassRef,
7851 jv->CIMObjectPathNewJ,
7852 jcopRef);
|
7853 mark.hamzy 1.43
7854 JMPIjvm::checkException(env);
7855
|
7856 kumpf 1.77 jstring jMethod =
|
7857 marek 1.68 env->NewStringUTF(
7858 request->methodName.getString().getCString());
|
7859 mark.hamzy 1.43
7860 JMPIjvm::checkException(env);
7861
7862 Uint32 m=request->inParameters.size();
7863
|
7864 marek 1.68 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(
7865 m,
7866 jv->CIMArgumentClassRef,
7867 NULL);
|
7868 mark.hamzy 1.43
7869 for (Uint32 i=0; i<m; i++) {
|
7870 marek 1.68 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
7871 jlong jArgRef = DEBUG_ConvertCToJava(CIMParamValue*, jlong, parm);
7872 jobject jArg = env->NewObject(
7873 jv->CIMArgumentClassRef,
7874 jv->CIMArgumentNewJ,
7875 jArgRef);
|
7876 mark.hamzy 1.43
7877 env->SetObjectArrayElement(jArIn,i,jArg);
7878 }
7879
|
7880 marek 1.68 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(
7881 24,
7882 jv->CIMArgumentClassRef,
7883 NULL);
|
7884 mark.hamzy 1.43
|
7885 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
7886
|
7887 mark.hamzy 1.43 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
7888 id,
7889 jcop,
7890 jMethod,
7891 jArIn,
7892 jArOut);
7893 JMPIjvm::checkException(env);
|
7894 mark.hamzy 1.37
|
7895 mark.hamzy 1.43 handler.processing();
|
7896 mark.hamzy 1.37
|
7897 marek 1.68 jlong jValueRetRef = env->CallLongMethod(
7898 jValueRet,
7899 JMPIjvm::jv.CIMValueCInst);
7900 CIMValue *valueRet = DEBUG_ConvertJavaToC(
7901 jlong,
7902 CIMValue*,
7903 jValueRetRef);
|
7904 schuur 1.11
|
7905 mark.hamzy 1.43 handler.deliver(*valueRet);
|
7906 schuur 1.1
|
7907 mark.hamzy 1.43 for (int i=0; i<24; i++) {
7908 jobject jArg = env->GetObjectArrayElement(jArOut,i);
|
7909 mark.hamzy 1.25
|
7910 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
7911 mark.hamzy 1.25
|
7912 mark.hamzy 1.43 if (jArg==NULL)
7913 break;
|
7914 mark.hamzy 1.25
|
7915 marek 1.68 jlong jpRef = env->CallLongMethod(
7916 jArg,
7917 JMPIjvm::jv.CIMArgumentCInst);
7918 CIMParamValue *p = DEBUG_ConvertJavaToC(
7919 jlong,
7920 CIMParamValue*,
7921 jpRef);
|
7922 mark.hamzy 1.25
|
7923 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
7924 mark.hamzy 1.25
|
7925 mark.hamzy 1.43 handler.deliverParamValue(*p);
|
7926 mark.hamzy 1.25 }
|
7927 mark.hamzy 1.43
7928 handler.complete();
7929 break;
|
7930 mark.hamzy 1.23 }
|
7931 mark.hamzy 1.25
|
7932 mark.hamzy 1.43 case METHOD_CIMMETHODPROVIDER2:
7933 {
|
7934 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
7935 OperationContext*,
7936 jlong,
7937 &request->operationContext);
7938 jobject joc = env->NewObject(
7939 jv->OperationContextClassRef,
7940 jv->OperationContextNewJ,
7941 jocRef);
7942
|
7943 kumpf 1.77 jlong jcopRef = DEBUG_ConvertCToJava(
|
7944 marek 1.68 CIMObjectPath*,
7945 jlong,
7946 objectPath);
7947 jobject jcop = env->NewObject(
7948 jv->CIMObjectPathClassRef,
7949 jv->CIMObjectPathNewJ,
7950 jcopRef);
|
7951 mark.hamzy 1.25
7952 JMPIjvm::checkException(env);
7953
|
7954 kumpf 1.77 jstring jMethod =
|
7955 marek 1.68 env->NewStringUTF(request->methodName.getString().getCString());
|
7956 mark.hamzy 1.29
|
7957 mark.hamzy 1.23 JMPIjvm::checkException(env);
7958
|
7959 mark.hamzy 1.25 Uint32 m=request->inParameters.size();
7960
|
7961 marek 1.68 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(
7962 m,
7963 jv->CIMArgumentClassRef,
7964 NULL);
|
7965 mark.hamzy 1.29
|
7966 mark.hamzy 1.25 for (Uint32 i=0; i<m; i++) {
|
7967 marek 1.68 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
7968 jlong jArgRef = DEBUG_ConvertCToJava(CIMParamValue*, jlong, parm);
7969 jobject jArg = env->NewObject(
7970 jv->CIMArgumentClassRef,
7971 jv->CIMArgumentNewJ,
7972 jArgRef);
|
7973 mark.hamzy 1.23
|
7974 mark.hamzy 1.25 env->SetObjectArrayElement(jArIn,i,jArg);
7975 }
|
7976 mark.hamzy 1.23
|
7977 marek 1.68 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(
7978 24,
7979 jv->CIMArgumentClassRef,
7980 NULL);
|
7981 mark.hamzy 1.23
|
7982 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
7983
|
7984 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
7985 id,
|
7986 mark.hamzy 1.43 joc,
|
7987 mark.hamzy 1.29 jcop,
7988 jMethod,
7989 jArIn,
7990 jArOut);
|
7991 mark.hamzy 1.23 JMPIjvm::checkException(env);
7992
|
7993 mark.hamzy 1.43 if (joc)
7994 {
|
7995 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
7996 mark.hamzy 1.43
7997 JMPIjvm::checkException(env);
7998 }
7999
|
8000 mark.hamzy 1.23 handler.processing();
8001
|
8002 marek 1.68 jlong jValueRetRef = env->CallLongMethod(
8003 jValueRet,
8004 JMPIjvm::jv.CIMValueCInst);
8005 CIMValue *valueRet = DEBUG_ConvertJavaToC(
8006 jlong,
8007 CIMValue*,
8008 jValueRetRef);
|
8009 mark.hamzy 1.23
|
8010 mark.hamzy 1.29 handler.deliver(*valueRet);
|
8011 schuur 1.13
|
8012 mark.hamzy 1.25 for (int i=0; i<24; i++) {
|
8013 mark.hamzy 1.29 jobject jArg = env->GetObjectArrayElement(jArOut,i);
8014
|
8015 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
8016 schuur 1.13
|
8017 mark.hamzy 1.29 if (jArg==NULL)
8018 break;
|
8019 schuur 1.13
|
8020 marek 1.68 jlong jpRef = env->CallLongMethod(
8021 jArg,
8022 JMPIjvm::jv.CIMArgumentCInst);
8023 CIMParamValue *p = DEBUG_ConvertJavaToC(
8024 jlong,
8025 CIMParamValue*,
8026 jpRef);
|
8027 schuur 1.13
|
8028 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
8029 schuur 1.1
|
8030 mark.hamzy 1.25 handler.deliverParamValue(*p);
|
8031 mark.hamzy 1.23 }
|
8032 schuur 1.1
|
8033 mark.hamzy 1.23 handler.complete();
|
8034 mark.hamzy 1.25 break;
|
8035 mark.hamzy 1.23 }
|
8036 schuur 1.11
|
8037 mark.hamzy 1.43 case METHOD_METHODPROVIDER:
8038 {
|
8039 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava(
8040 CIMObjectPath*,
8041 jlong,
8042 objectPath);
8043 jobject jcop = env->NewObject(
8044 jv->CIMObjectPathClassRef,
8045 jv->CIMObjectPathNewJ,
8046 jcopRef);
|
8047 mark.hamzy 1.43
8048 JMPIjvm::checkException(env);
8049
|
8050 marek 1.68 jstring jMethod = env->NewStringUTF(
8051 request->methodName.getString().getCString());
|
8052 mark.hamzy 1.43
8053 JMPIjvm::checkException(env);
8054
8055 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
8056
8057 JMPIjvm::checkException(env);
8058
8059 for (int i=0,m=request->inParameters.size(); i<m; i++)
8060 {
|
8061 marek 1.68 const CIMParamValue &parm = request->inParameters[i];
8062 const CIMValue v = parm.getValue();
8063 CIMProperty *p = new CIMProperty(
8064 parm.getParameterName(),
8065 v,
8066 v.getArraySize());
8067 jlong jpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, p);
8068 jobject jp = env->NewObject(
8069 jv->CIMPropertyClassRef,
8070 jv->CIMPropertyNewJ,
8071 jpRef);
|
8072 mark.hamzy 1.43
8073 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
8074 }
8075
8076 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
8077 JMPIjvm::checkException(env);
8078
|
8079 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8080
|
8081 mark.hamzy 1.43 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
8082 id,
8083 jcop,
8084 jMethod,
8085 jVecIn,
8086 jVecOut);
8087 JMPIjvm::checkException(env);
8088
8089 handler.processing();
8090
|
8091 marek 1.68 jlong jValueRetRef = env->CallLongMethod(
8092 jValueRet,
8093 JMPIjvm::jv.CIMValueCInst);
8094 CIMValue *valueRet = DEBUG_ConvertJavaToC(
8095 jlong,
8096 CIMValue*,
8097 jValueRetRef);
|
8098 mark.hamzy 1.43
8099 handler.deliver(*valueRet);
8100
|
8101 marek 1.68 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize);
8102 i<m;
8103 i++)
|
8104 mark.hamzy 1.43 {
8105 JMPIjvm::checkException(env);
8106
|
8107 marek 1.68 jobject jProp = env->CallObjectMethod(
8108 jVecOut,
8109 JMPIjvm::jv.VectorElementAt,
8110 i);
|
8111 mark.hamzy 1.43
8112 JMPIjvm::checkException(env);
8113
|
8114 marek 1.68 jlong jpRef = env->CallLongMethod(
8115 jProp,
8116 JMPIjvm::jv.CIMPropertyCInst);
8117 CIMProperty *p = DEBUG_ConvertJavaToC(
|
8118 kumpf 1.77 jlong,
|
8119 marek 1.68 CIMProperty*,
8120 jpRef);
|
8121 mark.hamzy 1.43
8122 JMPIjvm::checkException(env);
8123
|
8124 marek 1.68 handler.deliverParamValue(
8125 CIMParamValue(p->getName().getString(),
8126 p->getValue()));
|
8127 mark.hamzy 1.43 }
8128
8129 handler.complete();
8130 break;
8131 }
8132
8133 case METHOD_METHODPROVIDER2:
|
8134 mark.hamzy 1.25 {
|
8135 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
8136 OperationContext*,
8137 jlong,
8138 &request->operationContext);
8139 jobject joc = env->NewObject(
8140 jv->OperationContextClassRef,
8141 jv->OperationContextNewJ,
8142 jocRef);
8143
8144 jlong jcopRef = DEBUG_ConvertCToJava(
8145 CIMObjectPath*,
8146 jlong,
8147 objectPath);
|
8148 kumpf 1.77 jobject jcop = env->NewObject(
|
8149 marek 1.68 jv->CIMObjectPathClassRef,
8150 jv->CIMObjectPathNewJ,
8151 jcopRef);
|
8152 mark.hamzy 1.25
8153 JMPIjvm::checkException(env);
8154
|
8155 marek 1.68 jstring jMethod = env->NewStringUTF(
8156 request->methodName.getString().getCString());
|
8157 mark.hamzy 1.29
|
8158 mark.hamzy 1.25 JMPIjvm::checkException(env);
8159
|
8160 mark.hamzy 1.29 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
8161
|
8162 mark.hamzy 1.25 JMPIjvm::checkException(env);
8163
|
8164 mark.hamzy 1.29 for (int i=0,m=request->inParameters.size(); i<m; i++)
8165 {
8166 const CIMParamValue &parm = request->inParameters[i];
8167 const CIMValue v = parm.getValue();
|
8168 marek 1.68 CIMProperty *p = new CIMProperty(
8169 parm.getParameterName(),
8170 v,
8171 v.getArraySize());
8172 jlong jpRef = DEBUG_ConvertCToJava(CIMProperty*, jlong, p);
8173 jobject jp = env->NewObject(
8174 jv->CIMPropertyClassRef,
8175 jv->CIMPropertyNewJ,
8176 jpRef);
|
8177 mark.hamzy 1.23
|
8178 mark.hamzy 1.29 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
|
8179 mark.hamzy 1.25 }
|
8180 mark.hamzy 1.23
|
8181 mark.hamzy 1.25 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
8182 JMPIjvm::checkException(env);
|
8183 mark.hamzy 1.23
|
8184 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8185
|
8186 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
8187 id,
|
8188 mark.hamzy 1.43 joc,
|
8189 mark.hamzy 1.29 jcop,
8190 jMethod,
8191 jVecIn,
8192 jVecOut);
|
8193 mark.hamzy 1.23 JMPIjvm::checkException(env);
8194
|
8195 mark.hamzy 1.43 if (joc)
8196 {
|
8197 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
8198 mark.hamzy 1.43
8199 JMPIjvm::checkException(env);
8200 }
8201
|
8202 mark.hamzy 1.23 handler.processing();
|
8203 schuur 1.1
|
8204 marek 1.68 jlong jValueRetRef = env->CallLongMethod(
8205 jValueRet,
8206 JMPIjvm::jv.CIMValueCInst);
8207 CIMValue *valueRet = DEBUG_ConvertJavaToC(
8208 jlong,
8209 CIMValue*,
8210 jValueRetRef);
|
8211 mark.hamzy 1.23
|
8212 mark.hamzy 1.29 handler.deliver(*valueRet);
|
8213 mark.hamzy 1.23
|
8214 kumpf 1.77 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize);
|
8215 marek 1.68 i<m;
8216 i++)
|
8217 mark.hamzy 1.29 {
|
8218 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
8219 schuur 1.13
|
8220 marek 1.68 jobject jProp = env->CallObjectMethod(
8221 jVecOut,
8222 JMPIjvm::jv.VectorElementAt,
8223 i);
|
8224 mark.hamzy 1.29
|
8225 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8226 schuur 1.13
|
8227 marek 1.68 jlong jpRef = env->CallLongMethod(
8228 jProp,
8229 JMPIjvm::jv.CIMPropertyCInst);
8230 CIMProperty *p = DEBUG_ConvertJavaToC(
8231 jlong,
8232 CIMProperty*,
8233 jpRef);
|
8234 schuur 1.13
|
8235 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
8236 schuur 1.13
|
8237 marek 1.68 handler.deliverParamValue(
8238 CIMParamValue(p->getName().getString(),
8239 p->getValue()));
|
8240 mark.hamzy 1.25 }
8241
8242 handler.complete();
8243 break;
8244 }
|
8245 mark.hamzy 1.23
|
8246 mark.hamzy 1.25 case METHOD_UNKNOWN:
8247 {
|
8248 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8249 "handleInvokeMethodRequest: Unknown method provider!");
|
8250 mark.hamzy 1.25 break;
8251 }
|
8252 mark.hamzy 1.23 }
|
8253 schuur 1.1 }
8254 HandlerCatch(handler);
|
8255 schuur 1.11
8256 if (env) JMPIjvm::detachThread();
8257
|
8258 schuur 1.1 PEG_METHOD_EXIT();
8259
|
8260 schuur 1.11 return(response);
|
8261 schuur 1.1 }
|
8262 mark.hamzy 1.23
|
8263 marek 1.68 int LocateIndicationProviderNames(
8264 const CIMInstance& pInstance,
8265 const CIMInstance& pmInstance,
8266 String& providerName,
8267 String& location)
|
8268 schuur 1.1 {
|
8269 marek 1.73 Uint32 pos = pInstance.findProperty(PEGASUS_PROPERTYNAME_NAME);
|
8270 schuur 1.1 pInstance.getProperty(pos).getValue().get(providerName);
8271
8272 pos = pmInstance.findProperty(CIMName ("Location"));
8273 pmInstance.getProperty(pos).getValue().get(location);
8274 return 0;
8275 }
8276
|
8277 mark.hamzy 1.52 WQLSelectStatement *
8278 newSelectExp (String& query,
8279 String& queryLanguage)
|
8280 mark.hamzy 1.44 {
|
8281 mark.hamzy 1.52 WQLSelectStatement *stmt = new WQLSelectStatement (queryLanguage, query);
|
8282 mark.hamzy 1.44
|
8283 mark.hamzy 1.52 try
|
8284 mark.hamzy 1.44 {
|
8285 mark.hamzy 1.52 WQLParser::parse (query, *stmt);
|
8286 mark.hamzy 1.44 }
|
8287 mark.hamzy 1.52 catch (const Exception &e)
|
8288 mark.hamzy 1.44 {
|
8289 mark.hamzy 1.52 cerr << "Error: newSelectExp caught: " << e.getMessage () << endl;
|
8290 mark.hamzy 1.44 }
8291
|
8292 mark.hamzy 1.52 return stmt;
|
8293 mark.hamzy 1.44 }
8294
|
8295 marek 1.68 Message * JMPIProviderManager::handleCreateSubscriptionRequest(
8296 const Message * message) throw()
|
8297 schuur 1.1 {
|
8298 marek 1.68 PEG_METHOD_ENTER(
8299 TRC_PROVIDERMANAGER,
8300 "JMPIProviderManager::handleCreateSubscriptionRequest");
|
8301 schuur 1.1
|
8302 mark.hamzy 1.23 HandlerIntroInd(CreateSubscription,message,request,response,handler);
8303
|
8304 mark.hamzy 1.25 typedef enum {
8305 METHOD_UNKNOWN = 0,
|
8306 mark.hamzy 1.43 METHOD_EVENTPROVIDER,
8307 METHOD_EVENTPROVIDER2,
|
8308 mark.hamzy 1.25 } METHOD_VERSION;
|
8309 mark.hamzy 1.44 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
8310 JNIEnv *env = NULL;
|
8311 mark.hamzy 1.25
|
8312 schuur 1.1 try {
|
8313 mark.hamzy 1.44 String fileName,
8314 providerName,
|
8315 mark.hamzy 1.25 providerLocation;
8316 CIMInstance req_provider,
8317 req_providerModule;
|
8318 kumpf 1.77 ProviderIdContainer pidc =
|
8319 marek 1.68 (ProviderIdContainer) request->operationContext.get(
8320 ProviderIdContainer::NAME);
|
8321 mark.hamzy 1.25
|
8322 marek 1.68 req_provider = pidc.getProvider ();
|
8323 mark.hamzy 1.44 req_providerModule = pidc.getModule ();
|
8324 mark.hamzy 1.25
|
8325 marek 1.68 LocateIndicationProviderNames(
8326 req_provider,
8327 req_providerModule,
8328 providerName,
8329 providerLocation);
8330
8331 fileName = resolveFileName(providerLocation);
8332
|
8333 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
8334 "handleCreateSubscriptionRequest: "
8335 "name space = %s provider name = %s provider filename = %s",
|
8336 thilo.boehm 1.70 (const char*)request->nameSpace.getString().getCString(),
|
8337 kumpf 1.77 (const char*)providerName.getCString(),
|
8338 thilo.boehm 1.70 (const char*)fileName.getCString()
|
8339 thilo.boehm 1.69 ));
|
8340 schuur 1.1
8341 // get cached or load new provider module
|
8342 kumpf 1.77 JMPIProvider::OpProviderHolder ph =
|
8343 marek 1.68 providerManager.getProvider(
8344 fileName,
8345 providerName,
8346 String::EMPTY);
|
8347 schuur 1.1
|
8348 carolann.graves 1.21 //
8349 // Save the provider instance from the request
8350 //
8351 ph.GetProvider ().setProviderInstance (req_provider);
8352
|
8353 mark.hamzy 1.44 JMPIProvider &pr = ph.GetProvider ();
|
8354 mark.hamzy 1.25
|
8355 mark.hamzy 1.44 //
8356 // Increment count of current subscriptions for this provider
8357 //
8358 pr.testIfZeroAndIncrementSubscriptions ();
|
8359 schuur 1.1
|
8360 kumpf 1.77 SubscriptionFilterConditionContainer sub_cntr =
|
8361 marek 1.68 request->operationContext.get(
8362 SubscriptionFilterConditionContainer::NAME);
8363 indProvRecord *prec = NULL;
8364 bool fNewPrec = false;
|
8365 schuur 1.1
|
8366 mark.hamzy 1.25 {
|
8367 mark.hamzy 1.44 AutoMutex lock (mutexProvTab);
8368
8369 provTab.lookup (providerName, prec);
|
8370 schuur 1.12
|
8371 mark.hamzy 1.44 if (!prec)
8372 {
8373 fNewPrec = true;
|
8374 schuur 1.1
|
8375 mark.hamzy 1.44 prec = new indProvRecord ();
|
8376 schuur 1.1
|
8377 mark.hamzy 1.44 // convert arguments
8378 prec->ctx = new OperationContext ();
|
8379 schuur 1.12
|
8380 marek 1.68 prec->ctx->insert(
8381 request->operationContext.get(
8382 IdentityContainer::NAME));
8383 prec->ctx->insert(
8384 request->operationContext.get(
8385 AcceptLanguageListContainer::NAME));
8386 prec->ctx->insert(
8387 request->operationContext.get(
8388 ContentLanguageListContainer::NAME));
8389 prec->ctx->insert(
8390 request->operationContext.get(
8391 SubscriptionInstanceContainer::NAME));
8392 prec->ctx->insert(
8393 request->operationContext.get(
8394 SubscriptionFilterConditionContainer::NAME));
|
8395 konrad.r 1.22
|
8396 mark.hamzy 1.44 prec->enabled = true;
|
8397 konrad.r 1.22
|
8398 marek 1.68 prec->handler = new EnableIndicationsResponseHandler(
8399 0,
8400 0,
8401 req_provider,
8402 _indicationCallback,
8403 _responseChunkCallback);
8404
|
8405 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
8406 marek 1.68 "handleCreateSubscriptionRequest: "
|
8407 thilo.boehm 1.69 "Adding %s to provTab.",
8408 (const char*)providerName.getCString()));
|
8409 schuur 1.1
|
8410 mark.hamzy 1.44 provTab.insert (providerName, prec);
8411 }
8412 }
|
8413 schuur 1.1
|
8414 mark.hamzy 1.44 {
8415 AutoMutex lock (prec->mutex);
|
8416 schuur 1.1
|
8417 mark.hamzy 1.44 prec->count++;
|
8418 schuur 1.1 }
8419
|
8420 mark.hamzy 1.44 // Add a selection record for JNI CIMOMHandle deliverEvent calls
8421 indSelectRecord *srec = new indSelectRecord ();
|
8422 mark.hamzy 1.29
8423 {
|
8424 mark.hamzy 1.44 srec->query = request->query;
8425 srec->queryLanguage = sub_cntr.getQueryLanguage ();
8426 srec->propertyList = request->propertyList;
8427
|
8428 kumpf 1.77 CIMOMHandleQueryContext *qContext =
|
8429 marek 1.68 new CIMOMHandleQueryContext(
8430 CIMNamespaceName(
8431 request->nameSpace.getString()),
8432 *pr._cimom_handle);
|
8433 mark.hamzy 1.44 srec->qContext = qContext;
8434
|
8435 marek 1.68 CIMObjectPath sPath = request->subscriptionInstance.getPath();
|
8436 dave.sudlik 1.62 Array<CIMKeyBinding> kb;
|
8437 mark.hamzy 1.44
|
8438 dave.sudlik 1.62 // Technically we only need Name and Handler for uniqueness
8439 kb = sPath.getKeyBindings ();
8440
8441 // Add an entry for every provider.
8442 kb.append (CIMKeyBinding ("Provider",
8443 pr.getName (),
8444 CIMKeyBinding::STRING));
8445
8446 sPath.setKeyBindings (kb);
|
8447 mark.hamzy 1.29
|
8448 mark.hamzy 1.44 AutoMutex lock (mutexSelxTab);
|
8449 mark.hamzy 1.29
|
8450 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8451 "handleCreateSubscriptionRequest: "
8452 "Adding %s to selxTab.",
8453 (const char*)sPath.toString().getCString()));
|
8454 mark.hamzy 1.44
8455 selxTab.insert (sPath.toString (), srec);
8456
|
8457 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8458 "handleCreateSubscriptionRequest: "
|
8459 thilo.boehm 1.70 "For selxTab %s , srec = %p, qContext = %p",
|
8460 thilo.boehm 1.69 (const char*)sPath.toString().getCString(),
|
8461 thilo.boehm 1.70 srec,qContext));
|
8462 schuur 1.1 }
8463
|
8464 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,
|
8465 kumpf 1.77 "handleCreateSubscriptionRequest: Calling provider: %s",
|
8466 thilo.boehm 1.69 (const char*)pr.getName().getCString()));
|
8467 mark.hamzy 1.44
|
8468 mark.hamzy 1.25 JvmVector *jv = 0;
8469
8470 env = JMPIjvm::attachThread(&jv);
8471
|
8472 mark.hamzy 1.37 if (!env)
8473 {
|
8474 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8475 "handleCreateSubscriptionRequest: "
8476 "Could not initialize the JVM (Java Virtual Machine) "
8477 "runtime environment.");
8478
|
8479 mark.hamzy 1.37 PEG_METHOD_EXIT();
8480
|
8481 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
8482 CIM_ERR_FAILED,
8483 MessageLoaderParms(
|
8484 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
8485 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
8486 "runtime environment."));
|
8487 mark.hamzy 1.37 }
8488
|
8489 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
8490
|
8491 mark.hamzy 1.43 jmethodID id = NULL;
8492 String interfaceType;
8493 String interfaceVersion;
8494
|
8495 mark.hamzy 1.44 getInterfaceType (pidc,
|
8496 mark.hamzy 1.43 interfaceType,
8497 interfaceVersion);
8498
8499 if (interfaceType == "JMPI")
8500 {
|
8501 marek 1.68 id = env->GetMethodID(
8502 (jclass)pr.jProviderClass,
8503 "activateFilter",
8504 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
8505 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
8506 mark.hamzy 1.43
8507 if (id != NULL)
8508 {
8509 eMethodFound = METHOD_EVENTPROVIDER;
|
8510 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8511 "handleCreateSubscriptionRequest: "
8512 "Found METHOD_EVENTPROVIDER.");
|
8513 mark.hamzy 1.43 }
8514 }
8515 else if (interfaceType == "JMPIExperimental")
8516 {
|
8517 marek 1.68 id = env->GetMethodID(
8518 (jclass)pr.jProviderClass,
8519 "activateFilter",
8520 "(Lorg/pegasus/jmpi/OperationContext;"
8521 "Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
8522 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
8523 mark.hamzy 1.25
|
8524 mark.hamzy 1.43 if (id != NULL)
8525 {
8526 eMethodFound = METHOD_EVENTPROVIDER2;
|
8527 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8528 "handleCreateSubscriptionRequest: "
8529 "Found METHOD_EVENTPROVIDER2.");
|
8530 mark.hamzy 1.43 }
8531 }
|
8532 schuur 1.12
|
8533 mark.hamzy 1.43 if (id == NULL)
|
8534 mark.hamzy 1.25 {
|
8535 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8536 "handleCreateSubscriptionRequest: No method provider found!");
|
8537 mark.hamzy 1.43
8538 PEG_METHOD_EXIT();
8539
|
8540 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
8541 CIM_ERR_FAILED,
8542 MessageLoaderParms(
|
8543 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
8544 marek 1.68 "Could not find a method for the provider based on"
8545 " InterfaceType."));
|
8546 mark.hamzy 1.25 }
|
8547 mark.hamzy 1.23
8548 JMPIjvm::checkException(env);
8549
|
8550 mark.hamzy 1.25 switch (eMethodFound)
8551 {
|
8552 mark.hamzy 1.43 case METHOD_EVENTPROVIDER:
8553 {
|
8554 marek 1.68 WQLSelectStatement *stmt = newSelectExp(
8555 srec->query,
8556 srec->queryLanguage);
8557 jlong jStmtRef = DEBUG_ConvertCToJava(
8558 WQLSelectStatement *,
8559 jlong,
8560 stmt);
8561 jobject jSelectExp = env->NewObject(
8562 jv->SelectExpClassRef,
8563 jv->SelectExpNewJ,
8564 jStmtRef);
|
8565 mark.hamzy 1.43
8566 JMPIjvm::checkException(env);
8567
|
8568 marek 1.68 jstring jType = env->NewStringUTF(
8569 request->nameSpace.getString().getCString());
|
8570 mark.hamzy 1.43
8571 JMPIjvm::checkException(env);
8572
|
8573 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
8574 request->nameSpace,
8575 request->classNames[0]);
|
8576 marek 1.68 jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
8577 jobject jcop = env->NewObject(
8578 jv->CIMObjectPathClassRef,
8579 jv->CIMObjectPathNewJ,jcopRef);
|
8580 mark.hamzy 1.43
8581 JMPIjvm::checkException(env);
8582
|
8583 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8584
|
8585 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
8586 id,
|
8587 mark.hamzy 1.52 jSelectExp,
|
8588 mark.hamzy 1.44 jType,
8589 jcop,
8590 (jboolean)fNewPrec);
|
8591 mark.hamzy 1.43
8592 JMPIjvm::checkException(env);
8593 break;
8594 }
8595
8596 case METHOD_EVENTPROVIDER2:
|
8597 mark.hamzy 1.25 {
|
8598 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
8599 OperationContext*,
8600 jlong,
8601 &request->operationContext);
8602 jobject joc = env->NewObject(
8603 jv->OperationContextClassRef,
8604 jv->OperationContextNewJ,jocRef);
8605
8606 WQLSelectStatement *stmt = newSelectExp(srec->query,
8607 srec->queryLanguage);
8608 jlong jStmtRef = DEBUG_ConvertCToJava(
8609 WQLSelectStatement *,
8610 jlong,
8611 stmt);
8612 jobject jSelectExp = env->NewObject(
8613 jv->SelectExpClassRef,
8614 jv->SelectExpNewJ,
8615 jStmtRef);
|
8616 mark.hamzy 1.25
8617 JMPIjvm::checkException(env);
8618
|
8619 marek 1.68 jstring jType = env->NewStringUTF(
8620 request->nameSpace.getString().getCString());
|
8621 schuur 1.12
|
8622 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8623 schuur 1.1
|
8624 marek 1.68 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
8625 request->nameSpace,
8626 request->classNames[0]);
8627 jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
8628 jobject jcop = env->NewObject(
8629 jv->CIMObjectPathClassRef,
8630 jv->CIMObjectPathNewJ,jcopRef);
|
8631 schuur 1.1
|
8632 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8633 schuur 1.1
|
8634 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8635
|
8636 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
8637 id,
8638 joc,
|
8639 mark.hamzy 1.52 jSelectExp,
|
8640 mark.hamzy 1.44 jType,
8641 jcop,
8642 (jboolean)fNewPrec);
|
8643 schuur 1.12
|
8644 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8645 schuur 1.1
|
8646 mark.hamzy 1.43 if (joc)
8647 {
|
8648 marek 1.68 env->CallVoidMethod(joc,JMPIjvm::jv.OperationContextUnassociate);
|
8649 mark.hamzy 1.43
8650 JMPIjvm::checkException(env);
8651 }
|
8652 mark.hamzy 1.25 break;
|
8653 carolann.graves 1.21 }
8654
|
8655 mark.hamzy 1.25 case METHOD_UNKNOWN:
8656 {
|
8657 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8658 "handleCreateSubscriptionRequest: Unknown method provider!");
|
8659 mark.hamzy 1.25 break;
8660 }
8661 }
|
8662 schuur 1.1 }
8663 HandlerCatch(handler);
|
8664 schuur 1.12
|
8665 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
8666
|
8667 schuur 1.1 PEG_METHOD_EXIT();
8668
8669 return(response);
8670 }
8671
|
8672 marek 1.68 Message * JMPIProviderManager::handleDeleteSubscriptionRequest(
8673 const Message * message) throw()
|
8674 schuur 1.1 {
|
8675 marek 1.68 PEG_METHOD_ENTER(
8676 TRC_PROVIDERMANAGER,
8677 "JMPIProviderManager::handleDeleteSubscriptionRequest");
|
8678 schuur 1.1
|
8679 mark.hamzy 1.23 HandlerIntroInd(DeleteSubscription,message,request,response,handler);
8680
|
8681 mark.hamzy 1.25 typedef enum {
8682 METHOD_UNKNOWN = 0,
|
8683 mark.hamzy 1.43 METHOD_EVENTPROVIDER,
8684 METHOD_EVENTPROVIDER2,
|
8685 mark.hamzy 1.25 } METHOD_VERSION;
|
8686 mark.hamzy 1.44 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
8687 JNIEnv *env = NULL;
8688 bool fFreePrec = false;
8689 indProvRecord *prec = NULL;
8690 indSelectRecord *srec = NULL;
|
8691 mark.hamzy 1.25
|
8692 schuur 1.1 try {
|
8693 mark.hamzy 1.44 String fileName,
8694 providerName,
|
8695 mark.hamzy 1.25 providerLocation;
8696 CIMInstance req_provider,
8697 req_providerModule;
|
8698 marek 1.68 ProviderIdContainer pidc = (ProviderIdContainer)
8699 request->operationContext.get(
8700 ProviderIdContainer::NAME);
|
8701 mark.hamzy 1.25
|
8702 mark.hamzy 1.44 req_provider = pidc.getProvider ();
8703 req_providerModule = pidc.getModule ();
8704
8705 LocateIndicationProviderNames (req_provider,
8706 req_providerModule,
8707 providerName,
8708 providerLocation);
8709
8710 fileName = resolveFileName (providerLocation);
8711
|
8712 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,
8713 "handleDeleteSubscriptionRequest: "
8714 "name space = %s provider name = %s provider filename = %s",
8715 (const char*)request->nameSpace.getString().getCString(),
|
8716 kumpf 1.77 (const char*)providerName.getCString(),
|
8717 thilo.boehm 1.70 (const char*)fileName.getCString()
|
8718 thilo.boehm 1.69 ));
|
8719 se.gupta 1.9
|
8720 mark.hamzy 1.44 // get cached or load new provider module
|
8721 marek 1.68 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(
8722 fileName,
8723 providerName,
8724 String::EMPTY);
|
8725 schuur 1.1
|
8726 mark.hamzy 1.44 JMPIProvider &pr = ph.GetProvider ();
8727
8728 {
8729 AutoMutex lock (mutexProvTab);
8730
8731 provTab.lookup (providerName, prec);
8732 }
|
8733 schuur 1.1
|
8734 mark.hamzy 1.44 {
8735 AutoMutex lock (prec->mutex);
|
8736 mark.hamzy 1.23
|
8737 mark.hamzy 1.44 if (--prec->count <= 0)
8738 {
|
8739 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8740 "handleDeleteSubscriptionRequest: "
8741 "Removing %s from provTab.",
8742 (const char*)providerName.getCString()));
|
8743 schuur 1.1
|
8744 mark.hamzy 1.44 provTab.remove (providerName);
|
8745 schuur 1.1
|
8746 mark.hamzy 1.44 fFreePrec = true;
8747 }
8748 }
|
8749 mark.hamzy 1.25
8750 {
|
8751 marek 1.68 CIMObjectPath sPath = request->subscriptionInstance.getPath();
|
8752 dave.sudlik 1.62 Array<CIMKeyBinding> kb;
8753
8754 // Technically we only need Name and Handler for uniqueness
8755 kb = sPath.getKeyBindings ();
|
8756 mark.hamzy 1.44
|
8757 dave.sudlik 1.62 // Add an entry for every provider.
8758 kb.append (CIMKeyBinding ("Provider",
8759 pr.getName (),
8760 CIMKeyBinding::STRING));
8761
8762 sPath.setKeyBindings (kb);
|
8763 schuur 1.1
|
8764 mark.hamzy 1.44 String sPathString = sPath.toString ();
|
8765 mark.hamzy 1.25
|
8766 mark.hamzy 1.44 AutoMutex lock (mutexSelxTab);
|
8767 schuur 1.1
|
8768 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8769 "handleDeleteSubscriptionRequest: "
8770 "Removing %s from selxTab.",
8771 (const char*)sPathString.getCString()));
|
8772 konrad.r 1.22
|
8773 dave.sudlik 1.62 if (!selxTab.lookup (sPathString, srec))
8774 {
8775 PEGASUS_ASSERT(0);
8776 }
|
8777 schuur 1.1
|
8778 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8779 "handleDeleteSubscriptionRequest: "
|
8780 thilo.boehm 1.70 "For selxTab %s , srec = %p, qContext = %p",
|
8781 thilo.boehm 1.69 (const char*)sPathString.getCString(),
|
8782 thilo.boehm 1.70 srec,srec->qContext));
|
8783 schuur 1.1
|
8784 mark.hamzy 1.44 selxTab.remove (sPathString);
8785 }
|
8786 schuur 1.1
|
8787 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL3,
8788 "handleDeleteSubscriptionRequest: "
8789 "Calling provider: %s",
8790 (const char*)pr.getName().getCString()));
|
8791 schuur 1.1
|
8792 mark.hamzy 1.25 JvmVector *jv = 0;
8793
8794 env = JMPIjvm::attachThread(&jv);
8795
|
8796 mark.hamzy 1.37 if (!env)
8797 {
|
8798 thilo.boehm 1.69 PEG_TRACE_CSTRING( TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8799 "handleDeleteSubscriptionRequest: "
8800 "Could not initialize the JVM (Java Virtual Machine) "
8801 "runtime environment.");
8802
|
8803 mark.hamzy 1.37 PEG_METHOD_EXIT();
8804
|
8805 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
8806 CIM_ERR_FAILED,
8807 MessageLoaderParms(
|
8808 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.INIT_JVM_FAILED",
|
8809 marek 1.68 "Could not initialize the JVM (Java Virtual Machine) "
8810 "runtime environment."));
|
8811 mark.hamzy 1.37 }
8812
|
8813 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
8814
|
8815 mark.hamzy 1.43 jmethodID id = NULL;
8816 String interfaceType;
8817 String interfaceVersion;
8818
|
8819 marek 1.68 getInterfaceType(
8820 request->operationContext.get(ProviderIdContainer::NAME),
8821 interfaceType,
8822 interfaceVersion);
|
8823 mark.hamzy 1.43
8824 if (interfaceType == "JMPI")
8825 {
|
8826 marek 1.68 id = env->GetMethodID(
8827 (jclass)pr.jProviderClass,
8828 "deActivateFilter",
8829 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
8830 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
8831 mark.hamzy 1.43
8832 if (id != NULL)
8833 {
8834 eMethodFound = METHOD_EVENTPROVIDER;
|
8835 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8836 "handleDeleteSubscriptionRequest: "
8837 "Found METHOD_EVENTPROVIDER.");
|
8838 mark.hamzy 1.43 }
8839 }
8840 else if (interfaceType == "JMPIExperimental")
8841 {
|
8842 marek 1.68 id = env->GetMethodID(
8843 (jclass)pr.jProviderClass,
8844 "deActivateFilter",
8845 "(Lorg/pegasus/jmpi/OperationContext;"
8846 "Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
8847 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
8848 mark.hamzy 1.25
|
8849 mark.hamzy 1.43 if (id != NULL)
8850 {
8851 eMethodFound = METHOD_EVENTPROVIDER2;
|
8852 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
8853 "handleDeleteSubscriptionRequest: "
8854 "Found METHOD_EVENTPROVIDER2.");
|
8855 mark.hamzy 1.43 }
8856 }
|
8857 schuur 1.12
|
8858 mark.hamzy 1.43 if (id == NULL)
|
8859 mark.hamzy 1.25 {
|
8860 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8861 "handleDeleteSubscriptionRequest: No method provider found!");
|
8862 mark.hamzy 1.43
8863 PEG_METHOD_EXIT();
8864
|
8865 marek 1.68 throw PEGASUS_CIM_EXCEPTION_L(
8866 CIM_ERR_FAILED,
8867 MessageLoaderParms(
|
8868 thilo.boehm 1.69 "ProviderManager.JMPI.JMPIProviderManager.METHOD_NOT_FOUND",
|
8869 marek 1.68 "Could not find a method for the provider based on"
8870 " InterfaceType."));
|
8871 mark.hamzy 1.25 }
|
8872 mark.hamzy 1.23
8873 JMPIjvm::checkException(env);
8874
|
8875 mark.hamzy 1.25 switch (eMethodFound)
8876 {
|
8877 mark.hamzy 1.43 case METHOD_EVENTPROVIDER:
8878 {
|
8879 marek 1.68 WQLSelectStatement *stmt = newSelectExp(
8880 srec->query,
8881 srec->queryLanguage);
8882 jlong jStmtRef = DEBUG_ConvertCToJava(
8883 WQLSelectStatement *,
8884 jlong,
8885 stmt);
8886 jobject jSelectExp = env->NewObject(
8887 jv->SelectExpClassRef,
8888 jv->SelectExpNewJ,jStmtRef);
|
8889 mark.hamzy 1.43
8890 JMPIjvm::checkException(env);
8891
|
8892 marek 1.68 jstring jType = env->NewStringUTF(
8893 request->nameSpace.getString().getCString());
|
8894 mark.hamzy 1.43
8895 JMPIjvm::checkException(env);
8896
|
8897 marek 1.68 CIMObjectPath *cop = new CIMObjectPath(
8898 System::getHostName(),
8899 request->nameSpace,
8900 request->classNames[0]);
8901 jlong jcopRef = DEBUG_ConvertCToJava(CIMObjectPath*, jlong, cop);
8902 jobject jcop = env->NewObject(
8903 jv->CIMObjectPathClassRef,
8904 jv->CIMObjectPathNewJ,jcopRef);
|
8905 mark.hamzy 1.43
8906 JMPIjvm::checkException(env);
8907
|
8908 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8909
|
8910 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
8911 id,
|
8912 mark.hamzy 1.52 jSelectExp,
|
8913 mark.hamzy 1.44 jType,
8914 jcop,
8915 (jboolean)fFreePrec);
|
8916 mark.hamzy 1.43
8917 JMPIjvm::checkException(env);
8918 break;
8919 }
8920
8921 case METHOD_EVENTPROVIDER2:
|
8922 mark.hamzy 1.25 {
|
8923 marek 1.68 jlong jocRef = DEBUG_ConvertCToJava(
8924 OperationContext*,
8925 jlong,
8926 &request->operationContext);
8927 jobject joc = env->NewObject(
8928 jv->OperationContextClassRef,
8929 jv->OperationContextNewJ,jocRef);
|
8930 mark.hamzy 1.43
|
8931 mark.hamzy 1.52 WQLSelectStatement *stmt = newSelectExp (srec->query,
8932 srec->queryLanguage);
|
8933 marek 1.68 jlong jStmtRef = DEBUG_ConvertCToJava(
8934 WQLSelectStatement *,
8935 jlong,
8936 stmt);
8937 jobject jSelectExp = env->NewObject(
8938 jv->SelectExpClassRef,
8939 jv->SelectExpNewJ,
8940 jStmtRef);
|
8941 mark.hamzy 1.25
8942 JMPIjvm::checkException(env);
8943
|
8944 marek 1.68 jstring jType = env->NewStringUTF(
8945 request->nameSpace.getString().getCString());
|
8946 schuur 1.12
|
8947 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8948 schuur 1.12
|
8949 marek 1.68 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
8950 request->nameSpace,
8951 request->classNames[0]);
8952 jlong jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
8953 jobject jcop = env->NewObject(
8954 jv->CIMObjectPathClassRef,
8955 jv->CIMObjectPathNewJ,jcopRef);
|
8956 schuur 1.1
|
8957 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8958 schuur 1.1
|
8959 kumpf 1.55 StatProviderTimeMeasurement providerTime(response);
8960
|
8961 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
8962 id,
8963 joc,
|
8964 mark.hamzy 1.52 jSelectExp,
|
8965 mark.hamzy 1.44 jType,
8966 jcop,
8967 (jboolean)fFreePrec);
|
8968 schuur 1.1
|
8969 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
8970 schuur 1.1
|
8971 mark.hamzy 1.43 if (joc)
8972 {
|
8973 marek 1.68 env->CallVoidMethod(
8974 joc,
8975 JMPIjvm::jv.OperationContextUnassociate);
|
8976 mark.hamzy 1.43
8977 JMPIjvm::checkException(env);
8978 }
|
8979 mark.hamzy 1.25 break;
8980 }
|
8981 schuur 1.12
|
8982 mark.hamzy 1.25 case METHOD_UNKNOWN:
8983 {
|
8984 thilo.boehm 1.69 PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
8985 "handleDeleteSubscriptionRequest: Unknown method provider!");
|
8986 mark.hamzy 1.25 break;
8987 }
8988 }
|
8989 mark.hamzy 1.44
8990 //
8991 // Decrement count of current subscriptions for this provider
8992 //
8993 pr.decrementSubscriptionsAndTestIfZero ();
|
8994 schuur 1.1 }
8995 HandlerCatch(handler);
|
8996 schuur 1.12
|
8997 mark.hamzy 1.44 if (srec)
8998 {
8999 delete srec->qContext;
9000 }
9001 delete srec;
9002
9003 if (fFreePrec)
9004 {
9005 delete prec->ctx;
9006 delete prec->handler;
9007 delete prec;
9008 }
9009
|
9010 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
9011
|
9012 schuur 1.1 PEG_METHOD_EXIT();
9013
9014 return(response);
9015 }
9016
|
9017 marek 1.68 Message * JMPIProviderManager::handleDisableModuleRequest(
9018 const Message * message) throw()
|
9019 schuur 1.1 {
|
9020 marek 1.68 PEG_METHOD_ENTER(
9021 TRC_PROVIDERMANAGER,
9022 "JMPIProviderManager::handleDisableModuleRequest");
|
9023 schuur 1.1
9024 CIMDisableModuleRequestMessage * request =
|
9025 marek 1.68 dynamic_cast<CIMDisableModuleRequestMessage *>
9026 (const_cast<Message *>(message));
|
9027 schuur 1.1
9028 PEGASUS_ASSERT(request != 0);
9029
9030 // get provider module name
9031 String moduleName;
9032 CIMInstance mInstance = request->providerModule;
|
9033 marek 1.73 Uint32 pos = mInstance.findProperty(PEGASUS_PROPERTYNAME_NAME);
|
9034 schuur 1.1
9035 if(pos != PEG_NOT_FOUND)
9036 {
9037 mInstance.getProperty(pos).getValue().get(moduleName);
9038 }
9039
9040 Boolean disableProviderOnly = request->disableProviderOnly;
9041
9042 Array<Uint16> operationalStatus;
|
9043 kumpf 1.2 // Assume success.
|
9044 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
9045 schuur 1.1
|
9046 kumpf 1.2 //
|
9047 schuur 1.1 // Unload providers
|
9048 kumpf 1.2 //
|
9049 schuur 1.1 Array<CIMInstance> _pInstances = request->providers;
9050
|
9051 kumpf 1.67 CIMDisableModuleResponseMessage* response =
9052 dynamic_cast<CIMDisableModuleResponseMessage*>(
9053 request->buildResponse());
|
9054 schuur 1.1 PEGASUS_ASSERT(response != 0);
|
9055 kumpf 1.67 response->operationalStatus = operationalStatus;
|
9056 schuur 1.1
9057 PEG_METHOD_EXIT();
9058
9059 return(response);
9060 }
9061
|
9062 marek 1.68 Message * JMPIProviderManager::handleEnableModuleRequest(
9063 const Message * message) throw()
|
9064 schuur 1.1 {
|
9065 marek 1.68 PEG_METHOD_ENTER(
9066 TRC_PROVIDERMANAGER,
9067 "JMPIProviderManager::handleEnableModuleRequest");
|
9068 schuur 1.1
9069 CIMEnableModuleRequestMessage * request =
|
9070 marek 1.68 dynamic_cast<CIMEnableModuleRequestMessage *>
9071 (const_cast<Message *>(message));
|
9072 schuur 1.1
9073 PEGASUS_ASSERT(request != 0);
9074
9075 Array<Uint16> operationalStatus;
|
9076 kumpf 1.67 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
9077 schuur 1.1
|
9078 kumpf 1.67 CIMEnableModuleResponseMessage* response =
9079 dynamic_cast<CIMEnableModuleResponseMessage*>(
9080 request->buildResponse());
|
9081 schuur 1.1 PEGASUS_ASSERT(response != 0);
|
9082 kumpf 1.67 response->operationalStatus = operationalStatus;
|
9083 schuur 1.1
9084 PEG_METHOD_EXIT();
9085
9086 return(response);
9087 }
9088
|
9089 marek 1.68 Message * JMPIProviderManager::handleStopAllProvidersRequest(
9090 const Message * message) throw()
|
9091 schuur 1.1 {
|
9092 marek 1.68 PEG_METHOD_ENTER(
9093 TRC_PROVIDERMANAGER,
9094 "JMPIProviderManager::handleStopAllProvidersRequest");
|
9095 schuur 1.1
9096 CIMStopAllProvidersRequestMessage * request =
|
9097 marek 1.68 dynamic_cast<CIMStopAllProvidersRequestMessage *>
9098 (const_cast<Message *>(message));
|
9099 schuur 1.1
9100 PEGASUS_ASSERT(request != 0);
9101
|
9102 kumpf 1.67 CIMStopAllProvidersResponseMessage* response =
9103 dynamic_cast<CIMStopAllProvidersResponseMessage*>(
9104 request->buildResponse());
|
9105 schuur 1.1 PEGASUS_ASSERT(response != 0);
9106
9107 // tell the provider manager to shutdown all the providers
9108 providerManager.shutdownAllProviders();
9109
9110 PEG_METHOD_EXIT();
9111
9112 return(response);
9113 }
9114
|
9115 venkat.puvvada 1.79 Message* JMPIProviderManager::handleIndicationServiceDisabledRequest(
9116 Message* message)
9117 {
9118 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
9119 "JMPIProviderManager::_handleIndicationServiceDisabledRequest");
9120
9121 CIMIndicationServiceDisabledRequestMessage* request =
9122 dynamic_cast<CIMIndicationServiceDisabledRequestMessage*>(message);
9123 PEGASUS_ASSERT(request != 0);
9124
9125 CIMIndicationServiceDisabledResponseMessage* response =
9126 dynamic_cast<CIMIndicationServiceDisabledResponseMessage*>(
9127 request->buildResponse());
9128 PEGASUS_ASSERT(response != 0);
9129
9130 _subscriptionInitComplete = false;
9131
9132 PEG_METHOD_EXIT ();
9133 return response;
9134 }
9135
|
9136 marek 1.68 Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest(
9137 const Message * message)
|
9138 carolann.graves 1.21 {
9139 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
9140 "JMPIProviderManager::handleSubscriptionInitCompleteRequest");
9141
9142 CIMSubscriptionInitCompleteRequestMessage * request =
9143 dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
9144 (const_cast <Message *> (message));
9145
9146 PEGASUS_ASSERT (request != 0);
9147
9148 CIMSubscriptionInitCompleteResponseMessage * response =
9149 dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
9150 (request->buildResponse ());
9151
9152 PEGASUS_ASSERT (response != 0);
9153
9154 //
9155 // Set indicator
9156 //
9157 _subscriptionInitComplete = true;
9158
9159 carolann.graves 1.21 //
9160 // For each provider that has at least one subscription, call
9161 // provider's enableIndications method
9162 //
9163 Array <JMPIProvider *> enableProviders;
|
9164 mark.hamzy 1.44
|
9165 carolann.graves 1.21 enableProviders = providerManager.getIndicationProvidersToEnable ();
9166
9167 Uint32 numProviders = enableProviders.size ();
|
9168 mark.hamzy 1.44
|
9169 thilo.boehm 1.69 PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,
9170 "handleSubscriptionInitCompleteRequest: numProviders = %d ",
9171 numProviders));
|
9172 carolann.graves 1.21
9173 PEG_METHOD_EXIT ();
9174 return (response);
9175 }
9176
|
9177 marek 1.68 Message * JMPIProviderManager::handleUnsupportedRequest(
9178 const Message * message) throw()
|
9179 schuur 1.1 {
|
9180 marek 1.68 PEG_METHOD_ENTER(
9181 TRC_PROVIDERMANAGER,
9182 "JMPIProviderManager::handleUnsupportedRequest");
|
9183 mark.hamzy 1.23
|
9184 konrad.r 1.16 CIMRequestMessage* request =
9185 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
9186 PEGASUS_ASSERT(request != 0 );
9187
9188 CIMResponseMessage* response = request->buildResponse();
9189 response->cimException =
9190 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
|
9191 schuur 1.1
9192 PEG_METHOD_EXIT();
|
9193 konrad.r 1.16 return response;
|
9194 schuur 1.1 }
9195
|
9196 kumpf 1.2 ProviderName JMPIProviderManager::_resolveProviderName(
9197 const ProviderIdContainer & providerId)
|
9198 schuur 1.1 {
|
9199 kumpf 1.2 String providerName;
9200 String fileName;
|
9201 dmitry.mikulin 1.63 String moduleName;
|
9202 kumpf 1.2 CIMValue genericValue;
9203
|
9204 dmitry.mikulin 1.63 genericValue = providerId.getModule().getProperty(
|
9205 marek 1.73 providerId.getModule().findProperty(
9206 PEGASUS_PROPERTYNAME_NAME)).getValue();
|
9207 dmitry.mikulin 1.63 genericValue.get(moduleName);
9208
|
9209 kumpf 1.2 genericValue = providerId.getProvider().getProperty(
|
9210 marek 1.73 providerId.getProvider().findProperty(
9211 PEGASUS_PROPERTYNAME_NAME)).getValue();
|
9212 kumpf 1.2 genericValue.get(providerName);
9213
9214 genericValue = providerId.getModule().getProperty(
9215 providerId.getModule().findProperty("Location")).getValue();
9216 genericValue.get(fileName);
9217 fileName = resolveFileName(fileName);
9218
|
9219 dmitry.mikulin 1.63 return ProviderName(moduleName, providerName, fileName);
|
9220 schuur 1.1 }
9221
9222 String JMPIProviderManager::resolveFileName(String fileName)
9223 {
|
9224 marek 1.68 String name = ConfigManager::getHomedPath(
9225 ConfigManager::getInstance()->getCurrentValue("providerDir"));
|
9226 marek 1.54 // physfilename = everything up to the delimiter pointing at class start
9227 // in case there is no delimiter anymore, it takes the entire filename
9228 String physfilename = fileName.subString(0, fileName.find(":"));
9229 // look in all(multiple) homed pathes for the physical file
9230 name = FileSystem::getAbsoluteFileName(name, physfilename);
9231 // construct back the fully specified jar:<classname> provider name
9232 name = FileSystem::extractFilePath(name) + fileName;
|
9233 schuur 1.1 return name;
9234 }
9235
9236 PEGASUS_NAMESPACE_END
|
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI