patch 4.0

2022-10-24 10:34:53 +08:00
parent 4ad6e00ec3
commit 93a1074b0c
10533 changed files with 2588271 additions and 2299373 deletions
--- a/unittest/share/backup/test_backup_struct.cpp
+++ b/unittest/share/backup/test_backup_struct.cpp
@ -13,16 +13,10 @@
 #define USING_LOG_PREFIX SHARE

 #include <gtest/gtest.h>
-#include "lib/container/ob_array_array.h"
 #include "lib/container/ob_array_iterator.h"
 #define private public
 #include "share/backup/ob_backup_path.h"
 #include "share/backup/ob_log_archive_backup_info_mgr.h"
-#include "share/backup/ob_backup_struct.h"
-#include "rootserver/ob_backup_data_clean.h"
-#undef private
-#include <algorithm>
-#include "lib/hash/ob_hashmap.h"
 using namespace oceanbase;
 using namespace common;
 using namespace share;
@ -50,502 +44,91 @@ TEST(ObBackupUtils, check_is_tmp_file)
  ASSERT_FALSE(is_tmp_file);
 }

-TEST(ObSimpleBackupSetPath, simple_path_disk)
+TEST(ObBackupDest, nfs)
 {
-  ObSimpleBackupSetPath simple_path;
-  simple_path.backup_set_id_ = 1;
-  simple_path.backup_dest_ = "file:///root_backup_dir";
-  LOG_INFO("simple_path", K(simple_path.get_simple_path()), K(simple_path.get_storage_info()));
-  ASSERT_EQ(OB_SUCCESS, simple_path.get_simple_path().case_compare("file:///root_backup_dir"));
-  ASSERT_EQ(OB_SUCCESS, simple_path.get_storage_info().case_compare(""));
-}
-
-TEST(ObSimpleBackupSetPath, simple_path_oss)
-{
-  ObSimpleBackupSetPath simple_path;
-  simple_path.backup_set_id_ = 1;
-  simple_path.backup_dest_ =
-      "oss://backup_dir/?host=http://oss-cn-hangzhou-zmf.aliyuncs.com&access_id=111&access_key=222";
-  LOG_INFO("simple_path", K(simple_path.get_simple_path()), K(simple_path.get_storage_info()));
-  ASSERT_EQ(OB_SUCCESS, simple_path.get_simple_path().case_compare("oss://backup_dir/"));
-  ASSERT_EQ(OB_SUCCESS,
-      simple_path.get_storage_info().case_compare(
-          "host=http://oss-cn-hangzhou-zmf.aliyuncs.com&access_id=111&access_key=222"));
-}
-
-TEST(ObBackupDest, disk)
-{
-  const char* backup_test = "file:///root_backup_dir";
+  const char *backup_test = "file:///backup_dir/?&delete_mode=tagging";
  ObBackupDest dest;
+  ObBackupDest dest1;
+  char backup_dest_str[OB_MAX_BACKUP_DEST_LENGTH] = { 0 };
+  char backup_path_str[OB_MAX_BACKUP_DEST_LENGTH] = { 0 };
  ASSERT_EQ(OB_SUCCESS, dest.set(backup_test));
-  LOG_INFO("dump backup dest", K(dest));
-  ASSERT_EQ(0, strcmp(dest.root_path_, "file:///root_backup_dir"));
-  ASSERT_EQ(0, strcmp(dest.storage_info_, ""));
+  ASSERT_EQ(OB_SUCCESS, dest1.set(backup_test));
+  LOG_INFO("dump backup dest", K(dest), K(dest.get_root_path()), K(*(dest.get_storage_info())));
+  ASSERT_EQ(0, strcmp(dest.root_path_, "file:///backup_dir"));
+  ASSERT_TRUE(dest.storage_info_->device_type_ == 1);
+  ObString backup_str("file:///backup_dir/");
+  ObBackupDest dest2;
+  ASSERT_EQ(OB_SUCCESS, dest2.set(backup_str));
+  ASSERT_EQ(0, strcmp(dest.root_path_, "file:///backup_dir"));
+
+  ASSERT_EQ(OB_SUCCESS, dest.get_backup_dest_str(backup_dest_str, sizeof(backup_dest_str)));
+  ASSERT_EQ(0, strcmp(backup_dest_str, "file:///backup_dir"));
+  ASSERT_EQ(OB_SUCCESS, dest.get_backup_path_str(backup_path_str, sizeof(backup_path_str)));
+  ASSERT_EQ(0, strcmp(backup_path_str, "file:///backup_dir")); 
+  ASSERT_TRUE(dest.is_root_path_equal(dest1));
+  bool is_equal = false;
+  ASSERT_EQ(OB_SUCCESS, dest.is_backup_path_equal(dest1, is_equal));
+  ASSERT_TRUE(is_equal);
+  ASSERT_TRUE(dest == dest1);
+  ASSERT_EQ(OB_SUCCESS, dest2.deep_copy(dest));
+  ASSERT_EQ(0, strcmp(dest.root_path_, "file:///backup_dir"));
 }

 TEST(ObBackupDest, oss)
 {
-  const char* backup_test =
-      "oss://backup_dir/?host=http://oss-cn-hangzhou-zmf.aliyuncs.com&access_id=111&access_key=222";
+  const char *backup_test = "oss://backup_dir/?host=xxx.com&access_id=111&access_key=222&delete_mode=tagging";
+  ObBackupDest dest;
+  ObBackupDest dest1;
+  char backup_dest_str[OB_MAX_BACKUP_DEST_LENGTH] = { 0 };
+  char backup_path_str[OB_MAX_BACKUP_DEST_LENGTH] = { 0 };
+  ASSERT_EQ(OB_SUCCESS, dest.set(backup_test));
+  ASSERT_EQ(OB_SUCCESS, dest1.set(backup_test));
+  LOG_INFO("dump backup dest", K(dest), K(dest.get_root_path()), K(*(dest.get_storage_info())));
+  ASSERT_EQ(0, strcmp(dest.root_path_, "oss://backup_dir"));
+  ASSERT_TRUE(dest.storage_info_->device_type_ == 0);
+
+  ASSERT_EQ(OB_SUCCESS, dest.get_backup_dest_str(backup_dest_str, sizeof(backup_dest_str)));
+  ASSERT_EQ(0, strcmp(backup_dest_str, "oss://backup_dir?host=xxx.com&access_id=111&encrypt_key=9B6FDE7E1E54CD292CDE5494CEB86B6F&delete_mode=tagging"));
+  ASSERT_EQ(OB_SUCCESS, dest.get_backup_path_str(backup_path_str, sizeof(backup_path_str)));
+  ASSERT_EQ(0, strcmp(backup_path_str, "oss://backup_dir?host=xxx.com")); 
+  ASSERT_TRUE(dest.is_root_path_equal(dest1));
+  bool is_equal = false;
+  ASSERT_EQ(OB_SUCCESS, dest.is_backup_path_equal(dest1, is_equal));
+  ASSERT_TRUE(is_equal);
+  ASSERT_TRUE(dest == dest1);
+  dest1.reset();
+  ASSERT_EQ(OB_SUCCESS, dest1.set(dest.get_root_path().ptr(), dest.get_storage_info()));
+  ASSERT_TRUE(dest == dest1);
+}
+
+TEST(ObBackupDest, oss_encrypt)
+{
+  const char *backup_test = "oss://backup_dir?host=xxx.com&access_id=111&encrypt_key=9B6FDE7E1E54CD292CDE5494CEB86B6F";
  ObBackupDest dest;
  ASSERT_EQ(OB_SUCCESS, dest.set(backup_test));
-  LOG_INFO("dump backup dest", K(dest));
-  ASSERT_EQ(0, strcmp(dest.root_path_, "oss://backup_dir/"));
-  ASSERT_EQ(0, strcmp(dest.storage_info_, "host=http://oss-cn-hangzhou-zmf.aliyuncs.com&access_id=111&access_key=222"));
+  LOG_INFO("dump backup dest", K(dest.get_root_path()), K(*(dest.get_storage_info())));
+  ASSERT_EQ(0, strcmp(dest.root_path_, "oss://backup_dir"));
+  ASSERT_TRUE(dest.storage_info_->device_type_ == 0);
+  const char *path = "oss://backup_dir/";
+  const char *endpoint = "host=xxx.com";
+  const char *authorization = "access_id=111&encrypt_key=9B6FDE7E1E54CD292CDE5494CEB86B6F";
+  const char *extension = "";
+  ObBackupDest dest1;
+  ASSERT_EQ(OB_SUCCESS, dest1.set(path, endpoint, authorization, extension));
+  ASSERT_TRUE(dest == dest1);
+
+  char backup_dest_str[OB_MAX_BACKUP_DEST_LENGTH] = { 0 };
+  char backup_path_str[OB_MAX_BACKUP_DEST_LENGTH] = { 0 };
+  ASSERT_EQ(OB_SUCCESS, dest.get_backup_dest_str(backup_dest_str, sizeof(backup_dest_str)));
+  ASSERT_EQ(0, strcmp(backup_dest_str, "oss://backup_dir?host=xxx.com&access_id=111&encrypt_key=9B6FDE7E1E54CD292CDE5494CEB86B6F"));
+  ASSERT_EQ(OB_SUCCESS, dest.get_backup_path_str(backup_path_str, sizeof(backup_path_str)));
+  ASSERT_EQ(0, strcmp(backup_path_str, "oss://backup_dir?host=xxx.com")); 
+  
+  dest1.reset();
+  ASSERT_EQ(OB_SUCCESS, dest1.set(path, endpoint, authorization, extension));
+  ASSERT_TRUE(dest == dest1);
 }

-int check_backup_dest_opt(const ObBackupDestOpt& opt, int64_t log_archive_checkpoint_interval, int64_t recovery_window,
-    int64_t piece_switch_interval, int64_t backup_copies, bool auto_delete_obsolete_backup,
-    bool auto_touch_reserved_backup)
-{
-  int ret = OB_SUCCESS;
-
-  if (opt.log_archive_checkpoint_interval_ != log_archive_checkpoint_interval) {
-    ret = OB_ERR_SYS;
-    LOG_WARN("not match", K(log_archive_checkpoint_interval), K(opt));
-  } else if (opt.recovery_window_ != recovery_window) {
-    ret = OB_ERR_SYS;
-    LOG_WARN("not match", K(recovery_window), K(opt));
-  } else if (opt.piece_switch_interval_ != piece_switch_interval) {
-    ret = OB_ERR_SYS;
-    LOG_WARN("not match", K(piece_switch_interval), K(opt));
-  } else if (opt.backup_copies_ != backup_copies) {
-    ret = OB_ERR_SYS;
-    LOG_WARN("not match", K(backup_copies), K(opt));
-  } else if (opt.auto_delete_obsolete_backup_ != auto_delete_obsolete_backup) {
-    ret = OB_ERR_SYS;
-    LOG_WARN("not match", K(auto_delete_obsolete_backup), K(opt));
-  } else if (opt.auto_touch_reserved_backup_ != auto_touch_reserved_backup) {
-    ret = OB_ERR_SYS;
-    LOG_WARN("not match", K(auto_touch_reserved_backup), K(opt));
-  }
-
-  return ret;
-}
-
-TEST(ObBackupDestOpt, normal)
-{
-  const char* backup_dest_opt_str =
-      "recovery_window=7d&auto_delete_obsolete_backup=true&backup_copies=2&log_archive_piece_switch_interval=1d";
-  const char* backup_backup_dest_opt_str = "recovery_window=14d&auto_delete_obsolete_backup=true";
-  ObBackupDestOpt backup_dest_opt;
-  ObBackupDestOpt backup_backup_dest_opt;
-  const bool global_auto_delete = false;
-  const int64_t global_recovery_window = 0;
-  const int64_t global_checkpoint_interval = 120 * 1000LL * 1000;  // default config 120s
-  const int64_t global_backup_checkpoint_interval = 0;
-
-  ASSERT_EQ(OB_SUCCESS,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          backup_dest_opt_str,
-          global_auto_delete,
-          global_recovery_window,
-          global_checkpoint_interval,
-          false));
-  ASSERT_EQ(OB_SUCCESS,
-      check_backup_dest_opt(backup_dest_opt,
-          global_checkpoint_interval,
-          7 * 24 * 3600LL * 1000 * 1000 /*recovery_window*/,
-          1 * 24 * 3600LL * 1000 * 1000 /*piece_switch_interval*/,
-          2 /*backup_copies*/,
-          true /*auto delete*/,
-          false /*auto touch*/));
-
-  ASSERT_EQ(OB_SUCCESS,
-      backup_backup_dest_opt.init(true /*is_backup_backup*/,
-          backup_backup_dest_opt_str,
-          global_auto_delete,
-          global_recovery_window,
-          global_backup_checkpoint_interval,
-          false));
-  ASSERT_EQ(OB_SUCCESS,
-      check_backup_dest_opt(backup_backup_dest_opt,
-          0,
-          14 * 24 * 3600LL * 1000 * 1000 /*recovery_window*/,
-          0 /*piece_switch_interval*/,
-          0 /*backup_copies*/,
-          true /*auto delete*/,
-          false /*auto touch*/));
-}
-
-TEST(ObBackupDestOpt, backup_dest_all)
-{
-  ObBackupDestOpt backup_dest_opt;
-
-  ASSERT_EQ(OB_SUCCESS,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=30d&auto_delete_obsolete_backup=true&log_archive_piece_"
-          "switch_interval=3d&backup_copies=3",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-
-  ASSERT_EQ(OB_SUCCESS,
-      check_backup_dest_opt(backup_dest_opt,
-          10 * 60 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          30 * 24 * 3600LL * 1000 * 1000 /*recovery_window*/,
-          3 * 24 * 3600LL * 1000 * 1000 /*piece_switch_interval*/,
-          3 /*backup_copies*/,
-          true /*auto delete*/,
-          false /*auto touch*/));
-}
-
-TEST(ObBackupDestOpt, backup_dest_empty)
-{
-  ObBackupDestOpt backup_dest_opt;
-
-  ASSERT_EQ(OB_SUCCESS,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-
-  ASSERT_EQ(OB_SUCCESS,
-      check_backup_dest_opt(backup_dest_opt,
-          2 * 60 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          0 /*recovery_window*/,
-          0 /*piece_switch_interval*/,
-          0 /*backup_copies*/,
-          0 /*auto delete*/,
-          false /*auto touch*/));
-}
-
-TEST(ObBackupDestOpt, backup_dest_invalid_format)
-{
-  ObBackupDestOpt backup_dest_opt;
-
-  // invalid key checkpoint_interval
-  ASSERT_EQ(OB_INVALID_ARGUMENT,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "checkpoint_interval=10m&recovery_window=30d&auto_delete_obsolete_backup=true&log_archive_piece_switch_"
-          "interval=3d&backup_copies=3&auto_update_reserved_backup_timestamp=true",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-
-  // has blank space
-  ASSERT_EQ(OB_INVALID_ARGUMENT,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=30d "
-          "&auto_delete_obsolete_backup=true&log_archive_piece_switch_interval=3d&backup_copies=3&auto_update_reserved_"
-          "backup_timestamp=true",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-
-  // recovery_window has no value
-  ASSERT_EQ(OB_INVALID_ARGUMENT,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=&auto_delete_obsolete_backup=true&log_archive_piece_"
-          "switch_interval=3d&backup_copies=3&auto_update_reserved_backup_timestamp=true",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-
-  // recovery_window has invalid value
-  ASSERT_EQ(OB_INVALID_ARGUMENT,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=a&auto_delete_obsolete_backup=true&log_archive_piece_"
-          "switch_interval=3d&backup_copies=3&auto_update_reserved_backup_timestamp=true",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-
-  // auto_delete_obsolete_backup has invalid value
-  ASSERT_EQ(OB_INVALID_ARGUMENT,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=7d&auto_delete_obsolete_backup=a&log_archive_piece_"
-          "switch_interval=3d&backup_copies=3&auto_update_reserved_backup_timestamp=true",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-}
-
-TEST(ObBackupDestOpt, backup_dest_invalid_delete_and_touch)
-{
-  ObBackupDestOpt backup_dest_opt;
-  ASSERT_EQ(OB_NOT_SUPPORTED,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=30d&auto_delete_obsolete_backup=true&log_archive_piece_"
-          "switch_interval=3d&backup_copies=3&auto_update_reserved_backup_timestamp=true",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-}
-
-TEST(ObBackupDestOpt, backup_dest_invalid_copies)
-{
-  ObBackupDestOpt backup_dest_opt;
-  ASSERT_EQ(OB_NOT_SUPPORTED,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=30d&auto_delete_obsolete_backup=true&log_archive_piece_"
-          "switch_interval=3d&backup_copies=-1",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-}
-
-TEST(ObBackupDestOpt, backup_dest_invalid_recovery_window)
-{
-  ObBackupDestOpt backup_dest_opt;
-  ASSERT_EQ(OB_INVALID_ARGUMENT,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=-1d&log_archive_piece_switch_interval=3d&backup_copies="
-          "3&auto_update_reserved_backup_timestamp=true",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-}
-
-TEST(ObBackupDestOpt, backup_dest_invalid_piece_switch)
-{
-  ObBackupDestOpt backup_dest_opt;
-  ASSERT_EQ(OB_NOT_SUPPORTED,
-      backup_dest_opt.init(false /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=30d&log_archive_piece_switch_interval=1s&backup_copies="
-          "3&auto_update_reserved_backup_timestamp=true",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-}
-
-TEST(ObBackupDestOpt, backup_backup_dest_invalid_copies)
-{
-  ObBackupDestOpt backup_dest_opt;
-  ASSERT_EQ(OB_INVALID_ARGUMENT,
-      backup_dest_opt.init(true /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=30d&auto_delete_obsolete_backup=true&backup_copies=1",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-}
-
-TEST(ObBackupDestOpt, backup_backup_dest_invalid_piece_switch)
-{
-  ObBackupDestOpt backup_dest_opt;
-  ASSERT_EQ(OB_INVALID_ARGUMENT,
-      backup_dest_opt.init(true /*is_backup_backup*/,
-          "log_archive_checkpoint_interval=10m&recovery_window=30d&auto_delete_obsolete_backup=true&log_archive_piece_"
-          "switch_interval=3d&backup_copies=0",
-          false /*global_auto_delete*/,
-          0 /*global_recovery_window*/,
-          120 * 1000LL * 1000LL /*global_checkpoint_interval*/,
-          false));
-}
-
-TEST(ObLogArchiveBackupInfoMgr, log_archive_info_cmp)
-{
-  int ret = OB_SUCCESS;
-  ObLogArchiveBackupInfoMgr::CompareBackupPieceInfo cmp(ret);
-  ObBackupPieceInfo piece_info;
-  ObArray<ObBackupPieceInfo> piece_infos;
-  ObArray<ObBackupPieceInfo> piece_infos_copy1;
-  ObArray<ObBackupPieceInfo> piece_infos_copy2;
-  ObArray<ObBackupPieceInfo> piece_infos_copy3;
-
-  ret = piece_info.backup_dest_.assign("file::///oceanbase/");
-
-  ASSERT_EQ(OB_SUCCESS, ret);
-  piece_info.checkpoint_ts_ = 1621652028364222;
-  piece_info.compatible_ = ObTenantLogArchiveStatus::COMPATIBLE_VERSION_2;
-  piece_info.create_date_ = 20210523;
-  piece_info.file_status_ = ObBackupFileStatus::BACKUP_FILE_AVAILABLE;
-  piece_info.key_.tenant_id_ = 1;
-  piece_info.max_ts_ = 1621652028364222;
-  piece_info.start_piece_id_ = 0;
-  piece_info.start_ts_ = 0;
-  piece_info.status_ = ObBackupPieceStatus::BACKUP_PIECE_ACTIVE;
-
-  //mock array with same incarnation, round, copy id
-  for (int64_t i = 0; OB_SUCC(ret) && i < 10; ++i) {
-    piece_info.key_.copy_id_ = 0;
-    piece_info.key_.incarnation_ = 1;
-    piece_info.key_.round_id_ = 1;
-    piece_info.key_.backup_piece_id_ = i;
-    ret = piece_infos.push_back(piece_info);
-    ASSERT_EQ(OB_SUCCESS, ret);
-  }
-
-  std::sort(piece_infos.begin(), piece_infos.end(), cmp);
-
-  for (int64_t i = 0; OB_SUCC(ret) && i < piece_infos.count(); ++i) {
-    const ObBackupPieceInfo &tmp_piece_info = piece_infos.at(i);
-    ASSERT_EQ(tmp_piece_info.key_.backup_piece_id_, i);
-  }
-  piece_infos.reset();
-
-  for (int64_t i = 0; OB_SUCC(ret) && i < 10; ++i) {
-    piece_info.key_.copy_id_ = 1;
-    piece_info.key_.incarnation_ = 1;
-    piece_info.key_.round_id_ = 1+i;
-    piece_info.key_.backup_piece_id_ = i;
-    ret = piece_infos_copy1.push_back(piece_info);
-    ASSERT_EQ(OB_SUCCESS, ret);
-  }
-
-  for (int64_t i = 0; OB_SUCC(ret) && i < 9; ++i) {
-    piece_info.key_.copy_id_ = 2;
-    piece_info.key_.incarnation_ = 1;
-    piece_info.key_.round_id_ = 1+i;
-    piece_info.key_.backup_piece_id_ = i;
-    ret = piece_infos_copy2.push_back(piece_info);
-    ASSERT_EQ(OB_SUCCESS, ret);
-  }
-
-
-  for (int64_t i = 0; OB_SUCC(ret) && i < 7; ++i) {
-    piece_info.key_.copy_id_ = 3;
-    piece_info.key_.incarnation_ = 1;
-    piece_info.key_.round_id_ = 1+i;
-    piece_info.key_.backup_piece_id_ = i;
-    ret = piece_infos_copy3.push_back(piece_info);
-    ASSERT_EQ(OB_SUCCESS, ret);
-  }
-
-  //add to piece infos
-  for (int64_t i = 0; OB_SUCC(ret) && i < piece_infos_copy3.count(); ++i) {
-    const ObBackupPieceInfo &tmp_piece_info = piece_infos_copy3.at(i);
-    ret = piece_infos.push_back(tmp_piece_info);
-    ASSERT_EQ(OB_SUCCESS, ret);
-  }
-
-  for (int64_t i = 0; OB_SUCC(ret) && i < piece_infos_copy1.count(); ++i) {
-    const ObBackupPieceInfo &tmp_piece_info = piece_infos_copy1.at(i);
-    ret = piece_infos.push_back(tmp_piece_info);
-    ASSERT_EQ(OB_SUCCESS, ret);
-  }
-
-
-  for (int64_t i = 0; OB_SUCC(ret) && i < piece_infos_copy2.count(); ++i) {
-    const ObBackupPieceInfo &tmp_piece_info = piece_infos_copy2.at(i);
-    ret = piece_infos.push_back(tmp_piece_info);
-    ASSERT_EQ(OB_SUCCESS, ret);
-  }
-
-  std::sort(piece_infos.begin(), piece_infos.end(), cmp);
-
-  for (int64_t i = 0; OB_SUCC(ret) && i < 10; ++i) {
-    const ObBackupPieceInfo &tmp_piece_info = piece_infos.at(i);
-    ASSERT_EQ(tmp_piece_info.key_.backup_piece_id_, i);
-    ASSERT_EQ(tmp_piece_info.key_.round_id_, i + 1);
-    ASSERT_EQ(tmp_piece_info.key_.copy_id_, 1);
-  }
-
-  ret = piece_infos.push_back(piece_info);
-  ASSERT_EQ(OB_SUCCESS, ret);
-  std::sort(piece_infos.begin(), piece_infos.end(), cmp);
-  ASSERT_EQ(OB_ERR_UNEXPECTED, ret);
-
-}
-
-
-TEST(ObLogArchiveBackupInfoMgr, log_archive_info_cmp2)
-{
-  int ret = OB_SUCCESS;
-  ObArray<ObLogArchiveBackupInfo> log_infos;
-  ObLogArchiveBackupInfo log_info;
-  log_info.status_.start_ts_ = 1;
-  log_info.status_.checkpoint_ts_ = 0;
-  log_info.status_.round_ = 1;
-  ret = log_infos.push_back(log_info);
-  ASSERT_EQ(OB_SUCCESS, ret);
-  log_info.reset();
-  log_info.status_.start_ts_ = 1;
-  log_info.status_.checkpoint_ts_ = 0;
-  log_info.status_.round_ = 2;
-  ret = log_infos.push_back(log_info);
-  ASSERT_EQ(OB_SUCCESS, ret);
-  log_info.reset();
-  log_info.status_.start_ts_ = 1;
-  log_info.status_.checkpoint_ts_ = 0;
-  log_info.status_.round_ = 3;
-  ret = log_infos.push_back(log_info);
-  ASSERT_EQ(OB_SUCCESS, ret);
-
-
-  typedef ObArray<ObLogArchiveBackupInfo>::iterator ArrayIter;
-  rootserver::ObBackupDataClean::CompareLogArchiveSnapshotVersion cmp;
-  ArrayIter iter = std::lower_bound(log_infos.begin(),
-                                    log_infos.end(),
-                                    1,
-                                    cmp);
-  if (iter == log_infos.end()) {
-    --iter;
-  } else if (iter != log_infos.begin()
-      && iter->status_.start_ts_ > 1) {
-    --iter;
-  }
-  log_info = *iter;
-  LOG_INFO("log info", K(log_info));
-
-}
-
-
-TEST(ObBackupDataClean, duplicate_task)
-{
-  int ret = OB_SUCCESS;
-  ObTenantBackupTaskInfo task_info;
-  ObArray<ObTenantBackupTaskInfo> task_infos;
-
-  //mock task info
-  //array backup set id is : 1, 2, 1, 2
-  task_info.tenant_id_ = OB_SYS_TENANT_ID;
-  task_info.incarnation_ = 1;
-  task_info.backup_set_id_ = 1;
-  task_info.copy_id_ = 0;
-  task_info.status_ = ObTenantBackupTaskInfo::FINISH;
-  ret = task_infos.push_back(task_info);
-  ASSERT_EQ(OB_SUCCESS, ret);
-  task_info.reset();
-  task_info.tenant_id_ = OB_SYS_TENANT_ID;
-  task_info.incarnation_ = 1;
-  task_info.backup_set_id_ = 2;
-  ret = task_infos.push_back(task_info);
-  task_info.copy_id_ = 0;
-  task_info.status_ = ObTenantBackupTaskInfo::FINISH;
-  ASSERT_EQ(OB_SUCCESS, ret);
-  task_info.reset();
-  task_info.tenant_id_ = OB_SYS_TENANT_ID;
-  task_info.incarnation_ = 1;
-  task_info.backup_set_id_ = 1;
-  task_info.copy_id_ = 0;
-  task_info.status_ = ObTenantBackupTaskInfo::DOING;
-  ret = task_infos.push_back(task_info);
-  ASSERT_EQ(OB_SUCCESS, ret);
-  task_info.reset();
-  task_info.tenant_id_ = OB_SYS_TENANT_ID;
-  task_info.incarnation_ = 1;
-  task_info.backup_set_id_ = 2;
-  task_info.copy_id_ = 0;
-  task_info.status_ = ObTenantBackupTaskInfo::DOING;
-  ret = task_infos.push_back(task_info);
-  ASSERT_EQ(OB_SUCCESS, ret);
-
-  rootserver::ObBackupDataClean data_clean;
-  data_clean.is_inited_ = true;
-  ret = data_clean.duplicate_task_info(task_infos);
-  ASSERT_EQ(2, task_infos.count());
-  ASSERT_EQ(1, task_infos.at(0).backup_set_id_);
-  ASSERT_EQ(ObTenantBackupTaskInfo::DOING, task_infos.at(0).status_);
-  ASSERT_EQ(2, task_infos.at(1).backup_set_id_);
-  ASSERT_EQ(ObTenantBackupTaskInfo::DOING, task_infos.at(1).status_);
-
-}
-
-
 int main(int argc, char **argv)
 {
  OB_LOGGER.set_log_level("INFO");