1 kumpf 1.1 //%2006////////////////////////////////////////////////////////////////////////
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 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
9 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
11 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
13 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
20 //
21 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 kumpf 1.1 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34 #include "ProviderMessageHandler.h"
35
36 #include <Pegasus/Common/OperationContextInternal.h>
37 #include <Pegasus/Common/Tracer.h>
38 #include <Pegasus/Common/StatisticalData.h>
39 #include <Pegasus/Common/Logger.h>
40 #include <Pegasus/Common/MessageLoader.h>
41 #include <Pegasus/Common/Constants.h>
42
43 kumpf 1.1 #include <Pegasus/Provider/CIMInstanceQueryProvider.h>
44 #include <Pegasus/Provider/CIMAssociationProvider.h>
45 #include <Pegasus/Provider/CIMMethodProvider.h>
46 #include <Pegasus/Provider/CIMIndicationProvider.h>
47 #include <Pegasus/Provider/CIMIndicationConsumerProvider.h>
48
49 #include <Pegasus/Query/QueryExpression/QueryExpression.h>
50 #include <Pegasus/ProviderManager2/QueryExpressionFactory.h>
51
52 #include <Pegasus/ProviderManager2/SimpleResponseHandler.h>
53 #include <Pegasus/ProviderManager2/OperationResponseHandler.h>
54 #include <Pegasus/ProviderManager2/AutoPThreadSecurity.h>
55
56 #define HandleCatch(handler) \
57 catch (CIMException& e) \
58 { \
59 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
60 "Exception: " + e.getMessage()); \
61 handler.setStatus(e.getCode(), e.getContentLanguages(), e.getMessage()); \
62 } \
63 catch (Exception& e) \
64 kumpf 1.1 { \
65 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
66 "Exception: " + e.getMessage()); \
67 handler.setStatus(CIM_ERR_FAILED, e.getContentLanguages(), e.getMessage());\
68 } \
69 catch (...) \
70 { \
71 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, \
72 "Exception: Unknown"); \
73 handler.setStatus(CIM_ERR_FAILED, "Unknown error."); \
74 }
75
76
77 PEGASUS_NAMESPACE_BEGIN
78
79 // auto variable to protect provider during operations
80 class pm_service_op_lock
81 {
82 public:
83 pm_service_op_lock(ProviderStatus *providerStatus)
84 : _providerStatus(providerStatus)
85 kumpf 1.1 {
86 _providerStatus->protect();
87 }
88
89 ~pm_service_op_lock()
90 {
91 _providerStatus->unprotect();
92 }
93
94 private:
95 pm_service_op_lock();
96 pm_service_op_lock(const pm_service_op_lock&);
97 pm_service_op_lock& operator=(const pm_service_op_lock&);
98
99 ProviderStatus* _providerStatus;
100 };
101
102 class op_counter
103 {
104 public:
105 op_counter(AtomicInt* counter)
106 kumpf 1.1 : _counter(counter)
107 {
108 (*_counter)++;
109 }
110
111 ~op_counter()
112 {
113 (*_counter)--;
114 }
115
116 private:
117 op_counter();
118 op_counter(const op_counter&);
119 op_counter& operator=(const op_counter&);
120
121 AtomicInt* _counter;
122 };
123
124 template<class T>
125 inline T* getProviderInterface(CIMProvider* provider)
126 {
127 kumpf 1.1 T * p = dynamic_cast<T *>(provider);
128
129 if (p == 0)
130 {
131 throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_NOT_SUPPORTED, MessageLoaderParms(
132 "ProviderManager.ProviderFacade.INVALID_PROVIDER_INTERFACE",
133 "Invalid provider interface."));
134 }
135
136 return p;
137 }
138
139 //
140 // Default Provider Manager
141 //
142 ProviderMessageHandler::ProviderMessageHandler(
143 const String& name,
144 CIMProvider* provider,
145 PEGASUS_INDICATION_CALLBACK_T indicationCallback,
146 PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,
147 Boolean subscriptionInitComplete)
148 kumpf 1.1 : _name(name),
149 _provider(provider),
150 _indicationCallback(indicationCallback),
151 _responseChunkCallback(responseChunkCallback),
152 _subscriptionInitComplete(subscriptionInitComplete),
153 _indicationResponseHandler(0)
154 {
155 }
156
157 ProviderMessageHandler::~ProviderMessageHandler()
158 {
159 }
160
161 String ProviderMessageHandler::getName() const
162 {
163 return _name;
164 }
165
166 void ProviderMessageHandler::setProvider(CIMProvider* provider)
167 {
168 _provider = provider;
169 kumpf 1.1 }
170
171 void ProviderMessageHandler::initialize(CIMOMHandle& cimom)
172 {
173 _provider->initialize(cimom);
174 }
175
176 void ProviderMessageHandler::terminate()
177 {
178 _disableIndications();
179 _provider->terminate();
180 }
181
182 void ProviderMessageHandler::subscriptionInitComplete()
183 {
184 if (status.testSubscriptions())
185 {
186 _enableIndications();
187 }
188
189 _subscriptionInitComplete = true;
190 kumpf 1.1 }
191
192 CIMResponseMessage* ProviderMessageHandler::processMessage(
193 CIMRequestMessage* request)
194 {
195 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
196 "ProviderMessageHandler::processMessage()");
197
198 op_counter ops(&status._currentOperations);
199
200 CIMResponseMessage* response = 0;
201
202 // pass the request message to a handler method based on message type
203 switch(request->getType())
204 {
205 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
206 response = _handleGetInstanceRequest(request);
207 break;
208
209 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
210 response = _handleEnumerateInstancesRequest(request);
211 kumpf 1.1 break;
212
213 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
214 response = _handleEnumerateInstanceNamesRequest(request);
215 break;
216
217 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
218 response = _handleCreateInstanceRequest(request);
219 break;
220
221 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
222 response = _handleModifyInstanceRequest(request);
223 break;
224
225 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
226 response = _handleDeleteInstanceRequest(request);
227 break;
228
229 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
230 response = _handleExecQueryRequest(request);
231 break;
232 kumpf 1.1
233 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
234 response = _handleAssociatorsRequest(request);
235 break;
236
237 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
238 response = _handleAssociatorNamesRequest(request);
239 break;
240
241 case CIM_REFERENCES_REQUEST_MESSAGE:
242 response = _handleReferencesRequest(request);
243 break;
244
245 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
246 response = _handleReferenceNamesRequest(request);
247 break;
248
249 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
250 response = _handleGetPropertyRequest(request);
251 break;
252
253 kumpf 1.1 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
254 response = _handleSetPropertyRequest(request);
255 break;
256
257 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
258 response = _handleInvokeMethodRequest(request);
259 break;
260
261 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
262 response = _handleCreateSubscriptionRequest(request);
263 break;
264
265 case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
266 response = _handleModifySubscriptionRequest(request);
267 break;
268
269 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
270 response = _handleDeleteSubscriptionRequest(request);
271 break;
272
273 case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
274 kumpf 1.1 response = _handleExportIndicationRequest(request);
275 break;
276
277 default:
278 PEGASUS_ASSERT(0);
279 break;
280 }
281
282 PEG_METHOD_EXIT();
283
284 return response;
285 }
286
287 CIMResponseMessage* ProviderMessageHandler::_handleGetInstanceRequest(
288 CIMRequestMessage* message)
289 {
290 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
291 "ProviderMessageHandler::_handleGetInstanceRequest");
292
293 CIMGetInstanceRequestMessage* request =
294 dynamic_cast<CIMGetInstanceRequestMessage*>(message);
295 kumpf 1.1 PEGASUS_ASSERT(request != 0);
296
297 CIMGetInstanceResponseMessage* response =
298 dynamic_cast<CIMGetInstanceResponseMessage*>(
299 request->buildResponse());
300 PEGASUS_ASSERT(response != 0);
301
302 // create a handler for this request
303 GetInstanceResponseHandler handler(
304 request, response, _responseChunkCallback);
305
306 try
307 {
308 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
309 "ProviderMessageHandler::_handleGetInstanceRequest - "
310 "Host name: $0 Name space: $1 Class name: $2",
311 System::getHostName(),
312 request->nameSpace.getString(),
313 request->instanceName.getClassName().getString());
314
315 // make target object path
316 kumpf 1.1 CIMObjectPath objectPath(
317 System::getHostName(),
318 request->nameSpace,
319 request->instanceName.getClassName(),
320 request->instanceName.getKeyBindings());
321
322 // convert arguments
323 OperationContext context;
324
325 context.insert(request->operationContext.get(IdentityContainer::NAME));
326 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
327 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
328
329 // forward request
330 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
331 "Calling provider.getInstance: " + _name);
332
333 AutoPThreadSecurity threadLevelSecurity(context);
334
335 pm_service_op_lock op_lock(&status);
336
337 kumpf 1.1 StatProviderTimeMeasurement providerTime(response);
338
339 CIMInstanceProvider* provider =
340 getProviderInterface<CIMInstanceProvider>(_provider);
341
342 provider->getInstance(
343 context,
344 objectPath,
345 request->includeQualifiers,
346 request->includeClassOrigin,
347 request->propertyList,
348 handler);
349 }
350 HandleCatch(handler);
351
352 PEG_METHOD_EXIT();
353 return(response);
354 }
355
356 CIMResponseMessage* ProviderMessageHandler::_handleEnumerateInstancesRequest(
357 CIMRequestMessage* message)
358 kumpf 1.1 {
359 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
360 "ProviderMessageHandler::_handleEnumerateInstanceRequest");
361
362 CIMEnumerateInstancesRequestMessage* request =
363 dynamic_cast<CIMEnumerateInstancesRequestMessage*>(message);
364 PEGASUS_ASSERT(request != 0);
365
366 CIMEnumerateInstancesResponseMessage* response =
367 dynamic_cast<CIMEnumerateInstancesResponseMessage*>(
368 request->buildResponse());
369 PEGASUS_ASSERT(response != 0);
370
371 // create a handler for this request
372 EnumerateInstancesResponseHandler handler(
373 request, response, _responseChunkCallback);
374
375 try
376 {
377 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
378 Logger::TRACE,
379 kumpf 1.1 "ProviderMessageHandler::_handleEnumerateInstancesRequest - "
380 "Host name: $0 Name space: $1 Class name: $2",
381 System::getHostName(),
382 request->nameSpace.getString(),
383 request->className.getString()));
384
385 // make target object path
386 CIMObjectPath objectPath(
387 System::getHostName(),
388 request->nameSpace,
389 request->className);
390
391 // convert arguments
392 OperationContext context;
393
394 context.insert(request->operationContext.get(IdentityContainer::NAME));
395 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
396 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
397
398 // forward request
399 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
400 kumpf 1.1 "Calling provider.enumerateInstances: " + _name);
401
402 AutoPThreadSecurity threadLevelSecurity(context);
403
404 pm_service_op_lock op_lock(&status);
405
406 StatProviderTimeMeasurement providerTime(response);
407
408 CIMInstanceProvider* provider =
409 getProviderInterface<CIMInstanceProvider>(_provider);
410
411 provider->enumerateInstances(
412 context,
413 objectPath,
414 request->includeQualifiers,
415 request->includeClassOrigin,
416 request->propertyList,
417 handler);
418
419 }
420 HandleCatch(handler);
421 kumpf 1.1
422 PEG_METHOD_EXIT();
423
424 return(response);
425 }
426
427 CIMResponseMessage* ProviderMessageHandler::_handleEnumerateInstanceNamesRequest(
428 CIMRequestMessage* message)
429 {
430 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
431 "ProviderMessageHandler::_handleEnumerateInstanceNamesRequest");
432
433 CIMEnumerateInstanceNamesRequestMessage* request =
434 dynamic_cast<CIMEnumerateInstanceNamesRequestMessage*>(message);
435 PEGASUS_ASSERT(request != 0);
436
437 CIMEnumerateInstanceNamesResponseMessage* response =
438 dynamic_cast<CIMEnumerateInstanceNamesResponseMessage*>(
439 request->buildResponse());
440 PEGASUS_ASSERT(response != 0);
441
442 kumpf 1.1 // create a handler for this request
443 EnumerateInstanceNamesResponseHandler handler(
444 request, response, _responseChunkCallback);
445
446 // process the request
447 try
448 {
449 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
450 Logger::TRACE,
451 "ProviderMessageHandler::_handleEnumerateInstanceNamesRequest - "
452 "Host name: $0 Name space: $1 Class name: $2",
453 System::getHostName(),
454 request->nameSpace.getString(),
455 request->className.getString()));
456
457 // make target object path
458 CIMObjectPath objectPath(
459 System::getHostName(),
460 request->nameSpace,
461 request->className);
462
463 kumpf 1.1 // convert arguments
464 OperationContext context;
465
466 context.insert(request->operationContext.get(IdentityContainer::NAME));
467 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
468 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
469
470 // forward request
471 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
472 "Calling provider.enumerateInstanceNames: " + _name);
473
474 AutoPThreadSecurity threadLevelSecurity(context);
475
476 pm_service_op_lock op_lock(&status);
477
478 StatProviderTimeMeasurement providerTime(response);
479
480 CIMInstanceProvider* provider =
481 getProviderInterface<CIMInstanceProvider>(_provider);
482
483 provider->enumerateInstanceNames(
484 kumpf 1.1 context,
485 objectPath,
486 handler);
487
488 }
489 HandleCatch(handler);
490
491 PEG_METHOD_EXIT();
492
493 return(response);
494 }
495
496 CIMResponseMessage* ProviderMessageHandler::_handleCreateInstanceRequest(
497 CIMRequestMessage* message)
498 {
499 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
500 "ProviderMessageHandler::_handleCreateInstanceRequest");
501
502 CIMCreateInstanceRequestMessage* request =
503 dynamic_cast<CIMCreateInstanceRequestMessage*>(message);
504 PEGASUS_ASSERT(request != 0);
505 kumpf 1.1
506 // create response message
507 CIMCreateInstanceResponseMessage* response =
508 dynamic_cast<CIMCreateInstanceResponseMessage*>(
509 request->buildResponse());
510 PEGASUS_ASSERT(response != 0);
511
512 // create a handler for this request
513 CreateInstanceResponseHandler handler(
514 request, response, _responseChunkCallback);
515
516 try
517 {
518 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
519 Logger::TRACE,
520 "ProviderMessageHandler::_handleCreateInstanceRequest - "
521 "Host name: $0 Name space: $1 Class name: $2",
522 System::getHostName(),
523 request->nameSpace.getString(),
524 request->newInstance.getPath().getClassName().getString()));
525
526 kumpf 1.1 // make target object path
527 CIMObjectPath objectPath(
528 System::getHostName(),
529 request->nameSpace,
530 request->newInstance.getPath().getClassName(),
531 request->newInstance.getPath().getKeyBindings());
532
533 // convert arguments
534 OperationContext context;
535
536 context.insert(request->operationContext.get(IdentityContainer::NAME));
537 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
538 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
539
540 // forward request
541 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
542 "Calling provider.createInstance: " + _name);
543
544 AutoPThreadSecurity threadLevelSecurity(context);
545
546 pm_service_op_lock op_lock(&status);
547 kumpf 1.1
548 StatProviderTimeMeasurement providerTime(response);
549
550 CIMInstanceProvider* provider =
551 getProviderInterface<CIMInstanceProvider>(_provider);
552
553 provider->createInstance(
554 context,
555 objectPath,
556 request->newInstance,
557 handler);
558
559 }
560 HandleCatch(handler);
561
562 PEG_METHOD_EXIT();
563
564 return(response);
565 }
566
567 CIMResponseMessage* ProviderMessageHandler::_handleModifyInstanceRequest(
568 kumpf 1.1 CIMRequestMessage* message)
569 {
570 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
571 "ProviderMessageHandler::_handleModifyInstanceRequest");
572
573 CIMModifyInstanceRequestMessage* request =
574 dynamic_cast<CIMModifyInstanceRequestMessage*>(message);
575 PEGASUS_ASSERT(request != 0);
576
577 // create response message
578 CIMModifyInstanceResponseMessage* response =
579 dynamic_cast<CIMModifyInstanceResponseMessage*>(
580 request->buildResponse());
581 PEGASUS_ASSERT(response != 0);
582
583 // create a handler for this request
584 ModifyInstanceResponseHandler handler(
585 request, response, _responseChunkCallback);
586
587 try
588 {
589 kumpf 1.1 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
590 Logger::TRACE,
591 "ProviderMessageHandler::_handleModifyInstanceRequest - "
592 "Host name: $0 Name space: $1 Class name: $2",
593 System::getHostName(),
594 request->nameSpace.getString(),
595 request->modifiedInstance.getPath().getClassName().getString()));
596
597 // make target object path
598 CIMObjectPath objectPath(
599 System::getHostName(),
600 request->nameSpace,
601 request->modifiedInstance.getPath ().getClassName(),
602 request->modifiedInstance.getPath ().getKeyBindings());
603
604 // convert arguments
605 OperationContext context;
606
607 context.insert(request->operationContext.get(IdentityContainer::NAME));
608 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
609 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
610 kumpf 1.1
611 // forward request
612 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
613 "Calling provider.modifyInstance: " + _name);
614
615 AutoPThreadSecurity threadLevelSecurity(context);
616
617 pm_service_op_lock op_lock(&status);
618
619 StatProviderTimeMeasurement providerTime(response);
620
621 CIMInstanceProvider* provider =
622 getProviderInterface<CIMInstanceProvider>(_provider);
623
624 provider->modifyInstance(
625 context,
626 objectPath,
627 request->modifiedInstance,
628 request->includeQualifiers,
629 request->propertyList,
630 handler);
631 kumpf 1.1
632 }
633 HandleCatch(handler);
634
635 PEG_METHOD_EXIT();
636
637 return(response);
638 }
639
640 CIMResponseMessage* ProviderMessageHandler::_handleDeleteInstanceRequest(
641 CIMRequestMessage* message)
642 {
643 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
644 "ProviderMessageHandler::_handleDeleteInstanceRequest");
645
646 CIMDeleteInstanceRequestMessage* request =
647 dynamic_cast<CIMDeleteInstanceRequestMessage*>(message);
648 PEGASUS_ASSERT(request != 0);
649
650 // create response message
651 CIMDeleteInstanceResponseMessage* response =
652 kumpf 1.1 dynamic_cast<CIMDeleteInstanceResponseMessage*>(
653 request->buildResponse());
654 PEGASUS_ASSERT(response != 0);
655
656 // create a handler for this request
657 DeleteInstanceResponseHandler handler(
658 request, response, _responseChunkCallback);
659
660 try
661 {
662 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
663 Logger::TRACE,
664 "ProviderMessageHandler::_handleDeleteInstanceRequest - "
665 "Host name: $0 Name space: $1 Class name: $2",
666 System::getHostName(),
667 request->nameSpace.getString(),
668 request->instanceName.getClassName().getString()));
669
670 // make target object path
671 CIMObjectPath objectPath(
672 System::getHostName(),
673 kumpf 1.1 request->nameSpace,
674 request->instanceName.getClassName(),
675 request->instanceName.getKeyBindings());
676
677 // convert arguments
678 OperationContext context;
679
680 context.insert(request->operationContext.get(IdentityContainer::NAME));
681 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
682 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
683
684 // forward request
685 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
686 "Calling provider.deleteInstance: " + _name);
687
688 AutoPThreadSecurity threadLevelSecurity(context);
689
690 pm_service_op_lock op_lock(&status);
691
692 StatProviderTimeMeasurement providerTime(response);
693
694 kumpf 1.1 CIMInstanceProvider* provider =
695 getProviderInterface<CIMInstanceProvider>(_provider);
696
697 provider->deleteInstance(
698 context,
699 objectPath,
700 handler);
701
702 }
703 HandleCatch(handler);
704
705 PEG_METHOD_EXIT();
706
707 return(response);
708 }
709
710 CIMResponseMessage* ProviderMessageHandler::_handleExecQueryRequest(
711 CIMRequestMessage* message)
712 {
713 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
714 "ProviderMessageHandler::_handleExecQueryRequest");
715 kumpf 1.1
716 CIMExecQueryRequestMessage* request =
717 dynamic_cast<CIMExecQueryRequestMessage*>(message);
718 PEGASUS_ASSERT(request != 0);
719
720 CIMExecQueryResponseMessage* response =
721 dynamic_cast<CIMExecQueryResponseMessage*>(
722 request->buildResponse());
723 PEGASUS_ASSERT(response != 0);
724
725 // create a handler for this request
726 ExecQueryResponseHandler handler(
727 request, response, _responseChunkCallback);
728
729 try
730 {
731 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
732 Logger::TRACE,
733 "ProviderMessageHandler::_handleExecQueryRequest - "
734 "Host name: $0 Name space: $1 Class name: $2",
735 System::getHostName(),
736 kumpf 1.1 request->nameSpace.getString(),
737 request->className.getString()));
738
739 // make target object path
740 CIMObjectPath objectPath(
741 System::getHostName(),
742 request->nameSpace,
743 request->className);
744
745 // convert arguments
746 OperationContext context;
747
748 context.insert(request->operationContext.get(IdentityContainer::NAME));
749 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
750 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
751
752 QueryExpression qx(request->queryLanguage,request->query);
753
754 // forward request
755 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
756 "Calling provider.execQuery: " + _name);
757 kumpf 1.1
758 AutoPThreadSecurity threadLevelSecurity(context);
759
760 pm_service_op_lock op_lock(&status);
761
762 StatProviderTimeMeasurement providerTime(response);
763
764 CIMInstanceQueryProvider* provider =
765 getProviderInterface<CIMInstanceQueryProvider>(_provider);
766
767 provider->execQuery(
768 context,
769 objectPath,
770 qx,
771 handler);
772
773 }
774 HandleCatch(handler);
775
776 PEG_METHOD_EXIT();
777
778 kumpf 1.1 return(response);
779 }
780
781 CIMResponseMessage* ProviderMessageHandler::_handleAssociatorsRequest(
782 CIMRequestMessage* message)
783 {
784 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
785 "ProviderMessageHandler::_handleAssociatorsRequest");
786
787 CIMAssociatorsRequestMessage* request =
788 dynamic_cast<CIMAssociatorsRequestMessage*>(message);
789 PEGASUS_ASSERT(request != 0);
790
791 CIMAssociatorsResponseMessage* response =
792 dynamic_cast<CIMAssociatorsResponseMessage*>(
793 request->buildResponse());
794 PEGASUS_ASSERT(response != 0);
795
796 // create a handler for this request
797 AssociatorsResponseHandler handler(
798 request, response, _responseChunkCallback);
799 kumpf 1.1
800 // process the request
801 try
802 {
803 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
804 Logger::TRACE,
805 "ProviderMessageHandler::_handleAssociatorsRequest - "
806 "Host name: $0 Name space: $1 Class name: $2",
807 System::getHostName(),
808 request->nameSpace.getString(),
809 request->objectName.getClassName().getString()));
810
811 // make target object path
812 CIMObjectPath objectPath(
813 System::getHostName(),
814 request->nameSpace,
815 request->objectName.getClassName());
816
817 objectPath.setKeyBindings(request->objectName.getKeyBindings());
818
819 CIMObjectPath assocPath(
820 kumpf 1.1 System::getHostName(),
821 request->nameSpace,
822 request->assocClass.getString());
823
824 // convert arguments
825 OperationContext context;
826
827 context.insert(request->operationContext.get(IdentityContainer::NAME));
828 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
829 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
830
831 AutoPThreadSecurity threadLevelSecurity(context);
832
833 StatProviderTimeMeasurement providerTime(response);
834
835 pm_service_op_lock op_lock(&status);
836
837 CIMAssociationProvider* provider =
838 getProviderInterface<CIMAssociationProvider>(_provider);
839
840 provider->associators(
841 kumpf 1.1 context,
842 objectPath,
843 request->assocClass,
844 request->resultClass,
845 request->role,
846 request->resultRole,
847 request->includeQualifiers,
848 request->includeClassOrigin,
849 request->propertyList,
850 handler);
851
852 }
853 HandleCatch(handler);
854
855 PEG_METHOD_EXIT();
856
857 return(response);
858 }
859
860 CIMResponseMessage* ProviderMessageHandler::_handleAssociatorNamesRequest(
861 CIMRequestMessage* message)
862 kumpf 1.1 {
863 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
864 "ProviderMessageHandler::_handleAssociatorNamesRequest");
865
866 CIMAssociatorNamesRequestMessage* request =
867 dynamic_cast<CIMAssociatorNamesRequestMessage*>(message);
868 PEGASUS_ASSERT(request != 0);
869
870 CIMAssociatorNamesResponseMessage* response =
871 dynamic_cast<CIMAssociatorNamesResponseMessage*>(
872 request->buildResponse());
873 PEGASUS_ASSERT(response != 0);
874
875 // create a handler for this request
876 AssociatorNamesResponseHandler handler(
877 request, response, _responseChunkCallback);
878
879 // process the request
880 try
881 {
882 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
883 kumpf 1.1 Logger::TRACE,
884 "ProviderMessageHandler::_handleAssociationNamesRequest - "
885 "Host name: $0 Name space: $1 Class name: $2",
886 System::getHostName(),
887 request->nameSpace.getString(),
888 request->objectName.getClassName().getString()));
889
890 // make target object path
891 CIMObjectPath objectPath(
892 System::getHostName(),
893 request->nameSpace,
894 request->objectName.getClassName());
895
896 objectPath.setKeyBindings(request->objectName.getKeyBindings());
897
898 CIMObjectPath assocPath(
899 System::getHostName(),
900 request->nameSpace,
901 request->assocClass.getString());
902
903 // convert arguments
904 kumpf 1.1 OperationContext context;
905
906 context.insert(request->operationContext.get(IdentityContainer::NAME));
907 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
908 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
909
910 AutoPThreadSecurity threadLevelSecurity(context);
911
912 StatProviderTimeMeasurement providerTime(response);
913
914 pm_service_op_lock op_lock(&status);
915
916 CIMAssociationProvider* provider =
917 getProviderInterface<CIMAssociationProvider>(_provider);
918
919 provider->associatorNames(
920 context,
921 objectPath,
922 request->assocClass,
923 request->resultClass,
924 request->role,
925 kumpf 1.1 request->resultRole,
926 handler);
927
928 }
929 HandleCatch(handler);
930
931 PEG_METHOD_EXIT();
932
933 return(response);
934 }
935
936 CIMResponseMessage* ProviderMessageHandler::_handleReferencesRequest(
937 CIMRequestMessage* message)
938 {
939 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
940 "ProviderMessageHandler::_handleReferencesRequest");
941
942 CIMReferencesRequestMessage* request =
943 dynamic_cast<CIMReferencesRequestMessage*>(message);
944 PEGASUS_ASSERT(request != 0);
945
946 kumpf 1.1 CIMReferencesResponseMessage* response =
947 dynamic_cast<CIMReferencesResponseMessage*>(
948 request->buildResponse());
949 PEGASUS_ASSERT(response != 0);
950
951 // create a handler for this request
952 ReferencesResponseHandler handler(
953 request, response, _responseChunkCallback);
954
955 // process the request
956 try
957 {
958 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
959 Logger::TRACE,
960 "ProviderMessageHandler::_handleReferencesRequest - "
961 "Host name: $0 Name space: $1 Class name: $2",
962 System::getHostName(),
963 request->nameSpace.getString(),
964 request->objectName.getClassName().getString()));
965
966 // make target object path
967 kumpf 1.1 CIMObjectPath objectPath(
968 System::getHostName(),
969 request->nameSpace,
970 request->objectName.getClassName());
971
972 objectPath.setKeyBindings(request->objectName.getKeyBindings());
973
974 CIMObjectPath resultPath(
975 System::getHostName(),
976 request->nameSpace,
977 request->resultClass.getString());
978
979 // convert arguments
980 OperationContext context;
981
982 context.insert(request->operationContext.get(IdentityContainer::NAME));
983 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
984 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
985
986 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
987 "Calling provider.references: " + _name);
988 kumpf 1.1
989 AutoPThreadSecurity threadLevelSecurity(context);
990
991 StatProviderTimeMeasurement providerTime(response);
992
993 pm_service_op_lock op_lock(&status);
994
995 CIMAssociationProvider* provider =
996 getProviderInterface<CIMAssociationProvider>(_provider);
997
998 provider->references(
999 context,
1000 objectPath,
1001 request->resultClass,
1002 request->role,
1003 request->includeQualifiers,
1004 request->includeClassOrigin,
1005 request->propertyList,
1006 handler);
1007
1008 }
1009 kumpf 1.1 HandleCatch(handler);
1010
1011 PEG_METHOD_EXIT();
1012
1013 return(response);
1014 }
1015
1016 CIMResponseMessage* ProviderMessageHandler::_handleReferenceNamesRequest(
1017 CIMRequestMessage* message)
1018 {
1019 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1020 "ProviderMessageHandler::_handleReferenceNamesRequest");
1021
1022 CIMReferenceNamesRequestMessage* request =
1023 dynamic_cast<CIMReferenceNamesRequestMessage*>(message);
1024 PEGASUS_ASSERT(request != 0);
1025
1026 CIMReferenceNamesResponseMessage* response =
1027 dynamic_cast<CIMReferenceNamesResponseMessage*>(
1028 request->buildResponse());
1029 PEGASUS_ASSERT(response != 0);
1030 kumpf 1.1
1031 // create a handler for this request
1032 ReferenceNamesResponseHandler handler(
1033 request, response, _responseChunkCallback);
1034
1035 // process the request
1036 try
1037 {
1038 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
1039 Logger::TRACE,
1040 "ProviderMessageHandler::_handleReferenceNamesRequest - "
1041 "Host name: $0 Name space: $1 Class name: $2",
1042 System::getHostName(),
1043 request->nameSpace.getString(),
1044 request->objectName.getClassName().getString()));
1045
1046 // make target object path
1047 CIMObjectPath objectPath(
1048 System::getHostName(),
1049 request->nameSpace,
1050 request->objectName.getClassName());
1051 kumpf 1.1
1052 objectPath.setKeyBindings(request->objectName.getKeyBindings());
1053
1054 CIMObjectPath resultPath(
1055 System::getHostName(),
1056 request->nameSpace,
1057 request->resultClass.getString());
1058
1059 // convert arguments
1060 OperationContext context;
1061
1062 context.insert(request->operationContext.get(IdentityContainer::NAME));
1063 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1064 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1065
1066 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1067 "Calling provider.referenceNames: " + _name);
1068
1069 AutoPThreadSecurity threadLevelSecurity(context);
1070
1071 StatProviderTimeMeasurement providerTime(response);
1072 kumpf 1.1
1073 pm_service_op_lock op_lock(&status);
1074
1075 CIMAssociationProvider* provider =
1076 getProviderInterface<CIMAssociationProvider>(_provider);
1077
1078 provider->referenceNames(
1079 context,
1080 objectPath,
1081 request->resultClass,
1082 request->role,
1083 handler);
1084
1085 }
1086 HandleCatch(handler);
1087
1088 PEG_METHOD_EXIT();
1089
1090 return(response);
1091 }
1092
1093 kumpf 1.1 CIMResponseMessage* ProviderMessageHandler::_handleGetPropertyRequest(
1094 CIMRequestMessage* message)
1095 {
1096 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1097 "ProviderMessageHandler::_handleGetPropertyRequest");
1098
1099 CIMGetPropertyRequestMessage* request =
1100 dynamic_cast<CIMGetPropertyRequestMessage*>(message);
1101 PEGASUS_ASSERT(request != 0);
1102
1103 CIMGetPropertyResponseMessage* response =
1104 dynamic_cast<CIMGetPropertyResponseMessage*>(
1105 request->buildResponse());
1106 PEGASUS_ASSERT(response != 0);
1107
1108 // create a handler for this request
1109 SimpleInstanceResponseHandler handler;
1110
1111 try
1112 {
1113 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1114 kumpf 1.1 "ProviderMessageHandler::_handleGetPropertyRequest - "
1115 "Host name: $0 Name space: $1 Class name: $2 Property: $3",
1116 System::getHostName(),
1117 request->nameSpace.getString(),
1118 request->instanceName.getClassName().getString(),
1119 request->propertyName.getString());
1120
1121 // make target object path
1122 CIMObjectPath objectPath(
1123 System::getHostName(),
1124 request->nameSpace,
1125 request->instanceName.getClassName(),
1126 request->instanceName.getKeyBindings());
1127
1128 Array<CIMName> propertyList;
1129 propertyList.append(request->propertyName);
1130
1131 // convert arguments
1132 OperationContext context;
1133
1134 context.insert(request->operationContext.get(IdentityContainer::NAME));
1135 kumpf 1.1 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1136 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1137
1138 // forward request
1139 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1140 "Calling provider.getInstance: " + _name);
1141
1142 AutoPThreadSecurity threadLevelSecurity(context);
1143
1144 pm_service_op_lock op_lock(&status);
1145
1146 StatProviderTimeMeasurement providerTime(response);
1147
1148 CIMInstanceProvider* provider =
1149 getProviderInterface<CIMInstanceProvider>(_provider);
1150
1151 provider->getInstance(
1152 context,
1153 objectPath,
1154 false, // includeQualifiers
1155 false, // includeClassOrigin
1156 kumpf 1.1 propertyList,
1157 handler);
1158
1159 if (handler.getObjects().size())
1160 {
1161 CIMInstance instance = handler.getObjects()[0];
1162
1163 Uint32 pos = instance.findProperty(request->propertyName);
1164
1165 if (pos != PEG_NOT_FOUND)
1166 {
1167 response->value = instance.getProperty(pos).getValue();
1168 }
1169 else // Property not found. Return CIM_ERR_NO_SUCH_PROPERTY.
1170 {
1171 response->cimException = PEGASUS_CIM_EXCEPTION(
1172 CIM_ERR_NO_SUCH_PROPERTY,
1173 request->propertyName.getString());
1174 }
1175 }
1176
1177 kumpf 1.1 response->operationContext.set(
1178 ContentLanguageListContainer(handler.getLanguages()));
1179 }
1180 catch (CIMException& e)
1181 {
1182 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1183 "Exception: " + e.getMessage());
1184 response->cimException = PEGASUS_CIM_EXCEPTION_LANG(
1185 e.getContentLanguages(), e.getCode(), e.getMessage());
1186 }
1187 catch (Exception& e)
1188 {
1189 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1190 "Exception: " + e.getMessage());
1191 response->cimException = PEGASUS_CIM_EXCEPTION_LANG(
1192 e.getContentLanguages(), CIM_ERR_FAILED, e.getMessage());
1193 }
1194 catch (...)
1195 {
1196 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1197 "Exception: Unknown");
1198 kumpf 1.1 response->cimException = PEGASUS_CIM_EXCEPTION(
1199 CIM_ERR_FAILED, "Unknown error.");
1200 }
1201
1202 PEG_METHOD_EXIT();
1203 return(response);
1204 }
1205
1206 CIMResponseMessage* ProviderMessageHandler::_handleSetPropertyRequest(
1207 CIMRequestMessage* message)
1208 {
1209 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1210 "ProviderMessageHandler::_handleSetPropertyRequest");
1211
1212 CIMSetPropertyRequestMessage* request =
1213 dynamic_cast<CIMSetPropertyRequestMessage*>(message);
1214 PEGASUS_ASSERT(request != 0);
1215
1216 CIMSetPropertyResponseMessage* response =
1217 dynamic_cast<CIMSetPropertyResponseMessage*>(
1218 request->buildResponse());
1219 kumpf 1.1 PEGASUS_ASSERT(response != 0);
1220
1221 // create a handler for this request
1222 SimpleInstanceResponseHandler handler;
1223
1224 try
1225 {
1226 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
1227 "ProviderMessageHandler::_handleSetPropertyRequest - "
1228 "Host name: $0 Name space: $1 Class name: $2 Property: $3",
1229 System::getHostName(),
1230 request->nameSpace.getString(),
1231 request->instanceName.getClassName().getString(),
1232 request->propertyName.getString());
1233
1234 // make target object path
1235 CIMObjectPath objectPath(
1236 System::getHostName(),
1237 request->nameSpace,
1238 request->instanceName.getClassName(),
1239 request->instanceName.getKeyBindings());
1240 kumpf 1.1
1241 CIMInstance instance(request->instanceName.getClassName());
1242 instance.addProperty(CIMProperty(
1243 request->propertyName, request->newValue));
1244
1245 Array<CIMName> propertyList;
1246 propertyList.append(request->propertyName);
1247
1248 // convert arguments
1249 OperationContext context;
1250
1251 context.insert(request->operationContext.get(IdentityContainer::NAME));
1252 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1253 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1254
1255 // forward request
1256 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1257 "Calling provider.modifyInstance: " + _name);
1258
1259 AutoPThreadSecurity threadLevelSecurity(context);
1260
1261 kumpf 1.1 pm_service_op_lock op_lock(&status);
1262
1263 StatProviderTimeMeasurement providerTime(response);
1264
1265 CIMInstanceProvider* provider =
1266 getProviderInterface<CIMInstanceProvider>(_provider);
1267
1268 provider->modifyInstance(
1269 context,
1270 objectPath,
1271 instance,
1272 false, // includeQualifiers
1273 propertyList,
1274 handler);
1275
1276 response->operationContext.set(
1277 ContentLanguageListContainer(handler.getLanguages()));
1278 }
1279 catch (CIMException& e)
1280 {
1281 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1282 kumpf 1.1 "Exception: " + e.getMessage());
1283 response->cimException = PEGASUS_CIM_EXCEPTION_LANG(
1284 e.getContentLanguages(), e.getCode(), e.getMessage());
1285 }
1286 catch (Exception& e)
1287 {
1288 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1289 "Exception: " + e.getMessage());
1290 response->cimException = PEGASUS_CIM_EXCEPTION_LANG(
1291 e.getContentLanguages(), CIM_ERR_FAILED, e.getMessage());
1292 }
1293 catch (...)
1294 {
1295 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1296 "Exception: Unknown");
1297 response->cimException = PEGASUS_CIM_EXCEPTION(
1298 CIM_ERR_FAILED, "Unknown error.");
1299 }
1300
1301 PEG_METHOD_EXIT();
1302 return(response);
1303 kumpf 1.1 }
1304
1305 CIMResponseMessage* ProviderMessageHandler::_handleInvokeMethodRequest(
1306 CIMRequestMessage* message)
1307 {
1308 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1309 "ProviderMessageHandler::_handleInvokeMethodRequest");
1310
1311 CIMInvokeMethodRequestMessage* request =
1312 dynamic_cast<CIMInvokeMethodRequestMessage*>(message);
1313 PEGASUS_ASSERT(request != 0);
1314
1315 // create response message
1316 CIMInvokeMethodResponseMessage* response =
1317 dynamic_cast<CIMInvokeMethodResponseMessage*>(
1318 request->buildResponse());
1319 PEGASUS_ASSERT(response != 0);
1320
1321 // create a handler for this request
1322 InvokeMethodResponseHandler handler(
1323 request, response, _responseChunkCallback);
1324 kumpf 1.1
1325 try
1326 {
1327 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
1328 Logger::TRACE,
1329 "ProviderMessageHandler::_handleInvokeMethodRequest - "
1330 "Host name: $0 Name space: $1 Class name: $2",
1331 System::getHostName(),
1332 request->nameSpace.getString(),
1333 request->instanceName.getClassName().getString()));
1334
1335 // make target object path
1336 CIMObjectPath objectPath(
1337 System::getHostName(),
1338 request->nameSpace,
1339 request->instanceName.getClassName(),
1340 request->instanceName.getKeyBindings());
1341
1342 // convert arguments
1343 OperationContext context;
1344
1345 kumpf 1.1 context.insert(request->operationContext.get(IdentityContainer::NAME));
1346 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1347 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1348
1349 CIMObjectPath instanceReference(request->instanceName);
1350 instanceReference.setNameSpace(request->nameSpace);
1351
1352 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1353 "Calling provider.invokeMethod: " + _name);
1354
1355 AutoPThreadSecurity threadLevelSecurity(context);
1356
1357 StatProviderTimeMeasurement providerTime(response);
1358
1359 pm_service_op_lock op_lock(&status);
1360
1361 CIMMethodProvider* provider =
1362 getProviderInterface<CIMMethodProvider>(_provider);
1363
1364 provider->invokeMethod(
1365 context,
1366 kumpf 1.1 instanceReference,
1367 request->methodName,
1368 request->inParameters,
1369 handler);
1370
1371 }
1372 HandleCatch(handler);
1373
1374 PEG_METHOD_EXIT();
1375
1376 return(response);
1377 }
1378
1379 CIMResponseMessage* ProviderMessageHandler::_handleCreateSubscriptionRequest(
1380 CIMRequestMessage* message)
1381 {
1382 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1383 "ProviderMessageHandler::_handleCreateSubscriptionRequest");
1384
1385 CIMCreateSubscriptionRequestMessage* request =
1386 dynamic_cast<CIMCreateSubscriptionRequestMessage*>(message);
1387 kumpf 1.1 PEGASUS_ASSERT(request != 0);
1388
1389 CIMCreateSubscriptionResponseMessage* response =
1390 dynamic_cast<CIMCreateSubscriptionResponseMessage*>(
1391 request->buildResponse());
1392 PEGASUS_ASSERT(response != 0);
1393
1394 OperationResponseHandler handler(
1395 request, response, _responseChunkCallback);
1396
1397 try
1398 {
1399 String temp;
1400
1401 for (Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1402 {
1403 temp.append(request->classNames[i].getString());
1404
1405 if (i < (n - 1))
1406 {
1407 temp.append(", ");
1408 kumpf 1.1 }
1409 }
1410
1411 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
1412 Logger::TRACE,
1413 "ProviderMessageHandler::_handleCreateSubscriptionRequest - "
1414 "Host name: $0 Name space: $1 Class name(s): $2",
1415 System::getHostName(),
1416 request->nameSpace.getString(),
1417 temp));
1418
1419 //
1420 // Save the provider instance from the request
1421 //
1422 ProviderIdContainer pidc = (ProviderIdContainer)
1423 request->operationContext.get(ProviderIdContainer::NAME);
1424 status.setProviderInstance(pidc.getProvider());
1425
1426 // convert arguments
1427 OperationContext context;
1428
1429 kumpf 1.1 context.insert(request->operationContext.get(IdentityContainer::NAME));
1430 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1431 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1432 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
1433 context.insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
1434 context.insert(request->operationContext.get(SubscriptionFilterQueryContainer::NAME));
1435
1436 Array<CIMObjectPath> classNames;
1437
1438 for (Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1439 {
1440 CIMObjectPath className(
1441 System::getHostName(),
1442 request->nameSpace,
1443 request->classNames[i]);
1444
1445 classNames.append(className);
1446 }
1447
1448 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1449 "Calling provider.createSubscription: " + _name);
1450 kumpf 1.1
1451 AutoPThreadSecurity threadLevelSecurity(context);
1452
1453 pm_service_op_lock op_lock(&status);
1454
1455 CIMIndicationProvider* provider =
1456 getProviderInterface<CIMIndicationProvider>(_provider);
1457
1458 provider->createSubscription(
1459 context,
1460 request->subscriptionInstance.getPath(),
1461 classNames,
1462 request->propertyList,
1463 request->repeatNotificationPolicy);
1464
1465 //
1466 // Increment count of current subscriptions for this provider
1467 //
1468 if (status.testIfZeroAndIncrementSubscriptions())
1469 {
1470 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1471 kumpf 1.1 "First accepted subscription");
1472
1473 //
1474 // If there were no current subscriptions before the increment,
1475 // the first subscription has been created
1476 // Call the provider's enableIndications method
1477 //
1478 if (_subscriptionInitComplete)
1479 {
1480 _enableIndications();
1481 }
1482 }
1483 }
1484 HandleCatch(handler);
1485
1486 PEG_METHOD_EXIT();
1487 return(response);
1488 }
1489
1490 CIMResponseMessage* ProviderMessageHandler::_handleModifySubscriptionRequest(
1491 CIMRequestMessage* message)
1492 kumpf 1.1 {
1493 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1494 "ProviderMessageHandler::_handleModifySubscriptionRequest");
1495
1496 CIMModifySubscriptionRequestMessage* request =
1497 dynamic_cast<CIMModifySubscriptionRequestMessage*>(message);
1498 PEGASUS_ASSERT(request != 0);
1499
1500 CIMModifySubscriptionResponseMessage* response =
1501 dynamic_cast<CIMModifySubscriptionResponseMessage*>(
1502 request->buildResponse());
1503 PEGASUS_ASSERT(response != 0);
1504
1505 OperationResponseHandler handler(
1506 request, response, _responseChunkCallback);
1507
1508 try
1509 {
1510 String temp;
1511
1512 for (Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1513 kumpf 1.1 {
1514 temp.append(request->classNames[i].getString());
1515
1516 if (i < (n - 1))
1517 {
1518 temp.append(", ");
1519 }
1520 }
1521
1522 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
1523 Logger::TRACE,
1524 "ProviderMessageHandler::_handleCreateSubscriptionRequest - "
1525 "Host name: $0 Name space: $1 Class name(s): $2",
1526 System::getHostName(),
1527 request->nameSpace.getString(),
1528 temp));
1529
1530 // convert arguments
1531 OperationContext context;
1532 context.insert(request->operationContext.get(IdentityContainer::NAME));
1533 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1534 kumpf 1.1 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1535 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
1536 context.insert(request->operationContext.get(SubscriptionFilterConditionContainer::NAME));
1537 context.insert(request->operationContext.get(SubscriptionFilterQueryContainer::NAME));
1538
1539 Array<CIMObjectPath> classNames;
1540
1541 for (Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1542 {
1543 CIMObjectPath className(
1544 System::getHostName(),
1545 request->nameSpace,
1546 request->classNames[i]);
1547
1548 classNames.append(className);
1549 }
1550
1551 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1552 "Calling provider.modifySubscription: " + _name);
1553
1554 AutoPThreadSecurity threadLevelSecurity(context);
1555 kumpf 1.1
1556 pm_service_op_lock op_lock(&status);
1557
1558 CIMIndicationProvider* provider =
1559 getProviderInterface<CIMIndicationProvider>(_provider);
1560
1561 provider->modifySubscription(
1562 context,
1563 request->subscriptionInstance.getPath(),
1564 classNames,
1565 request->propertyList,
1566 request->repeatNotificationPolicy);
1567
1568 }
1569 HandleCatch(handler);
1570
1571 PEG_METHOD_EXIT();
1572 return(response);
1573 }
1574
1575 CIMResponseMessage* ProviderMessageHandler::_handleDeleteSubscriptionRequest(
1576 kumpf 1.1 CIMRequestMessage* message)
1577 {
1578 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1579 "ProviderMessageHandler::_handleDeleteSubscriptionRequest");
1580
1581 CIMDeleteSubscriptionRequestMessage* request =
1582 dynamic_cast<CIMDeleteSubscriptionRequestMessage*>(message);
1583 PEGASUS_ASSERT(request != 0);
1584
1585 CIMDeleteSubscriptionResponseMessage* response =
1586 dynamic_cast<CIMDeleteSubscriptionResponseMessage*>(
1587 request->buildResponse());
1588 PEGASUS_ASSERT(response != 0);
1589
1590 OperationResponseHandler handler(
1591 request, response, _responseChunkCallback);
1592
1593 try
1594 {
1595 String temp;
1596
1597 kumpf 1.1 for (Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1598 {
1599 temp.append(request->classNames[i].getString());
1600
1601 if (i < (n - 1))
1602 {
1603 temp.append(", ");
1604 }
1605 }
1606
1607 PEG_LOGGER_TRACE((Logger::STANDARD_LOG, System::CIMSERVER,
1608 Logger::TRACE,
1609 "ProviderMessageHandler::_handleDeleteSubscriptionRequest - "
1610 "Host name: $0 Name space: $1 Class name(s): $2",
1611 System::getHostName(),
1612 request->nameSpace.getString(),
1613 temp));
1614
1615 // convert arguments
1616 OperationContext context;
1617
1618 kumpf 1.1 context.insert(request->operationContext.get(IdentityContainer::NAME));
1619 context.insert(request->operationContext.get(AcceptLanguageListContainer::NAME));
1620 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1621 context.insert(request->operationContext.get(SubscriptionInstanceContainer::NAME));
1622
1623 Array<CIMObjectPath> classNames;
1624
1625 for (Uint32 i = 0, n = request->classNames.size(); i < n; i++)
1626 {
1627 CIMObjectPath className(
1628 System::getHostName(),
1629 request->nameSpace,
1630 request->classNames[i]);
1631
1632 classNames.append(className);
1633 }
1634
1635 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1636 "Calling provider.deleteSubscription: " + _name);
1637
1638 AutoPThreadSecurity threadLevelSecurity(context);
1639 kumpf 1.1
1640 pm_service_op_lock op_lock(&status);
1641
1642 CIMIndicationProvider* provider =
1643 getProviderInterface<CIMIndicationProvider>(_provider);
1644
1645 provider->deleteSubscription(
1646 context,
1647 request->subscriptionInstance.getPath(),
1648 classNames);
1649
1650 //
1651 // Decrement count of current subscriptions for this provider
1652 //
1653 if (status.decrementSubscriptionsAndTestIfZero())
1654 {
1655 //
1656 // If there are no current subscriptions after the decrement,
1657 // the last subscription has been deleted
1658 // Call the provider's disableIndications method
1659 //
1660 kumpf 1.1 if (_subscriptionInitComplete)
1661 {
1662 _disableIndications();
1663 }
1664 }
1665 }
1666 HandleCatch(handler);
1667
1668 PEG_METHOD_EXIT();
1669 return(response);
1670 }
1671
1672 CIMResponseMessage* ProviderMessageHandler::_handleExportIndicationRequest(
1673 CIMRequestMessage* message)
1674 {
1675 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1676 "ProviderMessageHandler::_handleExportIndicationRequest");
1677
1678 CIMExportIndicationRequestMessage* request =
1679 dynamic_cast<CIMExportIndicationRequestMessage*>(message);
1680 PEGASUS_ASSERT(request != 0);
1681 kumpf 1.1
1682 CIMExportIndicationResponseMessage* response =
1683 dynamic_cast<CIMExportIndicationResponseMessage*>(
1684 request->buildResponse());
1685 PEGASUS_ASSERT(response != 0);
1686
1687 OperationResponseHandler handler(
1688 request, response, _responseChunkCallback);
1689
1690 try
1691 {
1692 OperationContext context;
1693
1694 context.insert(request->operationContext.get(IdentityContainer::NAME));
1695
1696 //L10N_TODO
1697 // ATTN-CEC 06/04/03 NOTE: I can't find where the consume msg is sent. This
1698 // does not appear to be hooked up. When it is added, need to
1699 // make sure that Content-Language is set in the consume msg.
1700 // NOTE: A-L is not needed to be set in the consume msg.
1701
1702 kumpf 1.1 // add the langs to the context
1703 context.insert(request->operationContext.get(ContentLanguageListContainer::NAME));
1704
1705 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1706 "Calling provider.consumeIndication: " + _name);
1707
1708 StatProviderTimeMeasurement providerTime(response);
1709
1710 pm_service_op_lock op_lock(&status);
1711
1712 CIMIndicationConsumerProvider* provider =
1713 getProviderInterface<CIMIndicationConsumerProvider>(_provider);
1714
1715 provider->consumeIndication(
1716 context,
1717 request->destinationPath,
1718 request->indicationInstance);
1719 }
1720 HandleCatch(handler);
1721
1722 PEG_METHOD_EXIT();
1723 kumpf 1.1 return(response);
1724 }
1725
1726 void ProviderMessageHandler::_enableIndications()
1727 {
1728 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1729 "DefaultProviderManager::_enableIndications");
1730
1731 try
1732 {
1733 EnableIndicationsResponseHandler* indicationResponseHandler =
1734 new EnableIndicationsResponseHandler(
1735 0, // request
1736 0, // response
1737 status.getProviderInstance(),
1738 _indicationCallback,
1739 _responseChunkCallback);
1740
1741 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1742 "Calling provider.enableIndications: " + _name);
1743
1744 kumpf 1.1 pm_service_op_lock op_lock(&status);
1745
1746 status.protect();
1747
1748 status._indicationsEnabled = true;
1749
1750 CIMIndicationProvider* provider =
1751 getProviderInterface<CIMIndicationProvider>(_provider);
1752
1753 provider->enableIndications(*indicationResponseHandler);
1754
1755 _indicationResponseHandler = indicationResponseHandler;
1756 }
1757 catch (CIMException& e)
1758 {
1759 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
1760 "CIMException: " + e.getMessage ());
1761
1762 Logger::put_l(Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
1763 "ProviderManager.Default.DefaultProviderManager."
1764 "ENABLE_INDICATIONS_FAILED",
1765 kumpf 1.1 "Failed to enable indications for provider $0: $1.",
1766 _name, e.getMessage());
1767 }
1768 catch (Exception& e)
1769 {
1770 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
1771 "Exception: " + e.getMessage ());
1772
1773 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
1774 "ProviderManager.Default.DefaultProviderManager."
1775 "ENABLE_INDICATIONS_FAILED",
1776 "Failed to enable indications for provider $0: $1.",
1777 _name, e.getMessage());
1778 }
1779 catch(...)
1780 {
1781 PEG_TRACE_STRING (TRC_PROVIDERMANAGER, Tracer::LEVEL2,
1782 "Unexpected error in _enableIndications");
1783
1784 Logger::put_l (Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,
1785 "ProviderManager.Default.DefaultProviderManager."
1786 kumpf 1.1 "ENABLE_INDICATIONS_FAILED_UNKNOWN",
1787 "Failed to enable indications for provider $0.",
1788 _name);
1789 }
1790
1791 PEG_METHOD_EXIT();
1792 }
1793
1794 void ProviderMessageHandler::_disableIndications()
1795 {
1796 PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
1797 "DefaultProviderManager::_disableIndications");
1798
1799 try
1800 {
1801 if (status._indicationsEnabled)
1802 {
1803 pm_service_op_lock op_lock(&status);
1804
1805 CIMIndicationProvider* provider =
1806 getProviderInterface<CIMIndicationProvider>(_provider);
1807 kumpf 1.1
1808 provider->disableIndications();
1809
1810 status._indicationsEnabled = false;
1811
1812 status.unprotect();
1813
1814 status.resetSubscriptions();
1815
1816 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
1817 "Destroying indication response handler for " + _name);
1818
1819 delete _indicationResponseHandler;
1820 _indicationResponseHandler = 0;
1821 }
1822 }
1823 catch(...)
1824 {
1825 PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,
1826 "Error occured disabling indications in provider " + _name);
1827 }
1828 kumpf 1.1 }
1829
1830 PEGASUS_NAMESPACE_END
|
Return to
ProviderMessageHandler.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / Default