1 schuur 1.1 //%2003////////////////////////////////////////////////////////////////////////
2 //
3 // 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 // IBM Corp.; EMC Corporation, The Open Group.
7 //
8 // Permission is hereby granted, free of charge, to any person obtaining a copy
9 // of this software and associated documentation files (the "Software"), to
10 // deal in the Software without restriction, including without limitation the
11 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
12 // sell copies of the Software, and to permit persons to whom the Software is
13 // furnished to do so, subject to the following conditions:
14 //
15 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
16 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
17 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
18 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
19 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
21 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 schuur 1.1 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 //
24 //==============================================================================
25 //
26 // Author: Adrian Schuur, schuur@de.ibm.com
27 //
|
28 se.gupta 1.9 // Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135
|
29 schuur 1.1 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
32 #include "JMPIProviderManager.h"
33
34 #include "JMPIImpl.h"
35
36 #include <Pegasus/Common/CIMMessage.h>
37 #include <Pegasus/Common/OperationContext.h>
38 #include <Pegasus/Common/Destroyer.h>
39 #include <Pegasus/Common/Tracer.h>
40 #include <Pegasus/Common/StatisticalData.h>
41 #include <Pegasus/Common/Logger.h>
42 #include <Pegasus/Common/MessageLoader.h> //l10n
|
43 kumpf 1.10 #include <Pegasus/Common/Constants.h>
|
44 schuur 1.1
45 #include <Pegasus/Config/ConfigManager.h>
46
47 #include <Pegasus/ProviderManager2/ProviderName.h>
48 #include <Pegasus/ProviderManager2/JMPI/JMPIProvider.h>
49 #include <Pegasus/ProviderManager2/ProviderManagerService.h>
50
|
51 schuur 1.12 #include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h>
52
|
53 schuur 1.1
54 PEGASUS_USING_STD;
55 PEGASUS_NAMESPACE_BEGIN
56
57 int _jmpi_trace=0;
58
59 #define DDD(x) if (_jmpi_trace) x;
60
61 JMPIProviderManager::IndProvTab JMPIProviderManager::provTab;
62 JMPIProviderManager::IndSelectTab JMPIProviderManager::selxTab;
63 JMPIProviderManager::ProvRegistrar JMPIProviderManager::provReg;
64
65 JMPIProviderManager::JMPIProviderManager(Mode m)
66 {
67 mode=m;
68 if (getenv("JMPI_TRACE")) _jmpi_trace=1;
69 else _jmpi_trace=0;
70 }
71
72 JMPIProviderManager::~JMPIProviderManager(void)
73 {
74 schuur 1.1 }
75
|
76 schuur 1.12 Boolean JMPIProviderManager::insertProvider(const ProviderName & name,
|
77 schuur 1.1 const String &ns, const String &cn)
78 {
79 String key(ns+String("::")+cn+String("::")+CIMValue(name.getCapabilitiesMask()).toString());
80 return provReg.insert(key,name);
81 }
82
83
84 Message * JMPIProviderManager::processMessage(Message * request) throw()
85 {
86 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
87 "JMPIProviderManager::processMessage()");
88
89 Message * response = 0;
90
91 // pass the request message to a handler method based on message type
92 switch(request->getType())
93 {
94 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
95 response = handleGetInstanceRequest(request);
96
97 break;
98 schuur 1.1 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
99 response = handleEnumerateInstancesRequest(request);
100
101 break;
102 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
103 response = handleEnumerateInstanceNamesRequest(request);
104
105 break;
106 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
107 response = handleCreateInstanceRequest(request);
108
109 break;
110 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
111 response = handleModifyInstanceRequest(request);
112
113 break;
114 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
115 response = handleDeleteInstanceRequest(request);
116
117 break;
118 /* case CIM_EXEC_QUERY_REQUEST_MESSAGE:
119 schuur 1.1 response = handleExecuteQueryRequest(request);
120
121 */ break;
122 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
123 response = handleAssociatorsRequest(request);
124
125 break;
126 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
127 response = handleAssociatorNamesRequest(request);
128
129 break;
130 case CIM_REFERENCES_REQUEST_MESSAGE:
131 response = handleReferencesRequest(request);
132
133 break;
134 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
135 response = handleReferenceNamesRequest(request);
136
137 break;
|
138 schuur 1.11 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
|
139 schuur 1.1 response = handleInvokeMethodRequest(request);
140
141 break;
|
142 schuur 1.12 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
|
143 schuur 1.1 response = handleCreateSubscriptionRequest(request);
144
145 break;
|
146 schuur 1.12 /* case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
|
147 schuur 1.1 response = handleModifySubscriptionRequest(request);
148 break;
|
149 schuur 1.12 */
|
150 schuur 1.1 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
151 response = handleDeleteSubscriptionRequest(request);
152
153 break;
154 case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE:
155 response = handleEnableIndicationsRequest(request);
156
157 break;
158 case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE:
159 response = handleDisableIndicationsRequest(request);
160
161 break;
|
162 schuur 1.12 /* case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
|
163 kumpf 1.7 response = handleExportIndicationRequest(request);
|
164 schuur 1.1 break;
|
165 schuur 1.12 */
|
166 schuur 1.1 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
167 response = handleDisableModuleRequest(request);
168
169 break;
170 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
171 response = handleEnableModuleRequest(request);
172
173 break;
174 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
175 response = handleStopAllProvidersRequest(request);
176
|
177 schuur 1.12 break;
|
178 kumpf 1.4 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
179 response = handleInitializeProviderRequest(request);
180
181 break;
|
182 schuur 1.1 default:
|
183 kumpf 1.2 cout<<"*** Unsupported Request ??"<<request->getType()<<endl;
|
184 schuur 1.1 asm("int $3");
185 response = handleUnsupportedRequest(request);
186
187 break;
188 }
189
190 PEG_METHOD_EXIT();
191
192 return(response);
193 }
194
|
195 kumpf 1.6 Boolean JMPIProviderManager::hasActiveProviders()
196 {
197 return providerManager.hasActiveProviders();
198 }
199
200 void JMPIProviderManager::unloadIdleProviders()
|
201 schuur 1.1 {
|
202 kumpf 1.6 providerManager.unloadIdleProviders();
|
203 schuur 1.1 }
204
205 #define STRDUPA(s,o) \
206 if (s) { \
207 o=(const char*)alloca(strlen(s)); \
208 strcpy((char*)(o),(s)); \
209 } \
210 else o=NULL;
211
212 #define CHARS(cstring) (char*)(strlen(cstring)?(const char*)cstring:NULL)
213
214
215 #define HandlerIntroBase(type,type1,message,request,response,handler,respType) \
216 CIM##type##RequestMessage * request = \
217 dynamic_cast<CIM##type##RequestMessage *>(const_cast<Message *>(message)); \
218 PEGASUS_ASSERT(request != 0); \
219 CIM##type##ResponseMessage * response = \
220 new CIM##type##ResponseMessage( \
221 request->messageId, \
222 CIMException(), \
223 request->queueIds.copyAndPop() \
224 schuur 1.1 respType \
225 PEGASUS_ASSERT(response != 0); \
226 response->setKey(request->getKey()); \
227 response->setHttpMethod(request->getHttpMethod()); \
228 type1##ResponseHandler handler(request, response);
229
230 #define VOIDINTRO );
231 #define NOVOIDINTRO(type) ,type);
232 #define METHODINTRO ,CIMValue(), Array<CIMParamValue>(), request->methodName );
233
234
235 #define HandlerIntroVoid(type,message,request,response,handler) \
236 HandlerIntroBase(type,type,message,request,response,handler,VOIDINTRO)
237
238 #define HandlerIntroMethod(type,message,request,response,handler) \
239 HandlerIntroBase(type,type,message,request,response,handler,METHODINTRO)
240
241 #define HandlerIntroInd(type,message,request,response,handler) \
242 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
243
|
244 kumpf 1.4 #define HandlerIntroInit(type,message,request,response,handler) \
245 HandlerIntroBase(type,Operation,message,request,response,handler,VOIDINTRO)
246
|
247 schuur 1.1 #define HandlerIntro(type,message,request,response,handler,respType) \
248 HandlerIntroBase(type,type,message,request,response,handler,NOVOIDINTRO(respType))
249
250 #define HandlerCatch(handler) \
251 catch(CIMException & e) \
252 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
253 "Exception: " + e.getMessage()); \
254 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); \
255 } \
256 catch(Exception & e) \
257 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
258 "Exception: " + e.getMessage()); \
259 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage()); \
260 } \
261 catch(...) \
262 { PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
263 "Exception: Unknown"); \
264 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
265 }
266
|
267 schuur 1.13 static jobjectArray getList(JvmVector *jv, JNIEnv *env, CIMPropertyList &list)
268 {
269 Uint32 s=list.size();
270 jobjectArray pl=NULL;
271 if (s) {
272 jstring initial=env->NewString(NULL,0);
273 pl=env->NewObjectArray(s,jv->StringClassRef,initial);
274 for (Uint32 i=0; i<s; i++) {
275 env->SetObjectArrayElement
276 (pl,i,env->NewStringUTF(list[i].getString().getCString()));
277 }
278 }
279 return pl;
280 }
|
281 schuur 1.1
282 Message * JMPIProviderManager::handleGetInstanceRequest(const Message * message) throw()
283 {
284 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
285 "JMPIProviderManager::handleGetInstanceRequest");
286
287 HandlerIntro(GetInstance,message,request,response,handler,CIMInstance());
288
289 JNIEnv *env=NULL;
|
290 schuur 1.13 Boolean mode24=false;
291 CIMPropertyList propertyList;
292 jobjectArray pl=NULL;
293
|
294 schuur 1.1 try {
295 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
296 "JMPIProviderManager::handleGetInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
297 System::getHostName(),
298 request->nameSpace.getString(),
299 request->instanceName.getClassName().getString());
300
301 // make target object path
302 CIMObjectPath objectPath(
303 System::getHostName(),
304 request->nameSpace,
305 request->instanceName.getClassName(),
306 request->instanceName.getKeyBindings());
307
308 // resolve provider name
|
309 kumpf 1.2 ProviderName name = _resolveProviderName(
310 request->operationContext.get(ProviderIdContainer::NAME));
|
311 schuur 1.1
312 // get cached or load new provider module
313 JMPIProvider::OpProviderHolder ph = providerManager.getProvider(name.getPhysicalName(),
314 name.getLogicalName());
315 OperationContext context;
316
317 // forward request
318 JMPIProvider & pr=ph.GetProvider();
319
320 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
321 "Calling provider.getInstance: " + pr.getName());
322
|
323 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::getInstance"<<endl);
|
324 schuur 1.1
325 JvmVector *jv;
326 JNIEnv *env=JMPIjvm::attachThread(&jv);
327 JMPIjvm::checkException(env);
328 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
329 jv->CIMObjectPathNewI,(jint)&objectPath);
330 JMPIjvm::checkException(env);
331
332 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
333 request->instanceName.getClassName(),
334 false,true,true,CIMPropertyList());
335 JMPIjvm::checkException(env);
|
336 schuur 1.13 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls);
|
337 schuur 1.1 JMPIjvm::checkException(env);
338
339 JMPIProvider::pm_service_op_lock op_lock(&pr);
340
|
341 schuur 1.13 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance",
342 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;Z)Lorg/pegasus/jmpi/CIMInstance;");
343
344 if (id==NULL) {
345 env->ExceptionClear();
346 id=env->GetMethodID((jclass)pr.jProviderClass,"getInstance",
347 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)"
348 "Lorg/pegasus/jmpi/CIMInstance;");
349 JMPIjvm::checkException(env);
350 mode24=true;
351 pl=getList(jv,env,request->propertyList);
352 }
353 JMPIjvm::checkException(env);
354
|
355 schuur 1.1 STAT_GETSTARTTIME;
356
|
357 schuur 1.13 jobject inst=NULL;
358 if (mode24) inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
359 request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc);
360 else inst=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc,true);
361
|
362 schuur 1.1 STAT_PMS_PROVIDEREND;
|
363 schuur 1.13
|
364 schuur 1.1 JMPIjvm::checkException(env);
|
365 schuur 1.13 handler.processing();
|
366 schuur 1.1 if (inst) {
|
367 schuur 1.11 CIMInstance *ci=((CIMInstance*)env->CallIntMethod(inst,JMPIjvm::jv.CIMInstanceCInst));
|
368 schuur 1.1 handler.deliver(*ci);
369 }
370 handler.complete();
|
371 schuur 1.13 }
|
372 schuur 1.1 HandlerCatch(handler);
|
373 schuur 1.13
|
374 schuur 1.1 if (env) JMPIjvm::detachThread();
|
375 schuur 1.13
|
376 schuur 1.1 PEG_METHOD_EXIT();
377
378 return(response);
379 }
380
381 Message * JMPIProviderManager::handleEnumerateInstancesRequest(const Message * message) throw()
382 {
383 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
384 "JMPIProviderManager::handleEnumerateInstanceRequest");
385
386 HandlerIntro(EnumerateInstances,message,request,response,
387 handler,Array<CIMInstance>());
388 JNIEnv *env=NULL;
|
389 schuur 1.13 Boolean mode24=false;
390 CIMPropertyList propertyList;
391 jobjectArray pl=NULL;
392
393 try {
|
394 schuur 1.1 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
395 "JMPIProviderManager::handleEnumerateInstancesRequest - Host name: $0 Name space: $1 Class name: $2",
396 System::getHostName(),
397 request->nameSpace.getString(),
398 request->className.getString());
399
400 // make target object path
401 CIMObjectPath objectPath(
402 System::getHostName(),
403 request->nameSpace,
404 request->className);
405
406 // resolve provider name
|
407 kumpf 1.2 ProviderName name = _resolveProviderName(
408 request->operationContext.get(ProviderIdContainer::NAME));
|
409 schuur 1.1
410 // get cached or load new provider module
411 JMPIProvider::OpProviderHolder ph =
412 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
413 String::EMPTY);
414
|
415 schuur 1.12 // convert arguments
|
416 schuur 1.1 OperationContext context;
417
|
418 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
419 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
420 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
421 schuur 1.1
422 CIMPropertyList propertyList(request->propertyList);
423
424 // forward request
|
425 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
426 schuur 1.1
427 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
428 "Calling provider.enumerateInstances: " + pr.getName());
429
|
430 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::enumerateInstances"<<endl);
|
431 schuur 1.1
|
432 schuur 1.12
433 JvmVector *jv;
|
434 schuur 1.1 env=JMPIjvm::attachThread(&jv);
435
436 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
437 schuur 1.12 jv->CIMObjectPathNewI,(jint)&objectPath);
438 JMPIjvm::checkException(env);
439
|
440 schuur 1.1 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
|
441 schuur 1.12 request->className,
|
442 schuur 1.1 false,true,true,CIMPropertyList());
|
443 schuur 1.12 JMPIjvm::checkException(env);
|
444 schuur 1.1 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls);
445 JMPIjvm::checkException(env);
446
|
447 schuur 1.12 JMPIProvider::pm_service_op_lock op_lock(&pr);
|
448 schuur 1.1
|
449 schuur 1.12 STAT_GETSTARTTIME;
|
450 schuur 1.1
451 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances",
452 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;Z)Ljava/util/Vector;");
|
453 schuur 1.13
454 if (id==NULL) {
455 env->ExceptionClear();
456 id=env->GetMethodID((jclass)pr.jProviderClass,"enumerateInstances",
457 "(Lorg/pegasus/jmpi/CIMObjectPath;ZZZ[Ljava/lang/String;Lorg/pegasus/jmpi/CIMClass;)"
458 "[Lorg/pegasus/jmpi/CIMInstance;");
459 JMPIjvm::checkException(env);
460 mode24=true;
461 pl=getList(jv,env,request->propertyList);
462 }
|
463 schuur 1.1 JMPIjvm::checkException(env);
464
|
465 schuur 1.13 if (!mode24) {
466 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,false,jCc,true);
467 JMPIjvm::checkException(env);
468
469 STAT_PMS_PROVIDEREND;
470
471 handler.processing();
472 if (jVec) {
473 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
474 JMPIjvm::checkException(env);
475 jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
476 JMPIjvm::checkException(env);
477 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
478 JMPIjvm::checkException(env);
479
480 handler.deliver(inst);
481 }
482 }
483 handler.complete();
484 }
|
485 schuur 1.12
|
486 schuur 1.13 else {
487 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
488 request->localOnly,request->includeQualifiers,request->includeClassOrigin,pl,jCc);
489 JMPIjvm::checkException(env);
|
490 schuur 1.12
|
491 schuur 1.13 STAT_PMS_PROVIDEREND;
|
492 schuur 1.12
|
493 schuur 1.13 handler.processing();
494 if (jAr) {
495 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
496 JMPIjvm::checkException(env);
497 jobject jInst=env->GetObjectArrayElement(jAr,i);
498 JMPIjvm::checkException(env);
499 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
500 JMPIjvm::checkException(env);
|
501 schuur 1.12
|
502 schuur 1.13 handler.deliver(inst);
503 }
504 }
505 handler.complete();
|
506 schuur 1.1 }
507 }
508 HandlerCatch(handler);
|
509 schuur 1.12
|
510 schuur 1.11 if (env) JMPIjvm::detachThread();
|
511 schuur 1.12
|
512 schuur 1.1 PEG_METHOD_EXIT();
513
514 return(response);
515 }
516
517 Message * JMPIProviderManager::handleEnumerateInstanceNamesRequest(const Message * message) throw()
518 {
519 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnumerateInstanceNamesRequest");
520
521 HandlerIntro(EnumerateInstanceNames,message,request,response,
522 handler,Array<CIMObjectPath>());
523 JNIEnv *env=NULL;
|
524 schuur 1.13 Boolean mode24=false;
525 CIMPropertyList propertyList;
526 jobjectArray pl=NULL;
527
|
528 schuur 1.1 try {
529 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
530 "JMPIProviderManager::handleEnumerateInstanceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
531 System::getHostName(),
532 request->nameSpace.getString(),
533 request->className.getString());
534
535 // make target object path
536 CIMObjectPath objectPath(
537 System::getHostName(),
538 request->nameSpace,
539 request->className);
540
541 // resolve provider name
|
542 kumpf 1.2 ProviderName name = _resolveProviderName(
543 request->operationContext.get(ProviderIdContainer::NAME));
|
544 schuur 1.1
545 // get cached or load new provider module
546 JMPIProvider::OpProviderHolder ph =
547 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName());
548
549 // convert arguments
550 OperationContext context;
551
|
552 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
553 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
554 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
555 schuur 1.1
556 JMPIProvider & pr=ph.GetProvider();
557
558 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
559 "Calling provider.enumerateInstanceNames: " + pr.getName());
560
|
561 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::enumerateInstanceNames"<<endl);
|
562 schuur 1.1
|
563 schuur 1.12
|
564 schuur 1.1 JvmVector *jv;
565 env=JMPIjvm::attachThread(&jv);
566
567 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
568 jv->CIMObjectPathNewI,(jint)&objectPath);
569 JMPIjvm::checkException(env);
|
570 schuur 1.12
|
571 schuur 1.1 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
572 request->className,
573 false,true,true,CIMPropertyList());
574 JMPIjvm::checkException(env);
575 jobject jCc=env->NewObject(jv->CIMClassClassRef,jv->CIMClassNewI,(jint)&cls);
576 JMPIjvm::checkException(env);
577
578 JMPIProvider::pm_service_op_lock op_lock(&pr);
579
580 STAT_GETSTARTTIME;
581
582 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"enumInstances",
583 "(Lorg/pegasus/jmpi/CIMObjectPath;ZLorg/pegasus/jmpi/CIMClass;)Ljava/util/Vector;");
|
584 schuur 1.13
585 if (id==NULL) {
586 env->ExceptionClear();
587 id=env->GetMethodID((jclass)pr.jProviderClass,"enumerateInstanceNames",
588 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMClass;)"
589 "[Lorg/pegasus/jmpi/CIMObjectPath;");
590 JMPIjvm::checkException(env);
591 mode24=true;
592 }
|
593 schuur 1.1 JMPIjvm::checkException(env);
594
|
595 schuur 1.13 if (!mode24) {
596 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,true,jCc);
597 JMPIjvm::checkException(env);
598
599 STAT_PMS_PROVIDEREND;
600
601 handler.processing();
602 if (jVec) {
603 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
604 JMPIjvm::checkException(env);
605 jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
606 JMPIjvm::checkException(env);
607 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
608 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
609 JMPIjvm::checkException(env);
610 handler.deliver(*cop);
611 }
|
612 schuur 1.1 }
|
613 schuur 1.13 handler.complete();
614 }
615 else {
616 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jCc);
617 JMPIjvm::checkException(env);
618
619 STAT_PMS_PROVIDEREND;
620
621 handler.processing();
622 if (jAr) {
623 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
624 JMPIjvm::checkException(env);
625 jobject jCop=env->GetObjectArrayElement(jAr,i);
626 JMPIjvm::checkException(env);
627 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
628 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
629 JMPIjvm::checkException(env);
630 handler.deliver(*cop);
631 }
632 }
633 handler.complete();
|
634 schuur 1.1 }
635 }
636 HandlerCatch(handler);
637
638 if (env) JMPIjvm::detachThread();
639
640 PEG_METHOD_EXIT();
641
642 return(response);
643 }
644
645 Message * JMPIProviderManager::handleCreateInstanceRequest(const Message * message) throw()
646 {
647 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
648 "JMPIProviderManager::handleCreateInstanceRequest");
649
650 HandlerIntro(CreateInstance,message,request,response,
651 handler,CIMObjectPath());
652 JNIEnv *env=NULL;
653 try {
654 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
655 schuur 1.1 "JMPIProviderManager::handleCreateInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
656 System::getHostName(),
657 request->nameSpace.getString(),
658 request->newInstance.getPath().getClassName().getString());
659
660 // make target object path
661 CIMObjectPath objectPath(
662 System::getHostName(),
663 request->nameSpace,
664 request->newInstance.getPath().getClassName(),
665 request->newInstance.getPath().getKeyBindings());
666
667 // resolve provider name
|
668 kumpf 1.2 ProviderName name = _resolveProviderName(
669 request->operationContext.get(ProviderIdContainer::NAME));
|
670 schuur 1.1
671 // get cached or load new provider module
672 JMPIProvider::OpProviderHolder ph =
673 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(),
674 String::EMPTY);
675
676 // convert arguments
677 OperationContext context;
678
|
679 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
680 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
681 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
682 schuur 1.1
683 // forward request
684 JMPIProvider & pr=ph.GetProvider();
685
686 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
687 "Calling provider.createInstance: " +
688 ph.GetProvider().getName());
689
|
690 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::createInstances"<<endl);
|
691 schuur 1.12
|
692 schuur 1.1 JvmVector *jv;
693 env=JMPIjvm::attachThread(&jv);
694
695 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
696 jv->CIMObjectPathNewI,(jint)&objectPath);
697 JMPIjvm::checkException(env);
698 jobject jInst=env->NewObject(jv->CIMInstanceClassRef,
699 jv->CIMInstanceNewI,(jint)&request->newInstance);
700 JMPIjvm::checkException(env);
701
702 JMPIProvider::pm_service_op_lock op_lock(&pr);
703
704 STAT_GETSTARTTIME;
705
706 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"createInstance",
707 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)Lorg/pegasus/jmpi/CIMObjectPath;");
708 JMPIjvm::checkException(env);
709
710 jobject jCop=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jInst);
711
712 STAT_PMS_PROVIDEREND;
713 schuur 1.1
714 JMPIjvm::checkException(env);
715 handler.processing();
716 if (jCop) {
717 CIMObjectPath cop=*((CIMObjectPath*)env->CallIntMethod(jCop,JMPIjvm::jv.CIMObjectPathCInst));
718 handler.deliver(cop);
719 }
720 handler.complete();
721 }
722 HandlerCatch(handler);
723
724 if (env) JMPIjvm::detachThread();
725
726 PEG_METHOD_EXIT();
727
728 return(response);
729 }
730
731 Message * JMPIProviderManager::handleModifyInstanceRequest(const Message * message) throw()
732 {
733 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
734 schuur 1.1 "JMPIProviderManager::handleModifyInstanceRequest");
735
736 HandlerIntroVoid(ModifyInstance,message,request,response,handler);
737 JNIEnv *env=NULL;
|
738 schuur 1.13 Boolean mode24=false;
739 CIMPropertyList propertyList;
740 jobjectArray pl=NULL;
741
|
742 schuur 1.1 try {
743 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
744 "DefaultProviderManager::handleModifyInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
745 System::getHostName(),
746 request->nameSpace.getString(),
747 request->modifiedInstance.getPath().getClassName().getString());
748
749 // make target object path
750 CIMObjectPath objectPath(
751 System::getHostName(),
752 request->nameSpace,
753 request->modifiedInstance.getPath ().getClassName(),
754 request->modifiedInstance.getPath ().getKeyBindings());
755
756 // resolve provider name
|
757 kumpf 1.2 ProviderName name = _resolveProviderName(
758 request->operationContext.get(ProviderIdContainer::NAME));
|
759 schuur 1.1
760 // get cached or load new provider module
761 JMPIProvider::OpProviderHolder ph =
762 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
763
764 // convert arguments
765 OperationContext context;
766
|
767 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
768 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
769 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
770 schuur 1.1
771 CIMPropertyList propertyList(request->propertyList);
772
773 // forward request
774 JMPIProvider & pr=ph.GetProvider();
775
776 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
777 "Calling provider.modifyInstance: " + pr.getName());
778
|
779 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl);
|
780 schuur 1.1
781 JvmVector *jv;
782 env=JMPIjvm::attachThread(&jv);
783
784 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
785 schuur 1.12 jv->CIMObjectPathNewI,(jint)&objectPath);
|
786 schuur 1.1 JMPIjvm::checkException(env);
787 jobject jInst=env->NewObject(jv->CIMInstanceClassRef,
788 jv->CIMInstanceNewI,(jint)&request->modifiedInstance);
789 JMPIjvm::checkException(env);
790
791 JMPIProvider::pm_service_op_lock op_lock(&pr);
792
793 STAT_GETSTARTTIME;
794
795 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance",
796 "(Lorg/pegasus/jmpi/CIMObjectPath;Lorg/pegasus/jmpi/CIMInstance;)V");
|
797 schuur 1.13
798 if (id==NULL) {
799 env->ExceptionClear();
800 id=env->GetMethodID((jclass)pr.jProviderClass,"setInstance",
801 "(Lorg/pegasus/jmpi/CIMObjectPath;Z[Ljava/lang/String)V");
802 JMPIjvm::checkException(env);
803 mode24=true;
804 pl=getList(jv,env,request->propertyList);
805 }
|
806 schuur 1.1 JMPIjvm::checkException(env);
807
|
808 schuur 1.13 if (!mode24) env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst);
809 else env->CallVoidMethod((jobject)pr.jProvider,id,jRef,jInst,pl);
810
|
811 schuur 1.1 STAT_PMS_PROVIDEREND;
812
813 JMPIjvm::checkException(env);
814 JMPIjvm::detachThread();
815 }
816 HandlerCatch(handler);
817
818 if (env) JMPIjvm::detachThread();
819
820 PEG_METHOD_EXIT();
821
822 return(response);
823 }
824
825 Message * JMPIProviderManager::handleDeleteInstanceRequest(const Message * message) throw()
826 {
827 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
828 "JMPIProviderManager::handleDeleteInstanceRequest");
829
830 HandlerIntroVoid(DeleteInstance,message,request,response,
831 handler);
832 schuur 1.1 JNIEnv *env=NULL;
833 try {
834 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
835 "DefaultProviderManager::handleDeleteInstanceRequest - Host name: $0 Name space: $1 Class name: $2",
836 System::getHostName(),
837 request->nameSpace.getString(),
838 request->instanceName.getClassName().getString());
839
840 // make target object path
841 CIMObjectPath objectPath(
842 System::getHostName(),
843 request->nameSpace,
844 request->instanceName.getClassName(),
845 request->instanceName.getKeyBindings());
846
847 // resolve provider name
|
848 kumpf 1.2 ProviderName name = _resolveProviderName(
849 request->operationContext.get(ProviderIdContainer::NAME));
|
850 schuur 1.1
851 // get cached or load new provider module
852 JMPIProvider::OpProviderHolder ph =
853 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
854
855 // convert arguments
856 OperationContext context;
857
|
858 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
859 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
860 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
861 schuur 1.1
862 // forward request
863 JMPIProvider & pr=ph.GetProvider();
864
865 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
866 "Calling provider.deleteInstance: " + pr.getName());
867
|
868 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::modifyInstance"<<endl);
|
869 schuur 1.1
870 JvmVector *jv;
871 env=JMPIjvm::attachThread(&jv);
872
873 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
874 jv->CIMObjectPathNewI,(jint)&objectPath);
875 JMPIjvm::checkException(env);
876
877 JMPIProvider::pm_service_op_lock op_lock(&pr);
878
879 STAT_GETSTARTTIME;
880
881 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"deleteInstance",
882 "(Lorg/pegasus/jmpi/CIMObjectPath;)V");
883 JMPIjvm::checkException(env);
884
885 env->CallVoidMethod((jobject)pr.jProvider,id,jRef);
886
887 STAT_PMS_PROVIDEREND;
888
889 JMPIjvm::checkException(env);
890 schuur 1.1 JMPIjvm::detachThread();
891 }
892 HandlerCatch(handler);
893
894 if (env) JMPIjvm::detachThread();
895 PEG_METHOD_EXIT();
896
897 return(response);
898 }
899
900
901 Message * JMPIProviderManager::handleAssociatorsRequest(const Message * message) throw()
902 {
903 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
904 "JMPIProviderManager::handleAssociatorsRequest");
905
906 HandlerIntro(Associators,message,request,response,
907 handler,Array<CIMObject>());
908 JNIEnv *env=NULL;
|
909 schuur 1.13 Boolean mode24=false;
910 CIMPropertyList propertyList;
911 jobjectArray pl=NULL;
912
|
913 schuur 1.1 try {
914 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
915 "JMPIProviderManager::handleAssociatorsRequest - Host name: $0 Name space: $1 Class name: $2",
916 System::getHostName(),
917 request->nameSpace.getString(),
918 request->objectName.getClassName().getString());
919
920 // make target object path
921 CIMObjectPath objectPath(
922 System::getHostName(),
923 request->nameSpace,
924 request->objectName.getClassName());
925
926 objectPath.setKeyBindings(request->objectName.getKeyBindings());
927
928 CIMObjectPath assocPath(
929 System::getHostName(),
930 request->nameSpace,
931 request->assocClass.getString());
932
933 // resolve provider name
|
934 kumpf 1.2 ProviderName name = _resolveProviderName(
935 request->operationContext.get(ProviderIdContainer::NAME));
|
936 schuur 1.1
937 // get cached or load new provider module
938 JMPIProvider::OpProviderHolder ph =
939 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
940
941 // convert arguments
942 OperationContext context;
943
|
944 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
945 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
946 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
947 schuur 1.1
948 // forward request
949 JMPIProvider & pr=ph.GetProvider();
950
951 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
952 "Calling provider.associators: " + pr.getName());
953
|
954 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::associators"<<
|
955 schuur 1.1 " role: >"<<request->role<<"< aCls "<<
|
956 kumpf 1.2 request->assocClass<<endl);
|
957 schuur 1.1
958 JvmVector *jv;
959 env=JMPIjvm::attachThread(&jv);
960
961 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
962 schuur 1.12 jv->CIMObjectPathNewI,(jint)&objectPath);
|
963 schuur 1.1 JMPIjvm::checkException(env);
964
965 jstring rClass=env->NewStringUTF(request->resultClass.getString().getCString());
966 jstring rRole=env->NewStringUTF(request->role.getCString());
967 jstring resRole=env->NewStringUTF(request->resultRole.getCString());
968 JMPIjvm::checkException(env);
969
970 JMPIProvider::pm_service_op_lock op_lock(&pr);
971
972 STAT_GETSTARTTIME;
973
974 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"associators",
975 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
976 "Ljava/lang/String;ZZ[Ljava/lang/String;)Ljava/util/Vector;");
|
977 schuur 1.12
|
978 schuur 1.13 if (id==NULL) {
979 env->ExceptionClear();
980 id=env->GetMethodID((jclass)pr.jProviderClass,"associators",
981 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
982 "Ljava/lang/String;ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
983 JMPIjvm::checkException(env);
984 mode24=true;
985 }
|
986 schuur 1.1 JMPIjvm::checkException(env);
987
|
988 schuur 1.13 pl=getList(jv,env,request->propertyList);
989
990 if (!mode24) {
991 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
992 rClass,rRole,resRole,false,false,pl);
993 JMPIjvm::checkException(env);
994
995 STAT_PMS_PROVIDEREND;
|
996 schuur 1.1
|
997 schuur 1.13 handler.processing();
998 if (jVec) {
999 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1000 JMPIjvm::checkException(env);
1001 jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1002 JMPIjvm::checkException(env);
1003 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
1004 JMPIjvm::checkException(env);
|
1005 schuur 1.1
|
1006 schuur 1.13 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
|
1007 schuur 1.1 inst.getClassName(),false,true,true,CIMPropertyList());
|
1008 schuur 1.13 const CIMObjectPath& op=inst.getPath();
1009 CIMObjectPath iop=inst.buildPath(cls);
1010 iop.setNameSpace(op.getNameSpace());
1011 inst.setPath(iop);
1012
1013 handler.deliver(inst);
1014 }
1015 }
|
1016 schuur 1.1 }
|
1017 schuur 1.13
1018 else {
1019 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
1020 rClass,rRole,resRole,false,false,pl);
1021 JMPIjvm::checkException(env);
1022
1023 STAT_PMS_PROVIDEREND;
1024
1025 handler.processing();
1026 if (jAr) {
1027 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1028 JMPIjvm::checkException(env);
1029 jobject jInst=env->GetObjectArrayElement(jAr,i);
1030 JMPIjvm::checkException(env);
1031 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
1032 JMPIjvm::checkException(env);
1033
1034 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
1035 inst.getClassName(),false,true,true,CIMPropertyList());
1036 const CIMObjectPath& op=inst.getPath();
1037 CIMObjectPath iop=inst.buildPath(cls);
1038 schuur 1.13 iop.setNameSpace(op.getNameSpace());
1039 inst.setPath(iop);
1040
1041 handler.deliver(inst);
1042 }
1043 }
1044 }
|
1045 schuur 1.1 handler.complete();
1046 }
1047 HandlerCatch(handler);
|
1048 schuur 1.13
1049 if (env) JMPIjvm::detachThread();
1050
|
1051 schuur 1.1 PEG_METHOD_EXIT();
1052
1053 return(response);
1054 }
|
1055 schuur 1.13
|
1056 schuur 1.1
1057
1058 Message * JMPIProviderManager::handleAssociatorNamesRequest(const Message * message) throw()
1059 {
1060 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1061 "JMPIProviderManager::handleAssociatorNamesRequest");
1062
1063 HandlerIntro(AssociatorNames,message,request,response,
1064 handler,Array<CIMObjectPath>());
1065 JNIEnv *env=NULL;
|
1066 schuur 1.13 Boolean mode24=false;
1067 CIMPropertyList propertyList;
1068 jobjectArray pl=NULL;
1069
|
1070 schuur 1.1 try {
1071 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1072 "JMPIProviderManager::handleAssociatorNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1073 System::getHostName(),
1074 request->nameSpace.getString(),
1075 request->objectName.getClassName().getString());
1076
1077 // make target object path
1078 CIMObjectPath objectPath(
1079 System::getHostName(),
1080 request->nameSpace,
1081 request->objectName.getClassName());
1082
1083 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1084
1085 CIMObjectPath assocPath(
1086 System::getHostName(),
1087 request->nameSpace,
1088 request->assocClass.getString());
1089
1090 // resolve provider name
|
1091 kumpf 1.2 ProviderName name = _resolveProviderName(
1092 request->operationContext.get(ProviderIdContainer::NAME));
|
1093 schuur 1.1
1094 // get cached or load new provider module
1095 JMPIProvider::OpProviderHolder ph =
1096 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1097
1098 // convert arguments
1099 OperationContext context;
1100
|
1101 se.gupta 1.9 context.insert(request->operationContext.get(IdentityContainer::NAME));
1102 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1103 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1104 schuur 1.1
1105 // forward request
1106 JMPIProvider & pr=ph.GetProvider();
1107
1108 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1109 "Calling provider.associatorNames: " + pr.getName());
1110
|
1111 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::associatorNames"<<
|
1112 schuur 1.1 " role: >"<<request->role<<"< aCls "<<
|
1113 kumpf 1.2 request->assocClass<<endl);
|
1114 schuur 1.1
1115 JvmVector *jv;
1116 env=JMPIjvm::attachThread(&jv);
1117
1118 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
1119 jv->CIMObjectPathNewI,(jint)&objectPath);
1120 JMPIjvm::checkException(env);
1121
1122 jstring rClass=env->NewStringUTF(request->resultClass.getString().getCString());
1123 jstring rRole=env->NewStringUTF(request->role.getCString());
1124 jstring resRole=env->NewStringUTF(request->resultRole.getCString());
1125 JMPIjvm::checkException(env);
1126
1127 JMPIProvider::pm_service_op_lock op_lock(&pr);
1128
1129 STAT_GETSTARTTIME;
1130
1131 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"associatorNames",
1132 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
1133 "Ljava/lang/String;)Ljava/util/Vector;");
|
1134 schuur 1.13
1135 if (id==NULL) {
1136 env->ExceptionClear();
1137 id=env->GetMethodID((jclass)pr.jProviderClass,"associatorNames",
1138 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;Ljava/lang/String;"
1139 "Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
1140 JMPIjvm::checkException(env);
1141 mode24=true;
1142 }
|
1143 schuur 1.1 JMPIjvm::checkException(env);
1144
|
1145 schuur 1.13 if (!mode24) {
1146 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
1147 rClass,rRole,resRole);
1148 JMPIjvm::checkException(env);
1149
1150 STAT_PMS_PROVIDEREND;
1151
1152 handler.processing();
1153 if (jVec) {
1154 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1155 JMPIjvm::checkException(env);
1156 jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1157 JMPIjvm::checkException(env);
1158 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
1159 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
1160 JMPIjvm::checkException(env);
1161 handler.deliver(*cop);
1162 }
1163 }
1164 handler.complete();
1165 }
1166 schuur 1.13
1167 else {
1168 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
|
1169 schuur 1.1 rClass,rRole,resRole);
|
1170 schuur 1.13 JMPIjvm::checkException(env);
|
1171 schuur 1.1
|
1172 schuur 1.13 STAT_PMS_PROVIDEREND;
|
1173 schuur 1.1
|
1174 schuur 1.13 handler.processing();
1175 if (jAr) {
1176 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1177 JMPIjvm::checkException(env);
1178 jobject jCop=env->GetObjectArrayElement(jAr,i);
1179 JMPIjvm::checkException(env);
1180 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
1181 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
1182 JMPIjvm::checkException(env);
1183 handler.deliver(*cop);
1184 }
1185 }
1186 handler.complete();
1187 }
|
1188 schuur 1.1 }
1189 HandlerCatch(handler);
|
1190 schuur 1.12
|
1191 schuur 1.1 if (env) JMPIjvm::detachThread();
|
1192 schuur 1.12
|
1193 schuur 1.1 PEG_METHOD_EXIT();
1194
1195 return(response);
1196 }
1197
1198
1199 Message * JMPIProviderManager::handleReferencesRequest(const Message * message) throw()
1200 {
1201 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1202 "JMPIProviderManager::handleReferencesRequest");
1203
1204 HandlerIntro(References,message,request,response,
1205 handler,Array<CIMObject>());
1206 JNIEnv *env=NULL;
|
1207 schuur 1.13 Boolean mode24=false;
1208 CIMPropertyList propertyList;
1209 jobjectArray pl=NULL;
1210
|
1211 schuur 1.1 try {
1212 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1213 "DefaultProviderManager::handleReferencesRequest - Host name: $0 Name space: $1 Class name: $2",
1214 System::getHostName(),
1215 request->nameSpace.getString(),
1216 request->objectName.getClassName().getString());
1217
1218 // make target object path
1219 CIMObjectPath objectPath(
1220 System::getHostName(),
1221 request->nameSpace,
1222 request->objectName.getClassName());
1223
1224 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1225
1226 CIMObjectPath resultPath(
1227 System::getHostName(),
1228 request->nameSpace,
1229 request->resultClass.getString());
1230
1231 // resolve provider name
|
1232 kumpf 1.2 ProviderName name = _resolveProviderName(
1233 request->operationContext.get(ProviderIdContainer::NAME));
|
1234 schuur 1.1
1235 // get cached or load new provider module
1236 JMPIProvider::OpProviderHolder ph =
1237 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1238
1239 // convert arguments
1240 OperationContext context;
1241
|
1242 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
1243 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1244 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1245 schuur 1.1
1246 // forward request
|
1247 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
1248 schuur 1.1
1249 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1250 "Calling provider.references: " + pr.getName());
1251
|
1252 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::references"<<" role: >"<<request->role<<"< aCls "<<
|
1253 schuur 1.12 request->resultClass<<endl);
|
1254 schuur 1.1
|
1255 schuur 1.12 JvmVector *jv;
|
1256 schuur 1.1 env=JMPIjvm::attachThread(&jv);
1257
1258 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
1259 schuur 1.12 jv->CIMObjectPathNewI,(jint)&objectPath);
1260 JMPIjvm::checkException(env);
|
1261 schuur 1.1
1262 jstring rRole=env->NewStringUTF(request->role.getCString());
|
1263 schuur 1.12 JMPIjvm::checkException(env);
|
1264 schuur 1.1
1265 JMPIProvider::pm_service_op_lock op_lock(&pr);
1266
1267 STAT_GETSTARTTIME;
1268
1269 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"references",
1270 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
|
1271 schuur 1.12 "ZZ[Ljava/lang/String;)Ljava/util/Vector;");
1272
|
1273 schuur 1.13 if (id==NULL) {
1274 env->ExceptionClear();
1275 id=env->GetMethodID((jclass)pr.jProviderClass,"references",
1276 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
1277 "ZZ[Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMInstance;");
1278 JMPIjvm::checkException(env);
1279 mode24=true;
1280 }
|
1281 schuur 1.1 JMPIjvm::checkException(env);
1282
|
1283 schuur 1.13 pl=getList(jv,env,request->propertyList);
1284
1285 if (!mode24) {
1286 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
1287 rRole,false,false,pl);
1288 JMPIjvm::checkException(env);
1289
1290 STAT_PMS_PROVIDEREND;
1291
1292 handler.processing();
1293 if (jVec) {
1294 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1295 JMPIjvm::checkException(env);
1296 jobject jInst=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1297 JMPIjvm::checkException(env);
1298 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
1299 JMPIjvm::checkException(env);
1300
1301 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
1302 inst.getClassName(),false,true,true,CIMPropertyList());
1303 const CIMObjectPath& op=inst.getPath();
1304 schuur 1.13 CIMObjectPath iop=inst.buildPath(cls);
1305 iop.setNameSpace(op.getNameSpace());
1306 inst.setPath(iop);
1307
1308 handler.deliver(inst);
1309 }
1310 }
1311 handler.complete();
1312 }
1313
1314 else {
1315 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,
1316 rRole,false,false,pl);
1317 JMPIjvm::checkException(env);
|
1318 schuur 1.1
|
1319 schuur 1.13 STAT_PMS_PROVIDEREND;
|
1320 schuur 1.1
|
1321 schuur 1.13 handler.processing();
1322 if (jAr) {
1323 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1324 JMPIjvm::checkException(env);
1325 jobject jInst=env->GetObjectArrayElement(jAr,i);
1326 JMPIjvm::checkException(env);
1327 CIMInstance inst=*((CIMInstance*)env->CallIntMethod(jInst,JMPIjvm::jv.CIMInstanceCInst));
1328 JMPIjvm::checkException(env);
|
1329 schuur 1.12
|
1330 schuur 1.13 CIMClass cls=pr._cimom_handle->getClass(context,request->nameSpace,
|
1331 schuur 1.12 inst.getClassName(),false,true,true,CIMPropertyList());
|
1332 schuur 1.13 const CIMObjectPath& op=inst.getPath();
1333 CIMObjectPath iop=inst.buildPath(cls);
1334 iop.setNameSpace(op.getNameSpace());
1335 inst.setPath(iop);
|
1336 schuur 1.12
|
1337 schuur 1.13 handler.deliver(inst);
1338 }
|
1339 schuur 1.12 }
|
1340 schuur 1.13 handler.complete();
1341 }
1342
|
1343 schuur 1.1 }
1344 HandlerCatch(handler);
|
1345 schuur 1.12
1346 if (env) JMPIjvm::detachThread();
1347
|
1348 schuur 1.1 PEG_METHOD_EXIT();
1349
1350 return(response);
1351 }
1352
1353
1354 Message * JMPIProviderManager::handleReferenceNamesRequest(const Message * message) throw()
1355 {
1356 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1357 "JMPIProviderManager::handleReferenceNamesRequest");
1358
1359 HandlerIntro(ReferenceNames,message,request,response,
1360 handler,Array<CIMObjectPath>());
1361 JNIEnv *env=NULL;
|
1362 schuur 1.13 Boolean mode24=false;
1363 CIMPropertyList propertyList;
1364 jobjectArray pl=NULL;
1365
|
1366 schuur 1.1 try {
1367 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1368 "JMPIProviderManager::handleReferenceNamesRequest - Host name: $0 Name space: $1 Class name: $2",
1369 System::getHostName(),
1370 request->nameSpace.getString(),
1371 request->objectName.getClassName().getString());
1372
1373 // make target object path
1374 CIMObjectPath objectPath(
1375 System::getHostName(),
1376 request->nameSpace,
1377 request->objectName.getClassName());
1378
1379 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1380
1381 CIMObjectPath resultPath(
1382 System::getHostName(),
1383 request->nameSpace,
1384 request->resultClass.getString());
1385
1386 // resolve provider name
|
1387 kumpf 1.2 ProviderName name = _resolveProviderName(
1388 request->operationContext.get(ProviderIdContainer::NAME));
|
1389 schuur 1.1
1390 // get cached or load new provider module
1391 JMPIProvider::OpProviderHolder ph =
1392 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1393
1394 // convert arguments
1395 OperationContext context;
1396
|
1397 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
1398 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1399 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1400 schuur 1.1
1401 JMPIProvider & pr=ph.GetProvider();
1402
1403 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1404 "Calling provider.referenceNames: " + pr.getName());
1405
|
1406 schuur 1.12
|
1407 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::referenceNames"<<" role: >"<<request->role<<"< aCls "<<
1408 request->resultClass<<endl);
|
1409 schuur 1.1
1410 JvmVector *jv;
1411 env=JMPIjvm::attachThread(&jv);
1412
1413 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
|
1414 schuur 1.11 jv->CIMObjectPathNewI,(jint)&objectPath);
|
1415 schuur 1.1 JMPIjvm::checkException(env);
|
1416 schuur 1.11
|
1417 schuur 1.1 jstring rRole=env->NewStringUTF(request->role.getCString());
1418 JMPIjvm::checkException(env);
1419
1420 JMPIProvider::pm_service_op_lock op_lock(&pr);
1421
1422 STAT_GETSTARTTIME;
1423
1424 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"referenceNames",
1425 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)Ljava/util/Vector;");
|
1426 schuur 1.11
|
1427 schuur 1.13 if (id==NULL) {
1428 env->ExceptionClear();
1429 id=env->GetMethodID((jclass)pr.jProviderClass,"referenceNames",
1430 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;)[Lorg/pegasus/jmpi/CIMObjectPath;");
1431 JMPIjvm::checkException(env);
1432 mode24=true;
1433 }
|
1434 schuur 1.1 JMPIjvm::checkException(env);
1435
|
1436 schuur 1.13 if (!mode24) {
1437 jobject jVec=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,rRole);
1438 JMPIjvm::checkException(env);
1439
1440 STAT_PMS_PROVIDEREND;
1441
1442 handler.processing();
1443 if (jVec) {
1444 for (int i=0,m=env->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<m; i++) {
1445 JMPIjvm::checkException(env);
1446 jobject jCop=env->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,i);
1447 JMPIjvm::checkException(env);
1448 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
1449 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
1450 JMPIjvm::checkException(env);
1451 handler.deliver(*cop);
1452 }
1453 }
1454 handler.complete();
1455 }
1456
1457 schuur 1.13 else {
1458 jobjectArray jAr=(jobjectArray)env->CallObjectMethod((jobject)pr.jProvider,id,jRef,rRole);
1459 JMPIjvm::checkException(env);
|
1460 schuur 1.1
|
1461 schuur 1.13 STAT_PMS_PROVIDEREND;
|
1462 schuur 1.1
|
1463 schuur 1.13 handler.processing();
1464 if (jAr) {
1465 for (int i=0,m=env->GetArrayLength(jAr); i<m; i++) {
1466 JMPIjvm::checkException(env);
1467 jobject jCop=env->GetObjectArrayElement(jAr,i);
1468 JMPIjvm::checkException(env);
1469 CIMObjectPath *cop=((CIMObjectPath*)env->CallIntMethod
1470 (jCop,JMPIjvm::jv.CIMObjectPathCInst));
1471 JMPIjvm::checkException(env);
1472 handler.deliver(*cop);
1473 }
1474 }
1475 handler.complete();
1476 }
|
1477 schuur 1.1 }
1478 HandlerCatch(handler);
|
1479 schuur 1.11
1480 if (env) JMPIjvm::detachThread();
1481
|
1482 schuur 1.1 PEG_METHOD_EXIT();
1483
1484 return(response);
1485 }
1486
1487
1488 Message * JMPIProviderManager::handleInvokeMethodRequest(const Message * message) throw()
1489 {
1490 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1491 "JMPIProviderManager::handleInvokeMethodRequest");
1492
1493 HandlerIntroMethod(InvokeMethod,message,request,response,
1494 handler);
|
1495 schuur 1.11 JNIEnv *env=NULL;
|
1496 schuur 1.13 Boolean mode24=false;
1497
|
1498 schuur 1.1 try {
1499 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1500 "JMPIProviderManager::handleInvokeMethodRequest - Host name: $0 Name space: $1 Class name: $2",
1501 System::getHostName(),
1502 request->nameSpace.getString(),
1503 request->instanceName.getClassName().getString());
1504
1505 // make target object path
1506 CIMObjectPath objectPath(
1507 System::getHostName(),
1508 request->nameSpace,
1509 request->instanceName.getClassName(),
1510 request->instanceName.getKeyBindings());
1511
1512 // resolve provider name
|
1513 kumpf 1.2 ProviderName name = _resolveProviderName(
1514 request->operationContext.get(ProviderIdContainer::NAME));
|
1515 schuur 1.1
1516 // get cached or load new provider module
1517 JMPIProvider::OpProviderHolder ph =
1518 providerManager.getProvider(name.getPhysicalName(), name.getLogicalName(), String::EMPTY);
1519
1520 // convert arguments
1521 OperationContext context;
1522
|
1523 schuur 1.11 context.insert(request->operationContext.get(IdentityContainer::NAME));
1524 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1525 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
|
1526 schuur 1.1
1527 JMPIProvider & pr=ph.GetProvider();
1528
1529 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1530 "Calling provider.invokeMethod: " + pr.getName());
1531
|
1532 schuur 1.11 JvmVector *jv;
1533 env=JMPIjvm::attachThread(&jv);
1534
1535 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
1536 jv->CIMObjectPathNewI,(jint)&objectPath);
1537 JMPIjvm::checkException(env);
1538
1539 jstring jMethod=env->NewStringUTF(request->methodName.getString().getCString());
1540 JMPIjvm::checkException(env);
1541
|
1542 schuur 1.1 STAT_GETSTARTTIME;
1543
|
1544 schuur 1.11 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"invokeMethod",
1545 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
1546 "Ljava/util/Vector;Ljava/util/Vector;)Lorg/pegasus/jmpi/CIMValue;");
|
1547 schuur 1.13
1548 if (id==NULL) {
1549 env->ExceptionClear();
1550 id=env->GetMethodID((jclass)pr.jProviderClass,"invokeMethod",
1551 "(Lorg/pegasus/jmpi/CIMObjectPath;Ljava/lang/String;"
1552 "[Lorg/pegasus/jmpi/CIMArgument;[Lorg/pegasus/jmpi/CIMArgument;)Lorg/pegasus/jmpi/CIMValue;");
1553 JMPIjvm::checkException(env);
1554 mode24=true;
1555 }
|
1556 schuur 1.11 JMPIjvm::checkException(env);
1557
|
1558 schuur 1.13 if (!mode24) {
1559 jobject jVecIn=env->NewObject(jv->VectorClassRef,jv->VectorNew);
1560 JMPIjvm::checkException(env);
1561 for (int i=0,m=request->inParameters.size(); i<m; i++) {
1562 const CIMParamValue & parm=request->inParameters[i];
1563 const CIMValue v=parm.getValue();
1564 CIMProperty *p=new CIMProperty(parm.getParameterName(),v,v.getArraySize());
1565 jobject prop=env->NewObject(jv->CIMPropertyClassRef,
1566 jv->CIMPropertyNewI,(jint)p);
1567 env->CallVoidMethod(jVecIn,jv->VectorAddElement,prop);
1568 }
1569
1570 jobject jVecOut=env->NewObject(jv->VectorClassRef,jv->VectorNew);
1571 JMPIjvm::checkException(env);
1572
1573 jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jVecIn,jVecOut);
1574 JMPIjvm::checkException(env);
1575
1576 STAT_PMS_PROVIDEREND;
1577
1578 handler.processing();
|
1579 schuur 1.1
|
1580 schuur 1.13 CIMValue *v=((CIMValue*)env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst));
1581 handler.deliver(*v);
|
1582 schuur 1.1
|
1583 schuur 1.13 for (int i=0,m=env->CallIntMethod(jVecOut,JMPIjvm::jv.VectorSize); i<m; i++) {
1584 JMPIjvm::checkException(env);
1585 jobject jProp=env->CallObjectMethod(jVecOut,JMPIjvm::jv.VectorElementAt,i);
1586 JMPIjvm::checkException(env);
1587 CIMProperty *p=((CIMProperty*)env->CallIntMethod(jProp,JMPIjvm::jv.PropertyCInst));
1588 JMPIjvm::checkException(env);
1589 handler.deliverParamValue(CIMParamValue(p->getName().getString(),p->getValue()));
1590 }
1591 handler.complete();
1592 }
1593 else {
1594 Uint32 m=request->inParameters.size();
|
1595 schuur 1.11
|
1596 schuur 1.13 jobjectArray jArIn=env->NewObjectArray(m,jv->CIMArgumentClassRef,NULL);
1597 for (Uint32 i=0; i<m; i++) {
1598 CIMParamValue *parm=new CIMParamValue(request->inParameters[i]);
1599 jobject jArg=env->NewObject(jv->CIMArgumentClassRef,jv->CIMArgumentNewI,(jint)parm);
1600 env->SetObjectArrayElement(jArIn,i,jArg);
1601 }
1602 jobjectArray jArOut=env->NewObjectArray(24,jv->CIMArgumentClassRef,NULL);
|
1603 schuur 1.1
|
1604 schuur 1.13 jobject jValue=env->CallObjectMethod((jobject)pr.jProvider,id,jRef,jMethod,jArIn,jArOut);
|
1605 schuur 1.11 JMPIjvm::checkException(env);
|
1606 schuur 1.13
1607 STAT_PMS_PROVIDEREND;
1608
1609 handler.processing();
1610
1611 CIMValue *v=((CIMValue*)env->CallIntMethod(jValue,JMPIjvm::jv.CIMValueCInst));
1612 handler.deliver(*v);
1613
1614 for (int i=0; i<24; i++) {
1615 jobject jArg=env->GetObjectArrayElement(jArOut,i);
1616 JMPIjvm::checkException(env);
1617 if (jArg==NULL) break;
1618 CIMParamValue *p=((CIMParamValue*)env->CallIntMethod(jArg,JMPIjvm::jv.ArgumentCInst));
1619 JMPIjvm::checkException(env);
1620 handler.deliverParamValue(*p);
1621 }
1622 handler.complete();
1623 }
|
1624 schuur 1.1 }
1625 HandlerCatch(handler);
|
1626 schuur 1.11
1627 if (env) JMPIjvm::detachThread();
1628
|
1629 schuur 1.1 PEG_METHOD_EXIT();
1630
|
1631 schuur 1.11 return(response);
|
1632 schuur 1.1 }
|
1633 schuur 1.12
|
1634 schuur 1.1 int LocateIndicationProviderNames(const CIMInstance& pInstance, const CIMInstance& pmInstance,
1635 String& providerName, String& location)
1636 {
1637 Uint32 pos = pInstance.findProperty(CIMName ("Name"));
1638 pInstance.getProperty(pos).getValue().get(providerName);
1639
1640 pos = pmInstance.findProperty(CIMName ("Location"));
1641 pmInstance.getProperty(pos).getValue().get(location);
1642 return 0;
1643 }
1644
1645 Message * JMPIProviderManager::handleCreateSubscriptionRequest(const Message * message) throw()
1646 {
1647 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "DefaultProviderManager::handleCreateSubscriptionRequest");
1648
1649 HandlerIntroInd(CreateSubscription,message,request,response,
1650 handler);
|
1651 schuur 1.12 JNIEnv *env=NULL;
|
1652 schuur 1.1 try {
1653 const CIMObjectPath &x=request->subscriptionInstance.getPath();
1654
|
1655 schuur 1.12 String providerName,providerLocation;
1656 CIMInstance req_provider, req_providerModule;
1657 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
1658 req_provider = pidc.getProvider();
1659 req_providerModule = pidc.getModule();
1660 LocateIndicationProviderNames(req_provider, req_providerModule,providerName,providerLocation);
|
1661 schuur 1.1
1662 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1663 "JMPIProviderManager::handleCreateSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
1664 System::getHostName(),
1665 request->nameSpace.getString(),
1666 providerName);
1667
1668 String fileName = resolveFileName(providerLocation);
1669
1670 // get cached or load new provider module
1671 JMPIProvider::OpProviderHolder ph =
1672 providerManager.getProvider(fileName, providerName, String::EMPTY);
1673
1674 indProvRecord *prec=NULL;
|
1675 schuur 1.12 provTab.lookup(providerName,prec);
1676 if (prec) prec->count++;
|
1677 schuur 1.1 else {
|
1678 schuur 1.12 prec=new indProvRecord();
1679 provTab.insert(providerName,prec);
1680 }
|
1681 schuur 1.1
1682 indSelectRecord *srec=new indSelectRecord();
1683 const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
|
1684 schuur 1.12 selxTab.insert(sPath.toString(),srec);
|
1685 schuur 1.1
1686 // convert arguments
1687 OperationContext *context=new OperationContext();
1688
|
1689 schuur 1.12 if (prec->ctx==NULL) {
1690 prec->ctx=context;
1691 }
1692
1693 context->insert(request->operationContext.get(IdentityContainer::NAME));
1694 context->insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1695 context->insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1696 context->insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
1697 context->insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
1698 context->insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
|
1699 schuur 1.1
1700 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
1701
|
1702 schuur 1.12 SubscriptionFilterConditionContainer sub_cntr = request->operationContext.get
1703 (SubscriptionFilterConditionContainer::NAME);
1704
1705 CMPI_SelectExp *eSelx=new CMPI_SelectExp(*context,request->query,
1706 sub_cntr.getQueryLanguage());
1707 srec->eSelx=eSelx;
|
1708 schuur 1.1
|
1709 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
1710 schuur 1.1
1711 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1712 "Calling provider.createSubscriptionRequest: " + pr.getName());
1713
|
1714 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::createSubscriptionRequest"<<endl);
|
1715 schuur 1.1
1716 for(Uint32 i = 0, n = request->classNames.size(); i < n; i++) {
1717 CIMObjectPath className(
1718 System::getHostName(),
1719 request->nameSpace,
1720 request->classNames[i]);
1721 eSelx->classNames.append(className);
1722 }
1723
1724 CIMPropertyList propertyList = request->propertyList;
|
1725 schuur 1.12 if (!propertyList.isNull()) {
|
1726 schuur 1.1 Array<CIMName> p=propertyList.getPropertyNameArray();
1727 int pCount=p.size();
1728 eSelx->props=(const char**)malloc((1+pCount)*sizeof(char*));
1729 for (int i=0; i<pCount; i++) {
1730 eSelx->props[i]=strdup(p[i].getString().getCString());
1731 }
1732 eSelx->props[pCount]=NULL;
1733 }
1734
|
1735 schuur 1.12 JvmVector *jv;
1736 env=JMPIjvm::attachThread(&jv);
1737
1738 jobject jSel=env->NewObject(jv->SelectExpClassRef,
1739 jv->SelectExpNewI,(jint)eSelx);
1740 JMPIjvm::checkException(env);
1741
1742 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
1743 jv->CIMObjectPathNewI,(jint)&eSelx->classNames[0]);
1744 JMPIjvm::checkException(env);
1745
1746 jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString());
1747 JMPIjvm::checkException(env);
|
1748 schuur 1.1
1749 JMPIProvider::pm_service_op_lock op_lock(&pr);
1750
1751 STAT_GETSTARTTIME;
1752
|
1753 schuur 1.12 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"activateFilter",
1754 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
1755 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
1756 JMPIjvm::checkException(env);
1757
1758 env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType,
1759 jRef,(jboolean)0);
1760 JMPIjvm::checkException(env);
|
1761 schuur 1.1
1762 STAT_PMS_PROVIDEREND;
1763
1764 }
1765 HandlerCatch(handler);
|
1766 schuur 1.12
|
1767 schuur 1.1 PEG_METHOD_EXIT();
1768
1769 return(response);
1770 }
1771
1772 Message * JMPIProviderManager::handleDeleteSubscriptionRequest(const Message * message) throw()
1773 {
1774 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDeleteSubscriptionRequest");
1775
1776 HandlerIntroInd(DeleteSubscription,message,request,response,
1777 handler);
|
1778 schuur 1.12 JNIEnv *env=NULL;
|
1779 schuur 1.1 try {
|
1780 schuur 1.12 String providerName,providerLocation;
1781 CIMInstance req_provider, req_providerModule;
1782 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
1783 req_provider = pidc.getProvider();
1784 req_providerModule = pidc.getModule();
|
1785 se.gupta 1.9
|
1786 schuur 1.12 LocateIndicationProviderNames(req_provider, req_providerModule,
1787 providerName,providerLocation);
|
1788 schuur 1.1
1789 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1790 "JMPIProviderManager::handleDeleteSubscriptionRequest - Host name: $0 Name space: $1 Provider name(s): $2",
1791 System::getHostName(),
1792 request->nameSpace.getString(),
1793 providerName);
1794
1795 String fileName = resolveFileName(providerLocation);
1796
1797 // get cached or load new provider module
1798 JMPIProvider::OpProviderHolder ph =
1799 providerManager.getProvider(fileName, providerName, String::EMPTY);
1800
1801
1802 indProvRecord *prec=NULL;
|
1803 schuur 1.12 provTab.lookup(providerName,prec);
1804 if (--prec->count<=0) {
1805 provTab.remove(providerName);
1806 prec=NULL;
1807 }
|
1808 schuur 1.1
1809 indSelectRecord *srec=NULL;
1810 const CIMObjectPath &sPath=request->subscriptionInstance.getPath();
|
1811 schuur 1.12 String sPathString=sPath.toString();
1812 selxTab.lookup(sPathString,srec);
|
1813 schuur 1.1
1814 CMPI_SelectExp *eSelx=srec->eSelx;
|
1815 schuur 1.12 selxTab.remove(sPathString);
|
1816 schuur 1.1
|
1817 schuur 1.12 // convert arguments
|
1818 schuur 1.1 OperationContext context;
1819
|
1820 schuur 1.12 context.insert(request->operationContext.get(IdentityContainer::NAME));
1821 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1822 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1823 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
1824 context.insert(request->operationContext.get(SubscriptionLanguageListContainer::NAME));
1825
|
1826 schuur 1.1 CIMObjectPath subscriptionName = request->subscriptionInstance.getPath();
1827
|
1828 schuur 1.12 JMPIProvider & pr=ph.GetProvider();
|
1829 schuur 1.1
1830 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1831 "Calling provider.deleteSubscriptionRequest: " + pr.getName());
1832
|
1833 kumpf 1.2 DDD(cerr<<"--- JMPIProviderManager::deleteSubscriptionRequest"<<endl);
|
1834 schuur 1.1
|
1835 schuur 1.12 JvmVector *jv;
1836 env=JMPIjvm::attachThread(&jv);
1837
1838 jobject jSel=env->NewObject(jv->SelectExpClassRef,
1839 jv->SelectExpNewI,(jint)eSelx);
1840 JMPIjvm::checkException(env);
1841
1842 jobject jRef=env->NewObject(jv->CIMObjectPathClassRef,
1843 jv->CIMObjectPathNewI,(jint)&eSelx->classNames[0]);
1844 JMPIjvm::checkException(env);
1845
1846 jstring jType=env->NewStringUTF(request->nameSpace.getString().getCString());
1847 JMPIjvm::checkException(env);
1848
|
1849 schuur 1.1 JMPIProvider::pm_service_op_lock op_lock(&pr);
1850
1851 STAT_GETSTARTTIME;
1852
|
1853 schuur 1.12 jmethodID id=env->GetMethodID((jclass)pr.jProviderClass,"deActivateFilter",
1854 "(Lorg/pegasus/jmpi/SelectExp;Ljava/lang/String;"
1855 "Lorg/pegasus/jmpi/CIMObjectPath;Z)V");
1856 JMPIjvm::checkException(env);
|
1857 schuur 1.1
|
1858 schuur 1.12 env->CallVoidMethod((jobject)pr.jProvider,id,jSel,jType,
1859 jRef,(jboolean)(prec==NULL));
1860 JMPIjvm::checkException(env);
|
1861 schuur 1.1
1862 STAT_PMS_PROVIDEREND;
1863
|
1864 schuur 1.12 delete eSelx;
1865
|
1866 schuur 1.1 }
1867 HandlerCatch(handler);
|
1868 schuur 1.12
|
1869 schuur 1.1 PEG_METHOD_EXIT();
1870
1871 return(response);
1872 }
1873
1874 Message * JMPIProviderManager::handleEnableIndicationsRequest(const Message * message) throw()
1875 {
1876 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleEnableIndicationsRequest");
1877
1878 HandlerIntroInd(EnableIndications,message,request,response,
1879 handler);
1880 try {
1881 String providerName,providerLocation;
|
1882 se.gupta 1.9 CIMInstance req_provider, req_providerModule;
1883 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
1884 req_provider = pidc.getProvider();
1885 req_providerModule = pidc.getModule();
1886
1887 LocateIndicationProviderNames(req_provider, req_providerModule,
|
1888 schuur 1.1 providerName,providerLocation);
1889
1890 indProvRecord *provRec;
1891 if (provTab.lookup(providerName,provRec)) {
1892 provRec->enabled=true;
|
1893 kumpf 1.3 provRec->handler=new EnableIndicationsResponseHandler(
|
1894 schuur 1.12 request, response, req_provider, _indicationCallback);
|
1895 schuur 1.1 }
1896
1897 String fileName = resolveFileName(providerLocation);
1898
1899 // get cached or load new provider module
1900 JMPIProvider::OpProviderHolder ph =
1901 providerManager.getProvider(fileName, providerName, String::EMPTY);
1902
1903 }
1904 HandlerCatch(handler);
|
1905 schuur 1.12
|
1906 schuur 1.1 PEG_METHOD_EXIT();
1907
1908 return(response);
1909 }
1910
1911 Message * JMPIProviderManager::handleDisableIndicationsRequest(const Message * message) throw()
1912 {
1913 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager:: handleDisableIndicationsRequest");
1914
1915 HandlerIntroInd(DisableIndications,message,request,response,
1916 handler);
1917 try {
1918 String providerName,providerLocation;
|
1919 se.gupta 1.9 CIMInstance req_provider, req_providerModule;
1920 ProviderIdContainer pidc = (ProviderIdContainer)request->operationContext.get(ProviderIdContainer::NAME);
1921
1922 req_provider = pidc.getProvider();
1923 req_providerModule = pidc.getModule();
1924
1925 LocateIndicationProviderNames(req_provider, req_providerModule,
|
1926 schuur 1.1 providerName,providerLocation);
1927
1928 indProvRecord *provRec;
1929 if (provTab.lookup(providerName,provRec)) {
1930 provRec->enabled=false;
1931 if (provRec->handler) delete provRec->handler;
1932 provRec->handler=NULL;
1933 }
1934
1935 String fileName = resolveFileName(providerLocation);
1936
1937 // get cached or load new provider module
1938 JMPIProvider::OpProviderHolder ph =
1939 providerManager.getProvider(fileName, providerName, String::EMPTY);
1940 }
1941 HandlerCatch(handler);
|
1942 schuur 1.12
|
1943 schuur 1.1 PEG_METHOD_EXIT();
1944
1945 return(response);
|
1946 schuur 1.12 }
|
1947 schuur 1.1
1948 Message * JMPIProviderManager::handleDisableModuleRequest(const Message * message) throw()
1949 {
1950 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleDisableModuleRequest");
1951
1952 CIMDisableModuleRequestMessage * request =
1953 dynamic_cast<CIMDisableModuleRequestMessage *>(const_cast<Message *>(message));
1954
1955 PEGASUS_ASSERT(request != 0);
1956
1957 // get provider module name
1958 String moduleName;
1959 CIMInstance mInstance = request->providerModule;
1960 Uint32 pos = mInstance.findProperty(CIMName ("Name"));
1961
1962 if(pos != PEG_NOT_FOUND)
1963 {
1964 mInstance.getProperty(pos).getValue().get(moduleName);
1965 }
1966
1967 Boolean disableProviderOnly = request->disableProviderOnly;
1968 schuur 1.1
1969 Array<Uint16> operationalStatus;
|
1970 kumpf 1.2 // Assume success.
|
1971 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_STOPPED);
|
1972 schuur 1.1
|
1973 kumpf 1.2 //
|
1974 schuur 1.1 // Unload providers
|
1975 kumpf 1.2 //
|
1976 schuur 1.1 Array<CIMInstance> _pInstances = request->providers;
1977
1978 CIMDisableModuleResponseMessage * response =
1979 new CIMDisableModuleResponseMessage(
1980 request->messageId,
1981 CIMException(),
1982 request->queueIds.copyAndPop(),
1983 operationalStatus);
1984
1985 PEGASUS_ASSERT(response != 0);
1986
1987 // preserve message key
1988 response->setKey(request->getKey());
1989
1990 //
1991 // Set HTTP method in response from request
1992 //
1993 response->setHttpMethod (request->getHttpMethod ());
1994
1995 PEG_METHOD_EXIT();
1996
1997 schuur 1.1 return(response);
1998 }
1999
2000 Message * JMPIProviderManager::handleEnableModuleRequest(const Message * message) throw()
2001 {
2002 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleEnableModuleRequest");
2003
2004 CIMEnableModuleRequestMessage * request =
2005 dynamic_cast<CIMEnableModuleRequestMessage *>(const_cast<Message *>(message));
2006
2007 PEGASUS_ASSERT(request != 0);
2008
2009 Array<Uint16> operationalStatus;
|
2010 kumpf 1.10 operationalStatus.append(CIM_MSE_OPSTATUS_VALUE_OK);
|
2011 schuur 1.1
2012 CIMEnableModuleResponseMessage * response =
2013 new CIMEnableModuleResponseMessage(
2014 request->messageId,
2015 CIMException(),
2016 request->queueIds.copyAndPop(),
2017 operationalStatus);
2018
2019 PEGASUS_ASSERT(response != 0);
2020
2021 // preserve message key
2022 response->setKey(request->getKey());
2023
2024 // Set HTTP method in response from request
2025 response->setHttpMethod (request->getHttpMethod ());
2026
2027 PEG_METHOD_EXIT();
2028
2029 return(response);
2030 }
2031
2032 schuur 1.1 Message * JMPIProviderManager::handleStopAllProvidersRequest(const Message * message) throw()
2033 {
2034 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleStopAllProvidersRequest");
2035
2036 CIMStopAllProvidersRequestMessage * request =
2037 dynamic_cast<CIMStopAllProvidersRequestMessage *>(const_cast<Message *>(message));
2038
2039 PEGASUS_ASSERT(request != 0);
2040
2041 CIMStopAllProvidersResponseMessage * response =
2042 new CIMStopAllProvidersResponseMessage(
2043 request->messageId,
2044 CIMException(),
2045 request->queueIds.copyAndPop());
2046
2047 PEGASUS_ASSERT(response != 0);
2048
2049 // preserve message key
2050 response->setKey(request->getKey());
2051
2052 // Set HTTP method in response from request
2053 schuur 1.1 response->setHttpMethod (request->getHttpMethod ());
2054
2055 // tell the provider manager to shutdown all the providers
2056 providerManager.shutdownAllProviders();
2057
2058 PEG_METHOD_EXIT();
2059
2060 return(response);
2061 }
2062
|
2063 kumpf 1.4 Message * JMPIProviderManager::handleInitializeProviderRequest(const Message * message)
2064 {
2065 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleInitializeProviderRequest");
2066
2067 HandlerIntroInit(InitializeProvider,message,request,response,handler);
2068
2069 try
2070 {
2071 // resolve provider name
2072 ProviderName name = _resolveProviderName(
2073 request->operationContext.get(ProviderIdContainer::NAME));
2074
2075 // get cached or load new provider module
2076 JMPIProvider::OpProviderHolder ph =
2077 providerManager.getProvider(name.getPhysicalName(),
2078 name.getLogicalName(), String::EMPTY);
2079
2080 }
2081 HandlerCatch(handler);
2082
2083 PEG_METHOD_EXIT();
2084 kumpf 1.4
2085 return(response);
2086 }
2087
|
2088 schuur 1.1 Message * JMPIProviderManager::handleUnsupportedRequest(const Message * message) throw()
2089 {
2090 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "JMPIProviderManager::handleUnsupportedRequest");
2091
2092 PEG_METHOD_EXIT();
2093
2094 // a null response implies unsupported or unknown operation
2095 return(0);
2096 }
2097
|
2098 kumpf 1.2 ProviderName JMPIProviderManager::_resolveProviderName(
2099 const ProviderIdContainer & providerId)
|
2100 schuur 1.1 {
|
2101 kumpf 1.2 String providerName;
2102 String fileName;
2103 String interfaceName;
2104 CIMValue genericValue;
2105
2106 genericValue = providerId.getProvider().getProperty(
2107 providerId.getProvider().findProperty("Name")).getValue();
2108 genericValue.get(providerName);
2109
2110 genericValue = providerId.getModule().getProperty(
2111 providerId.getModule().findProperty("Location")).getValue();
2112 genericValue.get(fileName);
2113 fileName = resolveFileName(fileName);
2114
2115 // ATTN: This attribute is probably not required
2116 genericValue = providerId.getModule().getProperty(
2117 providerId.getModule().findProperty("InterfaceType")).getValue();
2118 genericValue.get(interfaceName);
2119
2120 return ProviderName(providerName, fileName, interfaceName, 0);
|
2121 schuur 1.1 }
2122
2123 String JMPIProviderManager::resolveFileName(String fileName)
2124 {
2125 String name;
2126 #if defined(PEGASUS_OS_TYPE_WINDOWS)
2127 name = fileName; // + String(".dll");
2128 #elif defined(PEGASUS_OS_HPUX) && defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
2129 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
2130 name.append(String("/") + fileName); // + String(".sl"));
2131 #elif defined(PEGASUS_OS_HPUX) && !defined(PEGASUS_PLATFORM_HPUX_PARISC_ACC)
2132 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
2133 name.append(String("/") + fileName); // + String(".so"));
2134 #elif defined(PEGASUS_OS_OS400)
2135 name = filrName;
2136 #else
2137 name = ConfigManager::getHomedPath(ConfigManager::getInstance()->getCurrentValue("providerDir"));
2138 name.append(String("/") + fileName); // + String(".so"));
2139 #endif
2140 return name;
2141 }
2142 schuur 1.1
2143 PEGASUS_NAMESPACE_END
|
Return to
JMPIProviderManager.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI