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::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);
}
}
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;
}
void MigrationVerifyActor::handleLocalVerifyRequest(const idgs::actor::ActorMessagePtr& msg) {
pb::MigrationVerifyRequest* request = NULL;
if (msg->getPayload()) {
request = dynamic_cast<pb::MigrationVerifyRequest*>(msg->getPayload().get());
}
auto datastore = idgs::store::idgs_store_module()->getDataStore();
std::vector<idgs::store::StorePtr> stores;
if (request && request->has_schema_name() && request->has_store_name()) {
auto store = datastore->getStore(request->schema_name(), request->store_name());
stores.push_back(store);
} else {
datastore->getStores(stores);
}
auto app = idgs_application();
auto cluster = app->getClusterFramework();
auto pcnt = cluster->getPartitionCount();
auto bkcnt = cluster->getClusterConfig()->max_replica_count() - 1;
auto local = cluster->getLocalMember()->getId();
auto partitionMgr = app->getPartitionManager();
auto payload = std::make_shared<pb::MigrationVerifyResponse>();
payload->set_result_code(static_cast<int32_t>(RC_SUCCESS));
auto memberData = payload->add_member_data();
memberData->set_member_id(local);
for (int32_t i = 0; i < stores.size(); ++ i) {
auto& store = stores.at(i);
auto& storeConfigWrapper = store->getStoreConfig();
if (storeConfigWrapper->getStoreConfig().partition_type() == idgs::store::pb::PARTITION_TABLE) {
auto pstore = dynamic_cast<idgs::store::PartitionedStore*>(store.get());
auto& schemaName = store->getStoreConfig()->getSchema();
auto& storeName = store->getStoreConfig()->getStoreConfig().name();
auto storeData = memberData->add_store_data();
storeData->set_schema_name(schemaName);
storeData->set_store_name(storeName);
for (int32_t p = 0; p < pcnt; ++ p) {
auto partition = partitionMgr->getPartition(p);
for (int32_t pos = 0; pos < bkcnt + 1; ++ pos) {
if (partition->getMemberId(pos) == local) {
auto partitionData = storeData->add_partition_data();
partitionData->set_partition_id(p);
partitionData->set_position(pos);
partitionData->set_member_id(local);
partitionData->set_size(pstore->dataSize(p));
VLOG(0) << schemaName << "." << storeName << " partition " << p << "(" << pos << ") data size " << partitionData->size() << " on member " << local;
std::shared_ptr<idgs::store::StoreMap> map;
pstore->snapshotStore(p, map);
auto it = map->iterator();
while (it->hasNext()) {
idgs::store::StoreOption ps;
storeConfigWrapper->calculatePartitionInfo(it->key(), &ps);
ps.memberId = partitionMgr->getPartition(ps.partitionId)->getMemberId(pos);
auto keyPartition = partitionData->add_key_partition();
keyPartition->set_key_partition_id(ps.partitionId);
keyPartition->set_key_member_id(ps.memberId);
it->next();
}
}
}
}
}
}
auto respMsg = msg->createResponse();
respMsg->setOperationName("VERIFY_RESPONSE");
respMsg->setPayload(payload);
idgs::actor::sendMessage(respMsg);
}
