void IOHandler::Handle(const EventMessage& message) {
MI_LOG_TRACE(logger, "IOHandler::Handle " << message);
switch (message.type_id) {
case minotaur::MessageType::kIOEvent:
{
if (message.payload & event::EventType::EV_READ) {
HandleIOReadEvent(message);
}
if (message.payload & event::EventType::EV_WRITE) {
HandleIOWriteEvent(message);
}
if (message.payload & event::EventType::EV_CLOSE) {
HandleIOCloseEvent(message);
}
break;
}
case minotaur::MessageType::kIOMessageEvent:
return HandleIOMessageEvent(message);
case minotaur::MessageType::kIOActiveCloseEvent:
return HandleIOActiveCloseEvent(message);
default:
MI_LOG_ERROR(logger, "IOHanlder unknown message:" << message.type_id);
return;
}
}
void IOHandler::HandleIOMessageEvent(const EventMessage& message) {
MI_LOG_TRACE(logger, "HandleIOMessageEvent");
IODescriptor* descriptor =
IODescriptorFactory::GetIODescriptor(message.descriptor_id);
if (!descriptor) {
MI_LOG_DEBUG(logger, "HandleIOCloseEvent descriptor not found:"
<< message.descriptor_id);
HandleIOMessageFailure(message);
return;
}
Channel* channel = dynamic_cast<Channel*>(descriptor);
if (!channel) {
MI_LOG_ERROR(logger, "IOHandler::HandleIOMessageEvent descriptor is not channel");
HandleIOMessageFailure(message);
return;
}
ProtocolMessage* protocol_message = message.GetProtocolMessage();
if (0 != channel->EncodeMessage(protocol_message)) {
HandleIOMessageFailure(message);
return;
}
descriptor->OnWrite();
}
void IOHandler::HandleIOActiveCloseEvent(const EventMessage& message) {
MI_LOG_TRACE(logger, "HandleIOActiveCloseEvent");
IODescriptor* descriptor =
IODescriptorFactory::GetIODescriptor(message.descriptor_id);
if (!descriptor) {
MI_LOG_DEBUG(logger, "HandleIOActiveCloseEvent descriptor not found:"
<< message.descriptor_id);
return;
}
descriptor->OnActiveClose();
}
void IOHandler::HandleIOWriteEvent(const EventMessage& message) {
IODescriptor* descriptor =
IODescriptorFactory::GetIODescriptor(message.descriptor_id);
if (!descriptor) {
MI_LOG_DEBUG(logger, "HandleWriteEvent descriptor not found:"
<< message.descriptor_id);
return;
}
MI_LOG_TRACE(logger, "HandleIOWriteEvent:" << *descriptor);
descriptor->OnWrite();
}
void SyncClientChannel::OnDecodeMessage(ProtocolMessage* message) {
ProtocolMessage* keeper_message = sequence_keeper_.Fetch();
if (!keeper_message) {
MI_LOG_WARN(logger, "SyncClientChannel::OnDecodeMessage keeper not found, might timeout"
<< ", client_channel:" << GetDiagnositicInfo());
MessageFactory::Destroy(message);
BreakChannel();
return;
}
if (keeper_message->type_id == MessageType::kHeartBeatMessage
|| keeper_message->direction == ProtocolMessage::kOneway) {
MI_LOG_TRACE(logger, "SyncClientChannel::OnDecodeMessage heartbeat or oneway:" << *message);
MessageFactory::Destroy(message);
MessageFactory::Destroy(keeper_message);
TryFireMessage();
return;
}
message->status = ProtocolMessage::kStatusOK;
message->direction = ProtocolMessage::kIncomingResponse;
message->handler_id = keeper_message->handler_id;
message->sequence_id = keeper_message->sequence_id;
message->descriptor_id = GetDescriptorId();
message->payload.data = keeper_message->payload.data;
MI_LOG_TRACE(logger, "SyncClientChannel::OnDecodeMessage " << *message);
MessageFactory::Destroy(keeper_message);
if (!GetIOService()->GetServiceStage()->Send(message)) {
MI_LOG_WARN(logger, "SyncClientChannel::OnDecodeMessage Send message fail");
MessageFactory::Destroy(message);
return;
}
TryFireMessage();
}
