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