int BalanceTestRpc::push_migrate_msg(const common::ObServer& src_cs, const common::ObServer& dest_cs, const common::ObRange& range, bool keep_src) { int ret = OB_SUCCESS; MigrateMsg* msg = new_migrate_msg(src_cs, dest_cs, range, keep_src); assert(msg); assert(msg->next_ == NULL); char addr_buf1[OB_IP_STR_BUFF]; char addr_buf2[OB_IP_STR_BUFF]; static char range_buf[OB_MAX_ROW_KEY_LENGTH * 2]; src_cs.to_string(addr_buf1, OB_IP_STR_BUFF); dest_cs.to_string(addr_buf2, OB_IP_STR_BUFF); tbsys::CThreadGuard guard(&migrate_msg_mutex_); if (NULL == msg_head_) { msg_head_ = msg; } else { msg->next_ = msg_head_; msg_head_ = msg; } msg_count_++; msg->range_.to_string(range_buf, OB_MAX_ROW_KEY_LENGTH*2); TBSYS_LOG(DEBUG, "push migrate msg, src=%s dest=%s range=%s", addr_buf1, addr_buf2, range_buf); return ret; }
int ObUpsRpcStub :: report_freeze(const common::ObServer &root_server, const common::ObServer &ups_master, const int64_t frozen_version, const int64_t timeout_us) { int err = OB_SUCCESS; ObDataBuffer data_buff; ObServer update_server; if (NULL == client_mgr_) { TBSYS_LOG(WARN, "invalid status, client_mgr_[%p]", client_mgr_); err = OB_ERROR; } else { err = get_thread_buffer_(data_buff); } // serialize ups_master if (OB_SUCCESS == err) { err = ups_master.serialize(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position()); } // serialize timestamp if (OB_SUCCESS == err) { err = common::serialization::encode_vi64(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position(), frozen_version); } // step 1. send freeze memtable resp if (OB_SUCCESS == err) { err = client_mgr_->send_request(root_server, OB_UPDATE_SERVER_REPORT_FREEZE, DEFAULT_VERSION, timeout_us, data_buff); if (err != OB_SUCCESS) { TBSYS_LOG(ERROR, "send freeze memtable failed, err[%d].", err); } } // step 2. deserialize the response code int64_t pos = 0; if (OB_SUCCESS == err) { ObResultCode result_code; err = result_code.deserialize(data_buff.get_data(), data_buff.get_position(), pos); if (OB_SUCCESS != err) { TBSYS_LOG(ERROR, "deserialize result_code failed:pos[%ld], err[%d].", pos, err); } else { err = result_code.result_code_; } } return err; }
void ObUpsBlackList::fail(const int32_t server_index, const common::ObServer & server) { if ((server_index < server_count_) && (fail_counter_[server_index].server_ == server)) { // no need thread safe if (0 == fail_counter_[server_index].fail_count_) { fail_counter_[server_index].fail_timestamp_ = tbsys::CTimeUtil::getTime(); } ++fail_counter_[server_index].fail_count_; } else { TBSYS_LOG(WARN, "check param failed:index[%d], count[%d], server[%u], port[%d]", server_index, server_count_, server.get_ipv4(), server.get_port()); } }
int ObUpsLeaseTask::init(common::ObRoleMgr *role_mgr, ObUpsRpcStub * rpc_stub, common::ObServer &root_server, ObUpsLogMgr *log_mgr, const int64_t inner_port, common::ObServer &self_server, const int64_t timeout_us) { int err = OB_SUCCESS; self_lease_ = 0; if (NULL == role_mgr || NULL == rpc_stub || NULL == log_mgr) { err = OB_INVALID_ARGUMENT; TBSYS_LOG(WARN, "invalid argument. role_mgr=%p", role_mgr); } else { role_mgr_ = role_mgr; rpc_stub_ = rpc_stub; log_mgr_ = log_mgr; root_server_.set_ipv4_addr(root_server.get_ipv4(), root_server.get_port()); inner_port_ = inner_port; self_addr_.set_ipv4_addr(self_server.get_ipv4(), self_server.get_port()); timeout_us_ = timeout_us; } return err; }
int ObRootRpcStub::migrate_tablet(const common::ObServer& src_cs, const common::ObServer& dest_cs, const common::ObRange& range, bool keey_src, const int64_t timeout_us) { int ret = OB_SUCCESS; ObDataBuffer msgbuf; if (NULL == client_mgr_) { TBSYS_LOG(ERROR, "client_mgr_=NULL"); ret = OB_ERROR; } else if (OB_SUCCESS != (ret = get_thread_buffer_(msgbuf))) { TBSYS_LOG(ERROR, "failed to get thread buffer, err=%d", ret); } else if (OB_SUCCESS != (ret = range.serialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position()))) { TBSYS_LOG(ERROR, "failed to serialize rage, err=%d", ret); } else if (OB_SUCCESS != (ret = dest_cs.serialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position()))) { TBSYS_LOG(ERROR, "failed to serialize dest_cs, err=%d", ret); } else if (OB_SUCCESS != (ret = common::serialization::encode_bool(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), keey_src))) { TBSYS_LOG(ERROR, "failed to serialize keey_src, err=%d", ret); } else if (OB_SUCCESS != (ret = client_mgr_->send_request(src_cs, OB_CS_MIGRATE, DEFAULT_VERSION, timeout_us, msgbuf))) { TBSYS_LOG(WARN, "failed to send request, err=%d", ret); } else { ObResultCode result; int64_t pos = 0; if (OB_SUCCESS != (ret = result.deserialize(msgbuf.get_data(), msgbuf.get_position(), pos))) { TBSYS_LOG(ERROR, "failed to deserialize response, err=%d", ret); } else if (OB_SUCCESS != result.result_code_) { TBSYS_LOG(WARN, "failed to migrate tablet, err=%d", result.result_code_); ret = result.result_code_; } else { } } return ret; }
int ObRootServerRpcStub::get_update_server(common::ObServer& update_server,bool for_merge /*=false*/) { int ret = OB_SUCCESS; const int64_t timeout = ObChunkServerMain::get_instance()-> get_chunk_server().get_param().get_network_time_out() ; // send_request timeout us ObDataBuffer data_buff; ret = get_frame_buffer(data_buff); // step 1. send get update server info request if (OB_SUCCESS == ret) { ret = rpc_frame_->send_request(root_server_, for_merge ? OB_GET_UPDATE_SERVER_INFO_FOR_MERGE : OB_GET_UPDATE_SERVER_INFO, DEFAULT_VERSION, timeout, data_buff); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "send request to root server for get update server addr failed:ret[%d]", ret); } } // step 2. deserialize restult code int64_t pos = 0; if (OB_SUCCESS == ret) { ObResultCode result_code; ret = result_code.deserialize(data_buff.get_data(), data_buff.get_position(), pos); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "deserialize result_code failed:pos[%ld], ret[%d]", pos, ret); } else { ret = result_code.result_code_; } } // step 3. deserialize update server addr if (OB_SUCCESS == ret) { ret = update_server.deserialize(data_buff.get_data(), data_buff.get_position(), pos); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "deserialize server failed:pos[%ld], ret[%d]", pos, ret); } } return ret; }
int ObRootRpcStub::switch_schema(const common::ObServer& ups, const common::ObSchemaManagerV2& schema_manager, const int64_t timeout_us) { int ret = OB_SUCCESS; ObDataBuffer msgbuf; if (NULL == client_mgr_) { TBSYS_LOG(ERROR, "client_mgr_=NULL"); ret = OB_ERROR; } else if (OB_SUCCESS != (ret = get_thread_buffer_(msgbuf))) { TBSYS_LOG(ERROR, "failed to get thread buffer, err=%d", ret); } else if (OB_SUCCESS != (ret = schema_manager.serialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position()))) { TBSYS_LOG(ERROR, "failed to serialize schema, err=%d", ret); } else if (OB_SUCCESS != (ret = client_mgr_->send_request(ups, OB_SWITCH_SCHEMA, DEFAULT_VERSION, timeout_us, msgbuf))) { TBSYS_LOG(WARN, "failed to send request, err=%d", ret); } else { ObResultCode result; int64_t pos = 0; if (OB_SUCCESS != (ret = result.deserialize(msgbuf.get_data(), msgbuf.get_position(), pos))) { TBSYS_LOG(ERROR, "failed to deserialize response, err=%d", ret); } else if (OB_SUCCESS != result.result_code_) { TBSYS_LOG(WARN, "failed to switch schema, err=%d", result.result_code_); ret = result.result_code_; } else { char server_buf[OB_IP_STR_BUFF]; ups.to_string(server_buf, OB_IP_STR_BUFF); TBSYS_LOG(INFO, "send up_switch_schema, ups=%s schema_version=%ld", server_buf, schema_manager.get_version()); } } return ret; }
int ObRootRpcStub::get_ups_max_log_seq(const common::ObServer& ups, uint64_t &max_log_seq, const int64_t timeout_us) { int ret = OB_SUCCESS; ObDataBuffer msgbuf; if (NULL == client_mgr_) { TBSYS_LOG(ERROR, "client_mgr_=NULL"); ret = OB_ERROR; } else if (OB_SUCCESS != (ret = get_thread_buffer_(msgbuf))) { TBSYS_LOG(ERROR, "failed to get thread buffer, err=%d", ret); } else if (OB_SUCCESS != (ret = client_mgr_->send_request(ups, OB_RS_GET_MAX_LOG_SEQ, DEFAULT_VERSION, timeout_us, msgbuf))) { TBSYS_LOG(WARN, "failed to send request, err=%d", ret); } else { // success ObResultCode result; int64_t pos = 0; if (OB_SUCCESS != (ret = result.deserialize(msgbuf.get_data(), msgbuf.get_position(), pos))) { TBSYS_LOG(ERROR, "failed to deserialize response, err=%d", ret); } else if (OB_SUCCESS != result.result_code_) { TBSYS_LOG(WARN, "failed to revoke lease, err=%d", result.result_code_); ret = result.result_code_; } else if (OB_SUCCESS != (ret = serialization::decode_vi64(msgbuf.get_data(), msgbuf.get_position(), pos, (int64_t*)&max_log_seq))) { TBSYS_LOG(WARN, "failed to deserialize, err=%d", ret); } else { TBSYS_LOG(INFO, "get ups max log seq, ups=%s seq=%lu", ups.to_cstring(), max_log_seq); } } return ret; }
int ObRootTableService::remove_replicas(ObScanHelper &scan_helper, const common::ObServer &cs) { int ret = OB_SUCCESS; if (0 == cs.get_port()) { TBSYS_LOG(WARN, "invalid cs port"); ret = OB_INVALID_ARGUMENT; } else if (OB_SUCCESS != (ret = check_integrity())) { TBSYS_LOG(ERROR, "integrity error"); } else { // @todo for each table remove_replicas_in_table(scan_helper, cs, 0); } return ret; }
int ObRootTableService::report_tablets(ObScanHelper &scan_helper, const common::ObServer& cs, const common::ObTabletReportInfoList& rtablets) { int ret = OB_SUCCESS; if (OB_SUCCESS != (ret = check_integrity())) { TBSYS_LOG(ERROR, "integrity error"); } else { TBSYS_LOG(INFO, "cs report tablets, cs=%s tablets_num=%ld", cs.to_cstring(), rtablets.get_tablet_size()); const ObTabletReportInfo* tablets = rtablets.get_tablet(); for (int64_t i = 0; i < rtablets.get_tablet_size(); ++i) { const ObTabletReportInfo &tablet = tablets[i]; if (OB_SUCCESS != (ret = report_tablet(scan_helper, tablet))) { TBSYS_LOG(WARN, "failed to report"); } } } return ret; }
int ObRootRpcStub::shutdown_cs(const common::ObServer& cs, bool is_restart, const int64_t timeout_us) { int ret = OB_SUCCESS; ObDataBuffer msgbuf; if (NULL == client_mgr_) { TBSYS_LOG(ERROR, "client_mgr_=NULL"); ret = OB_ERROR; } else if (OB_SUCCESS != (ret = get_thread_buffer_(msgbuf))) { TBSYS_LOG(ERROR, "failed to get thread buffer, err=%d", ret); } else if (OB_SUCCESS != (ret = serialization::encode_i32(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), is_restart ? 1 : 0))) { TBSYS_LOG(ERROR, "encode is_restart fail:ret[%d], is_restart[%d]", ret, is_restart ? 1 : 0); } else if (OB_SUCCESS != (ret = client_mgr_->send_request(cs, OB_STOP_SERVER, DEFAULT_VERSION, timeout_us, msgbuf))) { TBSYS_LOG(WARN, "failed to send request, err=%d", ret); } else { // success ObResultCode result; int64_t pos = 0; if (OB_SUCCESS != (ret = result.deserialize(msgbuf.get_data(), msgbuf.get_position(), pos))) { TBSYS_LOG(ERROR, "failed to deserialize response, err=%d", ret); } else if (OB_SUCCESS != result.result_code_) { TBSYS_LOG(WARN, "failed to restart, err=%d server=%s", result.result_code_, cs.to_cstring()); ret = result.result_code_; } } return ret; }
int ObRootServerRpcStub::register_server(const common::ObServer & server, const bool is_merge_server, int32_t& status) { const int64_t register_timeout = ObChunkServerMain::get_instance()-> get_chunk_server().get_param().get_network_time_out() ; // send_request timeout us int ret = OB_SUCCESS; ObDataBuffer data_buff; ret = get_frame_buffer(data_buff); // step 1. serialize server to data_buff if (OB_SUCCESS == ret) { ret = server.serialize(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position()); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize server failed[%d]", ret); } } if (OB_SUCCESS == ret) { ret = serialization::encode_bool(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position(), is_merge_server); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize is_merge_server failed=[%d]", ret); } } // step 2. send request for fetch new schema if (OB_SUCCESS == ret) { ret = rpc_frame_->send_request(root_server_, OB_SERVER_REGISTER, DEFAULT_VERSION, register_timeout, data_buff); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "send request to root server for register failed" ",ret=[%d].", ret); } } // step 3. deserialize the response code int64_t pos = 0; if (OB_SUCCESS == ret) { ObResultCode result_code; ret = result_code.deserialize(data_buff.get_data(), data_buff.get_position(), pos); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "deserialize result_code failed:pos[%ld], ret[%d].", pos, ret); } else { ret = result_code.result_code_; } } // step 4. deserialize status field if (OB_SUCCESS == ret) { ret = serialization::decode_vi32(data_buff.get_data(), data_buff.get_position(), pos, &status); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "deserialize status from buff failed," "pos[%ld], ret[%d].", pos, ret); } } return ret; }
int ObRootRpcStub::get_split_range(const common::ObServer& ups, const int64_t timeout_us, const uint64_t table_id, const int64_t forzen_version, ObTabletInfoList &tablets) { int ret = OB_SUCCESS; ObDataBuffer msgbuf; if (NULL == client_mgr_) { TBSYS_LOG(ERROR, "client_mgr_=NULL"); ret = OB_ERROR; } if (OB_SUCCESS == ret) { if (OB_SUCCESS != (ret = get_thread_buffer_(msgbuf))) { TBSYS_LOG(ERROR, "failed to get thread buffer, err=%d", ret); } } if (OB_SUCCESS == ret) { if (OB_SUCCESS != (ret = serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), forzen_version))) { TBSYS_LOG(WARN, "fail to encode forzen_version. forzen_version=%ld, ret=%d", forzen_version, ret); } } if (OB_SUCCESS == ret) { if (OB_SUCCESS != (ret = serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), table_id))) { TBSYS_LOG(WARN, "fail to encode table_id. table_id=%lu, ret=%d", table_id, ret); } } if (OB_SUCCESS == ret) { if (OB_SUCCESS != (ret = client_mgr_->send_request(ups, OB_RS_FETCH_SPLIT_RANGE, DEFAULT_VERSION, timeout_us, msgbuf))) { TBSYS_LOG(WARN, "failed to send request, err=%d", ret); } } ObResultCode result; int64_t pos = 0; if (OB_SUCCESS == ret) { if (OB_SUCCESS != (ret = result.deserialize(msgbuf.get_data(), msgbuf.get_position(), pos))) { TBSYS_LOG(ERROR, "failed to deserialize response, err=%d", ret); } else if (OB_SUCCESS != result.result_code_) { TBSYS_LOG(WARN, "failed to fetch split range, err=%d", result.result_code_); ret = result.result_code_; } } if (OB_SUCCESS == ret) { if (OB_SUCCESS != (ret = tablets.deserialize(msgbuf.get_data(), msgbuf.get_position(), pos))) { TBSYS_LOG(WARN, "failed to deserialize tablets, err=%d", ret); } } if (OB_SUCCESS == ret) { TBSYS_LOG(INFO, "fetch split range from ups succ."); } else { TBSYS_LOG(WARN, "fetch split range from ups fail, ups_addr=%s, version=%ld", ups.to_cstring(), forzen_version); } return ret; }
int ObRootRpcStub::request_report_tablet(const common::ObServer& chunkserver) { int ret = OB_SUCCESS; ObDataBuffer msgbuf; if (NULL == client_mgr_) { TBSYS_LOG(ERROR, "client_mgr_=NULL"); ret = OB_ERROR; } if (OB_SUCCESS == ret) { ret = get_thread_buffer_(msgbuf); if (OB_SUCCESS != ret) { TBSYS_LOG(WARN, "fail to get thread buffer. err=%d", ret); } } if (OB_SUCCESS == ret) { ret = client_mgr_->post_request(chunkserver, OB_RS_REQUEST_REPORT_TABLET, DEFAULT_VERSION, msgbuf); if (OB_SUCCESS != ret) { TBSYS_LOG(WARN, "fail to post request to chunkserver. err=%d, chunkserver_addr=%s", ret, chunkserver.to_cstring()); } } return ret; }
int ObRootRpcStub::slave_register(const common::ObServer& master, const common::ObServer& slave_addr, common::ObFetchParam& fetch_param, const int64_t timeout) { int err = OB_SUCCESS; ObDataBuffer data_buff; if (NULL == client_mgr_) { TBSYS_LOG(WARN, "invalid status, client_mgr_[%p]", client_mgr_); err = OB_ERROR; } else { err = get_thread_buffer_(data_buff); } // step 1. serialize slave addr if (OB_SUCCESS == err) { err = slave_addr.serialize(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position()); } // step 2. send request to register if (OB_SUCCESS == err) { err = client_mgr_->send_request(master, OB_SLAVE_REG, DEFAULT_VERSION, timeout, data_buff); if (err != OB_SUCCESS) { TBSYS_LOG(ERROR, "send request to register failed" "err[%d].", err); } } // step 3. deserialize the response code int64_t pos = 0; if (OB_SUCCESS == err) { ObResultCode result_code; err = result_code.deserialize(data_buff.get_data(), data_buff.get_position(), pos); if (OB_SUCCESS != err) { TBSYS_LOG(ERROR, "deserialize result_code failed:pos[%ld], err[%d].", pos, err); } else { err = result_code.result_code_; } } // step 3. deserialize fetch param if (OB_SUCCESS == err) { err = fetch_param.deserialize(data_buff.get_data(), data_buff.get_position(), pos); if (OB_SUCCESS != err) { TBSYS_LOG(WARN, "deserialize fetch param failed, err[%d]", err); } } return err; }
int ObRootRpcStub::create_tablet(const common::ObServer& cs, const common::ObRange& range, const int64_t mem_version, const int64_t timeout_us) { int ret = OB_SUCCESS; ObDataBuffer msgbuf; static char buff[OB_MAX_PACKET_LENGTH]; msgbuf.set_data(buff, OB_MAX_PACKET_LENGTH); if (NULL == client_mgr_) { TBSYS_LOG(ERROR, "client_mgr_=NULL"); ret = OB_ERROR; } else if (OB_SUCCESS != (ret = range.serialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position()))) { TBSYS_LOG(ERROR, "failed to serialize range, err=%d", ret); } else if (OB_SUCCESS != (ret = common::serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), mem_version))) { TBSYS_LOG(ERROR, "failed to serialize key_src, err=%d", ret); } else if (OB_SUCCESS != (ret = client_mgr_->send_request(cs, OB_CS_CREATE_TABLE, DEFAULT_VERSION, timeout_us, msgbuf))) { TBSYS_LOG(WARN, "failed to send request, err=%d", ret); } else { ObResultCode result; int64_t pos = 0; static char range_buff[OB_MAX_ROW_KEY_LENGTH * 2]; if (OB_SUCCESS != (ret = result.deserialize(msgbuf.get_data(), msgbuf.get_position(), pos))) { TBSYS_LOG(ERROR, "failed to deserialize response, err=%d", ret); } else if (OB_SUCCESS != result.result_code_) { range.to_string(range_buff, OB_MAX_ROW_KEY_LENGTH * 2); TBSYS_LOG(WARN, "failed to create tablet, err=%d, cs=%s, range=%s", result.result_code_, cs.to_cstring(), range_buff); ret = result.result_code_; } else { } } return ret; }
int ObRootServerRpcStub::migrate_over( const common::ObRange &range, const common::ObServer &src_server, const common::ObServer &dest_server, const bool keep_src, const int64_t tablet_version) { const int64_t timeout = ObChunkServerMain::get_instance()-> get_chunk_server().get_param().get_network_time_out() ; // send_request timeout us int ret = OB_SUCCESS; ObDataBuffer data_buff; ret = get_frame_buffer(data_buff); // step 1. serialize server to data_buff if (OB_SUCCESS == ret) { ret = range.serialize(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position()); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize range failed[%d]", ret); } } if (OB_SUCCESS == ret) { ret = src_server.serialize(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position()); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize src_server failed[%d]", ret); } } if (OB_SUCCESS == ret) { ret = dest_server.serialize(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position()); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize dest_server failed=[%d]", ret); } } if (OB_SUCCESS == ret) { ret = serialization::encode_bool(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position(), keep_src); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize keep_src failed=[%d]", ret); } } if (OB_SUCCESS == ret) { ret = serialization::encode_vi64(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position(), tablet_version); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize tablet_version failed=[%d]", ret); } } // step 2. send request for report tablet migrate over. if (OB_SUCCESS == ret) { ret = rpc_frame_->send_request(root_server_, OB_MIGRATE_OVER, DEFAULT_VERSION, timeout, data_buff); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "send request to root server for register failed" ",ret=[%d].", ret); } } // step 3. deserialize the response code int64_t pos = 0; if (OB_SUCCESS == ret) { ObResultCode result_code; ret = result_code.deserialize(data_buff.get_data(), data_buff.get_position(), pos); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "deserialize result_code failed:pos[%ld], ret[%d].", pos, ret); } else { ret = result_code.result_code_; } } return ret; }
int get_rs(common::ObServer &server, const bool change) { UNUSED(change); server.set_ipv4_addr("10.235.152.32", 41814); return OB_SUCCESS; };
int ObRootServerRpcStub::report_capacity_info(const common::ObServer &server, const int64_t capacity, const int64_t used) { const int64_t report_timeout = ObChunkServerMain::get_instance()-> get_chunk_server().get_param().get_network_time_out() ; // send_request timeout us int ret = OB_SUCCESS; ObDataBuffer data_buff; ret = get_frame_buffer(data_buff); // step 1. serialize server to data_buff if (OB_SUCCESS == ret) { ret = server.serialize(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position()); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize server failed[%d]", ret); } } if (OB_SUCCESS == ret) { ret = serialization::encode_vi64(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position(), capacity); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize capacity failed=[%d]", ret); } } if (OB_SUCCESS == ret) { ret = serialization::encode_vi64(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position(), used); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "serialize used failed=[%d]", ret); } } // step 2. send request for fetch new schema if (OB_SUCCESS == ret) { ret = rpc_frame_->send_request(root_server_, OB_REPORT_CAPACITY_INFO, DEFAULT_VERSION, report_timeout, data_buff); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "send request to root server for report capacity failed" ",ret=[%d].", ret); } } // step 3. deserialize the response code int64_t pos = 0; if (OB_SUCCESS == ret) { ObResultCode result_code; ret = result_code.deserialize(data_buff.get_data(), data_buff.get_position(), pos); if (OB_SUCCESS != ret) { TBSYS_LOG(ERROR, "deserialize result_code failed:pos[%ld], ret[%d].", pos, ret); } else { ret = result_code.result_code_; } } return ret; }
int ObRootTableService::migrate_replica(ObScanHelper &scan_helper, const ObNewRange &range, const int64_t version, const common::ObServer &from, const common::ObServer &to, bool keep_src) { int ret = OB_SUCCESS; ObRootTable3::ConstIterator *first; ObRootTable3 *root_table = NULL; const ObRootTable3::Value* crow = NULL; if (NULL == range.start_key_.ptr() || NULL == range.end_key_.ptr() || 0 >= version || 0 == from.get_port() || 0 == to.get_port()) { TBSYS_LOG(WARN, "invalid tablet"); ret = OB_INVALID_ARGUMENT; } else if (OB_SUCCESS != (ret = check_integrity())) { TBSYS_LOG(ERROR, "integrity error"); } else if (OB_SUCCESS != (ret = aquire_root_table(scan_helper, root_table))) { TBSYS_LOG(ERROR, "failed to aquire root table, err=%d", ret); } else if (OB_SUCCESS != (ret = root_table->search(range, first))) { TBSYS_LOG(WARN, "failed to search tablet, err=%d", ret); } else if (OB_SUCCESS != (ret = first->next(crow))) { TBSYS_LOG(WARN, "tablet not exist, err=%d range=%s", ret, to_cstring(range)); ret = OB_ENTRY_NOT_EXIST; } else if (!is_same_range(*crow, range)) { ret = OB_ENTRY_NOT_EXIST; TBSYS_LOG(WARN, "tablet not exist, range=%s", to_cstring(range)); } else { for (int32_t i = 0; i < crow->get_max_replica_count(); ++i) { const ObTabletReplica& replica = crow->get_replica(i); if (from == replica.cs_) { if (replica.version_ != version) { TBSYS_LOG(WARN, "migrate tablet with wrong version, old_v=%ld new_v=%ld cs=%s range=%s", replica.version_, version, from.to_cstring(), to_cstring(range)); ret = OB_CONFLICT_VALUE; } else { ObTabletMetaTable::Value new_row = *crow; // copy ObTabletReplica replica2(replica); replica2.cs_ = to; if (keep_src) { if (OB_SUCCESS != (ret = new_row.add_replica(replica2))) { TBSYS_LOG(WARN, "failed to add replica, err=%d", ret); } } else { new_row.set_replica(i, replica2); } if (OB_SUCCESS == ret) { if (OB_SUCCESS != (ret = root_table->update(new_row))) { TBSYS_LOG(ERROR, "failed to update root table, err=%d", ret); } else if (OB_SUCCESS != (ret = root_table->commit())) { TBSYS_LOG(ERROR, "failed to commit change, err=%d", ret); } } } break; } } // end for } release_root_table(root_table); return ret; }
int ObRootTableService::remove_replicas_in_table(ObScanHelper &scan_helper, const common::ObServer &cs, const uint64_t tid) { int ret = OB_SUCCESS; ObRootTable3 *root_table = NULL; ObNewRange range_min_max; range_min_max.table_id_ = tid; range_min_max.set_whole_range(); ObRootTable3::ConstIterator* it = NULL; const ObRootTable3::Value* crow = NULL; if (OB_SUCCESS != (ret = aquire_root_table(scan_helper, root_table))) { TBSYS_LOG(ERROR, "failed to aquire root table, err=%d", ret); } else if (OB_SUCCESS != (ret = root_table->search(range_min_max, it))) { TBSYS_LOG(WARN, "failed to search tablet, err=%d tid=%lu", ret, tid); } else { int32_t deleted_replicas = 0; int32_t updated_count = 0; const int32_t batch_count = 512; while(OB_SUCCESS == ret && OB_SUCCESS == (ret = it->next(crow))) { for (int32_t i = 0; i < crow->get_max_replica_count(); ++i) { const ObTabletReplica& replica = crow->get_replica(i); if (replica.cs_ == cs) { ObTabletReplica replica2; // remove the replica ObRootTable3::Value mrow = *crow; mrow.set_replica(i, replica2); if (OB_SUCCESS != (ret = root_table->update(mrow))) { TBSYS_LOG(ERROR, "failed to update root table, err=%d", ret); } else { updated_count++; if (updated_count % batch_count == 0) { if (OB_SUCCESS != (ret = root_table->commit())) { TBSYS_LOG(ERROR, "failed to commit change, err=%d", ret); } else { deleted_replicas += batch_count; } } } break; } } // end for } // end while if (OB_ITER_END != ret) { TBSYS_LOG(WARN, "failed to remove replicas, err=%d", ret); } else { ret = OB_SUCCESS; } if (updated_count != deleted_replicas) { if (OB_SUCCESS != (ret = root_table->commit())) { TBSYS_LOG(ERROR, "failed to commit change, err=%d", ret); } } TBSYS_LOG(INFO, "delete replicas by cs, cs=%s replicas_num=%d", cs.to_cstring(), deleted_replicas); } release_root_table(root_table); return ret; }