1 schuur 1.1 //%2003////////////////////////////////////////////////////////////////////////
2 //
3 // 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 // IBM Corp.; EMC Corporation, The Open Group.
7 //
8 // Permission is hereby granted, free of charge, to any person obtaining a copy
9 // of this software and associated documentation files (the "Software"), to
10 // deal in the Software without restriction, including without limitation the
11 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
12 // sell copies of the Software, and to permit persons to whom the Software is
13 // furnished to do so, subject to the following conditions:
14 //
15 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
16 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
17 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
18 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
19 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
21 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 schuur 1.1 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 //
24 //==============================================================================
25 //
26 // Author: Chip Vincent (cvincent@us.ibm.com)
27 //
28 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
29 // (carolann_graves@hp.com)
30 // Dave Rosckes (rosckes@us.ibm.com)
31 // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
32 // Adrian Schuur (schuur@de.ibm.com)
33 //
34 //%/////////////////////////////////////////////////////////////////////////////
35
36 #ifndef Pegasus_OperationResponseHandler_h
37 #define Pegasus_OperationResponseHandler_h
38
39 #include <Pegasus/Common/Config.h>
40 #include <Pegasus/Server/Linkage.h>
41 #include <Pegasus/Common/CIMMessage.h>
42 #include <Pegasus/Common/MessageQueueService.h>
43 schuur 1.1 #include <Pegasus/Common/Constants.h>
44 #include <Pegasus/Common/ContentLanguages.h> // l10n
45
46 #include <Pegasus/Common/CIMClass.h>
47 #include <Pegasus/Common/CIMInstance.h>
48 #include <Pegasus/Common/CIMIndication.h>
49 #include <Pegasus/Common/CIMValue.h>
50
51 #include <Pegasus/Common/ResponseHandler.h>
52 #include <Pegasus/Common/Logger.h>
53
54 #include <Pegasus/ProviderManager2/SimpleResponseHandler.h>
55
56 #include <Pegasus/ProviderManager2/Linkage.h>
57
58 PEGASUS_NAMESPACE_BEGIN
59
60 class PEGASUS_PPM_LINKAGE OperationResponseHandler
61 {
62 public:
63 OperationResponseHandler(CIMRequestMessage * request, CIMResponseMessage * response)
64 schuur 1.1 : _request(request), _response(response)
65 {
66 }
67
68 virtual ~OperationResponseHandler(void)
69 {
70 }
71
72 CIMRequestMessage * getRequest(void) const
73 {
74 return(_request);
75 }
76
77 CIMResponseMessage * getResponse(void) const
78 {
79 return(_response);
80 }
81
82 virtual void setStatus(const Uint32 code, const String & message = String::EMPTY)
83 {
84 _response->cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message);
85 schuur 1.1 }
86
87 virtual void setStatus(const Uint32 code,
88 const ContentLanguages & langs,
89 const String & message = String::EMPTY)
90 {
91 _response->cimException = PEGASUS_CIM_EXCEPTION_LANG(
92 langs,
93 CIMStatusCode(code),
94 message);
95 }
96
97 protected:
98 CIMRequestMessage * _request;
99 CIMResponseMessage * _response;
100
101 };
102
103
104 /* ------------------------------------------------------------------------- */
105 /* operation specific response handlers */
106 schuur 1.1 /* ------------------------------------------------------------------------- */
107
108 class GetInstanceResponseHandler: public OperationResponseHandler, public SimpleInstanceResponseHandler
109 {
110 public:
111 GetInstanceResponseHandler(
112 CIMGetInstanceRequestMessage * request,
113 CIMGetInstanceResponseMessage * response)
114 : OperationResponseHandler(request, response)
115 {
116 }
117
118 virtual void complete()
119 {
120 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
121 "OperationResponseHandler: complete()");
122
123 if(getObjects().size() == 0)
124 {
125 // error? provider claims success,
126 // but did not deliver an instance.
127 schuur 1.1 setStatus(CIM_ERR_NOT_FOUND);
128
129 return;
130 }
131
132 static_cast<CIMGetInstanceResponseMessage *>(
133 getResponse())->cimInstance = getObjects()[0];
134
135 // l10n
136 getResponse()->contentLanguages = getLanguages();
137 }
138 };
139
140 class EnumerateInstancesResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler
141 {
142 public:
143 EnumerateInstancesResponseHandler(
144 CIMEnumerateInstancesRequestMessage * request,
145 CIMEnumerateInstancesResponseMessage * response)
146 : OperationResponseHandler(request, response)
147 {
148 schuur 1.1 }
149
150 virtual void complete()
151 {
152 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
153 "OperationResponseHandler: complete()");
154
155 static_cast<CIMEnumerateInstancesResponseMessage *>(
156 getResponse())->cimNamedInstances = getObjects();
157
158 // l10n
159 getResponse()->contentLanguages = getLanguages();
160 }
161
162 };
163
164 class EnumerateInstanceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
165 {
166 public:
167 EnumerateInstanceNamesResponseHandler(
168 CIMEnumerateInstanceNamesRequestMessage * request,
169 schuur 1.1 CIMEnumerateInstanceNamesResponseMessage * response)
170 : OperationResponseHandler(request, response)
171 {
172 }
173
174 virtual void complete()
175 {
176 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
177 "OperationResponseHandler: complete()");
178
179 static_cast<CIMEnumerateInstanceNamesResponseMessage *>(
180 getResponse())->instanceNames = getObjects();
181
182 // l10n
183 getResponse()->contentLanguages = getLanguages();
184 }
185
186 };
187
188 class CreateInstanceResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
189 {
190 schuur 1.1 public:
191 CreateInstanceResponseHandler(
192 CIMCreateInstanceRequestMessage * request,
193 CIMCreateInstanceResponseMessage * response)
194 : OperationResponseHandler(request, response)
195 {
196 }
197
198 virtual void complete()
199 {
200 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
201 "OperationResponseHandler: complete()");
202
203 if(getObjects().size() == 0)
204 {
205 // ATTN: is it an error to not return instance name?
206 return;
207 }
208
209 static_cast<CIMCreateInstanceResponseMessage *>(
210 getResponse())->instanceName = getObjects()[0];
211 schuur 1.1
212 // l10n
213 getResponse()->contentLanguages = getLanguages();
214 }
215
216 };
217
218 class ModifyInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler
219 {
220 public:
221 ModifyInstanceResponseHandler(
222 CIMModifyInstanceRequestMessage * request,
223 CIMModifyInstanceResponseMessage * response)
224 : OperationResponseHandler(request, response)
225 {
226 }
227
228 };
229
230 class DeleteInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler
231 {
232 schuur 1.1 public:
233 DeleteInstanceResponseHandler(
234 CIMDeleteInstanceRequestMessage * request,
235 CIMDeleteInstanceResponseMessage * response)
236 : OperationResponseHandler(request, response)
237 {
238 }
239
240 };
241
242 class GetPropertyResponseHandler : public OperationResponseHandler, public SimpleValueResponseHandler
243 {
244 public:
245 GetPropertyResponseHandler(
246 CIMGetPropertyRequestMessage * request,
247 CIMGetPropertyResponseMessage * response)
248 : OperationResponseHandler(request, response)
249 {
250 }
251
252 virtual void complete()
253 schuur 1.1 {
254 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
255 "OperationResponseHandler: complete()");
256
257 if(getObjects().size() == 0)
258 {
259 // error? provider claims success,
260 // but did not deliver an instance.
261 setStatus(CIM_ERR_NOT_FOUND);
262
263 return;
264 }
265
266 static_cast<CIMGetPropertyResponseMessage *>(
267 getResponse())->value = getObjects()[0];
268
269 // l10n
270 getResponse()->contentLanguages = getLanguages();
271 }
272 };
273
274 schuur 1.1 class SetPropertyResponseHandler : public OperationResponseHandler, public SimpleResponseHandler
275 {
276 public:
277 SetPropertyResponseHandler(
278 CIMSetPropertyRequestMessage * request,
279 CIMSetPropertyResponseMessage * response)
280 : OperationResponseHandler(request, response)
281 {
282 }
283
284 };
285
286 class ExecQueryResponseHandler : public OperationResponseHandler, public SimpleInstance2ObjectResponseHandler
287 {
288 public:
289 ExecQueryResponseHandler(
290 CIMExecQueryRequestMessage * request,
291 CIMExecQueryResponseMessage * response)
292 : OperationResponseHandler(request, response)
293 {
294 }
295 schuur 1.1
296 virtual void complete()
297 {
298 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
299 "OperationResponseHandler: complete()");
300
301 static_cast<CIMExecQueryResponseMessage *>(
302 getResponse())->cimObjects = getObjects();
303
304 // l10n
305 getResponse()->contentLanguages = getLanguages();
306 }
307
308 };
309
310
311 class AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler
312 {
313 public:
314 AssociatorsResponseHandler(
315 CIMAssociatorsRequestMessage * request,
316 schuur 1.1 CIMAssociatorsResponseMessage * response)
317 : OperationResponseHandler(request, response)
318 {
319 }
320
321 virtual void complete()
322 {
323 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
324 "OperationResponseHandler: complete()");
325
326 static_cast<CIMAssociatorsResponseMessage *>(
327 getResponse())->cimObjects = getObjects();
328
329 // l10n
330 getResponse()->contentLanguages = getLanguages();
331 }
332
333 };
334
335 class AssociatorNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
336 {
337 schuur 1.1 public:
338 AssociatorNamesResponseHandler(
339 CIMAssociatorNamesRequestMessage * request,
340 CIMAssociatorNamesResponseMessage * response)
341 : OperationResponseHandler(request, response)
342 {
343 }
344
345 virtual void complete()
346 {
347 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
348 "OperationResponseHandler: complete()");
349
350 static_cast<CIMAssociatorNamesResponseMessage *>(
351 getResponse())->objectNames.appendArray(getObjects());
352
353 // l10n
354 getResponse()->contentLanguages = getLanguages();
355 }
356
357 };
358 schuur 1.1
359 class ReferencesResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler
360 {
361 public:
362 ReferencesResponseHandler(
363 CIMReferencesRequestMessage * request,
364 CIMReferencesResponseMessage * response)
365 : OperationResponseHandler(request, response)
366 {
367 }
368
369 virtual void complete()
370 {
371 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
372 "OperationResponseHandler: complete()");
373
374 static_cast<CIMReferencesResponseMessage *>(
375 getResponse())->cimObjects = getObjects();
376
377 // l10n
378 getResponse()->contentLanguages = getLanguages();
379 schuur 1.1 }
380
381 };
382
383 class ReferenceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
384 {
385 public:
386 ReferenceNamesResponseHandler(
387 CIMReferenceNamesRequestMessage * request,
388 CIMReferenceNamesResponseMessage * response)
389 : OperationResponseHandler(request, response)
390 {
391 }
392
393 virtual void complete()
394 {
395 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
396 "OperationResponseHandler: complete()");
397
398 static_cast<CIMReferenceNamesResponseMessage *>(
399 getResponse())->objectNames.appendArray(getObjects());
400 schuur 1.1
401 // l10n
402 getResponse()->contentLanguages = getLanguages();
403 }
404
405 };
406
407 class InvokeMethodResponseHandler : public OperationResponseHandler, public SimpleMethodResultResponseHandler
408 {
409 public:
410 InvokeMethodResponseHandler(
411 CIMInvokeMethodRequestMessage * request,
412 CIMInvokeMethodResponseMessage * response)
413 : OperationResponseHandler(request, response)
414 {
415 }
416
417 virtual void complete()
418 {
419 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
420 "OperationResponseHandler: complete()");
421 schuur 1.1
422 // ATTN-RK-20020903: Is it legal for the return value to be null?
423 //if(getReturnValue().isNull())
424 //{
425 // ATTN: error? provider claims success, but did not deliver a CIMValue.
426 // return;
427 //}
428
429 static_cast<CIMInvokeMethodResponseMessage *>(
430 getResponse())->outParameters = getParamValues();
431
432 static_cast<CIMInvokeMethodResponseMessage *>(
433 getResponse())->retValue = getReturnValue();
434
435 // l10n
436 getResponse()->contentLanguages = getLanguages();
437 }
438
439 };
440
441
442 schuur 1.1 class EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler
443 {
444 public:
445 EnableIndicationsResponseHandler(
446 CIMEnableIndicationsRequestMessage * request,
447 CIMEnableIndicationsResponseMessage * response,
448 CIMInstance & provider,
449 MessageQueueService * source,
450 MessageQueueService * target = 0)
451 : OperationResponseHandler(request, response),
452 _source(source),
453 _target(target),
454 _request_copy(*request),
455 _response_copy(*response)
456 {
457 PEGASUS_ASSERT(_source != 0);
458
459 _provider = provider;
460
461 // get indication service
462 if(_target == 0)
463 schuur 1.1 {
464 Array<Uint32> serviceIds;
465
466 _source->find_services(PEGASUS_QUEUENAME_INDICATIONSERVICE, 0, 0, &serviceIds);
467
468 PEGASUS_ASSERT(serviceIds.size() != 0);
469
470 _target = dynamic_cast<MessageQueueService *>(MessageQueue::lookup(serviceIds[0]));
471
472 PEGASUS_ASSERT(_target != 0);
473 }
474 }
475
476 virtual void deliver(const CIMIndication & cimIndication)
477 {
478 OperationContext context;
479
480 Array<CIMObjectPath> subscriptionInstanceNames;
481
482 context.insert(SubscriptionInstanceNamesContainer
483 (subscriptionInstanceNames));
484 schuur 1.1
485 deliver(context, cimIndication);
486 }
487
488 virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication)
489 {
490 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
491 "OperationResponseHandler: deliver()");
492 // ATTN: temporarily convert indication to instance
493 CIMInstance cimInstance(cimIndication);
494
495 //
496 // Get list of subscription instance names from context
497 //
498 Array<CIMObjectPath> subscriptionInstanceNames;
499 try
500 {
501 SubscriptionInstanceNamesContainer container = context.get
502 (SubscriptionInstanceNamesContainer::NAME);
503
504 subscriptionInstanceNames =
505 schuur 1.1 container.getInstanceNames();
506 }
507 catch (Exception& e)
508 {
509 subscriptionInstanceNames.clear();
510 }
511
512 // l10n
513 ContentLanguages contentLangs;
514 try
515 {
516 // Get the Content-Language for this indication. The provider
517 // does not have to add specify a language for the indication.
518 ContentLanguageListContainer langContainer = context.get
519 (ContentLanguageListContainer::NAME);
520
521 contentLangs = langContainer.getLanguages();
522 } catch (Exception & e)
523 {
524 // The provider did not explicitly set a Content-Language for
525 // the indication. Fall back to the lang set in this object.
526 schuur 1.1 contentLangs = getLanguages();
527 }
528 // l10n -end
529
530 // create message
531 // l10n
532 CIMProcessIndicationRequestMessage * request =
533 new CIMProcessIndicationRequestMessage(
534 _request_copy.messageId,
535 cimInstance.getPath().getNameSpace(),
536 cimInstance,
537 subscriptionInstanceNames,
538 _provider,
539 QueueIdStack(_target->getQueueId(), _source->getQueueId()),
540 contentLangs);
541 request->operationContext = context;
542
543 // send message
544 // <<< Wed Apr 10 21:04:00 2002 mdd >>>
545 // AsyncOpNode * op = _source->get_op();
546
547 schuur 1.1 AsyncLegacyOperationStart * asyncRequest =
548 new AsyncLegacyOperationStart(
549 _source->get_next_xid(),
550 0,
551 _target->getQueueId(),
552 request,
553 _target->getQueueId());
554
555 PEGASUS_ASSERT(asyncRequest != 0);
556
557 //AsyncReply * asyncReply = _source->SendWait(asyncRequest);
558 // <<< Wed Apr 10 21:04:50 2002 mdd >>>
559 _source->SendForget(asyncRequest);
560 //PEGASUS_ASSERT(asyncReply != 0);
561
562 // Chip - receiver of the request should delete it
563 //delete asyncRequest;
564 // <<< Wed Apr 10 21:05:10 2002 mdd >>>
565 }
566
567 virtual void deliver(const Array<CIMIndication> & cimIndications)
568 schuur 1.1 {
569 OperationContext context;
570
571 deliver(context, cimIndications);
572 }
573
574 virtual void deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications)
575 {
576 for(Uint32 i = 0, n = cimIndications.size(); i < n; i++)
577 {
578 deliver(context, cimIndications[i]);
579 }
580 }
581
582 protected:
583 MessageQueueService * _source;
584 MessageQueueService * _target;
585
586 private:
587 CIMEnableIndicationsRequestMessage _request_copy;
588 CIMEnableIndicationsResponseMessage _response_copy;
589 schuur 1.1 };
590
591 PEGASUS_NAMESPACE_END
592
593 #endif
|
Return to
OperationResponseHandler.h
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2