crimson: use get instead of deprecated get0

https://github.com/scylladb/seastar/commit/2b43417d210edbd7a3c3065bcfe3c0a9aea27f75

Signed-off-by: Matan Breizman <mbreizma@redhat.com>
(cherry picked from commit 425f3338dfd3dc3290d5a5fe0b7af712931d543b)

diff --git a/src/crimson/common/coroutine.h b/src/crimson/common/coroutine.h
index c4dfca58c58162792bfa26fc3012427c1f51c783..cf8476fcf47da08e9b70eaf65a6ff1a86d54b06f 100644 (file)
--- a/src/crimson/common/coroutine.h
+++ b/src/crimson/common/coroutine.h
@@ -222,15 +222,15 @@ public:
       // silence warning that we are discarding an exceptional future
       if (_future.failed()) _future.get_exception();
       if constexpr (is_errorated) {
-       return maybe_fut->unsafe_get0();
+       return (T)maybe_fut->unsafe_get();
       } else {
-       return maybe_fut->get0();
+       return (T)maybe_fut->get();
       }
     } else {
       if constexpr (is_errorated) {
-       return _future.unsafe_get0();
+       return (T)_future.unsafe_get();
       } else {
-       return _future.get0();
+       return (T)_future.get();
       }
     }
   }

diff --git a/src/crimson/common/errorator.h b/src/crimson/common/errorator.h
index b87a7fce8fe6d21ff42ee6e122aa44a1ddea45bd..5d30d6f14d4cf3443f652623002fe342f53677b9 100644 (file)
--- a/src/crimson/common/errorator.h
+++ b/src/crimson/common/errorator.h
@@ -110,7 +110,7 @@ inline auto repeat(AsyncAction action) {
         f.get_exception()
       );
     } else if (f.available()) {
-      if (auto done = f.get0()) {
+      if (auto done = f.get()) {
         return errorator_t::template make_ready_future<>();
       }
     } else {
@@ -751,9 +751,6 @@ private:
     auto &&unsafe_get() {
       return seastar::future<ValueT>::get();
     }
-    auto unsafe_get0() {
-      return seastar::future<ValueT>::get0();
-    }
     void unsafe_wait() {
       seastar::future<ValueT>::wait();
     }

diff --git a/src/crimson/common/interruptible_future.h b/src/crimson/common/interruptible_future.h
index 59bb0be30873bcb36977c24414134b6d02f45c86..54dbb15e66001bf84e05d1e50d476fc1c7440e23 100644 (file)
--- a/src/crimson/common/interruptible_future.h
+++ b/src/crimson/common/interruptible_future.h
@@ -408,7 +408,7 @@ public:
   template <typename U>
   using interrupt_futurize_t =
     typename interruptor<InterruptCond>::template futurize_t<U>;
-  using core_type::get0;
+  using core_type::get;
   using core_type::core_type;
   using core_type::get_exception;
   using core_type::ignore_ready_future;
@@ -719,7 +719,7 @@ class [[nodiscard]] interruptible_future_detail<
 {
 public:
   using core_type = ErroratedFuture<crimson::errorated_future_marker<T>>;
-  using core_type::unsafe_get0;
+  using core_type::unsafe_get;
   using errorator_type = typename core_type::errorator_type;
   using interrupt_errorator_type =
     interruptible_errorator<InterruptCond, errorator_type>;
@@ -1421,7 +1421,7 @@ public:
         ret = seastar::futurize_invoke(mapper, *begin++).then_wrapped_interruptible(
            [s = s.get(), ret = std::move(ret)] (auto f) mutable {
             try {
-                s->result = s->reduce(std::move(s->result), std::move(f.get0()));
+                s->result = s->reduce(std::move(s->result), std::move(f.get()));
                 return std::move(ret);
             } catch (...) {
                 return std::move(ret).then_wrapped_interruptible([ex = std::current_exception()] (auto f) {

diff --git a/src/crimson/os/seastore/async_cleaner.cc b/src/crimson/os/seastore/async_cleaner.cc
index 4ca5d1a2069ecf67c3e7089d5ab37097e44efc10..16adc046b344cd494b8d65e0fa6074d23e1a79ba 100644 (file)
--- a/src/crimson/os/seastore/async_cleaner.cc
+++ b/src/crimson/os/seastore/async_cleaner.cc
@@ -1477,7 +1477,7 @@ bool SegmentCleaner::check_usage()
         }
       }
     });
-  }).unsafe_get0();
+  }).unsafe_get();
   return space_tracker->equals(*tracker);
 }
 
@@ -1782,7 +1782,7 @@ bool RBMCleaner::check_usage()
        }
       }
     });
-  }).unsafe_get0();
+  }).unsafe_get();
   return equals(tracker);
 }
 

diff --git a/src/crimson/osd/ops_executer.cc b/src/crimson/osd/ops_executer.cc
index 656caa92ca445a9e685222b80bac17fe8230cd39..854c4eab6af098c3daf4b42cb22430b60c5eef38 100644 (file)
--- a/src/crimson/osd/ops_executer.cc
+++ b/src/crimson/osd/ops_executer.cc
@@ -1379,8 +1379,8 @@ static PG::interruptible_future<ceph::bufferlist> do_pgls_common(
           }),
         seastar::make_ready_future<hobject_t>(next));
     }).then_interruptible([pg_end](auto&& ret) {
-      auto entries = std::move(std::get<0>(ret).get0());
-      auto next = std::move(std::get<1>(ret).get0());
+      auto entries = std::move(std::get<0>(ret).get());
+      auto next = std::move(std::get<1>(ret).get());
       pg_ls_response_t response;
       response.handle = next.is_max() ? pg_end : next;
       response.entries = std::move(entries);

diff --git a/src/crimson/osd/shard_services.cc b/src/crimson/osd/shard_services.cc
index a8da40210e1e75e19e4b67a2cb66c08c54d29bb9..5f7c4a624471b1984269dd33485d24c50f6d4be6 100644 (file)
--- a/src/crimson/osd/shard_services.cc
+++ b/src/crimson/osd/shard_services.cc
@@ -593,8 +593,8 @@ seastar::future<Ref<PG>> ShardServices::make_pg(
     std::move(get_pool_info_for_pg),
     std::move(get_collection)
   ).then([pgid, create_map, this](auto &&ret) {
-    auto [pool, name, ec_profile] = std::move(std::get<0>(ret).get0());
-    auto coll = std::move(std::get<1>(ret).get0());
+    auto [pool, name, ec_profile] = std::move(std::get<0>(ret).get());
+    auto coll = std::move(std::get<1>(ret).get());
     return seastar::make_ready_future<Ref<PG>>(
       new PG{
        pgid,

diff --git a/src/crimson/tools/perf_crimson_msgr.cc b/src/crimson/tools/perf_crimson_msgr.cc
index 0bded8c2ea79cee7c4a453c8c6929660aa70e7b5..e5f56361fff3db6a16c7202924e1990dc1777e76 100644 (file)
--- a/src/crimson/tools/perf_crimson_msgr.cc
+++ b/src/crimson/tools/perf_crimson_msgr.cc
@@ -1107,8 +1107,8 @@ static seastar::future<> run(
           "ms_crc_data", crc_enabled ? "true" : "false");
     })
   ).then([=](auto&& ret) {
-    auto server = std::move(std::get<0>(ret).get0());
-    auto client = std::move(std::get<1>(ret).get0());
+    auto server = std::move(std::get<0>(ret).get());
+    auto client = std::move(std::get<1>(ret).get());
     // reserve core 0 for potentially better performance
     if (mode == perf_mode_t::both) {
       logger().info("\nperf settings:\n  smp={}\n  {}\n  {}\n",

diff --git a/src/crimson/tools/perf_staged_fltree.cc b/src/crimson/tools/perf_staged_fltree.cc
index 81b6217506f0d6acb57739977160c9be3dcc9e59..a55ee7704f0f3284ca724643bf770d8fdb539ba1 100644 (file)
--- a/src/crimson/tools/perf_staged_fltree.cc
+++ b/src/crimson/tools/perf_staged_fltree.cc
@@ -132,7 +132,7 @@ seastar::future<> run(const bpo::variables_map& config) {
         {range1[0], range1[1]},
         {range0[0], range0[1]});
     PerfTree<TRACK> perf{is_dummy};
-    perf.run(kvs, erase_ratio).get0();
+    perf.run(kvs, erase_ratio).get();
   });
 }
 

diff --git a/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc b/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc
index dd6c88dcf405d540cb8183e1fbe3f26ded0bdf64..f1a0cf65e82fecc6fd18f78bb5828f6833bb6560 100644 (file)
--- a/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc
+++ b/src/test/crimson/seastore/onode_tree/test_fltree_onode_manager.cc
@@ -118,7 +118,7 @@ struct fltree_onode_manager_test_t
       auto p_kv = *it;
       auto onode = with_trans_intr(t, [&](auto &t) {
         return manager->get_or_create_onode(t, p_kv->key);
-      }).unsafe_get0();
+      }).unsafe_get();
       std::invoke(f, t, *onode, p_kv->value);
     });
   }
@@ -128,7 +128,7 @@ struct fltree_onode_manager_test_t
       auto p_kv = *it;
       auto onode = with_trans_intr(t, [&](auto &t) {
         return manager->get_onode(t,  p_kv->key);
-      }).unsafe_get0();
+      }).unsafe_get();
       p_kv->value.validate(*onode);
     });
   }
@@ -138,7 +138,7 @@ struct fltree_onode_manager_test_t
       auto p_kv = *it;
       auto exist = with_trans_intr(t, [&](auto &t) {
         return manager->contains_onode(t, p_kv->key);
-      }).unsafe_get0();
+      }).unsafe_get();
       ceph_assert(exist == false);
     });
   }
@@ -167,7 +167,7 @@ struct fltree_onode_manager_test_t
         [this, f=std::move(f)] (auto& t, auto& oids, auto& items) {
       auto onodes = with_trans_intr(t, [&](auto &t) {
         return manager->get_or_create_onodes(t, oids);
-      }).unsafe_get0();
+      }).unsafe_get();
       for (auto tup : boost::combine(onodes, items)) {
         OnodeRef onode;
         onode_item_t* p_item;
@@ -187,7 +187,7 @@ struct fltree_onode_manager_test_t
         boost::tie(oid, p_item) = tup;
         auto onode = with_trans_intr(t, [&](auto &t) {
           return manager->get_onode(t, oid);
-        }).unsafe_get0();
+        }).unsafe_get();
         p_item->validate(*onode);
       }
     });
@@ -200,7 +200,7 @@ struct fltree_onode_manager_test_t
       for (auto& oid : oids) {
         auto exist = with_trans_intr(t, [&](auto &t) {
           return manager->contains_onode(t, oid);
-        }).unsafe_get0();
+        }).unsafe_get();
         ceph_assert(exist == false);
       }
     });
@@ -219,7 +219,7 @@ struct fltree_onode_manager_test_t
       while (start != end) {
         auto [list_ret, list_end] = with_trans_intr(t, [&](auto &t) {
           return manager->list_onodes(t, start, end, LIST_LIMIT);
-        }).unsafe_get0();
+        }).unsafe_get();
         listed_oids.insert(listed_oids.end(), list_ret.begin(), list_ret.end());
         start = list_end;
       }
@@ -252,7 +252,7 @@ TEST_P(fltree_onode_manager_test_t, 1_single)
       OnodeRef onode_ref = &onode;
       with_trans_intr(t, [&](auto &t) {
         return manager->erase_onode(t, onode_ref);
-      }).unsafe_get0();
+      }).unsafe_get();
     });
     validate_erased(iter);
   });
@@ -302,7 +302,7 @@ TEST_P(fltree_onode_manager_test_t, 2_synthetic)
       OnodeRef onode_ref = &onode;
       with_trans_intr(t, [&](auto &t) {
         return manager->erase_onode(t, onode_ref);
-      }).unsafe_get0();
+      }).unsafe_get();
     });
     restart();
     validate_erased(rd_start, rd_end);

diff --git a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc
index 79668ed9333ffd54b4bfb690e1ccb0bb1998fe4f..48b65909143ca31d41547e228fef512ee03b382b 100644 (file)
--- a/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc
+++ b/src/test/crimson/seastore/onode_tree/test_staged_fltree.cc
@@ -169,22 +169,22 @@ TEST_F(a_basic_test_t, 2_node_sizes)
     ValueBuilderImpl<UnboundedValue> vb;
     context_t c{*nm, vb, *t};
     std::array<std::pair<NodeImplURef, NodeExtentMutable>, 16> nodes = {
-      INTR_WITH_PARAM(InternalNode0::allocate, c, false, 1u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(InternalNode1::allocate, c, false, 1u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(InternalNode2::allocate, c, false, 1u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(InternalNode3::allocate, c, false, 1u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(InternalNode0::allocate, c, true, 1u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(InternalNode1::allocate, c, true, 1u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(InternalNode2::allocate, c, true, 1u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(InternalNode3::allocate, c, true, 1u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(LeafNode0::allocate, c, false, 0u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(LeafNode1::allocate, c, false, 0u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(LeafNode2::allocate, c, false, 0u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(LeafNode3::allocate, c, false, 0u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(LeafNode0::allocate, c, true, 0u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(LeafNode1::allocate, c, true, 0u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(LeafNode2::allocate, c, true, 0u).unsafe_get0().make_pair(),
-      INTR_WITH_PARAM(LeafNode3::allocate, c, true, 0u).unsafe_get0().make_pair()
+      INTR_WITH_PARAM(InternalNode0::allocate, c, false, 1u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(InternalNode1::allocate, c, false, 1u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(InternalNode2::allocate, c, false, 1u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(InternalNode3::allocate, c, false, 1u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(InternalNode0::allocate, c, true, 1u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(InternalNode1::allocate, c, true, 1u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(InternalNode2::allocate, c, true, 1u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(InternalNode3::allocate, c, true, 1u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(LeafNode0::allocate, c, false, 0u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(LeafNode1::allocate, c, false, 0u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(LeafNode2::allocate, c, false, 0u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(LeafNode3::allocate, c, false, 0u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(LeafNode0::allocate, c, true, 0u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(LeafNode1::allocate, c, true, 0u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(LeafNode2::allocate, c, true, 0u).unsafe_get().make_pair(),
+      INTR_WITH_PARAM(LeafNode3::allocate, c, true, 0u).unsafe_get().make_pair()
     };
     std::ostringstream oss;
     oss << "\nallocated nodes:";
@@ -227,9 +227,9 @@ TEST_F(b_dummy_tree_test_t, 3_random_insert_erase_leaf_node)
                   "\nrandomized leaf node insert:\n");
     auto key_s = ghobject_t();
     auto key_e = ghobject_t::get_max();
-    ASSERT_TRUE(INTR_R(tree->find, *ref_t, key_s).unsafe_get0().is_end());
-    ASSERT_TRUE(INTR(tree->begin, *ref_t).unsafe_get0().is_end());
-    ASSERT_TRUE(INTR(tree->last, *ref_t).unsafe_get0().is_end());
+    ASSERT_TRUE(INTR_R(tree->find, *ref_t, key_s).unsafe_get().is_end());
+    ASSERT_TRUE(INTR(tree->begin, *ref_t).unsafe_get().is_end());
+    ASSERT_TRUE(INTR(tree->last, *ref_t).unsafe_get().is_end());
 
     std::map<ghobject_t,
              std::tuple<test_item_t, UnboundedBtree::Cursor>> insert_history;
@@ -238,10 +238,10 @@ TEST_F(b_dummy_tree_test_t, 3_random_insert_erase_leaf_node)
         const ghobject_t& key, const test_item_t& value) {
       auto conf = UnboundedBtree::tree_value_config_t{value.get_payload_size()};
       auto [cursor, success] = INTR_R(tree->insert,
-          *ref_t, key, conf).unsafe_get0();
+          *ref_t, key, conf).unsafe_get();
       initialize_cursor_from_item(*ref_t, key, value, cursor, success);
       insert_history.emplace(key, std::make_tuple(value, cursor));
-      auto cursor_ = INTR_R(tree->find, *ref_t, key).unsafe_get0();
+      auto cursor_ = INTR_R(tree->find, *ref_t, key).unsafe_get();
       ceph_assert(cursor_ != tree->end());
       ceph_assert(cursor_.value() == cursor.value());
       validate_cursor_from_item(key, value, cursor_);
@@ -249,12 +249,12 @@ TEST_F(b_dummy_tree_test_t, 3_random_insert_erase_leaf_node)
     };
 
     auto f_validate_erase = [this, &insert_history] (const ghobject_t& key) {
-      auto cursor_erase = INTR_R(tree->find, *ref_t, key).unsafe_get0();
-      auto cursor_next = INTR(cursor_erase.get_next, *ref_t).unsafe_get0();
-      auto cursor_ret = INTR_R(tree->erase, *ref_t, cursor_erase).unsafe_get0();
+      auto cursor_erase = INTR_R(tree->find, *ref_t, key).unsafe_get();
+      auto cursor_next = INTR(cursor_erase.get_next, *ref_t).unsafe_get();
+      auto cursor_ret = INTR_R(tree->erase, *ref_t, cursor_erase).unsafe_get();
       ceph_assert(cursor_erase.is_end());
       ceph_assert(cursor_ret == cursor_next);
-      auto cursor_lb = INTR_R(tree->lower_bound, *ref_t, key).unsafe_get0();
+      auto cursor_lb = INTR_R(tree->lower_bound, *ref_t, key).unsafe_get();
       ceph_assert(cursor_lb == cursor_next);
       auto it = insert_history.find(key);
       ceph_assert(std::get<1>(it->second).is_end());
@@ -277,10 +277,10 @@ TEST_F(b_dummy_tree_test_t, 3_random_insert_erase_leaf_node)
 
     // validate lookup
     {
-      auto cursor1_s = INTR_R(tree->lower_bound, *ref_t, key_s).unsafe_get0();
+      auto cursor1_s = INTR_R(tree->lower_bound, *ref_t, key_s).unsafe_get();
       ASSERT_EQ(cursor1_s.get_ghobj(), key1);
       ASSERT_EQ(cursor1_s.value(), test_value1);
-      auto cursor1_e = INTR_R(tree->lower_bound, *ref_t, key_e).unsafe_get0();
+      auto cursor1_e = INTR_R(tree->lower_bound, *ref_t, key_e).unsafe_get();
       ASSERT_TRUE(cursor1_e.is_end());
     }
 
@@ -289,7 +289,7 @@ TEST_F(b_dummy_tree_test_t, 3_random_insert_erase_leaf_node)
       auto value1_dup = values.pick();
       auto conf = UnboundedBtree::tree_value_config_t{value1_dup.get_payload_size()};
       auto [cursor1_dup, ret1_dup] = INTR_R(tree->insert,
-          *ref_t, key1, conf).unsafe_get0();
+          *ref_t, key1, conf).unsafe_get();
       ASSERT_FALSE(ret1_dup);
       validate_cursor_from_item(key1, value1, cursor1_dup);
     }
@@ -370,7 +370,7 @@ TEST_F(b_dummy_tree_test_t, 3_random_insert_erase_leaf_node)
     std::for_each(kvs.begin(), kvs.end(), [&f_insert_erase_insert] (auto& kv) {
       f_insert_erase_insert(kv.first, kv.second);
     });
-    ASSERT_EQ(INTR(tree->height, *ref_t).unsafe_get0(), 1);
+    ASSERT_EQ(INTR(tree->height, *ref_t).unsafe_get(), 1);
     ASSERT_FALSE(tree->test_is_clean());
 
     for (auto& [k, val] : insert_history) {
@@ -378,22 +378,22 @@ TEST_F(b_dummy_tree_test_t, 3_random_insert_erase_leaf_node)
       // validate values in tree keep intact
       auto cursor = with_trans_intr(*ref_t, [this, &k=k](auto& tr) {
         return tree->find(tr, k);
-      }).unsafe_get0();
+      }).unsafe_get();
       EXPECT_NE(cursor, tree->end());
       validate_cursor_from_item(k, v, cursor);
       // validate values in cursors keep intact
       validate_cursor_from_item(k, v, c);
     }
     {
-      auto cursor = INTR_R(tree->lower_bound, *ref_t, key_s).unsafe_get0();
+      auto cursor = INTR_R(tree->lower_bound, *ref_t, key_s).unsafe_get();
       validate_cursor_from_item(smallest_key, smallest_value, cursor);
     }
     {
-      auto cursor = INTR(tree->begin, *ref_t).unsafe_get0();
+      auto cursor = INTR(tree->begin, *ref_t).unsafe_get();
       validate_cursor_from_item(smallest_key, smallest_value, cursor);
     }
     {
-      auto cursor = INTR(tree->last, *ref_t).unsafe_get0();
+      auto cursor = INTR(tree->last, *ref_t).unsafe_get();
       validate_cursor_from_item(largest_key, largest_value, cursor);
     }
 
@@ -408,11 +408,11 @@ TEST_F(b_dummy_tree_test_t, 3_random_insert_erase_leaf_node)
       std::sort(kvs.begin(), kvs.end(), [](auto& l, auto& r) {
         return l.first < r.first;
       });
-      auto cursor = INTR(tree->begin, *ref_t).unsafe_get0();
+      auto cursor = INTR(tree->begin, *ref_t).unsafe_get();
       for (auto& [k, v] : kvs) {
         ASSERT_FALSE(cursor.is_end());
         validate_cursor_from_item(k, v, cursor);
-        cursor = INTR(cursor.get_next, *ref_t).unsafe_get0();
+        cursor = INTR(cursor.get_next, *ref_t).unsafe_get();
       }
       ASSERT_TRUE(cursor.is_end());
     }
@@ -426,12 +426,12 @@ TEST_F(b_dummy_tree_test_t, 3_random_insert_erase_leaf_node)
     for (auto& [k, v] : kvs) {
       auto e_size = with_trans_intr(*ref_t, [this, &k=k](auto& tr) {
         return tree->erase(tr, k);
-      }).unsafe_get0();
+      }).unsafe_get();
       ASSERT_EQ(e_size, 1);
     }
-    auto cursor = INTR(tree->begin, *ref_t).unsafe_get0();
+    auto cursor = INTR(tree->begin, *ref_t).unsafe_get();
     ASSERT_TRUE(cursor.is_end());
-    ASSERT_EQ(INTR(tree->height, *ref_t).unsafe_get0(), 1);
+    ASSERT_EQ(INTR(tree->height, *ref_t).unsafe_get(), 1);
   });
 }
 
@@ -478,15 +478,15 @@ class TestTree {
       std::pair<unsigned, unsigned> range_0,
       size_t value_size) {
     return seastar::async([this, range_2, range_1, range_0, value_size] {
-      INTR(tree.mkfs, t).unsafe_get0();
+      INTR(tree.mkfs, t).unsafe_get();
       //logger().info("\n---------------------------------------------"
       //              "\nbefore leaf node split:\n");
       auto keys = build_key_set(range_2, range_1, range_0);
       for (auto& key : keys) {
         auto value = values.create(value_size);
-        insert_tree(key, value).get0();
+        insert_tree(key, value).get();
       }
-      ASSERT_EQ(INTR(tree.height, t).unsafe_get0(), 1);
+      ASSERT_EQ(INTR(tree.height, t).unsafe_get(), 1);
       ASSERT_FALSE(tree.test_is_clean());
       //std::ostringstream oss;
       //tree.dump(t, oss);
@@ -497,18 +497,18 @@ class TestTree {
   seastar::future<> build_tree(
       const std::vector<ghobject_t>& keys, const std::vector<test_item_t>& values) {
     return seastar::async([this, keys, values] {
-      INTR(tree.mkfs, t).unsafe_get0();
+      INTR(tree.mkfs, t).unsafe_get();
       //logger().info("\n---------------------------------------------"
       //              "\nbefore leaf node split:\n");
       ASSERT_EQ(keys.size(), values.size());
       auto key_iter = keys.begin();
       auto value_iter = values.begin();
       while (key_iter != keys.end()) {
-        insert_tree(*key_iter, *value_iter).get0();
+        insert_tree(*key_iter, *value_iter).get();
         ++key_iter;
         ++value_iter;
       }
-      ASSERT_EQ(INTR(tree.height, t).unsafe_get0(), 1);
+      ASSERT_EQ(INTR(tree.height, t).unsafe_get(), 1);
       ASSERT_FALSE(tree.test_is_clean());
       //std::ostringstream oss;
       //tree.dump(t, oss);
@@ -528,13 +528,13 @@ class TestTree {
       UnboundedBtree tree_clone(std::move(ref_dummy));
       auto ref_t_clone = make_test_transaction();
       Transaction& t_clone = *ref_t_clone;
-      INTR_R(tree_clone.test_clone_from, t_clone, t, tree).unsafe_get0();
+      INTR_R(tree_clone.test_clone_from, t_clone, t, tree).unsafe_get();
 
       // insert and split
       logger().info("\n\nINSERT-SPLIT {}:", key_hobj_t(key));
       auto conf = UnboundedBtree::tree_value_config_t{value.get_payload_size()};
       auto [cursor, success] = INTR_R(tree_clone.insert,
-          t_clone, key, conf).unsafe_get0();
+          t_clone, key, conf).unsafe_get();
       initialize_cursor_from_item(t, key, value, cursor, success);
 
       {
@@ -542,17 +542,17 @@ class TestTree {
         tree_clone.dump(t_clone, oss);
         logger().info("dump new root:\n{}", oss.str());
       }
-      EXPECT_EQ(INTR(tree_clone.height, t_clone).unsafe_get0(), 2);
+      EXPECT_EQ(INTR(tree_clone.height, t_clone).unsafe_get(), 2);
 
       for (auto& [k, val] : insert_history) {
         auto& [v, c] = val;
         auto result = with_trans_intr(t_clone, [&tree_clone, &k=k] (auto& tr) {
           return tree_clone.find(tr, k);
-        }).unsafe_get0();
+        }).unsafe_get();
         EXPECT_NE(result, tree_clone.end());
         validate_cursor_from_item(k, v, result);
       }
-      auto result = INTR_R(tree_clone.find, t_clone, key).unsafe_get0();
+      auto result = INTR_R(tree_clone.find, t_clone, key).unsafe_get();
       EXPECT_NE(result, tree_clone.end());
       validate_cursor_from_item(key, value, result);
       EXPECT_TRUE(last_split.match(expected));
@@ -562,11 +562,11 @@ class TestTree {
       logger().info("\n\nERASE-MERGE {}:", key_hobj_t(key));
       auto nxt_cursor = with_trans_intr(t_clone, [&cursor=cursor](auto& tr) {
         return cursor.erase<true>(tr);
-      }).unsafe_get0();
+      }).unsafe_get();
 
       {
         // track root again to dump
-        auto begin = INTR(tree_clone.begin, t_clone).unsafe_get0();
+        auto begin = INTR(tree_clone.begin, t_clone).unsafe_get();
         std::ignore = begin;
         std::ostringstream oss;
         tree_clone.dump(t_clone, oss);
@@ -586,11 +586,11 @@ class TestTree {
         auto& [v, c] = val;
         auto result = with_trans_intr(t_clone, [&tree_clone, &k=k](auto& tr) {
           return tree_clone.find(tr, k);
-        }).unsafe_get0();
+        }).unsafe_get();
         EXPECT_NE(result, tree_clone.end());
         validate_cursor_from_item(k, v, result);
       }
-      EXPECT_EQ(INTR(tree_clone.height, t_clone).unsafe_get0(), 1);
+      EXPECT_EQ(INTR(tree_clone.height, t_clone).unsafe_get(), 1);
       EXPECT_EQ(p_dummy->size(), 1);
     });
   }
@@ -604,7 +604,7 @@ class TestTree {
     return seastar::async([this, &key, &value] {
       auto conf = UnboundedBtree::tree_value_config_t{value.get_payload_size()};
       auto [cursor, success] = INTR_R(tree.insert,
-          t, key, conf).unsafe_get0();
+          t, key, conf).unsafe_get();
       initialize_cursor_from_item(t, key, value, cursor, success);
       insert_history.emplace(key, std::make_tuple(value, cursor));
     });
@@ -628,182 +628,182 @@ TEST_F(c_dummy_test_t, 4_split_merge_leaf_node)
   run_async([] {
     {
       TestTree test;
-      test.build_tree({2, 5}, {2, 5}, {2, 5}, 120).get0();
+      test.build_tree({2, 5}, {2, 5}, {2, 5}, 120).get();
 
       auto value = test.create_value(1144);
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 2; insert to left front at stage 2, 1, 0\n");
       test.split_merge(make_ghobj(1, 1, 1, "ns3", "oid3", 3, 3), value,
                        {2u, 2u, true, InsertType::BEGIN},
-                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(2, 2, 2, "ns1", "oid1", 3, 3), value,
                        {2u, 1u, true, InsertType::BEGIN},
-                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(2, 2, 2, "ns2", "oid2", 1, 1), value,
                        {2u, 0u, true, InsertType::BEGIN},
-                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 2; insert to left back at stage 0, 1, 2, 1, 0\n");
       test.split_merge(make_ghobj(2, 2, 2, "ns4", "oid4", 5, 5), value,
                        {2u, 0u, true, InsertType::LAST},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(2, 2, 2, "ns5", "oid5", 3, 3), value,
                        {2u, 1u, true, InsertType::LAST},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(2, 3, 3, "ns3", "oid3", 3, 3), value,
                        {2u, 2u, true, InsertType::LAST},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns1", "oid1", 3, 3), value,
                        {2u, 1u, true, InsertType::LAST},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns2", "oid2", 1, 1), value,
                        {2u, 0u, true, InsertType::LAST},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
 
       auto value0 = test.create_value(1416);
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 2; insert to right front at stage 0, 1, 2, 1, 0\n");
       test.split_merge(make_ghobj(3, 3, 3, "ns4", "oid4", 5, 5), value0,
                        {2u, 0u, false, InsertType::BEGIN},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns5", "oid5", 3, 3), value0,
                        {2u, 1u, false, InsertType::BEGIN},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 4, 4, "ns3", "oid3", 3, 3), value0,
                        {2u, 2u, false, InsertType::BEGIN},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(4, 4, 4, "ns1", "oid1", 3, 3), value0,
                        {2u, 1u, false, InsertType::BEGIN},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(4, 4, 4, "ns2", "oid2", 1, 1), value0,
                        {2u, 0u, false, InsertType::BEGIN},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 2; insert to right back at stage 0, 1, 2\n");
       test.split_merge(make_ghobj(4, 4, 4, "ns4", "oid4", 5, 5), value0,
                        {2u, 0u, false, InsertType::LAST},
-                       std::nullopt).get0();
+                       std::nullopt).get();
       test.split_merge(make_ghobj(4, 4, 4, "ns5", "oid5", 3, 3), value0,
                        {2u, 1u, false, InsertType::LAST},
-                       std::nullopt).get0();
+                       std::nullopt).get();
       test.split_merge(make_ghobj(5, 5, 5, "ns3", "oid3", 3, 3), value0,
                        {2u, 2u, false, InsertType::LAST},
-                       std::nullopt).get0();
+                       std::nullopt).get();
 
       auto value1 = test.create_value(316);
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 1; insert to left middle at stage 0, 1, 2, 1, 0\n");
       test.split_merge(make_ghobj(2, 2, 2, "ns4", "oid4", 5, 5), value1,
                        {1u, 0u, true, InsertType::MID},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(2, 2, 2, "ns5", "oid5", 3, 3), value1,
                        {1u, 1u, true, InsertType::MID},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(2, 2, 3, "ns3", "oid3", 3, 3), value1,
                        {1u, 2u, true, InsertType::MID},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns1", "oid1", 3, 3), value1,
                        {1u, 1u, true, InsertType::MID},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns2", "oid2", 1, 1), value1,
                        {1u, 0u, true, InsertType::MID},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 2, 2)}).get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 1; insert to left back at stage 0, 1, 0\n");
       test.split_merge(make_ghobj(3, 3, 3, "ns2", "oid2", 5, 5), value1,
                        {1u, 0u, true, InsertType::LAST},
-                       {make_ghobj(3, 3, 3, "ns3", "oid3", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns3", "oid3", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns2", "oid3", 3, 3), value1,
                        {1u, 1u, true, InsertType::LAST},
-                       {make_ghobj(3, 3, 3, "ns3", "oid3", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns3", "oid3", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns3", "oid3", 1, 1), value1,
                        {1u, 0u, true, InsertType::LAST},
-                       {make_ghobj(3, 3, 3, "ns3", "oid3", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns3", "oid3", 2, 2)}).get();
 
       auto value2 = test.create_value(452);
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 1; insert to right front at stage 0, 1, 0\n");
       test.split_merge(make_ghobj(3, 3, 3, "ns3", "oid3", 5, 5), value2,
                        {1u, 0u, false, InsertType::BEGIN},
-                       {make_ghobj(3, 3, 3, "ns4", "oid4", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns4", "oid4", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns3", "oid4", 3, 3), value2,
                        {1u, 1u, false, InsertType::BEGIN},
-                       {make_ghobj(3, 3, 3, "ns4", "oid4", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns4", "oid4", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns4", "oid4", 1, 1), value2,
                        {1u, 0u, false, InsertType::BEGIN},
-                       {make_ghobj(3, 3, 3, "ns4", "oid4", 2, 2)}).get0();
+                       {make_ghobj(3, 3, 3, "ns4", "oid4", 2, 2)}).get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 1; insert to right middle at stage 0, 1, 2, 1, 0\n");
       test.split_merge(make_ghobj(3, 3, 3, "ns4", "oid4", 5, 5), value2,
                        {1u, 0u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns5", "oid5", 3, 3), value2,
                        {1u, 1u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 4, "ns3", "oid3", 3, 3), value2,
                        {1u, 2u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(4, 4, 4, "ns1", "oid1", 3, 3), value2,
                        {1u, 1u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(4, 4, 4, "ns2", "oid2", 1, 1), value2,
                        {1u, 0u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
 
       auto value3 = test.create_value(834);
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 0; insert to right middle at stage 0, 1, 2, 1, 0\n");
       test.split_merge(make_ghobj(3, 3, 3, "ns4", "oid4", 5, 5), value3,
                        {0u, 0u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 3, "ns5", "oid5", 3, 3), value3,
                        {0u, 1u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(3, 3, 4, "ns3", "oid3", 3, 3), value3,
                        {0u, 2u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(4, 4, 4, "ns1", "oid1", 3, 3), value3,
                        {0u, 1u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
       test.split_merge(make_ghobj(4, 4, 4, "ns2", "oid2", 1, 1), value3,
                        {0u, 0u, false, InsertType::MID},
-                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(4, 4, 4, "ns2", "oid2", 2, 2)}).get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 0; insert to right front at stage 0\n");
       test.split_merge(make_ghobj(3, 3, 3, "ns4", "oid4", 2, 3), value3,
                        {0u, 0u, false, InsertType::BEGIN},
-                       {make_ghobj(3, 3, 3, "ns4", "oid4", 3, 3)}).get0();
+                       {make_ghobj(3, 3, 3, "ns4", "oid4", 3, 3)}).get();
 
       auto value4 = test.create_value(572);
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 0; insert to left back at stage 0\n");
       test.split_merge(make_ghobj(3, 3, 3, "ns2", "oid2", 3, 4), value4,
                        {0u, 0u, true, InsertType::LAST},
-                       {make_ghobj(3, 3, 3, "ns2", "oid2", 4, 4)}).get0();
+                       {make_ghobj(3, 3, 3, "ns2", "oid2", 4, 4)}).get();
     }
 
     {
       TestTree test;
-      test.build_tree({2, 4}, {2, 4}, {2, 4}, 232).get0();
+      test.build_tree({2, 4}, {2, 4}, {2, 4}, 232).get();
       auto value = test.create_value(1996);
       logger().info("\n---------------------------------------------"
                     "\nsplit at [0, 0, 0]; insert to left front at stage 2, 1, 0\n");
       test.split_merge(make_ghobj(1, 1, 1, "ns3", "oid3", 3, 3), value,
                        {2u, 2u, true, InsertType::BEGIN},
-                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get();
       EXPECT_TRUE(last_split.match_split_pos({0, {0, {0}}}));
       test.split_merge(make_ghobj(2, 2, 2, "ns1", "oid1", 3, 3), value,
                        {2u, 1u, true, InsertType::BEGIN},
-                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get();
       EXPECT_TRUE(last_split.match_split_pos({0, {0, {0}}}));
       test.split_merge(make_ghobj(2, 2, 2, "ns2", "oid2", 1, 1), value,
                        {2u, 0u, true, InsertType::BEGIN},
-                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get0();
+                       {make_ghobj(2, 2, 2, "ns2", "oid2", 2, 2)}).get();
       EXPECT_TRUE(last_split.match_split_pos({0, {0, {0}}}));
     }
 
@@ -815,21 +815,21 @@ TEST_F(c_dummy_test_t, 4_split_merge_leaf_node)
       std::vector<test_item_t> values = {
         test.create_value(1360),
         test.create_value(1632)};
-      test.build_tree(keys, values).get0();
+      test.build_tree(keys, values).get();
       auto value = test.create_value(1640);
       logger().info("\n---------------------------------------------"
                     "\nsplit at [END, END, END]; insert to right at stage 0, 1, 2\n");
       test.split_merge(make_ghobj(3, 3, 3, "ns3", "oid3", 4, 4), value,
                        {0u, 0u, false, InsertType::BEGIN},
-                       std::nullopt).get0();
+                       std::nullopt).get();
       EXPECT_TRUE(last_split.match_split_pos({1, {0, {1}}}));
       test.split_merge(make_ghobj(3, 3, 3, "ns4", "oid4", 3, 3), value,
                        {1u, 1u, false, InsertType::BEGIN},
-                       std::nullopt).get0();
+                       std::nullopt).get();
       EXPECT_TRUE(last_split.match_split_pos({1, {1, {0}}}));
       test.split_merge(make_ghobj(4, 4, 4, "ns3", "oid3", 3, 3), value,
                        {2u, 2u, false, InsertType::BEGIN},
-                       std::nullopt).get0();
+                       std::nullopt).get();
       EXPECT_TRUE(last_split.match_split_pos({2, {0, {0}}}));
     }
   });
@@ -1177,14 +1177,14 @@ class DummyChildPool {
       with_trans_intr(pool_clone.get_context().t, [&] (auto &t) {
         return node_to_split->insert_and_split(
           pool_clone.get_context(), key, pool_clone.splitable_nodes);
-      }).unsafe_get0();
+      }).unsafe_get();
       {
         std::ostringstream oss;
         pool_clone.p_btree->dump(pool_clone.t(), oss);
         logger().info("dump new root:\n{}", oss.str());
       }
       auto &pt = pool_clone.t();
-      EXPECT_EQ(INTR(pool_clone.p_btree->height, pt).unsafe_get0(), 3);
+      EXPECT_EQ(INTR(pool_clone.p_btree->height, pt).unsafe_get(), 3);
       EXPECT_TRUE(last_split.match(expected));
       EXPECT_EQ(pool_clone.p_dummy->size(), 3);
 
@@ -1195,9 +1195,9 @@ class DummyChildPool {
       with_trans_intr(pool_clone.get_context().t, [&] (auto &t) {
         return node_to_split->merge(
           pool_clone.get_context(), std::move(node_to_split));
-      }).unsafe_get0();
+      }).unsafe_get();
       auto &pt2 = pool_clone.t();
-      EXPECT_EQ(INTR(pool_clone.p_btree->height ,pt2).unsafe_get0(), 2);
+      EXPECT_EQ(INTR(pool_clone.p_btree->height ,pt2).unsafe_get(), 2);
       EXPECT_EQ(pool_clone.p_dummy->size(), 1);
     });
   }
@@ -1215,17 +1215,17 @@ class DummyChildPool {
                     pos, node_to_fix->get_name(), key_hobj_t(new_key), expect_split);
       with_trans_intr(pool_clone.get_context().t, [&] (auto &t) {
         return node_to_fix->fix_key(pool_clone.get_context(), new_key);
-      }).unsafe_get0();
+      }).unsafe_get();
       if (expect_split) {
         std::ostringstream oss;
         pool_clone.p_btree->dump(pool_clone.t(), oss);
         logger().info("dump new root:\n{}", oss.str());
         auto &pt = pool_clone.t();
-        EXPECT_EQ(INTR(pool_clone.p_btree->height, pt).unsafe_get0(), 3);
+        EXPECT_EQ(INTR(pool_clone.p_btree->height, pt).unsafe_get(), 3);
         EXPECT_EQ(pool_clone.p_dummy->size(), 3);
       } else {
         auto &pt = pool_clone.t();
-        EXPECT_EQ(INTR(pool_clone.p_btree->height, pt).unsafe_get0(), 2);
+        EXPECT_EQ(INTR(pool_clone.p_btree->height, pt).unsafe_get(), 2);
         EXPECT_EQ(pool_clone.p_dummy->size(), 1);
       }
 
@@ -1234,9 +1234,9 @@ class DummyChildPool {
                     pos, node_to_fix->get_name(), key_hobj_t(old_key));
       with_trans_intr(pool_clone.get_context().t, [&] (auto &t) {
           return node_to_fix->fix_key(pool_clone.get_context(), old_key);
-      }).unsafe_get0();
+      }).unsafe_get();
       auto &pt = pool_clone.t();
-      EXPECT_EQ(INTR(pool_clone.p_btree->height, pt).unsafe_get0(), 2);
+      EXPECT_EQ(INTR(pool_clone.p_btree->height, pt).unsafe_get(), 2);
       EXPECT_EQ(pool_clone.p_dummy->size(), 1);
     });
   }
@@ -1250,7 +1250,7 @@ class DummyChildPool {
     auto &pt = pool_clone.t();
     [[maybe_unused]] auto &tr = t();
     INTR_R(pool_clone.p_btree->test_clone_from,
-      pt, tr, *p_btree).unsafe_get0();
+      pt, tr, *p_btree).unsafe_get();
     pool_clone_in_progress = nullptr;
   }
 
@@ -1331,7 +1331,7 @@ TEST_F(c_dummy_test_t, 5_split_merge_internal_node)
       keys.insert(make_ghobj(5, 5, 5, "ns4", "oid4" + padding_e, 2, 2));
       keys.insert(make_ghobj(5, 5, 5, "ns4", "oid4" + padding_e, 3, 3));
       keys.insert(make_ghobj(5, 5, 5, "ns4", "oid4" + padding_e, 4, 4));
-      pool.build_tree(keys).unsafe_get0();
+      pool.build_tree(keys).unsafe_get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 2; insert to right front at stage 0, 1, 2, 1, 0\n");
@@ -1404,7 +1404,7 @@ TEST_F(c_dummy_test_t, 5_split_merge_internal_node)
       keys.insert(make_ghobj(5, 5, 5, "ns4", "oid4" + padding, 5, 5));
       keys.insert(make_ghobj(5, 5, 5, "ns4", "oid4" + padding, 6, 6));
       keys.insert(make_ghobj(5, 5, 5, "ns4", "oid4" + padding, 7, 7));
-      pool.build_tree(keys).unsafe_get0();
+      pool.build_tree(keys).unsafe_get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 2; insert to left back at stage 0, 1, 2, 1\n");
@@ -1431,7 +1431,7 @@ TEST_F(c_dummy_test_t, 5_split_merge_internal_node)
       keys.insert(make_ghobj(4, 4, 4, "n", "o", 3, 3));
       keys.insert(make_ghobj(5, 5, 5, "ns4", "oid4" + padding, 5, 5));
       keys.insert(make_ghobj(5, 5, 5, "ns4", "oid4" + padding, 6, 6));
-      pool.build_tree(keys).unsafe_get0();
+      pool.build_tree(keys).unsafe_get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 2; insert to left back at stage (0, 1, 2, 1,) 0\n");
@@ -1447,7 +1447,7 @@ TEST_F(c_dummy_test_t, 5_split_merge_internal_node)
       keys.erase(make_ghobj(4, 4, 4, "ns4", "oid4" + padding, 2, 2));
       keys.erase(make_ghobj(4, 4, 4, "ns4", "oid4" + padding, 3, 3));
       keys.erase(make_ghobj(4, 4, 4, "ns4", "oid4" + padding, 4, 4));
-      pool.build_tree(keys).unsafe_get0();
+      pool.build_tree(keys).unsafe_get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 1; insert to right front at stage 0, 1, 0\n");
@@ -1471,7 +1471,7 @@ TEST_F(c_dummy_test_t, 5_split_merge_internal_node)
       keys.insert(make_ghobj(2, 2, 2, "ns2", "oid2" + padding_s, 2, 2));
       keys.insert(make_ghobj(2, 2, 2, "ns2", "oid2" + padding_s, 3, 3));
       keys.insert(make_ghobj(2, 2, 2, "ns2", "oid2" + padding_s, 4, 4));
-      pool.build_tree(keys).unsafe_get0();
+      pool.build_tree(keys).unsafe_get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 1; insert to left back at stage 0, 1\n");
@@ -1502,7 +1502,7 @@ TEST_F(c_dummy_test_t, 5_split_merge_internal_node)
       keys.erase(make_ghobj(4, 4, 4, "ns4", "oid4" + padding, 2, 2));
       keys.erase(make_ghobj(4, 4, 4, "ns4", "oid4" + padding, 3, 3));
       keys.erase(make_ghobj(4, 4, 4, "ns4", "oid4" + padding, 4, 4));
-      pool.build_tree(keys).unsafe_get0();
+      pool.build_tree(keys).unsafe_get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 1; insert to left back at stage (0, 1,) 0\n");
@@ -1517,7 +1517,7 @@ TEST_F(c_dummy_test_t, 5_split_merge_internal_node)
       auto keys = build_key_set({2, 5}, {2, 5}, {2, 5}, padding);
       keys.insert(make_ghobj(5, 5, 5, "ns3", "oid3" + std::string(270, '_'), 3, 3));
       keys.insert(make_ghobj(9, 9, 9, "ns~last", "oid~last", 9, 9));
-      pool.build_tree(keys).unsafe_get0();
+      pool.build_tree(keys).unsafe_get();
 
       logger().info("\n---------------------------------------------"
                     "\nsplit at stage 0; insert to right front at stage 0\n");
@@ -1542,7 +1542,7 @@ TEST_F(c_dummy_test_t, 5_split_merge_internal_node)
       auto keys = build_key_set({2, 5}, {2, 5}, {2, 5}, padding);
       keys.insert(make_ghobj(4, 4, 4, "ns5", "oid5" + padding, 3, 3));
       keys.insert(make_ghobj(9, 9, 9, "ns~last", "oid~last", 9, 9));
-      pool.build_tree(keys).unsafe_get0();
+      pool.build_tree(keys).unsafe_get();
 
       logger().info("\n---------------------------------------------"
                     "\nfix end index from stage 1 to 0, 1, 2\n");
@@ -1649,7 +1649,7 @@ TEST_P(d_seastore_tm_test_t, 6_random_tree_insert_erase)
     {
       auto t = create_read_transaction();
       INTR(tree->validate, *t).unsafe_get();
-      EXPECT_EQ(INTR(tree->height, *t).unsafe_get0(), 1);
+      EXPECT_EQ(INTR(tree->height, *t).unsafe_get(), 1);
     }
 
     if constexpr (!TEST_SEASTORE) {
@@ -1690,8 +1690,8 @@ TEST_P(d_seastore_tm_test_t, 7_tree_insert_erase_eagain)
            return submit_transaction_fut(*t);
          });
        });
-    }).unsafe_get0();
-    epm->run_background_work_until_halt().get0();
+    }).unsafe_get();
+    epm->run_background_work_until_halt().get();
 
     // insert
     logger().warn("start inserting {} kvs ...", kvs.size());
@@ -1710,8 +1710,8 @@ TEST_P(d_seastore_tm_test_t, 7_tree_insert_erase_eagain)
                return submit_transaction_fut(*t);
              });
            });
-        }).unsafe_get0();
-        epm->run_background_work_until_halt().get0();
+        }).unsafe_get();
+        epm->run_background_work_until_halt().get();
         ++iter;
       }
     }
@@ -1719,7 +1719,7 @@ TEST_P(d_seastore_tm_test_t, 7_tree_insert_erase_eagain)
     {
       p_nm->set_generate_eagain(false);
       auto t = create_read_transaction();
-      INTR(tree->get_stats, *t).unsafe_get0();
+      INTR(tree->get_stats, *t).unsafe_get();
       p_nm->set_generate_eagain(true);
     }
 
@@ -1734,7 +1734,7 @@ TEST_P(d_seastore_tm_test_t, 7_tree_insert_erase_eagain)
           auto t = create_read_transaction();
           return INTR_R(tree->validate_one, *t, iter
           ).safe_then([t=std::move(t)]{});
-        }).unsafe_get0();
+        }).unsafe_get();
         ++iter;
       }
     }
@@ -1756,8 +1756,8 @@ TEST_P(d_seastore_tm_test_t, 7_tree_insert_erase_eagain)
                return submit_transaction_fut(*t);
              });
            });
-        }).unsafe_get0();
-        epm->run_background_work_until_halt().get0();
+        }).unsafe_get();
+        epm->run_background_work_until_halt().get();
         ++iter;
       }
       kvs.erase_from_random(kvs.random_begin(), kvs.random_end());
@@ -1766,9 +1766,9 @@ TEST_P(d_seastore_tm_test_t, 7_tree_insert_erase_eagain)
     {
       p_nm->set_generate_eagain(false);
       auto t = create_read_transaction();
-      INTR(tree->get_stats, *t).unsafe_get0();
-      INTR(tree->validate, *t).unsafe_get0();
-      EXPECT_EQ(INTR(tree->height,*t).unsafe_get0(), 1);
+      INTR(tree->get_stats, *t).unsafe_get();
+      INTR(tree->validate, *t).unsafe_get();
+      EXPECT_EQ(INTR(tree->height,*t).unsafe_get(), 1);
     }
 
     // we can adjust EAGAIN_PROBABILITY to get a proper eagain_rate

diff --git a/src/test/crimson/seastore/test_btree_lba_manager.cc b/src/test/crimson/seastore/test_btree_lba_manager.cc
index bb4085ce6878ae484f59b5445238d9c10a5b89e7..fd8e7684e3449f2e267eb23990572e99177827b9 100644 (file)
--- a/src/test/crimson/seastore/test_btree_lba_manager.cc
+++ b/src/test/crimson/seastore/test_btree_lba_manager.cc
@@ -267,7 +267,7 @@ struct lba_btree_test : btree_test_base {
        }).si_then([this, tref=std::move(tref)]() mutable {
          return submit_transaction(std::move(tref));
        });
-      }).unsafe_get0();
+      }).unsafe_get();
   }
 
   template <typename F>
@@ -288,7 +288,7 @@ struct lba_btree_test : btree_test_base {
              );
            });
        });
-      }).unsafe_get0();
+      }).unsafe_get();
   }
 
   static auto get_map_val(extent_len_t len) {
@@ -487,7 +487,7 @@ struct btree_lba_manager_test : btree_test_base {
            }
          });
        });
-      }).unsafe_get0();
+      }).unsafe_get();
     submit_transaction(std::move(t.t)).get();
     test_lba_mappings.swap(t.mappings);
   }
@@ -532,7 +532,7 @@ struct btree_lba_manager_test : btree_test_base {
          [this, &t, hint](auto &extents) {
          return lba_manager->alloc_extents(t, hint, std::move(extents), EXTENT_DEFAULT_REF_COUNT);
        });
-      }).unsafe_get0();
+      }).unsafe_get();
     for (auto &ret : rets) {
       logger().debug("alloc'd: {}", *ret);
       EXPECT_EQ(len, ret->get_length());
@@ -578,7 +578,7 @@ struct btree_lba_manager_test : btree_test_base {
          }
          return Cache::retire_extent_iertr::now();
        });
-      }).unsafe_get0();
+      }).unsafe_get();
     if (target->second.refcount == 0) {
       t.mappings.erase(target);
     }
@@ -601,7 +601,7 @@ struct btree_lba_manager_test : btree_test_base {
        return lba_manager->incref_extent(
          t,
          target->first);
-      }).unsafe_get0().refcount;
+      }).unsafe_get().refcount;
     EXPECT_EQ(refcnt, target->second.refcount);
   }
 
@@ -633,7 +633,7 @@ struct btree_lba_manager_test : btree_test_base {
       *t.t,
       [=, this](auto &t) {
        return lba_manager->check_child_trackers(t);
-      }).unsafe_get0();
+      }).unsafe_get();
     for (auto &&i: t.mappings) {
       auto laddr = i.first;
       auto len = i.second.len;
@@ -643,7 +643,7 @@ struct btree_lba_manager_test : btree_test_base {
        [=, this](auto &t) {
          return lba_manager->get_mappings(
            t, laddr, len);
-       }).unsafe_get0();
+       }).unsafe_get();
       EXPECT_EQ(ret_list.size(), 1);
       auto &ret = *ret_list.begin();
       EXPECT_EQ(i.second.addr, ret->get_val());
@@ -655,7 +655,7 @@ struct btree_lba_manager_test : btree_test_base {
        [=, this](auto &t) {
          return lba_manager->get_mapping(
            t, laddr);
-       }).unsafe_get0();
+       }).unsafe_get();
       EXPECT_EQ(i.second.addr, ret_pin->get_val());
       EXPECT_EQ(laddr, ret_pin->get_key());
       EXPECT_EQ(len, ret_pin->get_length());

diff --git a/src/test/crimson/seastore/test_cbjournal.cc b/src/test/crimson/seastore/test_cbjournal.cc
index 3c7007a5024d820dbee8c979cf318d39d9edeb69..d00a0f42729acdf5a518561d10364a17f378c795 100644 (file)
--- a/src/test/crimson/seastore/test_cbjournal.cc
+++ b/src/test/crimson/seastore/test_cbjournal.cc
@@ -100,12 +100,12 @@ struct entry_validator_t {
       paddr_t paddr = seq.offset.add_offset(offset);
       cursor.seq.offset = paddr;
       auto md = cbj.test_read_validate_record_metadata(
-       cursor, magic).unsafe_get0();
+       cursor, magic).unsafe_get();
       assert(md);
       auto& [header, md_bl] = *md;
       auto dbuf = cbj.read(
        paddr.add_offset(header.mdlength),
-       header.dlength).unsafe_get0();
+       header.dlength).unsafe_get();
 
       bufferlist bl;
       bl.append(md_bl);
@@ -184,7 +184,7 @@ struct cbjournal_test_t : public seastar_test_suite_t, JournalTrimmer
     OrderingHandle handle = get_dummy_ordering_handle();
     auto [addr, w_result] = cbj->submit_record(
          std::move(record),
-         handle).unsafe_get0();
+         handle).unsafe_get();
     entries.back().seq = w_result.start_seq;
     entries.back().entries = 1;
     entries.back().magic = cbj->get_cjs().get_cbj_header().magic;
@@ -314,7 +314,7 @@ struct cbjournal_test_t : public seastar_test_suite_t, JournalTrimmer
     cbj->update_journal_tail(
       seq,
       seq
-    ).get0();
+    ).get();
   }
   void set_written_to(journal_seq_t seq) {
     cbj->set_written_to(seq);
@@ -453,7 +453,7 @@ TEST_F(cbjournal_test_t, boudary_check_verify)
 TEST_F(cbjournal_test_t, update_header)
 {
   run_async([this] {
-    auto [header, _buf] = *(cbj->get_cjs().read_header().unsafe_get0());
+    auto [header, _buf] = *(cbj->get_cjs().read_header().unsafe_get());
     record_t rec {
      { generate_extent(1), generate_extent(2) },
      { generate_delta(20), generate_delta(21) }
@@ -463,10 +463,10 @@ TEST_F(cbjournal_test_t, update_header)
     submit_record(std::move(rec));
 
     update_journal_tail(entries.front().get_abs_addr(), record_total_size);
-    cbj->get_cjs().write_header().unsafe_get0();
-    auto [update_header, update_buf2] = *(cbj->get_cjs().read_header().unsafe_get0());
-    cbj->close().unsafe_get0();
-    replay().unsafe_get0();
+    cbj->get_cjs().write_header().unsafe_get();
+    auto [update_header, update_buf2] = *(cbj->get_cjs().read_header().unsafe_get());
+    cbj->close().unsafe_get();
+    replay().unsafe_get();
 
     ASSERT_EQ(update_header.dirty_tail.offset, update_header.dirty_tail.offset);
   });
@@ -502,8 +502,8 @@ TEST_F(cbjournal_test_t, replay)
        { generate_delta(20), generate_delta(21) }
        });
     ASSERT_TRUE(avail - record_total_size >= get_records_available_size());
-    cbj->close().unsafe_get0();
-    replay().unsafe_get0();
+    cbj->close().unsafe_get();
+    replay().unsafe_get();
   });
 }
 
@@ -531,8 +531,8 @@ TEST_F(cbjournal_test_t, replay_after_reset)
        convert_abs_addr_to_paddr(
          cbj->get_records_start(),
          cbj->get_device_id())});
-    cbj->close().unsafe_get0();
-    replay().unsafe_get0();
+    cbj->close().unsafe_get();
+    replay().unsafe_get();
     ASSERT_EQ(old_written_to, get_written_to());
     ASSERT_EQ(old_used_size,
       get_records_used_size());
@@ -574,9 +574,9 @@ TEST_F(cbjournal_test_t, multiple_submit_at_end)
            writes++;
          }
        });
-      }).get0();
+      }).get();
     auto old_written_to = get_written_to();
-    cbj->close().unsafe_get0();
+    cbj->close().unsafe_get();
     cbj->replay(
       [](const auto &offsets,
             const auto &e,
@@ -585,7 +585,7 @@ TEST_F(cbjournal_test_t, multiple_submit_at_end)
             auto last_modified) {
       return Journal::replay_ertr::make_ready_future<
        std::pair<bool, CachedExtentRef>>(true, nullptr);
-    }).unsafe_get0();
+    }).unsafe_get();
     assert(get_written_to() == old_written_to);
   });
 }

diff --git a/src/test/crimson/seastore/test_collection_manager.cc b/src/test/crimson/seastore/test_collection_manager.cc
index 92770b67d159c8daa071cd307c7caa41349a1ab7..ad77315708d1b5658708b3c01484b6c77ca54caf 100644 (file)
--- a/src/test/crimson/seastore/test_collection_manager.cc
+++ b/src/test/crimson/seastore/test_collection_manager.cc
@@ -35,7 +35,7 @@ namespace {
         std::forward<decltype(args)>(args)...);                                \
       },                                                               \
       root,                                                            \
-      std::forward<Args>(args)...).unsafe_get0();                      \
+      std::forward<Args>(args)...).unsafe_get();                       \
   }
 
 struct collection_manager_test_t :
@@ -74,7 +74,7 @@ struct collection_manager_test_t :
       *tref,
       [this](auto &t) {
        return collection_manager->mkfs(t);
-      }).unsafe_get0();
+      }).unsafe_get();
     submit_transaction(std::move(tref));
     return coll_root;
   }

diff --git a/src/test/crimson/seastore/test_object_data_handler.cc b/src/test/crimson/seastore/test_object_data_handler.cc
index 0e258b9a36ca1825f27f98fc7adfe67a6e825f9c..a9ef6428d6f438e82ca19db044131a0114fa6645 100644 (file)
--- a/src/test/crimson/seastore/test_object_data_handler.cc
+++ b/src/test/crimson/seastore/test_object_data_handler.cc
@@ -145,7 +145,7 @@ struct object_data_handler_test_t:
            offset,
            bl);
        });
-    }).unsafe_get0();
+    }).unsafe_get();
   }
   void write(objaddr_t offset, extent_len_t len, char fill) {
     auto t = create_mutate_transaction();
@@ -171,7 +171,7 @@ struct object_data_handler_test_t:
            },
            offset);
        });
-      }).unsafe_get0();
+      }).unsafe_get();
     }
     size = offset;
   }
@@ -191,7 +191,7 @@ struct object_data_handler_test_t:
         },
         offset,
         len);
-    }).unsafe_get0();
+    }).unsafe_get();
     bufferlist known;
     known.append(
       bufferptr(
@@ -219,14 +219,14 @@ struct object_data_handler_test_t:
     extent_len_t length) {
     auto ret = with_trans_intr(t, [&](auto &t) {
       return tm->get_pins(t, offset, length);
-    }).unsafe_get0();
+    }).unsafe_get();
     return ret;
   }
   std::list<LBAMappingRef> get_mappings(objaddr_t offset, extent_len_t length) {
     auto t = create_mutate_transaction();
     auto ret = with_trans_intr(*t, [&](auto &t) {
       return tm->get_pins(t, offset, length);
-    }).unsafe_get0();
+    }).unsafe_get();
     return ret;
   }
 
@@ -246,7 +246,7 @@ struct object_data_handler_test_t:
     }).handle_error(crimson::ct_error::eagain::handle([] {
       LBAMappingRef t = nullptr;
       return t;
-    }), crimson::ct_error::pass_further_all{}).unsafe_get0();
+    }), crimson::ct_error::pass_further_all{}).unsafe_get();
     EXPECT_TRUE(pin);
     return pin;
   }
@@ -257,7 +257,7 @@ struct object_data_handler_test_t:
     extent_len_t len) {
     auto ext = with_trans_intr(t, [&](auto& trans) {
        return tm->read_extent<ObjectDataBlock>(trans, addr, len);
-       }).unsafe_get0();
+       }).unsafe_get();
     EXPECT_EQ(addr, ext->get_laddr());
     return ext;
   }
@@ -844,7 +844,7 @@ TEST_P(object_data_handler_test_t, overwrite_then_read_within_transaction) {
         },
         base + 4096,
         4096);
-    }).unsafe_get0();
+    }).unsafe_get();
     bufferlist pending;
     pending.append(
       bufferptr(

diff --git a/src/test/crimson/seastore/test_omap_manager.cc b/src/test/crimson/seastore/test_omap_manager.cc
index 3811dc4ac4bc9071fef2b3787cca9fa49797465e..b9072fd7bc47f50c32b1f88eb0f5cf21854a5fec 100644 (file)
--- a/src/test/crimson/seastore/test_omap_manager.cc
+++ b/src/test/crimson/seastore/test_omap_manager.cc
@@ -79,7 +79,7 @@ struct omap_manager_test_t :
       t,
       [&, this](auto &t) {
        return omap_manager->omap_set_key(omap_root, t, key, val);
-      }).unsafe_get0();
+      }).unsafe_get();
     test_omap_mappings[key] = val;
   }
 
@@ -113,7 +113,7 @@ struct omap_manager_test_t :
       t,
       [&, this](auto &t) {
        return omap_manager->omap_get_value(omap_root, t, key);
-      }).unsafe_get0();
+      }).unsafe_get();
     auto iter = test_omap_mappings.find(key);
     if (iter == test_omap_mappings.end()) {
       EXPECT_FALSE(ret);
@@ -133,7 +133,7 @@ struct omap_manager_test_t :
       t,
       [&, this](auto &t) {
        return omap_manager->omap_rm_key(omap_root, t, key);
-      }).unsafe_get0();
+      }).unsafe_get();
     test_omap_mappings.erase(test_omap_mappings.find(key));
   }
 
@@ -152,7 +152,7 @@ struct omap_manager_test_t :
       [&, this](auto &t) {
       return omap_manager->omap_rm_key_range(
        omap_root, t, first, last, config);
-    }).unsafe_get0();
+    }).unsafe_get();
 
     std::vector<std::string> keys;
     size_t count = 0;
@@ -198,7 +198,7 @@ struct omap_manager_test_t :
       t,
       [&, this](auto &t) {
        return omap_manager->omap_list(omap_root, t, first, last, config);
-      }).unsafe_get0();
+      }).unsafe_get();
 
     test_omap_t::iterator it, lit;
     if (first) {
@@ -239,7 +239,7 @@ struct omap_manager_test_t :
       t,
       [&, this](auto &t) {
        return omap_manager->omap_clear(omap_root, t);
-      }).unsafe_get0();
+      }).unsafe_get();
     EXPECT_EQ(omap_root.get_location(), L_ADDR_NULL);
   }
 
@@ -274,7 +274,7 @@ struct omap_manager_test_t :
       *t,
       [this](auto &t) {
        return omap_manager->initialize_omap(t, L_ADDR_MIN);
-      }).unsafe_get0();
+      }).unsafe_get();
     submit_transaction(std::move(t));
     return omap_root;
   }

diff --git a/src/test/crimson/seastore/test_randomblock_manager.cc b/src/test/crimson/seastore/test_randomblock_manager.cc
index 9ddb7f9ad7c3ee7b218fad7e3f0416ae9f2697b0..5940717e69eae022be722250ebdf9fb01d6fd04f 100644 (file)
--- a/src/test/crimson/seastore/test_randomblock_manager.cc
+++ b/src/test/crimson/seastore/test_randomblock_manager.cc
@@ -67,38 +67,38 @@ struct rbm_test_t :
   }
 
   seastar::future<> tear_down_fut() final {
-    rbm_manager->close().unsafe_get0();
-    device->close().unsafe_get0();
+    rbm_manager->close().unsafe_get();
+    device->close().unsafe_get();
     rbm_manager.reset();
     device.reset();
     return seastar::now();
   }
 
   auto mkfs() {
-    return device->mkfs(config).unsafe_get0();
+    return device->mkfs(config).unsafe_get();
   }
 
   auto read_rbm_header() {
-    return device->read_rbm_header(RBM_START_ADDRESS).unsafe_get0();
+    return device->read_rbm_header(RBM_START_ADDRESS).unsafe_get();
   }
 
   auto open() {
-    device->mount().unsafe_get0();
-    return rbm_manager->open().unsafe_get0();
+    device->mount().unsafe_get();
+    return rbm_manager->open().unsafe_get();
   }
 
   auto write(uint64_t addr, bufferptr &ptr) {
     paddr_t paddr = convert_abs_addr_to_paddr(
       addr,
       rbm_manager->get_device_id());
-    return rbm_manager->write(paddr, ptr).unsafe_get0();
+    return rbm_manager->write(paddr, ptr).unsafe_get();
   }
 
   auto read(uint64_t addr, bufferptr &ptr) {
     paddr_t paddr = convert_abs_addr_to_paddr(
       addr,
       rbm_manager->get_device_id());
-    return rbm_manager->read(paddr, ptr).unsafe_get0();
+    return rbm_manager->read(paddr, ptr).unsafe_get();
   }
 
   bufferptr generate_extent(size_t blocks) {
@@ -111,7 +111,7 @@ struct rbm_test_t :
   }
 
   void close() {
-    rbm_manager->close().unsafe_get0();
+    rbm_manager->close().unsafe_get();
     return;
   }
 

diff --git a/src/test/crimson/seastore/test_seastore.cc b/src/test/crimson/seastore/test_seastore.cc
index 1a127214e8f0c98ec968876ab79a176d025a1aa5..7e2ac3ff923f58ff592f8cf95bd15b72516118d5 100644 (file)
--- a/src/test/crimson/seastore/test_seastore.cc
+++ b/src/test/crimson/seastore/test_seastore.cc
@@ -85,13 +85,13 @@ struct seastore_test_t :
   void do_transaction(CTransaction &&t) {
     return sharded_seastore->do_transaction(
       coll,
-      std::move(t)).get0();
+      std::move(t)).get();
   }
 
   void set_meta(
     const std::string& key,
     const std::string& value) {
-    return seastore->write_meta(key, value).get0();
+    return seastore->write_meta(key, value).get();
   }
 
   std::tuple<int, std::string> get_meta(
@@ -120,7 +120,7 @@ struct seastore_test_t :
       touch(t);
       sharded_seastore.do_transaction(
         coll,
-        std::move(t)).get0();
+        std::move(t)).get();
     }
 
     void truncate(
@@ -136,20 +136,20 @@ struct seastore_test_t :
       truncate(t, off);
       sharded_seastore.do_transaction(
         coll,
-        std::move(t)).get0();
+        std::move(t)).get();
     }
 
     std::map<uint64_t, uint64_t> fiemap(
       SeaStoreShard &sharded_seastore,
       uint64_t off,
       uint64_t len) {
-      return sharded_seastore.fiemap(coll, oid, off, len).unsafe_get0();
+      return sharded_seastore.fiemap(coll, oid, off, len).unsafe_get();
     }
 
     bufferlist readv(
       SeaStoreShard &sharded_seastore,
       interval_set<uint64_t>&m) {
-      return sharded_seastore.readv(coll, oid, m).unsafe_get0();
+      return sharded_seastore.readv(coll, oid, m).unsafe_get();
     }
 
     void remove(
@@ -164,7 +164,7 @@ struct seastore_test_t :
       remove(t);
       sharded_seastore.do_transaction(
         coll,
-        std::move(t)).get0();
+        std::move(t)).get();
     }
 
     void set_omap(
@@ -188,7 +188,7 @@ struct seastore_test_t :
       set_omap(t, key, val);
       sharded_seastore.do_transaction(
        coll,
-       std::move(t)).get0();
+       std::move(t)).get();
     }
 
     void write(
@@ -234,7 +234,7 @@ struct seastore_test_t :
       write(sharded_seastore, t, offset, bl);
       sharded_seastore.do_transaction(
        coll,
-       std::move(t)).get0();
+       std::move(t)).get();
     }
 
     void clone(
@@ -246,7 +246,7 @@ struct seastore_test_t :
       t.clone(cid, oid, coid);
       sharded_seastore.do_transaction(
        coll,
-       std::move(t)).get0();
+       std::move(t)).get();
       clone_contents[snap].reserve(contents.length());
       auto it = contents.begin();
       it.copy_all(clone_contents[snap]);
@@ -269,7 +269,7 @@ struct seastore_test_t :
       t.collection_move_rename(cid, oid, cid, other.oid);
       sharded_seastore.do_transaction(
        coll,
-       std::move(t)).get0();
+       std::move(t)).get();
       other.contents = contents;
       other.omap = omap;
       other.clone_contents = clone_contents;
@@ -331,7 +331,7 @@ struct seastore_test_t :
       zero(sharded_seastore, t, offset, len);
       sharded_seastore.do_transaction(
         coll,
-        std::move(t)).get0();
+        std::move(t)).get();
     }
 
     void read(
@@ -349,7 +349,7 @@ struct seastore_test_t :
        coll,
        oid,
        offset,
-       len).unsafe_get0();
+       len).unsafe_get();
       EXPECT_EQ(ret.length(), to_check.length());
       EXPECT_EQ(ret, to_check);
     }
@@ -357,7 +357,7 @@ struct seastore_test_t :
     void check_size(SeaStoreShard &sharded_seastore) {
       auto st = sharded_seastore.stat(
        coll,
-       oid).get0();
+       oid).get();
       EXPECT_EQ(contents.length(), st.st_size);
     }
 
@@ -369,7 +369,7 @@ struct seastore_test_t :
       t.setattr(cid, oid, key, val);
       sharded_seastore.do_transaction(
         coll,
-        std::move(t)).get0();
+        std::move(t)).get();
     }
 
     void rm_attr(
@@ -379,7 +379,7 @@ struct seastore_test_t :
       t.rmattr(cid, oid, key);
       sharded_seastore.do_transaction(
         coll,
-        std::move(t)).get0();
+        std::move(t)).get();
     }
 
     void rm_attrs(
@@ -388,7 +388,7 @@ struct seastore_test_t :
       t.rmattrs(cid, oid);
       sharded_seastore.do_transaction(
         coll,
-        std::move(t)).get0();
+        std::move(t)).get();
     }
 
     SeaStoreShard::attrs_t get_attrs(
@@ -416,7 +416,7 @@ struct seastore_test_t :
       auto result = sharded_seastore.omap_get_values(
        coll,
        oid,
-       to_check).unsafe_get0();
+       to_check).unsafe_get();
       if (result.empty()) {
        EXPECT_EQ(omap.find(key), omap.end());
       } else {
@@ -436,7 +436,7 @@ struct seastore_test_t :
         auto [done, kvs] = sharded_seastore.omap_get_values(
           coll,
           oid,
-          start).unsafe_get0();
+          start).unsafe_get();
         auto iter = kvs.begin();
         while (true) {
          if ((done && iter == kvs.end()) && refiter == omap.end()) {
@@ -495,7 +495,7 @@ struct seastore_test_t :
         coll,
         ghobject_t(),
         ghobject_t::get_max(),
-        std::numeric_limits<uint64_t>::max()).get0();
+        std::numeric_limits<uint64_t>::max()).get();
     EXPECT_EQ(std::get<1>(ret), ghobject_t::get_max());
     EXPECT_EQ(std::get<0>(ret), oids);
   }
@@ -581,7 +581,7 @@ struct seastore_test_t :
 
       // get results from seastore
       auto [listed, next] = sharded_seastore->list_objects(
-       coll, left_bound, right_bound, limit).get0();
+       coll, left_bound, right_bound, limit).get();
 
       // compute correct answer
       auto correct_begin = std::find_if(
@@ -645,13 +645,13 @@ TEST_P(seastore_test_t, collection_create_list_remove)
   run_async([this] {
     coll_t test_coll{spg_t{pg_t{1, 0}}};
     {
-      sharded_seastore->create_new_collection(test_coll).get0();
+      sharded_seastore->create_new_collection(test_coll).get();
       {
        CTransaction t;
        t.create_collection(test_coll, 4);
        do_transaction(std::move(t));
       }
-      auto colls_cores = seastore->list_collections().get0();
+      auto colls_cores = seastore->list_collections().get();
       std::vector<coll_t> colls;
       colls.resize(colls_cores.size());
       std::transform(
@@ -668,7 +668,7 @@ TEST_P(seastore_test_t, collection_create_list_remove)
        t.remove_collection(test_coll);
        do_transaction(std::move(t));
       }
-      auto colls_cores = seastore->list_collections().get0();
+      auto colls_cores = seastore->list_collections().get();
       std::vector<coll_t> colls;
       colls.resize(colls_cores.size());
       std::transform(

diff --git a/src/test/crimson/seastore/test_seastore_cache.cc b/src/test/crimson/seastore/test_seastore_cache.cc
index 87918dbd02e26e1dac5fe39f34dc7f98693d3105..6e24f436b98ea002f80a22edc07a0190c8ca9848 100644 (file)
--- a/src/test/crimson/seastore/test_seastore_cache.cc
+++ b/src/test/crimson/seastore/test_seastore_cache.cc
@@ -153,7 +153,7 @@ TEST_F(cache_test_t, test_addr_fixup)
        0);
       extent->set_contents('c');
       csum = extent->calc_crc32c();
-      submit_transaction(std::move(t)).get0();
+      submit_transaction(std::move(t)).get();
       addr = extent->get_paddr();
     }
     {
@@ -161,7 +161,7 @@ TEST_F(cache_test_t, test_addr_fixup)
       auto extent = get_extent<TestBlockPhysical>(
        *t,
        addr,
-       TestBlockPhysical::SIZE).unsafe_get0();
+       TestBlockPhysical::SIZE).unsafe_get();
       ASSERT_EQ(extent->get_paddr(), addr);
       ASSERT_EQ(extent->calc_crc32c(), csum);
     }
@@ -192,14 +192,14 @@ TEST_F(cache_test_t, test_dirty_extent)
        auto extent = get_extent<TestBlockPhysical>(
          *t,
          reladdr,
-         TestBlockPhysical::SIZE).unsafe_get0();
+         TestBlockPhysical::SIZE).unsafe_get();
        ASSERT_TRUE(extent->is_clean());
        ASSERT_TRUE(extent->is_pending());
        ASSERT_TRUE(extent->get_paddr().is_relative());
        ASSERT_EQ(extent->get_version(), 0);
        ASSERT_EQ(csum, extent->calc_crc32c());
       }
-      submit_transaction(std::move(t)).get0();
+      submit_transaction(std::move(t)).get();
       addr = extent->get_paddr();
     }
     {
@@ -208,12 +208,12 @@ TEST_F(cache_test_t, test_dirty_extent)
       auto extent = get_extent<TestBlockPhysical>(
        *t,
        addr,
-       TestBlockPhysical::SIZE).unsafe_get0();
+       TestBlockPhysical::SIZE).unsafe_get();
       auto t2 = get_transaction();
       auto extent2 = get_extent<TestBlockPhysical>(
        *t2,
        addr,
-       TestBlockPhysical::SIZE).unsafe_get0();
+       TestBlockPhysical::SIZE).unsafe_get();
       ASSERT_EQ(&*extent, &*extent2);
     }
     {
@@ -222,7 +222,7 @@ TEST_F(cache_test_t, test_dirty_extent)
       auto extent = get_extent<TestBlockPhysical>(
        *t,
        addr,
-       TestBlockPhysical::SIZE).unsafe_get0();
+       TestBlockPhysical::SIZE).unsafe_get();
       // duplicate and reset contents
       extent = cache->duplicate_for_write(*t, extent)->cast<TestBlockPhysical>();
       extent->set_contents('c');
@@ -235,7 +235,7 @@ TEST_F(cache_test_t, test_dirty_extent)
        auto extent = get_extent<TestBlockPhysical>(
          *t2,
          addr,
-         TestBlockPhysical::SIZE).unsafe_get0();
+         TestBlockPhysical::SIZE).unsafe_get();
        ASSERT_TRUE(extent->is_clean());
        ASSERT_FALSE(extent->is_pending());
        ASSERT_EQ(addr, extent->get_paddr());
@@ -247,7 +247,7 @@ TEST_F(cache_test_t, test_dirty_extent)
        auto extent = get_extent<TestBlockPhysical>(
          *t,
          addr,
-         TestBlockPhysical::SIZE).unsafe_get0();
+         TestBlockPhysical::SIZE).unsafe_get();
        ASSERT_TRUE(extent->is_dirty());
        ASSERT_TRUE(extent->is_pending());
        ASSERT_EQ(addr, extent->get_paddr());
@@ -255,7 +255,7 @@ TEST_F(cache_test_t, test_dirty_extent)
        ASSERT_EQ(csum2, extent->calc_crc32c());
       }
       // submit transaction
-      submit_transaction(std::move(t)).get0();
+      submit_transaction(std::move(t)).get();
       ASSERT_TRUE(extent->is_dirty());
       ASSERT_EQ(addr, extent->get_paddr());
       ASSERT_EQ(extent->get_version(), 1);
@@ -267,7 +267,7 @@ TEST_F(cache_test_t, test_dirty_extent)
       auto extent = get_extent<TestBlockPhysical>(
        *t,
        addr,
-       TestBlockPhysical::SIZE).unsafe_get0();
+       TestBlockPhysical::SIZE).unsafe_get();
       ASSERT_TRUE(extent->is_dirty());
       ASSERT_EQ(addr, extent->get_paddr());
       ASSERT_EQ(extent->get_version(), 1);

diff --git a/src/test/crimson/seastore/test_seastore_journal.cc b/src/test/crimson/seastore/test_seastore_journal.cc
index a0ff2b2478ee8a96473d8bbc31cf5f5ead969660..2eb791b1d46ab13909c5332bcf836d24b4e75fc4 100644 (file)
--- a/src/test/crimson/seastore/test_seastore_journal.cc
+++ b/src/test/crimson/seastore/test_seastore_journal.cc
@@ -32,7 +32,7 @@ struct record_validator_t {
     for (auto &&block : record.extents) {
       auto test = manager.read(
        record_final_offset.add_relative(addr),
-       block.bl.length()).unsafe_get0();
+       block.bl.length()).unsafe_get();
       addr = addr.add_offset(block.bl.length());
       bufferlist bl;
       bl.push_back(test);
@@ -222,7 +222,7 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider, JournalTrimmer {
        }
        return Journal::replay_ertr::make_ready_future<
          std::pair<bool, CachedExtentRef>>(true, nullptr);
-      }).unsafe_get0();
+      }).unsafe_get();
     ASSERT_EQ(record_iter, records.end());
     for (auto &i : records) {
       i.validate(*segment_manager);
@@ -236,7 +236,7 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider, JournalTrimmer {
     OrderingHandle handle = get_dummy_ordering_handle();
     auto [addr, _] = journal->submit_record(
       std::move(record),
-      handle).unsafe_get0();
+      handle).unsafe_get();
     records.back().record_final_offset = addr;
     return addr;
   }

diff --git a/src/test/crimson/seastore/test_transaction_manager.cc b/src/test/crimson/seastore/test_transaction_manager.cc
index a638896a86e7ddbfee0e60908dce77502022bc48..e0110f96b54012d02604686310b1292f6ed7a9d5 100644 (file)
--- a/src/test/crimson/seastore/test_transaction_manager.cc
+++ b/src/test/crimson/seastore/test_transaction_manager.cc
@@ -400,7 +400,7 @@ struct transaction_manager_test_t :
     char contents) {
     auto extents = with_trans_intr(*(t.t), [&](auto& trans) {
       return tm->alloc_data_extents<TestBlock>(trans, hint, len);
-    }).unsafe_get0();
+    }).unsafe_get();
     assert(extents.size() == 1);
     auto extent = extents.front();
     extent_len_t allocated_len = 0;
@@ -419,7 +419,7 @@ struct transaction_manager_test_t :
     char contents) {
     auto extents = with_trans_intr(*(t.t), [&](auto& trans) {
       return tm->alloc_data_extents<TestBlock>(trans, hint, len);
-    }).unsafe_get0();
+    }).unsafe_get();
     size_t length = 0;
     std::vector<TestBlockRef> exts;
     for (auto &extent : extents) {
@@ -503,7 +503,7 @@ struct transaction_manager_test_t :
 
     auto ext = with_trans_intr(*(t.t), [&](auto& trans) {
       return tm->read_pin<TestBlock>(trans, std::move(pin));
-    }).unsafe_get0();
+    }).unsafe_get();
     EXPECT_EQ(addr, ext->get_laddr());
     return ext;
   }
@@ -517,7 +517,7 @@ struct transaction_manager_test_t :
 
     auto ext = with_trans_intr(*(t.t), [&](auto& trans) {
       return tm->read_extent<TestBlock>(trans, addr, len);
-    }).unsafe_get0();
+    }).unsafe_get();
     EXPECT_EQ(addr, ext->get_laddr());
     return ext;
   }
@@ -540,7 +540,7 @@ struct transaction_manager_test_t :
       crimson::ct_error::assert_all{
        "get_extent got invalid error"
       }
-    ).get0();
+    ).get();
     if (ext) {
       EXPECT_EQ(addr, ext->get_laddr());
     }
@@ -567,7 +567,7 @@ struct transaction_manager_test_t :
       crimson::ct_error::assert_all{
        "get_extent got invalid error"
       }
-    ).get0();
+    ).get();
     if (ext) {
       EXPECT_EQ(addr, ext->get_laddr());
     }
@@ -593,7 +593,7 @@ struct transaction_manager_test_t :
       crimson::ct_error::assert_all{
        "read_pin got invalid error"
       }
-    ).get0();
+    ).get();
     if (ext) {
       if (indirect) {
        EXPECT_EQ(im_addr, ext->get_laddr());
@@ -640,7 +640,7 @@ struct transaction_manager_test_t :
     ceph_assert(test_mappings.contains(offset, t.mapping_delta));
     auto pin = with_trans_intr(*(t.t), [&](auto& trans) {
       return tm->get_pin(trans, offset);
-    }).unsafe_get0();
+    }).unsafe_get();
     EXPECT_EQ(offset, pin->get_key());
     return pin;
   }
@@ -651,7 +651,7 @@ struct transaction_manager_test_t :
     const LBAMapping &mapping) {
     auto pin = with_trans_intr(*(t.t), [&](auto &trans) {
       return tm->clone_pin(trans, offset, mapping);
-    }).unsafe_get0();
+    }).unsafe_get();
     EXPECT_EQ(offset, pin->get_key());
     EXPECT_EQ(mapping.get_key(), pin->get_intermediate_key());
     EXPECT_EQ(mapping.get_key(), pin->get_intermediate_base());
@@ -676,7 +676,7 @@ struct transaction_manager_test_t :
       crimson::ct_error::assert_all{
        "get_extent got invalid error"
       }
-    ).get0();
+    ).get();
     if (pin) {
       EXPECT_EQ(offset, pin->get_key());
     }
@@ -689,7 +689,7 @@ struct transaction_manager_test_t :
 
     auto refcnt = with_trans_intr(*(t.t), [&](auto& trans) {
       return tm->inc_ref(trans, offset);
-    }).unsafe_get0();
+    }).unsafe_get();
     auto check_refcnt = test_mappings.inc_ref(offset, t.mapping_delta);
     EXPECT_EQ(refcnt, check_refcnt);
   }
@@ -700,7 +700,7 @@ struct transaction_manager_test_t :
 
     auto refcnt = with_trans_intr(*(t.t), [&](auto& trans) {
       return tm->remove(trans, offset);
-    }).unsafe_get0();
+    }).unsafe_get();
     auto check_refcnt = test_mappings.dec_ref(offset, t.mapping_delta);
     EXPECT_EQ(refcnt, check_refcnt);
     if (refcnt == 0)
@@ -729,12 +729,12 @@ struct transaction_manager_test_t :
            EXPECT_EQ(l, iter->first);
            ++iter;
          });
-      }).unsafe_get0();
+      }).unsafe_get();
     (void)with_trans_intr(
       *t.t,
       [=, this](auto &t) {
        return lba_manager->check_child_trackers(t);
-      }).unsafe_get0();
+      }).unsafe_get();
   }
 
   bool try_submit_transaction(test_transaction_t t) {
@@ -755,7 +755,7 @@ struct transaction_manager_test_t :
     ).then([this](auto ret) {
       return epm->run_background_work_until_halt(
       ).then([ret] { return ret; });
-    }).get0();
+    }).get();
 
     if (success) {
       test_mappings.consume(t.mapping_delta, write_seq);
@@ -850,7 +850,7 @@ struct transaction_manager_test_t :
            });
          });
        });
-      }).unsafe_get0();
+      }).unsafe_get();
     });
   }
 
@@ -902,7 +902,7 @@ struct transaction_manager_test_t :
               failures += !success;
             }
           });
-        }).get0();
+        }).get();
       replay();
       logger().info("random_writes_concurrent: checking");
       check();
@@ -1126,7 +1126,7 @@ struct transaction_manager_test_t :
     }).handle_error(crimson::ct_error::eagain::handle([] {
       LBAMappingRef t = nullptr;
       return t;
-    }), crimson::ct_error::pass_further_all{}).unsafe_get0();
+    }), crimson::ct_error::pass_further_all{}).unsafe_get();
     if (t.t->is_conflicted()) {
       return nullptr;
     }
@@ -1294,7 +1294,7 @@ struct transaction_manager_test_t :
     }).handle_error(crimson::ct_error::eagain::handle([] {
       return std::make_tuple<LBAMappingRef, TestBlockRef, LBAMappingRef>(
         nullptr, nullptr, nullptr);
-    }), crimson::ct_error::pass_further_all{}).unsafe_get0();
+    }), crimson::ct_error::pass_further_all{}).unsafe_get();
     if (t.t->is_conflicted()) {
       return std::make_tuple<LBAMappingRef, TestBlockRef, LBAMappingRef>(
         nullptr, nullptr, nullptr);
@@ -1603,7 +1603,7 @@ struct transaction_manager_test_t :
          });
        }).handle_exception([](std::exception_ptr e) {
          logger().info("{}", e);
-       }).get0();
+       }).get();
       logger().info("test_remap_pin_concurrent: "
         "early_exit {} conflicted {} success {}",
         early_exit, conflicted, success);
@@ -1719,7 +1719,7 @@ struct transaction_manager_test_t :
          });
        }).handle_exception([](std::exception_ptr e) {
          logger().info("{}", e);
-       }).get0();
+       }).get();
       logger().info("test_overwrite_pin_concurrent: "
         "early_exit {} conflicted {} success {}",
         early_exit, conflicted, success);
@@ -2203,7 +2203,7 @@ TEST_P(tm_single_device_test_t, invalid_lba_mapping_detect)
       pin->maybe_fix_pos();
       auto v = pin->get_logical_extent(*t.t);
       assert(v.has_child());
-      auto extent2 = v.get_child_fut().unsafe_get0();
+      auto extent2 = v.get_child_fut().unsafe_get();
       assert(extent.get() == extent2.get());
       submit_transaction(std::move(t));
     }

diff --git a/src/test/crimson/seastore/transaction_manager_test_state.h b/src/test/crimson/seastore/transaction_manager_test_state.h
index 451d795a317fa5a0379613a303306a7ccaa655ce..105496e50c588b85e6c78e0d63f079d31dd5a564 100644 (file)
--- a/src/test/crimson/seastore/transaction_manager_test_state.h
+++ b/src/test/crimson/seastore/transaction_manager_test_state.h
@@ -219,7 +219,7 @@ protected:
   }
 
   void restart() {
-    restart_fut().get0();
+    restart_fut().get();
   }
 
   seastar::future<> tm_setup() {
@@ -370,8 +370,8 @@ protected:
   }
 
   void submit_transaction(TransactionRef t) {
-    submit_transaction_fut(*t).unsafe_get0();
-    epm->run_background_work_until_halt().get0();
+    submit_transaction_fut(*t).unsafe_get();
+    epm->run_background_work_until_halt().get();
   }
 };
 

diff --git a/src/test/crimson/test_errorator.cc b/src/test/crimson/test_errorator.cc
index 4eccb1a9dcb78b5cb92dbc7cc1c71cbcb97815c2..a7ee0cb35917013cde397c67a3a98cff4854220a 100644 (file)
--- a/src/test/crimson/test_errorator.cc
+++ b/src/test/crimson/test_errorator.cc
@@ -36,7 +36,7 @@ TEST_F(errorator_test_t, basic)
         return ertr::make_ready_future<seastar::stop_iteration>(
           seastar::stop_iteration::yes);
       }
-    }).unsafe_get0();
+    }).unsafe_get();
   });
 }
 
@@ -55,7 +55,7 @@ TEST_F(errorator_test_t, parallel_for_each)
                                       boost::make_counting_iterator(SIZE),
                                       0);
        ASSERT_EQ(*sum, expected);
-      }).unsafe_get0();
+      }).unsafe_get();
   });
 }
 
@@ -67,7 +67,7 @@ TEST_F(errorator_test_t, non_copy_then)
     };
     return create_noncopyable().safe_then([](auto) {
       return ertr::now();
-    }).unsafe_get0();
+    }).unsafe_get();
   });
 }
 
@@ -82,6 +82,6 @@ TEST_F(errorator_test_t, test_futurization)
       return 42;
     }).safe_then([](int life) {
       return ertr::make_ready_future<int>(life);
-    }).unsafe_get0();
+    }).unsafe_get();
   });
 }

diff --git a/src/test/crimson/test_interruptible_future.cc b/src/test/crimson/test_interruptible_future.cc
index 3be558b4df65ba557df2132af23dc75e474f9244..9f6b960c9ef92560a2eea98976669977434ecc97 100644 (file)
--- a/src/test/crimson/test_interruptible_future.cc
+++ b/src/test/crimson/test_interruptible_future.cc
@@ -67,7 +67,7 @@ TEST_F(seastar_test_suite_t, basic)
          return seastar::now();
          })
        );
-      }, [](std::exception_ptr) {}, false).get0();
+      }, [](std::exception_ptr) {}, false).get();
 
     interruptor::with_interruption(
       [] {
@@ -79,7 +79,7 @@ TEST_F(seastar_test_suite_t, basic)
       }, [](std::exception_ptr) {
        ceph_assert(!interruptible::interrupt_cond<TestInterruptCondition>.interrupt_cond);
        return seastar::now();
-      }, true).get0();
+      }, true).get();
 
 
   });
@@ -177,7 +177,7 @@ TEST_F(seastar_test_suite_t, loops)
          ceph_assert(interruptible::interrupt_cond<TestInterruptCondition>.interrupt_cond);
          return seastar::now();
        });
-      }, [](std::exception_ptr) {}, false).get0();
+      }, [](std::exception_ptr) {}, false).get();
   });
 }
 
@@ -208,7 +208,7 @@ TEST_F(seastar_test_suite_t, errorated)
        return base_iertr::now();
       }
     );
-    ret.unsafe_get0();
+    ret.unsafe_get();
   });
 }
 
@@ -221,7 +221,7 @@ TEST_F(seastar_test_suite_t, errorated_value)
          1
        );
       });
-    EXPECT_EQ(ret.unsafe_get0(), 1);
+    EXPECT_EQ(ret.unsafe_get(), 1);
   });
 }
 
@@ -236,7 +236,7 @@ TEST_F(seastar_test_suite_t, expand_errorated_value)
          return base2_iertr::make_ready_future<>();
        });
       });
-    ret.unsafe_get0();
+    ret.unsafe_get();
   });
 }
 
@@ -260,7 +260,7 @@ TEST_F(seastar_test_suite_t, interruptible_async)
       ceph_assert(interruptible::interrupt_cond<
        TestInterruptCondition>.ref_count == 1);
       return fut;
-    }, [](std::exception_ptr) {}, false).get0();
+    }, [](std::exception_ptr) {}, false).get();
   });
 }
 
@@ -278,7 +278,7 @@ TEST_F(seastar_test_suite_t, DISABLED_nested_interruptors)
         });
       }
     );
-    ret.unsafe_get0();
+    ret.unsafe_get();
   });
 }
 
@@ -298,7 +298,7 @@ TEST_F(seastar_test_suite_t, handle_error)
          return base_iertr::now();
        });
       });
-    ret.unsafe_get0();
+    ret.unsafe_get();
   });
 }
 #endif