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