CliManager::cli_parse_status CliManager::parse_command(std::string command){
ActionMessage m;
m.from_string(command);
StatusMessage response = LocalCommands::parse_local_command(m);
std::cout << response.to_string() << std::endl;
if (response.get_status() == "ok"){
return PARSE_OK;
}
if (response.get_status() == "command"){
if (response.get<std::string>("action") == "exit"){
return PARSE_EXIT;
}
}
return PARSE_ERROR;
}
int rm_no_replicate_block_from_ns(const char* ns_addr, const uint64_t block_id)
{
int ret = TFS_SUCCESS;
ClientCmdMessage req_cc_msg;
req_cc_msg.set_cmd(CLIENT_CMD_EXPBLK);
req_cc_msg.set_value3(block_id);
req_cc_msg.set_value4(tfs::nameserver::HANDLE_DELETE_BLOCK_FLAG_ONLY_RELATION);
NewClient* client = NewClientManager::get_instance().create_client();
tbnet::Packet* rsp = NULL;
if((ret = send_msg_to_server(Func::get_host_ip(ns_addr), client, &req_cc_msg, rsp)) != TFS_SUCCESS)
{
TBSYS_LOG(ERROR, "send remove block from ns command failed. block_id: %" PRI64_PREFIX "u, ret: %d", block_id, ret);
}
else
{
assert(NULL != rsp);
if (STATUS_MESSAGE == rsp->getPCode())
{
StatusMessage* sm = dynamic_cast<StatusMessage*>(rsp);
if (STATUS_MESSAGE_OK == sm->get_status())
{
TBSYS_LOG(INFO, "remove block from ns success, ns_addr: %s, blockid: %" PRI64_PREFIX "u", ns_addr, block_id);
}
else
{
TBSYS_LOG(ERROR, "remove block from ns fail, ns_addr: %s, blockid: %" PRI64_PREFIX "u, ret: %d",
ns_addr, block_id, sm->get_status());
ret = sm->get_status();
}
}
else
{
TBSYS_LOG(ERROR, "remove block from ns: %s fail, blockid: %" PRI64_PREFIX "u, unkonw msg type", ns_addr, block_id);
ret = EXIT_UNKNOWN_MSGTYPE;
}
}
NewClientManager::get_instance().destroy_client(client);
return ret;
}
int OpManager::update_block_info(const BlockInfoV2& block_info, const common::UpdateBlockInfoType type)
{
int ret = TFS_SUCCESS;
DsRuntimeGlobalInformation& ds_info = DsRuntimeGlobalInformation::instance();
create_msg_ref(UpdateBlockInfoMessageV2, req_msg);
req_msg.set_block_info(block_info);
req_msg.set_type(type);
req_msg.set_server_id(ds_info.information_.id_);
NewClient* client = NewClientManager::get_instance().create_client();
if (NULL == client)
{
ret = EXIT_CLIENT_MANAGER_CREATE_CLIENT_ERROR;
}
else
{
tbnet::Packet* ret_msg = NULL;
ret = send_msg_to_server(ds_info.ns_vip_port_, client, &req_msg, ret_msg);
if (TFS_SUCCESS == ret)
{
if (STATUS_MESSAGE == ret_msg->getPCode())
{
StatusMessage* smsg = dynamic_cast<StatusMessage*>(ret_msg);
ret = smsg->get_status();
TBSYS_LOG(DEBUG, "update block info. blockid: %"PRI64_PREFIX"u, status: %d %s",
block_info.block_id_, smsg->get_status(), smsg->get_error());
}
else
{
ret = EXIT_COMMIT_BLOCK_UPDATE_ERROR;
}
}
NewClientManager::get_instance().destroy_client(client);
}
return ret;
}
int TranBlock::write_index()
{
int ret = TFS_SUCCESS;
WriteInfoBatchMessage req_wib_msg;
req_wib_msg.set_block_id(seg_data_.seg_info_.block_id_);
req_wib_msg.set_offset(0);
req_wib_msg.set_length(dest_raw_meta_.size());
req_wib_msg.set_raw_meta_list(&dest_raw_meta_);
req_wib_msg.set_block_info(&dest_block_info_);
req_wib_msg.set_cluster(COPY_BETWEEN_CLUSTER);
NewClient* client = NewClientManager::get_instance().create_client();
tbnet::Packet* rsp = NULL;
if(TFS_SUCCESS != send_msg_to_server(dest_ds_id_, client, &req_wib_msg, rsp))
{
rsp = NULL;
}
if (NULL == rsp)
{
TBSYS_LOG(ERROR, "write index failed, blockid: %u, length: %zd, ret: %d",
seg_data_.seg_info_.block_id_, dest_raw_meta_.size(), ret);
ret = TFS_ERROR;
}
else
{
if (STATUS_MESSAGE == rsp->getPCode())
{
StatusMessage* sm = dynamic_cast<StatusMessage*>(rsp);
if (STATUS_MESSAGE_OK != sm->get_status())
{
TBSYS_LOG(ERROR, "write raw index to ds: %s fail, blockid: %u, file count: %d, ret: %d",
tbsys::CNetUtil::addrToString(dest_ds_id_).c_str(), seg_data_.seg_info_.block_id_, static_cast<int32_t>(dest_raw_meta_.size()), sm->get_status());
ret = TFS_ERROR;
}
}
else
{
TBSYS_LOG(ERROR, "write raw index to ds: %s fail, blockid: %u, file count: %d, unkonw msg type",
tbsys::CNetUtil::addrToString(dest_ds_id_).c_str(), seg_data_.seg_info_.block_id_, static_cast<int32_t>(dest_raw_meta_.size()));
ret = TFS_ERROR;
}
}
NewClientManager::get_instance().destroy_client(client);
return ret;
}
StatusMessage LocalCommands::register_peer(ActionMessage& pt){
ActionMessage m("register-peer");
std::string ip_address = pt.get<std::string>("ip-address");
AsyncRequestClient c(ip_address);
SerializableList<FileInfo> file_list = ConnectionManager::list_files();
m.push_back(std::make_pair("file-list", file_list.get_ptree()));
StatusMessage response = c.send_message(m);
if (response.get_status() == "ok"){
if (ConnectionManager::registered_peers.find(response.get_peer_id()) == ConnectionManager::registered_peers.end()){
ConnectionManager::register_peer(response.get_peer_id(), response.get<std::string>("ip-address"));
boost::property_tree::ptree ptr = response.get_ptree();
BOOST_FOREACH(const boost::property_tree::ptree::value_type& child, ptr.get_child("file-list")) {
boost::shared_ptr<FileInfo> f(new FileInfo);
f -> from_ptree(child.second.get_child(""));
ConnectionManager::register_extern_file(f);
}
}
}
int TranBlock::rm_block_from_ns(uint64_t ds_id)
{
int ret = TFS_SUCCESS;
ClientCmdMessage req_cc_msg;
req_cc_msg.set_cmd(CLIENT_CMD_EXPBLK);
req_cc_msg.set_value1(ds_id);
req_cc_msg.set_value3(seg_data_.seg_info_.block_id_);
NewClient* client = NewClientManager::get_instance().create_client();
tbnet::Packet* rsp = NULL;
if((ret = send_msg_to_server(Func::get_host_ip(dest_ns_addr_.c_str()), client, &req_cc_msg, rsp)) != TFS_SUCCESS)
{
TBSYS_LOG(ERROR, "send remove block from ns command failed. block_id: %u, ret: %d", seg_data_.seg_info_.block_id_, ret);
rsp = NULL;
}
else
{
if (rsp != NULL && STATUS_MESSAGE == rsp->getPCode())
{
StatusMessage* sm = dynamic_cast<StatusMessage*>(rsp);
if (STATUS_MESSAGE_OK == sm->get_status())
{
TBSYS_LOG(INFO, "remove block from ns success, ds_addr: %s, blockid: %u",
tbsys::CNetUtil::addrToString(ds_id).c_str(), seg_data_.seg_info_.block_id_);
}
else
{
TBSYS_LOG(ERROR, "remove block from ns fail, ds_addr: %s, blockid: %u, ret: %d",
tbsys::CNetUtil::addrToString(ds_id).c_str(), seg_data_.seg_info_.block_id_, sm->get_status());
ret = TFS_ERROR;
}
}
else
{
TBSYS_LOG(ERROR, "remove block from ns: %s fail, blockid: %u, unkonw msg type",
tbsys::CNetUtil::addrToString(ds_id).c_str(), seg_data_.seg_info_.block_id_);
ret = TFS_ERROR;
}
}
NewClientManager::get_instance().destroy_client(client);
return ret;
}
StatusMessage LocalCommands::get_file_tcp(ActionMessage& pt){
ActionMessage m("request-download");
std::string file_name = pt.get<std::string>("file-name");
boost::shared_ptr<FileInfo> file = ConnectionManager::get_extern_file_by_id(pt.get<std::string>("file-id"));
if (file){
boost::shared_ptr<DatadInfo> server = ConnectionManager::get_peer_by_id(file -> get_peer_id());
if (server){
m.put<std::string>("file-id", pt.get<std::string>("file-id"));
boost::shared_ptr<AsyncRequestClient> c = ConnectionManager::get_request_client_by_id(server -> get_id());
if (c){
StatusMessage response = c -> send_message(m);
std::string download_id = response.get<std::string>("download-id");
if (response.get_status() == "ok"){
ConnectionManager::tcp_file_client_session(server, file, file_name ,download_id);
return(response);
}
}
}
}
StatusMessage response("error");
response.put<std::string>("message", "Error starting download");
return(response);
}
int TranBlock::write_data()
{
int block_len = dest_content_buf_.getDataLen();
int cur_write_offset = 0;
int cur_len = 0;
int ret = TFS_SUCCESS;
while (block_len > 0)
{
int64_t remainder_retrys = RETRY_TIMES;
while (remainder_retrys > 0)
{
cur_len = std::min(static_cast<int64_t>(block_len), TRAN_BUFFER_SIZE);
WriteRawDataMessage req_wrd_msg;
req_wrd_msg.set_block_id(seg_data_.seg_info_.block_id_);
req_wrd_msg.set_offset(cur_write_offset);
req_wrd_msg.set_length(cur_len);
req_wrd_msg.set_data(dest_content_buf_.getData());
//new block
if (0 == cur_write_offset)
{
req_wrd_msg.set_new_block(1);
}
NewClient* client = NewClientManager::get_instance().create_client();
tbnet::Packet* rsp = NULL;
if(TFS_SUCCESS != send_msg_to_server(dest_ds_id_, client, &req_wrd_msg, rsp))
{
rsp = NULL;
}
if (NULL == rsp)
{
TBSYS_LOG(ERROR, "write data failed, blockid: %u, dest_ds: %s, cur_write_offset: %d, cur_len: %d, ret: %d",
seg_data_.seg_info_.block_id_, tbsys::CNetUtil::addrToString(dest_ds_id_).c_str(), cur_write_offset, cur_len, ret);
ret = TFS_ERROR;
}
else
{
if (STATUS_MESSAGE == rsp->getPCode())
{
StatusMessage* sm = dynamic_cast<StatusMessage*>(rsp);
if (STATUS_MESSAGE_OK != sm->get_status())
{
TBSYS_LOG(ERROR, "write raw data to ds: %s fail, blockid: %u, offset: %d, ret: %d",
tbsys::CNetUtil::addrToString(dest_ds_id_).c_str(), seg_data_.seg_info_.block_id_, cur_write_offset, sm->get_status());
ret = TFS_ERROR;
}
}
else
{
TBSYS_LOG(ERROR, "write raw data to ds: %s fail, blockid: %u, offset: %d, unkonw msg type",
tbsys::CNetUtil::addrToString(dest_ds_id_).c_str(), seg_data_.seg_info_.block_id_, cur_write_offset);
ret = TFS_ERROR;
}
dest_content_buf_.drainData(cur_len);
block_len = dest_content_buf_.getDataLen();
cur_write_offset += cur_len;
NewClientManager::get_instance().destroy_client(client);
if (NULL == rsp)
{
--remainder_retrys;
continue;
}
else
{
if (cur_len != TRAN_BUFFER_SIZE)
{
// quit
block_len = 0;
}
TBSYS_LOG(INFO, "write raw data to ds: %s successful, blockid: %u",
tbsys::CNetUtil::addrToString(dest_ds_id_).c_str(), seg_data_.seg_info_.block_id_);
break;
}
}
}
if (TFS_SUCCESS != ret)
{
break;
}
}
return ret;
}
int Requester::req_update_block_info(const uint32_t block_id, const UpdateBlockType repair)
{
UpdateBlockType tmp_repair = repair;
BlockInfo* blk = NULL;
if (UPDATE_BLOCK_MISSING != tmp_repair)
{
int32_t visit_count = 0;
int ret = data_management_->get_block_info(block_id, blk, visit_count);
if (EXIT_NO_LOGICBLOCK_ERROR == ret)
{
tmp_repair = UPDATE_BLOCK_MISSING;
}
else
{
if (NULL == blk)
{
TBSYS_LOG(ERROR, "blockid: %u can not find block info.", block_id);
tmp_repair = UPDATE_BLOCK_REPAIR;
}
else
{
TBSYS_LOG(
INFO,
"req update block info, blockid: %u, version: %d, file count: %d, size: %d, delfile count: %d, del_size: %d, seqno: %d\n",
blk->block_id_, blk->version_, blk->file_count_, blk->size_, blk->del_file_count_, blk->del_size_, blk->seq_no_);
}
}
}
int ret = TFS_ERROR;
UpdateBlockInfoMessage ub_msg;
ub_msg.set_block_id(block_id);
ub_msg.set_block(blk);
ub_msg.set_server_id(dataserver_id_);
ub_msg.set_repair(tmp_repair);
NewClient* client = NewClientManager::get_instance().create_client();
tbnet::Packet* return_msg = NULL;
ret = send_msg_to_server(ns_ip_port_, client, &ub_msg, return_msg);
if (TFS_SUCCESS != ret)
{
NewClientManager::get_instance().destroy_client(client);
return ret;
}
int need_expire = 0;
if (STATUS_MESSAGE == return_msg->getPCode())
{
StatusMessage* sm = dynamic_cast<StatusMessage*>(return_msg);
if (STATUS_MESSAGE_OK == sm->get_status())
{
ret = TFS_SUCCESS;
}
else if (STATUS_MESSAGE_REMOVE == sm->get_status())
{
need_expire = 1;
ret = TFS_SUCCESS;
}
else
{
TBSYS_LOG(ERROR, "req update block info: %s, id: %u, tmp_repair: %d\n", sm->get_error(), block_id, tmp_repair);
}
}
else
{
TBSYS_LOG(ERROR,"unknow packet pcode: %d", return_msg->getPCode());
}
NewClientManager::get_instance().destroy_client(client);
if (need_expire)
{
data_management_->del_single_block(block_id);
}
return ret;
}
int Requester::req_block_write_complete(const uint32_t block_id,
const int32_t lease_id, const int32_t success, const UnlinkFlag unlink_flag)
{
TBSYS_LOG(DEBUG, "req block write complete begin id: %u, lease_id: %u\n", block_id, lease_id);
BlockInfo* blk = NULL;
int visit_count = 0;
int ret = data_management_->get_block_info(block_id, blk, visit_count);
if (TFS_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "req block write complete: can not find block, id: %u, ret: %d\n", block_id, ret);
return TFS_ERROR;
}
BlockInfo tmpblk;
memcpy(&tmpblk, blk, sizeof(BlockInfo));
ret = data_management_->get_block_curr_size(block_id, tmpblk.size_);
if (TFS_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "req block write complete: can not find block, id: %u, ret: %d\n", block_id, ret);
return TFS_ERROR;
}
BlockWriteCompleteMessage bwc_msg;
bwc_msg.set_block(&tmpblk);
bwc_msg.set_server_id(dataserver_id_);
bwc_msg.set_lease_id(lease_id);
WriteCompleteStatus wc_status = WRITE_COMPLETE_STATUS_YES;
if (TFS_SUCCESS != success)
{
wc_status = WRITE_COMPLETE_STATUS_NO;
}
bwc_msg.set_success(wc_status);
bwc_msg.set_unlink_flag(unlink_flag);
NewClient* client = NewClientManager::get_instance().create_client();
tbnet::Packet* return_msg = NULL;
ret = send_msg_to_server(ns_ip_port_, client, &bwc_msg, return_msg);
if (TFS_SUCCESS != ret)
{
NewClientManager::get_instance().destroy_client(client);
return ret;
}
if (STATUS_MESSAGE == return_msg->getPCode())
{
StatusMessage* sm = dynamic_cast<StatusMessage*>(return_msg);
if (STATUS_MESSAGE_OK == sm->get_status())
{
ret = TFS_SUCCESS;
}
else
{
ret = TFS_ERROR;
TBSYS_LOG(ERROR, "rep block write complete, nsip: %s, error desc: %s, id: %u\n",
tbsys::CNetUtil::addrToString(ns_ip_port_).c_str(), sm->get_error(), block_id);
}
}
else
{
TBSYS_LOG(ERROR, "rep block write complete, blockid: %u, msg type: %d error.\n", block_id,
return_msg->getPCode());
ret = TFS_ERROR;
}
NewClientManager::get_instance().destroy_client(client);
return ret;
}
int do_monitor(const VSTRING& param, int32_t type)
{
int ret = TFS_SUCCESS;
string server = param[0];
uint64_t ip_port = 0;
{
char ip[MAX_CMD_SIZE+1]; // to support mutiple port in the same server, must copy
ip[MAX_CMD_SIZE] = '\0';
int32_t port = get_port(strncpy(ip, server.c_str(), MAX_CMD_SIZE));
ip_port = Func::str_to_addr(ip, port);
}
AdminCmdMessage* admin_msg = new AdminCmdMessage(type);
for (size_t i = 1; i < param.size(); i++)
{
admin_msg->set_index(param[i]);
}
NewClient* client = NewClientManager::get_instance().create_client();
if (NULL != client)
{
tbnet::Packet* message = NULL;
if (TFS_SUCCESS == (ret = send_msg_to_server(ip_port, client, admin_msg, message)))
{
if (STATUS_MESSAGE == message->getPCode())
{
StatusMessage* msg = dynamic_cast<StatusMessage*>(message);
ret = msg->get_status();
fprintf(stderr, "%s %s \033[0m\n", ret != TFS_SUCCESS ? FAIL_COLOR : SUC_COLOR, msg->get_error());
}
else if (ADMIN_CMD_MESSAGE == message->getPCode() &&
ADMIN_CMD_RESP == dynamic_cast<AdminCmdMessage*>(message)->get_cmd_type())
{
vector<MonitorStatus>* m_status = dynamic_cast<AdminCmdMessage*>(message)->get_status();
int32_t size = m_status->size();
fprintf(stderr, "\033[36m ================== %s count: %d ===================\033[0m\n",
server.c_str(), size);
// update server ==> index
VSTRING& index = g_server_map[server];
index.clear();
for (int32_t i = 0; i < size; i++)
{
(*m_status)[i].dump();
index.push_back((*m_status)[i].index_);
}
fprintf(stderr, "\033[36m-----------------------------------------------------------------------------------\033[0m\n\n");
}
else
{
fprintf(stderr, "%s unknown message recieved, op cmd fail\n \033[0m", FAIL_COLOR);
}
}
else
{
fprintf(stderr, "send message error");
}
NewClientManager::get_instance().destroy_client(client);
}
else
{
fprintf(stderr, "create client error");
ret = TFS_ERROR;
}
return ret;
}
