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

[4.3] fix some remain problems about clone

Browse Source
This commit is contained in:
obdev
2024-02-07 22:56:56 +00:00
committed by ob-robot
parent 3f197a59ec
commit 38893110e9
13 changed files with 285 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/rootserver/ob_ddl_service.cpp
View File

@ -25786,7 +25786,7 @@ int ObDDLService::modify_and_cal_resource_pool_diff(
LOG_WARN("fail to grant pool", K(ret), K(diff_pools));
} else if (OB_FAIL(unit_mgr_->grant_pools(
trans, new_ug_id_array, compat_mode, diff_pools, tenant_id,
OB_INVALID_TENANT_ID/*source_tenant_id*/))) {
false/*is_bootstrap*/, OB_INVALID_TENANT_ID/*source_tenant_id*/))) {
LOG_WARN("fail to grant pools", K(ret));
}
} else if (new_pool_name_list.count() + 1 == old_pool_name_list.count()) {
@ -26596,6 +26596,11 @@ int ObDDLService::drop_tenant(const ObDropTenantArg &arg)
if (OB_FAIL(ObAllTenantInfoProxy::load_tenant_info(
user_tenant_id, sql_proxy_, false, tenant_info))) {
LOG_WARN("failed to load tenant info", KR(ret), K(arg), K(user_tenant_id));
} else if (!tenant_info.is_primary() && !tenant_info.is_standby()) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("drop tenant not in primary or standby role is not supported",
KR(ret), K(arg), K(tenant_info));
LOG_USER_ERROR(OB_NOT_SUPPORTED, "should drop tenant force, drop tenant");
} else if (tenant_info.is_standby() && !open_recyclebin) {
//if standby tenant and no recyclebin, need drop force
drop_force = true;

34
src/rootserver/ob_disaster_recovery_worker.cpp
View File

@ -1972,31 +1972,29 @@ int ObDRWorker::try_disaster_recovery()
int ObDRWorker::check_whether_the_tenant_role_can_exec_dr_(const uint64_t tenant_id)
{
int ret = OB_SUCCESS;
ObAllTenantInfo tenant_info;
if (OB_UNLIKELY(!inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("not init", KR(ret));
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id)) {
} else if (OB_UNLIKELY(OB_INVALID_ID == tenant_id)
|| OB_ISNULL(GCTX.sql_proxy_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(tenant_id));
} else if (is_sys_tenant(tenant_id) || is_meta_tenant(tenant_id)) {
// good, sys tenant and meta tenant can not in clone procedure
} else if (OB_FAIL(ObAllTenantInfoProxy::load_tenant_info(
tenant_id,
GCTX.sql_proxy_,
false,
tenant_info))) {
LOG_WARN("fail to load tenant info", KR(ret), K(tenant_id));
} else if (tenant_info.is_clone()) {
ret = OB_STATE_NOT_MATCH;
LOG_INFO("the tenant is currently in the clone processing and disaster recovery will"
" not be executed for the time being", KR(ret), K(tenant_id));
} else {
if (is_sys_tenant(tenant_id) || is_meta_tenant(tenant_id)) {
ret = OB_SUCCESS;
} else {
ObAllTenantInfo tenant_info;
if (OB_FAIL(ObAllTenantInfoProxy::load_tenant_info(tenant_id,
GCTX.sql_proxy_,
false,
tenant_info))) {
LOG_WARN("fail to load tenant info", KR(ret), K(tenant_id));
} else if (tenant_info.is_clone()) {
ret = OB_STATE_NOT_MATCH;
LOG_INFO("the tenant is currently in the clone processing and disaster recovery will"
" not be executed for the time being", KR(ret), K(tenant_id));
} else {
ret = OB_SUCCESS;
}
}
// good, can do dr-task
}
return ret;
}

4
src/rootserver/ob_tenant_role_transition_service.cpp
View File

@ -433,8 +433,8 @@ int ObTenantRoleTransitionService::do_switch_access_mode_to_append(
LOG_WARN("Tenant status changed by concurrent operation, switch to primary not allowed",
KR(ret), K(tenant_info), K(cur_tenant_info));
LOG_USER_ERROR(OB_OP_NOT_ALLOW, "tenant status changed by concurrent operation, switch to primary");
} else if (OB_FAIL(ObAllTenantInfoProxy::update_tenant_role(
tenant_id_, &trans, tenant_info.get_switchover_epoch(),
} else if (OB_FAIL(ObAllTenantInfoProxy::update_tenant_role_in_trans(
tenant_id_, trans, tenant_info.get_switchover_epoch(),
share::PRIMARY_TENANT_ROLE, tenant_info.get_switchover_status(),
share::NORMAL_SWITCHOVER_STATUS, switchover_epoch_))) {
LOG_WARN("failed to update tenant switchover status", KR(ret), K(tenant_id_), K(tenant_info), K(cur_tenant_info));

41
src/rootserver/ob_upgrade_executor.cpp
View File

@ -1286,17 +1286,29 @@ int ObUpgradeExecutor::construct_tenant_ids_(
{
int ret = OB_SUCCESS;
ObArray<uint64_t> standby_tenants;
bool is_standby = false;
ObTenantRole tenant_role(share::ObTenantRole::INVALID_TENANT);
ObSchemaGetterGuard schema_guard;
if (OB_FAIL(check_inner_stat_())) {
LOG_WARN("fail to check inner stat", KR(ret));
} else if (OB_FAIL(schema_service_->get_tenant_schema_guard(OB_SYS_TENANT_ID, schema_guard))) {
LOG_WARN("fail to get sys tenant schema guard", KR(ret));
} else if (src_tenant_ids.count() > 0) {
for (int64_t i = 0; OB_SUCC(ret) && i < src_tenant_ids.count(); i++) {
const uint64_t tenant_id = src_tenant_ids.at(i);
if (OB_FAIL(ObAllTenantInfoProxy::is_standby_tenant(sql_proxy_, tenant_id, is_standby))) {
LOG_WARN("fail to check is standby tenant", KR(ret), K(tenant_id));
} else if (is_standby) {
const ObSimpleTenantSchema *tenant_schema = nullptr;
if (OB_FAIL(schema_guard.get_tenant_info(tenant_id, tenant_schema))) {
LOG_WARN("fail to get tenant info", KR(ret), K(tenant_id));
} else if (OB_ISNULL(tenant_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("tenant schema is null", KR(ret), KP(tenant_schema));
} else if (!tenant_schema->is_normal()) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("not support to upgrade a standby tenant", KR(ret), K(tenant_id));
LOG_WARN("tenant is not normal, can not do upgrade", KR(ret), K(tenant_id), KPC(tenant_schema));
} else if (OB_FAIL(ObAllTenantInfoProxy::get_tenant_role(sql_proxy_, tenant_id, tenant_role))) {
LOG_WARN("fail to get tenant role", KR(ret), K(tenant_id), K(tenant_role));
} else if (!tenant_role.is_primary()) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("not support to upgrade a non-primary tenant", KR(ret), K(tenant_id), K(tenant_role));
}
} // end for
// tenant_list is specified
@ -1310,10 +1322,23 @@ int ObUpgradeExecutor::construct_tenant_ids_(
}
for (int64_t i = 0; OB_SUCC(ret) && i < tenant_ids.count(); i++) {
const uint64_t tenant_id = tenant_ids.at(i);
if (OB_FAIL(ObAllTenantInfoProxy::is_standby_tenant(sql_proxy_, tenant_id, is_standby))) {
LOG_WARN("fail to check is standby tenant", KR(ret), K(tenant_id));
} else if (is_standby) {
const ObSimpleTenantSchema *tenant_schema = nullptr;
if (OB_FAIL(schema_guard.get_tenant_info(tenant_id, tenant_schema))) {
LOG_WARN("fail to get tenant info", KR(ret), K(tenant_id));
} else if (OB_ISNULL(tenant_schema)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("tenant schema is null", KR(ret), KP(tenant_schema));
} else if (!tenant_schema->is_normal()) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("tenant is not normal, can not do upgrade", KR(ret), K(tenant_id), KPC(tenant_schema));
} else if (OB_FAIL(ObAllTenantInfoProxy::get_tenant_role(sql_proxy_, tenant_id, tenant_role))) {
LOG_WARN("fail to get tenant role", KR(ret), K(tenant_id), K(tenant_role));
} else if (tenant_role.is_standby()) {
// skip
} else if (!tenant_role.is_primary()) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("not support do upgrade with tenant role is neither primary nor standby",
KR(ret), K(tenant_id), K(tenant_role));
} else if (OB_FAIL(dst_tenant_ids.push_back(tenant_id))) {
LOG_WARN("fail to push back tenant_id", KR(ret), K(tenant_id));
}

1
src/rootserver/restore/ob_clone_scheduler.cpp
View File

@ -1082,6 +1082,7 @@ int ObCloneScheduler::clone_user_finish(const share::ObCloneJob &job)
uint64_t user_tenant_id = job.get_tenant_id();
bool sync_satisfied = true;
DEBUG_SYNC(BEFORE_CREATE_CLONE_TENANT_END);
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
LOG_WARN("not inited", KR(ret));

115
src/rootserver/tenant_snapshot/ob_tenant_snapshot_util.cpp
View File

@ -36,7 +36,8 @@ static const char* conflict_case_with_clone_strs[] = {
"MODIFY_UNIT",
"MODIFY_LS",
"MODIFY_REPLICA",
"SWITCHOVER"
"MODIFY_TENANT_ROLE_OR_SWITCHOVER_STATUS",
"DELAY_DROP_TENANT"
};
const char* ObConflictCaseWithClone::get_case_name_str() const
@ -1291,6 +1292,8 @@ int ObTenantSnapshotUtil::check_tenant_has_no_conflict_tasks(
} else if (is_sys_tenant(tenant_id) || is_meta_tenant(tenant_id)) {
ret = OB_OP_NOT_ALLOW;
LOG_WARN("sys or meta tenant can not in clone procedure, clone not allowed", KR(ret), K(tenant_id));
} else if (OB_FAIL(check_tenant_is_in_dropping_procedure_(tenant_id))) {
LOG_WARN("fail to check tenant in dropping procedure", KR(ret), K(tenant_id));
} else if (OB_FAIL(check_tenant_is_in_upgrading_procedure_(tenant_id, data_version))) {
LOG_WARN("fail to check tenant in upgrading procedure", KR(ret), K(tenant_id));
} else if (OB_FAIL(check_tenant_is_in_transfer_procedure_(tenant_id))) {
@ -1314,13 +1317,40 @@ int ObTenantSnapshotUtil::check_tenant_has_no_conflict_tasks(
return ret;
}
int ObTenantSnapshotUtil::check_tenant_is_in_dropping_procedure_(
const uint64_t tenant_id)
{
int ret = OB_SUCCESS;
int64_t check_begin_time = ObTimeUtility::current_time();
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::DELAY_DROP_TENANT);
schema::ObTenantStatus tenant_status = ObTenantStatus::TENANT_STATUS_MAX;
LOG_INFO("begin to check whether tenant is dropping", K(tenant_id));
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant id", KR(ret), K(tenant_id));
} else if (OB_ISNULL(GCTX.sql_proxy_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret));
} else if (OB_FAIL(inner_lock_line_for_all_tenant_table_(tenant_id, *GCTX.sql_proxy_, tenant_status))) {
LOG_WARN("fail to lock line in __all_table table", KR(ret), K(tenant_id));
} else if (!is_tenant_normal(tenant_status)) {
ret = OB_CONFLICT_WITH_CLONE;
LOG_WARN("source tenant is in dropping procedure, can not do clone",
KR(ret), K(tenant_id), K(tenant_status));
LOG_USER_ERROR(OB_CONFLICT_WITH_CLONE, tenant_id, case_to_check.get_case_name_str(), CLONE_PROCEDURE_STR);
}
int64_t cost = ObTimeUtility::current_time() - check_begin_time;
LOG_INFO("finish check whether tenant is dropping", KR(ret), K(tenant_id), K(check_begin_time), K(cost));
return ret;
}
int ObTenantSnapshotUtil::check_tenant_is_in_upgrading_procedure_(
const uint64_t tenant_id,
uint64_t &data_version)
{
int ret = OB_SUCCESS;
data_version = 0;
int check_begin_time = ObTimeUtility::current_time();
int64_t check_begin_time = ObTimeUtility::current_time();
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::UPGRADE);
LOG_INFO("begin to check whether tenant is upgrading", K(tenant_id));
common::ObMySQLTransaction trans;
@ -1349,11 +1379,6 @@ int ObTenantSnapshotUtil::check_tenant_is_in_upgrading_procedure_(
data_version = target_data_version;
}
}
// TODO@jingyu.cr: need to solve problems below
// 1. after current_data_version==target_data_version in upgrade procedure, make sure whether check conflict in steps remained
// 2. clone tenant need target_tenant initialize data_version
// source tenant baseline + memdump's data_version need same
// make sure whether to double check tenant's data_version is same
if (trans.is_started()) {
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(trans.end(OB_SUCC(ret)))) {
@ -1370,7 +1395,7 @@ int ObTenantSnapshotUtil::check_tenant_is_in_transfer_procedure_(
const uint64_t tenant_id)
{
int ret = OB_SUCCESS;
int check_begin_time = ObTimeUtility::current_time();
int64_t check_begin_time = ObTimeUtility::current_time();
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::TRANSFER);
LOG_INFO("begin to check whether tenant is transfer", K(tenant_id));
common::ObMySQLTransaction trans;
@ -1428,7 +1453,7 @@ int ObTenantSnapshotUtil::check_tenant_is_in_modify_resource_pool_procedure_(
const uint64_t tenant_id)
{
int ret = OB_SUCCESS;
int check_begin_time = ObTimeUtility::current_time();
int64_t check_begin_time = ObTimeUtility::current_time();
LOG_INFO("begin to check whether tenant is transfer", K(tenant_id));
ObSqlString sql("FetchPool");
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id))) {
@ -1472,7 +1497,7 @@ int ObTenantSnapshotUtil::check_tenant_is_in_modify_ls_procedure_(
{
int ret = OB_SUCCESS;
common::ObMySQLTransaction trans;
int check_begin_time = ObTimeUtility::current_time();
int64_t check_begin_time = ObTimeUtility::current_time();
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::MODIFY_LS);
LOG_INFO("begin to check whether tenant is modifing ls", K(tenant_id));
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id))) {
@ -1530,7 +1555,7 @@ int ObTenantSnapshotUtil::check_tenant_is_in_modify_replica_procedure_(
observer::ObInnerSQLConnection *conn = NULL;
ObSqlString sql("FetchDRTask");
int64_t task_cnt = 0;
int check_begin_time = ObTimeUtility::current_time();
int64_t check_begin_time = ObTimeUtility::current_time();
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::MODIFY_REPLICA);
LOG_INFO("begin to check whether tenant is modifing ls", K(tenant_id));
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id))) {
@ -1593,8 +1618,8 @@ int ObTenantSnapshotUtil::check_tenant_is_in_switchover_procedure_(
int ret = OB_SUCCESS;
common::ObMySQLTransaction trans;
ObAllTenantInfo tenant_info;
int check_begin_time = ObTimeUtility::current_time();
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::SWITCHOVER);
int64_t check_begin_time = ObTimeUtility::current_time();
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::MODIFY_TENANT_ROLE_OR_SWITCHOVER_STATUS);
LOG_INFO("begin to check whether tenant is switchover", K(tenant_id));
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id))) {
ret = OB_INVALID_ARGUMENT;
@ -1634,7 +1659,7 @@ int ObTenantSnapshotUtil::check_tenant_is_in_modify_unit_procedure_(
int ret = OB_SUCCESS;
common::ObMySQLTransaction trans;
ObSqlString sql("FetchUnit");
int check_begin_time = ObTimeUtility::current_time();
int64_t check_begin_time = ObTimeUtility::current_time();
LOG_INFO("begin to check whether tenant is modifing unit", K(tenant_id));
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id))) {
ret = OB_INVALID_ARGUMENT;
@ -1802,3 +1827,65 @@ int ObTenantSnapshotUtil::lock_resource_pool_for_tenant(
}
return ret;
}
int ObTenantSnapshotUtil::lock_status_for_tenant(
ObMySQLTransaction &trans,
const uint64_t tenant_id_to_check)
{
int ret = OB_SUCCESS;
schema::ObTenantStatus tenant_status = ObTenantStatus::TENANT_STATUS_MAX; // not used
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id_to_check))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(tenant_id_to_check));
} else if (!is_user_tenant(tenant_id_to_check)) {
// do nothing
} else if (OB_FAIL(inner_lock_line_for_all_tenant_table_(tenant_id_to_check, trans, tenant_status))) {
LOG_WARN("fail to lock line in __all_table table", KR(ret), K(tenant_id_to_check));
}
return ret;
}
int ObTenantSnapshotUtil::inner_lock_line_for_all_tenant_table_(
const uint64_t tenant_id_to_lock,
ObISQLClient &sql_proxy,
share::schema::ObTenantStatus &tenant_status)
{
int ret = OB_SUCCESS;
tenant_status = ObTenantStatus::TENANT_STATUS_MAX;
ObSqlString sql("TenantLock");
if (OB_UNLIKELY(!is_valid_tenant_id(tenant_id_to_lock))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(tenant_id_to_lock));
} else if (OB_FAIL(sql.append_fmt("SELECT status FROM %s WHERE tenant_id = %lu FOR UPDATE",
OB_ALL_TENANT_TNAME, tenant_id_to_lock))) {
LOG_WARN("append_fmt failed", KR(ret), K(tenant_id_to_lock));
} else {
SMART_VAR(ObISQLClient::ReadResult, result) {
common::sqlclient::ObMySQLResult *res = NULL;
if (OB_FAIL(sql_proxy.read(result, GCONF.cluster_id, OB_SYS_TENANT_ID, sql.ptr()))) {
LOG_WARN("execute sql failed", KR(ret), "sql", sql.ptr());
} else if (OB_ISNULL(res = result.get_result())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get mysql result failed", KR(ret));
} else if (OB_FAIL(res->next())) {
if (OB_ITER_END == ret) {
// rewrite error code
ret = OB_STATE_NOT_MATCH;
LOG_WARN("expect at least one row in __all_tenant", KR(ret), K(sql));
} else {
LOG_WARN("iterate next result fail", KR(ret), K(sql));
}
} else {
ObString status_str;
schema::ObTenantStatus tenant_status;
EXTRACT_VARCHAR_FIELD_MYSQL(*res, "status", status_str);
if (OB_SUCC(ret)) {
if (OB_FAIL(schema::get_tenant_status(status_str, tenant_status))) {
LOG_WARN("get tenant status failed", KR(ret), K(status_str));
}
}
}
}
}
return ret;
}

37
src/rootserver/tenant_snapshot/ob_tenant_snapshot_util.h
View File

@ -44,7 +44,8 @@ public:
MODIFY_UNIT = 3,
MODIFY_LS = 4,
MODIFY_REPLICA = 5,
SWITCHOVER = 6,
MODIFY_TENANT_ROLE_OR_SWITCHOVER_STATUS = 6,
DELAY_DROP_TENANT = 7,
MAX_CASE_NAME
};
public:
@ -65,7 +66,8 @@ public:
bool is_modify_unit() const { return MODIFY_UNIT == case_name_; }
bool is_modify_ls() const { return MODIFY_LS == case_name_; }
bool is_modify_replica() const { return MODIFY_REPLICA == case_name_; }
bool is_switchover() const { return SWITCHOVER == case_name_; }
bool is_switchover() const { return MODIFY_TENANT_ROLE_OR_SWITCHOVER_STATUS == case_name_; }
bool is_delay_drop_tenant() const { return DELAY_DROP_TENANT == case_name_; }
const ConflictCaseWithClone &get_case_name() const { return case_name_; }
const char* get_case_name_str() const;
private:
@ -162,17 +164,47 @@ public:
const uint64_t tenant_id,
const share::ObTenantSnapshotID &tenant_snapshot_id);
// functions to check conflict conditions between clone and other operations
// some procedure need to conflict with clone, so need to check whether in clone procedure
// 1. ObDRTaskMgr::persist_task_info_ (can not do dr-task)
// 2. ObTenantBalanceService::persist_job_and_task_ (can not do transfer)
// 3. ObUpgradeExecutor::run_upgrade_begin_action_ (can not do upgrade)
// 4. ObTenantSqlService::delay_to_drop_tenant (can not do delay drop tenant)
// 5. ObAllTenantInfoProxy::update_tenant_role_in_trans (can not do switchover)
// ObAllTenantInfoProxy::update_tenant_status (can not do switchover)
// 6. ObUnitTableOperator::update_unit (can not modify unit)
// 7. ObUnitTableOperator::update_resource_pool (can not modify resource pool)
// 8. ObLSAttrOperator::operator_ls_in_trans_ (can not modify ls)
// ObLSAttrOperator::alter_ls_group_in_trans (can not modify ls)
// ObLSAttrOperator::update_ls_flag_in_trans (can not modify ls)
static int check_tenant_not_in_cloning_procedure(
const uint64_t tenant_id,
const ObConflictCaseWithClone &case_to_check);
static int check_tenant_has_no_conflict_tasks(const uint64_t tenant_id);
// when update __all_unit, in some case we have to lock __all_unit first and then check clone
// called by ObUnitTableOperator::update_unit
static int lock_unit_for_tenant(
common::ObISQLClient &client,
const share::ObUnit &unit,
uint64_t &tenant_id_to_lock);
// when update __all_resource_pool, in some case we have to lock __all_resource_pool first and then check clone
// called by ObUnitTableOperator::update_resource_pool
static int lock_resource_pool_for_tenant(
common::ObISQLClient &client,
const share::ObResourcePool &resource_pool);
// when update __all_tenant, inn some case we have to lock __all_tenant first and then check clone
// called by ObTenantSqlService::delay_to_drop_tenant
static int lock_status_for_tenant(
ObMySQLTransaction &trans,
const uint64_t tenant_id_to_check);
// inner lock __all_tenant for lock_status_for_tenant and check_tenant_is_in_dropping_procedure_
static int inner_lock_line_for_all_tenant_table_(
const uint64_t tenant_id_to_lock,
ObISQLClient &sql_proxy,
share::schema::ObTenantStatus &tenant_status);
private:
static int check_tenant_snapshot_simulated_mutex_(ObMySQLTransaction &trans,
const uint64_t tenant_id,
@ -204,6 +236,7 @@ private:
// @params[in] tenant_id, tenant to check
static int check_tenant_is_in_upgrading_procedure_(const uint64_t tenant_id,
uint64_t &data_version);
static int check_tenant_is_in_dropping_procedure_(const uint64_t tenant_id);
static int check_tenant_is_in_transfer_procedure_(const uint64_t tenant_id);
static int check_tenant_is_in_modify_resource_pool_procedure_(const uint64_t tenant_id);
static int check_tenant_is_in_modify_unit_procedure_(const uint64_t tenant_id);

1
src/share/ob_debug_sync_point.h
View File

@ -568,6 +568,7 @@ class ObString;
ACT(BEFORE_SEND_PARALLEL_CREATE_TABLE,)\
ACT(BEFORE_DROP_TENANT,)\
ACT(BEFORE_WAIT_SYS_LS_END_SCN,)\
ACT(BEFORE_CREATE_CLONE_TENANT_END,)\
ACT(BEFORE_CALC_CONSISTENT_SCN,)\
ACT(MAX_DEBUG_SYNC_POINT,)

4
src/share/ob_primary_standby_service.cpp
View File

@ -576,8 +576,8 @@ int ObPrimaryStandbyService::update_tenant_status_before_sw_to_standby_(
} else if (cur_switchover_epoch != tenant_info.get_switchover_epoch()) {
ret = OB_NEED_RETRY;
LOG_WARN("tenant not expect switchover epoch", KR(ret), K(tenant_info), K(cur_switchover_epoch));
} else if (OB_FAIL(ObAllTenantInfoProxy::update_tenant_role(
tenant_id, &trans, cur_switchover_epoch,
} else if (OB_FAIL(ObAllTenantInfoProxy::update_tenant_role_in_trans(
tenant_id, trans, cur_switchover_epoch,
PRIMARY_TENANT_ROLE, cur_switchover_status,
share::PREP_SWITCHING_TO_STANDBY_SWITCHOVER_STATUS, new_switchover_ts))) {
LOG_WARN("failed to update tenant role", KR(ret), K(tenant_id), K(cur_switchover_epoch), K(tenant_info));

55
src/share/ob_tenant_info_proxy.cpp
View File

@ -15,6 +15,7 @@
#include "share/ob_tenant_info_proxy.h"
#include "share/ob_cluster_role.h"//ObClusterTYPE
#include "share/ob_share_util.h"//ObShareUtil
#include "share/ob_tenant_info_proxy.h" //ObAllTenantInfo
#include "share/config/ob_server_config.h"//GCONF
#include "share/inner_table/ob_inner_table_schema.h"//ALL_TENANT_INFO_TNAME
#include "share/ls/ob_ls_i_life_manager.h"//TODO SCN VALUE
@ -581,7 +582,47 @@ int ObAllTenantInfoProxy::update_tenant_max_ls_id(
int ObAllTenantInfoProxy::update_tenant_role(
const uint64_t tenant_id,
ObISQLClient *proxy,
common::ObMySQLProxy *proxy,
int64_t old_switchover_epoch,
const ObTenantRole &new_role,
const ObTenantSwitchoverStatus &old_status,
const ObTenantSwitchoverStatus &new_status,
int64_t &new_switchover_ts)
{
int ret = OB_SUCCESS;
common::ObMySQLTransaction trans;
const uint64_t exec_tenant_id = gen_meta_tenant_id(tenant_id);
if (OB_UNLIKELY(!is_user_tenant(tenant_id)
|| OB_INVALID_VERSION == old_switchover_epoch
|| !new_role.is_valid()
|| !old_status.is_valid()
|| !new_status.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("tenant_info is invalid", KR(ret), K(tenant_id),
K(old_switchover_epoch), K(old_status), K(new_role), K(new_status));
} else if (OB_ISNULL(proxy)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret));
} else if (OB_FAIL(trans.start(proxy, exec_tenant_id))) {
LOG_WARN("failed to start trans", KR(ret), K(exec_tenant_id), K(tenant_id));
} else if (OB_FAIL(update_tenant_role_in_trans(tenant_id, trans, old_switchover_epoch,
new_role, old_status, new_status, new_switchover_ts))) {
LOG_WARN("fail to update tenant role in trans", KR(ret), K(tenant_id), K(old_switchover_epoch),
K(new_role), K(old_status), K(new_status), K(new_switchover_ts));
}
if (trans.is_started()) {
int tmp_ret = OB_SUCCESS;
if (OB_SUCCESS != (tmp_ret = trans.end(OB_SUCC(ret)))) {
LOG_WARN("failed to commit trans", KR(ret), KR(tmp_ret));
ret = OB_SUCC(ret) ? tmp_ret : ret;
}
}
return ret;
}
int ObAllTenantInfoProxy::update_tenant_role_in_trans(
const uint64_t tenant_id,
ObMySQLTransaction &trans,
int64_t old_switchover_epoch,
const ObTenantRole &new_role,
const ObTenantSwitchoverStatus &old_status,
@ -594,7 +635,8 @@ int ObAllTenantInfoProxy::update_tenant_role(
ObSqlString sql;
int64_t affected_rows = 0;
ObTimeoutCtx ctx;
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::SWITCHOVER);
ObAllTenantInfo cur_tenant_info;
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::MODIFY_TENANT_ROLE_OR_SWITCHOVER_STATUS);
if (OB_UNLIKELY(!is_user_tenant(tenant_id)
|| OB_INVALID_VERSION == old_switchover_epoch
@ -604,9 +646,8 @@ int ObAllTenantInfoProxy::update_tenant_role(
ret = OB_INVALID_ARGUMENT;
LOG_WARN("tenant_info is invalid", KR(ret), K(tenant_id), K(old_switchover_epoch), K(old_status),
K(new_role), K(new_status));
} else if (OB_ISNULL(proxy)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("proxy is null", KR(ret), KP(proxy));
} else if (OB_FAIL(ObAllTenantInfoProxy::load_tenant_info(tenant_id, &trans, true, cur_tenant_info))) {
LOG_WARN("failed to load all tenant info", KR(ret), K(tenant_id));
} else if (OB_FAIL(ObTenantSnapshotUtil::check_tenant_not_in_cloning_procedure(tenant_id, case_to_check))) {
LOG_WARN("fail to check whether tenant is in cloning procedure", KR(ret), K(tenant_id));
} else if (OB_FAIL(get_new_switchover_epoch_(old_switchover_epoch, old_status, new_status,
@ -627,7 +668,7 @@ int ObAllTenantInfoProxy::update_tenant_role(
new_switchover_ts, tenant_id, old_switchover_epoch, old_status.to_str()))) {
LOG_WARN("failed to assign sql", KR(ret), K(tenant_id), K(old_switchover_epoch),
K(new_role), K(old_status), K(sql));
} else if (OB_FAIL(proxy->write(exec_tenant_id, sql.ptr(), affected_rows))) {
} else if (OB_FAIL(trans.write(exec_tenant_id, sql.ptr(), affected_rows))) {
LOG_WARN("failed to execute sql", KR(ret), K(exec_tenant_id), K(sql));
} else if (0 == affected_rows) {
ret = OB_NEED_RETRY;
@ -775,7 +816,7 @@ int ObAllTenantInfoProxy::update_tenant_status(
ObTimeoutCtx ctx;
int64_t new_switchover_epoch = OB_INVALID_VERSION;
ObLogRestoreSourceMgr restore_source_mgr;
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::SWITCHOVER);
ObConflictCaseWithClone case_to_check(ObConflictCaseWithClone::MODIFY_TENANT_ROLE_OR_SWITCHOVER_STATUS);
if (OB_UNLIKELY(!is_user_tenant(tenant_id)
|| !new_role.is_valid()

27
src/share/ob_tenant_info_proxy.h
View File

@ -283,12 +283,37 @@ private:
* OB_SUCCESS update tenant role successfully
* OB_NEED_RETRY old_switchover_epoch not match, need retry
*/
static int update_tenant_role(const uint64_t tenant_id, ObISQLClient *proxy,
static int update_tenant_role(
const uint64_t tenant_id,
common::ObMySQLProxy *proxy,
int64_t old_switchover_epoch,
const ObTenantRole &new_role,
const ObTenantSwitchoverStatus &old_status,
const ObTenantSwitchoverStatus &new_status,
int64_t &new_switchover_epoch);
/**
* @description: update tenant role of __all_tenant_info in trans, make sure conflict with clone
* @param[in] tenant_id
* @param[in] trans
* @param[in] old_switchover_epoch, for operator concurrency
* @param[in] new_role : target tenant role to be update
* @param[in] old_status : old switchover status
* @param[in] new_status : target switchover status to be update
* @param[out] new_switchover_epoch, for operator concurrency
* return :
* OB_SUCCESS update tenant role successfully
* OB_NEED_RETRY old_switchover_epoch not match, need retry
*/
static int update_tenant_role_in_trans(
const uint64_t tenant_id,
ObMySQLTransaction &trans,
int64_t old_switchover_epoch,
const ObTenantRole &new_role,
const ObTenantSwitchoverStatus &old_status,
const ObTenantSwitchoverStatus &new_status,
int64_t &new_switchover_epoch);
static int fill_cell(common::sqlclient::ObMySQLResult *result, ObAllTenantInfo &tenant_info, int64_t &ora_rowscn);
/**
* @description: update tenant max ls id while create ls or upgrade, in upgrade from 4100 to 4200,

40
src/share/schema/ob_tenant_sql_service.cpp
View File

@ -16,6 +16,7 @@
#include "lib/oblog/ob_log_module.h"
#include "lib/string/ob_sql_string.h"
#include "lib/mysqlclient/ob_isql_client.h"
#include "rootserver/tenant_snapshot/ob_tenant_snapshot_util.h" // for ObTenantSnapshotUtil
#include "share/ob_dml_sql_splicer.h"
#include "share/inner_table/ob_inner_table_schema_constants.h"
#include "share/schema/ob_schema_struct.h"
@ -90,15 +91,25 @@ int ObTenantSqlService::alter_tenant(
int ObTenantSqlService::delay_to_drop_tenant(
const ObTenantSchema &tenant_schema,
ObISQLClient &sql_client,
ObMySQLTransaction &trans,
const ObString *ddl_stmt_str)
{
int ret = OB_SUCCESS;
const ObSchemaOperationType op = OB_DDL_DEL_TENANT_START;
rootserver::ObConflictCaseWithClone case_to_check(rootserver::ObConflictCaseWithClone::DELAY_DROP_TENANT);
uint64_t tenant_id_to_check_clone = tenant_schema.get_tenant_id();
if (!tenant_schema.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant schema", K(tenant_schema), K(ret));
} else if (OB_FAIL(replace_tenant(tenant_schema, op, sql_client, ddl_stmt_str))) {
} else if (!is_user_tenant(tenant_id_to_check_clone)) {
// sys tenant and meta tenant can not in clone procedure
} else if (OB_FAIL(rootserver::ObTenantSnapshotUtil::lock_status_for_tenant(trans, tenant_id_to_check_clone))) {
LOG_WARN("fail to lock __all_tenant for clone check", KR(ret), K(tenant_id_to_check_clone));
} else if (OB_FAIL(rootserver::ObTenantSnapshotUtil::check_tenant_not_in_cloning_procedure(tenant_id_to_check_clone, case_to_check))) {
LOG_WARN("fail to check whether tenant is cloning", KR(ret), K(tenant_id_to_check_clone), K(case_to_check));
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(replace_tenant(tenant_schema, op, trans, ddl_stmt_str))) {
LOG_WARN("replace_tenant failed", K(tenant_schema), K(op), K(ret));
}
return ret;
@ -175,31 +186,6 @@ int ObTenantSqlService::delete_tenant(
return ret;
}
int ObTenantSqlService::delete_tenant_content(
ObISQLClient &client,
const uint64_t tenant_id,
const char *table_name)
{
int ret = OB_SUCCESS;
ObSqlString sql;
int64_t affected_rows = 0;
const uint64_t exec_tenant_id = ObSchemaUtils::get_exec_tenant_id(tenant_id);
if (OB_INVALID_ID == tenant_id) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid tenant_id", K(tenant_id), K(ret));
} else if (OB_ISNULL(table_name)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("table_name is null", K(ret));
} else if (OB_FAIL(sql.assign_fmt("DELETE FROM %s WHERE tenant_id = %lu",
table_name,
ObSchemaUtils::get_extract_tenant_id(exec_tenant_id, tenant_id)))) {
LOG_WARN("assign_fmt failed", K(ret));
} else if (OB_FAIL(client.write(exec_tenant_id, sql.ptr(), affected_rows))) {
LOG_WARN("execute sql failed", K(sql), K(ret));
}
return ret;
}
int ObTenantSqlService::replace_tenant(
const ObTenantSchema &tenant_schema,
const ObSchemaOperationType op,

5
src/share/schema/ob_tenant_sql_service.h
View File

@ -47,7 +47,7 @@ public:
common::ObISQLClient &sql_client,
const common::ObString *ddl_stmt_str = NULL);
virtual int delay_to_drop_tenant(const ObTenantSchema &tenant_schema,
ObISQLClient &sql_client,
ObMySQLTransaction &trans,
const ObString *ddl_stmt_str);
virtual int drop_tenant_to_recyclebin(const ObTenantSchema &tenant_schema,
common::ObISQLClient &sql_client,
@ -57,9 +57,6 @@ public:
const int64_t new_schema_version,
common::ObISQLClient &sql_client,
const common::ObString *ddl_stmt_str = NULL);
virtual int delete_tenant_content(common::ObISQLClient &client,
const uint64_t tenant_id,
const char *table_name);
private:
int replace_tenant(const ObTenantSchema &tenant_schema,
const ObSchemaOperationType op,