int ObClientManager::send_request(const ObServer& server, const int32_t pcode, const int32_t version,
const int64_t timeout, ObDataBuffer& in_buffer, ObDataBuffer& out_buffer, int64_t& session_id) const
{
int rc = OB_SUCCESS;
ObPacket* response = NULL;
rc = do_send_request(server, pcode, version, timeout, in_buffer, response);
// deserialize response packet to out_buffer
if (OB_SUCCESS == rc && NULL != response)
{
session_id = response->get_session_id() ; // TODO
// copy response's inner_buffer to out_buffer.
int64_t data_length = response->get_data_length();
ObDataBuffer* response_buffer = response->get_buffer();
if (out_buffer.get_remain() < data_length)
{
TBSYS_LOG(ERROR, "insufficient memory in out_buffer, remain:%ld, length=%ld",
out_buffer.get_remain(), data_length);
rc = OB_ERROR;
}
else
{
memcpy(out_buffer.get_data() + out_buffer.get_position(),
response_buffer->get_data() + response_buffer->get_position(),
data_length);
out_buffer.get_position() += data_length;
}
}
return rc;
}
int ObRootRpcStub::heartbeat_to_cs(const common::ObServer& cs, const int64_t lease_time, const int64_t frozen_mem_version)
{
int ret = OB_SUCCESS;
static const int MY_VERSION = 2;
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 = common::serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), lease_time)))
{
TBSYS_LOG(ERROR, "failed to serialize, err=%d", ret);
}
else if (OB_SUCCESS != (ret = common::serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), frozen_mem_version)))
{
TBSYS_LOG(ERROR, "failed to serialize, err=%d", ret);
}
else if (OB_SUCCESS != (ret = client_mgr_->post_request(cs, OB_REQUIRE_HEARTBEAT, MY_VERSION, msgbuf)))
{
TBSYS_LOG(WARN, "failed to send request, err=%d", ret);
}
else
{
// success
}
return ret;
}
int MockChunkServer::handle_get_table(ObPacket * ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
if (NULL == data)
{
ret = OB_ERROR;
}
ObGetParam param;
if (OB_SUCCESS == ret)
{
ret = param.deserialize(data->get_data(), data->get_capacity(), data->get_position());
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "%s", "check param failed");
}
}
tbnet::Connection* connection = ob_packet->get_connection();
ThreadSpecificBuffer::Buffer* thread_buffer = response_packet_buffer_.get_buffer();
if (NULL == thread_buffer)
{
ret = OB_ERROR;
}
else
{
thread_buffer->reset();
ObDataBuffer out_buffer(thread_buffer->current(), thread_buffer->remain());
ObResultCode result_msg;
result_msg.result_code_ = ret;
ret = result_msg.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
// fake data cell
ObCellInfo cell;
ObScanner scanner;
ObRowkey row_key;
ObString column_name;
char temp[256] = "";
cell.table_id_ = 101;
for (uint64_t i = 0; i < 10; ++i)
{
snprintf(temp, 256, "chunk_%lu_get_row_key:%lu", i, i);
row_key = make_rowkey(temp, &allocator_);
cell.row_key_ = row_key;
cell.column_id_ = i + 1;
cell.value_.set_int(2234 + i);
scanner.add_cell(cell);
}
scanner.set_is_req_fullfilled(true, 1);
int32_t channel_id = ob_packet->getChannelId();
ret = scanner.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
//
ret = send_response(OB_GET_RESPONSE, 1, out_buffer, connection, channel_id);
}
TBSYS_LOG(INFO, "handle get table result:ret[%d]", ret);
return ret;
}
int append_header_delima(ObDataBuffer &buff)
{
if (buff.get_remain() < 1)
return OB_ERROR;
buff.get_data()[buff.get_position()++] = header_delima;
return OB_SUCCESS;
}
int append_end_rec(ObDataBuffer &buff)
{
char *data = buff.get_data();
int64_t pos = buff.get_position();
int64_t cap = buff.get_remain();
int len = snprintf(data + pos, cap, "\n");
if (len >=0 )
buff.get_position() += len;
return len;
}
int deserialize_result_0(const ObDataBuffer & data_buffer, int64_t & pos, ObResultCode & rc)
{
int ret = OB_SUCCESS;
if (OB_SUCCESS != (ret = rc.deserialize(data_buffer.get_data(), data_buffer.get_position(), pos)))
{
TBSYS_LOG(WARN, "deserialize result code failed. ret:%d, buffer length:%ld, pos:%ld",
ret, data_buffer.get_position(), pos);
}
else
{
ret = rc.result_code_;
}
return ret;
}
int MockRootServer::handle_fetch_schema(ObPacket * ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
if (NULL == data)
{
ret = OB_ERROR;
}
if (OB_SUCCESS == ret)
{
int64_t timestamp = 0;
ret = serialization::decode_vi64(data->get_data(), data->get_capacity(), data->get_position(), ×tamp);
if ((timestamp != 0) && (timestamp != 1024))
{
TBSYS_LOG(ERROR, "check timestamp failed:timestamp[%ld]", timestamp);
ret = OB_ERROR;
}
}
tbnet::Connection* connection = ob_packet->get_connection();
ThreadSpecificBuffer::Buffer* thread_buffer = response_packet_buffer_.get_buffer();
if (NULL == thread_buffer)
{
ret = OB_ERROR;
}
else
{
thread_buffer->reset();
ObDataBuffer out_buffer(thread_buffer->current(), thread_buffer->remain());
ObResultCode result_msg;
result_msg.result_code_ = ret;
ret = result_msg.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
// new version
ObSchemaManagerV2 schema(1025);
tbsys::CConfig conf;
if (!schema.parse_from_file("schema.ini", conf))
{
TBSYS_LOG(ERROR, "%s", "parse from file failed");
}
int32_t channel_id = ob_packet->getChannelId();
ret = schema.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
ret = send_response(OB_REPORT_TABLETS_RESPONSE, 1, out_buffer, connection, channel_id);
}
return ret;
}
int ObClientServerStub::get_frame_buffer(ObDataBuffer & data_buffer) const
{
int ret = OB_SUCCESS;
if (!check_inner_stat())
{
TBSYS_LOG(ERROR, "check inner stat failed.");
ret = OB_ERROR;
}
ThreadSpecificBuffer::Buffer* rpc_buffer = frame_buffer_.get_buffer();
if (OB_SUCCESS == ret)
{
if (NULL == rpc_buffer)
{
TBSYS_LOG(ERROR, "get thread rpc buff failed:buffer[%p].", rpc_buffer);
ret = OB_ERROR;
}
else
{
rpc_buffer->reset();
data_buffer.set_data(rpc_buffer->current(), rpc_buffer->remain());
}
}
return ret;
}
int ObServerRpc::get_frame_buffer(ObDataBuffer& data_buffer) const
{
int ret = OB_SUCCESS;
ThreadSpecificBuffer::Buffer* rpc_buffer = NULL;
if (NULL == rpc_frame_)
{
TBSYS_LOG(WARN, "server rpc doesn't init.");
ret = OB_ERROR;
}
if (OB_SUCCESS == ret)
{
rpc_buffer = frame_buffer_.get_buffer();
if (NULL == rpc_buffer)
{
TBSYS_LOG(WARN, "get thread rpc buff failed,buffer=%p.", rpc_buffer);
ret = OB_ERROR;
}
else
{
rpc_buffer->reset();
data_buffer.set_data(rpc_buffer->current(), rpc_buffer->remain());
}
}
return ret;
}
int ObUpsRpcStub :: get_thread_buffer_(ObDataBuffer& data_buff)
{
int err = OB_SUCCESS;
ThreadSpecificBuffer::Buffer* rpc_buffer = NULL;
// get buffer for rpc send and receive
ObUpdateServerMain* obj = ObUpdateServerMain::get_instance();
if (NULL == obj)
{
TBSYS_LOG(ERROR, "get ObUpdateServerMain instance failed.");
}
else
{
const ObUpdateServer& server = obj->get_update_server();
rpc_buffer = server.get_rpc_buffer();
if (NULL == rpc_buffer)
{
TBSYS_LOG(ERROR, "get thread rpc buff failed:buffer[%p].", rpc_buffer);
err = OB_ERROR;
}
else
{
rpc_buffer->reset();
data_buff.set_data(rpc_buffer->current(), rpc_buffer->remain());
}
}
return err;
}
int ObRootRpcStub::revoke_ups_lease(const common::ObServer& ups, const int64_t lease, const common::ObServer& master, const int64_t timeout_us)
{
int ret = OB_SUCCESS;
ObDataBuffer msgbuf;
ObMsgRevokeLease msg;
msg.lease_ = lease;
msg.ups_master_ = master;
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 = msg.serialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position())))
{
TBSYS_LOG(ERROR, "failed to serialize, err=%d", ret);
}
else if (OB_SUCCESS != (ret = client_mgr_->send_request(ups, OB_RS_UPS_REVOKE_LEASE, msg.MY_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
{
}
}
return ret;
}
int ObRootRpcStub::import_tablets(const common::ObServer& cs, const uint64_t table_id, const int64_t version, 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 = common::serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), table_id)))
{
TBSYS_LOG(ERROR, "failed to serialize keey_src, err=%d", ret);
}
else if (OB_SUCCESS != (ret = common::serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), version)))
{
TBSYS_LOG(ERROR, "failed to serialize keey_src, err=%d", ret);
}
else if (OB_SUCCESS != (ret = client_mgr_->send_request(cs, OB_CS_IMPORT_TABLETS, 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 create tablet, err=%d", result.result_code_);
ret = result.result_code_;
}
else
{
}
}
return ret;
}
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;
msgbuf.get_position() = 0;
if (OB_SUCCESS != (ret = result.deserialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position())))
{
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 ObRootRpcStub::get_last_frozen_version(const common::ObServer& ups, const int64_t timeout_us, int64_t &frozen_version)
{
int ret = OB_SUCCESS;
ObDataBuffer msgbuf;
frozen_version = -1;
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_UPS_GET_LAST_FROZEN_VERSION, 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 create tablet, err=%d", result.result_code_);
ret = result.result_code_;
}
else if (OB_SUCCESS != (ret = serialization::decode_vi64(msgbuf.get_data(), msgbuf.get_position(), pos, &frozen_version)))
{
TBSYS_LOG(WARN, "failed to deserialize frozen version ,err=%d", ret);
frozen_version = -1;
}
else
{
TBSYS_LOG(INFO, "last_frozen_version=%ld", frozen_version);
}
}
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 ObRootRpcStub::get_obi_role(const common::ObServer& master, const int64_t timeout_us, common::ObiRole &obi_role)
{
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(master, OB_GET_OBI_ROLE, 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 get obi_role, err=%d", result.result_code_);
ret = result.result_code_;
}
else if (OB_SUCCESS != (ret = obi_role.deserialize(msgbuf.get_data(), msgbuf.get_position(), pos)))
{
TBSYS_LOG(WARN, "failed to deserialize frozen version ,err=%d", ret);
}
else
{
TBSYS_LOG(INFO, "get obi_role from master, obi_role=%s", obi_role.get_role_str());
}
}
return ret;
}
//append ObScanner to output file
int TaskOutputFile::append(common::ObScanner &scanner)
{
int ret = OB_SUCCESS;
ObDataBuffer buffer;
TBSYS_LOG(DEBUG, "in task output file append");
if (file_ == NULL)
{
TBSYS_LOG(ERROR, "output file is not opened");
ret = OB_ERROR;
}
if (ret == OB_SUCCESS)
{
ret = get_buffer(buffer);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "can't get internal buffer");
}
}
if (ret == OB_SUCCESS)
{
ret = convert_result(scanner, buffer);
if (ret == OB_SUCCESS)
{
TBSYS_LOG(DEBUG, "result buffer len = %d", buffer.get_position());
if (file_->append(buffer) == -1)
{
ret = OB_ERROR;
TBSYS_LOG(ERROR, "can't append buffer to writable file");
}
}
else
{
TBSYS_LOG(ERROR, "convert_result failed");
}
}
return ret;
}
int MockChunkServer::handle_start_merge(ObPacket *ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
int32_t channel_id = ob_packet->getChannelId();
tbnet::Connection* connection = ob_packet->get_connection();
int64_t tmp_version = 0;
if (NULL == data)
{
ret = OB_ERROR;
}
ThreadSpecificBuffer::Buffer* thread_buffer = response_packet_buffer_.get_buffer();
if (NULL == thread_buffer)
{
ret = OB_ERROR;
}
else
{
ret = common::serialization::decode_vi64(data->get_data(), data->get_capacity(), data->get_position(), &tmp_version);
thread_buffer->reset();
ObDataBuffer out_buffer(thread_buffer->current(), thread_buffer->remain());
ObResultCode result_msg;
result_msg.result_code_ = ret;
ret = result_msg.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
if (OB_SUCCESS == ret)
{
ret = send_response(OB_HEARTBEAT_RESPONSE, 1, out_buffer, connection, channel_id);
}
}
TBSYS_LOG(INFO, "handle start merge result:ret[%d]", ret);
if (OB_SUCCESS == ret && tmp_version > version_)
{
version_ = tmp_version;
split_table();
}
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 ObRootRpcStub::set_obi_role(const common::ObServer& ups, const common::ObiRole& role, 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 = role.serialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position())))
{
TBSYS_LOG(WARN, "failed to serialize role, err=%d", ret);
}
else if (OB_SUCCESS != (ret = client_mgr_->send_request(ups, OB_SET_OBI_ROLE, DEFAULT_VERSION, timeout_us, msgbuf)))
{
TBSYS_LOG(WARN, "failed to send request, err=%d", ret);
}
else
{
ObResultCode result_code;
int64_t pos = 0;
if (OB_SUCCESS != (ret = result_code.deserialize(msgbuf.get_data(), msgbuf.get_position(), pos)))
{
TBSYS_LOG(ERROR, "failed to deserialize response, err=%d", ret);
}
else if (OB_SUCCESS != result_code.result_code_)
{
TBSYS_LOG(WARN, "failed to set obi role, err=%d", result_code.result_code_);
ret = result_code.result_code_;
}
}
return ret;
}
int ObRootRpcStub::delete_tablets(const common::ObServer& cs, const common::ObTabletReportInfoList &tablets, 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 = tablets.serialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position())))
{
TBSYS_LOG(ERROR, "failed to serializ, err=%d", ret);
}
else if (OB_SUCCESS != (ret = client_mgr_->send_request(cs, OB_CS_DELETE_TABLETS, 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 delete tablets, err=%d", result.result_code_);
ret = result.result_code_;
}
}
return ret;
}
int ObRootRpcStub::grant_lease_to_ups(const common::ObServer& ups,
const common::ObServer& master, const int64_t lease,
const ObiRole &obi_role,
const int64_t config_version)
{
int ret = OB_SUCCESS;
ObDataBuffer msgbuf;
ObMsgUpsHeartbeat msg;
msg.ups_master_ = master;
msg.self_lease_ = lease;
msg.obi_role_ = obi_role;
UNUSED(config_version);
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 = msg.serialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position())))
{
TBSYS_LOG(ERROR, "failed to serialize msg, err=%d", ret);
}
else if (OB_SUCCESS != (ret = client_mgr_->post_request(ups, OB_RS_UPS_HEARTBEAT, msg.MY_VERSION, msgbuf)))
{
TBSYS_LOG(WARN, "failed to send request, err=%d", ret);
}
else
{
// success
}
return ret;
}
void ObPacketQueue::push(ObPacket* packet)
{
if (packet != NULL)
{
ObPacket* ret_ptr = NULL;
ObDataBuffer* buf = packet->get_packet_buffer();
int64_t size = sizeof(ObPacket) + buf->get_position();
void* return_ptr = NULL;
int err = ring_buffer_.push_task((const void*)packet, size, return_ptr);
if (err == OB_SUCCESS)
{
ret_ptr = (ObPacket*)return_ptr;
ret_ptr->_next = NULL;
if (tail_ == NULL)
{
head_ = ret_ptr;
}
else
{
tail_->_next = ret_ptr;
}
ret_ptr->set_packet_buffer((char*)ret_ptr + sizeof(ObPacket), buf->get_position());
tail_ = ret_ptr;
size_ ++;
}
else
{
TBSYS_LOG(WARN, "push packet into ring buffer failed, size:%ld, err: %d", size, err);
}
}
else
{
TBSYS_LOG(ERROR, "cast packet to ObPacket failed");
}
}
int TaskOutputFile::get_buffer(ObDataBuffer &buffer)
{
int ret = OB_SUCCESS;
ret = buffer_.ensure_space(2 * OB_MAX_PACKET_LENGTH);
if (ret != OB_SUCCESS)
{
TBSYS_LOG(ERROR, "no enough memory for buffer");
}
else
{
buffer.set_data(buffer_.get_buffer(), buffer_.get_buffer_size());
}
return ret;
}
int MockRootServer::handle_register_server(ObPacket * ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data = ob_packet->get_buffer();
if (NULL == data)
{
ret = OB_ERROR;
}
if (OB_SUCCESS == ret)
{
ObServer server;
ret = server.deserialize(data->get_data(), data->get_capacity(), data->get_position());
}
if (OB_SUCCESS == ret)
{
bool is_merger = false;
ret = serialization::decode_bool(data->get_data(), data->get_capacity(), data->get_position(), &is_merger);
if ((ret == OB_SUCCESS) && is_merger)
{
TBSYS_LOG(INFO, "%s", "merge server registered");
}
}
// response
tbnet::Connection* connection = ob_packet->get_connection();
ThreadSpecificBuffer::Buffer* thread_buffer = response_packet_buffer_.get_buffer();
if (NULL == thread_buffer)
{
ret = OB_ERROR;
}
else
{
thread_buffer->reset();
ObDataBuffer out_buffer(thread_buffer->current(), thread_buffer->remain());
ObResultCode result_msg;
result_msg.result_code_ = ret;
result_msg.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
int32_t channel_id = ob_packet->getChannelId();
ret = send_response(OB_REPORT_TABLETS_RESPONSE, 1, out_buffer, connection, channel_id);
}
TBSYS_LOG(INFO, "handle register server result:ret[%d]", ret);
return ret;
}
int ObRootRpcStub::heartbeat_to_ms(
const common::ObServer& ms,
const int64_t lease_time,
const int64_t schema_version,
const common::ObiRole &role,
const int64_t config_version)
{
int ret = OB_SUCCESS;
ObDataBuffer msgbuf;
/*
* VERSION UPDATE LOG:
* - 2012/7/20 xiaochu.yh: add config_version, update MY_VERSION from 3 to 4
*/
static const int MY_VERSION = 4;
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 = common::serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), lease_time)))
{
TBSYS_LOG(ERROR, "failed to serialize, err=%d", ret);
}
else if (OB_SUCCESS != (ret = common::serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), schema_version)))
{
TBSYS_LOG(ERROR, "failed to serialize, err=%d", ret);
}
else if (OB_SUCCESS != (ret = role.serialize(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position())))
{
TBSYS_LOG(ERROR, "failed to serialize, err=%d", ret);
}
else if (OB_SUCCESS != (ret = common::serialization::encode_vi64(msgbuf.get_data(), msgbuf.get_capacity(), msgbuf.get_position(), config_version)))
{
TBSYS_LOG(ERROR, "failed to serialize, err=%d", ret);
}
else if (OB_SUCCESS != (ret = client_mgr_->post_request(ms, OB_REQUIRE_HEARTBEAT, MY_VERSION, msgbuf)))
{
TBSYS_LOG(WARN, "failed to send request, err=%d", ret);
}
else
{
// success
}
return ret;
}
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 ObRpcStub::get_rpc_buffer(ObDataBuffer & data_buffer) const
{
int ret = OB_SUCCESS;
common::ThreadSpecificBuffer::Buffer* rpc_buffer = NULL;
if (!check_inner_stat())
{
TBSYS_LOG(WARN, "check inner stat failed");
ret = OB_INNER_STAT_ERROR;
}
else if (NULL == (rpc_buffer = rpc_buffer_->get_buffer()))
{
TBSYS_LOG(ERROR, "get thread rpc buff failed:buffer[%p].", rpc_buffer);
ret = OB_INNER_STAT_ERROR;
}
else
{
rpc_buffer->reset();
data_buffer.set_data(rpc_buffer->current(), rpc_buffer->remain());
}
return ret;
}
int ObCommitLogReceiver::start_log(ObDataBuffer& buff)
{
int ret = OB_SUCCESS;
ObLogEntry entry;
ret = entry.deserialize(buff.get_data(), buff.get_limit(), buff.get_position());
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "ObLogEntry deserialize error, ret=%d", ret);
}
else
{
if (OB_LOG_SWITCH_LOG != entry.cmd_)
{
TBSYS_LOG(ERROR, "when starting log, the log entry must be SWITCH_LOG");
}
else
{
uint64_t log_id = 0;
ret = serialization::decode_i64(buff.get_data(), buff.get_limit(),
buff.get_position(), (int64_t*)&log_id);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "decode_i64 log_id error, ret=%d", ret);
}
else
{
ret = log_writer_->start_log(log_id, entry.seq_);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "start_log error, log_id=%lu ret=%d", log_id, ret);
}
}
}
}
return ret;
}
