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