152 lines
4.6 KiB
C++
152 lines
4.6 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#define USING_LOG_PREFIX RPC_OBMYSQL
|
|
#include "rpc/obmysql/ob_sql_sock_handler.h"
|
|
#include "rpc/frame/ob_req_deliver.h"
|
|
#include "rpc/obmysql/ob_sql_sock_processor.h"
|
|
|
|
namespace oceanbase
|
|
{
|
|
using namespace common;
|
|
using namespace observer;
|
|
namespace obmysql
|
|
{
|
|
|
|
int ObSqlSockHandler::init(rpc::frame::ObReqDeliver* deliver)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
deliver_ = deliver;
|
|
return ret;
|
|
}
|
|
|
|
static int get_client_addr_for_sql_sock_session(int fd, ObAddr& client_addr)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
struct sockaddr_storage addr;
|
|
socklen_t addr_len = sizeof(addr);
|
|
|
|
if (getpeername(fd, (struct sockaddr *)&addr, &addr_len) < 0) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("sql nio getpeername failed", K(errno), K(ret));
|
|
} else {
|
|
if (AF_INET == addr.ss_family) {
|
|
struct sockaddr_in *s = (struct sockaddr_in *)&addr;
|
|
if (false == client_addr.set_ipv4_addr(ntohl(s->sin_addr.s_addr), ntohs(s->sin_port))) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("sql nio set_ipv4_addr failed", K(ret));
|
|
}
|
|
} else if (AF_INET6 == addr.ss_family) {
|
|
struct sockaddr_in6 *s = (struct sockaddr_in6 *)&addr;
|
|
if (false == client_addr.set_ipv6_addr((void *)&s->sin6_addr, ntohs(s->sin6_port))) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("sql nio set_ipv6_addr failed", K(ret));
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ObSqlSockHandler::on_connect(void* udata, int fd)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObSqlSockSession* sess = (ObSqlSockSession*)udata;
|
|
new(sess)ObSqlSockSession(conn_cb_, nio_);
|
|
if (OB_FAIL(get_client_addr_for_sql_sock_session(fd, sess->client_addr_))) {
|
|
LOG_WARN("sql nio get_client_addr_for_sql_sock_session failed", K(ret));
|
|
} else if (OB_FAIL(sess->init())) {
|
|
LOG_WARN("sess init failed", K(ret));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObSqlSockHandler::on_close(void* udata, int err)
|
|
{
|
|
UNUSED(err);
|
|
ObSqlSockSession* sess = (ObSqlSockSession*)udata;
|
|
sess->destroy();
|
|
}
|
|
|
|
void ObSqlSockHandler::on_flushed(void* udata)
|
|
{
|
|
ObSqlSockSession* sess = (ObSqlSockSession*)udata;
|
|
sess->on_flushed();
|
|
}
|
|
|
|
/*
|
|
share::ObTenantSpace* global_tenant_space = NULL;
|
|
int process_my_request(rpc::frame::ObReqProcessor& processor, rpc::ObRequest& req)
|
|
{
|
|
ObAddr myaddr;
|
|
ObCurTraceId::set(req.generate_trace_id(myaddr));
|
|
ob_setup_default_tsi_warning_buffer();
|
|
ob_reset_tsi_warning_buffer();
|
|
|
|
processor.set_ob_request(req);
|
|
processor.run();
|
|
ObCurTraceId::reset();
|
|
return 0;
|
|
}
|
|
|
|
int handle_sql_req_inplace(void* udata)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
auto *pm = common::ObPageManager::thread_local_instance();
|
|
pm->set_tenant_ctx(OB_SERVER_TENANT_ID, ObCtxIds::DEFAULT_CTX_ID);
|
|
lib::ContextTLOptGuard guard(true);
|
|
lib::ContextParam param;
|
|
param.set_mem_attr(OB_SERVER_TENANT_ID, ObModIds::OB_SQL_EXECUTOR, ObCtxIds::DEFAULT_CTX_ID)
|
|
.set_properties(lib::USE_TL_PAGE_OPTIONAL)
|
|
.set_ablock_size(lib::INTACT_MIDDLE_AOBJECT_SIZE);
|
|
CREATE_WITH_TEMP_CONTEXT(param) {
|
|
THIS_WORKER.set_allocator(&CURRENT_CONTEXT->get_arena_allocator());
|
|
CREATE_WITH_TEMP_ENTITY(RESOURCE_OWNER, OB_SERVER_TENANT_ID) {
|
|
WITH_ENTITY(global_tenant_space) {
|
|
ObSqlSockSession* sess = (ObSqlSockSession*)udata;
|
|
ret = process_my_request(sess->req_processor_, sess->sock_req_);
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
*/
|
|
int ObSqlSockHandler::on_readable(void* udata)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
rpc::ObPacket *pkt = NULL;
|
|
rpc::ObRequest *sql_req = NULL;
|
|
ObSqlSockSession* sess = (ObSqlSockSession*)udata;
|
|
|
|
if (NULL == sess) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
LOG_ERROR("sess is null!", K(ret));
|
|
} else if (OB_FAIL(sock_processor_.decode_sql_packet(sess->pool_, *sess, NULL, pkt))) {
|
|
LOG_WARN("decode sql req fail", K(ret));
|
|
} else if (NULL == pkt) {
|
|
sess->revert_sock();
|
|
} else if (OB_FAIL(sock_processor_.build_sql_req(*sess, pkt, sql_req))) {
|
|
LOG_WARN("build sql req fail", K(ret));
|
|
}
|
|
|
|
if (OB_SUCCESS != ret || NULL == sql_req) {
|
|
} else if (FALSE_IT(sess->set_last_decode_succ_and_deliver_time(ObTimeUtility::current_time()))) {
|
|
} else if (OB_FAIL(deliver_->deliver(*sql_req))) {
|
|
LOG_WARN("deliver sql request fail", K(ret));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
}; // end namespace obmysql
|
|
}; // end namespace oceanbase
|