hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
8fb62754a18349688baec464fce0bde8241b1753
oceanbase/src/sql/engine/cmd/ob_alter_system_executor.cpp
hnwyllmm 59e975f9d7 fix typo
2023-01-12 19:02:33 +08:00

2236 lines
90 KiB
C++
Raw Blame History

/**
* 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 SQL_ENG
#include "lib/utility/ob_tracepoint.h"
#include "sql/engine/cmd/ob_alter_system_executor.h"
#include "share/ob_force_print_log.h"
#include "share/ob_common_rpc_proxy.h"
#include "share/inner_table/ob_inner_table_schema.h"
#include "share/backup/ob_backup_struct.h"
#include "observer/ob_server.h"
#include "sql/resolver/cmd/ob_bootstrap_stmt.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/executor/ob_task_executor_ctx.h"
#include "sql/plan_cache/ob_plan_cache_manager.h"
#include "sql/session/ob_sql_session_info.h"
#include "share/scheduler/ob_sys_task_stat.h"
#include "lib/allocator/page_arena.h"
#include "lib/utility/ob_tracepoint.h"
#include "observer/ob_server_event_history_table_operator.h"
#include "observer/omt/ob_multi_tenant.h"
#include "share/rc/ob_context.h"
#include "observer/ob_server_struct.h"
#include "observer/mysql/ob_mysql_request_manager.h"
#include "share/rc/ob_tenant_base.h"
#include "share/scheduler/ob_dag_warning_history_mgr.h"
#include "observer/omt/ob_tenant.h" //ObTenant
#include "rootserver/freeze/ob_major_freeze_helper.h" //ObMajorFreezeHelper
#include "share/ob_primary_standby_service.h" // ObPrimaryStandbyService
namespace oceanbase
{
using namespace common;
using namespace obrpc;
using namespace share;
using namespace omt;
using namespace obmysql;
namespace sql
{
int ObFreezeExecutor::execute(ObExecContext &ctx, ObFreezeStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc_proxy = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_FAIL(task_exec_ctx->get_common_rpc(common_rpc_proxy))) {
LOG_WARN("get common rpc proxy failed", K(ret));
} else if (OB_ISNULL(common_rpc_proxy)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("common_rpc_proxy is null", K(ret));
} else {
if (!stmt.is_major_freeze()) {
const uint64_t local_tenant_id = MTL_ID();
bool freeze_all = stmt.is_freeze_all();
ObRootMinorFreezeArg arg;
if (OB_FAIL(arg.tenant_ids_.assign(stmt.get_tenant_ids()))) {
LOG_WARN("failed to assign tenant_ids", K(ret));
} else if (OB_FAIL(arg.server_list_.assign(stmt.get_server_list()))) {
LOG_WARN("failed to assign server_list", K(ret));
} else {
arg.zone_ = stmt.get_zone();
arg.tablet_id_ = stmt.get_tablet_id();
}
if (OB_SUCC(ret)) {
// get all tenants to freeze
if (freeze_all) {
if (OB_ISNULL(GCTX.schema_service_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid GCTX", KR(ret));
} else if (OB_FAIL(GCTX.schema_service_->get_tenant_ids(arg.tenant_ids_))) {
LOG_WARN("fail to get all tenant ids", KR(ret));
}
// get local tenant to freeze if there is no any parameter except server_list
} else if (arg.tenant_ids_.empty() &&
arg.zone_.is_empty() &&
!arg.tablet_id_.is_valid() &&
!freeze_all) {
if (!is_sys_tenant(local_tenant_id) || arg.server_list_.empty()) {
if (OB_FAIL(arg.tenant_ids_.push_back(local_tenant_id))) {
LOG_WARN("failed to push back tenant_id", KR(ret));
}
}
// get local tenant to freeze if there is no any parameter
} else if (0 == arg.tenant_ids_.count() &&
0 == arg.server_list_.count() &&
arg.zone_.is_empty() &&
!arg.tablet_id_.is_valid() &&
!freeze_all) {
if (OB_FAIL(arg.tenant_ids_.push_back(local_tenant_id))) {
LOG_WARN("failed to push back tenant_id", KR(ret));
}
}
}
// access check:
// not allow user_tenant to freeze other tenants
if (OB_SUCC(ret) && !is_sys_tenant(local_tenant_id)) {
if (arg.tenant_ids_.count() > 1 ||
(!arg.tenant_ids_.empty() && local_tenant_id != arg.tenant_ids_[0])) {
ret = OB_ERR_NO_PRIVILEGE;
LOG_WARN("user_tenant cannot freeze other tenants", K(ret), K(local_tenant_id), K(arg));
}
}
if (OB_SUCC(ret)) {
int64_t timeout = THIS_WORKER.get_timeout_remain();
if (OB_FAIL(common_rpc_proxy->timeout(timeout).root_minor_freeze(arg))) {
LOG_WARN("minor freeze rpc failed", K(arg), K(ret), K(timeout), "dst", common_rpc_proxy->get_server());
}
}
} else {
rootserver::ObMajorFreezeParam param;
param.freeze_all_ = stmt.is_freeze_all();
param.transport_ = GCTX.net_frame_->get_req_transport();
for (int64_t i = 0; (i < stmt.get_tenant_ids().count()) && OB_SUCC(ret); ++i) {
uint64_t tenant_id = stmt.get_tenant_ids().at(i);
if (OB_FAIL(param.add_freeze_info(tenant_id))) {
LOG_WARN("fail to assign", KR(ret), K(tenant_id));
}
}
if (OB_SUCC(ret)) {
ObArray<int> merge_results; // save each tenant's major_freeze result, so use 'int' type
if (OB_FAIL(rootserver::ObMajorFreezeHelper::major_freeze(param, merge_results))) {
LOG_WARN("fail to major freeze", KR(ret), K(param), K(merge_results));
} else if (merge_results.count() > 0) {
bool is_frozen_exist = false;
bool is_merge_not_finish = false;
for (int64_t i = 0; i < merge_results.count(); ++i) {
if (OB_FROZEN_INFO_ALREADY_EXIST == merge_results.at(i)) {
is_frozen_exist = true;
} else if (OB_MAJOR_FREEZE_NOT_FINISHED == merge_results.at(i)) {
is_merge_not_finish = true;
}
}
if (is_frozen_exist || is_merge_not_finish) {
char buf[1024] = "larger frozen_scn already exist, some tenants' prev merge may not finish";
if (merge_results.count() > 1) {
LOG_USER_WARN(OB_FROZEN_INFO_ALREADY_EXIST, buf);
} else {
STRCPY(buf, "larger frozen_scn already exist, prev merge may not finish");
LOG_USER_WARN(OB_FROZEN_INFO_ALREADY_EXIST, buf);
}
}
}
LOG_INFO("finish do major freeze", KR(ret), K(param), K(merge_results));
}
}
}
return ret;
}
int ObFlushCacheExecutor::execute(ObExecContext &ctx, ObFlushCacheStmt &stmt)
{
int ret = OB_SUCCESS;
if (!stmt.is_global_) { // flush local
int64_t tenant_num = stmt.flush_cache_arg_.tenant_ids_.count();
int64_t db_num = stmt.flush_cache_arg_.db_ids_.count();
common::ObString sql_id = stmt.flush_cache_arg_.sql_id_;
switch (stmt.flush_cache_arg_.cache_type_) {
case CACHE_TYPE_LIB_CACHE: {
if (OB_ISNULL(GCTX.sql_engine_->get_plan_cache_manager())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("plan cache manager is null");
} else if (stmt.flush_cache_arg_.ns_type_ != ObLibCacheNameSpace::NS_INVALID) {
ObLibCacheNameSpace ns = stmt.flush_cache_arg_.ns_type_;
if (0 == tenant_num) { // purge in tenant level, aka. coarse-grained plan evict
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_all_lib_cache_by_ns(ns);
} else {
for (int64_t i = 0; i < tenant_num; ++i) { //ignore ret
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_lib_cache_by_ns(
stmt.flush_cache_arg_.tenant_ids_.at(i), ns);
}
}
} else {
if (0 == tenant_num) { // purge in tenant level, aka. coarse-grained plan evict
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_all_lib_cache();
} else {
for (int64_t i = 0; i < tenant_num; ++i) { //ignore ret
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_lib_cache(
stmt.flush_cache_arg_.tenant_ids_.at(i));
}
}
}
break;
}
case CACHE_TYPE_PLAN: {
if (OB_ISNULL(GCTX.sql_engine_->get_plan_cache_manager())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("plan cache manager is null");
} else if (stmt.flush_cache_arg_.is_fine_grained_) {
// purge in sql_id level, aka. fine-grained plan evict
// we assume tenant_list must not be empty and this will be checked in resolve phase
if (0 == tenant_num) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected tenant_list in fine-grained plan evict", K(tenant_num));
} else {
for (int64_t i = 0; i < tenant_num; i++) { // ignore ret
int64_t t_id = stmt.flush_cache_arg_.tenant_ids_.at(i);
if (db_num == 0) { // not specified db_name, evcit all dbs
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_plan_cache_by_sql_id(t_id, OB_INVALID_ID, sql_id);
} else { // evict db by db
for(int64_t j = 0; j < db_num; j++) { // ignore ret
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_plan_cache_by_sql_id(
t_id, stmt.flush_cache_arg_.db_ids_.at(j), sql_id);
}
}
}
}
} else if (0 == tenant_num) { // purge in tenant level, aka. coarse-grained plan evict
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_all_plan_cache();
} else {
for (int64_t i = 0; i < tenant_num; ++i) { //ignore ret
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_plan_cache(
stmt.flush_cache_arg_.tenant_ids_.at(i));
}
}
break;
}
case CACHE_TYPE_SQL_AUDIT: {
if (0 == tenant_num) {
common::ObArray<uint64_t> tenant_ids;
if (OB_ISNULL(GCTX.omt_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null of GCTX.omt_", K(ret));
} else if (OB_FAIL(GCTX.omt_->get_mtl_tenant_ids(tenant_ids))) {
LOG_WARN("fail to get_mtl_tenant_ids", K(ret));
}
if (OB_SUCC(ret)) {
for (int64_t i = 0; i < tenant_ids.size(); i++) { // ignore internal error
const uint64_t tenant_id = tenant_ids.at(i);
MTL_SWITCH(tenant_id) {
ObMySQLRequestManager *req_mgr = MTL(ObMySQLRequestManager*);
req_mgr->clear_queue();
} else if (OB_TENANT_NOT_IN_SERVER == ret) {
ret = OB_SUCCESS;
} else {
LOG_WARN("fail to switch to tenant", K(ret), K(tenant_id));
}
}
}
} else {
for (int64_t i = 0; i < tenant_num; i++) { // ignore ret
const uint64_t tenant_id = stmt.flush_cache_arg_.tenant_ids_.at(i);
MTL_SWITCH(tenant_id) {
ObMySQLRequestManager *req_mgr = MTL(ObMySQLRequestManager*);
req_mgr->clear_queue();
} else if (OB_TENANT_NOT_IN_SERVER == ret) {
ret = OB_SUCCESS;
} else {
LOG_WARN("fail to switch to tenant", K(ret), K(tenant_id));
}
}
}
break;
}
case CACHE_TYPE_PL_OBJ: {
if (0 == tenant_num) {
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_all_pl_cache();
} else {
for (int64_t i = 0; i < tenant_num; i++) { // ignore internal err code
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_pl_cache(stmt.flush_cache_arg_.tenant_ids_.at(i));
}
}
break;
}
case CACHE_TYPE_PS_OBJ: {
if (0 == tenant_num) {
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_all_ps_cache();
} else {
for (int64_t i = 0; i < tenant_num; i++) { // ignore internal err code
ret = GCTX.sql_engine_->get_plan_cache_manager()->flush_ps_cache(stmt.flush_cache_arg_.tenant_ids_.at(i));
}
}
break;
}
//case CACHE_TYPE_BALANCE: {
// ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
// obrpc::ObCommonRpcProxy *common_rpc_proxy = NULL;
// if (OB_ISNULL(task_exec_ctx)) {
// ret = OB_NOT_INIT;
// LOG_WARN("get task executor context failed");
// } else if (OB_FAIL(task_exec_ctx->get_common_rpc(common_rpc_proxy))) {
// LOG_WARN("get common rpc proxy failed", K(ret));
// } else if (OB_ISNULL(common_rpc_proxy)) {
// ret = OB_ERR_UNEXPECTED;
// LOG_WARN("common_rpc_proxy is null", K(ret));
// } else if (OB_FAIL(common_rpc_proxy->flush_balance_info())) {
// LOG_WARN("fail to flush balance info", K(ret));
// }
// break;
//}
case CACHE_TYPE_ALL:
case CACHE_TYPE_COLUMN_STAT:
case CACHE_TYPE_BLOCK_INDEX:
case CACHE_TYPE_BLOCK:
case CACHE_TYPE_ROW:
case CACHE_TYPE_BLOOM_FILTER:
case CACHE_TYPE_CLOG:
case CACHE_TYPE_ILOG:
case CACHE_TYPE_SCHEMA: {
ret = OB_NOT_SUPPORTED;
LOG_WARN("cache type not supported flush",
"type", stmt.flush_cache_arg_.cache_type_,
K(ret));
} break;
case CACHE_TYPE_LOCATION: {
// TODO: @wangzhennan.wzn
ret = OB_NOT_SUPPORTED;
LOG_WARN("location cache not supported to flush");
} break;
default: {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid cache type", "type", stmt.flush_cache_arg_.cache_type_);
}
}
} else { // flush global
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_flush_cache(
stmt.flush_cache_arg_))) {
LOG_WARN("flush cache rpc failed", K(ret), "rpc_arg", stmt.flush_cache_arg_);
}
}
return ret;
}
int ObFlushKVCacheExecutor::execute(ObExecContext &ctx, ObFlushKVCacheStmt &stmt)
{
UNUSED(stmt);
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else {
share::schema::ObSchemaGetterGuard schema_guard;
if (OB_FAIL(GCTX.schema_service_->get_tenant_schema_guard(
ctx.get_my_session()->get_effective_tenant_id(),
schema_guard))) {
LOG_WARN("get_schema_guard failed", K(ret));
} else {
if (stmt.tenant_name_.is_empty() && stmt.cache_name_.is_empty()) {
if (OB_FAIL(common::ObKVGlobalCache::get_instance().erase_cache())) {
LOG_WARN("clear kv cache failed", K(ret));
} else {
LOG_INFO("success erase all kvcache", K(ret));
}
} else if (!stmt.tenant_name_.is_empty() && stmt.cache_name_.is_empty()) {
uint64_t tenant_id = OB_INVALID_ID;
if (OB_FAIL(schema_guard.get_tenant_id(ObString::make_string(stmt.tenant_name_.ptr()), tenant_id)) ||
OB_INVALID_ID == tenant_id) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("tenant not found", K(ret));
} else if (OB_FAIL(common::ObKVGlobalCache::get_instance().erase_cache(tenant_id))) {
LOG_WARN("clear kv cache failed", K(ret));
} else {
LOG_INFO("success erase tenant kvcache", K(ret), K(tenant_id));
}
} else if (!stmt.tenant_name_.is_empty() && !stmt.cache_name_.is_empty()) {
uint64_t tenant_id = OB_INVALID_ID;
if (OB_FAIL(schema_guard.get_tenant_id(ObString::make_string(stmt.tenant_name_.ptr()), tenant_id)) ||
OB_INVALID_ID == tenant_id) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("tenant not found", K(ret));
} else if (OB_FAIL(common::ObKVGlobalCache::get_instance().erase_cache(tenant_id, stmt.cache_name_.ptr()))) {
LOG_WARN("clear kv cache failed", K(ret));
} else {
LOG_INFO("success erase tenant kvcache", K(ret), K(tenant_id), K(stmt.cache_name_));
}
} else if (stmt.tenant_name_.is_empty() && !stmt.cache_name_.is_empty()) {
if (OB_FAIL(common::ObKVGlobalCache::get_instance().erase_cache(stmt.cache_name_.ptr()))) {
LOG_WARN("clear kv cache failed", K(ret));
} else {
LOG_INFO("success erase kvcache", K(ret), K(stmt.cache_name_));
}
}
}
}
return ret;
}
int ObFlushIlogCacheExecutor::execute(ObExecContext &ctx, ObFlushIlogCacheStmt &stmt)
{
UNUSEDx(ctx, stmt);
int ret = OB_NOT_SUPPORTED;
// ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
// obrpc::ObCommonRpcProxy *common_rpc = NULL;
// if (OB_ISNULL(task_exec_ctx)) {
// ret = OB_NOT_INIT;
// LOG_WARN("get task executor context failed");
// } else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
// ret = OB_NOT_INIT;
// LOG_WARN("get task exec ctx error", K(ret), KP(task_exec_ctx));
// } else {
// int32_t file_id = stmt.file_id_;
// if (file_id < 0) {
// ret = OB_INVALID_ARGUMENT;
// LOG_ERROR("invalid file_id when execute flush ilogcache", K(ret), K(file_id));
// } else if (NULL == GCTX.par_ser_) {
// ret = OB_ERR_UNEXPECTED;
// LOG_ERROR("par_ser is null", K(ret), KP(GCTX.par_ser_));
// } else {
// // flush all file if file_id is default value 0
// if (0 == file_id) {
// if (OB_FAIL(GCTX.par_ser_->admin_wash_ilog_cache())) {
// LOG_WARN("cursor cache wash ilog error", K(ret));
// }
// } else {
// if (OB_FAIL(GCTX.par_ser_->admin_wash_ilog_cache(file_id))) {
// LOG_WARN("cursor cache wash ilog error", K(ret), K(file_id));
// }
// }
// }
// }
return ret;
}
int ObFlushDagWarningsExecutor::execute(ObExecContext &ctx, ObFlushDagWarningsStmt &stmt)
{
UNUSED(stmt);
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get task exec ctx error", K(ret), KP(task_exec_ctx));
} else {
share::ObDagWarningHistoryManager::get_instance().clear();
}
return ret;
}
int ObAdminServerExecutor::execute(ObExecContext &ctx, ObAdminServerStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = NULL;
ObCommonRpcProxy *common_proxy = NULL;
if (OB_ISNULL(task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx))) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor failed", K(ret));
} else if (OB_ISNULL(common_proxy = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(ret));
} else {
ObAdminServerArg arg;
if (OB_FAIL(arg.servers_.assign(stmt.get_server_list()))) {
LOG_WARN("assign failed", K(ret));
} else {
arg.zone_ = stmt.get_zone();
}
if (OB_FAIL(ret)) {
// nothing
} else if (ObAdminServerArg::ADD == stmt.get_op()) {
if (OB_FAIL(common_proxy->add_server(arg))) {
LOG_WARN("common rpc proxy add server failed", K(arg), K(ret));
}
} else if (ObAdminServerArg::CANCEL_DELETE == stmt.get_op()) {
if (OB_FAIL(common_proxy->cancel_delete_server(arg))) {
LOG_WARN("common rpc proxy cancel delete server failed", K(arg), K(ret));
}
} else if (ObAdminServerArg::DELETE == stmt.get_op()) {
if (OB_FAIL(common_proxy->delete_server(arg))) {
LOG_WARN("common rpc proxy delete server failed", K(arg), K(ret), "dst", common_proxy->get_server());
}
} else if (ObAdminServerArg::START == stmt.get_op()) {
if (OB_FAIL(common_proxy->start_server(arg))) {
LOG_WARN("common rpc proxy start server failed", K(arg), K(ret));
}
} else if (ObAdminServerArg::STOP == stmt.get_op()
|| ObAdminServerArg::FORCE_STOP == stmt.get_op()
|| ObAdminServerArg::ISOLATE == stmt.get_op()) {
if (ObAdminServerArg::FORCE_STOP == stmt.get_op()) {
arg.force_stop_ = true;
arg.op_ = ObAdminServerArg::FORCE_STOP;
} else if (ObAdminServerArg::ISOLATE == stmt.get_op()) {
arg.op_ = ObAdminServerArg::ISOLATE;
} else {
arg.force_stop_ = false;
arg.op_ = ObAdminServerArg::STOP;
}
int64_t timeout = THIS_WORKER.get_timeout_remain();
if (OB_FAIL(common_proxy->timeout(timeout).stop_server(arg))) {
LOG_WARN("common rpc proxy stop server failed", K(arg), K(ret));
} else if (ObAdminServerArg::STOP == stmt.get_op()
|| ObAdminServerArg::FORCE_STOP == stmt.get_op()) {
// check whether all leaders are switched out
ObMySQLProxy *sql_proxy = ctx.get_sql_proxy();
const int64_t idx = 0;
const int64_t retry_interval_us = 1000l * 1000l; // 1s
ObSqlString sql;
if (OB_FAIL(sql.assign_fmt(
"SELECT CAST(COUNT(*) AS SIGNED) FROM %s "
"WHERE role = 'LEADER' and (svr_ip, svr_port) IN (",
share::OB_CDB_OB_LS_LOCATIONS_TNAME))) {
LOG_WARN("assign_fmt failed", K(ret));
} else {
const int64_t size = arg.servers_.size();
for (int64_t idx = 0; OB_SUCC(ret) && idx < size; ++idx) {
const ObAddr &server = arg.servers_[idx];
char svr_ip[MAX_IP_ADDR_LENGTH] = "\0";
if (!server.is_valid()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("addr is not vaild", K(ret), K(server));
} else if (!server.ip_to_string(svr_ip, sizeof(svr_ip))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("format ip str failed", K(ret), K(server));
} else {
// server-zone mapping has been checked in rootservice
if (idx == (size - 1)) {
if (OB_FAIL(sql.append_fmt(
"('%s','%d'))", svr_ip, server.get_port()))) {
LOG_WARN("append_fmt failed", K(ret));
}
} else {
if (OB_FAIL(sql.append_fmt(
"('%s','%d'), ", svr_ip, server.get_port()))) {
LOG_WARN("append_fmt failed", K(ret));
}
}
}
}
}
bool stop = false;
while (OB_SUCC(ret) && !stop) {
SMART_VAR(ObMySQLProxy::MySQLResult, res) {
sqlclient::ObMySQLResult *result = NULL;
const int64_t rpc_timeout = THIS_WORKER.get_timeout_remain();
obrpc::Bool can_stop(true /* default value */);
int64_t leader_cnt = 0;
if (0 > THIS_WORKER.get_timeout_remain()) {
ret = OB_WAIT_LEADER_SWITCH_TIMEOUT;
LOG_WARN("wait switching out leaders from all servers timeout", K(ret));
} else if (OB_FAIL(THIS_WORKER.check_status())) {
LOG_WARN("ctx check status failed", K(ret));
}
if (OB_FAIL(ret)) {
} else if (!can_stop) {
} else if (OB_FAIL(sql_proxy->read(res, sql.ptr()))) {
if (OB_RS_SHUTDOWN == ret || OB_RS_NOT_MASTER == ret) {
// switching rs, sleep and retry
ret = OB_SUCCESS;
} else {
LOG_WARN("execute sql failed", K(ret), K(sql));
}
} else if (OB_ISNULL(result = res.get_result())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get result failed", K(ret));
} else if (OB_FAIL(result->next())) {
if (OB_ITER_END == ret) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("result is empty", K(ret));
} else {
LOG_WARN("get next result failed", K(ret));
}
} else if (OB_FAIL(result->get_int(idx, leader_cnt))) {
if (OB_ERR_NULL_VALUE == ret) {
// __all_virtual_server_stat is not ready, sleep and retry
ret = OB_SUCCESS;
} else {
LOG_WARN("get sum failed", K(ret));
}
} else if (0 == leader_cnt) {
stop = true;
} else {
LOG_INFO("waiting switching leaders out", K(ret), "left count", leader_cnt);
ob_usleep(retry_interval_us);
}
}
}
}
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected op", "type", static_cast<int64_t>(stmt.get_op()));
}
}
return ret;
}
int ObAdminZoneExecutor::execute(ObExecContext &ctx, ObAdminZoneStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = NULL;
ObCommonRpcProxy *common_proxy = NULL;
if (OB_ISNULL(task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx))) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor failed", K(ret));
} else if (OB_ISNULL(common_proxy = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(ret));
} else {
const ObAdminZoneArg &arg = stmt.get_arg();
ObString first_stmt;
if (OB_FAIL(stmt.get_first_stmt(first_stmt))) {
LOG_WARN("fail to get first stmt" , K(ret));
} else {
const_cast<obrpc::ObAdminZoneArg&>(arg).sql_stmt_str_ = first_stmt;
}
if (OB_FAIL(ret)) {
} else if (ObAdminZoneArg::ADD == stmt.get_op()) {
if (OB_FAIL(common_proxy->add_zone(arg))) {
LOG_WARN("common rpc proxy add zone failed", K(arg), K(ret));
}
} else if (ObAdminZoneArg::DELETE == stmt.get_op()) {
if (OB_FAIL(common_proxy->delete_zone(arg))) {
LOG_WARN("common rpc proxy delete zone failed", K(arg), K(ret));
}
} else if (ObAdminZoneArg::START == stmt.get_op()) {
if (OB_FAIL(common_proxy->start_zone(arg))) {
LOG_WARN("common rpc proxy start zone failed", K(arg), K(ret));
}
} else if (ObAdminZoneArg::STOP == stmt.get_op()
|| ObAdminZoneArg::FORCE_STOP == stmt.get_op()
|| ObAdminZoneArg::ISOLATE == stmt.get_op()) {
int64_t timeout = THIS_WORKER.get_timeout_remain();
if (OB_FAIL(common_proxy->timeout(timeout).stop_zone(arg))) {
LOG_WARN("common rpc proxy stop zone failed", K(arg), K(ret), "dst",
common_proxy->get_server());
} else if (ObAdminZoneArg::STOP == stmt.get_op()
|| ObAdminZoneArg::FORCE_STOP == stmt.get_op()) {
// check whether all leaders are switched out
ObMySQLProxy *sql_proxy = ctx.get_sql_proxy();
const int64_t idx = 0;
const int64_t retry_interval_us = 1000l * 1000l; // 1s
bool stop = false;
while (OB_SUCC(ret) && !stop) {
ObSqlString sql;
SMART_VAR(ObMySQLProxy::MySQLResult, res) {
sqlclient::ObMySQLResult *result = NULL;
const int64_t rpc_timeout = THIS_WORKER.get_timeout_remain();
obrpc::Bool can_stop(true /* default value */);
int64_t leader_cnt = 0;
if (0 > THIS_WORKER.get_timeout_remain()) {
ret = OB_WAIT_LEADER_SWITCH_TIMEOUT;
LOG_WARN("wait switching out all leaders timeout", K(ret));
} else if (OB_FAIL(THIS_WORKER.check_status())) {
LOG_WARN("ctx check status failed", K(ret));
}
if (OB_FAIL(ret)) {
} else if (!can_stop) {
} else if (OB_FAIL(sql.assign_fmt(
"SELECT CAST(COUNT(*) AS SIGNED) FROM %s WHERE role = 'LEADER' AND zone = '%s'",
share::OB_CDB_OB_LS_LOCATIONS_TNAME, arg.zone_.ptr()))) {
LOG_WARN("assign_fmt failed", K(ret));
} else if (OB_FAIL(sql_proxy->read(res, sql.ptr()))) {
if (OB_RS_SHUTDOWN == ret || OB_RS_NOT_MASTER == ret) {
// switching rs, sleep and retry
ret = OB_SUCCESS;
} else {
LOG_WARN("execute sql failed", K(ret), K(sql));
}
} else if (OB_ISNULL(result = res.get_result())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get result failed", K(ret));
} else if (OB_FAIL(result->next())) {
if (OB_ITER_END == ret) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("result is empty", K(ret));
} else {
LOG_WARN("get next result failed", K(ret));
}
} else if (OB_FAIL(result->get_int(idx, leader_cnt))) {
if (OB_ERR_NULL_VALUE == ret) {
ret = OB_SUCCESS;
ObSqlString this_sql;
SMART_VAR(ObMySQLProxy::MySQLResult, this_res) {
sqlclient::ObMySQLResult *this_result = NULL;
int64_t server_cnt = -1;
if (OB_FAIL(this_sql.assign_fmt("select count(*) from %s where zone = '%s'",
share::OB_ALL_SERVER_TNAME, arg.zone_.ptr()))) {
LOG_WARN("fail to assign fmt", K(ret));
} else if (OB_FAIL(sql_proxy->read(this_res, this_sql.ptr()))) {
LOG_WARN("fail to execute sql", K(ret), K(this_sql));
} else if (OB_ISNULL(this_result = this_res.get_result())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("fail to get result", K(ret));
} else if (OB_FAIL(this_result->next())) {
LOG_WARN("get result error", K(ret));
} else if (OB_FAIL(this_result->get_int(0L, server_cnt))) {
LOG_WARN("fail to get result", K(ret));
} else if (0 == server_cnt) {
// no server in this zone;
stop = true;
} else {
// __all_virtual_server_stat is not ready, sleep and retry
}
}
} else {
LOG_WARN("get sum failed", K(ret));
}
} else if (0 == leader_cnt) {
stop = true;
} else {
LOG_INFO("waiting switching leaders out", K(ret), "left count", leader_cnt);
ob_usleep(retry_interval_us);
}
}
}
} else {} // force stop, no need to wait leader switch
} else if (ObAdminZoneArg::MODIFY == stmt.get_op()) {
if (OB_FAIL(common_proxy->alter_zone(arg))) {
LOG_WARN("common rpc proxy alter zone failed", K(arg), K(ret));
}
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected op: %ld", "type", stmt.get_op());
}
}
return ret;
}
int ObSwitchReplicaRoleExecutor::execute(ObExecContext &ctx, ObSwitchReplicaRoleStmt &stmt)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(ctx.get_my_session())) {
ret = OB_NOT_INIT;
LOG_WARN("session should not be null");
} else {
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_switch_replica_role(
stmt.get_rpc_arg()))) {
LOG_WARN("switch replica role rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
}
return ret;
}
int ObSwitchRSRoleExecutor::execute(ObExecContext &ctx, ObSwitchRSRoleStmt &stmt)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(ctx.get_my_session())) {
ret = OB_NOT_INIT;
LOG_WARN("session should not be null");
} else {
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_switch_rs_role(
stmt.get_rpc_arg()))) {
LOG_WARN("switch rootserver role rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
}
return ret;
}
int ObReportReplicaExecutor::execute(ObExecContext &ctx, ObReportReplicaStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_report_replica(
stmt.get_rpc_arg()))) {
LOG_WARN("report replica rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObRecycleReplicaExecutor::execute(ObExecContext &ctx, ObRecycleReplicaStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_recycle_replica(
stmt.get_rpc_arg()))) {
LOG_WARN("recycle replica rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObAdminMergeExecutor::execute(ObExecContext &ctx, ObAdminMergeStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_merge(
stmt.get_rpc_arg()))) {
LOG_WARN("admin merge rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObAdminRecoveryExecutor::execute(ObExecContext &ctx, ObAdminRecoveryStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_recovery(
stmt.get_rpc_arg()))) {
LOG_WARN("admin merge rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObClearRoottableExecutor::execute(ObExecContext &ctx, ObClearRoottableStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_clear_roottable(
stmt.get_rpc_arg()))) {
LOG_WARN("clear roottable rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObRefreshSchemaExecutor::execute(ObExecContext &ctx, ObRefreshSchemaStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_refresh_schema(
stmt.get_rpc_arg()))) {
LOG_WARN("refresh schema rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObRefreshMemStatExecutor::execute(ObExecContext &ctx, ObRefreshMemStatStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_refresh_memory_stat(
stmt.get_rpc_arg()))) {
LOG_WARN("refresh memory stat rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObWashMemFragmentationExecutor::execute(ObExecContext &ctx, ObWashMemFragmentationStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_wash_memory_fragmentation(
stmt.get_rpc_arg()))) {
LOG_WARN("sync wash fragment rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObRefreshIOCalibraitonExecutor::execute(ObExecContext &ctx, ObRefreshIOCalibraitonStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_refresh_io_calibration(stmt.get_rpc_arg()))) {
LOG_WARN("refresh io calibration rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObSetConfigExecutor::execute(ObExecContext &ctx, ObSetConfigStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_set_config(stmt.get_rpc_arg()))) {
LOG_WARN("set config rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObSetTPExecutor::execute(ObExecContext &ctx, ObSetTPStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(task_exec_ctx->get_common_rpc()->admin_set_tracepoint(
stmt.get_rpc_arg()))) {
LOG_WARN("set tracepoint rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
LOG_INFO("set tracepoint rpc", K(stmt.get_rpc_arg()));
return ret;
}
int ObMigrateUnitExecutor::execute(ObExecContext &ctx, ObMigrateUnitStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_migrate_unit(
stmt.get_rpc_arg()))) {
LOG_WARN("migrate unit rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObClearLocationCacheExecutor::execute(ObExecContext &ctx, ObClearLocationCacheStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_clear_location_cache(
stmt.get_rpc_arg()))) {
LOG_WARN("clear location cache rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObReloadUnitExecutor::execute(ObExecContext &ctx, ObReloadUnitStmt &stmt)
{
int ret = OB_SUCCESS;
UNUSED(stmt);
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_reload_unit())) {
LOG_WARN("reload unit rpc failed", K(ret));
}
return ret;
}
int ObReloadServerExecutor::execute(ObExecContext &ctx, ObReloadServerStmt &stmt)
{
int ret = OB_SUCCESS;
UNUSED(stmt);
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_reload_server())) {
LOG_WARN("reload server rpc failed", K(ret));
}
return ret;
}
int ObReloadZoneExecutor::execute(ObExecContext &ctx, ObReloadZoneStmt &stmt)
{
int ret = OB_SUCCESS;
UNUSED(stmt);
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_reload_zone())) {
LOG_WARN("reload zone rpc failed", K(ret));
}
return ret;
}
int ObClearMergeErrorExecutor::execute(ObExecContext &ctx, ObClearMergeErrorStmt &stmt)
{
int ret = OB_SUCCESS;
UNUSED(stmt);
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->admin_clear_merge_error(stmt.get_rpc_arg()))) {
LOG_WARN("clear merge error rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObUpgradeVirtualSchemaExecutor ::execute(
ObExecContext &ctx, ObUpgradeVirtualSchemaStmt &stmt)
{
int ret = OB_SUCCESS;
UNUSED(stmt);
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
int64_t timeout = THIS_WORKER.get_timeout_remain();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->timeout(timeout).admin_upgrade_virtual_schema())) {
LOG_WARN("upgrade virtual schema rpc failed", K(ret));
}
return ret;
}
int ObAdminUpgradeCmdExecutor::execute(ObExecContext &ctx, ObAdminUpgradeCmdStmt &stmt)
{
int ret = OB_SUCCESS;
obrpc::Bool upgrade = true;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
int64_t timeout = THIS_WORKER.get_timeout_remain();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else {
if (ObAdminUpgradeCmdStmt::BEGIN == stmt.get_op()) {
upgrade = true;
if (OB_FAIL(common_rpc->timeout(timeout).admin_upgrade_cmd(upgrade))) {
LOG_WARN("begin upgrade rpc failed", K(ret));
}
} else if (ObAdminUpgradeCmdStmt::END == stmt.get_op()) {
upgrade = false;
if (OB_FAIL(common_rpc->timeout(timeout).admin_upgrade_cmd(upgrade))) {
LOG_WARN("end upgrade rpc failed", K(ret));
}
}
}
return ret;
}
int ObAdminRollingUpgradeCmdExecutor::execute(ObExecContext &ctx, ObAdminRollingUpgradeCmdStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
int64_t timeout = THIS_WORKER.get_timeout_remain();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else {
ObAdminRollingUpgradeArg arg;
if (ObAdminRollingUpgradeCmdStmt::BEGIN == stmt.get_op()) {
arg.stage_ = obrpc::OB_UPGRADE_STAGE_DBUPGRADE;
if (OB_FAIL(common_rpc->timeout(timeout).admin_rolling_upgrade_cmd(arg))) {
LOG_WARN("begin upgrade rpc failed", K(ret));
}
} else if (ObAdminRollingUpgradeCmdStmt::END == stmt.get_op()) {
arg.stage_ = obrpc::OB_UPGRADE_STAGE_POSTUPGRADE;
if (OB_FAIL(common_rpc->timeout(timeout).admin_rolling_upgrade_cmd(arg))) {
LOG_WARN("end upgrade rpc failed", K(ret));
}
}
}
return ret;
}
int ObRunJobExecutor::execute(
ObExecContext &ctx, ObRunJobStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
int64_t timeout = THIS_WORKER.get_timeout_remain();
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->timeout(timeout).run_job(
stmt.get_rpc_arg()))) {
LOG_WARN("run job rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObRunUpgradeJobExecutor::execute(
ObExecContext &ctx, ObRunUpgradeJobStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
int64_t timeout = THIS_WORKER.get_timeout_remain();
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->timeout(timeout).run_upgrade_job(
stmt.get_rpc_arg()))) {
LOG_WARN("run job rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObStopUpgradeJobExecutor::execute(
ObExecContext &ctx, ObStopUpgradeJobStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
int64_t timeout = THIS_WORKER.get_timeout_remain();
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->timeout(timeout).run_upgrade_job(
stmt.get_rpc_arg()))) {
LOG_WARN("run job rpc failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
int ObBootstrapExecutor::execute(ObExecContext &ctx, ObBootstrapStmt &stmt)
{
int ret = OB_SUCCESS;
const int64_t BS_TIMEOUT = 600 * 1000 * 1000; // 10 minutes
ObTaskExecutorCtx *task_exec_ctx = NULL;
obrpc::ObSrvRpcProxy *srv_rpc_proxy = NULL;
obrpc::ObBootstrapArg &bootstarp_arg = stmt.bootstrap_arg_;
int64_t rpc_timeout = BS_TIMEOUT;
if (INT64_MAX != THIS_WORKER.get_timeout_ts()) {
rpc_timeout = max(THIS_WORKER.get_timeout_remain(), BS_TIMEOUT);
}
LOG_INFO("bootstrap timeout", K(rpc_timeout));
if (OB_ISNULL(task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx))) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(srv_rpc_proxy = task_exec_ctx->get_srv_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed");
} else if (OB_FAIL(srv_rpc_proxy->to(task_exec_ctx->get_self_addr()).timeout(rpc_timeout).bootstrap(bootstarp_arg))) {
LOG_WARN("rpc proxy bootstrap failed", K(ret), K(rpc_timeout));
BOOTSTRAP_LOG(WARN, "STEP_0.1:alter_system execute fail");
} else {
BOOTSTRAP_LOG(INFO, "STEP_0.1:alter_system execute success");
}
return ret;
}
int ObRefreshTimeZoneInfoExecutor::execute(ObExecContext &ctx, ObRefreshTimeZoneInfoStmt &stmt)
{
int ret = OB_SUCCESS;
UNUSED(ctx);
UNUSED(stmt);
// 226改为定时刷新tz_map, RS与其他server间也不再同步tz_version
// 所以不再需要执行refresh timezone info触发RS刷新tz map
ret = OB_NOT_SUPPORTED;
LOG_USER_ERROR(OB_NOT_SUPPORTED, "alter system refresh time_zone_info ");
return ret;
}
int ObEnableSqlThrottleExecutor::execute(ObExecContext &ctx, ObEnableSqlThrottleStmt &stmt)
{
int ret = OB_SUCCESS;
ObMySQLProxy *sql_proxy = ctx.get_sql_proxy();
ObSqlString sql;
if (OB_ISNULL(sql_proxy)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get sql proxy from ctx fail", K(ret));
} else if (OB_FAIL(sql.assign_fmt(
"SET "
"GLOBAL sql_throttle_priority=%ld,"
"GLOBAL sql_throttle_rt=%.6lf,"
"GLOBAL sql_throttle_cpu=%.6lf,"
"GLOBAL sql_throttle_io=%ld,"
"GLOBAL sql_throttle_network=%.6lf,"
"GLOBAL sql_throttle_logical_reads=%ld",
stmt.get_priority(),
stmt.get_rt(),
stmt.get_cpu(),
stmt.get_io(),
stmt.get_queue_time(),
stmt.get_logical_reads()))) {
LOG_WARN("assign_fmt failed", K(stmt), K(ret));
} else {
int64_t affected_rows = 0;
if (OB_FAIL(sql_proxy->write(
GET_MY_SESSION(ctx)->get_priv_tenant_id(),
sql.ptr(),
affected_rows))) {
LOG_WARN("execute sql fail", K(sql), K(stmt), K(ret));
}
}
return ret;
}
int ObDisableSqlThrottleExecutor::execute(ObExecContext &ctx, ObDisableSqlThrottleStmt &stmt)
{
int ret = OB_SUCCESS;
ObMySQLProxy *sql_proxy = ctx.get_sql_proxy();
ObSqlString sql;
if (OB_ISNULL(sql_proxy)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get sql proxy from ctx fail", K(ret));
} else if (OB_FAIL(sql.assign_fmt(
"SET "
"GLOBAL sql_throttle_priority=%ld,"
"GLOBAL sql_throttle_rt=%.6lf,"
"GLOBAL sql_throttle_cpu=%.6lf,"
"GLOBAL sql_throttle_io=%ld,"
"GLOBAL sql_throttle_network=%.6lf,"
"GLOBAL sql_throttle_logical_reads=%ld",
-1L,
-1.0,
-1.0,
-1L,
-1.0,
-1L))) {
LOG_WARN("assign_fmt failed", K(stmt), K(ret));
} else {
int64_t affected_rows = 0;
if (OB_FAIL(sql_proxy->write(
GET_MY_SESSION(ctx)->get_priv_tenant_id(),
sql.ptr(),
affected_rows))) {
LOG_WARN("execute sql fail", K(sql), K(stmt), K(ret));
}
}
return ret;
}
int ObCancelTaskExecutor::execute(ObExecContext &ctx, ObCancelTaskStmt &stmt)
{
int ret = OB_SUCCESS;
ObAddr task_server;
share::ObTaskId task_id;
bool is_local_task = false;
LOG_INFO("cancel sys task log",
K(stmt.get_task_id()), K(stmt.get_task_type()), K(stmt.get_cmd_type()));
if (NULL == GCTX.ob_service_ || NULL == GCTX.srv_rpc_proxy_) {
ret = OB_ERR_SYS;
LOG_ERROR("GCTX must not inited", K(ret), KP(GCTX.srv_rpc_proxy_), KP(GCTX.ob_service_));
} else if (OB_FAIL(parse_task_id(stmt.get_task_id(), task_id))) {
LOG_WARN("failed to parse task id", K(ret), K(stmt.get_task_id()));
} else if (OB_FAIL(SYS_TASK_STATUS_MGR.task_exist(task_id, is_local_task))) {
LOG_WARN("failed to check is local task", K(ret), K(task_id));
} else if (is_local_task) {
if (OB_FAIL(GCTX.ob_service_->cancel_sys_task(task_id))) {
LOG_WARN("failed to cancel sys task at local", K(ret), K(task_id));
}
} else {
if (OB_FAIL(fetch_sys_task_info(ctx, stmt.get_task_id(), task_server))) {
LOG_WARN("failed to fetch sys task info", K(ret));
} else if (!task_server.is_valid() || task_id.is_invalid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid task info", K(ret), K(task_server), K(task_id));
} else {
obrpc::ObCancelTaskArg rpc_arg;
rpc_arg.task_id_ = task_id;
if (OB_FAIL(GCTX.srv_rpc_proxy_->to(task_server).cancel_sys_task(rpc_arg))) {
LOG_WARN("failed to cancel remote sys task", K(ret), K(task_server), K(rpc_arg));
} else {
LOG_INFO("succeed to cancel sys task at remote", K(task_server), K(rpc_arg));
}
}
}
return ret;
}
int ObCancelTaskExecutor::fetch_sys_task_info(
ObExecContext &ctx,
const common::ObString &task_id,
common::ObAddr &task_server)
{
int ret = OB_SUCCESS;
SMART_VAR(ObMySQLProxy::MySQLResult, res) {
ObMySQLProxy *sql_proxy = ctx.get_sql_proxy();
sqlclient::ObMySQLResult *result_set = NULL;
ObSQLSessionInfo *cur_sess = ctx.get_my_session();
ObSqlString read_sql;
char svr_ip[OB_IP_STR_BUFF] = "";
int64_t svr_port = 0;
int64_t tmp_real_str_len = 0;
const char *sql_str = "select svr_ip, svr_port, task_type "
" from oceanbase.__all_virtual_sys_task_status "
" where task_id = '%.*s'";
char task_type_str[common::OB_SYS_TASK_TYPE_LENGTH] = "";
task_server.reset();
//execute sql
if (OB_ISNULL(sql_proxy) || OB_ISNULL(cur_sess)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("sql proxy or session from exec context is NULL", K(ret), K(sql_proxy), K(cur_sess));
} else if (OB_FAIL(read_sql.append_fmt(sql_str, task_id.length(), task_id.ptr()))) {
LOG_WARN("fail to generate sql", K(ret), K(read_sql), K(*cur_sess), K(task_id));
} else if (OB_FAIL(sql_proxy->read(res, read_sql.ptr()))) {
LOG_WARN("fail to read by sql proxy", K(ret), K(read_sql));
} else if (OB_ISNULL(result_set = res.get_result())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("result set is NULL", K(ret), K(read_sql));
} else if (OB_FAIL(result_set->next())) {
if (OB_LIKELY(OB_ITER_END == ret)) {
ret = OB_ENTRY_NOT_EXIST;
LOG_WARN("task id not exist", K(ret), K(result_set), K(task_id));
} else {
LOG_WARN("fail to get next row", K(ret), K(result_set));
}
} else {
EXTRACT_STRBUF_FIELD_MYSQL(*result_set, "svr_ip", svr_ip, OB_IP_STR_BUFF, tmp_real_str_len);
EXTRACT_INT_FIELD_MYSQL(*result_set, "svr_port", svr_port, int64_t);
EXTRACT_STRBUF_FIELD_MYSQL(*result_set, "task_type", task_type_str, OB_SYS_TASK_TYPE_LENGTH, tmp_real_str_len);
UNUSED(tmp_real_str_len);
}
//set addr
if (OB_SUCC(ret)) {
if (OB_UNLIKELY(OB_ITER_END != result_set->next())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("more than one sessid record", K(ret), K(read_sql));
} else if (OB_UNLIKELY(!task_server.set_ip_addr(svr_ip, static_cast<int32_t>(svr_port)))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("fail to set ip_addr", K(ret), K(svr_ip), K(svr_port));
}
}
}
return ret;
}
int ObCancelTaskExecutor::parse_task_id(
const common::ObString &task_id_str, share::ObTaskId &task_id)
{
int ret = OB_SUCCESS;
char task_id_buf[common::OB_TRACE_STAT_BUFFER_SIZE] = "";
task_id.reset();
int n = snprintf(task_id_buf, sizeof(task_id_buf), "%.*s",
task_id_str.length(), task_id_str.ptr());
if (n < 0 || n >= sizeof(task_id_buf)) {
ret = common::OB_BUF_NOT_ENOUGH;
LOG_WARN("task id buf not enough", K(ret), K(n), K(task_id_str));
} else if (OB_FAIL(task_id.parse_from_buf(task_id_buf))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid task id", K(ret), K(n), K(task_id_buf));
} else {
// double check
n = snprintf(task_id_buf, sizeof(task_id_buf), "%s", to_cstring(task_id));
if (n < 0 || n >= sizeof(task_id_buf)) {
ret = OB_BUF_NOT_ENOUGH;
LOG_WARN("invalid task id", K(ret), K(n), K(task_id), K(task_id_buf));
} else if (0 != task_id_str.case_compare(task_id_buf)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("task id is not valid",
K(ret), K(task_id_str), K(task_id_buf), K(task_id_str.length()), K(strlen(task_id_buf)));
}
}
return ret;
}
int ObSetDiskValidExecutor::execute(ObExecContext &ctx, ObSetDiskValidStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = NULL;
obrpc::ObSrvRpcProxy *srv_rpc_proxy = NULL;
ObAddr server = stmt.server_;
ObSetDiskValidArg arg;
LOG_INFO("set_disk_valid", K(server));
if (OB_ISNULL(task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx))) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor failed");
} else if (OB_ISNULL(srv_rpc_proxy = task_exec_ctx->get_srv_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get srv rpc proxy failed");
} else if (OB_FAIL(srv_rpc_proxy->to(server).set_disk_valid(arg))) {
LOG_WARN("rpc proxy set_disk_valid failed", K(ret));
} else {
LOG_INFO("set_disk_valid success", K(server));
}
return ret;
}
int ObClearBalanceTaskExecutor::execute(ObExecContext &ctx, ObClearBalanceTaskStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
int64_t timeout = THIS_WORKER.get_timeout_remain();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(common_rpc->timeout(timeout).admin_clear_balance_task(
stmt.get_rpc_arg()))) {
LOG_WARN("send rpc for flush balance info failed", K(ret), "rpc_arg", stmt.get_rpc_arg());
}
return ret;
}
/*
* change tenant should statisfy the following factors:
* 0. can't change tenant by proxy.
* 1. login tenant is sys.
* 2. session is not in trans.
* 3. login user has oceanbase db's access privilege.
* 4. ObServer has target tenant's resource.
* https://lark.alipay.com/ob/rootservice/gkz8ex
*/
int ObChangeTenantExecutor::execute(ObExecContext &ctx, ObChangeTenantStmt &stmt)
{
int ret = OB_SUCCESS;
ObSQLSessionInfo *session_info = ctx.get_my_session();
share::schema::ObSchemaGetterGuard schema_guard;
uint64_t effective_tenant_id = stmt.get_tenant_id();
uint64_t pre_effective_tenant_id = OB_INVALID_TENANT_ID;
uint64_t login_tenant_id = OB_INVALID_TENANT_ID;
ObString database_name(OB_SYS_DATABASE_NAME);
share::schema::ObSessionPrivInfo session_priv;
if (OB_ISNULL(session_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session is null", KR(ret), K(effective_tenant_id));
} else if (ObBasicSessionInfo::VALID_PROXY_SESSID != session_info->get_proxy_sessid()) { // case 0
ret = OB_NOT_SUPPORTED;
LOG_WARN("can't change tenant by proxy", KR(ret));
LOG_USER_ERROR(OB_NOT_SUPPORTED, "operation from proxy");
} else if (OB_INVALID_TENANT_ID == effective_tenant_id) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant_id", KR(ret), K(effective_tenant_id));
} else if (OB_ISNULL(GCTX.omt_) || OB_ISNULL(GCTX.schema_service_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ptr is null", KR(ret));
} else if (FALSE_IT(pre_effective_tenant_id = session_info->get_effective_tenant_id())) {
} else if (FALSE_IT(login_tenant_id = session_info->get_login_tenant_id())) {
} else if (FALSE_IT(session_info->get_session_priv_info(session_priv))) {
} else if (effective_tenant_id == pre_effective_tenant_id) {
// do nothing
} else if (OB_SYS_TENANT_ID != login_tenant_id) { //case 1
ret = OB_NOT_SUPPORTED;
LOG_WARN("non-sys tenant change tenant not allowed", KR(ret),
K(effective_tenant_id), K(login_tenant_id));
LOG_USER_ERROR(OB_NOT_SUPPORTED, "operation from regular user tenant");
} else if (session_info->get_in_transaction()) { //case 2
ret = OB_OP_NOT_ALLOW;
LOG_WARN("change tenant in transaction not allowed", KR(ret), KPC(session_info));
LOG_USER_ERROR(OB_OP_NOT_ALLOW, "change tenant which has active transaction");
} else if (OB_FAIL(GCTX.schema_service_->get_tenant_schema_guard(
pre_effective_tenant_id, schema_guard))) {
LOG_WARN("get_schema_guard failed", KR(ret), K(pre_effective_tenant_id));
} else if (OB_FAIL(schema_guard.check_db_access(session_priv, database_name))) { // case 3
LOG_WARN("fail to check db access", KR(ret), K(pre_effective_tenant_id),
K(session_priv), K(database_name));
} else if (session_info->get_ps_session_info_size() > 0) { // case 4
ret = OB_OP_NOT_ALLOW;
LOG_WARN("chang tenant is not allow when prepared stmt already opened in session", KR(ret), KPC(session_info));
LOG_USER_ERROR(OB_OP_NOT_ALLOW, "change tenant when has prepared stmt already opened in session");
} else {
// switch connection
if (OB_SUCC(ret)) {
rpc::ObSqlSockDesc& sock_desc = session_info->get_sock_desc();
easy_connection_t* easy_conn = nullptr;
observer::ObSMConnection* conn = nullptr;
if (OB_ISNULL((easy_conn = static_cast<easy_connection_t*>(sock_desc.sock_desc_)))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("sock_desc is null", KR(ret), KPC(session_info));
} else if (OB_ISNULL(conn = static_cast<observer::ObSMConnection*>(easy_conn->user_data))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("connection is null", KR(ret), KPC(session_info));
} else {
omt::ObTenant* pre_effective_tenant = conn->tenant_;
if (OB_ISNULL(pre_effective_tenant)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("effective_tenant is null", KR(ret), KPC(session_info));
} else if (OB_FAIL(GCTX.omt_->get_tenant_with_tenant_lock(
effective_tenant_id, *conn->tmp_handle_, conn->tenant_))) { // case 4
LOG_WARN("fail to get tenant from omt", KR(ret),
K(pre_effective_tenant_id), K(effective_tenant_id));
conn->tenant_ = pre_effective_tenant;
} else {
// unlock pre tenant and swap the conn->handle_ and conn->tmp_handle_
conn->is_tenant_locked_ = true;
ObLDHandle *pre_handle = conn->handle_;
if (OB_FAIL(pre_effective_tenant->unlock(*pre_handle))) {
LOG_ERROR("unlock failed, may cause ref leak", KR(ret), KPC(session_info), K(lbt()));
} else {
conn->handle_ = conn->tmp_handle_;
conn->tmp_handle_ = pre_handle;
}
}
}
}
// switch session
if (OB_SUCC(ret)) {
ObPlanCacheManager *plan_cache_mgr = session_info->get_plan_cache_manager();
ObPCMemPctConf pc_mem_conf;
int64_t received_schema_version = OB_INVALID_VERSION;
if (OB_SUCC(ret)) {
ret = E(EventTable::EN_CHANGE_TENANT_FAILED) OB_SUCCESS;
}
if (OB_FAIL(ret)) {
} else if (OB_ISNULL(plan_cache_mgr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("plan_cache_mgr is null", KR(ret));
} else if (OB_FAIL(session_info->get_pc_mem_conf(pc_mem_conf))) {
LOG_WARN("fail to get pc mem conf", KR(ret), KPC(session_info));
} else if (OB_FAIL(GCTX.schema_service_->get_tenant_received_broadcast_version(
effective_tenant_id, received_schema_version))) {
LOG_WARN("fail to get tenant received broadcast version", KR(ret), K(effective_tenant_id));
} else if (OB_FAIL(session_info->switch_tenant(effective_tenant_id))) {
LOG_WARN("fail to switch tenant", KR(ret), K(effective_tenant_id), K(pre_effective_tenant_id));
} else if (OB_FAIL(session_info->set_default_database(database_name))) {
LOG_WARN("fail to set default database", KR(ret), K(database_name));
} else if (OB_FAIL(session_info->update_sys_variable(
share::SYS_VAR_OB_LAST_SCHEMA_VERSION, received_schema_version))) {
// bugfix: https://work.aone.alibaba-inc.com/issue/18698167
LOG_WARN("fail to set session variable for last_schema_version", KR(ret),
K(effective_tenant_id), K(pre_effective_tenant_id), K(received_schema_version));
} else {
session_info->set_database_id(OB_SYS_DATABASE_ID);
session_info->set_plan_cache(plan_cache_mgr->get_or_create_plan_cache(effective_tenant_id, pc_mem_conf));
session_info->set_ps_cache(plan_cache_mgr->get_or_create_ps_cache(effective_tenant_id, pc_mem_conf));
if (OB_SUCC(ret)) {
// System tenant's __oceanbase_inner_standby_user is used to execute remote sqls
// (mostly are used to fetch location infos) across cluster. Such remote sqls should
// have a higher priority than sqls from user. Otherwise, it may cause an unstable cluster status
// while cluster/tenant is lack of rpc resource. Here, we use special tenant' rpc resource to
// deal with remote sqls accross cluster to avoid the influence of user's sql.
// bugfix: https://work.aone.alibaba-inc.com/issue/33024810
const ObString &user_name = session_info->get_user_name();
if (0 == user_name.case_compare(OB_STANDBY_USER_NAME)) {
// TODO: (yanmu.ztl) should use a independent special tenant
session_info->set_rpc_tenant_id(OB_SYS_TENANT_ID);
}
}
}
if (OB_FAIL(ret)) {
int tmp_ret = OB_SUCCESS;
ObSQLSessionMgr *session_mgr = ctx.get_session_mgr();
uint32_t session_id = session_info->get_sessid();
if (OB_ISNULL(session_mgr)) {
tmp_ret = OB_ERR_UNEXPECTED;
LOG_WARN("session_mgr is null", KR(ret), KR(tmp_ret));
} else if (OB_SUCCESS != (tmp_ret = session_mgr->kill_session(*session_info))) {
LOG_WARN("kill session failed", KR(ret), KR(tmp_ret), K(session_id));
}
if (OB_SUCCESS != tmp_ret) {
LOG_ERROR("switch tenant failed, session info may be inconsistent",
KR(ret), K(tmp_ret), K(session_id), K(lbt()));
}
}
}
}
LOG_TRACE("change tenant", KR(ret), K(login_tenant_id), K(pre_effective_tenant_id), K(effective_tenant_id));
return ret;
}
int ObSwitchTenantExecutor::execute(ObExecContext &ctx, ObSwitchTenantStmt &stmt)
{
int ret = OB_SUCCESS;
ObString first_stmt;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_rpc = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(stmt.get_first_stmt(first_stmt))) {
LOG_WARN("fail to get first stmt", KR(ret), K(stmt));
} else {
ObSwitchTenantArg &arg = stmt.get_arg();
arg.set_stmt_str(first_stmt);
// TODO support specify ALL
if (OB_FAIL(ret)) {
} else if (OB_FAIL(OB_PRIMARY_STANDBY_SERVICE.switch_tenant(arg))) {
LOG_WARN("failed to switch_tenant", KR(ret), K(arg));
}
}
return ret;
}
int ObAddDiskExecutor::execute(ObExecContext &ctx, ObAddDiskStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObSrvRpcProxy *srv_rpc_proxy = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(srv_rpc_proxy = task_exec_ctx->get_srv_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get server rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(srv_rpc_proxy->to(stmt.arg_.server_).add_disk(stmt.arg_))) {
LOG_WARN("failed to send add disk rpc", K(ret), "arg", stmt.arg_);
} else {
FLOG_INFO("succeed to send add disk rpc", "arg", stmt.arg_);
}
return ret;
}
int ObDropDiskExecutor::execute(ObExecContext &ctx, ObDropDiskStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObSrvRpcProxy *srv_rpc_proxy = NULL;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(srv_rpc_proxy = task_exec_ctx->get_srv_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get server rpc proxy failed", K(task_exec_ctx));
} else if (OB_FAIL(srv_rpc_proxy->to(stmt.arg_.server_).drop_disk(stmt.arg_))) {
LOG_WARN("failed to send drop disk rpc", K(ret), "arg", stmt.arg_);
} else {
FLOG_INFO("succeed to send drop disk rpc", "arg", stmt.arg_);
}
return ret;
}
int ObArchiveLogExecutor::execute(ObExecContext &ctx, ObArchiveLogStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc_proxy = NULL;
common::ObCurTraceId::mark_user_request();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_FAIL(task_exec_ctx->get_common_rpc(common_rpc_proxy))) {
LOG_WARN("get common rpc proxy failed", K(ret));
} else if (OB_ISNULL(common_rpc_proxy)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("common_rpc_proxy is null", K(ret));
} else {
FLOG_INFO("ObArchiveLogExecutor::execute", K(stmt), K(ctx));
obrpc::ObArchiveLogArg arg;
arg.enable_ = stmt.is_enable();
arg.tenant_id_ = stmt.get_tenant_id();
if (OB_FAIL(arg.archive_tenant_ids_.assign(stmt.get_archive_tenant_ids()))) {
LOG_WARN("failed to assign archive tenant ids", K(ret), K(stmt));
} else if (OB_FAIL(common_rpc_proxy->archive_log(arg))) {
LOG_WARN("archive_tenant rpc failed", K(ret), K(arg), "dst", common_rpc_proxy->get_server());
}
}
return ret;
}
int ObBackupDatabaseExecutor::execute(ObExecContext &ctx, ObBackupDatabaseStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
ObSQLSessionInfo *session_info = ctx.get_my_session();
ObCommonRpcProxy *common_proxy = NULL;
common::ObCurTraceId::mark_user_request();
ObString passwd;
ObObj value;
obrpc::ObBackupDatabaseArg arg;
//rs会尝试更新冻结点的schema_version的intervale 5s
const int64_t SECOND = 1* 1000 * 1000; //1s
const int64_t MAX_RETRY_NUM = UPDATE_SCHEMA_ADDITIONAL_INTERVAL / SECOND + 1;
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_proxy = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(ret));
} else if (OB_ISNULL(session_info)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session_info must not null", K(ret));
} else if (!session_info->user_variable_exists(OB_BACKUP_ENCRYPTION_MODE_SESSION_STR)) {
arg.encryption_mode_ = ObBackupEncryptionMode::NONE;
arg.passwd_.reset();
LOG_INFO("no backup encryption mode is specified", K(stmt));
} else {
if (OB_FAIL(session_info->get_user_variable_value(OB_BACKUP_ENCRYPTION_MODE_SESSION_STR,
value))) {
LOG_WARN("failed to get encryption mode", K(ret));
} else if (FALSE_IT(arg.encryption_mode_ = ObBackupEncryptionMode::parse_str(value.get_varchar()))) {
} else if (!ObBackupEncryptionMode::is_valid(arg.encryption_mode_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid mode", K(ret), K(arg), K(value));
} else if (OB_FAIL(session_info->get_user_variable_value(OB_BACKUP_ENCRYPTION_PASSWD_SESSION_STR,
value))) {
LOG_WARN("failed to get passwd", K(ret));
} else if (OB_FAIL(arg.passwd_.assign(value.get_varchar()))) {
LOG_WARN("failed to assign passwd", K(ret));
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(arg.backup_dest_.assign(stmt.get_backup_dest()))) {
LOG_WARN("failed to assign backup dest", K(ret));
} else if (OB_FAIL(arg.backup_tenant_ids_.assign(stmt.get_backup_tenant_ids()))) {
LOG_WARN("failed to assign backup tenant ids", K(ret));
} else if (OB_FAIL(arg.backup_description_.assign(stmt.get_backup_description()))) {
LOG_WARN("failed to assign backup description", K(ret));
} else {
arg.tenant_id_ = stmt.get_tenant_id();
arg.is_incremental_ = stmt.get_incremental();
arg.is_compl_log_ = stmt.get_compl_log();
arg.initiator_tenant_id_ = stmt.get_tenant_id();
LOG_INFO("ObBackupDatabaseExecutor::execute", K(stmt), K(arg), K(ctx));
if (!arg.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret), K(arg));
} else {
int32_t retry_cnt = 0;
while (retry_cnt < MAX_RETRY_NUM) {
ret = OB_SUCCESS;
if (OB_FAIL(common_proxy->backup_database(arg))) {
if (OB_EAGAIN == ret) {
LOG_WARN("backup_database rpc failed, need retry", K(ret), K(arg),
"dst", common_proxy->get_server(), "retry_cnt", retry_cnt);
ob_usleep(SECOND); //1s
} else {
LOG_WARN("backup_database rpc failed", K(ret), K(arg), "dst", common_proxy->get_server());
break;
}
} else {
break;
}
++retry_cnt;
}
}
}
return ret;
}
int ObBackupManageExecutor::execute(ObExecContext &ctx, ObBackupManageStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
ObCommonRpcProxy *common_proxy = NULL;
common::ObCurTraceId::mark_user_request();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_proxy = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(ret));
} else {
LOG_INFO("ObBackupManageExecutor::execute", K(stmt), K(ctx));
obrpc::ObBackupManageArg arg;
arg.tenant_id_ = stmt.get_tenant_id();
arg.type_ = stmt.get_type();
arg.value_ = stmt.get_value();
arg.copy_id_ = stmt.get_copy_id();
if (OB_FAIL(append(arg.managed_tenant_ids_, stmt.get_managed_tenant_ids()))) {
LOG_WARN("failed to append managed tenants", K(ret), K(stmt));
} else if (OB_FAIL(common_proxy->backup_manage(arg))) {
LOG_WARN("backup_manage rpc failed", K(ret), K(arg), "dst", common_proxy->get_server());
}
}
return ret;
}
int ObBackupCleanExecutor::execute(ObExecContext &ctx, ObBackupCleanStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
ObCommonRpcProxy *common_proxy = NULL;
common::ObCurTraceId::mark_user_request();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_proxy = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(ret));
} else {
LOG_INFO("ObBackupCleanExecutor::execute", K(stmt), K(ctx));
obrpc::ObBackupCleanArg arg;
arg.initiator_tenant_id_ = stmt.get_tenant_id();
arg.type_ = stmt.get_type();
arg.value_ = stmt.get_value();
arg.dest_id_ = stmt.get_copy_id();
if (OB_FAIL(arg.description_.assign(stmt.get_description()))) {
LOG_WARN("set clean description failed", K(ret));
} else if (OB_FAIL(arg.clean_tenant_ids_.assign(stmt.get_clean_tenant_ids()))) {
LOG_WARN("set clean tenant ids failed", K(ret));
} else if (OB_FAIL(common_proxy->backup_delete(arg))) {
LOG_WARN("backup clean rpc failed", K(ret), K(arg), "dst", common_proxy->get_server());
}
}
FLOG_INFO("ObBackupCleanExecutor::execute");
return ret;
}
int ObDeletePolicyExecutor::execute(ObExecContext &ctx, ObDeletePolicyStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
ObCommonRpcProxy *common_proxy = NULL;
common::ObCurTraceId::mark_user_request();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_ISNULL(common_proxy = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(ret));
} else {
LOG_INFO("ObDeletePolicyExecutor::execute", K(stmt), K(ctx));
obrpc::ObDeletePolicyArg arg;
arg.initiator_tenant_id_ = stmt.get_tenant_id();
arg.type_ = stmt.get_type();
arg.redundancy_ = stmt.get_redundancy();
arg.backup_copies_ = stmt.get_backup_copies();
if (OB_FAIL(databuff_printf(arg.policy_name_, sizeof(arg.policy_name_), "%s", stmt.get_policy_name()))) {
LOG_WARN("failed to set policy name", K(ret), K(stmt));
} else if (OB_FAIL(databuff_printf(arg.recovery_window_, sizeof(arg.recovery_window_), "%s", stmt.get_recovery_window()))) {
LOG_WARN("failed to set recovery window", K(ret), K(stmt));
} else if (OB_FAIL(arg.clean_tenant_ids_.assign(stmt.get_clean_tenant_ids()))) {
LOG_WARN("set clean tenant ids failed", K(ret));
} else if (OB_FAIL(common_proxy->delete_policy(arg))) {
LOG_WARN("delete policy rpc failed", K(ret), K(arg), "dst", common_proxy->get_server());
}
}
FLOG_INFO("ObDeletePolicyExecutor::execute");
return ret;
}
int ObBackupBackupsetExecutor::execute(ObExecContext &ctx, ObBackupBackupsetStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
ObCommonRpcProxy *common_proxy = NULL;
common::ObCurTraceId::reset();
common::ObCurTraceId::mark_user_request();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("task exec ctx is null", KR(ret));
} else if (OB_ISNULL(common_proxy = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(ret));
} else {
ret = OB_NOT_SUPPORTED;
LOG_ERROR("not support now", K(ret));
}
return ret;
}
int ObBackupArchiveLogExecutor::execute(ObExecContext &ctx, ObBackupArchiveLogStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
obrpc::ObCommonRpcProxy *common_rpc_proxy = NULL;
common::ObCurTraceId::mark_user_request();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor context failed");
} else if (OB_FAIL(task_exec_ctx->get_common_rpc(common_rpc_proxy))) {
LOG_WARN("get common rpc proxy failed", K(ret));
} else if (OB_ISNULL(common_rpc_proxy)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("common_rpc_proxy is null", K(ret));
} else {
FLOG_INFO("ObBackupArchiveLogExecutor::execute", K(stmt), K(ctx));
// obrpc::ObBackupArchiveLogArg arg;
// arg.enable_ = stmt.is_enable();
ret = OB_NOT_SUPPORTED;
LOG_ERROR("not support now", K(ret));
// if (OB_FAIL(common_rpc_proxy->backup_archive_log(arg))) {
// LOG_WARN("archive_log rpc failed", K(ret), K(arg), "dst", common_rpc_proxy->get_server());
// }
}
return ret;
}
int ObBackupBackupPieceExecutor::execute(ObExecContext &ctx, ObBackupBackupPieceStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx);
ObCommonRpcProxy *common_proxy = NULL;
common::ObCurTraceId::reset();
common::ObCurTraceId::mark_user_request();
if (OB_ISNULL(task_exec_ctx)) {
ret = OB_NOT_INIT;
LOG_WARN("task exec ctx is null", KR(ret));
} else if (OB_ISNULL(common_proxy = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed", K(ret));
} else {
LOG_INFO("ObBackupBackupPieceExecutor::execute", K(stmt), K(ctx));
// obrpc::ObBackupBackupPieceArg arg;
// arg.tenant_id_ = stmt.get_tenant_id();
// arg.piece_id_ = stmt.get_piece_id();
// arg.max_backup_times_ = stmt.get_max_backup_times();
// arg.backup_all_ = stmt.is_backup_all();
// MEMCPY(arg.backup_backup_dest_, stmt.get_backup_backup_dest().ptr(), stmt.get_backup_backup_dest().length());
// arg.with_active_piece_ = stmt.with_active_piece();
ret = OB_NOT_SUPPORTED;
LOG_ERROR("not support now", K(ret));
// if (OB_FAIL(common_proxy->backup_backuppiece(arg))) {
// LOG_WARN("backup archive log rpc failed", KR(ret), K(arg), "dst", common_proxy->get_server());
// }
}
return ret;
}
int ObBackupSetEncryptionExecutor::execute(ObExecContext &ctx, ObBackupSetEncryptionStmt &stmt)
{
int ret = OB_SUCCESS;
common::ObCurTraceId::mark_user_request();
common::ObMySQLProxy *sql_proxy = nullptr;
ObSqlString set_mode_sql;
ObSqlString set_passwd_sql;
sqlclient::ObISQLConnection *conn = nullptr;
observer::ObInnerSQLConnectionPool *pool = nullptr;
ObSQLSessionInfo *session_info = ctx.get_my_session();
int64_t affected_rows = 0;
if (OB_ISNULL(session_info)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret), KP(session_info));
} else if (OB_ISNULL(sql_proxy = GCTX.sql_proxy_) || OB_ISNULL(sql_proxy->get_pool())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("sql proxy must not null", K(ret), KP(GCTX.sql_proxy_));
} else if (sqlclient::INNER_POOL != sql_proxy->get_pool()->get_type()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pool type must be inner", K(ret), "type", sql_proxy->get_pool()->get_type());
} else if (OB_ISNULL(pool = static_cast<observer::ObInnerSQLConnectionPool*>(sql_proxy->get_pool()))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pool must not null", K(ret));
} else if (OB_FAIL(set_mode_sql.assign_fmt("set @%s = '%s'",
OB_BACKUP_ENCRYPTION_MODE_SESSION_STR, ObBackupEncryptionMode::to_str(stmt.get_mode())))) {
LOG_WARN("failed to set mode", K(ret));
} else if (OB_FAIL(set_passwd_sql.assign_fmt("set @%s = '%.*s'",
OB_BACKUP_ENCRYPTION_PASSWD_SESSION_STR, stmt.get_passwd().length(), stmt.get_passwd().ptr()))) {
LOG_WARN("failed to set passwd", K(ret));
} else if (OB_FAIL(pool->acquire(session_info, conn))) {
LOG_WARN("failed to get conn", K(ret));
} else if (OB_FAIL(conn->execute_write(session_info->get_effective_tenant_id(), set_mode_sql.ptr(),
affected_rows))) {
LOG_WARN("failed to set mode", K(ret), K(set_mode_sql));
} else if (OB_FAIL(conn->execute_write(session_info->get_effective_tenant_id(), set_passwd_sql.ptr(),
affected_rows))) {
LOG_WARN("failed to set passwd", K(ret), K(set_passwd_sql));
} else {
LOG_INFO("ObBackupSetEncryptionExecutor::execute", K(stmt), K(ctx),
K(set_mode_sql), K(set_passwd_sql));
}
return ret;
}
int ObBackupSetDecryptionExecutor::execute(ObExecContext &ctx, ObBackupSetDecryptionStmt &stmt)
{
int ret = OB_SUCCESS;
common::ObCurTraceId::mark_user_request();
common::ObMySQLProxy *sql_proxy = nullptr;
ObSqlString set_passwd_sql;
sqlclient::ObISQLConnection *conn = nullptr;
observer::ObInnerSQLConnectionPool *pool = nullptr;
ObSQLSessionInfo *session_info = ctx.get_my_session();
int64_t affected_rows = 0;
if (OB_ISNULL(session_info)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret), KP(session_info));
} else if (OB_ISNULL(sql_proxy = GCTX.sql_proxy_) || OB_ISNULL(sql_proxy->get_pool())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("sql proxy must not null", K(ret), KP(GCTX.sql_proxy_));
} else if (sqlclient::INNER_POOL != sql_proxy->get_pool()->get_type()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pool type must be inner", K(ret), "type", sql_proxy->get_pool()->get_type());
} else if (OB_ISNULL(pool = static_cast<observer::ObInnerSQLConnectionPool*>(sql_proxy->get_pool()))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pool must not null", K(ret));
} else if (OB_FAIL(set_passwd_sql.assign_fmt("set @%s = '%.*s'", OB_BACKUP_DECRYPTION_PASSWD_ARRAY_SESSION_STR,
stmt.get_passwd_array().length(), stmt.get_passwd_array().ptr()))) {
LOG_WARN("failed to set passwd", K(ret));
} else if (OB_FAIL(pool->acquire(session_info, conn))) {
LOG_WARN("failed to get conn", K(ret));
} else if (OB_FAIL(conn->execute_write(session_info->get_effective_tenant_id(), set_passwd_sql.ptr(),
affected_rows))) {
LOG_WARN("failed to set passwd", K(ret), K(set_passwd_sql));
} else {
LOG_INFO("ObBackupSetEncryptionExecutor::execute", K(stmt), K(ctx), K(set_passwd_sql));
}
return ret;
}
int ObSetRegionBandwidthExecutor::execute(ObExecContext &ctx, ObSetRegionBandwidthStmt &stmt)
{
int ret = OB_SUCCESS;
ObSqlString sql_str;
common::ObMySQLProxy *sql_proxy = nullptr;
ObSQLSessionInfo *session_info = NULL;
int64_t affected_rows = 0;
session_info = ctx.get_my_session();
if (OB_ISNULL(session_info)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret), KP(session_info));
} else if (OB_ISNULL(sql_proxy = ctx.get_sql_proxy())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("sql proxy must not null", K(ret));
} else if (OB_FAIL(sql_str.assign_fmt("replace into %s(src_region, dst_region, max_bw) values('%s', '%s', %ld)",
"__all_region_network_bandwidth_limit",
stmt.get_src_region(), stmt.get_dst_region(), stmt.get_max_bw()))) {
LOG_WARN("failed to set region ratelimitor parameters", K(ret), K(sql_str));
} else if (OB_FAIL(sql_proxy->write(session_info->get_effective_tenant_id()/*get_priv_tenant_id ???*/,
sql_str.ptr(),
affected_rows))) {
LOG_WARN("failed to excutet sql write", K(ret), K(sql_str));
} else {
LOG_INFO("ObSetRegionBandwidthExecutor::execute", K(stmt), K(ctx), K(sql_str));
}
return ret;
}
int ObAddRestoreSourceExecutor::execute(ObExecContext &ctx, ObAddRestoreSourceStmt &stmt)
{
int ret = OB_SUCCESS;
common::ObCurTraceId::mark_user_request();
common::ObMySQLProxy *sql_proxy = nullptr;
ObSqlString add_restore_source_sql;
sqlclient::ObISQLConnection *conn = nullptr;
observer::ObInnerSQLConnectionPool *pool = nullptr;
ObSQLSessionInfo *session_info = ctx.get_my_session();
int64_t affected_rows = 0;
ObObj value;
if (OB_ISNULL(session_info)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret), KP(session_info));
} else if (OB_ISNULL(sql_proxy = GCTX.sql_proxy_) || OB_ISNULL(sql_proxy->get_pool())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("sql proxy must not null", K(ret), KP(GCTX.sql_proxy_));
} else if (sqlclient::INNER_POOL != sql_proxy->get_pool()->get_type()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pool type must be inner", K(ret), "type", sql_proxy->get_pool()->get_type());
} else if (OB_ISNULL(pool = static_cast<observer::ObInnerSQLConnectionPool*>(sql_proxy->get_pool()))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("pool must not null", K(ret));
} else if (!session_info->user_variable_exists(OB_RESTORE_SOURCE_NAME_SESSION_STR)) {
LOG_INFO("no restore source specified before");
} else {
if (OB_FAIL(session_info->get_user_variable_value(OB_RESTORE_SOURCE_NAME_SESSION_STR, value))) {
LOG_WARN("failed to get user variable value", KR(ret));
} else if (OB_FAIL(stmt.add_restore_source(value.get_char()))) {
LOG_WARN("failed to add restore source", KR(ret), K(value));
}
}
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(add_restore_source_sql.assign_fmt(
"set @%s = '%.*s'", OB_RESTORE_SOURCE_NAME_SESSION_STR,
stmt.get_restore_source_array().length(),
stmt.get_restore_source_array().ptr()))) {
LOG_WARN("failed to add restore source", K(ret), K(stmt));
} else if (OB_FAIL(pool->acquire(session_info, conn))) {
LOG_WARN("failed to get conn", K(ret));
} else if (OB_FAIL(conn->execute_write(session_info->get_effective_tenant_id(),
add_restore_source_sql.ptr(), affected_rows))) {
LOG_WARN("failed to add restore source", K(ret), K(add_restore_source_sql));
} else {
LOG_INFO("ObAddRestoreSourceExecutor::execute", K(stmt), K(ctx), K(add_restore_source_sql));
}
return ret;
}
int ObClearRestoreSourceExecutor::execute(ObExecContext &ctx, ObClearRestoreSourceStmt &stmt)
{
int ret = OB_SUCCESS;
common::ObCurTraceId::mark_user_request();
ObSQLSessionInfo *session_info = ctx.get_my_session();
if (OB_ISNULL(session_info)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret), KP(session_info));
} else {
if (session_info->user_variable_exists(OB_RESTORE_SOURCE_NAME_SESSION_STR)) {
if (OB_FAIL(session_info->remove_user_variable(OB_RESTORE_SOURCE_NAME_SESSION_STR))) {
LOG_WARN("failed to remove user variable", KR(ret));
}
}
}
UNUSED(stmt);
return ret;
}
int ObCheckpointSlogExecutor::execute(ObExecContext &ctx, ObCheckpointSlogStmt &stmt)
{
int ret = OB_SUCCESS;
ObTaskExecutorCtx *task_exec_ctx = NULL;
obrpc::ObSrvRpcProxy *srv_rpc_proxy = NULL;
const ObAddr server = stmt.server_;
ObCheckpointSlogArg arg;
const int64_t TIMEOUT = 60 * 1000 * 1000; // 60s
arg.tenant_id_ = stmt.tenant_id_;
if (OB_ISNULL(task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx))) {
ret = OB_NOT_INIT;
LOG_WARN("get task executor failed");
} else if (OB_ISNULL(srv_rpc_proxy = task_exec_ctx->get_srv_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get srv rpc proxy failed");
} else if (OB_FAIL(srv_rpc_proxy->to(server).timeout(TIMEOUT).checkpoint_slog(arg))) {
LOG_WARN("rpc proxy checkpoint slog failed", K(ret));
}
LOG_INFO("checkpoint slog execute finish", K(ret), K(arg.tenant_id_), K(server));
return ret;
}
} // end namespace sql
} // end namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink