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