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