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

tools: ob_admin add remove_lock/update_lock cmd

Browse Source
This commit is contained in:
obdev
2022-12-28 04:45:30 +00:00
committed by ob-robot
parent a453d36a83
commit 79bb01f4d1
11 changed files with 476 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/observer/ob_srv_xlator_partition.cpp
View File

@ -196,7 +196,9 @@ void oceanbase::observer::init_srv_xlator_for_others(ObSrvRpcXlator *xlator) {
RPC_PROCESSOR(ObHighPriorityTableLockTaskP, gctx_);
RPC_PROCESSOR(ObOutTransLockTableP, gctx_);
RPC_PROCESSOR(ObOutTransUnlockTableP, gctx_);
RPC_PROCESSOR(ObAdminRemoveLockP);
RPC_PROCESSOR(ObAdminUpdateLockP);
// Region Ratelimit rpc
RPC_PROCESSOR(ObRLGetRegionBWP, gctx_);

2
src/share/ob_srv_rpc_proxy.h
View File

@ -161,6 +161,8 @@ public:
transaction::tablelock::ObTableLockTaskResult);
RPC_AP(PR4 unlock_table, OB_HIGH_PRIORITY_TABLE_LOCK_TASK, (transaction::tablelock::ObTableLockTaskRequest),
transaction::tablelock::ObTableLockTaskResult);
RPC_S(PR4 admin_remove_lock_op, OB_REMOVE_OBJ_LOCK, (transaction::tablelock::ObAdminRemoveLockOpArg));
RPC_S(PR4 admin_update_lock_op, OB_UPDATE_OBJ_LOCK, (transaction::tablelock::ObAdminUpdateLockOpArg));
RPC_S(PR5 remote_write_ddl_redo_log, OB_REMOTE_WRITE_DDL_REDO_LOG, (obrpc::ObRpcRemoteWriteDDLRedoLogArg));
RPC_S(PR5 remote_write_ddl_prepare_log, OB_REMOTE_WRITE_DDL_PREPARE_LOG, (obrpc::ObRpcRemoteWriteDDLPrepareLogArg), obrpc::Int64);
RPC_S(PR5 remote_write_ddl_commit_log, OB_REMOTE_WRITE_DDL_COMMIT_LOG, (obrpc::ObRpcRemoteWriteDDLCommitLogArg), obrpc::Int64);

14
src/storage/ls/ob_ls.h
View File

@ -432,6 +432,20 @@ public:
// int unlock(ObStoreCtx &ctx,
// const transaction::tablelock::ObLockParam &param);
DELEGATE_WITH_RET(lock_table_, unlock, int);
// admin remove a lock op
// @param[in] op_info, contain the lock id, lock type and so on.
// void admin_remove_lock_op(const ObTableLockOp &op_info);
DELEGATE_WITH_RET(lock_table_, admin_remove_lock_op, int);
// used by admin tool. update lock op status.
// @param[in] op_info, the lock/unlock op will be update by admin.
// @param[in] commit_version, set the commit version.
// @param[in] commit_scn, set the commit logts.
// @param[in] status, the lock op status will be set.
// int admin_update_lock_op(const ObTableLockOp &op_info,
// const share::SCN &commit_version,
// const share::SCN &commit_scn,
// const ObTableLockOpStatus status);
DELEGATE_WITH_RET(lock_table_, admin_update_lock_op, int);
// get the lock memtable, used by ObMemtableCtx create process.
// @param[in] handle, will store the memtable of lock table.
// int get_lock_memtable(ObTableHandleV2 &handle)

43
src/storage/tablelock/ob_lock_table.cpp
View File

@ -677,6 +677,49 @@ int ObLockTable::get_lock_op_iter(const ObLockID &lock_id,
return ret;
}
int ObLockTable::admin_remove_lock_op(const ObTableLockOp &op_info)
{
int ret = OB_SUCCESS;
ObTableHandleV2 handle;
ObLockMemtable *memtable = nullptr;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
TABLELOCK_LOG(WARN, "ObLockTable not inited", K(ret));
} else if (OB_FAIL(get_lock_memtable(handle))) {
TABLELOCK_LOG(WARN, "get lock memtable failed", K(ret));
} else if (OB_FAIL(handle.get_lock_memtable(memtable))) {
TABLELOCK_LOG(ERROR, "get lock memtable from lock handle failed", K(ret));
} else {
memtable->remove_lock_record(op_info);
}
TABLELOCK_LOG(INFO, "ObLockTable::admin_remove_lock_op", K(ret), K(op_info));
return ret;
}
int ObLockTable::admin_update_lock_op(const ObTableLockOp &op_info,
const share::SCN &commit_version,
const share::SCN &commit_scn,
const ObTableLockOpStatus status)
{
int ret = OB_SUCCESS;
ObTableHandleV2 handle;
ObLockMemtable *memtable = nullptr;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
TABLELOCK_LOG(WARN, "ObLockTable not inited", K(ret));
} else if (OB_FAIL(get_lock_memtable(handle))) {
TABLELOCK_LOG(WARN, "get lock memtable failed", K(ret));
} else if (OB_FAIL(handle.get_lock_memtable(memtable))) {
TABLELOCK_LOG(ERROR, "get lock memtable from lock handle failed", K(ret));
} else if (OB_FAIL(memtable->update_lock_status(op_info,
commit_version,
commit_scn,
status))) {
LOG_WARN("update lock status failed", KR(ret), K(op_info), K(status));
}
TABLELOCK_LOG(INFO, "ObLockTable::admin_update_lock_op", K(ret), K(op_info));
return ret;
}
} // tablelock
} // transaction

12
src/storage/tablelock/ob_lock_table.h
View File

@ -117,6 +117,18 @@ public:
// @param[out] iter, the iterator returned.
int get_lock_op_iter(const ObLockID &lock_id,
ObLockOpIterator &iter);
// used by admin tool. remove lock records.
// @param[in] op_info, the lock/unlock op will be removed by admin.
int admin_remove_lock_op(const ObTableLockOp &op_info);
// used by admin tool. update lock op status.
// @param[in] op_info, the lock/unlock op will be update by admin.
// @param[in] commit_version, set the commit version.
// @param[in] commit_scn, set the commit logts.
// @param[in] status, the lock op status will be set.
int admin_update_lock_op(const ObTableLockOp &op_info,
const share::SCN &commit_version,
const share::SCN &commit_scn,
const ObTableLockOpStatus status);
private:
// We use the method to recover the lock_table for reboot.
int restore_lock_table_(storage::ObITable &sstable);

67
src/storage/tablelock/ob_table_lock_rpc_processor.cpp
View File

@ -13,6 +13,7 @@
#define USING_LOG_PREFIX TABLELOCK
#include "storage/tablelock/ob_table_lock_rpc_processor.h"
#include "storage/tx_storage/ob_access_service.h"
#include "storage/tx_storage/ob_ls_service.h"
#include "storage/tablelock/ob_table_lock_service.h"
#include "storage/tablelock/ob_table_lock_rpc_struct.h"
#include "storage/tx/ob_clog_encrypt_info.h" // TODO: remove with old trans interface
@ -167,5 +168,71 @@ int ObOutTransUnlockTableP::process()
return ret;
}
int ObAdminRemoveLockP::process()
{
int ret = OB_SUCCESS;
LOG_INFO("ObAdminRemoveLockP::process", K(arg_));
uint64_t tenant_id = arg_.tenant_id_;
MAKE_TENANT_SWITCH_SCOPE_GUARD(guard);
ObLSService *ls_service = nullptr;
ObLSHandle ls_handle;
ObLS *ls = nullptr;
if (tenant_id != MTL_ID()) {
ret = guard.switch_to(tenant_id);
}
if (OB_SUCC(ret)) {
ls_service = MTL(ObLSService*);
if (OB_ISNULL(ls_service)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("mtl ObLSService should not be null", K(ret));
} else if (OB_FAIL(ls_service->get_ls(arg_.ls_id_,
ls_handle,
ObLSGetMod::TABLELOCK_MOD))) {
LOG_WARN("failed to get ls", K(ret), K(arg_));
} else if (OB_ISNULL(ls = ls_handle.get_ls())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ls should not be NULL", K(ret), K(arg_));
} else if (OB_FAIL(ls->admin_remove_lock_op(arg_.lock_op_))) {
LOG_WARN("admin remove lock op failed", KR(ret), K(arg_));
}
}
return ret;
}
int ObAdminUpdateLockP::process()
{
int ret = OB_SUCCESS;
LOG_INFO("ObAdminUpdateLockP::process", K(arg_));
uint64_t tenant_id = arg_.tenant_id_;
MAKE_TENANT_SWITCH_SCOPE_GUARD(guard);
ObLSService *ls_service = nullptr;
ObLSHandle ls_handle;
ObLS *ls = nullptr;
if (tenant_id != MTL_ID()) {
ret = guard.switch_to(tenant_id);
}
if (OB_SUCC(ret)) {
ls_service = MTL(ObLSService*);
if (OB_ISNULL(ls_service)) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("mtl ObLSService should not be null", K(ret));
} else if (OB_FAIL(ls_service->get_ls(arg_.ls_id_,
ls_handle,
ObLSGetMod::TABLELOCK_MOD))) {
LOG_WARN("failed to get ls", K(ret), K(arg_));
} else if (OB_ISNULL(ls = ls_handle.get_ls())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ls should not be NULL", K(ret), K(arg_));
} else if (OB_FAIL(ls->admin_update_lock_op(arg_.lock_op_,
arg_.commit_version_,
arg_.commit_scn_,
arg_.lock_op_.lock_op_status_))) {
LOG_WARN("admin update lock op failed", KR(ret), K(arg_));
}
}
return ret;
}
} // observer
} // oceanbase

22
src/storage/tablelock/ob_table_lock_rpc_processor.h
View File

@ -28,6 +28,28 @@ OB_DEFINE_PROCESSOR_S(Srv, OB_HIGH_PRIORITY_TABLE_LOCK_TASK, ObHighPriorityTable
OB_DEFINE_PROCESSOR_S(TableLock, OB_OUT_TRANS_LOCK_TABLE, ObOutTransLockTableP);
OB_DEFINE_PROCESSOR_S(TableLock, OB_OUT_TRANS_UNLOCK_TABLE, ObOutTransUnlockTableP);
class ObAdminRemoveLockP : public obrpc::ObRpcProcessor<obrpc::ObSrvRpcProxy::ObRpc<obrpc::OB_REMOVE_OBJ_LOCK>>
{
public:
explicit ObAdminRemoveLockP() {}
~ObAdminRemoveLockP() {}
protected:
int process();
private:
DISALLOW_COPY_AND_ASSIGN(ObAdminRemoveLockP);
};
class ObAdminUpdateLockP : public obrpc::ObRpcProcessor<obrpc::ObSrvRpcProxy::ObRpc<obrpc::OB_UPDATE_OBJ_LOCK>>
{
public:
explicit ObAdminUpdateLockP() {}
~ObAdminUpdateLockP() {}
protected:
int process();
private:
DISALLOW_COPY_AND_ASSIGN(ObAdminUpdateLockP);
};
}
}

85
src/storage/tablelock/ob_table_lock_rpc_struct.cpp
View File

@ -216,6 +216,91 @@ int ObInTransLockTabletRequest::assign(const ObInTransLockTabletRequest &arg)
return ret;
}
OB_SERIALIZE_MEMBER(ObAdminRemoveLockOpArg, tenant_id_, ls_id_, lock_op_);
int ObAdminRemoveLockOpArg::set(const uint64_t tenant_id,
const share::ObLSID &ls_id,
const ObTableLockOp &lock_op)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(OB_INVALID_TENANT_ID == tenant_id ||
!ls_id.is_valid() ||
!lock_op.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(tenant_id), K(ls_id), K(lock_op));
} else {
tenant_id_ = tenant_id;
ls_id_ = ls_id;
lock_op_ = lock_op;
}
return ret;
}
int ObAdminRemoveLockOpArg::assign(const ObAdminRemoveLockOpArg &arg)
{
int ret = OB_SUCCESS;
tenant_id_ = arg.tenant_id_;
ls_id_ = arg.ls_id_;
lock_op_ = arg.lock_op_;
return ret;
}
bool ObAdminRemoveLockOpArg::is_valid() const
{
return (OB_INVALID_TENANT_ID != tenant_id_ &&
ls_id_.is_valid() &&
lock_op_.is_valid());
}
OB_SERIALIZE_MEMBER(ObAdminUpdateLockOpArg, tenant_id_, ls_id_, lock_op_,
commit_version_, commit_scn_);
int ObAdminUpdateLockOpArg::set(const uint64_t tenant_id,
const share::ObLSID &ls_id,
const ObTableLockOp &lock_op,
const share::SCN &commit_version,
const share::SCN &commit_scn)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(OB_INVALID_TENANT_ID == tenant_id ||
!ls_id.is_valid() ||
!lock_op.is_valid() ||
!commit_version.is_valid() ||
!commit_scn.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(tenant_id), K(ls_id), K(lock_op),
K(commit_version), K(commit_scn));
} else {
tenant_id_ = tenant_id;
ls_id_ = ls_id;
lock_op_ = lock_op;
commit_version_ = commit_version;
commit_scn_ = commit_scn;
}
return ret;
}
int ObAdminUpdateLockOpArg::assign(const ObAdminUpdateLockOpArg &arg)
{
int ret = OB_SUCCESS;
tenant_id_ = arg.tenant_id_;
ls_id_ = arg.ls_id_;
lock_op_ = arg.lock_op_;
commit_version_ = arg.commit_version_;
commit_scn_ = arg.commit_scn_;
return ret;
}
bool ObAdminUpdateLockOpArg::is_valid() const
{
return (OB_INVALID_TENANT_ID != tenant_id_ &&
ls_id_.is_valid() &&
lock_op_.is_valid() &&
commit_version_.is_valid() &&
commit_scn_.is_valid());
}
}
}
}

56
src/storage/tablelock/ob_table_lock_rpc_struct.h
View File

@ -217,6 +217,62 @@ public:
common::ObTabletID tablet_id_;
};
struct ObAdminRemoveLockOpArg
{
OB_UNIS_VERSION(1);
public:
ObAdminRemoveLockOpArg() : tenant_id_(OB_INVALID_TENANT_ID), ls_id_(), lock_op_() {}
~ObAdminRemoveLockOpArg()
{
tenant_id_ = OB_INVALID_TENANT_ID;
ls_id_.reset();
}
int set(const uint64_t tenant_id,
const share::ObLSID &ls_id,
const ObTableLockOp &lock_op);
int assign(const ObAdminRemoveLockOpArg &arg);
bool is_valid() const;
TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(lock_op));
public:
uint64_t tenant_id_;
share::ObLSID ls_id_;
ObTableLockOp lock_op_;
};
struct ObAdminUpdateLockOpArg
{
OB_UNIS_VERSION(1);
public:
ObAdminUpdateLockOpArg()
: tenant_id_(OB_INVALID_TENANT_ID),
ls_id_(),
lock_op_(),
commit_version_(),
commit_scn_()
{}
~ObAdminUpdateLockOpArg()
{
tenant_id_ = OB_INVALID_TENANT_ID;
ls_id_.reset();
commit_version_.reset();
commit_scn_.reset();
}
int set(const uint64_t tenant_id,
const share::ObLSID &ls_id,
const ObTableLockOp &lock_op,
const share::SCN &commit_version,
const share::SCN &commit_scn);
int assign(const ObAdminUpdateLockOpArg &arg);
bool is_valid() const;
TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(lock_op), K_(commit_version), K_(commit_scn));
public:
uint64_t tenant_id_;
share::ObLSID ls_id_;
ObTableLockOp lock_op_;
share::SCN commit_version_;
share::SCN commit_scn_;
};
}
}
}