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