void ListenerManager::handleListenerInsert(const idgs::actor::ActorMessagePtr& msg) { pb::InsertRequest* request = dynamic_cast<pb::InsertRequest*>(msg->getPayload().get()); const std::string& storeName = request->store_name(); std::shared_ptr<StoreConfigWrapper> config; auto code = idgs::util::singleton<DataStore>::getInstance().getStoreConfigWrappers().getStoreConfig(storeName, config); if (code != RC_SUCCESS) { LOG(ERROR) << "store " << storeName << " is not found."; return; } pb::StoreListenerInfo* listenerInfo = new pb::StoreListenerInfo; if (!msg->parseAttachment(STORE_ATTACH_LISTENER, listenerInfo)) { LOG(ERROR) << "store " << storeName << " is not found."; return; } uint32_t index = listenerInfo->listener_index(); auto& listeners = config->getStoreListener(); for (int32_t i = index; i < listeners.size(); ++ i) { StoreListener* listener = listeners[i]; auto code = listener->insert(msg); switch (code) { case LRC_CONTINUE: continue; case LRC_BREAK: case LRC_END: break; case LRC_ERROR: LOG(ERROR) << "error when execute listener " << listener->getName() << ", index " << i; break; } } delete listenerInfo; }
bool StoreListener::getAttachmentData(const idgs::actor::ActorMessagePtr& msg, idgs::actor::PbMessagePtr& key, idgs::actor::PbMessagePtr& value) { protobuf::MessageHelper& helper = idgs::util::singleton<protobuf::MessageHelper>::getInstance(); const string& keyType = storeConfig->getStoreConfig().key_type(); key = msg->getAttachement(STORE_ATTACH_KEY); if (!key) { key = helper.createMessage(keyType); if (!key) { LOG(ERROR) << "key type " << keyType << " is not registered."; return false; } if (!msg->parseAttachment(STORE_ATTACH_KEY, key.get())) { LOG(ERROR) << "invalid key with type " << keyType; return false; } } const string& valueType = storeConfig->getStoreConfig().value_type(); value = msg->getAttachement(STORE_ATTACH_VALUE); if (!value) { value = helper.createMessage(valueType); if (!key) { LOG(ERROR) << "value type " << valueType << " is not registered."; return false; } if (!msg->parseAttachment(STORE_ATTACH_VALUE, value.get())) { LOG(ERROR) << "invalid value with type " << valueType; return false; } } return true; }
void MigrationVerifyActor::handleVerifyRequest(const idgs::actor::ActorMessagePtr& msg) { pb::MigrationVerifyRequest* request = NULL; if (msg->getPayload()) { request = dynamic_cast<pb::MigrationVerifyRequest*>(msg->getPayload().get()); } if (request && request->has_schema_name() && request->has_store_name()) { auto datastore = idgs::store::idgs_store_module()->getDataStore(); auto store = datastore->getStore(request->schema_name(), request->store_name()); if (!store) { LOG(ERROR) << "store " << request->schema_name() << "." << request->store_name() << " is not found."; auto payload = std::make_shared<pb::MigrationVerifyResponse>(); payload->set_result_code(static_cast<int32_t>(RC_STORE_NOT_FOUND)); auto respMsg = msg->createResponse(); respMsg->setOperationName("VERIFY_RESPONSE"); respMsg->setPayload(payload); idgs::actor::sendMessage(respMsg); return; } if (store->getStoreConfig()->getStoreConfig().partition_type() != idgs::store::pb::PARTITION_TABLE) { LOG(ERROR) << "store " << request->schema_name() << "." << request->store_name() << " is not a partition store."; auto payload = std::make_shared<pb::MigrationVerifyResponse>(); payload->set_result_code(static_cast<int32_t>(RC_STORE_NOT_FOUND)); auto respMsg = msg->createResponse(); respMsg->setOperationName("VERIFY_RESPONSE"); respMsg->setPayload(payload); idgs::actor::sendMessage(respMsg); return; } } clientMsg = msg; auto& members = idgs_application()->getMemberManager()->getMemberTable(); auto it = members.begin(); for (; it != members.end(); ++ it) { if (it->isLocalStore() && (it->getState() == idgs::pb::MS_PREPARED || it->getState() == idgs::pb::MS_ACTIVE)) { auto reqMsg = createActorMessage(); reqMsg->setOperationName("LOCAL_VERIFY_REQUEST"); reqMsg->setDestMemberId(it->getId()); reqMsg->setDestActorId(actorId); reqMsg->setPayload(msg->getPayload()); idgs::actor::sendMessage(reqMsg); ++ memberSize; } } }
void PairStoreDelegateRddPartition::handleRddStoreListener(const idgs::actor::ActorMessagePtr& msg) { if (!active) { return; } PbMessagePtr key(rddLocal->getKeyTemplate()->New()); if (!msg->parseAttachment1(RE_PARTITION_KEY, key)) { LOG(ERROR)<< "RDD store listener key data is invalid"; return; } PbMessagePtr value(rddLocal->getValueTemplate()->New()); if (!msg->parseAttachment1(RE_PARTITION_VALUE, value)) { LOG(ERROR)<< "RDD store listener value data is invalid"; return; } transform(key, value); }
int32_t InnerUdtServer::sendMessage(idgs::actor::ActorMessagePtr& msg) { int32_t memberId = msg->getDestMemberId(); if(memberId < 0) { LOG(ERROR) << "Invalid member ID: " << memberId; return RC_ERROR; } auto q = getQueue(memberId); msg->freePbMemory(); q->push(msg); std::shared_ptr<InnerUdtConnection> conn = getConnection(memberId); if(conn) { conn->sendMessage(msg); } return 0; }
void PairStoreDelegateRddPartition::handleActionRequest(const idgs::actor::ActorMessagePtr& msg) { ActionRequest* request = dynamic_cast<ActionRequest*>(msg->getPayload().get()); DVLOG(3) << getPartitionName() << " run " << request->action_op_name() << " action"; shared_ptr<ActionResponse> response = make_shared<ActionResponse>(); response->set_action_id(request->action_id()); response->set_partition(partition); ActionMgr& actionMgr = *idgs_rdd_module()->getActionManager(); const ActionPtr& action = actionMgr.get(request->action_op_name()); RddResultCode code = RRC_SUCCESS; if (action.get()) { if (rddLocal->isReplicatedRdd() && partition > 0) { code = RRC_SUCCESS; } else { action::ActionContext ctx; if (ctx.initContext(&msg, &rddLocal->getKeyTemplate(), &rddLocal->getValueTemplate())) { code = action->action(&ctx, this); if (code == RRC_SUCCESS) { auto& result = ctx.getPartitionResult(); for (int32_t i = 0; i < result.size(); ++i) { response->add_action_value(result[i].toString()); } } } else { code = RRC_INVALID_ACTION_PARAM; } } } else { LOG(ERROR)<< "action " << request->action_op_name() << " is not registered."; code = RRC_ACTION_NOT_FOUND; } response->set_result_code(code); VLOG(2) << getPartitionName() << " process " << request->action_op_name() << " action done."; auto respMsg = msg->createResponse(); respMsg->setOperationName(RDD_ACTION_RESPONSE); respMsg->setPayload(response); idgs::actor::sendMessage(respMsg); }
void DataAggregatorActor::handleTruncateResponse(const idgs::actor::ActorMessagePtr& msg) { DVLOG_FIRST_N(2, 20) << "aggregator handle truncate store response"; idgs::store::pb::TruncateResponse* response = dynamic_cast<idgs::store::pb::TruncateResponse*>(msg->getPayload().get()); if (response->result_code() != idgs::store::pb::SRC_SUCCESS) { LOG(ERROR)<< "Truncate store error at member " << msg->getSourceMemberId(); resultCode = response->result_code(); } ++ responseCount; DVLOG_FIRST_N(2, 20) << "member " << msg->getSourceMemberId() << " response, left " << requestCount - responseCount << " members."; if (requestCount == responseCount) { DVLOG_FIRST_N(2, 20) << "all member responsed, send response to client."; shared_ptr<idgs::store::pb::TruncateResponse> globalResponse = make_shared<idgs::store::pb::TruncateResponse>(); globalResponse->set_result_code(resultCode); sendResponse(OP_TRUNCATE_RESPONSE, globalResponse); terminate(); } }
void StoreListener::sendBreakBranch(const idgs::actor::ActorMessagePtr& msg, const uint32_t& destMemberId) { ClusterFramework& cluster = singleton<ClusterFramework>::getInstance(); auto localMemberId = cluster.getMemberManager()->getLocalMemberId(); ActorMessagePtr message = msg->createRouteMessage(destMemberId, LISTENER_MANAGER); shared_ptr<StoreListenerInfo> listener = make_shared<StoreListenerInfo>(); listener->set_listener_index(listenerIndex); message->setAttachment(STORE_ATTACH_LISTENER, listener); idgs::actor::sendMessage(message); }
void MigrationVerifyActor::handleVerifyResponse(const idgs::actor::ActorMessagePtr& msg) { auto response = dynamic_cast<pb::MigrationVerifyResponse*>(msg->getPayload().get()); memberData.insert(std::pair<int32_t, pb::MemberMigrationData>(msg->getSourceMemberId(), response->member_data(0))); if (memberData.size() == memberSize) { auto payload = std::make_shared<pb::MigrationVerifyResponse>(); payload->set_result_code(static_cast<int32_t>(RC_SUCCESS)); auto it = memberData.begin(); for (; it != memberData.end(); ++ it) { payload->add_member_data()->CopyFrom(it->second); } auto respMsg = clientMsg->createResponse(); respMsg->setOperationName("VERIFY_RESPONSE"); respMsg->setPayload(payload); idgs::actor::sendMessage(respMsg); memberData.clear(); memberSize = 0; } }
void DataAggregatorActor::handleCountResponse(const idgs::actor::ActorMessagePtr& msg) { DVLOG_FIRST_N(2, 20) << "receive store size of member " << msg->getSourceActorId(); idgs::store::pb::SizeResponse* response = dynamic_cast<idgs::store::pb::SizeResponse*>(msg->getPayload().get()); if (response->result_code() != idgs::store::pb::SRC_SUCCESS) { // error DVLOG_FIRST_N(2, 20) << "error at member " << msg->getSourceActorId(); resultCode = response->result_code(); } // collect response from all members and calculate size and then response to client. shared_ptr<idgs::store::pb::SizeResponse> globalResponse = make_shared<idgs::store::pb::SizeResponse>(); dataSizeMap[msg->getSourceMemberId()] = response->size(); if (dataSizeMap.size() == requestCount) { DVLOG_FIRST_N(2, 20) << "aggregate done."; if (resultCode != idgs::store::pb::SRC_SUCCESS) { globalResponse->set_result_code(resultCode); } else { // calculate size size_t size = 0; map<int32_t, size_t>::iterator it = dataSizeMap.begin(); for (; it != dataSizeMap.end(); ++ it) { size += (* it).second; } globalResponse->set_result_code(idgs::store::pb::SRC_SUCCESS); globalResponse->set_size(size); } // response result DVLOG_FIRST_N(2, 20) << "response client."; sendResponse(OP_COUNT_RESPONSE, globalResponse); terminate(); } }
RddResultCode SumAction::action(const idgs::actor::ActorMessagePtr& msg, const BaseRddPartition* input, std::vector<PbVariant>& output) { ActionRequest* payload = dynamic_cast<ActionRequest*>(msg->getPayload().get()); if (!payload->has_expression()) { LOG(ERROR)<< "RDD \"" << input->getRddName() << " partition[" << input->getPartition() << "]" << "sum action error, lack sum's field"; return RRC_INVALID_ACTION_PARAM; } Expression* field_expr = NULL; auto rc = ExpressionFactory::build(&field_expr, payload->expression(), input->getKeyTemplate(), input->getValueTemplate()); if (idgs::RC_SUCCESS != rc) { LOG(ERROR)<< "RDD \"" << input->getRddName() << " partition[" << input->getPartition() << "]" << "parse sum's field expression error, caused by " << idgs::getErrorDescription(rc); return RRC_NOT_SUPPORT; } double sum = 0; if (payload->has_filter()) { /// with filter Expression* filter_expr = NULL; rc = ExpressionFactory::build(&filter_expr, payload->filter(), input->getKeyTemplate(), input->getValueTemplate()); if (idgs::RC_SUCCESS != rc) { LOG(ERROR)<< "RDD \"" << input->getRddName() << " partition[" << input->getPartition() << "]" << "parse filter expression error, caused by " << idgs::getErrorDescription(rc); return RRC_NOT_SUPPORT; } ExpressionContext ctx; input->foreach([filter_expr, field_expr, &sum, &ctx] (const PbMessagePtr& key, const PbMessagePtr& value) { ctx.setKeyValue(&key, &value); bool flag = (bool) filter_expr->evaluate(&ctx); /// filter expression's value is true or false if(flag) { /// meet filter condition PbVariant field_value = field_expr->evaluate(&ctx); sum += (double) field_value; } }); output.push_back(sum); } /// end with filter else { /// without filter ExpressionContext ctx; input->foreach([field_expr, &sum, &ctx] (const PbMessagePtr& key, const PbMessagePtr& value) { ctx.setKeyValue(&key, &value); PbVariant field_value = field_expr->evaluate(&ctx); sum += (double) field_value; }); output.push_back(sum); } /// end without filter return RRC_SUCCESS; }
RddResultCode SumAction::aggregate(const idgs::actor::ActorMessagePtr& actionRequest, idgs::actor::ActorMessagePtr& actionResponse, const vector<vector<string>>& input) { double sum = 0; for (size_t partition = 0; partition < input.size(); ++partition) { double pSize = 0; ResultCode code = sys::convert<double>(input[partition][0], pSize); if (code != RC_SUCCESS) { LOG(ERROR)<< "cannot convert \"" << input[partition][0] << "\" to a number."; return RRC_DATA_CONVERT_ERROR; } sum += pSize; } shared_ptr<SumActionResult> response(new SumActionResult); response->set_total(sum); actionResponse->setAttachment(ACTION_RESULT, response); return RRC_SUCCESS; }
void StoreMigrationSourceActor::handleMigrationRequest(const idgs::actor::ActorMessagePtr& msg) { // migration data if (it->hasNext()) { std::shared_ptr<pb::MigrationData> payload = std::make_shared<pb::MigrationData>(); size_t cnt = 0; auto mode = static_cast<protobuf::SerdesMode>(msg->getSerdesType()); while (it->hasNext() && cnt < batchSize) { auto data = payload->add_data(); data->set_operation_name(OP_INTERNAL_INSERT); protobuf::ProtoSerdesHelper::serialize(mode, it->key().get(), data->mutable_key()); protobuf::ProtoSerdesHelper::serialize(mode, it->value().get().get(), data->mutable_value()); ++ cnt; it->next(); } auto reqMsg = msg->createResponse(); reqMsg->setOperationName(MIGRATION_DATA); reqMsg->setPayload(payload); idgs::actor::postMessage(reqMsg); return; } // migration store cache if (!redoLog.empty()) { std::shared_ptr<pb::MigrationData> payload = std::make_shared<pb::MigrationData>(); auto mode = static_cast<protobuf::SerdesMode>(msg->getSerdesType()); size_t cnt = 0; while (!redoLog.empty() && cnt < batchSize) { MigrationRedoLog info; redoLog.try_pop(info); if (!info.key) { continue; } auto data = payload->add_data(); data->set_operation_name(info.opName); protobuf::ProtoSerdesHelper::serialize(mode, info.key.get(), data->mutable_key()); if (info.value) { protobuf::ProtoSerdesHelper::serialize(mode, info.value.get(), data->mutable_value()); } ++ cnt; } auto reqMsg = msg->createResponse(); reqMsg->setOperationName(MIGRATION_DATA); reqMsg->setPayload(payload); idgs::actor::postMessage(reqMsg); return; } auto& wrapper = pstore->getStoreConfig(); auto& schemaName = wrapper->getSchema(); auto& storeName = wrapper->getStoreConfig().name(); auto payload = std::make_shared<pb::StoreMigrationComplete>(); payload->set_schema_name(schemaName); payload->set_store_name(storeName); payload->set_data_size(map->size()); auto respMsg = msg->createResponse(); respMsg->setOperationName(STORE_MIGRATION_COMPLETE); respMsg->setPayload(payload); DVLOG(2) << "store " << schemaName << "." << storeName << " of partition " << partId << " migration complete on source member "; idgs::actor::sendMessage(respMsg); terminate(); }
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); }