1 karl 1.39 //%2006////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.17 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.17 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.18 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.39 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 schuur 1.1 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
|
20 mark.hamzy 1.40 //
|
21 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
|
32 mark.hamzy 1.23 // Author: Adrian Schuur, schuur@de.ibm.com
|
33 schuur 1.1 //
|
34 se.gupta 1.9 // Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135
|
35 joyce.j 1.19 // Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for PEP#101
|
36 schuur 1.1 //
37 //%/////////////////////////////////////////////////////////////////////////////
38
39 #include "JMPIProviderManager.h"
40
41 #include "JMPIImpl.h"
42
43 #include <Pegasus/Common/CIMMessage.h>
44 #include <Pegasus/Common/OperationContext.h>
45 #include <Pegasus/Common/Tracer.h>
46 #include <Pegasus/Common/StatisticalData.h>
47 #include <Pegasus/Common/Logger.h>
48 #include <Pegasus/Common/MessageLoader.h> //l10n
|
49 kumpf 1.10 #include <Pegasus/Common/Constants.h>
|
50 schuur 1.1
51 #include <Pegasus/Config/ConfigManager.h>
52
53 #include <Pegasus/ProviderManager2/ProviderName.h>
54 #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h>
|
55 konrad.r 1.22 #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h>
|
56 schuur 1.1 #include <Pegasus/ProviderManager2/ProviderManagerService.h>
57
|
58 schuur 1.12 #include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h>
59
|
60 schuur 1.1
61 PEGASUS_USING_STD;
62 PEGASUS_NAMESPACE_BEGIN
63
|
64 mark.hamzy 1.23 int JMPIProviderManager::trace=0;
|
65 mark.hamzy 1.24
66 #ifdef PEGASUS_DEBUG
|
67 mark.hamzy 1.23 #define DDD(x) if (JMPIProviderManager::trace) x;
|
68 mark.hamzy 1.24 #else
69 #define DDD(x)
70 #endif
|
71 mark.hamzy 1.36
72 // request->localOnly is replaced with JMPI_LOCALONLY for getInstance () and enumerateInstances ()
|
73 mark.hamzy 1.30 #define JMPI_LOCALONLY false
|
74 mark.hamzy 1.36
|
75 mark.hamzy 1.32 /* Fix for 4092 */
|
76 mark.hamzy 1.36 // request->includeQualifiers is replaced with JMPI_INCLUDE_QUALIFIERS for getInstance (),
77 // setInstance (), enumerateInstances (), associators (), and references ()
|
78 mark.hamzy 1.32 #define JMPI_INCLUDE_QUALIFIERS false
|
79 mark.hamzy 1.23
80 #include "Convert.h"
|
81 schuur 1.1
|
82 mark.hamzy 1.23 void JMPIProviderManager::debugPrintMethodPointers (JNIEnv *env, jclass jc)
83 {
84 // cd ${PEGAUSE_HOME}/src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/tests/JMPI_TestPropertyTypes
85 // javap -s -p JMPI_TestPropertyTypes
|
86 mark.hamzy 1.35 static const char *methodNames[][3] = {
|
87 mark.hamzy 1.24 // CIMProvider
88 // cimom-2003-11-24/org/snia/wbem/provider/CIMProvider.java
89 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMProvider.java
|
90 mark.hamzy 1.36 {"snia 2.0","initialize","(Lorg/pegasus/jmpi/CIMOMHandle;)V"},
91 {"snia 2.0","cleanup","()V"},
|
92 mark.hamzy 1.24 // InstanceProvider
93 // cimom-2003-11-24/org/snia/wbem/provider/InstanceProvider.java
94 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMInstanceProvider.java
|
95 mark.hamzy 1.36 {"snia 2.0","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"},
96 {"pegasus 2.4","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;"},
|
97 mark.hamzy 1.35 /* Begin Fix for 4189 */
|
98 mark.hamzy 1.38 {"pegasus 2.5","enumerateInstances","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
|
99 mark.hamzy 1.35 /* End Fix for 4189 */
|
100 mark.hamzy 1.36 {"snia 2.0","enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},
101 {"pegasus 2.4","enumerateInstanceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;"},
102 {"pegasus 2.5","enumerateInstanceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},
103 {"snia 2.0","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;"},
104 {"pegasus 2.4","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)Lorg/pegasus/jmpi/CIMInstance;"},
|
105 mark.hamzy 1.35 /* Begin Fix for 4238 */
|
106 mark.hamzy 1.38 {"pegasus 2.5","getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;"},
|
107 mark.hamzy 1.35 /* End Fix for 4238 */
|
108 mark.hamzy 1.36 {"snia 2.0","createInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;"},
109 {"snia 2.0","setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"},
110 {"pegasus 2.4","setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V"},
111 {"snia 2.0","deleteInstance","(Lorg/pegasus/jmpi/CIMObjectPath;)V"},
112 {"snia 2.0","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},
113 {"pegasus 2.4","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;"},
114 {"pegasus 2.5","execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},
|
115 mark.hamzy 1.24 // MethodProvider
116 // cimom-2003-11-24/org/snia/wbem/provider/MethodProvider.java
117 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMMethodProvider.java
|
118 mark.hamzy 1.36 {"snia 2.0","invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"},
119 {"pegasus 2.4","invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;"},
|
120 mark.hamzy 1.24 // PropertyProvider
121 // cimom-2003-11-24/org/snia/wbem/provider/PropertyProvider.java
|
122 mark.hamzy 1.36 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/PropertyProvider.java
123 {"snia 2.0","getPropertyValue","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;"},
124 {"snia 2.0","setPropertyValue","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V"},
|
125 mark.hamzy 1.24 // AssociatorProvider
126 // cimom-2003-11-24/org/snia/wbem/provider20/AssociatorProvider.java
|
127 mark.hamzy 1.36 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/AssociatorProvider.java
128 {"snia 2.0","associators","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
129 {"pegasus 2.4","associators","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
130 {"snia 2.0","associatorNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},
131 {"pegasus 2.4","associatorNames","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"},
132 {"snia 2.0","references","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
133 {"pegasus 2.4","references","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"},
134 {"snia 2.0","referenceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"},
135 {"pegasus 2.4","referenceNames","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;"},
|
136 mark.hamzy 1.24 // CIMProviderRouter
137 // cimom-2003-11-24/org/snia/wbem/provider20/CIMProviderRouter.java
138 // EventProvider
139 // cimom-2003-11-24/org/snia/wbem/provider20/EventProvider.java
140 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/EventProvider.java
|
141 mark.hamzy 1.36 {"snia 2.0","activateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},
142 {"snia 2.0","deActivateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},
|
143 mark.hamzy 1.24 // IndicationHandler
144 // cimom-2003-11-24/org/snia/wbem/provider20/IndicationHandler.java
145 // ProviderAdapter
146 // cimom-2003-11-24/org/snia/wbem/provider20/ProviderAdapter.java
147 // JMPI_TestPropertyTypes
|
148 mark.hamzy 1.36 {"JMPI_TestPropertyTypes","findObjectPath","(Lorg/pegasus/jmpi/CIMObjectPath;)I"},
149 {"JMPI_TestPropertyTypes","testPropertyTypesValue","(Lorg/pegasus/jmpi/CIMInstance;)V"}
|
150 mark.hamzy 1.23 };
151
152 if (!env)
153 {
154 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: env is NULL!"<<PEGASUS_STD(endl));
155 return;
156 }
157 if (!jc)
158 {
159 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: jc is NULL!"<<PEGASUS_STD(endl));
160 return;
161 }
162
163 for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++)
164 {
|
165 mark.hamzy 1.35 jmethodID id = env->GetMethodID(jc,methodNames[i][1], methodNames[i][2]);
166 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: "<<methodNames[i][0]<<", "<<methodNames[i][1]<<", id = "<<PEGASUS_STD(hex)<<(int)id<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
167 mark.hamzy 1.23 env->ExceptionClear();
168 }
|
169 mark.hamzy 1.29
170 env->ExceptionClear();
171 }
172
173 void
174 debugIntrospectJavaObject (JNIEnv *env, jobject jInst)
175 {
176 jclass jInstClass = env->GetObjectClass(jInst);
177 jclass jInstSuperClass = env->GetSuperclass(jInstClass);
178 jmethodID jmidGetDeclaredMethods = env->GetMethodID(jInstClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;");
179
180 if (!jmidGetDeclaredMethods)
181 {
182 env->ExceptionClear();
183 jmidGetDeclaredMethods = env->GetMethodID(jInstSuperClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;");
184 }
185
186 if (jmidGetDeclaredMethods)
187 {
188 jobjectArray jarrayDeclaredMethods = (jobjectArray)env->CallObjectMethod(jInstClass,
189 jmidGetDeclaredMethods);
190 mark.hamzy 1.29
191 if (jarrayDeclaredMethods)
192 {
193 for (int i = 0, iLen = env->GetArrayLength (jarrayDeclaredMethods); i < iLen; i++)
194 {
195 JMPIjvm::checkException(env);
196
197 jobject jDeclaredMethod = env->GetObjectArrayElement (jarrayDeclaredMethods, i);
198 jclass jDeclaredMethodClass = env->GetObjectClass (jDeclaredMethod);
199
200 JMPIjvm::checkException(env);
201
202 jmethodID jmidToString = env->GetMethodID (jDeclaredMethodClass, "toString", "()Ljava/lang/String;");
203 jstring jstringResult = (jstring)env->CallObjectMethod (jDeclaredMethod, jmidToString);
204 const char *pszResult = env->GetStringUTFChars(jstringResult, 0);
205
206 PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugIntrospectJavaObject: "<<pszResult<<PEGASUS_STD(endl);
207
208 env->ReleaseStringUTFChars (jstringResult, pszResult);
209 }
210 }
211 mark.hamzy 1.29 }
212
213
214 env->ExceptionClear();
215 }
216
217 void
218 debugDumpJavaObject (JNIEnv *env, jobject jInst)
219 {
220 jclass jInstClass = env->GetObjectClass(jInst);
221 jclass jInstSuperClass = env->GetSuperclass(jInstClass);
222 jmethodID jmidToString1 = env->GetMethodID(jInstClass, "toString", "()Ljava/lang/String;");
223 jmethodID jmidToString2 = env->GetMethodID(jInstSuperClass, "toString", "()Ljava/lang/String;");
224 if (!jmidToString1 || !jmidToString2)
225 {
226 env->ExceptionClear();
227 return;
228 }
229 jstring jstringResult1 = (jstring)env->CallObjectMethod(jInstClass, jmidToString1);
230 jstring jstringResult2 = (jstring)env->CallObjectMethod(jInstSuperClass, jmidToString2);
231 jstring jstringResult3 = (jstring)env->CallObjectMethod(jInst, jmidToString1);
232 mark.hamzy 1.29 const char *pszResult1 = env->GetStringUTFChars(jstringResult1, 0);
233 const char *pszResult2 = env->GetStringUTFChars(jstringResult2, 0);
234 const char *pszResult3 = env->GetStringUTFChars(jstringResult3, 0);
235
236 jmethodID jmidCInst = env->GetMethodID(env->GetObjectClass(jInst),JMPIjvm::jv.instanceMethodNames[22].methodName, JMPIjvm::jv.instanceMethodNames[22].signature);
237
238 PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugIntrospectJavaObject: jInstClass = "<<jInstClass<<", jInstSuperClass = "<<jInstSuperClass<<", jClassShouldBe = "<<JMPIjvm::jv.classRefs[18]<<", jmidCInst = "<<jmidCInst<<PEGASUS_STD(endl);
239 PEGASUS_STD(cout)<<"pszResult1 = "<<pszResult1<<PEGASUS_STD(endl);
240 PEGASUS_STD(cout)<<"pszResult2 = "<<pszResult2<<PEGASUS_STD(endl);
241 PEGASUS_STD(cout)<<"pszResult3 = "<<pszResult3<<PEGASUS_STD(endl);
242
243 env->ReleaseStringUTFChars (jstringResult1, pszResult1);
244 env->ReleaseStringUTFChars (jstringResult2, pszResult2);
245 env->ReleaseStringUTFChars (jstringResult3, pszResult3);
246
247 env->ExceptionClear();
|
248 mark.hamzy 1.23 }
|
249 schuur 1.1
|
250 mark.hamzy 1.43 bool JMPIProviderManager::getInterfaceType (ProviderIdContainer pidc,
251 String& interfaceType,
252 String& interfaceVersion)
253 {
254 ///CIMInstance ciProvider = pidc.getProvider ();
255 CIMInstance ciProviderModule = pidc.getModule ();
256 Uint32 idx;
257 bool fRet = true;
258
259 ///PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: ciProvider = "<<ciProvider.getPath ().toString ()<<PEGASUS_STD(endl);
260 ///PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: ciProviderModule = "<<ciProviderModule.getPath ().toString ()<<PEGASUS_STD(endl);
261
262 idx = ciProviderModule.findProperty ("InterfaceType");
263
264 if (idx != PEG_NOT_FOUND)
265 {
266 CIMValue itValue;
267
268 itValue = ciProviderModule.getProperty (idx).getValue ();
269
270 itValue.get (interfaceType);
271 mark.hamzy 1.43
272 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: interfaceType = "<<interfaceType<<PEGASUS_STD(endl));
273 }
274 else
275 {
276 fRet = false;
277 }
278
279 idx = ciProviderModule.findProperty ("InterfaceVersion");
280
281 if (idx != PEG_NOT_FOUND)
282 {
283 CIMValue itValue;
284
285 itValue = ciProviderModule.getProperty (idx).getValue ();
286
287 itValue.get (interfaceVersion);
288
289 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::getInterfaceType: interfaceVersion = "<<interfaceVersion<<PEGASUS_STD(endl));
290 }
291 else
292 mark.hamzy 1.43 {
293 fRet = false;
294 }
295
296 return fRet;
297 }
298
299 bool JMPIProviderManager::interfaceIsUsed (JNIEnv *env,
300 jobject jObject,
301 String searchInterfaceName)
302 {
303 jobjectArray jInterfaces = 0;
304 jsize jInterfacesLength = 0;
305 bool fFound = false;
306
307 if (!jObject)
308 {
309 return false;
310 }
311
312 jInterfaces = (jobjectArray)env->CallObjectMethod (env->GetObjectClass (jObject),
313 mark.hamzy 1.43 JMPIjvm::jv.ClassGetInterfaces);
314
315 if (!jInterfaces)
316 {
317 return false;
318 }
319
320 jInterfacesLength = env->GetArrayLength (jInterfaces);
321
322 for (jsize i = 0; !fFound && i < jInterfacesLength; i++)
323 {
324 jobject jInterface = env->GetObjectArrayElement (jInterfaces, i);
325
326 if (jInterface)
327 {
328 jstring jInterfaceName = (jstring)env->CallObjectMethod (jInterface,
329 JMPIjvm::jv.ClassGetName);
330
331 if (jInterfaceName)
332 {
333 const char *pszInterfaceName = env->GetStringUTFChars (jInterfaceName,
334 mark.hamzy 1.43 0);
335 String interfaceName = pszInterfaceName;
336
337 if (String::equal (interfaceName, searchInterfaceName))
338 {
339 fFound = true;
340 }
341
342 env->ReleaseStringUTFChars (jInterfaceName, pszInterfaceName);
343 }
344 }
345 }
346
347 return fFound;
348 }
349
|
350 schuur 1.1 JMPIProviderManager::IndProvTab JMPIProviderManager::provTab;
|
351 mark.hamzy 1.44 Mutex JMPIProviderManager::mutexProvTab;
|
352 schuur 1.1 JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab;
|
353 mark.hamzy 1.44 Mutex JMPIProviderManager::mutexSelxTab;
|
354 schuur 1.1 JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg;
|
355 mark.hamzy 1.44 Mutex JMPIProviderManager::mutexProvReg;
|
356 schuur 1.1
357 JMPIProviderManager::JMPIProviderManager(Mode m)
358 {
359 mode=m;
|
360 carolann.graves 1.21 _subscriptionInitComplete = false;
|
361 mark.hamzy 1.23
362 #ifdef PEGASUS_DEBUG
363 if (getenv("PEGASUS_JMPI_TRACE"))
364 JMPIProviderManager::trace = 1;
365 else
366 JMPIProviderManager::trace = 0;
367 #else
368 JMPIProviderManager::trace = 0;
369 #endif
|
370 schuur 1.1 }
371
372 JMPIProviderManager::~JMPIProviderManager(void)
373 {
374 }
375
|
376 schuur 1.12 Boolean JMPIProviderManager::insertProvider(const ProviderName & name,
|
377 schuur 1.1 const String &ns, const String &cn)
378 {
379 String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString());
|
380 mark.hamzy 1.23
381 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::insertProvider: "<<key<<PEGASUS_STD(endl));
382
|
383 mark.hamzy 1.44 Boolean ret = false;
384
385 {
386 AutoMutex lock (mutexProvReg);
387
388 ret = provReg.insert(key,name);
389 }
390
391 return ret;
|
392 schuur 1.1 }
|
393 mark.hamzy 1.23
|
394 schuur 1.1 Message * JMPIProviderManager::processMessage(Message * request) throw()
395 {
|
396 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::processMessage()");
|
397 schuur 1.1
398 Message * response = 0;
|
399 mark.hamzy 1.23
|
400 schuur 1.1 // pass the request message to a handler method based on message type
401 switch(request->getType())
402 {
403 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
404 response = handleGetInstanceRequest(request);
|
405 mark.hamzy 1.25 break;
|
406 schuur 1.1
407 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
408 response = handleEnumerateInstancesRequest(request);
|
409 mark.hamzy 1.25 break;
|
410 schuur 1.1
411 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
412 response = handleEnumerateInstanceNamesRequest(request);
|
413 mark.hamzy 1.25 break;
|
414 schuur 1.1
415 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
416 response = handleCreateInstanceRequest(request);
|
417 mark.hamzy 1.25 break;
|
418 schuur 1.1
419 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
420 response = handleModifyInstanceRequest(request);
|
421 mark.hamzy 1.25 break;
|
422 schuur 1.1
423 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
424 response = handleDeleteInstanceRequest(request);
|
425 mark.hamzy 1.25 break;
|
426 schuur 1.1
|
427 mark.hamzy 1.25 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
428 response = handleExecQueryRequest(request);
|
429 schuur 1.1 break;
430
431 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
432 response = handleAssociatorsRequest(request);
|
433 mark.hamzy 1.25 break;
|
434 schuur 1.1
435 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
436 response = handleAssociatorNamesRequest(request);
|
437 mark.hamzy 1.25 break;
|
438 schuur 1.1
439 case CIM_REFERENCES_REQUEST_MESSAGE:
440 response = handleReferencesRequest(request);
|
441 mark.hamzy 1.25 break;
|
442 schuur 1.1
443 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
444 response = handleReferenceNamesRequest(request);
|
445 mark.hamzy 1.25 break;
|
446 schuur 1.1
|
447 mark.hamzy 1.26 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
448 response = handleGetPropertyRequest(request);
449 break;
450
451 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
452 response = handleSetPropertyRequest(request);
453 break;
454
|
455 schuur 1.11 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
|
456 schuur 1.1 response = handleInvokeMethodRequest(request);
|
457 mark.hamzy 1.25 break;
|
458 schuur 1.1
|
459 schuur 1.12 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
|
460 schuur 1.1 response = handleCreateSubscriptionRequest(request);
|
461 mark.hamzy 1.25 break;
|
462 schuur 1.1
|
463 mark.hamzy 1.25 /* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
|
464 schuur 1.1 response = handleModifySubscriptionRequest(request);
465 break;
|
466 schuur 1.12 */
|
467 schuur 1.1 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
468 response = handleDeleteSubscriptionRequest(request);
|
469 mark.hamzy 1.25 break;
|
470 schuur 1.1
|
471 mark.hamzy 1.26 /* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
|
472 kumpf 1.7 response = handleExportIndicationRequest(request);
|
473 schuur 1.1 break;
|
474 schuur 1.12 */
|
475 schuur 1.1 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
476 response = handleDisableModuleRequest(request);
|
477 mark.hamzy 1.25 break;
|
478 schuur 1.1
479 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
480 response = handleEnableModuleRequest(request);
|
481 mark.hamzy 1.25 break;
|
482 schuur 1.1
483 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
484 response = handleStopAllProvidersRequest(request);
|
485 mark.hamzy 1.25 break;
|
486 schuur 1.1
|
487 kumpf 1.4 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
|
488 mark.hamzy 1.23 response = handleInitializeProviderRequest(request);
|
489 mark.hamzy 1.25 break;
|
490 kumpf 1.4
|
491 carolann.graves 1.21 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
492 response = handleSubscriptionInitCompleteRequest (request);
|
493 mark.hamzy 1.25 break;
|
494 carolann.graves 1.21
|
495 schuur 1.1 default:
|
496 mark.hamzy 1.23 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
497 "*** Unsupported Request "+request->getType());
498 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::processMessage: Unsupported request "<<request->getType ()<<PEGASUS_STD(endl));
|
499 mark.hamzy 1.25
|
500 schuur 1.1 response = handleUnsupportedRequest(request);
501 break;
502 }
503
504 PEG_METHOD_EXIT();
505
506 return(response);
507 }
508
|
509 kumpf 1.6 Boolean JMPIProviderManager::hasActiveProviders()
510 {
511 return providerManager.hasActiveProviders();
512 }
513
514 void JMPIProviderManager::unloadIdleProviders()
|
515 schuur 1.1 {
|
516 kumpf 1.6 providerManager.unloadIdleProviders();
|
517 schuur 1.1 }
518
519 #define STRDUPA(s,o) \
520 if (s) { \
521 o=(const char*)alloca(strlen(s)); \
522 strcpy((char*)(o),(s)); \
523 } \
524 else o=NULL;
525
526 #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)
527
528
529 #define HandlerIntroBase(type,type1,message,request,response,handler,respType) \
530 CIM##type##RequestMessage * request = \
531 dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \
532 PEGASUS_ASSERT(request != 0); \
533 CIM##type##ResponseMessage * response = \
534 new CIM##type##ResponseMessage( \
535 request->messageId, \
536 CIMException(), \
537 request->queueIds.copyAndPop() \
538 schuur 1.1 respType \
539 PEGASUS_ASSERT(response != 0); \
540 response->setKey(request->getKey()); \
541 response->setHttpMethod(request->getHttpMethod()); \
|
542 kumpf 1.42 type1##ResponseHandler handler(request, response, _responseChunkCallback);
|
543 schuur 1.1
544 #define VOIDINTRO );
545 #define NOVOIDINTRO(type) ,type);
546 #define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName );
547
548
549 #define HandlerIntroVoid(type,message,request,response,handler) \
550 HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO)
551
552 #define HandlerIntroMethod(type,message,request,response,handler) \
553 HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO)
554
555 #define HandlerIntroInd(type,message,request,response,handler) \
556 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
557
|
558 kumpf 1.4 #define HandlerIntroInit(type,message,request,response,handler) \
559 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
560
|
561 schuur 1.1 #define HandlerIntro(type,message,request,response,handler,respType) \
562 HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType))
563
564 #define HandlerCatch(handler) \
565 catch(CIMException & e) \
566 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
567 "Exception: " + e.getMessage()); \
568 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); \
569 } \
570 catch(Exception & e) \
571 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
572 "Exception: " + e.getMessage()); \
573 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \
574 } \
575 catch(...) \
576 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
577 "Exception: Unknown"); \
578 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
579 }
580
|
581 schuur 1.13 static jobjectArray getList(JvmVector *jv, JNIEnv *env, CIMPropertyList &list)
582 {
583 Uint32 s=list.size();
584 jobjectArray pl=NULL;
585 if (s) {
586 jstring initial=env->NewString(NULL,0);
|
587 mark.hamzy 1.23 pl=(jobjectArray)env->NewObjectArray(s,jv->StringClassRef,initial);
|
588 schuur 1.13 for (Uint32 i=0; i<s; i++) {
589 env->SetObjectArrayElement
590 (pl,i,env->NewStringUTF(list[i].getString().getCString()));
591 }
592 }
593 return pl;
594 }
|
595 schuur 1.1
596 Message * JMPIProviderManager::handleGetInstanceRequest(const Message * message) throw()
597 {
|
598 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetInstanceRequest");
|
599 schuur 1.1
600 HandlerIntro(GetInstance,message,request,response,handler,CIMInstance());
601
|
602 mark.hamzy 1.25 typedef enum {
603 METHOD_UNKNOWN = 0,
|
604 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
605 METHOD_INSTANCEPROVIDER,
606 METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2
|
607 mark.hamzy 1.25 } METHOD_VERSION;
608 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
609 JNIEnv *env = NULL;
|
610 schuur 1.13
|
611 schuur 1.1 try {
|
612 mark.hamzy 1.23 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
613 schuur 1.1 "JMPIProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
614 System::getHostName(),
615 request->nameSpace.getString(),
616 request->instanceName.getClassName().getString());
617
|
618 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->instanceName.getClassName().getString()<<PEGASUS_STD(endl));
619
|
620 schuur 1.1 // make target object path
|
621 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
622 request->nameSpace,
623 request->instanceName.getClassName(),
624 request->instanceName.getKeyBindings());
|
625 schuur 1.1
626 // resolve provider name
|
627 kumpf 1.2 ProviderName name = _resolveProviderName(
628 request->operationContext.get(ProviderIdContainer::NAME));
|
629 schuur 1.1
630 // get cached or load new provider module
|
631 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
632 name.getLogicalName());
|
633 schuur 1.1 OperationContext context;
634
|
635 mark.hamzy 1.43 context.insert(request->operationContext.get(IdentityContainer::NAME));
636 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
637 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
638
|
639 mark.hamzy 1.23 // forward request
|
640 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
641 schuur 1.1
|
642 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.getInstance: " + pr.getName());
|
643 schuur 1.1
|
644 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Calling provider getInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
645 schuur 1.1
|
646 mark.hamzy 1.25 JvmVector *jv = 0;
647
648 env = JMPIjvm::attachThread(&jv);
649
|
650 mark.hamzy 1.37 if (!env)
651 {
652 PEG_METHOD_EXIT();
653
654 STAT_COPYDISPATCHER
655
656 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
657 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
658 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
659 }
660
661 ////////DDD(debugPrintMethodPointers (env, (jclass)pr.jProviderClass));
662
|
663 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
664
665 STAT_GETSTARTTIME;
666
|
667 mark.hamzy 1.43 jmethodID id = NULL;
668 String interfaceType;
669 String interfaceVersion;
670
671 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
672 interfaceType,
673 interfaceVersion);
674
675 if (interfaceType == "JMPI")
676 {
677 // public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop,
678 // org.pegasus.jmpi.CIMClass cimClass,
679 // boolean localOnly)
680 // throws org.pegasus.jmpi.CIMException
681 id = env->GetMethodID((jclass)pr.jProviderClass,
682 "getInstance",
683 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;");
|
684 mark.hamzy 1.25
|
685 mark.hamzy 1.43 if (id != NULL)
686 {
687 eMethodFound = METHOD_INSTANCEPROVIDER;
688 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
689 }
690
691 if (id == NULL)
692 {
693 env->ExceptionClear();
|
694 mark.hamzy 1.25
|
695 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath op,
696 // boolean localOnly,
697 // boolean includeQualifiers,
698 // boolean includeClassOrigin,
699 // java.lang.String[] propertyList,
700 // org.pegasus.jmpi.CIMClass cc)
701 // throws org.pegasus.jmpi.CIMException
702 id = env->GetMethodID((jclass)pr.jProviderClass,
703 "getInstance",
704 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)Lorg/pegasus/jmpi/CIMInstance;");
705
706 if (id != NULL)
707 {
708 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
709 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
710 }
711 }
|
712 mark.hamzy 1.34 }
|
713 mark.hamzy 1.43 else if (interfaceType == "JMPIExperimental")
|
714 mark.hamzy 1.34 {
|
715 mark.hamzy 1.43 /* Fix for 4238 */
716 // public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.OperationContext oc
717 // org.pegasus.jmpi.CIMObjectPath cop,
718 // org.pegasus.jmpi.CIMClass cimClass,
719 // boolean includeQualifiers,
720 // boolean includeClassOrigin,
721 // String propertyList[])
722 // throws org.pegasus.jmpi.CIMException
723 id = env->GetMethodID((jclass)pr.jProviderClass,
724 "getInstance",
725 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;");
|
726 mark.hamzy 1.34
|
727 mark.hamzy 1.43 if (id != NULL)
728 {
729 eMethodFound = METHOD_INSTANCEPROVIDER2;
730 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
731 }
732 /* Fix for 4238 */
|
733 mark.hamzy 1.25 }
734
735 if (id == NULL)
736 {
|
737 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: No method found!"<<PEGASUS_STD(endl));
738
739 PEG_METHOD_EXIT();
|
740 mark.hamzy 1.25
|
741 mark.hamzy 1.43 STAT_COPYDISPATCHER
|
742 mark.hamzy 1.25
|
743 mark.hamzy 1.43 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
744 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
745 "Could not find a method for the provider based on InterfaceType."));
|
746 mark.hamzy 1.25 }
747
|
748 schuur 1.1 JMPIjvm::checkException(env);
|
749 mark.hamzy 1.23
|
750 mark.hamzy 1.25 switch (eMethodFound)
751 {
|
752 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER:
|
753 mark.hamzy 1.25 {
|
754 mark.hamzy 1.29 jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
755 jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);
|
756 mark.hamzy 1.25
757 JMPIjvm::checkException(env);
758
|
759 mark.hamzy 1.40 CIMClass cls;
760
761 try
762 {
763 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
764 AutoMutex lock (pr._cimomMutex);
765
766 cls = pr._cimom_handle->getClass(context,
767 request->nameSpace,
768 request->instanceName.getClassName(),
769 false,
770 true,
771 true,
772 CIMPropertyList());
773 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
774 }
775 catch (CIMException e)
776 {
777 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
778 throw;
779 }
780 mark.hamzy 1.40
|
781 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
782
783 JMPIjvm::checkException(env);
|
784 mark.hamzy 1.25
|
785 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
786 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
787 mark.hamzy 1.25
788 JMPIjvm::checkException(env);
|
789 mark.hamzy 1.23
|
790 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
791 schuur 1.1
|
792 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
793 id,
794 jop,
|
795 mark.hamzy 1.36 JMPI_LOCALONLY,
796 JMPI_INCLUDE_QUALIFIERS,
|
797 mark.hamzy 1.29 request->includeClassOrigin,
798 jPropertyList,
799 jcimClass);
|
800 mark.hamzy 1.23
|
801 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
802 mark.hamzy 1.23
|
803 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
|
804 schuur 1.1
|
805 mark.hamzy 1.25 handler.processing();
|
806 schuur 1.1
|
807 mark.hamzy 1.29 if (jciRet) {
808 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
809 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
810 schuur 1.13
|
811 mark.hamzy 1.29 handler.deliver(*ciRet);
|
812 mark.hamzy 1.25 }
813 handler.complete();
814 break;
|
815 mark.hamzy 1.23 }
|
816 schuur 1.13
|
817 mark.hamzy 1.34 /* Fix for 4238 */
|
818 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
|
819 mark.hamzy 1.34 {
|
820 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
821 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
822
|
823 mark.hamzy 1.34 jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
824 jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);
825
826 JMPIjvm::checkException(env);
827
|
828 mark.hamzy 1.40 CIMClass cls;
829
830 try
831 {
832 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
833 AutoMutex lock (pr._cimomMutex);
834
835 cls = pr._cimom_handle->getClass(context,
836 request->nameSpace,
837 request->instanceName.getClassName(),
838 false,
839 true,
840 true,
841 CIMPropertyList());
842 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
843 }
844 catch (CIMException e)
845 {
846 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
847 throw;
848 }
849 mark.hamzy 1.40
|
850 mark.hamzy 1.34 CIMClass *pcls = new CIMClass (cls);
851
852 JMPIjvm::checkException(env);
853
854 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
855 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
856
857 JMPIjvm::checkException(env);
858
859 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
860 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
861 id,
|
862 mark.hamzy 1.43 joc,
|
863 mark.hamzy 1.34 jop,
864 jcimClass,
865 JMPI_INCLUDE_QUALIFIERS,
866 request->includeClassOrigin,
867 jPropertyList);
868
869 JMPIjvm::checkException(env);
870
871 STAT_PMS_PROVIDEREND;
872
|
873 mark.hamzy 1.43 if (joc)
874 {
875 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
876
877 JMPIjvm::checkException(env);
878 }
879
|
880 mark.hamzy 1.34 handler.processing();
881
882 if (jciRet) {
883 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
884 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
885
886 handler.deliver(*ciRet);
887 }
888 handler.complete();
889 break;
890 }
891 /* Fix for 4238 */
892
|
893 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
894 mark.hamzy 1.25 {
|
895 mark.hamzy 1.29 jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
896 jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);
|
897 mark.hamzy 1.25
898 JMPIjvm::checkException(env);
899
|
900 mark.hamzy 1.40 CIMClass cls;
901
902 try
903 {
904 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
905 AutoMutex lock (pr._cimomMutex);
906
907 cls = pr._cimom_handle->getClass(context,
908 request->nameSpace,
909 request->instanceName.getClassName(),
910 false,
911 true,
912 true,
913 CIMPropertyList());
914 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
915 }
916 catch (CIMException e)
917 {
918 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
919 throw;
920 }
921 mark.hamzy 1.40
|
922 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
923 mark.hamzy 1.25
|
924 mark.hamzy 1.27 JMPIjvm::checkException(env);
925
|
926 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
927 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
928 mark.hamzy 1.25
929 JMPIjvm::checkException(env);
930
|
931 mark.hamzy 1.30 // Modified for Bugzilla# 3679
|
932 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
933 id,
934 jop,
935 jcimClass,
|
936 mark.hamzy 1.30 JMPI_LOCALONLY);
|
937 mark.hamzy 1.25
938 JMPIjvm::checkException(env);
939
940 STAT_PMS_PROVIDEREND;
|
941 schuur 1.1
|
942 mark.hamzy 1.25 handler.processing();
|
943 schuur 1.13
|
944 mark.hamzy 1.29 if (jciRet) {
945 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
946 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
947 schuur 1.13
|
948 mark.hamzy 1.29 handler.deliver(*ciRet);
|
949 mark.hamzy 1.25 }
950 handler.complete();
951 break;
952 }
|
953 mark.hamzy 1.23
|
954 mark.hamzy 1.25 case METHOD_UNKNOWN:
955 {
956 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
957 break;
958 }
|
959 schuur 1.1 }
|
960 schuur 1.13 }
|
961 schuur 1.1 HandlerCatch(handler);
|
962 schuur 1.13
|
963 schuur 1.1 if (env) JMPIjvm::detachThread();
|
964 schuur 1.13
|
965 schuur 1.1 PEG_METHOD_EXIT();
966
|
967 w.white 1.31 STAT_COPYDISPATCHER
968
|
969 schuur 1.1 return(response);
970 }
971
972 Message * JMPIProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()
973 {
|
974 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleEnumerateInstanceRequest");
975
976 HandlerIntro(EnumerateInstances,message,request,response,handler,Array<CIMInstance>());
|
977 schuur 1.1
|
978 mark.hamzy 1.25 typedef enum {
979 METHOD_UNKNOWN = 0,
|
980 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
981 METHOD_CIMINSTANCEPROVIDER2,
982 METHOD_INSTANCEPROVIDER,
983 METHOD_INSTANCEPROVIDER2,
|
984 mark.hamzy 1.25 } METHOD_VERSION;
985 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
986 JNIEnv *env = NULL;
|
987 schuur 1.13
988 try {
|
989 schuur 1.1 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
990 "JMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",
991 System::getHostName(),
992 request->nameSpace.getString(),
993 request->className.getString());
994
|
995 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
996
|
997 schuur 1.1 // make target object path
|
998 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
999 request->nameSpace,
1000 request->className);
|
1001 schuur 1.1
1002 // resolve provider name
|
1003 kumpf 1.2 ProviderName name = _resolveProviderName(
1004 request->operationContext.get(ProviderIdContainer::NAME));
|
1005 schuur 1.1
1006 // get cached or load new provider module
|
1007 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
1008 name.getLogicalName(),
1009 String::EMPTY);
|
1010 schuur 1.1
|
1011 schuur 1.12 // convert arguments
|
1012 schuur 1.1 OperationContext context;
1013
|
1014 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
1015 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1016 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1017 schuur 1.1
1018 // forward request
|
1019 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1020 schuur 1.1
|
1021 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.enumerateInstances: " + pr.getName());
|
1022 schuur 1.1
|
1023 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Calling provider enumerateInstances: "<<pr.getName()<<PEGASUS_STD(endl));
|
1024 schuur 1.12
|
1025 mark.hamzy 1.25 JvmVector *jv = 0;
1026
1027 env = JMPIjvm::attachThread(&jv);
1028
|
1029 mark.hamzy 1.37 if (!env)
1030 {
1031 PEG_METHOD_EXIT();
1032
1033 STAT_COPYDISPATCHER
1034
1035 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
1036 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
1037 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
1038 }
1039
|
1040 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
1041
1042 STAT_GETSTARTTIME;
1043
|
1044 mark.hamzy 1.43 jmethodID id = NULL;
1045 String interfaceType;
1046 String interfaceVersion;
1047
1048 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
1049 interfaceType,
1050 interfaceVersion);
1051
1052 if (interfaceType == "JMPI")
1053 {
1054 // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,
1055 // boolean deep,
1056 // org.pegasus.jmpi.CIMClass cimClass,
1057 // boolean localOnly)
1058 // throws org.pegasus.jmpi.CIMException
1059 id = env->GetMethodID((jclass)pr.jProviderClass,
1060 "enumInstances",
1061 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;");
|
1062 mark.hamzy 1.25
|
1063 mark.hamzy 1.43 if (id != NULL)
1064 {
1065 eMethodFound = METHOD_INSTANCEPROVIDER;
1066 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
1067 }
1068
1069 if (id == NULL)
1070 {
1071 env->ExceptionClear();
|
1072 mark.hamzy 1.25
|
1073 mark.hamzy 1.49 // public org.pegasus.jmpi.CIMInstance[] enumerateInstances (org.pegasus.jmpi.CIMObjectPath cop,
1074 // boolean localOnly,
1075 // boolean includeQualifiers,
1076 // boolean includeClassOrigin,
1077 // java.lang.String[] propertyList,
1078 // org.pegasus.jmpi.CIMClass cimClass)
|
1079 mark.hamzy 1.43 // throws org.pegasus.jmpi.CIMException
1080 id = env->GetMethodID((jclass)pr.jProviderClass,
|
1081 mark.hamzy 1.49 "enumerateInstances",
|
1082 mark.hamzy 1.43 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");
1083
1084 if (id != NULL)
1085 {
1086 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
1087 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
1088 }
1089 }
1090 }
1091 else if (interfaceType == "JMPIExperimental")
|
1092 mark.hamzy 1.25 {
|
1093 mark.hamzy 1.43 /* Fix for 4189 */
1094 // public abstract java.util.Vector enumerateInstances (org.pegasus.jmpi.OperationContext oc
1095 // org.pegasus.jmpi.CIMObjectPath cop,
1096 // org.pegasus.jmpi.CIMClass cimClass,
1097 // boolean includeQualifiers,
1098 // boolean includeClassOrigin,
1099 // java.lang.String[] propertyList)
1100 // throws org.pegasus.jmpi.CIMException
1101 id = env->GetMethodID((jclass)pr.jProviderClass,
1102 "enumerateInstances",
1103 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
1104 mark.hamzy 1.33
|
1105 mark.hamzy 1.43 if (id != NULL)
1106 {
1107 eMethodFound = METHOD_INSTANCEPROVIDER2;
1108 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
1109 }
1110 /* Fix for 4189 */
|
1111 mark.hamzy 1.33
|
1112 mark.hamzy 1.43 if (id == NULL)
1113 {
1114 env->ExceptionClear();
|
1115 mark.hamzy 1.33
|
1116 mark.hamzy 1.43 // public abstract org.pegasus.jmpi.CIMInstance[] enumerateInstances (org.pegasus.jmpi.OperationContext oc
1117 // org.pegasus.jmpi.CIMObjectPath cop,
1118 // org.pegasus.jmpi.CIMClass cimClass,
1119 // boolean includeQualifiers,
1120 // boolean includeClassOrigin,
1121 // java.lang.String[] propertyList)
1122 // throws org.pegasus.jmpi.CIMException
1123 id = env->GetMethodID((jclass)pr.jProviderClass,
|
1124 mark.hamzy 1.49 "enumerateInstances",
|
1125 mark.hamzy 1.43 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
1126
1127 if (id != NULL)
1128 {
1129 eMethodFound = METHOD_CIMINSTANCEPROVIDER2;
1130 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl));
1131 }
1132 }
|
1133 mark.hamzy 1.25 }
1134
1135 if (id == NULL)
1136 {
|
1137 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: No method found!"<<PEGASUS_STD(endl));
1138
1139 PEG_METHOD_EXIT();
|
1140 schuur 1.1
|
1141 mark.hamzy 1.43 STAT_COPYDISPATCHER
|
1142 mark.hamzy 1.23
|
1143 mark.hamzy 1.43 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
1144 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
1145 "Could not find a method for the provider based on InterfaceType."));
|
1146 mark.hamzy 1.25 }
|
1147 schuur 1.12
1148 JMPIjvm::checkException(env);
|
1149 mark.hamzy 1.23
|
1150 mark.hamzy 1.25 switch (eMethodFound)
1151 {
|
1152 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER:
|
1153 mark.hamzy 1.25 {
|
1154 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1155 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1156 mark.hamzy 1.23
|
1157 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
1158 schuur 1.1
|
1159 mark.hamzy 1.40 CIMClass cls;
1160
1161 try
1162 {
1163 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1164 AutoMutex lock (pr._cimomMutex);
1165
1166 cls = pr._cimom_handle->getClass(context,
1167 request->nameSpace,
1168 request->className,
1169 false,
1170 true,
1171 true,
1172 CIMPropertyList());
1173 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1174 }
1175 catch (CIMException e)
1176 {
1177 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1178 throw;
1179 }
1180 mark.hamzy 1.40
|
1181 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
1182
|
1183 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
1184 schuur 1.1
|
1185 mark.hamzy 1.29 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1186 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
|
1187 schuur 1.13
|
1188 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1189 schuur 1.1
|
1190 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
1191 mark.hamzy 1.36 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1192 id,
1193 jcop,
1194 JMPI_LOCALONLY,
1195 JMPI_INCLUDE_QUALIFIERS,
1196 request->includeClassOrigin,
1197 jPropertyList,
1198 jcc);
|
1199 mark.hamzy 1.25
|
1200 mark.hamzy 1.23 JMPIjvm::checkException(env);
1201
1202 STAT_PMS_PROVIDEREND;
1203
1204 handler.processing();
|
1205 mark.hamzy 1.25 if (jAr) {
1206 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
1207 mark.hamzy 1.23 JMPIjvm::checkException(env);
1208
|
1209 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jAr,i);
1210
|
1211 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1212 schuur 1.13
|
1213 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
1214 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
1215 schuur 1.13
|
1216 mark.hamzy 1.36 /* Fix for 4237 */
|
1217 mark.hamzy 1.40 CIMClass cls;
1218
1219 try
1220 {
1221 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1222 AutoMutex lock (pr._cimomMutex);
1223
1224 cls = pr._cimom_handle->getClass(context,
1225 request->nameSpace,
1226 ciRet->getClassName(),
1227 false,
1228 true,
1229 true,
1230 CIMPropertyList());
1231 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1232 }
1233 catch (CIMException e)
1234 {
1235 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1236 throw;
1237 }
1238 mark.hamzy 1.40
|
1239 mark.hamzy 1.36 const CIMObjectPath& op = ciRet->getPath();
1240 CIMObjectPath iop = ciRet->buildPath(cls);
1241
|
1242 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1243 schuur 1.13
|
1244 mark.hamzy 1.29 handler.deliver(*ciRet);
|
1245 mark.hamzy 1.23 }
1246 }
1247 handler.complete();
|
1248 mark.hamzy 1.25 break;
|
1249 schuur 1.13 }
|
1250 mark.hamzy 1.25
|
1251 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER2:
1252 {
1253 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
1254 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
1255
1256 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1257 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
1258
1259 JMPIjvm::checkException(env);
1260
1261 CIMClass cls;
1262
1263 try
1264 {
1265 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1266 AutoMutex lock (pr._cimomMutex);
1267
1268 cls = pr._cimom_handle->getClass(context,
1269 request->nameSpace,
1270 request->className,
1271 false,
1272 mark.hamzy 1.43 true,
1273 true,
1274 CIMPropertyList());
1275 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1276 }
1277 catch (CIMException e)
1278 {
1279 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1280 throw;
1281 }
1282
1283 CIMClass *pcls = new CIMClass (cls);
1284
1285 JMPIjvm::checkException(env);
1286
1287 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1288 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
1289
1290 JMPIjvm::checkException(env);
1291
1292 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
1293 mark.hamzy 1.43 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1294 id,
1295 joc,
1296 jcop,
1297 jcc,
1298 JMPI_INCLUDE_QUALIFIERS,
1299 request->includeClassOrigin,
1300 jPropertyList);
1301
1302 JMPIjvm::checkException(env);
1303
1304 STAT_PMS_PROVIDEREND;
1305
1306 if (joc)
1307 {
1308 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
1309
1310 JMPIjvm::checkException(env);
1311 }
1312
1313 handler.processing();
1314 mark.hamzy 1.43 if (jAr) {
1315 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1316 JMPIjvm::checkException(env);
1317
1318 jobject jciRet = env->GetObjectArrayElement(jAr,i);
1319
1320 JMPIjvm::checkException(env);
1321
1322 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
1323 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
1324
1325 /* Fix for 4237 */
1326 CIMClass cls;
1327
1328 try
1329 {
1330 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1331 AutoMutex lock (pr._cimomMutex);
1332
1333 cls = pr._cimom_handle->getClass(context,
1334 request->nameSpace,
1335 mark.hamzy 1.43 ciRet->getClassName(),
1336 false,
1337 true,
1338 true,
1339 CIMPropertyList());
1340 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1341 }
1342 catch (CIMException e)
1343 {
1344 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1345 throw;
1346 }
1347
1348 const CIMObjectPath& op = ciRet->getPath();
1349 CIMObjectPath iop = ciRet->buildPath(cls);
1350
1351 JMPIjvm::checkException(env);
1352
1353 handler.deliver(*ciRet);
1354 }
1355 }
1356 mark.hamzy 1.43 handler.complete();
1357 break;
1358 }
1359
|
1360 mark.hamzy 1.33 /* Fix for 4189 */
|
1361 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
|
1362 mark.hamzy 1.33 {
|
1363 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
1364 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
1365
|
1366 mark.hamzy 1.33 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1367 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
1368
1369 JMPIjvm::checkException(env);
1370
|
1371 mark.hamzy 1.40 CIMClass cls;
1372
1373 try
1374 {
1375 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1376 AutoMutex lock (pr._cimomMutex);
1377
1378 cls = pr._cimom_handle->getClass (context,
1379 request->nameSpace,
1380 request->className,
1381 false,
1382 true,
1383 true,
1384 CIMPropertyList());
1385 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1386 }
1387 catch (CIMException e)
1388 {
1389 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1390 throw;
1391 }
1392 mark.hamzy 1.40
|
1393 mark.hamzy 1.33 CIMClass *pcls = new CIMClass (cls);
1394
1395 JMPIjvm::checkException(env);
1396
1397 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1398 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
1399
1400 JMPIjvm::checkException(env);
1401
1402 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
1403 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1404 id,
|
1405 mark.hamzy 1.43 joc,
|
1406 mark.hamzy 1.33 jcop,
|
1407 mark.hamzy 1.35 jcc,
|
1408 mark.hamzy 1.33 JMPI_INCLUDE_QUALIFIERS,
1409 request->includeClassOrigin,
1410 jPropertyList);
1411
1412 JMPIjvm::checkException(env);
1413
1414 STAT_PMS_PROVIDEREND;
1415
|
1416 mark.hamzy 1.43 if (joc)
1417 {
1418 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
1419
1420 JMPIjvm::checkException(env);
1421 }
1422
|
1423 mark.hamzy 1.33 handler.processing();
1424 if (jVec) {
1425 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1426 JMPIjvm::checkException(env);
1427
1428 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1429
1430 JMPIjvm::checkException(env);
1431
1432 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
1433 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
1434
1435 /* Fix for 4237 */
|
1436 mark.hamzy 1.40 CIMClass cls;
1437
1438 try
1439 {
1440 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1441 AutoMutex lock (pr._cimomMutex);
1442
1443 cls = pr._cimom_handle->getClass(context,
1444 request->nameSpace,
1445 ciRet->getClassName(),
1446 false,
1447 true,
1448 true,
1449 CIMPropertyList());
1450 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1451 }
1452 catch (CIMException e)
1453 {
1454 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1455 throw;
1456 }
1457 mark.hamzy 1.40
|
1458 mark.hamzy 1.33 const CIMObjectPath& op = ciRet->getPath();
1459 CIMObjectPath iop = ciRet->buildPath(cls);
1460
1461 JMPIjvm::checkException(env);
1462
1463 iop.setNameSpace(op.getNameSpace());
1464
1465 ciRet->setPath(iop);
1466 /* Fix for 4237*/
1467
1468 handler.deliver(*ciRet);
1469 }
1470 }
1471 handler.complete();
1472 break;
1473 }
1474 /* Fix for 4189 */
1475
|
1476 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
1477 mark.hamzy 1.25 {
|
1478 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1479 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1480 mark.hamzy 1.25
1481 JMPIjvm::checkException(env);
1482
|
1483 mark.hamzy 1.40 CIMClass cls;
1484
1485 try
1486 {
1487 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1488 AutoMutex lock (pr._cimomMutex);
1489
1490 cls = pr._cimom_handle->getClass(context,
1491 request->nameSpace,
1492 request->className,
1493 false,
1494 true,
1495 true,
1496 CIMPropertyList());
1497 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1498 }
1499 catch (CIMException e)
1500 {
1501 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1502 throw;
1503 }
1504 mark.hamzy 1.40
|
1505 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
1506
|
1507 mark.hamzy 1.25 JMPIjvm::checkException(env);
1508
|
1509 mark.hamzy 1.29 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1510 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
|
1511 mark.hamzy 1.25
1512 JMPIjvm::checkException(env);
1513
|
1514 mark.hamzy 1.30 // Modified for Bugzilla# 3679
|
1515 mark.hamzy 1.25 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1516 id,
|
1517 mark.hamzy 1.29 jcop,
|
1518 mark.hamzy 1.33 request->deepInheritance,
|
1519 mark.hamzy 1.29 jcc,
|
1520 mark.hamzy 1.30 JMPI_LOCALONLY);
|
1521 mark.hamzy 1.25
|
1522 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1523 schuur 1.12
|
1524 mark.hamzy 1.23 STAT_PMS_PROVIDEREND;
1525
1526 handler.processing();
|
1527 mark.hamzy 1.25 if (jVec) {
1528 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
1529 mark.hamzy 1.23 JMPIjvm::checkException(env);
1530
|
1531 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1532
|
1533 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1534 schuur 1.12
|
1535 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
1536 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
1537 schuur 1.12
|
1538 mark.hamzy 1.33 /* Fix for 4237 */
|
1539 mark.hamzy 1.40 CIMClass cls;
1540
1541 try
1542 {
1543 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1544 AutoMutex lock (pr._cimomMutex);
1545
1546 cls = pr._cimom_handle->getClass(context,
1547 request->nameSpace,
1548 ciRet->getClassName(),
1549 false,
1550 true,
1551 true,
1552 CIMPropertyList());
1553 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1554 }
1555 catch (CIMException e)
1556 {
1557 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1558 throw;
1559 }
1560 mark.hamzy 1.40
|
1561 mark.hamzy 1.33 const CIMObjectPath& op = ciRet->getPath();
1562 CIMObjectPath iop = ciRet->buildPath(cls);
1563
1564 JMPIjvm::checkException(env);
1565
1566 iop.setNameSpace(op.getNameSpace());
1567
1568 ciRet->setPath(iop);
1569 /* Fix for 4237*/
1570
|
1571 mark.hamzy 1.29 handler.deliver(*ciRet);
|
1572 mark.hamzy 1.23 }
1573 }
1574 handler.complete();
|
1575 mark.hamzy 1.25 break;
1576 }
1577
1578 case METHOD_UNKNOWN:
1579 {
1580 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: should not be here!"<<PEGASUS_STD(endl));
1581 break;
1582 }
|
1583 schuur 1.1 }
1584 }
1585 HandlerCatch(handler);
|
1586 schuur 1.12
|
1587 schuur 1.11 if (env) JMPIjvm::detachThread();
|
1588 schuur 1.12
|
1589 schuur 1.1 PEG_METHOD_EXIT();
1590
|
1591 w.white 1.31 STAT_COPYDISPATCHER
1592
|
1593 schuur 1.1 return(response);
1594 }
1595
1596 Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()
1597 {
1598 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest");
1599
|
1600 mark.hamzy 1.23 HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>());
1601
|
1602 mark.hamzy 1.25 typedef enum {
1603 METHOD_UNKNOWN = 0,
|
1604 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
1605 METHOD_CIMINSTANCEPROVIDER2,
1606 METHOD_INSTANCEPROVIDER,
1607 METHOD_INSTANCEPROVIDER2,
|
1608 mark.hamzy 1.25 } METHOD_VERSION;
1609 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1610 JNIEnv *env = NULL;
|
1611 schuur 1.13
|
1612 schuur 1.1 try {
1613 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1614 "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1615 System::getHostName(),
1616 request->nameSpace.getString(),
1617 request->className.getString());
|
1618 mark.hamzy 1.23
1619 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
1620
|
1621 mark.hamzy 1.25 // make target object path
|
1622 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1623 request->nameSpace,
1624 request->className);
|
1625 schuur 1.1
1626 // resolve provider name
|
1627 kumpf 1.2 ProviderName name = _resolveProviderName(
1628 request->operationContext.get(ProviderIdContainer::NAME));
|
1629 schuur 1.1
1630 // get cached or load new provider module
|
1631 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
1632 name.getLogicalName());
|
1633 schuur 1.1
1634 // convert arguments
1635 OperationContext context;
1636
|
1637 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1638 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1639 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1640 schuur 1.1
|
1641 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1642 schuur 1.1
|
1643 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.enumerateInstanceNames: " + pr.getName());
|
1644 schuur 1.1
|
1645 mark.hamzy 1.37 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Calling provider : enumerateInstanceNames: "<<pr.getName()<<PEGASUS_STD(endl));
|
1646 schuur 1.1
|
1647 mark.hamzy 1.25 JvmVector *jv = 0;
|
1648 schuur 1.12
|
1649 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
1650 schuur 1.1
|
1651 mark.hamzy 1.37 if (!env)
1652 {
1653 PEG_METHOD_EXIT();
1654
1655 STAT_COPYDISPATCHER
1656
1657 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
1658 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
1659 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
1660 }
1661
|
1662 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
1663 schuur 1.12
|
1664 mark.hamzy 1.25 STAT_GETSTARTTIME;
|
1665 mark.hamzy 1.23
|
1666 mark.hamzy 1.43 jmethodID id = NULL;
1667 String interfaceType;
1668 String interfaceVersion;
1669
1670 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
1671 interfaceType,
1672 interfaceVersion);
1673
1674 if (interfaceType == "JMPI")
1675 {
1676 // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,
1677 // boolean deep,
1678 // org.pegasus.jmpi.CIMClass cimClass)
1679 // throws org.pegasus.jmpi.CIMException
1680 id = env->GetMethodID((jclass)pr.jProviderClass,
1681 "enumInstances",
1682 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
1683
1684 if (id != NULL)
1685 {
1686 eMethodFound = METHOD_INSTANCEPROVIDER;
1687 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
1688 }
|
1689 mark.hamzy 1.23
|
1690 mark.hamzy 1.43 if (id == NULL)
1691 {
1692 env->ExceptionClear();
|
1693 schuur 1.1
|
1694 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.CIMObjectPath op,
1695 // org.pegasus.jmpi.CIMClass cc)
1696 // throws org.pegasus.jmpi.CIMException
1697 id = env->GetMethodID((jclass)pr.jProviderClass,
1698 "enumerateInstanceNames",
1699 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;");
1700
1701 if (id != NULL)
1702 {
1703 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
1704 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
1705 }
1706 }
1707 }
1708 else if (interfaceType == "JMPIExperimental")
|
1709 mark.hamzy 1.25 {
|
1710 mark.hamzy 1.43 // public abstract java.util.Vector enumerateInstanceNames (org.pegasus.jmpi.OperationContext oc
1711 // org.pegasus.jmpi.CIMObjectPath cop,
1712 // org.pegasus.jmpi.CIMClass cimClass)
1713 // throws org.pegasus.jmpi.CIMException
1714 id = env->GetMethodID((jclass)pr.jProviderClass,
1715 "enumerateInstanceNames",
1716 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
|
1717 schuur 1.1
|
1718 mark.hamzy 1.43 if (id != NULL)
1719 {
1720 eMethodFound = METHOD_INSTANCEPROVIDER2;
1721 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
1722 }
|
1723 schuur 1.1
|
1724 mark.hamzy 1.43 if (id == NULL)
1725 {
1726 env->ExceptionClear();
|
1727 schuur 1.13
|
1728 mark.hamzy 1.43 // public abstract org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.OperationContext oc
1729 // org.pegasus.jmpi.CIMObjectPath cop,
1730 // org.pegasus.jmpi.CIMClass cimClass)
1731 // throws org.pegasus.jmpi.CIMException
1732 id = env->GetMethodID((jclass)pr.jProviderClass,
1733 "enumerateInstanceNames",
1734 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;");
1735
1736 if (id != NULL)
1737 {
1738 eMethodFound = METHOD_CIMINSTANCEPROVIDER2;
1739 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl));
1740 }
1741 }
|
1742 mark.hamzy 1.23 }
|
1743 mark.hamzy 1.25
|
1744 mark.hamzy 1.36 if (id == NULL)
1745 {
|
1746 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: No method found!"<<PEGASUS_STD(endl));
|
1747 mark.hamzy 1.36
|
1748 mark.hamzy 1.43 PEG_METHOD_EXIT();
|
1749 mark.hamzy 1.36
|
1750 mark.hamzy 1.43 STAT_COPYDISPATCHER
|
1751 mark.hamzy 1.36
|
1752 mark.hamzy 1.43 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
1753 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
1754 "Could not find a method for the provider based on InterfaceType."));
|
1755 mark.hamzy 1.36 }
1756
|
1757 schuur 1.1 JMPIjvm::checkException(env);
1758
|
1759 mark.hamzy 1.25 switch (eMethodFound)
1760 {
|
1761 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER:
|
1762 mark.hamzy 1.25 {
|
1763 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1764 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1765 mark.hamzy 1.25
1766 JMPIjvm::checkException(env);
1767
|
1768 mark.hamzy 1.40 CIMClass cls;
1769
1770 try
1771 {
1772 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1773 AutoMutex lock (pr._cimomMutex);
1774
1775 cls = pr._cimom_handle->getClass(context,
1776 request->nameSpace,
1777 request->className,
1778 false,
1779 true,
1780 true,
1781 CIMPropertyList());
1782 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1783 }
1784 catch (CIMException e)
1785 {
1786 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1787 throw;
1788 }
1789 mark.hamzy 1.40
|
1790 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
1791 mark.hamzy 1.25
1792 JMPIjvm::checkException(env);
1793
|
1794 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1795 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
1796 mark.hamzy 1.25
1797 JMPIjvm::checkException(env);
1798
1799 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1800 id,
|
1801 mark.hamzy 1.29 jcop,
1802 jcimClass);
|
1803 mark.hamzy 1.25
|
1804 mark.hamzy 1.23 JMPIjvm::checkException(env);
1805
1806 STAT_PMS_PROVIDEREND;
1807
1808 handler.processing();
|
1809 mark.hamzy 1.25 if (jAr) {
1810 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
1811 mark.hamzy 1.23 JMPIjvm::checkException(env);
1812
|
1813 mark.hamzy 1.29 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
1814
|
1815 mark.hamzy 1.23 JMPIjvm::checkException(env);
1816
|
1817 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1818 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
1819 schuur 1.13
|
1820 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1821 schuur 1.13
|
1822 mark.hamzy 1.29 handler.deliver(*copRet);
|
1823 mark.hamzy 1.23 }
1824 }
1825 handler.complete();
|
1826 mark.hamzy 1.25 break;
|
1827 schuur 1.13 }
|
1828 mark.hamzy 1.25
|
1829 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER2:
|
1830 mark.hamzy 1.36 {
|
1831 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
1832 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
1833
|
1834 mark.hamzy 1.36 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1835 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
1836
1837 JMPIjvm::checkException(env);
1838
|
1839 mark.hamzy 1.40 CIMClass cls;
1840
1841 try
1842 {
1843 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1844 AutoMutex lock (pr._cimomMutex);
1845
1846 cls = pr._cimom_handle->getClass(context,
1847 request->nameSpace,
1848 request->className,
1849 false,
1850 true,
1851 true,
1852 CIMPropertyList());
1853 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1854 }
1855 catch (CIMException e)
1856 {
1857 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1858 throw;
1859 }
1860 mark.hamzy 1.40
|
1861 mark.hamzy 1.36 CIMClass *pcls = new CIMClass (cls);
1862
1863 JMPIjvm::checkException(env);
1864
1865 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1866 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
1867
1868 JMPIjvm::checkException(env);
1869
|
1870 mark.hamzy 1.43 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1871 id,
1872 joc,
1873 jcop,
1874 jcimClass);
|
1875 mark.hamzy 1.36
1876 JMPIjvm::checkException(env);
1877
1878 STAT_PMS_PROVIDEREND;
1879
|
1880 mark.hamzy 1.43 if (joc)
1881 {
1882 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
1883
1884 JMPIjvm::checkException(env);
1885 }
1886
|
1887 mark.hamzy 1.36 handler.processing();
|
1888 mark.hamzy 1.43 if (jAr) {
1889 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
1890 mark.hamzy 1.36 JMPIjvm::checkException(env);
1891
|
1892 mark.hamzy 1.43 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
1893 mark.hamzy 1.36
1894 JMPIjvm::checkException(env);
1895
1896 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1897 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
1898
1899 JMPIjvm::checkException(env);
1900
1901 handler.deliver(*copRet);
1902 }
1903 }
1904 handler.complete();
1905 break;
1906 }
1907
|
1908 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
|
1909 mark.hamzy 1.25 {
|
1910 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
1911 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
1912
|
1913 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1914 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1915 mark.hamzy 1.25
1916 JMPIjvm::checkException(env);
1917
|
1918 mark.hamzy 1.40 CIMClass cls;
1919
1920 try
1921 {
1922 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1923 AutoMutex lock (pr._cimomMutex);
1924
1925 cls = pr._cimom_handle->getClass(context,
1926 request->nameSpace,
1927 request->className,
1928 false,
1929 true,
1930 true,
1931 CIMPropertyList());
1932 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1933 }
1934 catch (CIMException e)
1935 {
1936 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1937 throw;
1938 }
1939 mark.hamzy 1.40
|
1940 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
1941 mark.hamzy 1.25
1942 JMPIjvm::checkException(env);
1943
|
1944 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1945 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
1946 mark.hamzy 1.25
1947 JMPIjvm::checkException(env);
1948
1949 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1950 id,
|
1951 mark.hamzy 1.43 joc,
|
1952 mark.hamzy 1.29 jcop,
1953 jcimClass);
|
1954 mark.hamzy 1.25
|
1955 mark.hamzy 1.23 JMPIjvm::checkException(env);
1956
1957 STAT_PMS_PROVIDEREND;
1958
|
1959 mark.hamzy 1.43 if (joc)
1960 {
1961 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
1962
1963 JMPIjvm::checkException(env);
1964 }
1965
|
1966 mark.hamzy 1.23 handler.processing();
|
1967 mark.hamzy 1.25 if (jVec) {
1968 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
1969 mark.hamzy 1.23 JMPIjvm::checkException(env);
1970
|
1971 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1972
|
1973 mark.hamzy 1.23 JMPIjvm::checkException(env);
1974
|
1975 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1976 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
1977 schuur 1.13
|
1978 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1979 schuur 1.13
|
1980 mark.hamzy 1.29 handler.deliver(*copRet);
|
1981 mark.hamzy 1.23 }
1982 }
1983 handler.complete();
|
1984 mark.hamzy 1.25 break;
1985 }
1986
|
1987 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
1988 mark.hamzy 1.25 {
|
1989 mark.hamzy 1.43 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1990 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1991 mark.hamzy 1.23
|
1992 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
1993 schuur 1.1
|
1994 mark.hamzy 1.43 CIMClass cls;
|
1995 schuur 1.1
|
1996 mark.hamzy 1.43 try
1997 {
1998 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1999 AutoMutex lock (pr._cimomMutex);
2000
2001 cls = pr._cimom_handle->getClass(context,
2002 request->nameSpace,
2003 request->className,
2004 false,
2005 true,
2006 true,
2007 CIMPropertyList());
2008 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2009 }
2010 catch (CIMException e)
2011 {
2012 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
2013 throw;
2014 }
2015
2016 CIMClass *pcls = new CIMClass (cls);
2017 mark.hamzy 1.43
2018 JMPIjvm::checkException(env);
2019
2020 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
2021 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
2022
2023 JMPIjvm::checkException(env);
2024
2025 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
2026 id,
2027 jcop,
2028 true,
2029 jcimClass);
2030
2031 JMPIjvm::checkException(env);
2032
2033 STAT_PMS_PROVIDEREND;
2034
2035 handler.processing();
2036 if (jVec) {
2037 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
2038 mark.hamzy 1.43 JMPIjvm::checkException(env);
2039
2040 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
2041
2042 JMPIjvm::checkException(env);
2043
2044 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
2045 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
2046
2047 JMPIjvm::checkException(env);
2048
2049 handler.deliver(*copRet);
2050 }
2051 }
2052 handler.complete();
2053 break;
2054 }
2055
2056 case METHOD_UNKNOWN:
2057 {
2058 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: should not be here!"<<PEGASUS_STD(endl));
2059 mark.hamzy 1.43 break;
2060 }
2061 }
2062 }
2063 HandlerCatch(handler);
2064
2065 if (env) JMPIjvm::detachThread();
2066
2067 PEG_METHOD_EXIT();
2068
2069 STAT_COPYDISPATCHER
|
2070 w.white 1.31
|
2071 schuur 1.1 return(response);
2072 }
2073
2074 Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()
2075 {
|
2076 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest");
2077
2078 HandlerIntro(CreateInstance,message,request,response,handler,CIMObjectPath());
|
2079 schuur 1.1
|
2080 mark.hamzy 1.25 typedef enum {
2081 METHOD_UNKNOWN = 0,
|
2082 mark.hamzy 1.43 METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER
2083 METHOD_INSTANCEPROVIDER2 // same as METHOD_CIMINSTANCEPROVIDER2
|
2084 mark.hamzy 1.25 } METHOD_VERSION;
2085 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2086 JNIEnv *env = NULL;
2087
|
2088 schuur 1.1 try {
2089 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2090 "JMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
2091 System::getHostName(),
2092 request->nameSpace.getString(),
2093 request->newInstance.getPath().getClassName().getString());
2094
|
2095 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->newInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl));
2096
|
2097 schuur 1.1 // make target object path
|
2098 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2099 request->nameSpace,
2100 request->newInstance.getPath().getClassName(),
2101 request->newInstance.getPath().getKeyBindings());
|
2102 schuur 1.1
2103 // resolve provider name
|
2104 kumpf 1.2 ProviderName name = _resolveProviderName(
2105 request->operationContext.get(ProviderIdContainer::NAME));
|
2106 schuur 1.1
2107 // get cached or load new provider module
|
2108 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
2109 name.getLogicalName(),
2110 String::EMPTY);
|
2111 schuur 1.1
2112 // forward request
|
2113 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
2114 schuur 1.1
|
2115 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createInstance: " + ph.GetProvider().getName());
|
2116 schuur 1.1
|
2117 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
2118 schuur 1.12
|
2119 mark.hamzy 1.25 JvmVector *jv = 0;
2120
2121 env = JMPIjvm::attachThread(&jv);
2122
|
2123 mark.hamzy 1.37 if (!env)
2124 {
2125 PEG_METHOD_EXIT();
2126
2127 STAT_COPYDISPATCHER
2128
2129 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2130 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
2131 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
2132 }
2133
|
2134 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
2135
2136 STAT_GETSTARTTIME;
2137
|
2138 mark.hamzy 1.43 jmethodID id = NULL;
2139 String interfaceType;
2140 String interfaceVersion;
2141
2142 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
2143 interfaceType,
2144 interfaceVersion);
2145
2146 if (interfaceType == "JMPI")
2147 {
2148 // public org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop,
2149 // org.pegasus.jmpi.CIMInstance cimInstance)
2150 // throws org.pegasus.jmpi.CIMException
2151 id = env->GetMethodID((jclass)pr.jProviderClass,
2152 "createInstance",
2153 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");
2154
2155 if (id != NULL)
2156 {
2157 eMethodFound = METHOD_INSTANCEPROVIDER;
2158 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
2159 mark.hamzy 1.43 }
2160 }
2161 else if (interfaceType == "JMPIExperimental")
2162 {
2163 // public org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.OperationContext oc
2164 // org.pegasus.jmpi.CIMObjectPath cop,
2165 // org.pegasus.jmpi.CIMInstance cimInstance)
2166 // throws org.pegasus.jmpi.CIMException
2167 id = env->GetMethodID((jclass)pr.jProviderClass,
2168 "createInstance",
2169 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");
|
2170 mark.hamzy 1.25
|
2171 mark.hamzy 1.43 if (id != NULL)
2172 {
2173 eMethodFound = METHOD_INSTANCEPROVIDER2;
2174 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
2175 }
2176 }
|
2177 schuur 1.1
|
2178 mark.hamzy 1.43 if (id == NULL)
|
2179 mark.hamzy 1.25 {
|
2180 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: No method found!"<<PEGASUS_STD(endl));
2181
2182 PEG_METHOD_EXIT();
2183
2184 STAT_COPYDISPATCHER
2185
2186 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2187 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
2188 "Could not find a method for the provider based on InterfaceType."));
|
2189 mark.hamzy 1.25 }
|
2190 mark.hamzy 1.23
2191 JMPIjvm::checkException(env);
2192
|
2193 mark.hamzy 1.25 switch (eMethodFound)
2194 {
|
2195 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
2196 {
2197 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2198 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
2199
2200 JMPIjvm::checkException(env);
2201
2202 CIMInstance *ci = new CIMInstance (request->newInstance);
2203 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
2204 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
2205
2206 JMPIjvm::checkException(env);
2207
2208 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl));
2209
2210 jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,
2211 id,
2212 jcop,
2213 jci);
2214
2215 JMPIjvm::checkException(env);
2216 mark.hamzy 1.43
2217 STAT_PMS_PROVIDEREND;
2218
2219 handler.processing();
2220
2221 if (jcopRet) {
2222 jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
2223 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef);
2224
2225 handler.deliver(*copRet);
2226 }
2227 handler.complete();
2228 break;
2229 }
2230
2231 case METHOD_INSTANCEPROVIDER2:
|
2232 mark.hamzy 1.25 {
|
2233 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
2234 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
2235
|
2236 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2237 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
2238 mark.hamzy 1.25
2239 JMPIjvm::checkException(env);
2240
|
2241 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->newInstance);
2242 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
2243 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
|
2244 mark.hamzy 1.25
2245 JMPIjvm::checkException(env);
|
2246 schuur 1.1
|
2247 mark.hamzy 1.29 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl));
|
2248 schuur 1.1
|
2249 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,
2250 id,
|
2251 mark.hamzy 1.43 joc,
|
2252 mark.hamzy 1.29 jcop,
2253 jci);
|
2254 schuur 1.1
|
2255 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
2256 schuur 1.1
|
2257 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
|
2258 mark.hamzy 1.23
|
2259 mark.hamzy 1.43 if (joc)
2260 {
2261 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
2262
2263 JMPIjvm::checkException(env);
2264 }
2265
|
2266 mark.hamzy 1.25 handler.processing();
|
2267 mark.hamzy 1.23
|
2268 mark.hamzy 1.29 if (jcopRet) {
2269 jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
2270 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef);
|
2271 mark.hamzy 1.23
|
2272 mark.hamzy 1.29 handler.deliver(*copRet);
|
2273 mark.hamzy 1.25 }
2274 handler.complete();
2275 break;
2276 }
|
2277 mark.hamzy 1.23
|
2278 mark.hamzy 1.25 case METHOD_UNKNOWN:
2279 {
2280 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
2281 break;
2282 }
|
2283 schuur 1.1 }
2284 }
2285 HandlerCatch(handler);
|
2286 mark.hamzy 1.23
|
2287 schuur 1.1 if (env) JMPIjvm::detachThread();
|
2288 mark.hamzy 1.23
|
2289 schuur 1.1 PEG_METHOD_EXIT();
2290
|
2291 w.white 1.31 STAT_COPYDISPATCHER
2292
|
2293 schuur 1.1 return(response);
2294 }
2295
2296 Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()
2297 {
|
2298 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest");
|
2299 schuur 1.1
2300 HandlerIntroVoid(ModifyInstance,message,request,response,handler);
|
2301 mark.hamzy 1.23
|
2302 mark.hamzy 1.25 typedef enum {
2303 METHOD_UNKNOWN = 0,
|
2304 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
2305 METHOD_INSTANCEPROVIDER,
2306 METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2
|
2307 mark.hamzy 1.25 } METHOD_VERSION;
2308 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2309 JNIEnv *env = NULL;
|
2310 schuur 1.13
|
2311 schuur 1.1 try {
2312 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
2313 konrad.r 1.15 "JMPIProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
2314 schuur 1.1 System::getHostName(),
2315 request->nameSpace.getString(),
2316 request->modifiedInstance.getPath().getClassName().getString());
2317
|
2318 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->modifiedInstance.getPath().getClassName().getString()<<PEGASUS_STD(endl));
2319
|
2320 schuur 1.1 // make target object path
|
2321 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2322 request->nameSpace,
2323 request->modifiedInstance.getPath ().getClassName(),
2324 request->modifiedInstance.getPath ().getKeyBindings());
|
2325 schuur 1.1
2326 // resolve provider name
|
2327 kumpf 1.2 ProviderName name = _resolveProviderName(
2328 request->operationContext.get(ProviderIdContainer::NAME));
|
2329 schuur 1.1
|
2330 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl));
2331
|
2332 schuur 1.1 // get cached or load new provider module
|
2333 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
2334 name.getLogicalName(),
2335 String::EMPTY);
|
2336 schuur 1.1
2337 // forward request
|
2338 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
2339 mark.hamzy 1.23
2340 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName());
2341
|
2342 mark.hamzy 1.25 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: Calling provider "<<PEGASUS_STD(hex)<<(int)&pr<<PEGASUS_STD(dec)<<", name = "<<pr.getName ()<<", module = "<<pr.getModule()<<" modifyInstance: "<<pr.getName()<<PEGASUS_STD(endl));
2343
2344 JvmVector *jv = 0;
2345
2346 env = JMPIjvm::attachThread(&jv);
2347
|
2348 mark.hamzy 1.37 if (!env)
2349 {
2350 PEG_METHOD_EXIT();
2351
2352 STAT_COPYDISPATCHER
2353
2354 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2355 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
2356 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
2357 }
2358
|
2359 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
2360 mark.hamzy 1.23
|
2361 mark.hamzy 1.25 STAT_GETSTARTTIME;
2362
|
2363 mark.hamzy 1.43 jmethodID id = NULL;
2364 String interfaceType;
2365 String interfaceVersion;
2366
2367 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
2368 interfaceType,
2369 interfaceVersion);
2370
2371 if (interfaceType == "JMPI")
2372 {
2373 // public abstract void setInstance (org.pegasus.jmpi.CIMObjectPath cop,
2374 // org.pegasus.jmpi.CIMInstance cimInstance)
2375 // org.pegasus.jmpi.throws CIMException
2376 id = env->GetMethodID((jclass)pr.jProviderClass,
2377 "setInstance",
2378 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");
2379
2380 if (id != NULL)
2381 {
2382 eMethodFound = METHOD_INSTANCEPROVIDER;
2383 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
2384 mark.hamzy 1.43 }
|
2385 mark.hamzy 1.25
|
2386 mark.hamzy 1.43 if (id == NULL)
2387 {
2388 env->ExceptionClear();
|
2389 mark.hamzy 1.25
|
2390 mark.hamzy 1.43 // public void setInstance (org.pegasus.jmpi.CIMObjectPath op,
2391 // org.pegasus.jmpi.CIMInstance ci,
2392 // boolean includeQualifiers,
2393 // java.lang.String[] propertyList)
2394 // throws org.pegasus.jmpi.CIMException
2395 id = env->GetMethodID((jclass)pr.jProviderClass,
2396 "setInstance",
2397 "(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");
2398
2399 if (id != NULL)
2400 {
2401 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
2402 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
2403 }
2404 }
2405 }
2406 else if (interfaceType == "JMPIExperimental")
|
2407 mark.hamzy 1.25 {
|
2408 mark.hamzy 1.43 // public abstract void setInstance (org.pegasus.jmpi.OperationContext oc,
2409 // org.pegasus.jmpi.CIMObjectPath op,
2410 // org.pegasus.jmpi.CIMInstance cimInstance);
2411 // throws org.pegasus.jmpi.CIMException
2412 id = env->GetMethodID((jclass)pr.jProviderClass,
2413 "setInstance",
2414 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");
2415
2416 if (id != NULL)
2417 {
2418 eMethodFound = METHOD_INSTANCEPROVIDER2;
2419 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
2420 }
|
2421 mark.hamzy 1.25 }
2422
2423 if (id == NULL)
2424 {
|
2425 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: No method found!"<<PEGASUS_STD(endl));
|
2426 mark.hamzy 1.25
|
2427 mark.hamzy 1.43 PEG_METHOD_EXIT();
|
2428 schuur 1.1
|
2429 mark.hamzy 1.43 STAT_COPYDISPATCHER
2430
2431 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2432 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
2433 "Could not find a method for the provider based on InterfaceType."));
|
2434 mark.hamzy 1.25 }
|
2435 schuur 1.1
|
2436 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2437 schuur 1.1
|
2438 mark.hamzy 1.25 switch (eMethodFound)
2439 {
|
2440 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
2441 {
2442 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
2443 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
2444
2445 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2446 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
2447
2448 JMPIjvm::checkException(env);
2449
2450 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
2451 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
2452 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
2453
2454 JMPIjvm::checkException(env);
2455
2456 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
2457
2458 env->CallVoidMethod((jobject)pr.jProvider,
2459 id,
2460 joc,
2461 mark.hamzy 1.43 jcop,
2462 jci);
2463
2464 JMPIjvm::checkException(env);
2465
2466 STAT_PMS_PROVIDEREND;
2467
2468 if (joc)
2469 {
2470 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
2471
2472 JMPIjvm::checkException(env);
2473 }
2474 break;
2475 }
2476
2477 case METHOD_CIMINSTANCEPROVIDER:
|
2478 mark.hamzy 1.25 {
|
2479 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2480 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
2481 mark.hamzy 1.25
2482 JMPIjvm::checkException(env);
2483
|
2484 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
2485 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
2486 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
|
2487 mark.hamzy 1.25
2488 JMPIjvm::checkException(env);
|
2489 schuur 1.1
|
2490 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
2491 schuur 1.1
|
2492 mark.hamzy 1.25 env->CallVoidMethod((jobject)pr.jProvider,
2493 id,
|
2494 mark.hamzy 1.29 jcop,
2495 jci,
|
2496 mark.hamzy 1.36 JMPI_INCLUDE_QUALIFIERS,
|
2497 mark.hamzy 1.25 jPropertyList);
|
2498 schuur 1.1
|
2499 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
2500 schuur 1.13
|
2501 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
2502 break;
|
2503 schuur 1.13 }
|
2504 schuur 1.1
|
2505 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
2506 mark.hamzy 1.25 {
|
2507 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2508 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
2509 mark.hamzy 1.25
2510 JMPIjvm::checkException(env);
2511
|
2512 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
2513 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
2514 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
|
2515 mark.hamzy 1.25
2516 JMPIjvm::checkException(env);
2517
2518 env->CallVoidMethod((jobject)pr.jProvider,
2519 id,
|
2520 mark.hamzy 1.29 jcop,
2521 jci);
|
2522 mark.hamzy 1.25
2523 JMPIjvm::checkException(env);
|
2524 schuur 1.13
|
2525 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
2526 break;
2527 }
|
2528 mark.hamzy 1.23
|
2529 mark.hamzy 1.25 case METHOD_UNKNOWN:
2530 {
2531 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
2532 break;
2533 }
2534 }
|
2535 schuur 1.1 }
2536 HandlerCatch(handler);
|
2537 mark.hamzy 1.23
|
2538 schuur 1.1 if (env) JMPIjvm::detachThread();
|
2539 mark.hamzy 1.23
|
2540 schuur 1.1 PEG_METHOD_EXIT();
2541
|
2542 w.white 1.31 STAT_COPYDISPATCHER
2543
|
2544 schuur 1.1 return(response);
2545 }
2546
2547 Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()
2548 {
|
2549 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest");
2550
2551 HandlerIntroVoid(DeleteInstance,message,request,response,handler);
|
2552 schuur 1.1
|
2553 mark.hamzy 1.25 typedef enum {
2554 METHOD_UNKNOWN = 0,
|
2555 mark.hamzy 1.43 METHOD_INSTANCEPROVIDER, // same as METHOD_CIMINSTANCEPROVIDER
2556 METHOD_INSTANCEPROVIDER2, // same as METHOD_CIMINSTANCEPROVIDER2
|
2557 mark.hamzy 1.25 } METHOD_VERSION;
2558 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2559 JNIEnv *env = NULL;
2560
|
2561 schuur 1.1 try {
2562 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
2563 konrad.r 1.15 "JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
2564 schuur 1.1 System::getHostName(),
2565 request->nameSpace.getString(),
2566 request->instanceName.getClassName().getString());
2567
|
2568 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->instanceName.getClassName().getString()<<PEGASUS_STD(endl));
2569
|
2570 schuur 1.1 // make target object path
|
2571 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2572 request->nameSpace,
2573 request->instanceName.getClassName(),
2574 request->instanceName.getKeyBindings());
|
2575 schuur 1.1
2576 // resolve provider name
|
2577 kumpf 1.2 ProviderName name = _resolveProviderName(
2578 request->operationContext.get(ProviderIdContainer::NAME));
|
2579 schuur 1.1
2580 // get cached or load new provider module
|
2581 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
2582 name.getLogicalName(),
2583 String::EMPTY);
|
2584 schuur 1.1
2585 // forward request
|
2586 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
2587 schuur 1.1
|
2588 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteInstance: " + pr.getName());
|
2589 schuur 1.1
|
2590 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: Calling provider deleteInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
2591 schuur 1.1
|
2592 mark.hamzy 1.25 JvmVector *jv = 0;
2593
2594 env = JMPIjvm::attachThread(&jv);
2595
|
2596 mark.hamzy 1.37 if (!env)
2597 {
2598 PEG_METHOD_EXIT();
2599
2600 STAT_COPYDISPATCHER
2601
2602 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2603 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
2604 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
2605 }
2606
|
2607 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
2608
2609 STAT_GETSTARTTIME;
2610
|
2611 mark.hamzy 1.43 jmethodID id = NULL;
2612 String interfaceType;
2613 String interfaceVersion;
2614
2615 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
2616 interfaceType,
2617 interfaceVersion);
2618
2619 if (interfaceType == "JMPI")
2620 {
2621 // public abstract void deleteInstance (org.pegasus.jmpi.CIMObjectPath cop)
2622 // throws org.pegasus.jmpi.CIMException
2623 id = env->GetMethodID((jclass)pr.jProviderClass,
2624 "deleteInstance",
2625 "(Lorg/pegasus/jmpi/CIMObjectPath;)V");
2626
2627 if (id != NULL)
2628 {
2629 eMethodFound = METHOD_INSTANCEPROVIDER;
2630 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
2631 }
2632 mark.hamzy 1.43 }
2633 else if (interfaceType == "JMPIExperimental")
2634 {
2635 // public abstract void deleteInstance (org.pegasus.jmpi.OperationContext oc,
2636 // org.pegasus.jmpi.CIMObjectPath cop)
2637 // throws org.pegasus.jmpi.CIMException
2638 id = env->GetMethodID((jclass)pr.jProviderClass,
2639 "deleteInstance",
2640 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;)V");
|
2641 mark.hamzy 1.25
|
2642 mark.hamzy 1.43 if (id != NULL)
2643 {
2644 eMethodFound = METHOD_INSTANCEPROVIDER2;
2645 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
2646 }
2647 }
|
2648 schuur 1.1
|
2649 mark.hamzy 1.43 if (id == NULL)
|
2650 mark.hamzy 1.25 {
|
2651 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: No method found!"<<PEGASUS_STD(endl));
2652
2653 PEG_METHOD_EXIT();
2654
2655 STAT_COPYDISPATCHER
2656
2657 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2658 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
2659 "Could not find a method for the provider based on InterfaceType."));
|
2660 mark.hamzy 1.25 }
|
2661 mark.hamzy 1.23
2662 JMPIjvm::checkException(env);
|
2663 schuur 1.1
|
2664 mark.hamzy 1.25 switch (eMethodFound)
2665 {
|
2666 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER2:
2667 {
2668 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
2669 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
2670
2671 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2672 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
2673
2674 JMPIjvm::checkException(env);
2675
2676 env->CallVoidMethod((jobject)pr.jProvider,
2677 id,
2678 joc,
2679 jcop);
2680
2681 JMPIjvm::checkException(env);
2682
2683 STAT_PMS_PROVIDEREND;
2684
2685 if (joc)
2686 {
2687 mark.hamzy 1.43 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
2688
2689 JMPIjvm::checkException(env);
2690 }
2691 break;
2692 }
2693
2694 case METHOD_INSTANCEPROVIDER:
|
2695 mark.hamzy 1.25 {
|
2696 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2697 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
2698 mark.hamzy 1.25
2699 JMPIjvm::checkException(env);
2700
|
2701 mark.hamzy 1.36 env->CallVoidMethod((jobject)pr.jProvider,
2702 id,
2703 jcop);
|
2704 mark.hamzy 1.25
2705 JMPIjvm::checkException(env);
2706
2707 STAT_PMS_PROVIDEREND;
2708 break;
2709 }
2710
2711 case METHOD_UNKNOWN:
2712 {
2713 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
2714 break;
2715 }
2716 }
2717 }
2718 HandlerCatch(handler);
2719
2720 if (env) JMPIjvm::detachThread();
2721
2722 PEG_METHOD_EXIT();
2723
|
2724 w.white 1.31 STAT_COPYDISPATCHER
2725
|
2726 mark.hamzy 1.25 return(response);
2727 }
2728
2729 Message * JMPIProviderManager::handleExecQueryRequest(const Message * message) throw()
2730 {
2731 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleExecQueryRequest");
2732
2733 HandlerIntro(ExecQuery,message,request,response,handler,Array<CIMObject>());
2734
2735 typedef enum {
2736 METHOD_UNKNOWN = 0,
|
2737 mark.hamzy 1.43 METHOD_CIMINSTANCEPROVIDER,
2738 METHOD_CIMINSTANCEPROVIDER2,
2739 METHOD_INSTANCEPROVIDER,
2740 METHOD_INSTANCEPROVIDER2,
|
2741 mark.hamzy 1.25 } METHOD_VERSION;
2742 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2743 JNIEnv *env = NULL;
2744
2745 try {
2746 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2747 "JMPIProviderManager::handleExecQueryRequest - Host name: $0 Name space: $1 Class name: $2",
2748 System::getHostName(),
2749 request->nameSpace.getString(),
2750 request->className.getString());
2751
2752 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
2753
2754 // make target object path
|
2755 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2756 request->nameSpace,
2757 request->className);
|
2758 mark.hamzy 1.25
2759 // resolve provider name
2760 ProviderName name = _resolveProviderName(
2761 request->operationContext.get(ProviderIdContainer::NAME));
2762
2763 // get cached or load new provider module
|
2764 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
2765 name.getLogicalName(),
2766 String::EMPTY);
|
2767 mark.hamzy 1.25
2768 // convert arguments
2769 OperationContext context;
2770
2771 context.insert(request->operationContext.get(IdentityContainer::NAME));
2772 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2773 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
2774
2775 // forward request
2776 JMPIProvider &pr = ph.GetProvider();
2777
2778 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.execQuery: " + pr.getName());
2779
2780 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Calling provider execQuery: "<<pr.getName()<<", queryLanguage: "<<request->queryLanguage<<", query: "<<request->query<<PEGASUS_STD(endl));
2781
2782 JvmVector *jv = 0;
2783
2784 env = JMPIjvm::attachThread(&jv);
2785
|
2786 mark.hamzy 1.37 if (!env)
2787 {
2788 PEG_METHOD_EXIT();
2789
2790 STAT_COPYDISPATCHER
2791
2792 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2793 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
2794 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
2795 }
2796
|
2797 mark.hamzy 1.23 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
2798 schuur 1.1
|
2799 mark.hamzy 1.23 STAT_GETSTARTTIME;
|
2800 schuur 1.1
|
2801 mark.hamzy 1.43 jmethodID id = NULL;
2802 String interfaceType;
2803 String interfaceVersion;
2804
2805 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
2806 interfaceType,
2807 interfaceVersion);
2808
2809 if (interfaceType == "JMPI")
2810 {
2811 // public abstract java.util.Vector execQuery (org.pegasus.jmpi.CIMObjectPath cop,
2812 // java.lang.String queryStatement,
2813 // int ql,
2814 // org.pegasus.jmpi.CIMClass cimClass)
2815 // throws org.pegasus.jmpi.CIMException
2816 //
2817 id = env->GetMethodID((jclass)pr.jProviderClass,
2818 "execQuery",
2819 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
2820
2821 if (id != NULL)
2822 mark.hamzy 1.43 {
2823 eMethodFound = METHOD_INSTANCEPROVIDER;
2824 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_INSTANCEPROVIDER."<<PEGASUS_STD(endl));
2825 }
|
2826 mark.hamzy 1.25
|
2827 mark.hamzy 1.43 if (id == NULL)
2828 {
2829 env->ExceptionClear();
|
2830 mark.hamzy 1.25
|
2831 mark.hamzy 1.43 // public abstract org.pegasus.jmpi.CIMInstance[] execQuery(org.pegasus.jmpi.CIMObjectPath cop,
2832 // java.lang.String query,
2833 // java.lang.String ql,
2834 // org.pegasus.jmpi.CIMClass cimClass)
2835 // throws org.pegasus.jmpi.CIMException
2836 id = env->GetMethodID((jclass)pr.jProviderClass,
2837 "execQuery",
2838 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");
2839
2840 if (id != NULL)
2841 {
2842 eMethodFound = METHOD_CIMINSTANCEPROVIDER;
2843 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_CIMINSTANCEPROVIDER."<<PEGASUS_STD(endl));
2844 }
2845 }
2846 }
2847 else if (interfaceType == "JMPIExperimental")
|
2848 mark.hamzy 1.25 {
|
2849 mark.hamzy 1.43 // public abstract java.util.Vector execQuery (org.pegasus.jmpi.OperationContext oc,
2850 // org.pegasus.jmpi.CIMObjectPath cop,
2851 // org.pegasus.jmpi.CIMClass cimClass,
2852 // java.lang.String queryStatement,
2853 // java.lang.String queryLanguage)
2854 // throws org.pegasus.jmpi.CIMException
2855 id = env->GetMethodID((jclass)pr.jProviderClass,
2856 "execQuery",
2857 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
|
2858 mark.hamzy 1.25
|
2859 mark.hamzy 1.43 if (id != NULL)
2860 {
2861 eMethodFound = METHOD_INSTANCEPROVIDER2;
2862 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_INSTANCEPROVIDER2."<<PEGASUS_STD(endl));
2863 }
|
2864 mark.hamzy 1.25
|
2865 mark.hamzy 1.43 if (id == NULL)
2866 {
2867 env->ExceptionClear();
|
2868 mark.hamzy 1.25
|
2869 mark.hamzy 1.43 // public abstract org.pegasus.jmpi.CIMInstance[] execQuery (org.pegasus.jmpi.OperationContext oc,
2870 // org.pegasus.jmpi.CIMObjectPath cop,
2871 // org.pegasus.jmpi.CIMClass cimClass,
2872 // java.lang.String queryStatement,
2873 // java.lang.String queryLanguage)
2874 // throws org.pegasus.jmpi.CIMException
2875 id = env->GetMethodID((jclass)pr.jProviderClass,
2876 "execQuery",
2877 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
2878
2879 if (id != NULL)
2880 {
2881 eMethodFound = METHOD_CIMINSTANCEPROVIDER2;
2882 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_CIMINSTANCEPROVIDER2."<<PEGASUS_STD(endl));
2883 }
2884 }
|
2885 mark.hamzy 1.25 }
2886
2887 if (id == NULL)
2888 {
|
2889 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found no method!"<<PEGASUS_STD(endl));
|
2890 mark.hamzy 1.36
|
2891 mark.hamzy 1.43 PEG_METHOD_EXIT();
|
2892 mark.hamzy 1.36
|
2893 mark.hamzy 1.43 STAT_COPYDISPATCHER
|
2894 mark.hamzy 1.36
|
2895 mark.hamzy 1.43 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2896 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
2897 "Could not find a method for the provider based on InterfaceType."));
|
2898 mark.hamzy 1.25 }
2899
|
2900 schuur 1.1 JMPIjvm::checkException(env);
2901
|
2902 mark.hamzy 1.25 switch (eMethodFound)
2903 {
|
2904 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER:
|
2905 mark.hamzy 1.25 {
|
2906 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
2907 mark.hamzy 1.25 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
2908
2909 JMPIjvm::checkException(env);
2910
2911 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
2912 jstring jquery = env->NewStringUTF(request->query.getCString());
2913
|
2914 mark.hamzy 1.40 CIMClass cls;
2915
2916 try
2917 {
2918 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2919 AutoMutex lock (pr._cimomMutex);
2920
2921 cls = pr._cimom_handle->getClass(context,
2922 request->nameSpace,
2923 request->className,
2924 false,
2925 true,
2926 true,
2927 CIMPropertyList());
2928 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2929 }
2930 catch (CIMException e)
2931 {
2932 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
2933 throw;
2934 }
2935 mark.hamzy 1.40
|
2936 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
2937
|
2938 mark.hamzy 1.25 JMPIjvm::checkException(env);
2939
|
2940 mark.hamzy 1.27 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
|
2941 mark.hamzy 1.25
2942 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
2943
2944 JMPIjvm::checkException(env);
2945
2946 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2947 id,
2948 jcop,
2949 jquery,
2950 jqueryLanguage,
2951 jCc);
|
2952 mark.hamzy 1.23
|
2953 mark.hamzy 1.25 JMPIjvm::checkException(env);
2954
2955 STAT_PMS_PROVIDEREND;
2956
2957 handler.processing();
2958 if (jAr) {
2959 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
2960 JMPIjvm::checkException(env);
2961
|
2962 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jAr,i);
2963
|
2964 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
2965 mark.hamzy 1.23
|
2966 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
2967 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
2968 mark.hamzy 1.25
2969 JMPIjvm::checkException(env);
2970
|
2971 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2972 mark.hamzy 1.25 }
2973 }
2974 handler.complete();
2975 break;
2976 }
2977
|
2978 mark.hamzy 1.43 case METHOD_CIMINSTANCEPROVIDER2:
|
2979 mark.hamzy 1.36 {
|
2980 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
2981 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
2982
|
2983 mark.hamzy 1.36 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2984 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
2985
2986 JMPIjvm::checkException(env);
2987
2988 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
2989 jstring jquery = env->NewStringUTF(request->query.getCString());
2990
|
2991 mark.hamzy 1.40 CIMClass cls;
2992
2993 try
2994 {
2995 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2996 AutoMutex lock (pr._cimomMutex);
2997
2998 cls = pr._cimom_handle->getClass(context,
2999 request->nameSpace,
3000 request->className,
3001 false,
3002 true,
3003 true,
3004 CIMPropertyList());
3005 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
3006 }
3007 catch (CIMException e)
3008 {
3009 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3010 throw;
3011 }
3012 mark.hamzy 1.40
|
3013 mark.hamzy 1.36 CIMClass *pcls = new CIMClass (cls);
3014
3015 JMPIjvm::checkException(env);
3016
3017 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
3018
3019 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
3020
3021 JMPIjvm::checkException(env);
3022
|
3023 mark.hamzy 1.43 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
3024 mark.hamzy 1.36 id,
|
3025 mark.hamzy 1.43 joc,
|
3026 mark.hamzy 1.36 jcop,
3027 jquery,
|
3028 mark.hamzy 1.43 jqueryLanguage,
3029 jCc);
|
3030 mark.hamzy 1.36
3031 JMPIjvm::checkException(env);
3032
3033 STAT_PMS_PROVIDEREND;
3034
|
3035 mark.hamzy 1.43 if (joc)
3036 {
3037 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
3038
3039 JMPIjvm::checkException(env);
3040 }
3041
3042 handler.processing();
3043 if (jAr) {
3044 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
3045 JMPIjvm::checkException(env);
3046
3047 jobject jciRet = env->GetObjectArrayElement(jAr,i);
3048
3049 JMPIjvm::checkException(env);
3050
3051 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
3052 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
3053
3054 JMPIjvm::checkException(env);
3055
3056 mark.hamzy 1.43 handler.deliver(*ciRet);
3057 }
3058 }
3059 handler.complete();
3060 break;
3061 }
3062
3063 case METHOD_INSTANCEPROVIDER2:
3064 {
3065 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
3066 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
3067
3068 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
3069 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
3070
3071 JMPIjvm::checkException(env);
3072
3073 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
3074 jstring jquery = env->NewStringUTF(request->query.getCString());
3075
3076 CIMClass cls;
3077 mark.hamzy 1.43
3078 try
3079 {
3080 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
3081 AutoMutex lock (pr._cimomMutex);
3082
3083 cls = pr._cimom_handle->getClass(context,
3084 request->nameSpace,
3085 request->className,
3086 false,
3087 true,
3088 true,
3089 CIMPropertyList());
3090 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
3091 }
3092 catch (CIMException e)
3093 {
3094 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3095 throw;
3096 }
3097
3098 mark.hamzy 1.43 CIMClass *pcls = new CIMClass (cls);
3099
3100 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
3101
3102 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
3103
3104 JMPIjvm::checkException(env);
3105
|
3106 mark.hamzy 1.51 jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider,
3107 id,
3108 joc,
3109 jcop,
3110 jCc,
3111 jquery,
3112 jqueryLanguage);
|
3113 mark.hamzy 1.43
3114 JMPIjvm::checkException(env);
3115
3116 STAT_PMS_PROVIDEREND;
3117
3118 if (joc)
3119 {
3120 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
3121
3122 JMPIjvm::checkException(env);
3123 }
3124
|
3125 mark.hamzy 1.36 handler.processing();
|
3126 mark.hamzy 1.51 if (jVec)
3127 {
3128 for (int i = 0, m = env->CallIntMethod (jVec, JMPIjvm::jv.VectorSize); i < m; i++)
3129 {
|
3130 mark.hamzy 1.36 JMPIjvm::checkException(env);
3131
|
3132 mark.hamzy 1.51 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
3133 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: jciRet = "<<jciRet<<PEGASUS_STD(endl));
|
3134 mark.hamzy 1.36
3135 JMPIjvm::checkException(env);
3136
3137 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
3138 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
3139
3140 JMPIjvm::checkException(env);
3141
3142 handler.deliver(*ciRet);
3143 }
3144 }
|
3145 mark.hamzy 1.51 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: done!"<<PEGASUS_STD(endl));
|
3146 mark.hamzy 1.36 handler.complete();
3147 break;
3148 }
3149
|
3150 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
3151 mark.hamzy 1.25 {
|
3152 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3153 mark.hamzy 1.25 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
3154
3155 JMPIjvm::checkException(env);
3156
3157 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
3158 jstring jquery = env->NewStringUTF(request->query.getCString());
3159
|
3160 mark.hamzy 1.40 CIMClass cls;
3161
3162 try
3163 {
3164 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
3165 AutoMutex lock (pr._cimomMutex);
3166
3167 cls = pr._cimom_handle->getClass(context,
3168 request->nameSpace,
3169 request->className,
3170 false,
3171 true,
3172 true,
3173 CIMPropertyList());
3174 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
3175 }
3176 catch (CIMException e)
3177 {
3178 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3179 throw;
3180 }
3181 mark.hamzy 1.40
|
3182 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
3183
|
3184 mark.hamzy 1.25 JMPIjvm::checkException(env);
3185
|
3186 mark.hamzy 1.27 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
|
3187 mark.hamzy 1.25
3188 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
3189
3190 JMPIjvm::checkException(env);
3191
3192 jint jql = 0; // @BUG - how to convert?
3193
|
3194 mark.hamzy 1.51 jobject jVec = env->CallObjectMethod ((jobject)pr.jProvider,
3195 id,
3196 jcop,
3197 jquery,
3198 jql,
3199 jCc);
|
3200 mark.hamzy 1.25
3201 JMPIjvm::checkException(env);
3202
3203 STAT_PMS_PROVIDEREND;
3204
3205 handler.processing();
3206 if (jVec) {
|
3207 mark.hamzy 1.51 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
3208 mark.hamzy 1.25 JMPIjvm::checkException(env);
3209
|
3210 mark.hamzy 1.51 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
3211 mark.hamzy 1.29
|
3212 mark.hamzy 1.25 JMPIjvm::checkException(env);
3213
|
3214 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
3215 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
3216 mark.hamzy 1.25
3217 JMPIjvm::checkException(env);
3218
|
3219 mark.hamzy 1.29 handler.deliver(*ciRet);
|
3220 mark.hamzy 1.25 }
3221 }
3222 handler.complete();
3223 break;
3224 }
3225
3226 case METHOD_UNKNOWN:
3227 {
3228 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl));
3229 break;
3230 }
3231 }
|
3232 schuur 1.1 }
3233 HandlerCatch(handler);
|
3234 mark.hamzy 1.23
|
3235 schuur 1.1 if (env) JMPIjvm::detachThread();
|
3236 mark.hamzy 1.23
|
3237 schuur 1.1 PEG_METHOD_EXIT();
3238
|
3239 w.white 1.31 STAT_COPYDISPATCHER
3240
|
3241 schuur 1.1 return(response);
3242 }
3243
3244 Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()
3245 {
|
3246 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest");
3247
3248 HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>());
|
3249 schuur 1.1
|
3250 mark.hamzy 1.24 typedef enum {
3251 METHOD_UNKNOWN = 0,
|
3252 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
3253 METHOD_CIMASSOCIATORPROVIDER2,
3254 METHOD_ASSOCIATORPROVIDER,
3255 METHOD_ASSOCIATORPROVIDER2,
|
3256 mark.hamzy 1.24 } METHOD_VERSION;
3257 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3258 JNIEnv *env = NULL;
|
3259 schuur 1.13
|
3260 schuur 1.1 try {
3261 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3262 "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",
3263 System::getHostName(),
3264 request->nameSpace.getString(),
3265 request->objectName.getClassName().getString());
3266
|
3267 mark.hamzy 1.25 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl));
|
3268 mark.hamzy 1.23
|
3269 schuur 1.1 // make target object path
|
3270 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3271 request->nameSpace,
3272 request->objectName.getClassName(),
3273 request->objectName.getKeyBindings());
3274 CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),
3275 request->nameSpace,
3276 request->assocClass.getString());
|
3277 schuur 1.1
3278 // resolve provider name
|
3279 kumpf 1.2 ProviderName name = _resolveProviderName(
3280 request->operationContext.get(ProviderIdContainer::NAME));
|
3281 schuur 1.1
3282 // get cached or load new provider module
|
3283 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
3284 name.getLogicalName(),
3285 String::EMPTY);
|
3286 schuur 1.1
|
3287 mark.hamzy 1.24 // convert arguments
|
3288 schuur 1.1 OperationContext context;
3289
|
3290 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
3291 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3292 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
3293 schuur 1.1
3294 // forward request
|
3295 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
3296
3297 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName());
|
3298 schuur 1.1
|
3299 mark.hamzy 1.24 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
|
3300 schuur 1.1
|
3301 mark.hamzy 1.24 JvmVector *jv = 0;
|
3302 schuur 1.1
|
3303 mark.hamzy 1.24 env = JMPIjvm::attachThread(&jv);
|
3304 schuur 1.1
|
3305 mark.hamzy 1.37 if (!env)
3306 {
3307 PEG_METHOD_EXIT();
3308
3309 STAT_COPYDISPATCHER
3310
3311 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3312 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
3313 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
3314 }
3315
|
3316 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
3317
3318 STAT_GETSTARTTIME;
3319
|
3320 mark.hamzy 1.43 jmethodID id = NULL;
3321 String interfaceType;
3322 String interfaceVersion;
3323
3324 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
3325 interfaceType,
3326 interfaceVersion);
3327
3328 if (interfaceType == "JMPI")
3329 {
3330 // public java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,
3331 // org.pegasus.jmpi.CIMObjectPath pathName,
3332 // java.lang.String resultClass,
3333 // java.lang.String role,
3334 // java.lang.String resultRole,
3335 // boolean includeQualifiers,
3336 // boolean includeClassOrigin,
3337 // java.lang.String[] propertyList)
3338 // throws org.pegasus.jmpi.CIMException
3339 //
3340 id = env->GetMethodID((jclass)pr.jProviderClass,
3341 mark.hamzy 1.43 "associators",
3342 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
3343 mark.hamzy 1.24
|
3344 mark.hamzy 1.43 if (id != NULL)
3345 {
3346 eMethodFound = METHOD_ASSOCIATORPROVIDER;
3347 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
3348 }
3349
3350 if (id == NULL)
3351 {
3352 env->ExceptionClear();
|
3353 mark.hamzy 1.24
|
3354 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMInstance[] associators (org.pegasus.jmpi.CIMObjectPath assocName,
3355 // org.pegasus.jmpi.CIMObjectPath pathName,
3356 // java.lang.String resultClass,
3357 // java.lang.String role,
3358 // java.lang.String resultRole,
3359 // boolean includeQualifiers,
3360 // boolean includeClassOrigin,
3361 // java.lang.String[] propertyList)
3362 // throws org.pegasus.jmpi.CIMException
3363 //
3364 id = env->GetMethodID((jclass)pr.jProviderClass,
3365 "associators",
3366 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
3367
3368 if (id != NULL)
3369 {
3370 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
3371 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
3372 }
3373 }
3374 }
3375 mark.hamzy 1.43 else if (interfaceType == "JMPIExperimental")
|
3376 mark.hamzy 1.24 {
|
3377 mark.hamzy 1.43 // public java.util.Vector associators (org.pegasus.jmpi.OperationContext oc,
3378 // org.pegasus.jmpi.CIMObjectPath assocName,
3379 // org.pegasus.jmpi.CIMObjectPath pathName,
3380 // java.lang.String resultClass,
3381 // java.lang.String role,
3382 // java.lang.String resultRole,
3383 // boolean includeQualifiers,
3384 // boolean includeClassOrigin,
3385 // java.lang.String[] propertyList)
3386 // throws org.pegasus.jmpi.CIMException
3387 //
3388 id = env->GetMethodID((jclass)pr.jProviderClass,
3389 "associators",
3390 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
3391 schuur 1.12
|
3392 mark.hamzy 1.43 if (id != NULL)
3393 {
3394 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
3395 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
3396 }
|
3397 mark.hamzy 1.24
|
3398 mark.hamzy 1.43 if (id == NULL)
3399 {
3400 env->ExceptionClear();
|
3401 mark.hamzy 1.24
|
3402 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMInstance[] associators (org.pegasus.jmpi.OperationContext oc,
3403 // org.pegasus.jmpi.CIMObjectPath assocName,
3404 // org.pegasus.jmpi.CIMObjectPath pathName,
3405 // java.lang.String resultClass,
3406 // java.lang.String role,
3407 // java.lang.String resultRole,
3408 // boolean includeQualifiers,
3409 // boolean includeClassOrigin,
3410 // java.lang.String[] propertyList)
3411 // throws org.pegasus.jmpi.CIMException
3412 //
3413 id = env->GetMethodID((jclass)pr.jProviderClass,
3414 "associators",
3415 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
3416
3417 if (id != NULL)
3418 {
3419 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
3420 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
3421 }
3422 }
|
3423 mark.hamzy 1.24 }
3424
3425 if (id == NULL)
3426 {
3427 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));
|
3428 mark.hamzy 1.43
3429 PEG_METHOD_EXIT();
3430
3431 STAT_COPYDISPATCHER
3432
3433 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3434 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
3435 "Could not find a method for the provider based on InterfaceType."));
|
3436 mark.hamzy 1.23 }
|
3437 mark.hamzy 1.24
|
3438 schuur 1.1 JMPIjvm::checkException(env);
3439
|
3440 mark.hamzy 1.24 switch (eMethodFound)
3441 {
|
3442 mark.hamzy 1.43 case METHOD_CIMASSOCIATORPROVIDER:
|
3443 mark.hamzy 1.24 {
|
3444 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
3445 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3446
3447 JMPIjvm::checkException(env);
3448
|
3449 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
3450 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
3451
3452 JMPIjvm::checkException(env);
3453
|
3454 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
3455 jstring jRole = env->NewStringUTF(request->role.getCString());
3456 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
3457
3458 JMPIjvm::checkException(env);
3459
3460 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
3461
|
3462 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
3463 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
|
3464 mark.hamzy 1.49 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
3465 mark.hamzy 1.29 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
3466 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
3467 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
3468 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3469 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3470 #endif
3471
|
3472 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
3473 mark.hamzy 1.24 id,
3474 jAssociationName,
|
3475 mark.hamzy 1.43 jPathName,
|
3476 mark.hamzy 1.24 jResultClass,
3477 jRole,
3478 jResultRole,
|
3479 mark.hamzy 1.36 JMPI_INCLUDE_QUALIFIERS,
3480 request->includeClassOrigin,
|
3481 mark.hamzy 1.24 jPropertyList);
|
3482 mark.hamzy 1.25
|
3483 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3484 schuur 1.13
|
3485 mark.hamzy 1.23 STAT_PMS_PROVIDEREND;
|
3486 schuur 1.1
|
3487 mark.hamzy 1.23 handler.processing();
|
3488 mark.hamzy 1.45 if (jAr) {
3489 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
3490 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3491 schuur 1.1
|
3492 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
3493 mark.hamzy 1.24
|
3494 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3495 schuur 1.13
|
3496 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
3497 schuur 1.13
|
3498 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3499 schuur 1.13
|
3500 mark.hamzy 1.29 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
3501 mark.hamzy 1.40 CIMClass cls;
3502
3503 try
3504 {
3505 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3506 AutoMutex lock (pr._cimomMutex);
3507
3508 cls = pr._cimom_handle->getClass(context,
3509 request->nameSpace,
3510 ciRet->getClassName(),
3511 false,
3512 true,
3513 true,
3514 CIMPropertyList());
3515 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3516 }
3517 catch (CIMException e)
3518 {
3519 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3520 throw;
3521 }
3522 mark.hamzy 1.40
|
3523 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
3524 CIMObjectPath iop = ciRet->buildPath(cls);
|
3525 mark.hamzy 1.24
|
3526 mark.hamzy 1.27 JMPIjvm::checkException(env);
3527
|
3528 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
3529 mark.hamzy 1.29 ciRet->setPath(iop);
|
3530 schuur 1.13
|
3531 mark.hamzy 1.29 handler.deliver(*ciRet);
|
3532 mark.hamzy 1.23 }
3533 }
|
3534 mark.hamzy 1.24 handler.complete();
3535 break;
|
3536 mark.hamzy 1.23 }
|
3537 mark.hamzy 1.24
|
3538 mark.hamzy 1.43 case METHOD_CIMASSOCIATORPROVIDER2:
|
3539 mark.hamzy 1.24 {
|
3540 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
3541 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
3542
|
3543 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
3544 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3545
3546 JMPIjvm::checkException(env);
3547
|
3548 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3549 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
3550
3551 JMPIjvm::checkException(env);
3552
|
3553 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
3554 jstring jRole = env->NewStringUTF(request->role.getCString());
3555 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
3556
3557 JMPIjvm::checkException(env);
3558
3559 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
3560
|
3561 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
3562 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
|
3563 mark.hamzy 1.47 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
3564 mark.hamzy 1.29 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
3565 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
3566 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
3567 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3568 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3569 #endif
3570
|
3571 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
3572 mark.hamzy 1.43 id,
3573 joc,
3574 jAssociationName,
3575 jPathName,
3576 jResultClass,
3577 jRole,
3578 jResultRole,
3579 JMPI_INCLUDE_QUALIFIERS,
3580 request->includeClassOrigin,
3581 jPropertyList);
|
3582 mark.hamzy 1.25
|
3583 mark.hamzy 1.23 JMPIjvm::checkException(env);
3584
3585 STAT_PMS_PROVIDEREND;
3586
|
3587 mark.hamzy 1.43 if (joc)
3588 {
3589 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
3590
3591 JMPIjvm::checkException(env);
3592 }
3593
|
3594 mark.hamzy 1.23 handler.processing();
|
3595 mark.hamzy 1.45 if (jAr) {
3596 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
3597 mark.hamzy 1.43 JMPIjvm::checkException(env);
3598
|
3599 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
3600 mark.hamzy 1.43
|
3601 mark.hamzy 1.23 JMPIjvm::checkException(env);
3602
|
3603 mark.hamzy 1.43 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
3604 mark.hamzy 1.24
|
3605 mark.hamzy 1.23 JMPIjvm::checkException(env);
3606
|
3607 mark.hamzy 1.43 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
3608 mark.hamzy 1.40 CIMClass cls;
3609
3610 try
3611 {
3612 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3613 AutoMutex lock (pr._cimomMutex);
3614
3615 cls = pr._cimom_handle->getClass(context,
3616 request->nameSpace,
3617 ciRet->getClassName(),
3618 false,
3619 true,
3620 true,
3621 CIMPropertyList());
3622 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3623 }
3624 catch (CIMException e)
3625 {
3626 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3627 throw;
3628 }
3629 mark.hamzy 1.40
|
3630 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
3631 CIMObjectPath iop = ciRet->buildPath(cls);
|
3632 mark.hamzy 1.24
|
3633 mark.hamzy 1.27 JMPIjvm::checkException(env);
3634
|
3635 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
3636 mark.hamzy 1.29 ciRet->setPath(iop);
|
3637 schuur 1.13
|
3638 mark.hamzy 1.29 handler.deliver(*ciRet);
|
3639 mark.hamzy 1.23 }
3640 }
|
3641 mark.hamzy 1.24 handler.complete();
3642 break;
3643 }
3644
|
3645 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
3646 mark.hamzy 1.24 {
|
3647 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
3648 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
|
3649 schuur 1.13
|
3650 mark.hamzy 1.43 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
3651 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
3652 schuur 1.13
|
3653 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3654 schuur 1.1
|
3655 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
3656 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
|
3657 w.white 1.31
|
3658 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3659 schuur 1.13
|
3660 mark.hamzy 1.43 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
3661 jstring jRole = env->NewStringUTF(request->role.getCString());
3662 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
|
3663 mark.hamzy 1.23
|
3664 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3665 schuur 1.1
|
3666 mark.hamzy 1.43 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
3667 schuur 1.13
|
3668 mark.hamzy 1.43 #ifdef PEGASUS_DEBUG
3669 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
|
3670 mark.hamzy 1.49 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
3671 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
3672 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
3673 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
3674 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3675 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3676 #endif
|
3677 schuur 1.1
|
3678 mark.hamzy 1.43 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
3679 id,
3680 joc,
3681 jAssociationName,
3682 jPathName,
3683 jResultClass,
3684 jRole,
3685 jResultRole,
3686 JMPI_INCLUDE_QUALIFIERS,
3687 request->includeClassOrigin,
3688 jPropertyList);
|
3689 mark.hamzy 1.23
|
3690 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3691 mark.hamzy 1.23
|
3692 mark.hamzy 1.43 STAT_PMS_PROVIDEREND;
|
3693 schuur 1.1
|
3694 mark.hamzy 1.43 if (joc)
3695 {
3696 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
|
3697 schuur 1.1
|
3698 mark.hamzy 1.43 JMPIjvm::checkException(env);
3699 }
|
3700 schuur 1.1
|
3701 mark.hamzy 1.43 handler.processing();
3702 if (jVec) {
|
3703 mark.hamzy 1.45 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
3704 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3705 schuur 1.1
|
3706 mark.hamzy 1.45 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
3707 schuur 1.1
|
3708 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3709 schuur 1.1
|
3710 mark.hamzy 1.43 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
3711 schuur 1.1
|
3712 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3713 mark.hamzy 1.24
|
3714 mark.hamzy 1.43 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
3715 CIMClass cls;
|
3716 schuur 1.1
|
3717 mark.hamzy 1.43 try
3718 {
3719 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3720 AutoMutex lock (pr._cimomMutex);
3721
3722 cls = pr._cimom_handle->getClass(context,
3723 request->nameSpace,
3724 ciRet->getClassName(),
3725 false,
3726 true,
3727 true,
3728 CIMPropertyList());
3729 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3730 }
3731 catch (CIMException e)
3732 {
3733 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3734 throw;
3735 }
3736
3737 const CIMObjectPath& op = ciRet->getPath();
3738 mark.hamzy 1.43 CIMObjectPath iop = ciRet->buildPath(cls);
3739
3740 JMPIjvm::checkException(env);
3741
3742 iop.setNameSpace(op.getNameSpace());
3743 ciRet->setPath(iop);
3744
3745 handler.deliver(*ciRet);
3746 }
3747 }
3748 handler.complete();
3749 break;
3750 }
3751
3752 case METHOD_ASSOCIATORPROVIDER:
3753 {
3754 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
3755 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3756
3757 JMPIjvm::checkException(env);
3758
3759 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
3760 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
3761
3762 JMPIjvm::checkException(env);
3763
3764 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
3765 jstring jRole = env->NewStringUTF(request->role.getCString());
3766 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
3767
3768 JMPIjvm::checkException(env);
3769
3770 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
3771
3772 #ifdef PEGASUS_DEBUG
3773 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
3774 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
3775 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
3776 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
3777 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
3778 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3779 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3780 mark.hamzy 1.43 #endif
3781
3782 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
3783 mark.hamzy 1.49 id,
3784 jAssociationName,
3785 jPathName,
3786 jResultClass,
3787 jRole,
3788 jResultRole,
3789 JMPI_INCLUDE_QUALIFIERS,
3790 request->includeClassOrigin,
3791 jPropertyList);
|
3792 mark.hamzy 1.43
3793 JMPIjvm::checkException(env);
3794
3795 STAT_PMS_PROVIDEREND;
3796
3797 handler.processing();
3798 if (jVec) {
3799 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
3800 JMPIjvm::checkException(env);
3801
3802 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
3803
3804 JMPIjvm::checkException(env);
3805
3806 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
3807 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
3808 CIMClass cls;
3809
3810 try
3811 {
3812 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3813 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
3814
3815 cls = pr._cimom_handle->getClass(context,
3816 request->nameSpace,
3817 ciRet->getClassName(),
3818 false,
3819 true,
3820 true,
3821 CIMPropertyList());
3822 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3823 }
3824 catch (CIMException e)
3825 {
3826 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3827 throw;
3828 }
3829
3830 const CIMObjectPath& op = ciRet->getPath();
3831 CIMObjectPath iop = ciRet->buildPath(cls);
3832
3833 JMPIjvm::checkException(env);
3834 mark.hamzy 1.43
3835 iop.setNameSpace(op.getNameSpace());
3836 ciRet->setPath(iop);
3837
3838 handler.deliver(*ciRet);
3839 }
3840 }
3841 handler.complete();
3842 break;
3843 }
3844
3845 case METHOD_UNKNOWN:
3846 {
3847 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));
3848 break;
3849 }
3850 }
3851 }
3852 HandlerCatch(handler);
3853
3854 if (env) JMPIjvm::detachThread();
3855 mark.hamzy 1.43
3856 PEG_METHOD_EXIT();
3857
3858 STAT_COPYDISPATCHER
3859
3860 return(response);
3861 }
3862
3863 Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()
3864 {
3865 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest");
3866
3867 HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>());
3868
3869 typedef enum {
3870 METHOD_UNKNOWN = 0,
3871 METHOD_CIMASSOCIATORPROVIDER,
3872 METHOD_CIMASSOCIATORPROVIDER2,
3873 METHOD_ASSOCIATORPROVIDER,
3874 METHOD_ASSOCIATORPROVIDER2
3875 } METHOD_VERSION;
3876 mark.hamzy 1.43 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3877 JNIEnv *env = NULL;
3878
3879 try {
3880 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3881 "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2",
3882 System::getHostName(),
3883 request->nameSpace.getString(),
3884 request->objectName.getClassName().getString());
3885
3886 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<", assocName = "<<request->assocClass.getString()<<PEGASUS_STD(endl));
3887
3888 // make target object path
3889 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3890 request->nameSpace,
3891 request->objectName.getClassName(),
3892 request->objectName.getKeyBindings());
3893 CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),
3894 request->nameSpace,
3895 request->assocClass.getString());
3896
3897 mark.hamzy 1.43 // resolve provider name
3898 ProviderName name = _resolveProviderName(
3899 request->operationContext.get(ProviderIdContainer::NAME));
3900
3901 // get cached or load new provider module
3902 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
3903 name.getLogicalName(),
3904 String::EMPTY);
3905
3906 // forward request
3907 JMPIProvider &pr = ph.GetProvider();
3908
3909 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName());
3910
3911 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: Calling provider associatorNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
3912
3913 JvmVector *jv = 0;
3914
3915 env = JMPIjvm::attachThread(&jv);
3916
3917 if (!env)
3918 mark.hamzy 1.43 {
3919 PEG_METHOD_EXIT();
|
3920 mark.hamzy 1.37
3921 STAT_COPYDISPATCHER
3922
3923 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3924 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
3925 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
3926 }
3927
|
3928 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
3929
3930 STAT_GETSTARTTIME;
3931
|
3932 mark.hamzy 1.43 jmethodID id = NULL;
3933 String interfaceType;
3934 String interfaceVersion;
3935
3936 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
3937 interfaceType,
3938 interfaceVersion);
3939
3940 if (interfaceType == "JMPI")
3941 {
3942 // public java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
3943 // org.pegasus.jmpi.CIMObjectPath pathName,
3944 // java.lang.String resultClass,
3945 // java.lang.String role,
3946 // java.lang.String resultRole)
3947 // throws org.pegasus.jmpi.CIMException
3948 id = env->GetMethodID((jclass)pr.jProviderClass,
3949 "associatorNames",
3950 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
3951
3952 if (id != NULL)
3953 mark.hamzy 1.43 {
3954 eMethodFound = METHOD_ASSOCIATORPROVIDER;
3955 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
3956 }
|
3957 mark.hamzy 1.24
|
3958 mark.hamzy 1.43 if (id == NULL)
3959 {
3960 env->ExceptionClear();
|
3961 mark.hamzy 1.24
|
3962 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
3963 // org.pegasus.jmpi.CIMObjectPath pathName,
3964 // java.lang.String resultClass,
3965 // java.lang.String role,
3966 // java.lang.String resultRole)
3967 // throws org.pegasus.jmpi.CIMException
3968 id = env->GetMethodID((jclass)pr.jProviderClass,
3969 "associatorNames",
3970 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
3971
3972 if (id != NULL)
3973 {
3974 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
3975 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
3976 }
3977 }
3978 }
3979 else if (interfaceType == "JMPIExperimental")
|
3980 mark.hamzy 1.24 {
|
3981 mark.hamzy 1.43 // public java.util.Vector associatorNames (org.pegasus.jmpi.OperationContext oc,
3982 // org.pegasus.jmpi.CIMObjectPath assocName,
3983 // org.pegasus.jmpi.CIMObjectPath pathName,
3984 // java.lang.String resultClass,
3985 // java.lang.String role,
3986 // java.lang.String resultRole)
3987 // throws org.pegasus.jmpi.CIMException
3988 id = env->GetMethodID((jclass)pr.jProviderClass,
3989 "associatorNames",
3990 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
|
3991 mark.hamzy 1.24
|
3992 mark.hamzy 1.43 if (id != NULL)
3993 {
3994 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
3995 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
3996 }
|
3997 mark.hamzy 1.24
|
3998 mark.hamzy 1.43 if (id == NULL)
3999 {
4000 env->ExceptionClear();
|
4001 mark.hamzy 1.24
|
4002 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.OperationContext oc,
4003 // org.pegasus.jmpi.CIMObjectPath assocName,
4004 // org.pegasus.jmpi.CIMObjectPath pathName,
4005 // java.lang.String resultClass,
4006 // java.lang.String role,
4007 // java.lang.String resultRole)
4008 // throws org.pegasus.jmpi.CIMException
4009 id = env->GetMethodID((jclass)pr.jProviderClass,
4010 "associatorNames",
4011 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
4012
4013 if (id != NULL)
4014 {
4015 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
4016 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
4017 }
4018 }
|
4019 mark.hamzy 1.24 }
|
4020 schuur 1.13
|
4021 mark.hamzy 1.24 if (id == NULL)
4022 {
4023 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl));
|
4024 mark.hamzy 1.43
4025 PEG_METHOD_EXIT();
4026
4027 STAT_COPYDISPATCHER
4028
4029 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4030 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
4031 "Could not find a method for the provider based on InterfaceType."));
|
4032 mark.hamzy 1.23 }
|
4033 mark.hamzy 1.24
|
4034 schuur 1.1 JMPIjvm::checkException(env);
4035
|
4036 mark.hamzy 1.24 switch (eMethodFound)
4037 {
|
4038 mark.hamzy 1.43 case METHOD_CIMASSOCIATORPROVIDER:
4039 {
4040 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
4041 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4042
4043 JMPIjvm::checkException(env);
4044
4045 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4046 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4047
4048 JMPIjvm::checkException(env);
4049
4050 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
4051 jstring jRole = env->NewStringUTF(request->role.getCString());
4052 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
4053
4054 JMPIjvm::checkException(env);
4055
4056 #ifdef PEGASUS_DEBUG
4057 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
4058 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
4059 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4060 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
4061 #endif
4062
|
4063 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
4064 mark.hamzy 1.43 id,
4065 jAssociationName,
4066 jPathName,
4067 jResultClass,
4068 jRole,
4069 jResultRole);
4070
4071 JMPIjvm::checkException(env);
4072
4073 STAT_PMS_PROVIDEREND;
4074
4075 handler.processing();
|
4076 mark.hamzy 1.45 if (jAr) {
4077 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4078 mark.hamzy 1.43 JMPIjvm::checkException(env);
4079
|
4080 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
4081 mark.hamzy 1.43
4082 JMPIjvm::checkException(env);
4083
4084 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
4085 mark.hamzy 1.50 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
4086 mark.hamzy 1.43
4087 JMPIjvm::checkException(env);
4088
4089 handler.deliver(*copRet);
4090 }
4091 }
4092 handler.complete();
4093 break;
4094 }
4095
4096 case METHOD_CIMASSOCIATORPROVIDER2:
|
4097 mark.hamzy 1.24 {
|
4098 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
4099 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
|
4100 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
4101 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4102
4103 JMPIjvm::checkException(env);
4104
|
4105 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4106 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4107
4108 JMPIjvm::checkException(env);
4109
|
4110 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
4111 jstring jRole = env->NewStringUTF(request->role.getCString());
4112 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
4113
4114 JMPIjvm::checkException(env);
4115
|
4116 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
4117 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
4118 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
4119 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4120 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
4121 #endif
4122
|
4123 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
4124 mark.hamzy 1.24 id,
|
4125 mark.hamzy 1.43 joc,
|
4126 mark.hamzy 1.24 jAssociationName,
|
4127 mark.hamzy 1.43 jPathName,
|
4128 mark.hamzy 1.24 jResultClass,
4129 jRole,
4130 jResultRole);
|
4131 mark.hamzy 1.25
|
4132 mark.hamzy 1.23 JMPIjvm::checkException(env);
4133
4134 STAT_PMS_PROVIDEREND;
4135
|
4136 mark.hamzy 1.43 if (joc)
4137 {
4138 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
4139
4140 JMPIjvm::checkException(env);
4141 }
4142
|
4143 mark.hamzy 1.23 handler.processing();
|
4144 mark.hamzy 1.45 if (jAr) {
4145 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4146 mark.hamzy 1.23 JMPIjvm::checkException(env);
4147
|
4148 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
4149 mark.hamzy 1.24
|
4150 mark.hamzy 1.23 JMPIjvm::checkException(env);
4151
|
4152 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
4153 mark.hamzy 1.50 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
4154 mark.hamzy 1.23
4155 JMPIjvm::checkException(env);
4156
|
4157 mark.hamzy 1.29 handler.deliver(*copRet);
|
4158 mark.hamzy 1.23 }
4159 }
4160 handler.complete();
|
4161 mark.hamzy 1.24 break;
|
4162 mark.hamzy 1.23 }
|
4163 mark.hamzy 1.24
|
4164 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
4165 {
4166 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
4167 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4168
4169 JMPIjvm::checkException(env);
4170
4171 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4172 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4173
4174 JMPIjvm::checkException(env);
4175
4176 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
4177 jstring jRole = env->NewStringUTF(request->role.getCString());
4178 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
4179
4180 JMPIjvm::checkException(env);
4181
4182 #ifdef PEGASUS_DEBUG
4183 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
4184 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
4185 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
4186 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4187 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
4188 #endif
4189
4190 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
4191 id,
4192 jAssociationName,
4193 jPathName,
4194 jResultClass,
4195 jRole,
4196 jResultRole);
4197
4198 JMPIjvm::checkException(env);
4199
4200 STAT_PMS_PROVIDEREND;
4201
4202 handler.processing();
4203 if (jVec) {
4204 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
4205 JMPIjvm::checkException(env);
4206 mark.hamzy 1.43
4207 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
4208
4209 JMPIjvm::checkException(env);
4210
4211 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
4212 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
4213
4214 JMPIjvm::checkException(env);
4215
4216 handler.deliver(*copRet);
4217 }
4218 }
4219 handler.complete();
4220 break;
4221 }
4222
4223 case METHOD_ASSOCIATORPROVIDER2:
|
4224 mark.hamzy 1.24 {
|
4225 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
4226 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
4227
|
4228 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
4229 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4230
4231 JMPIjvm::checkException(env);
4232
|
4233 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
4234 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4235
4236 JMPIjvm::checkException(env);
4237
|
4238 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
4239 jstring jRole = env->NewStringUTF(request->role.getCString());
4240 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
4241
4242 JMPIjvm::checkException(env);
4243
|
4244 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
4245 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
4246 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
4247 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
4248 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4249 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
4250 #endif
4251
|
4252 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
4253 id,
|
4254 mark.hamzy 1.43 joc,
|
4255 mark.hamzy 1.24 jAssociationName,
|
4256 mark.hamzy 1.29 jPathName,
|
4257 mark.hamzy 1.24 jResultClass,
4258 jRole,
4259 jResultRole);
|
4260 mark.hamzy 1.25
|
4261 mark.hamzy 1.23 JMPIjvm::checkException(env);
4262
4263 STAT_PMS_PROVIDEREND;
|
4264 schuur 1.13
|
4265 mark.hamzy 1.43 if (joc)
4266 {
4267 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
4268
4269 JMPIjvm::checkException(env);
4270 }
4271
|
4272 mark.hamzy 1.23 handler.processing();
|
4273 mark.hamzy 1.24 if (jVec) {
|
4274 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
4275 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4276 schuur 1.13
|
4277 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
4278 mark.hamzy 1.24
|
4279 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4280 schuur 1.13
|
4281 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
4282 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
4283 schuur 1.1
|
4284 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4285 schuur 1.1
|
4286 mark.hamzy 1.29 handler.deliver(*copRet);
|
4287 mark.hamzy 1.23 }
4288 }
4289 handler.complete();
|
4290 mark.hamzy 1.24 break;
4291 }
4292
4293 case METHOD_UNKNOWN:
4294 {
4295 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: should not be here!"<<PEGASUS_STD(endl));
4296 break;
4297 }
|
4298 mark.hamzy 1.23 }
|
4299 schuur 1.1 }
4300 HandlerCatch(handler);
|
4301 schuur 1.12
|
4302 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
|
4303 schuur 1.12
|
4304 schuur 1.1 PEG_METHOD_EXIT();
4305
|
4306 w.white 1.31 STAT_COPYDISPATCHER
4307
|
4308 schuur 1.1 return(response);
4309 }
4310
4311 Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw()
4312 {
|
4313 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest");
4314
4315 HandlerIntro(References,message,request,response,handler,Array<CIMObject>());
|
4316 schuur 1.1
|
4317 mark.hamzy 1.24 typedef enum {
4318 METHOD_UNKNOWN = 0,
|
4319 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
4320 METHOD_CIMASSOCIATORPROVIDER2,
4321 METHOD_ASSOCIATORPROVIDER,
4322 METHOD_ASSOCIATORPROVIDER2,
|
4323 mark.hamzy 1.24 } METHOD_VERSION;
4324 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
4325 JNIEnv *env = NULL;
|
4326 schuur 1.13
|
4327 schuur 1.1 try {
4328 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
4329 konrad.r 1.15 "JMPIProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",
|
4330 schuur 1.1 System::getHostName(),
4331 request->nameSpace.getString(),
4332 request->objectName.getClassName().getString());
4333
|
4334 mark.hamzy 1.29 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<", result = "<<request->resultClass.getString()<<PEGASUS_STD(endl));
|
4335 mark.hamzy 1.23
|
4336 schuur 1.1 // make target object path
|
4337 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
4338 request->nameSpace,
4339 request->objectName.getClassName(),
4340 request->objectName.getKeyBindings());
4341 CIMObjectPath *resultPath = new CIMObjectPath (System::getHostName(),
4342 request->nameSpace,
4343 request->resultClass.getString());
|
4344 schuur 1.1
4345 // resolve provider name
|
4346 kumpf 1.2 ProviderName name = _resolveProviderName(
4347 request->operationContext.get(ProviderIdContainer::NAME));
|
4348 schuur 1.1
|
4349 mark.hamzy 1.43 // get cached or load new provider module
4350 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
4351 name.getLogicalName(),
4352 String::EMPTY);
4353
4354 // convert arguments
4355 OperationContext context;
4356
4357 context.insert(request->operationContext.get(IdentityContainer::NAME));
4358 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
4359 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
4360
4361 // forward request
4362 JMPIProvider &pr = ph.GetProvider();
4363
4364 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.references: " + pr.getName());
4365
4366 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Calling provider references: "<<pr.getName()<<", role: "<<request->role<<" aCls: "<<request->resultClass<<PEGASUS_STD(endl));
4367
4368 JvmVector *jv = 0;
4369
4370 mark.hamzy 1.43 env = JMPIjvm::attachThread(&jv);
4371
4372 if (!env)
4373 {
4374 PEG_METHOD_EXIT();
4375
4376 STAT_COPYDISPATCHER
4377
4378 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4379 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
4380 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
4381 }
4382
4383 JMPIProvider::pm_service_op_lock op_lock(&pr);
4384
4385 STAT_GETSTARTTIME;
4386
4387 jmethodID id = NULL;
4388 String interfaceType;
4389 String interfaceVersion;
4390
4391 mark.hamzy 1.43 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
4392 interfaceType,
4393 interfaceVersion);
4394
4395 if (interfaceType == "JMPI")
4396 {
4397 // public java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,
4398 // org.pegasus.jmpi.CIMObjectPath pathName,
4399 // java.lang.String role,
4400 // boolean includeQualifiers,
4401 // boolean includeClassOrigin,
4402 // java.lang.String[] propertyList)
4403 // throws org.pegasus.jmpi.CIMException
4404 id = env->GetMethodID((jclass)pr.jProviderClass,
4405 "references",
4406 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
4407
4408 if (id != NULL)
4409 {
4410 eMethodFound = METHOD_ASSOCIATORPROVIDER;
4411 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
4412 mark.hamzy 1.43 }
4413
4414 if (id == NULL)
4415 {
4416 env->ExceptionClear();
4417
4418 // public org.pegasus.jmpi.CIMInstance[] references (org.pegasus.jmpi.CIMObjectPath assocName,
4419 // org.pegasus.jmpi.CIMObjectPath pathName,
4420 // java.lang.String role,
4421 // boolean includeQualifiers,
4422 // boolean includeClassOrigin,
4423 // java.lang.String[] propertyList)
4424 // throws org.pegasus.jmpi.CIMException
4425 id = env->GetMethodID((jclass)pr.jProviderClass,
4426 "references",
4427 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
4428
4429 if (id != NULL)
4430 {
4431 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
4432 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
4433 mark.hamzy 1.43 }
4434 }
4435 }
4436 else if (interfaceType == "JMPIExperimental")
4437 {
4438 // public java.util.Vector references (org.pegasus.jmpi.OperationContext oc,
4439 // org.pegasus.jmpi.CIMObjectPath assocName,
4440 // org.pegasus.jmpi.CIMObjectPath pathName,
4441 // java.lang.String role,
4442 // boolean includeQualifiers,
4443 // boolean includeClassOrigin,
4444 // java.lang.String[] propertyList)
4445 // throws org.pegasus.jmpi.CIMException
4446 id = env->GetMethodID((jclass)pr.jProviderClass,
4447 "references",
|
4448 mark.hamzy 1.46 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
4449 mark.hamzy 1.43
4450 if (id != NULL)
4451 {
4452 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
4453 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
4454 }
4455
4456 if (id == NULL)
4457 {
4458 env->ExceptionClear();
4459
4460 // public org.pegasus.jmpi.CIMInstance[] references (org.pegasus.jmpi.OperationContext oc,
4461 // org.pegasus.jmpi.CIMObjectPath assocName,
4462 // org.pegasus.jmpi.CIMObjectPath pathName,
4463 // java.lang.String role,
4464 // boolean includeQualifiers,
4465 // boolean includeClassOrigin,
4466 // java.lang.String[] propertyList)
4467 // throws org.pegasus.jmpi.CIMException
4468 id = env->GetMethodID((jclass)pr.jProviderClass,
4469 "references",
4470 mark.hamzy 1.43 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
4471
4472 if (id != NULL)
4473 {
4474 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
4475 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
4476 }
4477 }
4478 }
4479
4480 if (id == NULL)
4481 {
4482 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found no method!"<<PEGASUS_STD(endl));
4483
4484 PEG_METHOD_EXIT();
4485
4486 STAT_COPYDISPATCHER
4487
4488 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4489 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
4490 "Could not find a method for the provider based on InterfaceType."));
4491 mark.hamzy 1.43 }
4492
4493 JMPIjvm::checkException(env);
4494
4495 switch (eMethodFound)
4496 {
4497 case METHOD_CIMASSOCIATORPROVIDER:
4498 {
4499 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
4500 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4501
4502 JMPIjvm::checkException(env);
4503
4504 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4505 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4506
4507 JMPIjvm::checkException(env);
4508
4509 jstring jRole = env->NewStringUTF(request->role.getCString());
4510
4511 JMPIjvm::checkException(env);
4512 mark.hamzy 1.43
4513 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
4514
4515 #ifdef PEGASUS_DEBUG
4516 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
4517 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4518 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
4519 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
4520 #endif
4521
|
4522 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
4523 mark.hamzy 1.43 id,
4524 jAssociationName,
4525 jPathName,
4526 jRole,
4527 JMPI_INCLUDE_QUALIFIERS,
4528 request->includeClassOrigin,
4529 jPropertyList);
4530
4531 JMPIjvm::checkException(env);
4532
4533 STAT_PMS_PROVIDEREND;
4534
4535 handler.processing();
|
4536 mark.hamzy 1.45 if (jAr) {
4537 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4538 mark.hamzy 1.43 JMPIjvm::checkException(env);
4539
|
4540 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
4541 mark.hamzy 1.43
4542 JMPIjvm::checkException(env);
4543
4544 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
4545
4546 JMPIjvm::checkException(env);
4547
4548 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
4549 CIMClass cls;
4550
4551 try
4552 {
4553 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4554 AutoMutex lock (pr._cimomMutex);
4555
4556 cls = pr._cimom_handle->getClass(context,
4557 request->nameSpace,
4558 ciRet->getClassName(),
4559 false,
4560 true,
4561 true,
4562 mark.hamzy 1.43 CIMPropertyList());
4563 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4564 }
4565 catch (CIMException e)
4566 {
4567 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
4568 throw;
4569 }
4570
4571 const CIMObjectPath& op = ciRet->getPath();
4572 CIMObjectPath iop = ciRet->buildPath(cls);
4573
4574 JMPIjvm::checkException(env);
4575
4576 iop.setNameSpace(op.getNameSpace());
4577 ciRet->setPath(iop);
4578
4579 handler.deliver(*ciRet);
4580 }
4581 }
4582 handler.complete();
4583 mark.hamzy 1.43 break;
4584 }
4585
4586 case METHOD_CIMASSOCIATORPROVIDER2:
4587 {
4588 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
4589 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
4590
4591 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
4592 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4593
4594 JMPIjvm::checkException(env);
4595
4596 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4597 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4598
4599 JMPIjvm::checkException(env);
4600
4601 jstring jRole = env->NewStringUTF(request->role.getCString());
4602
4603 JMPIjvm::checkException(env);
4604 mark.hamzy 1.43
4605 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
4606 schuur 1.1
|
4607 mark.hamzy 1.43 #ifdef PEGASUS_DEBUG
4608 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
4609 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4610 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
4611 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
4612 #endif
|
4613 schuur 1.1
|
4614 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
4615 mark.hamzy 1.43 id,
4616 joc,
4617 jAssociationName,
4618 jPathName,
4619 jRole,
4620 JMPI_INCLUDE_QUALIFIERS,
4621 request->includeClassOrigin,
4622 jPropertyList);
|
4623 schuur 1.1
|
4624 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4625 mark.hamzy 1.24
|
4626 mark.hamzy 1.43 STAT_PMS_PROVIDEREND;
|
4627 schuur 1.1
|
4628 mark.hamzy 1.43 if (joc)
4629 {
4630 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
|
4631 schuur 1.1
|
4632 mark.hamzy 1.43 JMPIjvm::checkException(env);
4633 }
|
4634 schuur 1.1
|
4635 mark.hamzy 1.43 handler.processing();
|
4636 mark.hamzy 1.45 if (jAr) {
4637 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4638 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4639 schuur 1.1
|
4640 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
4641 mark.hamzy 1.37
|
4642 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4643 mark.hamzy 1.37
|
4644 mark.hamzy 1.43 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
4645 mark.hamzy 1.37
|
4646 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4647 schuur 1.1
|
4648 mark.hamzy 1.43 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
4649 CIMClass cls;
|
4650 schuur 1.1
|
4651 mark.hamzy 1.43 try
4652 {
4653 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4654 AutoMutex lock (pr._cimomMutex);
|
4655 mark.hamzy 1.24
|
4656 mark.hamzy 1.43 cls = pr._cimom_handle->getClass(context,
4657 request->nameSpace,
4658 ciRet->getClassName(),
4659 false,
4660 true,
4661 true,
4662 CIMPropertyList());
4663 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4664 }
4665 catch (CIMException e)
4666 {
4667 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
4668 throw;
4669 }
|
4670 mark.hamzy 1.24
|
4671 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
4672 CIMObjectPath iop = ciRet->buildPath(cls);
|
4673 mark.hamzy 1.24
|
4674 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4675 mark.hamzy 1.24
|
4676 mark.hamzy 1.43 iop.setNameSpace(op.getNameSpace());
4677 ciRet->setPath(iop);
|
4678 mark.hamzy 1.24
|
4679 mark.hamzy 1.43 handler.deliver(*ciRet);
4680 }
|
4681 mark.hamzy 1.24 }
|
4682 mark.hamzy 1.43 handler.complete();
4683 break;
|
4684 mark.hamzy 1.24 }
|
4685 schuur 1.12
|
4686 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
|
4687 mark.hamzy 1.24 {
|
4688 mark.hamzy 1.43 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
4689 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
4690 mark.hamzy 1.24
|
4691 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4692 schuur 1.1
|
4693 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4694 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
|
4695 mark.hamzy 1.25
4696 JMPIjvm::checkException(env);
4697
4698 jstring jRole = env->NewStringUTF(request->role.getCString());
4699
4700 JMPIjvm::checkException(env);
4701
4702 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
4703
|
4704 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
4705 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
|
4706 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
4707 mark.hamzy 1.29 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4708 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
4709 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
4710 #endif
4711
|
4712 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
4713 id,
4714 jAssociationName,
|
4715 mark.hamzy 1.43 jPathName,
|
4716 mark.hamzy 1.24 jRole,
|
4717 mark.hamzy 1.36 JMPI_INCLUDE_QUALIFIERS,
4718 request->includeClassOrigin,
|
4719 mark.hamzy 1.24 jPropertyList);
|
4720 mark.hamzy 1.25
|
4721 mark.hamzy 1.23 JMPIjvm::checkException(env);
4722
4723 STAT_PMS_PROVIDEREND;
4724
4725 handler.processing();
4726 if (jVec) {
|
4727 mark.hamzy 1.43 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
4728 mark.hamzy 1.23 JMPIjvm::checkException(env);
4729
|
4730 mark.hamzy 1.43 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
4731 mark.hamzy 1.24
|
4732 mark.hamzy 1.23 JMPIjvm::checkException(env);
4733
|
4734 mark.hamzy 1.43 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
4735 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
4736 mark.hamzy 1.40 CIMClass cls;
4737
4738 try
4739 {
4740 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4741 AutoMutex lock (pr._cimomMutex);
4742
4743 cls = pr._cimom_handle->getClass(context,
4744 request->nameSpace,
4745 ciRet->getClassName(),
4746 false,
4747 true,
4748 true,
4749 CIMPropertyList());
4750 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4751 }
4752 catch (CIMException e)
4753 {
4754 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
4755 throw;
4756 }
4757 mark.hamzy 1.40
|
4758 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
4759 CIMObjectPath iop = ciRet->buildPath(cls);
|
4760 mark.hamzy 1.24
|
4761 mark.hamzy 1.27 JMPIjvm::checkException(env);
4762
|
4763 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
4764 mark.hamzy 1.29 ciRet->setPath(iop);
|
4765 schuur 1.13
|
4766 mark.hamzy 1.29 handler.deliver(*ciRet);
|
4767 mark.hamzy 1.23 }
4768 }
4769 handler.complete();
|
4770 mark.hamzy 1.24 break;
|
4771 mark.hamzy 1.23 }
|
4772 schuur 1.1
|
4773 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
4774 mark.hamzy 1.24 {
|
4775 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
4776 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
4777
|
4778 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
4779 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4780
4781 JMPIjvm::checkException(env);
4782
|
4783 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
4784 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4785
4786 JMPIjvm::checkException(env);
4787
|
4788 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
4789
4790 JMPIjvm::checkException(env);
4791
4792 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
4793
|
4794 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
4795 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
4796 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
4797 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4798 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
4799 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
4800 #endif
4801
|
4802 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
4803 id,
|
4804 mark.hamzy 1.43 joc,
|
4805 mark.hamzy 1.24 jAssociationName,
4806 jPathName,
4807 jRole,
|
4808 mark.hamzy 1.32 JMPI_INCLUDE_QUALIFIERS,
4809 request->includeClassOrigin,
|
4810 mark.hamzy 1.24 jPropertyList);
|
4811 mark.hamzy 1.25
|
4812 mark.hamzy 1.24 JMPIjvm::checkException(env);
4813
4814 STAT_PMS_PROVIDEREND;
4815
|
4816 mark.hamzy 1.43 if (joc)
4817 {
4818 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
4819
4820 JMPIjvm::checkException(env);
4821 }
4822
|
4823 mark.hamzy 1.24 handler.processing();
4824 if (jVec) {
|
4825 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
4826 mark.hamzy 1.24 JMPIjvm::checkException(env);
4827
|
4828 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
4829 mark.hamzy 1.24
4830 JMPIjvm::checkException(env);
4831
|
4832 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
4833 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
4834 mark.hamzy 1.40 CIMClass cls;
4835
4836 try
4837 {
4838 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4839 AutoMutex lock (pr._cimomMutex);
4840
4841 cls = pr._cimom_handle->getClass(context,
4842 request->nameSpace,
4843 ciRet->getClassName(),
4844 false,
4845 true,
4846 true,
4847 CIMPropertyList());
4848 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4849 }
4850 catch (CIMException e)
4851 {
4852 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
4853 throw;
4854 }
4855 mark.hamzy 1.40
|
4856 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
4857 CIMObjectPath iop = ciRet->buildPath(cls);
|
4858 schuur 1.1
|
4859 mark.hamzy 1.27 JMPIjvm::checkException(env);
4860
|
4861 mark.hamzy 1.24 iop.setNameSpace(op.getNameSpace());
|
4862 mark.hamzy 1.29 ciRet->setPath(iop);
|
4863 schuur 1.12
|
4864 mark.hamzy 1.29 handler.deliver(*ciRet);
|
4865 mark.hamzy 1.24 }
4866 }
4867 handler.complete();
4868 break;
4869 }
|
4870 mark.hamzy 1.23
|
4871 mark.hamzy 1.24 case METHOD_UNKNOWN:
4872 {
|
4873 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: should not be here!"<<PEGASUS_STD(endl));
|
4874 mark.hamzy 1.24 break;
4875 }
|
4876 mark.hamzy 1.23 }
|
4877 schuur 1.1 }
4878 HandlerCatch(handler);
|
4879 schuur 1.12
4880 if (env) JMPIjvm::detachThread();
4881
|
4882 schuur 1.1 PEG_METHOD_EXIT();
4883
|
4884 w.white 1.31 STAT_COPYDISPATCHER
4885
|
4886 schuur 1.1 return(response);
4887 }
4888
4889 Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw()
4890 {
|
4891 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest");
4892
4893 HandlerIntro(ReferenceNames,message,request,response,handler,Array<CIMObjectPath>());
|
4894 schuur 1.1
|
4895 mark.hamzy 1.24 typedef enum {
4896 METHOD_UNKNOWN = 0,
|
4897 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
4898 METHOD_CIMASSOCIATORPROVIDER2,
4899 METHOD_ASSOCIATORPROVIDER,
4900 METHOD_ASSOCIATORPROVIDER2,
|
4901 mark.hamzy 1.24 } METHOD_VERSION;
4902 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
4903 JNIEnv *env = NULL;
|
4904 schuur 1.13
|
4905 schuur 1.1 try {
4906 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
4907 "JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
4908 System::getHostName(),
4909 request->nameSpace.getString(),
4910 request->objectName.getClassName().getString());
4911
|
4912 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl));
4913
|
4914 schuur 1.1 // make target object path
|
4915 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
4916 request->nameSpace,
4917 request->objectName.getClassName(),
4918 request->objectName.getKeyBindings());
4919 CIMObjectPath *resultPath = new CIMObjectPath (System::getHostName(),
4920 request->nameSpace,
4921 request->resultClass.getString());
|
4922 schuur 1.1
4923 // resolve provider name
|
4924 kumpf 1.2 ProviderName name = _resolveProviderName(
4925 request->operationContext.get(ProviderIdContainer::NAME));
|
4926 schuur 1.1
4927 // get cached or load new provider module
|
4928 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
4929 name.getLogicalName(),
4930 String::EMPTY);
|
4931 schuur 1.1
|
4932 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
4933 schuur 1.1
|
4934 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.referenceNames: " + pr.getName());
|
4935 schuur 1.1
|
4936 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: Calling provider referenceNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->resultClass<<PEGASUS_STD(endl));
|
4937 schuur 1.12
|
4938 mark.hamzy 1.24 JvmVector *jv = 0;
4939
4940 env = JMPIjvm::attachThread(&jv);
|
4941 schuur 1.1
|
4942 mark.hamzy 1.37 if (!env)
4943 {
4944 PEG_METHOD_EXIT();
4945
4946 STAT_COPYDISPATCHER
4947
4948 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4949 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
4950 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
4951 }
4952
|
4953 mark.hamzy 1.43 JMPIProvider::pm_service_op_lock op_lock(&pr);
4954
4955 STAT_GETSTARTTIME;
4956
4957 jmethodID id = NULL;
4958 String interfaceType;
4959 String interfaceVersion;
4960
4961 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
4962 interfaceType,
4963 interfaceVersion);
4964
4965 if (interfaceType == "JMPI")
4966 {
4967 // public java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
4968 // org.pegasus.jmpi.CIMObjectPath pathName,
4969 // java.lang.String role)
4970 // throws org.pegasus.jmpi.CIMException
4971 id = env->GetMethodID((jclass)pr.jProviderClass,
4972 "referenceNames",
4973 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
4974 mark.hamzy 1.43
4975 if (id != NULL)
4976 {
4977 eMethodFound = METHOD_ASSOCIATORPROVIDER;
4978 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
4979 }
4980
4981 if (id == NULL)
4982 {
4983 env->ExceptionClear();
4984
4985 // public org.pegasus.jmpi.CIMObjectPath[] referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
4986 // org.pegasus.jmpi.CIMObjectPath pathName,
4987 // java.lang.String role)
4988 // throws org.pegasus.jmpi.CIMException
4989 id = env->GetMethodID((jclass)pr.jProviderClass,
4990 "referenceNames",
4991 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
4992
4993 if (id != NULL)
4994 {
4995 mark.hamzy 1.43 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
4996 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
4997 }
4998 }
4999 }
5000 else if (interfaceType == "JMPIExperimental")
5001 {
5002 // public java.util.Vector referenceNames (org.pegasus.jmpi.OperationContext oc,
5003 // org.pegasus.jmpi.CIMObjectPath assocName,
5004 // org.pegasus.jmpi.CIMObjectPath pathName,
5005 // java.lang.String role)
5006 // throws org.pegasus.jmpi.CIMException
5007 id = env->GetMethodID((jclass)pr.jProviderClass,
5008 "referenceNames",
5009 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
5010
5011 if (id != NULL)
5012 {
5013 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
5014 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
5015 }
5016 mark.hamzy 1.43
5017 if (id == NULL)
5018 {
5019 env->ExceptionClear();
5020
5021 // public org.pegasus.jmpi.CIMObjectPath[] referenceNames (org.pegasus.jmpi.OperationContext oc,
5022 // org.pegasus.jmpi.CIMObjectPath assocName,
5023 // org.pegasus.jmpi.CIMObjectPath pathName,
5024 // java.lang.String role)
5025 // throws org.pegasus.jmpi.CIMException
5026 id = env->GetMethodID((jclass)pr.jProviderClass,
5027 "referenceNames",
5028 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
5029
5030 if (id != NULL)
5031 {
5032 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
5033 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
5034 }
5035 }
5036 }
5037 mark.hamzy 1.43
5038 if (id == NULL)
5039 {
5040 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found no method!"<<PEGASUS_STD(endl));
5041
5042 PEG_METHOD_EXIT();
5043
5044 STAT_COPYDISPATCHER
5045
5046 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5047 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
5048 "Could not find a method for the provider based on InterfaceType."));
5049 }
5050
5051 JMPIjvm::checkException(env);
5052
5053 switch (eMethodFound)
5054 {
5055 case METHOD_CIMASSOCIATORPROVIDER:
5056 {
5057 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
5058 mark.hamzy 1.43 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
5059
5060 JMPIjvm::checkException(env);
5061
5062 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5063 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
5064
5065 JMPIjvm::checkException(env);
5066
5067 jstring jRole = env->NewStringUTF(request->role.getCString());
5068
5069 JMPIjvm::checkException(env);
5070
5071 #ifdef PEGASUS_DEBUG
5072 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
5073 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
5074 #endif
5075
|
5076 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
5077 mark.hamzy 1.43 id,
5078 jPathName,
5079 jAssociationName,
5080 jRole);
5081
5082 JMPIjvm::checkException(env);
5083
5084 STAT_PMS_PROVIDEREND;
5085
5086 handler.processing();
|
5087 mark.hamzy 1.45 if (jAr) {
5088 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
5089 mark.hamzy 1.43 JMPIjvm::checkException(env);
5090
|
5091 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
5092 mark.hamzy 1.43
5093 JMPIjvm::checkException(env);
5094
5095 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
5096
5097 JMPIjvm::checkException(env);
5098
5099 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
5100
5101 handler.deliver(*copRet);
5102 }
5103 }
5104 handler.complete();
5105 break;
5106 }
5107
5108 case METHOD_CIMASSOCIATORPROVIDER2:
5109 {
5110 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
5111 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
5112
5113 mark.hamzy 1.43 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
5114 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
5115
5116 JMPIjvm::checkException(env);
5117
5118 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5119 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
5120
5121 JMPIjvm::checkException(env);
5122
5123 jstring jRole = env->NewStringUTF(request->role.getCString());
5124
5125 JMPIjvm::checkException(env);
5126
5127 #ifdef PEGASUS_DEBUG
5128 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
5129 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
5130 #endif
5131
|
5132 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
5133 mark.hamzy 1.43 id,
5134 joc,
5135 jPathName,
5136 jAssociationName,
5137 jRole);
5138
5139 JMPIjvm::checkException(env);
5140
5141 STAT_PMS_PROVIDEREND;
5142
5143 if (joc)
5144 {
5145 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
5146
5147 JMPIjvm::checkException(env);
5148 }
5149
5150 handler.processing();
|
5151 mark.hamzy 1.45 if (jAr) {
5152 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
5153 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5154 schuur 1.1
|
5155 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
5156 schuur 1.1
|
5157 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5158 mark.hamzy 1.24
|
5159 mark.hamzy 1.43 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
5160 mark.hamzy 1.24
|
5161 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5162 mark.hamzy 1.24
|
5163 mark.hamzy 1.43 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
5164 mark.hamzy 1.24
|
5165 mark.hamzy 1.43 handler.deliver(*copRet);
5166 }
|
5167 mark.hamzy 1.24 }
|
5168 mark.hamzy 1.43 handler.complete();
5169 break;
|
5170 mark.hamzy 1.24 }
|
5171 schuur 1.11
|
5172 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
|
5173 mark.hamzy 1.24 {
|
5174 mark.hamzy 1.43 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
5175 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
5176 mark.hamzy 1.24
|
5177 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5178 schuur 1.1
|
5179 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5180 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
|
5181 mark.hamzy 1.25
5182 JMPIjvm::checkException(env);
5183
5184 jstring jRole = env->NewStringUTF(request->role.getCString());
5185
5186 JMPIjvm::checkException(env);
5187
|
5188 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
5189 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
5190 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
|
5191 mark.hamzy 1.29 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
5192 #endif
5193
|
5194 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
5195 id,
5196 jAssociationName,
|
5197 mark.hamzy 1.43 jPathName,
|
5198 mark.hamzy 1.24 jRole);
|
5199 mark.hamzy 1.25
|
5200 mark.hamzy 1.23 JMPIjvm::checkException(env);
5201
5202 STAT_PMS_PROVIDEREND;
5203
5204 handler.processing();
5205 if (jVec) {
|
5206 mark.hamzy 1.43 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
5207 mark.hamzy 1.23 JMPIjvm::checkException(env);
5208
|
5209 mark.hamzy 1.43 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
5210 mark.hamzy 1.24
|
5211 mark.hamzy 1.23 JMPIjvm::checkException(env);
5212
|
5213 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
5214 mark.hamzy 1.23
5215 JMPIjvm::checkException(env);
5216
|
5217 mark.hamzy 1.29 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
5218 mark.hamzy 1.24
|
5219 mark.hamzy 1.29 handler.deliver(*copRet);
|
5220 mark.hamzy 1.23 }
5221 }
5222 handler.complete();
|
5223 mark.hamzy 1.24 break;
|
5224 mark.hamzy 1.23 }
|
5225 mark.hamzy 1.24
|
5226 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
5227 mark.hamzy 1.24 {
|
5228 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
5229 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
5230
|
5231 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
5232 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
5233
5234 JMPIjvm::checkException(env);
5235
|
5236 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
5237 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
5238
5239 JMPIjvm::checkException(env);
5240
|
5241 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
5242
5243 JMPIjvm::checkException(env);
5244
|
5245 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
5246 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
5247 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
5248 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
5249 #endif
5250
|
5251 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
5252 id,
|
5253 mark.hamzy 1.43 joc,
|
5254 mark.hamzy 1.24 jAssociationName,
5255 jPathName,
5256 jRole);
|
5257 mark.hamzy 1.25
|
5258 mark.hamzy 1.23 JMPIjvm::checkException(env);
5259
5260 STAT_PMS_PROVIDEREND;
|
5261 schuur 1.13
|
5262 mark.hamzy 1.43 if (joc)
5263 {
5264 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
5265
5266 JMPIjvm::checkException(env);
5267 }
5268
|
5269 mark.hamzy 1.23 handler.processing();
|
5270 mark.hamzy 1.24 if (jVec) {
|
5271 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
5272 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
5273 schuur 1.13
|
5274 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
5275 mark.hamzy 1.24
|
5276 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
5277 schuur 1.13
|
5278 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
5279 schuur 1.1
|
5280 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
5281 schuur 1.1
|
5282 mark.hamzy 1.29 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
5283 mark.hamzy 1.24
|
5284 mark.hamzy 1.29 handler.deliver(*copRet);
|
5285 mark.hamzy 1.23 }
5286 }
5287 handler.complete();
|
5288 mark.hamzy 1.24 break;
5289 }
5290
5291 case METHOD_UNKNOWN:
5292 {
|
5293 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: should not be here!"<<PEGASUS_STD(endl));
|
5294 mark.hamzy 1.24 break;
5295 }
|
5296 mark.hamzy 1.23 }
|
5297 schuur 1.1 }
5298 HandlerCatch(handler);
|
5299 schuur 1.11
5300 if (env) JMPIjvm::detachThread();
5301
|
5302 schuur 1.1 PEG_METHOD_EXIT();
5303
|
5304 w.white 1.31 STAT_COPYDISPATCHER
5305
|
5306 schuur 1.1 return(response);
5307 }
5308
|
5309 mark.hamzy 1.26 Message * JMPIProviderManager::handleGetPropertyRequest(const Message * message) throw()
5310 {
5311 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetPropertyRequest");
5312
5313 HandlerIntro(GetProperty,message,request,response,handler,CIMValue());
5314
5315 typedef enum {
5316 METHOD_UNKNOWN = 0,
|
5317 mark.hamzy 1.43 METHOD_PROPERTYPROVIDER,
5318 METHOD_PROPERTYPROVIDER2,
|
5319 mark.hamzy 1.26 } METHOD_VERSION;
5320 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
5321 JNIEnv *env = NULL;
5322
5323 try {
5324 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
5325 "JMPIProviderManager::handleGetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
5326 System::getHostName(),
5327 request->nameSpace.getString(),
5328 request->instanceName.getClassName().getString());
5329
5330 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
5331
5332 // make target object path
|
5333 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
5334 request->nameSpace,
5335 request->instanceName.getClassName(),
5336 request->instanceName.getKeyBindings());
|
5337 mark.hamzy 1.26
5338 // resolve provider name
5339 ProviderName name = _resolveProviderName(
5340 request->operationContext.get(ProviderIdContainer::NAME));
5341
5342 // get cached or load new provider module
|
5343 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
5344 name.getLogicalName(),
5345 String::EMPTY);
|
5346 mark.hamzy 1.26
5347 // forward request
5348 JMPIProvider &pr = ph.GetProvider();
5349
5350 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.getPropertyValue: " + pr.getName());
5351
5352 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: Calling provider getPropertyValue: "<<pr.getName()<<PEGASUS_STD(endl));
5353
5354 JvmVector *jv = 0;
5355
5356 env = JMPIjvm::attachThread(&jv);
5357
|
5358 mark.hamzy 1.37 if (!env)
5359 {
5360 PEG_METHOD_EXIT();
5361
5362 STAT_COPYDISPATCHER
5363
5364 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5365 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
5366 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
5367 }
5368
|
5369 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
5370
5371 STAT_GETSTARTTIME;
5372
|
5373 mark.hamzy 1.43 jmethodID id = NULL;
5374 String interfaceType;
5375 String interfaceVersion;
5376
5377 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
5378 interfaceType,
5379 interfaceVersion);
5380
5381 if (interfaceType == "JMPI")
5382 {
5383 // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
5384 // java.lang.String oclass,
5385 // java.lang.String pName)
5386 // throws org.pegasus.jmpi.CIMException
5387 //
5388 id = env->GetMethodID((jclass)pr.jProviderClass,
5389 "getPropertyValue",
5390 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
|
5391 mark.hamzy 1.26
|
5392 mark.hamzy 1.43 if (id != NULL)
5393 {
5394 eMethodFound = METHOD_PROPERTYPROVIDER;
5395 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_PROPERTYPROVIDER."<<PEGASUS_STD(endl));
5396 }
5397 }
5398 else if (interfaceType == "JMPIExperimental")
5399 {
5400 // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.OperationContext oc,
5401 // org.pegasus.jmpi.CIMObjectPath cop,
5402 // java.lang.String oclass,
5403 // java.lang.String pName)
5404 // throws org.pegasus.jmpi.CIMException
5405 //
5406 id = env->GetMethodID((jclass)pr.jProviderClass,
5407 "getPropertyValue",
|
5408 mark.hamzy 1.46 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
|
5409 mark.hamzy 1.26
|
5410 mark.hamzy 1.43 if (id != NULL)
5411 {
5412 eMethodFound = METHOD_PROPERTYPROVIDER2;
5413 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_PROPERTYPROVIDER2."<<PEGASUS_STD(endl));
5414 }
|
5415 mark.hamzy 1.26 }
5416
5417 if (id == NULL)
5418 {
5419 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
|
5420 mark.hamzy 1.43
5421 PEG_METHOD_EXIT();
5422
5423 STAT_COPYDISPATCHER
5424
5425 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5426 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
5427 "Could not find a method for the provider based on InterfaceType."));
|
5428 mark.hamzy 1.26 }
5429
5430 JMPIjvm::checkException(env);
5431
5432 switch (eMethodFound)
5433 {
|
5434 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER:
|
5435 mark.hamzy 1.26 {
|
5436 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
5437 mark.hamzy 1.26 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
5438
5439 JMPIjvm::checkException(env);
5440
5441 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
5442
5443 JMPIjvm::checkException(env);
5444
5445 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
5446
5447 JMPIjvm::checkException(env);
5448
5449 STAT_GETSTARTTIME;
5450
|
5451 mark.hamzy 1.29 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
5452 id,
5453 jcop,
5454 joclass,
5455 jpName);
|
5456 mark.hamzy 1.26
5457 JMPIjvm::checkException(env);
5458
5459 STAT_PMS_PROVIDEREND;
5460
5461 handler.processing();
5462
|
5463 mark.hamzy 1.29 if (jvalRet)
|
5464 mark.hamzy 1.26 {
|
5465 mark.hamzy 1.29 jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);
5466 CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef);
|
5467 mark.hamzy 1.26
5468 JMPIjvm::checkException(env);
5469
|
5470 mark.hamzy 1.29 handler.deliver(*valRet);
|
5471 mark.hamzy 1.26 }
5472 handler.complete();
5473 break;
5474 }
5475
|
5476 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER2:
5477 {
5478 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
5479 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
5480
5481 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5482 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
5483
5484 JMPIjvm::checkException(env);
5485
5486 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
5487
5488 JMPIjvm::checkException(env);
5489
5490 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
5491
5492 JMPIjvm::checkException(env);
5493
5494 STAT_GETSTARTTIME;
5495
5496 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
5497 mark.hamzy 1.43 id,
5498 joc,
5499 jcop,
5500 joclass,
5501 jpName);
5502
5503 JMPIjvm::checkException(env);
5504
5505 STAT_PMS_PROVIDEREND;
5506
5507 if (joc)
5508 {
5509 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
5510
5511 JMPIjvm::checkException(env);
5512 }
5513
5514 handler.processing();
5515
5516 if (jvalRet)
5517 {
5518 mark.hamzy 1.43 jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);
5519 CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef);
5520
5521 JMPIjvm::checkException(env);
5522
5523 handler.deliver(*valRet);
5524 }
5525 handler.complete();
5526 break;
5527 }
5528
|
5529 mark.hamzy 1.26 case METHOD_UNKNOWN:
5530 {
5531 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: should not be here!"<<PEGASUS_STD(endl));
5532 break;
5533 }
5534 }
5535 }
5536 HandlerCatch(handler);
5537
5538 if (env) JMPIjvm::detachThread();
5539
5540 PEG_METHOD_EXIT();
5541
|
5542 w.white 1.31 STAT_COPYDISPATCHER
5543
|
5544 mark.hamzy 1.26 return(response);
5545 }
5546
5547 Message * JMPIProviderManager::handleSetPropertyRequest(const Message * message) throw()
5548 {
5549 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleSetPropertyRequest");
5550
5551 HandlerIntroVoid(SetProperty,message,request,response,handler);
5552
5553 typedef enum {
5554 METHOD_UNKNOWN = 0,
|
5555 mark.hamzy 1.43 METHOD_PROPERTYPROVIDER,
5556 METHOD_PROPERTYPROVIDER2,
|
5557 mark.hamzy 1.26 } METHOD_VERSION;
5558 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
5559 JNIEnv *env = NULL;
5560
5561 try {
5562 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
5563 "JMPIProviderManager::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
5564 System::getHostName(),
5565 request->nameSpace.getString(),
5566 request->instanceName.getClassName().getString());
5567
5568 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
5569
5570 // make target object path
|
5571 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
5572 request->nameSpace,
5573 request->instanceName.getClassName(),
5574 request->instanceName.getKeyBindings());
|
5575 mark.hamzy 1.26
5576 // resolve provider name
5577 ProviderName name = _resolveProviderName(
5578 request->operationContext.get(ProviderIdContainer::NAME));
5579
5580 // get cached or load new provider module
|
5581 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
5582 name.getLogicalName(),
5583 String::EMPTY);
|
5584 mark.hamzy 1.26
5585 // forward request
5586 JMPIProvider &pr = ph.GetProvider();
5587
5588 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.setPropertyValue: " + pr.getName());
5589
5590 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: Calling provider setPropertyValue: "<<pr.getName()<<PEGASUS_STD(endl));
5591
5592 JvmVector *jv = 0;
5593
5594 env = JMPIjvm::attachThread(&jv);
5595
|
5596 mark.hamzy 1.37 if (!env)
5597 {
5598 PEG_METHOD_EXIT();
5599
5600 STAT_COPYDISPATCHER
5601
5602 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5603 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
5604 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
5605 }
5606
|
5607 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
5608
5609 STAT_GETSTARTTIME;
5610
|
5611 mark.hamzy 1.43 jmethodID id = NULL;
5612 String interfaceType;
5613 String interfaceVersion;
5614
5615 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
5616 interfaceType,
5617 interfaceVersion);
5618
5619 if (interfaceType == "JMPI")
5620 {
5621 // public abstract void setPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
5622 // java.lang.String oclass,
5623 // java.lang.String pName,
5624 // org.pegasus.jmpi.CIMValue val)
5625 // throws org.pegasus.jmpi.CIMException
5626 //
5627 id = env->GetMethodID((jclass)pr.jProviderClass,
5628 "setPropertyValue",
5629 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
|
5630 mark.hamzy 1.26
|
5631 mark.hamzy 1.43 if (id != NULL)
5632 {
5633 eMethodFound = METHOD_PROPERTYPROVIDER;
5634 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_PROPERTYPROVIDER."<<PEGASUS_STD(endl));
5635 }
5636 }
5637 else if (interfaceType == "JMPIExperimental")
5638 {
5639 // public abstract void setPropertyValue (org.pegasus.jmpi.OperationContext oc,
5640 // org.pegasus.jmpi.CIMObjectPath cop,
5641 // java.lang.String oclass,
5642 // java.lang.String pName,
5643 // org.pegasus.jmpi.CIMValue val)
5644 // throws org.pegasus.jmpi.CIMException
5645 //
5646 id = env->GetMethodID((jclass)pr.jProviderClass,
5647 "setPropertyValue",
|
5648 mark.hamzy 1.46 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
|
5649 mark.hamzy 1.26
|
5650 mark.hamzy 1.43 if (id != NULL)
5651 {
5652 eMethodFound = METHOD_PROPERTYPROVIDER2;
5653 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_PROPERTYPROVIDER2."<<PEGASUS_STD(endl));
5654 }
|
5655 mark.hamzy 1.26 }
5656
5657 if (id == NULL)
5658 {
5659 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
|
5660 mark.hamzy 1.43
5661 PEG_METHOD_EXIT();
5662
5663 STAT_COPYDISPATCHER
5664
5665 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5666 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
5667 "Could not find a method for the provider based on InterfaceType."));
|
5668 mark.hamzy 1.26 }
5669
5670 JMPIjvm::checkException(env);
5671
5672 switch (eMethodFound)
5673 {
|
5674 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER:
5675 {
5676 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5677 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
5678
5679 JMPIjvm::checkException(env);
5680
5681 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
5682
5683 JMPIjvm::checkException(env);
5684
5685 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
5686
5687 JMPIjvm::checkException(env);
5688
5689 CIMValue *val = new CIMValue (request->newValue);
5690
5691 JMPIjvm::checkException(env);
5692
5693 jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);
5694 jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);
5695 mark.hamzy 1.43
5696 JMPIjvm::checkException(env);
5697
5698 STAT_GETSTARTTIME;
5699
5700 env->CallVoidMethod ((jobject)pr.jProvider,
5701 id,
5702 jcop,
5703 joclass,
5704 jpName,
5705 jval);
5706
5707 JMPIjvm::checkException(env);
5708
5709 STAT_PMS_PROVIDEREND;
5710 break;
5711 }
5712
5713 case METHOD_PROPERTYPROVIDER2:
|
5714 mark.hamzy 1.26 {
|
5715 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
5716 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
5717
|
5718 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
5719 mark.hamzy 1.26 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
5720
5721 JMPIjvm::checkException(env);
5722
5723 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
5724
5725 JMPIjvm::checkException(env);
5726
5727 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
5728
5729 JMPIjvm::checkException(env);
5730
|
5731 mark.hamzy 1.27 CIMValue *val = new CIMValue (request->newValue);
|
5732 mark.hamzy 1.26
5733 JMPIjvm::checkException(env);
5734
|
5735 mark.hamzy 1.27 jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);
|
5736 mark.hamzy 1.26 jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);
5737
5738 JMPIjvm::checkException(env);
5739
5740 STAT_GETSTARTTIME;
5741
5742 env->CallVoidMethod ((jobject)pr.jProvider,
5743 id,
|
5744 mark.hamzy 1.43 joc,
|
5745 mark.hamzy 1.26 jcop,
5746 joclass,
5747 jpName,
5748 jval);
5749
5750 JMPIjvm::checkException(env);
5751
|
5752 mark.hamzy 1.43 if (joc)
5753 {
5754 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
5755
5756 JMPIjvm::checkException(env);
5757 }
5758
|
5759 mark.hamzy 1.26 STAT_PMS_PROVIDEREND;
5760 break;
5761 }
5762
5763 case METHOD_UNKNOWN:
5764 {
5765 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: should not be here!"<<PEGASUS_STD(endl));
5766 break;
5767 }
5768 }
5769 }
5770 HandlerCatch(handler);
5771
5772 if (env) JMPIjvm::detachThread();
5773
5774 PEG_METHOD_EXIT();
5775
|
5776 w.white 1.31 STAT_COPYDISPATCHER
5777
|
5778 mark.hamzy 1.26 return(response);
5779 }
5780
|
5781 schuur 1.1 Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw()
5782 {
|
5783 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest");
5784
5785 HandlerIntroMethod(InvokeMethod,message,request,response,handler);
|
5786 schuur 1.1
|
5787 mark.hamzy 1.25 typedef enum {
5788 METHOD_UNKNOWN = 0,
|
5789 mark.hamzy 1.43 METHOD_CIMMETHODPROVIDER,
5790 METHOD_CIMMETHODPROVIDER2,
5791 METHOD_METHODPROVIDER,
5792 METHOD_METHODPROVIDER2,
|
5793 mark.hamzy 1.25 } METHOD_VERSION;
5794 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
5795 JNIEnv *env = NULL;
|
5796 schuur 1.13
|
5797 schuur 1.1 try {
5798 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
5799 "JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",
5800 System::getHostName(),
5801 request->nameSpace.getString(),
5802 request->instanceName.getClassName().getString());
5803
|
5804 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->instanceName.getClassName().getString()<<PEGASUS_STD(endl));
5805
|
5806 schuur 1.1 // make target object path
|
5807 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
5808 request->nameSpace,
5809 request->instanceName.getClassName(),
5810 request->instanceName.getKeyBindings());
|
5811 schuur 1.1
5812 // resolve provider name
|
5813 kumpf 1.2 ProviderName name = _resolveProviderName(
5814 request->operationContext.get(ProviderIdContainer::NAME));
|
5815 schuur 1.1
5816 // get cached or load new provider module
|
5817 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
5818 name.getLogicalName(),
5819 String::EMPTY);
|
5820 schuur 1.1
|
5821 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
5822 schuur 1.1
|
5823 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.invokeMethod: " + pr.getName());
|
5824 schuur 1.1
|
5825 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: Calling provider invokeMethod: "<<pr.getName()<<PEGASUS_STD(endl));
|
5826 schuur 1.11
|
5827 mark.hamzy 1.25 JvmVector *jv = 0;
|
5828 mark.hamzy 1.23
|
5829 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
5830 schuur 1.11
|
5831 mark.hamzy 1.37 if (!env)
5832 {
|
5833 mark.hamzy 1.43 PEG_METHOD_EXIT();
5834
5835 STAT_COPYDISPATCHER
5836
5837 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5838 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
5839 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
5840 }
5841
5842 JMPIProvider::pm_service_op_lock op_lock(&pr);
5843
5844 STAT_GETSTARTTIME;
5845
5846 jmethodID id = NULL;
5847 String interfaceType;
5848 String interfaceVersion;
5849
5850 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
5851 interfaceType,
5852 interfaceVersion);
5853
5854 mark.hamzy 1.43 if (interfaceType == "JMPI")
5855 {
5856 // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath cop,
5857 // java.lang.String name,
5858 // java.util.Vector in,
5859 // java.util.Vector out)
5860 // throws org.pegasus.jmpi.CIMException
5861 id = env->GetMethodID((jclass)pr.jProviderClass,
5862 "invokeMethod",
5863 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
5864
5865 if (id != NULL)
5866 {
5867 eMethodFound = METHOD_METHODPROVIDER;
5868 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER."<<PEGASUS_STD(endl));
5869 }
5870
5871 if (id == NULL)
5872 {
5873 env->ExceptionClear();
5874
5875 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath op,
5876 // java.lang.String methodName,
5877 // org.pegasus.jmpi.CIMArgument[] inArgs,
5878 // org.pegasus.jmpi.CIMArgument[] outArgs)
5879 // throws org.pegasus.jmpi.CIMException
5880 id = env->GetMethodID((jclass)pr.jProviderClass,
5881 "invokeMethod",
5882 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
5883
5884 if (id != NULL)
5885 {
5886 eMethodFound = METHOD_CIMMETHODPROVIDER;
5887 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER."<<PEGASUS_STD(endl));
5888 }
5889 }
5890 }
5891 else if (interfaceType == "JMPIExperimental")
5892 {
5893 // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,
5894 // org.pegasus.jmpi.CIMObjectPath cop,
5895 // java.lang.String name,
5896 mark.hamzy 1.43 // java.util.Vector in,
5897 // java.util.Vector out)
5898 // throws org.pegasus.jmpi.CIMException
5899 id = env->GetMethodID((jclass)pr.jProviderClass,
5900 "invokeMethod",
5901 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
5902
5903 if (id != NULL)
5904 {
5905 eMethodFound = METHOD_METHODPROVIDER2;
5906 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER2."<<PEGASUS_STD(endl));
5907 }
5908
5909 if (id == NULL)
5910 {
5911 env->ExceptionClear();
5912
5913 // public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,
5914 // org.pegasus.jmpi.CIMObjectPath op,
5915 // java.lang.String methodName,
5916 // org.pegasus.jmpi.CIMArgument[] inArgs,
5917 mark.hamzy 1.43 // org.pegasus.jmpi.CIMArgument[] outArgs)
5918 // throws org.pegasus.jmpi.CIMException
5919 id = env->GetMethodID((jclass)pr.jProviderClass,
5920 "invokeMethod",
5921 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
5922
5923 if (id != NULL)
5924 {
5925 eMethodFound = METHOD_CIMMETHODPROVIDER2;
5926 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER2."<<PEGASUS_STD(endl));
5927 }
5928 }
5929 }
5930
5931 if (id == NULL)
5932 {
5933 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: No method found!"<<PEGASUS_STD(endl));
5934
5935 PEG_METHOD_EXIT();
5936
5937 STAT_COPYDISPATCHER
5938 mark.hamzy 1.43
5939 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5940 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
5941 "Could not find a method for the provider based on InterfaceType."));
5942 }
5943
5944 JMPIjvm::checkException(env);
5945
5946 switch (eMethodFound)
5947 {
5948 case METHOD_CIMMETHODPROVIDER:
5949 {
5950 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5951 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
5952
5953 JMPIjvm::checkException(env);
5954
5955 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
5956
5957 JMPIjvm::checkException(env);
5958
5959 mark.hamzy 1.43 Uint32 m=request->inParameters.size();
5960
5961 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
5962
5963 for (Uint32 i=0; i<m; i++) {
5964 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
5965 jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);
5966 jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef);
5967
5968 env->SetObjectArrayElement(jArIn,i,jArg);
5969 }
5970
5971 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
5972
5973 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
5974 id,
5975 jcop,
5976 jMethod,
5977 jArIn,
5978 jArOut);
5979 JMPIjvm::checkException(env);
|
5980 mark.hamzy 1.37
|
5981 mark.hamzy 1.43 STAT_PMS_PROVIDEREND;
|
5982 mark.hamzy 1.37
|
5983 mark.hamzy 1.43 handler.processing();
|
5984 mark.hamzy 1.37
|
5985 mark.hamzy 1.43 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
5986 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
5987 schuur 1.11
|
5988 mark.hamzy 1.43 handler.deliver(*valueRet);
|
5989 schuur 1.1
|
5990 mark.hamzy 1.43 for (int i=0; i<24; i++) {
5991 jobject jArg = env->GetObjectArrayElement(jArOut,i);
|
5992 mark.hamzy 1.25
|
5993 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5994 mark.hamzy 1.25
|
5995 mark.hamzy 1.43 if (jArg==NULL)
5996 break;
|
5997 mark.hamzy 1.25
|
5998 mark.hamzy 1.43 jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);
5999 CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef);
|
6000 mark.hamzy 1.25
|
6001 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6002 mark.hamzy 1.25
|
6003 mark.hamzy 1.43 handler.deliverParamValue(*p);
|
6004 mark.hamzy 1.25 }
|
6005 mark.hamzy 1.43
6006 handler.complete();
6007 break;
|
6008 mark.hamzy 1.23 }
|
6009 mark.hamzy 1.25
|
6010 mark.hamzy 1.43 case METHOD_CIMMETHODPROVIDER2:
6011 {
6012 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
6013 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
|
6014 schuur 1.11
|
6015 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
6016 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6017 mark.hamzy 1.25
6018 JMPIjvm::checkException(env);
6019
|
6020 mark.hamzy 1.29 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
6021
|
6022 mark.hamzy 1.23 JMPIjvm::checkException(env);
6023
|
6024 mark.hamzy 1.25 Uint32 m=request->inParameters.size();
6025
6026 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
|
6027 mark.hamzy 1.29
|
6028 mark.hamzy 1.25 for (Uint32 i=0; i<m; i++) {
|
6029 mark.hamzy 1.29 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
6030 jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);
6031 jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef);
|
6032 mark.hamzy 1.23
|
6033 mark.hamzy 1.25 env->SetObjectArrayElement(jArIn,i,jArg);
6034 }
|
6035 mark.hamzy 1.23
|
6036 mark.hamzy 1.25 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
|
6037 mark.hamzy 1.23
|
6038 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
6039 id,
|
6040 mark.hamzy 1.43 joc,
|
6041 mark.hamzy 1.29 jcop,
6042 jMethod,
6043 jArIn,
6044 jArOut);
|
6045 mark.hamzy 1.23 JMPIjvm::checkException(env);
6046
6047 STAT_PMS_PROVIDEREND;
6048
|
6049 mark.hamzy 1.43 if (joc)
6050 {
6051 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
6052
6053 JMPIjvm::checkException(env);
6054 }
6055
|
6056 mark.hamzy 1.23 handler.processing();
6057
|
6058 mark.hamzy 1.29 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
6059 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
6060 mark.hamzy 1.23
|
6061 mark.hamzy 1.29 handler.deliver(*valueRet);
|
6062 schuur 1.13
|
6063 mark.hamzy 1.25 for (int i=0; i<24; i++) {
|
6064 mark.hamzy 1.29 jobject jArg = env->GetObjectArrayElement(jArOut,i);
6065
|
6066 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
6067 schuur 1.13
|
6068 mark.hamzy 1.29 if (jArg==NULL)
6069 break;
|
6070 schuur 1.13
|
6071 mark.hamzy 1.29 jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);
6072 CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef);
|
6073 schuur 1.13
|
6074 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
6075 schuur 1.1
|
6076 mark.hamzy 1.25 handler.deliverParamValue(*p);
|
6077 mark.hamzy 1.23 }
|
6078 schuur 1.1
|
6079 mark.hamzy 1.23 handler.complete();
|
6080 mark.hamzy 1.25 break;
|
6081 mark.hamzy 1.23 }
|
6082 schuur 1.11
|
6083 mark.hamzy 1.43 case METHOD_METHODPROVIDER:
6084 {
6085 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
6086 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
6087
6088 JMPIjvm::checkException(env);
6089
6090 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
6091
6092 JMPIjvm::checkException(env);
6093
6094 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
6095
6096 JMPIjvm::checkException(env);
6097
6098 for (int i=0,m=request->inParameters.size(); i<m; i++)
6099 {
6100 const CIMParamValue &parm = request->inParameters[i];
6101 const CIMValue v = parm.getValue();
6102 CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
6103 jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
6104 mark.hamzy 1.43 jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef);
6105
6106 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
6107 }
6108
6109 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
6110 JMPIjvm::checkException(env);
6111
6112 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
6113 id,
6114 jcop,
6115 jMethod,
6116 jVecIn,
6117 jVecOut);
6118 JMPIjvm::checkException(env);
6119
6120 STAT_PMS_PROVIDEREND;
6121
6122 handler.processing();
6123
6124 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
6125 mark.hamzy 1.43 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
6126
6127 handler.deliver(*valueRet);
6128
6129 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++)
6130 {
6131 JMPIjvm::checkException(env);
6132
6133 jobject jProp = env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
6134
6135 JMPIjvm::checkException(env);
6136
6137 jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);
6138 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef);
6139
6140 JMPIjvm::checkException(env);
6141
6142 handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
6143 }
6144
6145 handler.complete();
6146 mark.hamzy 1.43 break;
6147 }
6148
6149 case METHOD_METHODPROVIDER2:
|
6150 mark.hamzy 1.25 {
|
6151 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
6152 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
6153
|
6154 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
6155 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6156 mark.hamzy 1.25
6157 JMPIjvm::checkException(env);
6158
|
6159 mark.hamzy 1.29 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
6160
|
6161 mark.hamzy 1.25 JMPIjvm::checkException(env);
6162
|
6163 mark.hamzy 1.29 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
6164
|
6165 mark.hamzy 1.25 JMPIjvm::checkException(env);
6166
|
6167 mark.hamzy 1.29 for (int i=0,m=request->inParameters.size(); i<m; i++)
6168 {
6169 const CIMParamValue &parm = request->inParameters[i];
6170 const CIMValue v = parm.getValue();
6171 CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
6172 jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
6173 jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef);
|
6174 mark.hamzy 1.23
|
6175 mark.hamzy 1.29 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
|
6176 mark.hamzy 1.25 }
|
6177 mark.hamzy 1.23
|
6178 mark.hamzy 1.25 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
6179 JMPIjvm::checkException(env);
|
6180 mark.hamzy 1.23
|
6181 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
6182 id,
|
6183 mark.hamzy 1.43 joc,
|
6184 mark.hamzy 1.29 jcop,
6185 jMethod,
6186 jVecIn,
6187 jVecOut);
|
6188 mark.hamzy 1.23 JMPIjvm::checkException(env);
6189
6190 STAT_PMS_PROVIDEREND;
6191
|
6192 mark.hamzy 1.43 if (joc)
6193 {
6194 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
6195
6196 JMPIjvm::checkException(env);
6197 }
6198
|
6199 mark.hamzy 1.23 handler.processing();
|
6200 schuur 1.1
|
6201 mark.hamzy 1.29 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
6202 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
6203 mark.hamzy 1.23
|
6204 mark.hamzy 1.29 handler.deliver(*valueRet);
|
6205 mark.hamzy 1.23
|
6206 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++)
6207 {
|
6208 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
6209 schuur 1.13
|
6210 mark.hamzy 1.29 jobject jProp = env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
6211
|
6212 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6213 schuur 1.13
|
6214 mark.hamzy 1.29 jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);
6215 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef);
|
6216 schuur 1.13
|
6217 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
6218 schuur 1.13
|
6219 mark.hamzy 1.25 handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
6220 }
6221
6222 handler.complete();
6223 break;
6224 }
|
6225 mark.hamzy 1.23
|
6226 mark.hamzy 1.25 case METHOD_UNKNOWN:
6227 {
6228 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: should not be here!"<<PEGASUS_STD(endl));
6229 break;
6230 }
|
6231 mark.hamzy 1.23 }
|
6232 schuur 1.1 }
6233 HandlerCatch(handler);
|
6234 schuur 1.11
6235 if (env) JMPIjvm::detachThread();
6236
|
6237 schuur 1.1 PEG_METHOD_EXIT();
6238
|
6239 w.white 1.31 STAT_COPYDISPATCHER
6240
|
6241 schuur 1.11 return(response);
|
6242 schuur 1.1 }
|
6243 mark.hamzy 1.23
|
6244 schuur 1.1 int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance,
6245 String& providerName, String& location)
6246 {
6247 Uint32 pos = pInstance.findProperty(CIMName ("Name"));
6248 pInstance.getProperty(pos).getValue().get(providerName);
6249
6250 pos = pmInstance.findProperty(CIMName ("Location"));
6251 pmInstance.getProperty(pos).getValue().get(location);
6252 return 0;
6253 }
6254
|
6255 mark.hamzy 1.44 CMPI_SelectExp *
6256 newSelectExp (CIMOMHandleQueryContext *qContext,
6257 OperationContext *ctx,
6258 String& query,
6259 String& queryLanguage,
6260 CIMNamespaceName& nameSpace,
6261 Array<CIMName>& classNames,
6262 CIMPropertyList& propertyList)
6263 {
6264 CMPI_SelectExp *eSelx = NULL;
6265
6266 eSelx = new CMPI_SelectExp (*ctx,
6267 qContext,
6268 query,
6269 queryLanguage);
6270
6271 if (!eSelx)
6272 {
6273 return eSelx;
6274 }
6275
6276 mark.hamzy 1.44 for (Uint32 i = 0, n = classNames.size (); i < n; i++)
6277 {
6278 CIMObjectPath className (System::getHostName(),
6279 nameSpace,
6280 classNames[i]);
6281
6282 eSelx->classNames.append (className);
6283 }
6284
6285 if (!propertyList.isNull ())
6286 {
6287 Array<CIMName> p = propertyList.getPropertyNameArray ();
6288 int pCount = p.size ();
6289
6290 eSelx->props = (const char**)malloc ((1 + pCount) * sizeof (char*));
6291
6292 for (int i = 0; i < pCount; i++)
6293 {
6294 eSelx->props[i] = strdup (p[i].getString ().getCString ());
6295 }
6296
6297 mark.hamzy 1.44 eSelx->props[pCount] = NULL;
6298 }
6299
6300 return eSelx;
6301 }
6302
|
6303 schuur 1.1 Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()
6304 {
|
6305 konrad.r 1.15 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest");
|
6306 schuur 1.1
|
6307 mark.hamzy 1.23 HandlerIntroInd(CreateSubscription,message,request,response,handler);
6308
|
6309 mark.hamzy 1.25 typedef enum {
6310 METHOD_UNKNOWN = 0,
|
6311 mark.hamzy 1.43 METHOD_EVENTPROVIDER,
6312 METHOD_EVENTPROVIDER2,
|
6313 mark.hamzy 1.25 } METHOD_VERSION;
|
6314 mark.hamzy 1.44 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
6315 JNIEnv *env = NULL;
|
6316 mark.hamzy 1.25
|
6317 schuur 1.1 try {
|
6318 mark.hamzy 1.44 String fileName,
6319 providerName,
|
6320 mark.hamzy 1.25 providerLocation;
6321 CIMInstance req_provider,
6322 req_providerModule;
|
6323 mark.hamzy 1.44 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
|
6324 mark.hamzy 1.25
|
6325 mark.hamzy 1.44 req_provider = pidc.getProvider ();
6326 req_providerModule = pidc.getModule ();
|
6327 mark.hamzy 1.25
|
6328 mark.hamzy 1.44 LocateIndicationProviderNames (req_provider,
6329 req_providerModule,
6330 providerName,
6331 providerLocation);
6332
6333 fileName = resolveFileName (providerLocation);
6334
6335 Logger::put (Logger::STANDARD_LOG,
6336 System::CIMSERVER,
6337 Logger::TRACE,
6338 "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
6339 System::getHostName(),
6340 request->nameSpace.getString(),
6341 providerName);
6342
6343 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "
6344 <<System::getHostName()
6345 <<", namespace = "
6346 <<request->nameSpace.getString()
6347 <<", providername = "
6348 <<providerName
6349 mark.hamzy 1.44 <<", fileName = "
6350 <<fileName
6351 <<PEGASUS_STD(endl));
|
6352 schuur 1.1
6353 // get cached or load new provider module
|
6354 mark.hamzy 1.44 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName,
6355 providerName,
|
6356 mark.hamzy 1.43 String::EMPTY);
|
6357 schuur 1.1
|
6358 carolann.graves 1.21 //
6359 // Save the provider instance from the request
6360 //
6361 ph.GetProvider ().setProviderInstance (req_provider);
6362
|
6363 mark.hamzy 1.44 JMPIProvider &pr = ph.GetProvider ();
|
6364 mark.hamzy 1.25
|
6365 mark.hamzy 1.44 //
6366 // Increment count of current subscriptions for this provider
6367 //
6368 pr.testIfZeroAndIncrementSubscriptions ();
|
6369 schuur 1.1
|
6370 mark.hamzy 1.44 SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get (SubscriptionFilterConditionContainer::NAME);
6371 indProvRecord *prec = NULL;
6372 bool fNewPrec = false;
|
6373 schuur 1.1
|
6374 mark.hamzy 1.25 {
|
6375 mark.hamzy 1.44 AutoMutex lock (mutexProvTab);
6376
6377 provTab.lookup (providerName, prec);
|
6378 schuur 1.12
|
6379 mark.hamzy 1.44 if (!prec)
6380 {
6381 fNewPrec = true;
|
6382 schuur 1.1
|
6383 mark.hamzy 1.44 prec = new indProvRecord ();
|
6384 schuur 1.1
|
6385 mark.hamzy 1.44 // convert arguments
6386 prec->ctx = new OperationContext ();
|
6387 schuur 1.12
|
6388 mark.hamzy 1.44 prec->ctx->insert (request->operationContext.get (IdentityContainer::NAME));
6389 prec->ctx->insert (request->operationContext.get (AcceptLanguageListContainer::NAME));
6390 prec->ctx->insert (request->operationContext.get (ContentLanguageListContainer::NAME));
6391 prec->ctx->insert (request->operationContext.get (SubscriptionInstanceContainer::NAME));
6392 prec->ctx->insert (request->operationContext.get (SubscriptionFilterConditionContainer::NAME));
|
6393 konrad.r 1.22
|
6394 mark.hamzy 1.44 prec->enabled = true;
|
6395 konrad.r 1.22
|
6396 mark.hamzy 1.44 prec->handler = new EnableIndicationsResponseHandler (0,
6397 0,
6398 req_provider,
6399 _indicationCallback,
6400 _responseChunkCallback);
|
6401 konrad.r 1.22
|
6402 mark.hamzy 1.44 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to provTab "<<providerName<<PEGASUS_STD(endl));
|
6403 schuur 1.1
|
6404 mark.hamzy 1.44 provTab.insert (providerName, prec);
6405 }
6406 }
|
6407 schuur 1.1
|
6408 mark.hamzy 1.44 {
6409 AutoMutex lock (prec->mutex);
|
6410 schuur 1.1
|
6411 mark.hamzy 1.44 prec->count++;
|
6412 schuur 1.1 }
6413
|
6414 mark.hamzy 1.44 // Add a selection record for JNI CIMOMHandle deliverEvent calls
6415 indSelectRecord *srec = new indSelectRecord ();
|
6416 mark.hamzy 1.29
6417 {
|
6418 mark.hamzy 1.44 srec->query = request->query;
6419 srec->queryLanguage = sub_cntr.getQueryLanguage ();
6420 srec->propertyList = request->propertyList;
6421
6422 CIMOMHandleQueryContext *qContext = new CIMOMHandleQueryContext (CIMNamespaceName (request->nameSpace.getString ()),
6423 *pr._cimom_handle);
6424 CMPI_SelectExp *eSelx = newSelectExp (qContext,
6425 prec->ctx,
6426 srec->query,
6427 srec->queryLanguage,
6428 request->nameSpace,
6429 request->classNames,
6430 srec->propertyList);
6431
6432 srec->eSelx = eSelx;
6433 srec->qContext = qContext;
6434
6435 CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ());
6436
6437 sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ());
|
6438 mark.hamzy 1.29
|
6439 mark.hamzy 1.44 AutoMutex lock (mutexSelxTab);
|
6440 mark.hamzy 1.29
|
6441 mark.hamzy 1.44 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to selxTab "<<sPath.toString ()<<PEGASUS_STD(endl));
6442
6443 selxTab.insert (sPath.toString (), srec);
6444
6445 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: For selxTab "<<sPath.toString ()<<", srec = "<<PEGASUS_STD(hex)<<(int)srec<<PEGASUS_STD(dec)<<", eSelx = "<<PEGASUS_STD(hex)<<(int)eSelx<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(int)qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
6446 schuur 1.1 }
6447
|
6448 mark.hamzy 1.44 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName());
6449
6450 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Calling provider createSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
6451
|
6452 mark.hamzy 1.25 JvmVector *jv = 0;
6453
6454 env = JMPIjvm::attachThread(&jv);
6455
|
6456 mark.hamzy 1.37 if (!env)
6457 {
6458 PEG_METHOD_EXIT();
6459
6460 STAT_COPYDISPATCHER
6461
6462 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
6463 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
6464 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
6465 }
6466
|
6467 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
6468
6469 STAT_GETSTARTTIME;
6470
|
6471 mark.hamzy 1.43 jmethodID id = NULL;
6472 String interfaceType;
6473 String interfaceVersion;
6474
|
6475 mark.hamzy 1.44 getInterfaceType (pidc,
|
6476 mark.hamzy 1.43 interfaceType,
6477 interfaceVersion);
6478
6479 if (interfaceType == "JMPI")
6480 {
6481 // public void activateFilter (org.pegasus.jmpi.SelectExp filter,
6482 // java.lang.String eventType,
6483 // org.pegasus.jmpi.CIMObjectPath classPath,
6484 // boolean firstActivation)
6485 // throws org.pegasus.jmpi.CIMException
|
6486 mark.hamzy 1.44 id = env->GetMethodID ((jclass)pr.jProviderClass,
6487 "activateFilter",
6488 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
6489 mark.hamzy 1.43
6490 if (id != NULL)
6491 {
6492 eMethodFound = METHOD_EVENTPROVIDER;
6493 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_EVENTPROVIDER."<<PEGASUS_STD(endl));
6494 }
6495 }
6496 else if (interfaceType == "JMPIExperimental")
6497 {
6498 // public void activateFilter (org.pegasus.jmpi.OperationContext oc,
6499 // org.pegasus.jmpi.SelectExp filter,
6500 // java.lang.String eventType,
6501 // org.pegasus.jmpi.CIMObjectPath classPath,
6502 // boolean firstActivation)
6503 // throws org.pegasus.jmpi.CIMException
|
6504 mark.hamzy 1.44 id = env->GetMethodID ((jclass)pr.jProviderClass,
6505 "activateFilter",
6506 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
6507 mark.hamzy 1.25
|
6508 mark.hamzy 1.43 if (id != NULL)
6509 {
6510 eMethodFound = METHOD_EVENTPROVIDER2;
6511 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_EVENTPROVIDER2."<<PEGASUS_STD(endl));
6512 }
6513 }
|
6514 schuur 1.12
|
6515 mark.hamzy 1.43 if (id == NULL)
|
6516 mark.hamzy 1.25 {
|
6517 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: No method found!"<<PEGASUS_STD(endl));
6518
6519 PEG_METHOD_EXIT();
6520
6521 STAT_COPYDISPATCHER
6522
6523 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
6524 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
6525 "Could not find a method for the provider based on InterfaceType."));
|
6526 mark.hamzy 1.25 }
|
6527 mark.hamzy 1.23
6528 JMPIjvm::checkException(env);
6529
|
6530 mark.hamzy 1.25 switch (eMethodFound)
6531 {
|
6532 mark.hamzy 1.43 case METHOD_EVENTPROVIDER:
6533 {
|
6534 mark.hamzy 1.44 CMPI_SelectExp *eSelx = newSelectExp (srec->qContext,
6535 prec->ctx,
6536 srec->query,
6537 srec->queryLanguage,
6538 request->nameSpace,
6539 request->classNames,
6540 srec->propertyList);
6541 jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
6542 jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef);
|
6543 mark.hamzy 1.43
6544 JMPIjvm::checkException(env);
6545
|
6546 mark.hamzy 1.44 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
6547 mark.hamzy 1.43
6548 JMPIjvm::checkException(env);
6549
|
6550 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
6551 request->nameSpace,
6552 request->classNames[0]);
6553 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
6554 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6555 mark.hamzy 1.43
6556 JMPIjvm::checkException(env);
6557
|
6558 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
6559 id,
6560 jEselx,
6561 jType,
6562 jcop,
6563 (jboolean)fNewPrec);
|
6564 mark.hamzy 1.43
6565 JMPIjvm::checkException(env);
6566
6567 STAT_PMS_PROVIDEREND;
6568 break;
6569 }
6570
6571 case METHOD_EVENTPROVIDER2:
|
6572 mark.hamzy 1.25 {
|
6573 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
6574 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
6575
|
6576 mark.hamzy 1.44 CMPI_SelectExp *eSelx = newSelectExp (srec->qContext,
6577 prec->ctx,
6578 srec->query,
6579 srec->queryLanguage,
6580 request->nameSpace,
6581 request->classNames,
6582 srec->propertyList);
6583 jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
6584 jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef);
|
6585 mark.hamzy 1.25
6586 JMPIjvm::checkException(env);
6587
|
6588 mark.hamzy 1.44 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
6589 schuur 1.12
|
6590 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6591 schuur 1.1
|
6592 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
6593 request->nameSpace,
6594 request->classNames[0]);
6595 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
6596 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6597 schuur 1.1
|
6598 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6599 schuur 1.1
|
6600 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
6601 id,
6602 joc,
6603 jEselx,
6604 jType,
6605 jcop,
6606 (jboolean)fNewPrec);
|
6607 schuur 1.12
|
6608 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6609 schuur 1.1
|
6610 mark.hamzy 1.43 if (joc)
6611 {
6612 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
6613
6614 JMPIjvm::checkException(env);
6615 }
6616
|
6617 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
6618 break;
|
6619 carolann.graves 1.21 }
6620
|
6621 mark.hamzy 1.25 case METHOD_UNKNOWN:
6622 {
6623 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: should not be here!"<<PEGASUS_STD(endl));
6624 break;
6625 }
6626 }
|
6627 schuur 1.1 }
6628 HandlerCatch(handler);
|
6629 schuur 1.12
|
6630 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
6631
|
6632 schuur 1.1 PEG_METHOD_EXIT();
6633
6634 return(response);
6635 }
6636
6637 Message * JMPIProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()
6638 {
6639 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest");
6640
|
6641 mark.hamzy 1.23 HandlerIntroInd(DeleteSubscription,message,request,response,handler);
6642
|
6643 mark.hamzy 1.25 typedef enum {
6644 METHOD_UNKNOWN = 0,
|
6645 mark.hamzy 1.43 METHOD_EVENTPROVIDER,
6646 METHOD_EVENTPROVIDER2,
|
6647 mark.hamzy 1.25 } METHOD_VERSION;
|
6648 mark.hamzy 1.44 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
6649 JNIEnv *env = NULL;
6650 bool fFreePrec = false;
6651 indProvRecord *prec = NULL;
6652 indSelectRecord *srec = NULL;
|
6653 mark.hamzy 1.25
|
6654 schuur 1.1 try {
|
6655 mark.hamzy 1.44 String fileName,
6656 providerName,
|
6657 mark.hamzy 1.25 providerLocation;
6658 CIMInstance req_provider,
6659 req_providerModule;
6660 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
6661
|
6662 mark.hamzy 1.44 req_provider = pidc.getProvider ();
6663 req_providerModule = pidc.getModule ();
6664
6665 LocateIndicationProviderNames (req_provider,
6666 req_providerModule,
6667 providerName,
6668 providerLocation);
6669
6670 fileName = resolveFileName (providerLocation);
6671
6672 Logger::put (Logger::STANDARD_LOG,
6673 System::CIMSERVER,
6674 Logger::TRACE,
6675 "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
6676 System::getHostName(),
6677 request->nameSpace.getString(),
6678 providerName);
6679
6680 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "
6681 <<System::getHostName()
6682 <<", namespace = "
6683 mark.hamzy 1.44 <<request->nameSpace.getString()
6684 <<", providername = "
6685 <<providerName
6686 <<", fileName = "
6687 <<fileName
6688 <<PEGASUS_STD(endl));
|
6689 se.gupta 1.9
|
6690 mark.hamzy 1.44 // get cached or load new provider module
6691 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName,
6692 providerName,
6693 String::EMPTY);
|
6694 schuur 1.1
|
6695 mark.hamzy 1.44 JMPIProvider &pr = ph.GetProvider ();
6696
6697 {
6698 AutoMutex lock (mutexProvTab);
6699
6700 provTab.lookup (providerName, prec);
6701 }
|
6702 schuur 1.1
|
6703 mark.hamzy 1.44 {
6704 AutoMutex lock (prec->mutex);
|
6705 mark.hamzy 1.23
|
6706 mark.hamzy 1.44 if (--prec->count <= 0)
6707 {
6708 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing provTab "<<providerName<<PEGASUS_STD(endl));
|
6709 schuur 1.1
|
6710 mark.hamzy 1.44 provTab.remove (providerName);
|
6711 schuur 1.1
|
6712 mark.hamzy 1.44 fFreePrec = true;
6713 }
6714 }
|
6715 mark.hamzy 1.25
6716 {
|
6717 mark.hamzy 1.44 CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ());
6718
6719 sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ());
|
6720 schuur 1.1
|
6721 mark.hamzy 1.44 String sPathString = sPath.toString ();
|
6722 mark.hamzy 1.25
|
6723 mark.hamzy 1.44 AutoMutex lock (mutexSelxTab);
|
6724 schuur 1.1
|
6725 mark.hamzy 1.44 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing selxTab "<<sPathString<<PEGASUS_STD(endl));
|
6726 konrad.r 1.22
|
6727 mark.hamzy 1.44 selxTab.lookup (sPathString, srec);
|
6728 schuur 1.1
|
6729 mark.hamzy 1.44 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: For selxTab "<<sPathString<<", srec = "<<PEGASUS_STD(hex)<<(int)srec<<PEGASUS_STD(dec)<<", eSelx = "<<PEGASUS_STD(hex)<<(int)srec->eSelx<<PEGASUS_STD(dec)<<", qContext = "<<PEGASUS_STD(hex)<<(int)srec->qContext<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
6730 schuur 1.1
|
6731 mark.hamzy 1.44 selxTab.remove (sPathString);
6732 }
|
6733 schuur 1.1
|
6734 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteSubscriptionRequest: " + pr.getName());
|
6735 schuur 1.1
|
6736 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Calling provider deleteSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
|
6737 schuur 1.1
|
6738 mark.hamzy 1.25 JvmVector *jv = 0;
6739
6740 env = JMPIjvm::attachThread(&jv);
6741
|
6742 mark.hamzy 1.37 if (!env)
6743 {
6744 PEG_METHOD_EXIT();
6745
6746 STAT_COPYDISPATCHER
6747
6748 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
6749 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
6750 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
6751 }
6752
|
6753 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
6754
6755 STAT_GETSTARTTIME;
6756
|
6757 mark.hamzy 1.43 jmethodID id = NULL;
6758 String interfaceType;
6759 String interfaceVersion;
6760
6761 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
6762 interfaceType,
6763 interfaceVersion);
6764
6765 if (interfaceType == "JMPI")
6766 {
6767 // public void deActivateFilter (org.pegasus.jmpi.SelectExp filter,
6768 // java.lang.String eventType,
6769 // org.pegasus.jmpi.CIMObjectPath classPath,
6770 // boolean lastActivation)
6771 // throws org.pegasus.jmpi.CIMException
6772 id = env->GetMethodID((jclass)pr.jProviderClass,
6773 "deActivateFilter",
6774 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
6775
6776 if (id != NULL)
6777 {
6778 mark.hamzy 1.43 eMethodFound = METHOD_EVENTPROVIDER;
6779 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_EVENTPROVIDER."<<PEGASUS_STD(endl));
6780 }
6781 }
6782 else if (interfaceType == "JMPIExperimental")
6783 {
6784 // public void deActivateFilter (org.pegasus.jmpi.OperationContext oc,
6785 // org.pegasus.jmpi.SelectExp filter,
6786 // java.lang.String eventType,
6787 // org.pegasus.jmpi.CIMObjectPath classPath,
6788 // boolean lastActivation)
6789 // throws org.pegasus.jmpi.CIMException
6790 id = env->GetMethodID((jclass)pr.jProviderClass,
6791 "deActivateFilter",
|
6792 mark.hamzy 1.44 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
6793 mark.hamzy 1.25
|
6794 mark.hamzy 1.43 if (id != NULL)
6795 {
6796 eMethodFound = METHOD_EVENTPROVIDER2;
6797 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_EVENTPROVIDER2."<<PEGASUS_STD(endl));
6798 }
6799 }
|
6800 schuur 1.12
|
6801 mark.hamzy 1.43 if (id == NULL)
|
6802 mark.hamzy 1.25 {
|
6803 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: No method found!"<<PEGASUS_STD(endl));
6804
6805 PEG_METHOD_EXIT();
6806
6807 STAT_COPYDISPATCHER
6808
6809 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
6810 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
6811 "Could not find a method for the provider based on InterfaceType."));
|
6812 mark.hamzy 1.25 }
|
6813 mark.hamzy 1.23
6814 JMPIjvm::checkException(env);
6815
|
6816 mark.hamzy 1.25 switch (eMethodFound)
6817 {
|
6818 mark.hamzy 1.43 case METHOD_EVENTPROVIDER:
6819 {
|
6820 mark.hamzy 1.44 CMPI_SelectExp *eSelx = newSelectExp (srec->qContext,
6821 prec->ctx,
6822 srec->query,
6823 srec->queryLanguage,
6824 request->nameSpace,
6825 request->classNames,
6826 srec->propertyList);
6827 jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
6828 jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef);
|
6829 mark.hamzy 1.43
6830 JMPIjvm::checkException(env);
6831
|
6832 mark.hamzy 1.44 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
6833 mark.hamzy 1.43
6834 JMPIjvm::checkException(env);
6835
|
6836 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
6837 request->nameSpace,
6838 request->classNames[0]);
6839 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
6840 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6841 mark.hamzy 1.43
6842 JMPIjvm::checkException(env);
6843
|
6844 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
6845 id,
6846 jEselx,
6847 jType,
6848 jcop,
6849 (jboolean)fFreePrec);
|
6850 mark.hamzy 1.43
6851 JMPIjvm::checkException(env);
6852
6853 STAT_PMS_PROVIDEREND;
6854 break;
6855 }
6856
6857 case METHOD_EVENTPROVIDER2:
|
6858 mark.hamzy 1.25 {
|
6859 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
6860 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
6861
|
6862 mark.hamzy 1.44 CMPI_SelectExp *eSelx = newSelectExp (srec->qContext,
6863 prec->ctx,
6864 srec->query,
6865 srec->queryLanguage,
6866 request->nameSpace,
6867 request->classNames,
6868 srec->propertyList);
6869 jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
6870 jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef);
|
6871 mark.hamzy 1.25
6872 JMPIjvm::checkException(env);
6873
|
6874 mark.hamzy 1.44 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
6875 schuur 1.12
|
6876 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6877 schuur 1.12
|
6878 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
6879 request->nameSpace,
6880 request->classNames[0]);
6881 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
6882 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6883 schuur 1.1
|
6884 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6885 schuur 1.1
|
6886 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
6887 id,
6888 joc,
6889 jEselx,
6890 jType,
6891 jcop,
6892 (jboolean)fFreePrec);
|
6893 schuur 1.1
|
6894 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6895 schuur 1.1
|
6896 mark.hamzy 1.43 if (joc)
6897 {
6898 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
6899
6900 JMPIjvm::checkException(env);
6901 }
6902
|
6903 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
6904 break;
6905 }
|
6906 schuur 1.12
|
6907 mark.hamzy 1.25 case METHOD_UNKNOWN:
6908 {
6909 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: should not be here!"<<PEGASUS_STD(endl));
6910 break;
6911 }
6912 }
|
6913 mark.hamzy 1.44
6914 //
6915 // Decrement count of current subscriptions for this provider
6916 //
6917 pr.decrementSubscriptionsAndTestIfZero ();
|
6918 schuur 1.1 }
6919 HandlerCatch(handler);
|
6920 schuur 1.12
|
6921 mark.hamzy 1.44 if (srec)
6922 {
6923 if ( srec->eSelx
6924 && srec->eSelx->props
6925 )
6926 {
6927 const char **props = srec->eSelx->props;
6928
6929 while (*props)
6930 {
6931 const char *prop = *props;
6932
6933 props++;
6934
6935 if (prop)
6936 {
6937 free ((void *)prop);
6938 }
6939 }
6940
6941 free ((void *)srec->eSelx->props);
6942 mark.hamzy 1.44 }
6943 delete srec->eSelx;
6944 delete srec->qContext;
6945 }
6946 delete srec;
6947
6948 if (fFreePrec)
6949 {
6950 delete prec->ctx;
6951 delete prec->handler;
6952 delete prec;
6953 }
6954
|
6955 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
6956
|
6957 schuur 1.1 PEG_METHOD_EXIT();
6958
|
6959 w.white 1.31 STAT_COPYDISPATCHER
6960
|
6961 schuur 1.1 return(response);
6962 }
6963
6964 Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw()
6965 {
6966 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDisableModuleRequest");
6967
6968 CIMDisableModuleRequestMessage * request =
6969 dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));
6970
6971 PEGASUS_ASSERT(request != 0);
6972
6973 // get provider module name
6974 String moduleName;
6975 CIMInstance mInstance = request->providerModule;
6976 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
6977
6978 if(pos != PEG_NOT_FOUND)
6979 {
6980 mInstance.getProperty(pos).getValue().get(moduleName);
6981 }
6982 schuur 1.1
6983 Boolean disableProviderOnly = request->disableProviderOnly;
6984
6985 Array<Uint16> operationalStatus;
|
6986 kumpf 1.2 // Assume success.
|
6987 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
6988 schuur 1.1
|
6989 kumpf 1.2 //
|
6990 schuur 1.1 // Unload providers
|
6991 kumpf 1.2 //
|
6992 schuur 1.1 Array<CIMInstance> _pInstances = request->providers;
6993
6994 CIMDisableModuleResponseMessage * response =
6995 new CIMDisableModuleResponseMessage(
6996 request->messageId,
6997 CIMException(),
6998 request->queueIds.copyAndPop(),
6999 operationalStatus);
7000
7001 PEGASUS_ASSERT(response != 0);
7002
7003 // preserve message key
7004 response->setKey(request->getKey());
7005
7006 //
7007 // Set HTTP method in response from request
7008 //
7009 response->setHttpMethod (request->getHttpMethod ());
7010
7011 PEG_METHOD_EXIT();
7012
7013 schuur 1.1 return(response);
7014 }
7015
7016 Message * JMPIProviderManager::handleEnableModuleRequest(const Message * message) throw()
7017 {
7018 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnableModuleRequest");
7019
7020 CIMEnableModuleRequestMessage * request =
7021 dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));
7022
7023 PEGASUS_ASSERT(request != 0);
7024
7025 Array<Uint16> operationalStatus;
|
7026 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
|
7027 schuur 1.1
7028 CIMEnableModuleResponseMessage * response =
7029 new CIMEnableModuleResponseMessage(
7030 request->messageId,
7031 CIMException(),
7032 request->queueIds.copyAndPop(),
7033 operationalStatus);
7034
7035 PEGASUS_ASSERT(response != 0);
7036
7037 // preserve message key
7038 response->setKey(request->getKey());
7039
7040 // Set HTTP method in response from request
7041 response->setHttpMethod (request->getHttpMethod ());
7042
7043 PEG_METHOD_EXIT();
7044
7045 return(response);
7046 }
7047
7048 schuur 1.1 Message * JMPIProviderManager::handleStopAllProvidersRequest(const Message * message) throw()
7049 {
7050 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleStopAllProvidersRequest");
7051
7052 CIMStopAllProvidersRequestMessage * request =
7053 dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));
7054
7055 PEGASUS_ASSERT(request != 0);
7056
7057 CIMStopAllProvidersResponseMessage * response =
7058 new CIMStopAllProvidersResponseMessage(
7059 request->messageId,
7060 CIMException(),
7061 request->queueIds.copyAndPop());
7062
7063 PEGASUS_ASSERT(response != 0);
7064
7065 // preserve message key
7066 response->setKey(request->getKey());
7067
7068 // Set HTTP method in response from request
7069 schuur 1.1 response->setHttpMethod (request->getHttpMethod ());
7070
7071 // tell the provider manager to shutdown all the providers
7072 providerManager.shutdownAllProviders();
7073
7074 PEG_METHOD_EXIT();
7075
7076 return(response);
7077 }
7078
|
7079 kumpf 1.4 Message * JMPIProviderManager::handleInitializeProviderRequest(const Message * message)
7080 {
7081 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleInitializeProviderRequest");
7082
7083 HandlerIntroInit(InitializeProvider,message,request,response,handler);
7084
7085 try
7086 {
7087 // resolve provider name
|
7088 mark.hamzy 1.23 ProviderName name = _resolveProviderName(
7089 request->operationContext.get(ProviderIdContainer::NAME));
|
7090 kumpf 1.4
7091 // get cached or load new provider module
|
7092 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
7093 name.getLogicalName(),
7094 String::EMPTY);
|
7095 kumpf 1.4
7096 }
7097 HandlerCatch(handler);
7098
7099 PEG_METHOD_EXIT();
7100
7101 return(response);
7102 }
7103
|
7104 mark.hamzy 1.25 Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest (const Message * message)
|
7105 carolann.graves 1.21 {
7106 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
7107 "JMPIProviderManager::handleSubscriptionInitCompleteRequest");
7108
7109 CIMSubscriptionInitCompleteRequestMessage * request =
7110 dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
7111 (const_cast <Message *> (message));
7112
7113 PEGASUS_ASSERT (request != 0);
7114
7115 CIMSubscriptionInitCompleteResponseMessage * response =
7116 dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
7117 (request->buildResponse ());
7118
7119 PEGASUS_ASSERT (response != 0);
7120
7121 //
7122 // Set indicator
7123 //
7124 _subscriptionInitComplete = true;
7125
7126 carolann.graves 1.21 //
7127 // For each provider that has at least one subscription, call
7128 // provider's enableIndications method
7129 //
7130 Array <JMPIProvider *> enableProviders;
|
7131 mark.hamzy 1.44
|
7132 carolann.graves 1.21 enableProviders = providerManager.getIndicationProvidersToEnable ();
7133
7134 Uint32 numProviders = enableProviders.size ();
|
7135 mark.hamzy 1.44
7136 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: numProviders = "<<numProviders<<PEGASUS_STD(endl));
7137
7138 #if 0
|
7139 carolann.graves 1.21 for (Uint32 i = 0; i < numProviders; i++)
7140 {
7141 try
7142 {
7143 CIMInstance provider;
|
7144 mark.hamzy 1.44
7145 provider = enableProviders[i]->getProviderInstance ();
7146
7147 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: name = "<<enableProviders[i]->getName ()<<PEGASUS_STD(endl));
|
7148 carolann.graves 1.21
7149 //
7150 // Get cached or load new provider module
7151 //
|
7152 mark.hamzy 1.44 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (enableProviders[i]->getModule ()->getFileName (),
7153 enableProviders[i]->getName ());
7154 indProvRecord *prec = NULL;
7155
7156 {
7157 AutoMutex lock (mutexProvTab);
7158
7159 provTab.lookup (enableProviders[i]->getName (), prec);
|
7160 carolann.graves 1.21 }
7161 }
7162 catch (CIMException & e)
7163 {
7164 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7165 "CIMException: " + e.getMessage ());
7166 }
7167 catch (Exception & e)
7168 {
7169 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7170 "Exception: " + e.getMessage ());
7171 }
7172 catch(...)
7173 {
7174 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7175 "Unknown error in handleSubscriptionInitCompleteRequest");
7176 }
7177 }
|
7178 mark.hamzy 1.44 #endif
|
7179 carolann.graves 1.21
7180 PEG_METHOD_EXIT ();
7181 return (response);
7182 }
7183
|
7184 schuur 1.1 Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw()
7185 {
|
7186 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleUnsupportedRequest");
7187
|
7188 konrad.r 1.16 CIMRequestMessage* request =
7189 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
7190 PEGASUS_ASSERT(request != 0 );
7191
7192 CIMResponseMessage* response = request->buildResponse();
7193 response->cimException =
7194 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
|
7195 schuur 1.1
7196 PEG_METHOD_EXIT();
|
7197 konrad.r 1.16 return response;
|
7198 schuur 1.1 }
7199
|
7200 kumpf 1.2 ProviderName JMPIProviderManager::_resolveProviderName(
7201 const ProviderIdContainer & providerId)
|
7202 schuur 1.1 {
|
7203 kumpf 1.2 String providerName;
7204 String fileName;
7205 String interfaceName;
7206 CIMValue genericValue;
7207
7208 genericValue = providerId.getProvider().getProperty(
7209 providerId.getProvider().findProperty("Name")).getValue();
7210 genericValue.get(providerName);
7211
7212 genericValue = providerId.getModule().getProperty(
7213 providerId.getModule().findProperty("Location")).getValue();
7214 genericValue.get(fileName);
7215 fileName = resolveFileName(fileName);
7216
7217 // ATTN: This attribute is probably not required
7218 genericValue = providerId.getModule().getProperty(
7219 providerId.getModule().findProperty("InterfaceType")).getValue();
7220 genericValue.get(interfaceName);
7221
7222 return ProviderName(providerName, fileName, interfaceName, 0);
|
7223 schuur 1.1 }
7224
7225 String JMPIProviderManager::resolveFileName(String fileName)
7226 {
7227 String name;
7228 #if defined(PEGASUS_OS_TYPE_WINDOWS)
7229 name = fileName; // + String(".dll");
7230 #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
7231 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
7232 name.append(String("/") + fileName); // + String(".sl"));
7233 #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
7234 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
7235 name.append(String("/") + fileName); // + String(".so"));
7236 #elif defined(PEGASUS_OS_OS400)
7237 name = filrName;
7238 #else
7239 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
7240 name.append(String("/") + fileName); // + String(".so"));
7241 #endif
7242 return name;
7243 }
7244 schuur 1.1
7245 PEGASUS_NAMESPACE_END
|
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI