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