restrict different observer binary version migrate and rebuild

src/share/ob_errno.def

@@ -639,6 +639,7 @@ DEFINE_ERROR(OB_ERR_ROOTSERVICE_START, -4752, -1, "HY000", "rootservice start pr
 DEFINE_ERROR(OB_ERR_ROOTSERVICE_STOP, -4753, -1, "HY000", "rootservice stop process has failure");
 DEFINE_ERROR(OB_ERR_ROOT_INSPECTION, -4754, -1, "HY000", "root inspection is not passed");
 DEFINE_ERROR(OB_ERR_ROOTSERVICE_THREAD_HUNG, -4755, -1, "HY000", "rootservice backgroud thread may be hung");
+DEFINE_ERROR(OB_MIGRATE_NOT_COMPATIBLE, -4756, -1, "HY000", "Migration src and dest version is not compatible.");
 
 ////////////////////////////////////////////////////////////////
 // SQL & Schema specific error code, -5000 ~ -6000

src/share/ob_errno.h

@@ -443,6 +443,7 @@ constexpr int OB_ERR_ROOTSERVICE_START = -4752;
 constexpr int OB_ERR_ROOTSERVICE_STOP = -4753;
 constexpr int OB_ERR_ROOT_INSPECTION = -4754;
 constexpr int OB_ERR_ROOTSERVICE_THREAD_HUNG = -4755;
+constexpr int OB_MIGRATE_NOT_COMPATIBLE = -4756;
 constexpr int OB_ERR_PARSER_INIT = -5000;
 constexpr int OB_ERR_PARSE_SQL = -5001;
 constexpr int OB_ERR_RESOLVE_SQL = -5002;
@@ -2238,6 +2239,7 @@ constexpr int OB_ERR_INVALID_DATE_MSG_FMT_V2 = -4219;
 #define OB_ERR_ROOTSERVICE_STOP__USER_ERROR_MSG "rootservice stop process has failure"
 #define OB_ERR_ROOT_INSPECTION__USER_ERROR_MSG "root inspection is not passed"
 #define OB_ERR_ROOTSERVICE_THREAD_HUNG__USER_ERROR_MSG "rootservice backgroud thread may be hung"
+#define OB_MIGRATE_NOT_COMPATIBLE__USER_ERROR_MSG "Migration src and dest version is not compatible."
 #define OB_ERR_PARSER_INIT__USER_ERROR_MSG "Failed to init SQL parser"
 #define OB_ERR_PARSE_SQL__USER_ERROR_MSG "%s near \'%.*s\' at line %d"
 #define OB_ERR_RESOLVE_SQL__USER_ERROR_MSG "Resolve error"
@@ -4267,6 +4269,7 @@ constexpr int OB_ERR_INVALID_DATE_MSG_FMT_V2 = -4219;
 #define OB_ERR_ROOTSERVICE_STOP__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -4753, rootservice stop process has failure"
 #define OB_ERR_ROOT_INSPECTION__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -4754, root inspection is not passed"
 #define OB_ERR_ROOTSERVICE_THREAD_HUNG__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -4755, rootservice backgroud thread may be hung"
+#define OB_MIGRATE_NOT_COMPATIBLE__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -4756, Migration src and dest version is not compatible."
 #define OB_ERR_PARSER_INIT__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -5000, Failed to init SQL parser"
 #define OB_ERR_PARSE_SQL__ORA_USER_ERROR_MSG "ORA-00900: %s near \'%.*s\' at line %d"
 #define OB_ERR_RESOLVE_SQL__ORA_USER_ERROR_MSG "ORA-00600: internal error code, arguments: -5002, Resolve error"
@@ -5754,7 +5757,7 @@ constexpr int OB_ERR_INVALID_DATE_MSG_FMT_V2 = -4219;
 #define OB_ERR_INVALID_DATE_MSG_FMT_V2__ORA_USER_ERROR_MSG "ORA-01861: Incorrect datetime value for column '%.*s' at row %ld"
 #define OB_ERR_VARIABLE_NOT_IN_SELECT_LIST__ORA_USER_ERROR_MSG "ORA-01007: variable not in select list"
 
-extern int g_all_ob_errnos[2024];
+extern int g_all_ob_errnos[2025];
 
   const char *ob_error_name(const int oberr);
   const char* ob_error_cause(const int oberr);

src/storage/high_availability/ob_ls_migration.cpp

@@ -1141,6 +1141,8 @@ int ObStartMigrationTask::choose_src_()
       LOG_WARN("failed to choose ob src", K(ret), K(tenant_id), K(ls_id), K(local_clog_checkpoint_scn));
     } else if (OB_FAIL(fetch_ls_info_(tenant_id, ls_id, src_info.src_addr_, ls_info))) {
       LOG_WARN("failed to fetch ls info", K(ret), K(tenant_id), K(ls_id), K(src_info));
+    } else if (OB_FAIL(ObStorageHAUtils::check_server_version(ls_info.version_))) {
+      LOG_WARN("failed to check server version", K(ret), K(ls_id), K(ls_info));
     } else {
       ctx_->minor_src_ = src_info;
       ctx_->major_src_ = src_info;

src/storage/high_availability/ob_storage_ha_reader.cpp

@@ -18,6 +18,7 @@
 #include "share/scn.h"
 #include "storage/blocksstable/ob_logic_macro_id.h"
 #include "storage/tablet/ob_tablet.h"
+#include "storage/high_availability/ob_storage_ha_utils.h"
 
 namespace oceanbase
 {
@@ -796,6 +797,8 @@ int ObCopyTabletInfoObReader::fetch_tablet_info(obrpc::ObCopyTabletInfo &tablet_
     if (OB_ITER_END != ret) {
       LOG_WARN("fail to fetch and decode partition meta info", K(ret));
     }
+  } else if (OB_FAIL(ObStorageHAUtils::check_server_version(tablet_info.version_))) {
+    LOG_WARN("failed to check server version", K(ret));
   } else if (!tablet_info.is_valid()) {
     ret = OB_ERR_SYS;
     LOG_ERROR("invalid tablet info", K(ret), K(tablet_info));
@@ -892,6 +895,7 @@ int ObCopyTabletInfoRestoreReader::fetch_tablet_info(obrpc::ObCopyTabletInfo &ta
       tablet_info.data_size_ = 0;
       tablet_info.status_ = ObCopyTabletStatus::TABLET_EXIST;
       tablet_info.tablet_id_ = backup_tablet_meta.tablet_id_;
+      tablet_info.version_ = 0; // for restore this is invalid
       if (OB_FAIL(tablet_info.param_.ha_status_.set_restore_status(restore_status))) {
         LOG_WARN("failed to set restore status", K(ret), K(restore_status));
       } else if (OB_FAIL(tablet_info.param_.ha_status_.set_data_status(data_status))) {
@@ -992,6 +996,8 @@ int ObCopyTabletInfoObProducer::get_next_tablet_info(obrpc::ObCopyTabletInfo &ta
       LOG_WARN("failed to build migration tablet param", K(ret), K(tablet_id));
     } else if (OB_FAIL(tablet->get_ha_sstable_size(tablet_info.data_size_))) {
       LOG_WARN("failed to get sstable size", K(ret), K(tablet_id));
+    } else if (OB_FAIL(ObStorageHAUtils::get_server_version(tablet_info.version_))) {
+      LOG_WARN("failed to get server version", K(ret), K(tablet_info));
     } else {
       tablet_info.tablet_id_ = tablet_id;
       tablet_info.status_ = ObCopyTabletStatus::TABLET_EXIST;
@@ -1047,7 +1053,6 @@ int ObCopyTabletInfoObProducer::build_deleted_tablet_info_(
   return ret;
 }
 
-
 ObCopySSTableInfoObReader::ObCopySSTableInfoObReader()
   : is_inited_(false),
     rpc_reader_(),
@@ -1146,6 +1151,8 @@ int ObCopySSTableInfoObReader::get_next_tablet_sstable_header(
   } else if (!copy_header.is_valid()) {
     ret = OB_ERR_SYS;
     LOG_ERROR("copy header is invalid", K(ret), K(copy_header));
+  } else if (OB_FAIL(ObStorageHAUtils::check_server_version(copy_header.version_))) {
+    LOG_WARN("failed to check server version", K(ret));
   } else {
     is_sstable_iter_end_ = copy_header.sstable_count_ > 0 ? false : true;
     sstable_index_ = 0;
@@ -1382,6 +1389,7 @@ int ObCopySSTableInfoRestoreReader::get_next_tablet_sstable_header(
     copy_header.tablet_id_ = tablet_id;
     copy_header.status_ = ObCopyTabletStatus::TABLET_EXIST;
     copy_header.sstable_count_ = backup_sstable_meta_array_.count();
+    copy_header.version_ = 0; // restore version is not valid
     tablet_index_++;
   }
   return ret;
@@ -1843,6 +1851,8 @@ int ObCopySSTableInfoObProducer::get_copy_tablet_sstable_header(
   if (!is_inited_) {
     ret = OB_NOT_INIT;
     LOG_WARN("copy sstable info ob producer do not init", K(ret));
+  } else if (OB_FAIL(ObStorageHAUtils::get_server_version(copy_header.version_))) {
+    LOG_WARN("failed to get server version", K(ret), K_(ls_id));
   } else {
     copy_header.tablet_id_ = tablet_sstable_info_.tablet_id_;
     copy_header.status_ = status_;

src/storage/high_availability/ob_storage_ha_src_provider.cpp

@@ -14,6 +14,7 @@
 #include "ob_storage_ha_src_provider.h"
 #include "share/location_cache/ob_location_service.h"
 #include "observer/ob_server_event_history_table_operator.h"
+#include "storage/high_availability/ob_storage_ha_utils.h"
 
 namespace oceanbase {
 using namespace share;
@@ -196,6 +197,13 @@ int ObStorageHASrcProvider::inner_choose_ob_src_(const uint64_t tenant_id, const
     share::ObLSRestoreStatus restore_status;
     if (OB_TMP_FAIL(fetch_ls_meta_info_(tenant_id, ls_id, addr, ls_info))) {
       LOG_WARN("failed to fetch ls meta info", K(tmp_ret), K(tenant_id), K(ls_id), K(addr));
+    } else if (OB_FAIL(ObStorageHAUtils::check_server_version(ls_info.version_))) {
+      if (OB_MIGRATE_NOT_COMPATIBLE == ret) {
+        LOG_INFO("do not choose this src", K(ret), K(tenant_id), K(ls_id), K(ls_info));
+        ret = OB_SUCCESS;
+      } else {
+        LOG_WARN("failed to check version", K(ret), K(tenant_id), K(ls_id), K(ls_info));
+      }
     } else if (!ObReplicaTypeCheck::is_full_replica(ls_info.ls_meta_package_.ls_meta_.replica_type_)) {
       LOG_INFO("do not choose this src", K(tenant_id), K(ls_id), K(addr), K(ls_info));
     } else if (local_clog_checkpoint_scn > ls_info.ls_meta_package_.ls_meta_.get_clog_checkpoint_scn()) {

src/storage/high_availability/ob_storage_ha_tablet_builder.cpp

@@ -19,6 +19,7 @@
 #include "share/scn.h"
 #include "observer/ob_server_event_history_table_operator.h"
 #include "storage/tablet/ob_tablet.h"
+#include "storage/high_availability/ob_storage_ha_utils.h"
 
 namespace oceanbase
 {
@@ -284,6 +285,8 @@ int ObStorageHATabletsBuilder::get_tablet_info_ob_reader_(
   } else if (FALSE_IT(reader = ob_reader)) {
   } else if (OB_FAIL(arg.tablet_id_list_.assign(param_.tablet_id_array_))) {
     LOG_WARN("failed to assign tablet id array", K(ret), K(param_));
+  } else if (OB_FAIL(ObStorageHAUtils::get_server_version(arg.version_))) {
+    LOG_WARN("failed to get server version", K(ret), K_(param));
   } else {
     arg.tenant_id_ = param_.tenant_id_;
     arg.ls_rebuild_seq_ = param_.local_rebuild_seq_;
@@ -541,6 +544,8 @@ int ObStorageHATabletsBuilder::build_copy_tablets_sstable_info_arg_(
   } else if (!param_.need_check_seq_) {
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("get invalid args", K(ret), K_(param));
+  } else if (OB_FAIL(ObStorageHAUtils::get_server_version(arg.version_))) {
+    LOG_WARN("failed to get server version", K(ret), K_(param));
   } else {
     arg.tenant_id_ = param_.tenant_id_;
     arg.ls_rebuild_seq_ = param_.local_rebuild_seq_;

src/storage/high_availability/ob_storage_ha_utils.cpp

@@ -16,6 +16,8 @@
 #include "share/ob_global_merge_table_operator.h"
 #include "share/ob_tablet_replica_checksum_operator.h"
 #include "share/scn.h"
+#include "share/ob_version.h"
+#include "share/ob_cluster_version.h"
 
 using namespace oceanbase::share;
 
@@ -49,6 +51,29 @@ int ObStorageHAUtils::check_tablet_replica_validity(const uint64_t tenant_id, co
   return ret;
 }
 
+int ObStorageHAUtils::get_server_version(uint64_t &server_version)
+{
+  int ret = OB_SUCCESS;
+  server_version = CLUSTER_CURRENT_VERSION;
+  return ret;
+}
+
+int ObStorageHAUtils::check_server_version(const uint64_t server_version)
+{
+  int ret = OB_SUCCESS;
+  uint64_t cur_server_version = 0;
+  if (OB_FAIL(get_server_version(cur_server_version))) {
+    LOG_WARN("failed to get server version", K(ret));
+  } else {
+    bool can_migrate = cur_server_version >= server_version;
+    if (!can_migrate) {
+      ret = OB_MIGRATE_NOT_COMPATIBLE;
+      LOG_WARN("migrate server not compatible", K(ret), K(server_version), K(cur_server_version));
+    }
+  }
+  return ret;
+}
+
 int ObStorageHAUtils::check_merge_error_(const uint64_t tenant_id, common::ObISQLClient &sql_client)
 {
   int ret = OB_SUCCESS;

src/storage/high_availability/ob_storage_ha_utils.h

@@ -28,6 +28,8 @@ class ObStorageHAUtils
 public:
   static int check_tablet_replica_validity(const uint64_t tenant_id, const share::ObLSID &ls_id,
       const common::ObAddr &addr, const common::ObTabletID &tablet_id, common::ObISQLClient &sql_client);
+  static int get_server_version(uint64_t &server_version);
+  static int check_server_version(const uint64_t server_version);
 
 private:
   static int check_merge_error_(const uint64_t tenant_id, common::ObISQLClient &sql_client);

src/storage/ob_storage_rpc.cpp

@@ -23,6 +23,7 @@
 #include "logservice/ob_log_handler.h"
 #include "storage/restore/ob_ls_restore_handler.h"
 #include "observer/ob_server_event_history_table_operator.h"
+#include "storage/high_availability/ob_storage_ha_utils.h"
 
 namespace oceanbase
 {
@@ -216,7 +217,8 @@ ObCopyTabletInfoArg::ObCopyTabletInfoArg()
     tablet_id_list_(),
     need_check_seq_(false),
     ls_rebuild_seq_(-1),
-    is_only_copy_major_(false)
+    is_only_copy_major_(false),
+    version_(OB_INVALID_ID)
 {
 }
 
@@ -228,6 +230,7 @@ void ObCopyTabletInfoArg::reset()
   need_check_seq_ = false;
   ls_rebuild_seq_ = -1;
   is_only_copy_major_ = false;
+  version_ = OB_INVALID_ID;
 }
 
 bool ObCopyTabletInfoArg::is_valid() const
@@ -235,17 +238,19 @@ bool ObCopyTabletInfoArg::is_valid() const
   return tenant_id_ != OB_INVALID_ID
       && ls_id_.is_valid()
       && tablet_id_list_.count() > 0
-      && ((need_check_seq_ && ls_rebuild_seq_ >= 0) || !need_check_seq_);
+      && ((need_check_seq_ && ls_rebuild_seq_ >= 0) || !need_check_seq_)
+      && version_ != OB_INVALID_ID;
 }
 
 OB_SERIALIZE_MEMBER(ObCopyTabletInfoArg,
-    tenant_id_, ls_id_, tablet_id_list_, need_check_seq_, ls_rebuild_seq_, is_only_copy_major_);
+    tenant_id_, ls_id_, tablet_id_list_, need_check_seq_, ls_rebuild_seq_, is_only_copy_major_, version_);
 
 ObCopyTabletInfo::ObCopyTabletInfo()
   : tablet_id_(),
     status_(ObCopyTabletStatus::MAX_STATUS),
     param_(),
-    data_size_(0)
+    data_size_(0),
+    version_(OB_INVALID_ID)
 {
 }
 
@@ -255,6 +260,7 @@ void ObCopyTabletInfo::reset()
   status_ = ObCopyTabletStatus::MAX_STATUS;
   param_.reset();
   data_size_ = 0;
+  version_ = OB_INVALID_ID;
 }
 
 bool ObCopyTabletInfo::is_valid() const
@@ -262,7 +268,8 @@ bool ObCopyTabletInfo::is_valid() const
   return tablet_id_.is_valid()
       && ObCopyTabletStatus::is_valid(status_)
       && ((ObCopyTabletStatus::TABLET_EXIST == status_ && param_.is_valid() && data_size_ >= 0)
-        || ObCopyTabletStatus::TABLET_NOT_EXIST == status_);
+        || ObCopyTabletStatus::TABLET_NOT_EXIST == status_)
+      && version_ != OB_INVALID_ID;
 }
 
 int ObCopyTabletInfo::assign(const ObCopyTabletInfo &info)
@@ -276,11 +283,12 @@ int ObCopyTabletInfo::assign(const ObCopyTabletInfo &info)
   } else {
     status_ = info.status_;
     data_size_ = info.data_size_;
+    version_ = info.version_;
   }
   return ret;
 }
 
-OB_SERIALIZE_MEMBER(ObCopyTabletInfo, tablet_id_, status_, param_, data_size_);
+OB_SERIALIZE_MEMBER(ObCopyTabletInfo, tablet_id_, status_, param_, data_size_, version_);
 
 /******************ObCopyTabletSSTableInfoArg*********************/
 ObCopyTabletSSTableInfoArg::ObCopyTabletSSTableInfoArg()
@@ -320,7 +328,8 @@ ObCopyTabletsSSTableInfoArg::ObCopyTabletsSSTableInfoArg()
     need_check_seq_(false),
     ls_rebuild_seq_(-1),
     is_only_copy_major_(false),
-    tablet_sstable_info_arg_list_()
+    tablet_sstable_info_arg_list_(),
+    version_(OB_INVALID_ID)
 {
 }
 
@@ -337,6 +346,7 @@ void ObCopyTabletsSSTableInfoArg::reset()
   ls_rebuild_seq_ = -1;
   is_only_copy_major_ = false;
   tablet_sstable_info_arg_list_.reset();
+  version_ = OB_INVALID_ID;
 }
 
 bool ObCopyTabletsSSTableInfoArg::is_valid() const
@@ -344,11 +354,12 @@ bool ObCopyTabletsSSTableInfoArg::is_valid() const
   return OB_INVALID_ID != tenant_id_
       && ls_id_.is_valid()
       && ((need_check_seq_ && ls_rebuild_seq_ >= 0) || !need_check_seq_)
-      && tablet_sstable_info_arg_list_.count() > 0;
+      && tablet_sstable_info_arg_list_.count() > 0
+      && version_ != OB_INVALID_ID;
 }
 
 OB_SERIALIZE_MEMBER(ObCopyTabletsSSTableInfoArg,
-    tenant_id_, ls_id_, need_check_seq_, ls_rebuild_seq_, is_only_copy_major_, tablet_sstable_info_arg_list_);
+    tenant_id_, ls_id_, need_check_seq_, ls_rebuild_seq_, is_only_copy_major_, tablet_sstable_info_arg_list_, version_);
 
 
 ObCopyTabletSSTableInfo::ObCopyTabletSSTableInfo()
@@ -378,7 +389,8 @@ OB_SERIALIZE_MEMBER(ObCopyTabletSSTableInfo,
 
 ObCopyLSInfoArg::ObCopyLSInfoArg()
   : tenant_id_(OB_INVALID_ID),
-    ls_id_()
+    ls_id_(),
+    version_(OB_INVALID_ID)
 {
 }
 
@@ -386,22 +398,25 @@ void ObCopyLSInfoArg::reset()
 {
   tenant_id_ = OB_INVALID_ID;
   ls_id_.reset();
+  version_ = OB_INVALID_ID;
 }
 
 bool ObCopyLSInfoArg::is_valid() const
 {
   return OB_INVALID_ID != tenant_id_
-      && ls_id_.is_valid();
+      && ls_id_.is_valid()
+      && version_ != OB_INVALID_ID;
 }
 
 OB_SERIALIZE_MEMBER(ObCopyLSInfoArg,
-    tenant_id_, ls_id_);
+    tenant_id_, ls_id_, version_);
 
 
 ObCopyLSInfo::ObCopyLSInfo()
   : ls_meta_package_(),
     tablet_id_array_(),
-    is_log_sync_(false)
+    is_log_sync_(false),
+    version_(OB_INVALID_ID)
 {
 }
 
@@ -410,19 +425,21 @@ void ObCopyLSInfo::reset()
   ls_meta_package_.reset();
   tablet_id_array_.reset();
   is_log_sync_ = false;
+  version_ = OB_INVALID_ID;
 }
 
 bool ObCopyLSInfo::is_valid() const
 {
-  return ls_meta_package_.is_valid() && tablet_id_array_.count() > 0;
+  return ls_meta_package_.is_valid() && tablet_id_array_.count() > 0 && version_ != OB_INVALID_ID;
 }
 
 OB_SERIALIZE_MEMBER(ObCopyLSInfo,
-    ls_meta_package_, tablet_id_array_, is_log_sync_);
+    ls_meta_package_, tablet_id_array_, is_log_sync_, version_);
 
 ObFetchLSMetaInfoArg::ObFetchLSMetaInfoArg()
   : tenant_id_(OB_INVALID_ID),
-    ls_id_()
+    ls_id_(),
+    version_(OB_INVALID_ID)
 {
 }
 
@@ -430,33 +447,38 @@ void ObFetchLSMetaInfoArg::reset()
 {
   tenant_id_ = OB_INVALID_ID;
   ls_id_.reset();
+  version_ = OB_INVALID_ID;
 }
 
 bool ObFetchLSMetaInfoArg::is_valid() const
 {
   return OB_INVALID_ID != tenant_id_
-      && ls_id_.is_valid();
+      && ls_id_.is_valid()
+      && version_ != OB_INVALID_ID;
 }
 
-OB_SERIALIZE_MEMBER(ObFetchLSMetaInfoArg, tenant_id_, ls_id_);
+OB_SERIALIZE_MEMBER(ObFetchLSMetaInfoArg, tenant_id_, ls_id_, version_);
 
 
 ObFetchLSMetaInfoResp::ObFetchLSMetaInfoResp()
-  : ls_meta_package_()
+  : ls_meta_package_(),
+    version_(OB_INVALID_ID)
 {
 }
 
 void ObFetchLSMetaInfoResp::reset()
 {
   ls_meta_package_.reset();
+  version_ = OB_INVALID_ID;
 }
 
 bool ObFetchLSMetaInfoResp::is_valid() const
 {
-  return ls_meta_package_.is_valid();
+  return ls_meta_package_.is_valid()
+      && version_ != OB_INVALID_ID;
 }
 
-OB_SERIALIZE_MEMBER(ObFetchLSMetaInfoResp, ls_meta_package_);
+OB_SERIALIZE_MEMBER(ObFetchLSMetaInfoResp, ls_meta_package_, version_);
 
 ObFetchLSMemberListArg::ObFetchLSMemberListArg()
   : tenant_id_(OB_INVALID_ID),
@@ -580,7 +602,8 @@ ObCopyTabletSSTableHeader::ObCopyTabletSSTableHeader()
   : tablet_id_(),
     status_(ObCopyTabletStatus::MAX_STATUS),
     sstable_count_(0),
-    tablet_meta_()
+    tablet_meta_(),
+    version_(OB_INVALID_ID)
 {
 }
 
@@ -590,6 +613,7 @@ void ObCopyTabletSSTableHeader::reset()
   status_ = ObCopyTabletStatus::MAX_STATUS;
   sstable_count_ = 0;
   tablet_meta_.reset();
+  version_ = OB_INVALID_ID;
 }
 
 bool ObCopyTabletSSTableHeader::is_valid() const
@@ -598,11 +622,12 @@ bool ObCopyTabletSSTableHeader::is_valid() const
       && ObCopyTabletStatus::is_valid(status_)
       && sstable_count_ >= 0
       && ((ObCopyTabletStatus::TABLET_EXIST == status_ && tablet_meta_.is_valid())
-          || ObCopyTabletStatus::TABLET_NOT_EXIST == status_);
+          || ObCopyTabletStatus::TABLET_NOT_EXIST == status_)
+      && version_ != OB_INVALID_ID;
 }
 
 OB_SERIALIZE_MEMBER(ObCopyTabletSSTableHeader,
-    tablet_id_, status_, sstable_count_, tablet_meta_);
+    tablet_id_, status_, sstable_count_, tablet_meta_, version_);
 
 ObNotifyRestoreTabletsArg::ObNotifyRestoreTabletsArg()
   : tenant_id_(OB_INVALID_ID), ls_id_(), tablet_id_array_(), restore_status_(), leader_proposal_id_(0)
@@ -1247,6 +1272,8 @@ int ObFetchLSInfoP::process()
       ret = OB_SRC_DO_NOT_ALLOWED_MIGRATE;
       STORAGE_LOG(WARN, "src migration status do not allow to migrate out", K(ret), "src migration status",
           migration_status);
+    } else if (OB_FAIL(ObStorageHAUtils::get_server_version(result_.version_))) {
+      LOG_WARN("failed to get server version", K(ret), K_(arg));
     } else if (OB_FAIL(MTL(logservice::ObLogService*)->get_palf_role(ls->get_ls_id(), role, proposal_id))) {
       STORAGE_LOG(WARN, "failed to get palf role", K(ret), K(arg_), "meta package", result_.ls_meta_package_);
     } else if (is_strong_leader(role)) {
@@ -1298,6 +1325,8 @@ int ObFetchLSMetaInfoP::process()
       LOG_WARN("log handler should not be NULL", K(ret), KP(log_handler), K(arg_));
     } else if (OB_FAIL(ls->get_ls_meta_package(check_archive, result_.ls_meta_package_))) {
       LOG_WARN("failed to get ls meta package", K(ret), K(arg_));
+    } else if (OB_FAIL(ObStorageHAUtils::get_server_version(result_.version_))) {
+      LOG_WARN("failed to get server version", K(ret), K_(arg));
     }
   }
   return ret;
@@ -1840,7 +1869,9 @@ int ObStorageRpc::post_ls_info_request(
     ObCopyLSInfoArg arg;
     arg.tenant_id_ = tenant_id;
     arg.ls_id_ = ls_id;
-    if (OB_FAIL(rpc_proxy_->to(src_info.src_addr_).dst_cluster_id(src_info.cluster_id_).fetch_ls_info(arg, ls_info))) {
+    if (OB_FAIL(ObStorageHAUtils::get_server_version(arg.version_))) {
+      LOG_WARN("failed to get server version", K(ret), K(ls_id));
+    } else if (OB_FAIL(rpc_proxy_->to(src_info.src_addr_).dst_cluster_id(src_info.cluster_id_).fetch_ls_info(arg, ls_info))) {
       LOG_WARN("failed to fetch ls info", K(ret), K(arg), K(src_info));
     } else {
       FLOG_INFO("fetch ls info successfully", K(ls_info));
@@ -1867,7 +1898,9 @@ int ObStorageRpc::post_ls_meta_info_request(
     ObFetchLSMetaInfoArg arg;
     arg.tenant_id_ = tenant_id;
     arg.ls_id_ = ls_id;
-    if (OB_FAIL(rpc_proxy_->to(src_info.src_addr_).dst_cluster_id(src_info.cluster_id_).fetch_ls_meta_info(arg, ls_info))) {
+    if (OB_FAIL(ObStorageHAUtils::get_server_version(arg.version_))) {
+      LOG_WARN("failed to get server version", K(ret), K(arg));
+    } else if (OB_FAIL(rpc_proxy_->to(src_info.src_addr_).dst_cluster_id(src_info.cluster_id_).fetch_ls_meta_info(arg, ls_info))) {
       LOG_WARN("failed to fetch ls info", K(ret), K(arg), K(src_info));
     } else {
       FLOG_INFO("fetch ls meta info successfully", K(ls_info));

src/storage/ob_storage_rpc.h

@@ -125,13 +125,14 @@ public:
   void reset();
 
   TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(tablet_id_list), K_(need_check_seq),
-      K_(ls_rebuild_seq), K_(is_only_copy_major));
+      K_(ls_rebuild_seq), K_(is_only_copy_major), K_(version));
   uint64_t tenant_id_;
   share::ObLSID ls_id_;
   common::ObSArray<common::ObTabletID> tablet_id_list_;
   bool need_check_seq_;
   int64_t ls_rebuild_seq_;
   bool is_only_copy_major_;
+  uint64_t version_;
 };
 
 struct ObCopyTabletInfo
@@ -143,12 +144,13 @@ public:
   void reset();
   int assign(const ObCopyTabletInfo &info);
   bool is_valid() const;
-  TO_STRING_KV(K_(tablet_id), K_(status), K_(param), K_(data_size));
+  TO_STRING_KV(K_(tablet_id), K_(status), K_(param), K_(data_size), K_(version));
 
   common::ObTabletID tablet_id_;
   storage::ObCopyTabletStatus::STATUS status_;
   storage::ObMigrationTabletParam param_;
   int64_t data_size_; //need copy ssttablet size
+  uint64_t version_;
 };
 
 struct ObCopyTabletSSTableInfoArg final
@@ -179,7 +181,8 @@ public:
   int assign(const ObCopyTabletsSSTableInfoArg &arg);
 
   TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(need_check_seq),
-      K_(ls_rebuild_seq), K_(is_only_copy_major), K_(tablet_sstable_info_arg_list));
+      K_(ls_rebuild_seq), K_(is_only_copy_major), K_(tablet_sstable_info_arg_list),
+      K_(version));
 
   uint64_t tenant_id_;
   share::ObLSID ls_id_;
@@ -187,6 +190,7 @@ public:
   int64_t ls_rebuild_seq_;
   bool is_only_copy_major_;
   common::ObSArray<ObCopyTabletSSTableInfoArg> tablet_sstable_info_arg_list_;
+  uint64_t version_;
   DISALLOW_COPY_AND_ASSIGN(ObCopyTabletsSSTableInfoArg);
 };
 
@@ -218,6 +222,7 @@ public:
   TO_STRING_KV(K_(tenant_id), K_(ls_id));
   uint64_t tenant_id_;
   share::ObLSID ls_id_;
+  uint64_t version_;
 };
 
 struct ObCopyLSInfo
@@ -229,10 +234,11 @@ public:
   bool is_valid() const;
   void reset();
 
-  TO_STRING_KV(K_(ls_meta_package), K_(tablet_id_array), K_(is_log_sync));
+  TO_STRING_KV(K_(ls_meta_package), K_(tablet_id_array), K_(is_log_sync), K_(version));
   storage::ObLSMetaPackage ls_meta_package_;
   common::ObSArray<common::ObTabletID> tablet_id_array_;
   bool is_log_sync_;
+  uint64_t version_;
 };
 
 struct ObFetchLSMetaInfoArg
@@ -244,9 +250,10 @@ public:
   bool is_valid() const;
   void reset();
 
-  TO_STRING_KV(K_(tenant_id), K_(ls_id));
+  TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(version));
   uint64_t tenant_id_;
   share::ObLSID ls_id_;
+  uint64_t version_;
 };
 
 struct ObFetchLSMetaInfoResp
@@ -258,8 +265,9 @@ public:
   bool is_valid() const;
   void reset();
 
-  TO_STRING_KV(K_(ls_meta_package));
+  TO_STRING_KV(K_(ls_meta_package), K_(version));
   storage::ObLSMetaPackage ls_meta_package_;
+  uint64_t version_;
 };
 
 struct ObFetchLSMemberListArg
@@ -332,12 +340,13 @@ public:
   ~ObCopyTabletSSTableHeader() {}
   void reset();
   bool is_valid() const;
-  TO_STRING_KV(K_(tablet_id), K_(status), K_(sstable_count), K_(tablet_meta));
+  TO_STRING_KV(K_(tablet_id), K_(status), K_(sstable_count), K_(tablet_meta), K_(version));
 
   common::ObTabletID tablet_id_;
   storage::ObCopyTabletStatus::STATUS status_;
   int64_t sstable_count_;
   ObMigrationTabletParam tablet_meta_;
+  uint64_t version_;
 };
 
 // Leader notify follower to restore some tablets.