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