int ObClientManager::do_post_request(const ObServer& server,
const int32_t pcode, const int32_t version,
const int64_t session_id, const int64_t timeout,
const ObDataBuffer& in_buffer,
tbnet::IPacketHandler* handler, void* args) const
{
int rc = OB_SUCCESS;
ObPacket* packet = new (std::nothrow) ObPacket();
if (NULL == packet)
{
rc = OB_ALLOCATE_MEMORY_FAILED;
}
else if (OB_SUCCESS != error_)
{
packet->free();
rc = error_;
TBSYS_LOG(ERROR, "prev_error=%d", error_);
}
else
{
packet->set_packet_code(pcode);
packet->setChannelId(0);
packet->set_source_timeout(timeout);
packet->set_session_id(session_id);
packet->set_api_version(version);
packet->set_data(in_buffer);
if (timeout > max_request_timeout_)
{
max_request_timeout_ = timeout;
connmgr_->setDefaultQueueTimeout(0, static_cast<int32_t>(max_request_timeout_ / 1000));
}
rc = packet->serialize();
if (OB_SUCCESS != rc)
{
TBSYS_LOG(WARN, "packet serialize error");
packet->free();
packet = NULL;
}
else
{
rc = do_post_packet(server, packet, handler, args);
}
}
return rc;
}
int handle_async_request(ObMsSqlRpcEvent & result)
{
int rc = OB_SUCCESS;
ObPacket* packet = new (std::nothrow) ObPacket();
if (NULL == packet)
{
rc = OB_ALLOCATE_MEMORY_FAILED;
}
else
{
ObDataBuffer in_buffer;
int64_t data_len = 2 * 1024 * 1024;
char *data = (char *)ob_malloc(data_len);
const int32_t pcode = OB_SCAN_RESPONSE;
const int32_t version = 1;
const int64_t session_id = 0;
const int64_t timeout = 1000000;
in_buffer.set_data(data, data_len);
// fill scanner to buffer
handle_scan_table(in_buffer);
packet->set_packet_code(pcode);
packet->setChannelId(0);
packet->set_source_timeout(timeout);
packet->set_session_id(session_id);
packet->set_api_version(version);
packet->set_data(in_buffer);
rc = packet->serialize();
result.set_req_type(ObMergerRpcEvent::SCAN_RPC);
result.set_result_code(OB_SUCCESS);
if (rc != OB_SUCCESS)
{
TBSYS_LOG(WARN, "packet serialize error, error: %d", rc);
}
handler.push(&result, packet);
//result.handlePacket(packet, NULL);
}
return OB_SUCCESS;
}
int ObClientManager::get_next(const ObServer& server, const int64_t session_id,
const int64_t timeout, ObDataBuffer& in_buffer, ObDataBuffer& out_buffer) const
{
int rc = OB_SUCCESS;
ObPacket* response = NULL;
//rc = send_request(server, pcode, version, timeout, in_buffer, response);
ObPacket* packet = new (std::nothrow) ObPacket();
if (NULL == packet)
{
rc = OB_ALLOCATE_MEMORY_FAILED;
}
else
{
packet->set_packet_code(OB_SESSION_NEXT_REQUEST);
packet->setChannelId(0);
packet->set_api_version(0);
packet->set_data(in_buffer);
packet->set_source_timeout(timeout);
packet->set_session_id(session_id); //TODO
}
if (OB_SUCCESS == rc)
{
rc = packet->serialize();
if (OB_SUCCESS != rc)
TBSYS_LOG(WARN, "packet serialize error, code=%d", packet->get_packet_code());
}
// serialize failed
if (OB_SUCCESS != rc && NULL != packet)
{
packet->free();
}
if (OB_SUCCESS == rc)
{
rc = do_send_packet(server, packet, timeout, response);
}
// deserialize response packet to out_buffer
if (OB_SUCCESS == rc && NULL != response)
{
// 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;
}