1 karl 1.5 //%2005////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.2 // 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 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.2 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.5 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 schuur 1.1 //
12 // Permission is hereby granted, free of charge, to any person obtaining a copy
13 // of this software and associated documentation files (the "Software"), to
14 // deal in the Software without restriction, including without limitation the
15 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
16 // sell copies of the Software, and to permit persons to whom the Software is
17 // furnished to do so, subject to the following conditions:
|
18 chip 1.7 //
|
19 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
20 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
21 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
22 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
23 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //==============================================================================
29 //
30 // Author: Chip Vincent (cvincent@us.ibm.com)
31 //
32 // Modified By:
|
33 brian.campbell 1.3 // Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
|
34 chip 1.7 //
|
35 schuur 1.1 //%/////////////////////////////////////////////////////////////////////////////
36
37 #include "OperationResponseHandler.h"
|
38 chip 1.7
39 #include <Pegasus/Common/Logger.h>
40
41 #include <Pegasus/ProviderManager2/ProviderManagerService.h>
|
42 schuur 1.1
43 PEGASUS_NAMESPACE_BEGIN
44
|
45 chip 1.7 //
46 // OperationResponseHandler
47 //
48
49 OperationResponseHandler::OperationResponseHandler(
50 CIMRequestMessage *request,
51 CIMResponseMessage *response)
52 : _request(request),
53 _response(response),
|
54 chip 1.8 _responseObjectTotal(0),
|
55 chip 1.7 _responseMessageTotal(0),
56 _responseObjectThreshold(0)
|
57 brian.campbell 1.3 {
58 #ifndef PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD
|
59 chip 1.7 #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD 100
|
60 brian.campbell 1.3 #elif PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD == 0
|
61 chip 1.7 #undef PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD
62 #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD ~0
|
63 brian.campbell 1.3 #endif
64
|
65 carolann.graves 1.6 if (!request || (request->requestIsOOP == true))
|
66 a.dunfey 1.4 {
67 _responseObjectThreshold = ~0;
68 }
69 else
70 {
71 _responseObjectThreshold = PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD;
|
72 brian.campbell 1.3
73 #ifdef PEGASUS_DEBUG
|
74 chip 1.7 static const char *responseObjectThreshold =
|
75 a.dunfey 1.4 getenv("PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD");
|
76 chip 1.7
77 if (responseObjectThreshold)
|
78 a.dunfey 1.4 {
|
79 chip 1.7 Uint32 i = (Uint32)atoi(responseObjectThreshold);
80
81 if (i > 0)
82 {
83 _responseObjectThreshold = i;
84 }
|
85 a.dunfey 1.4 }
|
86 brian.campbell 1.3 #endif
|
87 a.dunfey 1.4 }
|
88 brian.campbell 1.3 }
89
90 OperationResponseHandler::~OperationResponseHandler()
91 {
92 _request = 0;
93 _response = 0;
94 }
95
|
96 chip 1.7 CIMRequestMessage * OperationResponseHandler::getRequest(void) const
97 {
98 return(_request);
99 }
100
101 CIMResponseMessage * OperationResponseHandler::getResponse(void) const
102 {
103 return(_response);
104 }
105
106 void OperationResponseHandler::setStatus(
107 const Uint32 code,
108 const String & message)
109 {
110 _response->cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message);
111 }
112
113 void OperationResponseHandler::setStatus(
114 const Uint32 code,
115 const ContentLanguages & langs,
116 const String & message)
117 chip 1.7 {
118 _response->cimException =
119 PEGASUS_CIM_EXCEPTION_LANG(
120 langs,
121 CIMStatusCode(code),
122 message);
123 }
124
125 Boolean OperationResponseHandler::isAsync(void) const
126 {
127 return(true);
128 }
129
|
130 brian.campbell 1.3 // This is only called from SimpleResponseHandler.deliver() but lives in this
131 // class because all asyncronous response must have a "response" pointer
132 // to go through. Only operation classes have a response pointer
133 void OperationResponseHandler::send(Boolean isComplete)
134 {
135 // some handlers do not send async because their callers cannot handle
136 // partial responses. If this is the case, stop here.
137
138 if (isAsync() == false)
139 {
140 // preserve tradional behavior
141 if (isComplete == true)
|
142 chip 1.7 {
143 transfer();
144 }
145
146 return;
|
147 brian.campbell 1.3 }
148
149 SimpleResponseHandler *simpleP = dynamic_cast<SimpleResponseHandler*>(this);
150
151 // It is possible to instantiate this class directly (not derived)
|
152 chip 1.7 // The caller would do this only if the operation does not have any data to
|
153 brian.campbell 1.3 // be returned
154
155 if (! simpleP)
156 {
157 // if there is no data to be returned, then the message should NEVER be
158 // incomplete (even on an error)
159 if (isComplete == false)
|
160 chip 1.7 {
161 PEGASUS_ASSERT(false);
162 }
163
164 return;
|
165 brian.campbell 1.3 }
166
167 SimpleResponseHandler &simple = *simpleP;
168 PEGASUS_ASSERT(_response);
169 Uint32 objectCount = simple.size();
170
171 // have not reached threshold yet
|
172 chip 1.7 if ((isComplete == false) && (objectCount < _responseObjectThreshold))
173 {
174 return;
175 }
|
176 brian.campbell 1.3
177 CIMResponseMessage *response = _response;
178
179 // for complete responses, just use the one handed down from caller
180 // otherwise, create our own that the caller never sees but is
181 // utilized for async responses underneath
182
183 if (isComplete == false)
|
184 chip 1.7 {
185 _response = _request->buildResponse();
186 }
|
187 brian.campbell 1.3
188 _response->setComplete(isComplete);
189 _responseObjectTotal += objectCount;
190
191 // since we are reusing response for every chunk,keep track of original count
192 _response->setIndex(_responseMessageTotal++);
193
194 // set the originally allocated response to one more than the current.
195 // The reason for doing this is proactive in case of an exception. This
196 // allows the last response to be set as it may not re-enter this code.
197
198 if (isComplete == false)
|
199 chip 1.7 {
200 response->setIndex(_responseMessageTotal);
201 }
|
202 brian.campbell 1.3
203 validate();
204
205 if (_response->cimException.getCode() != CIM_ERR_SUCCESS)
|
206 chip 1.7 {
207 simple.clear();
208 }
209
|
210 brian.campbell 1.3 String function = getClass() + "::" + "transfer";
|
211 chip 1.7 Logger::put(
212 Logger::STANDARD_LOG,
213 System::CIMSERVER,
214 Logger::TRACE,
215 function);
216
|
217 brian.campbell 1.3 transfer();
218 simple.clear();
219
220 // l10n
|
221 chip 1.7 _response->operationContext.set(ContentLanguageListContainer(simple.getLanguages()));
|
222 brian.campbell 1.3
223 // call thru ProviderManager to get externally declared entry point
224
225 if (isComplete == false)
226 {
227 ProviderManagerService::handleCimResponse(*_request, *_response);
228 }
229
230 // put caller's allocated response back in place. Note that _response
231 // is INVALID after sending because it has been deleted externally
232
233 _response = response;
234 }
235
|
236 chip 1.7 void OperationResponseHandler::transfer(void)
237 {
238 }
239
240 void OperationResponseHandler::validate(void)
241 {
242 }
243
244 String OperationResponseHandler::getClass(void) const
245 {
246 return(String("OperationResponseHandler"));
247 }
248
249 Uint32 OperationResponseHandler::getResponseObjectTotal(void) const
250 {
251 return(_responseObjectTotal);
252 }
253
254 Uint32 OperationResponseHandler::getResponseMessageTotal(void) const
255 {
256 return(_responseMessageTotal);
257 chip 1.7 }
258
259 Uint32 OperationResponseHandler::getResponseObjectThreshold(void) const
260 {
261 return(_responseObjectThreshold);
262 }
263
264 //
265 // GetInstanceResponseHandler
266 //
267
268 GetInstanceResponseHandler::GetInstanceResponseHandler(
269 CIMGetInstanceRequestMessage * request,
270 CIMGetInstanceResponseMessage * response)
271 : OperationResponseHandler(request, response)
272 {
273 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
274 // Attempt to get the cached class definition used to validate results of this
275 // operation. If it does not exist, then this feature is disabled for this
276 // operation.
277 CIMClass cimClass;
278 chip 1.7
279 try
280 {
281 CachedClassDefinitionContainer container =
282 request->operationContext.get(CachedClassDefinitionContainer::NAME);
283
284 cimClass = container.getClass();
285
286 }
287 catch(Exception &)
288 {
289 // Do nothing. Container is missing, which implies normalization is disabled
290 // for this operation.
291 }
292
293 _normalizer =
294 ObjectNormalizer(
295 cimClass,
296 request->includeQualifiers,
297 request->includeClassOrigin);
298 #endif
299 chip 1.7 }
300
301 void GetInstanceResponseHandler::deliver(const CIMInstance & cimInstance)
302 {
303 if(cimInstance.isUninitialized())
304 {
305 MessageLoaderParms message(
306 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
307 "The object is not initialized.");
308
309 throw CIMException(CIM_ERR_FAILED, message);
310 }
311
312 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
313 // The normalizer expects an object path embedded in instances even
314 // though it is not required by this operation. Use the requested
315 // object path is missing from the instance.
316 CIMInstance localInstance(cimInstance);
317
318 if(localInstance.getPath().getKeyBindings().size() == 0)
319 {
320 chip 1.7 // ATTN: should clone before modification
321 localInstance.setPath(static_cast<CIMGetInstanceRequestMessage *>(getRequest())->instanceName);
322 }
323
324 SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(localInstance));
325 #else
326 SimpleInstanceResponseHandler::deliver(cimInstance);
327 #endif
328 }
329
330 String GetInstanceResponseHandler::getClass(void) const
331 {
332 return(String("GetInstanceResponseHandler"));
333 }
334
335 void GetInstanceResponseHandler::transfer(void)
336 {
337 if(size() > 0)
338 {
339 CIMGetInstanceResponseMessage & msg =
340 *static_cast<CIMGetInstanceResponseMessage *>(getResponse());
341 chip 1.7
342 msg.cimInstance = getObjects()[0];
343 }
344 }
345
346 void GetInstanceResponseHandler::validate(void)
347 {
348 if(getResponseObjectTotal() == 0)
349 {
350 // error? provider claims success,
351 // but did not deliver an instance.
352 setStatus(CIM_ERR_NOT_FOUND);
353 }
354 }
355
356 //
357 // EnumerateInstancesResponseHandler
358 //
359
360 EnumerateInstancesResponseHandler::EnumerateInstancesResponseHandler(
361 CIMEnumerateInstancesRequestMessage * request,
362 chip 1.7 CIMEnumerateInstancesResponseMessage * response)
363 : OperationResponseHandler(request, response)
364 {
365 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
366 // Attempt to get the cached class definition used to validate results of this
367 // operation. If it does not exist, then this feature is disabled for this
368 // operation.
369 CIMClass cimClass;
370
371 try
372 {
373 CachedClassDefinitionContainer container =
374 request->operationContext.get(CachedClassDefinitionContainer::NAME);
375
376 cimClass = container.getClass();
377 }
378 catch(Exception &)
379 {
380 // Do nothing. Container is missing, which implies normalization is disabled
381 // for this operation.
382 }
383 chip 1.7
384 _normalizer =
385 ObjectNormalizer(
386 cimClass,
387 request->includeQualifiers,
388 request->includeClassOrigin);
389 #endif
390 }
391
392 void EnumerateInstancesResponseHandler::deliver(const CIMInstance & cimInstance)
393 {
394 if(cimInstance.isUninitialized())
395 {
396 MessageLoaderParms message(
397 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
398 "The object is not initialized.");
399
400 throw CIMException(CIM_ERR_FAILED, message);
401 }
402
403 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
404 chip 1.7 SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance));
405 #else
406 SimpleInstanceResponseHandler::deliver(cimInstance);
407 #endif
408 }
409
410 String EnumerateInstancesResponseHandler::getClass(void) const
411 {
412 return(String("EnumerateInstancesResponseHandler"));
413 }
414
415 void EnumerateInstancesResponseHandler::transfer(void)
416 {
417 CIMEnumerateInstancesResponseMessage & msg =
418 *static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse());
419
420 msg.cimNamedInstances = getObjects();
421 }
422
423 //
424 // EnumerateInstanceNamesResponseHandler
425 chip 1.7 //
426
427 EnumerateInstanceNamesResponseHandler::EnumerateInstanceNamesResponseHandler(
428 CIMEnumerateInstanceNamesRequestMessage * request,
429 CIMEnumerateInstanceNamesResponseMessage * response)
430 : OperationResponseHandler(request, response)
431 {
432 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
433 // Attempt to get the cached class definition used to validate results of this
434 // operation. If it does not exist, then this feature is disabled for this
435 // operation.
436 CIMClass cimClass;
437
438 try
439 {
440 CachedClassDefinitionContainer container =
441 request->operationContext.get(CachedClassDefinitionContainer::NAME);
442
443 cimClass = container.getClass();
444 }
445 catch(Exception &)
446 chip 1.7 {
447 // Do nothing. Container is missing, which implies normalization is disabled
448 // for this operation.
449 }
450
451 _normalizer =
452 ObjectNormalizer(
453 cimClass,
454 false,
455 false);
456 #endif
457 }
458
459 void EnumerateInstanceNamesResponseHandler::deliver(const CIMObjectPath & cimObjectPath)
460 {
461 if(cimObjectPath.getClassName().isNull())
462 {
463 MessageLoaderParms message(
464 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
465 "The object is not initialized.");
466
467 chip 1.7 throw CIMException(CIM_ERR_FAILED, message);
468 }
469
470 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
471 SimpleObjectPathResponseHandler::deliver(_normalizer.processInstanceObjectPath(cimObjectPath));
472 #else
473 SimpleObjectPathResponseHandler::deliver(cimObjectPath);
474 #endif
475 }
476
477 String EnumerateInstanceNamesResponseHandler::getClass(void) const
478 {
479 return(String("EnumerateInstanceNamesResponseHandler"));
480 }
481
482 void EnumerateInstanceNamesResponseHandler::transfer(void)
483 {
484 CIMEnumerateInstanceNamesResponseMessage & msg =
485 *static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse());
486
487 msg.instanceNames = getObjects();
488 chip 1.7 }
489
490 //
491 // CreateInstanceResponseHandler
492 //
493
494 CreateInstanceResponseHandler::CreateInstanceResponseHandler(
495 CIMCreateInstanceRequestMessage * request,
496 CIMCreateInstanceResponseMessage * response)
497 : OperationResponseHandler(request, response)
498 {
499 }
500
501 void CreateInstanceResponseHandler::deliver(const CIMObjectPath & cimObjectPath)
502 {
503 if(cimObjectPath.getClassName().isNull())
504 {
505 MessageLoaderParms message(
506 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
507 "The object is not initialized.");
508
509 chip 1.7 throw CIMException(CIM_ERR_FAILED, message);
510 }
511
512 SimpleObjectPathResponseHandler::deliver(cimObjectPath);
513 }
514
515 String CreateInstanceResponseHandler::getClass(void) const
516 {
517 return(String("CreateInstanceResponseHandler"));
518 }
519
520 #if 0
521 // ATTN: is it an error to not return instance name?
522 void CreateInstanceResponseHandler::validate(void)
523 {
524 if(getResponseObjectTotal() == 0)
525 {
526 setStatus(CIM_ERR_NOT_FOUND);
527 }
528 }
529 #endif
530 chip 1.7
531 void CreateInstanceResponseHandler::transfer(void)
532 {
533 if(size() > 0)
534 {
535 CIMCreateInstanceResponseMessage & msg =
536 *static_cast<CIMCreateInstanceResponseMessage *>(getResponse());
537
538 msg.instanceName = getObjects()[0];
539 }
540 }
541
542 //
543 // ModifyInstanceResponseHandler
544 //
545
546 ModifyInstanceResponseHandler::ModifyInstanceResponseHandler(
547 CIMModifyInstanceRequestMessage * request,
548 CIMModifyInstanceResponseMessage * response)
549 : OperationResponseHandler(request, response)
550 {
551 chip 1.7 }
552
553 String ModifyInstanceResponseHandler::getClass(void) const
554 {
555 return(String("ModifyInstanceResponseHandler"));
556 }
557
558 //
559 // DeleteInstanceResponseHandler
560 //
561
562 DeleteInstanceResponseHandler::DeleteInstanceResponseHandler(
563 CIMDeleteInstanceRequestMessage * request,
564 CIMDeleteInstanceResponseMessage * response)
565 : OperationResponseHandler(request, response)
566 {
567 }
568
569 String DeleteInstanceResponseHandler::getClass(void) const
570 {
571 return(String("DeleteInstanceResponseHandler"));
572 chip 1.7 }
573
574 //
575 // GetPropertyResponseHandler
576 //
577
578 GetPropertyResponseHandler::GetPropertyResponseHandler(
579 CIMGetPropertyRequestMessage * request,
580 CIMGetPropertyResponseMessage * response)
581 : OperationResponseHandler(request, response)
582 {
583 }
584
585 void GetPropertyResponseHandler::deliver(const CIMValue & cimValue)
586 {
587 if(cimValue.isNull())
588 {
589 MessageLoaderParms message(
590 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
591 "The object is not initialized.");
592
593 chip 1.7 throw CIMException(CIM_ERR_FAILED, message);
594 }
595
596 SimpleValueResponseHandler::deliver(cimValue);
597 }
598
599 String GetPropertyResponseHandler::getClass(void) const
600 {
601 return(String("GetPropertyResponseHandler"));
602 }
603
604 void GetPropertyResponseHandler::transfer(void)
605 {
606 if(size() > 0)
607 {
608 CIMGetPropertyResponseMessage & msg =
609 *static_cast<CIMGetPropertyResponseMessage *>(getResponse());
610
611 msg.value = getObjects()[0];
612 }
613 }
614 chip 1.7
615 void GetPropertyResponseHandler::validate(void)
616 {
617 // error? provider claims success,
618 // but did not deliver an instance.
619 if(getResponseObjectTotal() == 0)
620 {
621 setStatus(CIM_ERR_NOT_FOUND);
622 }
623 }
624
625 //
626 // SetPropertyResponseHandler
627 //
628
629 SetPropertyResponseHandler::SetPropertyResponseHandler(
630 CIMSetPropertyRequestMessage * request,
631 CIMSetPropertyResponseMessage * response)
632 : OperationResponseHandler(request, response)
633 {
634 }
635 chip 1.7
636 String SetPropertyResponseHandler::getClass(void) const
637 {
638 return(String("SetPropertyResponseHandler"));
639 }
640
641 //
642 // ExecQueryResponseHandler
643 //
644
645 ExecQueryResponseHandler::ExecQueryResponseHandler(
646 CIMExecQueryRequestMessage * request,
647 CIMExecQueryResponseMessage * response)
648 : OperationResponseHandler(request, response)
649 {
650 }
651
652 void ExecQueryResponseHandler::deliver(const CIMInstance & cimInstance)
653 {
654 if(cimInstance.isUninitialized())
655 {
656 chip 1.7 MessageLoaderParms message(
657 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
658 "The object is not initialized.");
659
660 throw CIMException(CIM_ERR_FAILED, message);
661 }
662
663 SimpleInstance2ObjectResponseHandler::deliver(cimInstance);
664 }
665
666 String ExecQueryResponseHandler::getClass(void) const
667 {
668 return(String("ExecQueryResponseHandler"));
669 }
670
671 void ExecQueryResponseHandler::transfer(void)
672 {
673 CIMExecQueryResponseMessage & msg =
674 *static_cast<CIMExecQueryResponseMessage *>(getResponse());
675
676 msg.cimObjects = getObjects();
677 chip 1.7 }
678
679 Boolean ExecQueryResponseHandler::isAsync(void) const
680 {
681 return(false);
682 }
683
684 //
685 // AssociatorsResponseHandler
686 //
687
688 AssociatorsResponseHandler::AssociatorsResponseHandler(
689 CIMAssociatorsRequestMessage * request,
690 CIMAssociatorsResponseMessage * response)
691 : OperationResponseHandler(request, response)
692 {
693 }
694
695 void AssociatorsResponseHandler::deliver(const CIMObject & cimObject)
696 {
697 if(cimObject.isUninitialized())
698 chip 1.7 {
699 MessageLoaderParms message(
700 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
701 "The object is not initialized.");
702
703 throw CIMException(CIM_ERR_FAILED, message);
704 }
705
706 SimpleObjectResponseHandler::deliver(cimObject);
707 }
708
709 String AssociatorsResponseHandler::getClass(void) const
710 {
711 return(String("AssociatorsResponseHandler"));
712 }
713
714 void AssociatorsResponseHandler::transfer(void)
715 {
716 CIMAssociatorsResponseMessage & msg =
717 *static_cast<CIMAssociatorsResponseMessage *>(getResponse());
718
719 chip 1.7 msg.cimObjects = getObjects();
720 }
721
722 //
723 // AssociatorNamesResponseHandler
724 //
725
726 AssociatorNamesResponseHandler::AssociatorNamesResponseHandler(
727 CIMAssociatorNamesRequestMessage * request,
728 CIMAssociatorNamesResponseMessage * response)
729 : OperationResponseHandler(request, response)
730 {
731 }
732
733 void AssociatorNamesResponseHandler::deliver(const CIMObjectPath & cimObjectPath)
734 {
735 if(cimObjectPath.getClassName().isNull())
736 {
737 MessageLoaderParms message(
738 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
739 "The object is not initialized.");
740 chip 1.7
741 throw CIMException(CIM_ERR_FAILED, message);
742 }
743
744 SimpleObjectPathResponseHandler::deliver(cimObjectPath);
745 }
746
747 String AssociatorNamesResponseHandler::getClass(void) const
748 {
749 return(String("AssociatorNamesResponseHandler"));
750 }
751
752 void AssociatorNamesResponseHandler::transfer(void)
753 {
754 CIMAssociatorNamesResponseMessage & msg =
755 *static_cast<CIMAssociatorNamesResponseMessage *>(getResponse());
756
757 msg.objectNames = getObjects();
758 }
759
760 //
761 chip 1.7 // ReferencesResponseHandler
762 //
763
764 ReferencesResponseHandler::ReferencesResponseHandler(
765 CIMReferencesRequestMessage * request,
766 CIMReferencesResponseMessage * response)
767 : OperationResponseHandler(request, response)
768 {
769 }
770
771 void ReferencesResponseHandler::deliver(const CIMObject & cimObject)
772 {
773 if(cimObject.isUninitialized())
774 {
775 MessageLoaderParms message(
776 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
777 "The object is not initialized.");
778
779 throw CIMException(CIM_ERR_FAILED, message);
780 }
781
782 chip 1.7 SimpleObjectResponseHandler::deliver(cimObject);
783 }
784
785 String ReferencesResponseHandler::getClass(void) const
786 {
787 return(String("ReferencesResponseHandler"));
788 }
789
790 void ReferencesResponseHandler::transfer(void)
791 {
792 CIMReferencesResponseMessage & msg =
793 *static_cast<CIMReferencesResponseMessage *>(getResponse());
794
795 msg.cimObjects = getObjects();
796 }
797
798 //
799 // ReferenceNamesResponseHandler
800 //
801
802 ReferenceNamesResponseHandler::ReferenceNamesResponseHandler(
803 chip 1.7 CIMReferenceNamesRequestMessage * request,
804 CIMReferenceNamesResponseMessage * response)
805 : OperationResponseHandler(request, response)
806 {
807 }
808
809 void ReferenceNamesResponseHandler::deliver(const CIMObjectPath & cimObjectPath)
810 {
811 if(cimObjectPath.getClassName().isNull())
812 {
813 MessageLoaderParms message(
814 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
815 "The object is not initialized.");
816
817 throw CIMException(CIM_ERR_FAILED, message);
818 }
819
820 SimpleObjectPathResponseHandler::deliver(cimObjectPath);
821 }
822
823 String ReferenceNamesResponseHandler::getClass(void) const
824 chip 1.7 {
825 return(String("ReferenceNamesResponseHandler"));
826 }
827
828 void ReferenceNamesResponseHandler::transfer(void)
829 {
830 CIMReferenceNamesResponseMessage & msg =
831 *static_cast<CIMReferenceNamesResponseMessage *>(getResponse());
832
833 msg.objectNames = getObjects();
834 }
835
836 //
837 // InvokeMethodResponseHandler
838 //
839
840 InvokeMethodResponseHandler::InvokeMethodResponseHandler(
841 CIMInvokeMethodRequestMessage * request,
842 CIMInvokeMethodResponseMessage * response)
843 : OperationResponseHandler(request, response)
844 {
845 chip 1.7 }
846
847 void InvokeMethodResponseHandler::deliverParamValue(const CIMParamValue & cimParamValue)
848 {
849 if(cimParamValue.isUninitialized())
850 {
851 MessageLoaderParms message(
852 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
853 "The object is not initialized.");
854
855 throw CIMException(CIM_ERR_FAILED, message);
856 }
857
858 SimpleMethodResultResponseHandler::deliverParamValue(cimParamValue);
859 }
860
861 void InvokeMethodResponseHandler::deliver(const CIMValue & cimValue)
862 {
863 if(cimValue.isNull())
864 {
865 MessageLoaderParms message(
866 chip 1.7 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
867 "The object is not initialized.");
868
869 throw CIMException(CIM_ERR_FAILED, message);
870 }
871
872 SimpleMethodResultResponseHandler::deliver(cimValue);
873 }
874
875 String InvokeMethodResponseHandler::getClass(void) const
876 {
877 return(String("InvokeMethodResponseHandler"));
878 }
879
880 void InvokeMethodResponseHandler::transfer(void)
881 {
882 CIMInvokeMethodResponseMessage & msg =
883 *static_cast<CIMInvokeMethodResponseMessage *>(getResponse());
884
885 msg.outParameters = getParamValues();
886
887 chip 1.7 // ATTN-RK-20020903: Is it legal for the return value to be null?
888 // if not, then the check must be done here since deliver() works off the
889 // virtual size, which refers to out parameters!
890 msg.retValue = getReturnValue();
891 }
892
893 //
894 // EnableIndicationsResponseHandler
895 //
896
897 typedef void (*PEGASUS_INDICATION_CALLBACK)(CIMProcessIndicationRequestMessage*);
898
899 EnableIndicationsResponseHandler::EnableIndicationsResponseHandler(
900 CIMRequestMessage * request,
901 CIMResponseMessage * response,
902 CIMInstance & provider,
903 PEGASUS_INDICATION_CALLBACK indicationCallback)
904 : OperationResponseHandler(request, response),
905 _indicationCallback(indicationCallback)
906 {
907 _provider = provider;
908 chip 1.7 }
909
910 void EnableIndicationsResponseHandler::deliver(const CIMIndication & cimIndication)
911 {
912 OperationContext context;
913
914 Array<CIMObjectPath> subscriptionInstanceNames;
915
916 context.insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames));
917
918 deliver(context, cimIndication);
919 }
920
921 void EnableIndicationsResponseHandler::deliver(const OperationContext & context, const CIMIndication & cimIndication)
922 {
923 if(cimIndication.isUninitialized())
924 {
925 MessageLoaderParms message(
926 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
927 "The object is not initialized.");
928
929 chip 1.7 throw CIMException(CIM_ERR_FAILED, message);
930 }
931
932 // ATTN: temporarily convert indication to instance
933 CIMInstance cimInstance(cimIndication);
934
935 // Get list of subscription instance names from context
936 Array<CIMObjectPath> subscriptionInstanceNames;
937
938 try
939 {
940 SubscriptionInstanceNamesContainer container =
941 context.get(SubscriptionInstanceNamesContainer::NAME);
942
943 subscriptionInstanceNames = container.getInstanceNames();
944 }
945 catch(Exception &)
946 {
947 subscriptionInstanceNames.clear();
948 }
949
950 chip 1.7 // l10n
951 ContentLanguages contentLangs;
952
953 try
954 {
955 // Get the Content-Language for this indication. The provider
956 // does not have to add specify a language for the indication.
957 ContentLanguageListContainer langContainer =
958 context.get(ContentLanguageListContainer::NAME);
959
960 contentLangs = langContainer.getLanguages();
961 }
962 catch(Exception &)
963 {
964 // The provider did not explicitly set a Content-Language for
965 // the indication. Fall back to the lang set in this object.
966 contentLangs = getLanguages();
967 }
968 // l10n -end
969
970 // create message
971 chip 1.7 // l10n
972 CIMProcessIndicationRequestMessage * request =
973 new CIMProcessIndicationRequestMessage(
974 XmlWriter::getNextMessageId(),
975 cimInstance.getPath().getNameSpace(),
976 cimInstance,
977 subscriptionInstanceNames,
978 _provider,
979 QueueIdStack()); // Must be filled in by the callback function
980
981 request->operationContext = context;
982
983 try
984 {
985 request->operationContext.set(ContentLanguageListContainer(contentLangs));
986 }
987 catch(Exception &)
988 {
989 request->operationContext.insert(ContentLanguageListContainer(contentLangs));
990 }
991
992 chip 1.7 _indicationCallback(request);
993 }
994
995 void EnableIndicationsResponseHandler::deliver(const Array<CIMIndication> & cimIndications)
996 {
997 OperationContext context;
998
999 deliver(context, cimIndications);
1000 }
1001
1002 void EnableIndicationsResponseHandler::deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications)
1003 {
1004 for(Uint32 i = 0, n = cimIndications.size(); i < n; i++)
1005 {
1006 deliver(context, cimIndications[i]);
1007 }
1008 }
1009
1010 String EnableIndicationsResponseHandler::getClass(void) const
1011 {
1012 return(String("EnableIndicationsResponseHandler"));
1013 chip 1.7 }
1014
1015 Boolean EnableIndicationsResponseHandler::isAsync(void) const
1016 {
1017 return(false);
1018 }
1019
|
1020 schuur 1.1 PEGASUS_NAMESPACE_END
|
Return to
OperationResponseHandler.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2