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