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
|
172 schuur 1.1 Message * JMPIProviderManager::processMessage(Message * request) throw()
173 {
|
174 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::processMessage()");
|
175 schuur 1.1
176 Message * response = 0;
|
177 mark.hamzy 1.23
|
178 schuur 1.1 // pass the request message to a handler method based on message type
179 switch(request->getType())
180 {
181 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
182 response = handleGetInstanceRequest(request);
183
184 break;
185 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
186 response = handleEnumerateInstancesRequest(request);
187
188 break;
189 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
190 response = handleEnumerateInstanceNamesRequest(request);
191
192 break;
193 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
194 response = handleCreateInstanceRequest(request);
195
196 break;
197 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
198 response = handleModifyInstanceRequest(request);
199 schuur 1.1
200 break;
201 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
202 response = handleDeleteInstanceRequest(request);
203
204 break;
205 /* case CIM_EXEC_QUERY_REQUEST_MESSAGE:
206 response = handleExecuteQueryRequest(request);
207
208 */ break;
209 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
210 response = handleAssociatorsRequest(request);
211
212 break;
213 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
214 response = handleAssociatorNamesRequest(request);
215
216 break;
217 case CIM_REFERENCES_REQUEST_MESSAGE:
218 response = handleReferencesRequest(request);
219
220 schuur 1.1 break;
221 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
222 response = handleReferenceNamesRequest(request);
223
224 break;
|
225 schuur 1.11 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
|
226 schuur 1.1 response = handleInvokeMethodRequest(request);
227
228 break;
|
229 schuur 1.12 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
|
230 schuur 1.1 response = handleCreateSubscriptionRequest(request);
231
232 break;
|
233 schuur 1.12 /* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
|
234 schuur 1.1 response = handleModifySubscriptionRequest(request);
235 break;
|
236 schuur 1.12 */
|
237 schuur 1.1 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
238 response = handleDeleteSubscriptionRequest(request);
239
240 break;
|
241 schuur 1.12 /* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
|
242 kumpf 1.7 response = handleExportIndicationRequest(request);
|
243 schuur 1.1 break;
|
244 schuur 1.12 */
|
245 schuur 1.1 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
246 response = handleDisableModuleRequest(request);
247
248 break;
249 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
250 response = handleEnableModuleRequest(request);
251
252 break;
253 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
254 response = handleStopAllProvidersRequest(request);
255
|
256 schuur 1.12 break;
|
257 kumpf 1.4 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
|
258 mark.hamzy 1.23 response = handleInitializeProviderRequest(request);
|
259 kumpf 1.4
|
260 mark.hamzy 1.23 break;
|
261 carolann.graves 1.21 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
262 response = handleSubscriptionInitCompleteRequest (request);
263
264 break;
|
265 schuur 1.1 default:
|
266 mark.hamzy 1.23 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,
267 "*** Unsupported Request "+request->getType());
268 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::processMessage: Unsupported request "<<request->getType ()<<PEGASUS_STD(endl));
|
269 schuur 1.1 response = handleUnsupportedRequest(request);
270
271 break;
272 }
273
274 PEG_METHOD_EXIT();
275
276 return(response);
277 }
278
|
279 kumpf 1.6 Boolean JMPIProviderManager::hasActiveProviders()
280 {
281 return providerManager.hasActiveProviders();
282 }
283
284 void JMPIProviderManager::unloadIdleProviders()
|
285 schuur 1.1 {
|
286 kumpf 1.6 providerManager.unloadIdleProviders();
|
287 schuur 1.1 }
288
289 #define STRDUPA(s,o) \
290 if (s) { \
291 o=(const char*)alloca(strlen(s)); \
292 strcpy((char*)(o),(s)); \
293 } \
294 else o=NULL;
295
296 #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)
297
298
299 #define HandlerIntroBase(type,type1,message,request,response,handler,respType) \
300 CIM##type##RequestMessage * request = \
301 dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \
302 PEGASUS_ASSERT(request != 0); \
303 CIM##type##ResponseMessage * response = \
304 new CIM##type##ResponseMessage( \
305 request->messageId, \
306 CIMException(), \
307 request->queueIds.copyAndPop() \
308 schuur 1.1 respType \
309 PEGASUS_ASSERT(response != 0); \
310 response->setKey(request->getKey()); \
311 response->setHttpMethod(request->getHttpMethod()); \
312 type1##ResponseHandler handler(request, response);
313
314 #define VOIDINTRO );
315 #define NOVOIDINTRO(type) ,type);
316 #define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName );
317
318
319 #define HandlerIntroVoid(type,message,request,response,handler) \
320 HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO)
321
322 #define HandlerIntroMethod(type,message,request,response,handler) \
323 HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO)
324
325 #define HandlerIntroInd(type,message,request,response,handler) \
326 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
327
|
328 kumpf 1.4 #define HandlerIntroInit(type,message,request,response,handler) \
329 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
330
|
331 schuur 1.1 #define HandlerIntro(type,message,request,response,handler,respType) \
332 HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType))
333
334 #define HandlerCatch(handler) \
335 catch(CIMException & e) \
336 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
337 "Exception: " + e.getMessage()); \
338 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); \
339 } \
340 catch(Exception & e) \
341 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
342 "Exception: " + e.getMessage()); \
343 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \
344 } \
345 catch(...) \
346 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
347 "Exception: Unknown"); \
348 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
349 }
350
|
351 schuur 1.13 static jobjectArray getList(JvmVector *jv, JNIEnv *env, CIMPropertyList &list)
352 {
353 Uint32 s=list.size();
354 jobjectArray pl=NULL;
355 if (s) {
356 jstring initial=env->NewString(NULL,0);
|
357 mark.hamzy 1.23 pl=(jobjectArray)env->NewObjectArray(s,jv->StringClassRef,initial);
|
358 schuur 1.13 for (Uint32 i=0; i<s; i++) {
359 env->SetObjectArrayElement
360 (pl,i,env->NewStringUTF(list[i].getString().getCString()));
361 }
362 }
363 return pl;
364 }
|
365 schuur 1.1
366 Message * JMPIProviderManager::handleGetInstanceRequest(const Message * message) throw()
367 {
|
368 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleGetInstanceRequest");
|
369 schuur 1.1
370 HandlerIntro(GetInstance,message,request,response,handler,CIMInstance());
371
372 JNIEnv *env=NULL;
|
373 schuur 1.13 Boolean mode24=false;
374 CIMPropertyList propertyList;
375 jobjectArray pl=NULL;
376
|
377 schuur 1.1 try {
|
378 mark.hamzy 1.23 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
379 schuur 1.1 "JMPIProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
380 System::getHostName(),
381 request->nameSpace.getString(),
382 request->instanceName.getClassName().getString());
383
|
384 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));
385
|
386 schuur 1.1 // make target object path
387 CIMObjectPath objectPath(
388 System::getHostName(),
389 request->nameSpace,
390 request->instanceName.getClassName(),
391 request->instanceName.getKeyBindings());
392
393 // resolve provider name
|
394 kumpf 1.2 ProviderName name = _resolveProviderName(
395 request->operationContext.get(ProviderIdContainer::NAME));
|
396 schuur 1.1
397 // get cached or load new provider module
398 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(),
|
399 mark.hamzy 1.23 name.getLogicalName());
|
400 schuur 1.1 OperationContext context;
401
|
402 mark.hamzy 1.23 // forward request
403 JMPIProvider & pr=ph.GetProvider();
|
404 schuur 1.1
405 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
406 "Calling provider.getInstance: " + pr.getName());
407
|
408 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleGetInstanceRequest: Calling provider getInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
409 schuur 1.1
410 JvmVector *jv;
411 JNIEnv *env=JMPIjvm::attachThread(&jv);
412 JMPIjvm::checkException(env);
|
413 mark.hamzy 1.23
414 jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
415
416 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
|
417 schuur 1.1 JMPIjvm::checkException(env);
418
419 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
|
420 mark.hamzy 1.23 request->instanceName.getClassName(),
|
421 schuur 1.1 false,true,true,CIMPropertyList());
422 JMPIjvm::checkException(env);
|
423 mark.hamzy 1.23
424 jObj = DEBUG_ConvertCToJava (CIMClass*, jint, &cls);
425
426 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj);
|
427 schuur 1.1 JMPIjvm::checkException(env);
428
|
429 mark.hamzy 1.23 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
430 schuur 1.1
|
431 mark.hamzy 1.23 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance",
|
432 schuur 1.13 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;");
433
|
434 mark.hamzy 1.23 if (id==NULL) {
|
435 schuur 1.13 env->ExceptionClear();
|
436 mark.hamzy 1.23 id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance",
|
437 schuur 1.13 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)"
|
438 mark.hamzy 1.23 "Lorg/pegasus/jmpi/CIMInstance;");
|
439 schuur 1.13 JMPIjvm::checkException(env);
|
440 mark.hamzy 1.23 mode24=true;
441 pl=getList(jv,env,request->propertyList);
442 }
|
443 schuur 1.13 JMPIjvm::checkException(env);
444
|
445 mark.hamzy 1.23 STAT_GETSTARTTIME;
|
446 schuur 1.1
|
447 mark.hamzy 1.23 jobject inst=NULL;
448 if (mode24)
449 inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
|
450 schuur 1.13 request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc);
|
451 mark.hamzy 1.23 else
452 inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc,true);
|
453 schuur 1.13
|
454 schuur 1.1 STAT_PMS_PROVIDEREND;
|
455 schuur 1.13
|
456 schuur 1.1 JMPIjvm::checkException(env);
|
457 schuur 1.13 handler.processing();
|
458 mark.hamzy 1.23 if (inst) {
459 jint jCi = env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst);
460 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
461
|
462 schuur 1.1 handler.deliver(*ci);
463 }
464 handler.complete();
|
465 schuur 1.13 }
|
466 schuur 1.1 HandlerCatch(handler);
|
467 schuur 1.13
|
468 schuur 1.1 if (env) JMPIjvm::detachThread();
|
469 schuur 1.13
|
470 schuur 1.1 PEG_METHOD_EXIT();
471
472 return(response);
473 }
474
475 Message * JMPIProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()
476 {
|
477 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleEnumerateInstanceRequest");
478
479 HandlerIntro(EnumerateInstances,message,request,response,handler,Array<CIMInstance>());
|
480 schuur 1.1
481 JNIEnv *env=NULL;
|
482 schuur 1.13 Boolean mode24=false;
483 CIMPropertyList propertyList;
484 jobjectArray pl=NULL;
485
486 try {
|
487 schuur 1.1 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
488 "JMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",
489 System::getHostName(),
490 request->nameSpace.getString(),
491 request->className.getString());
492
|
493 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
494
|
495 schuur 1.1 // make target object path
496 CIMObjectPath objectPath(
497 System::getHostName(),
498 request->nameSpace,
499 request->className);
500
501 // resolve provider name
|
502 kumpf 1.2 ProviderName name = _resolveProviderName(
503 request->operationContext.get(ProviderIdContainer::NAME));
|
504 schuur 1.1
505 // get cached or load new provider module
506 JMPIProvider::OpProviderHolder ph =
507 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
508 String::EMPTY);
509
|
510 schuur 1.12 // convert arguments
|
511 schuur 1.1 OperationContext context;
512
|
513 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
514 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
515 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
516 schuur 1.1
517 CIMPropertyList propertyList(request->propertyList);
518
519 // forward request
|
520 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
521 schuur 1.1
522 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
523 "Calling provider.enumerateInstances: " + pr.getName());
524
|
525 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstancesRequest: Calling provider enumerateInstances: "<<pr.getName()<<PEGASUS_STD(endl));
|
526 schuur 1.12
527 JvmVector *jv;
|
528 schuur 1.1 env=JMPIjvm::attachThread(&jv);
529
|
530 mark.hamzy 1.23 jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
531
532 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
|
533 schuur 1.12 JMPIjvm::checkException(env);
534
|
535 schuur 1.1 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
|
536 schuur 1.12 request->className,
|
537 schuur 1.1 false,true,true,CIMPropertyList());
|
538 schuur 1.12 JMPIjvm::checkException(env);
|
539 mark.hamzy 1.23
540 jObj = DEBUG_ConvertCToJava (CIMClass*, jint, &cls);
541
542 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj);
|
543 schuur 1.1 JMPIjvm::checkException(env);
544
|
545 schuur 1.12 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
546 schuur 1.1
|
547 schuur 1.12 STAT_GETSTARTTIME;
|
548 schuur 1.1
549 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances",
550 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;");
|
551 schuur 1.13
|
552 mark.hamzy 1.23 if (id==NULL) {
553 env->ExceptionClear();
554 id=env->GetMethodID((jclass)pr.jProviderClass,"enumerateInstances",
|
555 schuur 1.13 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)"
|
556 mark.hamzy 1.23 "[Lorg/pegasus/jmpi/CIMInstance;");
557 JMPIjvm::checkException(env);
558 mode24=true;
559 pl=getList(jv,env,request->propertyList);
560 }
|
561 schuur 1.1 JMPIjvm::checkException(env);
562
|
563 schuur 1.13 if (!mode24) {
|
564 mark.hamzy 1.23 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,false,jCc,true);
565 JMPIjvm::checkException(env);
566
567 STAT_PMS_PROVIDEREND;
568
569 handler.processing();
570 if (jVec) {
571 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
572 JMPIjvm::checkException(env);
573
574 jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
575 JMPIjvm::checkException(env);
|
576 schuur 1.13
|
577 mark.hamzy 1.23 jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);
578 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
|
579 schuur 1.13
|
580 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
581 schuur 1.13
|
582 mark.hamzy 1.23 handler.deliver(*ci);
583 }
584 }
585 handler.complete();
|
586 schuur 1.13 }
|
587 mark.hamzy 1.23 else {
588 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
589 request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc);
590 JMPIjvm::checkException(env);
|
591 schuur 1.12
|
592 mark.hamzy 1.23 STAT_PMS_PROVIDEREND;
593
594 handler.processing();
595 if (jAr) {
596 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
597 JMPIjvm::checkException(env);
598
599 jobject jInst=env->GetObjectArrayElement(jAr,i);
600 JMPIjvm::checkException(env);
|
601 schuur 1.12
|
602 mark.hamzy 1.23 jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);
603 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
|
604 schuur 1.12
|
605 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
606 schuur 1.12
|
607 mark.hamzy 1.23 handler.deliver(*ci);
608 }
609 }
610 handler.complete();
|
611 schuur 1.1 }
612 }
613 HandlerCatch(handler);
|
614 schuur 1.12
|
615 schuur 1.11 if (env) JMPIjvm::detachThread();
|
616 schuur 1.12
|
617 schuur 1.1 PEG_METHOD_EXIT();
618
619 return(response);
620 }
621
622 Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()
623 {
624 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest");
625
|
626 mark.hamzy 1.23 HandlerIntro(EnumerateInstanceNames,message,request,response, handler,Array<CIMObjectPath>());
627
|
628 schuur 1.1 JNIEnv *env=NULL;
|
629 schuur 1.13 Boolean mode24=false;
630 CIMPropertyList propertyList;
631 jobjectArray pl=NULL;
632
|
633 schuur 1.1 try {
634 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
635 "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
636 System::getHostName(),
637 request->nameSpace.getString(),
638 request->className.getString());
|
639 mark.hamzy 1.23
640 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->className.getString()<<PEGASUS_STD(endl));
641
|
642 schuur 1.1 // make target object path
643 CIMObjectPath objectPath(
644 System::getHostName(),
645 request->nameSpace,
646 request->className);
647
648 // resolve provider name
|
649 kumpf 1.2 ProviderName name = _resolveProviderName(
650 request->operationContext.get(ProviderIdContainer::NAME));
|
651 schuur 1.1
652 // get cached or load new provider module
653 JMPIProvider::OpProviderHolder ph =
654 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
655
656 // convert arguments
657 OperationContext context;
658
|
659 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
660 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
661 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
662 schuur 1.1
|
663 mark.hamzy 1.23 JMPIProvider & pr=ph.GetProvider();
|
664 schuur 1.1
|
665 mark.hamzy 1.23 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
|
666 schuur 1.1 "Calling provider.enumerateInstanceNames: " + pr.getName());
667
|
668 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleEnumerateInstanceNamesRequest: Calling provider : enumerateInstanceNames"<<pr.getName()<<PEGASUS_STD(endl));
|
669 schuur 1.1
|
670 mark.hamzy 1.23 JvmVector *jv;
671 env=JMPIjvm::attachThread(&jv);
|
672 schuur 1.12
|
673 mark.hamzy 1.23 jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
|
674 schuur 1.1
|
675 mark.hamzy 1.23 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
676 JMPIjvm::checkException(env);
|
677 schuur 1.12
|
678 schuur 1.1 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
|
679 mark.hamzy 1.23 request->className,
|
680 schuur 1.1 false,true,true,CIMPropertyList());
681 JMPIjvm::checkException(env);
|
682 mark.hamzy 1.23
683 jObj = DEBUG_ConvertCToJava (CIMClass*, jint, &cls);
684
685 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,jObj);
|
686 schuur 1.1 JMPIjvm::checkException(env);
687
|
688 mark.hamzy 1.23 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
689 schuur 1.1
|
690 mark.hamzy 1.23 STAT_GETSTARTTIME;
|
691 schuur 1.1
692 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances",
693 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
|
694 schuur 1.13
|
695 mark.hamzy 1.23 if (id==NULL) {
|
696 schuur 1.13 env->ExceptionClear();
|
697 mark.hamzy 1.23 id=env->GetMethodID((jclass)pr.jProviderClass,"enumerateInstanceNames",
|
698 schuur 1.13 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)"
|
699 mark.hamzy 1.23 "[Lorg/pegasus/jmpi/CIMObjectPath;");
|
700 schuur 1.13 JMPIjvm::checkException(env);
|
701 mark.hamzy 1.23 mode24=true;
702 }
|
703 schuur 1.1 JMPIjvm::checkException(env);
704
|
705 schuur 1.13 if (!mode24) {
|
706 mark.hamzy 1.23 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,true,jCc);
707 JMPIjvm::checkException(env);
708
709 STAT_PMS_PROVIDEREND;
710
711 handler.processing();
712 if (jVec) {
713 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
714 JMPIjvm::checkException(env);
715
716 jobject inst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
717 JMPIjvm::checkException(env);
718
719 jint jCop = env->CallIntMethod(inst,JMPIjvm::jv.CIMObjectPathCInst);
720 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
|
721 schuur 1.13
|
722 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
723 schuur 1.13
|
724 mark.hamzy 1.23 handler.deliver(*cop);
725 }
726 }
727 handler.complete();
|
728 schuur 1.13 }
729 else {
|
730 mark.hamzy 1.23 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc);
731 JMPIjvm::checkException(env);
732
733 STAT_PMS_PROVIDEREND;
734
735 handler.processing();
736 if (jAr) {
737 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
738 JMPIjvm::checkException(env);
739
740 jobject inst=env->GetObjectArrayElement(jAr,i);
741 JMPIjvm::checkException(env);
742
743 jint jCop = env->CallIntMethod(inst,JMPIjvm::jv.CIMObjectPathCInst);
744 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
|
745 schuur 1.13
|
746 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
747 schuur 1.13
|
748 mark.hamzy 1.23 handler.deliver(*cop);
749 }
750 }
751 handler.complete();
|
752 schuur 1.1 }
753 }
754 HandlerCatch(handler);
|
755 mark.hamzy 1.23
756 if (env) JMPIjvm::detachThread();
|
757 schuur 1.1
758 PEG_METHOD_EXIT();
759
760 return(response);
761 }
762
763 Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()
764 {
|
765 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleCreateInstanceRequest");
766
767 HandlerIntro(CreateInstance,message,request,response,handler,CIMObjectPath());
|
768 schuur 1.1
769 JNIEnv *env=NULL;
770 try {
771 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
772 "JMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
773 System::getHostName(),
774 request->nameSpace.getString(),
775 request->newInstance.getPath().getClassName().getString());
776
|
777 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));
778
|
779 schuur 1.1 // make target object path
780 CIMObjectPath objectPath(
781 System::getHostName(),
782 request->nameSpace,
783 request->newInstance.getPath().getClassName(),
784 request->newInstance.getPath().getKeyBindings());
785
786 // resolve provider name
|
787 kumpf 1.2 ProviderName name = _resolveProviderName(
788 request->operationContext.get(ProviderIdContainer::NAME));
|
789 schuur 1.1
790 // get cached or load new provider module
791 JMPIProvider::OpProviderHolder ph =
792 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
|
793 mark.hamzy 1.23 String::EMPTY);
|
794 schuur 1.1
795 // convert arguments
796 OperationContext context;
797
|
798 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
799 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
800 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
801 schuur 1.1
802 // forward request
|
803 mark.hamzy 1.23 JMPIProvider & pr=ph.GetProvider();
|
804 schuur 1.1
805 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
806 "Calling provider.createInstance: " +
807 ph.GetProvider().getName());
808
|
809 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: Calling provider createInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
810 schuur 1.12
|
811 mark.hamzy 1.23 JvmVector *jv;
|
812 schuur 1.1 env=JMPIjvm::attachThread(&jv);
813
|
814 mark.hamzy 1.23 jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
815
816 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
817 JMPIjvm::checkException(env);
818
819 jObj = DEBUG_ConvertCToJava (CIMInstance*, jint, &request->newInstance);
820
821 jobject jInst=env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jObj);
822 JMPIjvm::checkException(env);
|
823 schuur 1.1
|
824 mark.hamzy 1.23 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
825 schuur 1.1
|
826 mark.hamzy 1.23 STAT_GETSTARTTIME;
|
827 schuur 1.1
828 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"createInstance",
829 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");
830 JMPIjvm::checkException(env);
831
|
832 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateInstanceRequest: id = "<<id<<", jRef = "<<jRef<<", jInst = "<<jInst<<PEGASUS_STD(endl));
833
834 jobject inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jInst);
835
|
836 schuur 1.1 STAT_PMS_PROVIDEREND;
|
837 mark.hamzy 1.23
|
838 schuur 1.1 JMPIjvm::checkException(env);
|
839 mark.hamzy 1.23 handler.processing();
840 if (inst) {
841 jint jCop = env->CallIntMethod(inst,JMPIjvm::jv.CIMObjectPathCInst);
842 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
843
844 handler.deliver(*cop);
|
845 schuur 1.1 }
846 handler.complete();
847 }
848 HandlerCatch(handler);
|
849 mark.hamzy 1.23
|
850 schuur 1.1 if (env) JMPIjvm::detachThread();
|
851 mark.hamzy 1.23
|
852 schuur 1.1 PEG_METHOD_EXIT();
853
854 return(response);
855 }
856
857 Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()
858 {
|
859 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleModifyInstanceRequest");
|
860 schuur 1.1
861 HandlerIntroVoid(ModifyInstance,message,request,response,handler);
|
862 mark.hamzy 1.23
|
863 schuur 1.1 JNIEnv *env=NULL;
|
864 schuur 1.13 Boolean mode24=false;
865 CIMPropertyList propertyList;
866 jobjectArray pl=NULL;
867
|
868 schuur 1.1 try {
869 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
870 konrad.r 1.15 "JMPIProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
871 schuur 1.1 System::getHostName(),
872 request->nameSpace.getString(),
873 request->modifiedInstance.getPath().getClassName().getString());
874
|
875 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));
876
|
877 schuur 1.1 // make target object path
878 CIMObjectPath objectPath(
879 System::getHostName(),
880 request->nameSpace,
881 request->modifiedInstance.getPath ().getClassName(),
882 request->modifiedInstance.getPath ().getKeyBindings());
883
884 // resolve provider name
|
885 kumpf 1.2 ProviderName name = _resolveProviderName(
886 request->operationContext.get(ProviderIdContainer::NAME));
|
887 schuur 1.1
|
888 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleModifyInstanceRequest: provider name physical = "<<name.getPhysicalName()<<", logical = "<<name.getLogicalName()<<PEGASUS_STD(endl));
889
|
890 schuur 1.1 // get cached or load new provider module
891 JMPIProvider::OpProviderHolder ph =
892 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
893
894 // convert arguments
895 OperationContext context;
896
|
897 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
898 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
899 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
900 schuur 1.1
901 CIMPropertyList propertyList(request->propertyList);
902
903 // forward request
|
904 mark.hamzy 1.23 JMPIProvider & pr=ph.GetProvider();
905
906 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.modifyInstance: " + pr.getName());
907
908 JvmVector *jv;
909 env=JMPIjvm::attachThread(&jv);
910
911 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));
912 DDD(debugPrintMethodPointers (env, (jclass)pr.jProviderClass));
|
913 schuur 1.1
|
914 mark.hamzy 1.23 jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
|
915 schuur 1.1
|
916 mark.hamzy 1.23 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
917 JMPIjvm::checkException(env);
|
918 schuur 1.1
|
919 mark.hamzy 1.23 jObj = DEBUG_ConvertCToJava (CIMInstance*, jint, &request->modifiedInstance);
|
920 schuur 1.1
|
921 mark.hamzy 1.23 jobject jInst=env->NewObject(jv->CIMInstanceClassRef,jv->CIMInstanceNewI,jObj);
922 JMPIjvm::checkException(env);
|
923 schuur 1.1
|
924 mark.hamzy 1.23 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
925 schuur 1.1
|
926 mark.hamzy 1.23 STAT_GETSTARTTIME;
|
927 schuur 1.1
928 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance",
929 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");
|
930 schuur 1.13
|
931 mark.hamzy 1.23 if (id==NULL) {
|
932 schuur 1.13 env->ExceptionClear();
933 id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance",
934 "(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");
935 JMPIjvm::checkException(env);
936 mode24=true;
937 pl=getList(jv,env,request->propertyList);
938 }
|
939 schuur 1.1 JMPIjvm::checkException(env);
940
|
941 mark.hamzy 1.23 if (!mode24)
942 env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst);
943 else
944 env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst,pl);
|
945 schuur 1.13
|
946 schuur 1.1 STAT_PMS_PROVIDEREND;
|
947 mark.hamzy 1.23
|
948 schuur 1.1 JMPIjvm::checkException(env);
949 }
950 HandlerCatch(handler);
|
951 mark.hamzy 1.23
|
952 schuur 1.1 if (env) JMPIjvm::detachThread();
|
953 mark.hamzy 1.23
|
954 schuur 1.1 PEG_METHOD_EXIT();
955
956 return(response);
957 }
958
959 Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()
960 {
|
961 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleDeleteInstanceRequest");
962
963 HandlerIntroVoid(DeleteInstance,message,request,response,handler);
|
964 schuur 1.1
965 JNIEnv *env=NULL;
966 try {
967 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
968 konrad.r 1.15 "JMPIProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
|
969 schuur 1.1 System::getHostName(),
970 request->nameSpace.getString(),
971 request->instanceName.getClassName().getString());
972
|
973 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));
974
|
975 schuur 1.1 // make target object path
976 CIMObjectPath objectPath(
977 System::getHostName(),
978 request->nameSpace,
979 request->instanceName.getClassName(),
980 request->instanceName.getKeyBindings());
981
982 // resolve provider name
|
983 kumpf 1.2 ProviderName name = _resolveProviderName(
984 request->operationContext.get(ProviderIdContainer::NAME));
|
985 schuur 1.1
986 // get cached or load new provider module
987 JMPIProvider::OpProviderHolder ph =
988 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
989
990 // convert arguments
991 OperationContext context;
992
|
993 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
994 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
995 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
996 schuur 1.1
997 // forward request
|
998 mark.hamzy 1.23 JMPIProvider & pr=ph.GetProvider();
|
999 schuur 1.1
1000 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1001 "Calling provider.deleteInstance: " + pr.getName());
1002
|
1003 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: Calling provider deleteInstance: "<<pr.getName()<<PEGASUS_STD(endl));
|
1004 schuur 1.1
|
1005 mark.hamzy 1.23 JvmVector *jv;
|
1006 schuur 1.1 env=JMPIjvm::attachThread(&jv);
1007
|
1008 mark.hamzy 1.23 jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
1009
1010 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
1011 JMPIjvm::checkException(env);
|
1012 schuur 1.1
|
1013 mark.hamzy 1.23 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
1014 schuur 1.1
|
1015 mark.hamzy 1.23 STAT_GETSTARTTIME;
|
1016 schuur 1.1
1017 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"deleteInstance",
1018 "(Lorg/pegasus/jmpi/CIMObjectPath;)V");
1019 JMPIjvm::checkException(env);
1020
1021 env->CallVoidMethod((jobject)pr.jProvider,id,jRef);
|
1022 mark.hamzy 1.23
|
1023 schuur 1.1 STAT_PMS_PROVIDEREND;
|
1024 mark.hamzy 1.23
|
1025 schuur 1.1 JMPIjvm::checkException(env);
1026 }
1027 HandlerCatch(handler);
|
1028 mark.hamzy 1.23
|
1029 schuur 1.1 if (env) JMPIjvm::detachThread();
|
1030 mark.hamzy 1.23
|
1031 schuur 1.1 PEG_METHOD_EXIT();
1032
1033 return(response);
1034 }
1035
1036
1037 Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()
1038 {
|
1039 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorsRequest");
1040
1041 HandlerIntro(Associators,message,request,response,handler,Array<CIMObject>());
|
1042 schuur 1.1
|
1043 mark.hamzy 1.24 typedef enum {
1044 METHOD_UNKNOWN = 0,
1045 METHOD_DIRECTOR,
1046 METHOD_SNIA_PROVIDER20,
1047 } METHOD_VERSION;
1048 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1049 JNIEnv *env = NULL;
1050 CIMPropertyList propertyList;
1051 jobjectArray jPropertyList = NULL;
|
1052 schuur 1.13
|
1053 schuur 1.1 try {
1054 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1055 "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",
1056 System::getHostName(),
1057 request->nameSpace.getString(),
1058 request->objectName.getClassName().getString());
1059
|
1060 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteInstanceRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", classname = "<<request->objectName.getClassName().getString()<<PEGASUS_STD(endl));
1061
|
1062 schuur 1.1 // make target object path
1063 CIMObjectPath objectPath(
1064 System::getHostName(),
1065 request->nameSpace,
1066 request->objectName.getClassName());
1067
1068 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1069
1070 CIMObjectPath assocPath(
1071 System::getHostName(),
1072 request->nameSpace,
1073 request->assocClass.getString());
1074
1075 // resolve provider name
|
1076 kumpf 1.2 ProviderName name = _resolveProviderName(
1077 request->operationContext.get(ProviderIdContainer::NAME));
|
1078 schuur 1.1
1079 // get cached or load new provider module
1080 JMPIProvider::OpProviderHolder ph =
1081 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1082
|
1083 mark.hamzy 1.24 // convert arguments
|
1084 schuur 1.1 OperationContext context;
1085
|
1086 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1087 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1088 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1089 schuur 1.1
1090 // forward request
|
1091 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
1092
1093 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associators: " + pr.getName());
|
1094 schuur 1.1
|
1095 mark.hamzy 1.24 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: Calling provider associators: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
|
1096 schuur 1.1
|
1097 mark.hamzy 1.24 JvmVector *jv = 0;
|
1098 schuur 1.1
|
1099 mark.hamzy 1.24 env = JMPIjvm::attachThread(&jv);
|
1100 schuur 1.1
|
1101 mark.hamzy 1.24 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
1102 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
1103 mark.hamzy 1.23
1104 JMPIjvm::checkException(env);
|
1105 schuur 1.1
|
1106 mark.hamzy 1.24 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
1107 jstring jRole = env->NewStringUTF(request->role.getCString());
1108 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
1109
|
1110 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1111 schuur 1.1
1112 JMPIProvider::pm_service_op_lock op_lock(&pr);
1113
1114 STAT_GETSTARTTIME;
1115
|
1116 mark.hamzy 1.24 jmethodID id = NULL;
1117
1118 // public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,
1119 // java.lang.String resultClass,
1120 // java.lang.String role,
1121 // java.lang.String resultRole,
1122 // boolean includeQualifiers,
1123 // boolean includeClassOrigin,
1124 // java.lang.String[] propertyList)
1125 // throws org.pegasus.jmpi.CIMException;
1126 //
1127 id = env->GetMethodID((jclass)pr.jProviderClass,
1128 "associators",
1129 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
1130
1131 if (id != NULL)
1132 {
1133 eMethodFound = METHOD_DIRECTOR;
1134 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_DIRECTOR."<<PEGASUS_STD(endl));
1135 }
|
1136 schuur 1.12
|
1137 mark.hamzy 1.24 if (id == NULL)
1138 {
1139 env->ExceptionClear();
1140
1141 // public abstract java.util.Vector associators (org.pegasus.jmpi.CIMObjectPath assocName,
1142 // org.pegasus.jmpi.CIMObjectPath pathName,
1143 // java.lang.String resultClass,
1144 // java.lang.String role,
1145 // java.lang.String resultRole,
1146 // boolean includeQualifiers,
1147 // boolean includeClassOrigin,
1148 // java.lang.String[] propertyList)
1149 // throws org.pegasus.jmpi.CIMException;
1150 //
1151 id = env->GetMethodID((jclass)pr.jProviderClass,
1152 "associators",
1153 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
1154
1155 if (id != NULL)
1156 {
1157 eMethodFound = METHOD_SNIA_PROVIDER20;
1158 mark.hamzy 1.24 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1159 }
1160 }
1161
1162 if (id == NULL)
1163 {
1164 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));
|
1165 mark.hamzy 1.23 }
|
1166 mark.hamzy 1.24
|
1167 schuur 1.1 JMPIjvm::checkException(env);
1168
|
1169 mark.hamzy 1.24 jPropertyList = getList(jv,env,request->propertyList);
|
1170 schuur 1.13
|
1171 mark.hamzy 1.24 switch (eMethodFound)
1172 {
1173 case METHOD_DIRECTOR:
1174 {
1175 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1176 id,
1177 jAssociationName,
1178 jResultClass,
1179 jRole,
1180 jResultRole,
1181 false,
1182 false,
1183 jPropertyList);
|
1184 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1185 schuur 1.13
|
1186 mark.hamzy 1.23 STAT_PMS_PROVIDEREND;
|
1187 schuur 1.1
|
1188 mark.hamzy 1.23 handler.processing();
1189 if (jVec) {
|
1190 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
1191 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1192 schuur 1.1
|
1193 mark.hamzy 1.24 jobject jInst=env->GetObjectArrayElement(jVec,i);
1194
|
1195 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1196 schuur 1.13
|
1197 mark.hamzy 1.24 jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);
|
1198 schuur 1.13
|
1199 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1200 schuur 1.13
|
1201 mark.hamzy 1.24 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
1202 CIMClass cls = pr._cimom_handle->getClass(context,request->nameSpace,ci->getClassName(),false,true,true,CIMPropertyList());
1203 const CIMObjectPath& op = ci->getPath();
1204 CIMObjectPath iop = ci->buildPath(cls);
1205
|
1206 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
1207 ci->setPath(iop);
|
1208 schuur 1.13
|
1209 mark.hamzy 1.23 handler.deliver(*ci);
1210 }
1211 }
|
1212 mark.hamzy 1.24 handler.complete();
1213 break;
|
1214 mark.hamzy 1.23 }
|
1215 mark.hamzy 1.24
1216 case METHOD_SNIA_PROVIDER20:
1217 {
1218 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &assocPath);
1219 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
1220
1221 JMPIjvm::checkException(env);
1222
1223 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1224 id,
1225 jAssociationName,
1226 jPathName,
1227 jResultClass,
1228 jRole,
1229 jResultRole,
1230 false,
1231 false,
1232 jPropertyList);
|
1233 mark.hamzy 1.23 JMPIjvm::checkException(env);
1234
1235 STAT_PMS_PROVIDEREND;
1236
1237 handler.processing();
|
1238 mark.hamzy 1.24 if (jVec) {
1239 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
1240 mark.hamzy 1.23 JMPIjvm::checkException(env);
1241
|
1242 mark.hamzy 1.24 jobject jInst=env->GetObjectArrayElement(jVec,i);
1243
|
1244 mark.hamzy 1.23 JMPIjvm::checkException(env);
1245
|
1246 mark.hamzy 1.24 jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);
1247
|
1248 mark.hamzy 1.23 JMPIjvm::checkException(env);
1249
|
1250 mark.hamzy 1.24 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
1251 CIMClass cls = pr._cimom_handle->getClass(context,request->nameSpace,ci->getClassName(),false,true,true,CIMPropertyList());
1252 const CIMObjectPath& op = ci->getPath();
1253 CIMObjectPath iop = ci->buildPath(cls);
1254
|
1255 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
1256 ci->setPath(iop);
|
1257 schuur 1.13
|
1258 mark.hamzy 1.23 handler.deliver(*ci);
1259 }
1260 }
|
1261 mark.hamzy 1.24 handler.complete();
1262 break;
1263 }
1264
1265 case METHOD_UNKNOWN:
1266 {
1267 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));
1268 break;
1269 }
|
1270 mark.hamzy 1.23 }
|
1271 schuur 1.1 }
1272 HandlerCatch(handler);
|
1273 schuur 1.13
1274 if (env) JMPIjvm::detachThread();
1275
|
1276 schuur 1.1 PEG_METHOD_EXIT();
1277
1278 return(response);
1279 }
|
1280 schuur 1.13
|
1281 schuur 1.1 Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()
1282 {
|
1283 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleAssociatorNamesRequest");
1284
1285 HandlerIntro(AssociatorNames,message,request,response,handler,Array<CIMObjectPath>());
|
1286 schuur 1.1
|
1287 mark.hamzy 1.24 typedef enum {
1288 METHOD_UNKNOWN = 0,
1289 METHOD_DIRECTOR,
1290 METHOD_SNIA_PROVIDER20
1291 } METHOD_VERSION;
1292 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1293 JNIEnv *env = NULL;
|
1294 schuur 1.13
|
1295 schuur 1.1 try {
1296 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1297 "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1298 System::getHostName(),
1299 request->nameSpace.getString(),
1300 request->objectName.getClassName().getString());
1301
|
1302 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));
1303
|
1304 schuur 1.1 // make target object path
1305 CIMObjectPath objectPath(
1306 System::getHostName(),
1307 request->nameSpace,
1308 request->objectName.getClassName());
1309
1310 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1311
1312 CIMObjectPath assocPath(
1313 System::getHostName(),
1314 request->nameSpace,
1315 request->assocClass.getString());
|
1316 mark.hamzy 1.23
|
1317 schuur 1.1 // resolve provider name
|
1318 kumpf 1.2 ProviderName name = _resolveProviderName(
1319 request->operationContext.get(ProviderIdContainer::NAME));
|
1320 schuur 1.1
1321 // get cached or load new provider module
1322 JMPIProvider::OpProviderHolder ph =
1323 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1324
1325 // convert arguments
1326 OperationContext context;
1327
|
1328 mark.hamzy 1.23 context.insert(request->operationContext.get(IdentityContainer::NAME));
1329 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1330 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1331 schuur 1.1
1332 // forward request
|
1333 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
1334 schuur 1.1
|
1335 mark.hamzy 1.24 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.associatorNames: " + pr.getName());
|
1336 schuur 1.1
|
1337 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: Calling provider associatorNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->assocClass<<PEGASUS_STD(endl));
|
1338 schuur 1.1
|
1339 mark.hamzy 1.24 JvmVector *jv = 0;
1340
1341 env = JMPIjvm::attachThread(&jv);
|
1342 schuur 1.1
|
1343 mark.hamzy 1.24 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
1344 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
1345 mark.hamzy 1.23
1346 JMPIjvm::checkException(env);
1347
|
1348 mark.hamzy 1.24 jstring jResultClass = env->NewStringUTF(request->resultClass.getString().getCString());
1349 jstring jRole = env->NewStringUTF(request->role.getCString());
1350 jstring jResultRole = env->NewStringUTF(request->resultRole.getCString());
1351
|
1352 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1353 schuur 1.1
1354 JMPIProvider::pm_service_op_lock op_lock(&pr);
1355
1356 STAT_GETSTARTTIME;
1357
|
1358 mark.hamzy 1.24 jmethodID id = NULL;
1359
1360 // public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
1361 // java.lang.String resultClass,
1362 // java.lang.String role,
1363 // java.lang.String resultRole)
1364 // throws org.pegasus.jmpi.CIMException
1365 id = env->GetMethodID((jclass)pr.jProviderClass,
1366 "associatorNames",
1367 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
1368
1369 if (id != NULL)
1370 {
1371 eMethodFound = METHOD_DIRECTOR;
1372 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_DIRECTOR."<<PEGASUS_STD(endl));
1373 }
1374
1375 if (id == NULL)
1376 {
1377 env->ExceptionClear();
1378
1379 mark.hamzy 1.24 // public abstract java.util.Vector associatorNames (org.pegasus.jmpi.CIMObjectPath assocName,
1380 // org.pegasus.jmpi.CIMObjectPath pathName,
1381 // java.lang.String resultClass,
1382 // java.lang.String role,
1383 // java.lang.String resultRole)
1384 // throws org.pegasus.jmpi.CIMException
1385 id = env->GetMethodID((jclass)pr.jProviderClass,
1386 "associatorNames",
1387 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Vector;");
1388
1389 if (id != NULL)
1390 {
1391 eMethodFound = METHOD_SNIA_PROVIDER20;
1392 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1393 }
1394 }
|
1395 schuur 1.13
|
1396 mark.hamzy 1.24 if (id == NULL)
1397 {
1398 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: found no method!"<<PEGASUS_STD(endl));
|
1399 mark.hamzy 1.23 }
|
1400 mark.hamzy 1.24
|
1401 schuur 1.1 JMPIjvm::checkException(env);
1402
|
1403 mark.hamzy 1.24 switch (eMethodFound)
1404 {
1405 case METHOD_DIRECTOR:
1406 {
1407 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1408 id,
1409 jAssociationName,
1410 jResultClass,
1411 jRole,
1412 jResultRole);
|
1413 mark.hamzy 1.23 JMPIjvm::checkException(env);
1414
1415 STAT_PMS_PROVIDEREND;
1416
1417 handler.processing();
1418 if (jVec) {
|
1419 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
1420 mark.hamzy 1.23 JMPIjvm::checkException(env);
1421
|
1422 mark.hamzy 1.24 jobject jInst=env->GetObjectArrayElement(jVec,i);
1423
|
1424 mark.hamzy 1.23 JMPIjvm::checkException(env);
1425
|
1426 mark.hamzy 1.24 jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst);
|
1427 mark.hamzy 1.23 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1428
1429 JMPIjvm::checkException(env);
1430
1431 handler.deliver(*cop);
1432 }
1433 }
1434 handler.complete();
|
1435 mark.hamzy 1.24 break;
|
1436 mark.hamzy 1.23 }
|
1437 mark.hamzy 1.24
1438 case METHOD_SNIA_PROVIDER20:
1439 {
1440 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &assocPath);
1441 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
1442
1443 JMPIjvm::checkException(env);
1444
1445 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1446 id,
1447 jAssociationName,
1448 jPathNameRef,
1449 jResultClass,
1450 jRole,
1451 jResultRole);
|
1452 mark.hamzy 1.23 JMPIjvm::checkException(env);
1453
1454 STAT_PMS_PROVIDEREND;
|
1455 schuur 1.13
|
1456 mark.hamzy 1.23 handler.processing();
|
1457 mark.hamzy 1.24 if (jVec) {
1458 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
1459 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1460 schuur 1.13
|
1461 mark.hamzy 1.24 jobject jInst=env->GetObjectArrayElement(jVec,i);
1462
|
1463 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1464 schuur 1.13
|
1465 mark.hamzy 1.24 jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst);
|
1466 mark.hamzy 1.23 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
|
1467 schuur 1.1
|
1468 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1469 schuur 1.1
|
1470 mark.hamzy 1.23 handler.deliver(*cop);
1471 }
1472 }
1473 handler.complete();
|
1474 mark.hamzy 1.24 break;
1475 }
1476
1477 case METHOD_UNKNOWN:
1478 {
1479 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorNamesRequest: should not be here!"<<PEGASUS_STD(endl));
1480 break;
1481 }
|
1482 mark.hamzy 1.23 }
|
1483 schuur 1.1 }
1484 HandlerCatch(handler);
|
1485 schuur 1.12
|
1486 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
|
1487 schuur 1.12
|
1488 schuur 1.1 PEG_METHOD_EXIT();
1489
1490 return(response);
1491 }
1492
1493 Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw()
1494 {
|
1495 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferencesRequest");
1496
1497 HandlerIntro(References,message,request,response,handler,Array<CIMObject>());
|
1498 schuur 1.1
|
1499 mark.hamzy 1.24 typedef enum {
1500 METHOD_UNKNOWN = 0,
1501 METHOD_DIRECTOR,
1502 METHOD_SNIA_PROVIDER20,
1503 } METHOD_VERSION;
1504 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1505 JNIEnv *env = NULL;
1506 CIMPropertyList propertyList;
1507 jobjectArray jPropertyList = NULL;
|
1508 schuur 1.13
|
1509 schuur 1.1 try {
1510 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
|
1511 konrad.r 1.15 "JMPIProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",
|
1512 schuur 1.1 System::getHostName(),
1513 request->nameSpace.getString(),
1514 request->objectName.getClassName().getString());
1515
|
1516 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));
1517
|
1518 schuur 1.1 // make target object path
1519 CIMObjectPath objectPath(
1520 System::getHostName(),
1521 request->nameSpace,
1522 request->objectName.getClassName());
1523
1524 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1525
1526 CIMObjectPath resultPath(
1527 System::getHostName(),
1528 request->nameSpace,
1529 request->resultClass.getString());
1530
1531 // resolve provider name
|
1532 kumpf 1.2 ProviderName name = _resolveProviderName(
1533 request->operationContext.get(ProviderIdContainer::NAME));
|
1534 schuur 1.1
1535 // get cached or load new provider module
1536 JMPIProvider::OpProviderHolder ph =
1537 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1538
1539 // convert arguments
1540 OperationContext context;
1541
|
1542 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
1543 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1544 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1545 schuur 1.1
1546 // forward request
|
1547 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
1548
1549 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.references: " + pr.getName());
|
1550 schuur 1.1
|
1551 mark.hamzy 1.24 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferencesRequest: Calling provider references: "<<pr.getName()<<", role: "<<request->role<<" aCls: "<<request->resultClass<<PEGASUS_STD(endl));
|
1552 schuur 1.1
|
1553 mark.hamzy 1.24 JvmVector *jv = 0;
|
1554 schuur 1.1
|
1555 mark.hamzy 1.24 env = JMPIjvm::attachThread(&jv);
|
1556 schuur 1.1
|
1557 mark.hamzy 1.24 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
1558 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
1559 mark.hamzy 1.23
|
1560 schuur 1.12 JMPIjvm::checkException(env);
|
1561 schuur 1.1
|
1562 mark.hamzy 1.24 jstring jRole = env->NewStringUTF(request->role.getCString());
1563
|
1564 schuur 1.12 JMPIjvm::checkException(env);
|
1565 schuur 1.1
1566 JMPIProvider::pm_service_op_lock op_lock(&pr);
1567
1568 STAT_GETSTARTTIME;
1569
|
1570 mark.hamzy 1.24 jmethodID id = NULL;
1571
1572 // public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,
1573 // java.lang.String role,
1574 // boolean includeQualifiers,
1575 // boolean includeClassOrigin,
1576 // java.lang.String[] propertyList)
1577 // throws org.pegasus.jmpi.CIMException
1578 id = env->GetMethodID((jclass)pr.jProviderClass,
1579 "references",
1580 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
1581
1582 if (id != NULL)
1583 {
1584 eMethodFound = METHOD_DIRECTOR;
1585 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_DIRECTOR."<<PEGASUS_STD(endl));
1586 }
1587
1588 if (id == NULL)
1589 {
1590 env->ExceptionClear();
1591 mark.hamzy 1.24
1592 // public abstract java.util.Vector references (org.pegasus.jmpi.CIMObjectPath assocName,
1593 // org.pegasus.jmpi.CIMObjectPath pathName,
1594 // java.lang.String role,
1595 // boolean includeQualifiers,
1596 // boolean includeClassOrigin,
1597 // java.lang.String[] propertyList)
1598 // throws org.pegasus.jmpi.CIMException
1599 id = env->GetMethodID((jclass)pr.jProviderClass,
1600 "references",
1601 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
1602
1603 if (id != NULL)
1604 {
1605 eMethodFound = METHOD_SNIA_PROVIDER20;
1606 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1607 }
1608 }
|
1609 schuur 1.12
|
1610 mark.hamzy 1.24 if (id == NULL)
1611 {
1612 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));
|
1613 mark.hamzy 1.23 }
|
1614 mark.hamzy 1.24
|
1615 schuur 1.1 JMPIjvm::checkException(env);
1616
|
1617 mark.hamzy 1.24 jPropertyList = getList(jv,env,request->propertyList);
|
1618 schuur 1.13
|
1619 mark.hamzy 1.24 switch (eMethodFound)
1620 {
1621 case METHOD_DIRECTOR:
1622 {
1623 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1624 id,
1625 jAssociationName,
1626 jRole,
1627 false,
1628 false,
1629 jPropertyList);
|
1630 mark.hamzy 1.23 JMPIjvm::checkException(env);
1631
1632 STAT_PMS_PROVIDEREND;
1633
1634 handler.processing();
1635 if (jVec) {
|
1636 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
1637 mark.hamzy 1.23 JMPIjvm::checkException(env);
1638
|
1639 mark.hamzy 1.24 jobject jInst=env->GetObjectArrayElement(jVec,i);
1640
|
1641 mark.hamzy 1.23 JMPIjvm::checkException(env);
1642
|
1643 mark.hamzy 1.24 jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);
|
1644 mark.hamzy 1.23
1645 JMPIjvm::checkException(env);
1646
|
1647 mark.hamzy 1.24 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
1648 CIMClass cls = pr._cimom_handle->getClass(context,
1649 request->nameSpace,
1650 ci->getClassName(),
1651 false,
1652 true,
1653 true,
1654 CIMPropertyList());
1655 const CIMObjectPath& op = ci->getPath();
1656 CIMObjectPath iop = ci->buildPath(cls);
1657
|
1658 mark.hamzy 1.23 iop.setNameSpace(op.getNameSpace());
1659 ci->setPath(iop);
|
1660 schuur 1.13
|
1661 mark.hamzy 1.23 handler.deliver(*ci);
1662 }
1663 }
1664 handler.complete();
|
1665 mark.hamzy 1.24 break;
|
1666 mark.hamzy 1.23 }
|
1667 schuur 1.1
|
1668 mark.hamzy 1.24 case METHOD_SNIA_PROVIDER20:
1669 {
1670 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &resultPath);
1671 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
1672
1673 JMPIjvm::checkException(env);
1674
1675 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1676 id,
1677 jAssociationName,
1678 jPathName,
1679 jRole,
1680 false,
1681 false,
1682 jPropertyList);
1683 JMPIjvm::checkException(env);
1684
1685 STAT_PMS_PROVIDEREND;
1686
1687 handler.processing();
1688 if (jVec) {
1689 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
1690 JMPIjvm::checkException(env);
1691
1692 jobject jInst=env->GetObjectArrayElement(jVec,i);
1693
1694 JMPIjvm::checkException(env);
1695
1696 jint jCi = env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst);
1697
1698 JMPIjvm::checkException(env);
1699
1700 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
1701 CIMClass cls = pr._cimom_handle->getClass(context,
1702 request->nameSpace,
1703 ci->getClassName(),
1704 false,
1705 true,
1706 true,
1707 CIMPropertyList());
1708 const CIMObjectPath& op = ci->getPath();
1709 CIMObjectPath iop = ci->buildPath(cls);
|
1710 schuur 1.1
|
1711 mark.hamzy 1.24 iop.setNameSpace(op.getNameSpace());
1712 ci->setPath(iop);
|
1713 schuur 1.12
|
1714 mark.hamzy 1.24 handler.deliver(*ci);
1715 }
1716 }
1717 handler.complete();
1718 break;
1719 }
|
1720 mark.hamzy 1.23
|
1721 mark.hamzy 1.24 case METHOD_UNKNOWN:
1722 {
1723 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));
1724 break;
1725 }
|
1726 mark.hamzy 1.23 }
|
1727 schuur 1.1 }
1728 HandlerCatch(handler);
|
1729 schuur 1.12
1730 if (env) JMPIjvm::detachThread();
1731
|
1732 schuur 1.1 PEG_METHOD_EXIT();
1733
1734 return(response);
1735 }
1736
1737 Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw()
1738 {
|
1739 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleReferenceNamesRequest");
1740
1741 HandlerIntro(ReferenceNames,message,request,response,handler,Array<CIMObjectPath>());
|
1742 schuur 1.1
|
1743 mark.hamzy 1.24 typedef enum {
1744 METHOD_UNKNOWN = 0,
1745 METHOD_DIRECTOR,
1746 METHOD_SNIA_PROVIDER20,
1747 } METHOD_VERSION;
1748 METHOD_VERSION eMethodFound = METHOD_UNKNOWN;
1749 JNIEnv *env = NULL;
|
1750 schuur 1.13
|
1751 schuur 1.1 try {
1752 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1753 "JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1754 System::getHostName(),
1755 request->nameSpace.getString(),
1756 request->objectName.getClassName().getString());
1757
|
1758 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));
1759
|
1760 schuur 1.1 // make target object path
1761 CIMObjectPath objectPath(
1762 System::getHostName(),
1763 request->nameSpace,
1764 request->objectName.getClassName());
1765
1766 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1767
1768 CIMObjectPath resultPath(
1769 System::getHostName(),
1770 request->nameSpace,
1771 request->resultClass.getString());
1772
1773 // resolve provider name
|
1774 kumpf 1.2 ProviderName name = _resolveProviderName(
1775 request->operationContext.get(ProviderIdContainer::NAME));
|
1776 schuur 1.1
1777 // get cached or load new provider module
1778 JMPIProvider::OpProviderHolder ph =
1779 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1780
1781 // convert arguments
1782 OperationContext context;
1783
|
1784 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
1785 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1786 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1787 schuur 1.1
|
1788 mark.hamzy 1.24 JMPIProvider &pr = ph.GetProvider();
|
1789 schuur 1.1
|
1790 mark.hamzy 1.24 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,"Calling provider.referenceNames: " + pr.getName());
|
1791 schuur 1.1
|
1792 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleReferenceNamesRequest: Calling provider referenceNames: "<<pr.getName()<<", role: "<<request->role<<", aCls: "<<request->resultClass<<PEGASUS_STD(endl));
|
1793 schuur 1.12
|
1794 mark.hamzy 1.24 JvmVector *jv = 0;
1795
1796 env = JMPIjvm::attachThread(&jv);
|
1797 schuur 1.1
|
1798 mark.hamzy 1.24 jint jAssociationNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
1799 jobject jAssociationName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jAssociationNameRef);
|
1800 schuur 1.1
|
1801 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1802 schuur 1.11
|
1803 mark.hamzy 1.24 jstring jRole = env->NewStringUTF(request->role.getCString());
1804
|
1805 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1806 schuur 1.1
1807 JMPIProvider::pm_service_op_lock op_lock(&pr);
1808
1809 STAT_GETSTARTTIME;
1810
|
1811 mark.hamzy 1.24 jmethodID id = NULL;
1812
1813 // public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
1814 // java.lang.String role)
1815 // throws org/pegasus/jmpi/CIMException
1816 id = env->GetMethodID((jclass)pr.jProviderClass,
1817 "referenceNames",
1818 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
1819
1820 if (id != NULL)
1821 {
1822 eMethodFound = METHOD_DIRECTOR;
1823 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_DIRECTOR."<<PEGASUS_STD(endl));
1824 }
1825
1826 if (id == NULL)
1827 {
1828 env->ExceptionClear();
1829
1830 // public abstract java.util.Vector referenceNames (org.pegasus.jmpi.CIMObjectPath assocName,
1831 // org.pegasus.jmpi.CIMObjectPath pathName,
1832 mark.hamzy 1.24 // java.lang.String role)
1833 // throws org/pegasus/jmpi/CIMException
1834 id = env->GetMethodID((jclass)pr.jProviderClass,
1835 "referenceNames",
1836 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
1837
1838 if (id != NULL)
1839 {
1840 eMethodFound = METHOD_SNIA_PROVIDER20;
1841 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found METHOD_SNIA_PROVIDER20."<<PEGASUS_STD(endl));
1842 }
1843 }
|
1844 schuur 1.11
|
1845 mark.hamzy 1.24 if (id == NULL)
1846 {
1847 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: found no method!"<<PEGASUS_STD(endl));
|
1848 mark.hamzy 1.23 }
|
1849 mark.hamzy 1.24
|
1850 schuur 1.1 JMPIjvm::checkException(env);
1851
|
1852 mark.hamzy 1.24 switch (eMethodFound)
1853 {
1854 case METHOD_DIRECTOR:
1855 {
1856 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1857 id,
1858 jAssociationName,
1859 jRole);
|
1860 mark.hamzy 1.23 JMPIjvm::checkException(env);
1861
1862 STAT_PMS_PROVIDEREND;
1863
1864 handler.processing();
1865 if (jVec) {
|
1866 mark.hamzy 1.24 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
1867 mark.hamzy 1.23 JMPIjvm::checkException(env);
1868
|
1869 mark.hamzy 1.24 jobject jInst=env->GetObjectArrayElement(jVec,i);
1870
|
1871 mark.hamzy 1.23 JMPIjvm::checkException(env);
1872
|
1873 mark.hamzy 1.24 jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst);
|
1874 mark.hamzy 1.23
1875 JMPIjvm::checkException(env);
1876
|
1877 mark.hamzy 1.24 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1878
|
1879 mark.hamzy 1.23 handler.deliver(*cop);
1880 }
1881 }
1882 handler.complete();
|
1883 mark.hamzy 1.24 break;
|
1884 mark.hamzy 1.23 }
|
1885 mark.hamzy 1.24
1886 case METHOD_SNIA_PROVIDER20:
1887 {
1888 jint jPathNameRef = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &resultPath);
1889 jobject jPathName = env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jPathNameRef);
1890
1891 JMPIjvm::checkException(env);
1892
1893 jobjectArray jVec=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,
1894 id,
1895 jAssociationName,
1896 jPathName,
1897 jRole);
|
1898 mark.hamzy 1.23 JMPIjvm::checkException(env);
1899
1900 STAT_PMS_PROVIDEREND;
|
1901 schuur 1.13
|
1902 mark.hamzy 1.23 handler.processing();
|
1903 mark.hamzy 1.24 if (jVec) {
1904 for (int i=0,m=env->GetArrayLength(jVec); i<m; i++) {
|
1905 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1906 schuur 1.13
|
1907 mark.hamzy 1.24 jobject jInst=env->GetObjectArrayElement(jVec,i);
1908
|
1909 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1910 schuur 1.13
|
1911 mark.hamzy 1.24 jint jCop = env->CallIntMethod(jInst,JMPIjvm::jv.CIMObjectPathCInst);
|
1912 schuur 1.1
|
1913 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1914 schuur 1.1
|
1915 mark.hamzy 1.24 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1916
|
1917 mark.hamzy 1.23 handler.deliver(*cop);
1918 }
1919 }
1920 handler.complete();
|
1921 mark.hamzy 1.24 break;
1922 }
1923
1924 case METHOD_UNKNOWN:
1925 {
1926 DDD (PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleAssociatorsRequest: should not be here!"<<PEGASUS_STD(endl));
1927 break;
1928 }
|
1929 mark.hamzy 1.23 }
|
1930 schuur 1.1 }
1931 HandlerCatch(handler);
|
1932 schuur 1.11
1933 if (env) JMPIjvm::detachThread();
1934
|
1935 schuur 1.1 PEG_METHOD_EXIT();
1936
1937 return(response);
1938 }
1939
1940 Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw()
1941 {
|
1942 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleInvokeMethodRequest");
1943
1944 HandlerIntroMethod(InvokeMethod,message,request,response,handler);
|
1945 schuur 1.1
|
1946 schuur 1.11 JNIEnv *env=NULL;
|
1947 schuur 1.13 Boolean mode24=false;
1948
|
1949 schuur 1.1 try {
1950 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1951 "JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",
1952 System::getHostName(),
1953 request->nameSpace.getString(),
1954 request->instanceName.getClassName().getString());
1955
|
1956 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));
1957
|
1958 schuur 1.1 // make target object path
1959 CIMObjectPath objectPath(
1960 System::getHostName(),
1961 request->nameSpace,
1962 request->instanceName.getClassName(),
1963 request->instanceName.getKeyBindings());
1964
1965 // resolve provider name
|
1966 kumpf 1.2 ProviderName name = _resolveProviderName(
1967 request->operationContext.get(ProviderIdContainer::NAME));
|
1968 schuur 1.1
1969 // get cached or load new provider module
1970 JMPIProvider::OpProviderHolder ph =
1971 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1972
1973 // convert arguments
1974 OperationContext context;
1975
|
1976 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
1977 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1978 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1979 schuur 1.1
|
1980 mark.hamzy 1.23 JMPIProvider & pr=ph.GetProvider();
|
1981 schuur 1.1
1982 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1983 "Calling provider.invokeMethod: " + pr.getName());
1984
|
1985 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleInvokeMethodRequest: Calling provider invokeMethod: "<<pr.getName()<<PEGASUS_STD(endl));
1986 JvmVector *jv;
|
1987 schuur 1.11 env=JMPIjvm::attachThread(&jv);
1988
|
1989 mark.hamzy 1.23 jint jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &objectPath);
1990
1991 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
1992 JMPIjvm::checkException(env);
|
1993 schuur 1.11
1994 jstring jMethod=env->NewStringUTF(request->methodName.getString().getCString());
|
1995 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
1996 schuur 1.11
|
1997 schuur 1.1 STAT_GETSTARTTIME;
1998
|
1999 schuur 1.11 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"invokeMethod",
2000 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
|
2001 mark.hamzy 1.23 "Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
|
2002 schuur 1.13
|
2003 mark.hamzy 1.23 if (id==NULL) {
|
2004 schuur 1.13 env->ExceptionClear();
|
2005 mark.hamzy 1.23 id=env->GetMethodID((jclass)pr.jProviderClass,"invokeMethod",
|
2006 schuur 1.13 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
|
2007 mark.hamzy 1.23 "[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
|
2008 schuur 1.13 JMPIjvm::checkException(env);
|
2009 mark.hamzy 1.23 mode24=true;
2010 }
|
2011 schuur 1.11 JMPIjvm::checkException(env);
2012
|
2013 mark.hamzy 1.23 if (!mode24) {
2014 jobject jVecIn=env->NewObject(jv->VectorClassRef,jv->VectorNew);
2015 JMPIjvm::checkException(env);
2016 for (int i=0,m=request->inParameters.size(); i<m; i++) {
2017 const CIMParamValue &parm = request->inParameters[i];
2018 const CIMValue v = parm.getValue();
2019 CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
2020 jint jObj = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
2021
2022 jobject prop=env->NewObject(jv->CIMPropertyClassRef,jv->CIMPropertyNewI,jObj);
2023
2024 env->CallVoidMethod(jVecIn,jv->VectorAddElement,prop);
2025 }
2026
2027 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
2028 JMPIjvm::checkException(env);
2029
2030 jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jVecIn,jVecOut);
2031 JMPIjvm::checkException(env);
2032
2033 STAT_PMS_PROVIDEREND;
2034 mark.hamzy 1.23
2035 handler.processing();
2036
2037 jint jv = env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst);
2038 CIMValue *v = DEBUG_ConvertJavaToC (jint, CIMValue*, jv);
2039
2040 handler.deliver(*v);
|
2041 schuur 1.13
|
2042 mark.hamzy 1.23 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++) {
2043 JMPIjvm::checkException(env);
|
2044 schuur 1.13
|
2045 mark.hamzy 1.23 jobject jProp=env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
2046 JMPIjvm::checkException(env);
|
2047 schuur 1.13
|
2048 mark.hamzy 1.23 jint jp = env->CallIntMethod(jProp,JMPIjvm::jv.PropertyCInst);
2049 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);
|
2050 schuur 1.13
|
2051 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2052 schuur 1.1
|
2053 mark.hamzy 1.23 handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
2054 }
|
2055 schuur 1.1
|
2056 mark.hamzy 1.23 handler.complete();
2057 }
|
2058 schuur 1.13 else {
|
2059 mark.hamzy 1.23 Uint32 m=request->inParameters.size();
|
2060 schuur 1.11
|
2061 mark.hamzy 1.23 jobjectArray jArIn=(jobjectArray)env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
|
2062 schuur 1.13 for (Uint32 i=0; i<m; i++) {
|
2063 mark.hamzy 1.23 CIMParamValue *parm = new CIMParamValue(request->inParameters[i]);
2064 jint jObj = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);
2065 jobject jArg = env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,jObj);
2066
|
2067 schuur 1.13 env->SetObjectArrayElement(jArIn,i,jArg);
|
2068 mark.hamzy 1.23 }
2069
2070 jobjectArray jArOut=(jobjectArray)env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
2071
2072 jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jArIn,jArOut);
2073 JMPIjvm::checkException(env);
2074
2075 STAT_PMS_PROVIDEREND;
2076
2077 handler.processing();
|
2078 schuur 1.1
|
2079 mark.hamzy 1.23 jint jv = env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst);
2080 CIMValue *v = DEBUG_ConvertJavaToC (jint, CIMValue*, jv);
2081
2082 handler.deliver(*v);
2083
2084 for (int i=0; i<24; i++) {
2085 jobject jArg=env->GetObjectArrayElement(jArOut,i);
2086 JMPIjvm::checkException(env);
|
2087 schuur 1.13
|
2088 mark.hamzy 1.23 if (jArg==NULL) break;
|
2089 schuur 1.13
|
2090 mark.hamzy 1.23 jint jp = env->CallIntMethod(jArg,JMPIjvm::jv.ArgumentCInst);
2091 CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp);
|
2092 schuur 1.13
|
2093 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2094 schuur 1.13
|
2095 mark.hamzy 1.23 handler.deliverParamValue(*p);
|
2096 schuur 1.13 }
|
2097 mark.hamzy 1.23
|
2098 schuur 1.13 handler.complete();
|
2099 mark.hamzy 1.23 }
|
2100 schuur 1.1 }
2101 HandlerCatch(handler);
|
2102 schuur 1.11
2103 if (env) JMPIjvm::detachThread();
2104
|
2105 schuur 1.1 PEG_METHOD_EXIT();
2106
|
2107 schuur 1.11 return(response);
|
2108 schuur 1.1 }
|
2109 mark.hamzy 1.23
|
2110 schuur 1.1 int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance,
2111 String& providerName, String& location)
2112 {
2113 Uint32 pos = pInstance.findProperty(CIMName ("Name"));
2114 pInstance.getProperty(pos).getValue().get(providerName);
2115
2116 pos = pmInstance.findProperty(CIMName ("Location"));
2117 pmInstance.getProperty(pos).getValue().get(location);
2118 return 0;
2119 }
2120
2121 Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()
2122 {
|
2123 konrad.r 1.15 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleCreateSubscriptionRequest");
|
2124 schuur 1.1
|
2125 mark.hamzy 1.23 HandlerIntroInd(CreateSubscription,message,request,response,handler);
2126
|
2127 schuur 1.12 JNIEnv *env=NULL;
|
2128 schuur 1.1 try {
2129 const CIMObjectPath &x=request->subscriptionInstance.getPath();
2130
|
2131 schuur 1.12 String providerName,providerLocation;
2132 CIMInstance req_provider, req_providerModule;
2133 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
2134 req_provider = pidc.getProvider();
2135 req_providerModule = pidc.getModule();
2136 LocateIndicationProviderNames(req_provider, req_providerModule,providerName,providerLocation);
|
2137 schuur 1.1
2138 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2139 "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
2140 System::getHostName(),
2141 request->nameSpace.getString(),
2142 providerName);
2143
|
2144 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));
2145
|
2146 schuur 1.1 String fileName = resolveFileName(providerLocation);
2147
2148 // get cached or load new provider module
2149 JMPIProvider::OpProviderHolder ph =
2150 providerManager.getProvider(fileName, providerName, String::EMPTY);
2151
2152 indProvRecord *prec=NULL;
|
2153 schuur 1.12 provTab.lookup(providerName,prec);
|
2154 mark.hamzy 1.23 if (prec)
2155 prec->count++;
|
2156 schuur 1.1 else {
|
2157 schuur 1.12 prec=new indProvRecord();
2158 provTab.insert(providerName,prec);
2159 }
|
2160 schuur 1.1
|
2161 carolann.graves 1.21 //
2162 // Save the provider instance from the request
2163 //
2164 ph.GetProvider ().setProviderInstance (req_provider);
2165
|
2166 schuur 1.1 indSelectRecord *srec=new indSelectRecord();
2167 const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
|
2168 schuur 1.12 selxTab.insert(sPath.toString(),srec);
|
2169 schuur 1.1
2170 // convert arguments
2171 OperationContext *context=new OperationContext();
2172
|
2173 mark.hamzy 1.23 if (prec->ctx==NULL) {
|
2174 schuur 1.12 prec->ctx=context;
|
2175 mark.hamzy 1.23 }
|
2176 schuur 1.12
2177 context->insert(request->operationContext.get(IdentityContainer::NAME));
2178 context->insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2179 context->insert(request->operationContext.get(ContentLanguageListContainer::NAME));
2180 context->insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
2181 context->insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
2182 context->insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
|
2183 schuur 1.1
2184 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
2185
|
2186 schuur 1.12 SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get
2187 (SubscriptionFilterConditionContainer::NAME);
2188
|
2189 konrad.r 1.22 JMPIProvider & pr=ph.GetProvider();
2190
2191 CIMOMHandleQueryContext *qcontext=new CIMOMHandleQueryContext(CIMNamespaceName(request->nameSpace.getString()),
2192 *pr._cimom_handle);
2193
|
2194 konrad.r 1.20 CMPI_SelectExp *eSelx=new CMPI_SelectExp(*context,
|
2195 konrad.r 1.22 qcontext,
|
2196 konrad.r 1.20 request->query,
2197 sub_cntr.getQueryLanguage());
|
2198 konrad.r 1.22
|
2199 schuur 1.12 srec->eSelx=eSelx;
|
2200 konrad.r 1.22 srec->qContext=qcontext;
|
2201 schuur 1.1
2202
2203 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2204 "Calling provider.createSubscriptionRequest: " + pr.getName());
2205
|
2206 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleCreateSubscriptionRequest: Calling provider createSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
|
2207 schuur 1.1
2208 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) {
2209 CIMObjectPath className(
2210 System::getHostName(),
2211 request->nameSpace,
2212 request->classNames[i]);
2213 eSelx->classNames.append(className);
2214 }
2215
2216 CIMPropertyList propertyList = request->propertyList;
|
2217 schuur 1.12 if (!propertyList.isNull()) {
|
2218 schuur 1.1 Array<CIMName> p=propertyList.getPropertyNameArray();
2219 int pCount=p.size();
2220 eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*));
2221 for (int i=0; i<pCount; i++) {
2222 eSelx->props[i]=strdup(p[i].getString().getCString());
|
2223 mark.hamzy 1.23 }
|
2224 schuur 1.1 eSelx->props[pCount]=NULL;
2225 }
2226
|
2227 mark.hamzy 1.23 JvmVector *jv;
|
2228 schuur 1.12 env=JMPIjvm::attachThread(&jv);
2229
|
2230 mark.hamzy 1.23 jint jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
2231
2232 jobject jSel=env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj);
2233 JMPIjvm::checkException(env);
2234
2235 jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);
2236
2237 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
2238 JMPIjvm::checkException(env);
|
2239 schuur 1.12
2240 jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString());
|
2241 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2242 schuur 1.1
2243 JMPIProvider::pm_service_op_lock op_lock(&pr);
2244
2245 STAT_GETSTARTTIME;
2246
|
2247 schuur 1.12 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"activateFilter",
2248 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
|
2249 mark.hamzy 1.23 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
2250 schuur 1.12 JMPIjvm::checkException(env);
2251
2252 env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType,
|
2253 mark.hamzy 1.23 jRef,(jboolean)0);
|
2254 schuur 1.12 JMPIjvm::checkException(env);
|
2255 schuur 1.1
|
2256 carolann.graves 1.21 //
2257 // Increment count of current subscriptions for this provider
2258 //
2259 if (ph.GetProvider ().testIfZeroAndIncrementSubscriptions ())
2260 {
2261 //
2262 // If there were no current subscriptions before the increment,
2263 // the first subscription has been created
2264 // Call the provider's enableIndications method
2265 //
2266 if (_subscriptionInitComplete)
2267 {
2268 prec->enabled = true;
2269 CIMRequestMessage * request = 0;
2270 CIMResponseMessage * response = 0;
2271 prec->handler = new EnableIndicationsResponseHandler
2272 (request, response, req_provider, _indicationCallback);
2273 }
2274 }
2275
|
2276 schuur 1.1 STAT_PMS_PROVIDEREND;
2277
2278 }
2279 HandlerCatch(handler);
|
2280 schuur 1.12
|
2281 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
2282
|
2283 schuur 1.1 PEG_METHOD_EXIT();
2284
2285 return(response);
2286 }
2287
2288 Message * JMPIProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()
2289 {
2290 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest");
2291
|
2292 mark.hamzy 1.23 HandlerIntroInd(DeleteSubscription,message,request,response,handler);
2293
|
2294 schuur 1.12 JNIEnv *env=NULL;
|
2295 schuur 1.1 try {
|
2296 schuur 1.12 String providerName,providerLocation;
2297 CIMInstance req_provider, req_providerModule;
2298 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
2299 req_provider = pidc.getProvider();
2300 req_providerModule = pidc.getModule();
|
2301 se.gupta 1.9
|
2302 schuur 1.12 LocateIndicationProviderNames(req_provider, req_providerModule,
2303 providerName,providerLocation);
|
2304 schuur 1.1
2305 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
2306 "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
2307 System::getHostName(),
2308 request->nameSpace.getString(),
2309 providerName);
2310
|
2311 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: hostname = "<<System::getHostName()<<", namespace = "<<request->nameSpace.getString()<<", providername = "<<providerName<<PEGASUS_STD(endl));
2312
|
2313 schuur 1.1 String fileName = resolveFileName(providerLocation);
2314
2315 // get cached or load new provider module
2316 JMPIProvider::OpProviderHolder ph =
2317 providerManager.getProvider(fileName, providerName, String::EMPTY);
2318
2319 indProvRecord *prec=NULL;
|
2320 schuur 1.12 provTab.lookup(providerName,prec);
2321 if (--prec->count<=0) {
2322 provTab.remove(providerName);
2323 prec=NULL;
2324 }
|
2325 schuur 1.1
2326 indSelectRecord *srec=NULL;
2327 const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
|
2328 schuur 1.12 String sPathString=sPath.toString();
2329 selxTab.lookup(sPathString,srec);
|
2330 schuur 1.1
2331 CMPI_SelectExp *eSelx=srec->eSelx;
|
2332 mark.hamzy 1.23 CIMOMHandleQueryContext *qContext=srec->qContext;
|
2333 konrad.r 1.22
|
2334 schuur 1.12 selxTab.remove(sPathString);
|
2335 schuur 1.1
|
2336 schuur 1.12 // convert arguments
|
2337 schuur 1.1 OperationContext context;
2338
|
2339 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
2340 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
2341 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
2342 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
2343 context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
2344
|
2345 schuur 1.1 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
2346
|
2347 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
2348 schuur 1.1
2349 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
2350 "Calling provider.deleteSubscriptionRequest: " + pr.getName());
2351
|
2352 mark.hamzy 1.23 DDD(PEGASUS_STD(cout)<<"--- JMPIProviderManager::handleDeleteSubscriptionRequest: Calling provider deleteSubscriptionRequest: "<<pr.getName()<<PEGASUS_STD(endl));
|
2353 schuur 1.1
|
2354 mark.hamzy 1.23 JvmVector *jv;
|
2355 schuur 1.12 env=JMPIjvm::attachThread(&jv);
2356
|
2357 mark.hamzy 1.23 jint jObj = DEBUG_ConvertCToJava (CMPI_SelectExp*, jint, eSelx);
2358
2359 jobject jSel=env->NewObject(jv->SelectExpClassRef,jv->SelectExpNewI,jObj);
2360 JMPIjvm::checkException(env);
2361
2362 jObj = DEBUG_ConvertCToJava (CIMObjectPath*, jint, &eSelx->classNames[0]);
2363
2364 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,jv->CIMObjectPathNewI,jObj);
2365 JMPIjvm::checkException(env);
|
2366 schuur 1.12
2367 jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString());
|
2368 mark.hamzy 1.23 JMPIjvm::checkException(env);
|
2369 schuur 1.12
|
2370 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
2371
2372 STAT_GETSTARTTIME;
2373
|
2374 schuur 1.12 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"deActivateFilter",
2375 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
|
2376 mark.hamzy 1.23 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
|
2377 schuur 1.12 JMPIjvm::checkException(env);
|
2378 schuur 1.1
|
2379 schuur 1.12 env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType,
|
2380 mark.hamzy 1.23 jRef,(jboolean)(prec==NULL));
|
2381 schuur 1.12 JMPIjvm::checkException(env);
|
2382 schuur 1.1
|
2383 carolann.graves 1.21 //
2384 // Decrement count of current subscriptions for this provider
2385 //
2386 if (ph.GetProvider ().decrementSubscriptionsAndTestIfZero ())
2387 {
2388 //
2389 // If there are no current subscriptions after the decrement,
2390 // the last subscription has been deleted
2391 // Call the provider's disableIndications method
2392 //
2393 if (_subscriptionInitComplete)
2394 {
2395 prec->enabled = false;
2396 if (prec->handler) delete prec->handler;
2397 prec->handler = NULL;
2398 }
2399 }
2400
|
2401 schuur 1.1 STAT_PMS_PROVIDEREND;
2402
|
2403 schuur 1.12 delete eSelx;
|
2404 mark.hamzy 1.23 delete qContext;
2405 delete srec;
|
2406 schuur 1.12
|
2407 schuur 1.1 }
2408 HandlerCatch(handler);
|
2409 schuur 1.12
|
2410 mark.hamzy 1.23 if (env) JMPIjvm::detachThread();
2411
|
2412 schuur 1.1 PEG_METHOD_EXIT();
2413
2414 return(response);
2415 }
2416
2417 Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw()
2418 {
2419 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDisableModuleRequest");
2420
2421 CIMDisableModuleRequestMessage * request =
2422 dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));
2423
2424 PEGASUS_ASSERT(request != 0);
2425
2426 // get provider module name
2427 String moduleName;
2428 CIMInstance mInstance = request->providerModule;
2429 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
2430
2431 if(pos != PEG_NOT_FOUND)
2432 {
2433 schuur 1.1 mInstance.getProperty(pos).getValue().get(moduleName);
2434 }
2435
2436 Boolean disableProviderOnly = request->disableProviderOnly;
2437
2438 Array<Uint16> operationalStatus;
|
2439 kumpf 1.2 // Assume success.
|
2440 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
2441 schuur 1.1
|
2442 kumpf 1.2 //
|
2443 schuur 1.1 // Unload providers
|
2444 kumpf 1.2 //
|
2445 schuur 1.1 Array<CIMInstance> _pInstances = request->providers;
2446
2447 CIMDisableModuleResponseMessage * response =
2448 new CIMDisableModuleResponseMessage(
2449 request->messageId,
2450 CIMException(),
2451 request->queueIds.copyAndPop(),
2452 operationalStatus);
2453
2454 PEGASUS_ASSERT(response != 0);
2455
2456 // preserve message key
2457 response->setKey(request->getKey());
2458
2459 //
2460 // Set HTTP method in response from request
2461 //
2462 response->setHttpMethod (request->getHttpMethod ());
2463
2464 PEG_METHOD_EXIT();
2465
2466 schuur 1.1 return(response);
2467 }
2468
2469 Message * JMPIProviderManager::handleEnableModuleRequest(const Message * message) throw()
2470 {
2471 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnableModuleRequest");
2472
2473 CIMEnableModuleRequestMessage * request =
2474 dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));
2475
2476 PEGASUS_ASSERT(request != 0);
2477
2478 Array<Uint16> operationalStatus;
|
2479 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
|
2480 schuur 1.1
2481 CIMEnableModuleResponseMessage * response =
2482 new CIMEnableModuleResponseMessage(
2483 request->messageId,
2484 CIMException(),
2485 request->queueIds.copyAndPop(),
2486 operationalStatus);
2487
2488 PEGASUS_ASSERT(response != 0);
2489
2490 // preserve message key
2491 response->setKey(request->getKey());
2492
2493 // Set HTTP method in response from request
2494 response->setHttpMethod (request->getHttpMethod ());
2495
2496 PEG_METHOD_EXIT();
2497
2498 return(response);
2499 }
2500
2501 schuur 1.1 Message * JMPIProviderManager::handleStopAllProvidersRequest(const Message * message) throw()
2502 {
2503 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleStopAllProvidersRequest");
2504
2505 CIMStopAllProvidersRequestMessage * request =
2506 dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));
2507
2508 PEGASUS_ASSERT(request != 0);
2509
2510 CIMStopAllProvidersResponseMessage * response =
2511 new CIMStopAllProvidersResponseMessage(
2512 request->messageId,
2513 CIMException(),
2514 request->queueIds.copyAndPop());
2515
2516 PEGASUS_ASSERT(response != 0);
2517
2518 // preserve message key
2519 response->setKey(request->getKey());
2520
2521 // Set HTTP method in response from request
2522 schuur 1.1 response->setHttpMethod (request->getHttpMethod ());
2523
2524 // tell the provider manager to shutdown all the providers
2525 providerManager.shutdownAllProviders();
2526
2527 PEG_METHOD_EXIT();
2528
2529 return(response);
2530 }
2531
|
2532 kumpf 1.4 Message * JMPIProviderManager::handleInitializeProviderRequest(const Message * message)
2533 {
2534 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleInitializeProviderRequest");
2535
2536 HandlerIntroInit(InitializeProvider,message,request,response,handler);
2537
2538 try
2539 {
2540 // resolve provider name
|
2541 mark.hamzy 1.23 ProviderName name = _resolveProviderName(
2542 request->operationContext.get(ProviderIdContainer::NAME));
|
2543 kumpf 1.4
2544 // get cached or load new provider module
2545 JMPIProvider::OpProviderHolder ph =
|
2546 mark.hamzy 1.23 providerManager.getProvider(name.getPhysicalName(),
2547 name.getLogicalName(), String::EMPTY);
|
2548 kumpf 1.4
2549 }
2550 HandlerCatch(handler);
2551
2552 PEG_METHOD_EXIT();
2553
2554 return(response);
2555 }
2556
|
2557 carolann.graves 1.21 Message * JMPIProviderManager::handleSubscriptionInitCompleteRequest
2558 (const Message * message)
2559 {
2560 PEG_METHOD_ENTER (TRC_PROVIDERMANAGER,
2561 "JMPIProviderManager::handleSubscriptionInitCompleteRequest");
2562
2563 CIMSubscriptionInitCompleteRequestMessage * request =
2564 dynamic_cast <CIMSubscriptionInitCompleteRequestMessage *>
2565 (const_cast <Message *> (message));
2566
2567 PEGASUS_ASSERT (request != 0);
2568
2569 CIMSubscriptionInitCompleteResponseMessage * response =
2570 dynamic_cast <CIMSubscriptionInitCompleteResponseMessage *>
2571 (request->buildResponse ());
2572
2573 PEGASUS_ASSERT (response != 0);
2574
2575 //
2576 // Set indicator
2577 //
2578 carolann.graves 1.21 _subscriptionInitComplete = true;
2579
2580 //
2581 // For each provider that has at least one subscription, call
2582 // provider's enableIndications method
2583 //
2584 Array <JMPIProvider *> enableProviders;
2585 enableProviders = providerManager.getIndicationProvidersToEnable ();
2586
2587 Uint32 numProviders = enableProviders.size ();
2588 for (Uint32 i = 0; i < numProviders; i++)
2589 {
2590 try
2591 {
2592 CIMInstance provider;
2593 provider = enableProviders [i]->getProviderInstance ();
2594
2595 //
2596 // Get cached or load new provider module
2597 //
2598 JMPIProvider::OpProviderHolder ph = providerManager.getProvider
2599 carolann.graves 1.21 (enableProviders [i]->getModule ()->getFileName (),
2600 enableProviders [i]->getName ());
2601
2602 indProvRecord * prec = NULL;
2603 provTab.lookup (enableProviders [i]->getName (), prec);
2604 if (prec)
2605 {
2606 prec->enabled = true;
2607 CIMRequestMessage * request = 0;
2608 CIMResponseMessage * response = 0;
2609 prec->handler = new EnableIndicationsResponseHandler
2610 (request, response, provider, _indicationCallback);
2611 }
2612 }
2613 catch (CIMException & e)
2614 {
2615 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
2616 "CIMException: " + e.getMessage ());
2617 }
2618 catch (Exception & e)
2619 {
2620 carolann.graves 1.21 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
2621 "Exception: " + e.getMessage ());
2622 }
2623 catch(...)
2624 {
2625 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
2626 "Unknown error in handleSubscriptionInitCompleteRequest");
2627 }
2628 }
2629
2630 PEG_METHOD_EXIT ();
2631 return (response);
2632 }
2633
|
2634 schuur 1.1 Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw()
2635 {
|
2636 mark.hamzy 1.23 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIProviderManager::handleUnsupportedRequest");
2637
|
2638 konrad.r 1.16 CIMRequestMessage* request =
2639 dynamic_cast<CIMRequestMessage *>(const_cast<Message *>(message));
2640 PEGASUS_ASSERT(request != 0 );
2641
2642 CIMResponseMessage* response = request->buildResponse();
2643 response->cimException =
2644 PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED, String::EMPTY);
|
2645 schuur 1.1
2646 PEG_METHOD_EXIT();
|
2647 konrad.r 1.16 return response;
|
2648 schuur 1.1 }
2649
|
2650 kumpf 1.2 ProviderName JMPIProviderManager::_resolveProviderName(
2651 const ProviderIdContainer & providerId)
|
2652 schuur 1.1 {
|
2653 kumpf 1.2 String providerName;
2654 String fileName;
2655 String interfaceName;
2656 CIMValue genericValue;
2657
2658 genericValue = providerId.getProvider().getProperty(
2659 providerId.getProvider().findProperty("Name")).getValue();
2660 genericValue.get(providerName);
2661
2662 genericValue = providerId.getModule().getProperty(
2663 providerId.getModule().findProperty("Location")).getValue();
2664 genericValue.get(fileName);
2665 fileName = resolveFileName(fileName);
2666
2667 // ATTN: This attribute is probably not required
2668 genericValue = providerId.getModule().getProperty(
2669 providerId.getModule().findProperty("InterfaceType")).getValue();
2670 genericValue.get(interfaceName);
2671
2672 return ProviderName(providerName, fileName, interfaceName, 0);
|
2673 schuur 1.1 }
2674
2675 String JMPIProviderManager::resolveFileName(String fileName)
2676 {
2677 String name;
2678 #if defined(PEGASUS_OS_TYPE_WINDOWS)
2679 name = fileName; // + String(".dll");
2680 #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
2681 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
2682 name.append(String("/") + fileName); // + String(".sl"));
2683 #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
2684 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
2685 name.append(String("/") + fileName); // + String(".so"));
2686 #elif defined(PEGASUS_OS_OS400)
2687 name = filrName;
2688 #else
2689 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
2690 name.append(String("/") + fileName); // + String(".so"));
2691 #endif
2692 return name;
2693 }
2694 schuur 1.1
2695 PEGASUS_NAMESPACE_END
|
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI