static int8_t get_server_running_status(const uint64_t ip_port, const int32_t switch_flag)
{
int8_t status = -1;
int32_t count = 0;
NewClient* client = NULL;
const int64_t TIMEOUT = 500;
do
{
++count;
client = NewClientManager::get_instance().create_client();
if (NULL != client)
{
create_msg_ref(HeartBeatAndNSHeartMessage, heart_msg);
heart_msg.set_ns_switch_flag_and_status(switch_flag, 0);
tbnet::Packet* rsp_msg = NULL;
if (TFS_SUCCESS == send_msg_to_server(ip_port, client, &heart_msg, rsp_msg, TIMEOUT))
{
if (HEARTBEAT_AND_NS_HEART_MESSAGE == rsp_msg->getPCode())
{
status = dynamic_cast<HeartBeatAndNSHeartMessage*> (rsp_msg)->get_ns_status();
}
else
{
TBSYS_LOG(ERROR, "unknow packet pcode %d", rsp_msg->getPCode());
}
}
else
{
TBSYS_LOG(ERROR, "send packet error");
}
NewClientManager::get_instance().destroy_client(client);
}
}
while (count < 3 && -1 == status);
return status;
}
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;
}
int DsLib::read_file_info(DsTask& ds_task)
{
uint64_t server_id = ds_task.server_id_;
int32_t cluster_id = ds_task.cluster_id_;
uint32_t block_id = ds_task.block_id_;
uint64_t file_id = ds_task.new_file_id_;
int32_t mode = ds_task.mode_;
FileInfoMessage req_fi_msg;
req_fi_msg.set_block_id(block_id);
req_fi_msg.set_file_id(file_id);
req_fi_msg.set_mode(mode);
int ret_status = TFS_ERROR;
NewClient* client = NewClientManager::get_instance().create_client();
tbnet::Packet* ret_msg = NULL;
ret_status = send_msg_to_server(server_id, client, &req_fi_msg, ret_msg);
if ((ret_status == TFS_SUCCESS))
{
if (RESP_FILE_INFO_MESSAGE == ret_msg->getPCode())
{
RespFileInfoMessage* resp_fi_msg = dynamic_cast<RespFileInfoMessage*> (ret_msg);
if (resp_fi_msg->get_file_info() != NULL)
{
FileInfo file_info;
memcpy(&file_info, resp_fi_msg->get_file_info(), FILEINFO_SIZE);
if (file_info.id_ == file_id)
{
ret_status = TFS_SUCCESS;
tfs::client::FSName fsname(block_id, file_id, cluster_id);
printf(" FILE_NAME: %s\n", fsname.get_name());
printf(" BLOCK_ID: %u\n", fsname.get_block_id());
printf(" FILE_ID: %" PRI64_PREFIX "u\n", file_info.id_);
printf(" OFFSET: %d\n", file_info.offset_);
printf(" SIZE: %d\n", file_info.size_);
printf(" MODIFIED_TIME: %s\n", Func::time_to_str(file_info.modify_time_).c_str());
printf(" CREATE_TIME: %s\n", Func::time_to_str(file_info.create_time_).c_str());
printf(" STATUS: %d\n", file_info.flag_);
printf(" CRC: %u\n", file_info.crc_);
}
}
}
else if (STATUS_MESSAGE == ret_msg->getPCode())
{
printf("Read file info error:%s", (dynamic_cast<StatusMessage*> (ret_msg))->get_error());
ret_status = TFS_ERROR;
}
else
{
printf("message type is error.");
ret_status = TFS_ERROR;
}
}
else
{
fprintf(stderr, "Read file info fail\n");
ret_status = TFS_ERROR;
}
NewClientManager::get_instance().destroy_client(client);
return ret_status;
}
int DsLib::list_file(DsTask& ds_task)
{
uint64_t server_id = ds_task.server_id_;
int32_t cluster_id = ds_task.cluster_id_;
uint32_t block_id = ds_task.block_id_;
int32_t mode = ds_task.mode_;
GetServerStatusMessage req_gss_msg;
req_gss_msg.set_status_type(GSS_BLOCK_FILE_INFO);
req_gss_msg.set_return_row(block_id);
int ret_status = TFS_ERROR;
NewClient* client = NewClientManager::get_instance().create_client();
tbnet::Packet* ret_msg = NULL;
ret_status = send_msg_to_server(server_id, client, &req_gss_msg, ret_msg);
//if the information of file can be accessed.
if ((ret_status == TFS_SUCCESS))
{
if (BLOCK_FILE_INFO_MESSAGE == ret_msg->getPCode())
{
FILE_INFO_LIST* file_info_list = (dynamic_cast<BlockFileInfoMessage*> (ret_msg))->get_fileinfo_list();
int32_t i = 0;
int32_t list_size = file_info_list->size();
//output file information
printf("FileList Size = %d\n", list_size);
if (mode != 0)
{
printf(
"FILE_NAME FILE_ID OFFSET SIZE USIZE M_TIME C_TIME FLAG CRC\n");
printf(
"---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ----------\n");
for (i = 0; i < list_size; i++)
{
FileInfo& file_info = file_info_list->at(i);
tfs::client::FSName fsname(block_id, file_info.id_, cluster_id);
print_file_info(fsname.get_name(), file_info);
}
printf(
"---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ----------\n");
printf(
"FILE_NAME FILE_ID OFFSET SIZE USIZE M_TIME C_TIME FLAG CRC\n");
}
else
{
// just print file
for (i = 0; i < list_size; i++)
{
FileInfo& file_info = file_info_list->at(i);
tfs::client::FSName fsname(block_id, file_info.id_, cluster_id);
fprintf(stdout, "\n%s", fsname.get_name());
}
fprintf(stdout, "\n");
}
printf("Total : %d files\n", list_size);
}
else if (STATUS_MESSAGE == ret_msg->getPCode())
{
printf("%s", (dynamic_cast<StatusMessage*> (ret_msg))->get_error());
}
}
else
{
fprintf(stderr, "Get File list in Block failure\n");
}
NewClientManager::get_instance().destroy_client(client);
return ret_status;
}
int DsLib::read_file_data(DsTask& ds_task)
{
uint64_t server_id = ds_task.server_id_;
uint32_t block_id = ds_task.block_id_;
uint64_t file_id = ds_task.new_file_id_;
int fd = open(ds_task.local_file_, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
if (fd == -1)
{
fprintf(stderr, "Open %s fail\n", ds_task.local_file_);
return TFS_ERROR;
}
int32_t read_len = MAX_READ_SIZE;
static int32_t offset;
offset = 0;
static ReadDataMessage rd_message;
rd_message.set_block_id(block_id);
rd_message.set_file_id(file_id);
rd_message.set_length(read_len);
rd_message.set_offset(offset);
int ret_status = TFS_SUCCESS;
while (TFS_SUCCESS == ret_status)
{
NewClient* client = NewClientManager::get_instance().create_client();
tbnet::Packet* ret_msg = NULL;
ret_status = send_msg_to_server(server_id, client, &rd_message, ret_msg);
if (TFS_SUCCESS == ret_status && RESP_READ_DATA_MESSAGE != ret_msg->getPCode())
{
fprintf(stderr, "unexpected packet packet id :%d", ret_msg->getPCode());
ret_status = TFS_ERROR;
}
RespReadDataMessage *resp_rd_msg = NULL;
int32_t len_tmp = 0;
if (TFS_SUCCESS == ret_status)
{
resp_rd_msg = (RespReadDataMessage *) ret_msg;
len_tmp = resp_rd_msg->get_length();
if (len_tmp < 0)
{
fprintf(stderr, "read file(id: %" PRI64_PREFIX "u) data error. ret: %d\n", file_id, len_tmp);
ret_status = TFS_ERROR;
}
}
if (TFS_SUCCESS == ret_status)
{
if (len_tmp == 0)
{
ret_status = TFS_ERROR;
}
}
ssize_t write_len = 0;
if (TFS_SUCCESS == ret_status)
{
write_len = write(fd, resp_rd_msg->get_data(), len_tmp);
if (-1 == write_len)
{
fprintf(stderr, "write local file fail :%s\n", strerror(errno));
ret_status = TFS_ERROR;
}
}
if (TFS_SUCCESS == ret_status)
{
if (len_tmp < MAX_READ_SIZE)
{
ret_status = TFS_ERROR;
}
}
if (TFS_SUCCESS == ret_status)
{
offset += write_len;
rd_message.set_block_id(block_id);
rd_message.set_file_id(file_id);
rd_message.set_length(read_len);
rd_message.set_offset(offset);
}
NewClientManager::get_instance().destroy_client(client);
}
if (ret_status == TFS_SUCCESS)
{
printf("read file successful, block: %u, file: %" PRI64_PREFIX "u\n", block_id, file_id);
}
close(fd);
return ret_status;
}
