1 karl 1.16 //%2006////////////////////////////////////////////////////////////////////////
|
2 mday 1.2 //
|
3 karl 1.9 // 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 karl 1.5 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.9 // 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.10 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.16 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 mday 1.2 //
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 //
21 // 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: Mike Day (mdday@us.ibm.com)
33 //
|
34 carolann.graves 1.11 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
35 // (carolann_graves@hp.com)
36 //
|
37 mday 1.2 //%/////////////////////////////////////////////////////////////////////////////
38
39 #include "BinaryMessageHandler.h"
40 #include <Pegasus/Common/Thread.h>
41
42 PEGASUS_NAMESPACE_BEGIN
43
44 BinaryMessageHandler::BinaryMessageHandler(MessageQueueService *output_q)
45 : Base(PEGASUS_QUEUENAME_BINARY_HANDLER),
46 _outputQueue(output_q),
|
47 mike 1.19 _msg_q()
|
48 mday 1.2 {
49
50 }
51
52 BinaryMessageHandler::~BinaryMessageHandler(void)
53 {
54
55 }
56
57
58 Boolean BinaryMessageHandler::messageOK(const Message * msg)
59 {
60 return Base::messageOK(msg);
61 }
62
63 void BinaryMessageHandler::handleEnqueue(void)
64 {
65 Message *msg = dequeue();
66 handleEnqueue(msg);
67 }
68
69 mday 1.2 void BinaryMessageHandler::handleEnqueue(Message * message)
70 {
71 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
|
72 dave.sudlik 1.15 "BinaryMessageHandler::handleEnqueue(Message *)");
|
73 mday 1.2 PEGASUS_ASSERT(message != 0);
74
75 AsyncRequest * asyncRequest;
76 AsyncOpNode * op;
77
78 message->_async = 0;
79
80 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
81 "Converting legacy message to AsyncLegacyOperationStart");
82 op = this->get_op();
83 asyncRequest = new AsyncLegacyOperationStart(
84 op,
85 this->getQueueId(),
86 message,
87 this->getQueueId());
88 op->_flags |= ASYNC_OPFLAGS_FIRE_AND_FORGET;
89
90
91 _handle_async_request(asyncRequest);
92 PEG_METHOD_EXIT();
93 }
94 mday 1.2
95 void BinaryMessageHandler::_handle_async_request(AsyncRequest * request)
96 {
97 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
98 "BinaryMessageHandler::_handle_async_request");
99
100 PEGASUS_ASSERT(request != 0 && request->op != 0 );
101
102 if(request->getType() == async_messages::ASYNC_LEGACY_OP_START ||
103 request->getType() == async_messages::ASYNC_LEGACY_OP_RESULT)
104 {
105 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
106 "Processing ASYNC_LEGACY_OP_* Message.");
107 request->op->processing();
108 try
109 {
|
110 mike 1.19 _msg_q.enqueue(request->op);
|
111 mday 1.2 }
112 catch(ListFull & )
113 {
114 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
115 "Internal DQueue Full.");
116 Base::_handle_async_request(request);
117 PEG_METHOD_EXIT();
118 return;
119 }
120
121 catch(...)
122 {
123 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
124 "Internal DQueue Error.");
125 Base::_handle_async_request(request);
126 PEG_METHOD_EXIT();
127 return;
128 }
129
130 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
131 "Allocating pooled thread to handle binary message.");
|
132 konrad.r 1.14 if (_thread_pool->allocate_and_awaken(
133 (void *)this, BinaryMessageHandler::handle_binary_message)!=PEGASUS_THREAD_OK)
134 {
135 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
136 "Not enough threads to handle binary message.");
137
138 Tracer::trace(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL2,
139 "Could not allocate thread for %s. " \
140 "Queue has %d messages waiting. ",
141 getQueueName(),
142 _msg_q.count());
143 }
|
144 mday 1.2 }
145 else if(request->getType() == async_messages::CIMSERVICE_STOP)
146 {
147 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
148 "Handling CIMServer Stop Message");
149 Base::_handle_async_request(request);
150 }
151 else
152 {
153 // pass all other operations to the default handler
154 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
155 "Passing message to parent.");
|
156 kumpf 1.3 #ifdef BINARYMESSAGEHANDLER_DEBUG
|
157 mday 1.2 PEGASUS_STD(cout) << "Unexpected Message: type " << request->getType() << PEGASUS_STD(endl);
|
158 kumpf 1.3 #endif
|
159 mday 1.2
160 Base::_handle_async_request(request);
161 }
162
163 PEG_METHOD_EXIT();
164
165 return;
166 }
167
|
168 mike 1.22 ThreadReturnType PEGASUS_THREAD_CDECL
|
169 kumpf 1.12 BinaryMessageHandler::handle_binary_message(void* parm)
|
170 mday 1.2 {
171 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
|
172 dave.sudlik 1.15 "BinaryMessageHandler::handle_binary_message");
|
173 kumpf 1.12
174 BinaryMessageHandler* myself =
175 reinterpret_cast<BinaryMessageHandler*>(parm);
|
176 mday 1.2 PEGASUS_ASSERT(myself != 0);
|
177 kumpf 1.12
|
178 mday 1.2 AsyncOpNode *op;
179 try
180 {
|
181 mike 1.19 op = myself->_msg_q.dequeue();
|
182 mday 1.2 }
183 catch(...)
184 {
|
185 kumpf 1.12 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL2,
186 "Internal DQueue Error.");
|
187 mday 1.2 PEG_METHOD_EXIT();
188 return(0);
189 }
|
190 kumpf 1.12
|
191 mday 1.2 PEGASUS_ASSERT(op != 0);
192
193 // we only receive ASYNC_LEGACY_OP_START and
|
194 kumpf 1.12 // ASYNC_LEGACY_OP_RESULT messages
195
|
196 mday 1.2 Message *legacy = 0;
197 AsyncMessage *msg = 0;
|
198 kumpf 1.12
199 try
|
200 mday 1.2 {
|
201 kumpf 1.12 // if there is a response, dispatch the response
|
202 kumpf 1.21 if (op->_response.get() != 0)
|
203 kumpf 1.12 {
|
204 kumpf 1.21 msg = static_cast<AsyncMessage *>(op->_response.get());
|
205 kumpf 1.12 legacy = static_cast<AsyncLegacyOperationResult*>(msg)->get_result();
206 }
207 else
|
208 mday 1.2 {
|
209 kumpf 1.12 // there is no response so there has to be a request
|
210 kumpf 1.21 if (op->_request.get() == 0)
|
211 kumpf 1.12 {
212 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL2,
213 "Received OpNode with no messages.");
214 PEG_METHOD_EXIT();
215 return(0);
216 }
217 // dispatch the request
|
218 kumpf 1.21 msg = static_cast<AsyncMessage *>(op->_request.get());
|
219 kumpf 1.12 legacy = static_cast<AsyncLegacyOperationStart *>(msg)->get_action();
|
220 mday 1.2 }
|
221 kumpf 1.12 if(msg && legacy)
|
222 mday 1.2 {
|
223 kumpf 1.12 legacy->_async = 0;
|
224 mday 1.2
|
225 kumpf 1.12 switch(legacy->getType())
226 {
227 case CIM_CREATE_CLASS_REQUEST_MESSAGE:
228 myself->handleCreateClassRequest(
229 op, (CIMCreateClassRequestMessage *)legacy);
230 break;
231 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
232 myself->handleCreateInstanceRequest(
233 op, (CIMCreateInstanceRequestMessage *)legacy);
234 break;
235 case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
236 myself->handleModifyClassRequest(
237 op, (CIMModifyClassRequestMessage *)legacy);
238 break;
239 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
240 myself->handleModifyInstanceRequest(
241 op, (CIMModifyInstanceRequestMessage *)legacy);
242 break;
243 case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE: //10
244 myself->handleEnumerateClassesRequest(
245 op, (CIMEnumerateClassesRequestMessage *)legacy);
246 kumpf 1.12 break;
247 case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
248 myself->handleEnumerateClassNamesRequest(
249 op, (CIMEnumerateClassNamesRequestMessage *)legacy);
250 break;
251 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
252 myself->handleEnumerateInstancesRequest(
253 op, (CIMEnumerateInstancesRequestMessage *)legacy);
254 break;
255 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
256 myself->handleEnumerateInstanceNamesRequest(
257 op, (CIMEnumerateInstanceNamesRequestMessage *)legacy);
258 break;
259 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
260 myself->handleExecQueryRequest(
261 op, (CIMExecQueryRequestMessage *)legacy);
262 break;
263 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
264 myself->handleAssociatorsRequest(
265 op, (CIMAssociatorsRequestMessage *)legacy);
266 break;
267 kumpf 1.12 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
268 myself->handleAssociatorNamesRequest(
269 op, (CIMAssociatorNamesRequestMessage *)legacy);
270 break;
271 case CIM_REFERENCES_REQUEST_MESSAGE:
272 myself->handleReferencesRequest(
273 op, (CIMReferencesRequestMessage *)legacy);
274 break;
275 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
276 myself->handleReferenceNamesRequest(
277 op, (CIMReferenceNamesRequestMessage *)legacy);
278 break;
279 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
280 myself->handleGetPropertyRequest(
281 op, (CIMGetPropertyRequestMessage *)legacy);
282 break;
|
283 kumpf 1.18 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
|
284 kumpf 1.12 myself->handleSetPropertyRequest(
285 op, (CIMSetPropertyRequestMessage *)legacy);
286 break;
287 case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
288 myself->handleGetQualifierRequest(
289 op, (CIMGetQualifierRequestMessage *)legacy);
290 break;
291 case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
292 myself->handleSetQualifierRequest(
293 op, (CIMSetQualifierRequestMessage *)legacy);
294 break;
295 case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
296 myself->handleDeleteQualifiersRequest(
297 op, (CIMDeleteQualifierRequestMessage *)legacy);
298 break;
299 case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
300 myself->handleEnumerateQualifiersRequest(
301 op, (CIMEnumerateQualifiersRequestMessage *)legacy);
302 break;
303 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
304 myself->handleInvokeMethodRequest(
305 kumpf 1.12 op, (CIMInvokeMethodRequestMessage *)legacy);
306 break;
307 //**** response messages ****//
308 case CIM_GET_CLASS_RESPONSE_MESSAGE:
309 myself->handleGetClassResponse(
310 op, (CIMGetClassResponseMessage *)legacy);
311 break;
312 case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
313 myself->handleGetInstanceResponse(
314 op, (CIMGetInstanceResponseMessage *)legacy);
315 break;
316 case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
317 myself->handleDeleteClassResponse(
318 op, (CIMDeleteClassResponseMessage *)legacy);
319 break;
320 case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
321 myself->handleDeleteInstanceResponse(
322 op, (CIMDeleteInstanceResponseMessage *)legacy);
323 break;
324 case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
325 myself->handleCreateClassResponse(
326 kumpf 1.12 op, (CIMCreateClassResponseMessage *)legacy);
327 break;
328 case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
329 myself->handleCreateInstanceResponse(
330 op, (CIMCreateInstanceResponseMessage *)legacy);
331 break;
332 case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
333 myself->handleModifyClassResponse(
334 op, (CIMModifyClassResponseMessage *)legacy);
335 break;
336 case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
337 myself->handleModifyInstanceResponse(
338 op, (CIMModifyInstanceResponseMessage *)legacy);
339 break;
340 case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE:
341 myself->handleEnumerateClassesResponse(
342 op, (CIMEnumerateClassesResponseMessage *)legacy);
343 break;
344 case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE:
345 myself->handleEnumerateClassNamesResponse(
346 op, (CIMEnumerateClassNamesResponseMessage *)legacy);
347 kumpf 1.12 break;
348 case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
349 myself->handleEnumerateInstancesResponse(
350 op, (CIMEnumerateInstancesResponseMessage *)legacy);
351 break;
352 case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
353 myself->handleEnumerateInstanceNamesResponse(
354 op, (CIMEnumerateInstanceNamesResponseMessage *)legacy);
355 break;
356 case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
357 myself->handleExecQueryResponse(
358 op, (CIMExecQueryResponseMessage *)legacy);
359 break;
360 case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
361 myself->handleAssociatorsResponse(
362 op, (CIMAssociatorsResponseMessage *)legacy);
363 break;
364 case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
365 myself->handleAssociatorNamesResponse(
366 op, (CIMAssociatorNamesResponseMessage *)legacy);
367 break;
368 kumpf 1.12 case CIM_REFERENCES_RESPONSE_MESSAGE:
369 myself->handleReferencesResponse(
370 op, (CIMReferencesResponseMessage *)legacy);
371 break;
372 case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
373 myself->handleReferenceNamesResponse(
374 op, (CIMReferenceNamesResponseMessage *)legacy);
375 break;
376 case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
377 myself->handleGetPropertyResponse(
378 op, (CIMGetPropertyResponseMessage *)legacy);
379 break;
380 case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
381 myself->handleSetPropertyResponse(
382 op, (CIMSetPropertyResponseMessage *)legacy);
383 break;
384 case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
385 myself->handleGetQualifierResponse(
386 op, (CIMGetQualifierResponseMessage *)legacy);
387 break;
388 case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
389 kumpf 1.12 myself->handleSetQualifierResponse(
390 op, (CIMSetQualifierResponseMessage *)legacy);
391 break;
392 case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
393 myself->handleDeleteQualifierResponse(
394 op, (CIMDeleteQualifierResponseMessage *)legacy);
395 break;
396 case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:
397 myself->handleEnumerateQualifiersResponse(
398 op, (CIMEnumerateQualifiersResponseMessage *)legacy);
399 break;
400 case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
401 myself->handleInvokeMethodResponse(
402 op, (CIMInvokeMethodResponseMessage *)legacy);
403 break;
404
405 // unexpected requests
406 case CIM_PROCESS_INDICATION_REQUEST_MESSAGE:
|
407 kumpf 1.17 case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
|
408 kumpf 1.18 case CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE:
|
409 kumpf 1.12 case CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE:
410 case CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE:
411 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
412 case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
413 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
414 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
415 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
416 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
417
418 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
419
420 case CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE:
421
422 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
423 case CIM_GET_CLASS_REQUEST_MESSAGE:
424 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
425 case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
426 case CIM_DELETE_CLASS_REQUEST_MESSAGE:
427 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
428 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
429 "Received Unexpected legacy request message.");
430 kumpf 1.12 myself->_handleRequest(op, legacy);
431 break;
432
433 // unexpected replies
434 case CIM_PROCESS_INDICATION_RESPONSE_MESSAGE:
435 case CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE:
436 case CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE:
437 case CIM_HANDLE_INDICATION_RESPONSE_MESSAGE:
438 case CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE:
439 case CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE:
440 case CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE:
441 case CIM_SUBSCRIPTION_INIT_COMPLETE_RESPONSE_MESSAGE:
442 case CIM_DISABLE_MODULE_RESPONSE_MESSAGE:
443 case CIM_ENABLE_MODULE_RESPONSE_MESSAGE:
444 case CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE:
445 case CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE:
446 case CIM_INITIALIZE_PROVIDER_RESPONSE_MESSAGE:
447 case CIM_NOTIFY_CONFIG_CHANGE_RESPONSE_MESSAGE:
448 break;
|
449 kumpf 1.18 case CIM_EXPORT_INDICATION_RESPONSE_MESSAGE:
|
450 kumpf 1.12 default:
451 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
452 "Received Unexpected legacy response message.");
453 myself->_handleResponse(op, legacy);
454 break;
455 }
456 }
457 else
458 {
459 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
460 "Damaged or uninitialized AsyncOpNode received.");
|
461 mday 1.2 }
462 }
|
463 kumpf 1.12 catch (const Exception& e)
|
464 mday 1.2 {
|
465 kumpf 1.12 PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
466 "Caught exception: \"" + e.getMessage() +
467 "\". Exiting handle_binary_message.");
468 }
469 catch (...)
470 {
471 PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
472 "Caught unrecognized exception. Exiting handle_binary_message.");
|
473 mday 1.2 }
474
475 PEG_METHOD_EXIT();
476 return(0);
477 }
478
479 // requests always go to the output queue
480 void
481 BinaryMessageHandler::_handleRequest(AsyncOpNode *op, Message *msg)
482 throw()
483 {
484 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
|
485 kumpf 1.12 "BinaryMessageHandler::_handleRequest(AsyncOpNode *, Message *)");
|
486 mday 1.2
|
487 kumpf 1.21 AsyncRequest *async_request =
488 static_cast<AsyncRequest *>(op->removeRequest());
|
489 mday 1.2
490 msg->_async = 0;
491 try
492 {
493 _outputQueue->enqueue(msg) ;
494 }
495 catch(...)
496 {
|
497 dave.sudlik 1.15 // Should this exception really just be ignored?
498 // It seems like binary_message_handler should catch it.
499 PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
500 "Unrecognized exception caught and ignored by _handleRequest().");
|
501 mday 1.2 }
502
503 delete async_request;
504
505 _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
506 PEG_METHOD_EXIT();
507 }
508
509 // responses have their destination queue id in the message
510 void
511 BinaryMessageHandler::_handleResponse(AsyncOpNode *op, Message *msg)
512 throw()
513 {
514 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
515 "BinaryMessageHandler::_handleResponse(AsyncOpNode *, Message *)");
|
516 kumpf 1.21
517 if (op->_response.get() != 0)
518 {
519 AsyncReply* asyncReply = static_cast<AsyncReply *>(op->removeResponse());
520 delete asyncReply;
521 }
|
522 mday 1.2 msg->_async = 0;
523
524 MessageQueue *dest = MessageQueue::lookup(((CIMRequestMessage *)msg)->queueIds.top());
525 if(dest == 0)
526 {
527 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
528 "Bad or non-existent Queue ID for desination in legacy message.");
529 delete msg;
530 }
531 else
532 {
533 try
534 {
535
536 dest->enqueue(msg);
537 }
538 catch(...)
539 {
|
540 dave.sudlik 1.15 // Should this exception really just be ignored?
541 // It seems like binary_message_handler should catch it.
542 PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
543 "Unrecognized exception caught and ignored by _handleResponse().");
|
544 mday 1.2 }
545
546 }
547 _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
548 PEG_METHOD_EXIT();
549 }
550
551 void BinaryMessageHandler::handleCreateClassRequest(
552 AsyncOpNode *op,
553 CIMCreateClassRequestMessage *msg) throw()
554 {
555 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
556 "BinaryMessageHandler::handleCreateClassRequest()");
557 _handleRequest(op, msg);
558 PEG_METHOD_EXIT();
559 }
560
561
562 void BinaryMessageHandler::handleGetClassRequest(
563 AsyncOpNode *op,
564 CIMGetClassRequestMessage *msg) throw()
565 mday 1.2 {
566 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
567 "BinaryMessageHandler::handleGetClassRequest()");
568 _handleRequest(op, msg);
569 PEG_METHOD_EXIT();
570 }
571
572
573 void BinaryMessageHandler::handleModifyClassRequest(
574 AsyncOpNode *op,
575 CIMModifyClassRequestMessage *msg) throw()
576 {
577 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
578 "BinaryMessageHandler::handleModifyClassRequest()");
579 _handleRequest(op, msg);
580 PEG_METHOD_EXIT();
581 }
582
583 void BinaryMessageHandler::handleEnumerateClassNamesRequest(
584 AsyncOpNode *op,
585 CIMEnumerateClassNamesRequestMessage *msg) throw()
586 mday 1.2 {
587 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
588 "BinaryMessageHandler::handleEnumerateClassNamesRequest()");
589 _handleRequest(op, msg);
590 PEG_METHOD_EXIT();
591 }
592
593 void BinaryMessageHandler::handleEnumerateClassesRequest(
594 AsyncOpNode *op,
595 CIMEnumerateClassesRequestMessage *msg) throw()
596 {
597 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
598 "BinaryMessageHandler::handleEnumerateClassRequest()");
599 _handleRequest(op, msg);
600 PEG_METHOD_EXIT();
601 }
602
603
604 void BinaryMessageHandler::handleDeleteClassRequest(
605 AsyncOpNode *op,
606 CIMDeleteClassRequestMessage *msg) throw()
607 mday 1.2 {
608 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
609 "BinaryMessageHandler::handleDeleteClassRequest()");
610 _handleRequest(op, msg);
611 PEG_METHOD_EXIT();
612 }
613
614 void BinaryMessageHandler::handleCreateInstanceRequest(
615 AsyncOpNode *op,
616 CIMCreateInstanceRequestMessage *msg) throw()
617 {
618 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
619 "BinaryMessageHandler::handleCreateInstanceRequest()");
620 _handleRequest(op, msg);
621 PEG_METHOD_EXIT();
622 }
623
624 void BinaryMessageHandler::handleGetInstanceRequest(
625 AsyncOpNode *op,
626 CIMGetInstanceRequestMessage *msg) throw()
627 {
628 mday 1.2 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
629 "BinaryMessageHandler::handleGetInstanceRequest()");
630 _handleRequest(op, msg);
631 PEG_METHOD_EXIT();
632 }
633
634 void BinaryMessageHandler::handleModifyInstanceRequest(
635 AsyncOpNode *op,
636 CIMModifyInstanceRequestMessage *msg) throw()
637 {
638 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
639 "BinaryMessageHandler::handleModifyInstanceRequest()");
640 _handleRequest(op, msg);
641 PEG_METHOD_EXIT();
642 }
643
644 void BinaryMessageHandler::handleEnumerateInstanceNamesRequest(
645 AsyncOpNode *op,
646 CIMEnumerateInstanceNamesRequestMessage *msg) throw()
647 {
648 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
649 mday 1.2 "BinaryMessageHandler::handleEnumerateInstanceNamesRequest()");
650 _handleRequest(op, msg);
651 PEG_METHOD_EXIT();
652 }
653
654 void BinaryMessageHandler::handleEnumerateInstancesRequest(
655 AsyncOpNode *op,
656 CIMEnumerateInstancesRequestMessage *msg) throw()
657 {
658 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
659 "BinaryMessageHandler::handleEnumerateInstancesRequest()");
660 _handleRequest(op, msg);
661 PEG_METHOD_EXIT();
662 }
663
664 void BinaryMessageHandler::handleDeleteInstanceRequest(
665 AsyncOpNode *op,
666 CIMDeleteInstanceRequestMessage *msg) throw()
667 {
668 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
669 "BinaryMessageHandler::handleDeleteInstanceRequest()");
670 mday 1.2 _handleRequest(op, msg);
671 PEG_METHOD_EXIT();
672 }
673
674 void BinaryMessageHandler::handleSetQualifierRequest(
675 AsyncOpNode *op,
676 CIMSetQualifierRequestMessage *msg) throw()
677 {
678 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
679 "BinaryMessageHandler::handleSetQualifierRequest()");
680 _handleRequest(op, msg);
681 PEG_METHOD_EXIT();
682 }
683
684 void BinaryMessageHandler::handleGetQualifierRequest(
685 AsyncOpNode *op,
686 CIMGetQualifierRequestMessage *msg) throw()
687 {
688 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
689 "BinaryMessageHandler::handleGetQualifierRequest()");
690 _handleRequest(op, msg);
691 mday 1.2 PEG_METHOD_EXIT();
692 }
693
694 void BinaryMessageHandler::handleEnumerateQualifiersRequest(
695 AsyncOpNode *op,
696 CIMEnumerateQualifiersRequestMessage *msg) throw()
697 {
698 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
699 "BinaryMessageHandler::handleEnumerateQualifiersRequest()");
700 _handleRequest(op, msg);
701 PEG_METHOD_EXIT();
702 }
703
704 void BinaryMessageHandler::handleDeleteQualifiersRequest(
705 AsyncOpNode *op,
706 CIMDeleteQualifierRequestMessage *msg) throw()
707 {
708 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
709 "BinaryMessageHandler::handleDeleteQualifiersRequest()");
710 _handleRequest(op, msg);
711 PEG_METHOD_EXIT();
712 mday 1.2 }
713
714 void BinaryMessageHandler::handleReferenceNamesRequest(
715 AsyncOpNode *op,
716 CIMReferenceNamesRequestMessage *msg) throw()
717 {
718 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
719 "BinaryMessageHandler::handleReferenceNamesRequest()");
720 _handleRequest(op, msg);
721 PEG_METHOD_EXIT();
722 }
723
724 void BinaryMessageHandler::handleReferencesRequest(
725 AsyncOpNode *op,
726 CIMReferencesRequestMessage *msg) throw()
727 {
728 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
729 "BinaryMessageHandler::handleReferencesRequest()");
730 _handleRequest(op, msg);
731 PEG_METHOD_EXIT();
732 }
733 mday 1.2
734 void BinaryMessageHandler::handleAssociatorNamesRequest(
735 AsyncOpNode *op,
736 CIMAssociatorNamesRequestMessage *msg) throw()
737 {
738 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
739 "BinaryMessageHandler::handleAssociatorNamesRequest()");
740 _handleRequest(op, msg);
741 PEG_METHOD_EXIT();
742 }
743
744 void BinaryMessageHandler::handleAssociatorsRequest(
745 AsyncOpNode *op,
746 CIMAssociatorsRequestMessage *msg) throw()
747 {
748 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
749 "BinaryMessageHandler::handleAssociatorsRequest()");
750 _handleRequest(op, msg);
751 PEG_METHOD_EXIT();
752 }
753
754 mday 1.2 void BinaryMessageHandler::handleGetPropertyRequest(
755 AsyncOpNode *op,
756 CIMGetPropertyRequestMessage *msg) throw()
757 {
758 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
759 "BinaryMessageHandler::handleGetPropertyRequest()");
760 _handleRequest(op, msg);
761 PEG_METHOD_EXIT();
762 }
763
764 void BinaryMessageHandler::handleSetPropertyRequest(
765 AsyncOpNode *op,
766 CIMSetPropertyRequestMessage *msg) throw()
767 {
768 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
769 "BinaryMessageHandler::handleSetPropertyRequest()");
770 _handleRequest(op, msg);
771 PEG_METHOD_EXIT();
772 }
773
774 void BinaryMessageHandler::handleExecQueryRequest(
775 mday 1.2 AsyncOpNode *op,
776 CIMExecQueryRequestMessage *msg) throw()
777 {
778 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
779 "BinaryMessageHandler::handleExecQueryRequest()");
780 _handleRequest(op, msg);
781 PEG_METHOD_EXIT();
782 }
783
784 void BinaryMessageHandler::handleInvokeMethodRequest(
785 AsyncOpNode *op,
786 CIMInvokeMethodRequestMessage *msg) throw()
787 {
788 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
789 "BinaryMessageHandler::handleInvokeMethodRequest()");
790 _handleRequest(op, msg);
791 PEG_METHOD_EXIT();
792 }
793
794 // **** Response Messages **** //
795
796 mday 1.2 void BinaryMessageHandler::handleCreateClassResponse(
797 AsyncOpNode *op,
798 CIMCreateClassResponseMessage *msg) throw()
799 {
800 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
801 "BinaryMessageHandler::handleCreateClassResponse()");
802 _handleResponse(op, msg);
803 PEG_METHOD_EXIT();
804 }
805
806 void BinaryMessageHandler::handleGetClassResponse(
807 AsyncOpNode *op,
808 CIMGetClassResponseMessage *msg) throw()
809 {
810 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
811 "BinaryMessageHandler::handleGetClassResponse()");
812 _handleResponse(op, msg);
813 PEG_METHOD_EXIT();
814 }
815
816 void BinaryMessageHandler::handleModifyClassResponse(
817 mday 1.2 AsyncOpNode *op,
818 CIMModifyClassResponseMessage *msg) throw()
819 {
820 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
821 "BinaryMessageHandler::handleModifyClassResponse()");
822 _handleResponse(op, msg);
823 PEG_METHOD_EXIT();
824 }
825
826 void BinaryMessageHandler::handleEnumerateClassNamesResponse(
827 AsyncOpNode *op,
828 CIMEnumerateClassNamesResponseMessage *msg) throw()
829 {
830 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
831 "BinaryMessageHandler::handleEnumerateClassNamesResponse()");
832 _handleResponse(op, msg);
833 PEG_METHOD_EXIT();
834 }
835
836 void BinaryMessageHandler::handleEnumerateClassesResponse(
837 AsyncOpNode *op,
838 mday 1.2 CIMEnumerateClassesResponseMessage *msg) throw()
839 {
840 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
841 "BinaryMessageHandler::handleEnumerateClassesResponse()");
842 _handleResponse(op, msg);
843 PEG_METHOD_EXIT();
844 }
845
846 void BinaryMessageHandler::handleDeleteClassResponse(
847 AsyncOpNode *op,
848 CIMDeleteClassResponseMessage *msg) throw()
849 {
850 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
851 "BinaryMessageHandler::handleDeleteClassResponse()");
852 _handleResponse(op, msg);
853 PEG_METHOD_EXIT();
854 }
855
856 void BinaryMessageHandler::handleCreateInstanceResponse(
857 AsyncOpNode *op,
858 CIMCreateInstanceResponseMessage *msg) throw()
859 mday 1.2 {
860 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
861 "BinaryMessageHandler::handleCreateInstanceResponse()");
862 _handleResponse(op, msg);
863 PEG_METHOD_EXIT();
864 }
865
866 void BinaryMessageHandler::handleGetInstanceResponse(
867 AsyncOpNode *op,
868 CIMGetInstanceResponseMessage *msg) throw()
869 {
870 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
871 "BinaryMessageHandler::handleGetInstanceResponse()");
872 _handleResponse(op, msg);
873 PEG_METHOD_EXIT();
874 }
875
876 void BinaryMessageHandler::handleModifyInstanceResponse(
877 AsyncOpNode *op,
878 CIMModifyInstanceResponseMessage *msg) throw()
879 {
880 mday 1.2 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
881 "BinaryMessageHandler::handleModifyInstanceResponse()");
882 _handleResponse(op, msg);
883 PEG_METHOD_EXIT();
884 }
885
886 void BinaryMessageHandler::handleEnumerateInstanceNamesResponse(
887 AsyncOpNode *op,
888 CIMEnumerateInstanceNamesResponseMessage *msg) throw()
889 {
890 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
891 "BinaryMessageHandler::handleEnumerateInstanceNamesResponse()");
892 _handleResponse(op, msg);
893 PEG_METHOD_EXIT();
894 }
895
896 void BinaryMessageHandler::handleEnumerateInstancesResponse(
897 AsyncOpNode *op,
898 CIMEnumerateInstancesResponseMessage *msg) throw()
899 {
900 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
901 mday 1.2 "BinaryMessageHandler::handleEnumerateInstancesResponse()");
902 _handleResponse(op, msg);
903 PEG_METHOD_EXIT();
904 }
905
906 void BinaryMessageHandler::handleDeleteInstanceResponse(
907 AsyncOpNode *op,
908 CIMDeleteInstanceResponseMessage *msg) throw()
909 {
910 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
911 "BinaryMessageHandler::handleDeleteInstanceResponse()");
912 _handleResponse(op, msg);
913 PEG_METHOD_EXIT();
914 }
915
916 void BinaryMessageHandler::handleGetPropertyResponse(
917 AsyncOpNode *op,
918 CIMGetPropertyResponseMessage *msg) throw()
919 {
920 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
921 "BinaryMessageHandler::handleGetPropertyResponse()");
922 mday 1.2 _handleResponse(op, msg);
923 PEG_METHOD_EXIT();
924 }
925
926 void BinaryMessageHandler::handleSetPropertyResponse(
927 AsyncOpNode *op,
928 CIMSetPropertyResponseMessage *msg) throw()
929 {
930 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
931 "BinaryMessageHandler::handleSetPropertyResponse()");
932 _handleResponse(op, msg);
933 PEG_METHOD_EXIT();
934 }
935
936
937 void BinaryMessageHandler::handleSetQualifierResponse(
938 AsyncOpNode *op,
939 CIMSetQualifierResponseMessage *msg) throw()
940 {
941 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
942 "BinaryMessageHandler::handleSetQualifierResponse()");
943 mday 1.2 _handleResponse(op, msg);
944 PEG_METHOD_EXIT();
945 }
946
947 void BinaryMessageHandler::handleGetQualifierResponse(
948 AsyncOpNode *op,
949 CIMGetQualifierResponseMessage *msg) throw()
950 {
951 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
952 "BinaryMessageHandler::handleGetQualifierResponse()");
953 _handleResponse(op, msg);
954 PEG_METHOD_EXIT();
955 }
956
957 void BinaryMessageHandler::handleEnumerateQualifiersResponse(
958 AsyncOpNode *op,
959 CIMEnumerateQualifiersResponseMessage *msg) throw()
960 {
961 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
962 "BinaryMessageHandler::handleEnumerateQualifiersResponse()");
963 _handleResponse(op, msg);
964 mday 1.2 PEG_METHOD_EXIT();
965 }
966
967 void BinaryMessageHandler::handleDeleteQualifierResponse(
968 AsyncOpNode *op,
969 CIMDeleteQualifierResponseMessage *msg) throw()
970 {
971 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
972 "BinaryMessageHandler::handleDeleteQualifierResponse()");
973 _handleResponse(op, msg);
974 PEG_METHOD_EXIT();
975 }
976
977 void BinaryMessageHandler::handleReferenceNamesResponse(
978 AsyncOpNode *op,
979 CIMReferenceNamesResponseMessage *msg) throw()
980 {
981 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
982 "BinaryMessageHandler::handleReferenceNamesResponse()");
983 _handleResponse(op, msg);
984 PEG_METHOD_EXIT();
985 mday 1.2 }
986
987 void BinaryMessageHandler::handleReferencesResponse(
988 AsyncOpNode *op,
989 CIMReferencesResponseMessage *msg) throw()
990 {
991 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
992 "BinaryMessageHandler::handleReferencesResponse()");
993 _handleResponse(op, msg);
994 PEG_METHOD_EXIT();
995 }
996
997 void BinaryMessageHandler::handleAssociatorNamesResponse(
998 AsyncOpNode *op,
999 CIMAssociatorNamesResponseMessage *msg) throw()
1000 {
1001 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
1002 "BinaryMessageHandler::handleAssociatorNamesResponse()");
1003 _handleResponse(op, msg);
1004 PEG_METHOD_EXIT();
1005 }
1006 mday 1.2
1007 void BinaryMessageHandler::handleAssociatorsResponse(
1008 AsyncOpNode *op,
1009 CIMAssociatorsResponseMessage *msg) throw()
1010 {
1011 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
1012 "BinaryMessageHandler::handleAssociatorsResponse()");
1013 _handleResponse(op, msg);
1014 PEG_METHOD_EXIT();
1015 }
1016
1017 void BinaryMessageHandler::handleExecQueryResponse(
1018 AsyncOpNode *op,
1019 CIMExecQueryResponseMessage *msg) throw()
1020 {
1021 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
1022 "BinaryMessageHandler::handleExecQueryResponse()");
1023 _handleResponse(op, msg);
1024 PEG_METHOD_EXIT();
1025 }
1026
1027 mday 1.2
1028 void BinaryMessageHandler::handleInvokeMethodResponse(
1029 AsyncOpNode *op,
1030 CIMInvokeMethodResponseMessage *msg) throw()
1031 {
1032 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
1033 "BinaryMessageHandler::handleInvokeMethodResponse()");
1034 _handleResponse(op, msg);
1035 PEG_METHOD_EXIT();
1036 }
1037
1038 PEGASUS_NAMESPACE_END
|
Return to
BinaryMessageHandler.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Server