int ConfigManager::LoadClientRoutersConfig(tinyxml2::XMLElement* element, ClientRoutersConfig* config) {
if (!element) {
MI_LOG_WARN(logger, "ConfigManager::LoadClientRoutersConfig no element");
return 0;
}
tinyxml2::XMLElement* router = element->FirstChildElement("router");
while (router) {
ClientRouterConfig router_config;
XML_LOAD_STRING(router, "name", router_config.name, -1);
XML_LOAD_STRING_DEFAULT(router, "router", router_config.router, "round");
tinyxml2::XMLElement* client = router->FirstChildElement("client");
while (client) {
ClientConfig client_config;
int tmp;
XML_LOAD_STRING(client, "address", client_config.address, -1);
XML_LOAD_INT(client, "timeout", &tmp, -1);
client_config.timeout = tmp;
XML_LOAD_INT_DEFAULT(client, "heartbeat", &tmp, 0);
client_config.heartbeat = tmp;
XML_LOAD_INT(client, "count", &tmp, -1);
client_config.count = tmp;
router_config.clients.push_back(client_config);
client = client->NextSiblingElement("client");
}
config->push_back(router_config);
router = router->NextSiblingElement("router");
}
return 0;
}
void IOHandler::HandleIOMessageFailure(const EventMessage& message) {
ProtocolMessage* protocol_message = message.GetProtocolMessage();
if (protocol_message->direction == ProtocolMessage::kOutgoingRequest) {
protocol_message->status = ProtocolMessage::kInternalFailure;
if (!GetIOService()->GetServiceStage()->Send(protocol_message)) {
MI_LOG_WARN(logger, "IOHandler::HandleIOMessageFailure send fail");
}
} else {
message.Destroy();
}
}
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();
}
int SyncClientChannel::EncodeMessage(ProtocolMessage* message) {
if (GetStatus() != kConnected) {
MI_LOG_DEBUG(logger, "SyncClientChannel::EncodeMessage ChannelBroken:" << GetStatus());
return -1;
}
if (0 != sequence_keeper_.Register(message)) {
MI_LOG_WARN(logger, "SyncClientChannel::EncodeMessage Register fail");
return -1;
}
TryFireMessage();
return 0;
}
void SyncClientChannel::TryFireMessage() {
while (true) {
ProtocolMessage* fire_message = sequence_keeper_.Fire();
if (!fire_message) {
return;
}
if (Protocol::kEncodeSuccess != GetProtocol()->Encode(&write_buffer_, fire_message)) {
MI_LOG_WARN(logger, "SyncClientChannel::TryFireMessage encode fail");
DoSendBack(fire_message, ProtocolMessage::kStatusEncodeFail);
sequence_keeper_.Fetch();
continue;
}
OnWrite();
break;
}
}
int ConfigManager::LoadServicesConfig(tinyxml2::XMLElement* element, ServicesConfig* config) {
if (!element) {
MI_LOG_WARN(logger, "ConfigManager::LoadServicesConfig no element");
return 0;
}
tinyxml2::XMLElement* service = element->FirstChildElement("service");
while (service) {
ServiceConfig service_config;
XML_LOAD_STRING(service, "address", service_config.address, -1);
XML_LOAD_STRING(service, "name", service_config.name, -1);
services_config_.push_back(service_config);
service = service->NextSiblingElement("service");
}
return 0;
}
