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