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