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