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 JMPIjvm::checkException(env);
3101
3102 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
3103
3104 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
3105
3106 JMPIjvm::checkException(env);
3107
|
3108 mark.hamzy 1.45 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
3109 mark.hamzy 1.43 id,
3110 joc,
3111 jcop,
3112 jCc,
3113 jquery,
3114 jqueryLanguage);
3115
3116 JMPIjvm::checkException(env);
3117
3118 STAT_PMS_PROVIDEREND;
3119
3120 if (joc)
3121 {
3122 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
3123
3124 JMPIjvm::checkException(env);
3125 }
3126
|
3127 mark.hamzy 1.36 handler.processing();
|
3128 mark.hamzy 1.45 if (jAr) {
3129 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
3130 mark.hamzy 1.36 JMPIjvm::checkException(env);
3131
|
3132 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
3133 mark.hamzy 1.36
3134 JMPIjvm::checkException(env);
3135
3136 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
3137 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
3138
3139 JMPIjvm::checkException(env);
3140
3141 handler.deliver(*ciRet);
3142 }
3143 }
3144 handler.complete();
3145 break;
3146 }
3147
|
3148 mark.hamzy 1.43 case METHOD_INSTANCEPROVIDER:
|
3149 mark.hamzy 1.25 {
|
3150 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3151 mark.hamzy 1.25 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
3152
3153 JMPIjvm::checkException(env);
3154
3155 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
3156 jstring jquery = env->NewStringUTF(request->query.getCString());
3157
|
3158 mark.hamzy 1.40 CIMClass cls;
3159
3160 try
3161 {
3162 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
3163 AutoMutex lock (pr._cimomMutex);
3164
3165 cls = pr._cimom_handle->getClass(context,
3166 request->nameSpace,
3167 request->className,
3168 false,
3169 true,
3170 true,
3171 CIMPropertyList());
3172 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
3173 }
3174 catch (CIMException e)
3175 {
3176 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3177 throw;
3178 }
3179 mark.hamzy 1.40
|
3180 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
3181
|
3182 mark.hamzy 1.25 JMPIjvm::checkException(env);
3183
|
3184 mark.hamzy 1.27 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
|
3185 mark.hamzy 1.25
3186 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
3187
3188 JMPIjvm::checkException(env);
3189
3190 jint jql = 0; // @BUG - how to convert?
3191
3192 jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
3193 id,
3194 jcop,
3195 jquery,
3196 jql,
3197 jCc);
3198
3199 JMPIjvm::checkException(env);
3200
3201 STAT_PMS_PROVIDEREND;
3202
3203 handler.processing();
3204 if (jVec) {
3205 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
3206 mark.hamzy 1.25 JMPIjvm::checkException(env);
3207
|
3208 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jVec,i);
3209
|
3210 mark.hamzy 1.25 JMPIjvm::checkException(env);
3211
|
3212 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
3213 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
3214 mark.hamzy 1.25
3215 JMPIjvm::checkException(env);
3216
|
3217 mark.hamzy 1.29 handler.deliver(*ciRet);
|
3218 mark.hamzy 1.25 }
3219 }
3220 handler.complete();
3221 break;
3222 }
3223
3224 case METHOD_UNKNOWN:
3225 {
3226 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl));
3227 break;
3228 }
3229 }
|
3230 schuur 1.1 }
3231 HandlerCatch(handler);
|
3232 mark.hamzy 1.23
|
3233 schuur 1.1 if (env) JMPIjvm::detachThread();
|
3234 mark.hamzy 1.23
|
3235 schuur 1.1 PEG_METHOD_EXIT();
3236
|
3237 w.white 1.31 STAT_COPYDISPATCHER
3238
|
3239 schuur 1.1 return(response);
3240 }
3241
3242 Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()
3243 {
|
3244 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest");
3245
3246 HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>());
|
3247 schuur 1.1
|
3248 mark.hamzy 1.24 typedef enum {
3249 METHOD_UNKNOWN = 0,
|
3250 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
3251 METHOD_CIMASSOCIATORPROVIDER2,
3252 METHOD_ASSOCIATORPROVIDER,
3253 METHOD_ASSOCIATORPROVIDER2,
|
3254 mark.hamzy 1.24 } METHOD_VERSION;
3255 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3256 JNIEnv *env = NULL;
|
3257 schuur 1.13
|
3258 schuur 1.1 try {
3259 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3260 "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",
3261 System::getHostName(),
3262 request->nameSpace.getString(),
3263 request->objectName.getClassName().getString());
3264
|
3265 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));
|
3266 mark.hamzy 1.23
|
3267 schuur 1.1 // make target object path
|
3268 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3269 request->nameSpace,
3270 request->objectName.getClassName(),
3271 request->objectName.getKeyBindings());
3272 CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),
3273 request->nameSpace,
3274 request->assocClass.getString());
|
3275 schuur 1.1
3276 // resolve provider name
|
3277 kumpf 1.2 ProviderName name = _resolveProviderName(
3278 request->operationContext.get(ProviderIdContainer::NAME));
|
3279 schuur 1.1
3280 // get cached or load new provider module
|
3281 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
3282 name.getLogicalName(),
3283 String::EMPTY);
|
3284 schuur 1.1
|
3285 mark.hamzy 1.24 // convert arguments
|
3286 schuur 1.1 OperationContext context;
3287
|
3288 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
3289 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3290 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
3291 schuur 1.1
3292 // forward request
|
3293 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
3294
3295 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName());
|
3296 schuur 1.1
|
3297 mark.hamzy 1.24 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
|
3298 schuur 1.1
|
3299 mark.hamzy 1.24 JvmVector *jv = 0;
|
3300 schuur 1.1
|
3301 mark.hamzy 1.24 env = JMPIjvm::attachThread(&jv);
|
3302 schuur 1.1
|
3303 mark.hamzy 1.37 if (!env)
3304 {
3305 PEG_METHOD_EXIT();
3306
3307 STAT_COPYDISPATCHER
3308
3309 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3310 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
3311 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
3312 }
3313
|
3314 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
3315
3316 STAT_GETSTARTTIME;
3317
|
3318 mark.hamzy 1.43 jmethodID id = NULL;
3319 String interfaceType;
3320 String interfaceVersion;
3321
3322 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
3323 interfaceType,
3324 interfaceVersion);
3325
3326 if (interfaceType == "JMPI")
3327 {
3328 // public java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,
3329 // org.pegasus.jmpi.CIMObjectPath pathName,
3330 // java.lang.String resultClass,
3331 // java.lang.String role,
3332 // java.lang.String resultRole,
3333 // boolean includeQualifiers,
3334 // boolean includeClassOrigin,
3335 // java.lang.String[] propertyList)
3336 // throws org.pegasus.jmpi.CIMException
3337 //
3338 id = env->GetMethodID((jclass)pr.jProviderClass,
3339 mark.hamzy 1.43 "associators",
3340 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
3341 mark.hamzy 1.24
|
3342 mark.hamzy 1.43 if (id != NULL)
3343 {
3344 eMethodFound = METHOD_ASSOCIATORPROVIDER;
3345 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
3346 }
3347
3348 if (id == NULL)
3349 {
3350 env->ExceptionClear();
|
3351 mark.hamzy 1.24
|
3352 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMInstance[] associators (org.pegasus.jmpi.CIMObjectPath assocName,
3353 // org.pegasus.jmpi.CIMObjectPath pathName,
3354 // java.lang.String resultClass,
3355 // java.lang.String role,
3356 // java.lang.String resultRole,
3357 // boolean includeQualifiers,
3358 // boolean includeClassOrigin,
3359 // java.lang.String[] propertyList)
3360 // throws org.pegasus.jmpi.CIMException
3361 //
3362 id = env->GetMethodID((jclass)pr.jProviderClass,
3363 "associators",
3364 "(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;");
3365
3366 if (id != NULL)
3367 {
3368 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
3369 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
3370 }
3371 }
3372 }
3373 mark.hamzy 1.43 else if (interfaceType == "JMPIExperimental")
|
3374 mark.hamzy 1.24 {
|
3375 mark.hamzy 1.43 // public java.util.Vector associators (org.pegasus.jmpi.OperationContext oc,
3376 // org.pegasus.jmpi.CIMObjectPath assocName,
3377 // org.pegasus.jmpi.CIMObjectPath pathName,
3378 // java.lang.String resultClass,
3379 // java.lang.String role,
3380 // java.lang.String resultRole,
3381 // boolean includeQualifiers,
3382 // boolean includeClassOrigin,
3383 // java.lang.String[] propertyList)
3384 // throws org.pegasus.jmpi.CIMException
3385 //
3386 id = env->GetMethodID((jclass)pr.jProviderClass,
3387 "associators",
3388 "(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;");
|
3389 schuur 1.12
|
3390 mark.hamzy 1.43 if (id != NULL)
3391 {
3392 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
3393 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
3394 }
|
3395 mark.hamzy 1.24
|
3396 mark.hamzy 1.43 if (id == NULL)
3397 {
3398 env->ExceptionClear();
|
3399 mark.hamzy 1.24
|
3400 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMInstance[] associators (org.pegasus.jmpi.OperationContext oc,
3401 // org.pegasus.jmpi.CIMObjectPath assocName,
3402 // org.pegasus.jmpi.CIMObjectPath pathName,
3403 // java.lang.String resultClass,
3404 // java.lang.String role,
3405 // java.lang.String resultRole,
3406 // boolean includeQualifiers,
3407 // boolean includeClassOrigin,
3408 // java.lang.String[] propertyList)
3409 // throws org.pegasus.jmpi.CIMException
3410 //
3411 id = env->GetMethodID((jclass)pr.jProviderClass,
3412 "associators",
3413 "(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;");
3414
3415 if (id != NULL)
3416 {
3417 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
3418 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
3419 }
3420 }
|
3421 mark.hamzy 1.24 }
3422
3423 if (id == NULL)
3424 {
3425 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));
|
3426 mark.hamzy 1.43
3427 PEG_METHOD_EXIT();
3428
3429 STAT_COPYDISPATCHER
3430
3431 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3432 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
3433 "Could not find a method for the provider based on InterfaceType."));
|
3434 mark.hamzy 1.23 }
|
3435 mark.hamzy 1.24
|
3436 schuur 1.1 JMPIjvm::checkException(env);
3437
|
3438 mark.hamzy 1.24 switch (eMethodFound)
3439 {
|
3440 mark.hamzy 1.43 case METHOD_CIMASSOCIATORPROVIDER:
|
3441 mark.hamzy 1.24 {
|
3442 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
3443 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3444
3445 JMPIjvm::checkException(env);
3446
|
3447 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
3448 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
3449
3450 JMPIjvm::checkException(env);
3451
|
3452 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
3453 jstring jRole = env->NewStringUTF(request->role.getCString());
3454 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
3455
3456 JMPIjvm::checkException(env);
3457
3458 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
3459
|
3460 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
3461 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
|
3462 mark.hamzy 1.49 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
3463 mark.hamzy 1.29 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
3464 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
3465 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
3466 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3467 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3468 #endif
3469
|
3470 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
3471 mark.hamzy 1.24 id,
3472 jAssociationName,
|
3473 mark.hamzy 1.43 jPathName,
|
3474 mark.hamzy 1.24 jResultClass,
3475 jRole,
3476 jResultRole,
|
3477 mark.hamzy 1.36 JMPI_INCLUDE_QUALIFIERS,
3478 request->includeClassOrigin,
|
3479 mark.hamzy 1.24 jPropertyList);
|
3480 mark.hamzy 1.25
|
3481 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3482 schuur 1.13
|
3483 mark.hamzy 1.23 STAT_PMS_PROVIDEREND;
|
3484 schuur 1.1
|
3485 mark.hamzy 1.23 handler.processing();
|
3486 mark.hamzy 1.45 if (jAr) {
3487 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
3488 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3489 schuur 1.1
|
3490 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
3491 mark.hamzy 1.24
|
3492 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3493 schuur 1.13
|
3494 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
3495 schuur 1.13
|
3496 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3497 schuur 1.13
|
3498 mark.hamzy 1.29 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
3499 mark.hamzy 1.40 CIMClass cls;
3500
3501 try
3502 {
3503 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3504 AutoMutex lock (pr._cimomMutex);
3505
3506 cls = pr._cimom_handle->getClass(context,
3507 request->nameSpace,
3508 ciRet->getClassName(),
3509 false,
3510 true,
3511 true,
3512 CIMPropertyList());
3513 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3514 }
3515 catch (CIMException e)
3516 {
3517 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3518 throw;
3519 }
3520 mark.hamzy 1.40
|
3521 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
3522 CIMObjectPath iop = ciRet->buildPath(cls);
|
3523 mark.hamzy 1.24
|
3524 mark.hamzy 1.27 JMPIjvm::checkException(env);
3525
|
3526 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
3527 mark.hamzy 1.29 ciRet->setPath(iop);
|
3528 schuur 1.13
|
3529 mark.hamzy 1.29 handler.deliver(*ciRet);
|
3530 mark.hamzy 1.23 }
3531 }
|
3532 mark.hamzy 1.24 handler.complete();
3533 break;
|
3534 mark.hamzy 1.23 }
|
3535 mark.hamzy 1.24
|
3536 mark.hamzy 1.43 case METHOD_CIMASSOCIATORPROVIDER2:
|
3537 mark.hamzy 1.24 {
|
3538 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
3539 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
3540
|
3541 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
3542 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3543
3544 JMPIjvm::checkException(env);
3545
|
3546 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3547 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
3548
3549 JMPIjvm::checkException(env);
3550
|
3551 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
3552 jstring jRole = env->NewStringUTF(request->role.getCString());
3553 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
3554
3555 JMPIjvm::checkException(env);
3556
3557 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
3558
|
3559 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
3560 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
|
3561 mark.hamzy 1.47 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
3562 mark.hamzy 1.29 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
3563 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
3564 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
3565 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3566 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3567 #endif
3568
|
3569 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
3570 mark.hamzy 1.43 id,
3571 joc,
3572 jAssociationName,
3573 jPathName,
3574 jResultClass,
3575 jRole,
3576 jResultRole,
3577 JMPI_INCLUDE_QUALIFIERS,
3578 request->includeClassOrigin,
3579 jPropertyList);
|
3580 mark.hamzy 1.25
|
3581 mark.hamzy 1.23 JMPIjvm::checkException(env);
3582
3583 STAT_PMS_PROVIDEREND;
3584
|
3585 mark.hamzy 1.43 if (joc)
3586 {
3587 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
3588
3589 JMPIjvm::checkException(env);
3590 }
3591
|
3592 mark.hamzy 1.23 handler.processing();
|
3593 mark.hamzy 1.45 if (jAr) {
3594 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
3595 mark.hamzy 1.43 JMPIjvm::checkException(env);
3596
|
3597 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
3598 mark.hamzy 1.43
|
3599 mark.hamzy 1.23 JMPIjvm::checkException(env);
3600
|
3601 mark.hamzy 1.43 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
3602 mark.hamzy 1.24
|
3603 mark.hamzy 1.23 JMPIjvm::checkException(env);
3604
|
3605 mark.hamzy 1.43 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
3606 mark.hamzy 1.40 CIMClass cls;
3607
3608 try
3609 {
3610 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3611 AutoMutex lock (pr._cimomMutex);
3612
3613 cls = pr._cimom_handle->getClass(context,
3614 request->nameSpace,
3615 ciRet->getClassName(),
3616 false,
3617 true,
3618 true,
3619 CIMPropertyList());
3620 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3621 }
3622 catch (CIMException e)
3623 {
3624 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3625 throw;
3626 }
3627 mark.hamzy 1.40
|
3628 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
3629 CIMObjectPath iop = ciRet->buildPath(cls);
|
3630 mark.hamzy 1.24
|
3631 mark.hamzy 1.27 JMPIjvm::checkException(env);
3632
|
3633 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
3634 mark.hamzy 1.29 ciRet->setPath(iop);
|
3635 schuur 1.13
|
3636 mark.hamzy 1.29 handler.deliver(*ciRet);
|
3637 mark.hamzy 1.23 }
3638 }
|
3639 mark.hamzy 1.24 handler.complete();
3640 break;
3641 }
3642
|
3643 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
3644 mark.hamzy 1.24 {
|
3645 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
3646 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
|
3647 schuur 1.13
|
3648 mark.hamzy 1.43 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
3649 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
3650 schuur 1.13
|
3651 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3652 schuur 1.1
|
3653 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
3654 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
|
3655 w.white 1.31
|
3656 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3657 schuur 1.13
|
3658 mark.hamzy 1.43 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
3659 jstring jRole = env->NewStringUTF(request->role.getCString());
3660 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
|
3661 mark.hamzy 1.23
|
3662 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3663 schuur 1.1
|
3664 mark.hamzy 1.43 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
3665 schuur 1.13
|
3666 mark.hamzy 1.43 #ifdef PEGASUS_DEBUG
3667 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
|
3668 mark.hamzy 1.49 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
3669 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
3670 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
3671 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
3672 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3673 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3674 #endif
|
3675 schuur 1.1
|
3676 mark.hamzy 1.43 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
3677 id,
3678 joc,
3679 jAssociationName,
3680 jPathName,
3681 jResultClass,
3682 jRole,
3683 jResultRole,
3684 JMPI_INCLUDE_QUALIFIERS,
3685 request->includeClassOrigin,
3686 jPropertyList);
|
3687 mark.hamzy 1.23
|
3688 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3689 mark.hamzy 1.23
|
3690 mark.hamzy 1.43 STAT_PMS_PROVIDEREND;
|
3691 schuur 1.1
|
3692 mark.hamzy 1.43 if (joc)
3693 {
3694 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
|
3695 schuur 1.1
|
3696 mark.hamzy 1.43 JMPIjvm::checkException(env);
3697 }
|
3698 schuur 1.1
|
3699 mark.hamzy 1.43 handler.processing();
3700 if (jVec) {
|
3701 mark.hamzy 1.45 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
3702 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3703 schuur 1.1
|
3704 mark.hamzy 1.45 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
3705 schuur 1.1
|
3706 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3707 schuur 1.1
|
3708 mark.hamzy 1.43 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
3709 schuur 1.1
|
3710 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
3711 mark.hamzy 1.24
|
3712 mark.hamzy 1.43 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
3713 CIMClass cls;
|
3714 schuur 1.1
|
3715 mark.hamzy 1.43 try
3716 {
3717 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3718 AutoMutex lock (pr._cimomMutex);
3719
3720 cls = pr._cimom_handle->getClass(context,
3721 request->nameSpace,
3722 ciRet->getClassName(),
3723 false,
3724 true,
3725 true,
3726 CIMPropertyList());
3727 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3728 }
3729 catch (CIMException e)
3730 {
3731 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3732 throw;
3733 }
3734
3735 const CIMObjectPath& op = ciRet->getPath();
3736 mark.hamzy 1.43 CIMObjectPath iop = ciRet->buildPath(cls);
3737
3738 JMPIjvm::checkException(env);
3739
3740 iop.setNameSpace(op.getNameSpace());
3741 ciRet->setPath(iop);
3742
3743 handler.deliver(*ciRet);
3744 }
3745 }
3746 handler.complete();
3747 break;
3748 }
3749
3750 case METHOD_ASSOCIATORPROVIDER:
3751 {
3752 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
3753 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3754
3755 JMPIjvm::checkException(env);
3756
3757 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
3758 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
3759
3760 JMPIjvm::checkException(env);
3761
3762 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
3763 jstring jRole = env->NewStringUTF(request->role.getCString());
3764 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
3765
3766 JMPIjvm::checkException(env);
3767
3768 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
3769
3770 #ifdef PEGASUS_DEBUG
3771 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
3772 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
3773 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
3774 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
3775 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
3776 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3777 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3778 mark.hamzy 1.43 #endif
3779
3780 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
3781 mark.hamzy 1.49 id,
3782 jAssociationName,
3783 jPathName,
3784 jResultClass,
3785 jRole,
3786 jResultRole,
3787 JMPI_INCLUDE_QUALIFIERS,
3788 request->includeClassOrigin,
3789 jPropertyList);
|
3790 mark.hamzy 1.43
3791 JMPIjvm::checkException(env);
3792
3793 STAT_PMS_PROVIDEREND;
3794
3795 handler.processing();
3796 if (jVec) {
3797 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
3798 JMPIjvm::checkException(env);
3799
3800 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
3801
3802 JMPIjvm::checkException(env);
3803
3804 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
3805 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
3806 CIMClass cls;
3807
3808 try
3809 {
3810 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3811 mark.hamzy 1.43 AutoMutex lock (pr._cimomMutex);
3812
3813 cls = pr._cimom_handle->getClass(context,
3814 request->nameSpace,
3815 ciRet->getClassName(),
3816 false,
3817 true,
3818 true,
3819 CIMPropertyList());
3820 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3821 }
3822 catch (CIMException e)
3823 {
3824 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3825 throw;
3826 }
3827
3828 const CIMObjectPath& op = ciRet->getPath();
3829 CIMObjectPath iop = ciRet->buildPath(cls);
3830
3831 JMPIjvm::checkException(env);
3832 mark.hamzy 1.43
3833 iop.setNameSpace(op.getNameSpace());
3834 ciRet->setPath(iop);
3835
3836 handler.deliver(*ciRet);
3837 }
3838 }
3839 handler.complete();
3840 break;
3841 }
3842
3843 case METHOD_UNKNOWN:
3844 {
3845 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));
3846 break;
3847 }
3848 }
3849 }
3850 HandlerCatch(handler);
3851
3852 if (env) JMPIjvm::detachThread();
3853 mark.hamzy 1.43
3854 PEG_METHOD_EXIT();
3855
3856 STAT_COPYDISPATCHER
3857
3858 return(response);
3859 }
3860
3861 Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()
3862 {
3863 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest");
3864
3865 HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>());
3866
3867 typedef enum {
3868 METHOD_UNKNOWN = 0,
3869 METHOD_CIMASSOCIATORPROVIDER,
3870 METHOD_CIMASSOCIATORPROVIDER2,
3871 METHOD_ASSOCIATORPROVIDER,
3872 METHOD_ASSOCIATORPROVIDER2
3873 } METHOD_VERSION;
3874 mark.hamzy 1.43 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3875 JNIEnv *env = NULL;
3876
3877 try {
3878 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3879 "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2",
3880 System::getHostName(),
3881 request->nameSpace.getString(),
3882 request->objectName.getClassName().getString());
3883
3884 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));
3885
3886 // make target object path
3887 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3888 request->nameSpace,
3889 request->objectName.getClassName(),
3890 request->objectName.getKeyBindings());
3891 CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),
3892 request->nameSpace,
3893 request->assocClass.getString());
3894
3895 mark.hamzy 1.43 // resolve provider name
3896 ProviderName name = _resolveProviderName(
3897 request->operationContext.get(ProviderIdContainer::NAME));
3898
3899 // get cached or load new provider module
3900 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
3901 name.getLogicalName(),
3902 String::EMPTY);
3903
3904 // forward request
3905 JMPIProvider &pr = ph.GetProvider();
3906
3907 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName());
3908
3909 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: Calling provider associatorNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
3910
3911 JvmVector *jv = 0;
3912
3913 env = JMPIjvm::attachThread(&jv);
3914
3915 if (!env)
3916 mark.hamzy 1.43 {
3917 PEG_METHOD_EXIT();
|
3918 mark.hamzy 1.37
3919 STAT_COPYDISPATCHER
3920
3921 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3922 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
3923 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
3924 }
3925
|
3926 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
3927
3928 STAT_GETSTARTTIME;
3929
|
3930 mark.hamzy 1.43 jmethodID id = NULL;
3931 String interfaceType;
3932 String interfaceVersion;
3933
3934 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
3935 interfaceType,
3936 interfaceVersion);
3937
3938 if (interfaceType == "JMPI")
3939 {
3940 // public java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
3941 // org.pegasus.jmpi.CIMObjectPath pathName,
3942 // java.lang.String resultClass,
3943 // java.lang.String role,
3944 // java.lang.String resultRole)
3945 // throws org.pegasus.jmpi.CIMException
3946 id = env->GetMethodID((jclass)pr.jProviderClass,
3947 "associatorNames",
3948 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
3949
3950 if (id != NULL)
3951 mark.hamzy 1.43 {
3952 eMethodFound = METHOD_ASSOCIATORPROVIDER;
3953 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
3954 }
|
3955 mark.hamzy 1.24
|
3956 mark.hamzy 1.43 if (id == NULL)
3957 {
3958 env->ExceptionClear();
|
3959 mark.hamzy 1.24
|
3960 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
3961 // org.pegasus.jmpi.CIMObjectPath pathName,
3962 // java.lang.String resultClass,
3963 // java.lang.String role,
3964 // java.lang.String resultRole)
3965 // throws org.pegasus.jmpi.CIMException
3966 id = env->GetMethodID((jclass)pr.jProviderClass,
3967 "associatorNames",
3968 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
3969
3970 if (id != NULL)
3971 {
3972 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
3973 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
3974 }
3975 }
3976 }
3977 else if (interfaceType == "JMPIExperimental")
|
3978 mark.hamzy 1.24 {
|
3979 mark.hamzy 1.43 // public java.util.Vector associatorNames (org.pegasus.jmpi.OperationContext oc,
3980 // org.pegasus.jmpi.CIMObjectPath assocName,
3981 // org.pegasus.jmpi.CIMObjectPath pathName,
3982 // java.lang.String resultClass,
3983 // java.lang.String role,
3984 // java.lang.String resultRole)
3985 // throws org.pegasus.jmpi.CIMException
3986 id = env->GetMethodID((jclass)pr.jProviderClass,
3987 "associatorNames",
3988 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
|
3989 mark.hamzy 1.24
|
3990 mark.hamzy 1.43 if (id != NULL)
3991 {
3992 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
3993 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
3994 }
|
3995 mark.hamzy 1.24
|
3996 mark.hamzy 1.43 if (id == NULL)
3997 {
3998 env->ExceptionClear();
|
3999 mark.hamzy 1.24
|
4000 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMObjectPath[] associatorNames (org.pegasus.jmpi.OperationContext oc,
4001 // org.pegasus.jmpi.CIMObjectPath assocName,
4002 // org.pegasus.jmpi.CIMObjectPath pathName,
4003 // java.lang.String resultClass,
4004 // java.lang.String role,
4005 // java.lang.String resultRole)
4006 // throws org.pegasus.jmpi.CIMException
4007 id = env->GetMethodID((jclass)pr.jProviderClass,
4008 "associatorNames",
4009 "(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;");
4010
4011 if (id != NULL)
4012 {
4013 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
4014 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
4015 }
4016 }
|
4017 mark.hamzy 1.24 }
|
4018 schuur 1.13
|
4019 mark.hamzy 1.24 if (id == NULL)
4020 {
4021 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl));
|
4022 mark.hamzy 1.43
4023 PEG_METHOD_EXIT();
4024
4025 STAT_COPYDISPATCHER
4026
4027 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4028 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
4029 "Could not find a method for the provider based on InterfaceType."));
|
4030 mark.hamzy 1.23 }
|
4031 mark.hamzy 1.24
|
4032 schuur 1.1 JMPIjvm::checkException(env);
4033
|
4034 mark.hamzy 1.24 switch (eMethodFound)
4035 {
|
4036 mark.hamzy 1.43 case METHOD_CIMASSOCIATORPROVIDER:
4037 {
4038 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
4039 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4040
4041 JMPIjvm::checkException(env);
4042
4043 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4044 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4045
4046 JMPIjvm::checkException(env);
4047
4048 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
4049 jstring jRole = env->NewStringUTF(request->role.getCString());
4050 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
4051
4052 JMPIjvm::checkException(env);
4053
4054 #ifdef PEGASUS_DEBUG
4055 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
4056 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
4057 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4058 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
4059 #endif
4060
|
4061 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
4062 mark.hamzy 1.43 id,
4063 jAssociationName,
4064 jPathName,
4065 jResultClass,
4066 jRole,
4067 jResultRole);
4068
4069 JMPIjvm::checkException(env);
4070
4071 STAT_PMS_PROVIDEREND;
4072
4073 handler.processing();
|
4074 mark.hamzy 1.45 if (jAr) {
4075 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4076 mark.hamzy 1.43 JMPIjvm::checkException(env);
4077
|
4078 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
4079 mark.hamzy 1.43
4080 JMPIjvm::checkException(env);
4081
4082 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
4083 mark.hamzy 1.50 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
4084 mark.hamzy 1.43
4085 JMPIjvm::checkException(env);
4086
4087 handler.deliver(*copRet);
4088 }
4089 }
4090 handler.complete();
4091 break;
4092 }
4093
4094 case METHOD_CIMASSOCIATORPROVIDER2:
|
4095 mark.hamzy 1.24 {
|
4096 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
4097 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
|
4098 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
4099 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4100
4101 JMPIjvm::checkException(env);
4102
|
4103 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4104 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4105
4106 JMPIjvm::checkException(env);
4107
|
4108 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
4109 jstring jRole = env->NewStringUTF(request->role.getCString());
4110 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
4111
4112 JMPIjvm::checkException(env);
4113
|
4114 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
4115 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
4116 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
4117 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4118 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
4119 #endif
4120
|
4121 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
4122 mark.hamzy 1.24 id,
|
4123 mark.hamzy 1.43 joc,
|
4124 mark.hamzy 1.24 jAssociationName,
|
4125 mark.hamzy 1.43 jPathName,
|
4126 mark.hamzy 1.24 jResultClass,
4127 jRole,
4128 jResultRole);
|
4129 mark.hamzy 1.25
|
4130 mark.hamzy 1.23 JMPIjvm::checkException(env);
4131
4132 STAT_PMS_PROVIDEREND;
4133
|
4134 mark.hamzy 1.43 if (joc)
4135 {
4136 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
4137
4138 JMPIjvm::checkException(env);
4139 }
4140
|
4141 mark.hamzy 1.23 handler.processing();
|
4142 mark.hamzy 1.45 if (jAr) {
4143 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4144 mark.hamzy 1.23 JMPIjvm::checkException(env);
4145
|
4146 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
4147 mark.hamzy 1.24
|
4148 mark.hamzy 1.23 JMPIjvm::checkException(env);
4149
|
4150 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
4151 mark.hamzy 1.50 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
4152 mark.hamzy 1.23
4153 JMPIjvm::checkException(env);
4154
|
4155 mark.hamzy 1.29 handler.deliver(*copRet);
|
4156 mark.hamzy 1.23 }
4157 }
4158 handler.complete();
|
4159 mark.hamzy 1.24 break;
|
4160 mark.hamzy 1.23 }
|
4161 mark.hamzy 1.24
|
4162 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
4163 {
4164 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
4165 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4166
4167 JMPIjvm::checkException(env);
4168
4169 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4170 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4171
4172 JMPIjvm::checkException(env);
4173
4174 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
4175 jstring jRole = env->NewStringUTF(request->role.getCString());
4176 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
4177
4178 JMPIjvm::checkException(env);
4179
4180 #ifdef PEGASUS_DEBUG
4181 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
4182 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
4183 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
4184 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4185 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
4186 #endif
4187
4188 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
4189 id,
4190 jAssociationName,
4191 jPathName,
4192 jResultClass,
4193 jRole,
4194 jResultRole);
4195
4196 JMPIjvm::checkException(env);
4197
4198 STAT_PMS_PROVIDEREND;
4199
4200 handler.processing();
4201 if (jVec) {
4202 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
4203 JMPIjvm::checkException(env);
4204 mark.hamzy 1.43
4205 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
4206
4207 JMPIjvm::checkException(env);
4208
4209 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
4210 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
4211
4212 JMPIjvm::checkException(env);
4213
4214 handler.deliver(*copRet);
4215 }
4216 }
4217 handler.complete();
4218 break;
4219 }
4220
4221 case METHOD_ASSOCIATORPROVIDER2:
|
4222 mark.hamzy 1.24 {
|
4223 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
4224 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
4225
|
4226 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
4227 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4228
4229 JMPIjvm::checkException(env);
4230
|
4231 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
4232 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4233
4234 JMPIjvm::checkException(env);
4235
|
4236 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
4237 jstring jRole = env->NewStringUTF(request->role.getCString());
4238 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
4239
4240 JMPIjvm::checkException(env);
4241
|
4242 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
4243 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
4244 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
4245 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
4246 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4247 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
4248 #endif
4249
|
4250 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
4251 id,
|
4252 mark.hamzy 1.43 joc,
|
4253 mark.hamzy 1.24 jAssociationName,
|
4254 mark.hamzy 1.29 jPathName,
|
4255 mark.hamzy 1.24 jResultClass,
4256 jRole,
4257 jResultRole);
|
4258 mark.hamzy 1.25
|
4259 mark.hamzy 1.23 JMPIjvm::checkException(env);
4260
4261 STAT_PMS_PROVIDEREND;
|
4262 schuur 1.13
|
4263 mark.hamzy 1.43 if (joc)
4264 {
4265 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
4266
4267 JMPIjvm::checkException(env);
4268 }
4269
|
4270 mark.hamzy 1.23 handler.processing();
|
4271 mark.hamzy 1.24 if (jVec) {
|
4272 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
4273 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4274 schuur 1.13
|
4275 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
4276 mark.hamzy 1.24
|
4277 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4278 schuur 1.13
|
4279 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
4280 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
4281 schuur 1.1
|
4282 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4283 schuur 1.1
|
4284 mark.hamzy 1.29 handler.deliver(*copRet);
|
4285 mark.hamzy 1.23 }
4286 }
4287 handler.complete();
|
4288 mark.hamzy 1.24 break;
4289 }
4290
4291 case METHOD_UNKNOWN:
4292 {
4293 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: should not be here!"<<PEGASUS_STD(endl));
4294 break;
4295 }
|
4296 mark.hamzy 1.23 }
|
4297 schuur 1.1 }
4298 HandlerCatch(handler);
|
4299 schuur 1.12
|
4300 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
|
4301 schuur 1.12
|
4302 schuur 1.1 PEG_METHOD_EXIT();
4303
|
4304 w.white 1.31 STAT_COPYDISPATCHER
4305
|
4306 schuur 1.1 return(response);
4307 }
4308
4309 Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw()
4310 {
|
4311 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest");
4312
4313 HandlerIntro(References,message,request,response,handler,Array<CIMObject>());
|
4314 schuur 1.1
|
4315 mark.hamzy 1.24 typedef enum {
4316 METHOD_UNKNOWN = 0,
|
4317 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
4318 METHOD_CIMASSOCIATORPROVIDER2,
4319 METHOD_ASSOCIATORPROVIDER,
4320 METHOD_ASSOCIATORPROVIDER2,
|
4321 mark.hamzy 1.24 } METHOD_VERSION;
4322 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
4323 JNIEnv *env = NULL;
|
4324 schuur 1.13
|
4325 schuur 1.1 try {
4326 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
4327 konrad.r 1.15 "JMPIProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",
|
4328 schuur 1.1 System::getHostName(),
4329 request->nameSpace.getString(),
4330 request->objectName.getClassName().getString());
4331
|
4332 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));
|
4333 mark.hamzy 1.23
|
4334 schuur 1.1 // make target object path
|
4335 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
4336 request->nameSpace,
4337 request->objectName.getClassName(),
4338 request->objectName.getKeyBindings());
4339 CIMObjectPath *resultPath = new CIMObjectPath (System::getHostName(),
4340 request->nameSpace,
4341 request->resultClass.getString());
|
4342 schuur 1.1
4343 // resolve provider name
|
4344 kumpf 1.2 ProviderName name = _resolveProviderName(
4345 request->operationContext.get(ProviderIdContainer::NAME));
|
4346 schuur 1.1
|
4347 mark.hamzy 1.43 // get cached or load new provider module
4348 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
4349 name.getLogicalName(),
4350 String::EMPTY);
4351
4352 // convert arguments
4353 OperationContext context;
4354
4355 context.insert(request->operationContext.get(IdentityContainer::NAME));
4356 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
4357 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
4358
4359 // forward request
4360 JMPIProvider &pr = ph.GetProvider();
4361
4362 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.references: " + pr.getName());
4363
4364 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Calling provider references: "<<pr.getName()<<", role: "<<request->role<<" aCls: "<<request->resultClass<<PEGASUS_STD(endl));
4365
4366 JvmVector *jv = 0;
4367
4368 mark.hamzy 1.43 env = JMPIjvm::attachThread(&jv);
4369
4370 if (!env)
4371 {
4372 PEG_METHOD_EXIT();
4373
4374 STAT_COPYDISPATCHER
4375
4376 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4377 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
4378 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
4379 }
4380
4381 JMPIProvider::pm_service_op_lock op_lock(&pr);
4382
4383 STAT_GETSTARTTIME;
4384
4385 jmethodID id = NULL;
4386 String interfaceType;
4387 String interfaceVersion;
4388
4389 mark.hamzy 1.43 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
4390 interfaceType,
4391 interfaceVersion);
4392
4393 if (interfaceType == "JMPI")
4394 {
4395 // public java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,
4396 // org.pegasus.jmpi.CIMObjectPath pathName,
4397 // java.lang.String role,
4398 // boolean includeQualifiers,
4399 // boolean includeClassOrigin,
4400 // java.lang.String[] propertyList)
4401 // throws org.pegasus.jmpi.CIMException
4402 id = env->GetMethodID((jclass)pr.jProviderClass,
4403 "references",
4404 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
4405
4406 if (id != NULL)
4407 {
4408 eMethodFound = METHOD_ASSOCIATORPROVIDER;
4409 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
4410 mark.hamzy 1.43 }
4411
4412 if (id == NULL)
4413 {
4414 env->ExceptionClear();
4415
4416 // public org.pegasus.jmpi.CIMInstance[] references (org.pegasus.jmpi.CIMObjectPath assocName,
4417 // org.pegasus.jmpi.CIMObjectPath pathName,
4418 // java.lang.String role,
4419 // boolean includeQualifiers,
4420 // boolean includeClassOrigin,
4421 // java.lang.String[] propertyList)
4422 // throws org.pegasus.jmpi.CIMException
4423 id = env->GetMethodID((jclass)pr.jProviderClass,
4424 "references",
4425 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
4426
4427 if (id != NULL)
4428 {
4429 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
4430 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
4431 mark.hamzy 1.43 }
4432 }
4433 }
4434 else if (interfaceType == "JMPIExperimental")
4435 {
4436 // public java.util.Vector references (org.pegasus.jmpi.OperationContext oc,
4437 // org.pegasus.jmpi.CIMObjectPath assocName,
4438 // org.pegasus.jmpi.CIMObjectPath pathName,
4439 // java.lang.String role,
4440 // boolean includeQualifiers,
4441 // boolean includeClassOrigin,
4442 // java.lang.String[] propertyList)
4443 // throws org.pegasus.jmpi.CIMException
4444 id = env->GetMethodID((jclass)pr.jProviderClass,
4445 "references",
|
4446 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;");
|
4447 mark.hamzy 1.43
4448 if (id != NULL)
4449 {
4450 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
4451 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
4452 }
4453
4454 if (id == NULL)
4455 {
4456 env->ExceptionClear();
4457
4458 // public org.pegasus.jmpi.CIMInstance[] references (org.pegasus.jmpi.OperationContext oc,
4459 // org.pegasus.jmpi.CIMObjectPath assocName,
4460 // org.pegasus.jmpi.CIMObjectPath pathName,
4461 // java.lang.String role,
4462 // boolean includeQualifiers,
4463 // boolean includeClassOrigin,
4464 // java.lang.String[] propertyList)
4465 // throws org.pegasus.jmpi.CIMException
4466 id = env->GetMethodID((jclass)pr.jProviderClass,
4467 "references",
4468 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;");
4469
4470 if (id != NULL)
4471 {
4472 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
4473 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
4474 }
4475 }
4476 }
4477
4478 if (id == NULL)
4479 {
4480 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found no method!"<<PEGASUS_STD(endl));
4481
4482 PEG_METHOD_EXIT();
4483
4484 STAT_COPYDISPATCHER
4485
4486 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4487 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
4488 "Could not find a method for the provider based on InterfaceType."));
4489 mark.hamzy 1.43 }
4490
4491 JMPIjvm::checkException(env);
4492
4493 switch (eMethodFound)
4494 {
4495 case METHOD_CIMASSOCIATORPROVIDER:
4496 {
4497 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
4498 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4499
4500 JMPIjvm::checkException(env);
4501
4502 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4503 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4504
4505 JMPIjvm::checkException(env);
4506
4507 jstring jRole = env->NewStringUTF(request->role.getCString());
4508
4509 JMPIjvm::checkException(env);
4510 mark.hamzy 1.43
4511 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
4512
4513 #ifdef PEGASUS_DEBUG
4514 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
4515 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4516 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
4517 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
4518 #endif
4519
|
4520 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
4521 mark.hamzy 1.43 id,
4522 jAssociationName,
4523 jPathName,
4524 jRole,
4525 JMPI_INCLUDE_QUALIFIERS,
4526 request->includeClassOrigin,
4527 jPropertyList);
4528
4529 JMPIjvm::checkException(env);
4530
4531 STAT_PMS_PROVIDEREND;
4532
4533 handler.processing();
|
4534 mark.hamzy 1.45 if (jAr) {
4535 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4536 mark.hamzy 1.43 JMPIjvm::checkException(env);
4537
|
4538 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
4539 mark.hamzy 1.43
4540 JMPIjvm::checkException(env);
4541
4542 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
4543
4544 JMPIjvm::checkException(env);
4545
4546 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
4547 CIMClass cls;
4548
4549 try
4550 {
4551 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4552 AutoMutex lock (pr._cimomMutex);
4553
4554 cls = pr._cimom_handle->getClass(context,
4555 request->nameSpace,
4556 ciRet->getClassName(),
4557 false,
4558 true,
4559 true,
4560 mark.hamzy 1.43 CIMPropertyList());
4561 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4562 }
4563 catch (CIMException e)
4564 {
4565 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
4566 throw;
4567 }
4568
4569 const CIMObjectPath& op = ciRet->getPath();
4570 CIMObjectPath iop = ciRet->buildPath(cls);
4571
4572 JMPIjvm::checkException(env);
4573
4574 iop.setNameSpace(op.getNameSpace());
4575 ciRet->setPath(iop);
4576
4577 handler.deliver(*ciRet);
4578 }
4579 }
4580 handler.complete();
4581 mark.hamzy 1.43 break;
4582 }
4583
4584 case METHOD_CIMASSOCIATORPROVIDER2:
4585 {
4586 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
4587 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
4588
4589 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
4590 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4591
4592 JMPIjvm::checkException(env);
4593
4594 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4595 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4596
4597 JMPIjvm::checkException(env);
4598
4599 jstring jRole = env->NewStringUTF(request->role.getCString());
4600
4601 JMPIjvm::checkException(env);
4602 mark.hamzy 1.43
4603 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
4604 schuur 1.1
|
4605 mark.hamzy 1.43 #ifdef PEGASUS_DEBUG
4606 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
4607 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4608 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
4609 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
4610 #endif
|
4611 schuur 1.1
|
4612 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
4613 mark.hamzy 1.43 id,
4614 joc,
4615 jAssociationName,
4616 jPathName,
4617 jRole,
4618 JMPI_INCLUDE_QUALIFIERS,
4619 request->includeClassOrigin,
4620 jPropertyList);
|
4621 schuur 1.1
|
4622 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4623 mark.hamzy 1.24
|
4624 mark.hamzy 1.43 STAT_PMS_PROVIDEREND;
|
4625 schuur 1.1
|
4626 mark.hamzy 1.43 if (joc)
4627 {
4628 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
|
4629 schuur 1.1
|
4630 mark.hamzy 1.43 JMPIjvm::checkException(env);
4631 }
|
4632 schuur 1.1
|
4633 mark.hamzy 1.43 handler.processing();
|
4634 mark.hamzy 1.45 if (jAr) {
4635 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
4636 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4637 schuur 1.1
|
4638 mark.hamzy 1.45 jobject jciRet = env->GetObjectArrayElement(jAr,i);
|
4639 mark.hamzy 1.37
|
4640 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4641 mark.hamzy 1.37
|
4642 mark.hamzy 1.43 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
4643 mark.hamzy 1.37
|
4644 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4645 schuur 1.1
|
4646 mark.hamzy 1.43 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
4647 CIMClass cls;
|
4648 schuur 1.1
|
4649 mark.hamzy 1.43 try
4650 {
4651 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4652 AutoMutex lock (pr._cimomMutex);
|
4653 mark.hamzy 1.24
|
4654 mark.hamzy 1.43 cls = pr._cimom_handle->getClass(context,
4655 request->nameSpace,
4656 ciRet->getClassName(),
4657 false,
4658 true,
4659 true,
4660 CIMPropertyList());
4661 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4662 }
4663 catch (CIMException e)
4664 {
4665 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
4666 throw;
4667 }
|
4668 mark.hamzy 1.24
|
4669 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
4670 CIMObjectPath iop = ciRet->buildPath(cls);
|
4671 mark.hamzy 1.24
|
4672 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4673 mark.hamzy 1.24
|
4674 mark.hamzy 1.43 iop.setNameSpace(op.getNameSpace());
4675 ciRet->setPath(iop);
|
4676 mark.hamzy 1.24
|
4677 mark.hamzy 1.43 handler.deliver(*ciRet);
4678 }
|
4679 mark.hamzy 1.24 }
|
4680 mark.hamzy 1.43 handler.complete();
4681 break;
|
4682 mark.hamzy 1.24 }
|
4683 schuur 1.12
|
4684 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
|
4685 mark.hamzy 1.24 {
|
4686 mark.hamzy 1.43 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
4687 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
4688 mark.hamzy 1.24
|
4689 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
4690 schuur 1.1
|
4691 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4692 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
|
4693 mark.hamzy 1.25
4694 JMPIjvm::checkException(env);
4695
4696 jstring jRole = env->NewStringUTF(request->role.getCString());
4697
4698 JMPIjvm::checkException(env);
4699
4700 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
4701
|
4702 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
4703 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
|
4704 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
4705 mark.hamzy 1.29 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4706 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
4707 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
4708 #endif
4709
|
4710 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
4711 id,
4712 jAssociationName,
|
4713 mark.hamzy 1.43 jPathName,
|
4714 mark.hamzy 1.24 jRole,
|
4715 mark.hamzy 1.36 JMPI_INCLUDE_QUALIFIERS,
4716 request->includeClassOrigin,
|
4717 mark.hamzy 1.24 jPropertyList);
|
4718 mark.hamzy 1.25
|
4719 mark.hamzy 1.23 JMPIjvm::checkException(env);
4720
4721 STAT_PMS_PROVIDEREND;
4722
4723 handler.processing();
4724 if (jVec) {
|
4725 mark.hamzy 1.43 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
4726 mark.hamzy 1.23 JMPIjvm::checkException(env);
4727
|
4728 mark.hamzy 1.43 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
4729 mark.hamzy 1.24
|
4730 mark.hamzy 1.23 JMPIjvm::checkException(env);
4731
|
4732 mark.hamzy 1.43 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
4733 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
4734 mark.hamzy 1.40 CIMClass cls;
4735
4736 try
4737 {
4738 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4739 AutoMutex lock (pr._cimomMutex);
4740
4741 cls = pr._cimom_handle->getClass(context,
4742 request->nameSpace,
4743 ciRet->getClassName(),
4744 false,
4745 true,
4746 true,
4747 CIMPropertyList());
4748 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4749 }
4750 catch (CIMException e)
4751 {
4752 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
4753 throw;
4754 }
4755 mark.hamzy 1.40
|
4756 mark.hamzy 1.43 const CIMObjectPath& op = ciRet->getPath();
4757 CIMObjectPath iop = ciRet->buildPath(cls);
|
4758 mark.hamzy 1.24
|
4759 mark.hamzy 1.27 JMPIjvm::checkException(env);
4760
|
4761 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
4762 mark.hamzy 1.29 ciRet->setPath(iop);
|
4763 schuur 1.13
|
4764 mark.hamzy 1.29 handler.deliver(*ciRet);
|
4765 mark.hamzy 1.23 }
4766 }
4767 handler.complete();
|
4768 mark.hamzy 1.24 break;
|
4769 mark.hamzy 1.23 }
|
4770 schuur 1.1
|
4771 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
4772 mark.hamzy 1.24 {
|
4773 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
4774 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
4775
|
4776 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
4777 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
4778
4779 JMPIjvm::checkException(env);
4780
|
4781 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
4782 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
4783
4784 JMPIjvm::checkException(env);
4785
|
4786 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
4787
4788 JMPIjvm::checkException(env);
4789
4790 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
4791
|
4792 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
4793 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
4794 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
4795 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
4796 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
4797 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
4798 #endif
4799
|
4800 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
4801 id,
|
4802 mark.hamzy 1.43 joc,
|
4803 mark.hamzy 1.24 jAssociationName,
4804 jPathName,
4805 jRole,
|
4806 mark.hamzy 1.32 JMPI_INCLUDE_QUALIFIERS,
4807 request->includeClassOrigin,
|
4808 mark.hamzy 1.24 jPropertyList);
|
4809 mark.hamzy 1.25
|
4810 mark.hamzy 1.24 JMPIjvm::checkException(env);
4811
4812 STAT_PMS_PROVIDEREND;
4813
|
4814 mark.hamzy 1.43 if (joc)
4815 {
4816 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
4817
4818 JMPIjvm::checkException(env);
4819 }
4820
|
4821 mark.hamzy 1.24 handler.processing();
4822 if (jVec) {
|
4823 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
4824 mark.hamzy 1.24 JMPIjvm::checkException(env);
4825
|
4826 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
4827 mark.hamzy 1.24
4828 JMPIjvm::checkException(env);
4829
|
4830 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
4831 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
4832 mark.hamzy 1.40 CIMClass cls;
4833
4834 try
4835 {
4836 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4837 AutoMutex lock (pr._cimomMutex);
4838
4839 cls = pr._cimom_handle->getClass(context,
4840 request->nameSpace,
4841 ciRet->getClassName(),
4842 false,
4843 true,
4844 true,
4845 CIMPropertyList());
4846 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
4847 }
4848 catch (CIMException e)
4849 {
4850 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
4851 throw;
4852 }
4853 mark.hamzy 1.40
|
4854 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
4855 CIMObjectPath iop = ciRet->buildPath(cls);
|
4856 schuur 1.1
|
4857 mark.hamzy 1.27 JMPIjvm::checkException(env);
4858
|
4859 mark.hamzy 1.24 iop.setNameSpace(op.getNameSpace());
|
4860 mark.hamzy 1.29 ciRet->setPath(iop);
|
4861 schuur 1.12
|
4862 mark.hamzy 1.29 handler.deliver(*ciRet);
|
4863 mark.hamzy 1.24 }
4864 }
4865 handler.complete();
4866 break;
4867 }
|
4868 mark.hamzy 1.23
|
4869 mark.hamzy 1.24 case METHOD_UNKNOWN:
4870 {
|
4871 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: should not be here!"<<PEGASUS_STD(endl));
|
4872 mark.hamzy 1.24 break;
4873 }
|
4874 mark.hamzy 1.23 }
|
4875 schuur 1.1 }
4876 HandlerCatch(handler);
|
4877 schuur 1.12
4878 if (env) JMPIjvm::detachThread();
4879
|
4880 schuur 1.1 PEG_METHOD_EXIT();
4881
|
4882 w.white 1.31 STAT_COPYDISPATCHER
4883
|
4884 schuur 1.1 return(response);
4885 }
4886
4887 Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw()
4888 {
|
4889 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest");
4890
4891 HandlerIntro(ReferenceNames,message,request,response,handler,Array<CIMObjectPath>());
|
4892 schuur 1.1
|
4893 mark.hamzy 1.24 typedef enum {
4894 METHOD_UNKNOWN = 0,
|
4895 mark.hamzy 1.43 METHOD_CIMASSOCIATORPROVIDER,
4896 METHOD_CIMASSOCIATORPROVIDER2,
4897 METHOD_ASSOCIATORPROVIDER,
4898 METHOD_ASSOCIATORPROVIDER2,
|
4899 mark.hamzy 1.24 } METHOD_VERSION;
4900 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
4901 JNIEnv *env = NULL;
|
4902 schuur 1.13
|
4903 schuur 1.1 try {
4904 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
4905 "JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
4906 System::getHostName(),
4907 request->nameSpace.getString(),
4908 request->objectName.getClassName().getString());
4909
|
4910 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));
4911
|
4912 schuur 1.1 // make target object path
|
4913 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
4914 request->nameSpace,
4915 request->objectName.getClassName(),
4916 request->objectName.getKeyBindings());
4917 CIMObjectPath *resultPath = new CIMObjectPath (System::getHostName(),
4918 request->nameSpace,
4919 request->resultClass.getString());
|
4920 schuur 1.1
4921 // resolve provider name
|
4922 kumpf 1.2 ProviderName name = _resolveProviderName(
4923 request->operationContext.get(ProviderIdContainer::NAME));
|
4924 schuur 1.1
4925 // get cached or load new provider module
|
4926 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
4927 name.getLogicalName(),
4928 String::EMPTY);
|
4929 schuur 1.1
|
4930 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
4931 schuur 1.1
|
4932 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.referenceNames: " + pr.getName());
|
4933 schuur 1.1
|
4934 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: Calling provider referenceNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->resultClass<<PEGASUS_STD(endl));
|
4935 schuur 1.12
|
4936 mark.hamzy 1.24 JvmVector *jv = 0;
4937
4938 env = JMPIjvm::attachThread(&jv);
|
4939 schuur 1.1
|
4940 mark.hamzy 1.37 if (!env)
4941 {
4942 PEG_METHOD_EXIT();
4943
4944 STAT_COPYDISPATCHER
4945
4946 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4947 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
4948 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
4949 }
4950
|
4951 mark.hamzy 1.43 JMPIProvider::pm_service_op_lock op_lock(&pr);
4952
4953 STAT_GETSTARTTIME;
4954
4955 jmethodID id = NULL;
4956 String interfaceType;
4957 String interfaceVersion;
4958
4959 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
4960 interfaceType,
4961 interfaceVersion);
4962
4963 if (interfaceType == "JMPI")
4964 {
4965 // public java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
4966 // org.pegasus.jmpi.CIMObjectPath pathName,
4967 // java.lang.String role)
4968 // throws org.pegasus.jmpi.CIMException
4969 id = env->GetMethodID((jclass)pr.jProviderClass,
4970 "referenceNames",
4971 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
4972 mark.hamzy 1.43
4973 if (id != NULL)
4974 {
4975 eMethodFound = METHOD_ASSOCIATORPROVIDER;
4976 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_ASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
4977 }
4978
4979 if (id == NULL)
4980 {
4981 env->ExceptionClear();
4982
4983 // public org.pegasus.jmpi.CIMObjectPath[] referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
4984 // org.pegasus.jmpi.CIMObjectPath pathName,
4985 // java.lang.String role)
4986 // throws org.pegasus.jmpi.CIMException
4987 id = env->GetMethodID((jclass)pr.jProviderClass,
4988 "referenceNames",
4989 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
4990
4991 if (id != NULL)
4992 {
4993 mark.hamzy 1.43 eMethodFound = METHOD_CIMASSOCIATORPROVIDER;
4994 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_CIMASSOCIATORPROVIDER."<<PEGASUS_STD(endl));
4995 }
4996 }
4997 }
4998 else if (interfaceType == "JMPIExperimental")
4999 {
5000 // public java.util.Vector referenceNames (org.pegasus.jmpi.OperationContext oc,
5001 // org.pegasus.jmpi.CIMObjectPath assocName,
5002 // org.pegasus.jmpi.CIMObjectPath pathName,
5003 // java.lang.String role)
5004 // throws org.pegasus.jmpi.CIMException
5005 id = env->GetMethodID((jclass)pr.jProviderClass,
5006 "referenceNames",
5007 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
5008
5009 if (id != NULL)
5010 {
5011 eMethodFound = METHOD_ASSOCIATORPROVIDER2;
5012 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_ASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
5013 }
5014 mark.hamzy 1.43
5015 if (id == NULL)
5016 {
5017 env->ExceptionClear();
5018
5019 // public org.pegasus.jmpi.CIMObjectPath[] referenceNames (org.pegasus.jmpi.OperationContext oc,
5020 // org.pegasus.jmpi.CIMObjectPath assocName,
5021 // org.pegasus.jmpi.CIMObjectPath pathName,
5022 // java.lang.String role)
5023 // throws org.pegasus.jmpi.CIMException
5024 id = env->GetMethodID((jclass)pr.jProviderClass,
5025 "referenceNames",
5026 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
5027
5028 if (id != NULL)
5029 {
5030 eMethodFound = METHOD_CIMASSOCIATORPROVIDER2;
5031 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_CIMASSOCIATORPROVIDER2."<<PEGASUS_STD(endl));
5032 }
5033 }
5034 }
5035 mark.hamzy 1.43
5036 if (id == NULL)
5037 {
5038 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found no method!"<<PEGASUS_STD(endl));
5039
5040 PEG_METHOD_EXIT();
5041
5042 STAT_COPYDISPATCHER
5043
5044 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5045 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
5046 "Could not find a method for the provider based on InterfaceType."));
5047 }
5048
5049 JMPIjvm::checkException(env);
5050
5051 switch (eMethodFound)
5052 {
5053 case METHOD_CIMASSOCIATORPROVIDER:
5054 {
5055 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
5056 mark.hamzy 1.43 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
5057
5058 JMPIjvm::checkException(env);
5059
5060 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5061 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
5062
5063 JMPIjvm::checkException(env);
5064
5065 jstring jRole = env->NewStringUTF(request->role.getCString());
5066
5067 JMPIjvm::checkException(env);
5068
5069 #ifdef PEGASUS_DEBUG
5070 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
5071 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
5072 #endif
5073
|
5074 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
5075 mark.hamzy 1.43 id,
5076 jPathName,
5077 jAssociationName,
5078 jRole);
5079
5080 JMPIjvm::checkException(env);
5081
5082 STAT_PMS_PROVIDEREND;
5083
5084 handler.processing();
|
5085 mark.hamzy 1.45 if (jAr) {
5086 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
5087 mark.hamzy 1.43 JMPIjvm::checkException(env);
5088
|
5089 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
5090 mark.hamzy 1.43
5091 JMPIjvm::checkException(env);
5092
5093 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
5094
5095 JMPIjvm::checkException(env);
5096
5097 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
5098
5099 handler.deliver(*copRet);
5100 }
5101 }
5102 handler.complete();
5103 break;
5104 }
5105
5106 case METHOD_CIMASSOCIATORPROVIDER2:
5107 {
5108 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
5109 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
5110
5111 mark.hamzy 1.43 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
5112 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
5113
5114 JMPIjvm::checkException(env);
5115
5116 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5117 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
5118
5119 JMPIjvm::checkException(env);
5120
5121 jstring jRole = env->NewStringUTF(request->role.getCString());
5122
5123 JMPIjvm::checkException(env);
5124
5125 #ifdef PEGASUS_DEBUG
5126 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
5127 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
5128 #endif
5129
|
5130 mark.hamzy 1.45 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
|
5131 mark.hamzy 1.43 id,
5132 joc,
5133 jPathName,
5134 jAssociationName,
5135 jRole);
5136
5137 JMPIjvm::checkException(env);
5138
5139 STAT_PMS_PROVIDEREND;
5140
5141 if (joc)
5142 {
5143 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
5144
5145 JMPIjvm::checkException(env);
5146 }
5147
5148 handler.processing();
|
5149 mark.hamzy 1.45 if (jAr) {
5150 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
5151 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5152 schuur 1.1
|
5153 mark.hamzy 1.45 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
|
5154 schuur 1.1
|
5155 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5156 mark.hamzy 1.24
|
5157 mark.hamzy 1.43 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
5158 mark.hamzy 1.24
|
5159 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5160 mark.hamzy 1.24
|
5161 mark.hamzy 1.43 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
5162 mark.hamzy 1.24
|
5163 mark.hamzy 1.43 handler.deliver(*copRet);
5164 }
|
5165 mark.hamzy 1.24 }
|
5166 mark.hamzy 1.43 handler.complete();
5167 break;
|
5168 mark.hamzy 1.24 }
|
5169 schuur 1.11
|
5170 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER:
|
5171 mark.hamzy 1.24 {
|
5172 mark.hamzy 1.43 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
5173 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
5174 mark.hamzy 1.24
|
5175 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5176 schuur 1.1
|
5177 mark.hamzy 1.43 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5178 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
|
5179 mark.hamzy 1.25
5180 JMPIjvm::checkException(env);
5181
5182 jstring jRole = env->NewStringUTF(request->role.getCString());
5183
5184 JMPIjvm::checkException(env);
5185
|
5186 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
5187 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
|
5188 mark.hamzy 1.43 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
|
5189 mark.hamzy 1.29 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
5190 #endif
5191
|
5192 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
5193 id,
5194 jAssociationName,
|
5195 mark.hamzy 1.43 jPathName,
|
5196 mark.hamzy 1.24 jRole);
|
5197 mark.hamzy 1.25
|
5198 mark.hamzy 1.23 JMPIjvm::checkException(env);
5199
5200 STAT_PMS_PROVIDEREND;
5201
5202 handler.processing();
5203 if (jVec) {
|
5204 mark.hamzy 1.43 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
5205 mark.hamzy 1.23 JMPIjvm::checkException(env);
5206
|
5207 mark.hamzy 1.43 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
5208 mark.hamzy 1.24
|
5209 mark.hamzy 1.23 JMPIjvm::checkException(env);
5210
|
5211 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
5212 mark.hamzy 1.23
5213 JMPIjvm::checkException(env);
5214
|
5215 mark.hamzy 1.29 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
5216 mark.hamzy 1.24
|
5217 mark.hamzy 1.29 handler.deliver(*copRet);
|
5218 mark.hamzy 1.23 }
5219 }
5220 handler.complete();
|
5221 mark.hamzy 1.24 break;
|
5222 mark.hamzy 1.23 }
|
5223 mark.hamzy 1.24
|
5224 mark.hamzy 1.43 case METHOD_ASSOCIATORPROVIDER2:
|
5225 mark.hamzy 1.24 {
|
5226 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
5227 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
5228
|
5229 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
5230 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
5231
5232 JMPIjvm::checkException(env);
5233
|
5234 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
5235 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
5236
5237 JMPIjvm::checkException(env);
5238
|
5239 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
5240
5241 JMPIjvm::checkException(env);
5242
|
5243 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
5244 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
5245 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
5246 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
5247 #endif
5248
|
5249 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
5250 id,
|
5251 mark.hamzy 1.43 joc,
|
5252 mark.hamzy 1.24 jAssociationName,
5253 jPathName,
5254 jRole);
|
5255 mark.hamzy 1.25
|
5256 mark.hamzy 1.23 JMPIjvm::checkException(env);
5257
5258 STAT_PMS_PROVIDEREND;
|
5259 schuur 1.13
|
5260 mark.hamzy 1.43 if (joc)
5261 {
5262 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
5263
5264 JMPIjvm::checkException(env);
5265 }
5266
|
5267 mark.hamzy 1.23 handler.processing();
|
5268 mark.hamzy 1.24 if (jVec) {
|
5269 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
5270 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
5271 schuur 1.13
|
5272 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
5273 mark.hamzy 1.24
|
5274 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
5275 schuur 1.13
|
5276 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
5277 schuur 1.1
|
5278 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
5279 schuur 1.1
|
5280 mark.hamzy 1.29 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
5281 mark.hamzy 1.24
|
5282 mark.hamzy 1.29 handler.deliver(*copRet);
|
5283 mark.hamzy 1.23 }
5284 }
5285 handler.complete();
|
5286 mark.hamzy 1.24 break;
5287 }
5288
5289 case METHOD_UNKNOWN:
5290 {
|
5291 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: should not be here!"<<PEGASUS_STD(endl));
|
5292 mark.hamzy 1.24 break;
5293 }
|
5294 mark.hamzy 1.23 }
|
5295 schuur 1.1 }
5296 HandlerCatch(handler);
|
5297 schuur 1.11
5298 if (env) JMPIjvm::detachThread();
5299
|
5300 schuur 1.1 PEG_METHOD_EXIT();
5301
|
5302 w.white 1.31 STAT_COPYDISPATCHER
5303
|
5304 schuur 1.1 return(response);
5305 }
5306
|
5307 mark.hamzy 1.26 Message * JMPIProviderManager::handleGetPropertyRequest(const Message * message) throw()
5308 {
5309 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetPropertyRequest");
5310
5311 HandlerIntro(GetProperty,message,request,response,handler,CIMValue());
5312
5313 typedef enum {
5314 METHOD_UNKNOWN = 0,
|
5315 mark.hamzy 1.43 METHOD_PROPERTYPROVIDER,
5316 METHOD_PROPERTYPROVIDER2,
|
5317 mark.hamzy 1.26 } METHOD_VERSION;
5318 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
5319 JNIEnv *env = NULL;
5320
5321 try {
5322 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
5323 "JMPIProviderManager::handleGetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
5324 System::getHostName(),
5325 request->nameSpace.getString(),
5326 request->instanceName.getClassName().getString());
5327
5328 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
5329
5330 // make target object path
|
5331 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
5332 request->nameSpace,
5333 request->instanceName.getClassName(),
5334 request->instanceName.getKeyBindings());
|
5335 mark.hamzy 1.26
5336 // resolve provider name
5337 ProviderName name = _resolveProviderName(
5338 request->operationContext.get(ProviderIdContainer::NAME));
5339
5340 // get cached or load new provider module
|
5341 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
5342 name.getLogicalName(),
5343 String::EMPTY);
|
5344 mark.hamzy 1.26
5345 // forward request
5346 JMPIProvider &pr = ph.GetProvider();
5347
5348 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.getPropertyValue: " + pr.getName());
5349
5350 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: Calling provider getPropertyValue: "<<pr.getName()<<PEGASUS_STD(endl));
5351
5352 JvmVector *jv = 0;
5353
5354 env = JMPIjvm::attachThread(&jv);
5355
|
5356 mark.hamzy 1.37 if (!env)
5357 {
5358 PEG_METHOD_EXIT();
5359
5360 STAT_COPYDISPATCHER
5361
5362 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5363 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
5364 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
5365 }
5366
|
5367 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
5368
5369 STAT_GETSTARTTIME;
5370
|
5371 mark.hamzy 1.43 jmethodID id = NULL;
5372 String interfaceType;
5373 String interfaceVersion;
5374
5375 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
5376 interfaceType,
5377 interfaceVersion);
5378
5379 if (interfaceType == "JMPI")
5380 {
5381 // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
5382 // java.lang.String oclass,
5383 // java.lang.String pName)
5384 // throws org.pegasus.jmpi.CIMException
5385 //
5386 id = env->GetMethodID((jclass)pr.jProviderClass,
5387 "getPropertyValue",
5388 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
|
5389 mark.hamzy 1.26
|
5390 mark.hamzy 1.43 if (id != NULL)
5391 {
5392 eMethodFound = METHOD_PROPERTYPROVIDER;
5393 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_PROPERTYPROVIDER."<<PEGASUS_STD(endl));
5394 }
5395 }
5396 else if (interfaceType == "JMPIExperimental")
5397 {
5398 // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.OperationContext oc,
5399 // org.pegasus.jmpi.CIMObjectPath cop,
5400 // java.lang.String oclass,
5401 // java.lang.String pName)
5402 // throws org.pegasus.jmpi.CIMException
5403 //
5404 id = env->GetMethodID((jclass)pr.jProviderClass,
5405 "getPropertyValue",
|
5406 mark.hamzy 1.46 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
|
5407 mark.hamzy 1.26
|
5408 mark.hamzy 1.43 if (id != NULL)
5409 {
5410 eMethodFound = METHOD_PROPERTYPROVIDER2;
5411 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_PROPERTYPROVIDER2."<<PEGASUS_STD(endl));
5412 }
|
5413 mark.hamzy 1.26 }
5414
5415 if (id == NULL)
5416 {
5417 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
|
5418 mark.hamzy 1.43
5419 PEG_METHOD_EXIT();
5420
5421 STAT_COPYDISPATCHER
5422
5423 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5424 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
5425 "Could not find a method for the provider based on InterfaceType."));
|
5426 mark.hamzy 1.26 }
5427
5428 JMPIjvm::checkException(env);
5429
5430 switch (eMethodFound)
5431 {
|
5432 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER:
|
5433 mark.hamzy 1.26 {
|
5434 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
5435 mark.hamzy 1.26 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
5436
5437 JMPIjvm::checkException(env);
5438
5439 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
5440
5441 JMPIjvm::checkException(env);
5442
5443 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
5444
5445 JMPIjvm::checkException(env);
5446
5447 STAT_GETSTARTTIME;
5448
|
5449 mark.hamzy 1.29 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
5450 id,
5451 jcop,
5452 joclass,
5453 jpName);
|
5454 mark.hamzy 1.26
5455 JMPIjvm::checkException(env);
5456
5457 STAT_PMS_PROVIDEREND;
5458
5459 handler.processing();
5460
|
5461 mark.hamzy 1.29 if (jvalRet)
|
5462 mark.hamzy 1.26 {
|
5463 mark.hamzy 1.29 jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);
5464 CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef);
|
5465 mark.hamzy 1.26
5466 JMPIjvm::checkException(env);
5467
|
5468 mark.hamzy 1.29 handler.deliver(*valRet);
|
5469 mark.hamzy 1.26 }
5470 handler.complete();
5471 break;
5472 }
5473
|
5474 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER2:
5475 {
5476 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
5477 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
5478
5479 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5480 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
5481
5482 JMPIjvm::checkException(env);
5483
5484 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
5485
5486 JMPIjvm::checkException(env);
5487
5488 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
5489
5490 JMPIjvm::checkException(env);
5491
5492 STAT_GETSTARTTIME;
5493
5494 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
5495 mark.hamzy 1.43 id,
5496 joc,
5497 jcop,
5498 joclass,
5499 jpName);
5500
5501 JMPIjvm::checkException(env);
5502
5503 STAT_PMS_PROVIDEREND;
5504
5505 if (joc)
5506 {
5507 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
5508
5509 JMPIjvm::checkException(env);
5510 }
5511
5512 handler.processing();
5513
5514 if (jvalRet)
5515 {
5516 mark.hamzy 1.43 jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);
5517 CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef);
5518
5519 JMPIjvm::checkException(env);
5520
5521 handler.deliver(*valRet);
5522 }
5523 handler.complete();
5524 break;
5525 }
5526
|
5527 mark.hamzy 1.26 case METHOD_UNKNOWN:
5528 {
5529 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: should not be here!"<<PEGASUS_STD(endl));
5530 break;
5531 }
5532 }
5533 }
5534 HandlerCatch(handler);
5535
5536 if (env) JMPIjvm::detachThread();
5537
5538 PEG_METHOD_EXIT();
5539
|
5540 w.white 1.31 STAT_COPYDISPATCHER
5541
|
5542 mark.hamzy 1.26 return(response);
5543 }
5544
5545 Message * JMPIProviderManager::handleSetPropertyRequest(const Message * message) throw()
5546 {
5547 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleSetPropertyRequest");
5548
5549 HandlerIntroVoid(SetProperty,message,request,response,handler);
5550
5551 typedef enum {
5552 METHOD_UNKNOWN = 0,
|
5553 mark.hamzy 1.43 METHOD_PROPERTYPROVIDER,
5554 METHOD_PROPERTYPROVIDER2,
|
5555 mark.hamzy 1.26 } METHOD_VERSION;
5556 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
5557 JNIEnv *env = NULL;
5558
5559 try {
5560 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
5561 "JMPIProviderManager::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
5562 System::getHostName(),
5563 request->nameSpace.getString(),
5564 request->instanceName.getClassName().getString());
5565
5566 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
5567
5568 // make target object path
|
5569 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
5570 request->nameSpace,
5571 request->instanceName.getClassName(),
5572 request->instanceName.getKeyBindings());
|
5573 mark.hamzy 1.26
5574 // resolve provider name
5575 ProviderName name = _resolveProviderName(
5576 request->operationContext.get(ProviderIdContainer::NAME));
5577
5578 // get cached or load new provider module
|
5579 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
5580 name.getLogicalName(),
5581 String::EMPTY);
|
5582 mark.hamzy 1.26
5583 // forward request
5584 JMPIProvider &pr = ph.GetProvider();
5585
5586 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.setPropertyValue: " + pr.getName());
5587
5588 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: Calling provider setPropertyValue: "<<pr.getName()<<PEGASUS_STD(endl));
5589
5590 JvmVector *jv = 0;
5591
5592 env = JMPIjvm::attachThread(&jv);
5593
|
5594 mark.hamzy 1.37 if (!env)
5595 {
5596 PEG_METHOD_EXIT();
5597
5598 STAT_COPYDISPATCHER
5599
5600 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5601 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
5602 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
5603 }
5604
|
5605 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
5606
5607 STAT_GETSTARTTIME;
5608
|
5609 mark.hamzy 1.43 jmethodID id = NULL;
5610 String interfaceType;
5611 String interfaceVersion;
5612
5613 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
5614 interfaceType,
5615 interfaceVersion);
5616
5617 if (interfaceType == "JMPI")
5618 {
5619 // public abstract void setPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
5620 // java.lang.String oclass,
5621 // java.lang.String pName,
5622 // org.pegasus.jmpi.CIMValue val)
5623 // throws org.pegasus.jmpi.CIMException
5624 //
5625 id = env->GetMethodID((jclass)pr.jProviderClass,
5626 "setPropertyValue",
5627 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
|
5628 mark.hamzy 1.26
|
5629 mark.hamzy 1.43 if (id != NULL)
5630 {
5631 eMethodFound = METHOD_PROPERTYPROVIDER;
5632 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_PROPERTYPROVIDER."<<PEGASUS_STD(endl));
5633 }
5634 }
5635 else if (interfaceType == "JMPIExperimental")
5636 {
5637 // public abstract void setPropertyValue (org.pegasus.jmpi.OperationContext oc,
5638 // org.pegasus.jmpi.CIMObjectPath cop,
5639 // java.lang.String oclass,
5640 // java.lang.String pName,
5641 // org.pegasus.jmpi.CIMValue val)
5642 // throws org.pegasus.jmpi.CIMException
5643 //
5644 id = env->GetMethodID((jclass)pr.jProviderClass,
5645 "setPropertyValue",
|
5646 mark.hamzy 1.46 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
|
5647 mark.hamzy 1.26
|
5648 mark.hamzy 1.43 if (id != NULL)
5649 {
5650 eMethodFound = METHOD_PROPERTYPROVIDER2;
5651 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_PROPERTYPROVIDER2."<<PEGASUS_STD(endl));
5652 }
|
5653 mark.hamzy 1.26 }
5654
5655 if (id == NULL)
5656 {
5657 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
|
5658 mark.hamzy 1.43
5659 PEG_METHOD_EXIT();
5660
5661 STAT_COPYDISPATCHER
5662
5663 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5664 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
5665 "Could not find a method for the provider based on InterfaceType."));
|
5666 mark.hamzy 1.26 }
5667
5668 JMPIjvm::checkException(env);
5669
5670 switch (eMethodFound)
5671 {
|
5672 mark.hamzy 1.43 case METHOD_PROPERTYPROVIDER:
5673 {
5674 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5675 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
5676
5677 JMPIjvm::checkException(env);
5678
5679 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
5680
5681 JMPIjvm::checkException(env);
5682
5683 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
5684
5685 JMPIjvm::checkException(env);
5686
5687 CIMValue *val = new CIMValue (request->newValue);
5688
5689 JMPIjvm::checkException(env);
5690
5691 jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);
5692 jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);
5693 mark.hamzy 1.43
5694 JMPIjvm::checkException(env);
5695
5696 STAT_GETSTARTTIME;
5697
5698 env->CallVoidMethod ((jobject)pr.jProvider,
5699 id,
5700 jcop,
5701 joclass,
5702 jpName,
5703 jval);
5704
5705 JMPIjvm::checkException(env);
5706
5707 STAT_PMS_PROVIDEREND;
5708 break;
5709 }
5710
5711 case METHOD_PROPERTYPROVIDER2:
|
5712 mark.hamzy 1.26 {
|
5713 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
5714 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
5715
|
5716 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
5717 mark.hamzy 1.26 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
5718
5719 JMPIjvm::checkException(env);
5720
5721 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
5722
5723 JMPIjvm::checkException(env);
5724
5725 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
5726
5727 JMPIjvm::checkException(env);
5728
|
5729 mark.hamzy 1.27 CIMValue *val = new CIMValue (request->newValue);
|
5730 mark.hamzy 1.26
5731 JMPIjvm::checkException(env);
5732
|
5733 mark.hamzy 1.27 jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);
|
5734 mark.hamzy 1.26 jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);
5735
5736 JMPIjvm::checkException(env);
5737
5738 STAT_GETSTARTTIME;
5739
5740 env->CallVoidMethod ((jobject)pr.jProvider,
5741 id,
|
5742 mark.hamzy 1.43 joc,
|
5743 mark.hamzy 1.26 jcop,
5744 joclass,
5745 jpName,
5746 jval);
5747
5748 JMPIjvm::checkException(env);
5749
|
5750 mark.hamzy 1.43 if (joc)
5751 {
5752 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
5753
5754 JMPIjvm::checkException(env);
5755 }
5756
|
5757 mark.hamzy 1.26 STAT_PMS_PROVIDEREND;
5758 break;
5759 }
5760
5761 case METHOD_UNKNOWN:
5762 {
5763 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: should not be here!"<<PEGASUS_STD(endl));
5764 break;
5765 }
5766 }
5767 }
5768 HandlerCatch(handler);
5769
5770 if (env) JMPIjvm::detachThread();
5771
5772 PEG_METHOD_EXIT();
5773
|
5774 w.white 1.31 STAT_COPYDISPATCHER
5775
|
5776 mark.hamzy 1.26 return(response);
5777 }
5778
|
5779 schuur 1.1 Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw()
5780 {
|
5781 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest");
5782
5783 HandlerIntroMethod(InvokeMethod,message,request,response,handler);
|
5784 schuur 1.1
|
5785 mark.hamzy 1.25 typedef enum {
5786 METHOD_UNKNOWN = 0,
|
5787 mark.hamzy 1.43 METHOD_CIMMETHODPROVIDER,
5788 METHOD_CIMMETHODPROVIDER2,
5789 METHOD_METHODPROVIDER,
5790 METHOD_METHODPROVIDER2,
|
5791 mark.hamzy 1.25 } METHOD_VERSION;
5792 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
5793 JNIEnv *env = NULL;
|
5794 schuur 1.13
|
5795 schuur 1.1 try {
5796 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
5797 "JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",
5798 System::getHostName(),
5799 request->nameSpace.getString(),
5800 request->instanceName.getClassName().getString());
5801
|
5802 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));
5803
|
5804 schuur 1.1 // make target object path
|
5805 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
5806 request->nameSpace,
5807 request->instanceName.getClassName(),
5808 request->instanceName.getKeyBindings());
|
5809 schuur 1.1
5810 // resolve provider name
|
5811 kumpf 1.2 ProviderName name = _resolveProviderName(
5812 request->operationContext.get(ProviderIdContainer::NAME));
|
5813 schuur 1.1
5814 // get cached or load new provider module
|
5815 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
5816 name.getLogicalName(),
5817 String::EMPTY);
|
5818 schuur 1.1
|
5819 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
5820 schuur 1.1
|
5821 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.invokeMethod: " + pr.getName());
|
5822 schuur 1.1
|
5823 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: Calling provider invokeMethod: "<<pr.getName()<<PEGASUS_STD(endl));
|
5824 schuur 1.11
|
5825 mark.hamzy 1.25 JvmVector *jv = 0;
|
5826 mark.hamzy 1.23
|
5827 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
5828 schuur 1.11
|
5829 mark.hamzy 1.37 if (!env)
5830 {
|
5831 mark.hamzy 1.43 PEG_METHOD_EXIT();
5832
5833 STAT_COPYDISPATCHER
5834
5835 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5836 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
5837 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
5838 }
5839
5840 JMPIProvider::pm_service_op_lock op_lock(&pr);
5841
5842 STAT_GETSTARTTIME;
5843
5844 jmethodID id = NULL;
5845 String interfaceType;
5846 String interfaceVersion;
5847
5848 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
5849 interfaceType,
5850 interfaceVersion);
5851
5852 mark.hamzy 1.43 if (interfaceType == "JMPI")
5853 {
5854 // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath cop,
5855 // java.lang.String name,
5856 // java.util.Vector in,
5857 // java.util.Vector out)
5858 // throws org.pegasus.jmpi.CIMException
5859 id = env->GetMethodID((jclass)pr.jProviderClass,
5860 "invokeMethod",
5861 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
5862
5863 if (id != NULL)
5864 {
5865 eMethodFound = METHOD_METHODPROVIDER;
5866 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER."<<PEGASUS_STD(endl));
5867 }
5868
5869 if (id == NULL)
5870 {
5871 env->ExceptionClear();
5872
5873 mark.hamzy 1.43 // public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath op,
5874 // java.lang.String methodName,
5875 // org.pegasus.jmpi.CIMArgument[] inArgs,
5876 // org.pegasus.jmpi.CIMArgument[] outArgs)
5877 // throws org.pegasus.jmpi.CIMException
5878 id = env->GetMethodID((jclass)pr.jProviderClass,
5879 "invokeMethod",
5880 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
5881
5882 if (id != NULL)
5883 {
5884 eMethodFound = METHOD_CIMMETHODPROVIDER;
5885 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER."<<PEGASUS_STD(endl));
5886 }
5887 }
5888 }
5889 else if (interfaceType == "JMPIExperimental")
5890 {
5891 // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,
5892 // org.pegasus.jmpi.CIMObjectPath cop,
5893 // java.lang.String name,
5894 mark.hamzy 1.43 // java.util.Vector in,
5895 // java.util.Vector out)
5896 // throws org.pegasus.jmpi.CIMException
5897 id = env->GetMethodID((jclass)pr.jProviderClass,
5898 "invokeMethod",
5899 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
5900
5901 if (id != NULL)
5902 {
5903 eMethodFound = METHOD_METHODPROVIDER2;
5904 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_METHODPROVIDER2."<<PEGASUS_STD(endl));
5905 }
5906
5907 if (id == NULL)
5908 {
5909 env->ExceptionClear();
5910
5911 // public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.OperationContext oc,
5912 // org.pegasus.jmpi.CIMObjectPath op,
5913 // java.lang.String methodName,
5914 // org.pegasus.jmpi.CIMArgument[] inArgs,
5915 mark.hamzy 1.43 // org.pegasus.jmpi.CIMArgument[] outArgs)
5916 // throws org.pegasus.jmpi.CIMException
5917 id = env->GetMethodID((jclass)pr.jProviderClass,
5918 "invokeMethod",
5919 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
5920
5921 if (id != NULL)
5922 {
5923 eMethodFound = METHOD_CIMMETHODPROVIDER2;
5924 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_CIMMETHODPROVIDER2."<<PEGASUS_STD(endl));
5925 }
5926 }
5927 }
5928
5929 if (id == NULL)
5930 {
5931 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: No method found!"<<PEGASUS_STD(endl));
5932
5933 PEG_METHOD_EXIT();
5934
5935 STAT_COPYDISPATCHER
5936 mark.hamzy 1.43
5937 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
5938 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
5939 "Could not find a method for the provider based on InterfaceType."));
5940 }
5941
5942 JMPIjvm::checkException(env);
5943
5944 switch (eMethodFound)
5945 {
5946 case METHOD_CIMMETHODPROVIDER:
5947 {
5948 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
5949 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
5950
5951 JMPIjvm::checkException(env);
5952
5953 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
5954
5955 JMPIjvm::checkException(env);
5956
5957 mark.hamzy 1.43 Uint32 m=request->inParameters.size();
5958
5959 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
5960
5961 for (Uint32 i=0; i<m; i++) {
5962 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
5963 jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);
5964 jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef);
5965
5966 env->SetObjectArrayElement(jArIn,i,jArg);
5967 }
5968
5969 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
5970
5971 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
5972 id,
5973 jcop,
5974 jMethod,
5975 jArIn,
5976 jArOut);
5977 JMPIjvm::checkException(env);
|
5978 mark.hamzy 1.37
|
5979 mark.hamzy 1.43 STAT_PMS_PROVIDEREND;
|
5980 mark.hamzy 1.37
|
5981 mark.hamzy 1.43 handler.processing();
|
5982 mark.hamzy 1.37
|
5983 mark.hamzy 1.43 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
5984 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
5985 schuur 1.11
|
5986 mark.hamzy 1.43 handler.deliver(*valueRet);
|
5987 schuur 1.1
|
5988 mark.hamzy 1.43 for (int i=0; i<24; i++) {
5989 jobject jArg = env->GetObjectArrayElement(jArOut,i);
|
5990 mark.hamzy 1.25
|
5991 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
5992 mark.hamzy 1.25
|
5993 mark.hamzy 1.43 if (jArg==NULL)
5994 break;
|
5995 mark.hamzy 1.25
|
5996 mark.hamzy 1.43 jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);
5997 CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef);
|
5998 mark.hamzy 1.25
|
5999 mark.hamzy 1.43 JMPIjvm::checkException(env);
|
6000 mark.hamzy 1.25
|
6001 mark.hamzy 1.43 handler.deliverParamValue(*p);
|
6002 mark.hamzy 1.25 }
|
6003 mark.hamzy 1.43
6004 handler.complete();
6005 break;
|
6006 mark.hamzy 1.23 }
|
6007 mark.hamzy 1.25
|
6008 mark.hamzy 1.43 case METHOD_CIMMETHODPROVIDER2:
6009 {
6010 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
6011 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
|
6012 schuur 1.11
|
6013 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
6014 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6015 mark.hamzy 1.25
6016 JMPIjvm::checkException(env);
6017
|
6018 mark.hamzy 1.29 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
6019
|
6020 mark.hamzy 1.23 JMPIjvm::checkException(env);
6021
|
6022 mark.hamzy 1.25 Uint32 m=request->inParameters.size();
6023
6024 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
|
6025 mark.hamzy 1.29
|
6026 mark.hamzy 1.25 for (Uint32 i=0; i<m; i++) {
|
6027 mark.hamzy 1.29 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
6028 jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);
6029 jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef);
|
6030 mark.hamzy 1.23
|
6031 mark.hamzy 1.25 env->SetObjectArrayElement(jArIn,i,jArg);
6032 }
|
6033 mark.hamzy 1.23
|
6034 mark.hamzy 1.25 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
|
6035 mark.hamzy 1.23
|
6036 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
6037 id,
|
6038 mark.hamzy 1.43 joc,
|
6039 mark.hamzy 1.29 jcop,
6040 jMethod,
6041 jArIn,
6042 jArOut);
|
6043 mark.hamzy 1.23 JMPIjvm::checkException(env);
6044
6045 STAT_PMS_PROVIDEREND;
6046
|
6047 mark.hamzy 1.43 if (joc)
6048 {
6049 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
6050
6051 JMPIjvm::checkException(env);
6052 }
6053
|
6054 mark.hamzy 1.23 handler.processing();
6055
|
6056 mark.hamzy 1.29 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
6057 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
6058 mark.hamzy 1.23
|
6059 mark.hamzy 1.29 handler.deliver(*valueRet);
|
6060 schuur 1.13
|
6061 mark.hamzy 1.25 for (int i=0; i<24; i++) {
|
6062 mark.hamzy 1.29 jobject jArg = env->GetObjectArrayElement(jArOut,i);
6063
|
6064 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
6065 schuur 1.13
|
6066 mark.hamzy 1.29 if (jArg==NULL)
6067 break;
|
6068 schuur 1.13
|
6069 mark.hamzy 1.29 jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);
6070 CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef);
|
6071 schuur 1.13
|
6072 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
6073 schuur 1.1
|
6074 mark.hamzy 1.25 handler.deliverParamValue(*p);
|
6075 mark.hamzy 1.23 }
|
6076 schuur 1.1
|
6077 mark.hamzy 1.23 handler.complete();
|
6078 mark.hamzy 1.25 break;
|
6079 mark.hamzy 1.23 }
|
6080 schuur 1.11
|
6081 mark.hamzy 1.43 case METHOD_METHODPROVIDER:
6082 {
6083 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
6084 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
6085
6086 JMPIjvm::checkException(env);
6087
6088 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
6089
6090 JMPIjvm::checkException(env);
6091
6092 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
6093
6094 JMPIjvm::checkException(env);
6095
6096 for (int i=0,m=request->inParameters.size(); i<m; i++)
6097 {
6098 const CIMParamValue &parm = request->inParameters[i];
6099 const CIMValue v = parm.getValue();
6100 CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
6101 jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
6102 mark.hamzy 1.43 jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef);
6103
6104 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
6105 }
6106
6107 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
6108 JMPIjvm::checkException(env);
6109
6110 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
6111 id,
6112 jcop,
6113 jMethod,
6114 jVecIn,
6115 jVecOut);
6116 JMPIjvm::checkException(env);
6117
6118 STAT_PMS_PROVIDEREND;
6119
6120 handler.processing();
6121
6122 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
6123 mark.hamzy 1.43 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
6124
6125 handler.deliver(*valueRet);
6126
6127 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++)
6128 {
6129 JMPIjvm::checkException(env);
6130
6131 jobject jProp = env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
6132
6133 JMPIjvm::checkException(env);
6134
6135 jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);
6136 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef);
6137
6138 JMPIjvm::checkException(env);
6139
6140 handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
6141 }
6142
6143 handler.complete();
6144 mark.hamzy 1.43 break;
6145 }
6146
6147 case METHOD_METHODPROVIDER2:
|
6148 mark.hamzy 1.25 {
|
6149 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
6150 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
6151
|
6152 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
6153 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6154 mark.hamzy 1.25
6155 JMPIjvm::checkException(env);
6156
|
6157 mark.hamzy 1.29 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
6158
|
6159 mark.hamzy 1.25 JMPIjvm::checkException(env);
6160
|
6161 mark.hamzy 1.29 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
6162
|
6163 mark.hamzy 1.25 JMPIjvm::checkException(env);
6164
|
6165 mark.hamzy 1.29 for (int i=0,m=request->inParameters.size(); i<m; i++)
6166 {
6167 const CIMParamValue &parm = request->inParameters[i];
6168 const CIMValue v = parm.getValue();
6169 CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
6170 jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
6171 jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef);
|
6172 mark.hamzy 1.23
|
6173 mark.hamzy 1.29 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
|
6174 mark.hamzy 1.25 }
|
6175 mark.hamzy 1.23
|
6176 mark.hamzy 1.25 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
6177 JMPIjvm::checkException(env);
|
6178 mark.hamzy 1.23
|
6179 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
6180 id,
|
6181 mark.hamzy 1.43 joc,
|
6182 mark.hamzy 1.29 jcop,
6183 jMethod,
6184 jVecIn,
6185 jVecOut);
|
6186 mark.hamzy 1.23 JMPIjvm::checkException(env);
6187
6188 STAT_PMS_PROVIDEREND;
6189
|
6190 mark.hamzy 1.43 if (joc)
6191 {
6192 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
6193
6194 JMPIjvm::checkException(env);
6195 }
6196
|
6197 mark.hamzy 1.23 handler.processing();
|
6198 schuur 1.1
|
6199 mark.hamzy 1.29 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
6200 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
6201 mark.hamzy 1.23
|
6202 mark.hamzy 1.29 handler.deliver(*valueRet);
|
6203 mark.hamzy 1.23
|
6204 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++)
6205 {
|
6206 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
6207 schuur 1.13
|
6208 mark.hamzy 1.29 jobject jProp = env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
6209
|
6210 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6211 schuur 1.13
|
6212 mark.hamzy 1.29 jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);
6213 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef);
|
6214 schuur 1.13
|
6215 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
6216 schuur 1.13
|
6217 mark.hamzy 1.25 handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
6218 }
6219
6220 handler.complete();
6221 break;
6222 }
|
6223 mark.hamzy 1.23
|
6224 mark.hamzy 1.25 case METHOD_UNKNOWN:
6225 {
6226 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: should not be here!"<<PEGASUS_STD(endl));
6227 break;
6228 }
|
6229 mark.hamzy 1.23 }
|
6230 schuur 1.1 }
6231 HandlerCatch(handler);
|
6232 schuur 1.11
6233 if (env) JMPIjvm::detachThread();
6234
|
6235 schuur 1.1 PEG_METHOD_EXIT();
6236
|
6237 w.white 1.31 STAT_COPYDISPATCHER
6238
|
6239 schuur 1.11 return(response);
|
6240 schuur 1.1 }
|
6241 mark.hamzy 1.23
|
6242 schuur 1.1 int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance,
6243 String& providerName, String& location)
6244 {
6245 Uint32 pos = pInstance.findProperty(CIMName ("Name"));
6246 pInstance.getProperty(pos).getValue().get(providerName);
6247
6248 pos = pmInstance.findProperty(CIMName ("Location"));
6249 pmInstance.getProperty(pos).getValue().get(location);
6250 return 0;
6251 }
6252
|
6253 mark.hamzy 1.44 CMPI_SelectExp *
6254 newSelectExp (CIMOMHandleQueryContext *qContext,
6255 OperationContext *ctx,
6256 String& query,
6257 String& queryLanguage,
6258 CIMNamespaceName& nameSpace,
6259 Array<CIMName>& classNames,
6260 CIMPropertyList& propertyList)
6261 {
6262 CMPI_SelectExp *eSelx = NULL;
6263
6264 eSelx = new CMPI_SelectExp (*ctx,
6265 qContext,
6266 query,
6267 queryLanguage);
6268
6269 if (!eSelx)
6270 {
6271 return eSelx;
6272 }
6273
6274 mark.hamzy 1.44 for (Uint32 i = 0, n = classNames.size (); i < n; i++)
6275 {
6276 CIMObjectPath className (System::getHostName(),
6277 nameSpace,
6278 classNames[i]);
6279
6280 eSelx->classNames.append (className);
6281 }
6282
6283 if (!propertyList.isNull ())
6284 {
6285 Array<CIMName> p = propertyList.getPropertyNameArray ();
6286 int pCount = p.size ();
6287
6288 eSelx->props = (const char**)malloc ((1 + pCount) * sizeof (char*));
6289
6290 for (int i = 0; i < pCount; i++)
6291 {
6292 eSelx->props[i] = strdup (p[i].getString ().getCString ());
6293 }
6294
6295 mark.hamzy 1.44 eSelx->props[pCount] = NULL;
6296 }
6297
6298 return eSelx;
6299 }
6300
|
6301 schuur 1.1 Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()
6302 {
|
6303 konrad.r 1.15 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest");
|
6304 schuur 1.1
|
6305 mark.hamzy 1.23 HandlerIntroInd(CreateSubscription,message,request,response,handler);
6306
|
6307 mark.hamzy 1.25 typedef enum {
6308 METHOD_UNKNOWN = 0,
|
6309 mark.hamzy 1.43 METHOD_EVENTPROVIDER,
6310 METHOD_EVENTPROVIDER2,
|
6311 mark.hamzy 1.25 } METHOD_VERSION;
|
6312 mark.hamzy 1.44 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
6313 JNIEnv *env = NULL;
|
6314 mark.hamzy 1.25
|
6315 schuur 1.1 try {
|
6316 mark.hamzy 1.44 String fileName,
6317 providerName,
|
6318 mark.hamzy 1.25 providerLocation;
6319 CIMInstance req_provider,
6320 req_providerModule;
|
6321 mark.hamzy 1.44 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
|
6322 mark.hamzy 1.25
|
6323 mark.hamzy 1.44 req_provider = pidc.getProvider ();
6324 req_providerModule = pidc.getModule ();
|
6325 mark.hamzy 1.25
|
6326 mark.hamzy 1.44 LocateIndicationProviderNames (req_provider,
6327 req_providerModule,
6328 providerName,
6329 providerLocation);
6330
6331 fileName = resolveFileName (providerLocation);
6332
6333 Logger::put (Logger::STANDARD_LOG,
6334 System::CIMSERVER,
6335 Logger::TRACE,
6336 "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
6337 System::getHostName(),
6338 request->nameSpace.getString(),
6339 providerName);
6340
6341 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "
6342 <<System::getHostName()
6343 <<", namespace = "
6344 <<request->nameSpace.getString()
6345 <<", providername = "
6346 <<providerName
6347 mark.hamzy 1.44 <<", fileName = "
6348 <<fileName
6349 <<PEGASUS_STD(endl));
|
6350 schuur 1.1
6351 // get cached or load new provider module
|
6352 mark.hamzy 1.44 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName,
6353 providerName,
|
6354 mark.hamzy 1.43 String::EMPTY);
|
6355 schuur 1.1
|
6356 carolann.graves 1.21 //
6357 // Save the provider instance from the request
6358 //
6359 ph.GetProvider ().setProviderInstance (req_provider);
6360
|
6361 mark.hamzy 1.44 JMPIProvider &pr = ph.GetProvider ();
|
6362 mark.hamzy 1.25
|
6363 mark.hamzy 1.44 //
6364 // Increment count of current subscriptions for this provider
6365 //
6366 pr.testIfZeroAndIncrementSubscriptions ();
|
6367 schuur 1.1
|
6368 mark.hamzy 1.44 SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get (SubscriptionFilterConditionContainer::NAME);
6369 indProvRecord *prec = NULL;
6370 bool fNewPrec = false;
|
6371 schuur 1.1
|
6372 mark.hamzy 1.25 {
|
6373 mark.hamzy 1.44 AutoMutex lock (mutexProvTab);
6374
6375 provTab.lookup (providerName, prec);
|
6376 schuur 1.12
|
6377 mark.hamzy 1.44 if (!prec)
6378 {
6379 fNewPrec = true;
|
6380 schuur 1.1
|
6381 mark.hamzy 1.44 prec = new indProvRecord ();
|
6382 schuur 1.1
|
6383 mark.hamzy 1.44 // convert arguments
6384 prec->ctx = new OperationContext ();
|
6385 schuur 1.12
|
6386 mark.hamzy 1.44 prec->ctx->insert (request->operationContext.get (IdentityContainer::NAME));
6387 prec->ctx->insert (request->operationContext.get (AcceptLanguageListContainer::NAME));
6388 prec->ctx->insert (request->operationContext.get (ContentLanguageListContainer::NAME));
6389 prec->ctx->insert (request->operationContext.get (SubscriptionInstanceContainer::NAME));
6390 prec->ctx->insert (request->operationContext.get (SubscriptionFilterConditionContainer::NAME));
|
6391 konrad.r 1.22
|
6392 mark.hamzy 1.44 prec->enabled = true;
|
6393 konrad.r 1.22
|
6394 mark.hamzy 1.44 prec->handler = new EnableIndicationsResponseHandler (0,
6395 0,
6396 req_provider,
6397 _indicationCallback,
6398 _responseChunkCallback);
|
6399 konrad.r 1.22
|
6400 mark.hamzy 1.44 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to provTab "<<providerName<<PEGASUS_STD(endl));
|
6401 schuur 1.1
|
6402 mark.hamzy 1.44 provTab.insert (providerName, prec);
6403 }
6404 }
|
6405 schuur 1.1
|
6406 mark.hamzy 1.44 {
6407 AutoMutex lock (prec->mutex);
|
6408 schuur 1.1
|
6409 mark.hamzy 1.44 prec->count++;
|
6410 schuur 1.1 }
6411
|
6412 mark.hamzy 1.44 // Add a selection record for JNI CIMOMHandle deliverEvent calls
6413 indSelectRecord *srec = new indSelectRecord ();
|
6414 mark.hamzy 1.29
6415 {
|
6416 mark.hamzy 1.44 srec->query = request->query;
6417 srec->queryLanguage = sub_cntr.getQueryLanguage ();
6418 srec->propertyList = request->propertyList;
6419
6420 CIMOMHandleQueryContext *qContext = new CIMOMHandleQueryContext (CIMNamespaceName (request->nameSpace.getString ()),
6421 *pr._cimom_handle);
6422 CMPI_SelectExp *eSelx = newSelectExp (qContext,
6423 prec->ctx,
6424 srec->query,
6425 srec->queryLanguage,
6426 request->nameSpace,
6427 request->classNames,
6428 srec->propertyList);
6429
6430 srec->eSelx = eSelx;
6431 srec->qContext = qContext;
6432
6433 CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ());
6434
6435 sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ());
|
6436 mark.hamzy 1.29
|
6437 mark.hamzy 1.44 AutoMutex lock (mutexSelxTab);
|
6438 mark.hamzy 1.29
|
6439 mark.hamzy 1.44 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Adding to selxTab "<<sPath.toString ()<<PEGASUS_STD(endl));
6440
6441 selxTab.insert (sPath.toString (), srec);
6442
6443 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));
|
6444 schuur 1.1 }
6445
|
6446 mark.hamzy 1.44 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName());
6447
6448 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Calling provider createSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
6449
|
6450 mark.hamzy 1.25 JvmVector *jv = 0;
6451
6452 env = JMPIjvm::attachThread(&jv);
6453
|
6454 mark.hamzy 1.37 if (!env)
6455 {
6456 PEG_METHOD_EXIT();
6457
6458 STAT_COPYDISPATCHER
6459
6460 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
6461 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
6462 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
6463 }
6464
|
6465 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
6466
6467 STAT_GETSTARTTIME;
6468
|
6469 mark.hamzy 1.43 jmethodID id = NULL;
6470 String interfaceType;
6471 String interfaceVersion;
6472
|
6473 mark.hamzy 1.44 getInterfaceType (pidc,
|
6474 mark.hamzy 1.43 interfaceType,
6475 interfaceVersion);
6476
6477 if (interfaceType == "JMPI")
6478 {
6479 // public void activateFilter (org.pegasus.jmpi.SelectExp filter,
6480 // java.lang.String eventType,
6481 // org.pegasus.jmpi.CIMObjectPath classPath,
6482 // boolean firstActivation)
6483 // throws org.pegasus.jmpi.CIMException
|
6484 mark.hamzy 1.44 id = env->GetMethodID ((jclass)pr.jProviderClass,
6485 "activateFilter",
6486 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
6487 mark.hamzy 1.43
6488 if (id != NULL)
6489 {
6490 eMethodFound = METHOD_EVENTPROVIDER;
6491 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_EVENTPROVIDER."<<PEGASUS_STD(endl));
6492 }
6493 }
6494 else if (interfaceType == "JMPIExperimental")
6495 {
6496 // public void activateFilter (org.pegasus.jmpi.OperationContext oc,
6497 // org.pegasus.jmpi.SelectExp filter,
6498 // java.lang.String eventType,
6499 // org.pegasus.jmpi.CIMObjectPath classPath,
6500 // boolean firstActivation)
6501 // throws org.pegasus.jmpi.CIMException
|
6502 mark.hamzy 1.44 id = env->GetMethodID ((jclass)pr.jProviderClass,
6503 "activateFilter",
6504 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
6505 mark.hamzy 1.25
|
6506 mark.hamzy 1.43 if (id != NULL)
6507 {
6508 eMethodFound = METHOD_EVENTPROVIDER2;
6509 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_EVENTPROVIDER2."<<PEGASUS_STD(endl));
6510 }
6511 }
|
6512 schuur 1.12
|
6513 mark.hamzy 1.43 if (id == NULL)
|
6514 mark.hamzy 1.25 {
|
6515 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: No method found!"<<PEGASUS_STD(endl));
6516
6517 PEG_METHOD_EXIT();
6518
6519 STAT_COPYDISPATCHER
6520
6521 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
6522 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
6523 "Could not find a method for the provider based on InterfaceType."));
|
6524 mark.hamzy 1.25 }
|
6525 mark.hamzy 1.23
6526 JMPIjvm::checkException(env);
6527
|
6528 mark.hamzy 1.25 switch (eMethodFound)
6529 {
|
6530 mark.hamzy 1.43 case METHOD_EVENTPROVIDER:
6531 {
|
6532 mark.hamzy 1.44 CMPI_SelectExp *eSelx = newSelectExp (srec->qContext,
6533 prec->ctx,
6534 srec->query,
6535 srec->queryLanguage,
6536 request->nameSpace,
6537 request->classNames,
6538 srec->propertyList);
6539 jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
6540 jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef);
|
6541 mark.hamzy 1.43
6542 JMPIjvm::checkException(env);
6543
|
6544 mark.hamzy 1.44 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
6545 mark.hamzy 1.43
6546 JMPIjvm::checkException(env);
6547
|
6548 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
6549 request->nameSpace,
6550 request->classNames[0]);
6551 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
6552 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6553 mark.hamzy 1.43
6554 JMPIjvm::checkException(env);
6555
|
6556 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
6557 id,
6558 jEselx,
6559 jType,
6560 jcop,
6561 (jboolean)fNewPrec);
|
6562 mark.hamzy 1.43
6563 JMPIjvm::checkException(env);
6564
6565 STAT_PMS_PROVIDEREND;
6566 break;
6567 }
6568
6569 case METHOD_EVENTPROVIDER2:
|
6570 mark.hamzy 1.25 {
|
6571 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
6572 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
6573
|
6574 mark.hamzy 1.44 CMPI_SelectExp *eSelx = newSelectExp (srec->qContext,
6575 prec->ctx,
6576 srec->query,
6577 srec->queryLanguage,
6578 request->nameSpace,
6579 request->classNames,
6580 srec->propertyList);
6581 jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
6582 jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef);
|
6583 mark.hamzy 1.25
6584 JMPIjvm::checkException(env);
6585
|
6586 mark.hamzy 1.44 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
6587 schuur 1.12
|
6588 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6589 schuur 1.1
|
6590 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
6591 request->nameSpace,
6592 request->classNames[0]);
6593 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
6594 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6595 schuur 1.1
|
6596 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6597 schuur 1.1
|
6598 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
6599 id,
6600 joc,
6601 jEselx,
6602 jType,
6603 jcop,
6604 (jboolean)fNewPrec);
|
6605 schuur 1.12
|
6606 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6607 schuur 1.1
|
6608 mark.hamzy 1.43 if (joc)
6609 {
6610 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
6611
6612 JMPIjvm::checkException(env);
6613 }
6614
|
6615 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
6616 break;
|
6617 carolann.graves 1.21 }
6618
|
6619 mark.hamzy 1.25 case METHOD_UNKNOWN:
6620 {
6621 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: should not be here!"<<PEGASUS_STD(endl));
6622 break;
6623 }
6624 }
|
6625 schuur 1.1 }
6626 HandlerCatch(handler);
|
6627 schuur 1.12
|
6628 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
6629
|
6630 schuur 1.1 PEG_METHOD_EXIT();
6631
6632 return(response);
6633 }
6634
6635 Message * JMPIProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()
6636 {
6637 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest");
6638
|
6639 mark.hamzy 1.23 HandlerIntroInd(DeleteSubscription,message,request,response,handler);
6640
|
6641 mark.hamzy 1.25 typedef enum {
6642 METHOD_UNKNOWN = 0,
|
6643 mark.hamzy 1.43 METHOD_EVENTPROVIDER,
6644 METHOD_EVENTPROVIDER2,
|
6645 mark.hamzy 1.25 } METHOD_VERSION;
|
6646 mark.hamzy 1.44 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
6647 JNIEnv *env = NULL;
6648 bool fFreePrec = false;
6649 indProvRecord *prec = NULL;
6650 indSelectRecord *srec = NULL;
|
6651 mark.hamzy 1.25
|
6652 schuur 1.1 try {
|
6653 mark.hamzy 1.44 String fileName,
6654 providerName,
|
6655 mark.hamzy 1.25 providerLocation;
6656 CIMInstance req_provider,
6657 req_providerModule;
6658 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
6659
|
6660 mark.hamzy 1.44 req_provider = pidc.getProvider ();
6661 req_providerModule = pidc.getModule ();
6662
6663 LocateIndicationProviderNames (req_provider,
6664 req_providerModule,
6665 providerName,
6666 providerLocation);
6667
6668 fileName = resolveFileName (providerLocation);
6669
6670 Logger::put (Logger::STANDARD_LOG,
6671 System::CIMSERVER,
6672 Logger::TRACE,
6673 "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
6674 System::getHostName(),
6675 request->nameSpace.getString(),
6676 providerName);
6677
6678 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "
6679 <<System::getHostName()
6680 <<", namespace = "
6681 mark.hamzy 1.44 <<request->nameSpace.getString()
6682 <<", providername = "
6683 <<providerName
6684 <<", fileName = "
6685 <<fileName
6686 <<PEGASUS_STD(endl));
|
6687 se.gupta 1.9
|
6688 mark.hamzy 1.44 // get cached or load new provider module
6689 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (fileName,
6690 providerName,
6691 String::EMPTY);
|
6692 schuur 1.1
|
6693 mark.hamzy 1.44 JMPIProvider &pr = ph.GetProvider ();
6694
6695 {
6696 AutoMutex lock (mutexProvTab);
6697
6698 provTab.lookup (providerName, prec);
6699 }
|
6700 schuur 1.1
|
6701 mark.hamzy 1.44 {
6702 AutoMutex lock (prec->mutex);
|
6703 mark.hamzy 1.23
|
6704 mark.hamzy 1.44 if (--prec->count <= 0)
6705 {
6706 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing provTab "<<providerName<<PEGASUS_STD(endl));
|
6707 schuur 1.1
|
6708 mark.hamzy 1.44 provTab.remove (providerName);
|
6709 schuur 1.1
|
6710 mark.hamzy 1.44 fFreePrec = true;
6711 }
6712 }
|
6713 mark.hamzy 1.25
6714 {
|
6715 mark.hamzy 1.44 CIMObjectPath sPath (request->subscriptionInstance.getPath ().getClassName ().getString ());
6716
6717 sPath.setNameSpace (request->subscriptionInstance.getPath ().getNameSpace ());
|
6718 schuur 1.1
|
6719 mark.hamzy 1.44 String sPathString = sPath.toString ();
|
6720 mark.hamzy 1.25
|
6721 mark.hamzy 1.44 AutoMutex lock (mutexSelxTab);
|
6722 schuur 1.1
|
6723 mark.hamzy 1.44 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Removing selxTab "<<sPathString<<PEGASUS_STD(endl));
|
6724 konrad.r 1.22
|
6725 mark.hamzy 1.44 selxTab.lookup (sPathString, srec);
|
6726 schuur 1.1
|
6727 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));
|
6728 schuur 1.1
|
6729 mark.hamzy 1.44 selxTab.remove (sPathString);
6730 }
|
6731 schuur 1.1
|
6732 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteSubscriptionRequest: " + pr.getName());
|
6733 schuur 1.1
|
6734 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Calling provider deleteSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
|
6735 schuur 1.1
|
6736 mark.hamzy 1.25 JvmVector *jv = 0;
6737
6738 env = JMPIjvm::attachThread(&jv);
6739
|
6740 mark.hamzy 1.37 if (!env)
6741 {
6742 PEG_METHOD_EXIT();
6743
6744 STAT_COPYDISPATCHER
6745
6746 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
6747 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
6748 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
6749 }
6750
|
6751 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
6752
6753 STAT_GETSTARTTIME;
6754
|
6755 mark.hamzy 1.43 jmethodID id = NULL;
6756 String interfaceType;
6757 String interfaceVersion;
6758
6759 getInterfaceType (request->operationContext.get (ProviderIdContainer::NAME),
6760 interfaceType,
6761 interfaceVersion);
6762
6763 if (interfaceType == "JMPI")
6764 {
6765 // public void deActivateFilter (org.pegasus.jmpi.SelectExp filter,
6766 // java.lang.String eventType,
6767 // org.pegasus.jmpi.CIMObjectPath classPath,
6768 // boolean lastActivation)
6769 // throws org.pegasus.jmpi.CIMException
6770 id = env->GetMethodID((jclass)pr.jProviderClass,
6771 "deActivateFilter",
6772 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
6773
6774 if (id != NULL)
6775 {
6776 mark.hamzy 1.43 eMethodFound = METHOD_EVENTPROVIDER;
6777 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_EVENTPROVIDER."<<PEGASUS_STD(endl));
6778 }
6779 }
6780 else if (interfaceType == "JMPIExperimental")
6781 {
6782 // public void deActivateFilter (org.pegasus.jmpi.OperationContext oc,
6783 // org.pegasus.jmpi.SelectExp filter,
6784 // java.lang.String eventType,
6785 // org.pegasus.jmpi.CIMObjectPath classPath,
6786 // boolean lastActivation)
6787 // throws org.pegasus.jmpi.CIMException
6788 id = env->GetMethodID((jclass)pr.jProviderClass,
6789 "deActivateFilter",
|
6790 mark.hamzy 1.44 "(Lorg/pegasus/jmpi/OperationContext;Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
6791 mark.hamzy 1.25
|
6792 mark.hamzy 1.43 if (id != NULL)
6793 {
6794 eMethodFound = METHOD_EVENTPROVIDER2;
6795 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_EVENTPROVIDER2."<<PEGASUS_STD(endl));
6796 }
6797 }
|
6798 schuur 1.12
|
6799 mark.hamzy 1.43 if (id == NULL)
|
6800 mark.hamzy 1.25 {
|
6801 mark.hamzy 1.43 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: No method found!"<<PEGASUS_STD(endl));
6802
6803 PEG_METHOD_EXIT();
6804
6805 STAT_COPYDISPATCHER
6806
6807 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
6808 MessageLoaderParms ("ProviderManager.JMPI.METHOD_NOT_FOUND",
6809 "Could not find a method for the provider based on InterfaceType."));
|
6810 mark.hamzy 1.25 }
|
6811 mark.hamzy 1.23
6812 JMPIjvm::checkException(env);
6813
|
6814 mark.hamzy 1.25 switch (eMethodFound)
6815 {
|
6816 mark.hamzy 1.43 case METHOD_EVENTPROVIDER:
6817 {
|
6818 mark.hamzy 1.44 CMPI_SelectExp *eSelx = newSelectExp (srec->qContext,
6819 prec->ctx,
6820 srec->query,
6821 srec->queryLanguage,
6822 request->nameSpace,
6823 request->classNames,
6824 srec->propertyList);
6825 jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
6826 jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef);
|
6827 mark.hamzy 1.43
6828 JMPIjvm::checkException(env);
6829
|
6830 mark.hamzy 1.44 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
6831 mark.hamzy 1.43
6832 JMPIjvm::checkException(env);
6833
|
6834 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
6835 request->nameSpace,
6836 request->classNames[0]);
6837 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
6838 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6839 mark.hamzy 1.43
6840 JMPIjvm::checkException(env);
6841
|
6842 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
6843 id,
6844 jEselx,
6845 jType,
6846 jcop,
6847 (jboolean)fFreePrec);
|
6848 mark.hamzy 1.43
6849 JMPIjvm::checkException(env);
6850
6851 STAT_PMS_PROVIDEREND;
6852 break;
6853 }
6854
6855 case METHOD_EVENTPROVIDER2:
|
6856 mark.hamzy 1.25 {
|
6857 mark.hamzy 1.43 jint jocRef = DEBUG_ConvertCToJava (OperationContext*, jint, &request->operationContext);
6858 jobject joc = env->NewObject(jv->OperationContextClassRef,jv->OperationContextNewI,jocRef);
6859
|
6860 mark.hamzy 1.44 CMPI_SelectExp *eSelx = newSelectExp (srec->qContext,
6861 prec->ctx,
6862 srec->query,
6863 srec->queryLanguage,
6864 request->nameSpace,
6865 request->classNames,
6866 srec->propertyList);
6867 jint jEselxRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
6868 jobject jEselx = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jEselxRef);
|
6869 mark.hamzy 1.25
6870 JMPIjvm::checkException(env);
6871
|
6872 mark.hamzy 1.44 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
6873 schuur 1.12
|
6874 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6875 schuur 1.12
|
6876 mark.hamzy 1.44 CIMObjectPath *cop = new CIMObjectPath (System::getHostName(),
6877 request->nameSpace,
6878 request->classNames[0]);
6879 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
6880 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
6881 schuur 1.1
|
6882 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6883 schuur 1.1
|
6884 mark.hamzy 1.44 env->CallVoidMethod ((jobject)pr.jProvider,
6885 id,
6886 joc,
6887 jEselx,
6888 jType,
6889 jcop,
6890 (jboolean)fFreePrec);
|
6891 schuur 1.1
|
6892 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
6893 schuur 1.1
|
6894 mark.hamzy 1.43 if (joc)
6895 {
6896 env->CallVoidMethod (joc, JMPIjvm::jv.OperationContextUnassociate);
6897
6898 JMPIjvm::checkException(env);
6899 }
6900
|
6901 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
6902 break;
6903 }
|
6904 schuur 1.12
|
6905 mark.hamzy 1.25 case METHOD_UNKNOWN:
6906 {
6907 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: should not be here!"<<PEGASUS_STD(endl));
6908 break;
6909 }
6910 }
|
6911 mark.hamzy 1.44
6912 //
6913 // Decrement count of current subscriptions for this provider
6914 //
6915 pr.decrementSubscriptionsAndTestIfZero ();
|
6916 schuur 1.1 }
6917 HandlerCatch(handler);
|
6918 schuur 1.12
|
6919 mark.hamzy 1.44 if (srec)
6920 {
6921 if ( srec->eSelx
6922 && srec->eSelx->props
6923 )
6924 {
6925 const char **props = srec->eSelx->props;
6926
6927 while (*props)
6928 {
6929 const char *prop = *props;
6930
6931 props++;
6932
6933 if (prop)
6934 {
6935 free ((void *)prop);
6936 }
6937 }
6938
6939 free ((void *)srec->eSelx->props);
6940 mark.hamzy 1.44 }
6941 delete srec->eSelx;
6942 delete srec->qContext;
6943 }
6944 delete srec;
6945
6946 if (fFreePrec)
6947 {
6948 delete prec->ctx;
6949 delete prec->handler;
6950 delete prec;
6951 }
6952
|
6953 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
6954
|
6955 schuur 1.1 PEG_METHOD_EXIT();
6956
|
6957 w.white 1.31 STAT_COPYDISPATCHER
6958
|
6959 schuur 1.1 return(response);
6960 }
6961
6962 Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw()
6963 {
6964 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDisableModuleRequest");
6965
6966 CIMDisableModuleRequestMessage * request =
6967 dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));
6968
6969 PEGASUS_ASSERT(request != 0);
6970
6971 // get provider module name
6972 String moduleName;
6973 CIMInstance mInstance = request->providerModule;
6974 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
6975
6976 if(pos != PEG_NOT_FOUND)
6977 {
6978 mInstance.getProperty(pos).getValue().get(moduleName);
6979 }
6980 schuur 1.1
6981 Boolean disableProviderOnly = request->disableProviderOnly;
6982
6983 Array<Uint16> operationalStatus;
|
6984 kumpf 1.2 // Assume success.
|
6985 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
6986 schuur 1.1
|
6987 kumpf 1.2 //
|
6988 schuur 1.1 // Unload providers
|
6989 kumpf 1.2 //
|
6990 schuur 1.1 Array<CIMInstance> _pInstances = request->providers;
6991
6992 CIMDisableModuleResponseMessage * response =
6993 new CIMDisableModuleResponseMessage(
6994 request->messageId,
6995 CIMException(),
6996 request->queueIds.copyAndPop(),
6997 operationalStatus);
6998
6999 PEGASUS_ASSERT(response != 0);
7000
7001 // preserve message key
7002 response->setKey(request->getKey());
7003
7004 //
7005 // Set HTTP method in response from request
7006 //
7007 response->setHttpMethod (request->getHttpMethod ());
7008
7009 PEG_METHOD_EXIT();
7010
7011 schuur 1.1 return(response);
7012 }
7013
7014 Message * JMPIProviderManager::handleEnableModuleRequest(const Message * message) throw()
7015 {
7016 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnableModuleRequest");
7017
7018 CIMEnableModuleRequestMessage * request =
7019 dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));
7020
7021 PEGASUS_ASSERT(request != 0);
7022
7023 Array<Uint16> operationalStatus;
|
7024 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
|
7025 schuur 1.1
7026 CIMEnableModuleResponseMessage * response =
7027 new CIMEnableModuleResponseMessage(
7028 request->messageId,
7029 CIMException(),
7030 request->queueIds.copyAndPop(),
7031 operationalStatus);
7032
7033 PEGASUS_ASSERT(response != 0);
7034
7035 // preserve message key
7036 response->setKey(request->getKey());
7037
7038 // Set HTTP method in response from request
7039 response->setHttpMethod (request->getHttpMethod ());
7040
7041 PEG_METHOD_EXIT();
7042
7043 return(response);
7044 }
7045
7046 schuur 1.1 Message * JMPIProviderManager::handleStopAllProvidersRequest(const Message * message) throw()
7047 {
7048 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleStopAllProvidersRequest");
7049
7050 CIMStopAllProvidersRequestMessage * request =
7051 dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));
7052
7053 PEGASUS_ASSERT(request != 0);
7054
7055 CIMStopAllProvidersResponseMessage * response =
7056 new CIMStopAllProvidersResponseMessage(
7057 request->messageId,
7058 CIMException(),
7059 request->queueIds.copyAndPop());
7060
7061 PEGASUS_ASSERT(response != 0);
7062
7063 // preserve message key
7064 response->setKey(request->getKey());
7065
7066 // Set HTTP method in response from request
7067 schuur 1.1 response->setHttpMethod (request->getHttpMethod ());
7068
7069 // tell the provider manager to shutdown all the providers
7070 providerManager.shutdownAllProviders();
7071
7072 PEG_METHOD_EXIT();
7073
7074 return(response);
7075 }
7076
|
7077 kumpf 1.4 Message * JMPIProviderManager::handleInitializeProviderRequest(const Message * message)
7078 {
7079 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleInitializeProviderRequest");
7080
7081 HandlerIntroInit(InitializeProvider,message,request,response,handler);
7082
7083 try
7084 {
7085 // resolve provider name
|
7086 mark.hamzy 1.23 ProviderName name = _resolveProviderName(
7087 request->operationContext.get(ProviderIdContainer::NAME));
|
7088 kumpf 1.4
7089 // get cached or load new provider module
|
7090 mark.hamzy 1.43 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (name.getPhysicalName(),
7091 name.getLogicalName(),
7092 String::EMPTY);
|
7093 kumpf 1.4
7094 }
7095 HandlerCatch(handler);
7096
7097 PEG_METHOD_EXIT();
7098
7099 return(response);
7100 }
7101
|
7102 mark.hamzy 1.25 Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest (const Message * message)
|
7103 carolann.graves 1.21 {
7104 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
7105 "JMPIProviderManager::handleSubscriptionInitCompleteRequest");
7106
7107 CIMSubscriptionInitCompleteRequestMessage * request =
7108 dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
7109 (const_cast <Message *> (message));
7110
7111 PEGASUS_ASSERT (request != 0);
7112
7113 CIMSubscriptionInitCompleteResponseMessage * response =
7114 dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
7115 (request->buildResponse ());
7116
7117 PEGASUS_ASSERT (response != 0);
7118
7119 //
7120 // Set indicator
7121 //
7122 _subscriptionInitComplete = true;
7123
7124 carolann.graves 1.21 //
7125 // For each provider that has at least one subscription, call
7126 // provider's enableIndications method
7127 //
7128 Array <JMPIProvider *> enableProviders;
|
7129 mark.hamzy 1.44
|
7130 carolann.graves 1.21 enableProviders = providerManager.getIndicationProvidersToEnable ();
7131
7132 Uint32 numProviders = enableProviders.size ();
|
7133 mark.hamzy 1.44
7134 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: numProviders = "<<numProviders<<PEGASUS_STD(endl));
7135
7136 #if 0
|
7137 carolann.graves 1.21 for (Uint32 i = 0; i < numProviders; i++)
7138 {
7139 try
7140 {
7141 CIMInstance provider;
|
7142 mark.hamzy 1.44
7143 provider = enableProviders[i]->getProviderInstance ();
7144
7145 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSubscriptionInitCompleteRequest: name = "<<enableProviders[i]->getName ()<<PEGASUS_STD(endl));
|
7146 carolann.graves 1.21
7147 //
7148 // Get cached or load new provider module
7149 //
|
7150 mark.hamzy 1.44 JMPIProvider::OpProviderHolder ph = providerManager.getProvider (enableProviders[i]->getModule ()->getFileName (),
7151 enableProviders[i]->getName ());
7152 indProvRecord *prec = NULL;
7153
7154 {
7155 AutoMutex lock (mutexProvTab);
7156
7157 provTab.lookup (enableProviders[i]->getName (), prec);
|
7158 carolann.graves 1.21 }
7159 }
7160 catch (CIMException & e)
7161 {
7162 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7163 "CIMException: " + e.getMessage ());
7164 }
7165 catch (Exception & e)
7166 {
7167 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7168 "Exception: " + e.getMessage ());
7169 }
7170 catch(...)
7171 {
7172 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
7173 "Unknown error in handleSubscriptionInitCompleteRequest");
7174 }
7175 }
|
7176 mark.hamzy 1.44 #endif
|
7177 carolann.graves 1.21
7178 PEG_METHOD_EXIT ();
7179 return (response);
7180 }
7181
|
7182 schuur 1.1 Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw()
7183 {
|
7184 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleUnsupportedRequest");
7185
|
7186 konrad.r 1.16 CIMRequestMessage* request =
7187 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
7188 PEGASUS_ASSERT(request != 0 );
7189
7190 CIMResponseMessage* response = request->buildResponse();
7191 response->cimException =
7192 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
|
7193 schuur 1.1
7194 PEG_METHOD_EXIT();
|
7195 konrad.r 1.16 return response;
|
7196 schuur 1.1 }
7197
|
7198 kumpf 1.2 ProviderName JMPIProviderManager::_resolveProviderName(
7199 const ProviderIdContainer & providerId)
|
7200 schuur 1.1 {
|
7201 kumpf 1.2 String providerName;
7202 String fileName;
7203 String interfaceName;
7204 CIMValue genericValue;
7205
7206 genericValue = providerId.getProvider().getProperty(
7207 providerId.getProvider().findProperty("Name")).getValue();
7208 genericValue.get(providerName);
7209
7210 genericValue = providerId.getModule().getProperty(
7211 providerId.getModule().findProperty("Location")).getValue();
7212 genericValue.get(fileName);
7213 fileName = resolveFileName(fileName);
7214
7215 // ATTN: This attribute is probably not required
7216 genericValue = providerId.getModule().getProperty(
7217 providerId.getModule().findProperty("InterfaceType")).getValue();
7218 genericValue.get(interfaceName);
7219
7220 return ProviderName(providerName, fileName, interfaceName, 0);
|
7221 schuur 1.1 }
7222
7223 String JMPIProviderManager::resolveFileName(String fileName)
7224 {
7225 String name;
7226 #if defined(PEGASUS_OS_TYPE_WINDOWS)
7227 name = fileName; // + String(".dll");
7228 #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
7229 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
7230 name.append(String("/") + fileName); // + String(".sl"));
7231 #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
7232 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
7233 name.append(String("/") + fileName); // + String(".so"));
7234 #elif defined(PEGASUS_OS_OS400)
7235 name = filrName;
7236 #else
7237 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
7238 name.append(String("/") + fileName); // + String(".so"));
7239 #endif
7240 return name;
7241 }
7242 schuur 1.1
7243 PEGASUS_NAMESPACE_END
|
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI