void cimom::_completeAsyncResponse( AsyncRequest *request, AsyncReply *reply) { PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE, "cimom::_completeAsyncResponse"); PEGASUS_ASSERT(request != 0); AsyncOpNode *op = request->op; if (op->_flags == ASYNC_OPFLAGS_CALLBACK) { if (reply != 0) { op->_response.reset(reply); } _complete_op_node(op); return; } else if (op->_flags == ASYNC_OPFLAGS_FIRE_AND_FORGET) { PEGASUS_ASSERT(op->_state == ASYNC_OPSTATE_UNKNOWN); _global_this->cache_op(op); } else { PEGASUS_ASSERT (op->_flags == ASYNC_OPFLAGS_PSEUDO_CALLBACK); PEGASUS_ASSERT(op->_state == ASYNC_OPSTATE_UNKNOWN); op->_state = ASYNC_OPSTATE_COMPLETE; op->_client_sem.signal(); } PEG_METHOD_EXIT(); }
void ModuleController::_handle_async_request(AsyncRequest *rq) { if( rq->getType() == async_messages::ASYNC_MODULE_OP_START) { // find the target module pegasus_module *target; Message *module_result = NULL; { _module_lock lock(&_modules); target = _modules.next(0); while(target != NULL) { if(target->get_name() == static_cast<AsyncModuleOperationStart *>(rq)->_target_module) { break; } target = _modules.next(target); } } if (target) { // ATTN: This statement was taken out of the _module_lock block // above because that caused all requests to control providers to // be serialized. There is now a risk that the control provider // module may be deleted after the lookup and before this call. // See Bugzilla 3120. module_result = target->_receive_message( static_cast<AsyncModuleOperationStart *>(rq)->_act); } if(module_result == NULL) { module_result = new AsyncReply(async_messages::REPLY, static_cast<AsyncModuleOperationStart *>(rq)->_act->getKey(), static_cast<AsyncModuleOperationStart *>(rq)->_act->getRouting(), message_mask::ha_async | message_mask::ha_reply, rq->op, async_results::CIM_NAK, rq->resp, false); } AsyncModuleOperationResult *result = new AsyncModuleOperationResult(rq->getKey(), rq->getRouting(), rq->op, async_results::OK, static_cast<AsyncModuleOperationStart *>(rq)->resp, false, static_cast<AsyncModuleOperationStart *>(rq)->_target_module, module_result); _complete_op_node(rq->op, 0, 0, 0); } else Base::_handle_async_request(rq); }
void test_async_queue::_handle_async_request (AsyncRequest * rq) { if ((rq->getType () == ASYNC_ASYNC_OP_START) || (rq->getType () == ASYNC_ASYNC_LEGACY_OP_START)) { try { PEGASUS_TEST_ASSERT (_role == SERVER); Message *response_data = new Message (CIM_GET_INSTANCE_RESPONSE_MESSAGE); async_complete *response_msg = new async_complete (static_cast < async_start & >(*rq), async_results::OK, response_data); _complete_op_node (rq->op); } catch (const PEGASUS_STD(bad_alloc) &) { cerr <<" Out of memory!" << endl; } } else if (rq->getType () == ASYNC_CIMSERVICE_STOP) { PEGASUS_TEST_ASSERT (_role == SERVER); _handle_stop ((CimServiceStop *) rq); } else Base::_handle_async_request (rq); }
void CIMExportRequestDispatcher::_handle_async_request(AsyncRequest *req) { PEG_METHOD_ENTER(TRC_EXP_REQUEST_DISP, "CIMExportRequestDispatcher::_handle_async_request"); PEGASUS_ASSERT(req != 0 && req->op != 0); if (req->getType() == ASYNC_CIMSERVICE_STOP) { handle_CimServiceStop(static_cast<CimServiceStop *>(req)); } else if (req->getType() == ASYNC_ASYNC_LEGACY_OP_START) { Message *legacy = (static_cast<AsyncLegacyOperationStart *>(req)->get_action()); if (legacy->getType() == CIM_EXPORT_INDICATION_REQUEST_MESSAGE) { Message* legacy_response = _handleExportIndicationRequest( (CIMExportIndicationRequestMessage*) legacy); // constructor puts itself into a linked list, DO NOT remove the new new AsyncLegacyOperationResult(req->op, legacy_response); _complete_op_node(req->op); delete legacy; } else { PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1, "CIMExportRequestDispatcher::_handle_async_request got " "unexpected legacy message type '%s'", MessageTypeToString(legacy->getType()))); _make_response(req, async_results::CIM_NAK); delete legacy; } } else { Base::_handle_async_request(req); } PEG_METHOD_EXIT(); }
void IndicationHandlerService::_handle_async_request(AsyncRequest *req) { if ( req->getType() == async_messages::CIMSERVICE_STOP ) { req->op->processing(); handle_CimServiceStop(static_cast<CimServiceStop *>(req)); } else if ( req->getType() == async_messages::ASYNC_LEGACY_OP_START ) { req->op->processing(); AutoPtr<Message> legacy(static_cast<AsyncLegacyOperationStart *>(req)->get_action()); //PEP 101 if (legacy->getType() == CIM_HANDLE_INDICATION_REQUEST_MESSAGE) { AutoPtr<Message> legacy_response(_handleIndication( (CIMHandleIndicationRequestMessage*) legacy.get())); //PEP 101 legacy.release(); AutoPtr<AsyncLegacyOperationResult> async_result(new AsyncLegacyOperationResult( req->getKey(), req->getRouting(), req->op, legacy_response.get())); //PEP 101 legacy_response.release(); async_result.release(); _complete_op_node(req->op, ASYNC_OPSTATE_COMPLETE, 0, 0); } else { Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2, "IndicationHandlerService::_handle_async_request got " "unexpected legacy message type '%u'", legacy->getType()); _make_response(req, async_results::CIM_NAK); } } else { Base::_handle_async_request(req); } }
void IndicationHandlerService::_handle_async_request(AsyncRequest* req) { if (req->getType() == ASYNC_CIMSERVICE_STOP) { handle_CimServiceStop(static_cast<CimServiceStop *>(req)); } else if (req->getType() == ASYNC_ASYNC_LEGACY_OP_START) { AutoPtr<Message> legacy( static_cast<AsyncLegacyOperationStart *>(req)->get_action()); if (legacy->getType() == CIM_HANDLE_INDICATION_REQUEST_MESSAGE) { AutoPtr<Message> legacy_response(_handleIndication( (CIMHandleIndicationRequestMessage*) legacy.get())); legacy.release(); AutoPtr<AsyncLegacyOperationResult> async_result( new AsyncLegacyOperationResult( req->op, legacy_response.get())); legacy_response.release(); async_result.release(); _complete_op_node(req->op); } else { PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2, "IndicationHandlerService::_handle_async_request got " "unexpected legacy message type '%u'", legacy->getType())); _make_response(req, async_results::CIM_NAK); } } else { Base::_handle_async_request(req); } }