int ObAppStats::sum_cluster_stats(const ObRole server_type, const common::ObArrayHelper<common::ObServer>& server_array) { ObStatManager node_stats; node_stats.set_server_type(server_type); char addr_string[MAX_SERVER_NUM]; int ret = OB_SUCCESS; for (int i = 0; i < server_array.get_array_index(); i++) { ObServer addr = *server_array.at(i); addr.to_string(addr_string, MAX_SERVER_NUM); ObClientRpcStub remote_stub; if (OB_SUCCESS != (ret = remote_stub.initialize(addr, &GFactory::get_instance().get_base_client().get_client_mgr()))) { fprintf(stderr, "initialize server stub error\n"); break; } else if (OB_SUCCESS != (ret = remote_stub.fetch_stats(node_stats))) { fprintf(stderr, "fetch server (%s) stats error\n", addr_string); break; } if (store_.current.begin(mod_) == store_.current.end(mod_)) store_.current = node_stats; else store_.current.add(node_stats); } return ret; }
void get_clog_master(MockClient &client) { ObServer server; int err = client.get_clog_master(server, timeout); char addr[256]; fprintf(stdout, "[%s] err=%d\n", __FUNCTION__, err); server.to_string(addr, sizeof(addr)); fprintf(stdout, "%s\n", addr); }
void BalanceTestRpc::run(tbsys::CThread *thread, void *arg) { UNUSED(thread); UNUSED(arg); TBSYS_LOG(INFO, "balance test rpc thread begin"); while(!_stop) { TBSYS_LOG(DEBUG, "balance test rpc thread running"); MigrateMsg *msg = NULL; int ret = pop_migrate_msg(msg); if (OB_SUCCESS == ret) { assert(server_); if (blocked_cs_ == msg->src_cs_) { char addr_buf1[OB_IP_STR_BUFF]; blocked_cs_.to_string(addr_buf1, OB_IP_STR_BUFF); TBSYS_LOG(DEBUG, "drop migrate msg, src_cs=%s", addr_buf1); } else if (blocked_dest_cs_ == msg->dest_cs_) { char addr_buf1[OB_IP_STR_BUFF]; blocked_dest_cs_.to_string(addr_buf1, OB_IP_STR_BUFF); TBSYS_LOG(DEBUG, "drop migrate msg, dest_cs=%s", addr_buf1); } else { server_->migrate_over(msg->range_, msg->src_cs_, msg->dest_cs_, msg->keep_src_, 2); } delete_migrate_msg(msg); } else { usleep(500*1000); } } TBSYS_LOG(INFO, "balance test rpc thread finished"); }
int main(int argc, char ** argv) { UNUSED(argc); UNUSED(argv); int ret = OB_SUCCESS; //char * test = "00596331192663719"; char * test = "00912219024438372"; ObString rowkey; rowkey.assign(test, strlen(test)); char temp[1024]; hex_to_str(rowkey.ptr(), rowkey.length(), temp, 1024); printf("test2str:test[%s], str[%s]\n", test, temp); int64_t ip = 539289610; //488957962; //522512394; ObServer server; server.set_ipv4_addr(ip, 1024); static const int32_t MAX_SERVER_ADDR_SIZE = 128; char server_addr[MAX_SERVER_ADDR_SIZE]; server.to_string(server_addr, MAX_SERVER_ADDR_SIZE); printf("server:[%ld], server[%s]\n", ip, server_addr); return ret; }
int32_t ObClusterStats::refresh() { int ret = 0; ObRole server_type = store_.diff.get_server_type(); if (server_type == OB_ROOTSERVER) { ret = ObServerStats::refresh(); } else if (server_type == OB_UPDATESERVER) { ObServer update_server; ret = rpc_stub_.get_update_server(update_server); ObClientRpcStub update_stub; if (OB_SUCCESS == ret) { ret = update_stub.initialize(update_server, &GFactory::get_instance().get_base_client().get_client_mgr()); } if (OB_SUCCESS == ret) { ret = update_stub.fetch_stats(store_.current); } } else if (server_type == OB_CHUNKSERVER || server_type == OB_MERGESERVER) { ObChunkServerManager obsm; ret = rpc_stub_.rs_dump_cs_info(obsm); if (OB_SUCCESS == ret) { ObChunkServerManager::const_iterator it = obsm.begin(); ObServer node; char ipstr[OB_MAX_SERVER_ADDR_SIZE]; int alive_server_count = 0; while (it != obsm.end()) { node = it->server_; if (server_type == OB_CHUNKSERVER) node.set_port(it->port_cs_); else node.set_port(it->port_ms_); node.to_string(ipstr, OB_MAX_SERVER_ADDR_SIZE); /* fprintf(stderr, "dump server ip:%s, server status:%ld, serving:%d\n", ipstr, it->status_, ObServerStatus::STATUS_SERVING); */ if (it->status_ != ObServerStatus::STATUS_DEAD) { ObClientRpcStub node_stub; ObStatManager node_stats; node_stats.set_server_type(server_type); ret = node_stub.initialize( node, &GFactory::get_instance().get_base_client().get_client_mgr()); if (OB_SUCCESS != ret) { ++it; continue ;} ret = node_stub.fetch_stats(node_stats); //printf("ret=%d, node_stats:%lu\n", ret, node_stats.get_server_type()); if (OB_SUCCESS != ret) { ++it; continue ;} if (alive_server_count == 0) store_.current = node_stats; else store_.current.add(node_stats); ++alive_server_count; } ++it; } if (0 == alive_server_count) { fprintf(stderr, "no any alive servers, cannot collect data.\n"); } } } return ret; }
int ObRootServerRpcStub::get_tablet_info(const common::ObSchemaManagerV2& schema, const uint64_t table_id, const ObRange& range, ObTabletLocation location [],int32_t& size) { int ret = OB_SUCCESS; int32_t index = 0; const ObChunkServer& chunk_server = ObChunkServerMain::get_instance()->get_chunk_server(); const int64_t timeout = chunk_server.get_param().get_network_time_out(); if (OB_INVALID_ID == table_id || size <= 0) { TBSYS_LOG(ERROR,"invalid table id"); ret = OB_ERROR; } ObScanParam param; ObScanner scanner; ObString table_name; const ObTableSchema *table = schema.get_table_schema(table_id); if (NULL == table) { TBSYS_LOG(ERROR,"can not find table %lu",table_id); ret = OB_ERROR; } else { table_name.assign_ptr(const_cast<char *>(table->get_table_name()),strlen(table->get_table_name())); } if (OB_SUCCESS == ret) { param.set(OB_INVALID_ID,table_name,range); //use table name param.set_is_read_consistency(false); } if ((OB_SUCCESS == ret) && ((ret = scan(root_server_,timeout,param,scanner)) != OB_SUCCESS) ) { TBSYS_LOG(ERROR,"get tablet from rootserver failed:[%d]",ret); } ObServer server; char tmp_buf[32]; ObString start_key; ObString end_key; ObCellInfo * cell = NULL; ObScannerIterator iter; bool row_change = false; if (OB_SUCCESS == ret) { int64_t ip = 0; int64_t port = 0; int64_t version = 0; iter = scanner.begin(); ret = iter.get_cell(&cell, &row_change); row_change = false; while((OB_SUCCESS == ret) && index < size) { if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "get cell from scanner iterator failed:ret[%d]", ret); } else if (row_change) { TBSYS_LOG(DEBUG,"row changed,ignore"); hex_dump(cell->row_key_.ptr(),cell->row_key_.length(),false,TBSYS_LOG_LEVEL_INFO); break; //just get one row } else if (cell != NULL) { end_key.assign(cell->row_key_.ptr(), cell->row_key_.length()); if ((cell->column_name_.compare("1_port") == 0) || (cell->column_name_.compare("2_port") == 0) || (cell->column_name_.compare("3_port") == 0)) { ret = cell->value_.get_int(port); TBSYS_LOG(DEBUG,"port is %ld",port); } else if ((cell->column_name_.compare("1_ipv4") == 0) || (cell->column_name_.compare("2_ipv4") == 0) || (cell->column_name_.compare("3_ipv4") == 0)) { ret = cell->value_.get_int(ip); TBSYS_LOG(DEBUG,"ip is %ld",ip); } else if (cell->column_name_.compare("1_tablet_version") == 0 || cell->column_name_.compare("2_tablet_version") == 0 || cell->column_name_.compare("3_tablet_version") == 0) { ret = cell->value_.get_int(version); hex_dump(cell->row_key_.ptr(),cell->row_key_.length(),false,TBSYS_LOG_LEVEL_INFO); TBSYS_LOG(DEBUG,"tablet_version is %d",version); } if (OB_SUCCESS == ret) { if (0 != port && 0 != ip && 0 != version) { server.set_ipv4_addr(ip, port); server.to_string(tmp_buf,sizeof(tmp_buf)); TBSYS_LOG(INFO,"add tablet s:%s,%ld",tmp_buf,version); ObTabletLocation addr(version, server); location[index++] = addr; ip = port = version = 0; } } else { TBSYS_LOG(ERROR, "check get value failed:ret[%d]", ret); } if (++iter == scanner.end()) break; ret = iter.get_cell(&cell, &row_change); } else { //impossible } } } if (OB_SUCCESS == ret) { size = index; TBSYS_LOG(INFO,"get %d tablets from rootserver",size); } return ret; }
// maybe not find a merge server int TaskFactory::get_table_tablet(const char * table_name, const uint64_t table_id, uint64_t & count) { int ret = OB_SUCCESS; ObScanParam scan_param; uint64_t max_len = 0; if (NULL == table_name) { TBSYS_LOG(ERROR, "check table name failed:table[%s], id[%lu]", table_name, table_id); ret = OB_ERROR; } else { ret = init_scan_param(table_name, table_id, max_len, scan_param); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "init scan param failed:table[%s], ret[%d]", table_name, ret); } } if (OB_SUCCESS == ret) { TaskInfo task; task.set_table_id(table_id); task.set_table_name(table_name); // for the first table tablet ObString row_key; char temp_buffer[1]; memset(temp_buffer, 0, sizeof(temp_buffer)); row_key.assign(temp_buffer, sizeof(temp_buffer)); ObGetParam param; ObScanner scanner; ObServer server; ObString start_key; ObString end_key; ObCellInfo * cell = NULL; ObScannerIterator iter; bool row_change = false; ObString name; name.assign(const_cast<char*>(table_name), strlen(table_name)); ObCellInfo temp_cell; temp_cell.table_id_ = table_id; temp_cell.column_id_ = 0; const uint64_t MAX_LEN = 1024; char last_tablet_rowkey[MAX_LEN] = ""; const int32_t MAX_SERVER_ADDR_SIZE = 128; char server_addr[MAX_SERVER_ADDR_SIZE]; while ((OB_SUCCESS == ret) && (!is_max_rowkey(max_len, row_key.ptr(), row_key.length() - 1))) { param.reset(); param.set_is_read_consistency(false); temp_cell.row_key_ = row_key; ret = param.add_cell(temp_cell); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "add cell failed:ret[%d]", ret); break; } ret = rpc_->get(root_server_, timeout_, param, scanner); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "get root table for tablet failed:table[%lu], ret[%d]", table_id, ret); break; } else { // skip the first row iter = scanner.begin(); ++iter; while ((iter != scanner.end()) && (OB_SUCCESS == (ret = iter.get_cell(&cell, &row_change))) && !row_change) { if (NULL == cell) { TBSYS_LOG(ERROR, "%s", "check cell failed"); ret = OB_INNER_STAT_ERROR; break; } start_key.assign(cell->row_key_.ptr(), cell->row_key_.length()); ++iter; } } if (ret == OB_SUCCESS) { int64_t ip = 0; int64_t port = 0; int64_t version = 0; TabletLocation list; for (++iter; iter != scanner.end(); ++iter) { ret = iter.get_cell(&cell, &row_change); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "get cell from scanner iterator failed:ret[%d]", ret); break; } else if (row_change) // && (iter != last_iter)) { ret = init_new_task(name, start_key, end_key, scan_param, task); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "init new task failed:ret[%d]", ret); break; } else { ret = insert_new_task(list, task); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "insert new task failed:ret[%d]", ret); break; } ++count; } list.clear(); start_key = end_key; end_key.assign(cell->row_key_.ptr(), cell->row_key_.length()); } else { end_key.assign(cell->row_key_.ptr(), cell->row_key_.length()); if ((cell->column_name_.compare("1_ms_port") == 0) || (cell->column_name_.compare("2_ms_port") == 0) || (cell->column_name_.compare("3_ms_port") == 0)) { ret = cell->value_.get_int(port); } else if ((cell->column_name_.compare("1_ipv4") == 0) || (cell->column_name_.compare("2_ipv4") == 0) || (cell->column_name_.compare("3_ipv4") == 0)) { ret = cell->value_.get_int(ip); } else if ((cell->column_name_.compare("1_tablet_version") == 0) || (cell->column_name_.compare("2_tablet_version") == 0) || (cell->column_name_.compare("3_tablet_version") == 0)) { ret = cell->value_.get_int(version); if (OB_SUCCESS == ret) { if (0 == port || port == 0) { TBSYS_LOG(WARN, "%s", "check port or ip failed"); } else { server.set_ipv4_addr(ip, port); ObTabletLocation addr(version, server); if (OB_SUCCESS != (ret = list.add(addr))) { TBSYS_LOG(ERROR, "add addr failed:server[%d], port[%d], ret[%d]", server.get_ipv4(), server.get_port(), ret); } else { server.to_string(server_addr, MAX_SERVER_ADDR_SIZE); TBSYS_LOG(DEBUG, "add addr succ:server[%s], version:%ld", server_addr, version); } } ip = port = version = 0; } } if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "check get value failed:ret[%d]", ret); break; } } } // for the last row if ((OB_SUCCESS == ret) && (start_key != end_key)) { ret = init_new_task(name, start_key, end_key, scan_param, task); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "init new task failed:ret[%d]", ret); } else { ret = insert_new_task(list, task); if (ret != OB_SUCCESS) { TBSYS_LOG(ERROR, "insert new task failed:ret[%d]", ret); } ++count; } if (OB_SUCCESS == ret) { // modify last row key for next get root table uint64_t len = end_key.length(); if (MAX_LEN > len + 1) { memcpy(last_tablet_rowkey, end_key.ptr(), len); last_tablet_rowkey[len] = 0; row_key.assign(last_tablet_rowkey, len + 1); } else { TBSYS_LOG(ERROR, "check end key failed:len[%lu]", len); } } } list.clear(); } } } return ret; }
int ObMergerRpcStub::scan( const int64_t timeout, const ObServer & server, const ObScanParam & scan_param, ObScanner & scanner) const { int ret = OB_SUCCESS; ObDataBuffer data_buff; int64_t start_time = tbsys::CTimeUtil::getTime(); ret = get_rpc_buffer(data_buff); // step 1. serialize ObScanParam to the data_buff if (OB_SUCCESS == ret) { ret = scan_param.serialize(data_buff.get_data(), data_buff.get_capacity(), data_buff.get_position()); if (OB_SUCCESS != ret) { TBSYS_LOG(WARN, "serialize scan param failed:ret[%d]", ret); } } // step 2. send request for scan data if (OB_SUCCESS == ret) { ret = rpc_frame_->send_request(server, OB_SCAN_REQUEST, DEFAULT_VERSION, timeout, data_buff); if (ret != OB_SUCCESS) { TBSYS_LOG(WARN, "send scan request to server failed:ret[%d], timeout=%ld", ret, timeout); } } // step 3. deserialize the response result 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(WARN, "deserialize result failed:pos[%ld], ret[%d]", pos, ret); } else { ret = result_code.result_code_; } } // step 4. deserialize the scanner if (OB_SUCCESS == ret) { ret = scanner.deserialize(data_buff.get_data(), data_buff.get_position(), pos); if (OB_SUCCESS != ret) { TBSYS_LOG(WARN, "deserialize scanner from buff failed:pos[%ld], ret[%d]", pos, ret); } } // write debug log const int32_t MAX_SERVER_ADDR_SIZE = 128; char server_addr[MAX_SERVER_ADDR_SIZE]; server.to_string(server_addr, MAX_SERVER_ADDR_SIZE); bool is_fullfilled = false; int64_t fullfilled_item_num = 0; scanner.get_is_req_fullfilled(is_fullfilled,fullfilled_item_num); if (OB_SUCCESS == ret) { TBSYS_LOG(DEBUG, "scan data succ from server:addr[%s]", server_addr); } else { TBSYS_LOG(WARN, "scan data failed from server:addr[%s], " "version_range=%s, ret[%d]", server_addr, range2str(scan_param.get_version_range()), ret); } int64_t consume_time = tbsys::CTimeUtil::getTime() - start_time; if ((double)consume_time > (double)timeout * 0.8) { TBSYS_LOG(WARN, "slow ups scan, ups_addr=%s, timeout=%ld, consume=%ld", server.to_cstring(), timeout, consume_time); } return ret; }