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 JMPIProviderManager::IndProvTab JMPIProviderManager::provTab;
251 JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab;
252 JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg;
253
254 JMPIProviderManager::JMPIProviderManager(Mode m)
255 {
256 mode=m;
|
257 carolann.graves 1.21 _subscriptionInitComplete = false;
|
258 mark.hamzy 1.23
259 #ifdef PEGASUS_DEBUG
260 if (getenv("PEGASUS_JMPI_TRACE"))
261 JMPIProviderManager::trace = 1;
262 else
263 JMPIProviderManager::trace = 0;
264 #else
265 JMPIProviderManager::trace = 0;
266 #endif
|
267 schuur 1.1 }
268
269 JMPIProviderManager::~JMPIProviderManager(void)
270 {
271 }
272
|
273 schuur 1.12 Boolean JMPIProviderManager::insertProvider(const ProviderName & name,
|
274 schuur 1.1 const String &ns, const String &cn)
275 {
276 String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString());
|
277 mark.hamzy 1.23
278 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::insertProvider: "<<key<<PEGASUS_STD(endl));
279
|
280 schuur 1.1 return provReg.insert(key,name);
281 }
|
282 mark.hamzy 1.23
|
283 schuur 1.1 Message * JMPIProviderManager::processMessage(Message * request) throw()
284 {
|
285 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::processMessage()");
|
286 schuur 1.1
287 Message * response = 0;
|
288 mark.hamzy 1.23
|
289 schuur 1.1 // pass the request message to a handler method based on message type
290 switch(request->getType())
291 {
292 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
293 response = handleGetInstanceRequest(request);
|
294 mark.hamzy 1.25 break;
|
295 schuur 1.1
296 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
297 response = handleEnumerateInstancesRequest(request);
|
298 mark.hamzy 1.25 break;
|
299 schuur 1.1
300 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
301 response = handleEnumerateInstanceNamesRequest(request);
|
302 mark.hamzy 1.25 break;
|
303 schuur 1.1
304 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
305 response = handleCreateInstanceRequest(request);
|
306 mark.hamzy 1.25 break;
|
307 schuur 1.1
308 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
309 response = handleModifyInstanceRequest(request);
|
310 mark.hamzy 1.25 break;
|
311 schuur 1.1
312 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
313 response = handleDeleteInstanceRequest(request);
|
314 mark.hamzy 1.25 break;
|
315 schuur 1.1
|
316 mark.hamzy 1.25 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
317 response = handleExecQueryRequest(request);
|
318 schuur 1.1 break;
319
320 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
321 response = handleAssociatorsRequest(request);
|
322 mark.hamzy 1.25 break;
|
323 schuur 1.1
324 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
325 response = handleAssociatorNamesRequest(request);
|
326 mark.hamzy 1.25 break;
|
327 schuur 1.1
328 case CIM_REFERENCES_REQUEST_MESSAGE:
329 response = handleReferencesRequest(request);
|
330 mark.hamzy 1.25 break;
|
331 schuur 1.1
332 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
333 response = handleReferenceNamesRequest(request);
|
334 mark.hamzy 1.25 break;
|
335 schuur 1.1
|
336 mark.hamzy 1.26 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
337 response = handleGetPropertyRequest(request);
338 break;
339
340 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
341 response = handleSetPropertyRequest(request);
342 break;
343
|
344 schuur 1.11 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
|
345 schuur 1.1 response = handleInvokeMethodRequest(request);
|
346 mark.hamzy 1.25 break;
|
347 schuur 1.1
|
348 schuur 1.12 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
|
349 schuur 1.1 response = handleCreateSubscriptionRequest(request);
|
350 mark.hamzy 1.25 break;
|
351 schuur 1.1
|
352 mark.hamzy 1.25 /* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
|
353 schuur 1.1 response = handleModifySubscriptionRequest(request);
354 break;
|
355 schuur 1.12 */
|
356 schuur 1.1 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
357 response = handleDeleteSubscriptionRequest(request);
|
358 mark.hamzy 1.25 break;
|
359 schuur 1.1
|
360 mark.hamzy 1.26 /* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
|
361 kumpf 1.7 response = handleExportIndicationRequest(request);
|
362 schuur 1.1 break;
|
363 schuur 1.12 */
|
364 schuur 1.1 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
365 response = handleDisableModuleRequest(request);
|
366 mark.hamzy 1.25 break;
|
367 schuur 1.1
368 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
369 response = handleEnableModuleRequest(request);
|
370 mark.hamzy 1.25 break;
|
371 schuur 1.1
372 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
373 response = handleStopAllProvidersRequest(request);
|
374 mark.hamzy 1.25 break;
|
375 schuur 1.1
|
376 kumpf 1.4 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
|
377 mark.hamzy 1.23 response = handleInitializeProviderRequest(request);
|
378 mark.hamzy 1.25 break;
|
379 kumpf 1.4
|
380 carolann.graves 1.21 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
381 response = handleSubscriptionInitCompleteRequest (request);
|
382 mark.hamzy 1.25 break;
|
383 carolann.graves 1.21
|
384 schuur 1.1 default:
|
385 mark.hamzy 1.23 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
386 "*** Unsupported Request "+request->getType());
387 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::processMessage: Unsupported request "<<request->getType ()<<PEGASUS_STD(endl));
|
388 mark.hamzy 1.25
|
389 schuur 1.1 response = handleUnsupportedRequest(request);
390 break;
391 }
392
393 PEG_METHOD_EXIT();
394
395 return(response);
396 }
397
|
398 kumpf 1.6 Boolean JMPIProviderManager::hasActiveProviders()
399 {
400 return providerManager.hasActiveProviders();
401 }
402
403 void JMPIProviderManager::unloadIdleProviders()
|
404 schuur 1.1 {
|
405 kumpf 1.6 providerManager.unloadIdleProviders();
|
406 schuur 1.1 }
407
408 #define STRDUPA(s,o) \
409 if (s) { \
410 o=(const char*)alloca(strlen(s)); \
411 strcpy((char*)(o),(s)); \
412 } \
413 else o=NULL;
414
415 #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)
416
417
418 #define HandlerIntroBase(type,type1,message,request,response,handler,respType) \
419 CIM##type##RequestMessage * request = \
420 dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \
421 PEGASUS_ASSERT(request != 0); \
422 CIM##type##ResponseMessage * response = \
423 new CIM##type##ResponseMessage( \
424 request->messageId, \
425 CIMException(), \
426 request->queueIds.copyAndPop() \
427 schuur 1.1 respType \
428 PEGASUS_ASSERT(response != 0); \
429 response->setKey(request->getKey()); \
430 response->setHttpMethod(request->getHttpMethod()); \
431 type1##ResponseHandler handler(request, response);
432
433 #define VOIDINTRO );
434 #define NOVOIDINTRO(type) ,type);
435 #define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName );
436
437
438 #define HandlerIntroVoid(type,message,request,response,handler) \
439 HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO)
440
441 #define HandlerIntroMethod(type,message,request,response,handler) \
442 HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO)
443
444 #define HandlerIntroInd(type,message,request,response,handler) \
445 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
446
|
447 kumpf 1.4 #define HandlerIntroInit(type,message,request,response,handler) \
448 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
449
|
450 schuur 1.1 #define HandlerIntro(type,message,request,response,handler,respType) \
451 HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType))
452
453 #define HandlerCatch(handler) \
454 catch(CIMException & e) \
455 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
456 "Exception: " + e.getMessage()); \
457 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); \
458 } \
459 catch(Exception & e) \
460 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
461 "Exception: " + e.getMessage()); \
462 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \
463 } \
464 catch(...) \
465 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
466 "Exception: Unknown"); \
467 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
468 }
469
|
470 schuur 1.13 static jobjectArray getList(JvmVector *jv, JNIEnv *env, CIMPropertyList &list)
471 {
472 Uint32 s=list.size();
473 jobjectArray pl=NULL;
474 if (s) {
475 jstring initial=env->NewString(NULL,0);
|
476 mark.hamzy 1.23 pl=(jobjectArray)env->NewObjectArray(s,jv->StringClassRef,initial);
|
477 schuur 1.13 for (Uint32 i=0; i<s; i++) {
478 env->SetObjectArrayElement
479 (pl,i,env->NewStringUTF(list[i].getString().getCString()));
480 }
481 }
482 return pl;
483 }
|
484 schuur 1.1
485 Message * JMPIProviderManager::handleGetInstanceRequest(const Message * message) throw()
486 {
|
487 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetInstanceRequest");
|
488 schuur 1.1
489 HandlerIntro(GetInstance,message,request,response,handler,CIMInstance());
490
|
491 mark.hamzy 1.25 typedef enum {
492 METHOD_UNKNOWN = 0,
493 METHOD_PEGASUS_24,
|
494 mark.hamzy 1.35 METHOD_PEGASUS_25,
495 METHOD_SNIA_PROVIDER20,
|
496 mark.hamzy 1.25 } METHOD_VERSION;
497 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
498 JNIEnv *env = NULL;
|
499 schuur 1.13
|
500 schuur 1.1 try {
|
501 mark.hamzy 1.23 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
502 schuur 1.1 "JMPIProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
503 System::getHostName(),
504 request->nameSpace.getString(),
505 request->instanceName.getClassName().getString());
506
|
507 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));
508
|
509 schuur 1.1 // make target object path
|
510 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
511 request->nameSpace,
512 request->instanceName.getClassName(),
513 request->instanceName.getKeyBindings());
|
514 schuur 1.1
515 // resolve provider name
|
516 kumpf 1.2 ProviderName name = _resolveProviderName(
517 request->operationContext.get(ProviderIdContainer::NAME));
|
518 schuur 1.1
519 // get cached or load new provider module
520 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(),
|
521 mark.hamzy 1.23 name.getLogicalName());
|
522 schuur 1.1 OperationContext context;
523
|
524 mark.hamzy 1.23 // forward request
|
525 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
526 schuur 1.1
|
527 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.getInstance: " + pr.getName());
|
528 schuur 1.1
|
529 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Calling provider getInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
530 schuur 1.1
|
531 mark.hamzy 1.25 JvmVector *jv = 0;
532
533 env = JMPIjvm::attachThread(&jv);
534
|
535 mark.hamzy 1.37 if (!env)
536 {
537 PEG_METHOD_EXIT();
538
539 STAT_COPYDISPATCHER
540
541 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
542 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
543 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
544 }
545
546 ////////DDD(debugPrintMethodPointers (env, (jclass)pr.jProviderClass));
547
|
548 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
549
550 STAT_GETSTARTTIME;
551
552 jmethodID id = NULL;
553
|
554 mark.hamzy 1.34 /* Fix for 4238 */
|
555 mark.hamzy 1.25 // public abstract org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop,
556 // org.pegasus.jmpi.CIMClass cimClass,
|
557 mark.hamzy 1.34 // boolean includeQualifiers,
558 // boolean includeClassOrigin,
559 // String propertyList[])
|
560 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
561 id = env->GetMethodID((jclass)pr.jProviderClass,
562 "getInstance",
|
563 mark.hamzy 1.38 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Lorg/pegasus/jmpi/CIMInstance;");
|
564 mark.hamzy 1.25
565 if (id != NULL)
566 {
|
567 mark.hamzy 1.35 eMethodFound = METHOD_PEGASUS_25;
568 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_PEGASUS_25."<<PEGASUS_STD(endl));
|
569 mark.hamzy 1.34 }
570 /* Fix for 4238 */
571
572 if (id == NULL)
573 {
574 env->ExceptionClear();
575
576 // public abstract org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop,
577 // org.pegasus.jmpi.CIMClass cimClass,
578 // boolean localOnly)
579 // throws org.pegasus.jmpi.CIMException
580 id = env->GetMethodID((jclass)pr.jProviderClass,
581 "getInstance",
582 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;");
583
584 if (id != NULL)
585 {
|
586 mark.hamzy 1.35 eMethodFound = METHOD_SNIA_PROVIDER20;
587 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
588 mark.hamzy 1.34 }
|
589 mark.hamzy 1.25 }
590
591 if (id == NULL)
592 {
593 env->ExceptionClear();
594
595 // public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath op,
596 // boolean localOnly,
597 // boolean includeQualifiers,
598 // boolean includeClassOrigin,
599 // java.lang.String[] propertyList,
600 // org.pegasus.jmpi.CIMClass cc)
601 // throws org.pegasus.jmpi.CIMException
602 id = env->GetMethodID((jclass)pr.jProviderClass,
603 "getInstance",
604 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)Lorg/pegasus/jmpi/CIMInstance;");
605
606 if (id != NULL)
607 {
608 eMethodFound = METHOD_PEGASUS_24;
609 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
610 mark.hamzy 1.25 }
611 }
612
|
613 schuur 1.1 JMPIjvm::checkException(env);
|
614 mark.hamzy 1.23
|
615 mark.hamzy 1.25 switch (eMethodFound)
616 {
617 case METHOD_PEGASUS_24:
618 {
|
619 mark.hamzy 1.29 jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
620 jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);
|
621 mark.hamzy 1.25
622 JMPIjvm::checkException(env);
623
|
624 mark.hamzy 1.40 CIMClass cls;
625
626 try
627 {
628 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
629 AutoMutex lock (pr._cimomMutex);
630
631 cls = pr._cimom_handle->getClass(context,
632 request->nameSpace,
633 request->instanceName.getClassName(),
634 false,
635 true,
636 true,
637 CIMPropertyList());
638 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
639 }
640 catch (CIMException e)
641 {
642 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
643 throw;
644 }
645 mark.hamzy 1.40
|
646 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
647
648 JMPIjvm::checkException(env);
|
649 mark.hamzy 1.25
|
650 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
651 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
652 mark.hamzy 1.25
653 JMPIjvm::checkException(env);
|
654 mark.hamzy 1.23
|
655 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
656 schuur 1.1
|
657 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
658 id,
659 jop,
|
660 mark.hamzy 1.36 JMPI_LOCALONLY,
661 JMPI_INCLUDE_QUALIFIERS,
|
662 mark.hamzy 1.29 request->includeClassOrigin,
663 jPropertyList,
664 jcimClass);
|
665 mark.hamzy 1.23
|
666 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
667 mark.hamzy 1.23
|
668 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
|
669 schuur 1.1
|
670 mark.hamzy 1.25 handler.processing();
|
671 schuur 1.1
|
672 mark.hamzy 1.29 if (jciRet) {
673 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
674 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
675 schuur 1.13
|
676 mark.hamzy 1.29 handler.deliver(*ciRet);
|
677 mark.hamzy 1.25 }
678 handler.complete();
679 break;
|
680 mark.hamzy 1.23 }
|
681 schuur 1.13
|
682 mark.hamzy 1.34 /* Fix for 4238 */
|
683 mark.hamzy 1.35 case METHOD_PEGASUS_25:
|
684 mark.hamzy 1.34 {
685 jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
686 jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);
687
688 JMPIjvm::checkException(env);
689
|
690 mark.hamzy 1.40 CIMClass cls;
691
692 try
693 {
694 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
695 AutoMutex lock (pr._cimomMutex);
696
697 cls = pr._cimom_handle->getClass(context,
698 request->nameSpace,
699 request->instanceName.getClassName(),
700 false,
701 true,
702 true,
703 CIMPropertyList());
704 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
705 }
706 catch (CIMException e)
707 {
708 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
709 throw;
710 }
711 mark.hamzy 1.40
|
712 mark.hamzy 1.34 CIMClass *pcls = new CIMClass (cls);
713
714 JMPIjvm::checkException(env);
715
716 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
717 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
718
719 JMPIjvm::checkException(env);
720
721 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
722 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
723 id,
724 jop,
725 jcimClass,
726 JMPI_INCLUDE_QUALIFIERS,
727 request->includeClassOrigin,
728 jPropertyList);
729
730 JMPIjvm::checkException(env);
731
732 STAT_PMS_PROVIDEREND;
733 mark.hamzy 1.34
734 handler.processing();
735
736 if (jciRet) {
737 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
738 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
739
740 handler.deliver(*ciRet);
741 }
742 handler.complete();
743 break;
744 }
745 /* Fix for 4238 */
746
|
747 mark.hamzy 1.35 case METHOD_SNIA_PROVIDER20:
|
748 mark.hamzy 1.25 {
|
749 mark.hamzy 1.29 jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
750 jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);
|
751 mark.hamzy 1.25
752 JMPIjvm::checkException(env);
753
|
754 mark.hamzy 1.40 CIMClass cls;
755
756 try
757 {
758 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
759 AutoMutex lock (pr._cimomMutex);
760
761 cls = pr._cimom_handle->getClass(context,
762 request->nameSpace,
763 request->instanceName.getClassName(),
764 false,
765 true,
766 true,
767 CIMPropertyList());
768 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->instanceName.getClassName()<<PEGASUS_STD(endl));
769 }
770 catch (CIMException e)
771 {
772 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
773 throw;
774 }
775 mark.hamzy 1.40
|
776 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
777 mark.hamzy 1.25
|
778 mark.hamzy 1.27 JMPIjvm::checkException(env);
779
|
780 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
781 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
782 mark.hamzy 1.25
783 JMPIjvm::checkException(env);
784
|
785 mark.hamzy 1.30 // Modified for Bugzilla# 3679
|
786 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
787 id,
788 jop,
789 jcimClass,
|
790 mark.hamzy 1.30 JMPI_LOCALONLY);
|
791 mark.hamzy 1.25
792 JMPIjvm::checkException(env);
793
794 STAT_PMS_PROVIDEREND;
|
795 schuur 1.1
|
796 mark.hamzy 1.25 handler.processing();
|
797 schuur 1.13
|
798 mark.hamzy 1.29 if (jciRet) {
799 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
800 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
801 schuur 1.13
|
802 mark.hamzy 1.29 handler.deliver(*ciRet);
|
803 mark.hamzy 1.25 }
804 handler.complete();
805 break;
806 }
|
807 mark.hamzy 1.23
|
808 mark.hamzy 1.25 case METHOD_UNKNOWN:
809 {
810 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
811 break;
812 }
|
813 schuur 1.1 }
|
814 schuur 1.13 }
|
815 schuur 1.1 HandlerCatch(handler);
|
816 schuur 1.13
|
817 schuur 1.1 if (env) JMPIjvm::detachThread();
|
818 schuur 1.13
|
819 schuur 1.1 PEG_METHOD_EXIT();
820
|
821 w.white 1.31 STAT_COPYDISPATCHER
822
|
823 schuur 1.1 return(response);
824 }
825
826 Message * JMPIProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()
827 {
|
828 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleEnumerateInstanceRequest");
829
830 HandlerIntro(EnumerateInstances,message,request,response,handler,Array<CIMInstance>());
|
831 schuur 1.1
|
832 mark.hamzy 1.25 typedef enum {
833 METHOD_UNKNOWN = 0,
834 METHOD_PEGASUS_24,
|
835 mark.hamzy 1.35 METHOD_PEGASUS_25,
836 METHOD_SNIA_PROVIDER20,
|
837 mark.hamzy 1.25 } METHOD_VERSION;
838 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
839 JNIEnv *env = NULL;
|
840 schuur 1.13
841 try {
|
842 schuur 1.1 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
843 "JMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",
844 System::getHostName(),
845 request->nameSpace.getString(),
846 request->className.getString());
847
|
848 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
849
|
850 schuur 1.1 // make target object path
|
851 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
852 request->nameSpace,
853 request->className);
|
854 schuur 1.1
855 // resolve provider name
|
856 kumpf 1.2 ProviderName name = _resolveProviderName(
857 request->operationContext.get(ProviderIdContainer::NAME));
|
858 schuur 1.1
859 // get cached or load new provider module
860 JMPIProvider::OpProviderHolder ph =
861 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
862 String::EMPTY);
863
|
864 schuur 1.12 // convert arguments
|
865 schuur 1.1 OperationContext context;
866
|
867 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
868 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
869 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
870 schuur 1.1
871 // forward request
|
872 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
873 schuur 1.1
|
874 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.enumerateInstances: " + pr.getName());
|
875 schuur 1.1
|
876 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Calling provider enumerateInstances: "<<pr.getName()<<PEGASUS_STD(endl));
|
877 schuur 1.12
|
878 mark.hamzy 1.25 JvmVector *jv = 0;
879
880 env = JMPIjvm::attachThread(&jv);
881
|
882 mark.hamzy 1.37 if (!env)
883 {
884 PEG_METHOD_EXIT();
885
886 STAT_COPYDISPATCHER
887
888 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
889 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
890 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
891 }
892
|
893 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
894
895 STAT_GETSTARTTIME;
896
897 jmethodID id = NULL;
898
|
899 mark.hamzy 1.33 /* Fix for 4189 */
|
900 mark.hamzy 1.36 // public java.util.Vector enumerateInstances (org.pegasus.jmpi.CIMObjectPath cop,
901 // org.pegasus.jmpi.CIMClass cimClass,
902 // boolean includeQualifiers,
903 // boolean includeClassOrigin,
904 // java.lang.String[] propertyList)
905 // throws org.pegasus.jmpi.CIMException
|
906 mark.hamzy 1.25 id = env->GetMethodID((jclass)pr.jProviderClass,
|
907 mark.hamzy 1.36 "enumerateInstances",
|
908 mark.hamzy 1.38 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
909 mark.hamzy 1.25
910 if (id != NULL)
911 {
|
912 mark.hamzy 1.35 eMethodFound = METHOD_PEGASUS_25;
913 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_PEGASUS_25."<<PEGASUS_STD(endl));
|
914 mark.hamzy 1.33 }
915 /* Fix for 4189 */
916
917 if (id == NULL)
918 {
919 env->ExceptionClear();
920
921 // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,
922 // boolean deep,
923 // org.pegasus.jmpi.CIMClass cimClass,
924 // boolean localOnly)
925 // throws org.pegasus.jmpi.CIMException
926 id = env->GetMethodID((jclass)pr.jProviderClass,
927 "enumInstances",
928 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;");
929
930 if (id != NULL)
931 {
|
932 mark.hamzy 1.35 eMethodFound = METHOD_SNIA_PROVIDER20;
933 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
934 mark.hamzy 1.33 }
|
935 mark.hamzy 1.25 }
936
937 if (id == NULL)
938 {
939 env->ExceptionClear();
|
940 schuur 1.1
|
941 mark.hamzy 1.36 // public org.pegasus.jmpi.CIMInstance[] enumInstances (org.pegasus.jmpi.CIMObjectPath cop,
942 // boolean localOnly,
943 // boolean includeQualifiers,
944 // boolean includeClassOrigin,
945 // java.lang.String[] propertyList,
946 // org.pegasus.jmpi.CIMClass cimClass)
|
947 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
948 id = env->GetMethodID((jclass)pr.jProviderClass,
|
949 mark.hamzy 1.36 "enumInstances",
|
950 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");
|
951 mark.hamzy 1.23
|
952 mark.hamzy 1.25 if (id != NULL)
953 {
954 eMethodFound = METHOD_PEGASUS_24;
955 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
956 }
957 }
|
958 schuur 1.12
959 JMPIjvm::checkException(env);
|
960 mark.hamzy 1.23
|
961 mark.hamzy 1.25 switch (eMethodFound)
962 {
963 case METHOD_PEGASUS_24:
964 {
|
965 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
966 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
967 mark.hamzy 1.23
|
968 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
969 schuur 1.1
|
970 mark.hamzy 1.40 CIMClass cls;
971
972 try
973 {
974 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
975 AutoMutex lock (pr._cimomMutex);
976
977 cls = pr._cimom_handle->getClass(context,
978 request->nameSpace,
979 request->className,
980 false,
981 true,
982 true,
983 CIMPropertyList());
984 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
985 }
986 catch (CIMException e)
987 {
988 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
989 throw;
990 }
991 mark.hamzy 1.40
|
992 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
993
|
994 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
995 schuur 1.1
|
996 mark.hamzy 1.29 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
997 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
|
998 schuur 1.13
|
999 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1000 schuur 1.1
|
1001 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
1002 mark.hamzy 1.36 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1003 id,
1004 jcop,
1005 JMPI_LOCALONLY,
1006 JMPI_INCLUDE_QUALIFIERS,
1007 request->includeClassOrigin,
1008 jPropertyList,
1009 jcc);
|
1010 mark.hamzy 1.25
|
1011 mark.hamzy 1.23 JMPIjvm::checkException(env);
1012
1013 STAT_PMS_PROVIDEREND;
1014
1015 handler.processing();
|
1016 mark.hamzy 1.25 if (jAr) {
1017 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
1018 mark.hamzy 1.23 JMPIjvm::checkException(env);
1019
|
1020 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jAr,i);
1021
|
1022 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1023 schuur 1.13
|
1024 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
1025 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
1026 schuur 1.13
|
1027 mark.hamzy 1.36 /* Fix for 4237 */
|
1028 mark.hamzy 1.40 CIMClass cls;
1029
1030 try
1031 {
1032 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1033 AutoMutex lock (pr._cimomMutex);
1034
1035 cls = pr._cimom_handle->getClass(context,
1036 request->nameSpace,
1037 ciRet->getClassName(),
1038 false,
1039 true,
1040 true,
1041 CIMPropertyList());
1042 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1043 }
1044 catch (CIMException e)
1045 {
1046 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1047 throw;
1048 }
1049 mark.hamzy 1.40
|
1050 mark.hamzy 1.36 const CIMObjectPath& op = ciRet->getPath();
1051 CIMObjectPath iop = ciRet->buildPath(cls);
1052
|
1053 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1054 schuur 1.13
|
1055 mark.hamzy 1.29 handler.deliver(*ciRet);
|
1056 mark.hamzy 1.23 }
1057 }
1058 handler.complete();
|
1059 mark.hamzy 1.25 break;
|
1060 schuur 1.13 }
|
1061 mark.hamzy 1.25
|
1062 mark.hamzy 1.33 /* Fix for 4189 */
|
1063 mark.hamzy 1.35 case METHOD_PEGASUS_25:
|
1064 mark.hamzy 1.33 {
1065 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1066 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
1067
1068 JMPIjvm::checkException(env);
1069
|
1070 mark.hamzy 1.40 CIMClass cls;
1071
1072 try
1073 {
1074 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1075 AutoMutex lock (pr._cimomMutex);
1076
1077 cls = pr._cimom_handle->getClass (context,
1078 request->nameSpace,
1079 request->className,
1080 false,
1081 true,
1082 true,
1083 CIMPropertyList());
1084 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1085 }
1086 catch (CIMException e)
1087 {
1088 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1089 throw;
1090 }
1091 mark.hamzy 1.40
|
1092 mark.hamzy 1.33 CIMClass *pcls = new CIMClass (cls);
1093
1094 JMPIjvm::checkException(env);
1095
1096 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1097 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
1098
1099 JMPIjvm::checkException(env);
1100
1101 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
1102 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1103 id,
1104 jcop,
|
1105 mark.hamzy 1.35 jcc,
|
1106 mark.hamzy 1.33 JMPI_INCLUDE_QUALIFIERS,
1107 request->includeClassOrigin,
1108 jPropertyList);
1109
1110 JMPIjvm::checkException(env);
1111
1112 STAT_PMS_PROVIDEREND;
1113
1114 handler.processing();
1115 if (jVec) {
1116 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1117 JMPIjvm::checkException(env);
1118
1119 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1120
1121 JMPIjvm::checkException(env);
1122
1123 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
1124 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
1125
1126 /* Fix for 4237 */
|
1127 mark.hamzy 1.40 CIMClass cls;
1128
1129 try
1130 {
1131 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1132 AutoMutex lock (pr._cimomMutex);
1133
1134 cls = pr._cimom_handle->getClass(context,
1135 request->nameSpace,
1136 ciRet->getClassName(),
1137 false,
1138 true,
1139 true,
1140 CIMPropertyList());
1141 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1142 }
1143 catch (CIMException e)
1144 {
1145 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1146 throw;
1147 }
1148 mark.hamzy 1.40
|
1149 mark.hamzy 1.33 const CIMObjectPath& op = ciRet->getPath();
1150 CIMObjectPath iop = ciRet->buildPath(cls);
1151
1152 JMPIjvm::checkException(env);
1153
1154 iop.setNameSpace(op.getNameSpace());
1155
1156 ciRet->setPath(iop);
1157 /* Fix for 4237*/
1158
1159 handler.deliver(*ciRet);
1160 }
1161 }
1162 handler.complete();
1163 break;
1164 }
1165 /* Fix for 4189 */
1166
|
1167 mark.hamzy 1.35 case METHOD_SNIA_PROVIDER20:
|
1168 mark.hamzy 1.25 {
|
1169 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1170 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1171 mark.hamzy 1.25
1172 JMPIjvm::checkException(env);
1173
|
1174 mark.hamzy 1.40 CIMClass cls;
1175
1176 try
1177 {
1178 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1179 AutoMutex lock (pr._cimomMutex);
1180
1181 cls = pr._cimom_handle->getClass(context,
1182 request->nameSpace,
1183 request->className,
1184 false,
1185 true,
1186 true,
1187 CIMPropertyList());
1188 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1189 }
1190 catch (CIMException e)
1191 {
1192 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1193 throw;
1194 }
1195 mark.hamzy 1.40
|
1196 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
1197
|
1198 mark.hamzy 1.25 JMPIjvm::checkException(env);
1199
|
1200 mark.hamzy 1.29 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1201 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
|
1202 mark.hamzy 1.25
1203 JMPIjvm::checkException(env);
1204
|
1205 mark.hamzy 1.30 // Modified for Bugzilla# 3679
|
1206 mark.hamzy 1.25 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1207 id,
|
1208 mark.hamzy 1.29 jcop,
|
1209 mark.hamzy 1.33 request->deepInheritance,
|
1210 mark.hamzy 1.29 jcc,
|
1211 mark.hamzy 1.30 JMPI_LOCALONLY);
|
1212 mark.hamzy 1.25
|
1213 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1214 schuur 1.12
|
1215 mark.hamzy 1.23 STAT_PMS_PROVIDEREND;
1216
1217 handler.processing();
|
1218 mark.hamzy 1.25 if (jVec) {
1219 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
1220 mark.hamzy 1.23 JMPIjvm::checkException(env);
1221
|
1222 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1223
|
1224 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1225 schuur 1.12
|
1226 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
1227 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
1228 schuur 1.12
|
1229 mark.hamzy 1.33 /* Fix for 4237 */
|
1230 mark.hamzy 1.40 CIMClass cls;
1231
1232 try
1233 {
1234 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1235 AutoMutex lock (pr._cimomMutex);
1236
1237 cls = pr._cimom_handle->getClass(context,
1238 request->nameSpace,
1239 ciRet->getClassName(),
1240 false,
1241 true,
1242 true,
1243 CIMPropertyList());
1244 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
1245 }
1246 catch (CIMException e)
1247 {
1248 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1249 throw;
1250 }
1251 mark.hamzy 1.40
|
1252 mark.hamzy 1.33 const CIMObjectPath& op = ciRet->getPath();
1253 CIMObjectPath iop = ciRet->buildPath(cls);
1254
1255 JMPIjvm::checkException(env);
1256
1257 iop.setNameSpace(op.getNameSpace());
1258
1259 ciRet->setPath(iop);
1260 /* Fix for 4237*/
1261
|
1262 mark.hamzy 1.29 handler.deliver(*ciRet);
|
1263 mark.hamzy 1.23 }
1264 }
1265 handler.complete();
|
1266 mark.hamzy 1.25 break;
1267 }
1268
1269 case METHOD_UNKNOWN:
1270 {
1271 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: should not be here!"<<PEGASUS_STD(endl));
1272 break;
1273 }
|
1274 schuur 1.1 }
1275 }
1276 HandlerCatch(handler);
|
1277 schuur 1.12
|
1278 schuur 1.11 if (env) JMPIjvm::detachThread();
|
1279 schuur 1.12
|
1280 schuur 1.1 PEG_METHOD_EXIT();
1281
|
1282 w.white 1.31 STAT_COPYDISPATCHER
1283
|
1284 schuur 1.1 return(response);
1285 }
1286
1287 Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()
1288 {
1289 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest");
1290
|
1291 mark.hamzy 1.23 HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>());
1292
|
1293 mark.hamzy 1.25 typedef enum {
1294 METHOD_UNKNOWN = 0,
1295 METHOD_PEGASUS_24,
|
1296 mark.hamzy 1.36 METHOD_PEGASUS_25,
|
1297 mark.hamzy 1.25 METHOD_SNIA_PROVIDER20,
1298 } METHOD_VERSION;
1299 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1300 JNIEnv *env = NULL;
|
1301 schuur 1.13
|
1302 schuur 1.1 try {
1303 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1304 "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1305 System::getHostName(),
1306 request->nameSpace.getString(),
1307 request->className.getString());
|
1308 mark.hamzy 1.23
1309 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
1310
|
1311 mark.hamzy 1.25 // make target object path
|
1312 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1313 request->nameSpace,
1314 request->className);
|
1315 schuur 1.1
1316 // resolve provider name
|
1317 kumpf 1.2 ProviderName name = _resolveProviderName(
1318 request->operationContext.get(ProviderIdContainer::NAME));
|
1319 schuur 1.1
1320 // get cached or load new provider module
1321 JMPIProvider::OpProviderHolder ph =
1322 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
1323
1324 // convert arguments
1325 OperationContext context;
1326
|
1327 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1328 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1329 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1330 schuur 1.1
|
1331 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1332 schuur 1.1
|
1333 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.enumerateInstanceNames: " + pr.getName());
|
1334 schuur 1.1
|
1335 mark.hamzy 1.37 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Calling provider : enumerateInstanceNames: "<<pr.getName()<<PEGASUS_STD(endl));
|
1336 schuur 1.1
|
1337 mark.hamzy 1.25 JvmVector *jv = 0;
|
1338 schuur 1.12
|
1339 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
1340 schuur 1.1
|
1341 mark.hamzy 1.37 if (!env)
1342 {
1343 PEG_METHOD_EXIT();
1344
1345 STAT_COPYDISPATCHER
1346
1347 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
1348 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
1349 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
1350 }
1351
|
1352 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
1353 schuur 1.12
|
1354 mark.hamzy 1.25 STAT_GETSTARTTIME;
|
1355 mark.hamzy 1.23
|
1356 mark.hamzy 1.25 jmethodID id = NULL;
|
1357 mark.hamzy 1.23
|
1358 mark.hamzy 1.25 // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,
1359 // boolean deep,
1360 // org.pegasus.jmpi.CIMClass cimClass)
1361 // throws org.pegasus.jmpi.CIMException
1362 id = env->GetMethodID((jclass)pr.jProviderClass,
1363 "enumInstances",
1364 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
|
1365 schuur 1.1
|
1366 mark.hamzy 1.25 if (id != NULL)
1367 {
1368 eMethodFound = METHOD_SNIA_PROVIDER20;
1369 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1370 }
|
1371 schuur 1.1
|
1372 mark.hamzy 1.25 if (id == NULL)
1373 {
1374 env->ExceptionClear();
|
1375 schuur 1.1
|
1376 mark.hamzy 1.36 // public org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.CIMObjectPath cop,
1377 // org.pegasus.jmpi.CIMClass cimClass)
|
1378 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
1379 id = env->GetMethodID((jclass)pr.jProviderClass,
1380 "enumerateInstanceNames",
1381 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;");
|
1382 schuur 1.13
|
1383 mark.hamzy 1.25 if (id != NULL)
1384 {
1385 eMethodFound = METHOD_PEGASUS_24;
1386 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
1387 }
|
1388 mark.hamzy 1.23 }
|
1389 mark.hamzy 1.25
|
1390 mark.hamzy 1.36 if (id == NULL)
1391 {
1392 env->ExceptionClear();
1393
1394 // public java.util.Vector enumerateInstanceNames (org.pegasus.jmpi.CIMObjectPath cop,
1395 // org.pegasus.jmpi.CIMClass cimClass)
1396 // throws org.pegasus.jmpi.CIMException
1397 id = env->GetMethodID((jclass)pr.jProviderClass,
1398 "enumerateInstanceNames",
1399 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
1400
1401 if (id != NULL)
1402 {
1403 eMethodFound = METHOD_PEGASUS_25;
1404 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_PEGASUS_25."<<PEGASUS_STD(endl));
1405 }
1406 }
1407
1408 if (id == NULL)
1409 {
1410 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: No method found!"<<PEGASUS_STD(endl));
1411 mark.hamzy 1.36 }
1412
|
1413 schuur 1.1 JMPIjvm::checkException(env);
1414
|
1415 mark.hamzy 1.25 switch (eMethodFound)
1416 {
1417 case METHOD_PEGASUS_24:
1418 {
|
1419 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1420 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1421 mark.hamzy 1.25
1422 JMPIjvm::checkException(env);
1423
|
1424 mark.hamzy 1.40 CIMClass cls;
1425
1426 try
1427 {
1428 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1429 AutoMutex lock (pr._cimomMutex);
1430
1431 cls = pr._cimom_handle->getClass(context,
1432 request->nameSpace,
1433 request->className,
1434 false,
1435 true,
1436 true,
1437 CIMPropertyList());
1438 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1439 }
1440 catch (CIMException e)
1441 {
1442 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1443 throw;
1444 }
1445 mark.hamzy 1.40
|
1446 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
1447 mark.hamzy 1.25
1448 JMPIjvm::checkException(env);
1449
|
1450 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1451 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
1452 mark.hamzy 1.25
1453 JMPIjvm::checkException(env);
1454
1455 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1456 id,
|
1457 mark.hamzy 1.29 jcop,
1458 jcimClass);
|
1459 mark.hamzy 1.25
|
1460 mark.hamzy 1.23 JMPIjvm::checkException(env);
1461
1462 STAT_PMS_PROVIDEREND;
1463
1464 handler.processing();
|
1465 mark.hamzy 1.25 if (jAr) {
1466 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
1467 mark.hamzy 1.23 JMPIjvm::checkException(env);
1468
|
1469 mark.hamzy 1.29 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
1470
|
1471 mark.hamzy 1.23 JMPIjvm::checkException(env);
1472
|
1473 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1474 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
1475 schuur 1.13
|
1476 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1477 schuur 1.13
|
1478 mark.hamzy 1.29 handler.deliver(*copRet);
|
1479 mark.hamzy 1.23 }
1480 }
1481 handler.complete();
|
1482 mark.hamzy 1.25 break;
|
1483 schuur 1.13 }
|
1484 mark.hamzy 1.25
|
1485 mark.hamzy 1.36 case METHOD_PEGASUS_25:
1486 {
1487 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1488 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
1489
1490 JMPIjvm::checkException(env);
1491
|
1492 mark.hamzy 1.40 CIMClass cls;
1493
1494 try
1495 {
1496 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1497 AutoMutex lock (pr._cimomMutex);
1498
1499 cls = pr._cimom_handle->getClass(context,
1500 request->nameSpace,
1501 request->className,
1502 false,
1503 true,
1504 true,
1505 CIMPropertyList());
1506 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1507 }
1508 catch (CIMException e)
1509 {
1510 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1511 throw;
1512 }
1513 mark.hamzy 1.40
|
1514 mark.hamzy 1.36 CIMClass *pcls = new CIMClass (cls);
1515
1516 JMPIjvm::checkException(env);
1517
1518 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1519 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
1520
1521 JMPIjvm::checkException(env);
1522
1523 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1524 id,
1525 jcop,
1526 jcimClass);
1527
1528 JMPIjvm::checkException(env);
1529
1530 STAT_PMS_PROVIDEREND;
1531
1532 handler.processing();
1533 if (jVec) {
1534 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1535 mark.hamzy 1.36 JMPIjvm::checkException(env);
1536
1537 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1538
1539 JMPIjvm::checkException(env);
1540
1541 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1542 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
1543
1544 JMPIjvm::checkException(env);
1545
1546 handler.deliver(*copRet);
1547 }
1548 }
1549 handler.complete();
1550 break;
1551 }
1552
|
1553 mark.hamzy 1.25 case METHOD_SNIA_PROVIDER20:
1554 {
|
1555 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1556 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1557 mark.hamzy 1.25
1558 JMPIjvm::checkException(env);
1559
|
1560 mark.hamzy 1.40 CIMClass cls;
1561
1562 try
1563 {
1564 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1565 AutoMutex lock (pr._cimomMutex);
1566
1567 cls = pr._cimom_handle->getClass(context,
1568 request->nameSpace,
1569 request->className,
1570 false,
1571 true,
1572 true,
1573 CIMPropertyList());
1574 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
1575 }
1576 catch (CIMException e)
1577 {
1578 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
1579 throw;
1580 }
1581 mark.hamzy 1.40
|
1582 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
1583 mark.hamzy 1.25
1584 JMPIjvm::checkException(env);
1585
|
1586 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1587 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
1588 mark.hamzy 1.25
1589 JMPIjvm::checkException(env);
1590
1591 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1592 id,
|
1593 mark.hamzy 1.29 jcop,
|
1594 mark.hamzy 1.25 true,
|
1595 mark.hamzy 1.29 jcimClass);
|
1596 mark.hamzy 1.25
|
1597 mark.hamzy 1.23 JMPIjvm::checkException(env);
1598
1599 STAT_PMS_PROVIDEREND;
1600
1601 handler.processing();
|
1602 mark.hamzy 1.25 if (jVec) {
1603 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
1604 mark.hamzy 1.23 JMPIjvm::checkException(env);
1605
|
1606 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1607
|
1608 mark.hamzy 1.23 JMPIjvm::checkException(env);
1609
|
1610 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1611 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
1612 schuur 1.13
|
1613 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1614 schuur 1.13
|
1615 mark.hamzy 1.29 handler.deliver(*copRet);
|
1616 mark.hamzy 1.23 }
1617 }
1618 handler.complete();
|
1619 mark.hamzy 1.25 break;
1620 }
1621
1622 case METHOD_UNKNOWN:
1623 {
1624 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: should not be here!"<<PEGASUS_STD(endl));
1625 break;
1626 }
|
1627 schuur 1.1 }
1628 }
1629 HandlerCatch(handler);
|
1630 mark.hamzy 1.23
1631 if (env) JMPIjvm::detachThread();
|
1632 schuur 1.1
1633 PEG_METHOD_EXIT();
1634
|
1635 w.white 1.31 STAT_COPYDISPATCHER
1636
|
1637 schuur 1.1 return(response);
1638 }
1639
1640 Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()
1641 {
|
1642 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest");
1643
1644 HandlerIntro(CreateInstance,message,request,response,handler,CIMObjectPath());
|
1645 schuur 1.1
|
1646 mark.hamzy 1.25 typedef enum {
1647 METHOD_UNKNOWN = 0,
1648 METHOD_SNIA_PROVIDER20,
1649 } METHOD_VERSION;
1650 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1651 JNIEnv *env = NULL;
1652
|
1653 schuur 1.1 try {
1654 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1655 "JMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
1656 System::getHostName(),
1657 request->nameSpace.getString(),
1658 request->newInstance.getPath().getClassName().getString());
1659
|
1660 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));
1661
|
1662 schuur 1.1 // make target object path
|
1663 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1664 request->nameSpace,
1665 request->newInstance.getPath().getClassName(),
1666 request->newInstance.getPath().getKeyBindings());
|
1667 schuur 1.1
1668 // resolve provider name
|
1669 kumpf 1.2 ProviderName name = _resolveProviderName(
1670 request->operationContext.get(ProviderIdContainer::NAME));
|
1671 schuur 1.1
1672 // get cached or load new provider module
1673 JMPIProvider::OpProviderHolder ph =
1674 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
|
1675 mark.hamzy 1.23 String::EMPTY);
|
1676 schuur 1.1
1677 // convert arguments
1678 OperationContext context;
1679
|
1680 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1681 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1682 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1683 schuur 1.1
1684 // forward request
|
1685 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1686 schuur 1.1
|
1687 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createInstance: " + ph.GetProvider().getName());
|
1688 schuur 1.1
|
1689 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
1690 schuur 1.12
|
1691 mark.hamzy 1.25 JvmVector *jv = 0;
1692
1693 env = JMPIjvm::attachThread(&jv);
1694
|
1695 mark.hamzy 1.37 if (!env)
1696 {
1697 PEG_METHOD_EXIT();
1698
1699 STAT_COPYDISPATCHER
1700
1701 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
1702 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
1703 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
1704 }
1705
|
1706 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
1707
1708 STAT_GETSTARTTIME;
1709
1710 jmethodID id = NULL;
1711
1712 // public abstract org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop,
1713 // org.pegasus.jmpi.CIMInstance cimInstance)
1714 // throws org.pegasus.jmpi.CIMException
1715 id = env->GetMethodID((jclass)pr.jProviderClass,
1716 "createInstance",
1717 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");
|
1718 schuur 1.1
|
1719 mark.hamzy 1.25 if (id != NULL)
1720 {
1721 eMethodFound = METHOD_SNIA_PROVIDER20;
1722 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1723 }
|
1724 mark.hamzy 1.23
1725 JMPIjvm::checkException(env);
1726
|
1727 mark.hamzy 1.25 switch (eMethodFound)
1728 {
1729 case METHOD_SNIA_PROVIDER20:
1730 {
|
1731 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1732 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1733 mark.hamzy 1.25
1734 JMPIjvm::checkException(env);
1735
|
1736 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->newInstance);
1737 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
1738 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
|
1739 mark.hamzy 1.25
1740 JMPIjvm::checkException(env);
|
1741 schuur 1.1
|
1742 mark.hamzy 1.29 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl));
|
1743 schuur 1.1
|
1744 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,
1745 id,
1746 jcop,
1747 jci);
|
1748 schuur 1.1
|
1749 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
1750 schuur 1.1
|
1751 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
|
1752 mark.hamzy 1.23
|
1753 mark.hamzy 1.25 handler.processing();
|
1754 mark.hamzy 1.23
|
1755 mark.hamzy 1.29 if (jcopRet) {
1756 jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1757 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef);
|
1758 mark.hamzy 1.23
|
1759 mark.hamzy 1.29 handler.deliver(*copRet);
|
1760 mark.hamzy 1.25 }
1761 handler.complete();
1762 break;
1763 }
|
1764 mark.hamzy 1.23
|
1765 mark.hamzy 1.25 case METHOD_UNKNOWN:
1766 {
1767 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
1768 break;
1769 }
|
1770 schuur 1.1 }
1771 }
1772 HandlerCatch(handler);
|
1773 mark.hamzy 1.23
|
1774 schuur 1.1 if (env) JMPIjvm::detachThread();
|
1775 mark.hamzy 1.23
|
1776 schuur 1.1 PEG_METHOD_EXIT();
1777
|
1778 w.white 1.31 STAT_COPYDISPATCHER
1779
|
1780 schuur 1.1 return(response);
1781 }
1782
1783 Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()
1784 {
|
1785 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest");
|
1786 schuur 1.1
1787 HandlerIntroVoid(ModifyInstance,message,request,response,handler);
|
1788 mark.hamzy 1.23
|
1789 mark.hamzy 1.25 typedef enum {
1790 METHOD_UNKNOWN = 0,
1791 METHOD_PEGASUS_24,
1792 METHOD_SNIA_PROVIDER20,
1793 } METHOD_VERSION;
1794 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1795 JNIEnv *env = NULL;
|
1796 schuur 1.13
|
1797 schuur 1.1 try {
1798 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
1799 konrad.r 1.15 "JMPIProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
1800 schuur 1.1 System::getHostName(),
1801 request->nameSpace.getString(),
1802 request->modifiedInstance.getPath().getClassName().getString());
1803
|
1804 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));
1805
|
1806 schuur 1.1 // make target object path
|
1807 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1808 request->nameSpace,
1809 request->modifiedInstance.getPath ().getClassName(),
1810 request->modifiedInstance.getPath ().getKeyBindings());
|
1811 schuur 1.1
1812 // resolve provider name
|
1813 kumpf 1.2 ProviderName name = _resolveProviderName(
1814 request->operationContext.get(ProviderIdContainer::NAME));
|
1815 schuur 1.1
|
1816 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl));
1817
|
1818 schuur 1.1 // get cached or load new provider module
1819 JMPIProvider::OpProviderHolder ph =
1820 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1821
1822 // convert arguments
1823 OperationContext context;
1824
|
1825 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1826 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1827 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1828 schuur 1.1
1829 // forward request
|
1830 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1831 mark.hamzy 1.23
1832 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName());
1833
|
1834 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));
1835
1836 JvmVector *jv = 0;
1837
1838 env = JMPIjvm::attachThread(&jv);
1839
|
1840 mark.hamzy 1.37 if (!env)
1841 {
1842 PEG_METHOD_EXIT();
1843
1844 STAT_COPYDISPATCHER
1845
1846 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
1847 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
1848 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
1849 }
1850
|
1851 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
1852 mark.hamzy 1.23
|
1853 mark.hamzy 1.25 STAT_GETSTARTTIME;
1854
1855 jmethodID id = NULL;
1856
1857 // public abstract void setInstance (org.pegasus.jmpi.CIMObjectPath cop,
1858 // org.pegasus.jmpi.CIMInstance cimInstance)
1859 // org.pegasus.jmpi.throws CIMException
1860 id = env->GetMethodID((jclass)pr.jProviderClass,
1861 "setInstance",
1862 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");
1863
1864 if (id != NULL)
1865 {
1866 eMethodFound = METHOD_SNIA_PROVIDER20;
1867 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1868 }
1869
1870 if (id == NULL)
1871 {
1872 env->ExceptionClear();
1873
1874 mark.hamzy 1.25 // public void setInstance (org.pegasus.jmpi.CIMObjectPath op,
1875 // org.pegasus.jmpi.CIMInstance ci,
1876 // boolean includeQualifiers,
1877 // java.lang.String[] propertyList)
1878 // throws org.pegasus.jmpi.CIMException
1879 id = env->GetMethodID((jclass)pr.jProviderClass,
1880 "setInstance",
1881 "(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");
|
1882 schuur 1.1
|
1883 mark.hamzy 1.25 if (id != NULL)
1884 {
1885 eMethodFound = METHOD_PEGASUS_24;
1886 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
1887 }
1888 }
|
1889 schuur 1.1
|
1890 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1891 schuur 1.1
|
1892 mark.hamzy 1.25 switch (eMethodFound)
1893 {
1894 case METHOD_PEGASUS_24:
1895 {
|
1896 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1897 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1898 mark.hamzy 1.25
1899 JMPIjvm::checkException(env);
1900
|
1901 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
1902 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
1903 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
|
1904 mark.hamzy 1.25
1905 JMPIjvm::checkException(env);
|
1906 schuur 1.1
|
1907 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
1908 schuur 1.1
|
1909 mark.hamzy 1.25 env->CallVoidMethod((jobject)pr.jProvider,
1910 id,
|
1911 mark.hamzy 1.29 jcop,
1912 jci,
|
1913 mark.hamzy 1.36 JMPI_INCLUDE_QUALIFIERS,
|
1914 mark.hamzy 1.25 jPropertyList);
|
1915 schuur 1.1
|
1916 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
1917 schuur 1.13
|
1918 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
1919 break;
|
1920 schuur 1.13 }
|
1921 schuur 1.1
|
1922 mark.hamzy 1.25 case METHOD_SNIA_PROVIDER20:
1923 {
|
1924 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1925 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1926 mark.hamzy 1.25
1927 JMPIjvm::checkException(env);
1928
|
1929 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
1930 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
1931 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
|
1932 mark.hamzy 1.25
1933 JMPIjvm::checkException(env);
1934
1935 env->CallVoidMethod((jobject)pr.jProvider,
1936 id,
|
1937 mark.hamzy 1.29 jcop,
1938 jci);
|
1939 mark.hamzy 1.25
1940 JMPIjvm::checkException(env);
|
1941 schuur 1.13
|
1942 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
1943 break;
1944 }
|
1945 mark.hamzy 1.23
|
1946 mark.hamzy 1.25 case METHOD_UNKNOWN:
1947 {
1948 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
1949 break;
1950 }
1951 }
|
1952 schuur 1.1 }
1953 HandlerCatch(handler);
|
1954 mark.hamzy 1.23
|
1955 schuur 1.1 if (env) JMPIjvm::detachThread();
|
1956 mark.hamzy 1.23
|
1957 schuur 1.1 PEG_METHOD_EXIT();
1958
|
1959 w.white 1.31 STAT_COPYDISPATCHER
1960
|
1961 schuur 1.1 return(response);
1962 }
1963
1964 Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()
1965 {
|
1966 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest");
1967
1968 HandlerIntroVoid(DeleteInstance,message,request,response,handler);
|
1969 schuur 1.1
|
1970 mark.hamzy 1.25 typedef enum {
1971 METHOD_UNKNOWN = 0,
1972 METHOD_SNIA_PROVIDER20,
1973 } METHOD_VERSION;
1974 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1975 JNIEnv *env = NULL;
1976
|
1977 schuur 1.1 try {
1978 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
1979 konrad.r 1.15 "JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
1980 schuur 1.1 System::getHostName(),
1981 request->nameSpace.getString(),
1982 request->instanceName.getClassName().getString());
1983
|
1984 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));
1985
|
1986 schuur 1.1 // make target object path
|
1987 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1988 request->nameSpace,
1989 request->instanceName.getClassName(),
1990 request->instanceName.getKeyBindings());
|
1991 schuur 1.1
1992 // resolve provider name
|
1993 kumpf 1.2 ProviderName name = _resolveProviderName(
1994 request->operationContext.get(ProviderIdContainer::NAME));
|
1995 schuur 1.1
1996 // get cached or load new provider module
1997 JMPIProvider::OpProviderHolder ph =
1998 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1999
2000 // convert arguments
2001 OperationContext context;
2002
|
2003 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
2004 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2005 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
2006 schuur 1.1
2007 // forward request
|
2008 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
2009 schuur 1.1
|
2010 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteInstance: " + pr.getName());
|
2011 schuur 1.1
|
2012 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: Calling provider deleteInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
2013 schuur 1.1
|
2014 mark.hamzy 1.25 JvmVector *jv = 0;
2015
2016 env = JMPIjvm::attachThread(&jv);
2017
|
2018 mark.hamzy 1.37 if (!env)
2019 {
2020 PEG_METHOD_EXIT();
2021
2022 STAT_COPYDISPATCHER
2023
2024 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2025 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
2026 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
2027 }
2028
|
2029 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
2030
2031 STAT_GETSTARTTIME;
2032
2033 jmethodID id = NULL;
2034
2035 // public abstract void deleteInstance (org.pegasus.jmpi.CIMObjectPath cop)
2036 // throws org.pegasus.jmpi.CIMException
2037 id = env->GetMethodID((jclass)pr.jProviderClass,
2038 "deleteInstance",
2039 "(Lorg/pegasus/jmpi/CIMObjectPath;)V");
|
2040 schuur 1.1
|
2041 mark.hamzy 1.25 if (id != NULL)
2042 {
2043 eMethodFound = METHOD_SNIA_PROVIDER20;
2044 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
2045 }
|
2046 mark.hamzy 1.23
2047 JMPIjvm::checkException(env);
|
2048 schuur 1.1
|
2049 mark.hamzy 1.25 switch (eMethodFound)
2050 {
2051 case METHOD_SNIA_PROVIDER20:
2052 {
|
2053 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2054 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
2055 mark.hamzy 1.25
2056 JMPIjvm::checkException(env);
2057
|
2058 mark.hamzy 1.36 env->CallVoidMethod((jobject)pr.jProvider,
2059 id,
2060 jcop);
|
2061 mark.hamzy 1.25
2062 JMPIjvm::checkException(env);
2063
2064 STAT_PMS_PROVIDEREND;
2065 break;
2066 }
2067
2068 case METHOD_UNKNOWN:
2069 {
2070 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
2071 break;
2072 }
2073 }
2074 }
2075 HandlerCatch(handler);
2076
2077 if (env) JMPIjvm::detachThread();
2078
2079 PEG_METHOD_EXIT();
2080
|
2081 w.white 1.31 STAT_COPYDISPATCHER
2082
|
2083 mark.hamzy 1.25 return(response);
2084 }
2085
2086 Message * JMPIProviderManager::handleExecQueryRequest(const Message * message) throw()
2087 {
2088 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleExecQueryRequest");
2089
2090 HandlerIntro(ExecQuery,message,request,response,handler,Array<CIMObject>());
2091
2092 typedef enum {
2093 METHOD_UNKNOWN = 0,
2094 METHOD_PEGASUS_24,
|
2095 mark.hamzy 1.36 METHOD_PEGASUS_25,
|
2096 mark.hamzy 1.25 METHOD_SNIA_PROVIDER20,
2097 } METHOD_VERSION;
2098 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2099 JNIEnv *env = NULL;
2100
2101 try {
2102 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2103 "JMPIProviderManager::handleExecQueryRequest - Host name: $0 Name space: $1 Class name: $2",
2104 System::getHostName(),
2105 request->nameSpace.getString(),
2106 request->className.getString());
2107
2108 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
2109
2110 // make target object path
|
2111 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2112 request->nameSpace,
2113 request->className);
|
2114 mark.hamzy 1.25
2115 // resolve provider name
2116 ProviderName name = _resolveProviderName(
2117 request->operationContext.get(ProviderIdContainer::NAME));
2118
2119 // get cached or load new provider module
2120 JMPIProvider::OpProviderHolder ph =
2121 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2122
2123 // convert arguments
2124 OperationContext context;
2125
2126 context.insert(request->operationContext.get(IdentityContainer::NAME));
2127 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2128 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
2129
2130 // forward request
2131 JMPIProvider &pr = ph.GetProvider();
2132
2133 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.execQuery: " + pr.getName());
2134
2135 mark.hamzy 1.25 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Calling provider execQuery: "<<pr.getName()<<", queryLanguage: "<<request->queryLanguage<<", query: "<<request->query<<PEGASUS_STD(endl));
2136
2137 JvmVector *jv = 0;
2138
2139 env = JMPIjvm::attachThread(&jv);
2140
|
2141 mark.hamzy 1.37 if (!env)
2142 {
2143 PEG_METHOD_EXIT();
2144
2145 STAT_COPYDISPATCHER
2146
2147 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2148 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
2149 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
2150 }
2151
|
2152 mark.hamzy 1.23 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
2153 schuur 1.1
|
2154 mark.hamzy 1.23 STAT_GETSTARTTIME;
|
2155 schuur 1.1
|
2156 mark.hamzy 1.25 jmethodID id = NULL;
2157
2158 // public abstract java.util.Vector execQuery (org.pegasus.jmpi.CIMObjectPath cop,
2159 // java.lang.String queryStatement,
2160 // int ql,
2161 // org.pegasus.jmpi.CIMClass cimClass)
2162 // throws org.pegasus.jmpi.CIMException
2163 //
2164 id = env->GetMethodID((jclass)pr.jProviderClass,
2165 "execQuery",
2166 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
2167
2168 if (id != NULL)
2169 {
2170 eMethodFound = METHOD_SNIA_PROVIDER20;
2171 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
2172 }
2173
2174 if (id == NULL)
2175 {
2176 env->ExceptionClear();
2177 mark.hamzy 1.25
|
2178 mark.hamzy 1.36 // public abstract org.pegasus.jmpi.CIMInstance[] execQuery(org.pegasus.jmpi.CIMObjectPath cop,
|
2179 mark.hamzy 1.25 // java.lang.String query,
2180 // java.lang.String ql,
|
2181 mark.hamzy 1.36 // org.pegasus.jmpi.CIMClass cimClass)
|
2182 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
2183 id = env->GetMethodID((jclass)pr.jProviderClass,
2184 "execQuery",
2185 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");
2186
2187 if (id != NULL)
2188 {
2189 eMethodFound = METHOD_PEGASUS_24;
2190 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
2191 }
2192 }
2193
2194 if (id == NULL)
2195 {
|
2196 mark.hamzy 1.36 env->ExceptionClear();
2197
2198 // public abstract java.util.Vector execQuery(org.pegasus.jmpi.CIMObjectPath cop,
2199 // org.pegasus.jmpi.CIMClass cimClass,
2200 // java.lang.String query,
2201 // java.lang.String ql)
2202 // throws org.pegasus.jmpi.CIMException
2203 id = env->GetMethodID((jclass)pr.jProviderClass,
2204 "execQuery",
2205 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
2206
2207 if (id != NULL)
2208 {
2209 eMethodFound = METHOD_PEGASUS_25;
2210 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_PEGASUS_25."<<PEGASUS_STD(endl));
2211 }
2212 }
2213
2214 if (id == NULL)
2215 {
|
2216 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found no method!"<<PEGASUS_STD(endl));
2217 }
2218
|
2219 schuur 1.1 JMPIjvm::checkException(env);
2220
|
2221 mark.hamzy 1.25 switch (eMethodFound)
2222 {
2223 case METHOD_PEGASUS_24:
2224 {
|
2225 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
2226 mark.hamzy 1.25 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
2227
2228 JMPIjvm::checkException(env);
2229
2230 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
2231 jstring jquery = env->NewStringUTF(request->query.getCString());
2232
|
2233 mark.hamzy 1.40 CIMClass cls;
2234
2235 try
2236 {
2237 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2238 AutoMutex lock (pr._cimomMutex);
2239
2240 cls = pr._cimom_handle->getClass(context,
2241 request->nameSpace,
2242 request->className,
2243 false,
2244 true,
2245 true,
2246 CIMPropertyList());
2247 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2248 }
2249 catch (CIMException e)
2250 {
2251 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
2252 throw;
2253 }
2254 mark.hamzy 1.40
|
2255 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
2256
|
2257 mark.hamzy 1.25 JMPIjvm::checkException(env);
2258
|
2259 mark.hamzy 1.27 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
|
2260 mark.hamzy 1.25
2261 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
2262
2263 JMPIjvm::checkException(env);
2264
2265 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2266 id,
2267 jcop,
2268 jquery,
2269 jqueryLanguage,
2270 jCc);
|
2271 mark.hamzy 1.23
|
2272 mark.hamzy 1.25 JMPIjvm::checkException(env);
2273
2274 STAT_PMS_PROVIDEREND;
2275
2276 handler.processing();
2277 if (jAr) {
2278 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
2279 JMPIjvm::checkException(env);
2280
|
2281 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jAr,i);
2282
|
2283 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
2284 mark.hamzy 1.23
|
2285 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
2286 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
2287 mark.hamzy 1.25
2288 JMPIjvm::checkException(env);
2289
|
2290 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2291 mark.hamzy 1.25 }
2292 }
2293 handler.complete();
2294 break;
2295 }
2296
|
2297 mark.hamzy 1.36 case METHOD_PEGASUS_25:
2298 {
2299 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
2300 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
2301
2302 JMPIjvm::checkException(env);
2303
2304 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
2305 jstring jquery = env->NewStringUTF(request->query.getCString());
2306
|
2307 mark.hamzy 1.40 CIMClass cls;
2308
2309 try
2310 {
2311 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2312 AutoMutex lock (pr._cimomMutex);
2313
2314 cls = pr._cimom_handle->getClass(context,
2315 request->nameSpace,
2316 request->className,
2317 false,
2318 true,
2319 true,
2320 CIMPropertyList());
2321 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2322 }
2323 catch (CIMException e)
2324 {
2325 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
2326 throw;
2327 }
2328 mark.hamzy 1.40
|
2329 mark.hamzy 1.36 CIMClass *pcls = new CIMClass (cls);
2330
2331 JMPIjvm::checkException(env);
2332
2333 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
2334
2335 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
2336
2337 JMPIjvm::checkException(env);
2338
2339 jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2340 id,
2341 jcop,
2342 jCc,
2343 jquery,
2344 jqueryLanguage);
2345
2346 JMPIjvm::checkException(env);
2347
2348 STAT_PMS_PROVIDEREND;
2349
2350 mark.hamzy 1.36 handler.processing();
2351 if (jVec) {
2352 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
2353 JMPIjvm::checkException(env);
2354
2355 jobject jciRet = env->GetObjectArrayElement(jVec,i);
2356
2357 JMPIjvm::checkException(env);
2358
2359 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
2360 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
2361
2362 JMPIjvm::checkException(env);
2363
2364 handler.deliver(*ciRet);
2365 }
2366 }
2367 handler.complete();
2368 break;
2369 }
2370
|
2371 mark.hamzy 1.25 case METHOD_SNIA_PROVIDER20:
2372 {
|
2373 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
2374 mark.hamzy 1.25 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
2375
2376 JMPIjvm::checkException(env);
2377
2378 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
2379 jstring jquery = env->NewStringUTF(request->query.getCString());
2380
|
2381 mark.hamzy 1.40 CIMClass cls;
2382
2383 try
2384 {
2385 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2386 AutoMutex lock (pr._cimomMutex);
2387
2388 cls = pr._cimom_handle->getClass(context,
2389 request->nameSpace,
2390 request->className,
2391 false,
2392 true,
2393 true,
2394 CIMPropertyList());
2395 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<request->className<<PEGASUS_STD(endl));
2396 }
2397 catch (CIMException e)
2398 {
2399 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
2400 throw;
2401 }
2402 mark.hamzy 1.40
|
2403 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
2404
|
2405 mark.hamzy 1.25 JMPIjvm::checkException(env);
2406
|
2407 mark.hamzy 1.27 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
|
2408 mark.hamzy 1.25
2409 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
2410
2411 JMPIjvm::checkException(env);
2412
2413 jint jql = 0; // @BUG - how to convert?
2414
2415 jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2416 id,
2417 jcop,
2418 jquery,
2419 jql,
2420 jCc);
2421
2422 JMPIjvm::checkException(env);
2423
2424 STAT_PMS_PROVIDEREND;
2425
2426 handler.processing();
2427 if (jVec) {
2428 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
2429 mark.hamzy 1.25 JMPIjvm::checkException(env);
2430
|
2431 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jVec,i);
2432
|
2433 mark.hamzy 1.25 JMPIjvm::checkException(env);
2434
|
2435 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
2436 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
2437 mark.hamzy 1.25
2438 JMPIjvm::checkException(env);
2439
|
2440 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2441 mark.hamzy 1.25 }
2442 }
2443 handler.complete();
2444 break;
2445 }
2446
2447 case METHOD_UNKNOWN:
2448 {
2449 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl));
2450 break;
2451 }
2452 }
|
2453 schuur 1.1 }
2454 HandlerCatch(handler);
|
2455 mark.hamzy 1.23
|
2456 schuur 1.1 if (env) JMPIjvm::detachThread();
|
2457 mark.hamzy 1.23
|
2458 schuur 1.1 PEG_METHOD_EXIT();
2459
|
2460 w.white 1.31 STAT_COPYDISPATCHER
2461
|
2462 schuur 1.1 return(response);
2463 }
2464
2465 Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()
2466 {
|
2467 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest");
2468
2469 HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>());
|
2470 schuur 1.1
|
2471 mark.hamzy 1.24 typedef enum {
2472 METHOD_UNKNOWN = 0,
|
2473 mark.hamzy 1.25 METHOD_PEGASUS_24,
|
2474 mark.hamzy 1.24 METHOD_SNIA_PROVIDER20,
2475 } METHOD_VERSION;
2476 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2477 JNIEnv *env = NULL;
|
2478 schuur 1.13
|
2479 schuur 1.1 try {
2480 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2481 "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",
2482 System::getHostName(),
2483 request->nameSpace.getString(),
2484 request->objectName.getClassName().getString());
2485
|
2486 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));
|
2487 mark.hamzy 1.23
|
2488 schuur 1.1 // make target object path
|
2489 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2490 request->nameSpace,
2491 request->objectName.getClassName(),
2492 request->objectName.getKeyBindings());
2493 CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),
2494 request->nameSpace,
2495 request->assocClass.getString());
|
2496 schuur 1.1
2497 // resolve provider name
|
2498 kumpf 1.2 ProviderName name = _resolveProviderName(
2499 request->operationContext.get(ProviderIdContainer::NAME));
|
2500 schuur 1.1
2501 // get cached or load new provider module
2502 JMPIProvider::OpProviderHolder ph =
2503 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2504
|
2505 mark.hamzy 1.24 // convert arguments
|
2506 schuur 1.1 OperationContext context;
2507
|
2508 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
2509 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2510 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
2511 schuur 1.1
2512 // forward request
|
2513 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
2514
2515 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName());
|
2516 schuur 1.1
|
2517 mark.hamzy 1.24 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
|
2518 schuur 1.1
|
2519 mark.hamzy 1.24 JvmVector *jv = 0;
|
2520 schuur 1.1
|
2521 mark.hamzy 1.24 env = JMPIjvm::attachThread(&jv);
|
2522 schuur 1.1
|
2523 mark.hamzy 1.37 if (!env)
2524 {
2525 PEG_METHOD_EXIT();
2526
2527 STAT_COPYDISPATCHER
2528
2529 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2530 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
2531 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
2532 }
2533
|
2534 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
2535
2536 STAT_GETSTARTTIME;
2537
|
2538 mark.hamzy 1.24 jmethodID id = NULL;
2539
2540 // public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,
|
2541 mark.hamzy 1.25 // org.pegasus.jmpi.CIMObjectPath pathName,
|
2542 mark.hamzy 1.24 // java.lang.String resultClass,
2543 // java.lang.String role,
2544 // java.lang.String resultRole,
2545 // boolean includeQualifiers,
2546 // boolean includeClassOrigin,
2547 // java.lang.String[] propertyList)
|
2548 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
|
2549 mark.hamzy 1.24 //
2550 id = env->GetMethodID((jclass)pr.jProviderClass,
2551 "associators",
|
2552 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
2553 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"
|
2554 mark.hamzy 1.24
2555 if (id != NULL)
2556 {
|
2557 mark.hamzy 1.25 eMethodFound = METHOD_SNIA_PROVIDER20;
2558 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
2559 mark.hamzy 1.24 }
|
2560 schuur 1.12
|
2561 mark.hamzy 1.24 if (id == NULL)
2562 {
2563 env->ExceptionClear();
2564
2565 // public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,
2566 // java.lang.String resultClass,
2567 // java.lang.String role,
2568 // java.lang.String resultRole,
2569 // boolean includeQualifiers,
2570 // boolean includeClassOrigin,
2571 // java.lang.String[] propertyList)
|
2572 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
|
2573 mark.hamzy 1.24 //
2574 id = env->GetMethodID((jclass)pr.jProviderClass,
2575 "associators",
|
2576 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
2577 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"
|
2578 mark.hamzy 1.24
2579 if (id != NULL)
2580 {
|
2581 mark.hamzy 1.25 eMethodFound = METHOD_PEGASUS_24;
2582 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
|
2583 mark.hamzy 1.24 }
2584 }
2585
2586 if (id == NULL)
2587 {
2588 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));
|
2589 mark.hamzy 1.23 }
|
2590 mark.hamzy 1.24
|
2591 schuur 1.1 JMPIjvm::checkException(env);
2592
|
2593 mark.hamzy 1.24 switch (eMethodFound)
2594 {
|
2595 mark.hamzy 1.25 case METHOD_PEGASUS_24:
|
2596 mark.hamzy 1.24 {
|
2597 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
2598 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2599
2600 JMPIjvm::checkException(env);
2601
2602 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
2603 jstring jRole = env->NewStringUTF(request->role.getCString());
2604 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
2605
2606 JMPIjvm::checkException(env);
2607
2608 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
2609
|
2610 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2611 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
2612 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
2613 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
2614 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
2615 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
2616 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
2617 #endif
2618
|
2619 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2620 id,
2621 jAssociationName,
2622 jResultClass,
2623 jRole,
2624 jResultRole,
|
2625 mark.hamzy 1.36 JMPI_INCLUDE_QUALIFIERS,
2626 request->includeClassOrigin,
|
2627 mark.hamzy 1.24 jPropertyList);
|
2628 mark.hamzy 1.25
|
2629 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2630 schuur 1.13
|
2631 mark.hamzy 1.23 STAT_PMS_PROVIDEREND;
|
2632 schuur 1.1
|
2633 mark.hamzy 1.23 handler.processing();
2634 if (jVec) {
|
2635 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
2636 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2637 schuur 1.1
|
2638 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jVec,i);
|
2639 mark.hamzy 1.24
|
2640 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2641 schuur 1.13
|
2642 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
2643 schuur 1.13
|
2644 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2645 schuur 1.13
|
2646 mark.hamzy 1.29 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
2647 mark.hamzy 1.40 CIMClass cls;
2648
2649 try
2650 {
2651 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
2652 AutoMutex lock (pr._cimomMutex);
2653
2654 cls = pr._cimom_handle->getClass(context,
2655 request->nameSpace,
2656 ciRet->getClassName(),
2657 false,
2658 true,
2659 true,
2660 CIMPropertyList());
2661 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
2662 }
2663 catch (CIMException e)
2664 {
2665 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
2666 throw;
2667 }
2668 mark.hamzy 1.40
|
2669 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
2670 CIMObjectPath iop = ciRet->buildPath(cls);
|
2671 mark.hamzy 1.24
|
2672 mark.hamzy 1.27 JMPIjvm::checkException(env);
2673
|
2674 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
2675 mark.hamzy 1.29 ciRet->setPath(iop);
|
2676 schuur 1.13
|
2677 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2678 mark.hamzy 1.23 }
2679 }
|
2680 mark.hamzy 1.24 handler.complete();
2681 break;
|
2682 mark.hamzy 1.23 }
|
2683 mark.hamzy 1.24
2684 case METHOD_SNIA_PROVIDER20:
2685 {
|
2686 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
2687 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2688
2689 JMPIjvm::checkException(env);
2690
|
2691 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
2692 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
2693
2694 JMPIjvm::checkException(env);
2695
|
2696 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
2697 jstring jRole = env->NewStringUTF(request->role.getCString());
2698 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
2699
2700 JMPIjvm::checkException(env);
2701
2702 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
2703
|
2704 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2705 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
2706 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
2707 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
2708 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
2709 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
2710 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
2711 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
2712 #endif
2713
|
2714 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2715 id,
2716 jAssociationName,
2717 jPathName,
2718 jResultClass,
2719 jRole,
2720 jResultRole,
|
2721 mark.hamzy 1.32 JMPI_INCLUDE_QUALIFIERS,
2722 request->includeClassOrigin,
|
2723 mark.hamzy 1.24 jPropertyList);
|
2724 mark.hamzy 1.25
|
2725 mark.hamzy 1.23 JMPIjvm::checkException(env);
2726
2727 STAT_PMS_PROVIDEREND;
2728
2729 handler.processing();
|
2730 mark.hamzy 1.24 if (jVec) {
|
2731 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
2732 mark.hamzy 1.23 JMPIjvm::checkException(env);
2733
|
2734 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
2735 mark.hamzy 1.24
|
2736 mark.hamzy 1.23 JMPIjvm::checkException(env);
2737
|
2738 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
2739 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
2740 mark.hamzy 1.40 CIMClass cls;
2741
2742 try
2743 {
2744 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
2745 AutoMutex lock (pr._cimomMutex);
2746
2747 cls = pr._cimom_handle->getClass(context,
2748 request->nameSpace,
2749 ciRet->getClassName(),
2750 false,
2751 true,
2752 true,
2753 CIMPropertyList());
2754 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
2755 }
2756 catch (CIMException e)
2757 {
2758 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
2759 throw;
2760 }
2761 mark.hamzy 1.40
|
2762 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
2763 CIMObjectPath iop = ciRet->buildPath(cls);
|
2764 mark.hamzy 1.24
|
2765 mark.hamzy 1.27 JMPIjvm::checkException(env);
2766
|
2767 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
2768 mark.hamzy 1.29 ciRet->setPath(iop);
|
2769 schuur 1.13
|
2770 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2771 mark.hamzy 1.23 }
2772 }
|
2773 mark.hamzy 1.24 handler.complete();
2774 break;
2775 }
2776
2777 case METHOD_UNKNOWN:
2778 {
2779 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));
2780 break;
2781 }
|
2782 mark.hamzy 1.23 }
|
2783 schuur 1.1 }
2784 HandlerCatch(handler);
|
2785 schuur 1.13
2786 if (env) JMPIjvm::detachThread();
2787
|
2788 schuur 1.1 PEG_METHOD_EXIT();
2789
|
2790 w.white 1.31 STAT_COPYDISPATCHER
2791
|
2792 schuur 1.1 return(response);
2793 }
|
2794 schuur 1.13
|
2795 schuur 1.1 Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()
2796 {
|
2797 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest");
2798
2799 HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>());
|
2800 schuur 1.1
|
2801 mark.hamzy 1.24 typedef enum {
2802 METHOD_UNKNOWN = 0,
|
2803 mark.hamzy 1.25 METHOD_PEGASUS_24,
|
2804 mark.hamzy 1.24 METHOD_SNIA_PROVIDER20
2805 } METHOD_VERSION;
2806 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2807 JNIEnv *env = NULL;
|
2808 schuur 1.13
|
2809 schuur 1.1 try {
2810 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2811 "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2",
2812 System::getHostName(),
2813 request->nameSpace.getString(),
2814 request->objectName.getClassName().getString());
2815
|
2816 mark.hamzy 1.29 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));
|
2817 mark.hamzy 1.23
|
2818 schuur 1.1 // make target object path
|
2819 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2820 request->nameSpace,
2821 request->objectName.getClassName(),
2822 request->objectName.getKeyBindings());
2823 CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),
2824 request->nameSpace,
2825 request->assocClass.getString());
|
2826 mark.hamzy 1.23
|
2827 schuur 1.1 // resolve provider name
|
2828 kumpf 1.2 ProviderName name = _resolveProviderName(
2829 request->operationContext.get(ProviderIdContainer::NAME));
|
2830 schuur 1.1
2831 // get cached or load new provider module
2832 JMPIProvider::OpProviderHolder ph =
2833 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2834
2835 // convert arguments
2836 OperationContext context;
2837
|
2838 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
2839 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2840 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
2841 schuur 1.1
2842 // forward request
|
2843 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
2844 schuur 1.1
|
2845 mark.hamzy 1.24 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName());
|
2846 schuur 1.1
|
2847 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: Calling provider associatorNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
|
2848 schuur 1.1
|
2849 mark.hamzy 1.24 JvmVector *jv = 0;
2850
2851 env = JMPIjvm::attachThread(&jv);
|
2852 schuur 1.1
|
2853 mark.hamzy 1.37 if (!env)
2854 {
2855 PEG_METHOD_EXIT();
2856
2857 STAT_COPYDISPATCHER
2858
2859 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
2860 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
2861 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
2862 }
2863
|
2864 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
2865
2866 STAT_GETSTARTTIME;
2867
|
2868 mark.hamzy 1.24 jmethodID id = NULL;
2869
2870 // public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
|
2871 mark.hamzy 1.25 // org.pegasus.jmpi.CIMObjectPath pathName,
|
2872 mark.hamzy 1.24 // java.lang.String resultClass,
2873 // java.lang.String role,
2874 // java.lang.String resultRole)
2875 // throws org.pegasus.jmpi.CIMException
2876 id = env->GetMethodID((jclass)pr.jProviderClass,
2877 "associatorNames",
|
2878 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
2879 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"
|
2880 mark.hamzy 1.24
2881 if (id != NULL)
2882 {
|
2883 mark.hamzy 1.25 eMethodFound = METHOD_SNIA_PROVIDER20;
2884 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
2885 mark.hamzy 1.24 }
2886
2887 if (id == NULL)
2888 {
2889 env->ExceptionClear();
2890
2891 // public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
2892 // java.lang.String resultClass,
2893 // java.lang.String role,
2894 // java.lang.String resultRole)
2895 // throws org.pegasus.jmpi.CIMException
2896 id = env->GetMethodID((jclass)pr.jProviderClass,
2897 "associatorNames",
|
2898 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
2899 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"
|
2900 mark.hamzy 1.24
2901 if (id != NULL)
2902 {
|
2903 mark.hamzy 1.25 eMethodFound = METHOD_PEGASUS_24;
2904 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
|
2905 mark.hamzy 1.24 }
2906 }
|
2907 schuur 1.13
|
2908 mark.hamzy 1.24 if (id == NULL)
2909 {
2910 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl));
|
2911 mark.hamzy 1.23 }
|
2912 mark.hamzy 1.24
|
2913 schuur 1.1 JMPIjvm::checkException(env);
2914
|
2915 mark.hamzy 1.24 switch (eMethodFound)
2916 {
|
2917 mark.hamzy 1.25 case METHOD_PEGASUS_24:
|
2918 mark.hamzy 1.24 {
|
2919 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
2920 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2921
2922 JMPIjvm::checkException(env);
2923
2924 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
2925 jstring jRole = env->NewStringUTF(request->role.getCString());
2926 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
2927
2928 JMPIjvm::checkException(env);
2929
|
2930 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2931 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
2932 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
2933 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
2934 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
2935 #endif
2936
|
2937 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2938 id,
2939 jAssociationName,
2940 jResultClass,
2941 jRole,
2942 jResultRole);
|
2943 mark.hamzy 1.25
|
2944 mark.hamzy 1.23 JMPIjvm::checkException(env);
2945
2946 STAT_PMS_PROVIDEREND;
2947
2948 handler.processing();
2949 if (jVec) {
|
2950 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
2951 mark.hamzy 1.23 JMPIjvm::checkException(env);
2952
|
2953 mark.hamzy 1.29 jobject jcopRet = env->GetObjectArrayElement(jVec,i);
|
2954 mark.hamzy 1.24
|
2955 mark.hamzy 1.23 JMPIjvm::checkException(env);
2956
|
2957 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
2958 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRet);
|
2959 mark.hamzy 1.23
2960 JMPIjvm::checkException(env);
2961
|
2962 mark.hamzy 1.29 handler.deliver(*copRet);
|
2963 mark.hamzy 1.23 }
2964 }
2965 handler.complete();
|
2966 mark.hamzy 1.24 break;
|
2967 mark.hamzy 1.23 }
|
2968 mark.hamzy 1.24
2969 case METHOD_SNIA_PROVIDER20:
2970 {
|
2971 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
2972 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2973
2974 JMPIjvm::checkException(env);
2975
|
2976 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
2977 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
2978
2979 JMPIjvm::checkException(env);
2980
|
2981 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
2982 jstring jRole = env->NewStringUTF(request->role.getCString());
2983 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
2984
2985 JMPIjvm::checkException(env);
2986
|
2987 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2988 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
2989 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
2990 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
2991 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
2992 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
2993 #endif
2994
|
2995 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2996 id,
2997 jAssociationName,
|
2998 mark.hamzy 1.29 jPathName,
|
2999 mark.hamzy 1.24 jResultClass,
3000 jRole,
3001 jResultRole);
|
3002 mark.hamzy 1.25
|
3003 mark.hamzy 1.23 JMPIjvm::checkException(env);
3004
3005 STAT_PMS_PROVIDEREND;
|
3006 schuur 1.13
|
3007 mark.hamzy 1.23 handler.processing();
|
3008 mark.hamzy 1.24 if (jVec) {
|
3009 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
3010 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3011 schuur 1.13
|
3012 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
3013 mark.hamzy 1.24
|
3014 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3015 schuur 1.13
|
3016 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
3017 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
3018 schuur 1.1
|
3019 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3020 schuur 1.1
|
3021 mark.hamzy 1.29 handler.deliver(*copRet);
|
3022 mark.hamzy 1.23 }
3023 }
3024 handler.complete();
|
3025 mark.hamzy 1.24 break;
3026 }
3027
3028 case METHOD_UNKNOWN:
3029 {
3030 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: should not be here!"<<PEGASUS_STD(endl));
3031 break;
3032 }
|
3033 mark.hamzy 1.23 }
|
3034 schuur 1.1 }
3035 HandlerCatch(handler);
|
3036 schuur 1.12
|
3037 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
|
3038 schuur 1.12
|
3039 schuur 1.1 PEG_METHOD_EXIT();
3040
|
3041 w.white 1.31 STAT_COPYDISPATCHER
3042
|
3043 schuur 1.1 return(response);
3044 }
3045
3046 Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw()
3047 {
|
3048 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest");
3049
3050 HandlerIntro(References,message,request,response,handler,Array<CIMObject>());
|
3051 schuur 1.1
|
3052 mark.hamzy 1.24 typedef enum {
3053 METHOD_UNKNOWN = 0,
|
3054 mark.hamzy 1.25 METHOD_PEGASUS_24,
|
3055 mark.hamzy 1.24 METHOD_SNIA_PROVIDER20,
3056 } METHOD_VERSION;
3057 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3058 JNIEnv *env = NULL;
|
3059 schuur 1.13
|
3060 schuur 1.1 try {
3061 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
3062 konrad.r 1.15 "JMPIProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",
|
3063 schuur 1.1 System::getHostName(),
3064 request->nameSpace.getString(),
3065 request->objectName.getClassName().getString());
3066
|
3067 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));
|
3068 mark.hamzy 1.23
|
3069 schuur 1.1 // make target object path
|
3070 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3071 request->nameSpace,
3072 request->objectName.getClassName(),
3073 request->objectName.getKeyBindings());
3074 CIMObjectPath *resultPath = new CIMObjectPath (System::getHostName(),
3075 request->nameSpace,
3076 request->resultClass.getString());
|
3077 schuur 1.1
3078 // resolve provider name
|
3079 kumpf 1.2 ProviderName name = _resolveProviderName(
3080 request->operationContext.get(ProviderIdContainer::NAME));
|
3081 schuur 1.1
3082 // get cached or load new provider module
3083 JMPIProvider::OpProviderHolder ph =
3084 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
3085
3086 // convert arguments
3087 OperationContext context;
3088
|
3089 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
3090 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3091 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
3092 schuur 1.1
3093 // forward request
|
3094 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
3095
3096 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.references: " + pr.getName());
|
3097 schuur 1.1
|
3098 mark.hamzy 1.24 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Calling provider references: "<<pr.getName()<<", role: "<<request->role<<" aCls: "<<request->resultClass<<PEGASUS_STD(endl));
|
3099 schuur 1.1
|
3100 mark.hamzy 1.24 JvmVector *jv = 0;
|
3101 schuur 1.1
|
3102 mark.hamzy 1.24 env = JMPIjvm::attachThread(&jv);
|
3103 schuur 1.1
|
3104 mark.hamzy 1.37 if (!env)
3105 {
3106 PEG_METHOD_EXIT();
3107
3108 STAT_COPYDISPATCHER
3109
3110 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3111 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
3112 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
3113 }
3114
|
3115 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
3116
3117 STAT_GETSTARTTIME;
3118
|
3119 mark.hamzy 1.24 jmethodID id = NULL;
3120
3121 // public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,
|
3122 mark.hamzy 1.25 // org.pegasus.jmpi.CIMObjectPath pathName,
|
3123 mark.hamzy 1.24 // java.lang.String role,
3124 // boolean includeQualifiers,
3125 // boolean includeClassOrigin,
3126 // java.lang.String[] propertyList)
3127 // throws org.pegasus.jmpi.CIMException
3128 id = env->GetMethodID((jclass)pr.jProviderClass,
3129 "references",
|
3130 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
3131 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"
|
3132 mark.hamzy 1.24
3133 if (id != NULL)
3134 {
|
3135 mark.hamzy 1.25 eMethodFound = METHOD_SNIA_PROVIDER20;
3136 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
3137 mark.hamzy 1.24 }
3138
3139 if (id == NULL)
3140 {
3141 env->ExceptionClear();
3142
3143 // public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,
3144 // java.lang.String role,
3145 // boolean includeQualifiers,
3146 // boolean includeClassOrigin,
3147 // java.lang.String[] propertyList)
3148 // throws org.pegasus.jmpi.CIMException
3149 id = env->GetMethodID((jclass)pr.jProviderClass,
3150 "references",
|
3151 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
3152 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"
|
3153 mark.hamzy 1.24
3154 if (id != NULL)
3155 {
|
3156 mark.hamzy 1.25 eMethodFound = METHOD_PEGASUS_24;
3157 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
|
3158 mark.hamzy 1.24 }
3159 }
|
3160 schuur 1.12
|
3161 mark.hamzy 1.24 if (id == NULL)
3162 {
|
3163 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found no method!"<<PEGASUS_STD(endl));
|
3164 mark.hamzy 1.23 }
|
3165 mark.hamzy 1.24
|
3166 schuur 1.1 JMPIjvm::checkException(env);
3167
|
3168 mark.hamzy 1.24 switch (eMethodFound)
3169 {
|
3170 mark.hamzy 1.25 case METHOD_PEGASUS_24:
|
3171 mark.hamzy 1.24 {
|
3172 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
3173 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3174
3175 JMPIjvm::checkException(env);
3176
3177 jstring jRole = env->NewStringUTF(request->role.getCString());
3178
3179 JMPIjvm::checkException(env);
3180
3181 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
3182
|
3183 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
3184 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
3185 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
3186 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3187 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3188 #endif
3189
|
3190 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
3191 id,
3192 jAssociationName,
3193 jRole,
|
3194 mark.hamzy 1.36 JMPI_INCLUDE_QUALIFIERS,
3195 request->includeClassOrigin,
|
3196 mark.hamzy 1.24 jPropertyList);
|
3197 mark.hamzy 1.25
|
3198 mark.hamzy 1.23 JMPIjvm::checkException(env);
3199
3200 STAT_PMS_PROVIDEREND;
3201
3202 handler.processing();
3203 if (jVec) {
|
3204 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
3205 mark.hamzy 1.23 JMPIjvm::checkException(env);
3206
|
3207 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jVec,i);
|
3208 mark.hamzy 1.24
|
3209 mark.hamzy 1.23 JMPIjvm::checkException(env);
3210
|
3211 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
3212 mark.hamzy 1.23
3213 JMPIjvm::checkException(env);
3214
|
3215 mark.hamzy 1.29 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
3216 mark.hamzy 1.40 CIMClass cls;
3217
3218 try
3219 {
3220 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3221 AutoMutex lock (pr._cimomMutex);
3222
3223 cls = pr._cimom_handle->getClass(context,
3224 request->nameSpace,
3225 ciRet->getClassName(),
3226 false,
3227 true,
3228 true,
3229 CIMPropertyList());
3230 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3231 }
3232 catch (CIMException e)
3233 {
3234 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3235 throw;
3236 }
3237 mark.hamzy 1.40
|
3238 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
3239 CIMObjectPath iop = ciRet->buildPath(cls);
|
3240 mark.hamzy 1.24
|
3241 mark.hamzy 1.27 JMPIjvm::checkException(env);
3242
|
3243 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
3244 mark.hamzy 1.29 ciRet->setPath(iop);
|
3245 schuur 1.13
|
3246 mark.hamzy 1.29 handler.deliver(*ciRet);
|
3247 mark.hamzy 1.23 }
3248 }
3249 handler.complete();
|
3250 mark.hamzy 1.24 break;
|
3251 mark.hamzy 1.23 }
|
3252 schuur 1.1
|
3253 mark.hamzy 1.24 case METHOD_SNIA_PROVIDER20:
3254 {
|
3255 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
3256 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3257
3258 JMPIjvm::checkException(env);
3259
|
3260 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3261 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
3262
3263 JMPIjvm::checkException(env);
3264
|
3265 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
3266
3267 JMPIjvm::checkException(env);
3268
3269 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
3270
|
3271 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
3272 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
3273 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
3274 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
3275 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
3276 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
3277 #endif
3278
|
3279 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
3280 id,
3281 jAssociationName,
3282 jPathName,
3283 jRole,
|
3284 mark.hamzy 1.32 JMPI_INCLUDE_QUALIFIERS,
3285 request->includeClassOrigin,
|
3286 mark.hamzy 1.24 jPropertyList);
|
3287 mark.hamzy 1.25
|
3288 mark.hamzy 1.24 JMPIjvm::checkException(env);
3289
3290 STAT_PMS_PROVIDEREND;
3291
3292 handler.processing();
3293 if (jVec) {
|
3294 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
3295 mark.hamzy 1.24 JMPIjvm::checkException(env);
3296
|
3297 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
3298 mark.hamzy 1.24
3299 JMPIjvm::checkException(env);
3300
|
3301 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
3302 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
3303 mark.hamzy 1.40 CIMClass cls;
3304
3305 try
3306 {
3307 DDD (PEGASUS_STD(cout)<<"enter: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3308 AutoMutex lock (pr._cimomMutex);
3309
3310 cls = pr._cimom_handle->getClass(context,
3311 request->nameSpace,
3312 ciRet->getClassName(),
3313 false,
3314 true,
3315 true,
3316 CIMPropertyList());
3317 DDD (PEGASUS_STD(cout)<<"exit: cimom_handle->getClass("<<__LINE__<<") "<<ciRet->getClassName()<<PEGASUS_STD(endl));
3318 }
3319 catch (CIMException e)
3320 {
3321 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Error: Caught CIMExcetion during cimom_handle->getClass("<<__LINE__<<") "<<PEGASUS_STD(endl));
3322 throw;
3323 }
3324 mark.hamzy 1.40
|
3325 mark.hamzy 1.29 const CIMObjectPath& op = ciRet->getPath();
3326 CIMObjectPath iop = ciRet->buildPath(cls);
|
3327 schuur 1.1
|
3328 mark.hamzy 1.27 JMPIjvm::checkException(env);
3329
|
3330 mark.hamzy 1.24 iop.setNameSpace(op.getNameSpace());
|
3331 mark.hamzy 1.29 ciRet->setPath(iop);
|
3332 schuur 1.12
|
3333 mark.hamzy 1.29 handler.deliver(*ciRet);
|
3334 mark.hamzy 1.24 }
3335 }
3336 handler.complete();
3337 break;
3338 }
|
3339 mark.hamzy 1.23
|
3340 mark.hamzy 1.24 case METHOD_UNKNOWN:
3341 {
|
3342 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: should not be here!"<<PEGASUS_STD(endl));
|
3343 mark.hamzy 1.24 break;
3344 }
|
3345 mark.hamzy 1.23 }
|
3346 schuur 1.1 }
3347 HandlerCatch(handler);
|
3348 schuur 1.12
3349 if (env) JMPIjvm::detachThread();
3350
|
3351 schuur 1.1 PEG_METHOD_EXIT();
3352
|
3353 w.white 1.31 STAT_COPYDISPATCHER
3354
|
3355 schuur 1.1 return(response);
3356 }
3357
3358 Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw()
3359 {
|
3360 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest");
3361
3362 HandlerIntro(ReferenceNames,message,request,response,handler,Array<CIMObjectPath>());
|
3363 schuur 1.1
|
3364 mark.hamzy 1.24 typedef enum {
3365 METHOD_UNKNOWN = 0,
|
3366 mark.hamzy 1.25 METHOD_PEGASUS_24,
|
3367 mark.hamzy 1.24 METHOD_SNIA_PROVIDER20,
3368 } METHOD_VERSION;
3369 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3370 JNIEnv *env = NULL;
|
3371 schuur 1.13
|
3372 schuur 1.1 try {
3373 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3374 "JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
3375 System::getHostName(),
3376 request->nameSpace.getString(),
3377 request->objectName.getClassName().getString());
3378
|
3379 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));
3380
|
3381 schuur 1.1 // make target object path
|
3382 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3383 request->nameSpace,
3384 request->objectName.getClassName(),
3385 request->objectName.getKeyBindings());
3386 CIMObjectPath *resultPath = new CIMObjectPath (System::getHostName(),
3387 request->nameSpace,
3388 request->resultClass.getString());
|
3389 schuur 1.1
3390 // resolve provider name
|
3391 kumpf 1.2 ProviderName name = _resolveProviderName(
3392 request->operationContext.get(ProviderIdContainer::NAME));
|
3393 schuur 1.1
3394 // get cached or load new provider module
3395 JMPIProvider::OpProviderHolder ph =
3396 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
3397
3398 // convert arguments
3399 OperationContext context;
3400
|
3401 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
3402 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3403 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
3404 schuur 1.1
|
3405 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
3406 schuur 1.1
|
3407 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.referenceNames: " + pr.getName());
|
3408 schuur 1.1
|
3409 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: Calling provider referenceNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->resultClass<<PEGASUS_STD(endl));
|
3410 schuur 1.12
|
3411 mark.hamzy 1.24 JvmVector *jv = 0;
3412
3413 env = JMPIjvm::attachThread(&jv);
|
3414 schuur 1.1
|
3415 mark.hamzy 1.37 if (!env)
3416 {
3417 PEG_METHOD_EXIT();
3418
3419 STAT_COPYDISPATCHER
3420
3421 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3422 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
3423 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
3424 }
3425
|
3426 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
3427
3428 STAT_GETSTARTTIME;
3429
|
3430 mark.hamzy 1.24 jmethodID id = NULL;
3431
3432 // public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
|
3433 mark.hamzy 1.25 // org.pegasus.jmpi.CIMObjectPath pathName,
|
3434 mark.hamzy 1.24 // java.lang.String role)
|
3435 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
|
3436 mark.hamzy 1.24 id = env->GetMethodID((jclass)pr.jProviderClass,
3437 "referenceNames",
|
3438 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
3439 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;)Ljava/util/Vector;"
|
3440 mark.hamzy 1.24
3441 if (id != NULL)
3442 {
|
3443 mark.hamzy 1.25 eMethodFound = METHOD_SNIA_PROVIDER20;
3444 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
3445 mark.hamzy 1.24 }
3446
3447 if (id == NULL)
3448 {
3449 env->ExceptionClear();
3450
3451 // public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
3452 // java.lang.String role)
|
3453 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
|
3454 mark.hamzy 1.24 id = env->GetMethodID((jclass)pr.jProviderClass,
3455 "referenceNames",
|
3456 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
3457 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"
|
3458 mark.hamzy 1.24
3459 if (id != NULL)
3460 {
|
3461 mark.hamzy 1.25 eMethodFound = METHOD_PEGASUS_24;
3462 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
|
3463 mark.hamzy 1.24 }
3464 }
|
3465 schuur 1.11
|
3466 mark.hamzy 1.24 if (id == NULL)
3467 {
|
3468 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found no method!"<<PEGASUS_STD(endl));
|
3469 mark.hamzy 1.23 }
|
3470 mark.hamzy 1.24
|
3471 schuur 1.1 JMPIjvm::checkException(env);
3472
|
3473 mark.hamzy 1.24 switch (eMethodFound)
3474 {
|
3475 mark.hamzy 1.25 case METHOD_PEGASUS_24:
|
3476 mark.hamzy 1.24 {
|
3477 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
3478 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3479
3480 JMPIjvm::checkException(env);
3481
3482 jstring jRole = env->NewStringUTF(request->role.getCString());
3483
3484 JMPIjvm::checkException(env);
3485
|
3486 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
3487 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
3488 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
3489 #endif
3490
|
3491 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
3492 id,
3493 jAssociationName,
3494 jRole);
|
3495 mark.hamzy 1.25
|
3496 mark.hamzy 1.23 JMPIjvm::checkException(env);
3497
3498 STAT_PMS_PROVIDEREND;
3499
3500 handler.processing();
3501 if (jVec) {
|
3502 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
3503 mark.hamzy 1.23 JMPIjvm::checkException(env);
3504
|
3505 mark.hamzy 1.29 jobject jcopRet = env->GetObjectArrayElement(jVec,i);
|
3506 mark.hamzy 1.24
|
3507 mark.hamzy 1.23 JMPIjvm::checkException(env);
3508
|
3509 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
3510 mark.hamzy 1.23
3511 JMPIjvm::checkException(env);
3512
|
3513 mark.hamzy 1.29 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
3514 mark.hamzy 1.24
|
3515 mark.hamzy 1.29 handler.deliver(*copRet);
|
3516 mark.hamzy 1.23 }
3517 }
3518 handler.complete();
|
3519 mark.hamzy 1.24 break;
|
3520 mark.hamzy 1.23 }
|
3521 mark.hamzy 1.24
3522 case METHOD_SNIA_PROVIDER20:
3523 {
|
3524 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
3525 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
3526
3527 JMPIjvm::checkException(env);
3528
|
3529 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3530 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
3531
3532 JMPIjvm::checkException(env);
3533
|
3534 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
3535
3536 JMPIjvm::checkException(env);
3537
|
3538 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
3539 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
3540 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
3541 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
3542 #endif
3543
|
3544 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
3545 id,
3546 jAssociationName,
3547 jPathName,
3548 jRole);
|
3549 mark.hamzy 1.25
|
3550 mark.hamzy 1.23 JMPIjvm::checkException(env);
3551
3552 STAT_PMS_PROVIDEREND;
|
3553 schuur 1.13
|
3554 mark.hamzy 1.23 handler.processing();
|
3555 mark.hamzy 1.24 if (jVec) {
|
3556 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
3557 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3558 schuur 1.13
|
3559 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
3560 mark.hamzy 1.24
|
3561 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3562 schuur 1.13
|
3563 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
3564 schuur 1.1
|
3565 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3566 schuur 1.1
|
3567 mark.hamzy 1.29 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
3568 mark.hamzy 1.24
|
3569 mark.hamzy 1.29 handler.deliver(*copRet);
|
3570 mark.hamzy 1.23 }
3571 }
3572 handler.complete();
|
3573 mark.hamzy 1.24 break;
3574 }
3575
3576 case METHOD_UNKNOWN:
3577 {
|
3578 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: should not be here!"<<PEGASUS_STD(endl));
|
3579 mark.hamzy 1.24 break;
3580 }
|
3581 mark.hamzy 1.23 }
|
3582 schuur 1.1 }
3583 HandlerCatch(handler);
|
3584 schuur 1.11
3585 if (env) JMPIjvm::detachThread();
3586
|
3587 schuur 1.1 PEG_METHOD_EXIT();
3588
|
3589 w.white 1.31 STAT_COPYDISPATCHER
3590
|
3591 schuur 1.1 return(response);
3592 }
3593
|
3594 mark.hamzy 1.26 Message * JMPIProviderManager::handleGetPropertyRequest(const Message * message) throw()
3595 {
3596 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetPropertyRequest");
3597
3598 HandlerIntro(GetProperty,message,request,response,handler,CIMValue());
3599
3600 typedef enum {
3601 METHOD_UNKNOWN = 0,
3602 METHOD_SNIA_PROVIDER20,
3603 } METHOD_VERSION;
3604 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3605 JNIEnv *env = NULL;
3606
3607 try {
3608 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3609 "JMPIProviderManager::handleGetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
3610 System::getHostName(),
3611 request->nameSpace.getString(),
3612 request->instanceName.getClassName().getString());
3613
3614 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
3615 mark.hamzy 1.26
3616 // make target object path
|
3617 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3618 request->nameSpace,
3619 request->instanceName.getClassName(),
3620 request->instanceName.getKeyBindings());
|
3621 mark.hamzy 1.26
3622 // resolve provider name
3623 ProviderName name = _resolveProviderName(
3624 request->operationContext.get(ProviderIdContainer::NAME));
3625
3626 // get cached or load new provider module
3627 JMPIProvider::OpProviderHolder ph =
3628 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
3629
3630 // convert arguments
3631 OperationContext context;
3632
3633 context.insert(request->operationContext.get(IdentityContainer::NAME));
3634 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3635 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
3636
3637 // forward request
3638 JMPIProvider &pr = ph.GetProvider();
3639
3640 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.getPropertyValue: " + pr.getName());
3641
3642 mark.hamzy 1.26 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: Calling provider getPropertyValue: "<<pr.getName()<<PEGASUS_STD(endl));
3643
3644 JvmVector *jv = 0;
3645
3646 env = JMPIjvm::attachThread(&jv);
3647
|
3648 mark.hamzy 1.37 if (!env)
3649 {
3650 PEG_METHOD_EXIT();
3651
3652 STAT_COPYDISPATCHER
3653
3654 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3655 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
3656 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
3657 }
3658
|
3659 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
3660
3661 STAT_GETSTARTTIME;
3662
3663 jmethodID id = NULL;
3664
3665 // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
3666 // java.lang.String oclass,
3667 // java.lang.String pName)
3668 // throws org.pegasus.jmpi.CIMException
3669 //
3670 id = env->GetMethodID((jclass)pr.jProviderClass,
3671 "getPropertyValue",
3672 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
3673
3674 if (id != NULL)
3675 {
3676 eMethodFound = METHOD_SNIA_PROVIDER20;
3677 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
3678 }
3679
3680 mark.hamzy 1.26 if (id == NULL)
3681 {
3682 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
3683 }
3684
3685 JMPIjvm::checkException(env);
3686
3687 switch (eMethodFound)
3688 {
3689 case METHOD_SNIA_PROVIDER20:
3690 {
|
3691 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3692 mark.hamzy 1.26 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
3693
3694 JMPIjvm::checkException(env);
3695
3696 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
3697
3698 JMPIjvm::checkException(env);
3699
3700 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
3701
3702 JMPIjvm::checkException(env);
3703
3704 STAT_GETSTARTTIME;
3705
|
3706 mark.hamzy 1.29 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
3707 id,
3708 jcop,
3709 joclass,
3710 jpName);
|
3711 mark.hamzy 1.26
3712 JMPIjvm::checkException(env);
3713
3714 STAT_PMS_PROVIDEREND;
3715
3716 handler.processing();
3717
|
3718 mark.hamzy 1.29 if (jvalRet)
|
3719 mark.hamzy 1.26 {
|
3720 mark.hamzy 1.29 jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);
3721 CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef);
|
3722 mark.hamzy 1.26
3723 JMPIjvm::checkException(env);
3724
|
3725 mark.hamzy 1.29 handler.deliver(*valRet);
|
3726 mark.hamzy 1.26 }
3727 handler.complete();
3728 break;
3729 }
3730
3731 case METHOD_UNKNOWN:
3732 {
3733 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: should not be here!"<<PEGASUS_STD(endl));
3734 break;
3735 }
3736 }
3737 }
3738 HandlerCatch(handler);
3739
3740 if (env) JMPIjvm::detachThread();
3741
3742 PEG_METHOD_EXIT();
3743
|
3744 w.white 1.31 STAT_COPYDISPATCHER
3745
|
3746 mark.hamzy 1.26 return(response);
3747 }
3748
3749 Message * JMPIProviderManager::handleSetPropertyRequest(const Message * message) throw()
3750 {
3751 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleSetPropertyRequest");
3752
3753 HandlerIntroVoid(SetProperty,message,request,response,handler);
3754
3755 typedef enum {
3756 METHOD_UNKNOWN = 0,
3757 METHOD_SNIA_PROVIDER20,
3758 } METHOD_VERSION;
3759 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3760 JNIEnv *env = NULL;
3761
3762 try {
3763 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3764 "JMPIProviderManager::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
3765 System::getHostName(),
3766 request->nameSpace.getString(),
3767 mark.hamzy 1.26 request->instanceName.getClassName().getString());
3768
3769 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
3770
3771 // make target object path
|
3772 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3773 request->nameSpace,
3774 request->instanceName.getClassName(),
3775 request->instanceName.getKeyBindings());
|
3776 mark.hamzy 1.26
3777 // resolve provider name
3778 ProviderName name = _resolveProviderName(
3779 request->operationContext.get(ProviderIdContainer::NAME));
3780
3781 // get cached or load new provider module
3782 JMPIProvider::OpProviderHolder ph =
3783 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
3784
3785 // convert arguments
3786 OperationContext context;
3787
3788 context.insert(request->operationContext.get(IdentityContainer::NAME));
3789 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3790 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
3791
3792 // forward request
3793 JMPIProvider &pr = ph.GetProvider();
3794
3795 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.setPropertyValue: " + pr.getName());
3796
3797 mark.hamzy 1.26 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: Calling provider setPropertyValue: "<<pr.getName()<<PEGASUS_STD(endl));
3798
3799 JvmVector *jv = 0;
3800
3801 env = JMPIjvm::attachThread(&jv);
3802
|
3803 mark.hamzy 1.37 if (!env)
3804 {
3805 PEG_METHOD_EXIT();
3806
3807 STAT_COPYDISPATCHER
3808
3809 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3810 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
3811 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
3812 }
3813
|
3814 mark.hamzy 1.26 JMPIProvider::pm_service_op_lock op_lock(&pr);
3815
3816 STAT_GETSTARTTIME;
3817
3818 jmethodID id = NULL;
3819
3820 // public abstract void setPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
3821 // java.lang.String oclass,
3822 // java.lang.String pName,
3823 // org.pegasus.jmpi.CIMValue val)
3824 // throws org.pegasus.jmpi.CIMException
3825 //
3826 id = env->GetMethodID((jclass)pr.jProviderClass,
3827 "setPropertyValue",
3828 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
3829
3830 if (id != NULL)
3831 {
3832 eMethodFound = METHOD_SNIA_PROVIDER20;
3833 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
3834 }
3835 mark.hamzy 1.26
3836 if (id == NULL)
3837 {
3838 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
3839 }
3840
3841 JMPIjvm::checkException(env);
3842
3843 switch (eMethodFound)
3844 {
3845 case METHOD_SNIA_PROVIDER20:
3846 {
|
3847 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3848 mark.hamzy 1.26 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
3849
3850 JMPIjvm::checkException(env);
3851
3852 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
3853
3854 JMPIjvm::checkException(env);
3855
3856 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
3857
3858 JMPIjvm::checkException(env);
3859
|
3860 mark.hamzy 1.27 CIMValue *val = new CIMValue (request->newValue);
|
3861 mark.hamzy 1.26
3862 JMPIjvm::checkException(env);
3863
|
3864 mark.hamzy 1.27 jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);
|
3865 mark.hamzy 1.26 jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);
3866
3867 JMPIjvm::checkException(env);
3868
3869 STAT_GETSTARTTIME;
3870
3871 env->CallVoidMethod ((jobject)pr.jProvider,
3872 id,
3873 jcop,
3874 joclass,
3875 jpName,
3876 jval);
3877
3878 JMPIjvm::checkException(env);
3879
3880 STAT_PMS_PROVIDEREND;
3881 break;
3882 }
3883
3884 case METHOD_UNKNOWN:
3885 {
3886 mark.hamzy 1.26 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: should not be here!"<<PEGASUS_STD(endl));
3887 break;
3888 }
3889 }
3890 }
3891 HandlerCatch(handler);
3892
3893 if (env) JMPIjvm::detachThread();
3894
3895 PEG_METHOD_EXIT();
3896
|
3897 w.white 1.31 STAT_COPYDISPATCHER
3898
|
3899 mark.hamzy 1.26 return(response);
3900 }
3901
|
3902 schuur 1.1 Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw()
3903 {
|
3904 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest");
3905
3906 HandlerIntroMethod(InvokeMethod,message,request,response,handler);
|
3907 schuur 1.1
|
3908 mark.hamzy 1.25 typedef enum {
3909 METHOD_UNKNOWN = 0,
3910 METHOD_PEGASUS_24,
3911 METHOD_SNIA_PROVIDER20,
3912 } METHOD_VERSION;
3913 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3914 JNIEnv *env = NULL;
|
3915 schuur 1.13
|
3916 schuur 1.1 try {
3917 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3918 "JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",
3919 System::getHostName(),
3920 request->nameSpace.getString(),
3921 request->instanceName.getClassName().getString());
3922
|
3923 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));
3924
|
3925 schuur 1.1 // make target object path
|
3926 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3927 request->nameSpace,
3928 request->instanceName.getClassName(),
3929 request->instanceName.getKeyBindings());
|
3930 schuur 1.1
3931 // resolve provider name
|
3932 kumpf 1.2 ProviderName name = _resolveProviderName(
3933 request->operationContext.get(ProviderIdContainer::NAME));
|
3934 schuur 1.1
3935 // get cached or load new provider module
3936 JMPIProvider::OpProviderHolder ph =
3937 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
3938
3939 // convert arguments
3940 OperationContext context;
3941
|
3942 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
3943 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3944 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
3945 schuur 1.1
|
3946 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
3947 schuur 1.1
|
3948 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.invokeMethod: " + pr.getName());
|
3949 schuur 1.1
|
3950 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: Calling provider invokeMethod: "<<pr.getName()<<PEGASUS_STD(endl));
|
3951 schuur 1.11
|
3952 mark.hamzy 1.25 JvmVector *jv = 0;
|
3953 mark.hamzy 1.23
|
3954 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
3955 schuur 1.11
|
3956 mark.hamzy 1.37 if (!env)
3957 {
3958 PEG_METHOD_EXIT();
3959
3960 STAT_COPYDISPATCHER
3961
3962 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
3963 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
3964 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
3965 }
3966
|
3967 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
3968 schuur 1.11
|
3969 schuur 1.1 STAT_GETSTARTTIME;
3970
|
3971 mark.hamzy 1.25 jmethodID id = NULL;
3972
3973 // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath cop,
3974 // java.lang.String name,
3975 // java.util.Vector in,
3976 // java.util.Vector out)
3977 // throws org.pegasus.jmpi.CIMException
3978 id = env->GetMethodID((jclass)pr.jProviderClass,
3979 "invokeMethod",
3980 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
3981
3982 if (id != NULL)
3983 {
3984 eMethodFound = METHOD_SNIA_PROVIDER20;
3985 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
3986 }
3987
3988 if (id == NULL)
3989 {
3990 env->ExceptionClear();
3991
3992 mark.hamzy 1.25 // public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath op,
3993 // java.lang.String methodName,
3994 // org.pegasus.jmpi.CIMArgument[] inArgs,
3995 // org.pegasus.jmpi.CIMArgument[] outArgs)
3996 // throws org.pegasus.jmpi.CIMException
3997 id = env->GetMethodID((jclass)pr.jProviderClass,
3998 "invokeMethod",
3999 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
4000
4001 if (id != NULL)
4002 {
4003 eMethodFound = METHOD_PEGASUS_24;
4004 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
4005 }
|
4006 mark.hamzy 1.23 }
|
4007 mark.hamzy 1.25
|
4008 schuur 1.11 JMPIjvm::checkException(env);
4009
|
4010 mark.hamzy 1.25 switch (eMethodFound)
4011 {
4012 case METHOD_PEGASUS_24:
4013 {
|
4014 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4015 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
4016 mark.hamzy 1.25
4017 JMPIjvm::checkException(env);
4018
|
4019 mark.hamzy 1.29 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
4020
|
4021 mark.hamzy 1.23 JMPIjvm::checkException(env);
4022
|
4023 mark.hamzy 1.25 Uint32 m=request->inParameters.size();
4024
4025 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
|
4026 mark.hamzy 1.29
|
4027 mark.hamzy 1.25 for (Uint32 i=0; i<m; i++) {
|
4028 mark.hamzy 1.29 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
4029 jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);
4030 jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef);
|
4031 mark.hamzy 1.23
|
4032 mark.hamzy 1.25 env->SetObjectArrayElement(jArIn,i,jArg);
4033 }
|
4034 mark.hamzy 1.23
|
4035 mark.hamzy 1.25 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
|
4036 mark.hamzy 1.23
|
4037 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
4038 id,
4039 jcop,
4040 jMethod,
4041 jArIn,
4042 jArOut);
|
4043 mark.hamzy 1.23 JMPIjvm::checkException(env);
4044
4045 STAT_PMS_PROVIDEREND;
4046
4047 handler.processing();
4048
|
4049 mark.hamzy 1.29 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
4050 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
4051 mark.hamzy 1.23
|
4052 mark.hamzy 1.29 handler.deliver(*valueRet);
|
4053 schuur 1.13
|
4054 mark.hamzy 1.25 for (int i=0; i<24; i++) {
|
4055 mark.hamzy 1.29 jobject jArg = env->GetObjectArrayElement(jArOut,i);
4056
|
4057 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4058 schuur 1.13
|
4059 mark.hamzy 1.29 if (jArg==NULL)
4060 break;
|
4061 schuur 1.13
|
4062 mark.hamzy 1.29 jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);
4063 CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef);
|
4064 schuur 1.13
|
4065 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4066 schuur 1.1
|
4067 mark.hamzy 1.25 handler.deliverParamValue(*p);
|
4068 mark.hamzy 1.23 }
|
4069 schuur 1.1
|
4070 mark.hamzy 1.23 handler.complete();
|
4071 mark.hamzy 1.25 break;
|
4072 mark.hamzy 1.23 }
|
4073 schuur 1.11
|
4074 mark.hamzy 1.25 case METHOD_SNIA_PROVIDER20:
4075 {
|
4076 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
4077 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
4078 mark.hamzy 1.25
4079 JMPIjvm::checkException(env);
4080
|
4081 mark.hamzy 1.29 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
4082
|
4083 mark.hamzy 1.25 JMPIjvm::checkException(env);
4084
|
4085 mark.hamzy 1.29 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
4086
|
4087 mark.hamzy 1.25 JMPIjvm::checkException(env);
4088
|
4089 mark.hamzy 1.29 for (int i=0,m=request->inParameters.size(); i<m; i++)
4090 {
4091 const CIMParamValue &parm = request->inParameters[i];
4092 const CIMValue v = parm.getValue();
4093 CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
4094 jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
4095 jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef);
|
4096 mark.hamzy 1.23
|
4097 mark.hamzy 1.29 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
|
4098 mark.hamzy 1.25 }
|
4099 mark.hamzy 1.23
|
4100 mark.hamzy 1.25 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
4101 JMPIjvm::checkException(env);
|
4102 mark.hamzy 1.23
|
4103 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
4104 id,
4105 jcop,
4106 jMethod,
4107 jVecIn,
4108 jVecOut);
|
4109 mark.hamzy 1.23 JMPIjvm::checkException(env);
4110
4111 STAT_PMS_PROVIDEREND;
4112
4113 handler.processing();
|
4114 schuur 1.1
|
4115 mark.hamzy 1.29 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
4116 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
4117 mark.hamzy 1.23
|
4118 mark.hamzy 1.29 handler.deliver(*valueRet);
|
4119 mark.hamzy 1.23
|
4120 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++)
4121 {
|
4122 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4123 schuur 1.13
|
4124 mark.hamzy 1.29 jobject jProp = env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
4125
|
4126 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
4127 schuur 1.13
|
4128 mark.hamzy 1.29 jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);
4129 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef);
|
4130 schuur 1.13
|
4131 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
4132 schuur 1.13
|
4133 mark.hamzy 1.25 handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
4134 }
4135
4136 handler.complete();
4137 break;
4138 }
|
4139 mark.hamzy 1.23
|
4140 mark.hamzy 1.25 case METHOD_UNKNOWN:
4141 {
4142 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: should not be here!"<<PEGASUS_STD(endl));
4143 break;
4144 }
|
4145 mark.hamzy 1.23 }
|
4146 schuur 1.1 }
4147 HandlerCatch(handler);
|
4148 schuur 1.11
4149 if (env) JMPIjvm::detachThread();
4150
|
4151 schuur 1.1 PEG_METHOD_EXIT();
4152
|
4153 w.white 1.31 STAT_COPYDISPATCHER
4154
|
4155 schuur 1.11 return(response);
|
4156 schuur 1.1 }
|
4157 mark.hamzy 1.23
|
4158 schuur 1.1 int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance,
4159 String& providerName, String& location)
4160 {
4161 Uint32 pos = pInstance.findProperty(CIMName ("Name"));
4162 pInstance.getProperty(pos).getValue().get(providerName);
4163
4164 pos = pmInstance.findProperty(CIMName ("Location"));
4165 pmInstance.getProperty(pos).getValue().get(location);
4166 return 0;
4167 }
4168
4169 Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()
4170 {
|
4171 konrad.r 1.15 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest");
|
4172 schuur 1.1
|
4173 mark.hamzy 1.23 HandlerIntroInd(CreateSubscription,message,request,response,handler);
4174
|
4175 mark.hamzy 1.25 typedef enum {
4176 METHOD_UNKNOWN = 0,
4177 METHOD_SNIA_PROVIDER20,
4178 } METHOD_VERSION;
4179 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
4180 JNIEnv *env = NULL;
4181
|
4182 schuur 1.1 try {
|
4183 mark.hamzy 1.25 String providerName,
4184 providerLocation;
4185 CIMInstance req_provider,
4186 req_providerModule;
4187
4188 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
|
4189 schuur 1.1
|
4190 mark.hamzy 1.25 req_provider = pidc.getProvider();
|
4191 schuur 1.12 req_providerModule = pidc.getModule();
|
4192 mark.hamzy 1.25
|
4193 schuur 1.12 LocateIndicationProviderNames(req_provider, req_providerModule,providerName,providerLocation);
|
4194 schuur 1.1
4195 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
4196 "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
4197 System::getHostName(),
4198 request->nameSpace.getString(),
4199 providerName);
4200
|
4201 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));
4202
|
4203 schuur 1.1 String fileName = resolveFileName(providerLocation);
4204
4205 // get cached or load new provider module
4206 JMPIProvider::OpProviderHolder ph =
4207 providerManager.getProvider(fileName, providerName, String::EMPTY);
4208
|
4209 mark.hamzy 1.25 indProvRecord *prec = NULL;
4210
|
4211 schuur 1.12 provTab.lookup(providerName,prec);
|
4212 mark.hamzy 1.25
|
4213 mark.hamzy 1.23 if (prec)
|
4214 mark.hamzy 1.25 {
|
4215 mark.hamzy 1.23 prec->count++;
|
4216 mark.hamzy 1.25 }
4217 else
4218 {
4219 prec=new indProvRecord();
4220 provTab.insert(providerName,prec);
|
4221 schuur 1.12 }
|
4222 schuur 1.1
|
4223 carolann.graves 1.21 //
4224 // Save the provider instance from the request
4225 //
4226 ph.GetProvider ().setProviderInstance (req_provider);
4227
|
4228 mark.hamzy 1.25 indSelectRecord *srec = new indSelectRecord();
4229 const CIMObjectPath &sPath = request->subscriptionInstance.getPath();
4230
|
4231 schuur 1.12 selxTab.insert(sPath.toString(),srec);
|
4232 schuur 1.1
4233 // convert arguments
4234 OperationContext *context=new OperationContext();
4235
|
4236 mark.hamzy 1.25 if (prec->ctx==NULL)
4237 {
4238 prec->ctx=context;
|
4239 mark.hamzy 1.23 }
|
4240 schuur 1.12
4241 context->insert(request->operationContext.get(IdentityContainer::NAME));
4242 context->insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
4243 context->insert(request->operationContext.get(ContentLanguageListContainer::NAME));
4244 context->insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
4245 context->insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
|
4246 schuur 1.1
4247 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
4248
|
4249 schuur 1.12 SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get
4250 (SubscriptionFilterConditionContainer::NAME);
4251
|
4252 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
4253 konrad.r 1.22
|
4254 mark.hamzy 1.25 CIMOMHandleQueryContext *qcontext=new CIMOMHandleQueryContext(CIMNamespaceName(request->nameSpace.getString()),
4255 *pr._cimom_handle);
|
4256 konrad.r 1.22
|
4257 mark.hamzy 1.25 CMPI_SelectExp *eSelx = new CMPI_SelectExp(*context,
4258 qcontext,
4259 request->query,
4260 sub_cntr.getQueryLanguage());
|
4261 konrad.r 1.22
|
4262 schuur 1.12 srec->eSelx=eSelx;
|
4263 mark.hamzy 1.25 srec->qContext=qcontext;
|
4264 schuur 1.1
|
4265 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName());
|
4266 schuur 1.1
|
4267 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Calling provider createSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
|
4268 schuur 1.1
4269 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) {
4270 CIMObjectPath className(
4271 System::getHostName(),
4272 request->nameSpace,
4273 request->classNames[i]);
4274 eSelx->classNames.append(className);
4275 }
4276
4277 CIMPropertyList propertyList = request->propertyList;
|
4278 mark.hamzy 1.29
4279 if (!propertyList.isNull())
4280 {
4281 Array<CIMName> p = propertyList.getPropertyNameArray();
4282 int pCount = p.size();
4283
|
4284 schuur 1.1 eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*));
|
4285 mark.hamzy 1.29
4286 for (int i=0; i<pCount; i++)
4287 {
|
4288 schuur 1.1 eSelx->props[i]=strdup(p[i].getString().getCString());
|
4289 mark.hamzy 1.29 }
|
4290 schuur 1.1 eSelx->props[pCount]=NULL;
4291 }
4292
|
4293 mark.hamzy 1.25 JvmVector *jv = 0;
4294
4295 env = JMPIjvm::attachThread(&jv);
4296
|
4297 mark.hamzy 1.37 if (!env)
4298 {
4299 PEG_METHOD_EXIT();
4300
4301 STAT_COPYDISPATCHER
4302
4303 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4304 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
4305 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
4306 }
4307
|
4308 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
4309
4310 STAT_GETSTARTTIME;
4311
4312 jmethodID id = NULL;
4313
|
4314 mark.hamzy 1.36 // public void activateFilter (org.pegasus.jmpi.SelectExp filter,
4315 // java.lang.String eventType,
4316 // org.pegasus.jmpi.CIMObjectPath classPath,
4317 // java.lang.String owner)
|
4318 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
4319 id = env->GetMethodID((jclass)pr.jProviderClass,
4320 "activateFilter",
4321 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
4322 schuur 1.12
|
4323 mark.hamzy 1.25 if (id != NULL)
4324 {
4325 eMethodFound = METHOD_SNIA_PROVIDER20;
4326 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
4327 }
|
4328 mark.hamzy 1.23
4329 JMPIjvm::checkException(env);
4330
|
4331 mark.hamzy 1.25 switch (eMethodFound)
4332 {
4333 case METHOD_SNIA_PROVIDER20:
4334 {
|
4335 mark.hamzy 1.29 jint jSelRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
4336 jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jSelRef);
|
4337 mark.hamzy 1.25
4338 JMPIjvm::checkException(env);
4339
|
4340 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);
4341 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
4342 schuur 1.12
|
4343 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
4344 schuur 1.1
|
4345 mark.hamzy 1.25 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
4346 schuur 1.1
|
4347 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
4348 schuur 1.1
|
4349 mark.hamzy 1.25 env->CallVoidMethod((jobject)pr.jProvider,
4350 id,
4351 jSel,
4352 jType,
|
4353 mark.hamzy 1.29 jcop,
|
4354 mark.hamzy 1.25 (jboolean)0);
|
4355 schuur 1.12
|
4356 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
4357 schuur 1.1
|
4358 carolann.graves 1.21 //
|
4359 mark.hamzy 1.25 // Increment count of current subscriptions for this provider
|
4360 carolann.graves 1.21 //
|
4361 mark.hamzy 1.25 if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())
|
4362 carolann.graves 1.21 {
|
4363 mark.hamzy 1.25 //
4364 // If there were no current subscriptions before the increment,
4365 // the first subscription has been created
4366 // Call the provider's enableIndications method
4367 //
4368 if (_subscriptionInitComplete)
4369 {
4370 prec->enabled = true;
4371 CIMRequestMessage * request = 0;
4372 CIMResponseMessage * response = 0;
4373 prec->handler = new EnableIndicationsResponseHandler
4374 (request, response, req_provider, _indicationCallback);
4375 }
|
4376 carolann.graves 1.21 }
|
4377 mark.hamzy 1.25
4378 STAT_PMS_PROVIDEREND;
4379 break;
|
4380 carolann.graves 1.21 }
4381
|
4382 mark.hamzy 1.25 case METHOD_UNKNOWN:
4383 {
4384 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: should not be here!"<<PEGASUS_STD(endl));
4385 break;
4386 }
4387 }
|
4388 schuur 1.1
4389 }
4390 HandlerCatch(handler);
|
4391 schuur 1.12
|
4392 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
4393
|
4394 schuur 1.1 PEG_METHOD_EXIT();
4395
4396 return(response);
4397 }
4398
4399 Message * JMPIProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()
4400 {
4401 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest");
4402
|
4403 mark.hamzy 1.23 HandlerIntroInd(DeleteSubscription,message,request,response,handler);
4404
|
4405 mark.hamzy 1.25 typedef enum {
4406 METHOD_UNKNOWN = 0,
4407 METHOD_SNIA_PROVIDER20,
4408 } METHOD_VERSION;
4409 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
4410 JNIEnv *env = NULL;
4411
|
4412 schuur 1.1 try {
|
4413 mark.hamzy 1.25 String providerName,
4414 providerLocation;
4415 CIMInstance req_provider,
4416 req_providerModule;
4417 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
4418
4419 req_provider = pidc.getProvider();
|
4420 schuur 1.12 req_providerModule = pidc.getModule();
|
4421 se.gupta 1.9
|
4422 mark.hamzy 1.25 LocateIndicationProviderNames(req_provider, req_providerModule, providerName,providerLocation);
|
4423 schuur 1.1
4424 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
4425 "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
4426 System::getHostName(),
4427 request->nameSpace.getString(),
4428 providerName);
4429
|
4430 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));
4431
|
4432 schuur 1.1 String fileName = resolveFileName(providerLocation);
4433
4434 // get cached or load new provider module
4435 JMPIProvider::OpProviderHolder ph =
4436 providerManager.getProvider(fileName, providerName, String::EMPTY);
4437
|
4438 mark.hamzy 1.25 indProvRecord *prec = NULL;
4439
|
4440 schuur 1.12 provTab.lookup(providerName,prec);
|
4441 mark.hamzy 1.25 if (--prec->count <= 0)
4442 {
4443 provTab.remove(providerName);
4444 prec=NULL;
|
4445 schuur 1.12 }
|
4446 schuur 1.1
|
4447 mark.hamzy 1.25 indSelectRecord *srec = NULL;
4448 const CIMObjectPath &sPath = request->subscriptionInstance.getPath();
4449 String sPathString = sPath.toString();
4450
|
4451 schuur 1.12 selxTab.lookup(sPathString,srec);
|
4452 schuur 1.1
|
4453 mark.hamzy 1.25 CMPI_SelectExp *eSelx = srec->eSelx;
4454 CIMOMHandleQueryContext *qContext = srec->qContext;
|
4455 konrad.r 1.22
|
4456 schuur 1.12 selxTab.remove(sPathString);
|
4457 schuur 1.1
|
4458 schuur 1.12 // convert arguments
|
4459 schuur 1.1 OperationContext context;
4460
|
4461 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
4462 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
4463 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
4464 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
4465
|
4466 schuur 1.1 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
4467
|
4468 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
4469 schuur 1.1
|
4470 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteSubscriptionRequest: " + pr.getName());
|
4471 schuur 1.1
|
4472 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Calling provider deleteSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
|
4473 schuur 1.1
|
4474 mark.hamzy 1.25 JvmVector *jv = 0;
4475
4476 env = JMPIjvm::attachThread(&jv);
4477
|
4478 mark.hamzy 1.37 if (!env)
4479 {
4480 PEG_METHOD_EXIT();
4481
4482 STAT_COPYDISPATCHER
4483
4484 throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
4485 MessageLoaderParms("ProviderManager.JMPI.INIT_JVM_FAILED",
4486 "Could not initialize the JVM (Java Virtual Machine) runtime environment."));
4487 }
4488
|
4489 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
4490
4491 STAT_GETSTARTTIME;
4492
4493 jmethodID id = NULL;
4494
4495 // public void deActivateFilter (org.pegasus.jmpi.SelectExp filter,
4496 // java.lang.String eventType,
4497 // org.pegasus.jmpi.CIMObjectPath classPath,
4498 // boolean lastActivation)
4499 // throws org.pegasus.jmpi.CIMException
4500 id = env->GetMethodID((jclass)pr.jProviderClass,
4501 "deActivateFilter",
4502 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
4503 schuur 1.12
|
4504 mark.hamzy 1.25 if (id != NULL)
4505 {
4506 eMethodFound = METHOD_SNIA_PROVIDER20;
4507 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
4508 }
|
4509 mark.hamzy 1.23
4510 JMPIjvm::checkException(env);
4511
|
4512 mark.hamzy 1.25 switch (eMethodFound)
4513 {
4514 case METHOD_SNIA_PROVIDER20:
4515 {
4516 jint jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
4517 jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj);
4518
4519 JMPIjvm::checkException(env);
4520
4521 jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);
|
4522 mark.hamzy 1.23
|
4523 mark.hamzy 1.25 jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
|
4524 schuur 1.12
|
4525 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
4526 schuur 1.12
|
4527 mark.hamzy 1.25 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
4528 schuur 1.1
|
4529 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
4530 schuur 1.1
|
4531 mark.hamzy 1.25 env->CallVoidMethod((jobject)pr.jProvider,
4532 id,
4533 jSel,
4534 jType,
4535 jRef,
4536 (jboolean)(prec==NULL));
|
4537 schuur 1.1
|
4538 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
4539 schuur 1.1
|
4540 carolann.graves 1.21 //
|
4541 mark.hamzy 1.25 // Decrement count of current subscriptions for this provider
|
4542 carolann.graves 1.21 //
|
4543 mark.hamzy 1.25 if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())
|
4544 carolann.graves 1.21 {
|
4545 mark.hamzy 1.25 //
4546 // If there are no current subscriptions after the decrement,
4547 // the last subscription has been deleted
4548 // Call the provider's disableIndications method
4549 //
4550 if (_subscriptionInitComplete)
4551 {
4552 prec->enabled = false;
4553 if (prec->handler) delete prec->handler;
4554 prec->handler = NULL;
4555 }
|
4556 carolann.graves 1.21 }
4557
|
4558 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
|
4559 schuur 1.1
|
4560 mark.hamzy 1.25 delete eSelx;
4561 delete qContext;
4562 delete srec;
4563 break;
4564 }
|
4565 schuur 1.12
|
4566 mark.hamzy 1.25 case METHOD_UNKNOWN:
4567 {
4568 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: should not be here!"<<PEGASUS_STD(endl));
4569 break;
4570 }
4571 }
|
4572 schuur 1.1 }
4573 HandlerCatch(handler);
|
4574 schuur 1.12
|
4575 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
4576
|
4577 schuur 1.1 PEG_METHOD_EXIT();
4578
|
4579 w.white 1.31 STAT_COPYDISPATCHER
4580
|
4581 schuur 1.1 return(response);
4582 }
4583
4584 Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw()
4585 {
4586 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDisableModuleRequest");
4587
4588 CIMDisableModuleRequestMessage * request =
4589 dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));
4590
4591 PEGASUS_ASSERT(request != 0);
4592
4593 // get provider module name
4594 String moduleName;
4595 CIMInstance mInstance = request->providerModule;
4596 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
4597
4598 if(pos != PEG_NOT_FOUND)
4599 {
4600 mInstance.getProperty(pos).getValue().get(moduleName);
4601 }
4602 schuur 1.1
4603 Boolean disableProviderOnly = request->disableProviderOnly;
4604
4605 Array<Uint16> operationalStatus;
|
4606 kumpf 1.2 // Assume success.
|
4607 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
4608 schuur 1.1
|
4609 kumpf 1.2 //
|
4610 schuur 1.1 // Unload providers
|
4611 kumpf 1.2 //
|
4612 schuur 1.1 Array<CIMInstance> _pInstances = request->providers;
4613
4614 CIMDisableModuleResponseMessage * response =
4615 new CIMDisableModuleResponseMessage(
4616 request->messageId,
4617 CIMException(),
4618 request->queueIds.copyAndPop(),
4619 operationalStatus);
4620
4621 PEGASUS_ASSERT(response != 0);
4622
4623 // preserve message key
4624 response->setKey(request->getKey());
4625
4626 //
4627 // Set HTTP method in response from request
4628 //
4629 response->setHttpMethod (request->getHttpMethod ());
4630
4631 PEG_METHOD_EXIT();
4632
4633 schuur 1.1 return(response);
4634 }
4635
4636 Message * JMPIProviderManager::handleEnableModuleRequest(const Message * message) throw()
4637 {
4638 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnableModuleRequest");
4639
4640 CIMEnableModuleRequestMessage * request =
4641 dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));
4642
4643 PEGASUS_ASSERT(request != 0);
4644
4645 Array<Uint16> operationalStatus;
|
4646 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
|
4647 schuur 1.1
4648 CIMEnableModuleResponseMessage * response =
4649 new CIMEnableModuleResponseMessage(
4650 request->messageId,
4651 CIMException(),
4652 request->queueIds.copyAndPop(),
4653 operationalStatus);
4654
4655 PEGASUS_ASSERT(response != 0);
4656
4657 // preserve message key
4658 response->setKey(request->getKey());
4659
4660 // Set HTTP method in response from request
4661 response->setHttpMethod (request->getHttpMethod ());
4662
4663 PEG_METHOD_EXIT();
4664
4665 return(response);
4666 }
4667
4668 schuur 1.1 Message * JMPIProviderManager::handleStopAllProvidersRequest(const Message * message) throw()
4669 {
4670 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleStopAllProvidersRequest");
4671
4672 CIMStopAllProvidersRequestMessage * request =
4673 dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));
4674
4675 PEGASUS_ASSERT(request != 0);
4676
4677 CIMStopAllProvidersResponseMessage * response =
4678 new CIMStopAllProvidersResponseMessage(
4679 request->messageId,
4680 CIMException(),
4681 request->queueIds.copyAndPop());
4682
4683 PEGASUS_ASSERT(response != 0);
4684
4685 // preserve message key
4686 response->setKey(request->getKey());
4687
4688 // Set HTTP method in response from request
4689 schuur 1.1 response->setHttpMethod (request->getHttpMethod ());
4690
4691 // tell the provider manager to shutdown all the providers
4692 providerManager.shutdownAllProviders();
4693
4694 PEG_METHOD_EXIT();
4695
4696 return(response);
4697 }
4698
|
4699 kumpf 1.4 Message * JMPIProviderManager::handleInitializeProviderRequest(const Message * message)
4700 {
4701 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleInitializeProviderRequest");
4702
4703 HandlerIntroInit(InitializeProvider,message,request,response,handler);
4704
4705 try
4706 {
4707 // resolve provider name
|
4708 mark.hamzy 1.23 ProviderName name = _resolveProviderName(
4709 request->operationContext.get(ProviderIdContainer::NAME));
|
4710 kumpf 1.4
4711 // get cached or load new provider module
4712 JMPIProvider::OpProviderHolder ph =
|
4713 mark.hamzy 1.23 providerManager.getProvider(name.getPhysicalName(),
4714 name.getLogicalName(), String::EMPTY);
|
4715 kumpf 1.4
4716 }
4717 HandlerCatch(handler);
4718
4719 PEG_METHOD_EXIT();
4720
4721 return(response);
4722 }
4723
|
4724 mark.hamzy 1.25 Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest (const Message * message)
|
4725 carolann.graves 1.21 {
4726 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
4727 "JMPIProviderManager::handleSubscriptionInitCompleteRequest");
4728
4729 CIMSubscriptionInitCompleteRequestMessage * request =
4730 dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
4731 (const_cast <Message *> (message));
4732
4733 PEGASUS_ASSERT (request != 0);
4734
4735 CIMSubscriptionInitCompleteResponseMessage * response =
4736 dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
4737 (request->buildResponse ());
4738
4739 PEGASUS_ASSERT (response != 0);
4740
4741 //
4742 // Set indicator
4743 //
4744 _subscriptionInitComplete = true;
4745
4746 carolann.graves 1.21 //
4747 // For each provider that has at least one subscription, call
4748 // provider's enableIndications method
4749 //
4750 Array <JMPIProvider *> enableProviders;
4751 enableProviders = providerManager.getIndicationProvidersToEnable ();
4752
4753 Uint32 numProviders = enableProviders.size ();
4754 for (Uint32 i = 0; i < numProviders; i++)
4755 {
4756 try
4757 {
4758 CIMInstance provider;
4759 provider = enableProviders [i]->getProviderInstance ();
4760
4761 //
4762 // Get cached or load new provider module
4763 //
4764 JMPIProvider::OpProviderHolder ph = providerManager.getProvider
4765 (enableProviders [i]->getModule ()->getFileName (),
4766 enableProviders [i]->getName ());
4767 carolann.graves 1.21
4768 indProvRecord * prec = NULL;
4769 provTab.lookup (enableProviders [i]->getName (), prec);
4770 if (prec)
4771 {
4772 prec->enabled = true;
4773 CIMRequestMessage * request = 0;
4774 CIMResponseMessage * response = 0;
4775 prec->handler = new EnableIndicationsResponseHandler
4776 (request, response, provider, _indicationCallback);
4777 }
4778 }
4779 catch (CIMException & e)
4780 {
4781 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4782 "CIMException: " + e.getMessage ());
4783 }
4784 catch (Exception & e)
4785 {
4786 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4787 "Exception: " + e.getMessage ());
4788 carolann.graves 1.21 }
4789 catch(...)
4790 {
4791 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4792 "Unknown error in handleSubscriptionInitCompleteRequest");
4793 }
4794 }
4795
4796 PEG_METHOD_EXIT ();
4797 return (response);
4798 }
4799
|
4800 schuur 1.1 Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw()
4801 {
|
4802 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleUnsupportedRequest");
4803
|
4804 konrad.r 1.16 CIMRequestMessage* request =
4805 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
4806 PEGASUS_ASSERT(request != 0 );
4807
4808 CIMResponseMessage* response = request->buildResponse();
4809 response->cimException =
4810 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
|
4811 schuur 1.1
4812 PEG_METHOD_EXIT();
|
4813 konrad.r 1.16 return response;
|
4814 schuur 1.1 }
4815
|
4816 kumpf 1.2 ProviderName JMPIProviderManager::_resolveProviderName(
4817 const ProviderIdContainer & providerId)
|
4818 schuur 1.1 {
|
4819 kumpf 1.2 String providerName;
4820 String fileName;
4821 String interfaceName;
4822 CIMValue genericValue;
4823
4824 genericValue = providerId.getProvider().getProperty(
4825 providerId.getProvider().findProperty("Name")).getValue();
4826 genericValue.get(providerName);
4827
4828 genericValue = providerId.getModule().getProperty(
4829 providerId.getModule().findProperty("Location")).getValue();
4830 genericValue.get(fileName);
4831 fileName = resolveFileName(fileName);
4832
4833 // ATTN: This attribute is probably not required
4834 genericValue = providerId.getModule().getProperty(
4835 providerId.getModule().findProperty("InterfaceType")).getValue();
4836 genericValue.get(interfaceName);
4837
4838 return ProviderName(providerName, fileName, interfaceName, 0);
|
4839 schuur 1.1 }
4840
4841 String JMPIProviderManager::resolveFileName(String fileName)
4842 {
4843 String name;
4844 #if defined(PEGASUS_OS_TYPE_WINDOWS)
4845 name = fileName; // + String(".dll");
4846 #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
4847 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
4848 name.append(String("/") + fileName); // + String(".sl"));
4849 #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
4850 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
4851 name.append(String("/") + fileName); // + String(".so"));
4852 #elif defined(PEGASUS_OS_OS400)
4853 name = filrName;
4854 #else
4855 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
4856 name.append(String("/") + fileName); // + String(".so"));
4857 #endif
4858 return name;
4859 }
4860 schuur 1.1
4861 PEGASUS_NAMESPACE_END
|
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI