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);
}
}
