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