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