int handle_grant_lease(ObPacket* ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data_buffer = ob_packet->get_buffer();
if (NULL == data_buffer)
{
TBSYS_LOG(ERROR, "data_buffer is NUll should not reach this");
ret = OB_ERROR;
}
else
{
tbnet::Connection* connection = ob_packet->get_connection();
char buf[10 * 1024];
ObDataBuffer out_buffer(buf, sizeof(buf));
ObLease lease;
ret = lease.deserialize(data_buffer->get_data(), data_buffer->get_capacity(),
data_buffer->get_position());
TBSYS_LOG(DEBUG, "recv grant lease request, lease_time=%ld, lease_interval=%ld, "
"ret=%d", lease.lease_time, lease.lease_interval, ret);
ObResultCode response;
response.result_code_ = OB_SUCCESS;
response.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
int32_t version = 1;
int32_t channel_id = ob_packet->getChannelId();
ret = send_response(OB_GRANT_LEASE_RESPONSE, version, out_buffer, connection, channel_id);
TBSYS_LOG(DEBUG, "send grant lease response, ret=%d", ret);
}
return ret;
}
int MockMergeServer::ms_scan(const int64_t start_time,const int32_t version,const int32_t channel_id,tbnet::Connection* connection,common::ObDataBuffer& in_buffer,common::ObDataBuffer& out_buffer,const int64_t timeout_us)
{
ObResultCode rc;
rc.result_code_ = OB_SUCCESS;
int ret = OB_SUCCESS;
const int32_t MS_SCAN_VERSION = 1;
ret = rc.serialize(out_buffer.get_data(), out_buffer.get_capacity(), out_buffer.get_position());
if (OB_SUCCESS == ret)
{
ObScanner result_scanner;
ObCellInfo cell;
cell.table_name_.assign((char*)"table1", 6);
//TODO
char rowkey[30 * 1024];
cell.row_key_.assign(rowkey, 30 * 1024);
cell.column_name_.assign((char*)"column1", 7);
cell.value_.set_int(0xff);
ret = result_scanner.add_cell(cell);
result_scanner.set_is_req_fullfilled(true, 1);
if (OB_SUCCESS == ret)
{
ret = result_scanner.serialize(out_buffer.get_data(),out_buffer.get_capacity(), out_buffer.get_position());
}
if (OB_SUCCESS == ret)
{
ret = this->send_response(OB_SCAN_RESPONSE, MS_SCAN_VERSION, out_buffer, connection, channel_id, 0);
}
}
return ret;
}
int handle_send_log(ObPacket* ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data_buffer = ob_packet->get_buffer();
if (NULL == data_buffer)
{
TBSYS_LOG(ERROR, "data_buffer is NUll should not reach this");
ret = OB_ERROR;
}
else
{
tbnet::Connection* connection = ob_packet->get_connection();
char buf[10 * 1024];
ObDataBuffer out_buffer(buf, sizeof(buf));
ObResultCode response;
response.result_code_ = OB_SUCCESS;
response.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
TBSYS_LOG(DEBUG, "recv send log request, ret=%d", ret);
int32_t version = 1;
int32_t channel_id = ob_packet->getChannelId();
ret = send_response(OB_SEND_LOG_RES, version, out_buffer, connection, channel_id);
TBSYS_LOG(DEBUG, "send log response, ret=%d", ret);
}
return ret;
}
int rpc_cs_drop(ObClientManager& cp,
const ObServer& cs,
int64_t memtable_frozen_version)
{
int ret = OB_SUCCESS;
int64_t start = 0, end = 0;
const int32_t BUFFER_SIZE = 2*1024*1024;
char* param_buffer = new char[BUFFER_SIZE];
ObDataBuffer ob_inout_buffer;
ObResultCode rc;
int64_t return_start_pos = 0;
if (NULL == param_buffer)
{
goto exit;
}
ob_inout_buffer.set_data(param_buffer, BUFFER_SIZE);
ret = encode_i64(ob_inout_buffer.get_data(),
ob_inout_buffer.get_capacity(), ob_inout_buffer.get_position(),memtable_frozen_version);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"serialize memtable_frozen_version into buffer failed\n");
goto exit;
}
// send request;
start = tbsys::CTimeUtil::getTime();
ret = cp.send_request(cs, OB_DROP_OLD_TABLETS, 1, 2000*2000, ob_inout_buffer);
end = tbsys::CTimeUtil::getTime();
fprintf(stderr,"time consume:%ld\n", end - start);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"rpc failed\n");
goto exit;
}
ret = rc.deserialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_position(), return_start_pos);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"deserialize failed\n");
goto exit;
}
fprintf(stderr,"return rc code:%d, msg:%s\n", rc.result_code_, rc.message_.ptr());
if (OB_SUCCESS != rc.result_code_)
{
goto exit;
}
fprintf(stderr,"return_start_pos:%ld, %ld\n", return_start_pos, ob_inout_buffer.get_position());
exit:
if (param_buffer) delete []param_buffer;
return ret;
}
int ObMsSqlRpcEvent::deserialize_packet(ObPacket & packet, ObNewScanner & result)
{
ObDataBuffer * data_buff = NULL;
int ret = packet.deserialize();
if (ret != OB_SUCCESS)
{
TBSYS_LOG(WARN, "deserialize the packet failed:ret[%d]", ret);
}
else
{
data_buff = packet.get_buffer();
if (NULL == data_buff)
{
ret = OB_INNER_STAT_ERROR;
TBSYS_LOG(WARN, "check packet data buff failed:buff[%p]", data_buff);
}
if (packet.get_packet_code() == OB_SESSION_END)
{
/// when session end, set session id to 0
set_session_end();
}
else
{
set_session_id(packet.get_session_id());
}
}
ObResultCode code;
if (OB_SUCCESS == ret)
{
ret = code.deserialize(data_buff->get_data(), data_buff->get_capacity(),
data_buff->get_position());
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "deserialize result failed:pos[%ld], ret[%d]",
data_buff->get_position(), ret);
}
else
{
ObCommonSqlRpcEvent::set_result_code(code.result_code_);
}
}
///
result.clear();
if ((OB_SUCCESS == ret) && (OB_SUCCESS == code.result_code_))
{
ret = result.deserialize(data_buff->get_data(), data_buff->get_capacity(),
data_buff->get_position());
if (ret != OB_SUCCESS)
{
TBSYS_LOG(WARN, "deserialize scanner failed:pos[%ld], ret[%d]",
data_buff->get_position(), ret);
}
}
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;
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 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::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 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_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::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;
}
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::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 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 handle_renew_lease(ObPacket* ob_packet)
{
int ret = OB_SUCCESS;
ObDataBuffer* data_buffer = ob_packet->get_buffer();
if (NULL == data_buffer)
{
TBSYS_LOG(ERROR, "data_buffer is NUll should not reach this");
ret = OB_ERROR;
}
else
{
ObServer slave_addr;
char addr_buf[1024];
ret = slave_addr.deserialize(data_buffer->get_data(), data_buffer->get_capacity(),
data_buffer->get_position());
slave_addr.to_string(addr_buf, sizeof(addr_buf));
addr_buf[sizeof(addr_buf) - 1] = '\0';
TBSYS_LOG(DEBUG, "recv renew lease request, slave_addr=%s, ret=%d", addr_buf, ret);
tbnet::Connection* connection = ob_packet->get_connection();
char buf[10 * 1024];
ObDataBuffer out_buffer(buf, sizeof(buf));
ObResultCode response;
response.result_code_ = OB_SUCCESS;
response.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
int32_t version = 1;
int32_t channel_id = ob_packet->getChannelId();
ret = send_response(OB_RENEW_LEASE_RESPONSE, version, out_buffer, connection, channel_id);
TBSYS_LOG(DEBUG, "send renew lease response, ret=%d", ret);
}
return ret;
}
int ObFileService::receive_file_end(ObString& file_path, ObString& tmp_file_path,
const int64_t file_size, easy_request_t* request, ObDataBuffer& out_buffer,
int32_t& response_cid, const int64_t session_id)
{
int ret = OB_SUCCESS;
struct stat file_stat;
char tmp_path_buf[OB_MAX_FILE_NAME_LENGTH];
char path_buf[OB_MAX_FILE_NAME_LENGTH];
int n = snprintf(tmp_path_buf, OB_MAX_FILE_NAME_LENGTH, "%.*s",
tmp_file_path.length(), tmp_file_path.ptr());
if (n<0 || n>=OB_MAX_FILE_NAME_LENGTH)
{
TBSYS_LOG(ERROR, "failed to get tmp_file_path length[%d] [%.*s]",
n, tmp_file_path.length(), tmp_file_path.ptr());
ret = OB_SIZE_OVERFLOW;
}
else if (stat(tmp_path_buf, &file_stat) != 0)
{
TBSYS_LOG(ERROR, "stat tmp_file_path[%s] failed: %s",
tmp_path_buf, strerror(errno));
ret = OB_IO_ERROR;
}
n = snprintf(path_buf, OB_MAX_FILE_NAME_LENGTH, "%.*s",
file_path.length(), file_path.ptr());
if (OB_SUCCESS == ret && (n<0 || n>=OB_MAX_FILE_NAME_LENGTH))
{
TBSYS_LOG(ERROR, "failed to get path_buf length[%d] [%.*s]",
n, file_path.length(), file_path.ptr());
ret = OB_SIZE_OVERFLOW;
}
if (OB_SUCCESS == ret && file_stat.st_size != file_size)
{
TBSYS_LOG(ERROR, "The size of received tmp file size[%ld], "
"remote file size[%ld]", file_stat.st_size, file_size);
ret = OB_INVALID_DATA;
}
if (OB_SUCCESS == ret && 0 != rename(tmp_path_buf, path_buf))
{
TBSYS_LOG(ERROR, "Rename [%s] to path[%s] failed: errno[%d] %s",
tmp_path_buf, path_buf, errno, strerror(errno));
ret = OB_IO_ERROR;
}
int err = OB_SUCCESS;
ObResultCode rc;
rc.result_code_ = ret;
err = rc.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Encode result code failed:ret=[%d]", err);
}
if (OB_SUCCESS == err)
{
err = server_->send_response(OB_SEND_FILE_REQUEST_RESPONSE, DEFAULT_VERSION,
out_buffer, request, response_cid, session_id);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Send send_file_end_response failed:ret[%d]", err);
}
}
if (OB_SUCCESS == ret && OB_SUCCESS != err)
{
ret = err;
}
return ret;
}
int ObFileService::receive_file_loop(ObString& file_path, ObString& tmp_file_path,
const int64_t file_size, ObFileAppender& file_appender,
easy_request_t* request, ObDataBuffer& out_buffer,
int32_t& response_cid, const int64_t session_id)
{
int ret = OB_SUCCESS;
ObResultCode rc;
ObPacket *next_request = NULL;
if (!file_appender.is_opened())
{
ret = OB_ERR_UNEXPECTED;
TBSYS_LOG(WARN, "File appender is not opened yet in receive_file_loop");
}
//generate block_buf
char *block_buf = NULL;
if (OB_SUCCESS == ret)
{
block_buf = reinterpret_cast<char *>(ob_malloc(block_size_, ObModIds::OB_FILE_CLIENT));
if(NULL == block_buf)
{
ret = OB_ALLOCATE_MEMORY_FAILED;
TBSYS_LOG(WARN, "Allocate memory for block buffer in receive_file_loop"
" failed:err[%d]", ret);
}
}
// do receive file loop
ObDataBuffer *in_buffer = NULL;
while(OB_SUCCESS == ret)
{
ret = queue_thread_->wait_for_next_request(session_id, next_request,
network_timeout_);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "wait for next request fail:ret[%d] "
"network_timeout_[%ld]", ret, network_timeout_);
}
if (OB_SUCCESS == ret)
{
response_cid = next_request->get_channel_id();
request = next_request->get_request();
ret = next_request->deserialize();
if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "Deserialize next request failed:ret[%d]", ret);
}
}
if (OB_SUCCESS == ret)
{
in_buffer = next_request->get_buffer();
if (NULL == in_buffer)
{
ret = OB_INNER_STAT_ERROR;
TBSYS_LOG(WARN, "Get buffer for next request failed");
}
}
if (OB_SUCCESS == ret)
{
ret = rc.deserialize(in_buffer->get_data(), in_buffer->get_capacity(),
in_buffer->get_position());
if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "Decode result code failed: ret=[%d]", ret);
}
}
if (OB_SUCCESS == ret)
{
if (OB_SUCCESS == rc.result_code_) // receive file block
{
ret = receive_file_block(file_appender, block_buf, request,
*in_buffer, out_buffer, response_cid, session_id);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "failed to receive_file_block");
}
//FILL_TRACE_LOG("receive_file_block ");
}
else if (OB_ITER_END == rc.result_code_) // the whole file is received
{
if (file_appender.is_opened())
{
file_appender.close();
}
//FILL_TRACE_LOG("receive_file_end");
ret = receive_file_end(file_path, tmp_file_path, file_size,
request, out_buffer, response_cid, session_id);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "failed to send receive_file_end");
}
break;// end the receive loop
}
}
}
if (NULL != block_buf)
{
ob_free(block_buf);
}
if (file_appender.is_opened())
{
file_appender.close();
}
return ret;
}
int ObRootRpcStub::table_exist_in_cs(const ObServer &cs, const int64_t timeout_us,
const uint64_t table_id, bool &is_exist_in_cs)
{
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(), table_id)))
{
TBSYS_LOG(WARN, "fail to encode table_id, table_id=%ld, ret=%d", table_id, ret);
}
}
if (OB_SUCCESS == ret)
{
if (OB_SUCCESS != (ret = client_mgr_->send_request(cs, OB_CS_CHECK_TABLET, 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);
}
}
if (OB_SUCCESS == ret)
{
if (OB_CS_TABLET_NOT_EXIST == result.result_code_)
{
ret = OB_SUCCESS;
is_exist_in_cs = false;
}
else if (OB_SUCCESS == result.result_code_)
{
is_exist_in_cs = true;
}
else
{
ret = result.result_code_;
TBSYS_LOG(WARN, "fail to check cs tablet. table_id=%lu, cs_addr=%s, err=%d",
table_id, cs.to_cstring(), 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 ObFileService::handle_send_file_request(
const int32_t version,
const int32_t channel_id,
easy_request_t* request,
common::ObDataBuffer& in_buffer,
common::ObDataBuffer& out_buffer)
{
int ret = OB_SUCCESS;
bool inc_concurrency_count_flag = false;
int32_t response_cid = channel_id;
int64_t session_id = queue_thread_->generate_session_id();
const char* src_ip;
//FILL_TRACE_LOG("handle_send_file_request");
if (!inited_)
{
ret = OB_NOT_INIT;
TBSYS_LOG(ERROR, "ob file client is not inited yet.");
}
if (OB_SUCCESS == ret && NULL == request)
{
ret = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "Connection param in receive_file_loop should not be null");
}
if (request != NULL && request->ms != NULL && request->ms->c != NULL)
{
src_ip = get_peer_ip(request);
}
else
{
src_ip = "";
TBSYS_LOG(WARN, "can't get src ip for send_file_request");
}
if (DEFAULT_VERSION != version)
{
ret = OB_ERROR_FUNC_VERSION;
TBSYS_LOG(ERROR, "Can'd handle send_file_request in different version:"
"Server version:%d, Packet version:%d", DEFAULT_VERSION, version);
// send back error message
ObResultCode rc;
rc.result_code_ = OB_ERROR_FUNC_VERSION;
int err = OB_SUCCESS;
out_buffer.get_position() = 0;
err = rc.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Encode result code failed:ret=[%d]", err);
}
else
{
err = server_->send_response(OB_SEND_FILE_REQUEST_RESPONSE,
DEFAULT_VERSION, out_buffer, request, response_cid, session_id);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Send error message for OB_SEND_FILE_REQUEST failed:"
"ret[%d]", err);
}
}
}
if (OB_SUCCESS == ret)
{
ret = inc_concurrency_count();
if(OB_SUCCESS == ret)
{
inc_concurrency_count_flag = true;
}
else
{
// send back error message
ObResultCode rc;
int err = OB_SUCCESS;
rc.result_code_ = ret;
out_buffer.get_position() = 0;
err = rc.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Encode result code failed:ret=[%d]", err);
}
else
{
err = server_->send_response(OB_SEND_FILE_REQUEST_RESPONSE,
DEFAULT_VERSION, out_buffer, request, response_cid, session_id);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Send error message for OB_SEND_FILE_REQUEST failed:"
"ret[%d]", err);
}
}
}
}
// handle...
ObFileAppender file_appender;
int64_t file_size;
ObString file_path;
ObString tmp_file_path;
char file_path_buf[OB_MAX_FILE_NAME_LENGTH];
char tmp_file_path_buf[OB_MAX_FILE_NAME_LENGTH];
int64_t t1 = tbsys::CTimeUtil::getTime();
file_path.assign_buffer(file_path_buf, sizeof(file_path_buf));
tmp_file_path.assign_buffer(tmp_file_path_buf, sizeof(tmp_file_path_buf));
if (OB_SUCCESS == ret)
{
ret = receive_file_pre(file_appender, file_size, file_path, tmp_file_path,
request, in_buffer, out_buffer, response_cid, session_id);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "Prepare for receive_file failed: ret=[%d]", ret);
}
}
if (OB_SUCCESS == ret)
{
ret = receive_file_loop(file_path, tmp_file_path, file_size,
file_appender, request, out_buffer,
response_cid, session_id);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(ERROR, "Reveive_file_loop failed:ret=[%d]", ret);
}
}
int64_t duration = tbsys::CTimeUtil::getTime() - t1;
if (OB_SUCCESS == ret && duration == 0)
{
TBSYS_LOG(ERROR, "duration of recieve time should not be zero");
ret = OB_ERR_UNEXPECTED;
}
if (OB_SUCCESS == ret)
{
TBSYS_LOG(INFO, "Recieve file from server[%s] to file_path[%.*s] "
"tmp_file_path[%.*s] filesize[%ld] time[%ld]us speed[%ld]KB/s",
src_ip, file_path.length(), file_path.ptr(),
tmp_file_path.length(), tmp_file_path.ptr(),
file_size, duration, file_size*1000000/1024/duration);
}
else
{
TBSYS_LOG(ERROR, "Recieve file from server[%s] to file_path[%.*s] "
"tmp_file_path[%.*s] failed, filesize[%ld] cost time[%ld]:ret[%d]",
src_ip, file_path.length(), file_path.ptr(),
tmp_file_path.length(), tmp_file_path.ptr(),
file_size, duration, ret);
}
if (inc_concurrency_count_flag)
{
dec_concurrency_count();
}
int tmp_ret = queue_thread_->destroy_session(session_id);
if (OB_SUCCESS == ret && OB_SUCCESS != tmp_ret)
{
ret = tmp_ret;
}
//PRINT_TRACE_LOG();
return ret;
}
int ObFileService::receive_file_block(ObFileAppender& file_appender,
char* block_buf, easy_request_t* request, ObDataBuffer& in_buffer,
ObDataBuffer& out_buffer, int32_t & response_cid, const int64_t session_id)
{
int err = OB_SUCCESS;
int64_t offset;
int64_t read_size = -1;
//FILL_TRACE_LOG("Start receive_file_block");
if (OB_SUCCESS == err)
{
err = serialization::decode_i64(in_buffer.get_data(),
in_buffer.get_capacity(), in_buffer.get_position(), &offset);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Decode offset failed: err=[%d]", err);
}
}
if (OB_SUCCESS == err)
{
if (NULL == serialization::decode_vstr(in_buffer.get_data(),
in_buffer.get_capacity(), in_buffer.get_position(),
block_buf, block_size_, &read_size))
{
err = OB_DESERIALIZE_ERROR;
TBSYS_LOG(WARN, "Decode block failed");
}
}
//FILL_TRACE_LOG("decode end");
// write file block
if (OB_SUCCESS == err)
{
const bool is_fsync = false;
err = file_appender.append(block_buf, read_size, is_fsync);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Appender file block failed:err=[%d]", err);
}
}
//FILL_TRACE_LOG("append end");
// send response
ObResultCode rc;
int ret = OB_SUCCESS;
rc.result_code_ = err;
if (OB_SUCCESS == ret)
{
ret = rc.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "Encode result code failed:ret=[%d]", ret);
}
}
//FILL_TRACE_LOG("encode end");
if (OB_SUCCESS == ret)
{
ret = queue_thread_->prepare_for_next_request(session_id);
if(OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "prepare for next request fail:ret[%d]", ret);
}
}
if (OB_SUCCESS == ret)
{
ret = server_->send_response(OB_SEND_FILE_REQUEST_RESPONSE, DEFAULT_VERSION,
out_buffer, request, response_cid, session_id);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "Send send_file_end_response failed:ret[%d]", ret);
}
}
//FILL_TRACE_LOG("send response end");
if (OB_SUCCESS == ret && OB_SUCCESS != err)
{
ret = err;
}
return ret;
}
int rpc_cs_migrate(ObClientManager& cp,
const ObServer& src,
const ObServer& dest,
const ObRange& range,
bool keep_src)
{
int ret = OB_SUCCESS;
int64_t start = 0, end = 0;
const int32_t BUFFER_SIZE = 2*1024*1024;
char* param_buffer = new char[BUFFER_SIZE];
ObDataBuffer ob_inout_buffer;
ObResultCode rc;
int64_t return_start_pos = 0;
if (NULL == param_buffer)
{
goto exit;
}
ob_inout_buffer.set_data(param_buffer, BUFFER_SIZE);
ret = range.serialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_capacity(), ob_inout_buffer.get_position());
if (OB_SUCCESS != ret)
{
fprintf(stderr,"serialize migrate range into buffer failed\n");
goto exit;
}
ret = dest.serialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_capacity(), ob_inout_buffer.get_position());
if (OB_SUCCESS != ret)
{
fprintf(stderr,"serialize dest_server into buffer failed\n");
goto exit;
}
ret = encode_bool(ob_inout_buffer.get_data(),ob_inout_buffer.get_capacity(),ob_inout_buffer.get_position(),keep_src);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"serialize keep_src into buffer failed\n");
goto exit;
}
// send request;
start = tbsys::CTimeUtil::getTime();
ret = cp.send_request(src, OB_CS_MIGRATE, 1, 2000*2000, ob_inout_buffer);
end = tbsys::CTimeUtil::getTime();
fprintf(stderr,"time consume:%ld\n", end - start);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"rpc failed\n");
goto exit;
}
ret = rc.deserialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_position(), return_start_pos);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"deserialize failed\n");
goto exit;
}
fprintf(stderr,"return rc code:%d, msg:%s\n", rc.result_code_, rc.message_.ptr());
if (OB_SUCCESS != rc.result_code_)
{
goto exit;
}
fprintf(stderr,"return_start_pos:%ld, %ld\n", return_start_pos, ob_inout_buffer.get_position());
exit:
if (param_buffer) delete []param_buffer;
return ret;
}
int rpc_cs_get(ObClientManager& cp,
const ObServer& cs,
const ObGetParam& get_param,
ObScanner& scanner)
{
int ret = OB_SUCCESS;
int64_t start = 0, end = 0;
const int32_t BUFFER_SIZE = 2*1024*1024;
char* param_buffer = new char[BUFFER_SIZE];
ObDataBuffer ob_inout_buffer;
ObResultCode rc;
int64_t return_start_pos = 0;
if (NULL == param_buffer)
{
goto exit;
}
ob_inout_buffer.set_data(param_buffer, BUFFER_SIZE);
ret = get_param.serialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_capacity(), ob_inout_buffer.get_position());
if (OB_SUCCESS != ret)
{
fprintf(stderr,"serialize get_param into buffer failed\n");
goto exit;
}
// send request;
start = tbsys::CTimeUtil::getTime();
ret = cp.send_request(cs, OB_GET_REQUEST, 1, 2000*2000, ob_inout_buffer);
end = tbsys::CTimeUtil::getTime();
fprintf(stderr,"time consume:%ld\n", end - start);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"rpc failed\n");
goto exit;
}
ret = rc.deserialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_position(), return_start_pos);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"deserialize obscanner failed\n");
goto exit;
}
fprintf(stderr,"return rc code:%d, msg:%s\n", rc.result_code_, rc.message_.ptr());
if (OB_SUCCESS != rc.result_code_)
{
goto exit;
}
fprintf(stderr,"return_start_pos:%ld, %ld\n", return_start_pos, ob_inout_buffer.get_position());
// deserialize output
ret = scanner.deserialize(ob_inout_buffer.get_data(),
ob_inout_buffer.get_position(), return_start_pos);
if (OB_SUCCESS != ret)
{
fprintf(stderr,"deserialize obscanner failed\n");
goto exit;
}
fprintf(stderr,"return_start_pos:%ld, %ld\n", return_start_pos, ob_inout_buffer.get_position());
exit:
if (param_buffer) delete []param_buffer;
return ret;
}
int ObFileService::receive_file_pre(ObFileAppender& file_appender,
int64_t& file_size, ObString& file_path, ObString& tmp_file_path,
easy_request_t* request, ObDataBuffer& in_buffer,
ObDataBuffer& out_buffer, int32_t& response_cid, const int64_t session_id)
{
int err = OB_SUCCESS;
if (OB_SUCCESS == err)
{
err = serialization::decode_i64(in_buffer.get_data(),
in_buffer.get_capacity(), in_buffer.get_position(), &file_size);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Decode file_info failed: err=[%d]", err);
}
}
char dest_dir_buf[OB_MAX_FILE_NAME_LENGTH];
ObString dest_dir;
dest_dir.assign_buffer(dest_dir_buf, sizeof(dest_dir_buf));
if (OB_SUCCESS == err)
{
err = dest_dir.deserialize(in_buffer.get_data(), in_buffer.get_capacity(),
in_buffer.get_position());
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Decode dest_dir failed:err=[%d]", err);
}
}
char dest_file_name_buf[OB_MAX_FILE_NAME_LENGTH];
ObString dest_file_name;
dest_file_name.assign_buffer(dest_file_name_buf, sizeof(dest_file_name_buf));
if (OB_SUCCESS == err)
{
err = dest_file_name.deserialize(in_buffer.get_data(),
in_buffer.get_capacity(), in_buffer.get_position());
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Decode dest_file_name failed:err=[%d]", err);
}
}
// check dir
if (OB_SUCCESS == err)
{
err = check_dir(dest_dir, file_size);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "Check dir failed:err=[%d]", err);
}
}
// generate tmp_file_path and file_path
char file_path_buf[OB_MAX_FILE_NAME_LENGTH];
char tmp_file_path_buf[OB_MAX_FILE_NAME_LENGTH];
if (OB_SUCCESS == err)
{
const char tmp_file_prefix[]= "tmp_";
int64_t count = 0;
count = snprintf(file_path_buf, OB_MAX_FILE_NAME_LENGTH, "%.*s/%.*s",
dest_dir.length(), dest_dir.ptr(), dest_file_name.length(), dest_file_name.ptr());
if (count<0 || count >= OB_MAX_FILE_NAME_LENGTH)
{
err = OB_SIZE_OVERFLOW;
TBSYS_LOG(WARN, "snprintf file name failed, return[%ld] [%.*s]/[%.*s]",
count, dest_dir.length(), dest_dir.ptr(), dest_file_name.length(), dest_file_name.ptr());
}
count = file_path.write(file_path_buf,
static_cast<ObString::obstr_size_t>(strlen(file_path_buf)));
if (count != static_cast<int>(strlen(file_path_buf)))
{
err = OB_SIZE_OVERFLOW;
TBSYS_LOG(WARN, "Write file_path_buf to ObString failed");
}
count = snprintf(tmp_file_path_buf, OB_MAX_FILE_NAME_LENGTH, "%.*s/%s%.*s",
dest_dir.length(), dest_dir.ptr(), tmp_file_prefix, dest_file_name.length(), dest_file_name.ptr());
if (count <0 || count >= OB_MAX_FILE_NAME_LENGTH)
{
err = OB_SIZE_OVERFLOW;
TBSYS_LOG(WARN, "snprintf tmp file name failed, return[%ld] [%.*s]/[%s][%.*s]",
count, dest_dir.length(), dest_dir.ptr(), tmp_file_prefix, dest_file_name.length(), dest_file_name.ptr());
}
count = tmp_file_path.write(tmp_file_path_buf,
static_cast<ObString::obstr_size_t>(strlen(tmp_file_path_buf)));
if (count != static_cast<int>(strlen(tmp_file_path_buf)))
{
err = OB_SIZE_OVERFLOW;
TBSYS_LOG(WARN, "Write tmp_file_path_buf to ObString failed");
}
}
// check if the tmp_file and the dest file exist already
if (OB_SUCCESS == err)
{
if (0 == access(tmp_file_path_buf, F_OK))
{
TBSYS_LOG(WARN, "Tmp file [%s] already exists", tmp_file_path_buf);
err = OB_FILE_ALREADY_EXIST;
}
if (0 == access(file_path_buf, F_OK))
{
TBSYS_LOG(WARN, "File [%s] already exists", file_path_buf);
err = OB_FILE_ALREADY_EXIST;
}
}
// log operation
if (OB_SUCCESS == err)
{
TBSYS_LOG(INFO, "start receive file: dir[%.*s] file_name[%.*s] "
"tmp_file_path[%.*s] from server [%s]",
dest_dir.length(), dest_dir.ptr(),
dest_file_name.length(), dest_file_name.ptr(),
tmp_file_path.length(), tmp_file_path.ptr(),
get_peer_ip(request));
}
// open tmp file
if (OB_SUCCESS == err)
{
bool is_dio = true;
bool is_create = true;
bool is_trunc = true;
err = file_appender.open(tmp_file_path, is_dio, is_create, is_trunc);
if (OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "open file_appender failed:tmp_file[%.*s] err[%d]",
tmp_file_path.length(), tmp_file_path.ptr(), err);
}
}
// send response
ObResultCode rc;
int ret = OB_SUCCESS;
rc.result_code_ = err;
out_buffer.get_position() = 0;
if (OB_SUCCESS == ret)
{
ret = rc.serialize(out_buffer.get_data(), out_buffer.get_capacity(),
out_buffer.get_position());
if(OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "Serialize result code failed:ret=[%d]", ret);
}
}
if(OB_SUCCESS == ret)
{
ret = queue_thread_->prepare_for_next_request(session_id);
if(OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "prepare for next request fail:ret=[%d]", ret);
}
}
if (OB_SUCCESS == ret)
{
ret = server_->send_response(OB_SEND_FILE_REQUEST_RESPONSE, DEFAULT_VERSION,
out_buffer, request, response_cid, session_id);
if (OB_SUCCESS != ret)
{
TBSYS_LOG(WARN, "Send send_file_request_response failed:ret=[%d]", ret);
}
}
if (OB_SUCCESS == ret && OB_SUCCESS != err)
{
ret = err;
}
return ret;
}
