[CP] [42x] support use ob_admin to do replica dr-tasks

src/share/ob_rpc_struct.cpp

@@ -4033,6 +4033,84 @@ int ObDRTaskExistArg::init(
   return ret;
 }
 
+static const char* ob_admin_drtask_type_strs[] = {
+  "ADD REPLICA",
+  "REMOVE REPLICA"
+};
+
+static const char* ob_admin_drtask_comment_strs[] = {
+  "add ls replica trigger by ob_admin",
+  "remove ls replica trigger by ob_admin"
+};
+
+OB_SERIALIZE_MEMBER(ObAdminDRTaskType, type_);
+const char* ObAdminDRTaskType::get_type_str() const
+{
+  STATIC_ASSERT(ARRAYSIZEOF(ob_admin_drtask_type_strs) == (int64_t)MAX_TYPE,
+                "ob_admin_drtask_type_strs string array size mismatch enum AdminDRTaskType count");
+  const char *str = NULL;
+  if (type_ > INVALID_TYPE && type_ < MAX_TYPE) {
+    str = ob_admin_drtask_type_strs[static_cast<int64_t>(type_)];
+  } else {
+    LOG_WARN_RET(OB_ERR_UNEXPECTED, "invalid AdminDRTaskType", K_(type));
+  }
+  return str;
+}
+
+const char* ObAdminDRTaskType::get_comment() const
+{
+  STATIC_ASSERT(ARRAYSIZEOF(ob_admin_drtask_comment_strs) == (int64_t)MAX_TYPE,
+                "ob_admin_drtask_comment_strs string array size mismatch enum AdminDRTaskType count");
+  const char *str = NULL;
+  if (type_ > INVALID_TYPE && type_ < MAX_TYPE) {
+    str = ob_admin_drtask_comment_strs[static_cast<int64_t>(type_)];
+  } else {
+    LOG_WARN_RET(OB_ERR_UNEXPECTED, "invalid AdminDRTaskType", K_(type));
+  }
+  return str;
+}
+
+int64_t ObAdminDRTaskType::to_string(char *buf, const int64_t buf_len) const
+{
+  int64_t pos = 0;
+  J_OBJ_START();
+  J_KV(K_(type), "type", get_type_str());
+  J_OBJ_END();
+  return pos;
+}
+
+OB_SERIALIZE_MEMBER(ObAdminCommandArg, admin_command_, task_type_);
+int ObAdminCommandArg::assign(const ObAdminCommandArg &other)
+{
+  int ret = OB_SUCCESS;
+  if (this == &other) {
+    //pass
+  } else if (OB_FAIL(admin_command_.assign(other.get_admin_command_str()))) {
+    LOG_WARN("fail to assign obadmin command string", KR(ret), K(other));
+  } else {
+    task_type_ = other.get_task_type();
+  }
+  return ret;
+}
+
+int ObAdminCommandArg::init(const ObString &admin_command, const ObAdminDRTaskType &task_type)
+{
+  int ret = OB_SUCCESS;
+  if (OB_UNLIKELY(admin_command.length() > OB_MAX_ADMIN_COMMAND_LENGTH)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid argument", KR(ret), K(admin_command));
+    LOG_USER_ERROR(OB_INVALID_ARGUMENT, "admin command, length oversize");
+  } else if (OB_UNLIKELY(admin_command.empty()) || OB_UNLIKELY(!task_type.is_valid())) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("invalid argument", KR(ret), K(admin_command), K(task_type));
+  } else if (OB_FAIL(admin_command_.assign(admin_command))) {
+    LOG_WARN("fali to assign admin command", KR(ret), K(admin_command));
+  } else {
+    task_type_ = task_type;
+  }
+  return ret;
+}
+
 #ifdef OB_BUILD_ARBITRATION
 OB_SERIALIZE_MEMBER(ObAddArbArg,
                     tenant_id_,

src/share/ob_rpc_struct.h

@@ -4459,6 +4459,63 @@ public:
   share::ObLSID ls_id_;
 };
 
+class ObAdminDRTaskType
+{
+  OB_UNIS_VERSION(1);
+public:
+  enum AdminDRTaskType
+  {
+    INVALID_TYPE = -1,
+    ADD_REPLICA = 0,
+    REMOVE_REPLICA = 1,
+    MAX_TYPE
+  };
+public:
+  ObAdminDRTaskType() : type_(INVALID_TYPE) {}
+  explicit ObAdminDRTaskType(AdminDRTaskType type) : type_(type) {}
+  ObAdminDRTaskType &operator=(const AdminDRTaskType type) { type_ = type; return *this; }
+  ObAdminDRTaskType &operator=(const ObAdminDRTaskType &other) { type_ = other.type_; return *this; }
+  bool operator==(const ObAdminDRTaskType &other) const { return other.type_ == type_; }
+  bool operator!=(const ObAdminDRTaskType &other) const { return other.type_ != type_; }
+  void reset() { type_ = INVALID_TYPE; }
+  int64_t to_string(char *buf, const int64_t buf_len) const;
+  void assign(const ObAdminDRTaskType &other) { type_ = other.type_; }
+  bool is_valid() const { return INVALID_TYPE < type_ && MAX_TYPE > type_; }
+  bool is_add_task() const { return ADD_REPLICA == type_; }
+  bool is_remove_task() const { return REMOVE_REPLICA == type_; }
+  const AdminDRTaskType &get_type() const { return type_; }
+  const char* get_type_str() const;
+  const char* get_comment() const;
+private:
+  AdminDRTaskType type_;
+};
+
+struct ObAdminCommandArg
+{
+public:
+  OB_UNIS_VERSION(1);
+public:
+  ObAdminCommandArg()
+    : admin_command_(),
+      task_type_(ObAdminDRTaskType::INVALID_TYPE) {}
+  ~ObAdminCommandArg() {}
+public:
+  int assign(const ObAdminCommandArg &other);
+  int init(const ObString &admin_command, const ObAdminDRTaskType &task_type);
+  bool is_valid() const { return !admin_command_.is_empty() && task_type_.is_valid(); }
+  void reset() { admin_command_.reset(); task_type_.reset(); }
+  const ObString get_admin_command_str() const { return admin_command_.str(); }
+  const ObAdminDRTaskType &get_task_type() const { return task_type_; }
+  const char* get_type_str() const { return task_type_.get_type_str(); }
+  const char* get_comment() const { return task_type_.get_comment(); }
+  bool is_remove_task() const { return task_type_.is_remove_task(); }
+  bool is_add_task() const { return task_type_.is_add_task(); }
+  TO_STRING_KV(K(admin_command_), K(task_type_));
+private:
+  common::ObFixedLengthString<OB_MAX_ADMIN_COMMAND_LENGTH + 1> admin_command_;
+  ObAdminDRTaskType task_type_;
+};
+
 #ifdef OB_BUILD_ARBITRATION
 // send to leader to add A-replica for log stream
 struct ObAddArbArg

src/share/ob_srv_rpc_proxy.h

@@ -80,6 +80,7 @@ public:
   RPC_S(PR5 ls_remove_nonpaxos_replica, OB_LS_REMOVE_NONPAXOS_REPLICA, (ObLSDropNonPaxosReplicaArg));
   RPC_S(PR5 ls_modify_paxos_replica_number, OB_LS_MODIFY_PAXOS_REPLICA_NUMBER, (ObLSModifyPaxosReplicaNumberArg));
   RPC_S(PR5 ls_check_dr_task_exist, OB_LS_CHECK_DR_TASK_EXIST, (ObDRTaskExistArg), obrpc::Bool);
+  RPC_S(PR5 ob_exec_drtask_obadmin_command, OB_EXEC_DRTASK_OBADMIN_COMMAND, (ObAdminCommandArg));
 #ifdef OB_BUILD_ARBITRATION
   RPC_S(PR5 add_arb, OB_ADD_ARB, (ObAddArbArg), obrpc::ObAddArbResult);
   RPC_S(PR5 remove_arb, OB_REMOVE_ARB, (ObRemoveArbArg), obrpc::ObRemoveArbResult);