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 a.dunfey 1.11.10.1 const ContentLanguageList & langs,
|
116 chip 1.7 const String & message)
117 {
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 chip 1.9 if(SimpleInstanceResponseHandler::size() != 0)
313 {
314 MessageLoaderParms message(
315 "Server.OperationResponseHandler.TOO_MANY_OBJECTS_DELIVERED",
316 "Too many objects delivered.");
317
318 throw CIMException(CIM_ERR_FAILED, message);
319 }
320
|
321 chip 1.7 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
322 // The normalizer expects an object path embedded in instances even
323 // though it is not required by this operation. Use the requested
324 // object path is missing from the instance.
325 CIMInstance localInstance(cimInstance);
326
327 if(localInstance.getPath().getKeyBindings().size() == 0)
328 {
329 // ATTN: should clone before modification
330 localInstance.setPath(static_cast<CIMGetInstanceRequestMessage *>(getRequest())->instanceName);
331 }
332
333 SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(localInstance));
334 #else
335 SimpleInstanceResponseHandler::deliver(cimInstance);
336 #endif
337 }
338
|
339 chip 1.9 void GetInstanceResponseHandler::complete(void)
340 {
|
341 chip 1.10 if(SimpleInstanceResponseHandler::size() == 0)
|
342 chip 1.9 {
343 MessageLoaderParms message(
344 "Server.OperationResponseHandler.TOO_FEW_OBJECTS_DELIVERED",
345 "Too few objects delivered.");
346
347 throw CIMException(CIM_ERR_FAILED, message);
348 }
349
350 SimpleInstanceResponseHandler::complete();
351 }
352
|
353 chip 1.7 String GetInstanceResponseHandler::getClass(void) const
354 {
355 return(String("GetInstanceResponseHandler"));
356 }
357
358 void GetInstanceResponseHandler::transfer(void)
359 {
360 if(size() > 0)
361 {
362 CIMGetInstanceResponseMessage & msg =
363 *static_cast<CIMGetInstanceResponseMessage *>(getResponse());
364
365 msg.cimInstance = getObjects()[0];
366 }
367 }
368
369 void GetInstanceResponseHandler::validate(void)
370 {
371 if(getResponseObjectTotal() == 0)
372 {
373 // error? provider claims success,
374 chip 1.7 // but did not deliver an instance.
375 setStatus(CIM_ERR_NOT_FOUND);
376 }
377 }
378
379 //
380 // EnumerateInstancesResponseHandler
381 //
382
383 EnumerateInstancesResponseHandler::EnumerateInstancesResponseHandler(
384 CIMEnumerateInstancesRequestMessage * request,
385 CIMEnumerateInstancesResponseMessage * response)
386 : OperationResponseHandler(request, response)
387 {
388 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
389 // Attempt to get the cached class definition used to validate results of this
390 // operation. If it does not exist, then this feature is disabled for this
391 // operation.
392 CIMClass cimClass;
393
394 try
395 chip 1.7 {
396 CachedClassDefinitionContainer container =
397 request->operationContext.get(CachedClassDefinitionContainer::NAME);
398
399 cimClass = container.getClass();
400 }
401 catch(Exception &)
402 {
403 // Do nothing. Container is missing, which implies normalization is disabled
404 // for this operation.
405 }
406
407 _normalizer =
408 ObjectNormalizer(
409 cimClass,
410 request->includeQualifiers,
411 request->includeClassOrigin);
412 #endif
413 }
414
415 void EnumerateInstancesResponseHandler::deliver(const CIMInstance & cimInstance)
416 chip 1.7 {
417 if(cimInstance.isUninitialized())
418 {
419 MessageLoaderParms message(
420 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
421 "The object is not initialized.");
422
423 throw CIMException(CIM_ERR_FAILED, message);
424 }
425
426 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
427 SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance));
428 #else
429 SimpleInstanceResponseHandler::deliver(cimInstance);
430 #endif
431 }
432
433 String EnumerateInstancesResponseHandler::getClass(void) const
434 {
435 return(String("EnumerateInstancesResponseHandler"));
436 }
437 chip 1.7
438 void EnumerateInstancesResponseHandler::transfer(void)
439 {
440 CIMEnumerateInstancesResponseMessage & msg =
441 *static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse());
442
443 msg.cimNamedInstances = getObjects();
444 }
445
446 //
447 // EnumerateInstanceNamesResponseHandler
448 //
449
450 EnumerateInstanceNamesResponseHandler::EnumerateInstanceNamesResponseHandler(
451 CIMEnumerateInstanceNamesRequestMessage * request,
452 CIMEnumerateInstanceNamesResponseMessage * response)
453 : OperationResponseHandler(request, response)
454 {
455 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
456 // Attempt to get the cached class definition used to validate results of this
457 // operation. If it does not exist, then this feature is disabled for this
458 chip 1.7 // operation.
459 CIMClass cimClass;
460
461 try
462 {
463 CachedClassDefinitionContainer container =
464 request->operationContext.get(CachedClassDefinitionContainer::NAME);
465
466 cimClass = container.getClass();
467 }
468 catch(Exception &)
469 {
470 // Do nothing. Container is missing, which implies normalization is disabled
471 // for this operation.
472 }
473
474 _normalizer =
475 ObjectNormalizer(
476 cimClass,
477 false,
478 false);
479 chip 1.7 #endif
480 }
481
482 void EnumerateInstanceNamesResponseHandler::deliver(const CIMObjectPath & cimObjectPath)
483 {
484 if(cimObjectPath.getClassName().isNull())
485 {
486 MessageLoaderParms message(
487 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
488 "The object is not initialized.");
489
490 throw CIMException(CIM_ERR_FAILED, message);
491 }
492
493 #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
494 SimpleObjectPathResponseHandler::deliver(_normalizer.processInstanceObjectPath(cimObjectPath));
495 #else
496 SimpleObjectPathResponseHandler::deliver(cimObjectPath);
497 #endif
498 }
499
500 chip 1.7 String EnumerateInstanceNamesResponseHandler::getClass(void) const
501 {
502 return(String("EnumerateInstanceNamesResponseHandler"));
503 }
504
505 void EnumerateInstanceNamesResponseHandler::transfer(void)
506 {
507 CIMEnumerateInstanceNamesResponseMessage & msg =
508 *static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse());
509
510 msg.instanceNames = getObjects();
511 }
512
513 //
514 // CreateInstanceResponseHandler
515 //
516
517 CreateInstanceResponseHandler::CreateInstanceResponseHandler(
518 CIMCreateInstanceRequestMessage * request,
519 CIMCreateInstanceResponseMessage * response)
520 : OperationResponseHandler(request, response)
521 chip 1.7 {
522 }
523
524 void CreateInstanceResponseHandler::deliver(const CIMObjectPath & cimObjectPath)
525 {
526 if(cimObjectPath.getClassName().isNull())
527 {
528 MessageLoaderParms message(
529 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
530 "The object is not initialized.");
531
532 throw CIMException(CIM_ERR_FAILED, message);
533 }
534
|
535 chip 1.11 if(SimpleObjectPathResponseHandler::size() != 0)
536 {
537 MessageLoaderParms message(
538 "Server.OperationResponseHandler.TOO_MANY_OBJECTS_DELIVERED",
539 "Too many objects delivered.");
540
541 throw CIMException(CIM_ERR_FAILED, message);
542 }
543
|
544 chip 1.7 SimpleObjectPathResponseHandler::deliver(cimObjectPath);
545 }
546
|
547 chip 1.9 void CreateInstanceResponseHandler::complete(void)
548 {
|
549 chip 1.10 if(SimpleObjectPathResponseHandler::size() == 0)
|
550 chip 1.9 {
551 MessageLoaderParms message(
552 "Server.OperationResponseHandler.TOO_FEW_OBJECTS_DELIVERED",
553 "Too few objects delivered.");
554
555 throw CIMException(CIM_ERR_FAILED, message);
556 }
557
558 SimpleObjectPathResponseHandler::complete();
559 }
560
|
561 chip 1.7 String CreateInstanceResponseHandler::getClass(void) const
562 {
563 return(String("CreateInstanceResponseHandler"));
564 }
565
566 #if 0
567 // ATTN: is it an error to not return instance name?
568 void CreateInstanceResponseHandler::validate(void)
569 {
570 if(getResponseObjectTotal() == 0)
571 {
572 setStatus(CIM_ERR_NOT_FOUND);
573 }
574 }
575 #endif
576
577 void CreateInstanceResponseHandler::transfer(void)
578 {
579 if(size() > 0)
580 {
581 CIMCreateInstanceResponseMessage & msg =
582 chip 1.7 *static_cast<CIMCreateInstanceResponseMessage *>(getResponse());
583
584 msg.instanceName = getObjects()[0];
585 }
586 }
587
588 //
589 // ModifyInstanceResponseHandler
590 //
591
592 ModifyInstanceResponseHandler::ModifyInstanceResponseHandler(
593 CIMModifyInstanceRequestMessage * request,
594 CIMModifyInstanceResponseMessage * response)
595 : OperationResponseHandler(request, response)
596 {
597 }
598
599 String ModifyInstanceResponseHandler::getClass(void) const
600 {
601 return(String("ModifyInstanceResponseHandler"));
602 }
603 chip 1.7
604 //
605 // DeleteInstanceResponseHandler
606 //
607
608 DeleteInstanceResponseHandler::DeleteInstanceResponseHandler(
609 CIMDeleteInstanceRequestMessage * request,
610 CIMDeleteInstanceResponseMessage * response)
611 : OperationResponseHandler(request, response)
612 {
613 }
614
615 String DeleteInstanceResponseHandler::getClass(void) const
616 {
617 return(String("DeleteInstanceResponseHandler"));
618 }
619
620 //
621 // GetPropertyResponseHandler
622 //
623
624 chip 1.7 GetPropertyResponseHandler::GetPropertyResponseHandler(
625 CIMGetPropertyRequestMessage * request,
626 CIMGetPropertyResponseMessage * response)
627 : OperationResponseHandler(request, response)
628 {
629 }
630
631 void GetPropertyResponseHandler::deliver(const CIMValue & cimValue)
632 {
633 if(cimValue.isNull())
634 {
635 MessageLoaderParms message(
636 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
637 "The object is not initialized.");
638
639 throw CIMException(CIM_ERR_FAILED, message);
640 }
641
642 SimpleValueResponseHandler::deliver(cimValue);
643 }
644
645 chip 1.7 String GetPropertyResponseHandler::getClass(void) const
646 {
647 return(String("GetPropertyResponseHandler"));
648 }
649
650 void GetPropertyResponseHandler::transfer(void)
651 {
652 if(size() > 0)
653 {
654 CIMGetPropertyResponseMessage & msg =
655 *static_cast<CIMGetPropertyResponseMessage *>(getResponse());
656
657 msg.value = getObjects()[0];
658 }
659 }
660
661 void GetPropertyResponseHandler::validate(void)
662 {
663 // error? provider claims success,
664 // but did not deliver an instance.
665 if(getResponseObjectTotal() == 0)
666 chip 1.7 {
667 setStatus(CIM_ERR_NOT_FOUND);
668 }
669 }
670
671 //
672 // SetPropertyResponseHandler
673 //
674
675 SetPropertyResponseHandler::SetPropertyResponseHandler(
676 CIMSetPropertyRequestMessage * request,
677 CIMSetPropertyResponseMessage * response)
678 : OperationResponseHandler(request, response)
679 {
680 }
681
682 String SetPropertyResponseHandler::getClass(void) const
683 {
684 return(String("SetPropertyResponseHandler"));
685 }
686
687 chip 1.7 //
688 // ExecQueryResponseHandler
689 //
690
691 ExecQueryResponseHandler::ExecQueryResponseHandler(
692 CIMExecQueryRequestMessage * request,
693 CIMExecQueryResponseMessage * response)
694 : OperationResponseHandler(request, response)
695 {
696 }
697
698 void ExecQueryResponseHandler::deliver(const CIMInstance & cimInstance)
699 {
700 if(cimInstance.isUninitialized())
701 {
702 MessageLoaderParms message(
703 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
704 "The object is not initialized.");
705
706 throw CIMException(CIM_ERR_FAILED, message);
707 }
708 chip 1.7
709 SimpleInstance2ObjectResponseHandler::deliver(cimInstance);
710 }
711
712 String ExecQueryResponseHandler::getClass(void) const
713 {
714 return(String("ExecQueryResponseHandler"));
715 }
716
717 void ExecQueryResponseHandler::transfer(void)
718 {
719 CIMExecQueryResponseMessage & msg =
720 *static_cast<CIMExecQueryResponseMessage *>(getResponse());
721
722 msg.cimObjects = getObjects();
723 }
724
725 Boolean ExecQueryResponseHandler::isAsync(void) const
726 {
727 return(false);
728 }
729 chip 1.7
730 //
731 // AssociatorsResponseHandler
732 //
733
734 AssociatorsResponseHandler::AssociatorsResponseHandler(
735 CIMAssociatorsRequestMessage * request,
736 CIMAssociatorsResponseMessage * response)
737 : OperationResponseHandler(request, response)
738 {
739 }
740
741 void AssociatorsResponseHandler::deliver(const CIMObject & cimObject)
742 {
743 if(cimObject.isUninitialized())
744 {
745 MessageLoaderParms message(
746 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
747 "The object is not initialized.");
748
749 throw CIMException(CIM_ERR_FAILED, message);
750 chip 1.7 }
751
752 SimpleObjectResponseHandler::deliver(cimObject);
753 }
754
755 String AssociatorsResponseHandler::getClass(void) const
756 {
757 return(String("AssociatorsResponseHandler"));
758 }
759
760 void AssociatorsResponseHandler::transfer(void)
761 {
762 CIMAssociatorsResponseMessage & msg =
763 *static_cast<CIMAssociatorsResponseMessage *>(getResponse());
764
765 msg.cimObjects = getObjects();
766 }
767
768 //
769 // AssociatorNamesResponseHandler
770 //
771 chip 1.7
772 AssociatorNamesResponseHandler::AssociatorNamesResponseHandler(
773 CIMAssociatorNamesRequestMessage * request,
774 CIMAssociatorNamesResponseMessage * response)
775 : OperationResponseHandler(request, response)
776 {
777 }
778
779 void AssociatorNamesResponseHandler::deliver(const CIMObjectPath & cimObjectPath)
780 {
781 if(cimObjectPath.getClassName().isNull())
782 {
783 MessageLoaderParms message(
784 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
785 "The object is not initialized.");
786
787 throw CIMException(CIM_ERR_FAILED, message);
788 }
789
790 SimpleObjectPathResponseHandler::deliver(cimObjectPath);
791 }
792 chip 1.7
793 String AssociatorNamesResponseHandler::getClass(void) const
794 {
795 return(String("AssociatorNamesResponseHandler"));
796 }
797
798 void AssociatorNamesResponseHandler::transfer(void)
799 {
800 CIMAssociatorNamesResponseMessage & msg =
801 *static_cast<CIMAssociatorNamesResponseMessage *>(getResponse());
802
803 msg.objectNames = getObjects();
804 }
805
806 //
807 // ReferencesResponseHandler
808 //
809
810 ReferencesResponseHandler::ReferencesResponseHandler(
811 CIMReferencesRequestMessage * request,
812 CIMReferencesResponseMessage * response)
813 chip 1.7 : OperationResponseHandler(request, response)
814 {
815 }
816
817 void ReferencesResponseHandler::deliver(const CIMObject & cimObject)
818 {
819 if(cimObject.isUninitialized())
820 {
821 MessageLoaderParms message(
822 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
823 "The object is not initialized.");
824
825 throw CIMException(CIM_ERR_FAILED, message);
826 }
827
828 SimpleObjectResponseHandler::deliver(cimObject);
829 }
830
831 String ReferencesResponseHandler::getClass(void) const
832 {
833 return(String("ReferencesResponseHandler"));
834 chip 1.7 }
835
836 void ReferencesResponseHandler::transfer(void)
837 {
838 CIMReferencesResponseMessage & msg =
839 *static_cast<CIMReferencesResponseMessage *>(getResponse());
840
841 msg.cimObjects = getObjects();
842 }
843
844 //
845 // ReferenceNamesResponseHandler
846 //
847
848 ReferenceNamesResponseHandler::ReferenceNamesResponseHandler(
849 CIMReferenceNamesRequestMessage * request,
850 CIMReferenceNamesResponseMessage * response)
851 : OperationResponseHandler(request, response)
852 {
853 }
854
855 chip 1.7 void ReferenceNamesResponseHandler::deliver(const CIMObjectPath & cimObjectPath)
856 {
857 if(cimObjectPath.getClassName().isNull())
858 {
859 MessageLoaderParms message(
860 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
861 "The object is not initialized.");
862
863 throw CIMException(CIM_ERR_FAILED, message);
864 }
865
866 SimpleObjectPathResponseHandler::deliver(cimObjectPath);
867 }
868
869 String ReferenceNamesResponseHandler::getClass(void) const
870 {
871 return(String("ReferenceNamesResponseHandler"));
872 }
873
874 void ReferenceNamesResponseHandler::transfer(void)
875 {
876 chip 1.7 CIMReferenceNamesResponseMessage & msg =
877 *static_cast<CIMReferenceNamesResponseMessage *>(getResponse());
878
879 msg.objectNames = getObjects();
880 }
881
882 //
883 // InvokeMethodResponseHandler
884 //
885
886 InvokeMethodResponseHandler::InvokeMethodResponseHandler(
887 CIMInvokeMethodRequestMessage * request,
888 CIMInvokeMethodResponseMessage * response)
889 : OperationResponseHandler(request, response)
890 {
891 }
892
893 void InvokeMethodResponseHandler::deliverParamValue(const CIMParamValue & cimParamValue)
894 {
895 if(cimParamValue.isUninitialized())
896 {
897 chip 1.7 MessageLoaderParms message(
898 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
899 "The object is not initialized.");
900
901 throw CIMException(CIM_ERR_FAILED, message);
902 }
903
904 SimpleMethodResultResponseHandler::deliverParamValue(cimParamValue);
905 }
906
907 void InvokeMethodResponseHandler::deliver(const CIMValue & cimValue)
908 {
909 if(cimValue.isNull())
910 {
911 MessageLoaderParms message(
912 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
913 "The object is not initialized.");
914
915 throw CIMException(CIM_ERR_FAILED, message);
916 }
917
918 chip 1.7 SimpleMethodResultResponseHandler::deliver(cimValue);
919 }
920
921 String InvokeMethodResponseHandler::getClass(void) const
922 {
923 return(String("InvokeMethodResponseHandler"));
924 }
925
926 void InvokeMethodResponseHandler::transfer(void)
927 {
928 CIMInvokeMethodResponseMessage & msg =
929 *static_cast<CIMInvokeMethodResponseMessage *>(getResponse());
930
931 msg.outParameters = getParamValues();
932
933 // ATTN-RK-20020903: Is it legal for the return value to be null?
934 // if not, then the check must be done here since deliver() works off the
935 // virtual size, which refers to out parameters!
936 msg.retValue = getReturnValue();
937 }
938
939 chip 1.7 //
940 // EnableIndicationsResponseHandler
941 //
942
943 typedef void (*PEGASUS_INDICATION_CALLBACK)(CIMProcessIndicationRequestMessage*);
944
945 EnableIndicationsResponseHandler::EnableIndicationsResponseHandler(
946 CIMRequestMessage * request,
947 CIMResponseMessage * response,
948 CIMInstance & provider,
949 PEGASUS_INDICATION_CALLBACK indicationCallback)
950 : OperationResponseHandler(request, response),
951 _indicationCallback(indicationCallback)
952 {
953 _provider = provider;
954 }
955
956 void EnableIndicationsResponseHandler::deliver(const CIMIndication & cimIndication)
957 {
958 OperationContext context;
959
960 chip 1.7 Array<CIMObjectPath> subscriptionInstanceNames;
961
962 context.insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames));
963
964 deliver(context, cimIndication);
965 }
966
967 void EnableIndicationsResponseHandler::deliver(const OperationContext & context, const CIMIndication & cimIndication)
968 {
969 if(cimIndication.isUninitialized())
970 {
971 MessageLoaderParms message(
972 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
973 "The object is not initialized.");
974
975 throw CIMException(CIM_ERR_FAILED, message);
976 }
977
978 // ATTN: temporarily convert indication to instance
979 CIMInstance cimInstance(cimIndication);
980
981 chip 1.7 // Get list of subscription instance names from context
982 Array<CIMObjectPath> subscriptionInstanceNames;
983
984 try
985 {
986 SubscriptionInstanceNamesContainer container =
987 context.get(SubscriptionInstanceNamesContainer::NAME);
988
989 subscriptionInstanceNames = container.getInstanceNames();
990 }
991 catch(Exception &)
992 {
993 subscriptionInstanceNames.clear();
994 }
995
996 // l10n
|
997 a.dunfey 1.11.10.1 ContentLanguageList contentLangs;
|
998 chip 1.7
999 try
1000 {
1001 // Get the Content-Language for this indication. The provider
1002 // does not have to add specify a language for the indication.
1003 ContentLanguageListContainer langContainer =
1004 context.get(ContentLanguageListContainer::NAME);
1005
1006 contentLangs = langContainer.getLanguages();
1007 }
1008 catch(Exception &)
1009 {
1010 // The provider did not explicitly set a Content-Language for
1011 // the indication. Fall back to the lang set in this object.
1012 contentLangs = getLanguages();
1013 }
1014 // l10n -end
1015
1016 // create message
1017 // l10n
1018 CIMProcessIndicationRequestMessage * request =
1019 chip 1.7 new CIMProcessIndicationRequestMessage(
1020 XmlWriter::getNextMessageId(),
1021 cimInstance.getPath().getNameSpace(),
1022 cimInstance,
1023 subscriptionInstanceNames,
1024 _provider,
1025 QueueIdStack()); // Must be filled in by the callback function
1026
1027 request->operationContext = context;
1028
1029 try
1030 {
1031 request->operationContext.set(ContentLanguageListContainer(contentLangs));
1032 }
1033 catch(Exception &)
1034 {
1035 request->operationContext.insert(ContentLanguageListContainer(contentLangs));
1036 }
1037
1038 _indicationCallback(request);
1039 }
1040 chip 1.7
1041 void EnableIndicationsResponseHandler::deliver(const Array<CIMIndication> & cimIndications)
1042 {
1043 OperationContext context;
1044
1045 deliver(context, cimIndications);
1046 }
1047
1048 void EnableIndicationsResponseHandler::deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications)
1049 {
1050 for(Uint32 i = 0, n = cimIndications.size(); i < n; i++)
1051 {
1052 deliver(context, cimIndications[i]);
1053 }
1054 }
1055
1056 String EnableIndicationsResponseHandler::getClass(void) const
1057 {
1058 return(String("EnableIndicationsResponseHandler"));
1059 }
1060
1061 chip 1.7 Boolean EnableIndicationsResponseHandler::isAsync(void) const
1062 {
1063 return(false);
1064 }
1065
|
1066 schuur 1.1 PEGASUS_NAMESPACE_END
|
Return to
OperationResponseHandler.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2