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;
}
