void
AsyncChannel::ProcessLink::OnEchoMessage(Message* msg)
{
AssertIOThread();
OnMessageReceived(*msg);
delete msg;
}
void
ProcessLink::OnEchoMessage(Message* msg)
{
AssertIOThread();
OnMessageReceived(Move(*msg));
delete msg;
}
void User::HandleServerInfoGameMessage (yap::IPacket& packet)
{
yap::String senderName = packet.ReadString ();
yap::String content = packet.ReadString ();
yap::GameMessage gameMessage;
gameMessage.SetSenderName (senderName);
gameMessage.SetContent (content);
OnMessageReceived (*this, gameMessage);
}
/* ------------------------------------------------------------------------- */
static int OnRxBody(TServant *const servant)
{
TRxControl *const ctrl = &servant->m_rx;
if (GetRxData(servant->m_session.m_connection, ctrl))
return -EXIT_FAILURE;
if (ctrl->m_n_to_receive)
return -EXIT_SUCCESS; /* continue receiving */
/* body is received */
{
ezxml_t xml;
const char* body;
size_t len;
body = GetBody(ctrl, &len);
assert(len > 0 && body);
xml = ezxml_parse_str_d(body, len);
if (!xml)
{
LOG1_ERROR("servant", "the session (%u) received an invalid "
"formated message", servant->m_session.m_id);
return -EXIT_FAILURE;
}
if (OnMessageReceived(servant, xml))
return -EXIT_FAILURE;
}
StartRx(servant);
return -EXIT_SUCCESS;
}
void
ProcessLink::OnTakeConnectedChannel()
{
AssertIOThread();
queue<Message> pending;
{
MonitorAutoLock lock(*mChan->mMonitor);
mChan->mChannelState = ChannelConnected;
mExistingListener = mTransport->set_listener(this);
if (mExistingListener) {
mExistingListener->GetQueuedMessages(pending);
}
lock.Notify();
}
// Dispatch whatever messages the previous listener had queued up.
while (!pending.empty()) {
OnMessageReceived(Move(pending.front()));
pending.pop();
}
}
void IOLoop::Run()
{
while (m_shouldRun)
{
//remove channels
if (m_removeChannels.GetLength() > 0)
{
m_channelsMutex.Lock();
m_removeChannelsMutex.Lock();
for (int i = 0; i < m_removeChannels.GetLength(); i++)
{
m_channels.Remove(m_removeChannels[i]);
delete m_removeChannels[i];
}
m_removeChannels.Reset();
m_removeChannelsMutex.Unlock();
m_channelsMutex.Unlock();
}
//get channel events
int numChannels = m_channels.GetLength();
int numProcesses = m_processes.GetLength();
int numEvents = numChannels + numProcesses;
if (numEvents < 1)
{
Sleep(10);
continue;
}
else if (numEvents > MAXIMUM_WAIT_OBJECTS)
{
VASSERT("Too many Events" == NULL);
continue;
}
HANDLE eventHandles[MAXIMUM_WAIT_OBJECTS];
m_channelsMutex.Lock();
for (int i = 0; i < numChannels; i++)
{
eventHandles[i] = m_channels[i]->GetPendingMessagesEvent();
}
m_channelsMutex.Unlock();
m_processesMutex.Lock();
for (int i = 0; i < numProcesses; i++)
{
eventHandles[numChannels + i] = m_processes[i];
}
m_processesMutex.Unlock();
DWORD waitRes = WaitForMultipleObjects(numEvents, eventHandles, FALSE, 200);
if (waitRes == WAIT_FAILED)
{
DWORD lastError = GetLastError();
std::cout << "WaitForMultipleObjects failed with error code: " << lastError << std::endl;
continue;
}
if (waitRes == WAIT_TIMEOUT)
continue;
int eventIndex = waitRes - WAIT_OBJECT_0;
if (eventIndex >= 0 && eventIndex < numChannels)
{
m_channels[eventIndex]->ProcessMessages();
if (!m_channels[eventIndex]->IsValid())
{
MsgChannelClosed msg(eventIndex);
msg.SetReceiverId(m_id);
msg.SetSenderId(1);
OnMessageReceived(msg);
}
}
else if (eventIndex < numEvents)
{
HANDLE processHandle = m_processes[eventIndex - numChannels];
MsgPeerIsDead msg(processHandle);
msg.SetReceiverId(m_id);
msg.SetSenderId(1);
OnMessageReceived(msg);
VMutexLocker lock(m_processesMutex);
CloseHandle(processHandle);
m_processes.Remove(processHandle);
}
}
}
