hcq/oceanbase
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h vendored
View File

@ -733,6 +733,8 @@ PCODE_DEF(OB_IN_TRANS_LOCK_TABLET, 0x92A)
PCODE_DEF(OB_HIGH_PRIORITY_TABLE_LOCK_TASK, 0x92B)
//PCODE_DEF(OB_CREATE_ARB, 0x92C)
//PCODE_DEF(OB_DELETE_ARB, 0x92D)
PCODE_DEF(OB_REMOVE_OBJ_LOCK, 0x92E)
PCODE_DEF(OB_UPDATE_OBJ_LOCK, 0x930)
// ddl
PCODE_DEF(OB_REMOTE_WRITE_DDL_REDO_LOG, 0x950)

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_;
};
}
}
}

170
tools/ob_admin/server_tool/ob_admin_routine.cpp
View File

@ -19,6 +19,7 @@
#include <unistd.h>
#include "ob_admin_utils.h"
#include "share/ob_rpc_struct.h"
#include "storage/tablelock/ob_table_lock_rpc_struct.h"
using namespace std;
@ -43,6 +44,8 @@ using namespace std;
using namespace oceanbase::tools;
using namespace oceanbase::common;
using namespace oceanbase::transaction;
using namespace oceanbase::transaction::tablelock;
namespace oceanbase {
namespace tools {
@ -587,3 +590,170 @@ DEF_COMMAND(TRANS, ls_remove_member, 1, "tenant_id ls_id svr_ip svr_port orig_pa
COMMON_LOG(INFO, "ls_remove_member", K(arg));
return ret;
}
// remove_lock
// @params [in] tenant_id, which tenant to modify
// @params [in] ls_id, which log stream to modify
// @params [in] obj_type, lock object type (1:OBJ_TYPE_TABLE, 2:OBJ_TYPE_TABLET)
// @params [in] obj_id, lock object id
// @params [in] lock_mode, lock mode (1:EXCLUSIVE, 2:SHARE, 4:ROW_EXCLUSIVE, 6:SHARE_ROW_EXCLUSIVE, 8:ROW_SHARE)
// @params [in] owner_id, for OUT_TRANS lock and unlock
// @params [in] create_tx_id, which transaction create this lock
// @params [in] op_type, (1:IN_TRANS_DML_LOCK; 2:OUT_TRANS_LOCK; 3:OUT_TRANS_UNLOCK; 4:IN_TRANS_LOCK_TABLE_LOCK)
DEF_COMMAND(TRANS, remove_lock, 1, "tenant_id ls_id obj_type obj_id lock_mode owner_id create_tx_id op_type # remove_lock")
{
int ret = OB_SUCCESS;
string arg_str;
ObAdminRemoveLockOpArg arg;
int64_t tenant_id_to_set = OB_INVALID_TENANT_ID;
int64_t ls_id_to_set = 0;
int64_t obj_type = 0; // how to change int64_t to be enum class
int64_t obj_id = 0;
int64_t lock_mode = 0;
int64_t owner_id = 0;
int64_t create_tx_id = 0;
int64_t op_type = 0;
int64_t lock_op_status = 1; // does not used.
int64_t seq_no = 0;
int64_t create_timestamp = 0;
int64_t create_schema_version = 0;
if (cmd_ == action_name_) {
ret = OB_INVALID_ARGUMENT;
ADMIN_WARN("should provide tenant_id, ls_id, obj_type, obj_id, lock_mode, owner_id, create_tx_id, op_type");
} else {
arg_str = cmd_.substr(action_name_.length() + 1);
}
if (OB_FAIL(ret)) {
} else if (12 != sscanf(arg_str.c_str(),
"%ld %ld %ld %ld %ld %ld %ld %ld",
&tenant_id_to_set, &ls_id_to_set, &obj_type,
&obj_id, &lock_mode, &owner_id, &create_tx_id, &op_type)) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid arg", K(ret), K(arg_str.c_str()), K(cmd_.c_str()),
K(tenant_id_to_set), K(ls_id_to_set),
K(obj_type), K(obj_id), K(lock_mode), K(owner_id), K(create_tx_id),
K(op_type), K(lock_op_status), K(seq_no), K(create_timestamp),
K(create_schema_version));
} else {
share::ObLSID ls_id(ls_id_to_set);
ObLockID lock_id;
ObLockOBJType real_obj_type = static_cast<ObLockOBJType>(obj_type);
ObTableLockMode real_lock_mode = static_cast<ObTableLockMode>(lock_mode);
ObTableLockOwnerID real_owner_id = owner_id;
ObTransID real_create_tx_id = create_tx_id;
ObTableLockOpType real_op_type = static_cast<ObTableLockOpType>(op_type);
ObTableLockOpStatus real_lock_op_status = static_cast<ObTableLockOpStatus>(lock_op_status);
ObTableLockOp lock_op;
lock_id.set(real_obj_type, obj_id);
lock_op.set(lock_id, real_lock_mode, real_owner_id, real_create_tx_id, real_op_type,
real_lock_op_status, seq_no, create_timestamp, create_schema_version);
if (OB_ISNULL(client_)
|| OB_UNLIKELY(OB_INVALID_TENANT_ID == tenant_id_to_set
|| !ls_id.is_valid_with_tenant(tenant_id_to_set)
|| !lock_op.is_valid())) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid argument", K(ret), K(tenant_id_to_set), K(ls_id),
K(lock_op), KP(client_));
} else if (OB_FAIL(arg.set(tenant_id_to_set, ls_id, lock_op))) {
COMMON_LOG(WARN, "set remove lock op arg failed", K(ret), K(tenant_id_to_set),
K(ls_id), K(lock_op));
} else if (OB_FAIL(client_->admin_remove_lock_op(arg))) {
COMMON_LOG(ERROR, "send req fail", K(ret));
}
}
COMMON_LOG(INFO, "remove_lock", K(arg));
return ret;
}
// update_lock
// @params [in] tenant_id, which tenant to modify
// @params [in] ls_id, which log stream to modify
// @params [in] obj_type, lock object type (1:OBJ_TYPE_TABLE, 2:OBJ_TYPE_TABLET)
// @params [in] obj_id, lock object id
// @params [in] lock_mode, lock mode (1:EXCLUSIVE, 2:SHARE, 4:ROW_EXCLUSIVE, 6:SHARE_ROW_EXCLUSIVE, 8:ROW_SHARE)
// @params [in] owner_id, for OUT_TRANS lock and unlock
// @params [in] create_tx_id, which transaction create this lock
// @params [in] op_type, (1:IN_TRANS_DML_LOCK; 2:OUT_TRANS_LOCK; 3:OUT_TRANS_UNLOCK; 4:IN_TRANS_LOCK_TABLE_LOCK)
// @params [in] op_status, (1:LOCK_OP_DOING; 2:LOCK_OP_COMPLETE;)
// @params [in] commit_version, the lock op transaction commit version
// @params [in] commit_scn, the lock op transaction commit scn
DEF_COMMAND(TRANS, update_lock, 1, "tenant_id ls_id obj_type obj_id lock_mode owner_id create_tx_id op_type new_op_status commit_version commit_scn# update_lock")
{
int ret = OB_SUCCESS;
string arg_str;
ObAdminUpdateLockOpArg arg;
int64_t tenant_id_to_set = OB_INVALID_TENANT_ID;
int64_t ls_id_to_set = 0;
int64_t obj_type = 0; // how to change int64_t to be enum class
int64_t obj_id = 0;
int64_t lock_mode = 0;
int64_t owner_id = 0;
int64_t create_tx_id = 0;
int64_t op_type = 0;
int64_t lock_op_status = 1;
int64_t commit_version = 0;
int64_t commit_scn = 0;
int64_t seq_no = 0;
int64_t create_timestamp = 0;
int64_t create_schema_version = 0;
if (cmd_ == action_name_) {
ret = OB_INVALID_ARGUMENT;
ADMIN_WARN("should provide tenant_id, ls_id, obj_type, obj_id, lock_mode, owner_id, create_tx_id, op_type, new_op_status, commit_version, commit_scn");
} else {
arg_str = cmd_.substr(action_name_.length() + 1);
}
if (OB_FAIL(ret)) {
} else if (11 != sscanf(arg_str.c_str(),
"%ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld",
&tenant_id_to_set, &ls_id_to_set, &obj_type,
&obj_id, &lock_mode, &owner_id, &create_tx_id, &op_type,
&lock_op_status, &commit_version, &commit_scn)) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid arg", K(ret), K(arg_str.c_str()), K(cmd_.c_str()),
K(tenant_id_to_set), K(ls_id_to_set),
K(obj_type), K(obj_id), K(lock_mode), K(owner_id), K(create_tx_id),
K(op_type), K(lock_op_status), K(commit_version), K(commit_scn));
} else {
share::ObLSID ls_id(ls_id_to_set);
ObLockID lock_id;
ObLockOBJType real_obj_type = static_cast<ObLockOBJType>(obj_type);
ObTableLockMode real_lock_mode = static_cast<ObTableLockMode>(lock_mode);
ObTableLockOwnerID real_owner_id = owner_id;
ObTransID real_create_tx_id = create_tx_id;
ObTableLockOpType real_op_type = static_cast<ObTableLockOpType>(op_type);
ObTableLockOpStatus real_lock_op_status = static_cast<ObTableLockOpStatus>(lock_op_status);
ObTableLockOp lock_op;
share::SCN real_commit_version;
share::SCN real_commit_scn;
lock_id.set(real_obj_type, obj_id);
lock_op.set(lock_id, real_lock_mode, real_owner_id, real_create_tx_id, real_op_type,
real_lock_op_status, seq_no, create_timestamp, create_schema_version);
real_commit_version.convert_for_tx(commit_version);
real_commit_scn.convert_for_logservice(commit_scn);
if (OB_ISNULL(client_)
|| OB_UNLIKELY(OB_INVALID_TENANT_ID == tenant_id_to_set
|| !ls_id.is_valid_with_tenant(tenant_id_to_set)
|| !lock_op.is_valid())) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid argument", K(ret), K(tenant_id_to_set), K(ls_id),
K(lock_op), KP(client_));
} else if (OB_FAIL(arg.set(tenant_id_to_set,
ls_id,
lock_op,
real_commit_version,
real_commit_scn))) {
COMMON_LOG(WARN, "set update lock op arg failed", K(ret), K(tenant_id_to_set),
K(ls_id), K(lock_op), K(real_commit_version), K(real_commit_scn));
} else if (OB_FAIL(client_->admin_update_lock_op(arg))) {
COMMON_LOG(ERROR, "send req fail", K(ret));
}
}
COMMON_LOG(INFO, "update_lock", K(arg));
return ret;
}