1 karl 1.18 //%2005////////////////////////////////////////////////////////////////////////
|
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 schuur 1.1 //
12 // Permission is hereby granted, free of charge, to any person obtaining a copy
13 // of this software and associated documentation files (the "Software"), to
14 // deal in the Software without restriction, including without limitation the
15 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
16 // sell copies of the Software, and to permit persons to whom the Software is
17 // furnished to do so, subject to the following conditions:
|
18 mark.hamzy 1.23 //
|
19 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
20 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
21 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
22 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
23 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //==============================================================================
29 //
|
30 mark.hamzy 1.23 // Author: Adrian Schuur, schuur@de.ibm.com
|
31 schuur 1.1 //
|
32 se.gupta 1.9 // Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135
|
33 joyce.j 1.19 // Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for PEP#101
|
34 schuur 1.1 //
35 //%/////////////////////////////////////////////////////////////////////////////
36
37 #include "JMPIProviderManager.h"
38
39 #include "JMPIImpl.h"
40
41 #include <Pegasus/Common/CIMMessage.h>
42 #include <Pegasus/Common/OperationContext.h>
43 #include <Pegasus/Common/Tracer.h>
44 #include <Pegasus/Common/StatisticalData.h>
45 #include <Pegasus/Common/Logger.h>
46 #include <Pegasus/Common/MessageLoader.h> //l10n
|
47 kumpf 1.10 #include <Pegasus/Common/Constants.h>
|
48 schuur 1.1
49 #include <Pegasus/Config/ConfigManager.h>
50
51 #include <Pegasus/ProviderManager2/ProviderName.h>
52 #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h>
|
53 konrad.r 1.22 #include <Pegasus/ProviderManager2/JMPI/JMPIProviderModule.h>
|
54 schuur 1.1 #include <Pegasus/ProviderManager2/ProviderManagerService.h>
55
|
56 schuur 1.12 #include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h>
57
|
58 schuur 1.1
59 PEGASUS_USING_STD;
60 PEGASUS_NAMESPACE_BEGIN
61
|
62 mark.hamzy 1.23 int JMPIProviderManager::trace=0;
|
63 mark.hamzy 1.24
64 #ifdef PEGASUS_DEBUG
|
65 mark.hamzy 1.23 #define DDD(x) if (JMPIProviderManager::trace) x;
|
66 mark.hamzy 1.24 #else
67 #define DDD(x)
68 #endif
|
69 mark.hamzy 1.30 #define JMPI_LOCALONLY false
70 #define JMPI_DEEPINHERITANCE true
|
71 mark.hamzy 1.32 /* Fix for 4092 */
72 #define JMPI_INCLUDE_QUALIFIERS false
|
73 mark.hamzy 1.23
74 #include "Convert.h"
|
75 schuur 1.1
|
76 mark.hamzy 1.23 void JMPIProviderManager::debugPrintMethodPointers (JNIEnv *env, jclass jc)
77 {
78 // cd ${PEGAUSE_HOME}/src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/tests/JMPI_TestPropertyTypes
79 // javap -s -p JMPI_TestPropertyTypes
80 static const char *methodNames[][2] = {
|
81 mark.hamzy 1.24 // CIMProvider
82 // cimom-2003-11-24/org/snia/wbem/provider/CIMProvider.java
83 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMProvider.java
84 {"initialize","(Lorg/pegasus/jmpi/CIMOMHandle;)V"},
|
85 mark.hamzy 1.23 {"cleanup","()V"},
|
86 mark.hamzy 1.24 // InstanceProvider
87 // cimom-2003-11-24/org/snia/wbem/provider/InstanceProvider.java
88 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMInstanceProvider.java
89 {"enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},
90 {"enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"},
|
91 mark.hamzy 1.33 /* Fix for 4189 */
92 {"enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;ZZZ[Ljava/lang/String;)Ljava/util/Vector;"},
93 {"enumInstances","(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;"},
94 /* Fix for 4189 */
|
95 mark.hamzy 1.24 {"getInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;"},
|
96 mark.hamzy 1.23 {"createInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;"},
97 {"setInstance","(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V"},
98 {"deleteInstance","(Lorg/pegasus/jmpi/CIMObjectPath;)V"},
99 {"execQuery","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;"},
|
100 mark.hamzy 1.24 // MethodProvider
101 // cimom-2003-11-24/org/snia/wbem/provider/MethodProvider.java
102 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMMethodProvider.java
|
103 mark.hamzy 1.23 {"invokeMethod","(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;"},
|
104 mark.hamzy 1.24 // PropertyProvider
105 // cimom-2003-11-24/org/snia/wbem/provider/PropertyProvider.java
106 // AssociatorProvider
107 // cimom-2003-11-24/org/snia/wbem/provider20/AssociatorProvider.java
108 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/CIMAssociationProvider.java
109 // CIMProviderRouter
110 // cimom-2003-11-24/org/snia/wbem/provider20/CIMProviderRouter.java
111 // EventProvider
112 // cimom-2003-11-24/org/snia/wbem/provider20/EventProvider.java
113 // src/Pegasus/ProviderManager2/JMPI/org/pegasus/jmpi/EventProvider.java
|
114 mark.hamzy 1.23 {"authorizeFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)V"},
115 {"mustPoll","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;)Z"},
116 {"activateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},
|
117 mark.hamzy 1.24 {"deActivateFilter","(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V"},
118 // IndicationHandler
119 // cimom-2003-11-24/org/snia/wbem/provider20/IndicationHandler.java
120 // ProviderAdapter
121 // cimom-2003-11-24/org/snia/wbem/provider20/ProviderAdapter.java
122 // JMPI_TestPropertyTypes
123 {"findObjectPath","(Lorg/pegasus/jmpi/CIMObjectPath;)I"},
124 {"testPropertyTypesValue","(Lorg/pegasus/jmpi/CIMInstance;)V"}
|
125 mark.hamzy 1.23 };
126
127 if (!env)
128 {
129 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: env is NULL!"<<PEGASUS_STD(endl));
130 return;
131 }
132 if (!jc)
133 {
134 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: jc is NULL!"<<PEGASUS_STD(endl));
135 return;
136 }
137
138 for (int i = 0; i < (int)(sizeof (methodNames)/sizeof (methodNames[0])); i++)
139 {
140 jmethodID id = env->GetMethodID(jc,methodNames[i][0], methodNames[i][1]);
141 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugPrintMethodPointers: "<<methodNames[i][0]<<", id = "<<PEGASUS_STD(hex)<<(int)id<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
142 env->ExceptionClear();
143 }
|
144 mark.hamzy 1.29
145 env->ExceptionClear();
146 }
147
148 void
149 debugIntrospectJavaObject (JNIEnv *env, jobject jInst)
150 {
151 jclass jInstClass = env->GetObjectClass(jInst);
152 jclass jInstSuperClass = env->GetSuperclass(jInstClass);
153 jmethodID jmidGetDeclaredMethods = env->GetMethodID(jInstClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;");
154
155 if (!jmidGetDeclaredMethods)
156 {
157 env->ExceptionClear();
158 jmidGetDeclaredMethods = env->GetMethodID(jInstSuperClass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;");
159 }
160
161 if (jmidGetDeclaredMethods)
162 {
163 jobjectArray jarrayDeclaredMethods = (jobjectArray)env->CallObjectMethod(jInstClass,
164 jmidGetDeclaredMethods);
165 mark.hamzy 1.29
166 if (jarrayDeclaredMethods)
167 {
168 for (int i = 0, iLen = env->GetArrayLength (jarrayDeclaredMethods); i < iLen; i++)
169 {
170 JMPIjvm::checkException(env);
171
172 jobject jDeclaredMethod = env->GetObjectArrayElement (jarrayDeclaredMethods, i);
173 jclass jDeclaredMethodClass = env->GetObjectClass (jDeclaredMethod);
174
175 JMPIjvm::checkException(env);
176
177 jmethodID jmidToString = env->GetMethodID (jDeclaredMethodClass, "toString", "()Ljava/lang/String;");
178 jstring jstringResult = (jstring)env->CallObjectMethod (jDeclaredMethod, jmidToString);
179 const char *pszResult = env->GetStringUTFChars(jstringResult, 0);
180
181 PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugIntrospectJavaObject: "<<pszResult<<PEGASUS_STD(endl);
182
183 env->ReleaseStringUTFChars (jstringResult, pszResult);
184 }
185 }
186 mark.hamzy 1.29 }
187
188
189 env->ExceptionClear();
190 }
191
192 void
193 debugDumpJavaObject (JNIEnv *env, jobject jInst)
194 {
195 jclass jInstClass = env->GetObjectClass(jInst);
196 jclass jInstSuperClass = env->GetSuperclass(jInstClass);
197 jmethodID jmidToString1 = env->GetMethodID(jInstClass, "toString", "()Ljava/lang/String;");
198 jmethodID jmidToString2 = env->GetMethodID(jInstSuperClass, "toString", "()Ljava/lang/String;");
199 if (!jmidToString1 || !jmidToString2)
200 {
201 env->ExceptionClear();
202 return;
203 }
204 jstring jstringResult1 = (jstring)env->CallObjectMethod(jInstClass, jmidToString1);
205 jstring jstringResult2 = (jstring)env->CallObjectMethod(jInstSuperClass, jmidToString2);
206 jstring jstringResult3 = (jstring)env->CallObjectMethod(jInst, jmidToString1);
207 mark.hamzy 1.29 const char *pszResult1 = env->GetStringUTFChars(jstringResult1, 0);
208 const char *pszResult2 = env->GetStringUTFChars(jstringResult2, 0);
209 const char *pszResult3 = env->GetStringUTFChars(jstringResult3, 0);
210
211 jmethodID jmidCInst = env->GetMethodID(env->GetObjectClass(jInst),JMPIjvm::jv.instanceMethodNames[22].methodName, JMPIjvm::jv.instanceMethodNames[22].signature);
212
213 PEGASUS_STD(cout)<<"--- JMPIProviderManager::debugIntrospectJavaObject: jInstClass = "<<jInstClass<<", jInstSuperClass = "<<jInstSuperClass<<", jClassShouldBe = "<<JMPIjvm::jv.classRefs[18]<<", jmidCInst = "<<jmidCInst<<PEGASUS_STD(endl);
214 PEGASUS_STD(cout)<<"pszResult1 = "<<pszResult1<<PEGASUS_STD(endl);
215 PEGASUS_STD(cout)<<"pszResult2 = "<<pszResult2<<PEGASUS_STD(endl);
216 PEGASUS_STD(cout)<<"pszResult3 = "<<pszResult3<<PEGASUS_STD(endl);
217
218 env->ReleaseStringUTFChars (jstringResult1, pszResult1);
219 env->ReleaseStringUTFChars (jstringResult2, pszResult2);
220 env->ReleaseStringUTFChars (jstringResult3, pszResult3);
221
222 env->ExceptionClear();
|
223 mark.hamzy 1.23 }
|
224 schuur 1.1
225 JMPIProviderManager::IndProvTab JMPIProviderManager::provTab;
226 JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab;
227 JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg;
228
229 JMPIProviderManager::JMPIProviderManager(Mode m)
230 {
231 mode=m;
|
232 carolann.graves 1.21 _subscriptionInitComplete = false;
|
233 mark.hamzy 1.23
234 #ifdef PEGASUS_DEBUG
235 if (getenv("PEGASUS_JMPI_TRACE"))
236 JMPIProviderManager::trace = 1;
237 else
238 JMPIProviderManager::trace = 0;
239 #else
240 JMPIProviderManager::trace = 0;
241 #endif
|
242 schuur 1.1 }
243
244 JMPIProviderManager::~JMPIProviderManager(void)
245 {
246 }
247
|
248 schuur 1.12 Boolean JMPIProviderManager::insertProvider(const ProviderName & name,
|
249 schuur 1.1 const String &ns, const String &cn)
250 {
251 String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString());
|
252 mark.hamzy 1.23
253 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::insertProvider: "<<key<<PEGASUS_STD(endl));
254
|
255 schuur 1.1 return provReg.insert(key,name);
256 }
|
257 mark.hamzy 1.23
|
258 schuur 1.1 Message * JMPIProviderManager::processMessage(Message * request) throw()
259 {
|
260 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::processMessage()");
|
261 schuur 1.1
262 Message * response = 0;
|
263 mark.hamzy 1.23
|
264 schuur 1.1 // pass the request message to a handler method based on message type
265 switch(request->getType())
266 {
267 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
268 response = handleGetInstanceRequest(request);
|
269 mark.hamzy 1.25 break;
|
270 schuur 1.1
271 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
272 response = handleEnumerateInstancesRequest(request);
|
273 mark.hamzy 1.25 break;
|
274 schuur 1.1
275 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
276 response = handleEnumerateInstanceNamesRequest(request);
|
277 mark.hamzy 1.25 break;
|
278 schuur 1.1
279 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
280 response = handleCreateInstanceRequest(request);
|
281 mark.hamzy 1.25 break;
|
282 schuur 1.1
283 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
284 response = handleModifyInstanceRequest(request);
|
285 mark.hamzy 1.25 break;
|
286 schuur 1.1
287 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
288 response = handleDeleteInstanceRequest(request);
|
289 mark.hamzy 1.25 break;
|
290 schuur 1.1
|
291 mark.hamzy 1.25 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
292 response = handleExecQueryRequest(request);
|
293 schuur 1.1 break;
294
295 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
296 response = handleAssociatorsRequest(request);
|
297 mark.hamzy 1.25 break;
|
298 schuur 1.1
299 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
300 response = handleAssociatorNamesRequest(request);
|
301 mark.hamzy 1.25 break;
|
302 schuur 1.1
303 case CIM_REFERENCES_REQUEST_MESSAGE:
304 response = handleReferencesRequest(request);
|
305 mark.hamzy 1.25 break;
|
306 schuur 1.1
307 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
308 response = handleReferenceNamesRequest(request);
|
309 mark.hamzy 1.25 break;
|
310 schuur 1.1
|
311 mark.hamzy 1.26 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
312 response = handleGetPropertyRequest(request);
313 break;
314
315 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
316 response = handleSetPropertyRequest(request);
317 break;
318
|
319 schuur 1.11 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
|
320 schuur 1.1 response = handleInvokeMethodRequest(request);
|
321 mark.hamzy 1.25 break;
|
322 schuur 1.1
|
323 schuur 1.12 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
|
324 schuur 1.1 response = handleCreateSubscriptionRequest(request);
|
325 mark.hamzy 1.25 break;
|
326 schuur 1.1
|
327 mark.hamzy 1.25 /* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
|
328 schuur 1.1 response = handleModifySubscriptionRequest(request);
329 break;
|
330 schuur 1.12 */
|
331 schuur 1.1 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
332 response = handleDeleteSubscriptionRequest(request);
|
333 mark.hamzy 1.25 break;
|
334 schuur 1.1
|
335 mark.hamzy 1.26 /* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
|
336 kumpf 1.7 response = handleExportIndicationRequest(request);
|
337 schuur 1.1 break;
|
338 schuur 1.12 */
|
339 schuur 1.1 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
340 response = handleDisableModuleRequest(request);
|
341 mark.hamzy 1.25 break;
|
342 schuur 1.1
343 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
344 response = handleEnableModuleRequest(request);
|
345 mark.hamzy 1.25 break;
|
346 schuur 1.1
347 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
348 response = handleStopAllProvidersRequest(request);
|
349 mark.hamzy 1.25 break;
|
350 schuur 1.1
|
351 kumpf 1.4 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
|
352 mark.hamzy 1.23 response = handleInitializeProviderRequest(request);
|
353 mark.hamzy 1.25 break;
|
354 kumpf 1.4
|
355 carolann.graves 1.21 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
356 response = handleSubscriptionInitCompleteRequest (request);
|
357 mark.hamzy 1.25 break;
|
358 carolann.graves 1.21
|
359 schuur 1.1 default:
|
360 mark.hamzy 1.23 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
361 "*** Unsupported Request "+request->getType());
362 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::processMessage: Unsupported request "<<request->getType ()<<PEGASUS_STD(endl));
|
363 mark.hamzy 1.25
|
364 schuur 1.1 response = handleUnsupportedRequest(request);
365 break;
366 }
367
368 PEG_METHOD_EXIT();
369
370 return(response);
371 }
372
|
373 kumpf 1.6 Boolean JMPIProviderManager::hasActiveProviders()
374 {
375 return providerManager.hasActiveProviders();
376 }
377
378 void JMPIProviderManager::unloadIdleProviders()
|
379 schuur 1.1 {
|
380 kumpf 1.6 providerManager.unloadIdleProviders();
|
381 schuur 1.1 }
382
383 #define STRDUPA(s,o) \
384 if (s) { \
385 o=(const char*)alloca(strlen(s)); \
386 strcpy((char*)(o),(s)); \
387 } \
388 else o=NULL;
389
390 #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)
391
392
393 #define HandlerIntroBase(type,type1,message,request,response,handler,respType) \
394 CIM##type##RequestMessage * request = \
395 dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \
396 PEGASUS_ASSERT(request != 0); \
397 CIM##type##ResponseMessage * response = \
398 new CIM##type##ResponseMessage( \
399 request->messageId, \
400 CIMException(), \
401 request->queueIds.copyAndPop() \
402 schuur 1.1 respType \
403 PEGASUS_ASSERT(response != 0); \
404 response->setKey(request->getKey()); \
405 response->setHttpMethod(request->getHttpMethod()); \
406 type1##ResponseHandler handler(request, response);
407
408 #define VOIDINTRO );
409 #define NOVOIDINTRO(type) ,type);
410 #define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName );
411
412
413 #define HandlerIntroVoid(type,message,request,response,handler) \
414 HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO)
415
416 #define HandlerIntroMethod(type,message,request,response,handler) \
417 HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO)
418
419 #define HandlerIntroInd(type,message,request,response,handler) \
420 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
421
|
422 kumpf 1.4 #define HandlerIntroInit(type,message,request,response,handler) \
423 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
424
|
425 schuur 1.1 #define HandlerIntro(type,message,request,response,handler,respType) \
426 HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType))
427
428 #define HandlerCatch(handler) \
429 catch(CIMException & e) \
430 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
431 "Exception: " + e.getMessage()); \
432 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); \
433 } \
434 catch(Exception & e) \
435 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
436 "Exception: " + e.getMessage()); \
437 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \
438 } \
439 catch(...) \
440 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
441 "Exception: Unknown"); \
442 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
443 }
444
|
445 schuur 1.13 static jobjectArray getList(JvmVector *jv, JNIEnv *env, CIMPropertyList &list)
446 {
447 Uint32 s=list.size();
448 jobjectArray pl=NULL;
449 if (s) {
450 jstring initial=env->NewString(NULL,0);
|
451 mark.hamzy 1.23 pl=(jobjectArray)env->NewObjectArray(s,jv->StringClassRef,initial);
|
452 schuur 1.13 for (Uint32 i=0; i<s; i++) {
453 env->SetObjectArrayElement
454 (pl,i,env->NewStringUTF(list[i].getString().getCString()));
455 }
456 }
457 return pl;
458 }
|
459 schuur 1.1
460 Message * JMPIProviderManager::handleGetInstanceRequest(const Message * message) throw()
461 {
|
462 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetInstanceRequest");
|
463 schuur 1.1
464 HandlerIntro(GetInstance,message,request,response,handler,CIMInstance());
465
|
466 mark.hamzy 1.25 typedef enum {
467 METHOD_UNKNOWN = 0,
468 METHOD_PEGASUS_24,
469 METHOD_SNIA_PROVIDER20,
470 } METHOD_VERSION;
471 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
472 JNIEnv *env = NULL;
|
473 schuur 1.13
|
474 schuur 1.1 try {
|
475 mark.hamzy 1.23 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
476 schuur 1.1 "JMPIProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
477 System::getHostName(),
478 request->nameSpace.getString(),
479 request->instanceName.getClassName().getString());
480
|
481 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));
482
|
483 schuur 1.1 // make target object path
|
484 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
485 request->nameSpace,
486 request->instanceName.getClassName(),
487 request->instanceName.getKeyBindings());
|
488 schuur 1.1
489 // resolve provider name
|
490 kumpf 1.2 ProviderName name = _resolveProviderName(
491 request->operationContext.get(ProviderIdContainer::NAME));
|
492 schuur 1.1
493 // get cached or load new provider module
494 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(),
|
495 mark.hamzy 1.23 name.getLogicalName());
|
496 schuur 1.1 OperationContext context;
497
|
498 mark.hamzy 1.23 // forward request
|
499 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
500 schuur 1.1
|
501 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.getInstance: " + pr.getName());
|
502 schuur 1.1
|
503 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Calling provider getInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
504 schuur 1.1
|
505 mark.hamzy 1.25 JvmVector *jv = 0;
506
507 env = JMPIjvm::attachThread(&jv);
508
509 JMPIProvider::pm_service_op_lock op_lock(&pr);
510
511 STAT_GETSTARTTIME;
512
513 jmethodID id = NULL;
514
515 // public abstract org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath cop,
516 // org.pegasus.jmpi.CIMClass cimClass,
517 // boolean localOnly)
518 // throws org.pegasus.jmpi.CIMException
519 id = env->GetMethodID((jclass)pr.jProviderClass,
520 "getInstance",
521 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;");
522
523 if (id != NULL)
524 {
525 eMethodFound = METHOD_SNIA_PROVIDER20;
526 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
527 }
528
529 if (id == NULL)
530 {
531 env->ExceptionClear();
532
533 // public org.pegasus.jmpi.CIMInstance getInstance (org.pegasus.jmpi.CIMObjectPath op,
534 // boolean localOnly,
535 // boolean includeQualifiers,
536 // boolean includeClassOrigin,
537 // java.lang.String[] propertyList,
538 // org.pegasus.jmpi.CIMClass cc)
539 // throws org.pegasus.jmpi.CIMException
540 id = env->GetMethodID((jclass)pr.jProviderClass,
541 "getInstance",
542 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)Lorg/pegasus/jmpi/CIMInstance;");
543
544 if (id != NULL)
545 {
546 eMethodFound = METHOD_PEGASUS_24;
547 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
548 }
549 }
550
|
551 schuur 1.1 JMPIjvm::checkException(env);
|
552 mark.hamzy 1.23
|
553 mark.hamzy 1.25 switch (eMethodFound)
554 {
555 case METHOD_PEGASUS_24:
556 {
|
557 mark.hamzy 1.29 jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
558 jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);
|
559 mark.hamzy 1.25
560 JMPIjvm::checkException(env);
561
562 CIMClass cls = pr._cimom_handle->getClass(context,
563 request->nameSpace,
564 request->instanceName.getClassName(),
565 false,
566 true,
567 true,
568 CIMPropertyList());
|
569 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
570
571 JMPIjvm::checkException(env);
|
572 mark.hamzy 1.25
|
573 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
574 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
575 mark.hamzy 1.25
576 JMPIjvm::checkException(env);
|
577 mark.hamzy 1.23
|
578 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
579 schuur 1.1
|
580 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
581 id,
582 jop,
583 request->localOnly,
584 request->includeQualifiers,
585 request->includeClassOrigin,
586 jPropertyList,
587 jcimClass);
|
588 mark.hamzy 1.23
|
589 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
590 mark.hamzy 1.23
|
591 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
|
592 schuur 1.1
|
593 mark.hamzy 1.25 handler.processing();
|
594 schuur 1.1
|
595 mark.hamzy 1.29 if (jciRet) {
596 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
597 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
598 schuur 1.13
|
599 mark.hamzy 1.29 handler.deliver(*ciRet);
|
600 mark.hamzy 1.25 }
601 handler.complete();
602 break;
|
603 mark.hamzy 1.23 }
|
604 schuur 1.13
|
605 mark.hamzy 1.25 case METHOD_SNIA_PROVIDER20:
606 {
|
607 mark.hamzy 1.29 jint jopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
608 jobject jop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jopRef);
|
609 mark.hamzy 1.25
610 JMPIjvm::checkException(env);
611
612 CIMClass cls = pr._cimom_handle->getClass(context,
613 request->nameSpace,
614 request->instanceName.getClassName(),
615 false,
616 true,
617 true,
618 CIMPropertyList());
|
619 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
620 mark.hamzy 1.25
|
621 mark.hamzy 1.27 JMPIjvm::checkException(env);
622
|
623 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
624 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
625 mark.hamzy 1.25
626 JMPIjvm::checkException(env);
627
|
628 mark.hamzy 1.30 // Modified for Bugzilla# 3679
|
629 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod((jobject)pr.jProvider,
630 id,
631 jop,
632 jcimClass,
|
633 mark.hamzy 1.30 JMPI_LOCALONLY);
|
634 mark.hamzy 1.25
635 JMPIjvm::checkException(env);
636
637 STAT_PMS_PROVIDEREND;
|
638 schuur 1.1
|
639 mark.hamzy 1.25 handler.processing();
|
640 schuur 1.13
|
641 mark.hamzy 1.29 if (jciRet) {
642 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
643 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
644 schuur 1.13
|
645 mark.hamzy 1.29 handler.deliver(*ciRet);
|
646 mark.hamzy 1.25 }
647 handler.complete();
648 break;
649 }
|
650 mark.hamzy 1.23
|
651 mark.hamzy 1.25 case METHOD_UNKNOWN:
652 {
653 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
654 break;
655 }
|
656 schuur 1.1 }
|
657 schuur 1.13 }
|
658 schuur 1.1 HandlerCatch(handler);
|
659 schuur 1.13
|
660 schuur 1.1 if (env) JMPIjvm::detachThread();
|
661 schuur 1.13
|
662 schuur 1.1 PEG_METHOD_EXIT();
663
|
664 w.white 1.31 STAT_COPYDISPATCHER
665
|
666 schuur 1.1 return(response);
667 }
668
669 Message * JMPIProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()
670 {
|
671 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleEnumerateInstanceRequest");
672
673 HandlerIntro(EnumerateInstances,message,request,response,handler,Array<CIMInstance>());
|
674 schuur 1.1
|
675 mark.hamzy 1.25 typedef enum {
676 METHOD_UNKNOWN = 0,
677 METHOD_PEGASUS_24,
|
678 mark.hamzy 1.33 METHOD_SNIA_PROVIDER20_VER1,
679 METHOD_SNIA_PROVIDER20_VER2,
|
680 mark.hamzy 1.25 } METHOD_VERSION;
681 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
682 JNIEnv *env = NULL;
|
683 schuur 1.13
684 try {
|
685 schuur 1.1 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
686 "JMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",
687 System::getHostName(),
688 request->nameSpace.getString(),
689 request->className.getString());
690
|
691 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
692
|
693 schuur 1.1 // make target object path
|
694 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
695 request->nameSpace,
696 request->className);
|
697 schuur 1.1
698 // resolve provider name
|
699 kumpf 1.2 ProviderName name = _resolveProviderName(
700 request->operationContext.get(ProviderIdContainer::NAME));
|
701 schuur 1.1
702 // get cached or load new provider module
703 JMPIProvider::OpProviderHolder ph =
704 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
705 String::EMPTY);
706
|
707 schuur 1.12 // convert arguments
|
708 schuur 1.1 OperationContext context;
709
|
710 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
711 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
712 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
713 schuur 1.1
714 // forward request
|
715 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
716 schuur 1.1
|
717 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.enumerateInstances: " + pr.getName());
|
718 schuur 1.1
|
719 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Calling provider enumerateInstances: "<<pr.getName()<<PEGASUS_STD(endl));
|
720 schuur 1.12
|
721 mark.hamzy 1.25 JvmVector *jv = 0;
722
723 env = JMPIjvm::attachThread(&jv);
724
725 JMPIProvider::pm_service_op_lock op_lock(&pr);
726
727 STAT_GETSTARTTIME;
728
729 jmethodID id = NULL;
730
|
731 mark.hamzy 1.33 /* Fix for 4189 */
732 // public synchronized Vector enumInstances(CIMObjectPath cop,
733 // boolean deep,
734 // CIMClass cimClass,
735 // boolean localOnly,
736 // boolean includeQualifiers,
737 // boolean includeClassOrigin,
738 // String propertyList[])
|
739 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
740 id = env->GetMethodID((jclass)pr.jProviderClass,
741 "enumInstances",
|
742 mark.hamzy 1.33 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;ZZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
743 mark.hamzy 1.25
744 if (id != NULL)
745 {
|
746 mark.hamzy 1.33 eMethodFound = METHOD_SNIA_PROVIDER20_VER1;
747 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_SNIA_PROVIDER20_VER1."<<PEGASUS_STD(endl));
748 }
749 /* Fix for 4189 */
750
751 if (id == NULL)
752 {
753 env->ExceptionClear();
754
755 // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,
756 // boolean deep,
757 // org.pegasus.jmpi.CIMClass cimClass,
758 // boolean localOnly)
759 // throws org.pegasus.jmpi.CIMException
760 id = env->GetMethodID((jclass)pr.jProviderClass,
761 "enumInstances",
762 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;");
763
764 if (id != NULL)
765 {
766 eMethodFound = METHOD_SNIA_PROVIDER20_VER2;
767 mark.hamzy 1.33 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_SNIA_PROVIDER20_VER2."<<PEGASUS_STD(endl));
768 }
|
769 mark.hamzy 1.25 }
770
771 if (id == NULL)
772 {
773 env->ExceptionClear();
|
774 schuur 1.1
|
775 mark.hamzy 1.25 // public org.pegasus.jmpi.CIMInstance[] enumerateInstances (org.pegasus.jmpi.CIMObjectPath op,
776 // boolean localOnly,
777 // boolean includeQualifiers,
778 // boolean includeClassOrigin,
779 // java.lang.String[] propertyList,
780 // org.pegasus.jmpi.CIMClass cc)
781 // throws org.pegasus.jmpi.CIMException
782 id = env->GetMethodID((jclass)pr.jProviderClass,
783 "enumerateInstances",
784 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");
|
785 mark.hamzy 1.23
|
786 mark.hamzy 1.25 if (id != NULL)
787 {
788 eMethodFound = METHOD_PEGASUS_24;
789 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
790 }
791 }
|
792 schuur 1.12
793 JMPIjvm::checkException(env);
|
794 mark.hamzy 1.23
|
795 mark.hamzy 1.25 switch (eMethodFound)
796 {
797 case METHOD_PEGASUS_24:
798 {
|
799 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
800 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
801 mark.hamzy 1.23
|
802 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
803 schuur 1.1
|
804 mark.hamzy 1.25 CIMClass cls = pr._cimom_handle->getClass(context,
805 request->nameSpace,
806 request->className,
807 false,
808 true,
809 true,
810 CIMPropertyList());
|
811 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
812
|
813 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
814 schuur 1.1
|
815 mark.hamzy 1.29 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
816 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
|
817 schuur 1.13
|
818 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
819 schuur 1.1
|
820 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
821
822 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
823 id,
|
824 mark.hamzy 1.29 jcop,
|
825 mark.hamzy 1.25 request->localOnly,
826 request->includeQualifiers,
827 request->includeClassOrigin,
828 jPropertyList,
|
829 mark.hamzy 1.29 jcc);
|
830 mark.hamzy 1.25
|
831 mark.hamzy 1.23 JMPIjvm::checkException(env);
832
833 STAT_PMS_PROVIDEREND;
834
835 handler.processing();
|
836 mark.hamzy 1.25 if (jAr) {
837 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
838 mark.hamzy 1.23 JMPIjvm::checkException(env);
839
|
840 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jAr,i);
841
|
842 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
843 schuur 1.13
|
844 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
845 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
846 schuur 1.13
|
847 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
848 schuur 1.13
|
849 mark.hamzy 1.29 handler.deliver(*ciRet);
|
850 mark.hamzy 1.23 }
851 }
852 handler.complete();
|
853 mark.hamzy 1.25 break;
|
854 schuur 1.13 }
|
855 mark.hamzy 1.25
|
856 mark.hamzy 1.33 /* Fix for 4189 */
857 case METHOD_SNIA_PROVIDER20_VER1:
858 {
859 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
860 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
861
862 JMPIjvm::checkException(env);
863
864 CIMClass cls = pr._cimom_handle->getClass(context,
865 request->nameSpace,
866 request->className,
867 false,
868 true,
869 true,
870 CIMPropertyList());
871 CIMClass *pcls = new CIMClass (cls);
872
873 JMPIjvm::checkException(env);
874
875 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
876 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
877 mark.hamzy 1.33
878 JMPIjvm::checkException(env);
879
880 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
881 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
882 id,
883 jcop,
884 request->deepInheritance,
885 jcc,
886 JMPI_LOCALONLY,
887 JMPI_INCLUDE_QUALIFIERS,
888 request->includeClassOrigin,
889 jPropertyList);
890
891 JMPIjvm::checkException(env);
892
893 STAT_PMS_PROVIDEREND;
894
895 handler.processing();
896 if (jVec) {
897 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
898 mark.hamzy 1.33 JMPIjvm::checkException(env);
899
900 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
901
902 JMPIjvm::checkException(env);
903
904 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
905 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
906
907 /* Fix for 4237 */
908 CIMClass cls = pr._cimom_handle->getClass(context,
909 request->nameSpace,
910 ciRet->getClassName(),
911 false,
912 true,
913 true,
914 CIMPropertyList());
915 const CIMObjectPath& op = ciRet->getPath();
916 CIMObjectPath iop = ciRet->buildPath(cls);
917
918 JMPIjvm::checkException(env);
919 mark.hamzy 1.33
920 iop.setNameSpace(op.getNameSpace());
921
922 ciRet->setPath(iop);
923 /* Fix for 4237*/
924
925 handler.deliver(*ciRet);
926 }
927 }
928 handler.complete();
929 break;
930 }
931 /* Fix for 4189 */
932
933 case METHOD_SNIA_PROVIDER20_VER2:
|
934 mark.hamzy 1.25 {
|
935 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
936 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
937 mark.hamzy 1.25
938 JMPIjvm::checkException(env);
939
940 CIMClass cls = pr._cimom_handle->getClass(context,
941 request->nameSpace,
942 request->className,
943 false,
944 true,
945 true,
946 CIMPropertyList());
|
947 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
948
|
949 mark.hamzy 1.25 JMPIjvm::checkException(env);
950
|
951 mark.hamzy 1.29 jint jccRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
952 jobject jcc = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jccRef);
|
953 mark.hamzy 1.25
954 JMPIjvm::checkException(env);
955
|
956 mark.hamzy 1.30 // Modified for Bugzilla# 3679
|
957 mark.hamzy 1.25 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
958 id,
|
959 mark.hamzy 1.29 jcop,
|
960 mark.hamzy 1.33 request->deepInheritance,
|
961 mark.hamzy 1.29 jcc,
|
962 mark.hamzy 1.30 JMPI_LOCALONLY);
|
963 mark.hamzy 1.25
|
964 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
965 schuur 1.12
|
966 mark.hamzy 1.23 STAT_PMS_PROVIDEREND;
967
968 handler.processing();
|
969 mark.hamzy 1.25 if (jVec) {
970 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
971 mark.hamzy 1.23 JMPIjvm::checkException(env);
972
|
973 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
974
|
975 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
976 schuur 1.12
|
977 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
978 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
979 schuur 1.12
|
980 mark.hamzy 1.33 /* Fix for 4237 */
981 CIMClass cls = pr._cimom_handle->getClass(context,
982 request->nameSpace,
983 ciRet->getClassName(),
984 false,
985 true,
986 true,
987 CIMPropertyList());
988 const CIMObjectPath& op = ciRet->getPath();
989 CIMObjectPath iop = ciRet->buildPath(cls);
990
991 JMPIjvm::checkException(env);
992
993 iop.setNameSpace(op.getNameSpace());
994
995 ciRet->setPath(iop);
996 /* Fix for 4237*/
997
|
998 mark.hamzy 1.29 handler.deliver(*ciRet);
|
999 mark.hamzy 1.23 }
1000 }
1001 handler.complete();
|
1002 mark.hamzy 1.25 break;
1003 }
1004
1005 case METHOD_UNKNOWN:
1006 {
1007 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: should not be here!"<<PEGASUS_STD(endl));
1008 break;
1009 }
|
1010 schuur 1.1 }
1011 }
1012 HandlerCatch(handler);
|
1013 schuur 1.12
|
1014 schuur 1.11 if (env) JMPIjvm::detachThread();
|
1015 schuur 1.12
|
1016 schuur 1.1 PEG_METHOD_EXIT();
1017
|
1018 w.white 1.31 STAT_COPYDISPATCHER
1019
|
1020 schuur 1.1 return(response);
1021 }
1022
1023 Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()
1024 {
1025 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest");
1026
|
1027 mark.hamzy 1.23 HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>());
1028
|
1029 mark.hamzy 1.25 typedef enum {
1030 METHOD_UNKNOWN = 0,
1031 METHOD_PEGASUS_24,
1032 METHOD_SNIA_PROVIDER20,
1033 } METHOD_VERSION;
1034 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1035 JNIEnv *env = NULL;
|
1036 schuur 1.13
|
1037 schuur 1.1 try {
1038 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1039 "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1040 System::getHostName(),
1041 request->nameSpace.getString(),
1042 request->className.getString());
|
1043 mark.hamzy 1.23
1044 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
1045
|
1046 mark.hamzy 1.25 // make target object path
|
1047 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1048 request->nameSpace,
1049 request->className);
|
1050 schuur 1.1
1051 // resolve provider name
|
1052 kumpf 1.2 ProviderName name = _resolveProviderName(
1053 request->operationContext.get(ProviderIdContainer::NAME));
|
1054 schuur 1.1
1055 // get cached or load new provider module
1056 JMPIProvider::OpProviderHolder ph =
1057 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
1058
1059 // convert arguments
1060 OperationContext context;
1061
|
1062 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1063 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1064 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1065 schuur 1.1
|
1066 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1067 schuur 1.1
|
1068 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.enumerateInstanceNames: " + pr.getName());
|
1069 schuur 1.1
|
1070 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Calling provider : enumerateInstanceNames"<<pr.getName()<<PEGASUS_STD(endl));
|
1071 schuur 1.1
|
1072 mark.hamzy 1.25 JvmVector *jv = 0;
|
1073 schuur 1.12
|
1074 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
1075 schuur 1.1
|
1076 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
1077 schuur 1.12
|
1078 mark.hamzy 1.25 STAT_GETSTARTTIME;
|
1079 mark.hamzy 1.23
|
1080 mark.hamzy 1.25 jmethodID id = NULL;
|
1081 mark.hamzy 1.23
|
1082 mark.hamzy 1.25 // public abstract java.util.Vector enumInstances (org.pegasus.jmpi.CIMObjectPath cop,
1083 // boolean deep,
1084 // org.pegasus.jmpi.CIMClass cimClass)
1085 // throws org.pegasus.jmpi.CIMException
1086 id = env->GetMethodID((jclass)pr.jProviderClass,
1087 "enumInstances",
1088 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
|
1089 schuur 1.1
|
1090 mark.hamzy 1.25 if (id != NULL)
1091 {
1092 eMethodFound = METHOD_SNIA_PROVIDER20;
1093 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1094 }
|
1095 schuur 1.1
|
1096 mark.hamzy 1.25 if (id == NULL)
1097 {
1098 env->ExceptionClear();
|
1099 schuur 1.1
|
1100 mark.hamzy 1.25 // public org.pegasus.jmpi.CIMObjectPath[] enumerateInstanceNames (org.pegasus.jmpi.CIMObjectPath op,
1101 // org.pegasus.jmpi.CIMClass cc)
1102 // throws org.pegasus.jmpi.CIMException
1103 id = env->GetMethodID((jclass)pr.jProviderClass,
1104 "enumerateInstanceNames",
1105 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMObjectPath;");
|
1106 schuur 1.13
|
1107 mark.hamzy 1.25 if (id != NULL)
1108 {
1109 eMethodFound = METHOD_PEGASUS_24;
1110 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
1111 }
|
1112 mark.hamzy 1.23 }
|
1113 mark.hamzy 1.25
|
1114 schuur 1.1 JMPIjvm::checkException(env);
1115
|
1116 mark.hamzy 1.25 switch (eMethodFound)
1117 {
1118 case METHOD_PEGASUS_24:
1119 {
|
1120 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1121 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1122 mark.hamzy 1.25
1123 JMPIjvm::checkException(env);
1124
1125 CIMClass cls = pr._cimom_handle->getClass(context,
1126 request->nameSpace,
1127 request->className,
1128 false,
1129 true,
1130 true,
1131 CIMPropertyList());
|
1132 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
1133 mark.hamzy 1.25
1134 JMPIjvm::checkException(env);
1135
|
1136 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1137 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
1138 mark.hamzy 1.25
1139 JMPIjvm::checkException(env);
1140
1141 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1142 id,
|
1143 mark.hamzy 1.29 jcop,
1144 jcimClass);
|
1145 mark.hamzy 1.25
|
1146 mark.hamzy 1.23 JMPIjvm::checkException(env);
1147
1148 STAT_PMS_PROVIDEREND;
1149
1150 handler.processing();
|
1151 mark.hamzy 1.25 if (jAr) {
1152 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
|
1153 mark.hamzy 1.23 JMPIjvm::checkException(env);
1154
|
1155 mark.hamzy 1.29 jobject jcopRet = env->GetObjectArrayElement(jAr,i);
1156
|
1157 mark.hamzy 1.23 JMPIjvm::checkException(env);
1158
|
1159 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1160 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
1161 schuur 1.13
|
1162 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1163 schuur 1.13
|
1164 mark.hamzy 1.29 handler.deliver(*copRet);
|
1165 mark.hamzy 1.23 }
1166 }
1167 handler.complete();
|
1168 mark.hamzy 1.25 break;
|
1169 schuur 1.13 }
|
1170 mark.hamzy 1.25
1171 case METHOD_SNIA_PROVIDER20:
1172 {
|
1173 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1174 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1175 mark.hamzy 1.25
1176 JMPIjvm::checkException(env);
1177
1178 CIMClass cls = pr._cimom_handle->getClass(context,
1179 request->nameSpace,
1180 request->className,
1181 false,
1182 true,
1183 true,
1184 CIMPropertyList());
|
1185 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
|
1186 mark.hamzy 1.25
1187 JMPIjvm::checkException(env);
1188
|
1189 mark.hamzy 1.29 jint jcimClassRef = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
1190 jobject jcimClass = env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcimClassRef);
|
1191 mark.hamzy 1.25
1192 JMPIjvm::checkException(env);
1193
1194 jobject jVec = env->CallObjectMethod((jobject)pr.jProvider,
1195 id,
|
1196 mark.hamzy 1.29 jcop,
|
1197 mark.hamzy 1.25 true,
|
1198 mark.hamzy 1.29 jcimClass);
|
1199 mark.hamzy 1.25
|
1200 mark.hamzy 1.23 JMPIjvm::checkException(env);
1201
1202 STAT_PMS_PROVIDEREND;
1203
1204 handler.processing();
|
1205 mark.hamzy 1.25 if (jVec) {
1206 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
1207 mark.hamzy 1.23 JMPIjvm::checkException(env);
1208
|
1209 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1210
|
1211 mark.hamzy 1.23 JMPIjvm::checkException(env);
1212
|
1213 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1214 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
1215 schuur 1.13
|
1216 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1217 schuur 1.13
|
1218 mark.hamzy 1.29 handler.deliver(*copRet);
|
1219 mark.hamzy 1.23 }
1220 }
1221 handler.complete();
|
1222 mark.hamzy 1.25 break;
1223 }
1224
1225 case METHOD_UNKNOWN:
1226 {
1227 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: should not be here!"<<PEGASUS_STD(endl));
1228 break;
1229 }
|
1230 schuur 1.1 }
1231 }
1232 HandlerCatch(handler);
|
1233 mark.hamzy 1.23
1234 if (env) JMPIjvm::detachThread();
|
1235 schuur 1.1
1236 PEG_METHOD_EXIT();
1237
|
1238 w.white 1.31 STAT_COPYDISPATCHER
1239
|
1240 schuur 1.1 return(response);
1241 }
1242
1243 Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()
1244 {
|
1245 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest");
1246
1247 HandlerIntro(CreateInstance,message,request,response,handler,CIMObjectPath());
|
1248 schuur 1.1
|
1249 mark.hamzy 1.25 typedef enum {
1250 METHOD_UNKNOWN = 0,
1251 METHOD_SNIA_PROVIDER20,
1252 } METHOD_VERSION;
1253 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1254 JNIEnv *env = NULL;
1255
|
1256 schuur 1.1 try {
1257 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1258 "JMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
1259 System::getHostName(),
1260 request->nameSpace.getString(),
1261 request->newInstance.getPath().getClassName().getString());
1262
|
1263 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));
1264
|
1265 schuur 1.1 // make target object path
|
1266 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1267 request->nameSpace,
1268 request->newInstance.getPath().getClassName(),
1269 request->newInstance.getPath().getKeyBindings());
|
1270 schuur 1.1
1271 // resolve provider name
|
1272 kumpf 1.2 ProviderName name = _resolveProviderName(
1273 request->operationContext.get(ProviderIdContainer::NAME));
|
1274 schuur 1.1
1275 // get cached or load new provider module
1276 JMPIProvider::OpProviderHolder ph =
1277 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
|
1278 mark.hamzy 1.23 String::EMPTY);
|
1279 schuur 1.1
1280 // convert arguments
1281 OperationContext context;
1282
|
1283 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1284 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1285 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1286 schuur 1.1
1287 // forward request
|
1288 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1289 schuur 1.1
|
1290 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createInstance: " + ph.GetProvider().getName());
|
1291 schuur 1.1
|
1292 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
1293 schuur 1.12
|
1294 mark.hamzy 1.25 JvmVector *jv = 0;
1295
1296 env = JMPIjvm::attachThread(&jv);
1297
1298 JMPIProvider::pm_service_op_lock op_lock(&pr);
1299
1300 STAT_GETSTARTTIME;
1301
1302 jmethodID id = NULL;
1303
1304 // public abstract org.pegasus.jmpi.CIMObjectPath createInstance (org.pegasus.jmpi.CIMObjectPath cop,
1305 // org.pegasus.jmpi.CIMInstance cimInstance)
1306 // throws org.pegasus.jmpi.CIMException
1307 id = env->GetMethodID((jclass)pr.jProviderClass,
1308 "createInstance",
1309 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");
|
1310 schuur 1.1
|
1311 mark.hamzy 1.25 if (id != NULL)
1312 {
1313 eMethodFound = METHOD_SNIA_PROVIDER20;
1314 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1315 }
|
1316 mark.hamzy 1.23
1317 JMPIjvm::checkException(env);
1318
|
1319 mark.hamzy 1.25 switch (eMethodFound)
1320 {
1321 case METHOD_SNIA_PROVIDER20:
1322 {
|
1323 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1324 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1325 mark.hamzy 1.25
1326 JMPIjvm::checkException(env);
1327
|
1328 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->newInstance);
1329 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
1330 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
|
1331 mark.hamzy 1.25
1332 JMPIjvm::checkException(env);
|
1333 schuur 1.1
|
1334 mark.hamzy 1.29 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jcop = "<<jcop<<", jci = "<<jci<<PEGASUS_STD(endl));
|
1335 schuur 1.1
|
1336 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod((jobject)pr.jProvider,
1337 id,
1338 jcop,
1339 jci);
|
1340 schuur 1.1
|
1341 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
1342 schuur 1.1
|
1343 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
|
1344 mark.hamzy 1.23
|
1345 mark.hamzy 1.25 handler.processing();
|
1346 mark.hamzy 1.23
|
1347 mark.hamzy 1.29 if (jcopRet) {
1348 jint jCopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
1349 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCopRetRef);
|
1350 mark.hamzy 1.23
|
1351 mark.hamzy 1.29 handler.deliver(*copRet);
|
1352 mark.hamzy 1.25 }
1353 handler.complete();
1354 break;
1355 }
|
1356 mark.hamzy 1.23
|
1357 mark.hamzy 1.25 case METHOD_UNKNOWN:
1358 {
1359 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
1360 break;
1361 }
|
1362 schuur 1.1 }
1363 }
1364 HandlerCatch(handler);
|
1365 mark.hamzy 1.23
|
1366 schuur 1.1 if (env) JMPIjvm::detachThread();
|
1367 mark.hamzy 1.23
|
1368 schuur 1.1 PEG_METHOD_EXIT();
1369
|
1370 w.white 1.31 STAT_COPYDISPATCHER
1371
|
1372 schuur 1.1 return(response);
1373 }
1374
1375 Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()
1376 {
|
1377 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest");
|
1378 schuur 1.1
1379 HandlerIntroVoid(ModifyInstance,message,request,response,handler);
|
1380 mark.hamzy 1.23
|
1381 mark.hamzy 1.25 typedef enum {
1382 METHOD_UNKNOWN = 0,
1383 METHOD_PEGASUS_24,
1384 METHOD_SNIA_PROVIDER20,
1385 } METHOD_VERSION;
1386 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1387 JNIEnv *env = NULL;
|
1388 schuur 1.13
|
1389 schuur 1.1 try {
1390 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
1391 konrad.r 1.15 "JMPIProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
1392 schuur 1.1 System::getHostName(),
1393 request->nameSpace.getString(),
1394 request->modifiedInstance.getPath().getClassName().getString());
1395
|
1396 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));
1397
|
1398 schuur 1.1 // make target object path
|
1399 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1400 request->nameSpace,
1401 request->modifiedInstance.getPath ().getClassName(),
1402 request->modifiedInstance.getPath ().getKeyBindings());
|
1403 schuur 1.1
1404 // resolve provider name
|
1405 kumpf 1.2 ProviderName name = _resolveProviderName(
1406 request->operationContext.get(ProviderIdContainer::NAME));
|
1407 schuur 1.1
|
1408 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl));
1409
|
1410 schuur 1.1 // get cached or load new provider module
1411 JMPIProvider::OpProviderHolder ph =
1412 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1413
1414 // convert arguments
1415 OperationContext context;
1416
|
1417 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1418 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1419 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1420 schuur 1.1
1421 // forward request
|
1422 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1423 mark.hamzy 1.23
1424 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName());
1425
|
1426 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));
1427 ////////DDD(debugPrintMethodPointers (env, (jclass)pr.jProviderClass));
1428
1429 JvmVector *jv = 0;
1430
1431 env = JMPIjvm::attachThread(&jv);
1432
1433 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
1434 mark.hamzy 1.23
|
1435 mark.hamzy 1.25 STAT_GETSTARTTIME;
1436
1437 jmethodID id = NULL;
1438
1439 // public abstract void setInstance (org.pegasus.jmpi.CIMObjectPath cop,
1440 // org.pegasus.jmpi.CIMInstance cimInstance)
1441 // org.pegasus.jmpi.throws CIMException
1442 id = env->GetMethodID((jclass)pr.jProviderClass,
1443 "setInstance",
1444 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");
1445
1446 if (id != NULL)
1447 {
1448 eMethodFound = METHOD_SNIA_PROVIDER20;
1449 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1450 }
1451
1452 if (id == NULL)
1453 {
1454 env->ExceptionClear();
1455
1456 mark.hamzy 1.25 // public void setInstance (org.pegasus.jmpi.CIMObjectPath op,
1457 // org.pegasus.jmpi.CIMInstance ci,
1458 // boolean includeQualifiers,
1459 // java.lang.String[] propertyList)
1460 // throws org.pegasus.jmpi.CIMException
1461 id = env->GetMethodID((jclass)pr.jProviderClass,
1462 "setInstance",
1463 "(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");
|
1464 schuur 1.1
|
1465 mark.hamzy 1.25 if (id != NULL)
1466 {
1467 eMethodFound = METHOD_PEGASUS_24;
1468 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
1469 }
1470 }
|
1471 schuur 1.1
|
1472 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1473 schuur 1.1
|
1474 mark.hamzy 1.25 switch (eMethodFound)
1475 {
1476 case METHOD_PEGASUS_24:
1477 {
|
1478 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1479 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1480 mark.hamzy 1.25
1481 JMPIjvm::checkException(env);
1482
|
1483 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
1484 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
1485 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
|
1486 mark.hamzy 1.25
1487 JMPIjvm::checkException(env);
|
1488 schuur 1.1
|
1489 mark.hamzy 1.25 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
|
1490 schuur 1.1
|
1491 mark.hamzy 1.25 env->CallVoidMethod((jobject)pr.jProvider,
1492 id,
|
1493 mark.hamzy 1.29 jcop,
1494 jci,
|
1495 mark.hamzy 1.25 jPropertyList);
|
1496 schuur 1.1
|
1497 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
1498 schuur 1.13
|
1499 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
1500 break;
|
1501 schuur 1.13 }
|
1502 schuur 1.1
|
1503 mark.hamzy 1.25 case METHOD_SNIA_PROVIDER20:
1504 {
|
1505 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1506 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1507 mark.hamzy 1.25
1508 JMPIjvm::checkException(env);
1509
|
1510 mark.hamzy 1.29 CIMInstance *ci = new CIMInstance (request->modifiedInstance);
1511 jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
1512 jobject jci = env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jciRef);
|
1513 mark.hamzy 1.25
1514 JMPIjvm::checkException(env);
1515
1516 env->CallVoidMethod((jobject)pr.jProvider,
1517 id,
|
1518 mark.hamzy 1.29 jcop,
1519 jci);
|
1520 mark.hamzy 1.25
1521 JMPIjvm::checkException(env);
|
1522 schuur 1.13
|
1523 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
1524 break;
1525 }
|
1526 mark.hamzy 1.23
|
1527 mark.hamzy 1.25 case METHOD_UNKNOWN:
1528 {
1529 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
1530 break;
1531 }
1532 }
|
1533 schuur 1.1 }
1534 HandlerCatch(handler);
|
1535 mark.hamzy 1.23
|
1536 schuur 1.1 if (env) JMPIjvm::detachThread();
|
1537 mark.hamzy 1.23
|
1538 schuur 1.1 PEG_METHOD_EXIT();
1539
|
1540 w.white 1.31 STAT_COPYDISPATCHER
1541
|
1542 schuur 1.1 return(response);
1543 }
1544
1545 Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()
1546 {
|
1547 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest");
1548
1549 HandlerIntroVoid(DeleteInstance,message,request,response,handler);
|
1550 schuur 1.1
|
1551 mark.hamzy 1.25 typedef enum {
1552 METHOD_UNKNOWN = 0,
1553 METHOD_SNIA_PROVIDER20,
1554 } METHOD_VERSION;
1555 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1556 JNIEnv *env = NULL;
1557
|
1558 schuur 1.1 try {
1559 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
1560 konrad.r 1.15 "JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
1561 schuur 1.1 System::getHostName(),
1562 request->nameSpace.getString(),
1563 request->instanceName.getClassName().getString());
1564
|
1565 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));
1566
|
1567 schuur 1.1 // make target object path
|
1568 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1569 request->nameSpace,
1570 request->instanceName.getClassName(),
1571 request->instanceName.getKeyBindings());
|
1572 schuur 1.1
1573 // resolve provider name
|
1574 kumpf 1.2 ProviderName name = _resolveProviderName(
1575 request->operationContext.get(ProviderIdContainer::NAME));
|
1576 schuur 1.1
1577 // get cached or load new provider module
1578 JMPIProvider::OpProviderHolder ph =
1579 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1580
1581 // convert arguments
1582 OperationContext context;
1583
|
1584 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1585 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1586 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1587 schuur 1.1
1588 // forward request
|
1589 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
1590 schuur 1.1
|
1591 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteInstance: " + pr.getName());
|
1592 schuur 1.1
|
1593 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: Calling provider deleteInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
1594 schuur 1.1
|
1595 mark.hamzy 1.25 JvmVector *jv = 0;
1596
1597 env = JMPIjvm::attachThread(&jv);
1598
1599 JMPIProvider::pm_service_op_lock op_lock(&pr);
1600
1601 STAT_GETSTARTTIME;
1602
1603 jmethodID id = NULL;
1604
1605 // public abstract void deleteInstance (org.pegasus.jmpi.CIMObjectPath cop)
1606 // throws org.pegasus.jmpi.CIMException
1607 id = env->GetMethodID((jclass)pr.jProviderClass,
1608 "deleteInstance",
1609 "(Lorg/pegasus/jmpi/CIMObjectPath;)V");
|
1610 schuur 1.1
|
1611 mark.hamzy 1.25 if (id != NULL)
1612 {
1613 eMethodFound = METHOD_SNIA_PROVIDER20;
1614 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1615 }
|
1616 mark.hamzy 1.23
1617 JMPIjvm::checkException(env);
|
1618 schuur 1.1
|
1619 mark.hamzy 1.25 switch (eMethodFound)
1620 {
1621 case METHOD_SNIA_PROVIDER20:
1622 {
|
1623 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
1624 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
1625 mark.hamzy 1.25
1626 JMPIjvm::checkException(env);
1627
|
1628 mark.hamzy 1.29 env->CallVoidMethod((jobject)pr.jProvider,id,jcop);
|
1629 mark.hamzy 1.25
1630 JMPIjvm::checkException(env);
1631
1632 STAT_PMS_PROVIDEREND;
1633 break;
1634 }
1635
1636 case METHOD_UNKNOWN:
1637 {
1638 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: should not be here!"<<PEGASUS_STD(endl));
1639 break;
1640 }
1641 }
1642 }
1643 HandlerCatch(handler);
1644
1645 if (env) JMPIjvm::detachThread();
1646
1647 PEG_METHOD_EXIT();
1648
|
1649 w.white 1.31 STAT_COPYDISPATCHER
1650
|
1651 mark.hamzy 1.25 return(response);
1652 }
1653
1654 Message * JMPIProviderManager::handleExecQueryRequest(const Message * message) throw()
1655 {
1656 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleExecQueryRequest");
1657
1658 HandlerIntro(ExecQuery,message,request,response,handler,Array<CIMObject>());
1659
1660 typedef enum {
1661 METHOD_UNKNOWN = 0,
1662 METHOD_PEGASUS_24,
1663 METHOD_SNIA_PROVIDER20,
1664 } METHOD_VERSION;
1665 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1666 JNIEnv *env = NULL;
1667
1668 try {
1669 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1670 "JMPIProviderManager::handleExecQueryRequest - Host name: $0 Name space: $1 Class name: $2",
1671 System::getHostName(),
1672 mark.hamzy 1.25 request->nameSpace.getString(),
1673 request->className.getString());
1674
1675 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
1676
1677 // make target object path
|
1678 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1679 request->nameSpace,
1680 request->className);
|
1681 mark.hamzy 1.25
1682 // resolve provider name
1683 ProviderName name = _resolveProviderName(
1684 request->operationContext.get(ProviderIdContainer::NAME));
1685
1686 // get cached or load new provider module
1687 JMPIProvider::OpProviderHolder ph =
1688 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1689
1690 // convert arguments
1691 OperationContext context;
1692
1693 context.insert(request->operationContext.get(IdentityContainer::NAME));
1694 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1695 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1696
1697 // forward request
1698 JMPIProvider &pr = ph.GetProvider();
1699
1700 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.execQuery: " + pr.getName());
1701
1702 mark.hamzy 1.25 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: Calling provider execQuery: "<<pr.getName()<<", queryLanguage: "<<request->queryLanguage<<", query: "<<request->query<<PEGASUS_STD(endl));
1703
1704 JvmVector *jv = 0;
1705
1706 env = JMPIjvm::attachThread(&jv);
1707
|
1708 mark.hamzy 1.23 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
1709 schuur 1.1
|
1710 mark.hamzy 1.23 STAT_GETSTARTTIME;
|
1711 schuur 1.1
|
1712 mark.hamzy 1.25 jmethodID id = NULL;
1713
1714 // public abstract java.util.Vector execQuery (org.pegasus.jmpi.CIMObjectPath cop,
1715 // java.lang.String queryStatement,
1716 // int ql,
1717 // org.pegasus.jmpi.CIMClass cimClass)
1718 // throws org.pegasus.jmpi.CIMException
1719 //
1720 id = env->GetMethodID((jclass)pr.jProviderClass,
1721 "execQuery",
1722 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ILorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
1723
1724 if (id != NULL)
1725 {
1726 eMethodFound = METHOD_SNIA_PROVIDER20;
1727 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1728 }
1729
1730 if (id == NULL)
1731 {
1732 env->ExceptionClear();
1733 mark.hamzy 1.25
1734 // public abstract org.pegasus.jmpi.CIMInstance[] execQuery(org.pegasus.jmpi.CIMObjectPath op,
1735 // java.lang.String query,
1736 // java.lang.String ql,
1737 // org.pegasus.jmpi.CIMClass cc)
1738 // throws org.pegasus.jmpi.CIMException
1739 id = env->GetMethodID((jclass)pr.jProviderClass,
1740 "execQuery",
1741 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)[Lorg/pegasus/jmpi/CIMInstance;");
1742
1743 if (id != NULL)
1744 {
1745 eMethodFound = METHOD_PEGASUS_24;
1746 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
1747 }
1748 }
1749
1750 if (id == NULL)
1751 {
1752 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: found no method!"<<PEGASUS_STD(endl));
1753 }
1754 mark.hamzy 1.25
|
1755 schuur 1.1 JMPIjvm::checkException(env);
1756
|
1757 mark.hamzy 1.25 switch (eMethodFound)
1758 {
1759 case METHOD_PEGASUS_24:
1760 {
|
1761 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
1762 mark.hamzy 1.25 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
1763
1764 JMPIjvm::checkException(env);
1765
1766 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
1767 jstring jquery = env->NewStringUTF(request->query.getCString());
1768
1769 CIMClass cls = pr._cimom_handle->getClass(context,
1770 request->nameSpace,
1771 request->className,
1772 false,
1773 true,
1774 true,
1775 CIMPropertyList());
|
1776 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
1777
|
1778 mark.hamzy 1.25 JMPIjvm::checkException(env);
1779
|
1780 mark.hamzy 1.27 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
|
1781 mark.hamzy 1.25
1782 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
1783
1784 JMPIjvm::checkException(env);
1785
1786 jobjectArray jAr = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1787 id,
1788 jcop,
1789 jquery,
1790 jqueryLanguage,
1791 jCc);
|
1792 mark.hamzy 1.23
|
1793 mark.hamzy 1.25 JMPIjvm::checkException(env);
1794
1795 STAT_PMS_PROVIDEREND;
1796
1797 handler.processing();
1798 if (jAr) {
1799 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1800 JMPIjvm::checkException(env);
1801
|
1802 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jAr,i);
1803
|
1804 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
1805 mark.hamzy 1.23
|
1806 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
1807 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
1808 mark.hamzy 1.25
1809 JMPIjvm::checkException(env);
1810
|
1811 mark.hamzy 1.29 handler.deliver(*ciRet);
|
1812 mark.hamzy 1.25 }
1813 }
1814 handler.complete();
1815 break;
1816 }
1817
1818 case METHOD_SNIA_PROVIDER20:
1819 {
|
1820 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
1821 mark.hamzy 1.25 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
1822
1823 JMPIjvm::checkException(env);
1824
1825 jstring jqueryLanguage = env->NewStringUTF(request->queryLanguage.getCString());
1826 jstring jquery = env->NewStringUTF(request->query.getCString());
1827
1828 CIMClass cls = pr._cimom_handle->getClass(context,
1829 request->nameSpace,
1830 request->className,
1831 false,
1832 true,
1833 true,
1834 CIMPropertyList());
|
1835 mark.hamzy 1.27 CIMClass *pcls = new CIMClass (cls);
1836
|
1837 mark.hamzy 1.25 JMPIjvm::checkException(env);
1838
|
1839 mark.hamzy 1.27 jint jcls = DEBUG_ConvertCToJava (CIMClass*, jint, pcls);
|
1840 mark.hamzy 1.25
1841 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jcls);
1842
1843 JMPIjvm::checkException(env);
1844
1845 jint jql = 0; // @BUG - how to convert?
1846
1847 jobjectArray jVec = (jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1848 id,
1849 jcop,
1850 jquery,
1851 jql,
1852 jCc);
1853
1854 JMPIjvm::checkException(env);
1855
1856 STAT_PMS_PROVIDEREND;
1857
1858 handler.processing();
1859 if (jVec) {
1860 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
1861 mark.hamzy 1.25 JMPIjvm::checkException(env);
1862
|
1863 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jVec,i);
1864
|
1865 mark.hamzy 1.25 JMPIjvm::checkException(env);
1866
|
1867 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
1868 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
|
1869 mark.hamzy 1.25
1870 JMPIjvm::checkException(env);
1871
|
1872 mark.hamzy 1.29 handler.deliver(*ciRet);
|
1873 mark.hamzy 1.25 }
1874 }
1875 handler.complete();
1876 break;
1877 }
1878
1879 case METHOD_UNKNOWN:
1880 {
1881 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleExecQueryRequest: should not be here!"<<PEGASUS_STD(endl));
1882 break;
1883 }
1884 }
|
1885 schuur 1.1 }
1886 HandlerCatch(handler);
|
1887 mark.hamzy 1.23
|
1888 schuur 1.1 if (env) JMPIjvm::detachThread();
|
1889 mark.hamzy 1.23
|
1890 schuur 1.1 PEG_METHOD_EXIT();
1891
|
1892 w.white 1.31 STAT_COPYDISPATCHER
1893
|
1894 schuur 1.1 return(response);
1895 }
1896
1897 Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()
1898 {
|
1899 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest");
1900
1901 HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>());
|
1902 schuur 1.1
|
1903 mark.hamzy 1.24 typedef enum {
1904 METHOD_UNKNOWN = 0,
|
1905 mark.hamzy 1.25 METHOD_PEGASUS_24,
|
1906 mark.hamzy 1.24 METHOD_SNIA_PROVIDER20,
1907 } METHOD_VERSION;
1908 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1909 JNIEnv *env = NULL;
|
1910 schuur 1.13
|
1911 schuur 1.1 try {
1912 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1913 "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",
1914 System::getHostName(),
1915 request->nameSpace.getString(),
1916 request->objectName.getClassName().getString());
1917
|
1918 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));
|
1919 mark.hamzy 1.23
|
1920 schuur 1.1 // make target object path
|
1921 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
1922 request->nameSpace,
1923 request->objectName.getClassName(),
1924 request->objectName.getKeyBindings());
1925 CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),
1926 request->nameSpace,
1927 request->assocClass.getString());
|
1928 schuur 1.1
1929 // resolve provider name
|
1930 kumpf 1.2 ProviderName name = _resolveProviderName(
1931 request->operationContext.get(ProviderIdContainer::NAME));
|
1932 schuur 1.1
1933 // get cached or load new provider module
1934 JMPIProvider::OpProviderHolder ph =
1935 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1936
|
1937 mark.hamzy 1.24 // convert arguments
|
1938 schuur 1.1 OperationContext context;
1939
|
1940 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1941 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1942 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1943 schuur 1.1
1944 // forward request
|
1945 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
1946
1947 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName());
|
1948 schuur 1.1
|
1949 mark.hamzy 1.24 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
|
1950 schuur 1.1
|
1951 mark.hamzy 1.24 JvmVector *jv = 0;
|
1952 schuur 1.1
|
1953 mark.hamzy 1.24 env = JMPIjvm::attachThread(&jv);
|
1954 schuur 1.1
1955 JMPIProvider::pm_service_op_lock op_lock(&pr);
1956
1957 STAT_GETSTARTTIME;
1958
|
1959 mark.hamzy 1.24 jmethodID id = NULL;
1960
1961 // public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,
|
1962 mark.hamzy 1.25 // org.pegasus.jmpi.CIMObjectPath pathName,
|
1963 mark.hamzy 1.24 // java.lang.String resultClass,
1964 // java.lang.String role,
1965 // java.lang.String resultRole,
1966 // boolean includeQualifiers,
1967 // boolean includeClassOrigin,
1968 // java.lang.String[] propertyList)
|
1969 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
|
1970 mark.hamzy 1.24 //
1971 id = env->GetMethodID((jclass)pr.jProviderClass,
1972 "associators",
|
1973 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;");
1974 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"
|
1975 mark.hamzy 1.24
1976 if (id != NULL)
1977 {
|
1978 mark.hamzy 1.25 eMethodFound = METHOD_SNIA_PROVIDER20;
1979 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
1980 mark.hamzy 1.24 }
|
1981 schuur 1.12
|
1982 mark.hamzy 1.24 if (id == NULL)
1983 {
1984 env->ExceptionClear();
1985
1986 // public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,
1987 // java.lang.String resultClass,
1988 // java.lang.String role,
1989 // java.lang.String resultRole,
1990 // boolean includeQualifiers,
1991 // boolean includeClassOrigin,
1992 // java.lang.String[] propertyList)
|
1993 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
|
1994 mark.hamzy 1.24 //
1995 id = env->GetMethodID((jclass)pr.jProviderClass,
1996 "associators",
|
1997 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
1998 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"
|
1999 mark.hamzy 1.24
2000 if (id != NULL)
2001 {
|
2002 mark.hamzy 1.25 eMethodFound = METHOD_PEGASUS_24;
2003 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
|
2004 mark.hamzy 1.24 }
2005 }
2006
2007 if (id == NULL)
2008 {
2009 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));
|
2010 mark.hamzy 1.23 }
|
2011 mark.hamzy 1.24
|
2012 schuur 1.1 JMPIjvm::checkException(env);
2013
|
2014 mark.hamzy 1.24 switch (eMethodFound)
2015 {
|
2016 mark.hamzy 1.25 case METHOD_PEGASUS_24:
|
2017 mark.hamzy 1.24 {
|
2018 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
2019 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2020
2021 JMPIjvm::checkException(env);
2022
2023 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
2024 jstring jRole = env->NewStringUTF(request->role.getCString());
2025 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
2026
2027 JMPIjvm::checkException(env);
2028
2029 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
2030
|
2031 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2032 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
2033 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
2034 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
2035 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
2036 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
2037 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
2038 #endif
2039
|
2040 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2041 id,
2042 jAssociationName,
2043 jResultClass,
2044 jRole,
2045 jResultRole,
2046 false,
2047 false,
2048 jPropertyList);
|
2049 mark.hamzy 1.25
|
2050 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2051 schuur 1.13
|
2052 mark.hamzy 1.23 STAT_PMS_PROVIDEREND;
|
2053 schuur 1.1
|
2054 mark.hamzy 1.23 handler.processing();
2055 if (jVec) {
|
2056 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
2057 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2058 schuur 1.1
|
2059 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jVec,i);
|
2060 mark.hamzy 1.24
|
2061 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2062 schuur 1.13
|
2063 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
2064 schuur 1.13
|
2065 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2066 schuur 1.13
|
2067 mark.hamzy 1.29 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
2068 CIMClass cls = pr._cimom_handle->getClass(context,
2069 request->nameSpace,
2070 ciRet->getClassName(),
2071 false,
2072 true,
2073 true,
2074 CIMPropertyList());
2075 const CIMObjectPath& op = ciRet->getPath();
2076 CIMObjectPath iop = ciRet->buildPath(cls);
|
2077 mark.hamzy 1.24
|
2078 mark.hamzy 1.27 JMPIjvm::checkException(env);
2079
|
2080 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
2081 mark.hamzy 1.29 ciRet->setPath(iop);
|
2082 schuur 1.13
|
2083 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2084 mark.hamzy 1.23 }
2085 }
|
2086 mark.hamzy 1.24 handler.complete();
2087 break;
|
2088 mark.hamzy 1.23 }
|
2089 mark.hamzy 1.24
2090 case METHOD_SNIA_PROVIDER20:
2091 {
|
2092 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
2093 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2094
2095 JMPIjvm::checkException(env);
2096
|
2097 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
2098 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
2099
2100 JMPIjvm::checkException(env);
2101
|
2102 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
2103 jstring jRole = env->NewStringUTF(request->role.getCString());
2104 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
2105
2106 JMPIjvm::checkException(env);
2107
2108 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
2109
|
2110 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2111 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
2112 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
2113 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
2114 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: role = "<<request->role<<PEGASUS_STD(endl));
2115 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
2116 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
2117 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorsRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
2118 #endif
2119
|
2120 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2121 id,
2122 jAssociationName,
2123 jPathName,
2124 jResultClass,
2125 jRole,
2126 jResultRole,
|
2127 mark.hamzy 1.32 JMPI_INCLUDE_QUALIFIERS,
2128 request->includeClassOrigin,
|
2129 mark.hamzy 1.24 jPropertyList);
|
2130 mark.hamzy 1.25
|
2131 mark.hamzy 1.23 JMPIjvm::checkException(env);
2132
2133 STAT_PMS_PROVIDEREND;
2134
2135 handler.processing();
|
2136 mark.hamzy 1.24 if (jVec) {
|
2137 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
2138 mark.hamzy 1.23 JMPIjvm::checkException(env);
2139
|
2140 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
2141 mark.hamzy 1.24
|
2142 mark.hamzy 1.23 JMPIjvm::checkException(env);
2143
|
2144 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
2145 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
2146 CIMClass cls = pr._cimom_handle->getClass(context,
2147 request->nameSpace,
2148 ciRet->getClassName(),
2149 false,
2150 true,
2151 true,
2152 CIMPropertyList());
2153 const CIMObjectPath& op = ciRet->getPath();
2154 CIMObjectPath iop = ciRet->buildPath(cls);
|
2155 mark.hamzy 1.24
|
2156 mark.hamzy 1.27 JMPIjvm::checkException(env);
2157
|
2158 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
2159 mark.hamzy 1.29 ciRet->setPath(iop);
|
2160 schuur 1.13
|
2161 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2162 mark.hamzy 1.23 }
2163 }
|
2164 mark.hamzy 1.24 handler.complete();
2165 break;
2166 }
2167
2168 case METHOD_UNKNOWN:
2169 {
2170 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));
2171 break;
2172 }
|
2173 mark.hamzy 1.23 }
|
2174 schuur 1.1 }
2175 HandlerCatch(handler);
|
2176 schuur 1.13
2177 if (env) JMPIjvm::detachThread();
2178
|
2179 schuur 1.1 PEG_METHOD_EXIT();
2180
|
2181 w.white 1.31 STAT_COPYDISPATCHER
2182
|
2183 schuur 1.1 return(response);
2184 }
|
2185 schuur 1.13
|
2186 schuur 1.1 Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()
2187 {
|
2188 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest");
2189
2190 HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>());
|
2191 schuur 1.1
|
2192 mark.hamzy 1.24 typedef enum {
2193 METHOD_UNKNOWN = 0,
|
2194 mark.hamzy 1.25 METHOD_PEGASUS_24,
|
2195 mark.hamzy 1.24 METHOD_SNIA_PROVIDER20
2196 } METHOD_VERSION;
2197 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2198 JNIEnv *env = NULL;
|
2199 schuur 1.13
|
2200 schuur 1.1 try {
2201 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2202 "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2",
2203 System::getHostName(),
2204 request->nameSpace.getString(),
2205 request->objectName.getClassName().getString());
2206
|
2207 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));
|
2208 mark.hamzy 1.23
|
2209 schuur 1.1 // make target object path
|
2210 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2211 request->nameSpace,
2212 request->objectName.getClassName(),
2213 request->objectName.getKeyBindings());
2214 CIMObjectPath *assocPath = new CIMObjectPath (System::getHostName(),
2215 request->nameSpace,
2216 request->assocClass.getString());
|
2217 mark.hamzy 1.23
|
2218 schuur 1.1 // resolve provider name
|
2219 kumpf 1.2 ProviderName name = _resolveProviderName(
2220 request->operationContext.get(ProviderIdContainer::NAME));
|
2221 schuur 1.1
2222 // get cached or load new provider module
2223 JMPIProvider::OpProviderHolder ph =
2224 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2225
2226 // convert arguments
2227 OperationContext context;
2228
|
2229 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
2230 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2231 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
2232 schuur 1.1
2233 // forward request
|
2234 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
2235 schuur 1.1
|
2236 mark.hamzy 1.24 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName());
|
2237 schuur 1.1
|
2238 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: Calling provider associatorNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
|
2239 schuur 1.1
|
2240 mark.hamzy 1.24 JvmVector *jv = 0;
2241
2242 env = JMPIjvm::attachThread(&jv);
|
2243 schuur 1.1
2244 JMPIProvider::pm_service_op_lock op_lock(&pr);
2245
2246 STAT_GETSTARTTIME;
2247
|
2248 mark.hamzy 1.24 jmethodID id = NULL;
2249
2250 // public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
|
2251 mark.hamzy 1.25 // org.pegasus.jmpi.CIMObjectPath pathName,
|
2252 mark.hamzy 1.24 // java.lang.String resultClass,
2253 // java.lang.String role,
2254 // java.lang.String resultRole)
2255 // throws org.pegasus.jmpi.CIMException
2256 id = env->GetMethodID((jclass)pr.jProviderClass,
2257 "associatorNames",
|
2258 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
2259 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;"
|
2260 mark.hamzy 1.24
2261 if (id != NULL)
2262 {
|
2263 mark.hamzy 1.25 eMethodFound = METHOD_SNIA_PROVIDER20;
2264 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
2265 mark.hamzy 1.24 }
2266
2267 if (id == NULL)
2268 {
2269 env->ExceptionClear();
2270
2271 // public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
2272 // java.lang.String resultClass,
2273 // java.lang.String role,
2274 // java.lang.String resultRole)
2275 // throws org.pegasus.jmpi.CIMException
2276 id = env->GetMethodID((jclass)pr.jProviderClass,
2277 "associatorNames",
|
2278 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
2279 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"
|
2280 mark.hamzy 1.24
2281 if (id != NULL)
2282 {
|
2283 mark.hamzy 1.25 eMethodFound = METHOD_PEGASUS_24;
2284 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
|
2285 mark.hamzy 1.24 }
2286 }
|
2287 schuur 1.13
|
2288 mark.hamzy 1.24 if (id == NULL)
2289 {
2290 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl));
|
2291 mark.hamzy 1.23 }
|
2292 mark.hamzy 1.24
|
2293 schuur 1.1 JMPIjvm::checkException(env);
2294
|
2295 mark.hamzy 1.24 switch (eMethodFound)
2296 {
|
2297 mark.hamzy 1.25 case METHOD_PEGASUS_24:
|
2298 mark.hamzy 1.24 {
|
2299 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
2300 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2301
2302 JMPIjvm::checkException(env);
2303
2304 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
2305 jstring jRole = env->NewStringUTF(request->role.getCString());
2306 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
2307
2308 JMPIjvm::checkException(env);
2309
|
2310 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2311 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
2312 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
2313 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
2314 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
2315 #endif
2316
|
2317 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2318 id,
2319 jAssociationName,
2320 jResultClass,
2321 jRole,
2322 jResultRole);
|
2323 mark.hamzy 1.25
|
2324 mark.hamzy 1.23 JMPIjvm::checkException(env);
2325
2326 STAT_PMS_PROVIDEREND;
2327
2328 handler.processing();
2329 if (jVec) {
|
2330 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
2331 mark.hamzy 1.23 JMPIjvm::checkException(env);
2332
|
2333 mark.hamzy 1.29 jobject jcopRet = env->GetObjectArrayElement(jVec,i);
|
2334 mark.hamzy 1.24
|
2335 mark.hamzy 1.23 JMPIjvm::checkException(env);
2336
|
2337 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
2338 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRet);
|
2339 mark.hamzy 1.23
2340 JMPIjvm::checkException(env);
2341
|
2342 mark.hamzy 1.29 handler.deliver(*copRet);
|
2343 mark.hamzy 1.23 }
2344 }
2345 handler.complete();
|
2346 mark.hamzy 1.24 break;
|
2347 mark.hamzy 1.23 }
|
2348 mark.hamzy 1.24
2349 case METHOD_SNIA_PROVIDER20:
2350 {
|
2351 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, assocPath);
|
2352 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2353
2354 JMPIjvm::checkException(env);
2355
|
2356 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
2357 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
2358
2359 JMPIjvm::checkException(env);
2360
|
2361 mark.hamzy 1.25 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
2362 jstring jRole = env->NewStringUTF(request->role.getCString());
2363 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
2364
2365 JMPIjvm::checkException(env);
2366
|
2367 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2368 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: assocName = "<<assocPath->toString ()<<PEGASUS_STD(endl));
2369 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
2370 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultClass = "<<request->resultClass<<PEGASUS_STD(endl));
2371 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
2372 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: resultRole = "<<request->resultRole<<PEGASUS_STD(endl));
2373 #endif
2374
|
2375 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2376 id,
2377 jAssociationName,
|
2378 mark.hamzy 1.29 jPathName,
|
2379 mark.hamzy 1.24 jResultClass,
2380 jRole,
2381 jResultRole);
|
2382 mark.hamzy 1.25
|
2383 mark.hamzy 1.23 JMPIjvm::checkException(env);
2384
2385 STAT_PMS_PROVIDEREND;
|
2386 schuur 1.13
|
2387 mark.hamzy 1.23 handler.processing();
|
2388 mark.hamzy 1.24 if (jVec) {
|
2389 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
2390 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2391 schuur 1.13
|
2392 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
2393 mark.hamzy 1.24
|
2394 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2395 schuur 1.13
|
2396 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
2397 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
2398 schuur 1.1
|
2399 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2400 schuur 1.1
|
2401 mark.hamzy 1.29 handler.deliver(*copRet);
|
2402 mark.hamzy 1.23 }
2403 }
2404 handler.complete();
|
2405 mark.hamzy 1.24 break;
2406 }
2407
2408 case METHOD_UNKNOWN:
2409 {
2410 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: should not be here!"<<PEGASUS_STD(endl));
2411 break;
2412 }
|
2413 mark.hamzy 1.23 }
|
2414 schuur 1.1 }
2415 HandlerCatch(handler);
|
2416 schuur 1.12
|
2417 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
|
2418 schuur 1.12
|
2419 schuur 1.1 PEG_METHOD_EXIT();
2420
|
2421 w.white 1.31 STAT_COPYDISPATCHER
2422
|
2423 schuur 1.1 return(response);
2424 }
2425
2426 Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw()
2427 {
|
2428 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest");
2429
2430 HandlerIntro(References,message,request,response,handler,Array<CIMObject>());
|
2431 schuur 1.1
|
2432 mark.hamzy 1.24 typedef enum {
2433 METHOD_UNKNOWN = 0,
|
2434 mark.hamzy 1.25 METHOD_PEGASUS_24,
|
2435 mark.hamzy 1.24 METHOD_SNIA_PROVIDER20,
2436 } METHOD_VERSION;
2437 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2438 JNIEnv *env = NULL;
|
2439 schuur 1.13
|
2440 schuur 1.1 try {
2441 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
2442 konrad.r 1.15 "JMPIProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",
|
2443 schuur 1.1 System::getHostName(),
2444 request->nameSpace.getString(),
2445 request->objectName.getClassName().getString());
2446
|
2447 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));
|
2448 mark.hamzy 1.23
|
2449 schuur 1.1 // make target object path
|
2450 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2451 request->nameSpace,
2452 request->objectName.getClassName(),
2453 request->objectName.getKeyBindings());
2454 CIMObjectPath *resultPath = new CIMObjectPath (System::getHostName(),
2455 request->nameSpace,
2456 request->resultClass.getString());
|
2457 schuur 1.1
2458 // resolve provider name
|
2459 kumpf 1.2 ProviderName name = _resolveProviderName(
2460 request->operationContext.get(ProviderIdContainer::NAME));
|
2461 schuur 1.1
2462 // get cached or load new provider module
2463 JMPIProvider::OpProviderHolder ph =
2464 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2465
2466 // convert arguments
2467 OperationContext context;
2468
|
2469 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
2470 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2471 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
2472 schuur 1.1
2473 // forward request
|
2474 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
2475
2476 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.references: " + pr.getName());
|
2477 schuur 1.1
|
2478 mark.hamzy 1.24 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Calling provider references: "<<pr.getName()<<", role: "<<request->role<<" aCls: "<<request->resultClass<<PEGASUS_STD(endl));
|
2479 schuur 1.1
|
2480 mark.hamzy 1.24 JvmVector *jv = 0;
|
2481 schuur 1.1
|
2482 mark.hamzy 1.24 env = JMPIjvm::attachThread(&jv);
|
2483 schuur 1.1
2484 JMPIProvider::pm_service_op_lock op_lock(&pr);
2485
2486 STAT_GETSTARTTIME;
2487
|
2488 mark.hamzy 1.24 jmethodID id = NULL;
2489
2490 // public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,
|
2491 mark.hamzy 1.25 // org.pegasus.jmpi.CIMObjectPath pathName,
|
2492 mark.hamzy 1.24 // java.lang.String role,
2493 // boolean includeQualifiers,
2494 // boolean includeClassOrigin,
2495 // java.lang.String[] propertyList)
2496 // throws org.pegasus.jmpi.CIMException
2497 id = env->GetMethodID((jclass)pr.jProviderClass,
2498 "references",
|
2499 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
2500 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;"
|
2501 mark.hamzy 1.24
2502 if (id != NULL)
2503 {
|
2504 mark.hamzy 1.25 eMethodFound = METHOD_SNIA_PROVIDER20;
2505 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
2506 mark.hamzy 1.24 }
2507
2508 if (id == NULL)
2509 {
2510 env->ExceptionClear();
2511
2512 // public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,
2513 // java.lang.String role,
2514 // boolean includeQualifiers,
2515 // boolean includeClassOrigin,
2516 // java.lang.String[] propertyList)
2517 // throws org.pegasus.jmpi.CIMException
2518 id = env->GetMethodID((jclass)pr.jProviderClass,
2519 "references",
|
2520 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
2521 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;"
|
2522 mark.hamzy 1.24
2523 if (id != NULL)
2524 {
|
2525 mark.hamzy 1.25 eMethodFound = METHOD_PEGASUS_24;
2526 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
|
2527 mark.hamzy 1.24 }
2528 }
|
2529 schuur 1.12
|
2530 mark.hamzy 1.24 if (id == NULL)
2531 {
|
2532 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: found no method!"<<PEGASUS_STD(endl));
|
2533 mark.hamzy 1.23 }
|
2534 mark.hamzy 1.24
|
2535 schuur 1.1 JMPIjvm::checkException(env);
2536
|
2537 mark.hamzy 1.24 switch (eMethodFound)
2538 {
|
2539 mark.hamzy 1.25 case METHOD_PEGASUS_24:
|
2540 mark.hamzy 1.24 {
|
2541 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
2542 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2543
2544 JMPIjvm::checkException(env);
2545
2546 jstring jRole = env->NewStringUTF(request->role.getCString());
2547
2548 JMPIjvm::checkException(env);
2549
2550 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
2551
|
2552 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2553 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
2554 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
2555 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
2556 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
2557 #endif
2558
|
2559 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2560 id,
2561 jAssociationName,
2562 jRole,
2563 false,
2564 false,
2565 jPropertyList);
|
2566 mark.hamzy 1.25
|
2567 mark.hamzy 1.23 JMPIjvm::checkException(env);
2568
2569 STAT_PMS_PROVIDEREND;
2570
2571 handler.processing();
2572 if (jVec) {
|
2573 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
2574 mark.hamzy 1.23 JMPIjvm::checkException(env);
2575
|
2576 mark.hamzy 1.29 jobject jciRet = env->GetObjectArrayElement(jVec,i);
|
2577 mark.hamzy 1.24
|
2578 mark.hamzy 1.23 JMPIjvm::checkException(env);
2579
|
2580 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
|
2581 mark.hamzy 1.23
2582 JMPIjvm::checkException(env);
2583
|
2584 mark.hamzy 1.29 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
2585 CIMClass cls = pr._cimom_handle->getClass(context,
2586 request->nameSpace,
2587 ciRet->getClassName(),
2588 false,
2589 true,
2590 true,
2591 CIMPropertyList());
2592 const CIMObjectPath& op = ciRet->getPath();
2593 CIMObjectPath iop = ciRet->buildPath(cls);
|
2594 mark.hamzy 1.24
|
2595 mark.hamzy 1.27 JMPIjvm::checkException(env);
2596
|
2597 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
|
2598 mark.hamzy 1.29 ciRet->setPath(iop);
|
2599 schuur 1.13
|
2600 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2601 mark.hamzy 1.23 }
2602 }
2603 handler.complete();
|
2604 mark.hamzy 1.24 break;
|
2605 mark.hamzy 1.23 }
|
2606 schuur 1.1
|
2607 mark.hamzy 1.24 case METHOD_SNIA_PROVIDER20:
2608 {
|
2609 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
2610 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2611
2612 JMPIjvm::checkException(env);
2613
|
2614 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
2615 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
2616
2617 JMPIjvm::checkException(env);
2618
|
2619 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
2620
2621 JMPIjvm::checkException(env);
2622
2623 jobjectArray jPropertyList = getList(jv,env,request->propertyList);
2624
|
2625 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2626 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: assocName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
2627 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: pathName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
2628 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: role = "<<request->role<<PEGASUS_STD(endl));
2629 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeQualifiers = "<<false<<PEGASUS_STD(endl));
2630 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferencesRequest: includeClassOrigin = "<<false<<PEGASUS_STD(endl));
2631 #endif
2632
|
2633 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2634 id,
2635 jAssociationName,
2636 jPathName,
2637 jRole,
|
2638 mark.hamzy 1.32 JMPI_INCLUDE_QUALIFIERS,
2639 request->includeClassOrigin,
|
2640 mark.hamzy 1.24 jPropertyList);
|
2641 mark.hamzy 1.25
|
2642 mark.hamzy 1.24 JMPIjvm::checkException(env);
2643
2644 STAT_PMS_PROVIDEREND;
2645
2646 handler.processing();
2647 if (jVec) {
|
2648 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
2649 mark.hamzy 1.24 JMPIjvm::checkException(env);
2650
|
2651 mark.hamzy 1.29 jobject jciRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
2652 mark.hamzy 1.24
2653 JMPIjvm::checkException(env);
2654
|
2655 mark.hamzy 1.29 jint jciRetRef = env->CallIntMethod(jciRet,JMPIjvm::jv.CIMInstanceCInst);
2656 CIMInstance *ciRet = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciRetRef);
2657 CIMClass cls = pr._cimom_handle->getClass(context,
2658 request->nameSpace,
2659 ciRet->getClassName(),
2660 false,
2661 true,
2662 true,
2663 CIMPropertyList());
2664 const CIMObjectPath& op = ciRet->getPath();
2665 CIMObjectPath iop = ciRet->buildPath(cls);
|
2666 schuur 1.1
|
2667 mark.hamzy 1.27 JMPIjvm::checkException(env);
2668
|
2669 mark.hamzy 1.24 iop.setNameSpace(op.getNameSpace());
|
2670 mark.hamzy 1.29 ciRet->setPath(iop);
|
2671 schuur 1.12
|
2672 mark.hamzy 1.29 handler.deliver(*ciRet);
|
2673 mark.hamzy 1.24 }
2674 }
2675 handler.complete();
2676 break;
2677 }
|
2678 mark.hamzy 1.23
|
2679 mark.hamzy 1.24 case METHOD_UNKNOWN:
2680 {
|
2681 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: should not be here!"<<PEGASUS_STD(endl));
|
2682 mark.hamzy 1.24 break;
2683 }
|
2684 mark.hamzy 1.23 }
|
2685 schuur 1.1 }
2686 HandlerCatch(handler);
|
2687 schuur 1.12
2688 if (env) JMPIjvm::detachThread();
2689
|
2690 schuur 1.1 PEG_METHOD_EXIT();
2691
|
2692 w.white 1.31 STAT_COPYDISPATCHER
2693
|
2694 schuur 1.1 return(response);
2695 }
2696
2697 Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw()
2698 {
|
2699 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest");
2700
2701 HandlerIntro(ReferenceNames,message,request,response,handler,Array<CIMObjectPath>());
|
2702 schuur 1.1
|
2703 mark.hamzy 1.24 typedef enum {
2704 METHOD_UNKNOWN = 0,
|
2705 mark.hamzy 1.25 METHOD_PEGASUS_24,
|
2706 mark.hamzy 1.24 METHOD_SNIA_PROVIDER20,
2707 } METHOD_VERSION;
2708 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2709 JNIEnv *env = NULL;
|
2710 schuur 1.13
|
2711 schuur 1.1 try {
2712 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2713 "JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
2714 System::getHostName(),
2715 request->nameSpace.getString(),
2716 request->objectName.getClassName().getString());
2717
|
2718 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));
2719
|
2720 schuur 1.1 // make target object path
|
2721 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2722 request->nameSpace,
2723 request->objectName.getClassName(),
2724 request->objectName.getKeyBindings());
2725 CIMObjectPath *resultPath = new CIMObjectPath (System::getHostName(),
2726 request->nameSpace,
2727 request->resultClass.getString());
|
2728 schuur 1.1
2729 // resolve provider name
|
2730 kumpf 1.2 ProviderName name = _resolveProviderName(
2731 request->operationContext.get(ProviderIdContainer::NAME));
|
2732 schuur 1.1
2733 // get cached or load new provider module
2734 JMPIProvider::OpProviderHolder ph =
2735 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2736
2737 // convert arguments
2738 OperationContext context;
2739
|
2740 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
2741 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2742 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
2743 schuur 1.1
|
2744 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
2745 schuur 1.1
|
2746 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.referenceNames: " + pr.getName());
|
2747 schuur 1.1
|
2748 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: Calling provider referenceNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->resultClass<<PEGASUS_STD(endl));
|
2749 schuur 1.12
|
2750 mark.hamzy 1.24 JvmVector *jv = 0;
2751
2752 env = JMPIjvm::attachThread(&jv);
|
2753 schuur 1.1
2754 JMPIProvider::pm_service_op_lock op_lock(&pr);
2755
2756 STAT_GETSTARTTIME;
2757
|
2758 mark.hamzy 1.24 jmethodID id = NULL;
2759
2760 // public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
|
2761 mark.hamzy 1.25 // org.pegasus.jmpi.CIMObjectPath pathName,
|
2762 mark.hamzy 1.24 // java.lang.String role)
|
2763 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
|
2764 mark.hamzy 1.24 id = env->GetMethodID((jclass)pr.jProviderClass,
2765 "referenceNames",
|
2766 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
2767 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath; Ljava/lang/String;)Ljava/util/Vector;"
|
2768 mark.hamzy 1.24
2769 if (id != NULL)
2770 {
|
2771 mark.hamzy 1.25 eMethodFound = METHOD_SNIA_PROVIDER20;
2772 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
|
2773 mark.hamzy 1.24 }
2774
2775 if (id == NULL)
2776 {
2777 env->ExceptionClear();
2778
2779 // public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
2780 // java.lang.String role)
|
2781 mark.hamzy 1.25 // throws org.pegasus.jmpi.CIMException
|
2782 mark.hamzy 1.24 id = env->GetMethodID((jclass)pr.jProviderClass,
2783 "referenceNames",
|
2784 mark.hamzy 1.25 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
2785 //@BUG was: "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;"
|
2786 mark.hamzy 1.24
2787 if (id != NULL)
2788 {
|
2789 mark.hamzy 1.25 eMethodFound = METHOD_PEGASUS_24;
2790 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
|
2791 mark.hamzy 1.24 }
2792 }
|
2793 schuur 1.11
|
2794 mark.hamzy 1.24 if (id == NULL)
2795 {
|
2796 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: found no method!"<<PEGASUS_STD(endl));
|
2797 mark.hamzy 1.23 }
|
2798 mark.hamzy 1.24
|
2799 schuur 1.1 JMPIjvm::checkException(env);
2800
|
2801 mark.hamzy 1.24 switch (eMethodFound)
2802 {
|
2803 mark.hamzy 1.25 case METHOD_PEGASUS_24:
|
2804 mark.hamzy 1.24 {
|
2805 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
2806 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2807
2808 JMPIjvm::checkException(env);
2809
2810 jstring jRole = env->NewStringUTF(request->role.getCString());
2811
2812 JMPIjvm::checkException(env);
2813
|
2814 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2815 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
2816 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
2817 #endif
2818
|
2819 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2820 id,
2821 jAssociationName,
2822 jRole);
|
2823 mark.hamzy 1.25
|
2824 mark.hamzy 1.23 JMPIjvm::checkException(env);
2825
2826 STAT_PMS_PROVIDEREND;
2827
2828 handler.processing();
2829 if (jVec) {
|
2830 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
2831 mark.hamzy 1.23 JMPIjvm::checkException(env);
2832
|
2833 mark.hamzy 1.29 jobject jcopRet = env->GetObjectArrayElement(jVec,i);
|
2834 mark.hamzy 1.24
|
2835 mark.hamzy 1.23 JMPIjvm::checkException(env);
2836
|
2837 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
2838 mark.hamzy 1.23
2839 JMPIjvm::checkException(env);
2840
|
2841 mark.hamzy 1.29 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
2842 mark.hamzy 1.24
|
2843 mark.hamzy 1.29 handler.deliver(*copRet);
|
2844 mark.hamzy 1.23 }
2845 }
2846 handler.complete();
|
2847 mark.hamzy 1.24 break;
|
2848 mark.hamzy 1.23 }
|
2849 mark.hamzy 1.24
2850 case METHOD_SNIA_PROVIDER20:
2851 {
|
2852 mark.hamzy 1.29 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, resultPath);
|
2853 mark.hamzy 1.25 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
2854
2855 JMPIjvm::checkException(env);
2856
|
2857 mark.hamzy 1.29 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
2858 mark.hamzy 1.24 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
2859
2860 JMPIjvm::checkException(env);
2861
|
2862 mark.hamzy 1.25 jstring jRole = env->NewStringUTF(request->role.getCString());
2863
2864 JMPIjvm::checkException(env);
2865
|
2866 mark.hamzy 1.29 #ifdef PEGASUS_DEBUG
2867 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: assocName = "<<objectPath->toString ()<<PEGASUS_STD(endl));
2868 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: pathName = "<<resultPath->toString ()<<PEGASUS_STD(endl));
2869 DDD(PEGASUS_STD(cerr)<<"--- JMPIProviderManager::handleReferenceNamesRequest: role = "<<request->role<<PEGASUS_STD(endl));
2870 #endif
2871
|
2872 mark.hamzy 1.24 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
2873 id,
2874 jAssociationName,
2875 jPathName,
2876 jRole);
|
2877 mark.hamzy 1.25
|
2878 mark.hamzy 1.23 JMPIjvm::checkException(env);
2879
2880 STAT_PMS_PROVIDEREND;
|
2881 schuur 1.13
|
2882 mark.hamzy 1.23 handler.processing();
|
2883 mark.hamzy 1.24 if (jVec) {
|
2884 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
|
2885 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2886 schuur 1.13
|
2887 mark.hamzy 1.29 jobject jcopRet = env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
|
2888 mark.hamzy 1.24
|
2889 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2890 schuur 1.13
|
2891 mark.hamzy 1.29 jint jcopRetRef = env->CallIntMethod(jcopRet,JMPIjvm::jv.CIMObjectPathCInst);
|
2892 schuur 1.1
|
2893 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2894 schuur 1.1
|
2895 mark.hamzy 1.29 CIMObjectPath *copRet = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jcopRetRef);
|
2896 mark.hamzy 1.24
|
2897 mark.hamzy 1.29 handler.deliver(*copRet);
|
2898 mark.hamzy 1.23 }
2899 }
2900 handler.complete();
|
2901 mark.hamzy 1.24 break;
2902 }
2903
2904 case METHOD_UNKNOWN:
2905 {
|
2906 mark.hamzy 1.25 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: should not be here!"<<PEGASUS_STD(endl));
|
2907 mark.hamzy 1.24 break;
2908 }
|
2909 mark.hamzy 1.23 }
|
2910 schuur 1.1 }
2911 HandlerCatch(handler);
|
2912 schuur 1.11
2913 if (env) JMPIjvm::detachThread();
2914
|
2915 schuur 1.1 PEG_METHOD_EXIT();
2916
|
2917 w.white 1.31 STAT_COPYDISPATCHER
2918
|
2919 schuur 1.1 return(response);
2920 }
2921
|
2922 mark.hamzy 1.26 Message * JMPIProviderManager::handleGetPropertyRequest(const Message * message) throw()
2923 {
2924 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetPropertyRequest");
2925
2926 HandlerIntro(GetProperty,message,request,response,handler,CIMValue());
2927
2928 typedef enum {
2929 METHOD_UNKNOWN = 0,
2930 METHOD_SNIA_PROVIDER20,
2931 } METHOD_VERSION;
2932 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
2933 JNIEnv *env = NULL;
2934
2935 try {
2936 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2937 "JMPIProviderManager::handleGetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
2938 System::getHostName(),
2939 request->nameSpace.getString(),
2940 request->instanceName.getClassName().getString());
2941
2942 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
2943 mark.hamzy 1.26
2944 // make target object path
|
2945 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
2946 request->nameSpace,
2947 request->instanceName.getClassName(),
2948 request->instanceName.getKeyBindings());
|
2949 mark.hamzy 1.26
2950 // resolve provider name
2951 ProviderName name = _resolveProviderName(
2952 request->operationContext.get(ProviderIdContainer::NAME));
2953
2954 // get cached or load new provider module
2955 JMPIProvider::OpProviderHolder ph =
2956 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
2957
2958 // convert arguments
2959 OperationContext context;
2960
2961 context.insert(request->operationContext.get(IdentityContainer::NAME));
2962 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2963 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
2964
2965 // forward request
2966 JMPIProvider &pr = ph.GetProvider();
2967
2968 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.getPropertyValue: " + pr.getName());
2969
2970 mark.hamzy 1.26 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: Calling provider getPropertyValue: "<<pr.getName()<<PEGASUS_STD(endl));
2971
2972 JvmVector *jv = 0;
2973
2974 env = JMPIjvm::attachThread(&jv);
2975
2976 JMPIProvider::pm_service_op_lock op_lock(&pr);
2977
2978 STAT_GETSTARTTIME;
2979
2980 jmethodID id = NULL;
2981
2982 // public abstract org.pegasus.jmpi.CIMValue getPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
2983 // java.lang.String oclass,
2984 // java.lang.String pName)
2985 // throws org.pegasus.jmpi.CIMException
2986 //
2987 id = env->GetMethodID((jclass)pr.jProviderClass,
2988 "getPropertyValue",
2989 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;)Lorg/pegasus/jmpi/CIMValue;");
2990
2991 mark.hamzy 1.26 if (id != NULL)
2992 {
2993 eMethodFound = METHOD_SNIA_PROVIDER20;
2994 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
2995 }
2996
2997 if (id == NULL)
2998 {
2999 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
3000 }
3001
3002 JMPIjvm::checkException(env);
3003
3004 switch (eMethodFound)
3005 {
3006 case METHOD_SNIA_PROVIDER20:
3007 {
|
3008 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3009 mark.hamzy 1.26 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
3010
3011 JMPIjvm::checkException(env);
3012
3013 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
3014
3015 JMPIjvm::checkException(env);
3016
3017 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
3018
3019 JMPIjvm::checkException(env);
3020
3021 STAT_GETSTARTTIME;
3022
|
3023 mark.hamzy 1.29 jobject jvalRet = env->CallObjectMethod ((jobject)pr.jProvider,
3024 id,
3025 jcop,
3026 joclass,
3027 jpName);
|
3028 mark.hamzy 1.26
3029 JMPIjvm::checkException(env);
3030
3031 STAT_PMS_PROVIDEREND;
3032
3033 handler.processing();
3034
|
3035 mark.hamzy 1.29 if (jvalRet)
|
3036 mark.hamzy 1.26 {
|
3037 mark.hamzy 1.29 jint jvalRetRef = env->CallIntMethod(jvalRet,JMPIjvm::jv.CIMValueCInst);
3038 CIMValue *valRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jvalRetRef);
|
3039 mark.hamzy 1.26
3040 JMPIjvm::checkException(env);
3041
|
3042 mark.hamzy 1.29 handler.deliver(*valRet);
|
3043 mark.hamzy 1.26 }
3044 handler.complete();
3045 break;
3046 }
3047
3048 case METHOD_UNKNOWN:
3049 {
3050 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetPropertyRequest: should not be here!"<<PEGASUS_STD(endl));
3051 break;
3052 }
3053 }
3054 }
3055 HandlerCatch(handler);
3056
3057 if (env) JMPIjvm::detachThread();
3058
3059 PEG_METHOD_EXIT();
3060
|
3061 w.white 1.31 STAT_COPYDISPATCHER
3062
|
3063 mark.hamzy 1.26 return(response);
3064 }
3065
3066 Message * JMPIProviderManager::handleSetPropertyRequest(const Message * message) throw()
3067 {
3068 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleSetPropertyRequest");
3069
3070 HandlerIntroVoid(SetProperty,message,request,response,handler);
3071
3072 typedef enum {
3073 METHOD_UNKNOWN = 0,
3074 METHOD_SNIA_PROVIDER20,
3075 } METHOD_VERSION;
3076 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3077 JNIEnv *env = NULL;
3078
3079 try {
3080 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3081 "JMPIProviderManager::handleSetPropertyRequest - Host name: $0 Name space: $1 Class name: $2",
3082 System::getHostName(),
3083 request->nameSpace.getString(),
3084 mark.hamzy 1.26 request->instanceName.getClassName().getString());
3085
3086 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
3087
3088 // make target object path
|
3089 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3090 request->nameSpace,
3091 request->instanceName.getClassName(),
3092 request->instanceName.getKeyBindings());
|
3093 mark.hamzy 1.26
3094 // resolve provider name
3095 ProviderName name = _resolveProviderName(
3096 request->operationContext.get(ProviderIdContainer::NAME));
3097
3098 // get cached or load new provider module
3099 JMPIProvider::OpProviderHolder ph =
3100 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
3101
3102 // convert arguments
3103 OperationContext context;
3104
3105 context.insert(request->operationContext.get(IdentityContainer::NAME));
3106 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3107 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
3108
3109 // forward request
3110 JMPIProvider &pr = ph.GetProvider();
3111
3112 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.setPropertyValue: " + pr.getName());
3113
3114 mark.hamzy 1.26 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: Calling provider setPropertyValue: "<<pr.getName()<<PEGASUS_STD(endl));
3115
3116 JvmVector *jv = 0;
3117
3118 env = JMPIjvm::attachThread(&jv);
3119
3120 JMPIProvider::pm_service_op_lock op_lock(&pr);
3121
3122 STAT_GETSTARTTIME;
3123
3124 jmethodID id = NULL;
3125
3126 // public abstract void setPropertyValue (org.pegasus.jmpi.CIMObjectPath cop,
3127 // java.lang.String oclass,
3128 // java.lang.String pName,
3129 // org.pegasus.jmpi.CIMValue val)
3130 // throws org.pegasus.jmpi.CIMException
3131 //
3132 id = env->GetMethodID((jclass)pr.jProviderClass,
3133 "setPropertyValue",
3134 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Lorg/pegasus/jmpi/CIMValue;)V");
3135 mark.hamzy 1.26
3136 if (id != NULL)
3137 {
3138 eMethodFound = METHOD_SNIA_PROVIDER20;
3139 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
3140 }
3141
3142 if (id == NULL)
3143 {
3144 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: found no method!"<<PEGASUS_STD(endl));
3145 }
3146
3147 JMPIjvm::checkException(env);
3148
3149 switch (eMethodFound)
3150 {
3151 case METHOD_SNIA_PROVIDER20:
3152 {
|
3153 mark.hamzy 1.27 jint jcopref = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
|
3154 mark.hamzy 1.26 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef, jv->CIMObjectPathNewI, jcopref);
3155
3156 JMPIjvm::checkException(env);
3157
3158 jstring joclass = env->NewStringUTF(request->instanceName.getClassName().getString().getCString());
3159
3160 JMPIjvm::checkException(env);
3161
3162 jstring jpName = env->NewStringUTF(request->propertyName.getString().getCString());
3163
3164 JMPIjvm::checkException(env);
3165
|
3166 mark.hamzy 1.27 CIMValue *val = new CIMValue (request->newValue);
|
3167 mark.hamzy 1.26
3168 JMPIjvm::checkException(env);
3169
|
3170 mark.hamzy 1.27 jint jvalref = DEBUG_ConvertCToJava (CIMValue*, jint, val);
|
3171 mark.hamzy 1.26 jobject jval = env->NewObject(jv->CIMValueClassRef, jv->CIMValueNewI, jvalref);
3172
3173 JMPIjvm::checkException(env);
3174
3175 STAT_GETSTARTTIME;
3176
3177 env->CallVoidMethod ((jobject)pr.jProvider,
3178 id,
3179 jcop,
3180 joclass,
3181 jpName,
3182 jval);
3183
3184 JMPIjvm::checkException(env);
3185
3186 STAT_PMS_PROVIDEREND;
3187 break;
3188 }
3189
3190 case METHOD_UNKNOWN:
3191 {
3192 mark.hamzy 1.26 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleSetPropertyRequest: should not be here!"<<PEGASUS_STD(endl));
3193 break;
3194 }
3195 }
3196 }
3197 HandlerCatch(handler);
3198
3199 if (env) JMPIjvm::detachThread();
3200
3201 PEG_METHOD_EXIT();
3202
|
3203 w.white 1.31 STAT_COPYDISPATCHER
3204
|
3205 mark.hamzy 1.26 return(response);
3206 }
3207
|
3208 schuur 1.1 Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw()
3209 {
|
3210 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest");
3211
3212 HandlerIntroMethod(InvokeMethod,message,request,response,handler);
|
3213 schuur 1.1
|
3214 mark.hamzy 1.25 typedef enum {
3215 METHOD_UNKNOWN = 0,
3216 METHOD_PEGASUS_24,
3217 METHOD_SNIA_PROVIDER20,
3218 } METHOD_VERSION;
3219 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3220 JNIEnv *env = NULL;
|
3221 schuur 1.13
|
3222 schuur 1.1 try {
3223 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3224 "JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",
3225 System::getHostName(),
3226 request->nameSpace.getString(),
3227 request->instanceName.getClassName().getString());
3228
|
3229 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));
3230
|
3231 schuur 1.1 // make target object path
|
3232 mark.hamzy 1.27 CIMObjectPath *objectPath = new CIMObjectPath (System::getHostName(),
3233 request->nameSpace,
3234 request->instanceName.getClassName(),
3235 request->instanceName.getKeyBindings());
|
3236 schuur 1.1
3237 // resolve provider name
|
3238 kumpf 1.2 ProviderName name = _resolveProviderName(
3239 request->operationContext.get(ProviderIdContainer::NAME));
|
3240 schuur 1.1
3241 // get cached or load new provider module
3242 JMPIProvider::OpProviderHolder ph =
3243 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
3244
3245 // convert arguments
3246 OperationContext context;
3247
|
3248 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
3249 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3250 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
3251 schuur 1.1
|
3252 mark.hamzy 1.25 JMPIProvider &pr=ph.GetProvider();
|
3253 schuur 1.1
|
3254 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.invokeMethod: " + pr.getName());
|
3255 schuur 1.1
|
3256 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: Calling provider invokeMethod: "<<pr.getName()<<PEGASUS_STD(endl));
|
3257 schuur 1.11
|
3258 mark.hamzy 1.25 JvmVector *jv = 0;
|
3259 mark.hamzy 1.23
|
3260 mark.hamzy 1.25 env = JMPIjvm::attachThread(&jv);
|
3261 schuur 1.11
|
3262 mark.hamzy 1.25 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
3263 schuur 1.11
|
3264 schuur 1.1 STAT_GETSTARTTIME;
3265
|
3266 mark.hamzy 1.25 jmethodID id = NULL;
3267
3268 // public abstract org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath cop,
3269 // java.lang.String name,
3270 // java.util.Vector in,
3271 // java.util.Vector out)
3272 // throws org.pegasus.jmpi.CIMException
3273 id = env->GetMethodID((jclass)pr.jProviderClass,
3274 "invokeMethod",
3275 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
3276
3277 if (id != NULL)
3278 {
3279 eMethodFound = METHOD_SNIA_PROVIDER20;
3280 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
3281 }
3282
3283 if (id == NULL)
3284 {
3285 env->ExceptionClear();
3286
3287 mark.hamzy 1.25 // public org.pegasus.jmpi.CIMValue invokeMethod (org.pegasus.jmpi.CIMObjectPath op,
3288 // java.lang.String methodName,
3289 // org.pegasus.jmpi.CIMArgument[] inArgs,
3290 // org.pegasus.jmpi.CIMArgument[] outArgs)
3291 // throws org.pegasus.jmpi.CIMException
3292 id = env->GetMethodID((jclass)pr.jProviderClass,
3293 "invokeMethod",
3294 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
3295
3296 if (id != NULL)
3297 {
3298 eMethodFound = METHOD_PEGASUS_24;
3299 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: found METHOD_PEGASUS_24."<<PEGASUS_STD(endl));
3300 }
|
3301 mark.hamzy 1.23 }
|
3302 mark.hamzy 1.25
|
3303 schuur 1.11 JMPIjvm::checkException(env);
3304
|
3305 mark.hamzy 1.25 switch (eMethodFound)
3306 {
3307 case METHOD_PEGASUS_24:
3308 {
|
3309 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
3310 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
3311 mark.hamzy 1.25
3312 JMPIjvm::checkException(env);
3313
|
3314 mark.hamzy 1.29 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
3315
|
3316 mark.hamzy 1.23 JMPIjvm::checkException(env);
3317
|
3318 mark.hamzy 1.25 Uint32 m=request->inParameters.size();
3319
3320 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
|
3321 mark.hamzy 1.29
|
3322 mark.hamzy 1.25 for (Uint32 i=0; i<m; i++) {
|
3323 mark.hamzy 1.29 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
3324 jint jArgRef = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);
3325 jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jArgRef);
|
3326 mark.hamzy 1.23
|
3327 mark.hamzy 1.25 env->SetObjectArrayElement(jArIn,i,jArg);
3328 }
|
3329 mark.hamzy 1.23
|
3330 mark.hamzy 1.25 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
|
3331 mark.hamzy 1.23
|
3332 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
3333 id,
3334 jcop,
3335 jMethod,
3336 jArIn,
3337 jArOut);
|
3338 mark.hamzy 1.23 JMPIjvm::checkException(env);
3339
3340 STAT_PMS_PROVIDEREND;
3341
3342 handler.processing();
3343
|
3344 mark.hamzy 1.29 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
3345 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
3346 mark.hamzy 1.23
|
3347 mark.hamzy 1.29 handler.deliver(*valueRet);
|
3348 schuur 1.13
|
3349 mark.hamzy 1.25 for (int i=0; i<24; i++) {
|
3350 mark.hamzy 1.29 jobject jArg = env->GetObjectArrayElement(jArOut,i);
3351
|
3352 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3353 schuur 1.13
|
3354 mark.hamzy 1.29 if (jArg==NULL)
3355 break;
|
3356 schuur 1.13
|
3357 mark.hamzy 1.29 jint jpRef = env->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);
3358 CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jpRef);
|
3359 schuur 1.13
|
3360 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3361 schuur 1.1
|
3362 mark.hamzy 1.25 handler.deliverParamValue(*p);
|
3363 mark.hamzy 1.23 }
|
3364 schuur 1.1
|
3365 mark.hamzy 1.23 handler.complete();
|
3366 mark.hamzy 1.25 break;
|
3367 mark.hamzy 1.23 }
|
3368 schuur 1.11
|
3369 mark.hamzy 1.25 case METHOD_SNIA_PROVIDER20:
3370 {
|
3371 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, objectPath);
3372 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
3373 mark.hamzy 1.25
3374 JMPIjvm::checkException(env);
3375
|
3376 mark.hamzy 1.29 jstring jMethod = env->NewStringUTF(request->methodName.getString().getCString());
3377
|
3378 mark.hamzy 1.25 JMPIjvm::checkException(env);
3379
|
3380 mark.hamzy 1.29 jobject jVecIn = env->NewObject(jv->VectorClassRef,jv->VectorNew);
3381
|
3382 mark.hamzy 1.25 JMPIjvm::checkException(env);
3383
|
3384 mark.hamzy 1.29 for (int i=0,m=request->inParameters.size(); i<m; i++)
3385 {
3386 const CIMParamValue &parm = request->inParameters[i];
3387 const CIMValue v = parm.getValue();
3388 CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
3389 jint jpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
3390 jobject jp = env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jpRef);
|
3391 mark.hamzy 1.23
|
3392 mark.hamzy 1.29 env->CallVoidMethod(jVecIn,jv->VectorAddElement,jp);
|
3393 mark.hamzy 1.25 }
|
3394 mark.hamzy 1.23
|
3395 mark.hamzy 1.25 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
3396 JMPIjvm::checkException(env);
|
3397 mark.hamzy 1.23
|
3398 mark.hamzy 1.29 jobject jValueRet = env->CallObjectMethod((jobject)pr.jProvider,
3399 id,
3400 jcop,
3401 jMethod,
3402 jVecIn,
3403 jVecOut);
|
3404 mark.hamzy 1.23 JMPIjvm::checkException(env);
3405
3406 STAT_PMS_PROVIDEREND;
3407
3408 handler.processing();
|
3409 schuur 1.1
|
3410 mark.hamzy 1.29 jint jValueRetRef = env->CallIntMethod(jValueRet,JMPIjvm::jv.CIMValueCInst);
3411 CIMValue *valueRet = DEBUG_ConvertJavaToC (jint, CIMValue*, jValueRetRef);
|
3412 mark.hamzy 1.23
|
3413 mark.hamzy 1.29 handler.deliver(*valueRet);
|
3414 mark.hamzy 1.23
|
3415 mark.hamzy 1.29 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++)
3416 {
|
3417 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3418 schuur 1.13
|
3419 mark.hamzy 1.29 jobject jProp = env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
3420
|
3421 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
3422 schuur 1.13
|
3423 mark.hamzy 1.29 jint jpRef = env->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);
3424 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jpRef);
|
3425 schuur 1.13
|
3426 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
3427 schuur 1.13
|
3428 mark.hamzy 1.25 handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
3429 }
3430
3431 handler.complete();
3432 break;
3433 }
|
3434 mark.hamzy 1.23
|
3435 mark.hamzy 1.25 case METHOD_UNKNOWN:
3436 {
3437 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: should not be here!"<<PEGASUS_STD(endl));
3438 break;
3439 }
|
3440 mark.hamzy 1.23 }
|
3441 schuur 1.1 }
3442 HandlerCatch(handler);
|
3443 schuur 1.11
3444 if (env) JMPIjvm::detachThread();
3445
|
3446 schuur 1.1 PEG_METHOD_EXIT();
3447
|
3448 w.white 1.31 STAT_COPYDISPATCHER
3449
|
3450 schuur 1.11 return(response);
|
3451 schuur 1.1 }
|
3452 mark.hamzy 1.23
|
3453 schuur 1.1 int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance,
3454 String& providerName, String& location)
3455 {
3456 Uint32 pos = pInstance.findProperty(CIMName ("Name"));
3457 pInstance.getProperty(pos).getValue().get(providerName);
3458
3459 pos = pmInstance.findProperty(CIMName ("Location"));
3460 pmInstance.getProperty(pos).getValue().get(location);
3461 return 0;
3462 }
3463
3464 Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()
3465 {
|
3466 konrad.r 1.15 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest");
|
3467 schuur 1.1
|
3468 mark.hamzy 1.23 HandlerIntroInd(CreateSubscription,message,request,response,handler);
3469
|
3470 mark.hamzy 1.25 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 schuur 1.1 try {
|
3478 mark.hamzy 1.25 String providerName,
3479 providerLocation;
3480 CIMInstance req_provider,
3481 req_providerModule;
3482
3483 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
|
3484 schuur 1.1
|
3485 mark.hamzy 1.25 req_provider = pidc.getProvider();
|
3486 schuur 1.12 req_providerModule = pidc.getModule();
|
3487 mark.hamzy 1.25
|
3488 schuur 1.12 LocateIndicationProviderNames(req_provider, req_providerModule,providerName,providerLocation);
|
3489 schuur 1.1
3490 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3491 "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
3492 System::getHostName(),
3493 request->nameSpace.getString(),
3494 providerName);
3495
|
3496 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));
3497
|
3498 schuur 1.1 String fileName = resolveFileName(providerLocation);
3499
3500 // get cached or load new provider module
3501 JMPIProvider::OpProviderHolder ph =
3502 providerManager.getProvider(fileName, providerName, String::EMPTY);
3503
|
3504 mark.hamzy 1.25 indProvRecord *prec = NULL;
3505
|
3506 schuur 1.12 provTab.lookup(providerName,prec);
|
3507 mark.hamzy 1.25
|
3508 mark.hamzy 1.23 if (prec)
|
3509 mark.hamzy 1.25 {
|
3510 mark.hamzy 1.23 prec->count++;
|
3511 mark.hamzy 1.25 }
3512 else
3513 {
3514 prec=new indProvRecord();
3515 provTab.insert(providerName,prec);
|
3516 schuur 1.12 }
|
3517 schuur 1.1
|
3518 carolann.graves 1.21 //
3519 // Save the provider instance from the request
3520 //
3521 ph.GetProvider ().setProviderInstance (req_provider);
3522
|
3523 mark.hamzy 1.25 indSelectRecord *srec = new indSelectRecord();
3524 const CIMObjectPath &sPath = request->subscriptionInstance.getPath();
3525
|
3526 schuur 1.12 selxTab.insert(sPath.toString(),srec);
|
3527 schuur 1.1
3528 // convert arguments
3529 OperationContext *context=new OperationContext();
3530
|
3531 mark.hamzy 1.25 if (prec->ctx==NULL)
3532 {
3533 prec->ctx=context;
|
3534 mark.hamzy 1.23 }
|
3535 schuur 1.12
3536 context->insert(request->operationContext.get(IdentityContainer::NAME));
3537 context->insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3538 context->insert(request->operationContext.get(ContentLanguageListContainer::NAME));
3539 context->insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
3540 context->insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
3541 context->insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
|
3542 schuur 1.1
3543 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
3544
|
3545 schuur 1.12 SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get
3546 (SubscriptionFilterConditionContainer::NAME);
3547
|
3548 mark.hamzy 1.25 JMPIProvider &pr = ph.GetProvider();
|
3549 konrad.r 1.22
|
3550 mark.hamzy 1.25 CIMOMHandleQueryContext *qcontext=new CIMOMHandleQueryContext(CIMNamespaceName(request->nameSpace.getString()),
3551 *pr._cimom_handle);
|
3552 konrad.r 1.22
|
3553 mark.hamzy 1.25 CMPI_SelectExp *eSelx = new CMPI_SelectExp(*context,
3554 qcontext,
3555 request->query,
3556 sub_cntr.getQueryLanguage());
|
3557 konrad.r 1.22
|
3558 schuur 1.12 srec->eSelx=eSelx;
|
3559 mark.hamzy 1.25 srec->qContext=qcontext;
|
3560 schuur 1.1
|
3561 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.createSubscriptionRequest: " + pr.getName());
|
3562 schuur 1.1
|
3563 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Calling provider createSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
|
3564 schuur 1.1
3565 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) {
3566 CIMObjectPath className(
3567 System::getHostName(),
3568 request->nameSpace,
3569 request->classNames[i]);
3570 eSelx->classNames.append(className);
3571 }
3572
3573 CIMPropertyList propertyList = request->propertyList;
|
3574 mark.hamzy 1.29
3575 if (!propertyList.isNull())
3576 {
3577 Array<CIMName> p = propertyList.getPropertyNameArray();
3578 int pCount = p.size();
3579
|
3580 schuur 1.1 eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*));
|
3581 mark.hamzy 1.29
3582 for (int i=0; i<pCount; i++)
3583 {
|
3584 schuur 1.1 eSelx->props[i]=strdup(p[i].getString().getCString());
|
3585 mark.hamzy 1.29 }
|
3586 schuur 1.1 eSelx->props[pCount]=NULL;
3587 }
3588
|
3589 mark.hamzy 1.25 JvmVector *jv = 0;
3590
3591 env = JMPIjvm::attachThread(&jv);
3592
3593 JMPIProvider::pm_service_op_lock op_lock(&pr);
3594
3595 STAT_GETSTARTTIME;
3596
3597 jmethodID id = NULL;
3598
3599 // public void authorizeFilter (org.pegasus.jmpi.SelectExp filter,
3600 // java.lang.String eventType,
3601 // org.pegasus.jmpi.CIMObjectPath classPath,
3602 // java.lang.String owner)
3603 // throws org.pegasus.jmpi.CIMException
3604 id = env->GetMethodID((jclass)pr.jProviderClass,
3605 "activateFilter",
3606 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
3607 schuur 1.12
|
3608 mark.hamzy 1.25 if (id != NULL)
3609 {
3610 eMethodFound = METHOD_SNIA_PROVIDER20;
3611 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
3612 }
|
3613 mark.hamzy 1.23
3614 JMPIjvm::checkException(env);
3615
|
3616 mark.hamzy 1.25 switch (eMethodFound)
3617 {
3618 case METHOD_SNIA_PROVIDER20:
3619 {
|
3620 mark.hamzy 1.29 jint jSelRef = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
3621 jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jSelRef);
|
3622 mark.hamzy 1.25
3623 JMPIjvm::checkException(env);
3624
|
3625 mark.hamzy 1.29 jint jcopRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);
3626 jobject jcop = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jcopRef);
|
3627 schuur 1.12
|
3628 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
3629 schuur 1.1
|
3630 mark.hamzy 1.25 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
3631 schuur 1.1
|
3632 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
3633 schuur 1.1
|
3634 mark.hamzy 1.25 env->CallVoidMethod((jobject)pr.jProvider,
3635 id,
3636 jSel,
3637 jType,
|
3638 mark.hamzy 1.29 jcop,
|
3639 mark.hamzy 1.25 (jboolean)0);
|
3640 schuur 1.12
|
3641 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
3642 schuur 1.1
|
3643 carolann.graves 1.21 //
|
3644 mark.hamzy 1.25 // Increment count of current subscriptions for this provider
|
3645 carolann.graves 1.21 //
|
3646 mark.hamzy 1.25 if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())
|
3647 carolann.graves 1.21 {
|
3648 mark.hamzy 1.25 //
3649 // If there were no current subscriptions before the increment,
3650 // the first subscription has been created
3651 // Call the provider's enableIndications method
3652 //
3653 if (_subscriptionInitComplete)
3654 {
3655 prec->enabled = true;
3656 CIMRequestMessage * request = 0;
3657 CIMResponseMessage * response = 0;
3658 prec->handler = new EnableIndicationsResponseHandler
3659 (request, response, req_provider, _indicationCallback);
3660 }
|
3661 carolann.graves 1.21 }
|
3662 mark.hamzy 1.25
3663 STAT_PMS_PROVIDEREND;
3664 break;
|
3665 carolann.graves 1.21 }
3666
|
3667 mark.hamzy 1.25 case METHOD_UNKNOWN:
3668 {
3669 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: should not be here!"<<PEGASUS_STD(endl));
3670 break;
3671 }
3672 }
|
3673 schuur 1.1
3674 }
3675 HandlerCatch(handler);
|
3676 schuur 1.12
|
3677 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
3678
|
3679 schuur 1.1 PEG_METHOD_EXIT();
3680
3681 return(response);
3682 }
3683
3684 Message * JMPIProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()
3685 {
3686 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest");
3687
|
3688 mark.hamzy 1.23 HandlerIntroInd(DeleteSubscription,message,request,response,handler);
3689
|
3690 mark.hamzy 1.25 typedef enum {
3691 METHOD_UNKNOWN = 0,
3692 METHOD_SNIA_PROVIDER20,
3693 } METHOD_VERSION;
3694 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
3695 JNIEnv *env = NULL;
3696
|
3697 schuur 1.1 try {
|
3698 mark.hamzy 1.25 String providerName,
3699 providerLocation;
3700 CIMInstance req_provider,
3701 req_providerModule;
3702 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
3703
3704 req_provider = pidc.getProvider();
|
3705 schuur 1.12 req_providerModule = pidc.getModule();
|
3706 se.gupta 1.9
|
3707 mark.hamzy 1.25 LocateIndicationProviderNames(req_provider, req_providerModule, providerName,providerLocation);
|
3708 schuur 1.1
3709 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
3710 "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
3711 System::getHostName(),
3712 request->nameSpace.getString(),
3713 providerName);
3714
|
3715 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));
3716
|
3717 schuur 1.1 String fileName = resolveFileName(providerLocation);
3718
3719 // get cached or load new provider module
3720 JMPIProvider::OpProviderHolder ph =
3721 providerManager.getProvider(fileName, providerName, String::EMPTY);
3722
|
3723 mark.hamzy 1.25 indProvRecord *prec = NULL;
3724
|
3725 schuur 1.12 provTab.lookup(providerName,prec);
|
3726 mark.hamzy 1.25 if (--prec->count <= 0)
3727 {
3728 provTab.remove(providerName);
3729 prec=NULL;
|
3730 schuur 1.12 }
|
3731 schuur 1.1
|
3732 mark.hamzy 1.25 indSelectRecord *srec = NULL;
3733 const CIMObjectPath &sPath = request->subscriptionInstance.getPath();
3734 String sPathString = sPath.toString();
3735
|
3736 schuur 1.12 selxTab.lookup(sPathString,srec);
|
3737 schuur 1.1
|
3738 mark.hamzy 1.25 CMPI_SelectExp *eSelx = srec->eSelx;
3739 CIMOMHandleQueryContext *qContext = srec->qContext;
|
3740 konrad.r 1.22
|
3741 schuur 1.12 selxTab.remove(sPathString);
|
3742 schuur 1.1
|
3743 schuur 1.12 // convert arguments
|
3744 schuur 1.1 OperationContext context;
3745
|
3746 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
3747 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
3748 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
3749 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
3750 context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
3751
|
3752 schuur 1.1 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
3753
|
3754 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
3755 schuur 1.1
|
3756 mark.hamzy 1.25 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, "Calling provider.deleteSubscriptionRequest: " + pr.getName());
|
3757 schuur 1.1
|
3758 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Calling provider deleteSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
|
3759 schuur 1.1
|
3760 mark.hamzy 1.25 JvmVector *jv = 0;
3761
3762 env = JMPIjvm::attachThread(&jv);
3763
3764 JMPIProvider::pm_service_op_lock op_lock(&pr);
3765
3766 STAT_GETSTARTTIME;
3767
3768 jmethodID id = NULL;
3769
3770 // public void deActivateFilter (org.pegasus.jmpi.SelectExp filter,
3771 // java.lang.String eventType,
3772 // org.pegasus.jmpi.CIMObjectPath classPath,
3773 // boolean lastActivation)
3774 // throws org.pegasus.jmpi.CIMException
3775 id = env->GetMethodID((jclass)pr.jProviderClass,
3776 "deActivateFilter",
3777 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
3778 schuur 1.12
|
3779 mark.hamzy 1.25 if (id != NULL)
3780 {
3781 eMethodFound = METHOD_SNIA_PROVIDER20;
3782 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
3783 }
|
3784 mark.hamzy 1.23
3785 JMPIjvm::checkException(env);
3786
|
3787 mark.hamzy 1.25 switch (eMethodFound)
3788 {
3789 case METHOD_SNIA_PROVIDER20:
3790 {
3791 jint jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
3792 jobject jSel = env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj);
3793
3794 JMPIjvm::checkException(env);
3795
3796 jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);
|
3797 mark.hamzy 1.23
|
3798 mark.hamzy 1.25 jobject jRef = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
|
3799 schuur 1.12
|
3800 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
3801 schuur 1.12
|
3802 mark.hamzy 1.25 jstring jType = env->NewStringUTF(request->nameSpace.getString().getCString());
|
3803 schuur 1.1
|
3804 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
3805 schuur 1.1
|
3806 mark.hamzy 1.25 env->CallVoidMethod((jobject)pr.jProvider,
3807 id,
3808 jSel,
3809 jType,
3810 jRef,
3811 (jboolean)(prec==NULL));
|
3812 schuur 1.1
|
3813 mark.hamzy 1.25 JMPIjvm::checkException(env);
|
3814 schuur 1.1
|
3815 carolann.graves 1.21 //
|
3816 mark.hamzy 1.25 // Decrement count of current subscriptions for this provider
|
3817 carolann.graves 1.21 //
|
3818 mark.hamzy 1.25 if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())
|
3819 carolann.graves 1.21 {
|
3820 mark.hamzy 1.25 //
3821 // If there are no current subscriptions after the decrement,
3822 // the last subscription has been deleted
3823 // Call the provider's disableIndications method
3824 //
3825 if (_subscriptionInitComplete)
3826 {
3827 prec->enabled = false;
3828 if (prec->handler) delete prec->handler;
3829 prec->handler = NULL;
3830 }
|
3831 carolann.graves 1.21 }
3832
|
3833 mark.hamzy 1.25 STAT_PMS_PROVIDEREND;
|
3834 schuur 1.1
|
3835 mark.hamzy 1.25 delete eSelx;
3836 delete qContext;
3837 delete srec;
3838 break;
3839 }
|
3840 schuur 1.12
|
3841 mark.hamzy 1.25 case METHOD_UNKNOWN:
3842 {
3843 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: should not be here!"<<PEGASUS_STD(endl));
3844 break;
3845 }
3846 }
|
3847 schuur 1.1 }
3848 HandlerCatch(handler);
|
3849 schuur 1.12
|
3850 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
3851
|
3852 schuur 1.1 PEG_METHOD_EXIT();
3853
|
3854 w.white 1.31 STAT_COPYDISPATCHER
3855
|
3856 schuur 1.1 return(response);
3857 }
3858
3859 Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw()
3860 {
3861 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDisableModuleRequest");
3862
3863 CIMDisableModuleRequestMessage * request =
3864 dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));
3865
3866 PEGASUS_ASSERT(request != 0);
3867
3868 // get provider module name
3869 String moduleName;
3870 CIMInstance mInstance = request->providerModule;
3871 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
3872
3873 if(pos != PEG_NOT_FOUND)
3874 {
3875 mInstance.getProperty(pos).getValue().get(moduleName);
3876 }
3877 schuur 1.1
3878 Boolean disableProviderOnly = request->disableProviderOnly;
3879
3880 Array<Uint16> operationalStatus;
|
3881 kumpf 1.2 // Assume success.
|
3882 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
3883 schuur 1.1
|
3884 kumpf 1.2 //
|
3885 schuur 1.1 // Unload providers
|
3886 kumpf 1.2 //
|
3887 schuur 1.1 Array<CIMInstance> _pInstances = request->providers;
3888
3889 CIMDisableModuleResponseMessage * response =
3890 new CIMDisableModuleResponseMessage(
3891 request->messageId,
3892 CIMException(),
3893 request->queueIds.copyAndPop(),
3894 operationalStatus);
3895
3896 PEGASUS_ASSERT(response != 0);
3897
3898 // preserve message key
3899 response->setKey(request->getKey());
3900
3901 //
3902 // Set HTTP method in response from request
3903 //
3904 response->setHttpMethod (request->getHttpMethod ());
3905
3906 PEG_METHOD_EXIT();
3907
3908 schuur 1.1 return(response);
3909 }
3910
3911 Message * JMPIProviderManager::handleEnableModuleRequest(const Message * message) throw()
3912 {
3913 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnableModuleRequest");
3914
3915 CIMEnableModuleRequestMessage * request =
3916 dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));
3917
3918 PEGASUS_ASSERT(request != 0);
3919
3920 Array<Uint16> operationalStatus;
|
3921 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
|
3922 schuur 1.1
3923 CIMEnableModuleResponseMessage * response =
3924 new CIMEnableModuleResponseMessage(
3925 request->messageId,
3926 CIMException(),
3927 request->queueIds.copyAndPop(),
3928 operationalStatus);
3929
3930 PEGASUS_ASSERT(response != 0);
3931
3932 // preserve message key
3933 response->setKey(request->getKey());
3934
3935 // Set HTTP method in response from request
3936 response->setHttpMethod (request->getHttpMethod ());
3937
3938 PEG_METHOD_EXIT();
3939
3940 return(response);
3941 }
3942
3943 schuur 1.1 Message * JMPIProviderManager::handleStopAllProvidersRequest(const Message * message) throw()
3944 {
3945 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleStopAllProvidersRequest");
3946
3947 CIMStopAllProvidersRequestMessage * request =
3948 dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));
3949
3950 PEGASUS_ASSERT(request != 0);
3951
3952 CIMStopAllProvidersResponseMessage * response =
3953 new CIMStopAllProvidersResponseMessage(
3954 request->messageId,
3955 CIMException(),
3956 request->queueIds.copyAndPop());
3957
3958 PEGASUS_ASSERT(response != 0);
3959
3960 // preserve message key
3961 response->setKey(request->getKey());
3962
3963 // Set HTTP method in response from request
3964 schuur 1.1 response->setHttpMethod (request->getHttpMethod ());
3965
3966 // tell the provider manager to shutdown all the providers
3967 providerManager.shutdownAllProviders();
3968
3969 PEG_METHOD_EXIT();
3970
3971 return(response);
3972 }
3973
|
3974 kumpf 1.4 Message * JMPIProviderManager::handleInitializeProviderRequest(const Message * message)
3975 {
3976 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleInitializeProviderRequest");
3977
3978 HandlerIntroInit(InitializeProvider,message,request,response,handler);
3979
3980 try
3981 {
3982 // resolve provider name
|
3983 mark.hamzy 1.23 ProviderName name = _resolveProviderName(
3984 request->operationContext.get(ProviderIdContainer::NAME));
|
3985 kumpf 1.4
3986 // get cached or load new provider module
3987 JMPIProvider::OpProviderHolder ph =
|
3988 mark.hamzy 1.23 providerManager.getProvider(name.getPhysicalName(),
3989 name.getLogicalName(), String::EMPTY);
|
3990 kumpf 1.4
3991 }
3992 HandlerCatch(handler);
3993
3994 PEG_METHOD_EXIT();
3995
3996 return(response);
3997 }
3998
|
3999 mark.hamzy 1.25 Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest (const Message * message)
|
4000 carolann.graves 1.21 {
4001 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
4002 "JMPIProviderManager::handleSubscriptionInitCompleteRequest");
4003
4004 CIMSubscriptionInitCompleteRequestMessage * request =
4005 dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
4006 (const_cast <Message *> (message));
4007
4008 PEGASUS_ASSERT (request != 0);
4009
4010 CIMSubscriptionInitCompleteResponseMessage * response =
4011 dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
4012 (request->buildResponse ());
4013
4014 PEGASUS_ASSERT (response != 0);
4015
4016 //
4017 // Set indicator
4018 //
4019 _subscriptionInitComplete = true;
4020
4021 carolann.graves 1.21 //
4022 // For each provider that has at least one subscription, call
4023 // provider's enableIndications method
4024 //
4025 Array <JMPIProvider *> enableProviders;
4026 enableProviders = providerManager.getIndicationProvidersToEnable ();
4027
4028 Uint32 numProviders = enableProviders.size ();
4029 for (Uint32 i = 0; i < numProviders; i++)
4030 {
4031 try
4032 {
4033 CIMInstance provider;
4034 provider = enableProviders [i]->getProviderInstance ();
4035
4036 //
4037 // Get cached or load new provider module
4038 //
4039 JMPIProvider::OpProviderHolder ph = providerManager.getProvider
4040 (enableProviders [i]->getModule ()->getFileName (),
4041 enableProviders [i]->getName ());
4042 carolann.graves 1.21
4043 indProvRecord * prec = NULL;
4044 provTab.lookup (enableProviders [i]->getName (), prec);
4045 if (prec)
4046 {
4047 prec->enabled = true;
4048 CIMRequestMessage * request = 0;
4049 CIMResponseMessage * response = 0;
4050 prec->handler = new EnableIndicationsResponseHandler
4051 (request, response, provider, _indicationCallback);
4052 }
4053 }
4054 catch (CIMException & e)
4055 {
4056 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4057 "CIMException: " + e.getMessage ());
4058 }
4059 catch (Exception & e)
4060 {
4061 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4062 "Exception: " + e.getMessage ());
4063 carolann.graves 1.21 }
4064 catch(...)
4065 {
4066 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
4067 "Unknown error in handleSubscriptionInitCompleteRequest");
4068 }
4069 }
4070
4071 PEG_METHOD_EXIT ();
4072 return (response);
4073 }
4074
|
4075 schuur 1.1 Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw()
4076 {
|
4077 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleUnsupportedRequest");
4078
|
4079 konrad.r 1.16 CIMRequestMessage* request =
4080 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
4081 PEGASUS_ASSERT(request != 0 );
4082
4083 CIMResponseMessage* response = request->buildResponse();
4084 response->cimException =
4085 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
|
4086 schuur 1.1
4087 PEG_METHOD_EXIT();
|
4088 konrad.r 1.16 return response;
|
4089 schuur 1.1 }
4090
|
4091 kumpf 1.2 ProviderName JMPIProviderManager::_resolveProviderName(
4092 const ProviderIdContainer & providerId)
|
4093 schuur 1.1 {
|
4094 kumpf 1.2 String providerName;
4095 String fileName;
4096 String interfaceName;
4097 CIMValue genericValue;
4098
4099 genericValue = providerId.getProvider().getProperty(
4100 providerId.getProvider().findProperty("Name")).getValue();
4101 genericValue.get(providerName);
4102
4103 genericValue = providerId.getModule().getProperty(
4104 providerId.getModule().findProperty("Location")).getValue();
4105 genericValue.get(fileName);
4106 fileName = resolveFileName(fileName);
4107
4108 // ATTN: This attribute is probably not required
4109 genericValue = providerId.getModule().getProperty(
4110 providerId.getModule().findProperty("InterfaceType")).getValue();
4111 genericValue.get(interfaceName);
4112
4113 return ProviderName(providerName, fileName, interfaceName, 0);
|
4114 schuur 1.1 }
4115
4116 String JMPIProviderManager::resolveFileName(String fileName)
4117 {
4118 String name;
4119 #if defined(PEGASUS_OS_TYPE_WINDOWS)
4120 name = fileName; // + String(".dll");
4121 #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
4122 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
4123 name.append(String("/") + fileName); // + String(".sl"));
4124 #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
4125 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
4126 name.append(String("/") + fileName); // + String(".so"));
4127 #elif defined(PEGASUS_OS_OS400)
4128 name = filrName;
4129 #else
4130 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
4131 name.append(String("/") + fileName); // + String(".so"));
4132 #endif
4133 return name;
4134 }
4135 schuur 1.1
4136 PEGASUS_NAMESPACE_END
|
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI