hcq/oceanbase
hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

support check ls restore status when creating standby tenant

Browse Source
This commit is contained in:
obdev 2023-07-03 10:42:21 +00:00 committed by ob-robot
parent 01d017adfc
commit 469144616f
10 changed files with 236 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
deps/oblib/src/lib/ob_errno.h vendored
View File

@ -138,6 +138,7 @@ constexpr int OB_ERR_THREAD_PANIC = -4396;
constexpr int OB_ERR_INTERVAL_PARTITION_EXIST = -4728;
constexpr int OB_ERR_INTERVAL_PARTITION_ERROR = -4729;
constexpr int OB_FROZEN_INFO_ALREADY_EXIST = -4744;
constexpr int OB_CREATE_STANDBY_TENANT_FAILED = -4765;
constexpr int OB_ERR_PARSER_SYNTAX = -5006;
constexpr int OB_ERR_COLUMN_NOT_FOUND = -5031;
constexpr int OB_ERR_SYS_VARIABLE_UNKNOWN = -5044;

2
src/rootserver/ob_create_standby_from_net_actor.cpp
View File

@ -168,6 +168,8 @@ int ObCreateStandbyFromNetActor::finish_restore_if_possible_()
WSTAT("tenant info loader should not be NULL", KR(ret), KP(tenant_info_loader));
} else {
ISTAT("start to wait whether can finish restore", K_(tenant_id), K(min_user_ls_create_scn));
DEBUG_SYNC(BLOCK_CREATE_STANDBY_TENANT_END);
int64_t retry_cnt_after_sync_user_ls = 0;
// wait 1 minute, sleep 1s and retry 60 times
for (int64_t retry_cnt = 60; OB_SUCC(ret) && retry_cnt > 0 && !has_set_stop(); --retry_cnt) {

1
src/share/ob_debug_sync_point.h
View File

@ -399,6 +399,7 @@ class ObString;
ACT(BEFORE_RECOVER_USER_LS,)\
ACT(BEFORE_PREPARE_FLASHBACK,)\
ACT(BLOCK_STANDBY_REFRESH_SCHEMA,)\
ACT(BLOCK_CREATE_STANDBY_TENANT_END,)\
ACT(BEFORE_LS_RESTORE_SYS_TABLETS,)\
ACT(BEFORE_WAIT_RESTORE_SYS_TABLETS,)\
ACT(BEFORE_WAIT_RESTORE_TABLETS_META,)\

15
src/share/ob_errno.cpp
View File

File diff suppressed because one or more lines are too long

1
src/share/ob_errno.def
View File

@ -654,6 +654,7 @@ DEFINE_ERROR(OB_LS_IS_DELETED, -4761, -1, "HY000", "log stream is deleted");
DEFINE_ERROR(OB_SKIP_CHECKING_LS_STATUS, -4762, -1, "HY000", "This operation has been finished without checking ls status");
DEFINE_ORACLE_ERROR(OB_ERR_USE_ROWID_FOR_UPDATE, -4763, -1, "HY000", "invalid user.table.column, table.column, or column specification", 1747, "invalid user.table.column, table.column, or column specification");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_UNKNOWN_SET_OPTION, -4764, -1, "HY000", "unknown SET option", "unknown SET option \'%s\'", 600, "unknown SET option", "unknown SET option \'%s\'");
DEFINE_ERROR_EXT_DEP(OB_CREATE_STANDBY_TENANT_FAILED, -4765, -1, "HY000", "create standby tenant may fail", "create standby tenant may fail, %s");
////////////////////////////////////////////////////////////////
// SQL & Schema specific error code, -5000 ~ -6000

4
src/share/ob_errno.h
View File

@ -2315,6 +2315,7 @@ constexpr int OB_ERR_INVALID_DATE_MSG_FMT_V2 = -4219;
#define OB_SKIP_CHECKING_LS_STATUS__USER_ERROR_MSG "This operation has been finished without checking ls status"
#define OB_ERR_USE_ROWID_FOR_UPDATE__USER_ERROR_MSG "invalid user.table.column, table.column, or column specification"
#define OB_ERR_UNKNOWN_SET_OPTION__USER_ERROR_MSG "unknown SET option \'%s\'"
#define OB_CREATE_STANDBY_TENANT_FAILED__USER_ERROR_MSG "create standby tenant may fail, %s"
#define OB_ERR_PARSER_INIT__USER_ERROR_MSG "Failed to init SQL parser"
#define OB_ERR_PARSE_SQL__USER_ERROR_MSG "%s near \'%.*s\' at line %d"
#define OB_ERR_RESOLVE_SQL__USER_ERROR_MSG "Resolve error"
@ -4409,6 +4410,7 @@ constexpr int OB_ERR_INVALID_DATE_MSG_FMT_V2 = -4219;
#define OB_SKIP_CHECKING_LS_STATUS__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -4762, This operation has been finished without checking ls status"
#define OB_ERR_USE_ROWID_FOR_UPDATE__ORA_USER_ERROR_MSG "ORA-01747: invalid user.table.column, table.column, or column specification"
#define OB_ERR_UNKNOWN_SET_OPTION__ORA_USER_ERROR_MSG "ORA-00600: unknown SET option \'%s\'"
#define OB_CREATE_STANDBY_TENANT_FAILED__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -4765, create standby tenant may fail, %s"
#define OB_ERR_PARSER_INIT__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -5000, Failed to init SQL parser"
#define OB_ERR_PARSE_SQL__ORA_USER_ERROR_MSG "ORA-00900: %s near \'%.*s\' at line %d"
#define OB_ERR_RESOLVE_SQL__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -5002, Resolve error"
@ -5947,7 +5949,7 @@ constexpr int OB_ERR_INVALID_DATE_MSG_FMT_V2 = -4219;
#define OB_ERR_DATA_TOO_LONG_MSG_FMT_V2__ORA_USER_ERROR_MSG "ORA-12899: value too large for column %.*s (actual: %ld, maximum: %ld)"
#define OB_ERR_INVALID_DATE_MSG_FMT_V2__ORA_USER_ERROR_MSG "ORA-01861: Incorrect datetime value for column '%.*s' at row %ld"
extern int g_all_ob_errnos[2090];
extern int g_all_ob_errnos[2091];
const char *ob_error_name(const int oberr);
const char* ob_error_cause(const int oberr);

182
src/share/ob_primary_standby_service.cpp
View File

@ -23,10 +23,12 @@
#include "share/ls/ob_ls_recovery_stat_operator.h"// ObLSRecoveryStatOperator
#include "share/ls/ob_ls_life_manager.h" //ObLSLifeAgentManager
#include "share/ls/ob_ls_operator.h" //ObLSAttr
#include "storage/tx/ob_timestamp_service.h" // ObTimestampService
#include "share/schema/ob_multi_version_schema_service.h" // for GSCHEMASERVICE
#include "share/ob_standby_upgrade.h" // ObStandbyUpgrade
#include "share/backup/ob_backup_config.h" // ObBackupConfigParserMgr
#include "observer/ob_inner_sql_connection.h"//ObInnerSQLConnection
#include "storage/tx/ob_trans_service.h" //ObTransService
#include "storage/tx/ob_timestamp_service.h" // ObTimestampService
namespace oceanbase
{
@ -679,5 +681,183 @@ int ObPrimaryStandbyService::write_upgrade_barrier_log(
return ret;
}
int ObPrimaryStandbyService::check_can_create_standby_tenant(
const common::ObString &log_restore_source,
ObCompatibilityMode &compat_mode)
{
int ret = OB_SUCCESS;
int64_t start_ts = ObTimeUtility::current_time();
share::ObBackupConfigParserMgr config_parser_mgr;
common::ObSqlString name;
common::ObSqlString value;
compat_mode = ObCompatibilityMode::OCEANBASE_MODE;
if (OB_FAIL(check_inner_stat_())) {
LOG_WARN("inner stat error", KR(ret), K_(inited));
} else if (OB_FAIL(name.assign("log_restore_source"))) {
LOG_WARN("assign sql failed", KR(ret));
} else if (OB_FAIL(value.assign(log_restore_source))) {
LOG_WARN("fail to assign value", KR(ret), K(log_restore_source));
} else if (OB_FAIL(config_parser_mgr.init(name, value, 1002 /* fake_user_tenant_id */))) {
LOG_WARN("fail to init backup config parser mgr", KR(ret), K(name), K(value));
} else if (OB_FAIL(config_parser_mgr.only_check_before_update(compat_mode))) {
LOG_WARN("fail to only_check_before_update", KR(ret), K(name), K(value));
}
LOG_INFO("[CREATE STANDBY TENANT] check can create standby tenant", KR(ret), K(log_restore_source),
K(compat_mode), "cost", ObTimeUtility::current_time() - start_ts);
return ret;
}
int ObPrimaryStandbyService::wait_create_standby_tenant_end(const uint64_t tenant_id)
{
int ret = OB_SUCCESS;
int64_t start_ts = ObTimeUtility::current_time();
bool is_dropped = false;
const uint64_t user_tenant_id = gen_user_tenant_id(tenant_id);
const uint64_t meta_tenant_id = gen_meta_tenant_id(tenant_id);
int64_t user_schema_version = OB_INVALID_VERSION;
int64_t meta_schema_version = OB_INVALID_VERSION;
const ObSimpleTenantSchema *tenant_schema = nullptr;
if (OB_FAIL(check_inner_stat_())) {
LOG_WARN("inner stat error", KR(ret), K_(inited));
} else if (!is_user_tenant(tenant_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(tenant_id));
} else {
while (OB_SUCC(ret)) {
ObSchemaGetterGuard schema_guard;
if (THIS_WORKER.is_timeout()) {
ret = OB_TIMEOUT;
LOG_WARN("failed to wait creating standby tenant end", KR(ret), K(tenant_id));
} else if (OB_FAIL(GSCHEMASERVICE.check_if_tenant_has_been_dropped(meta_tenant_id, is_dropped))) {
LOG_WARN("meta tenant has been dropped", KR(ret), K(meta_tenant_id));
} else if (is_dropped) {
ret = OB_TENANT_HAS_BEEN_DROPPED;
LOG_WARN("meta tenant has been dropped", KR(ret), K(meta_tenant_id));
} else if (OB_FAIL(GSCHEMASERVICE.check_if_tenant_has_been_dropped(user_tenant_id, is_dropped))) {
LOG_WARN("user tenant has been dropped", KR(ret), K(user_tenant_id));
} else if (is_dropped) {
ret = OB_TENANT_HAS_BEEN_DROPPED;
LOG_WARN("user tenant has been dropped", KR(ret), K(user_tenant_id));
} else if (OB_FAIL(GSCHEMASERVICE.get_tenant_schema_guard(OB_SYS_TENANT_ID, schema_guard))) {
LOG_WARN("failed to get schema guard", KR(ret));
} else if (OB_FAIL(schema_guard.get_tenant_info(user_tenant_id, tenant_schema))) {
LOG_WARN("failed to get tenant info", KR(ret), K(user_tenant_id));
} else if (OB_ISNULL(tenant_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("tenant_schema is null", KR(ret), K(user_tenant_id));
} else if (tenant_schema->is_creating_standby_tenant_status()) {
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(check_ls_restore_status_(user_tenant_id))) {
LOG_WARN("failed to check ls restore_status", KR(ret), KR(tmp_ret), K(user_tenant_id));
if (OB_CREATE_STANDBY_TENANT_FAILED == tmp_ret) {
ret = OB_SUCC(ret) ? tmp_ret : ret;
}
}
} else if (tenant_schema->is_normal()) {
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(GSCHEMASERVICE.get_tenant_refreshed_schema_version(
meta_tenant_id, meta_schema_version))) {
if (OB_ENTRY_NOT_EXIST != tmp_ret) {
ret = tmp_ret;
LOG_WARN("get refreshed schema version failed", KR(ret), K(meta_tenant_id));
}
} else if (OB_TMP_FAIL(GSCHEMASERVICE.get_tenant_refreshed_schema_version(
user_tenant_id, user_schema_version))) {
if (OB_ENTRY_NOT_EXIST != tmp_ret) {
ret = tmp_ret;
LOG_WARN("get refreshed schema version failed", KR(ret), K(user_tenant_id));
}
}
if (OB_FAIL(ret)) {
} else if (ObSchemaService::is_formal_version(meta_schema_version)
&& ObSchemaService::is_formal_version(user_schema_version)) {
break;
}
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected tenant status", KR(ret), K(user_tenant_id), K(meta_tenant_id), KPC(tenant_schema));
LOG_USER_ERROR(OB_ERR_UNEXPECTED, "unexpected tenant status, create standby tenant failed");
}
if (OB_FAIL(ret)) {
} else {
LOG_INFO("[CREATE STANDBY TENANT] wait create standby tenant end", K(tenant_id), K(user_tenant_id),
K(meta_tenant_id), K(meta_schema_version), K(user_schema_version), KPC(tenant_schema));
ob_usleep(1000 * 1000L); // 1s
}
}
}
LOG_INFO("[CREATE STANDBY TENANT] finish to wait create standby tenant end", KR(ret), K(tenant_id),
"cost", ObTimeUtility::current_time() - start_ts, K(user_tenant_id),
K(meta_tenant_id), K(meta_schema_version), K(user_schema_version), KPC(tenant_schema));
return ret;
}
int ObPrimaryStandbyService::check_ls_restore_status_(const uint64_t tenant_id)
{
int ret = OB_SUCCESS;
ObMySQLProxy *sql_proxy = GCTX.sql_proxy_;
if (OB_FAIL(check_inner_stat_())) {
LOG_WARN("inner stat error", KR(ret), K_(inited));
} else if (OB_ISNULL(sql_proxy)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("sql_proxy is null", KR(ret), K(tenant_id));
} else if (!is_user_tenant(tenant_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant id", KR(ret), K(tenant_id));
} else {
SMART_VAR(ObMySQLProxy::MySQLResult, result) {
ObSqlString sql;
if (OB_FAIL(sql.assign_fmt("SELECT LS_ID, SYNC_STATUS, SYNC_SCN FROM %s WHERE TENANT_ID = '%lu' and SYNC_STATUS !='NORMAL' and ls_id = %ld",
OB_V_OB_LS_LOG_RESTORE_STATUS_TNAME, tenant_id, SYS_LS.id()))) {
LOG_WARN("fail to generate sql", KR(ret), K(tenant_id));
} else if (OB_FAIL(sql_proxy->read(result, sql.ptr()))) {
LOG_WARN("read V$OB_LS_LOG_RESTORE_STATUS failed", KR(ret), K(tenant_id), K(sql));
} else if (OB_ISNULL(result.get_result())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("result is null", KR(ret), K(tenant_id), K(sql));
} else if (OB_FAIL(result.get_result()->next())) {
if (OB_ITER_END == ret) {
// there isn't abnormal ls
ret = OB_SUCCESS;
} else {
LOG_WARN("get result next failed", KR(ret), K(tenant_id), K(sql));
}
} else if (OB_ISNULL(result.get_result())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("result is null", KR(ret), K(tenant_id), K(sql));
} else {
int64_t ls_id = 0;
ObString sync_status_str;
SCN sync_scn;
uint64_t sync_scn_val = OB_INVALID_SCN_VAL;
EXTRACT_INT_FIELD_MYSQL(*result.get_result(), "LS_ID", ls_id, int64_t);
EXTRACT_VARCHAR_FIELD_MYSQL(*result.get_result(), "SYNC_STATUS", sync_status_str);
EXTRACT_UINT_FIELD_MYSQL(*result.get_result(), "SYNC_SCN", sync_scn_val, uint64_t);
if (OB_FAIL(ret)) {
LOG_WARN("failed to get result", KR(ret), K(tenant_id), K(sql));
} else if (OB_FAIL(sync_scn.convert_for_inner_table_field(sync_scn_val))) {
LOG_WARN("failed to convert_for_inner_table_field", KR(ret), K(sync_scn_val));
} else {
LOG_WARN("get LS restore status", KR(ret), K(tenant_id), K(ls_id), K(sync_status_str), K(sync_scn), K(sql));
ret = OB_CREATE_STANDBY_TENANT_FAILED;
std::string fail_reason = "SYS LS sync status is abnormal: "
+ std::string(sync_status_str.ptr(), sync_status_str.length())
+ ", please check V$OB_LS_LOG_RESTORE_STATUS";
LOG_USER_ERROR(OB_CREATE_STANDBY_TENANT_FAILED, fail_reason.c_str());
}
}
}
}
return ret;
}
}
}

27
src/share/ob_primary_standby_service.h
View File

@ -81,6 +81,25 @@ public:
const obrpc::ObRecoverTenantArg::RecoverType &recover_type,
const share::SCN &recovery_until_scn);
/**
* @description:
* check log_restore_source config, check whether can create net standby tenant
* @param[in] log_restore_source log_restore_source config string
* @param[out] compat_mode primary tenant compat_mode
* @return return code
*/
int check_can_create_standby_tenant(
const common::ObString &log_restore_source,
ObCompatibilityMode &compat_mode);
/**
* @description:
* wait net standby tenant create end
* @param[in] tenant_id
* @return return code
*/
int wait_create_standby_tenant_end(const uint64_t tenant_id);
private:
int check_inner_stat_();
@ -185,6 +204,14 @@ private:
const uint64_t tenant_id,
ObTenantStatus &status);
/**
* @description:
* check ls restore_status is normal
* @param[in] tenant_id the tenant id to check
* @return return code
*/
int check_ls_restore_status_(const uint64_t tenant_id);
private:
const static int64_t SEC_UNIT = 1000L * 1000L;
const static int64_t PRINT_INTERVAL = 10 * 1000 * 1000L;

118
src/sql/engine/cmd/ob_tenant_executor.cpp
View File

@ -23,7 +23,8 @@
#include "share/ob_get_compat_mode.h"
#include "share/ls/ob_ls_operator.h"
#include "share/ob_leader_election_waiter.h"
#include "share/backup/ob_backup_config.h" // ObBackupConfigParserMgr
#include "share/ls/ob_ls_status_operator.h" //ObLSStatusInfo, ObLSStatusOperator
#include "share/ob_primary_standby_service.h" // ObPrimaryStandbyService
#include "sql/session/ob_sql_session_info.h"
#include "sql/resolver/ddl/ob_create_tenant_stmt.h"
#include "sql/resolver/ddl/ob_drop_tenant_stmt.h"
@ -249,8 +250,9 @@ int ObCreateStandbyTenantExecutor::execute(ObExecContext &ctx, ObCreateTenantStm
} else if (OB_ISNULL(common_rpc_proxy = task_exec_ctx->get_common_rpc())) {
ret = OB_NOT_INIT;
LOG_WARN("get common rpc proxy failed");
} else if (OB_FAIL(check_can_create_standby_tenant_(create_tenant_arg.log_restore_source_, compat_mode))) {
LOG_WARN("check_can_create_standby_tenant_ failed", KR(ret), K(create_tenant_arg));
} else if (OB_FAIL(OB_PRIMARY_STANDBY_SERVICE.check_can_create_standby_tenant(
create_tenant_arg.log_restore_source_, compat_mode))) {
LOG_WARN("check can create standby_tenant failed", KR(ret), K(create_tenant_arg));
} else {
create_tenant_arg.tenant_schema_.set_compatibility_mode(compat_mode);
}
@ -262,7 +264,7 @@ int ObCreateStandbyTenantExecutor::execute(ObExecContext &ctx, ObCreateTenantStm
ret = OB_ERR_UNEXPECTED;
LOG_WARN("if_not_exist not set and tenant_id invalid tenant_id", KR(ret), K(create_tenant_arg), K(tenant_id));
} else if (OB_INVALID_ID != tenant_id) {
if (OB_FAIL(wait_create_standby_tenant_end_(tenant_id))) {
if (OB_FAIL(OB_PRIMARY_STANDBY_SERVICE.wait_create_standby_tenant_end(tenant_id))) {
LOG_WARN("failed to wait user create end", KR(ret), K(tenant_id));
}
}
@ -271,114 +273,6 @@ int ObCreateStandbyTenantExecutor::execute(ObExecContext &ctx, ObCreateTenantStm
return ret;
}
int ObCreateStandbyTenantExecutor::wait_create_standby_tenant_end_(const uint64_t tenant_id)
{
int ret = OB_SUCCESS;
int64_t start_ts = ObTimeUtility::current_time();
bool is_dropped = false;
const uint64_t user_tenant_id = gen_user_tenant_id(tenant_id);
const uint64_t meta_tenant_id = gen_meta_tenant_id(tenant_id);
int64_t user_schema_version = OB_INVALID_VERSION;
int64_t meta_schema_version = OB_INVALID_VERSION;
const ObSimpleTenantSchema *tenant_schema = nullptr;
while (OB_SUCC(ret)) {
ObSchemaGetterGuard schema_guard;
if (THIS_WORKER.is_timeout()) {
ret = OB_TIMEOUT;
LOG_WARN("failed to wait creating standby tenant end", KR(ret), K(tenant_id));
} else if (OB_FAIL(GSCHEMASERVICE.check_if_tenant_has_been_dropped(meta_tenant_id, is_dropped))) {
LOG_WARN("meta tenant has been dropped", KR(ret), K(meta_tenant_id));
} else if (is_dropped) {
ret = OB_TENANT_HAS_BEEN_DROPPED;
LOG_WARN("meta tenant has been dropped", KR(ret), K(meta_tenant_id));
} else if (OB_FAIL(GSCHEMASERVICE.check_if_tenant_has_been_dropped(user_tenant_id, is_dropped))) {
LOG_WARN("user tenant has been dropped", KR(ret), K(user_tenant_id));
} else if (is_dropped) {
ret = OB_TENANT_HAS_BEEN_DROPPED;
LOG_WARN("user tenant has been dropped", KR(ret), K(user_tenant_id));
} else if (OB_FAIL(GSCHEMASERVICE.get_tenant_schema_guard(OB_SYS_TENANT_ID, schema_guard))) {
LOG_WARN("failed to get schema guard", KR(ret));
} else if (OB_FAIL(schema_guard.get_tenant_info(user_tenant_id, tenant_schema))) {
LOG_WARN("failed to get tenant info", KR(ret), K(user_tenant_id));
} else if (OB_ISNULL(tenant_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("tenant_schema is null", KR(ret), K(user_tenant_id));
} else if (tenant_schema->is_creating_standby_tenant_status()) {
int tmp_ret = OB_SUCCESS;
/* TODO zbf271370 wait ls restore status view
if (OB_TMP_FAIL(check_sys_ls_restore_status(user_tenant_id))) {
if (SYNC_ERROR == tmp_ret) {
ret = tmp_ret;
LOG_WARN("tenant restore failed", KR(ret), K(user_tenant_id));
LOG_USER_ERROR(SYNC_ERROR, "tenant restore failed");
}
}
*/
} else if (tenant_schema->is_normal()) {
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(GSCHEMASERVICE.get_tenant_refreshed_schema_version(
meta_tenant_id, meta_schema_version))) {
if (OB_ENTRY_NOT_EXIST != tmp_ret) {
ret = tmp_ret;
LOG_WARN("get refreshed schema version failed", KR(ret), K(meta_tenant_id));
}
} else if (OB_TMP_FAIL(GSCHEMASERVICE.get_tenant_refreshed_schema_version(
user_tenant_id, user_schema_version))) {
if (OB_ENTRY_NOT_EXIST != tmp_ret) {
ret = tmp_ret;
LOG_WARN("get refreshed schema version failed", KR(ret), K(user_tenant_id));
}
}
if (OB_FAIL(ret)) {
} else if (ObSchemaService::is_formal_version(meta_schema_version)
&& ObSchemaService::is_formal_version(user_schema_version)) {
break;
}
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected tenant status", KR(ret), K(user_tenant_id), K(meta_tenant_id), KPC(tenant_schema));
LOG_USER_ERROR(OB_ERR_UNEXPECTED, "unexpected tenant status, create standby tenant failed");
}
if (OB_FAIL(ret)) {
} else {
LOG_INFO("[CREATE STANDBY TENANT] wait create standby tenant end", K(tenant_id), K(user_tenant_id),
K(meta_tenant_id), K(meta_schema_version), K(user_schema_version), KPC(tenant_schema));
ob_usleep(500 * 1000L); // 500ms
}
}
LOG_INFO("[CREATE STANDBY TENANT] finish to wait create standby tenant end", KR(ret), K(tenant_id),
"cost", ObTimeUtility::current_time() - start_ts, K(user_tenant_id),
K(meta_tenant_id), K(meta_schema_version), K(user_schema_version), KPC(tenant_schema));
return ret;
}
int ObCreateStandbyTenantExecutor::check_can_create_standby_tenant_(
const common::ObString &log_restore_source,
ObCompatibilityMode &compat_mode)
{
int ret = OB_SUCCESS;
int64_t start_ts = ObTimeUtility::current_time();
share::ObBackupConfigParserMgr config_parser_mgr;
common::ObSqlString name;
common::ObSqlString value;
compat_mode = ObCompatibilityMode::OCEANBASE_MODE;
if (OB_FAIL(name.assign("log_restore_source"))) {
LOG_WARN("assign sql failed", KR(ret));
} else if (OB_FAIL(value.assign(log_restore_source))) {
LOG_WARN("fail to assign value", KR(ret), K(log_restore_source));
} else if (OB_FAIL(config_parser_mgr.init(name, value, 1002 /* fake_user_tenant_id */))) {
LOG_WARN("fail to init backup config parser mgr", KR(ret), K(name), K(value));
} else if (OB_FAIL(config_parser_mgr.only_check_before_update(compat_mode))) {
LOG_WARN("fail to only_check_before_update", KR(ret), K(name), K(value));
}
LOG_INFO("[CREATE STANDBY TENANT] check can create standby tenant", KR(ret), K(log_restore_source),
K(compat_mode), "cost", ObTimeUtility::current_time() - start_ts);
return ret;
}
int check_sys_var_options(ObExecContext &ctx,
const common::ObIArray<ObVariableSetStmt::VariableSetNode> &sys_var_nodes,
share::schema::ObTenantSchema &tenant_schema,

4
src/sql/engine/cmd/ob_tenant_executor.h
View File

@ -63,10 +63,6 @@ public:
virtual ~ObCreateStandbyTenantExecutor() {}
int execute(ObExecContext &ctx, ObCreateTenantStmt &stmt);
private:
int wait_create_standby_tenant_end_(const uint64_t tenant_id);
int check_can_create_standby_tenant_(
const common::ObString &log_restore_source,
ObCompatibilityMode &compat_mode);
DISALLOW_COPY_AND_ASSIGN(ObCreateStandbyTenantExecutor);
};