From 79bb01f4d10bff7074cb8557e0814c9320f41399 Mon Sep 17 00:00:00 2001 From: obdev Date: Wed, 28 Dec 2022 04:45:30 +0000 Subject: [PATCH] tools: ob_admin add remove_lock/update_lock cmd --- deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h | 2 + src/observer/ob_srv_xlator_partition.cpp | 4 +- src/share/ob_srv_rpc_proxy.h | 2 + src/storage/ls/ob_ls.h | 14 ++ src/storage/tablelock/ob_lock_table.cpp | 43 +++++ src/storage/tablelock/ob_lock_table.h | 12 ++ .../tablelock/ob_table_lock_rpc_processor.cpp | 67 +++++++ .../tablelock/ob_table_lock_rpc_processor.h | 22 +++ .../tablelock/ob_table_lock_rpc_struct.cpp | 85 +++++++++ .../tablelock/ob_table_lock_rpc_struct.h | 56 ++++++ .../ob_admin/server_tool/ob_admin_routine.cpp | 170 ++++++++++++++++++ 11 files changed, 476 insertions(+), 1 deletion(-) diff --git a/deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h b/deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h index 10fb3035b..29945e6c1 100644 --- a/deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h +++ b/deps/oblib/src/rpc/obrpc/ob_rpc_packet_list.h @@ -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) diff --git a/src/observer/ob_srv_xlator_partition.cpp b/src/observer/ob_srv_xlator_partition.cpp index b4e499073..97020b300 100644 --- a/src/observer/ob_srv_xlator_partition.cpp +++ b/src/observer/ob_srv_xlator_partition.cpp @@ -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_); diff --git a/src/share/ob_srv_rpc_proxy.h b/src/share/ob_srv_rpc_proxy.h index 72caa6fef..3545e02f5 100644 --- a/src/share/ob_srv_rpc_proxy.h +++ b/src/share/ob_srv_rpc_proxy.h @@ -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); diff --git a/src/storage/ls/ob_ls.h b/src/storage/ls/ob_ls.h index f7c46f7de..2b3b189cc 100644 --- a/src/storage/ls/ob_ls.h +++ b/src/storage/ls/ob_ls.h @@ -432,6 +432,20 @@ public: // int unlock(ObStoreCtx &ctx, // const transaction::tablelock::ObLockParam ¶m); 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) diff --git a/src/storage/tablelock/ob_lock_table.cpp b/src/storage/tablelock/ob_lock_table.cpp index 9c2ca2b9a..c5f2f899c 100644 --- a/src/storage/tablelock/ob_lock_table.cpp +++ b/src/storage/tablelock/ob_lock_table.cpp @@ -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 diff --git a/src/storage/tablelock/ob_lock_table.h b/src/storage/tablelock/ob_lock_table.h index f9fae0d41..8b5ce8aa6 100644 --- a/src/storage/tablelock/ob_lock_table.h +++ b/src/storage/tablelock/ob_lock_table.h @@ -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); diff --git a/src/storage/tablelock/ob_table_lock_rpc_processor.cpp b/src/storage/tablelock/ob_table_lock_rpc_processor.cpp index 1367d4f5f..9ac5f1f4c 100644 --- a/src/storage/tablelock/ob_table_lock_rpc_processor.cpp +++ b/src/storage/tablelock/ob_table_lock_rpc_processor.cpp @@ -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 diff --git a/src/storage/tablelock/ob_table_lock_rpc_processor.h b/src/storage/tablelock/ob_table_lock_rpc_processor.h index 2bb9870b5..f990f2bfe 100644 --- a/src/storage/tablelock/ob_table_lock_rpc_processor.h +++ b/src/storage/tablelock/ob_table_lock_rpc_processor.h @@ -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> +{ +public: + explicit ObAdminRemoveLockP() {} + ~ObAdminRemoveLockP() {} +protected: + int process(); +private: + DISALLOW_COPY_AND_ASSIGN(ObAdminRemoveLockP); +}; + +class ObAdminUpdateLockP : public obrpc::ObRpcProcessor> +{ +public: + explicit ObAdminUpdateLockP() {} + ~ObAdminUpdateLockP() {} +protected: + int process(); +private: + DISALLOW_COPY_AND_ASSIGN(ObAdminUpdateLockP); +}; + } } diff --git a/src/storage/tablelock/ob_table_lock_rpc_struct.cpp b/src/storage/tablelock/ob_table_lock_rpc_struct.cpp index f50042518..774f65176 100644 --- a/src/storage/tablelock/ob_table_lock_rpc_struct.cpp +++ b/src/storage/tablelock/ob_table_lock_rpc_struct.cpp @@ -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()); +} + + } } } diff --git a/src/storage/tablelock/ob_table_lock_rpc_struct.h b/src/storage/tablelock/ob_table_lock_rpc_struct.h index 2a336d665..a58cdb22f 100644 --- a/src/storage/tablelock/ob_table_lock_rpc_struct.h +++ b/src/storage/tablelock/ob_table_lock_rpc_struct.h @@ -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_; +}; + } } } diff --git a/tools/ob_admin/server_tool/ob_admin_routine.cpp b/tools/ob_admin/server_tool/ob_admin_routine.cpp index 80ee2f85b..c9bfaf050 100644 --- a/tools/ob_admin/server_tool/ob_admin_routine.cpp +++ b/tools/ob_admin/server_tool/ob_admin_routine.cpp @@ -19,6 +19,7 @@ #include #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(obj_type); + ObTableLockMode real_lock_mode = static_cast(lock_mode); + ObTableLockOwnerID real_owner_id = owner_id; + ObTransID real_create_tx_id = create_tx_id; + ObTableLockOpType real_op_type = static_cast(op_type); + ObTableLockOpStatus real_lock_op_status = static_cast(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(obj_type); + ObTableLockMode real_lock_mode = static_cast(lock_mode); + ObTableLockOwnerID real_owner_id = owner_id; + ObTransID real_create_tx_id = create_tx_id; + ObTableLockOpType real_op_type = static_cast(op_type); + ObTableLockOpStatus real_lock_op_status = static_cast(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; +}