Merge pull request ceph#62747 from bill-scales/issue70844

test: add replica pool support to ceph_test_rados_io_sequence

Reviewed-by: Ronen Friedman <[email protected]>
Reviewed-by: Connor Fawcett <[email protected]>

Author: JonBailey1993

src/common/io_exerciser/RadosIo.cc

@@ -46,14 +46,14 @@ RadosIo::RadosIo(librados::Rados& rados, boost::asio::io_context& asio,
                  const std::string& pool, const std::string& oid,
                  const std::optional<std::vector<int>>& cached_shard_order,
                  uint64_t block_size, int seed, int threads, ceph::mutex& lock,
-                 ceph::condition_variable& cond, bool ec_optimizations)
+                 ceph::condition_variable& cond, bool is_replicated_pool,
+                 bool ec_optimizations)
     : Model(oid, block_size),
       rados(rados),
       asio(asio),
       om(std::make_unique<ObjectModel>(oid, block_size, seed)),
       db(data_generation::DataGenerator::create_generator(
           data_generation::GenerationType::HeaderedSeededRandom, *om)),
-      cc(std::make_unique<ConsistencyChecker>(rados, asio, pool)),
       pool(pool),
       cached_shard_order(cached_shard_order),
       threads(threads),
@@ -63,6 +63,9 @@ RadosIo::RadosIo(librados::Rados& rados, boost::asio::io_context& asio,
   int rc;
   rc = rados.ioctx_create(pool.c_str(), io);
   ceph_assert(rc == 0);
+  if (!is_replicated_pool) {
+    cc = std::make_unique<ConsistencyChecker>(rados, asio, pool);
+  }
 }
 
 RadosIo::~RadosIo() {}

src/common/io_exerciser/RadosIo.h

@@ -48,7 +48,8 @@ class RadosIo : public Model {
           const std::string& pool, const std::string& oid,
           const std::optional<std::vector<int>>& cached_shard_order,
           uint64_t block_size, int seed, int threads, ceph::mutex& lock,
-          ceph::condition_variable& cond, bool ec_optimizations);
+          ceph::condition_variable& cond, bool is_replicated_pool,
+          bool ec_optimizations);
 
   ~RadosIo();
 

src/common/json/OSDStructures.cc

@@ -60,12 +60,36 @@ void OSDPoolGetRequest::decode_json(JSONObj* obj) {
 }
 
 void OSDPoolGetReply::dump(Formatter* f) const {
+  encode_json("size", size, f);
+  encode_json("min_size", min_size, f);
+  encode_json("pg_num", pg_num, f);
+  encode_json("pgp_num", pgp_num, f);
+  encode_json("crush_rule", crush_rule, f);
+  encode_json("allow_ec_overwrites", allow_ec_overwrites, f);
+  encode_json("nodelete", nodelete, f);
+  encode_json("nopgchange", nopgchange, f);
+  encode_json("nosizechange", nosizechange, f);
+  encode_json("noscrub", noscrub, f);
+  encode_json("nodeep-scrub", nodeep_scrub, f);
   encode_json("erasure_code_profile", erasure_code_profile, f);
+  encode_json("fast_read", fast_read, f);
   encode_json("allow_ec_optimizations", allow_ec_optimizations, f);
 }
 
 void OSDPoolGetReply::decode_json(JSONObj* obj) {
+  JSONDecoder::decode_json("size", size, obj);
+  JSONDecoder::decode_json("min_size", min_size, obj);
+  JSONDecoder::decode_json("pg_num", pg_num, obj);
+  JSONDecoder::decode_json("pgp_num", pgp_num, obj);
+  JSONDecoder::decode_json("crush_rule", crush_rule, obj);
+  JSONDecoder::decode_json("allow_ec_overwrites", allow_ec_overwrites, obj);
+  JSONDecoder::decode_json("nodelete", nodelete, obj);
+  JSONDecoder::decode_json("nopgchange", nopgchange, obj);
+  JSONDecoder::decode_json("nosizechange", nosizechange, obj);
+  JSONDecoder::decode_json("noscrub", noscrub, obj);
+  JSONDecoder::decode_json("nodeep-scrub", nodeep_scrub, obj);
   JSONDecoder::decode_json("erasure_code_profile", erasure_code_profile, obj);
+  JSONDecoder::decode_json("fast_read", fast_read, obj);
   JSONDecoder::decode_json("allow_ec_optimizations", allow_ec_optimizations, obj);
 }
 

src/common/json/OSDStructures.h

@@ -41,16 +41,29 @@ struct OSDMapReply {
 
 struct OSDPoolGetRequest {
   std::string pool;
-  std::string var = "erasure_code_profile";
+  std::string var;
   std::string format = "json";
 
   void dump(Formatter* f) const;
   void decode_json(JSONObj* obj);
 };
 
 struct OSDPoolGetReply {
-  std::string erasure_code_profile;
-  bool allow_ec_optimizations;
+  std::optional<int> size;
+  std::optional<int> min_size;
+  std::optional<int> pg_num;
+  std::optional<int> pgp_num;
+  std::optional<std::string> crush_rule;
+  std::optional<bool> allow_ec_overwrites;
+  std::optional<bool> nodelete;
+  std::optional<bool> nopgchange;
+  std::optional<bool> nosizechange;
+  std::optional<bool> noscrub;
+  std::optional<bool> nodeep_scrub;
+  std::optional<std::string> erasure_code_profile;
+  std::optional<int> fast_read;
+  std::optional<bool> allow_ec_optimizations;
+
   void dump(Formatter* f) const;
   void decode_json(JSONObj* obj);
 };

src/erasure-code/consistency/RadosCommands.cc

@@ -54,7 +54,7 @@ int RadosCommands::get_primary_osd(const std::string& pool_name,
  */
 bool RadosCommands::get_pool_allow_ec_optimizations(const std::string& pool_name)
 {
-  ceph::messaging::osd::OSDPoolGetRequest osd_pool_get_request{pool_name, "allow_ec_optimizations"};
+  ceph::messaging::osd::OSDPoolGetRequest osd_pool_get_request{pool_name, "all"};
   encode_json("OSDPoolGetRequest", osd_pool_get_request, formatter.get());
 
   std::ostringstream oss;
@@ -71,7 +71,7 @@ bool RadosCommands::get_pool_allow_ec_optimizations(const std::string& pool_name
   ceph::messaging::osd::OSDPoolGetReply osd_pool_get_reply;
   osd_pool_get_reply.decode_json(&p);
 
-  return osd_pool_get_reply.allow_ec_optimizations;
+  return osd_pool_get_reply.allow_ec_optimizations.value_or(false);
 }
 
 /**
@@ -83,7 +83,7 @@ bool RadosCommands::get_pool_allow_ec_optimizations(const std::string& pool_name
  */
 std::string RadosCommands::get_pool_ec_profile_name(const std::string& pool_name)
 {
-  ceph::messaging::osd::OSDPoolGetRequest osd_pool_get_request{pool_name};
+  ceph::messaging::osd::OSDPoolGetRequest osd_pool_get_request{pool_name, "all"};
   encode_json("OSDPoolGetRequest", osd_pool_get_request, formatter.get());
 
   std::ostringstream oss;
@@ -100,7 +100,12 @@ std::string RadosCommands::get_pool_ec_profile_name(const std::string& pool_name
   ceph::messaging::osd::OSDPoolGetReply osd_pool_get_reply;
   osd_pool_get_reply.decode_json(&p);
 
-  return osd_pool_get_reply.erasure_code_profile;
+  if (!osd_pool_get_reply.erasure_code_profile) {
+    throw std::runtime_error("No profile for given pool. "
+                             "Is it an Erasure Coded pool?");
+  }
+
+  return *osd_pool_get_reply.erasure_code_profile;
 }
 
 /**

src/erasure-code/consistency/ceph_ec_consistency_checker.cc

@@ -71,9 +71,14 @@ int main(int argc, char **argv)
   guard.emplace(boost::asio::make_work_guard(asio));
   thread = make_named_thread("io_thread",[&asio] { asio.run(); });
 
-  auto checker = ceph::consistency::ConsistencyChecker(rados, asio, pool);
-  checker.single_read_and_check_consistency(oid, blocksize, offset, length);
-  checker.print_results(std::cout);
+  try {
+    auto checker = ceph::consistency::ConsistencyChecker(rados, asio, pool);
+    checker.single_read_and_check_consistency(oid, blocksize, offset, length);
+    checker.print_results(std::cout);
+  } catch (std::runtime_error& e) {
+    std::cerr << e.what() << std::endl;
+    exit(1);
+  }
 
   exit(0);
 }

src/test/osd/ceph_test_rados_io_sequence/ceph_test_rados_io_sequence.cc

@@ -134,7 +134,7 @@ constexpr std::string_view usage[] = {
     "ceph_test_rados_io_sequence --blocksize <b> --pool <p> --object <oid>",
     "                            --objectsize <min,max> --threads <t>",
     "\tCustomize the test, if a pool is specified then it defines the",
-    "\tReplica/EC configuration",
+    "\tReplicated/EC configuration",
     "",
     "ceph_test_rados_io_sequence --listsequence",
     "\t Display list of supported I/O sequences",
@@ -793,6 +793,7 @@ ceph::io_sequence::tester::SelectErasurePool::SelectErasurePool(
     bool allow_pool_balancer,
     bool allow_pool_deep_scrubbing,
     bool allow_pool_scrubbing,
+    bool check_consistency,
     bool test_recovery,
     bool allow_pool_ec_optimizations)
     : ProgramOptionReader<std::string>(vm, "pool"),
@@ -802,6 +803,7 @@ ceph::io_sequence::tester::SelectErasurePool::SelectErasurePool(
       allow_pool_balancer(allow_pool_balancer),
       allow_pool_deep_scrubbing(allow_pool_deep_scrubbing),
       allow_pool_scrubbing(allow_pool_scrubbing),
+      check_consistency(check_consistency),
       test_recovery(test_recovery),
       allow_pool_ec_optimizations(allow_pool_ec_optimizations),
       first_use(true),
@@ -831,7 +833,8 @@ const std::string ceph::io_sequence::tester::SelectErasurePool::select() {
       bufferlist inbl, outbl;
       auto formatter = std::make_shared<JSONFormatter>(false);
 
-      ceph::messaging::osd::OSDPoolGetRequest osdPoolGetRequest{*force_value};
+      ceph::messaging::osd::OSDPoolGetRequest osdPoolGetRequest{*force_value,
+                                                                "all"};
       rc = send_mon_command(osdPoolGetRequest, rados, "OSDPoolGetRequest", inbl,
                             &outbl, formatter.get());
       ceph_assert(rc == 0);
@@ -843,18 +846,32 @@ const std::string ceph::io_sequence::tester::SelectErasurePool::select() {
       ceph::messaging::osd::OSDPoolGetReply pool_get_reply;
       pool_get_reply.decode_json(&p);
 
-      profile = sep.selectExistingProfile(pool_get_reply.erasure_code_profile);
+      if (pool_get_reply.erasure_code_profile.has_value()) {
+        pool_type = pg_pool_t::TYPE_ERASURE;
+        profile = sep.selectExistingProfile(*pool_get_reply.erasure_code_profile);
+      } else {
+        pool_type = pg_pool_t::TYPE_REPLICATED;
+        if (check_consistency) {
+          throw std::invalid_argument(fmt::format("checkconsistency option not "
+                                                  "allowed if using a {} pool",
+                                                  pg_pool_t::get_type_name(pool_type)));
+        }
+      }
     } else {
+      pool_type = pg_pool_t::TYPE_ERASURE;
       created_pool_name = create();
     }
 
     if (!dry_run) {
-      configureServices(force_value.value_or(created_pool_name),
+      configureServices(force_value.value_or(created_pool_name), pool_type,
                         allow_pool_autoscaling, allow_pool_balancer,
                         allow_pool_deep_scrubbing, allow_pool_scrubbing,
                         allow_pool_ec_optimizations, true, test_recovery);
 
-      setApplication(created_pool_name);
+      if (!force_value)
+      {
+        setApplication(created_pool_name);
+      }
     }
   }
 
@@ -897,6 +914,7 @@ void ceph::io_sequence::tester::SelectErasurePool::setApplication(
 
 void ceph::io_sequence::tester::SelectErasurePool::configureServices(
     const std::string& pool_name,
+    PoolType pool_type,
     bool allow_pool_autoscaling,
     bool allow_pool_balancer,
     bool allow_pool_deep_scrubbing,
@@ -952,26 +970,29 @@ void ceph::io_sequence::tester::SelectErasurePool::configureServices(
     ceph_assert(rc == 0);
   }
 
-  if (allow_pool_ec_optimizations) {
-    ceph::messaging::osd::OSDPoolSetRequest
-        allow_ec_optimisations_request{pool_name,
-                                       "allow_ec_optimizations",
-                                       "true",
-                                       std::nullopt};
-    rc = send_mon_command(allow_ec_optimisations_request, rados,
-                          "OSDPoolSetRequest", inbl, &outbl, formatter.get());
-    ceph_assert(rc == 0);
-  }
+  if (pool_type == pg_pool_t::TYPE_ERASURE)
+  {
+    if (allow_pool_ec_optimizations) {
+      ceph::messaging::osd::OSDPoolSetRequest
+          allow_ec_optimisations_request{pool_name,
+                                        "allow_ec_optimizations",
+                                        "true",
+                                        std::nullopt};
+      rc = send_mon_command(allow_ec_optimisations_request, rados,
+                            "OSDPoolSetRequest", inbl, &outbl, formatter.get());
+      ceph_assert(rc == 0);
+    }
 
-  if (allow_pool_ec_overwrites) {
-    ceph::messaging::osd::OSDPoolSetRequest
-        allow_ec_optimisations_request{pool_name,
-                                       "allow_ec_overwrites",
-                                       "true",
-                                       std::nullopt};
-    rc = send_mon_command(allow_ec_optimisations_request, rados,
-                          "OSDPoolSetRequest", inbl, &outbl, formatter.get());
-    ceph_assert(rc == 0);
+    if (allow_pool_ec_overwrites) {
+      ceph::messaging::osd::OSDPoolSetRequest
+          allow_ec_optimisations_request{pool_name,
+                                        "allow_ec_overwrites",
+                                        "true",
+                                        std::nullopt};
+      rc = send_mon_command(allow_ec_optimisations_request, rados,
+                            "OSDPoolSetRequest", inbl, &outbl, formatter.get());
+      ceph_assert(rc == 0);
+    }
   }
 
   if (test_recovery) {
@@ -1004,11 +1025,13 @@ ceph::io_sequence::tester::TestObject::TestObject(
   } else {
     const std::string pool = spo.select();
     if (!dryrun) {
-      ceph_assert(spo.getProfile());
-      pool_km = spo.getProfile()->km;
-      if (spo.getProfile()->mapping && spo.getProfile()->layers) {
-        pool_mappinglayers = {*spo.getProfile()->mapping,
-                             *spo.getProfile()->layers};
+      if (!spo.is_replicated_pool()) {
+	ceph_assert(spo.getProfile());
+	pool_km = spo.getProfile()->km;
+	if (spo.getProfile()->mapping && spo.getProfile()->layers) {
+	  pool_mappinglayers = {*spo.getProfile()->mapping,
+	                        *spo.getProfile()->layers};
+	}
       }
     }
 
@@ -1038,7 +1061,8 @@ ceph::io_sequence::tester::TestObject::TestObject(
 
     exerciser_model = std::make_unique<ceph::io_exerciser::RadosIo>(
         rados, asio, pool, oid, cached_shard_order, sbs.select(), rng(),
-        threads, lock, cond, spo.get_allow_pool_ec_optimizations());
+        threads, lock, cond, spo.is_replicated_pool(),
+        spo.get_allow_pool_ec_optimizations());
     dout(0) << "= " << oid << " pool=" << pool << " threads=" << threads
             << " blocksize=" << exerciser_model->get_block_size() << " ="
             << dendl;
@@ -1130,6 +1154,7 @@ ceph::io_sequence::tester::TestRunner::TestRunner(
           vm.contains("allow_pool_balancer"),
           vm.contains("allow_pool_deep_scrubbing"),
           vm.contains("allow_pool_scrubbing"),
+          vm.contains("checkconsistency"),
           vm.contains("testrecovery"),
           !vm.contains("disable_pool_ec_optimizations")},
       snt{rng, vm, "threads", true},
@@ -1317,7 +1342,7 @@ bool ceph::io_sequence::tester::TestRunner::run_interactive_test() {
     model = std::make_unique<ceph::io_exerciser::RadosIo>(
         rados, asio, pool, object_name, osd_map_reply.acting, sbs.select(), rng(),
         1,  // 1 thread
-        lock, cond,
+        lock, cond, spo.is_replicated_pool(),
         spo.get_allow_pool_ec_optimizations());
   }
 
@@ -1473,6 +1498,10 @@ bool ceph::io_sequence::tester::TestRunner::run_automated_test() {
       std::cerr << "Error: " << e.what() << std::endl;
       return false;
     }
+    catch (const std::invalid_argument &e) {
+      std::cerr << "Error: " << e.what() << std::endl;
+      return false;
+    }
   }
   if (!dryrun) {
     rados.wait_for_latest_osdmap();

src/test/osd/ceph_test_rados_io_sequence/ceph_test_rados_io_sequence.h

@@ -388,6 +388,7 @@ class SelectErasurePool : public ProgramOptionReader<std::string> {
                     bool allow_pool_balancer,
                     bool allow_pool_deep_scrubbing,
                     bool allow_pool_scrubbing,
+                    bool check_consistency,
                     bool test_recovery,
                     bool allow_pool_ec_optimizations);
   const std::string select() override;
@@ -402,6 +403,9 @@ class SelectErasurePool : public ProgramOptionReader<std::string> {
   inline bool get_allow_pool_ec_optimizations() {
     return allow_pool_ec_optimizations;
   }
+
+  inline bool is_replicated_pool() const { return pool_type
+                                              == pg_pool_t::TYPE_REPLICATED; }
   inline std::optional<Profile> getProfile() { return profile; }
 
  private:
@@ -412,16 +416,21 @@ class SelectErasurePool : public ProgramOptionReader<std::string> {
   bool allow_pool_balancer;
   bool allow_pool_deep_scrubbing;
   bool allow_pool_scrubbing;
+  bool check_consistency;
   bool test_recovery;
   bool allow_pool_ec_optimizations;
 
+  using PoolType = int;
+  PoolType pool_type;
+
   bool first_use;
 
   SelectErasureProfile sep;
 
   std::optional<Profile> profile;
 
   void configureServices(const std::string& pool_name,
+                         PoolType pool_type,
                          bool allow_pool_autoscaling,
                          bool allow_pool_balancer,
                          bool allow_pool_deep_scrubbing,