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