void IndicationHandlerService::handleEnqueue(Message* message)
{
PEGASUS_ASSERT(message != 0);
CIMMessage* tmp = dynamic_cast<CIMMessage *>(message);
AutoPtr<CIMMessage> cimMessage(tmp);
PEGASUS_ASSERT(cimMessage.get() != 0);
// Set the client's requested language into this service thread.
// This will allow functions in this service to return messages
// in the correct language.
cimMessage->updateThreadLanguages();
switch (message->getType())
{
case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
{
AutoPtr<CIMHandleIndicationResponseMessage> response(
_handleIndication(
(CIMHandleIndicationRequestMessage*) message));
SendForget(response.get());
response.release();
break;
}
default:
PEGASUS_ASSERT(0);
break;
}
}
Boolean MessageQueueService::_enqueueResponse(
Message* request,
Message* response)
{
STAT_COPYDISPATCHER
PEG_METHOD_ENTER(TRC_MESSAGEQUEUESERVICE,
"MessageQueueService::_enqueueResponse");
if (request->getMask() & message_mask::ha_async)
{
if (response->getMask() & message_mask::ha_async)
{
_completeAsyncResponse(static_cast<AsyncRequest *>(request),
static_cast<AsyncReply *>(response),
ASYNC_OPSTATE_COMPLETE, 0);
PEG_METHOD_EXIT();
return true;
}
}
if (request->_async != 0)
{
Uint32 mask = request->_async->getMask();
PEGASUS_ASSERT(mask & (message_mask::ha_async | message_mask::ha_request));
AsyncRequest *async = static_cast<AsyncRequest *>(request->_async);
AsyncOpNode *op = async->op;
request->_async = 0;
// the legacy request is going to be deleted by its handler
// remove it from the op node
static_cast<AsyncLegacyOperationStart *>(async)->get_action();
AsyncLegacyOperationResult *async_result =
new AsyncLegacyOperationResult(
async->getKey(),
async->getRouting(),
op,
response);
_completeAsyncResponse(
async,
async_result,
ASYNC_OPSTATE_COMPLETE,
0);
PEG_METHOD_EXIT();
return true;
}
// ensure that the destination queue is in response->dest
PEG_METHOD_EXIT();
return SendForget(response);
}
Boolean ModuleController::_send_forget(Uint32 destination_q,
const String & destination_module,
AsyncRequest *message)
{
AsyncOpNode *op = get_op();
message->dest = destination_q;
AsyncModuleOperationStart *request =
new AsyncModuleOperationStart(0,
op,
destination_q,
getQueueId(),
true,
destination_module,
message);
return SendForget(request);
}
void IndicationHandlerService::handleEnqueue(Message* message)
{
if (!message)
{
return;
}
// l10n
// Set the client's requested language into this service thread.
// This will allow functions in this service to return messages
// in the correct language.
AutoPtr<CIMMessage> msg(dynamic_cast<CIMMessage *>(message));
if (msg.get() != NULL)
{
if (msg->thread_changed())
{
AutoPtr<AcceptLanguages> langs(new AcceptLanguages(((AcceptLanguageListContainer)msg->operationContext.get(AcceptLanguageListContainer::NAME)).getLanguages()));
Thread::setLanguages(langs.get());
langs.release();
}
}
else
{
Thread::clearLanguages();
}
switch (message->getType())
{
case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
{
AutoPtr<CIMHandleIndicationResponseMessage> response(_handleIndication(
(CIMHandleIndicationRequestMessage*) message));
SendForget(response.get());
response.release();
break;
}
default:
Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2,
"IndicationHandlerService::handleEnqueue got unexpected "
"message type '%u'", message->getType());
break;
}
}
Boolean MessageQueueService::SendAsync(
Message *msg,
Uint32 destination,
void (*callback)(Message *response, void *handle, void *parameter),
void *handle,
void *parameter)
{
if (msg == NULL)
return false;
if (callback == NULL)
return SendForget(msg);
AsyncOpNode *op = get_op();
msg->dest = destination;
if (NULL == (op->_op_dest = MessageQueue::lookup(msg->dest)))
{
op->release();
return_op(op);
return false;
}
op->_flags |= ASYNC_OPFLAGS_SAFE_CALLBACK;
op->_flags &= ~(ASYNC_OPFLAGS_FIRE_AND_FORGET);
op->_state &= ~ASYNC_OPSTATE_COMPLETE;
op->__async_callback = callback;
op->_callback_node = op;
op->_callback_handle = handle;
op->_callback_parameter = parameter;
op->_callback_response_q = this;
if (!(msg->getMask() & message_mask::ha_async))
{
AsyncLegacyOperationStart *wrapper = new AsyncLegacyOperationStart(
get_next_xid(),
op,
destination,
msg,
destination);
}
else
{
op->_request.insert_first(msg);
(static_cast<AsyncMessage *>(msg))->op = op;
}
return _meta_dispatcher->route_async(op);
}
Boolean ModuleController::_send_forget(Uint32 destination_q, AsyncRequest *message)
{
message->dest = destination_q;
return SendForget(message);
}
