InnerTcpConnection::~InnerTcpConnection() { function_footprint(); if (socket.is_open()) { socket.close(); } }
void MembershipTableMgr::handleNormalJoinEvent(const MemberWrapper& member) { function_footprint(); queue.push(member); if(joining) { DVLOG(0) << "$$$$$$$$$$$$$$$$$$$$$$$$$$"; DVLOG(0) << "$$$$$$$$$$$$$$$$$$$$$$$$$$"; DVLOG(0) << "current joining member queue size: " << queue.unsafe_size(); DVLOG(0) << "$$$$$$$$$$$$$$$$$$$$$$$$$$"; DVLOG(0) << "$$$$$$$$$$$$$$$$$$$$$$$$$$"; return; } while(!queue.empty()) { joining.store(true); MemberWrapper joined_member; queue.try_pop(joined_member); // leading generate whole member table and send to joining member. auto wholeMemberTable = std::make_shared<WholeMembershipTableEvent>(); genMembershipTable(*wholeMemberTable->mutable_table()); ResultCode rs; rs = multicastMemberMessage(WHOLE_MEMBERSHIP_TABLE, wholeMemberTable); if (rs != RC_SUCCESS) { LOG(ERROR)<< getErrorDescription(rs); return; } // leading send delta member to all members. auto deltaMember = std::make_shared<DeltaMemberEvent>(); deltaMember->set_position(findAddPos()); deltaMember->mutable_member()->CopyFrom(joined_member.getMember()); rs = multicastMemberMessage(DELTA_MEMBER_AND_JOIN_POSITION, deltaMember); if (rs != RC_SUCCESS) { LOG(ERROR)<< getErrorDescription(rs); return; } } }
void MembershipTableMgr::handleLeadingJoinEvent(const MemberWrapper& joined_member) { function_footprint(); auto leading = addMember(joined_member); // set local member index localIndex = leading->getId(); // joined leading->setStatus(JOINED); setMemberStatus(leading, JOINED); }
void MembershipTableMgr::handleJoinedEvent(const std::shared_ptr<ActorMessage>& actor_msg_ptr) { function_footprint(); Member* payload = dynamic_cast<Member*>(actor_msg_ptr->getPayload().get()); MemberWrapper joined_member; joined_member.setMember(*payload); if (joined_member.isLeading()) { // handle leading member join handleLeadingJoinEvent(joined_member); } else if (getLocalMember() && getLocalMember()->isLeading()) { // only leading handle normal member join handleNormalJoinEvent(joined_member); } }
void MembershipTableMgr::handleWholeTableEvent(const std::shared_ptr<ActorMessage>& actor_msg_ptr) { function_footprint(); if(!members.empty()) { return; } auto evt = dynamic_cast<WholeMembershipTableEvent*>(actor_msg_ptr->getPayload().get()); for (int i = 0, size = evt->table().member_size(); i < size; ++i) { MemberWrapper member; member.setMember(evt->table().member(i)); members.push_back(member); } LOG(INFO)<< toSimpleString(); }
void ActorDescriptorMgr::unRegisterModuleDescriptor(const std::string& module_name) { function_footprint(); auto itr = moduleDescriptors.find(module_name); if (itr == moduleDescriptors.end()) { return; } const std::map<std::string, idgs::actor::ActorDescriptorPtr>& map = itr->second->getActorDescriptors(); for (auto it = map.begin(); it != map.end(); ++it) { removeActorDescriptor(it->first); } moduleDescriptors.erase(module_name); }
void MembershipTableMgr::handleDeltaMemberEvent(const std::shared_ptr<ActorMessage>& msg) { function_footprint(); if(members.empty()){ return; } auto payload = dynamic_cast<DeltaMemberEvent*>(msg->getPayload().get()); MemberWrapper member; member.setMember(payload->member()); const uint32_t pos = payload->position(); auto joined_member = addMember(member, pos); if(isLocalMember(*joined_member)) { localIndex = pos; } setMemberStatus(joined_member, JOINED); }
void MembershipTableMgr::handleMemberStatusEvent(const std::shared_ptr<ActorMessage>& actor_msg_ptr) { function_footprint(); if (members.empty() || !getLocalMember()) { return; } auto payload = dynamic_cast<MemberStatusEvent*>(actor_msg_ptr->getPayload().get()); uint32_t pos = payload->member_id(); auto status = payload->status(); auto member = getMember(pos); if (!member) { return; } setMemberStatus(member, status); if(member->isPrepared()) { DVLOG(0) << toSimpleString(); joining.store(false); } }
int TpcModule::stop(void){ function_footprint(); LOG(INFO) << "stop module tpc_svc"; TransformerMgr& transformerMgr = idgs_rdd_module()->getTransformManager(); transformerMgr.remove(TPCH_Q6_TRANSFORMER); transformerMgr.remove(SSB_Q1_1_TRANSFORMER); ActionMgr& actionMgr = idgs_rdd_module()->getActionManager(); actionMgr.remove(TPCH_Q6_ACTION); actionMgr.remove(SSB_Q1_1_ACTION); DVLOG(3) << "begin unregister actor"; app->getActorframework()->unRegisterStatelessActor("linecrud_actor"); /// unregister actor DVLOG(3) << "end unregister actor"; DVLOG(3) << "begin unregister module descriptor"; ::idgs::util::singleton<idgs::actor::ActorDescriptorMgr>::getInstance().unRegisterModuleDescriptor(TPC_MODULE_DESCRIPTOR_NAME);/// unregister module descriptor DVLOG(3) << "end unregister module actor"; return RC_OK; }
int TpcModule::init(const char* config_path, idgs::Application* theApp){ function_footprint(); LOG(INFO) << "initialize module tpc_svc"; app = theApp; /// Create LineCrud Actor LineCrudActor* actor = new LineCrudActor; actor->init(); app->getActorframework()->Register(actor->getActorId(), actor); /// Register Actor /// Register module descriptor std::shared_ptr<ModuleDescriptorWrapper> module_descriptor(new ModuleDescriptorWrapper); module_descriptor->setName(TPC_MODULE_DESCRIPTOR_NAME); module_descriptor->setDescription("tpc module descriptor"); module_descriptor->addActorDescriptor(actor->getDescriptor()); ::idgs::util::singleton<idgs::actor::ActorDescriptorMgr>::getInstance().registerModuleDescriptor(module_descriptor->getName(), module_descriptor); TransformerMgr& transformerMgr = idgs_rdd_module()->getTransformManager(); TransformerPtr tpchQ6Transformer(new TpchQ6Transformer); transformerMgr.put(TPCH_Q6_TRANSFORMER, tpchQ6Transformer); TransformerPtr ssbQ1Transformer(new SsbQ1_1Transformer); transformerMgr.put(SSB_Q1_1_TRANSFORMER, ssbQ1Transformer); ActionMgr& actionMgr = idgs_rdd_module()->getActionManager(); ActionPtr tpchQ6Action(new TpchQ6Action); actionMgr.put(TPCH_Q6_ACTION, tpchQ6Action); ActionPtr ssbQ1Action(new SsbQ1_1Action); actionMgr.put(SSB_Q1_1_ACTION, ssbQ1Action); ActionPtr partition_count_action(new PartitionCountAction); actionMgr.put(PARTITION_COUNT_ACTION, partition_count_action); return RC_OK; }
idgs::ResultCode MembershipTableMgr::memberLeft(const std::vector<MemberWrapper*>& leftMembers) { function_footprint(); if (!getLocalMember()) { return RC_OK; } for(auto it = leftMembers.begin(); it != leftMembers.end(); ++it) { // local member exists in left member list, quit, do nothing if(getLocalMemberId() == (*it)->getId()) { ///left member itself, do nothing return RC_OK; } } MemberWrapper* leaveLeadingMember = NULL; for(auto it = leftMembers.begin(); it != leftMembers.end(); ++it) { // check if exists leading leave if ((*it)->isLeading()) { leaveLeadingMember = *it; break; } } if(leaveLeadingMember) { /// leading member leave MemberWrapper* newLeadingMember = selectLeading(leftMembers); if(!newLeadingMember) { // no member can be selected as leading,quit! return RC_OK; } DVLOG(0) << "Member " << *newLeadingMember << " is selected as leading"; newLeadingMember->setIsleading(true); leaveLeadingMember->setIsleading(false); for(auto it = leftMembers.begin(); it != leftMembers.end(); ++it) { setMemberStatus(*it, INACTIVE); } } /// end if else { /// normal member leave for(auto it = leftMembers.begin(); it != leftMembers.end(); ++it) { // local member exists in left member list, quit, do nothing setMemberStatus(*it, INACTIVE); } } LOG(INFO) << toSimpleString(); return RC_OK; }
ActorDescriptorMgr::~ActorDescriptorMgr() { function_footprint(); }
int TpcModule::start(void) { function_footprint(); return RC_OK; }
void InnerTcpConnection::realSendMessage() { function_footprint(); static uint32_t BATCH_TCP_MESSAGES = InnerTcpConnection::innerTcpServer->getTcpBatchSize(); InnerTcpConnectionState expectedState = READY; if(!state.compare_exchange_strong(expectedState, WRITING)) { VLOG(3) << "Connection is not ready: " << state.load(); return; } auto conn = shared_from_this(); if(unlikely(!socket.is_open())) { terminate(); return; } idgs::actor::ActorMessagePtr msg; std::vector<idgs::actor::ActorMessagePtr>* msgs = new std::vector<idgs::actor::ActorMessagePtr>(); msgs->reserve(BATCH_TCP_MESSAGES); std::vector<asio::const_buffer> outBuffers; outBuffers.reserve(BATCH_TCP_MESSAGES * 2 + 1); uint32_t sendLength; sendLength = 0; outBuffers.push_back(asio::buffer(reinterpret_cast<void*>(&sendLength), sizeof(sendLength))); while(getQueue().try_pop(msg)) { DVLOG(2) << "send message: " << msg->toString(); DVLOG(3) << "Send head size: " << sizeof(idgs::net::TcpHeader) << ", content: " << dumpBinaryBuffer(std::string((char*)msg->getRpcBuffer()->getHeader(), sizeof(idgs::net::TcpHeader))); DVLOG(3) << "Send body size: " << msg->getRpcBuffer()->getBodyLength() << ", content: " << dumpBinaryBuffer(std::string(msg->getRpcBuffer()->getBody(), msg->getRpcBuffer()->getBodyLength())); msgs->push_back(msg); outBuffers.push_back(asio::buffer(reinterpret_cast<void*>(msg->getRpcBuffer()->getHeader()), sizeof(idgs::net::TcpHeader))); outBuffers.push_back(asio::buffer(reinterpret_cast<void*>(msg->getRpcBuffer()->getBody()), msg->getRpcBuffer()->getBodyLength())); sendLength += sizeof(idgs::net::TcpHeader) + msg->getRpcBuffer()->getBodyLength(); // if(msgs->size() >= BATCH_TCP_MESSAGES || sendLength > (1024 * 50)) { if(msgs->size() >= BATCH_TCP_MESSAGES) { break; } } if(msgs->empty()) { DVLOG(2) << "No availabe message to send."; state.store(READY); delete msgs; return; } try { DVLOG(2) << "Send " << msgs->size() << " messages"; if(unlikely(!socket.is_open())) { // @fixme messagea lost delete msgs; terminate(); return; } asio::async_write( socket, outBuffers, asio::transfer_all(), [msgs, conn] (const asio::error_code& error, const std::size_t& bytes_transferred) { DVLOG(2) << "Sent " << msgs->size() << " messages"; conn->handleSendMessage(error); static NetworkStatistics* stats = InnerTcpConnection::innerTcpServer->network->getNetworkStatistics(); stats->innerTcpBytesSent.fetch_add(bytes_transferred); stats->innerTcpPacketSent.fetch_add(msgs->size()); delete msgs; } ); } catch (std::exception& e) { LOG(ERROR) << "send message error, exception: " << e.what() << ", messages: " << msgs->size(); delete msgs; terminate(); } catch (...) { LOG(ERROR) << "send message error " << ", messages: " << msgs->size(); catchUnknownException(); delete msgs; terminate(); } }
void MembershipTableMgr::onDestroy() { list<MemberEventListener*>().swap(this->listeners); function_footprint(); }
MembershipTableMgr::~MembershipTableMgr() { function_footprint(); }
ScheduledMessageService::~ScheduledMessageService() { function_footprint(); }
int client_run() { function_footprint(); try { ResultCode resultCode; auto client = getTcpClientPool().getTcpClient(resultCode); if (resultCode != RC_SUCCESS) { cerr << "Get Client error: " << getErrorDescription(resultCode) << endl; return RC_ERROR; } // step 1, 2 idgs::client::ClientActorMessagePtr clientActorMsg = make_shared<idgs::client::ClientActorMessage>(); clientActorMsg->setDestActorId(test_server_id); clientActorMsg->setDestMemberId(ANY_MEMBER); clientActorMsg->setSourceActorId("client_actor_id"); clientActorMsg->setSourceMemberId(CLIENT_MEMBER); clientActorMsg->setOperationName(start_work_operation); clientActorMsg->getRpcMessage()->set_payload("payload"); ResultCode errorCode; idgs::client::ClientActorMessagePtr response; errorCode = client->sendRecv(clientActorMsg, response); if (errorCode != RC_SUCCESS) { cerr << "execute the command error: " << getErrorDescription(errorCode) << endl; client->close(); return RC_ERROR; } DLOG(INFO) << "write message to server" << clientActorMsg->toString(); // step 3, 4 errorCode = client->receive(response); if (errorCode != RC_SUCCESS) { DLOG(INFO) << "get response error " << errorCode; return errorCode; } if (response->getOperationName() == sending_reponse_succ) { response->setOperationName(new_client_message_comes); response->setDestActorId(test_server_id); response->setSourceActorId("client_actor_id"); response->setDestMemberId(response->getSourceMemberId()); response->setChannel(TC_TCP); response->setSourceMemberId(CLIENT_MEMBER); ResultCode errorCode; idgs::client::ClientActorMessagePtr tcpResponse; errorCode = client->sendRecv(response, tcpResponse); DVLOG(2) << "after sendRecv"; if (errorCode != RC_SUCCESS) { cerr << "execute the command error: " << getErrorDescription(errorCode) << endl; client->close(); return RC_ERROR; } if (tcpResponse->getOperationName() == sending_total) { idgs::pb::Long l; tcpResponse->parsePayload(&l); test_server_count = l.value(); } ++count; } else { std::cerr <<"Test client error, receive error server response" ; return RC_ERROR; } //while (1) {} //socket.close(); } catch (std::exception& e) { std::cerr <<"Test client error" << e.what() << std::endl; return RC_ERROR; } return RC_SUCCESS; }