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

add some commonds for ob_admin

Browse Source
This commit is contained in:
sunzhoujia 2024-10-15 15:43:46 +00:00 committed by ob-robot
parent dc714a31d1
commit ec3019a2db
8 changed files with 319 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1211,7 +1211,10 @@ PCODE_DEF(OB_GET_SS_MICRO_CACHE_INFO, 0x1630)
PCODE_DEF(OB_CLEAR_SS_MICRO_CACHE, 0x1632)
PCODE_DEF(OB_COLLECT_MV_MERGE_INFO, 0x1633)
PCODE_DEF(OB_FETCH_STABLE_MEMBER_LIST, 0x1634)
PCODE_DEF(OB_DEL_SS_LOCAL_TMPFILE, 0x1635)
PCODE_DEF(OB_DEL_SS_LOCAL_MAJOR, 0x1636)
PCODE_DEF(OB_CALIBRATE_SS_DISK_SPACE, 0x1637)
PCODE_DEF(OB_DEL_SS_TABLET_MICRO, 0x1638)
//**** 注意：在此行之前增加新的RPC ID ******
//
//占位须知：

86
src/observer/ob_rpc_processor_simple.cpp
View File

@ -3849,6 +3849,92 @@ int ObDelSSTabletMetaP::process()
return ret;
}
int ObDelSSLocalTmpFileP::process()
{
int ret = OB_SUCCESS;
LOG_INFO("start delete ss_local_tmpfile process", K_(arg));
if (!arg_.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K_(arg));
} else {
MTL_SWITCH(arg_.tenant_id_) {
ObTenantFileManager *file_mgr = nullptr;
if (OB_ISNULL(file_mgr = MTL(ObTenantFileManager *))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("MTL ObTenantFileManager is null", KR(ret), K_(arg_.tenant_id));
} else if (OB_FAIL(file_mgr->delete_local_tmp_file(arg_.macro_id_, true/* is_only_delete_read_cache */))) {
LOG_WARN("fail to delete ss_local_tmpfile", KR(ret), K_(arg_.macro_id));
}
}
}
return ret;
}
int ObDelSSLocalMajorP::process()
{
int ret = OB_SUCCESS;
LOG_INFO("start delete ss_local_major process", K_(arg));
if (!arg_.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K_(arg));
} else {
MTL_SWITCH(arg_.tenant_id_) {
ObTenantFileManager *file_mgr = nullptr;
const int64_t cur_time_s = ObTimeUtility::current_time_s();
if (OB_ISNULL(file_mgr = MTL(ObTenantFileManager *))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("MTL ObTenantFileManager is null", KR(ret), K_(arg_.tenant_id));
} else if (OB_FAIL(file_mgr->delete_local_major_data_dir(cur_time_s))) {
LOG_WARN("fail to delete ss_local_major", KR(ret), K(cur_time_s));
}
}
}
return ret;
}
int ObCalibrateSSDiskSpaceP::process()
{
int ret = OB_SUCCESS;
LOG_INFO("start calibrate_ss_disk_space process", K_(arg));
if (!arg_.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K_(arg));
} else {
MTL_SWITCH(arg_.tenant_id_) {
ObTenantFileManager *file_mgr = nullptr;
if (OB_ISNULL(file_mgr = MTL(ObTenantFileManager *))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("MTL ObTenantFileManager is null", KR(ret), K_(arg_.tenant_id));
} else if (OB_FAIL(file_mgr->calibrate_disk_space())) {
LOG_WARN("fail to calibrate_ss_disk_space", KR(ret));
}
}
}
return ret;
}
int ObDelSSTabletMicroP::process()
{
int ret = OB_SUCCESS;
LOG_INFO("start del_ss_tablet_micro process", K_(arg));
if (!arg_.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K_(arg));
} else {
MTL_SWITCH(arg_.tenant_id_) {
ObSSMicroCache *micro_cache = nullptr;
if (OB_ISNULL(micro_cache = MTL(ObSSMicroCache *))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ObSSMicroCache is null", KR(ret), K_(arg_.tenant_id));
} else if (OB_FAIL(micro_cache->clear_micro_meta_by_tablet_id(arg_.tablet_id_))) {
LOG_WARN("fail to del_ss_tablet_micro", KR(ret));
}
}
}
return ret;
}
int ObEnableSSMicroCacheP::process()
{
int ret = OB_SUCCESS;

4
src/observer/ob_rpc_processor_simple.h
View File

@ -251,6 +251,10 @@ OB_DEFINE_PROCESSOR_S(Srv, OB_DEL_SS_TABLET_META, ObDelSSTabletMetaP);
OB_DEFINE_PROCESSOR_S(Srv, OB_ENABLE_SS_MICRO_CACHE, ObEnableSSMicroCacheP);
OB_DEFINE_PROCESSOR_S(Srv, OB_GET_SS_MICRO_CACHE_INFO, ObGetSSMicroCacheInfoP);
OB_DEFINE_PROCESSOR_S(Srv, OB_CLEAR_SS_MICRO_CACHE, ObRpcClearSSMicroCacheP);
OB_DEFINE_PROCESSOR_S(Srv, OB_DEL_SS_LOCAL_TMPFILE, ObDelSSLocalTmpFileP);
OB_DEFINE_PROCESSOR_S(Srv, OB_DEL_SS_LOCAL_MAJOR, ObDelSSLocalMajorP);
OB_DEFINE_PROCESSOR_S(Srv, OB_CALIBRATE_SS_DISK_SPACE, ObCalibrateSSDiskSpaceP);
OB_DEFINE_PROCESSOR_S(Srv, OB_DEL_SS_TABLET_MICRO, ObDelSSTabletMicroP);
#endif
OB_DEFINE_PROCESSOR_S(Srv, OB_REMOTE_WRITE_DDL_INC_COMMIT_LOG, ObRpcRemoteWriteDDLIncCommitLogP);
OB_DEFINE_PROCESSOR_S(Srv, OB_CHECK_LS_CAN_OFFLINE, ObRpcCheckLSCanOfflineP);

4
src/observer/ob_srv_xlator_storage.cpp
View File

@ -161,6 +161,10 @@ void oceanbase::observer::init_srv_xlator_for_storage(ObSrvRpcXlator *xlator) {
RPC_PROCESSOR(ObEnableSSMicroCacheP, gctx_);
RPC_PROCESSOR(ObGetSSMicroCacheInfoP, gctx_);
RPC_PROCESSOR(ObRpcClearSSMicroCacheP, gctx_);
RPC_PROCESSOR(ObDelSSLocalTmpFileP, gctx_);
RPC_PROCESSOR(ObDelSSLocalMajorP, gctx_);
RPC_PROCESSOR(ObCalibrateSSDiskSpaceP, gctx_);
RPC_PROCESSOR(ObDelSSTabletMicroP, gctx_);
#endif
RPC_PROCESSOR(ObNotifySharedStorageInfoP, gctx_);
}

4
src/share/ob_rpc_struct.cpp
View File

@ -11370,6 +11370,10 @@ OB_SERIALIZE_MEMBER(ObEnableSSMicroCacheArg, tenant_id_, is_enabled_);
OB_SERIALIZE_MEMBER(ObGetSSMicroCacheInfoArg, tenant_id_);
OB_SERIALIZE_MEMBER(ObGetSSMicroCacheInfoResult, micro_cache_stat_, super_block_, arc_info_);
OB_SERIALIZE_MEMBER(ObClearSSMicroCacheArg, tenant_id_);
OB_SERIALIZE_MEMBER(ObDelSSLocalTmpFileArg, tenant_id_, macro_id_);
OB_SERIALIZE_MEMBER(ObDelSSLocalMajorArg, tenant_id_);
OB_SERIALIZE_MEMBER(ObCalibrateSSDiskSpaceArg, tenant_id_);
OB_SERIALIZE_MEMBER(ObDelSSTabletMicroArg, tenant_id_, tablet_id_);
#endif
ObRpcRemoteWriteDDLIncCommitLogArg::ObRpcRemoteWriteDDLIncCommitLogArg()

66
src/share/ob_rpc_struct.h
View File

@ -11450,7 +11450,8 @@ public:
ObSSARCInfo arc_info_;
};
struct ObClearSSMicroCacheArg {
struct ObClearSSMicroCacheArg final
{
OB_UNIS_VERSION(1);
public:
@ -11465,8 +11466,69 @@ public:
public:
uint64_t tenant_id_;
};
#endif
struct ObDelSSLocalTmpFileArg final
{
OB_UNIS_VERSION(1);
public:
ObDelSSLocalTmpFileArg() : tenant_id_(OB_INVALID_TENANT_ID), macro_id_() {}
~ObDelSSLocalTmpFileArg() {}
bool is_valid() const
{
return OB_INVALID_TENANT_ID != tenant_id_ && macro_id_.is_valid();
}
TO_STRING_KV(K_(tenant_id), K_(macro_id));
public:
int64_t tenant_id_;
blocksstable::MacroBlockId macro_id_;
};
struct ObDelSSLocalMajorArg final
{
OB_UNIS_VERSION(1);
public:
ObDelSSLocalMajorArg() : tenant_id_(OB_INVALID_TENANT_ID) {}
~ObDelSSLocalMajorArg() {}
bool is_valid() const
{
return OB_INVALID_TENANT_ID != tenant_id_;
}
TO_STRING_KV(K_(tenant_id));
public:
int64_t tenant_id_;
};
struct ObDelSSTabletMicroArg final
{
OB_UNIS_VERSION(1);
public:
ObDelSSTabletMicroArg() : tenant_id_(OB_INVALID_TENANT_ID), tablet_id_() {}
~ObDelSSTabletMicroArg() {}
bool is_valid() const
{
return OB_INVALID_TENANT_ID != tenant_id_ && tablet_id_.is_valid();
}
TO_STRING_KV(K_(tenant_id), K_(tablet_id));
public:
int64_t tenant_id_;
ObTabletID tablet_id_;
};
struct ObCalibrateSSDiskSpaceArg final
{
OB_UNIS_VERSION(1);
public:
ObCalibrateSSDiskSpaceArg() : tenant_id_(OB_INVALID_TENANT_ID){}
~ObCalibrateSSDiskSpaceArg() {}
bool is_valid() const
{
return OB_INVALID_TENANT_ID != tenant_id_;
}
TO_STRING_KV(K_(tenant_id));
public:
int64_t tenant_id_;
};
#endif
struct ObRpcRemoteWriteDDLIncCommitLogArg final
{
OB_UNIS_VERSION(1);

4
src/share/ob_srv_rpc_proxy.h
View File

@ -235,6 +235,10 @@ public:
RPC_S(PR5 enable_ss_micro_cache, OB_ENABLE_SS_MICRO_CACHE, (obrpc::ObEnableSSMicroCacheArg));
RPC_S(PR5 get_ss_micro_cache_info, OB_GET_SS_MICRO_CACHE_INFO, (obrpc::ObGetSSMicroCacheInfoArg), obrpc::ObGetSSMicroCacheInfoResult);
RPC_S(PR5 clear_ss_micro_cache, OB_CLEAR_SS_MICRO_CACHE, (obrpc::ObClearSSMicroCacheArg));
RPC_S(PR5 del_ss_local_tmpfile, OB_DEL_SS_LOCAL_TMPFILE, (obrpc::ObDelSSLocalTmpFileArg));
RPC_S(PR5 del_ss_local_major, OB_DEL_SS_LOCAL_MAJOR, (obrpc::ObDelSSLocalMajorArg));
RPC_S(PR5 calibrate_ss_disk_space, OB_CALIBRATE_SS_DISK_SPACE, (obrpc::ObCalibrateSSDiskSpaceArg));
RPC_S(PR5 del_ss_tablet_micro, OB_DEL_SS_TABLET_MICRO, (obrpc::ObDelSSTabletMicroArg));
#endif
RPC_S(PR5 remote_write_ddl_inc_commit_log, OB_REMOTE_WRITE_DDL_INC_COMMIT_LOG, (obrpc::ObRpcRemoteWriteDDLIncCommitLogArg), ObRpcRemoteWriteDDLIncCommitLogRes);
RPC_S(PR5 check_ls_can_offline, OB_CHECK_LS_CAN_OFFLINE, (obrpc::ObCheckLSCanOfflineArg));

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

@ -1271,6 +1271,155 @@ DEF_COMMAND(SERVER, del_ss_tablet_meta, 1, "tenant_id:tablet_id:compaction_scn")
return ret;
}
DEF_COMMAND(SERVER, del_ss_local_tmpfile, 1, "tenant_id:tmpfile_id")
{
int ret = OB_SUCCESS;
string arg_str;
ObDelSSLocalTmpFileArg arg;
if (cmd_ == action_name_) {
ret = OB_INVALID_ARGUMENT;
ADMIN_WARN("should provide tenant_id, tmpfile_id");
} else {
arg_str = cmd_.substr(action_name_.length() + 1);
}
int64_t tmpfile_id = 0;
if (OB_FAIL(ret)) {
} else if (2 != sscanf(arg_str.c_str(), "%ld:%ld", &arg.tenant_id_, &tmpfile_id)) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid arg", K(ret), K(arg_str.c_str()));
} else {
MacroBlockId macro_id;
macro_id.set_ss_version(MacroBlockId::MACRO_BLOCK_ID_VERSION_V2);
macro_id.set_ss_id_mode(static_cast<uint64_t>(ObMacroBlockIdMode::ID_MODE_SHARE));
macro_id.set_storage_object_type(static_cast<uint64_t>(ObStorageObjectType::TMP_FILE));
macro_id.set_second_id(tmpfile_id);
arg.macro_id_ = macro_id;
const int64_t rpc_timeout = 60000000;
if (!arg.is_valid()) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "argument is invalid", K(ret), K(arg));
} else if (OB_FALSE_IT(client_->set_timeout(rpc_timeout))) {
} else if (OB_FAIL(client_->del_ss_local_tmpfile(arg))) {
COMMON_LOG(ERROR, "send req fail", K(ret));
} else {
fprintf(
stdout, "Successfully del_ss_local_tmpfile [tenant_id:%ld, tmpfile_id:%ld]", arg.tenant_id_, tmpfile_id);
}
}
if (OB_FAIL(ret)) {
fprintf(stderr, "fail to del_ss_local_tmpfile, ret=%s\n", ob_error_name(ret));
}
COMMON_LOG(INFO, "del_ss_local_tmpfile", K(arg));
return ret;
}
DEF_COMMAND(SERVER, del_ss_local_major, 1, "tenant_id")
{
int ret = OB_SUCCESS;
string arg_str;
ObDelSSLocalMajorArg arg;
if (cmd_ == action_name_) {
ret = OB_INVALID_ARGUMENT;
ADMIN_WARN("should provide tenant_id");
} else {
arg_str = cmd_.substr(action_name_.length() + 1);
}
const int64_t rpc_timeout = 60000000;
if (OB_FAIL(ret)) {
} else if (1 != sscanf(arg_str.c_str(), "%ld", &arg.tenant_id_)) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid arg", K(ret), K(arg_str.c_str()));
} else if (!arg.is_valid()) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "argument is invalid", K(ret), K(arg));
} else if (OB_FALSE_IT(client_->set_timeout(rpc_timeout))) {
} else if (OB_FAIL(client_->del_ss_local_major(arg))) {
COMMON_LOG(ERROR, "send req fail", K(ret));
} else {
fprintf(stdout, "Successfully del_ss_local_major [tenant_id:%ld]", arg.tenant_id_);
}
if (OB_FAIL(ret)) {
fprintf(stderr, "fail to del_ss_local_major, ret=%s\n", ob_error_name(ret));
}
COMMON_LOG(INFO, "del_ss_local_major", K(arg));
return ret;
}
DEF_COMMAND(SERVER, calibrate_ss_disk_space, 1, "tenant_id")
{
int ret = OB_SUCCESS;
string arg_str;
ObCalibrateSSDiskSpaceArg arg;
if (cmd_ == action_name_) {
ret = OB_INVALID_ARGUMENT;
ADMIN_WARN("should provide tenant_id");
} else {
arg_str = cmd_.substr(action_name_.length() + 1);
}
const int64_t rpc_timeout = 60000000;
if (OB_FAIL(ret)) {
} else if (1 != sscanf(arg_str.c_str(), "%ld", &arg.tenant_id_)) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid arg", K(ret), K(arg_str.c_str()));
} else if (!arg.is_valid()) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "argument is invalid", K(ret), K(arg));
} else if (OB_FALSE_IT(client_->set_timeout(rpc_timeout))) {
} else if (OB_FAIL(client_->calibrate_ss_disk_space(arg))) {
COMMON_LOG(ERROR, "send req fail", K(ret));
} else {
fprintf(stdout, "Successfully calibrate_ss_disk_space [tenant_id:%ld]", arg.tenant_id_);
}
if (OB_FAIL(ret)) {
fprintf(stderr, "fail to calibrate_ss_disk_space, ret=%s\n", ob_error_name(ret));
}
COMMON_LOG(INFO, "calibrate_ss_disk_space", K(arg));
return ret;
}
DEF_COMMAND(SERVER, del_ss_tablet_micro, 1, "tenant_id:tablet_id")
{
int ret = OB_SUCCESS;
string arg_str;
ObDelSSTabletMicroArg arg;
if (cmd_ == action_name_) {
ret = OB_INVALID_ARGUMENT;
ADMIN_WARN("should provide tenant_id, tablet_id");
} else {
arg_str = cmd_.substr(action_name_.length() + 1);
}
int64_t tablet_id = 0;
const int64_t rpc_timeout = 1800000000; // 3min
if (OB_FAIL(ret)) {
} else if (2 != sscanf(arg_str.c_str(), "%ld:%ld", &arg.tenant_id_, &tablet_id)) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid arg", K(ret), K(arg_str.c_str()));
} else {
arg.tablet_id_ = ObTabletID(tablet_id);
if (!arg.is_valid()) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "argument is invalid", K(ret), K(arg));
} else if (OB_FALSE_IT(client_->set_timeout(rpc_timeout))) {
} else if (OB_FAIL(client_->del_ss_tablet_micro(arg))) {
COMMON_LOG(ERROR, "send req fail", K(ret));
} else {
fprintf(stdout, "Successfully del_ss_tablet_micro [tenant_id:%ld, tablet_id:%ld]", arg.tenant_id_, arg.tablet_id_.id());
}
}
if (OB_FAIL(ret)) {
fprintf(stderr, "fail to del_ss_tablet_micro, ret=%s\n", ob_error_name(ret));
}
COMMON_LOG(INFO, "del_ss_tablet_micro", K(arg));
return ret;
}
DEF_COMMAND(SERVER, download_ss_macro_block, 1, "tenant_id:ver:mode:obj_type:incar_id:cg_id:second_id:third_id:fourth_id #download ss_macro_block")
{
int ret = OB_SUCCESS;