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