int KvMetaService::put_object(ReqKvMetaPutObjectMessage* req_put_object_msg) { int ret = TFS_SUCCESS; if (NULL == req_put_object_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::put_object fail, ret: %d", ret); } if (TFS_SUCCESS == ret) { //tbutil::Time start = tbutil::Time::now(); ObjectInfo object_info = req_put_object_msg->get_object_info(); const UserInfo &user_info = req_put_object_msg->get_user_info(); ret = meta_info_helper_.put_object(req_put_object_msg->get_bucket_name(), req_put_object_msg->get_file_name(), object_info, user_info); //tbutil::Time end = tbutil::Time::now(); //TBSYS_LOG(INFO, "put_object cost: %"PRI64_PREFIX"d", (int64_t)(end - start).toMilliSeconds()); } if (TFS_SUCCESS != ret) { ret = req_put_object_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "put object fail"); } else { ret = req_put_object_msg->reply(new StatusMessage(STATUS_MESSAGE_OK)); stat_mgr_.update_entry(tfs_kv_meta_stat_, "put_object", 1); } return ret; }
int KvMetaService::get_service(ReqKvMetaGetServiceMessage *req_get_service_msg) { int ret = TFS_SUCCESS; if (NULL == req_get_service_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::get_service fail, ret: %d", ret); } RspKvMetaGetServiceMessage *rsp = new RspKvMetaGetServiceMessage(); if (TFS_SUCCESS == ret) { const UserInfo &user_info = req_get_service_msg->get_user_info(); ret = meta_info_helper_.list_buckets(rsp->get_mutable_buckets_result(), user_info); } if (TFS_SUCCESS != ret) { ret = req_get_service_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "get service fail"); tbsys::gDelete(rsp); } else { ret = req_get_service_msg->reply(rsp); stat_mgr_.update_entry(tfs_kv_meta_stat_, "get_service", 1); } return ret; }
int KvMetaService::get_file_lifecycle(ReqKvMetaGetLifeCycleMessage *req_get_lifecycle_msg) { int ret = TFS_SUCCESS; if (NULL == req_get_lifecycle_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::get_lifecycle fail, ret: %d", ret); } if (TFS_SUCCESS == ret) { int32_t invalid_time_s = 0; ret = life_cycle_helper_.get_file_lifecycle(req_get_lifecycle_msg->get_file_type(), req_get_lifecycle_msg->get_file_name(), &invalid_time_s); if (TFS_SUCCESS == ret) { RspKvMetaGetLifeCycleMessage* rsp_get_lifecycle_msg = new(std::nothrow) RspKvMetaGetLifeCycleMessage(); assert(NULL != rsp_get_lifecycle_msg); rsp_get_lifecycle_msg->set_invalid_time_s(invalid_time_s); ret = req_get_lifecycle_msg->reply(rsp_get_lifecycle_msg); } else { ret = req_get_lifecycle_msg->reply_error_packet(TBSYS_LOG_LEVEL(ERROR), ret, "get_lifecycle fail"); } } return ret; }
/** handle packet*/ bool KvRootServer::handlePacketQueue(tbnet::Packet *packet, void *args) { bool bret = BaseService::handlePacketQueue(packet, args); if (bret) { int32_t pcode = packet->getPCode(); int32_t iret = LOCAL_PACKET == pcode ? TFS_ERROR : common::TFS_SUCCESS; if (TFS_SUCCESS == iret) { TBSYS_LOG(DEBUG, "PCODE: %d", pcode); common::BasePacket* msg = dynamic_cast<common::BasePacket*>(packet); switch (pcode) { case REQ_KV_RT_GET_TABLE_MESSAGE: iret = get_tables(msg); break; default: iret = EXIT_UNKNOWN_MSGTYPE; TBSYS_LOG(ERROR, "unknown msg type: %d", pcode); break; } if (common::TFS_SUCCESS != iret) { msg->reply_error_packet(TBSYS_LOG_LEVEL(ERROR), iret, "execute message failed, pcode: %d", pcode); } } } return bret; }
/** handle packet*/ bool ExpRootServer::handlePacketQueue(tbnet::Packet *packet, void *args) { bool bret = BaseService::handlePacketQueue(packet, args); if (bret) { int32_t pcode = packet->getPCode(); int32_t iret = LOCAL_PACKET == pcode ? TFS_ERROR : common::TFS_SUCCESS; if (TFS_SUCCESS == iret) { TBSYS_LOG(DEBUG, "PCODE: %d", pcode); common::BasePacket* msg = dynamic_cast<common::BasePacket*>(packet); switch (pcode) { case REQ_RT_FINISH_TASK_MESSAGE: iret = handle_finish_task(dynamic_cast<ReqFinishTaskFromEsMessage*>(msg)); break; case REQ_QUERY_TASK_MESSAGE: iret = query_task(dynamic_cast<ReqQueryTaskMessage*>(msg)); break; default: iret = EXIT_UNKNOWN_MSGTYPE; TBSYS_LOG(ERROR, "unknown msg type: %d", pcode); break; } if (common::TFS_SUCCESS != iret) { msg->reply_error_packet(TBSYS_LOG_LEVEL(ERROR), iret, "execute message failed, pcode: %d", pcode); } } } return bret; }
int KvMetaService::rm_file_lifecycle(ReqKvMetaRmLifeCycleMessage *req_rm_lifecycle_msg) { int ret = TFS_SUCCESS; if (NULL == req_rm_lifecycle_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::rm lifecycle fail, ret: %d", ret); } if (TFS_SUCCESS == ret) { ret = life_cycle_helper_.rm_life_cycle(req_rm_lifecycle_msg->get_file_type(), req_rm_lifecycle_msg->get_file_name()); } if (TFS_SUCCESS != ret) { ret = req_rm_lifecycle_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "rm life cycle fail"); } else { ret = req_rm_lifecycle_msg->reply(new StatusMessage(STATUS_MESSAGE_OK)); } return ret; }
// libeasy handle packet int ExpRootServer::handle(common::BasePacket* packet) { assert(NULL != packet); int ret = TFS_SUCCESS; int32_t pcode = packet->getPCode(); switch (pcode) { case REQ_RT_ES_KEEPALIVE_MESSAGE: ret = rt_es_keepalive(dynamic_cast<BasePacket*>(packet)); break; case REQ_RT_FINISH_TASK_MESSAGE: ret = handle_finish_task(dynamic_cast<ReqFinishTaskFromEsMessage*>(packet)); break; case REQ_QUERY_TASK_MESSAGE: ret = query_task(dynamic_cast<ReqQueryTaskMessage*>(packet)); break; default: ret = EXIT_UNKNOWN_MSGTYPE; TBSYS_LOG(ERROR, "unknown msg type: %d", pcode); break; } if (common::TFS_SUCCESS != ret) { packet->reply_error_packet(TBSYS_LOG_LEVEL(ERROR), ret, "execute message failed, pcode: %d", pcode); } return EASY_OK; }
int KvMetaService::del_object(ReqKvMetaDelObjectMessage* req_del_object_msg) { int ret = TFS_SUCCESS; if (NULL == req_del_object_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::del_object fail, ret: %d", ret); } ObjectInfo object_info; bool still_have = false; if (TFS_SUCCESS == ret) { ret = meta_info_helper_.del_object(req_del_object_msg->get_bucket_name(), req_del_object_msg->get_file_name(), req_del_object_msg->get_user_info(), &object_info, &still_have); } if (TFS_SUCCESS == ret) { RspKvMetaDelObjectMessage* rsp_del_object_msg = new(std::nothrow) RspKvMetaDelObjectMessage(); assert(NULL != rsp_del_object_msg); rsp_del_object_msg->set_object_info(object_info); rsp_del_object_msg->set_still_have(still_have); req_del_object_msg->reply(rsp_del_object_msg); stat_mgr_.update_entry(tfs_kv_meta_stat_, "del_object", 1); } else { ret = req_del_object_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "del object fail"); } return ret; }
int KvMetaService::set_file_lifecycle(ReqKvMetaSetLifeCycleMessage *req_set_lifecycle_msg) { int ret = TFS_SUCCESS; if (NULL == req_set_lifecycle_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::set life cycle fail, ret: %d", ret); } TBSYS_LOG(DEBUG, "into set_file_lifecycle: %d, %s, %d, %s", req_set_lifecycle_msg->get_file_type(), req_set_lifecycle_msg->get_file_name().c_str(), req_set_lifecycle_msg->get_invalid_time_s(), req_set_lifecycle_msg->get_app_key().c_str()); if (TFS_SUCCESS == ret) { ret = life_cycle_helper_.set_file_lifecycle(req_set_lifecycle_msg->get_file_type(), req_set_lifecycle_msg->get_file_name(), req_set_lifecycle_msg->get_invalid_time_s(), req_set_lifecycle_msg->get_app_key()); TBSYS_LOG(DEBUG, "KvMetaService::set life cycle ret: %d", ret); } if (TFS_SUCCESS != ret) { ret = req_set_lifecycle_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "set life cycle fail"); } else { ret = req_set_lifecycle_msg->reply(new StatusMessage(STATUS_MESSAGE_OK)); } return ret; }
int KvMetaService::del_bucket(ReqKvMetaDelBucketMessage* del_bucket_msg) { int ret = TFS_SUCCESS; if (NULL == del_bucket_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::del_bucket fail, ret: %d", ret); } if (TFS_SUCCESS == ret) { const UserInfo &user_info = del_bucket_msg->get_user_info(); ret = meta_info_helper_.del_bucket(del_bucket_msg->get_bucket_name(), user_info); } if (TFS_SUCCESS != ret) { ret = del_bucket_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "del bucket fail"); } else { ret = del_bucket_msg->reply(new StatusMessage(STATUS_MESSAGE_OK)); stat_mgr_.update_entry(tfs_kv_meta_stat_, "del_bucket", 1); } //stat_info_helper_.put_bucket() return ret; }
int KvMetaService::head_bucket(ReqKvMetaHeadBucketMessage* head_bucket_msg) { int ret = TFS_SUCCESS; if (NULL == head_bucket_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::head_bucket fail, ret: %d", ret); } RspKvMetaHeadBucketMessage *rsp = new RspKvMetaHeadBucketMessage(); if (TFS_SUCCESS == ret) { ret = meta_info_helper_.head_bucket(head_bucket_msg->get_bucket_name(), head_bucket_msg->get_user_info(), rsp->get_mutable_bucket_meta_info()); } if (TFS_SUCCESS != ret) { ret = head_bucket_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "head bucket fail"); tbsys::gDelete(rsp); } else { ret = head_bucket_msg->reply(rsp); stat_mgr_.update_entry(tfs_kv_meta_stat_, "head_bucket", 1); } //stat_info_helper_.put_bucket() return ret; }
int KvMetaService::put_bucket(ReqKvMetaPutBucketMessage* put_bucket_msg) { int ret = TFS_SUCCESS; if (NULL == put_bucket_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::put_bucket fail, ret: %d", ret); } if (TFS_SUCCESS == ret) { const CANNED_ACL acl = (common::CANNED_ACL)(put_bucket_msg->get_canned_acl()); BucketMetaInfo *bucket_meta_info = put_bucket_msg->get_mutable_bucket_meta_info(); const UserInfo &user_info = put_bucket_msg->get_user_info(); ret = meta_info_helper_.put_bucket(put_bucket_msg->get_bucket_name(), *bucket_meta_info, user_info, acl); } if (TFS_SUCCESS != ret) { ret = put_bucket_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "put bucket fail"); } else { ret = put_bucket_msg->reply(new StatusMessage(STATUS_MESSAGE_OK)); stat_mgr_.update_entry(tfs_kv_meta_stat_, "put_bucket", 1); } //stat_info_helper_.put_bucket() return ret; }
int KvMetaService::del_object_user_metadata(ReqKvMetaDelObjectUserMetadataMessage* req_del_object_tag_msg) { int ret = TFS_SUCCESS; if (NULL == req_del_object_tag_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::del_object_user_metadata fail, ret: %d", ret); } if (TFS_SUCCESS == ret) { ret = meta_info_helper_.del_object_user_metadata(req_del_object_tag_msg->get_bucket_name(), req_del_object_tag_msg->get_object_name(), req_del_object_tag_msg->get_user_info()); } if (TFS_SUCCESS != ret) { ret = req_del_object_tag_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "del object tag fail"); } else { ret = req_del_object_tag_msg->reply(new StatusMessage(STATUS_MESSAGE_OK)); stat_mgr_.update_entry(tfs_kv_meta_stat_, "del_object tag ", 1); } return ret; }
bool ExpireService::handlePacketQueue(tbnet::Packet *packet, void *args) { int ret = true; BasePacket* base_packet = NULL; if (!(ret = BaseService::handlePacketQueue(packet, args))) { TBSYS_LOG(ERROR, "call BaseService::handlePacketQueue fail. ret: %d", ret); } else { base_packet = dynamic_cast<BasePacket*>(packet); switch (base_packet->getPCode()) { case REQ_EXPIRE_CLEAN_TASK_MESSAGE: ret = do_clean_task(dynamic_cast<ReqCleanTaskFromRtsMessage*>(base_packet)); break; default: ret = EXIT_UNKNOWN_MSGTYPE; TBSYS_LOG(ERROR, "unknown msg type: %d", base_packet->getPCode()); break; } } if (ret != TFS_SUCCESS && NULL != base_packet) { base_packet->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "execute message failed"); } // always return true. packet will be freed by caller return true; }
int KvMetaService::get_bucket_acl(ReqKvMetaGetBucketAclMessage* get_bucket_acl_msg) { int ret = TFS_SUCCESS; if (NULL == get_bucket_acl_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::get_bucket_acl fail, ret: %d", ret); } RspKvMetaGetBucketAclMessage* rsp = new RspKvMetaGetBucketAclMessage(); if (TFS_SUCCESS == ret) { const string& bucket_name = get_bucket_acl_msg->get_bucket_name(); const UserInfo &user_info = get_bucket_acl_msg->get_user_info(); int64_t owner_id; rsp->set_bucket_name(bucket_name); ret = meta_info_helper_.get_bucket_acl(bucket_name, rsp->get_mutable_bucket_acl_map(), user_info, owner_id); rsp->set_owner_id(owner_id); } if (TFS_SUCCESS != ret) { ret = get_bucket_acl_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "get bucket acl fail"); tbsys::gDelete(rsp); } else { ret = get_bucket_acl_msg->reply(rsp); //stat_mgr_.update_entry(tfs_kv_meta_stat_, "get_bucket_tag", 1); } //stat_info_helper_.get_bucket_tag() return ret; }
/** handle single packet */ tbnet::IPacketHandler::HPRetCode KvRootServer::handlePacket(tbnet::Connection *connection, tbnet::Packet *packet) { tbnet::IPacketHandler::HPRetCode hret = tbnet::IPacketHandler::FREE_CHANNEL; bool bret = NULL != connection && NULL != packet; if (bret) { TBSYS_LOG(DEBUG, "receive pcode : %d", packet->getPCode()); if (!packet->isRegularPacket()) { bret = false; TBSYS_LOG(WARN, "control packet, pcode: %d", dynamic_cast<tbnet::ControlPacket*>(packet)->getCommand()); } if (bret) { BasePacket* bpacket = dynamic_cast<BasePacket*>(packet); bpacket->set_connection(connection); bpacket->setExpireTime(MAX_RESPONSE_TIME); bpacket->set_direction(static_cast<DirectionStatus>(bpacket->get_direction()|DIRECTION_RECEIVE)); if (bpacket->is_enable_dump()) { bpacket->dump(); } int32_t pcode = bpacket->getPCode(); int32_t iret = common::TFS_SUCCESS; if (common::TFS_SUCCESS == iret) { hret = tbnet::IPacketHandler::KEEP_CHANNEL; switch (pcode) { case REQ_KV_RT_MS_KEEPALIVE_MESSAGE: ms_rs_heartbeat_workers_.push(bpacket, 0/* no limit */, false/* no block */); break; default: if (!main_workers_.push(bpacket, work_queue_size_)) { bpacket->reply_error_packet(TBSYS_LOG_LEVEL(ERROR),STATUS_MESSAGE_ERROR, "%s, task message beyond max queue size, discard", get_ip_addr()); bpacket->free(); } break; } } else { bpacket->free(); TBSYS_LOG(WARN, "the msg: %d will be ignored", pcode); } } } return hret; }
void SyncManager::do_sync_(const int32_t timeout_ms, const bool print) { create_msg_ref(SyncFileEntryMessage, req_msg); common::ArrayHelper<SyncFileEntry> helper(MAX_SYNC_FILE_ENTRY_COUNT, req_msg.get_entry()); mutex_.lock(); QUEUE_CONST_ITER iter = queue_.begin(); while (iter != queue_.end() && helper.get_array_index() < MAX_SYNC_FILE_ENTRY_COUNT) { helper.push_back((*iter)); } mutex_.unlock(); if (!helper.empty()) { NewClient* client = NewClientManager::get_instance().create_client(); int32_t ret = (NULL != client) ? TFS_SUCCESS : EXIT_CLIENT_MANAGER_CREATE_CLIENT_ERROR; if (TFS_SUCCESS == ret) { tbnet::Packet* result = NULL; ret = send_msg_to_server(dest_addr_, client, &req_msg, result, timeout_ms); if (TFS_SUCCESS == ret) { ret = RSP_SYNC_FILE_ENTRY_MESSAGE == result->getPCode() ? TFS_SUCCESS : EXIT_SEND_SYNC_FILE_ENTRY_MSG_ERROR; } } NewClientManager::get_instance().destroy_client(client); if (TFS_SUCCESS == ret) { tbutil::Mutex::Lock lock(mutex_); queue_size_ -= helper.get_array_index(); for (int64_t index = 0; index < helper.get_array_index(); ++index) { queue_.pop_front(); } } if (TFS_SUCCESS != ret && print) { mutex_.lock(); queue_size_ -= helper.get_array_index(); mutex_.unlock(); for (int64_t index = 0; index < helper.get_array_index(); ++index) { SyncFileEntry* entry = helper.at(index); entry->dump(TBSYS_LOG_LEVEL(INFO), "sync file entry failed"); } } } }
int KvMetaService::get_bucket(ReqKvMetaGetBucketMessage* get_bucket_msg) { int ret = TFS_SUCCESS; if (NULL == get_bucket_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::get_bucket fail, ret: %d", ret); } RspKvMetaGetBucketMessage* rsp = new RspKvMetaGetBucketMessage(); if (TFS_SUCCESS == ret) { const string& bucket_name = get_bucket_msg->get_bucket_name(); const string& prefix = get_bucket_msg->get_prefix(); const string& start_key = get_bucket_msg->get_start_key(); char delimiter = get_bucket_msg->get_delimiter(); int32_t limit = get_bucket_msg->get_mutable_limit(); ret = meta_info_helper_.get_bucket(bucket_name, prefix, start_key, delimiter, &limit, get_bucket_msg->get_user_info(), rsp->get_mutable_v_object_meta_info(), rsp->get_mutable_v_object_name(), rsp->get_mutable_s_common_prefix(), rsp->get_mutable_truncated()); if (TFS_SUCCESS == ret) { rsp->set_bucket_name(bucket_name); rsp->set_prefix(prefix); rsp->set_start_key(start_key); rsp->set_delimiter(delimiter); rsp->set_limit(limit); } } if (TFS_SUCCESS != ret) { ret = get_bucket_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "get bucket fail"); tbsys::gDelete(rsp); } else { ret = get_bucket_msg->reply(rsp); stat_mgr_.update_entry(tfs_kv_meta_stat_, "get_bucket", 1); } //stat_info_helper_.get_bucket() return ret; }
int KvMetaService::get_object(ReqKvMetaGetObjectMessage* req_get_object_msg) { int ret = TFS_SUCCESS; if (NULL == req_get_object_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "KvMetaService::get_object fail, ret: %d", ret); } if (TFS_SUCCESS == ret) { ObjectInfo object_info; bool still_have = false; ret = meta_info_helper_.get_object(req_get_object_msg->get_bucket_name(), req_get_object_msg->get_file_name(), req_get_object_msg->get_offset(), req_get_object_msg->get_length(), req_get_object_msg->get_user_info(), &object_info, &still_have); TBSYS_LOG(DEBUG, "get object, bucket_name: %s , object_name: %s, still_have: %d owner_id: %"PRI64_PREFIX"d ret: %d", req_get_object_msg->get_bucket_name().c_str(), req_get_object_msg->get_file_name().c_str(), still_have, object_info.meta_info_.owner_id_, ret); if (TFS_SUCCESS == ret) { RspKvMetaGetObjectMessage* rsp_get_object_msg = new(std::nothrow) RspKvMetaGetObjectMessage(); assert(NULL != rsp_get_object_msg); rsp_get_object_msg->set_object_info(object_info); rsp_get_object_msg->set_still_have(still_have); object_info.dump(); ret = req_get_object_msg->reply(rsp_get_object_msg); stat_mgr_.update_entry(tfs_kv_meta_stat_, "get_object", 1); } else { ret = req_get_object_msg->reply_error_packet(TBSYS_LOG_LEVEL(ERROR), ret, "get object fail"); } } return ret; }
int32_t ExpRootServer::handle_finish_task(ReqFinishTaskFromEsMessage *msg) { int32_t iret = NULL != msg ? TFS_SUCCESS : TFS_ERROR; if (TFS_SUCCESS == iret) { uint64_t es_id = msg->get_es_id(); const ExpireTaskInfo task = msg->get_task(); iret = handle_task_helper_.handle_finish_task(es_id, task); if (TFS_SUCCESS == iret) { iret = msg->reply(new StatusMessage(STATUS_MESSAGE_OK)); } else { iret = msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), iret, "handle finish task fail"); } } return iret; }
int ExpireService::handle(common::BasePacket* packet) { assert(NULL != packet); int ret = TFS_SUCCESS; int32_t pcode = packet->getPCode(); switch (pcode) { case REQ_EXPIRE_CLEAN_TASK_MESSAGE: ret = do_clean_task(dynamic_cast<ReqCleanTaskFromRtsMessage*>(packet)); break; default: ret = EXIT_UNKNOWN_MSGTYPE; TBSYS_LOG(ERROR, "unknown msg type: %d", packet->getPCode()); break; } if (ret != TFS_SUCCESS) { packet->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "execute message failed"); } return EASY_OK; }
int32_t ExpRootServer::query_task(ReqQueryTaskMessage *msg) { int32_t iret = NULL != msg ? TFS_SUCCESS : TFS_ERROR; if (TFS_SUCCESS == iret) { RspQueryTaskMessage* rsp = new(std::nothrow) RspQueryTaskMessage(); assert(NULL != rsp); uint64_t es_id = msg->get_es_id(); std::vector<common::ServerExpireTask>* p_running_tasks = rsp->get_mutable_running_tasks_info(); iret = handle_task_helper_.query_task(es_id, p_running_tasks); if (TFS_SUCCESS == iret) { iret = msg->reply(rsp); } else { iret = msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), iret, "query task fail"); tbsys::gDelete(rsp); } } return iret; }
bool KvMetaService::handlePacketQueue(tbnet::Packet *packet, void *args) { int ret = true; BasePacket* base_packet = NULL; if (!(ret = BaseService::handlePacketQueue(packet, args))) { TBSYS_LOG(ERROR, "call BaseService::handlePacketQueue fail. ret: %d", ret); } else { base_packet = dynamic_cast<BasePacket*>(packet); switch (base_packet->getPCode()) { case REQ_KVMETA_GET_SERVICE_MESSAGE: ret = get_service(dynamic_cast<ReqKvMetaGetServiceMessage*>(base_packet)); break; case REQ_KVMETA_PUT_OBJECT_MESSAGE: ret = put_object(dynamic_cast<ReqKvMetaPutObjectMessage*>(base_packet)); break; case REQ_KVMETA_GET_OBJECT_MESSAGE: ret = get_object(dynamic_cast<ReqKvMetaGetObjectMessage*>(base_packet)); break; case REQ_KVMETA_DEL_OBJECT_MESSAGE: ret = del_object(dynamic_cast<ReqKvMetaDelObjectMessage*>(base_packet)); break; case REQ_KVMETA_HEAD_OBJECT_MESSAGE: ret = head_object(dynamic_cast<ReqKvMetaHeadObjectMessage*>(base_packet)); break; case REQ_KVMETA_PUT_OBJECT_USER_METADATA_MESSAGE: ret = put_object_user_metadata(dynamic_cast<ReqKvMetaPutObjectUserMetadataMessage*>(base_packet)); break; case REQ_KVMETA_DEL_OBJECT_USER_METADATA_MESSAGE: ret = del_object_user_metadata(dynamic_cast<ReqKvMetaDelObjectUserMetadataMessage*>(base_packet)); break; case REQ_KVMETA_PUT_BUCKET_MESSAGE: ret = put_bucket(dynamic_cast<ReqKvMetaPutBucketMessage*>(base_packet)); break; case REQ_KVMETA_GET_BUCKET_MESSAGE: ret = get_bucket(dynamic_cast<ReqKvMetaGetBucketMessage*>(base_packet)); break; case REQ_KVMETA_DEL_BUCKET_MESSAGE: ret = del_bucket(dynamic_cast<ReqKvMetaDelBucketMessage*>(base_packet)); break; case REQ_KVMETA_HEAD_BUCKET_MESSAGE: ret = head_bucket(dynamic_cast<ReqKvMetaHeadBucketMessage*>(base_packet)); break; case REQ_KVMETA_SET_LIFE_CYCLE_MESSAGE: ret = set_file_lifecycle(dynamic_cast<ReqKvMetaSetLifeCycleMessage*>(base_packet)); break; case REQ_KVMETA_GET_LIFE_CYCLE_MESSAGE: ret = get_file_lifecycle(dynamic_cast<ReqKvMetaGetLifeCycleMessage*>(base_packet)); break; case REQ_KVMETA_RM_LIFE_CYCLE_MESSAGE: ret = rm_file_lifecycle(dynamic_cast<ReqKvMetaRmLifeCycleMessage*>(base_packet)); break; case REQ_KVMETA_PUT_BUCKET_ACL_MESSAGE: ret = put_bucket_acl(dynamic_cast<ReqKvMetaPutBucketAclMessage*>(base_packet)); break; case REQ_KVMETA_GET_BUCKET_ACL_MESSAGE: ret = get_bucket_acl(dynamic_cast<ReqKvMetaGetBucketAclMessage*>(base_packet)); break; default: ret = EXIT_UNKNOWN_MSGTYPE; TBSYS_LOG(ERROR, "unknown msg type: %d", base_packet->getPCode()); break; } } if (ret != TFS_SUCCESS && NULL != base_packet) { base_packet->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "execute message failed"); } // always return true. packet will be freed by caller return true; }
int KvMetaService::handle(common::BasePacket* packet) { assert(NULL != packet); int ret = TFS_SUCCESS; int32_t pcode = packet->getPCode(); if (!is_inited_) { ret = EXIT_NOT_INIT_ERROR; } else { switch (pcode) { case REQ_KVMETA_GET_SERVICE_MESSAGE: ret = get_service(dynamic_cast<ReqKvMetaGetServiceMessage*>(packet)); break; case REQ_KVMETA_PUT_OBJECT_MESSAGE: ret = put_object(dynamic_cast<ReqKvMetaPutObjectMessage*>(packet)); break; case REQ_KVMETA_GET_OBJECT_MESSAGE: ret = get_object(dynamic_cast<ReqKvMetaGetObjectMessage*>(packet)); break; case REQ_KVMETA_DEL_OBJECT_MESSAGE: ret = del_object(dynamic_cast<ReqKvMetaDelObjectMessage*>(packet)); break; case REQ_KVMETA_HEAD_OBJECT_MESSAGE: ret = head_object(dynamic_cast<ReqKvMetaHeadObjectMessage*>(packet)); break; case REQ_KVMETA_PUT_OBJECT_USER_METADATA_MESSAGE: ret = put_object_user_metadata(dynamic_cast<ReqKvMetaPutObjectUserMetadataMessage*>(packet)); break; case REQ_KVMETA_DEL_OBJECT_USER_METADATA_MESSAGE: ret = del_object_user_metadata(dynamic_cast<ReqKvMetaDelObjectUserMetadataMessage*>(packet)); break; case REQ_KVMETA_PUT_BUCKET_MESSAGE: ret = put_bucket(dynamic_cast<ReqKvMetaPutBucketMessage*>(packet)); break; case REQ_KVMETA_GET_BUCKET_MESSAGE: ret = get_bucket(dynamic_cast<ReqKvMetaGetBucketMessage*>(packet)); break; case REQ_KVMETA_DEL_BUCKET_MESSAGE: ret = del_bucket(dynamic_cast<ReqKvMetaDelBucketMessage*>(packet)); break; case REQ_KVMETA_HEAD_BUCKET_MESSAGE: ret = head_bucket(dynamic_cast<ReqKvMetaHeadBucketMessage*>(packet)); break; case REQ_KVMETA_SET_LIFE_CYCLE_MESSAGE: ret = set_file_lifecycle(dynamic_cast<ReqKvMetaSetLifeCycleMessage*>(packet)); break; case REQ_KVMETA_GET_LIFE_CYCLE_MESSAGE: ret = get_file_lifecycle(dynamic_cast<ReqKvMetaGetLifeCycleMessage*>(packet)); break; case REQ_KVMETA_RM_LIFE_CYCLE_MESSAGE: ret = rm_file_lifecycle(dynamic_cast<ReqKvMetaRmLifeCycleMessage*>(packet)); break; case REQ_KVMETA_PUT_BUCKET_ACL_MESSAGE: ret = put_bucket_acl(dynamic_cast<ReqKvMetaPutBucketAclMessage*>(packet)); break; case REQ_KVMETA_GET_BUCKET_ACL_MESSAGE: ret = get_bucket_acl(dynamic_cast<ReqKvMetaGetBucketAclMessage*>(packet)); break; default: ret = EXIT_UNKNOWN_MSGTYPE; TBSYS_LOG(ERROR, "unknown msg type: %d", pcode); break; } } if (ret != TFS_SUCCESS) { packet->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "execute message failed"); } return EASY_OK; }
int ExpireService::do_clean_task(ReqCleanTaskFromRtsMessage* req_clean_task_msg) { //we will give a resp to rootserver first, //then execute the clean task and report task result to rootserver int ret = TFS_SUCCESS; int rspret = TFS_SUCCESS; if (NULL == req_clean_task_msg) { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "ExpireService::req_clean_task fail, ret: %d", ret); } ExpireTaskInfo::ExpireTaskType task_type; int32_t total_es; int32_t num_es; int32_t note_interval; int32_t task_time; ExpireTaskInfo task; if (TFS_SUCCESS == ret) { task = req_clean_task_msg->get_task(); task_type = task.type_; total_es = task.alive_total_; num_es = task.assign_no_; note_interval = task.note_interval_; task_time = task.spec_time_; if ((task_type == ExpireTaskInfo::TASK_TYPE_DELETE) && (total_es > 0 && num_es >= 0 && note_interval >= 0) && (num_es < total_es) && task_time > 0) { TBSYS_LOG(DEBUG, "%d, %d, %d, %d, %d",task_type, total_es, num_es, note_interval, task_time); ret = TFS_SUCCESS; } else { ret = EXIT_INVALID_ARGU; TBSYS_LOG(ERROR, "ExpireService::req_clean_task fail EXIT_INVALID_ARGU, ret: %d", ret); } } if (TFS_SUCCESS != ret) { rspret = req_clean_task_msg->reply_error_packet(TBSYS_LOG_LEVEL(INFO), ret, "clean is not start"); } else { rspret = req_clean_task_msg->reply(new StatusMessage(STATUS_MESSAGE_OK)); } if (TFS_SUCCESS == ret) { //tbutil::Time start = tbutil::Time::now(); if (ExpireTaskInfo::TASK_TYPE_DELETE == task_type) { ret = clean_task_helper_.do_clean_task(local_ipport_id_, total_es, num_es, note_interval, task_time); } //tbutil::Time end = tbutil::Time::now(); //TBSYS_LOG(INFO, "put_object cost: %"PRI64_PREFIX"d", (int64_t)(end - start).toMilliSeconds()); int32_t retry_count = 0; int32_t iret = TFS_SUCCESS; do { // send finish msg create_msg_ref(ReqFinishTaskFromEsMessage, req_finish_task_msg); //req_finish_task_msg.set_reserve(0); req_finish_task_msg.set_es_id(local_ipport_id_); req_finish_task_msg.set_task(task); NewClient* client = NULL; tbnet::Packet* response = NULL; ++retry_count; client = NewClientManager::get_instance().create_client(); iret = send_msg_to_server(expireroot_ipport_id_, client, &req_finish_task_msg, response, MAX_TIMEOUT_MS); if (TFS_SUCCESS != iret) { TBSYS_LOG(ERROR, "EXIT_NETWORK_ERROR ret: %d",iret); iret = EXIT_NETWORK_ERROR; } else if (STATUS_MESSAGE == response->getPCode()) { StatusMessage* resp_status_msg = dynamic_cast<StatusMessage*>(response); if ((iret = resp_status_msg->get_status()) != STATUS_MESSAGE_OK) { TBSYS_LOG(ERROR, "es root return error, ret: %d", ret); } } else { ret = EXIT_UNKNOWN_MSGTYPE; TBSYS_LOG(ERROR, "rsp fail," "server_addr: %s," "ret: %d, msg type: %d", tbsys::CNetUtil::addrToString(expireroot_ipport_id_).c_str(), ret, response->getPCode()); } NewClientManager::get_instance().destroy_client(client); }while ((retry_count < FINISH_TASK_MAX_RETRY_COUNT) && (TFS_SUCCESS != iret)); } return ret; }