void Slave::MessageReceived(ChannelHandlerContext& ctx, MessageEvent<RedisMessage>& e)
{
if (e.GetMessage()->IsReply())
{
HandleRedisReply(ctx.GetChannel(), e.GetMessage()->reply);
}
else if (e.GetMessage()->IsCommand())
{
HandleRedisCommand(ctx.GetChannel(), e.GetMessage()->command);
}
else
{
HandleRedisDumpChunk(ctx.GetChannel(), e.GetMessage()->chunk);
}
}
bool ChannelService::EventSunk(ChannelPipeline* pipeline, MessageEvent<DatagramPacket>& e)
{
DatagramPacket* packet = e.GetMessage();
Channel* ch = e.GetChannel();
DatagramChannel* sc = (DatagramChannel*) ch;
return sc->Send(packet->GetInetAddress(), &(packet->GetBuffer())) > 0;
}
void Master::MessageReceived(ChannelHandlerContext& ctx, MessageEvent<RedisCommandFrame>& e)
{
RedisCommandFrame* cmd = e.GetMessage();
DEBUG_LOG("Master recv cmd from slave:%s", cmd->ToString().c_str());
if (!strcasecmp(cmd->GetCommand().c_str(), "replconf"))
{
if (cmd->GetArguments().size() == 2 && !strcasecmp(cmd->GetArguments()[0].c_str(), "ack"))
{
int64 offset;
if (string_toint64(cmd->GetArguments()[1], offset))
{
SlaveConnTable::iterator found = m_slaves.find(ctx.GetChannel()->GetID());
if (found != m_slaves.end())
{
SlaveConn* slave = found->second;
if (NULL != slave)
{
slave->acktime = time(NULL);
slave->ack_offset = offset;
}
}
}
}
}
}
void MessageReceived(ChannelHandlerContext& ctx,
MessageEvent<Buffer>& e)
{
total_recv += (e.GetMessage()->ReadableBytes());
Buffer send(7);
send.Write("Hello\r\n", 7);
ctx.GetChannel()->Write(send);
//total_received++;
//DEBUG_LOG("Received response with total:%d", total_received);
// if (total_received == total_would_send)
// {
// ctx.GetChannel()->Close();
// ctx.GetChannel()->GetService().Stop();
// }
// else if (total_received % 2000 == 0)
// {
// //INFO_LOG("Received %d response\n", total_received);
// Buffer buf(16);
// buf.Write("Hello,world\r\n", 13);
// for (uint32 i = 0; i < 2000; i++)
// {
// if (!ctx.GetChannel()->Write(buf))
// {
// ERROR_LOG("Failed to write buf to channel with total send:%d", total_send);
// continue;
// }
// total_send++;
// buf.SetReadIndex(0);
// }
// //INFO_LOG("Write %d request\n", total_send);
// }
}
bool ChannelService::EventSunk(ChannelPipeline* pipeline, MessageEvent<Buffer>& e)
{
Buffer* buffer = e.GetMessage();
RETURN_FALSE_IF_NULL(buffer);
uint32 len = buffer->ReadableBytes();
int32 ret = e.GetChannel()->WriteNow(buffer);
return ret >= 0 ? (len == (uint32) ret) : false;
}
bool RedisCommandEncoder::WriteRequested(ChannelHandlerContext& ctx, MessageEvent<RedisCommandFrame>& e)
{
RedisCommandFrame* msg = e.GetMessage();
m_buffer.Clear();
if (Encode(m_buffer, *msg))
{
return ctx.GetChannel()->Write(m_buffer);
}
return false;
}
bool RedisCommandEncoder::WriteRequested(ChannelHandlerContext& ctx, MessageEvent<RedisCommandFrame>& e)
{
RedisCommandFrame* msg = e.GetMessage();
if (Encode(ctx.GetChannel()->GetOutputBuffer(), *msg))
{
ctx.GetChannel()->EnableWriting();
return true;
}
return false;
}
void MessageReceived(ChannelHandlerContext& ctx,
MessageEvent<Buffer>& e)
{
Buffer* input = e.GetMessage();
if (m_cumulation.Readable())
{
m_cumulation.DiscardReadedBytes();
m_cumulation.Write(input, input->ReadableBytes());
CallDecode(ctx, e.GetChannel(), m_cumulation);
} else
{
CallDecode(ctx, e.GetChannel(), *input);
if (input->Readable())
{
m_cumulation.Write(input, input->ReadableBytes());
}
}
}
void FastRedisCommandDecoder::MessageReceived(ChannelHandlerContext& ctx, MessageEvent<Buffer>& e)
{
Buffer& buffer = *(e.GetMessage());
bool have_empty = false;
while (buffer.GetRawReadBuffer()[0] == '\r' || buffer.GetRawReadBuffer()[0] == '\n')
{
buffer.AdvanceReadIndex(1);
have_empty = true;
}
if(!m_ignore_empty && have_empty)
{
m_cmd.Clear();
fire_message_received<RedisCommandFrame>(ctx, &m_cmd, NULL);
}
Channel* ch = ctx.GetChannel();
std::string err;
size_t mark_read_index = buffer.GetReadIndex();
while (buffer.Readable() && !ch->IsReadBlocked())
{
/* Determine request type when unknown. */
if (!m_reqtype)
{
if (buffer.GetRawReadBuffer()[0] == '*')
{
m_reqtype = REDIS_REQ_MULTIBULK;
}
else
{
m_reqtype = REDIS_REQ_INLINE;
}
}
if (m_reqtype == REDIS_REQ_INLINE)
{
m_cmd.Clear();
if (RedisCommandDecoder::ProcessInlineBuffer(buffer, m_cmd) == 1)
{
fire_message_received<RedisCommandFrame>(ctx, &m_cmd, NULL);
}
else
{
break;
}
}
else if (m_reqtype == REDIS_REQ_MULTIBULK)
{
if (ProcessMultibulkBuffer(buffer, err) == 1)
{
size_t raw_data_size = buffer.GetReadIndex() - mark_read_index;
m_cmd.m_raw_msg.WrapReadableContent(buffer.GetRawReadBuffer() - raw_data_size, raw_data_size);
fire_message_received<RedisCommandFrame>(ctx, &m_cmd, NULL);
}
else
{
break;
}
}
else
{
err = "Unknown request type";
}
if (!err.empty())
{
APIException ex(err);
fire_exception_caught(ctx.GetChannel(), ex);
ERROR_LOG("Exception:%s occured.", err.c_str());
}
}
}
void CoroChannel::MessageReceived(ChannelHandlerContext& ctx, MessageEvent<Buffer>& e)
{
Buffer* buf = e.GetMessage();
SetReadedContent(buf);
WakeupCoro();
}
void CoroRedisClient::MessageReceived(ChannelHandlerContext& ctx, MessageEvent<RedisReply>& e)
{
SetReply(e.GetMessage());
}
void ServiceIPCEventHandler::MessageReceived(ChannelHandlerContext& ctx,
MessageEvent<IPCEvent>& e)
{
#define CHECK_SEVICE_HANDLER() do{ \
if (NULL == m_handler) \
{ \
if( GetServiceProcess()->GetServiceType() == DISPATCHER_SERVICE_PROCESS_TYPE) return; \
WARN_LOG("ServiceHandler is NULL for handling IPC event."); \
return; \
} \
}while(0)
IPCEvent* ipc_event = e.GetMessage();
IPCEventType type = ipc_event->GetType();
switch (type)
{
case SOCKET_MSG:
{
CHECK_SEVICE_HANDLER();
SocketMessageEvent* msg = (SocketMessageEvent*) ipc_event;
uint32 reportSocketChannelID = msg->GetChannelID();
if (m_has_dispatcher)
{
uint32 realID = msg->GetChannelID();
Channel* src_channel = e.GetChannel();
VirtualChannelHelper::GetVirtualSocketID(src_channel, realID,
reportSocketChannelID);
}
if (NULL != msg->GetContent())
{
if (NULL != msg->GetSocketInetAddress())
{
m_handler->OnSocketMessage(reportSocketChannelID,
*(msg->GetContent()),
*(msg->GetSocketInetAddress()));
}
else
{
m_handler->OnSocketMessage(reportSocketChannelID,
*(msg->GetContent()));
}
}
break;
}
case IPC_MSG:
{
CHECK_SEVICE_HANDLER();
IPCMessageEvent* msg = (IPCMessageEvent*) ipc_event;
if (NULL != msg->GetContent())
{
m_handler->OnIPCMessage(msg->GetSrcType(), msg->GetSrcIndex(),
*(msg->GetContent()));
}
break;
}
case ADMIN:
{
CHECK_SEVICE_HANDLER();
IPCMessageEvent* msg = (IPCMessageEvent*) ipc_event;
if (NULL != msg->GetContent())
{
AdminCommand cmd;
if (0
== AdminCommandHandler::DecodeCommand(cmd,
msg->GetContent()))
{
std::string result;
Buffer tmp;
if (AdminCommandHandler::HandleCommand(cmd, result) >= 0)
{
tmp.EnsureWritableBytes(result.size() + 2);
tmp.Printf("%s\r\n", result.c_str());
}
else
{
tmp.Printf("Failed to handler command:%s\r\n",
cmd.name.c_str());
}
VirtualChannelHelper::WriteSocket(cmd.admin_channel_id,
tmp);
}
}
break;
}
case IPC_CTRL:
{
IPCCtrlEvent* event = (IPCCtrlEvent*) ipc_event;
switch (event->GetIPCCtrlType())
{
case SERV_PROC_STARTED:
{
CHECK_SEVICE_HANDLER();
m_handler->OnServiceProcessStarted(event->GetSrcType(),
event->GetSrcIndex());
break;
}
case SERV_PROC_STOPED:
{
CHECK_SEVICE_HANDLER();
m_handler->OnServiceProcessStoped(event->GetSrcType(),
event->GetSrcIndex());
break;
}
default:
{
break;
}
}
break;
}
case SOCKET_CTRL:
{
CHECK_SEVICE_HANDLER();
SocketCtrlEvent* event = (SocketCtrlEvent*) ipc_event;
uint32 reportSocketChannelID = event->GetSocketChannelID();
if (m_has_dispatcher)
{
uint32 realID = event->GetSocketChannelID();
Channel* src_channel = ctx.GetChannel();
VirtualChannelHelper::GetVirtualSocketID(src_channel, realID,
reportSocketChannelID);
}
switch (event->GetSocketCtrlType())
{
case SOCKET_OPENED:
{
m_handler->OnSocketOpened(reportSocketChannelID);
break;
}
case SOCKET_CONNECTED:
{
if (NULL != event->GetAddress())
{
m_handler->OnSocketConnected(reportSocketChannelID,
*(event->GetAddress()));
}
else if (NULL != event->GetUnixAddress())
{
m_handler->OnSocketConnected(reportSocketChannelID,
*(event->GetUnixAddress()));
}
break;
}
case SOCKET_CLOSED:
{
m_handler->OnSocketClosed(reportSocketChannelID);
if (m_has_dispatcher)
{
VirtualChannelHelper::ClearTable(ctx.GetChannel(),
event->GetSocketChannelID());
}
break;
}
case SOCKET_CONNECT_FAILED:
{
if (NULL != event->GetAddress())
{
m_handler->OnSocketConnectFailed(reportSocketChannelID,
*(event->GetAddress()));
}
else if (NULL != event->GetUnixAddress())
{
m_handler->OnSocketConnectFailed(reportSocketChannelID,
*(event->GetUnixAddress()));
}
if (m_has_dispatcher)
{
VirtualChannelHelper::ClearTable(ctx.GetChannel(),
event->GetSocketChannelID());
}
break;
}
default:
{
ERROR_LOG(
"Unknown socket ctrl type %u", event->GetSocketCtrlType());
break;
}
}
break;
}
default:
{
ERROR_LOG("Unknown ipc event type %u", ipc_event->GetType());
break;
}
}
}
