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