From 8d727701a472777926ef5cb82d8938c68505b11b Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 15:10:22 +0300 Subject: [PATCH 01/16] test: Remove vector of mutation interposer from test_key_count_estimation The test generates a vector of mutation to be later passed into make_sstable() helper which just applies them to memtable. The test case can generate memtable directly. This makes it possible to stop using the local tempdir in this test case by future patches. Signed-off-by: Pavel Emelyanov --- test/boost/sstable_mutation_test.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/boost/sstable_mutation_test.cc b/test/boost/sstable_mutation_test.cc index ae8289eff2..de2996a371 100644 --- a/test/boost/sstable_mutation_test.cc +++ b/test/boost/sstable_mutation_test.cc @@ -1309,15 +1309,15 @@ SEASTAR_TEST_CASE(test_key_count_estimation) { int count = 10'000; std::vector all_pks = tests::generate_partition_keys(count + 2, s, local_shard_only::yes, tests::key_size{8, 8}); std::vector pks(all_pks.begin() + 1, all_pks.end() - 1); - std::vector muts; + auto mt = make_lw_shared(s); for (auto pk : pks) { mutation m(s, pk); m.set_clustered_cell(clustering_key::make_empty(), bytes("v"), data_value(int32_t(1)), 1 /* ts */); - muts.push_back(std::move(m)); + mt->apply(m); } tmpdir dir; - shared_sstable sst = make_sstable(env, s, dir.path().string(), muts, env.manager().configure_writer(), version); + shared_sstable sst = make_sstable_easy(env, dir.path(), mt, env.manager().configure_writer(), 1, version, pks.size()); auto max_est = sst->get_estimated_key_count(); testlog.trace("count = {}", count); From 090e007e3067a476d21deb851c02ccc93014c209 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 14:37:47 +0300 Subject: [PATCH 02/16] test/lib: Open-code make_sstabl_easy into make_sstable The former helper is going to get rid of the fs::path& dir argument, but the latter cannot yet live without it. The simplest solution is to open-code the helper until better times. Signed-off-by: Pavel Emelyanov --- test/lib/sstable_utils.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/test/lib/sstable_utils.cc b/test/lib/sstable_utils.cc index 789b4be4fb..badc234144 100644 --- a/test/lib/sstable_utils.cc +++ b/test/lib/sstable_utils.cc @@ -77,7 +77,11 @@ shared_sstable make_sstable(sstables::test_env& env, schema_ptr s, sstring dir, mt->apply(m); } - return make_sstable_easy(env, dir_path, mt, cfg, 1, version, mutations.size(), query_time); + auto sst = env.make_sstable(s, dir_path.string(), 1, version, sstable_format_types::big, default_sstable_buffer_size, query_time); + auto mr = mt->make_flat_reader(s, env.make_reader_permit()); + sst->write_components(std::move(mr), mutations.size(), s, cfg, mt->get_encoding_stats()).get(); + sst->load().get(); + return sst; } shared_sstable make_sstable_easy(test_env& env, const fs::path& path, flat_mutation_reader_v2 rd, sstable_writer_config cfg, From 21e70e7edd73ce24dab413e2d883a68876b1e691 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 11:03:56 +0300 Subject: [PATCH 03/16] test/lib: Add tempdir sweeper This is a RAII-sh helper that cleans temp directory on destruction. To be used in cases when a test needs to do several checks over clean temporary directory (future patches). Signed-off-by: Pavel Emelyanov --- test/lib/tmpdir.cc | 9 +++++++++ test/lib/tmpdir.hh | 8 ++++++++ 2 files changed, 17 insertions(+) diff --git a/test/lib/tmpdir.cc b/test/lib/tmpdir.cc index 0bfaf5c354..0a248b9efb 100644 --- a/test/lib/tmpdir.cc +++ b/test/lib/tmpdir.cc @@ -21,6 +21,15 @@ void tmpdir::remove() noexcept { } } +tmpdir::sweeper::~sweeper() { + memory::scoped_critical_alloc_section dfg; + if (!_tmpd._path.empty()) { + for (const auto& ent : fs::directory_iterator(_tmpd._path)) { + fs::remove_all(ent.path()); + } + } +} + tmpdir::tmpdir() : _path(fs::temp_directory_path() / fs::path(fmt::format(FMT_STRING("scylla-{}"), utils::make_random_uuid()))) { fs::create_directories(_path); diff --git a/test/lib/tmpdir.hh b/test/lib/tmpdir.hh index 5c099acb4b..807ebe3245 100644 --- a/test/lib/tmpdir.hh +++ b/test/lib/tmpdir.hh @@ -24,6 +24,13 @@ class tmpdir { private: void remove() noexcept; + class sweeper { + const tmpdir& _tmpd; + public: + sweeper(const tmpdir& t) noexcept : _tmpd(t) {} + ~sweeper(); + }; + public: tmpdir(); @@ -35,4 +42,5 @@ public: ~tmpdir(); const fs::path& path() const noexcept { return _path; } + sweeper make_sweeper() const noexcept { return sweeper(*this); } }; From 904853cd7b9bf90f0f58ce67990e1cc6d78bed88 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 11:05:32 +0300 Subject: [PATCH 04/16] test,sstables: Use sstables::test_env's tempdir The one is maintained by the env throughout its lifetime. For many test cases there's no point in generating tempdir on their own, so just switch to using env's one. The code gets longer lines, but this is going to change really soon. Signed-off-by: Pavel Emelyanov --- test/boost/schema_changes_test.cc | 7 +- test/boost/sstable_compaction_test.cc | 185 +++++++++++--------------- test/boost/sstable_datafile_test.cc | 94 ++++++------- test/boost/sstable_mutation_test.cc | 46 +++---- 4 files changed, 132 insertions(+), 200 deletions(-) diff --git a/test/boost/schema_changes_test.cc b/test/boost/schema_changes_test.cc index 33bad7b0b5..e5b0835bb3 100644 --- a/test/boost/schema_changes_test.cc +++ b/test/boost/schema_changes_test.cc @@ -23,7 +23,6 @@ using namespace std::chrono_literals; SEASTAR_TEST_CASE(test_schema_changes) { return sstables::test_env::do_with_async([] (sstables::test_env& env) { - auto dir = tmpdir(); int gen = 1; std::map, std::tuple> cache; @@ -40,9 +39,9 @@ SEASTAR_TEST_CASE(test_schema_changes) { mt->apply(m); } - created_with_base_schema = make_sstable_easy(env, dir.path(), mt, env.manager().configure_writer(), gen, version, base_mutations.size()); + created_with_base_schema = make_sstable_easy(env, env.tempdir().path(), mt, env.manager().configure_writer(), gen, version, base_mutations.size()); - created_with_changed_schema = env.make_sstable(changed, dir.path().string(), gen, version, sstables::sstable::format_types::big); + created_with_changed_schema = env.make_sstable(changed, env.tempdir().path().string(), gen, version, sstables::sstable::format_types::big); created_with_changed_schema->load().get(); cache.emplace(std::tuple { version, base }, std::tuple { created_with_base_schema, gen }); @@ -50,7 +49,7 @@ SEASTAR_TEST_CASE(test_schema_changes) { } else { created_with_base_schema = std::get(it->second); - created_with_changed_schema = env.make_sstable(changed, dir.path().string(), std::get(it->second), version, sstables::sstable::format_types::big); + created_with_changed_schema = env.make_sstable(changed, env.tempdir().path().string(), std::get(it->second), version, sstables::sstable::format_types::big); created_with_changed_schema->load().get(); } diff --git a/test/boost/sstable_compaction_test.cc b/test/boost/sstable_compaction_test.cc index 54b90939ec..e40ae0cfa2 100644 --- a/test/boost/sstable_compaction_test.cc +++ b/test/boost/sstable_compaction_test.cc @@ -154,8 +154,7 @@ SEASTAR_TEST_CASE(compaction_manager_basic_test) { auto s = make_shared_schema({}, some_keyspace, some_column_family, {{"p1", utf8_type}}, {{"c1", utf8_type}}, {{"r1", int32_type}}, {}, utf8_type); - auto tmp = tmpdir(); - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto& cm = cf.get_compaction_manager(); auto close_cf = deferred_stop(cf); cf->set_compaction_strategy(sstables::compaction_strategy_type::size_tiered); @@ -176,7 +175,7 @@ SEASTAR_TEST_CASE(compaction_manager_basic_test) { m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), column_family_test::calculate_generation_for_new_table(*cf), sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), column_family_test::calculate_generation_for_new_table(*cf), sstables::get_highest_sstable_version(), big); write_memtable_to_sstable_for_test(*mt, sst).get(); sst->load().get(); @@ -1000,9 +999,8 @@ SEASTAR_TEST_CASE(tombstone_purge_test) { builder.set_gc_grace_seconds(0); auto s = builder.build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto compact = [&, s] (std::vector all, std::vector to_compact) -> std::vector { @@ -1359,11 +1357,10 @@ SEASTAR_TEST_CASE(compaction_with_fully_expired_table) { builder.set_gc_grace_seconds(0); auto s = builder.build(); - auto tmp = tmpdir(); auto key = partition_key::from_exploded(*s, {to_bytes("key1")}); auto c_key = clustering_key_prefix::from_exploded(*s, {to_bytes("c1")}); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto mt = make_lw_shared(s); @@ -1373,7 +1370,7 @@ SEASTAR_TEST_CASE(compaction_with_fully_expired_table) { mt->apply(std::move(m)); auto sst = sst_gen(); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 1).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 1).get0(); table_for_tests cf(env.manager(), s); auto close_cf = deferred_stop(cf); @@ -1557,9 +1554,8 @@ SEASTAR_TEST_CASE(time_window_strategy_correctness_test) { .with_column("id", utf8_type, column_kind::partition_key) .with_column("value", int32_type).build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (partition_key key, api::timestamp_type t) { @@ -1659,9 +1655,8 @@ SEASTAR_TEST_CASE(time_window_strategy_size_tiered_behavior_correctness) { .with_column("id", utf8_type, column_kind::partition_key) .with_column("value", int32_type).build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (partition_key key, api::timestamp_type t) { @@ -1757,7 +1752,6 @@ SEASTAR_TEST_CASE(min_max_clustering_key_test_2) { .build(); table_for_tests cf(env.manager(), s); auto close_cf = deferred_stop(cf); - auto tmp = tmpdir(); auto mt = make_lw_shared(s); const column_definition &r1_col = *s->get_column_definition("r1"); @@ -1770,9 +1764,9 @@ SEASTAR_TEST_CASE(min_max_clustering_key_test_2) { } mt->apply(std::move(m)); } - auto sst = env.make_sstable(s, tmp.path().string(), 1, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 1, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); check_min_max_column_names(sst, {"0ck100"}, {"7ck149"}); mt = make_lw_shared(s); @@ -1783,12 +1777,12 @@ SEASTAR_TEST_CASE(min_max_clustering_key_test_2) { m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); } mt->apply(std::move(m)); - auto sst2 = env.make_sstable(s, tmp.path().string(), 2, version, big); + auto sst2 = env.make_sstable(s, env.tempdir().path().string(), 2, version, big); write_memtable_to_sstable_for_test(*mt, sst2).get(); - sst2 = env.reusable_sst(s, tmp.path().string(), 2, version).get0(); + sst2 = env.reusable_sst(s, env.tempdir().path().string(), 2, version).get0(); check_min_max_column_names(sst2, {"9ck101"}, {"9ck298"}); - auto creator = [&env, s, &tmp, version] { return env.make_sstable(s, tmp.path().string(), 3, version, big); }; + auto creator = [&env, s, version] { return env.make_sstable(s, env.tempdir().path().string(), 3, version, big); }; auto info = compact_sstables(sstables::compaction_descriptor({sst, sst2}, default_priority_class()), cf, creator).get0(); BOOST_REQUIRE(info.new_sstables.size() == 1); check_min_max_column_names(info.new_sstables.front(), {"0ck100"}, {"9ck298"}); @@ -1818,7 +1812,6 @@ SEASTAR_TEST_CASE(size_tiered_beyond_max_threshold_test) { SEASTAR_TEST_CASE(sstable_expired_data_ratio) { return test_env::do_with_async([] (test_env& env) { - auto tmp = tmpdir(); auto s = make_shared_schema({}, some_keyspace, some_column_family, {{"p1", utf8_type}}, {{"c1", utf8_type}}, {{"r1", utf8_type}}, {}, utf8_type); @@ -1849,9 +1842,9 @@ SEASTAR_TEST_CASE(sstable_expired_data_ratio) { for (auto i = 0; i < remaining; i++) { insert_key(to_bytes("key" + to_sstring(i)), 3600, expiration_time); } - auto sst = env.make_sstable(s, tmp.path().string(), 1, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 1).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 1).get0(); const auto& stats = sst->get_stats_metadata(); BOOST_REQUIRE(stats.estimated_tombstone_drop_time.bin.size() == sstables::TOMBSTONE_HISTOGRAM_BIN_SIZE); auto gc_before = gc_clock::now() - s->gc_grace_seconds(); @@ -1865,7 +1858,7 @@ SEASTAR_TEST_CASE(sstable_expired_data_ratio) { table_for_tests cf(env.manager(), s); auto close_cf = deferred_stop(cf); auto creator = [&, gen = make_lw_shared(2)] { - auto sst = env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; auto info = compact_sstables(sstables::compaction_descriptor({ sst }, default_priority_class()), cf, creator).get0(); @@ -1930,9 +1923,8 @@ SEASTAR_TEST_CASE(compaction_correctness_with_partitioned_sstable_set) { builder.set_compaction_strategy(sstables::compaction_strategy_type::leveled); auto s = builder.build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - auto sst = env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + auto sst = env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; @@ -2038,9 +2030,8 @@ SEASTAR_TEST_CASE(sstable_cleanup_correctness_test) { .with_column("id", utf8_type, column_kind::partition_key) .with_column("value", int32_type).build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (dht::decorated_key key) { @@ -2058,7 +2049,7 @@ SEASTAR_TEST_CASE(sstable_cleanup_correctness_test) { auto sst = make_sstable_containing(sst_gen, mutations); auto run_identifier = sst->run_identifier(); - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); cf->start(); @@ -2186,9 +2177,8 @@ SEASTAR_TEST_CASE(sstable_scrub_validate_mode_test) { .with_column("v", int32_type).build(); auto permit = env.make_reader_permit(); - auto tmp = tmpdir(); - auto sst_gen = [&env, schema, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, tmp.path().string(), (*gen)++); + auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(schema, env.tempdir().path().string(), (*gen)++); }; auto scrubbed_mt = make_lw_shared(schema); @@ -2208,7 +2198,7 @@ SEASTAR_TEST_CASE(sstable_scrub_validate_mode_test) { testlog.info("Loaded sstable {}", sst->get_filename()); - table_for_tests table(env.manager(), schema, tmp.path().string()); + table_for_tests table(env.manager(), schema, env.tempdir().path().string()); auto close_cf = deferred_stop(table); table->start(); @@ -2384,9 +2374,8 @@ SEASTAR_TEST_CASE(sstable_scrub_skip_mode_test) { .with_column("v", int32_type).build(); auto permit = env.make_reader_permit(); - auto tmp = tmpdir(); - auto sst_gen = [&env, schema, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, tmp.path().string(), (*gen)++); + auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(schema, env.tempdir().path().string(), (*gen)++); }; std::vector scrubbed_fragments; @@ -2404,7 +2393,7 @@ SEASTAR_TEST_CASE(sstable_scrub_skip_mode_test) { testlog.info("Loaded sstable {}", sst->get_filename()); - table_for_tests table(env.manager(), schema, tmp.path().string()); + table_for_tests table(env.manager(), schema, env.tempdir().path().string()); auto close_cf = deferred_stop(table); table->start(); auto& compaction_manager = table.get_compaction_manager(); @@ -2478,9 +2467,8 @@ SEASTAR_TEST_CASE(sstable_scrub_segregate_mode_test) { .with_column("v", int32_type).build(); auto permit = env.make_reader_permit(); - auto tmp = tmpdir(); - auto sst_gen = [&env, schema, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, tmp.path().string(), (*gen)++); + auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(schema, env.tempdir().path().string(), (*gen)++); }; auto scrubbed_mt = make_lw_shared(schema); @@ -2500,7 +2488,7 @@ SEASTAR_TEST_CASE(sstable_scrub_segregate_mode_test) { testlog.info("Loaded sstable {}", sst->get_filename()); - table_for_tests table(env.manager(), schema, tmp.path().string()); + table_for_tests table(env.manager(), schema, env.tempdir().path().string()); auto close_cf = deferred_stop(table); table->start(); auto& compaction_manager = table.get_compaction_manager(); @@ -2589,9 +2577,8 @@ SEASTAR_TEST_CASE(sstable_scrub_quarantine_mode_test) { .with_column("v", int32_type).build(); auto permit = env.make_reader_permit(); - auto tmp = tmpdir(); - auto sst_gen = [&env, schema, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, tmp.path().string(), (*gen)++); + auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(schema, env.tempdir().path().string(), (*gen)++); }; auto scrubbed_mt = make_lw_shared(schema); @@ -2611,7 +2598,7 @@ SEASTAR_TEST_CASE(sstable_scrub_quarantine_mode_test) { testlog.info("Loaded sstable {}", sst->get_filename()); - table_for_tests table(env.manager(), schema, tmp.path().string()); + table_for_tests table(env.manager(), schema, env.tempdir().path().string()); auto close_cf = deferred_stop(table); table->start(); auto& compaction_manager = table.get_compaction_manager(); @@ -2937,9 +2924,8 @@ SEASTAR_TEST_CASE(sstable_run_based_compaction_test) { .with_column("value", int32_type); auto s = builder.build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - auto sst = env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + auto sst = env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; @@ -3067,9 +3053,8 @@ SEASTAR_TEST_CASE(compaction_strategy_aware_major_compaction_test) { .with_column("id", utf8_type, column_kind::partition_key) .with_column("value", int32_type).build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (partition_key key) { mutation m(s, key); @@ -3112,9 +3097,8 @@ SEASTAR_TEST_CASE(backlog_tracker_correctness_after_changing_compaction_strategy .with_column("value", int32_type); auto s = builder.build(); - auto tmp = make_lw_shared(); - auto sst_gen = [&env, s, tmp, gen = make_lw_shared(1)] () mutable { - auto sst = env.make_sstable(s, tmp->path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + auto sst = env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; @@ -3169,9 +3153,7 @@ SEASTAR_TEST_CASE(partial_sstable_run_filtered_out_test) { .with_column("id", utf8_type, column_kind::partition_key) .with_column("value", int32_type).build(); - auto tmp = tmpdir(); - - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); cf->start(); @@ -3181,7 +3163,7 @@ SEASTAR_TEST_CASE(partial_sstable_run_filtered_out_test) { sstable_writer_config sst_cfg = env.manager().configure_writer(); sst_cfg.run_identifier = partial_sstable_run_identifier; - auto partial_sstable_run_sst = make_sstable_easy(env, tmp.path(), make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), { std::move(mut) }), sst_cfg); + auto partial_sstable_run_sst = make_sstable_easy(env, env.tempdir().path(), make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), { std::move(mut) }), sst_cfg); column_family_test(cf).add_sstable(partial_sstable_run_sst).get(); column_family_test::update_sstables_known_generation(*cf, generation_value(partial_sstable_run_sst->generation())); @@ -3216,9 +3198,8 @@ SEASTAR_TEST_CASE(purged_tombstone_consumer_sstable_test) { builder.set_gc_grace_seconds(0); auto s = builder.build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; class compacting_sstable_writer_test { @@ -3373,9 +3354,8 @@ SEASTAR_TEST_CASE(incremental_compaction_data_resurrection_test) { builder.set_gc_grace_seconds(0); auto s = builder.build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto next_timestamp = [] { @@ -3420,7 +3400,7 @@ SEASTAR_TEST_CASE(incremental_compaction_data_resurrection_test) { // make mut1_deletion gc'able. forward_jump_clocks(std::chrono::seconds(ttl)); - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); cf->start(); cf->set_compaction_strategy(sstables::compaction_strategy_type::null); @@ -3492,9 +3472,8 @@ SEASTAR_TEST_CASE(twcs_major_compaction_test) { .with_column("value", int32_type); auto s = builder.build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto next_timestamp = [] (auto step) { @@ -3523,7 +3502,7 @@ SEASTAR_TEST_CASE(twcs_major_compaction_test) { auto mut3 = make_insert(0ms); auto mut4 = make_insert(1ms); - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); cf->start(); cf->set_compaction_strategy(sstables::compaction_strategy_type::time_window); @@ -3546,8 +3525,7 @@ SEASTAR_TEST_CASE(autocompaction_control_test) { .with_column("value", int32_type) .build(); - auto tmp = tmpdir(); - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto& cm = cf.get_compaction_manager(); auto close_cf = deferred_stop(cf); cf->set_compaction_strategy(sstables::compaction_strategy_type::size_tiered); @@ -3563,8 +3541,8 @@ SEASTAR_TEST_CASE(autocompaction_control_test) { BOOST_REQUIRE(cf->is_auto_compaction_disabled_by_user()); // generate a few sstables - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (const dht::decorated_key& key) { mutation m(s, key); @@ -3914,9 +3892,8 @@ SEASTAR_TEST_CASE(test_twcs_compaction_across_buckets) { auto next_timestamp = [] (std::chrono::hours step = std::chrono::hours(0)) { return (gc_clock::now().time_since_epoch() - std::chrono::duration_cast(step)).count(); }; - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto pkey = tests::generate_partition_key(s); @@ -4044,10 +4021,8 @@ SEASTAR_TEST_CASE(twcs_reshape_with_disjoint_set_test) { return m; }; - auto tmp = tmpdir(); - - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)]() { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::sstable::version_types::md, big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::sstable::version_types::md, big); }; { @@ -4181,10 +4156,8 @@ SEASTAR_TEST_CASE(stcs_reshape_overlapping_test) { return m; }; - auto tmp = tmpdir(); - - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)]() { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::sstable::version_types::md, big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::sstable::version_types::md, big); }; { @@ -4225,9 +4198,8 @@ SEASTAR_TEST_CASE(test_twcs_single_key_reader_filtering) { builder.set_compaction_strategy(sstables::compaction_strategy_type::time_window); auto s = builder.build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)]() { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::sstable::version_types::md, big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::sstable::version_types::md, big); }; auto make_row = [&] (int32_t pk, int32_t ck) { @@ -4240,7 +4212,7 @@ SEASTAR_TEST_CASE(test_twcs_single_key_reader_filtering) { auto sst2 = make_sstable_containing(sst_gen, {make_row(0, 1)}); auto dkey = sst1->get_first_decorated_key(); - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); cf->start(); @@ -4304,7 +4276,6 @@ SEASTAR_TEST_CASE(max_ongoing_compaction_test) { auto cm = compaction_manager_for_testing(); - auto tmp = tmpdir(); auto cl_stats = make_lw_shared(); auto tracker = make_lw_shared(); @@ -4338,7 +4309,7 @@ SEASTAR_TEST_CASE(max_ongoing_compaction_test) { schemas.push_back(s); replica::column_family::config cfg = env.make_table_config(); - cfg.datadir = tmp.path().string() + "/" + std::to_string(idx); + cfg.datadir = env.tempdir().path().string() + "/" + std::to_string(idx); touch_directory(cfg.datadir).get(); cfg.enable_commitlog = false; cfg.enable_incremental_backups = false; @@ -4551,16 +4522,15 @@ SEASTAR_TEST_CASE(twcs_single_key_reader_through_compound_set_test) { return m; }; - auto tmp = tmpdir(); - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); cf->start(); auto set1 = make_lw_shared(cs.make_sstable_set(s)); auto set2 = make_lw_shared(cs.make_sstable_set(s)); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)]() { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::sstable::version_types::md, big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::sstable::version_types::md, big); }; // sstables with same key but belonging to different windows @@ -4597,13 +4567,12 @@ SEASTAR_TEST_CASE(test_major_does_not_miss_data_in_memtable) { .with_column("value", int32_type); auto s = builder.build(); - auto tmp = tmpdir(); auto pkey = tests::generate_partition_key(s); - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); - auto sst_gen = [&env, &cf, s, &tmp] () mutable { - return env.make_sstable(s, tmp.path().string(), column_family_test::calculate_generation_for_new_table(*cf), + auto sst_gen = [&env, &cf, s] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), column_family_test::calculate_generation_for_new_table(*cf), sstables::get_highest_sstable_version(), big); }; @@ -4859,9 +4828,8 @@ SEASTAR_TEST_CASE(test_large_partition_splitting_on_compaction) { auto next_timestamp = [] (std::chrono::seconds step = 0s) { return (gc_clock::now().time_since_epoch() + duration_cast(step)).count(); }; - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto pkey = tests::generate_partition_key(s); table_for_tests cf(env.manager(), s); @@ -4931,7 +4899,7 @@ SEASTAR_TEST_CASE(test_large_partition_splitting_on_compaction) { position_in_partition::tri_compare pos_tri_cmp(*s); for (auto& sst : ret.new_sstables) { - sst = env.reusable_sst(s, tmp.path().string(), sst->generation().value()).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), sst->generation().value()).get0(); BOOST_REQUIRE(sst->may_have_partition_tombstones()); auto reader = sstable_reader(sst, s, env.make_reader_permit()); @@ -4987,9 +4955,8 @@ SEASTAR_TEST_CASE(check_table_sstable_set_includes_maintenance_sstables) { simple_schema ss; auto s = ss.schema(); auto pks = ss.make_pkeys(1); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp] () { - return env.make_sstable(s, tmp.path().string(), 1, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s] () { + return env.make_sstable(s, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); }; auto mut1 = mutation(s, pks[0]); diff --git a/test/boost/sstable_datafile_test.cc b/test/boost/sstable_datafile_test.cc index 22eed87089..a56fa9d036 100644 --- a/test/boost/sstable_datafile_test.cc +++ b/test/boost/sstable_datafile_test.cc @@ -1931,14 +1931,13 @@ SEASTAR_TEST_CASE(test_repeated_tombstone_skipping) { ++seq; } - tmpdir dir; sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 100; auto mut = mutation(table.schema(), table.make_pkey("key")); for (auto&& mf : fragments) { mut.apply(mf); } - auto sst = make_sstable_easy(env, dir.path(), make_flat_mutation_reader_from_mutations_v2(table.schema(), std::move(permit), { std::move(mut) }), cfg, 1, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), make_flat_mutation_reader_from_mutations_v2(table.schema(), std::move(permit), { std::move(mut) }), cfg, 1, version); auto ms = as_mutation_source(sst); for (uint32_t i = 3; i < seq; i++) { @@ -1984,11 +1983,10 @@ SEASTAR_TEST_CASE(test_skipping_using_index) { std::sort(partitions.begin(), partitions.end(), mutation_decorated_key_less_comparator()); - tmpdir dir; sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; // So that every fragment is indexed cfg.promoted_index_auto_scale_threshold = 0; // disable auto-scaling - auto sst = make_sstable_easy(env, dir.path(), make_flat_mutation_reader_from_mutations_v2(table.schema(), env.make_reader_permit(), partitions), cfg, 1, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), make_flat_mutation_reader_from_mutations_v2(table.schema(), env.make_reader_permit(), partitions), cfg, 1, version); auto ms = as_mutation_source(sst); auto rd = ms.make_reader_v2(table.schema(), @@ -2094,17 +2092,16 @@ static void copy_directory(fs::path src_dir, fs::path dst_dir) { SEASTAR_TEST_CASE(test_unknown_component) { return test_env::do_with_async([] (test_env& env) { - auto tmp = tmpdir(); - copy_directory("test/resource/sstables/unknown_component", std::string(tmp.path().string()) + "/unknown_component"); - auto sstp = env.reusable_sst(uncompressed_schema(), tmp.path().string() + "/unknown_component", 1).get0(); - test::create_links(*sstp, tmp.path().string()).get(); + copy_directory("test/resource/sstables/unknown_component", std::string(env.tempdir().path().string()) + "/unknown_component"); + auto sstp = env.reusable_sst(uncompressed_schema(), env.tempdir().path().string() + "/unknown_component", 1).get0(); + test::create_links(*sstp, env.tempdir().path().string()).get(); // check that create_links() moved unknown component to new dir - BOOST_REQUIRE(file_exists(tmp.path().string() + "/la-1-big-UNKNOWN.txt").get0()); + BOOST_REQUIRE(file_exists(env.tempdir().path().string() + "/la-1-big-UNKNOWN.txt").get0()); - sstp = env.reusable_sst(uncompressed_schema(), tmp.path().string(), 1).get0(); + sstp = env.reusable_sst(uncompressed_schema(), env.tempdir().path().string(), 1).get0(); sstables::sstable_directory::delete_atomically({sstp}).get(); // assure unknown component is deleted - BOOST_REQUIRE(!file_exists(tmp.path().string() + "/la-1-big-UNKNOWN.txt").get0()); + BOOST_REQUIRE(!file_exists(env.tempdir().path().string() + "/la-1-big-UNKNOWN.txt").get0()); }); } @@ -2233,9 +2230,8 @@ SEASTAR_TEST_CASE(sstable_tombstone_histogram_test) { .with_column("value", int32_type); auto s = builder.build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1), version]() mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, version, big); + auto sst_gen = [&env, s, gen = make_lw_shared(1), version]() mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, version, big); }; auto next_timestamp = [] { @@ -2258,7 +2254,7 @@ SEASTAR_TEST_CASE(sstable_tombstone_histogram_test) { } auto sst = make_sstable_containing(sst_gen, mutations); auto histogram = sst->get_stats_metadata().estimated_tombstone_drop_time; - sst = env.reusable_sst(s, tmp.path().string(), generation_value(sst->generation()), version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), generation_value(sst->generation()), version).get0(); auto histogram2 = sst->get_stats_metadata().estimated_tombstone_drop_time; // check that histogram respected limit @@ -2290,7 +2286,6 @@ SEASTAR_TEST_CASE(sstable_owner_shards) { .with_column("value", int32_type); auto s = builder.build(); - auto tmp = tmpdir(); auto make_insert = [&] (const dht::decorated_key& key) { mutation m(s, key); m.set_clustered_cell(clustering_key::make_empty(), bytes("value"), data_value(int32_t(1)), 1); @@ -2304,14 +2299,14 @@ SEASTAR_TEST_CASE(sstable_owner_shards) { }; auto muts = boost::copy_range>(shards | boost::adaptors::transformed([&] (auto shard) { return mut(shard); })); - auto sst_gen = [&env, s, &tmp, gen, ignore_msb] () mutable { + auto sst_gen = [&env, s, gen, ignore_msb] () mutable { auto schema = schema_builder(s).with_sharder(1, ignore_msb).build(); - auto sst = env.make_sstable(std::move(schema), tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(std::move(schema), env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; auto sst = make_sstable_containing(sst_gen, std::move(muts)); auto schema = schema_builder(s).with_sharder(smp_count, ignore_msb).build(); - sst = env.reusable_sst(std::move(schema), tmp.path().string(), generation_value(sst->generation())).get0(); + sst = env.reusable_sst(std::move(schema), env.tempdir().path().string(), generation_value(sst->generation())).get0(); return sst; }; @@ -2363,12 +2358,11 @@ SEASTAR_TEST_CASE(test_summary_entry_spanning_more_keys_than_min_interval) { keys_written++; } - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto sst = make_sstable_containing(sst_gen, mutations); - sst = env.reusable_sst(s, tmp.path().string(), generation_value(sst->generation())).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), generation_value(sst->generation())).get0(); summary& sum = sstables::test(sst).get_summary(); BOOST_REQUIRE(sum.entries.size() == 1); @@ -2567,9 +2561,8 @@ SEASTAR_TEST_CASE(summary_rebuild_sanity) { mutations.push_back(make_insert(partition_key::from_exploded(*s, {std::move(key)}))); } - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto sst = make_sstable_containing(sst_gen, mutations); @@ -2577,7 +2570,7 @@ SEASTAR_TEST_CASE(summary_rebuild_sanity) { BOOST_REQUIRE(s1.entries.size() > 1); sstables::test(sst).remove_component(component_type::Summary).get(); - sst = env.reusable_sst(s, tmp.path().string(), 1).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 1).get0(); summary& s2 = sstables::test(sst).get_summary(); BOOST_REQUIRE(::memcmp(&s1.header, &s2.header, sizeof(summary::header)) == 0); @@ -2611,9 +2604,8 @@ SEASTAR_TEST_CASE(sstable_partition_estimation_sanity_test) { return m; }; - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; { @@ -2652,9 +2644,8 @@ SEASTAR_TEST_CASE(sstable_timestamp_metadata_correcness_with_negative) { .with_column("id", utf8_type, column_kind::partition_key) .with_column("value", int32_type).build(); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1), version]() mutable { - return env.make_sstable(s, tmp.path().string(), (*gen)++, version, big); + auto sst_gen = [&env, s, gen = make_lw_shared(1), version]() mutable { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, version, big); }; auto make_insert = [&](partition_key key, api::timestamp_type ts) { @@ -2687,10 +2678,9 @@ SEASTAR_TEST_CASE(sstable_run_identifier_correctness) { mutation mut(s, partition_key::from_exploded(*s, {to_bytes("alpha")})); mut.set_clustered_cell(clustering_key::make_empty(), bytes("value"), data_value(int32_t(1)), 0); - auto tmp = tmpdir(); sstable_writer_config cfg = env.manager().configure_writer(); cfg.run_identifier = sstables::run_id::create_random_id(); - auto sst = make_sstable_easy(env, tmp.path(), make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), { std::move(mut) }), cfg); + auto sst = make_sstable_easy(env, env.tempdir().path(), make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), { std::move(mut) }), cfg); BOOST_REQUIRE(sst->run_identifier() == cfg.run_identifier); }); @@ -2737,9 +2727,8 @@ SEASTAR_TEST_CASE(sstable_run_clustering_disjoint_invariant_test) { simple_schema ss; auto s = ss.schema(); auto pks = ss.make_pkeys(1); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp, gen = make_lw_shared(1)]() { - return env.make_sstable(s, tmp.path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { + return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_sstable = [&] (int first_ckey_idx, int last_ckey_idx) { @@ -2863,21 +2852,19 @@ SEASTAR_TEST_CASE(basic_interval_map_testing_for_sstable_set) { SEASTAR_TEST_CASE(test_zero_estimated_partitions) { return test_env::do_with_async([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); simple_schema ss; auto s = ss.schema(); const auto pk = tests::generate_partition_key(s); auto mut = mutation(s, pk); ss.add_row(mut, ss.make_ckey(0), "val"); - fs::path tmp(tmpdir_path); for (const auto version : writable_sstable_versions) { testlog.info("version={}", sstables::to_string(version)); auto mr = make_flat_mutation_reader_from_mutations_v2(ss.schema(), env.make_reader_permit(), {mut}); sstable_writer_config cfg = env.manager().configure_writer(); - auto sst = make_sstable_easy(env, tmp, std::move(mr), cfg, 0, version, 0); + auto sst = make_sstable_easy(env, env.tempdir().path(), std::move(mr), cfg, 0, version, 0); auto sst_mr = sst->as_mutation_source().make_reader_v2(s, env.make_reader_permit(), query::full_partition_range, s->full_slice()); auto close_mr = deferred_close(sst_mr); @@ -2899,7 +2886,6 @@ SEASTAR_TEST_CASE(test_may_have_partition_tombstones) { auto s = ss.schema(); auto pks = ss.make_pkeys(2); - auto tmp = tmpdir(); unsigned gen = 0; for (auto version : all_sstable_versions) { if (version < sstable_version_types::md) { @@ -2914,8 +2900,8 @@ SEASTAR_TEST_CASE(test_may_have_partition_tombstones) { ss.delete_range(mut1, query::clustering_range::make({ss.make_ckey(3)}, {ss.make_ckey(5)})); ss.add_row(mut2, ss.make_ckey(6), "val"); - auto sst_gen = [&env, s, &tmp, &gen, version] () { - return env.make_sstable(s, tmp.path().string(), ++gen, version, big); + auto sst_gen = [&env, s, &gen, version] () { + return env.make_sstable(s, env.tempdir().path().string(), ++gen, version, big); }; { @@ -2978,7 +2964,6 @@ SEASTAR_TEST_CASE(test_sstable_origin) { auto mut = mutation(s, pk); ss.add_row(mut, ss.make_ckey(0), "val"); int gen = 1; - fs::path tmp = env.tempdir().path(); for (const auto version : all_sstable_versions) { if (version < sstable_version_types::mc) { @@ -2988,14 +2973,14 @@ SEASTAR_TEST_CASE(test_sstable_origin) { // Test empty sstable_origin. auto mr = make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), {mut}); sstable_writer_config cfg = env.manager().configure_writer(""); - auto sst = make_sstable_easy(env, tmp, std::move(mr), cfg, gen++, version, 0); + auto sst = make_sstable_easy(env, env.tempdir().path(), std::move(mr), cfg, gen++, version, 0); BOOST_REQUIRE_EQUAL(sst->get_origin(), ""); // Test that a random sstable_origin is stored and retrieved properly. mr = make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), {mut}); sstring origin = fmt::format("test-{}", tests::random::get_sstring()); cfg = env.manager().configure_writer(origin); - sst = make_sstable_easy(env, tmp, std::move(mr), cfg, gen++, version, 0); + sst = make_sstable_easy(env, env.tempdir().path(), std::move(mr), cfg, gen++, version, 0); BOOST_REQUIRE_EQUAL(sst->get_origin(), origin); } }); @@ -3156,9 +3141,8 @@ SEASTAR_TEST_CASE(partial_sstable_deletion_test) { simple_schema ss; auto s = ss.schema(); auto pks = ss.make_pkeys(1); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp] () { - return env.make_sstable(s, tmp.path().string(), 1, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s] () { + return env.make_sstable(s, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); }; auto mut1 = mutation(s, pks[0]); @@ -3241,9 +3225,8 @@ SEASTAR_TEST_CASE(test_crawling_reader_out_of_range_last_range_tombstone_change) using bound = query::clustering_range::bound; table.delete_range(mut, query::clustering_range::make(bound{ckeys[3], true}, bound{clustering_key::make_empty(), true}), tombstone(1, gc_clock::now())); - auto tmp = tmpdir(); - auto sst_gen = [&env, &table, &tmp] () { - return env.make_sstable(table.schema(), tmp.path().string(), 1, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, &table] () { + return env.make_sstable(table.schema(), env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); }; auto sst = make_sstable_containing(sst_gen, {mut}); @@ -3266,9 +3249,8 @@ SEASTAR_TEST_CASE(test_crawling_reader_random_schema_random_mutations) { const auto muts = tests::generate_random_mutations(random_schema, 20).get(); - auto tmp = tmpdir(); - auto sst_gen = [&env, schema, &tmp] () { - return env.make_sstable(schema, tmp.path().string(), 1, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, schema] () { + return env.make_sstable(schema, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); }; auto sst = make_sstable_containing(sst_gen, muts); diff --git a/test/boost/sstable_mutation_test.cc b/test/boost/sstable_mutation_test.cc index de2996a371..242e8930a9 100644 --- a/test/boost/sstable_mutation_test.cc +++ b/test/boost/sstable_mutation_test.cc @@ -400,7 +400,6 @@ mutation_source make_sstable_mutation_source(sstables::test_env& env, schema_ptr SEASTAR_TEST_CASE(test_sstable_can_write_and_read_range_tombstone) { return test_env::do_with_async([] (test_env& env) { - auto dir = tmpdir(); auto s = make_shared_schema({}, "ks", "cf", {{"p1", utf8_type}}, {{"c1", int32_type}}, {{"r1", int32_type}}, {}, utf8_type); @@ -416,7 +415,7 @@ SEASTAR_TEST_CASE(test_sstable_can_write_and_read_range_tombstone) { mt->apply(std::move(m)); auto sst = env.make_sstable(s, - dir.path().string(), + env.tempdir().path().string(), 1 /* generation */, sstables::get_highest_sstable_version(), sstables::sstable::format_types::big); @@ -842,7 +841,6 @@ SEASTAR_TEST_CASE(buffer_overflow) { SEASTAR_TEST_CASE(test_non_compound_table_row_is_not_marked_as_static) { return test_env::do_with_async([] (test_env& env) { for (const auto version : writable_sstable_versions) { - auto dir = tmpdir(); schema_builder builder("ks", "cf"); builder.with_column("p", utf8_type, column_kind::partition_key); builder.with_column("c", int32_type, column_kind::clustering_key); @@ -860,7 +858,7 @@ SEASTAR_TEST_CASE(test_non_compound_table_row_is_not_marked_as_static) { mt->apply(std::move(m)); auto sst = env.make_sstable(s, - dir.path().string(), + env.tempdir().path().string(), 1 /* generation */, version, sstables::sstable::format_types::big); @@ -877,7 +875,6 @@ SEASTAR_TEST_CASE(test_non_compound_table_row_is_not_marked_as_static) { SEASTAR_TEST_CASE(test_has_partition_key) { return test_env::do_with_async([] (test_env& env) { for (const auto version : writable_sstable_versions) { - auto dir = tmpdir(); schema_builder builder("ks", "cf"); builder.with_column("p", utf8_type, column_kind::partition_key); builder.with_column("c", int32_type, column_kind::clustering_key); @@ -895,7 +892,7 @@ SEASTAR_TEST_CASE(test_has_partition_key) { mt->apply(std::move(m)); auto sst = env.make_sstable(s, - dir.path().string(), + env.tempdir().path().string(), 1 /* generation */, version, sstables::sstable::format_types::big); @@ -922,7 +919,6 @@ static std::unique_ptr get_index_reader(shared_sstable sst, reader SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic) { return test_env::do_with_async([] (test_env& env) { - auto dir = tmpdir(); schema_builder builder("ks", "cf"); builder.with_column("p", utf8_type, column_kind::partition_key); builder.with_column("c1", int32_type, column_kind::clustering_key); @@ -959,14 +955,13 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic) { cfg.promoted_index_block_size = 1; cfg.promoted_index_auto_scale_threshold = 0; // disable auto-scaling - auto sst = make_sstable_easy(env, dir.path(), mt, cfg); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg); assert_that(get_index_reader(sst, env.make_reader_permit())).has_monotonic_positions(*s); }); } SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_with_auto_scaling) { return test_env::do_with_async([] (test_env& env) { - auto dir = tmpdir(); schema_builder builder("ks", "cf"); builder.with_column("p", utf8_type, column_kind::partition_key); builder.with_column("c1", int32_type, column_kind::clustering_key); @@ -996,7 +991,7 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_with_auto_scaling) { cfg.promoted_index_block_size = 1; cfg.promoted_index_auto_scale_threshold = 100; // set to a low value to trigger auto-scaling - auto sst = make_sstable_easy(env, dir.path(), mt, cfg); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg); assert_that(get_index_reader(sst, env.make_reader_permit())).has_monotonic_positions(*s); }); } @@ -1004,7 +999,6 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_with_auto_scaling) { SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_compound_dense) { return test_env::do_with_async([] (test_env& env) { for (const auto version : writable_sstable_versions) { - auto dir = tmpdir(); schema_builder builder("ks", "cf"); builder.with_column("p", utf8_type, column_kind::partition_key); builder.with_column("c1", int32_type, column_kind::clustering_key); @@ -1040,7 +1034,7 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_compound_dense) { sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; - auto sst = make_sstable_easy(env, dir.path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); { assert_that(get_index_reader(sst, env.make_reader_permit())).has_monotonic_positions(*s); @@ -1059,7 +1053,6 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_compound_dense) { SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_non_compound_dense) { return test_env::do_with_async([] (test_env& env) { for (const auto version : writable_sstable_versions) { - auto dir = tmpdir(); schema_builder builder("ks", "cf"); builder.with_column("p", utf8_type, column_kind::partition_key); builder.with_column("c1", int32_type, column_kind::clustering_key); @@ -1091,7 +1084,7 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_non_compound_dense) { sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; - auto sst = make_sstable_easy(env, dir.path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); { assert_that(get_index_reader(sst, env.make_reader_permit())).has_monotonic_positions(*s); @@ -1110,7 +1103,6 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_non_compound_dense) { SEASTAR_TEST_CASE(test_promoted_index_repeats_open_tombstones) { return test_env::do_with_async([] (test_env& env) { for (const auto version : writable_sstable_versions) { - auto dir = tmpdir(); int id = 0; for (auto& compact : { schema_builder::compact_storage::no, schema_builder::compact_storage::yes }) { const auto generation = id++; @@ -1139,7 +1131,7 @@ SEASTAR_TEST_CASE(test_promoted_index_repeats_open_tombstones) { sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; - auto sst = make_sstable_easy(env, dir.path(), mt, cfg, generation, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, generation, version); { auto slice = partition_slice_builder(*s).with_range(query::clustering_range::make_starting_with({ck})).build(); @@ -1155,7 +1147,6 @@ SEASTAR_TEST_CASE(test_promoted_index_repeats_open_tombstones) { SEASTAR_TEST_CASE(test_range_tombstones_are_correctly_seralized_for_non_compound_dense_schemas) { return test_env::do_with_async([] (test_env& env) { for (const auto version : writable_sstable_versions) { - auto dir = tmpdir(); schema_builder builder("ks", "cf"); builder.with_column("p", utf8_type, column_kind::partition_key); builder.with_column("c", int32_type, column_kind::clustering_key); @@ -1176,7 +1167,7 @@ SEASTAR_TEST_CASE(test_range_tombstones_are_correctly_seralized_for_non_compound mt->apply(m); sstable_writer_config cfg = env.manager().configure_writer(); - auto sst = make_sstable_easy(env, dir.path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); { auto slice = partition_slice_builder(*s).build(); @@ -1191,7 +1182,6 @@ SEASTAR_TEST_CASE(test_range_tombstones_are_correctly_seralized_for_non_compound SEASTAR_TEST_CASE(test_promoted_index_is_absent_for_schemas_without_clustering_key) { return test_env::do_with_async([] (test_env& env) { for (const auto version : writable_sstable_versions) { - auto dir = tmpdir(); schema_builder builder("ks", "cf"); builder.with_column("p", utf8_type, column_kind::partition_key); builder.with_column("v", int32_type); @@ -1208,7 +1198,7 @@ SEASTAR_TEST_CASE(test_promoted_index_is_absent_for_schemas_without_clustering_k sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; - auto sst = make_sstable_easy(env, dir.path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); assert_that(get_index_reader(sst, env.make_reader_permit())).is_empty(*s); } }); @@ -1217,7 +1207,6 @@ SEASTAR_TEST_CASE(test_promoted_index_is_absent_for_schemas_without_clustering_k SEASTAR_TEST_CASE(test_writing_combined_stream_with_tombstones_at_the_same_position) { return test_env::do_with_async([] (test_env& env) { for (const auto version : writable_sstable_versions) { - auto dir = tmpdir(); simple_schema ss; auto s = ss.schema(); @@ -1247,7 +1236,7 @@ SEASTAR_TEST_CASE(test_writing_combined_stream_with_tombstones_at_the_same_posit auto combined_permit = env.make_reader_permit(); auto mr = make_combined_reader(s, combined_permit, mt1->make_flat_reader(s, combined_permit), mt2->make_flat_reader(s, combined_permit)); - auto sst = make_sstable_easy(env, dir.path(), std::move(mr), env.manager().configure_writer(), 1, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), std::move(mr), env.manager().configure_writer(), 1, version); assert_that(sst->as_mutation_source().make_reader_v2(s, env.make_reader_permit())) .produces(m1 + m2) @@ -1368,7 +1357,6 @@ SEASTAR_TEST_CASE(test_large_index_pages_do_not_cause_large_allocations) { return test_env::do_with_async([] (test_env& env) { // We create a sequence of partitions such that first we have a partition with a very long key, then // series of partitions with small keys. This should result in large index page. - auto dir = tmpdir(); simple_schema ss; auto s = ss.schema(); @@ -1418,7 +1406,7 @@ SEASTAR_TEST_CASE(test_large_index_pages_do_not_cause_large_allocations) { } sstable_writer_config cfg = env.manager().configure_writer(); - auto sst = make_sstable_easy(env, dir.path(), mt, cfg); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg); auto pr = dht::partition_range::make_singular(small_keys[0]); @@ -1443,8 +1431,6 @@ SEASTAR_TEST_CASE(test_large_index_pages_do_not_cause_large_allocations) { SEASTAR_TEST_CASE(test_reading_serialization_header) { return test_env::do_with_async([] (test_env& env) { - auto dir = tmpdir(); - auto random_int32_value = [] { return int32_type->decompose(tests::random::get_int()); }; @@ -1485,11 +1471,11 @@ SEASTAR_TEST_CASE(test_reading_serialization_header) { // SSTable class has way too many responsibilities. In particular, it mixes the reading and // writting parts. Let's use a separate objects for writing and reading to ensure that nothing // carries over that wouldn't normally be read from disk. - auto sst = env.make_sstable(s, dir.path().string(), 1, sstable::version_types::mc, sstables::sstable::format_types::big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, sstable::version_types::mc, sstables::sstable::format_types::big); sst->write_components(mt->make_flat_reader(s, env.make_reader_permit()), 2, s, env.manager().configure_writer(), mt->get_encoding_stats()).get(); } - auto sst = env.make_sstable(s, dir.path().string(), 1, sstable::version_types::mc, sstables::sstable::format_types::big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, sstable::version_types::mc, sstables::sstable::format_types::big); sst->load().get(); auto hdr = sst->get_serialization_header(); @@ -1549,8 +1535,6 @@ SEASTAR_THREAD_TEST_CASE(test_merging_encoding_stats) { // Reproducer for #4206 SEASTAR_TEST_CASE(test_counter_header_size) { return test_env::do_with_async([] (test_env& env) { - auto dir = tmpdir(); - auto s = schema_builder("ks", "counter_test") .with_column("pk", int32_type, column_kind::partition_key) .with_column("ck", int32_type, column_kind::clustering_key) @@ -1579,7 +1563,7 @@ SEASTAR_TEST_CASE(test_counter_header_size) { mt->apply(m); for (const auto version : writable_sstable_versions) { - auto sst = make_sstable_easy(env, dir.path(), mt, env.manager().configure_writer(), 1, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, env.manager().configure_writer(), 1, version); assert_that(sst->as_mutation_source().make_reader_v2(s, env.make_reader_permit())) .produces(m) .produces_end_of_stream(); From d28589a2f7be3670f79268bf58d796e4b467198d Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 11:05:52 +0300 Subject: [PATCH 05/16] test,sstables: Use sstables::test_env's tempdir with sweeper Continuation of the previous patch. Some test cases are sensitive to having the temp directory clean, so patch them similarly, but equip with the sweeper on entry instead of their own temprid instance. Signed-off-by: Pavel Emelyanov --- test/boost/sstable_3_x_test.cc | 4 +- test/boost/sstable_compaction_test.cc | 12 +- test/boost/sstable_datafile_test.cc | 154 +++++++++++++------------- test/boost/sstable_mutation_test.cc | 8 +- 4 files changed, 89 insertions(+), 89 deletions(-) diff --git a/test/boost/sstable_3_x_test.cc b/test/boost/sstable_3_x_test.cc index 74edeb8136..c79876b923 100644 --- a/test/boost/sstable_3_x_test.cc +++ b/test/boost/sstable_3_x_test.cc @@ -5107,10 +5107,10 @@ SEASTAR_TEST_CASE(test_sstable_reader_on_unknown_column) { auto mt = make_lw_shared(write_schema); mt->apply(partition); for (auto index_block_size : {1, 128, 64*1024}) { - tmpdir dir; + auto _ = env.tempdir().make_sweeper(); sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = index_block_size; - auto sst = make_sstable_easy(env, dir.path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); BOOST_REQUIRE_EXCEPTION( assert_that(sst->make_reader(read_schema, env.make_reader_permit(), query::full_partition_range, read_schema->full_slice())) diff --git a/test/boost/sstable_compaction_test.cc b/test/boost/sstable_compaction_test.cc index e40ae0cfa2..da1de26a33 100644 --- a/test/boost/sstable_compaction_test.cc +++ b/test/boost/sstable_compaction_test.cc @@ -3850,8 +3850,8 @@ SEASTAR_TEST_CASE(test_twcs_interposer_on_memtable_flush) { return m; }; - auto tmp = tmpdir(); - table_for_tests cf(env.manager(), s, tmp.path().string()); + auto _ = env.tempdir().make_sweeper(); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); cf->start(); @@ -4738,13 +4738,13 @@ SEASTAR_TEST_CASE(test_compaction_strategy_cleanup_method) { builder.set_compaction_strategy_options(std::move(strategy_options)); auto s = builder.build(); - auto tmp = tmpdir(); + auto _ = env.tempdir().make_sweeper(); auto keys = tests::generate_partition_keys(all_files, s); - table_for_tests cf(env.manager(), s, tmp.path().string()); + table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); - auto sst_gen = [&env, &cf, s, &tmp]() mutable { - return env.make_sstable(s, tmp.path().string(), column_family_test::calculate_generation_for_new_table(*cf), + auto sst_gen = [&env, &cf, s]() mutable { + return env.make_sstable(s, env.tempdir().path().string(), column_family_test::calculate_generation_for_new_table(*cf), sstables::get_highest_sstable_version(), big); }; diff --git a/test/boost/sstable_datafile_test.cc b/test/boost/sstable_datafile_test.cc index a56fa9d036..458e8aafe4 100644 --- a/test/boost/sstable_datafile_test.cc +++ b/test/boost/sstable_datafile_test.cc @@ -1093,10 +1093,10 @@ static void test_min_max_clustering_key(test_env& env, schema_ptr s, std::vector } } } - auto tmp = tmpdir(); - auto sst = env.make_sstable(s, tmp.path().string(), 1, version, big); + auto tmp = env.tempdir().make_sweeper(); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 1, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); check_min_max_column_names(sst, std::move(min_components), std::move(max_components)); } @@ -1215,7 +1215,7 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { .with_column("ck1", utf8_type, column_kind::clustering_key) .with_column("r1", int32_type) .build(); - auto tmp = tmpdir(); + auto tmp = env.tempdir().make_sweeper(); auto key = partition_key::from_exploded(*s, {to_bytes("key1")}); auto c_key = clustering_key_prefix::from_exploded(*s, {to_bytes("c1")}); const column_definition& r1_col = *s->get_column_definition("r1"); @@ -1228,9 +1228,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply_delete(*s, c_key, tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 1, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 1, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1"}, {"c1"}); } @@ -1240,9 +1240,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_dead_atomic_cell(3600)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 2, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 2, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 2, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 2, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1"}, {"c1"}); } @@ -1252,9 +1252,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 3, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 3, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 3, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 3, version).get0(); BOOST_REQUIRE(!sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1"}, {"c1"}); } @@ -1272,9 +1272,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { m2.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m2)); - auto sst = env.make_sstable(s, tmp.path().string(), 4, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 4, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 4, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 4, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1"}, {"c1"}); } @@ -1285,9 +1285,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply(tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 5, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 5, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 5, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 5, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {}); } @@ -1300,9 +1300,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { "a")), clustering_key_prefix::from_single_value(*s, bytes("a")), tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 6, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 6, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 6, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 6, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a"}, {"a"}); @@ -1320,9 +1320,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 7, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 7, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 7, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 7, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a"}, {"c1"}); @@ -1340,9 +1340,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 8, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 8, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 8, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 8, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c"}, {"d"}); @@ -1360,9 +1360,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 9, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 9, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 9, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 9, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1"}, {"z"}); @@ -1381,9 +1381,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 10, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 10, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 10, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 10, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {"z"}); } @@ -1399,9 +1399,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 11, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 11, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 11, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 11, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"a"}, {}); } @@ -1413,9 +1413,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply_delete(*s, clustering_key_prefix::make_empty(), tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 12, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 12, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 12, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 12, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {}); } @@ -1433,7 +1433,7 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { .with_column("ck2", utf8_type, column_kind::clustering_key) .with_column("r1", int32_type) .build(); - auto tmp = tmpdir(); + auto tmp = env.tempdir().make_sweeper(); auto key = partition_key::from_exploded(*s, {to_bytes("key1")}); auto c_key = clustering_key_prefix::from_exploded(*s, {to_bytes("c1"), to_bytes("c2")}); const column_definition& r1_col = *s->get_column_definition("r1"); @@ -1446,9 +1446,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply_delete(*s, c_key, tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 1, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 1, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1458,9 +1458,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_dead_atomic_cell(3600)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 2, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 2, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 2, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 2, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1470,9 +1470,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 3, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 3, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 3, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 3, version).get0(); BOOST_REQUIRE(!sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1490,9 +1490,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { m2.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m2)); - auto sst = env.make_sstable(s, tmp.path().string(), 4, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 4, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 4, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 4, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1503,9 +1503,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply(tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 5, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 5, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 5, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 5, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {}); } @@ -1520,9 +1520,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 6, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 6, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 6, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 6, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a", "aa"}, {"z", "zz"}); @@ -1540,9 +1540,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 7, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 7, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 7, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 7, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a"}, {"c1", "c2"}); @@ -1560,9 +1560,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 8, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 8, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 8, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 8, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1", "aa"}, {"c1", "zz"}); @@ -1580,9 +1580,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 9, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 9, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 9, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 9, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1", "c2"}, {"z", "zz"}); @@ -1601,9 +1601,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 10, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 10, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 10, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 10, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {"z"}); } @@ -1619,9 +1619,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 11, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 11, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 11, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 11, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"a"}, {}); } @@ -1639,7 +1639,7 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { .with_column("ck2", reversed_type_impl::get_instance(utf8_type), column_kind::clustering_key) .with_column("r1", int32_type) .build(); - auto tmp = tmpdir(); + auto tmp = env.tempdir().make_sweeper(); auto key = partition_key::from_exploded(*s, {to_bytes("key1")}); auto c_key = clustering_key_prefix::from_exploded(*s, {to_bytes("c1"), to_bytes("c2")}); const column_definition& r1_col = *s->get_column_definition("r1"); @@ -1652,9 +1652,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply_delete(*s, c_key, tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 1, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 1, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1664,9 +1664,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_dead_atomic_cell(3600)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 2, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 2, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 2, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 2, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1676,9 +1676,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 3, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 3, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 3, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 3, version).get0(); BOOST_REQUIRE(!sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1696,9 +1696,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { m2.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m2)); - auto sst = env.make_sstable(s, tmp.path().string(), 4, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 4, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 4, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 4, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1709,9 +1709,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply(tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 5, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 5, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 5, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 5, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {}); } @@ -1726,9 +1726,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 6, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 6, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 6, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 6, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a", "zz"}, {"a", "aa"}); @@ -1746,9 +1746,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 7, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 7, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 7, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 7, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a", "zz"}, {"c1", "c2"}); @@ -1766,9 +1766,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 8, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 8, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 8, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 8, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1", "zz"}, {"c1"}); @@ -1786,9 +1786,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 9, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 9, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 9, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 9, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1", "zz"}, {"c1", "c2"}); @@ -1807,9 +1807,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 10, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 10, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 10, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 10, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {"z"}); } @@ -1825,9 +1825,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmp.path().string(), 11, version, big); + auto sst = env.make_sstable(s, env.tempdir().path().string(), 11, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, tmp.path().string(), 11, version).get0(); + sst = env.reusable_sst(s, env.tempdir().path().string(), 11, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"a"}, {}); } @@ -3279,9 +3279,9 @@ SEASTAR_TEST_CASE(find_first_position_in_partition_from_sstable_test) { simple_schema ss; auto s = ss.schema(); auto pks = ss.make_pkeys(partitions); - auto tmp = tmpdir(); - auto sst_gen = [&env, s, &tmp]() { - return env.make_sstable(s, tmp.path().string(), 1, sstables::get_highest_sstable_version(), big); + auto tmp = env.tempdir().make_sweeper(); + auto sst_gen = [&env, s]() { + return env.make_sstable(s, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); }; std::vector muts; diff --git a/test/boost/sstable_mutation_test.cc b/test/boost/sstable_mutation_test.cc index 242e8930a9..3c0f5bf3a6 100644 --- a/test/boost/sstable_mutation_test.cc +++ b/test/boost/sstable_mutation_test.cc @@ -1305,8 +1305,8 @@ SEASTAR_TEST_CASE(test_key_count_estimation) { mt->apply(m); } - tmpdir dir; - shared_sstable sst = make_sstable_easy(env, dir.path(), mt, env.manager().configure_writer(), 1, version, pks.size()); + auto _ = env.tempdir().make_sweeper(); + shared_sstable sst = make_sstable_easy(env, env.tempdir().path(), mt, env.manager().configure_writer(), 1, version, pks.size()); auto max_est = sst->get_estimated_key_count(); testlog.trace("count = {}", count); @@ -1655,8 +1655,8 @@ SEASTAR_TEST_CASE(writer_handles_subsequent_range_tombstone_changes_without_tomb flat_mutation_reader_v2 input_reader = make_flat_mutation_reader_from_fragments(s, p, std::move(fragments)); deferred_close dc1{input_reader}; sstable_writer_config cfg = env.manager().configure_writer(); - tmpdir dir; - shared_sstable sstable = env.make_sstable(s, dir.path().string(), 0); + auto _ = env.tempdir().make_sweeper(); + shared_sstable sstable = env.make_sstable(s, env.tempdir().path().string(), 0); encoding_stats es; sstable->write_components(std::move(input_reader), 1, s, cfg, es).get(); sstable->load().get(); From dfcfe0a355ee33ccf59ccb259b5f1e2f66ca7932 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 11:38:18 +0300 Subject: [PATCH 06/16] test/sstable::test_env: Add dir-less sstables making helpers Lots of (most of) test cases out there generate sstables inside env's temporary directory. This patch adds some sugar to env that will allow test cases omit explicit env.tempdir() call. Signed-off-by: Pavel Emelyanov --- test/lib/sstable_test_env.hh | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/test/lib/sstable_test_env.hh b/test/lib/sstable_test_env.hh index d36c8d3e47..cb6fdd08d9 100644 --- a/test/lib/sstable_test_env.hh +++ b/test/lib/sstable_test_env.hh @@ -77,6 +77,12 @@ public: return _impl->mgr.make_sstable(std::move(schema), dir, generation_from_value(generation), v, f, now, default_io_error_handler_gen(), buffer_size); } + shared_sstable make_sstable(schema_ptr schema, unsigned long generation, + sstable::version_types v = sstables::get_highest_sstable_version(), sstable::format_types f = sstable::format_types::big, + size_t buffer_size = default_sstable_buffer_size, gc_clock::time_point now = gc_clock::now()) { + return make_sstable(std::move(schema), _impl->dir.path().native(), generation, std::move(v), std::move(f), buffer_size, now); + } + struct sst_not_found : public std::runtime_error { sst_not_found(const sstring& dir, unsigned long generation) : std::runtime_error(format("no versions of sstable generation {} found in {}", generation, dir)) @@ -92,9 +98,18 @@ public: }); } + future reusable_sst(schema_ptr schema, unsigned long generation, + sstable::version_types version, sstable::format_types f = sstable::format_types::big) { + return reusable_sst(std::move(schema), _impl->dir.path().native(), std::move(generation), std::move(version), std::move(f)); + } + // looks up the sstable in the given dir future reusable_sst(schema_ptr schema, sstring dir, unsigned long generation); + future reusable_sst(schema_ptr schema, unsigned long generation) { + return reusable_sst(std::move(schema), _impl->dir.path().native(), generation); + } + test_env_sstables_manager& manager() { return _impl->mgr; } reader_concurrency_semaphore& semaphore() { return _impl->semaphore; } db::config& db_config() { return *_impl->db_config; } From 4bd79dc9000b7cbd4b611ac62cd9612fee0c9b00 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 11:38:31 +0300 Subject: [PATCH 07/16] test,sstables: Dont mess with tempdir where possible Beneficiary of the previuous patch -- those cases that make sstables in env's tempdir can now enjoy not mentioning this explicitly and letting the env specify the sstable making path itself. Signed-off-by: Pavel Emelyanov --- test/boost/sstable_compaction_test.cc | 112 ++++++----- test/boost/sstable_datafile_test.cc | 266 ++++++++++++-------------- test/boost/sstable_mutation_test.cc | 9 +- 3 files changed, 182 insertions(+), 205 deletions(-) diff --git a/test/boost/sstable_compaction_test.cc b/test/boost/sstable_compaction_test.cc index da1de26a33..54d2aa7fe2 100644 --- a/test/boost/sstable_compaction_test.cc +++ b/test/boost/sstable_compaction_test.cc @@ -175,7 +175,7 @@ SEASTAR_TEST_CASE(compaction_manager_basic_test) { m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), column_family_test::calculate_generation_for_new_table(*cf), sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, column_family_test::calculate_generation_for_new_table(*cf), sstables::get_highest_sstable_version(), big); write_memtable_to_sstable_for_test(*mt, sst).get(); sst->load().get(); @@ -1000,7 +1000,7 @@ SEASTAR_TEST_CASE(tombstone_purge_test) { auto s = builder.build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto compact = [&, s] (std::vector all, std::vector to_compact) -> std::vector { @@ -1189,7 +1189,6 @@ SEASTAR_TEST_CASE(tombstone_purge_test) { SEASTAR_TEST_CASE(sstable_rewrite) { BOOST_REQUIRE(smp::count == 1); return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = make_shared_schema({}, some_keyspace, some_column_family, {{"p1", utf8_type}}, {{"c1", utf8_type}}, {{"r1", utf8_type}}, {}, utf8_type); @@ -1206,13 +1205,13 @@ SEASTAR_TEST_CASE(sstable_rewrite) { }; apply_key(key_for_this_shard[0]); - auto sst = env.make_sstable(s, tmpdir_path, 51, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s, sst, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, 51); - }).then([&env, s, key = key_for_this_shard[0], tmpdir_path] (auto sstp) mutable { + auto sst = env.make_sstable(s, 51, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s, sst] { + return env.reusable_sst(s, 51); + }).then([&env, s, key = key_for_this_shard[0]] (auto sstp) mutable { auto new_tables = make_lw_shared>(); - auto creator = [&env, new_tables, s, tmpdir_path] { - auto sst = env.make_sstable(s, tmpdir_path, 52, sstables::get_highest_sstable_version(), big); + auto creator = [&env, new_tables, s] { + auto sst = env.make_sstable(s, 52, sstables::get_highest_sstable_version(), big); new_tables->emplace_back(sst); return sst; }; @@ -1248,7 +1247,6 @@ SEASTAR_TEST_CASE(test_sstable_max_local_deletion_time_2) { // Create sstable B with tombstone for column in sstable A with TTL 1000. // Compact them and expect that maximum deletion time is that of column with TTL 100. return test_env::do_with_async([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); for (auto version : writable_sstable_versions) { schema_builder builder(some_keyspace, some_column_family); builder.with_column("p1", utf8_type, column_kind::partition_key); @@ -1267,10 +1265,10 @@ SEASTAR_TEST_CASE(test_sstable_max_local_deletion_time_2) { make_atomic_cell(utf8_type, bytes(""), ttl, last_expiry)); mt->apply(std::move(m)); }; - auto get_usable_sst = [&env, s, tmpdir_path, version](replica::memtable &mt, int64_t gen) -> future { - auto sst = env.make_sstable(s, tmpdir_path, gen, version, big); - return write_memtable_to_sstable_for_test(mt, sst).then([&env, sst, gen, s, tmpdir_path, version] { - return env.reusable_sst(s, tmpdir_path, gen, version); + auto get_usable_sst = [&env, s, version](replica::memtable &mt, int64_t gen) -> future { + auto sst = env.make_sstable(s, gen, version, big); + return write_memtable_to_sstable_for_test(mt, sst).then([&env, sst, gen, s, version] { + return env.reusable_sst(s, gen, version); }); }; @@ -1290,7 +1288,7 @@ SEASTAR_TEST_CASE(test_sstable_max_local_deletion_time_2) { auto sst2 = get_usable_sst(*mt, 55).get0(); BOOST_REQUIRE(now.time_since_epoch().count() == sst2->get_stats_metadata().max_local_deletion_time); - auto creator = [&env, s, tmpdir_path, version, gen = make_lw_shared(56)] { return env.make_sstable(s, tmpdir_path, (*gen)++, version, big); }; + auto creator = [&env, s, version, gen = make_lw_shared(56)] { return env.make_sstable(s, (*gen)++, version, big); }; auto info = compact_sstables(sstables::compaction_descriptor({sst1, sst2}, default_priority_class()), cf, creator).get0(); BOOST_REQUIRE(info.new_sstables.size() == 1); BOOST_REQUIRE(((now + gc_clock::duration(100)).time_since_epoch().count()) == @@ -1360,7 +1358,7 @@ SEASTAR_TEST_CASE(compaction_with_fully_expired_table) { auto key = partition_key::from_exploded(*s, {to_bytes("key1")}); auto c_key = clustering_key_prefix::from_exploded(*s, {to_bytes("c1")}); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto mt = make_lw_shared(s); @@ -1370,7 +1368,7 @@ SEASTAR_TEST_CASE(compaction_with_fully_expired_table) { mt->apply(std::move(m)); auto sst = sst_gen(); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 1).get0(); + sst = env.reusable_sst(s, 1).get0(); table_for_tests cf(env.manager(), s); auto close_cf = deferred_stop(cf); @@ -1555,7 +1553,7 @@ SEASTAR_TEST_CASE(time_window_strategy_correctness_test) { .with_column("value", int32_type).build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (partition_key key, api::timestamp_type t) { @@ -1656,7 +1654,7 @@ SEASTAR_TEST_CASE(time_window_strategy_size_tiered_behavior_correctness) { .with_column("value", int32_type).build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (partition_key key, api::timestamp_type t) { @@ -1764,9 +1762,9 @@ SEASTAR_TEST_CASE(min_max_clustering_key_test_2) { } mt->apply(std::move(m)); } - auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); + auto sst = env.make_sstable(s, 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); + sst = env.reusable_sst(s, 1, version).get0(); check_min_max_column_names(sst, {"0ck100"}, {"7ck149"}); mt = make_lw_shared(s); @@ -1777,12 +1775,12 @@ SEASTAR_TEST_CASE(min_max_clustering_key_test_2) { m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); } mt->apply(std::move(m)); - auto sst2 = env.make_sstable(s, env.tempdir().path().string(), 2, version, big); + auto sst2 = env.make_sstable(s, 2, version, big); write_memtable_to_sstable_for_test(*mt, sst2).get(); - sst2 = env.reusable_sst(s, env.tempdir().path().string(), 2, version).get0(); + sst2 = env.reusable_sst(s, 2, version).get0(); check_min_max_column_names(sst2, {"9ck101"}, {"9ck298"}); - auto creator = [&env, s, version] { return env.make_sstable(s, env.tempdir().path().string(), 3, version, big); }; + auto creator = [&env, s, version] { return env.make_sstable(s, 3, version, big); }; auto info = compact_sstables(sstables::compaction_descriptor({sst, sst2}, default_priority_class()), cf, creator).get0(); BOOST_REQUIRE(info.new_sstables.size() == 1); check_min_max_column_names(info.new_sstables.front(), {"0ck100"}, {"9ck298"}); @@ -1842,9 +1840,9 @@ SEASTAR_TEST_CASE(sstable_expired_data_ratio) { for (auto i = 0; i < remaining; i++) { insert_key(to_bytes("key" + to_sstring(i)), 3600, expiration_time); } - auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, 1, sstables::get_highest_sstable_version(), big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 1).get0(); + sst = env.reusable_sst(s, 1).get0(); const auto& stats = sst->get_stats_metadata(); BOOST_REQUIRE(stats.estimated_tombstone_drop_time.bin.size() == sstables::TOMBSTONE_HISTOGRAM_BIN_SIZE); auto gc_before = gc_clock::now() - s->gc_grace_seconds(); @@ -1858,7 +1856,7 @@ SEASTAR_TEST_CASE(sstable_expired_data_ratio) { table_for_tests cf(env.manager(), s); auto close_cf = deferred_stop(cf); auto creator = [&, gen = make_lw_shared(2)] { - auto sst = env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; auto info = compact_sstables(sstables::compaction_descriptor({ sst }, default_priority_class()), cf, creator).get0(); @@ -1924,7 +1922,7 @@ SEASTAR_TEST_CASE(compaction_correctness_with_partitioned_sstable_set) { auto s = builder.build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - auto sst = env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; @@ -2031,7 +2029,7 @@ SEASTAR_TEST_CASE(sstable_cleanup_correctness_test) { .with_column("value", int32_type).build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (dht::decorated_key key) { @@ -2178,7 +2176,7 @@ SEASTAR_TEST_CASE(sstable_scrub_validate_mode_test) { auto permit = env.make_reader_permit(); auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, env.tempdir().path().string(), (*gen)++); + return env.make_sstable(schema, (*gen)++); }; auto scrubbed_mt = make_lw_shared(schema); @@ -2375,7 +2373,7 @@ SEASTAR_TEST_CASE(sstable_scrub_skip_mode_test) { auto permit = env.make_reader_permit(); auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, env.tempdir().path().string(), (*gen)++); + return env.make_sstable(schema, (*gen)++); }; std::vector scrubbed_fragments; @@ -2468,7 +2466,7 @@ SEASTAR_TEST_CASE(sstable_scrub_segregate_mode_test) { auto permit = env.make_reader_permit(); auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, env.tempdir().path().string(), (*gen)++); + return env.make_sstable(schema, (*gen)++); }; auto scrubbed_mt = make_lw_shared(schema); @@ -2578,7 +2576,7 @@ SEASTAR_TEST_CASE(sstable_scrub_quarantine_mode_test) { auto permit = env.make_reader_permit(); auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, env.tempdir().path().string(), (*gen)++); + return env.make_sstable(schema, (*gen)++); }; auto scrubbed_mt = make_lw_shared(schema); @@ -2925,7 +2923,7 @@ SEASTAR_TEST_CASE(sstable_run_based_compaction_test) { auto s = builder.build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - auto sst = env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; @@ -3054,7 +3052,7 @@ SEASTAR_TEST_CASE(compaction_strategy_aware_major_compaction_test) { .with_column("value", int32_type).build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (partition_key key) { mutation m(s, key); @@ -3098,7 +3096,7 @@ SEASTAR_TEST_CASE(backlog_tracker_correctness_after_changing_compaction_strategy auto s = builder.build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - auto sst = env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; @@ -3199,7 +3197,7 @@ SEASTAR_TEST_CASE(purged_tombstone_consumer_sstable_test) { auto s = builder.build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; class compacting_sstable_writer_test { @@ -3355,7 +3353,7 @@ SEASTAR_TEST_CASE(incremental_compaction_data_resurrection_test) { auto s = builder.build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto next_timestamp = [] { @@ -3473,7 +3471,7 @@ SEASTAR_TEST_CASE(twcs_major_compaction_test) { auto s = builder.build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto next_timestamp = [] (auto step) { @@ -3542,7 +3540,7 @@ SEASTAR_TEST_CASE(autocompaction_control_test) { // generate a few sstables auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_insert = [&] (const dht::decorated_key& key) { mutation m(s, key); @@ -3584,7 +3582,6 @@ SEASTAR_TEST_CASE(autocompaction_control_test) { // SEASTAR_TEST_CASE(test_bug_6472) { return test_env::do_with_async([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto builder = schema_builder("tests", "test_bug_6472") .with_column("id", utf8_type, column_kind::partition_key) .with_column("cl", int32_type, column_kind::clustering_key) @@ -3598,8 +3595,8 @@ SEASTAR_TEST_CASE(test_bug_6472) { builder.set_gc_grace_seconds(0); auto s = builder.build(); - auto sst_gen = [&env, s, tmpdir_path, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmpdir_path, (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto next_timestamp = [] (auto step) { @@ -3618,7 +3615,7 @@ SEASTAR_TEST_CASE(test_bug_6472) { return m; }; - table_for_tests cf(env.manager(), s, tmpdir_path); + table_for_tests cf(env.manager(), s, env.tempdir().path().native()); auto close_cf = deferred_stop(cf); cf->start(); @@ -3693,7 +3690,6 @@ SEASTAR_TEST_CASE(sstable_needs_cleanup_test) { SEASTAR_TEST_CASE(test_twcs_partition_estimate) { return test_env::do_with_async([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto builder = schema_builder("tests", "test_bug_6472") .with_column("id", utf8_type, column_kind::partition_key) .with_column("cl", int32_type, column_kind::clustering_key) @@ -3709,8 +3705,8 @@ SEASTAR_TEST_CASE(test_twcs_partition_estimate) { const auto rows_per_partition = 200; - auto sst_gen = [&env, s, tmpdir_path, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, tmpdir_path, (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto next_timestamp = [] (int sstable_idx, int ck_idx) { @@ -3734,7 +3730,7 @@ SEASTAR_TEST_CASE(test_twcs_partition_estimate) { return make_sstable_containing(sst_gen, {m}); }; - table_for_tests cf(env.manager(), s, tmpdir_path); + table_for_tests cf(env.manager(), s, env.tempdir().path().native()); auto close_cf = deferred_stop(cf); cf->start(); @@ -3893,7 +3889,7 @@ SEASTAR_TEST_CASE(test_twcs_compaction_across_buckets) { return (gc_clock::now().time_since_epoch() - std::chrono::duration_cast(step)).count(); }; auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto pkey = tests::generate_partition_key(s); @@ -4022,7 +4018,7 @@ SEASTAR_TEST_CASE(twcs_reshape_with_disjoint_set_test) { }; auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::sstable::version_types::md, big); + return env.make_sstable(s, (*gen)++, sstables::sstable::version_types::md, big); }; { @@ -4157,7 +4153,7 @@ SEASTAR_TEST_CASE(stcs_reshape_overlapping_test) { }; auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::sstable::version_types::md, big); + return env.make_sstable(s, (*gen)++, sstables::sstable::version_types::md, big); }; { @@ -4199,7 +4195,7 @@ SEASTAR_TEST_CASE(test_twcs_single_key_reader_filtering) { auto s = builder.build(); auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::sstable::version_types::md, big); + return env.make_sstable(s, (*gen)++, sstables::sstable::version_types::md, big); }; auto make_row = [&] (int32_t pk, int32_t ck) { @@ -4530,7 +4526,7 @@ SEASTAR_TEST_CASE(twcs_single_key_reader_through_compound_set_test) { auto set2 = make_lw_shared(cs.make_sstable_set(s)); auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::sstable::version_types::md, big); + return env.make_sstable(s, (*gen)++, sstables::sstable::version_types::md, big); }; // sstables with same key but belonging to different windows @@ -4572,7 +4568,7 @@ SEASTAR_TEST_CASE(test_major_does_not_miss_data_in_memtable) { table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); auto sst_gen = [&env, &cf, s] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), column_family_test::calculate_generation_for_new_table(*cf), + return env.make_sstable(s, column_family_test::calculate_generation_for_new_table(*cf), sstables::get_highest_sstable_version(), big); }; @@ -4744,7 +4740,7 @@ SEASTAR_TEST_CASE(test_compaction_strategy_cleanup_method) { table_for_tests cf(env.manager(), s, env.tempdir().path().string()); auto close_cf = deferred_stop(cf); auto sst_gen = [&env, &cf, s]() mutable { - return env.make_sstable(s, env.tempdir().path().string(), column_family_test::calculate_generation_for_new_table(*cf), + return env.make_sstable(s, column_family_test::calculate_generation_for_new_table(*cf), sstables::get_highest_sstable_version(), big); }; @@ -4829,7 +4825,7 @@ SEASTAR_TEST_CASE(test_large_partition_splitting_on_compaction) { return (gc_clock::now().time_since_epoch() + duration_cast(step)).count(); }; auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto pkey = tests::generate_partition_key(s); table_for_tests cf(env.manager(), s); @@ -4899,7 +4895,7 @@ SEASTAR_TEST_CASE(test_large_partition_splitting_on_compaction) { position_in_partition::tri_compare pos_tri_cmp(*s); for (auto& sst : ret.new_sstables) { - sst = env.reusable_sst(s, env.tempdir().path().string(), sst->generation().value()).get0(); + sst = env.reusable_sst(s, sst->generation().value()).get0(); BOOST_REQUIRE(sst->may_have_partition_tombstones()); auto reader = sstable_reader(sst, s, env.make_reader_permit()); @@ -4956,7 +4952,7 @@ SEASTAR_TEST_CASE(check_table_sstable_set_includes_maintenance_sstables) { auto s = ss.schema(); auto pks = ss.make_pkeys(1); auto sst_gen = [&env, s] () { - return env.make_sstable(s, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, 1, sstables::get_highest_sstable_version(), big); }; auto mut1 = mutation(s, pks[0]); diff --git a/test/boost/sstable_datafile_test.cc b/test/boost/sstable_datafile_test.cc index 458e8aafe4..f27ffe0d07 100644 --- a/test/boost/sstable_datafile_test.cc +++ b/test/boost/sstable_datafile_test.cc @@ -92,7 +92,6 @@ static void assert_sstable_set_size(const sstable_set& s, size_t expected_size) SEASTAR_TEST_CASE(datafile_generation_09) { // Test that generated sstable components can be successfully loaded. return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = make_shared_schema({}, some_keyspace, some_column_family, {{"p1", utf8_type}}, {{"c1", utf8_type}}, {{"r1", int32_type}}, {}, utf8_type); @@ -107,10 +106,10 @@ SEASTAR_TEST_CASE(datafile_generation_09) { m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, 9, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, 9, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mt, sst).then([&env, mt, sst, s, tmpdir_path] { - auto sst2 = env.make_sstable(s, tmpdir_path, 9, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mt, sst).then([&env, mt, sst, s] { + auto sst2 = env.make_sstable(s, 9, sstables::get_highest_sstable_version(), big); return sstables::test(sst2).read_summary().then([sst, sst2] { summary& sst1_s = sstables::test(sst).get_summary(); @@ -135,7 +134,6 @@ SEASTAR_TEST_CASE(datafile_generation_09) { SEASTAR_TEST_CASE(datafile_generation_11) { return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = complex_schema(); auto mt = make_lw_shared(s); @@ -183,9 +181,9 @@ SEASTAR_TEST_CASE(datafile_generation_11) { }); }; - auto sst = env.make_sstable(s, tmpdir_path, 11, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s, sst, mt, verifier, tomb, &static_set_col, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, 11).then([&env, s, verifier, tomb, &static_set_col] (auto sstp) mutable { + auto sst = env.make_sstable(s, 11, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s, sst, mt, verifier, tomb, &static_set_col] { + return env.reusable_sst(s, 11).then([&env, s, verifier, tomb, &static_set_col] (auto sstp) mutable { return do_with(dht::partition_range::make_singular(make_dkey(s, "key1")), [&env, sstp, s, verifier, tomb, &static_set_col] (auto& pr) { auto rd = make_lw_shared(sstp->make_reader(s, env.make_reader_permit(), pr, s->full_slice())); return read_mutation_from_flat_mutation_reader(*rd).then([sstp, s, verifier, tomb, &static_set_col, rd] (auto mutation) { @@ -235,7 +233,6 @@ SEASTAR_TEST_CASE(datafile_generation_11) { SEASTAR_TEST_CASE(datafile_generation_12) { return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = complex_schema(); auto mt = make_lw_shared(s); @@ -249,9 +246,9 @@ SEASTAR_TEST_CASE(datafile_generation_12) { m.partition().apply_delete(*s, cp, tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, 12, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s, tomb, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, 12).then([&env, s, tomb] (auto sstp) mutable { + auto sst = env.make_sstable(s, 12, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s, tomb] { + return env.reusable_sst(s, 12).then([&env, s, tomb] (auto sstp) mutable { return do_with(dht::partition_range::make_singular(make_dkey(s, "key1")), [&env, sstp, s, tomb] (auto& pr) { auto rd = make_lw_shared(sstp->make_reader(s, env.make_reader_permit(), pr, s->full_slice())); return read_mutation_from_flat_mutation_reader(*rd).then([sstp, s, tomb, rd] (auto mutation) { @@ -271,7 +268,6 @@ SEASTAR_TEST_CASE(datafile_generation_12) { static future<> sstable_compression_test(compressor_ptr c, unsigned generation) { return test_env::do_with([c, generation] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); // NOTE: set a given compressor algorithm to schema. schema_builder builder(complex_schema()); builder.set_compressor_params(c); @@ -288,9 +284,9 @@ static future<> sstable_compression_test(compressor_ptr c, unsigned generation) m.partition().apply_delete(*s, cp, tomb); mtp->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, generation, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s, tomb, generation, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, generation).then([&env, s, tomb] (auto sstp) mutable { + auto sst = env.make_sstable(s, generation, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s, tomb, generation] { + return env.reusable_sst(s, generation).then([&env, s, tomb] (auto sstp) mutable { return do_with(dht::partition_range::make_singular(make_dkey(s, "key1")), [&env, sstp, s, tomb] (auto& pr) { auto rd = make_lw_shared(sstp->make_reader(s, env.make_reader_permit(), pr, s->full_slice())); return read_mutation_from_flat_mutation_reader(*rd).then([sstp, s, tomb, rd] (auto mutation) { @@ -322,7 +318,6 @@ SEASTAR_TEST_CASE(datafile_generation_15) { SEASTAR_TEST_CASE(datafile_generation_16) { return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = uncompressed_schema(); auto mtp = make_lw_shared(s); @@ -337,9 +332,9 @@ SEASTAR_TEST_CASE(datafile_generation_16) { mtp->apply(std::move(m)); } - auto sst = env.make_sstable(s, tmpdir_path, 16, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, 16).then([] (auto s) { + auto sst = env.make_sstable(s, 16, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s] { + return env.reusable_sst(s, 16).then([] (auto s) { // Not crashing is enough return make_ready_future<>(); }); @@ -359,7 +354,6 @@ static flat_mutation_reader_v2 sstable_reader_v2(shared_sstable sst, schema_ptr SEASTAR_TEST_CASE(datafile_generation_37) { return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = compact_simple_dense_schema(); auto mtp = make_lw_shared(s); @@ -373,9 +367,9 @@ SEASTAR_TEST_CASE(datafile_generation_37) { m.set_clustered_cell(c_key, cl2, make_atomic_cell(bytes_type, bytes_type->decompose(data_value(to_bytes("cl2"))))); mtp->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, 37, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, 37).then([&env, s, tmpdir_path] (auto sstp) { + auto sst = env.make_sstable(s, 37, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s] { + return env.reusable_sst(s, 37).then([&env, s] (auto sstp) { return do_with(dht::partition_range::make_singular(make_dkey(s, "key1")), [&env, sstp, s] (auto& pr) { auto rd = make_lw_shared(sstp->make_reader(s, env.make_reader_permit(), pr, s->full_slice())); return read_mutation_from_flat_mutation_reader(*rd).then([sstp, s, rd] (auto mutation) { @@ -397,7 +391,6 @@ SEASTAR_TEST_CASE(datafile_generation_37) { SEASTAR_TEST_CASE(datafile_generation_38) { return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = compact_dense_schema(); auto mtp = make_lw_shared(s); @@ -411,9 +404,9 @@ SEASTAR_TEST_CASE(datafile_generation_38) { m.set_clustered_cell(c_key, cl3, make_atomic_cell(bytes_type, bytes_type->decompose(data_value(to_bytes("cl3"))))); mtp->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, 38, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, 38).then([&env, s] (auto sstp) { + auto sst = env.make_sstable(s, 38, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s] { + return env.reusable_sst(s, 38).then([&env, s] (auto sstp) { return do_with(dht::partition_range::make_singular(make_dkey(s, "key1")), [&env, sstp, s] (auto& pr) { auto rd = make_lw_shared(sstp->make_reader(s, env.make_reader_permit(), pr, s->full_slice())); return read_mutation_from_flat_mutation_reader(*rd).then([sstp, s, rd] (auto mutation) { @@ -434,7 +427,6 @@ SEASTAR_TEST_CASE(datafile_generation_38) { SEASTAR_TEST_CASE(datafile_generation_39) { return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = compact_sparse_schema(); auto mtp = make_lw_shared(s); @@ -450,9 +442,9 @@ SEASTAR_TEST_CASE(datafile_generation_39) { m.set_clustered_cell(c_key, cl2, make_atomic_cell(bytes_type, bytes_type->decompose(data_value(to_bytes("cl2"))))); mtp->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, 39, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, 39).then([&env, s] (auto sstp) { + auto sst = env.make_sstable(s, 39, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mtp, sst).then([&env, s] { + return env.reusable_sst(s, 39).then([&env, s] (auto sstp) { return do_with(dht::partition_range::make_singular(make_dkey(s, "key1")), [&env, sstp, s] (auto& pr) { auto rd = make_lw_shared(sstp->make_reader(s, env.make_reader_permit(), pr, s->full_slice())); return read_mutation_from_flat_mutation_reader(*rd).then([sstp, s, rd] (auto mutation) { @@ -472,7 +464,6 @@ SEASTAR_TEST_CASE(datafile_generation_39) { SEASTAR_TEST_CASE(datafile_generation_41) { return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = make_shared_schema({}, some_keyspace, some_column_family, {{"p1", utf8_type}}, {{"c1", utf8_type}}, {{"r1", int32_type}, {"r2", int32_type}}, {}, utf8_type); @@ -486,9 +477,9 @@ SEASTAR_TEST_CASE(datafile_generation_41) { m.partition().apply_delete(*s, std::move(c_key), tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, 41, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s, tomb, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, 41).then([&env, s, tomb] (auto sstp) mutable { + auto sst = env.make_sstable(s, 41, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s, tomb] { + return env.reusable_sst(s, 41).then([&env, s, tomb] (auto sstp) mutable { return do_with(dht::partition_range::make_singular(make_dkey(s, "key1")), [&env, sstp, s, tomb] (auto& pr) { auto rd = make_lw_shared(sstp->make_reader(s, env.make_reader_permit(), pr, s->full_slice())); return read_mutation_from_flat_mutation_reader(*rd).then([sstp, s, tomb, rd] (auto mutation) { @@ -508,7 +499,6 @@ SEASTAR_TEST_CASE(datafile_generation_41) { SEASTAR_TEST_CASE(datafile_generation_47) { // Tests the problem in which the sstable row parser would hang. return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = make_shared_schema({}, some_keyspace, some_column_family, {{"p1", utf8_type}}, {{"c1", utf8_type}}, {{"r1", utf8_type}}, {}, utf8_type); @@ -522,9 +512,9 @@ SEASTAR_TEST_CASE(datafile_generation_47) { m.set_clustered_cell(c_key, r1_col, make_atomic_cell(utf8_type, bytes(512*1024, 'a'))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, 47, sstables::get_highest_sstable_version(), big); - return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s, tmpdir_path] { - return env.reusable_sst(s, tmpdir_path, 47).then([&env, s] (auto sstp) mutable { + auto sst = env.make_sstable(s, 47, sstables::get_highest_sstable_version(), big); + return write_memtable_to_sstable_for_test(*mt, sst).then([&env, s] { + return env.reusable_sst(s, 47).then([&env, s] (auto sstp) mutable { auto reader = make_lw_shared(sstable_reader_v2(sstp, s, env.make_reader_permit())); return repeat([reader] { return (*reader)().then([] (mutation_fragment_v2_opt m) { @@ -543,7 +533,6 @@ SEASTAR_TEST_CASE(datafile_generation_47) { SEASTAR_TEST_CASE(test_counter_write) { return test_env::do_with_async([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = schema_builder(some_keyspace, some_column_family) .with_column("p1", utf8_type, column_kind::partition_key) .with_column("c1", utf8_type, column_kind::clustering_key) @@ -581,10 +570,10 @@ SEASTAR_TEST_CASE(test_counter_write) { mt->apply(m); - auto sst = env.make_sstable(s, tmpdir_path, 900, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, 900, sstables::get_highest_sstable_version(), big); write_memtable_to_sstable_for_test(*mt, sst).get(); - auto sstp = env.reusable_sst(s, tmpdir_path, 900).get0(); + auto sstp = env.reusable_sst(s, 900).get0(); assert_that(sstable_reader_v2(sstp, s, env.make_reader_permit())) .produces(m) .produces_end_of_stream(); @@ -961,7 +950,6 @@ SEASTAR_TEST_CASE(test_counter_read) { SEASTAR_TEST_CASE(test_sstable_max_local_deletion_time) { return test_env::do_with_async([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); for (const auto version : writable_sstable_versions) { schema_builder builder(some_keyspace, some_column_family); builder.with_column("p1", utf8_type, column_kind::partition_key); @@ -979,9 +967,9 @@ SEASTAR_TEST_CASE(test_sstable_max_local_deletion_time) { make_atomic_cell(utf8_type, bytes("a"), 3600 + i, last_expiry)); mt->apply(std::move(m)); } - auto sst = env.make_sstable(s, tmpdir_path, 53, version, big); + auto sst = env.make_sstable(s, 53, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - auto sstp = env.reusable_sst(s, tmpdir_path, 53, version).get0(); + auto sstp = env.reusable_sst(s, 53, version).get0(); BOOST_REQUIRE(last_expiry == sstp->get_stats_metadata().max_local_deletion_time); } }); @@ -1094,9 +1082,9 @@ static void test_min_max_clustering_key(test_env& env, schema_ptr s, std::vector } } auto tmp = env.tempdir().make_sweeper(); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); + auto sst = env.make_sstable(s, 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); + sst = env.reusable_sst(s, 1, version).get0(); check_min_max_column_names(sst, std::move(min_components), std::move(max_components)); } @@ -1228,9 +1216,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply_delete(*s, c_key, tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); + auto sst = env.make_sstable(s, 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); + sst = env.reusable_sst(s, 1, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1"}, {"c1"}); } @@ -1240,9 +1228,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_dead_atomic_cell(3600)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 2, version, big); + auto sst = env.make_sstable(s, 2, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 2, version).get0(); + sst = env.reusable_sst(s, 2, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1"}, {"c1"}); } @@ -1252,9 +1240,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 3, version, big); + auto sst = env.make_sstable(s, 3, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 3, version).get0(); + sst = env.reusable_sst(s, 3, version).get0(); BOOST_REQUIRE(!sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1"}, {"c1"}); } @@ -1272,9 +1260,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { m2.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m2)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 4, version, big); + auto sst = env.make_sstable(s, 4, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 4, version).get0(); + sst = env.reusable_sst(s, 4, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1"}, {"c1"}); } @@ -1285,9 +1273,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply(tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 5, version, big); + auto sst = env.make_sstable(s, 5, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 5, version).get0(); + sst = env.reusable_sst(s, 5, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {}); } @@ -1300,9 +1288,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { "a")), clustering_key_prefix::from_single_value(*s, bytes("a")), tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 6, version, big); + auto sst = env.make_sstable(s, 6, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 6, version).get0(); + sst = env.reusable_sst(s, 6, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a"}, {"a"}); @@ -1320,9 +1308,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 7, version, big); + auto sst = env.make_sstable(s, 7, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 7, version).get0(); + sst = env.reusable_sst(s, 7, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a"}, {"c1"}); @@ -1340,9 +1328,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 8, version, big); + auto sst = env.make_sstable(s, 8, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 8, version).get0(); + sst = env.reusable_sst(s, 8, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c"}, {"d"}); @@ -1360,9 +1348,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 9, version, big); + auto sst = env.make_sstable(s, 9, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 9, version).get0(); + sst = env.reusable_sst(s, 9, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1"}, {"z"}); @@ -1381,9 +1369,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 10, version, big); + auto sst = env.make_sstable(s, 10, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 10, version).get0(); + sst = env.reusable_sst(s, 10, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {"z"}); } @@ -1399,9 +1387,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 11, version, big); + auto sst = env.make_sstable(s, 11, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 11, version).get0(); + sst = env.reusable_sst(s, 11, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"a"}, {}); } @@ -1413,9 +1401,9 @@ SEASTAR_TEST_CASE(sstable_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply_delete(*s, clustering_key_prefix::make_empty(), tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 12, version, big); + auto sst = env.make_sstable(s, 12, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 12, version).get0(); + sst = env.reusable_sst(s, 12, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {}); } @@ -1446,9 +1434,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply_delete(*s, c_key, tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); + auto sst = env.make_sstable(s, 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); + sst = env.reusable_sst(s, 1, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1458,9 +1446,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_dead_atomic_cell(3600)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 2, version, big); + auto sst = env.make_sstable(s, 2, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 2, version).get0(); + sst = env.reusable_sst(s, 2, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1470,9 +1458,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 3, version, big); + auto sst = env.make_sstable(s, 3, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 3, version).get0(); + sst = env.reusable_sst(s, 3, version).get0(); BOOST_REQUIRE(!sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1490,9 +1478,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { m2.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m2)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 4, version, big); + auto sst = env.make_sstable(s, 4, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 4, version).get0(); + sst = env.reusable_sst(s, 4, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1503,9 +1491,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply(tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 5, version, big); + auto sst = env.make_sstable(s, 5, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 5, version).get0(); + sst = env.reusable_sst(s, 5, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {}); } @@ -1520,9 +1508,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 6, version, big); + auto sst = env.make_sstable(s, 6, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 6, version).get0(); + sst = env.reusable_sst(s, 6, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a", "aa"}, {"z", "zz"}); @@ -1540,9 +1528,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 7, version, big); + auto sst = env.make_sstable(s, 7, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 7, version).get0(); + sst = env.reusable_sst(s, 7, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a"}, {"c1", "c2"}); @@ -1560,9 +1548,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 8, version, big); + auto sst = env.make_sstable(s, 8, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 8, version).get0(); + sst = env.reusable_sst(s, 8, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1", "aa"}, {"c1", "zz"}); @@ -1580,9 +1568,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 9, version, big); + auto sst = env.make_sstable(s, 9, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 9, version).get0(); + sst = env.reusable_sst(s, 9, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1", "c2"}, {"z", "zz"}); @@ -1601,9 +1589,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 10, version, big); + auto sst = env.make_sstable(s, 10, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 10, version).get0(); + sst = env.reusable_sst(s, 10, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {"z"}); } @@ -1619,9 +1607,9 @@ SEASTAR_TEST_CASE(sstable_composite_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 11, version, big); + auto sst = env.make_sstable(s, 11, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 11, version).get0(); + sst = env.reusable_sst(s, 11, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"a"}, {}); } @@ -1652,9 +1640,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply_delete(*s, c_key, tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, version, big); + auto sst = env.make_sstable(s, 1, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 1, version).get0(); + sst = env.reusable_sst(s, 1, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1664,9 +1652,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_dead_atomic_cell(3600)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 2, version, big); + auto sst = env.make_sstable(s, 2, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 2, version).get0(); + sst = env.reusable_sst(s, 2, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1676,9 +1664,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { mutation m(s, key); m.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 3, version, big); + auto sst = env.make_sstable(s, 3, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 3, version).get0(); + sst = env.reusable_sst(s, 3, version).get0(); BOOST_REQUIRE(!sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1696,9 +1684,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { m2.set_clustered_cell(c_key, r1_col, make_atomic_cell(int32_type, int32_type->decompose(1))); mt->apply(std::move(m2)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 4, version, big); + auto sst = env.make_sstable(s, 4, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 4, version).get0(); + sst = env.reusable_sst(s, 4, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"c1", "c2"}, {"c1", "c2"}); } @@ -1709,9 +1697,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tombstone tomb(api::new_timestamp(), gc_clock::now()); m.partition().apply(tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 5, version, big); + auto sst = env.make_sstable(s, 5, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 5, version).get0(); + sst = env.reusable_sst(s, 5, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {}); } @@ -1726,9 +1714,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 6, version, big); + auto sst = env.make_sstable(s, 6, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 6, version).get0(); + sst = env.reusable_sst(s, 6, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a", "zz"}, {"a", "aa"}); @@ -1746,9 +1734,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 7, version, big); + auto sst = env.make_sstable(s, 7, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 7, version).get0(); + sst = env.reusable_sst(s, 7, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"a", "zz"}, {"c1", "c2"}); @@ -1766,9 +1754,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 8, version, big); + auto sst = env.make_sstable(s, 8, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 8, version).get0(); + sst = env.reusable_sst(s, 8, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1", "zz"}, {"c1"}); @@ -1786,9 +1774,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 9, version, big); + auto sst = env.make_sstable(s, 9, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 9, version).get0(); + sst = env.reusable_sst(s, 9, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); if (version >= sstable_version_types::mc) { check_min_max_column_names(sst, {"c1", "zz"}, {"c1", "c2"}); @@ -1807,9 +1795,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 10, version, big); + auto sst = env.make_sstable(s, 10, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 10, version).get0(); + sst = env.reusable_sst(s, 10, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {}, {"z"}); } @@ -1825,9 +1813,9 @@ SEASTAR_TEST_CASE(sstable_composite_reverse_tombstone_metadata_check) { tomb); m.partition().apply_delete(*s, std::move(rt)); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, env.tempdir().path().string(), 11, version, big); + auto sst = env.make_sstable(s, 11, version, big); write_memtable_to_sstable_for_test(*mt, sst).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 11, version).get0(); + sst = env.reusable_sst(s, 11, version).get0(); BOOST_REQUIRE(sst->get_stats_metadata().estimated_tombstone_drop_time.bin.size()); check_min_max_column_names(sst, {"a"}, {}); } @@ -2231,7 +2219,7 @@ SEASTAR_TEST_CASE(sstable_tombstone_histogram_test) { auto s = builder.build(); auto sst_gen = [&env, s, gen = make_lw_shared(1), version]() mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, version, big); + return env.make_sstable(s, (*gen)++, version, big); }; auto next_timestamp = [] { @@ -2254,7 +2242,7 @@ SEASTAR_TEST_CASE(sstable_tombstone_histogram_test) { } auto sst = make_sstable_containing(sst_gen, mutations); auto histogram = sst->get_stats_metadata().estimated_tombstone_drop_time; - sst = env.reusable_sst(s, env.tempdir().path().string(), generation_value(sst->generation()), version).get0(); + sst = env.reusable_sst(s, generation_value(sst->generation()), version).get0(); auto histogram2 = sst->get_stats_metadata().estimated_tombstone_drop_time; // check that histogram respected limit @@ -2301,12 +2289,12 @@ SEASTAR_TEST_CASE(sstable_owner_shards) { | boost::adaptors::transformed([&] (auto shard) { return mut(shard); })); auto sst_gen = [&env, s, gen, ignore_msb] () mutable { auto schema = schema_builder(s).with_sharder(1, ignore_msb).build(); - auto sst = env.make_sstable(std::move(schema), env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(std::move(schema), (*gen)++, sstables::get_highest_sstable_version(), big); return sst; }; auto sst = make_sstable_containing(sst_gen, std::move(muts)); auto schema = schema_builder(s).with_sharder(smp_count, ignore_msb).build(); - sst = env.reusable_sst(std::move(schema), env.tempdir().path().string(), generation_value(sst->generation())).get0(); + sst = env.reusable_sst(std::move(schema), generation_value(sst->generation())).get0(); return sst; }; @@ -2359,10 +2347,10 @@ SEASTAR_TEST_CASE(test_summary_entry_spanning_more_keys_than_min_interval) { } auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto sst = make_sstable_containing(sst_gen, mutations); - sst = env.reusable_sst(s, env.tempdir().path().string(), generation_value(sst->generation())).get0(); + sst = env.reusable_sst(s, generation_value(sst->generation())).get0(); summary& sum = sstables::test(sst).get_summary(); BOOST_REQUIRE(sum.entries.size() == 1); @@ -2562,7 +2550,7 @@ SEASTAR_TEST_CASE(summary_rebuild_sanity) { } auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto sst = make_sstable_containing(sst_gen, mutations); @@ -2570,7 +2558,7 @@ SEASTAR_TEST_CASE(summary_rebuild_sanity) { BOOST_REQUIRE(s1.entries.size() > 1); sstables::test(sst).remove_component(component_type::Summary).get(); - sst = env.reusable_sst(s, env.tempdir().path().string(), 1).get0(); + sst = env.reusable_sst(s, 1).get0(); summary& s2 = sstables::test(sst).get_summary(); BOOST_REQUIRE(::memcmp(&s1.header, &s2.header, sizeof(summary::header)) == 0); @@ -2605,7 +2593,7 @@ SEASTAR_TEST_CASE(sstable_partition_estimation_sanity_test) { }; auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; { @@ -2645,7 +2633,7 @@ SEASTAR_TEST_CASE(sstable_timestamp_metadata_correcness_with_negative) { .with_column("value", int32_type).build(); auto sst_gen = [&env, s, gen = make_lw_shared(1), version]() mutable { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, version, big); + return env.make_sstable(s, (*gen)++, version, big); }; auto make_insert = [&](partition_key key, api::timestamp_type ts) { @@ -2728,7 +2716,7 @@ SEASTAR_TEST_CASE(sstable_run_clustering_disjoint_invariant_test) { auto s = ss.schema(); auto pks = ss.make_pkeys(1); auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { - return env.make_sstable(s, env.tempdir().path().string(), (*gen)++, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); }; auto make_sstable = [&] (int first_ckey_idx, int last_ckey_idx) { @@ -2901,7 +2889,7 @@ SEASTAR_TEST_CASE(test_may_have_partition_tombstones) { ss.add_row(mut2, ss.make_ckey(6), "val"); auto sst_gen = [&env, s, &gen, version] () { - return env.make_sstable(s, env.tempdir().path().string(), ++gen, version, big); + return env.make_sstable(s, ++gen, version, big); }; { @@ -2918,7 +2906,6 @@ SEASTAR_TEST_CASE(test_may_have_partition_tombstones) { SEASTAR_TEST_CASE(test_missing_partition_end_fragment) { return test_env::do_with_async([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); simple_schema ss; auto s = ss.schema(); @@ -2941,7 +2928,7 @@ SEASTAR_TEST_CASE(test_missing_partition_end_fragment) { auto mr = make_flat_mutation_reader_from_fragments(s, env.make_reader_permit(), std::move(frags)); auto close_mr = deferred_close(mr); - auto sst = env.make_sstable(s, tmpdir_path, 0, version, big); + auto sst = env.make_sstable(s, 0, version, big); sstable_writer_config cfg = env.manager().configure_writer(); try { @@ -3035,7 +3022,6 @@ SEASTAR_TEST_CASE(compound_sstable_set_basic_test) { SEASTAR_TEST_CASE(sstable_reader_with_timeout) { return test_env::do_with_async([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); auto s = complex_schema(); auto mt = make_lw_shared(s); @@ -3049,9 +3035,9 @@ SEASTAR_TEST_CASE(sstable_reader_with_timeout) { m.partition().apply_delete(*s, cp, tomb); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, 12, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, 12, sstables::get_highest_sstable_version(), big); write_memtable_to_sstable_for_test(*mt, sst).get(); - auto sstp = env.reusable_sst(s, tmpdir_path, 12).get0(); + auto sstp = env.reusable_sst(s, 12).get0(); auto pr = dht::partition_range::make_singular(make_dkey(s, "key1")); auto timeout = db::timeout_clock::now(); auto rd = sstp->make_reader(s, env.make_reader_permit(timeout), pr, s->full_slice()); @@ -3063,7 +3049,6 @@ SEASTAR_TEST_CASE(sstable_reader_with_timeout) { SEASTAR_TEST_CASE(test_validate_checksums) { return test_env::do_with_async([&] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); tests::reader_concurrency_semaphore_wrapper semaphore; auto random_spec = tests::make_random_schema_specification( get_name(), @@ -3093,7 +3078,7 @@ SEASTAR_TEST_CASE(test_validate_checksums) { auto mr = make_flat_mutation_reader_from_mutations_v2(schema, permit, muts); auto close_mr = deferred_close(mr); - auto sst = env.make_sstable(sst_schema, tmpdir_path, gen++, version, big); + auto sst = env.make_sstable(sst_schema, gen++, version, big); sstable_writer_config cfg = env.manager().configure_writer(); auto wr = sst->get_writer(*sst_schema, 1, cfg, encoding_stats{}, default_priority_class()); @@ -3142,7 +3127,7 @@ SEASTAR_TEST_CASE(partial_sstable_deletion_test) { auto s = ss.schema(); auto pks = ss.make_pkeys(1); auto sst_gen = [&env, s] () { - return env.make_sstable(s, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, 1, sstables::get_highest_sstable_version(), big); }; auto mut1 = mutation(s, pks[0]); @@ -3158,7 +3143,6 @@ SEASTAR_TEST_CASE(partial_sstable_deletion_test) { SEASTAR_TEST_CASE(test_index_fast_forwarding_after_eof) { return test_env::do_with_async([&] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); tests::reader_concurrency_semaphore_wrapper semaphore; auto random_spec = tests::make_random_schema_specification( get_name(), @@ -3174,7 +3158,7 @@ SEASTAR_TEST_CASE(test_index_fast_forwarding_after_eof) { const auto muts = tests::generate_random_mutations(random_schema, 2).get(); - auto sst = env.make_sstable(schema, tmpdir_path, 0, writable_sstable_versions.back(), big); + auto sst = env.make_sstable(schema, 0, writable_sstable_versions.back(), big); { auto mr = make_flat_mutation_reader_from_mutations_v2(schema, permit, muts); auto close_mr = deferred_close(mr); @@ -3226,7 +3210,7 @@ SEASTAR_TEST_CASE(test_crawling_reader_out_of_range_last_range_tombstone_change) table.delete_range(mut, query::clustering_range::make(bound{ckeys[3], true}, bound{clustering_key::make_empty(), true}), tombstone(1, gc_clock::now())); auto sst_gen = [&env, &table] () { - return env.make_sstable(table.schema(), env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); + return env.make_sstable(table.schema(), 1, sstables::get_highest_sstable_version(), big); }; auto sst = make_sstable_containing(sst_gen, {mut}); @@ -3250,7 +3234,7 @@ SEASTAR_TEST_CASE(test_crawling_reader_random_schema_random_mutations) { const auto muts = tests::generate_random_mutations(random_schema, 20).get(); auto sst_gen = [&env, schema] () { - return env.make_sstable(schema, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); + return env.make_sstable(schema, 1, sstables::get_highest_sstable_version(), big); }; auto sst = make_sstable_containing(sst_gen, muts); @@ -3281,7 +3265,7 @@ SEASTAR_TEST_CASE(find_first_position_in_partition_from_sstable_test) { auto pks = ss.make_pkeys(partitions); auto tmp = env.tempdir().make_sweeper(); auto sst_gen = [&env, s]() { - return env.make_sstable(s, env.tempdir().path().string(), 1, sstables::get_highest_sstable_version(), big); + return env.make_sstable(s, 1, sstables::get_highest_sstable_version(), big); }; std::vector muts; diff --git a/test/boost/sstable_mutation_test.cc b/test/boost/sstable_mutation_test.cc index 3c0f5bf3a6..db8218d5a6 100644 --- a/test/boost/sstable_mutation_test.cc +++ b/test/boost/sstable_mutation_test.cc @@ -415,7 +415,6 @@ SEASTAR_TEST_CASE(test_sstable_can_write_and_read_range_tombstone) { mt->apply(std::move(m)); auto sst = env.make_sstable(s, - env.tempdir().path().string(), 1 /* generation */, sstables::get_highest_sstable_version(), sstables::sstable::format_types::big); @@ -858,7 +857,6 @@ SEASTAR_TEST_CASE(test_non_compound_table_row_is_not_marked_as_static) { mt->apply(std::move(m)); auto sst = env.make_sstable(s, - env.tempdir().path().string(), 1 /* generation */, version, sstables::sstable::format_types::big); @@ -892,7 +890,6 @@ SEASTAR_TEST_CASE(test_has_partition_key) { mt->apply(std::move(m)); auto sst = env.make_sstable(s, - env.tempdir().path().string(), 1 /* generation */, version, sstables::sstable::format_types::big); @@ -1471,11 +1468,11 @@ SEASTAR_TEST_CASE(test_reading_serialization_header) { // SSTable class has way too many responsibilities. In particular, it mixes the reading and // writting parts. Let's use a separate objects for writing and reading to ensure that nothing // carries over that wouldn't normally be read from disk. - auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, sstable::version_types::mc, sstables::sstable::format_types::big); + auto sst = env.make_sstable(s, 1, sstable::version_types::mc, sstables::sstable::format_types::big); sst->write_components(mt->make_flat_reader(s, env.make_reader_permit()), 2, s, env.manager().configure_writer(), mt->get_encoding_stats()).get(); } - auto sst = env.make_sstable(s, env.tempdir().path().string(), 1, sstable::version_types::mc, sstables::sstable::format_types::big); + auto sst = env.make_sstable(s, 1, sstable::version_types::mc, sstables::sstable::format_types::big); sst->load().get(); auto hdr = sst->get_serialization_header(); @@ -1656,7 +1653,7 @@ SEASTAR_TEST_CASE(writer_handles_subsequent_range_tombstone_changes_without_tomb deferred_close dc1{input_reader}; sstable_writer_config cfg = env.manager().configure_writer(); auto _ = env.tempdir().make_sweeper(); - shared_sstable sstable = env.make_sstable(s, env.tempdir().path().string(), 0); + shared_sstable sstable = env.make_sstable(s, 0); encoding_stats es; sstable->write_components(std::move(input_reader), 1, s, cfg, es).get(); sstable->load().get(); From 2bbc59dd580f8262a70c189175a202c92b773d33 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 11:59:17 +0300 Subject: [PATCH 08/16] test: Remove last occurrence of test_env::do_with(rval, ...) There's the lonely test case that uses the mentioned template to carry its own instance of tempdir over its lifetime. Patch the case to re-use the already existing env's tempdir and drop the template. Signed-off-by: Pavel Emelyanov --- test/boost/sstable_test.cc | 6 +++--- test/lib/sstable_test_env.hh | 9 --------- 2 files changed, 3 insertions(+), 12 deletions(-) diff --git a/test/boost/sstable_test.cc b/test/boost/sstable_test.cc index c6d7e23a5c..deaae65299 100644 --- a/test/boost/sstable_test.cc +++ b/test/boost/sstable_test.cc @@ -242,9 +242,9 @@ SEASTAR_TEST_CASE(check_compressed_info_func) { future<> write_and_validate_sst(schema_ptr s, sstring dir, noncopyable_function (shared_sstable sst1, shared_sstable sst2)> func) { - return test_env::do_with(tmpdir(), [s = std::move(s), dir = std::move(dir), func = std::move(func)] (test_env& env, tmpdir& tmp) mutable { - return do_write_sst(env, s, dir, tmp.path().string(), 1).then([&env, &tmp, s = std::move(s), func = std::move(func)] (auto sst1) { - auto sst2 = env.make_sstable(s, tmp.path().string(), 2, sst1->get_version()); + return test_env::do_with([s = std::move(s), dir = std::move(dir), func = std::move(func)] (test_env& env) mutable { + return do_write_sst(env, s, dir, env.tempdir().path().string(), 1).then([&env, s = std::move(s), func = std::move(func)] (auto sst1) { + auto sst2 = env.make_sstable(s, 2, sst1->get_version()); return func(std::move(sst1), std::move(sst2)); }); }); diff --git a/test/lib/sstable_test_env.hh b/test/lib/sstable_test_env.hh index cb6fdd08d9..cb794f345f 100644 --- a/test/lib/sstable_test_env.hh +++ b/test/lib/sstable_test_env.hh @@ -135,15 +135,6 @@ public: }); } - template - static inline auto do_with(T&& rval, Func&& func) { - return seastar::do_with(test_env(), std::forward(rval), [func = std::move(func)] (test_env& env, T& val) mutable { - return futurize_invoke(func, env, val).finally([&env] { - return env.stop(); - }); - }); - } - static inline future<> do_with_async(noncopyable_function func, test_env_config cfg = {}) { return seastar::async([func = std::move(func), cfg = std::move(cfg)] () mutable { test_env env(std::move(cfg)); From bc208799716642d205382b9c974dd3fd1cd9c7a9 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 12:12:58 +0300 Subject: [PATCH 09/16] test/lib: Add sstable maker helper without factory There's a make_sstable_containing() helper that creates sstable and populates it with mutations (and makes some post validation). The helper accepts a factory function that should make sstable for it. This patch shuffles this helper a bit by introducing an overload that populates (and validates) the already existing sstable. Signed-off-by: Pavel Emelyanov --- test/lib/sstable_utils.cc | 5 ++++- test/lib/sstable_utils.hh | 1 + 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/test/lib/sstable_utils.cc b/test/lib/sstable_utils.cc index badc234144..43fecaa774 100644 --- a/test/lib/sstable_utils.cc +++ b/test/lib/sstable_utils.cc @@ -25,9 +25,12 @@ using namespace sstables; using namespace std::chrono_literals; sstables::shared_sstable make_sstable_containing(std::function sst_factory, std::vector muts) { + return make_sstable_containing(sst_factory(), std::move(muts)); +} + +sstables::shared_sstable make_sstable_containing(sstables::shared_sstable sst, std::vector muts) { tests::reader_concurrency_semaphore_wrapper semaphore; - auto sst = sst_factory(); schema_ptr s = muts[0].schema(); auto mt = make_lw_shared(s); diff --git a/test/lib/sstable_utils.hh b/test/lib/sstable_utils.hh index a912c8b12c..a4ee88a0ac 100644 --- a/test/lib/sstable_utils.hh +++ b/test/lib/sstable_utils.hh @@ -26,6 +26,7 @@ using namespace sstables; using namespace std::chrono_literals; sstables::shared_sstable make_sstable_containing(std::function sst_factory, std::vector muts); +sstables::shared_sstable make_sstable_containing(sstables::shared_sstable sst, std::vector muts); inline future<> write_memtable_to_sstable_for_test(replica::memtable& mt, sstables::shared_sstable sst) { return write_memtable_to_sstable(mt, sst, sst->manager().configure_writer("memtable")); From be7f4ff53a73a7a0817629160a5ac7e306a1b616 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 12:13:11 +0300 Subject: [PATCH 10/16] test/sstable::test_env: Keep track of auto-incrementing generation Lots of test cases make sstables with monotonically incrementing generation values. In Scylla code this counter is maintained in class table, but sstable tests not always have it. To mimic this behavior, the test_env can keep track of the generation, so that callers just don't mess with it (next patch). Signed-off-by: Pavel Emelyanov --- test/lib/sstable_test_env.hh | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/test/lib/sstable_test_env.hh b/test/lib/sstable_test_env.hh index cb794f345f..f072fee6d1 100644 --- a/test/lib/sstable_test_env.hh +++ b/test/lib/sstable_test_env.hh @@ -55,6 +55,7 @@ class test_env { db::nop_large_data_handler nop_ld_handler; test_env_sstables_manager mgr; reader_concurrency_semaphore semaphore; + unsigned generation = 1; impl(test_env_config cfg); impl(impl&&) = delete; @@ -83,6 +84,10 @@ public: return make_sstable(std::move(schema), _impl->dir.path().native(), generation, std::move(v), std::move(f), buffer_size, now); } + shared_sstable make_sstable(schema_ptr schema, sstable::version_types v = sstables::get_highest_sstable_version()) { + return make_sstable(std::move(schema), _impl->generation++, std::move(v)); + } + struct sst_not_found : public std::runtime_error { sst_not_found(const sstring& dir, unsigned long generation) : std::runtime_error(format("no versions of sstable generation {} found in {}", generation, dir)) From ef8928f2cc911e8f5354beb12593509b0fdea8d9 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 12:13:25 +0300 Subject: [PATCH 11/16] test: Relax making sstable with sequential generation Many test cases populate sstable with a factory that at the same time serves as a stable maintainer of a monitomic generation. Those can be greately relaxed by re-using the recently introduced generation from the test_env. Signed-off-by: Pavel Emelyanov --- test/boost/sstable_compaction_test.cc | 64 +++++++-------------------- test/boost/sstable_datafile_test.cc | 64 ++++++--------------------- test/boost/sstable_mutation_test.cc | 15 ++----- 3 files changed, 31 insertions(+), 112 deletions(-) diff --git a/test/boost/sstable_compaction_test.cc b/test/boost/sstable_compaction_test.cc index 54d2aa7fe2..f1bc3e7d2a 100644 --- a/test/boost/sstable_compaction_test.cc +++ b/test/boost/sstable_compaction_test.cc @@ -1552,10 +1552,6 @@ SEASTAR_TEST_CASE(time_window_strategy_correctness_test) { .with_column("id", utf8_type, column_kind::partition_key) .with_column("value", int32_type).build(); - auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); - }; - auto make_insert = [&] (partition_key key, api::timestamp_type t) { mutation m(s, key); m.set_clustered_cell(clustering_key::make_empty(), bytes("value"), data_value(int32_t(1)), t); @@ -1571,14 +1567,14 @@ SEASTAR_TEST_CASE(time_window_strategy_correctness_test) { for (api::timestamp_type t = 0; t < 3; t++) { auto key = partition_key::from_exploded(*s, {to_bytes("key" + to_sstring(t))}); auto mut = make_insert(std::move(key), t); - sstables.push_back(make_sstable_containing(sst_gen, {std::move(mut)})); + sstables.push_back(make_sstable_containing(env.make_sstable(s), {std::move(mut)})); } // Decrement the timestamp to simulate a timestamp in the past hour for (api::timestamp_type t = 3; t < 5; t++) { // And add progressively more cells into each sstable auto key = partition_key::from_exploded(*s, {to_bytes("key" + to_sstring(t))}); auto mut = make_insert(std::move(key), t); - sstables.push_back(make_sstable_containing(sst_gen, {std::move(mut)})); + sstables.push_back(make_sstable_containing(env.make_sstable(s), {std::move(mut)})); } std::map options; @@ -1625,7 +1621,7 @@ SEASTAR_TEST_CASE(time_window_strategy_correctness_test) { for (int i = 0 ; i < r ; i++) { mutations.push_back(make_insert(key, tstamp + r)); } - sstables.push_back(make_sstable_containing(sst_gen, std::move(mutations))); + sstables.push_back(make_sstable_containing(env.make_sstable(s), std::move(mutations))); } // Reset the buckets, overfill it now @@ -2175,12 +2171,8 @@ SEASTAR_TEST_CASE(sstable_scrub_validate_mode_test) { .with_column("v", int32_type).build(); auto permit = env.make_reader_permit(); - auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, (*gen)++); - }; - auto scrubbed_mt = make_lw_shared(schema); - auto sst = sst_gen(); + auto sst = env.make_sstable(schema); testlog.info("Writing sstable {}", sst->get_filename()); @@ -2372,12 +2364,8 @@ SEASTAR_TEST_CASE(sstable_scrub_skip_mode_test) { .with_column("v", int32_type).build(); auto permit = env.make_reader_permit(); - auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, (*gen)++); - }; - std::vector scrubbed_fragments; - auto sst = sst_gen(); + auto sst = env.make_sstable(schema); const auto corrupt_fragments = write_corrupt_sstable(env, *sst, permit, [&] (mutation_fragment_v2&& mf, bool is_corrupt) { if (!is_corrupt) { @@ -2465,12 +2453,8 @@ SEASTAR_TEST_CASE(sstable_scrub_segregate_mode_test) { .with_column("v", int32_type).build(); auto permit = env.make_reader_permit(); - auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, (*gen)++); - }; - auto scrubbed_mt = make_lw_shared(schema); - auto sst = sst_gen(); + auto sst = env.make_sstable(schema); testlog.info("Writing sstable {}", sst->get_filename()); @@ -2575,12 +2559,8 @@ SEASTAR_TEST_CASE(sstable_scrub_quarantine_mode_test) { .with_column("v", int32_type).build(); auto permit = env.make_reader_permit(); - auto sst_gen = [&env, schema, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(schema, (*gen)++); - }; - auto scrubbed_mt = make_lw_shared(schema); - auto sst = sst_gen(); + auto sst = env.make_sstable(schema); testlog.info("Writing sstable {}", sst->get_filename()); @@ -3051,9 +3031,6 @@ SEASTAR_TEST_CASE(compaction_strategy_aware_major_compaction_test) { .with_column("id", utf8_type, column_kind::partition_key) .with_column("value", int32_type).build(); - auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); - }; auto make_insert = [&] (partition_key key) { mutation m(s, key); m.set_clustered_cell(clustering_key::make_empty(), bytes("value"), data_value(int32_t(1)), api::timestamp_type(0)); @@ -3061,9 +3038,9 @@ SEASTAR_TEST_CASE(compaction_strategy_aware_major_compaction_test) { }; auto alpha = partition_key::from_exploded(*s, {to_bytes("alpha")}); - auto sst = make_sstable_containing(sst_gen, {make_insert(alpha)}); + auto sst = make_sstable_containing(env.make_sstable(s), {make_insert(alpha)}); sst->set_sstable_level(2); - auto sst2 = make_sstable_containing(sst_gen, {make_insert(alpha)}); + auto sst2 = make_sstable_containing(env.make_sstable(s), {make_insert(alpha)}); sst2->set_sstable_level(3); auto candidates = std::vector({ sst, sst2 }); @@ -3196,10 +3173,6 @@ SEASTAR_TEST_CASE(purged_tombstone_consumer_sstable_test) { builder.set_gc_grace_seconds(0); auto s = builder.build(); - auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); - }; - class compacting_sstable_writer_test { shared_sstable& _sst; sstable_writer _writer; @@ -3231,8 +3204,8 @@ SEASTAR_TEST_CASE(purged_tombstone_consumer_sstable_test) { return max_purgeable_ts; }; - auto non_purged = sst_gen(); - auto purged_only = sst_gen(); + auto non_purged = env.make_sstable(s); + auto purged_only = env.make_sstable(s); auto cr = compacting_sstable_writer_test(s, non_purged, env.manager()); auto purged_cr = compacting_sstable_writer_test(s, purged_only, env.manager()); @@ -3310,8 +3283,8 @@ SEASTAR_TEST_CASE(purged_tombstone_consumer_sstable_test) { auto [mut3, mut3_tombstone] = make_delete(alpha); std::vector sstables = { - make_sstable_containing(sst_gen, {mut1, mut2}), - make_sstable_containing(sst_gen, {mut3}) + make_sstable_containing(env.make_sstable(s), {mut1, mut2}), + make_sstable_containing(env.make_sstable(s), {mut3}) }; forward_jump_clocks(std::chrono::seconds(ttl)); @@ -3538,10 +3511,6 @@ SEASTAR_TEST_CASE(autocompaction_control_test) { // check it is disabled BOOST_REQUIRE(cf->is_auto_compaction_disabled_by_user()); - // generate a few sstables - auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); - }; auto make_insert = [&] (const dht::decorated_key& key) { mutation m(s, key); m.set_clustered_cell(clustering_key::make_empty(), bytes("value"), data_value(int32_t(1)), 1 /* ts */); @@ -3551,7 +3520,7 @@ SEASTAR_TEST_CASE(autocompaction_control_test) { const auto keys = tests::generate_partition_keys(1, s); for (auto i = 0; i < 2 * min_threshold; ++i) { auto mut = make_insert(keys[0]); - auto sst = make_sstable_containing(sst_gen, {mut}); + auto sst = make_sstable_containing(env.make_sstable(s), {mut}); cf->add_sstable_and_update_cache(sst).wait(); } @@ -4951,13 +4920,10 @@ SEASTAR_TEST_CASE(check_table_sstable_set_includes_maintenance_sstables) { simple_schema ss; auto s = ss.schema(); auto pks = ss.make_pkeys(1); - auto sst_gen = [&env, s] () { - return env.make_sstable(s, 1, sstables::get_highest_sstable_version(), big); - }; auto mut1 = mutation(s, pks[0]); mut1.partition().apply_insert(*s, ss.make_ckey(0), ss.new_timestamp()); - auto sst = make_sstable_containing(sst_gen, {std::move(mut1)}); + auto sst = make_sstable_containing(env.make_sstable(s), {std::move(mut1)}); table_for_tests cf(env.manager(), s); auto close_cf = deferred_stop(cf); diff --git a/test/boost/sstable_datafile_test.cc b/test/boost/sstable_datafile_test.cc index f27ffe0d07..bf0205eadf 100644 --- a/test/boost/sstable_datafile_test.cc +++ b/test/boost/sstable_datafile_test.cc @@ -2218,10 +2218,6 @@ SEASTAR_TEST_CASE(sstable_tombstone_histogram_test) { .with_column("value", int32_type); auto s = builder.build(); - auto sst_gen = [&env, s, gen = make_lw_shared(1), version]() mutable { - return env.make_sstable(s, (*gen)++, version, big); - }; - auto next_timestamp = [] { static thread_local api::timestamp_type next = 1; return next++; @@ -2240,7 +2236,7 @@ SEASTAR_TEST_CASE(sstable_tombstone_histogram_test) { mutations.push_back(make_delete(key)); forward_jump_clocks(std::chrono::seconds(1)); } - auto sst = make_sstable_containing(sst_gen, mutations); + auto sst = make_sstable_containing(env.make_sstable(s, version), mutations); auto histogram = sst->get_stats_metadata().estimated_tombstone_drop_time; sst = env.reusable_sst(s, generation_value(sst->generation()), version).get0(); auto histogram2 = sst->get_stats_metadata().estimated_tombstone_drop_time; @@ -2346,10 +2342,7 @@ SEASTAR_TEST_CASE(test_summary_entry_spanning_more_keys_than_min_interval) { keys_written++; } - auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); - }; - auto sst = make_sstable_containing(sst_gen, mutations); + auto sst = make_sstable_containing(env.make_sstable(s), mutations); sst = env.reusable_sst(s, generation_value(sst->generation())).get0(); summary& sum = sstables::test(sst).get_summary(); @@ -2549,10 +2542,7 @@ SEASTAR_TEST_CASE(summary_rebuild_sanity) { mutations.push_back(make_insert(partition_key::from_exploded(*s, {std::move(key)}))); } - auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); - }; - auto sst = make_sstable_containing(sst_gen, mutations); + auto sst = make_sstable_containing(env.make_sstable(s), mutations); summary s1 = sstables::test(sst).move_summary(); BOOST_REQUIRE(s1.entries.size() > 1); @@ -2592,10 +2582,6 @@ SEASTAR_TEST_CASE(sstable_partition_estimation_sanity_test) { return m; }; - auto sst_gen = [&env, s, gen = make_lw_shared(1)] () mutable { - return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); - }; - { auto total_partitions = s->min_index_interval()*2; @@ -2604,7 +2590,7 @@ SEASTAR_TEST_CASE(sstable_partition_estimation_sanity_test) { auto key = to_bytes("key" + to_sstring(i)); mutations.push_back(make_large_partition(partition_key::from_exploded(*s, {std::move(key)}))); } - auto sst = make_sstable_containing(sst_gen, mutations); + auto sst = make_sstable_containing(env.make_sstable(s), mutations); BOOST_REQUIRE(std::abs(int64_t(total_partitions) - int64_t(sst->get_estimated_key_count())) <= s->min_index_interval()); } @@ -2617,7 +2603,7 @@ SEASTAR_TEST_CASE(sstable_partition_estimation_sanity_test) { auto key = to_bytes("key" + to_sstring(i)); mutations.push_back(make_small_partition(partition_key::from_exploded(*s, {std::move(key)}))); } - auto sst = make_sstable_containing(sst_gen, mutations); + auto sst = make_sstable_containing(env.make_sstable(s), mutations); BOOST_REQUIRE(std::abs(int64_t(total_partitions) - int64_t(sst->get_estimated_key_count())) <= s->min_index_interval()); } @@ -2632,10 +2618,6 @@ SEASTAR_TEST_CASE(sstable_timestamp_metadata_correcness_with_negative) { .with_column("id", utf8_type, column_kind::partition_key) .with_column("value", int32_type).build(); - auto sst_gen = [&env, s, gen = make_lw_shared(1), version]() mutable { - return env.make_sstable(s, (*gen)++, version, big); - }; - auto make_insert = [&](partition_key key, api::timestamp_type ts) { mutation m(s, key); m.set_clustered_cell(clustering_key::make_empty(), bytes("value"), data_value(int32_t(1)), ts); @@ -2648,7 +2630,7 @@ SEASTAR_TEST_CASE(sstable_timestamp_metadata_correcness_with_negative) { auto mut1 = make_insert(alpha, -50); auto mut2 = make_insert(beta, 5); - auto sst = make_sstable_containing(sst_gen, {mut1, mut2}); + auto sst = make_sstable_containing(env.make_sstable(s, version), {mut1, mut2}); BOOST_REQUIRE(sst->get_stats_metadata().min_timestamp == -50); BOOST_REQUIRE(sst->get_stats_metadata().max_timestamp == 5); @@ -2715,9 +2697,6 @@ SEASTAR_TEST_CASE(sstable_run_clustering_disjoint_invariant_test) { simple_schema ss; auto s = ss.schema(); auto pks = ss.make_pkeys(1); - auto sst_gen = [&env, s, gen = make_lw_shared(1)]() { - return env.make_sstable(s, (*gen)++, sstables::get_highest_sstable_version(), big); - }; auto make_sstable = [&] (int first_ckey_idx, int last_ckey_idx) { std::vector muts; @@ -2731,7 +2710,7 @@ SEASTAR_TEST_CASE(sstable_run_clustering_disjoint_invariant_test) { } muts.push_back(std::move(mut)); - auto sst = make_sstable_containing(sst_gen, std::move(muts)); + auto sst = make_sstable_containing(env.make_sstable(s), std::move(muts)); BOOST_REQUIRE(sst->min_position().key() == first_ckey_prefix); BOOST_REQUIRE(sst->max_position().key() == last_ckey_prefix); @@ -2874,7 +2853,6 @@ SEASTAR_TEST_CASE(test_may_have_partition_tombstones) { auto s = ss.schema(); auto pks = ss.make_pkeys(2); - unsigned gen = 0; for (auto version : all_sstable_versions) { if (version < sstable_version_types::md) { continue; @@ -2888,17 +2866,13 @@ SEASTAR_TEST_CASE(test_may_have_partition_tombstones) { ss.delete_range(mut1, query::clustering_range::make({ss.make_ckey(3)}, {ss.make_ckey(5)})); ss.add_row(mut2, ss.make_ckey(6), "val"); - auto sst_gen = [&env, s, &gen, version] () { - return env.make_sstable(s, ++gen, version, big); - }; - { - auto sst = make_sstable_containing(sst_gen, {mut1, mut2}); + auto sst = make_sstable_containing(env.make_sstable(s, version), {mut1, mut2}); BOOST_REQUIRE(!sst->may_have_partition_tombstones()); } mut2.partition().apply(ss.new_tombstone()); - auto sst = make_sstable_containing(sst_gen, {mut1, mut2}); + auto sst = make_sstable_containing(env.make_sstable(s, version), {mut1, mut2}); BOOST_REQUIRE(sst->may_have_partition_tombstones()); } }); @@ -3126,13 +3100,10 @@ SEASTAR_TEST_CASE(partial_sstable_deletion_test) { simple_schema ss; auto s = ss.schema(); auto pks = ss.make_pkeys(1); - auto sst_gen = [&env, s] () { - return env.make_sstable(s, 1, sstables::get_highest_sstable_version(), big); - }; auto mut1 = mutation(s, pks[0]); mut1.partition().apply_insert(*s, ss.make_ckey(0), ss.new_timestamp()); - auto sst = make_sstable_containing(sst_gen, {std::move(mut1)}); + auto sst = make_sstable_containing(env.make_sstable(s), {std::move(mut1)}); // Rename TOC into TMP toc, to stress deletion path for partial files rename_file(test::filename(*sst, sstables::component_type::TOC).native(), test::filename(*sst, sstables::component_type::TemporaryTOC).native()).get(); @@ -3209,10 +3180,7 @@ SEASTAR_TEST_CASE(test_crawling_reader_out_of_range_last_range_tombstone_change) using bound = query::clustering_range::bound; table.delete_range(mut, query::clustering_range::make(bound{ckeys[3], true}, bound{clustering_key::make_empty(), true}), tombstone(1, gc_clock::now())); - auto sst_gen = [&env, &table] () { - return env.make_sstable(table.schema(), 1, sstables::get_highest_sstable_version(), big); - }; - auto sst = make_sstable_containing(sst_gen, {mut}); + auto sst = make_sstable_containing(env.make_sstable(table.schema()), {mut}); assert_that(sst->make_crawling_reader(table.schema(), env.make_reader_permit())).has_monotonic_positions(); }); @@ -3233,10 +3201,7 @@ SEASTAR_TEST_CASE(test_crawling_reader_random_schema_random_mutations) { const auto muts = tests::generate_random_mutations(random_schema, 20).get(); - auto sst_gen = [&env, schema] () { - return env.make_sstable(schema, 1, sstables::get_highest_sstable_version(), big); - }; - auto sst = make_sstable_containing(sst_gen, muts); + auto sst = make_sstable_containing(env.make_sstable(schema), muts); { auto rd = assert_that(sst->make_crawling_reader(schema, env.make_reader_permit())); @@ -3264,9 +3229,6 @@ SEASTAR_TEST_CASE(find_first_position_in_partition_from_sstable_test) { auto s = ss.schema(); auto pks = ss.make_pkeys(partitions); auto tmp = env.tempdir().make_sweeper(); - auto sst_gen = [&env, s]() { - return env.make_sstable(s, 1, sstables::get_highest_sstable_version(), big); - }; std::vector muts; std::optional first_position, last_position; @@ -3303,7 +3265,7 @@ SEASTAR_TEST_CASE(find_first_position_in_partition_from_sstable_test) { } muts.push_back(std::move(mut1)); } - auto sst = make_sstable_containing(sst_gen, std::move(muts)); + auto sst = make_sstable_containing(env.make_sstable(s), std::move(muts)); position_in_partition::equal_compare eq(*s); if (!with_static_row) { BOOST_REQUIRE(sst->min_position().key() == first_position->key()); diff --git a/test/boost/sstable_mutation_test.cc b/test/boost/sstable_mutation_test.cc index db8218d5a6..f22433891a 100644 --- a/test/boost/sstable_mutation_test.cc +++ b/test/boost/sstable_mutation_test.cc @@ -414,10 +414,7 @@ SEASTAR_TEST_CASE(test_sstable_can_write_and_read_range_tombstone) { auto mt = make_lw_shared(s); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, - 1 /* generation */, - sstables::get_highest_sstable_version(), - sstables::sstable::format_types::big); + auto sst = env.make_sstable(s); write_memtable_to_sstable_for_test(*mt, sst).get(); sst->load().get(); auto mut = with_closeable(sst->make_reader(s, env.make_reader_permit(), query::full_partition_range, s->full_slice()), [] (auto& mr) { @@ -856,10 +853,7 @@ SEASTAR_TEST_CASE(test_non_compound_table_row_is_not_marked_as_static) { auto mt = make_lw_shared(s); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, - 1 /* generation */, - version, - sstables::sstable::format_types::big); + auto sst = env.make_sstable(s, version); write_memtable_to_sstable_for_test(*mt, sst).get(); sst->load().get(); auto mut = with_closeable(sst->make_reader(s, env.make_reader_permit(), query::full_partition_range, s->full_slice()), [] (auto& mr) { @@ -889,10 +883,7 @@ SEASTAR_TEST_CASE(test_has_partition_key) { auto mt = make_lw_shared(s); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, - 1 /* generation */, - version, - sstables::sstable::format_types::big); + auto sst = env.make_sstable(s, version); write_memtable_to_sstable_for_test(*mt, sst).get(); auto hk = sstables::sstable::make_hashed_key(*s, dk.key()); sst->load().get(); From 19ef07b059e329d60e59b4a90cda8b3f7f183cce Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 13:15:12 +0300 Subject: [PATCH 12/16] test,compaction: Make check_compacted_sstables() use env's dir It's in fact using it already via argument. Next patch will do the same with another call, but having this change separately makes the next patch shorter and easier to review. Signed-off-by: Pavel Emelyanov --- test/boost/sstable_compaction_test.cc | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/test/boost/sstable_compaction_test.cc b/test/boost/sstable_compaction_test.cc index f1bc3e7d2a..611b6ae3c0 100644 --- a/test/boost/sstable_compaction_test.cc +++ b/test/boost/sstable_compaction_test.cc @@ -419,13 +419,13 @@ static future<> compact_sstables(test_env& env, sstring tmpdir_path, std::vector }); } -static future<> check_compacted_sstables(test_env& env, sstring tmpdir_path, unsigned long generation, std::vector compacted_generations) { +static future<> check_compacted_sstables(test_env& env, unsigned long generation, std::vector compacted_generations) { auto s = make_shared_schema({}, some_keyspace, some_column_family, {{"p1", utf8_type}}, {{"c1", utf8_type}}, {{"r1", utf8_type}}, {}, utf8_type); auto generations = make_lw_shared>(std::move(compacted_generations)); - return open_sstable(env, s, tmpdir_path, generation).then([&env, s, generations] (shared_sstable sst) { + return env.reusable_sst(s, generation).then([&env, s, generations] (shared_sstable sst) { auto reader = sstable_reader(sst, s, env.make_reader_permit()); // reader holds sst and s alive. auto keys = make_lw_shared>(); @@ -469,24 +469,24 @@ SEASTAR_TEST_CASE(compact_02) { // E.g.: generations 18, 19, 20 and 21 will be compacted into generation 22. return compact_sstables(env, tmpdir_path, { 18, 19, 20, 21 }, 22).then([&env, tmpdir_path] { // Check that generation 22 contains all keys of generations 18, 19, 20 and 21. - return check_compacted_sstables(env, tmpdir_path, 22, { 18, 19, 20, 21 }); + return check_compacted_sstables(env, 22, { 18, 19, 20, 21 }); }).then([&env, tmpdir_path] { return compact_sstables(env, tmpdir_path, { 23, 24, 25, 26 }, 27).then([&env, tmpdir_path] { - return check_compacted_sstables(env, tmpdir_path, 27, { 23, 24, 25, 26 }); + return check_compacted_sstables(env, 27, { 23, 24, 25, 26 }); }); }).then([&env, tmpdir_path] { return compact_sstables(env, tmpdir_path, { 28, 29, 30, 31 }, 32).then([&env, tmpdir_path] { - return check_compacted_sstables(env, tmpdir_path, 32, { 28, 29, 30, 31 }); + return check_compacted_sstables(env, 32, { 28, 29, 30, 31 }); }); }).then([&env, tmpdir_path] { return compact_sstables(env, tmpdir_path, { 33, 34, 35, 36 }, 37).then([&env, tmpdir_path] { - return check_compacted_sstables(env, tmpdir_path, 37, { 33, 34, 35, 36 }); + return check_compacted_sstables(env, 37, { 33, 34, 35, 36 }); }); }).then([&env, tmpdir_path] { // In this step, we compact 4 compacted sstables. return compact_sstables(env, tmpdir_path, { 22, 27, 32, 37 }, 38, false).then([&env, tmpdir_path] { // Check that the compacted sstable contains all keys. - return check_compacted_sstables(env, tmpdir_path, 38, + return check_compacted_sstables(env, 38, { 18, 19, 20, 21, 23, 24, 25, 26, 28, 29, 30, 31, 33, 34, 35, 36 }); }); }); From fdff97a294ae24b1316b206d8e0a66f130fe8819 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 13:20:02 +0300 Subject: [PATCH 13/16] test,compaction: Use env tempdir in some more cases Both already do so, but get the tempdir explicitly. It's possible to make them much shorter by not carrying this variable over the code. Signed-off-by: Pavel Emelyanov --- test/boost/sstable_compaction_test.cc | 48 ++++++++++++--------------- 1 file changed, 22 insertions(+), 26 deletions(-) diff --git a/test/boost/sstable_compaction_test.cc b/test/boost/sstable_compaction_test.cc index 611b6ae3c0..b6658d94ad 100644 --- a/test/boost/sstable_compaction_test.cc +++ b/test/boost/sstable_compaction_test.cc @@ -310,7 +310,7 @@ static std::vector get_candidates_for_leveled_strategy } // Return vector of sstables generated by compaction. Only relevant for leveled one. -static future> compact_sstables(test_env& env, sstring tmpdir_path, std::vector generations_to_compact, +static future> compact_sstables(test_env& env, std::vector generations_to_compact, unsigned long new_generation, bool create_sstables, uint64_t min_sstable_size, compaction_strategy_type strategy) { BOOST_REQUIRE(smp::count == 1); schema_builder builder(make_shared_schema({}, some_keyspace, some_column_family, @@ -327,16 +327,16 @@ static future> compact_sstables(test_env& env, sstrin auto f = make_ready_future<>(); - return f.then([&env, generations, sstables, s, create_sstables, min_sstable_size, tmpdir_path] () mutable { + return f.then([&env, generations, sstables, s, create_sstables, min_sstable_size] () mutable { if (!create_sstables) { - return open_sstables(env, s, tmpdir_path, *generations).then([sstables] (auto opened_sstables) mutable { + return open_sstables(env, s, env.tempdir().path().native(), *generations).then([sstables] (auto opened_sstables) mutable { for (auto& sst : opened_sstables) { sstables->push_back(sst); } return make_ready_future<>(); }); } - return do_for_each(*generations, [&env, generations, sstables, s, min_sstable_size, tmpdir_path] (unsigned long generation) { + return do_for_each(*generations, [&env, generations, sstables, s, min_sstable_size] (unsigned long generation) { auto mt = make_lw_shared(s); const column_definition& r1_col = *s->get_column_definition("r1"); @@ -349,7 +349,7 @@ static future> compact_sstables(test_env& env, sstrin m.set_clustered_cell(c_key, r1_col, make_atomic_cell(utf8_type, bytes(min_sstable_size, 'a'))); mt->apply(std::move(m)); - auto sst = env.make_sstable(s, tmpdir_path, generation, sstables::get_highest_sstable_version(), big); + auto sst = env.make_sstable(s, generation, sstables::get_highest_sstable_version(), big); return write_memtable_to_sstable_for_test(*mt, sst).then([mt, sst, s, sstables] { return sst->load().then([sst, sstables] { @@ -358,13 +358,12 @@ static future> compact_sstables(test_env& env, sstrin }); }); }); - }).then([&env, cf = *cf, sstables, new_generation, generations, strategy, created, min_sstable_size, s, tmpdir_path] () mutable { + }).then([&env, cf = *cf, sstables, new_generation, generations, strategy, created, min_sstable_size, s] () mutable { auto generation = make_lw_shared(new_generation); - auto new_sstable = [&env, generation, created, s, tmpdir_path] { + auto new_sstable = [&env, generation, created, s] { auto gen = (*generation)++; created->push_back(gen); - return env.make_sstable(s, tmpdir_path, - gen, sstables::get_highest_sstable_version(), sstables::sstable::format_types::big); + return env.make_sstable(s, gen, sstables::get_highest_sstable_version(), sstables::sstable::format_types::big); }; // We must have opened at least all original candidates. BOOST_REQUIRE(generations->size() == sstables->size()); @@ -408,9 +407,9 @@ static future> compact_sstables(test_env& env, sstrin }); } -static future<> compact_sstables(test_env& env, sstring tmpdir_path, std::vector generations_to_compact, unsigned long new_generation, bool create_sstables = true) { +static future<> compact_sstables(test_env& env, std::vector generations_to_compact, unsigned long new_generation, bool create_sstables = true) { uint64_t min_sstable_size = 50; - return compact_sstables(env, tmpdir_path, std::move(generations_to_compact), new_generation, create_sstables, min_sstable_size, + return compact_sstables(env, std::move(generations_to_compact), new_generation, create_sstables, min_sstable_size, compaction_strategy_type::size_tiered).then([new_generation] (auto ret) { // size tiered compaction will output at most one sstable, let's assert that. BOOST_REQUIRE(ret.size() == 1); @@ -464,27 +463,26 @@ SEASTAR_TEST_CASE(compact_02) { // strategy algorithm that selects candidates for compaction. return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); // Compact 4 sstables into 1 using size-tiered strategy to select sstables. // E.g.: generations 18, 19, 20 and 21 will be compacted into generation 22. - return compact_sstables(env, tmpdir_path, { 18, 19, 20, 21 }, 22).then([&env, tmpdir_path] { + return compact_sstables(env, { 18, 19, 20, 21 }, 22).then([&env] { // Check that generation 22 contains all keys of generations 18, 19, 20 and 21. return check_compacted_sstables(env, 22, { 18, 19, 20, 21 }); - }).then([&env, tmpdir_path] { - return compact_sstables(env, tmpdir_path, { 23, 24, 25, 26 }, 27).then([&env, tmpdir_path] { + }).then([&env] { + return compact_sstables(env, { 23, 24, 25, 26 }, 27).then([&env] { return check_compacted_sstables(env, 27, { 23, 24, 25, 26 }); }); - }).then([&env, tmpdir_path] { - return compact_sstables(env, tmpdir_path, { 28, 29, 30, 31 }, 32).then([&env, tmpdir_path] { + }).then([&env] { + return compact_sstables(env, { 28, 29, 30, 31 }, 32).then([&env] { return check_compacted_sstables(env, 32, { 28, 29, 30, 31 }); }); - }).then([&env, tmpdir_path] { - return compact_sstables(env, tmpdir_path, { 33, 34, 35, 36 }, 37).then([&env, tmpdir_path] { + }).then([&env] { + return compact_sstables(env, { 33, 34, 35, 36 }, 37).then([&env] { return check_compacted_sstables(env, 37, { 33, 34, 35, 36 }); }); - }).then([&env, tmpdir_path] { + }).then([&env] { // In this step, we compact 4 compacted sstables. - return compact_sstables(env, tmpdir_path, { 22, 27, 32, 37 }, 38, false).then([&env, tmpdir_path] { + return compact_sstables(env, { 22, 27, 32, 37 }, 38, false).then([&env] { // Check that the compacted sstable contains all keys. return check_compacted_sstables(env, 38, { 18, 19, 20, 21, 23, 24, 25, 26, 28, 29, 30, 31, 33, 34, 35, 36 }); @@ -768,17 +766,15 @@ SEASTAR_TEST_CASE(leveled_04) { SEASTAR_TEST_CASE(leveled_05) { // NOTE: Generations from 48 to 51 are used here. return test_env::do_with([] (test_env& env) { - auto tmpdir_path = env.tempdir().path().native(); - // Check compaction code with leveled strategy. In this test, two sstables of level 0 will be created. - return compact_sstables(env, tmpdir_path, { 48, 49 }, 50, true, 1024*1024, compaction_strategy_type::leveled).then([tmpdir_path] (auto generations) { + return compact_sstables(env, { 48, 49 }, 50, true, 1024*1024, compaction_strategy_type::leveled).then([&env] (auto generations) { BOOST_REQUIRE(generations.size() == 2); BOOST_REQUIRE(generations[0] == 50); BOOST_REQUIRE(generations[1] == 51); - return seastar::async([&, generations = std::move(generations), tmpdir_path] { + return seastar::async([&, generations = std::move(generations)] { for (auto gen : generations) { - auto fname = sstable::filename(tmpdir_path, "ks", "cf", sstables::get_highest_sstable_version(), generation_from_value(gen), big, component_type::Data); + auto fname = sstable::filename(env.tempdir().path().native(), "ks", "cf", sstables::get_highest_sstable_version(), generation_from_value(gen), big, component_type::Data); BOOST_REQUIRE(file_size(fname).get0() >= 1024*1024); } }); From 27d45df35f8b57b8765d0b421c16029b1c4a20b1 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 13:26:40 +0300 Subject: [PATCH 14/16] test: Make "compact" test case use env dir Same as most of the previous work -- remove the explicit capturing of env's tempdir over the test. Signed-off-by: Pavel Emelyanov --- test/boost/sstable_compaction_test.cc | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/test/boost/sstable_compaction_test.cc b/test/boost/sstable_compaction_test.cc index b6658d94ad..6f591b74b1 100644 --- a/test/boost/sstable_compaction_test.cc +++ b/test/boost/sstable_compaction_test.cc @@ -220,15 +220,12 @@ SEASTAR_TEST_CASE(compact) { auto s = builder.build(); table_for_tests cf(env.manager(), s); auto close_cf = deferred_stop(cf); - tmpdir dir; - sstring tmpdir_path = dir.path().string(); - open_sstables(env, s, "test/resource/sstables/compaction", {1,2,3}).then([&env, tmpdir_path, s, cf, generation] (auto sstables) mutable { - auto new_sstable = [&env, gen = make_lw_shared(generation), s, tmpdir_path] { - return env.make_sstable(s, tmpdir_path, - (*gen)++, sstables::get_highest_sstable_version(), sstables::sstable::format_types::big); + open_sstables(env, s, "test/resource/sstables/compaction", {1,2,3}).then([&env, s, cf, generation] (auto sstables) mutable { + auto new_sstable = [&env, gen = make_lw_shared(generation), s] { + return env.make_sstable(s, (*gen)++); }; - return compact_sstables(sstables::compaction_descriptor(std::move(sstables), default_priority_class()), cf, new_sstable).then([&env, s, cf, tmpdir_path] (auto) { + return compact_sstables(sstables::compaction_descriptor(std::move(sstables), default_priority_class()), cf, new_sstable).then([&env, s, cf] (auto) { // Verify that the compacted sstable has the right content. We expect to see: // name | age | height // -------+-----+-------- @@ -236,7 +233,7 @@ SEASTAR_TEST_CASE(compact) { // tom | 20 | 180 // john | 20 | deleted // nadav - deleted partition - return open_sstable(env, s, tmpdir_path, generation).then([&env, s] (shared_sstable sst) { + return env.reusable_sst(s, generation).then([&env, s] (shared_sstable sst) { auto reader = make_lw_shared(sstable_reader(sst, s, env.make_reader_permit())); // reader holds sst and s alive. return read_mutation_from_flat_mutation_reader(*reader).then([reader, s] (mutation_opt m) { BOOST_REQUIRE(m); From 8297ac0082e87cfb659fab9db51fc2ad126bef32 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 13:30:26 +0300 Subject: [PATCH 15/16] test,lib: Remove wrapper over reusable_sst and move the comment There's a wonderful comment describing what the reusable_sst is for near one of its wrappers. It's better to drop the wrapper and move the comment to where it belongs. Signed-off-by: Pavel Emelyanov --- test/boost/sstable_compaction_test.cc | 12 +----------- test/lib/sstable_test_env.hh | 6 ++++++ 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/test/boost/sstable_compaction_test.cc b/test/boost/sstable_compaction_test.cc index 6f591b74b1..8cef241e14 100644 --- a/test/boost/sstable_compaction_test.cc +++ b/test/boost/sstable_compaction_test.cc @@ -91,23 +91,13 @@ atomic_cell make_atomic_cell(data_type dt, bytes_view value, uint32_t ttl = 0, u //////////////////////////////// Test basic compaction support -// open_sstable() opens the requested sstable for reading only (sstables are -// immutable, so an existing sstable cannot be opened for writing). -// It returns a future because opening requires reading from disk, and -// therefore may block. The future value is a shared sstable - a reference- -// counting pointer to an sstable - allowing for the returned handle to -// be passed around until no longer needed. -static future open_sstable(test_env& env, schema_ptr schema, sstring dir, unsigned long generation) { - return env.reusable_sst(std::move(schema), dir, generation); -} - // open_sstables() opens several generations of the same sstable, returning, // after all the tables have been open, their vector. static future> open_sstables(test_env& env, schema_ptr s, sstring dir, std::vector generations) { return do_with(std::vector(), [&env, dir = std::move(dir), generations = std::move(generations), s] (auto& ret) mutable { return parallel_for_each(generations, [&env, &ret, &dir, s] (unsigned long generation) { - return open_sstable(env, s, dir, generation).then([&ret] (sstables::shared_sstable sst) { + return env.reusable_sst(s, dir, generation).then([&ret] (sstables::shared_sstable sst) { ret.push_back(std::move(sst)); }); }).then([&ret] { diff --git a/test/lib/sstable_test_env.hh b/test/lib/sstable_test_env.hh index f072fee6d1..a8fa0a2144 100644 --- a/test/lib/sstable_test_env.hh +++ b/test/lib/sstable_test_env.hh @@ -94,6 +94,12 @@ public: {} }; + // reusable_sst() opens the requested sstable for reading only (sstables are + // immutable, so an existing sstable cannot be opened for writing). + // It returns a future because opening requires reading from disk, and + // therefore may block. The future value is a shared sstable - a reference- + // counting pointer to an sstable - allowing for the returned handle to + // be passed around until no longer needed. future reusable_sst(schema_ptr schema, sstring dir, unsigned long generation, sstable::version_types version, sstable::format_types f = sstable::format_types::big) { auto sst = make_sstable(std::move(schema), dir, generation, version, f); From 47df08436300ccf54c435fc71d6404158cf8cef2 Mon Sep 17 00:00:00 2001 From: Pavel Emelyanov Date: Tue, 7 Mar 2023 14:44:34 +0300 Subject: [PATCH 16/16] test,sstables: Remove path from make_sstable_easy() The method in question is only called with env's tempdir, so there's no point in explicitly passing it. Signed-off-by: Pavel Emelyanov --- test/boost/schema_changes_test.cc | 2 +- test/boost/sstable_3_x_test.cc | 2 +- test/boost/sstable_compaction_test.cc | 2 +- test/boost/sstable_datafile_test.cc | 12 ++++++------ test/boost/sstable_mutation_test.cc | 22 +++++++++++----------- test/boost/sstable_set_test.cc | 10 ++++------ test/lib/sstable_utils.cc | 8 ++++---- test/lib/sstable_utils.hh | 4 ++-- 8 files changed, 30 insertions(+), 32 deletions(-) diff --git a/test/boost/schema_changes_test.cc b/test/boost/schema_changes_test.cc index e5b0835bb3..f052cdac0d 100644 --- a/test/boost/schema_changes_test.cc +++ b/test/boost/schema_changes_test.cc @@ -39,7 +39,7 @@ SEASTAR_TEST_CASE(test_schema_changes) { mt->apply(m); } - created_with_base_schema = make_sstable_easy(env, env.tempdir().path(), mt, env.manager().configure_writer(), gen, version, base_mutations.size()); + created_with_base_schema = make_sstable_easy(env, mt, env.manager().configure_writer(), gen, version, base_mutations.size()); created_with_changed_schema = env.make_sstable(changed, env.tempdir().path().string(), gen, version, sstables::sstable::format_types::big); created_with_changed_schema->load().get(); diff --git a/test/boost/sstable_3_x_test.cc b/test/boost/sstable_3_x_test.cc index c79876b923..aa3c6cdb3c 100644 --- a/test/boost/sstable_3_x_test.cc +++ b/test/boost/sstable_3_x_test.cc @@ -5110,7 +5110,7 @@ SEASTAR_TEST_CASE(test_sstable_reader_on_unknown_column) { auto _ = env.tempdir().make_sweeper(); sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = index_block_size; - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, mt, cfg, 1, version); BOOST_REQUIRE_EXCEPTION( assert_that(sst->make_reader(read_schema, env.make_reader_permit(), query::full_partition_range, read_schema->full_slice())) diff --git a/test/boost/sstable_compaction_test.cc b/test/boost/sstable_compaction_test.cc index 8cef241e14..7dc667355d 100644 --- a/test/boost/sstable_compaction_test.cc +++ b/test/boost/sstable_compaction_test.cc @@ -3121,7 +3121,7 @@ SEASTAR_TEST_CASE(partial_sstable_run_filtered_out_test) { sstable_writer_config sst_cfg = env.manager().configure_writer(); sst_cfg.run_identifier = partial_sstable_run_identifier; - auto partial_sstable_run_sst = make_sstable_easy(env, env.tempdir().path(), make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), { std::move(mut) }), sst_cfg); + auto partial_sstable_run_sst = make_sstable_easy(env, make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), { std::move(mut) }), sst_cfg); column_family_test(cf).add_sstable(partial_sstable_run_sst).get(); column_family_test::update_sstables_known_generation(*cf, generation_value(partial_sstable_run_sst->generation())); diff --git a/test/boost/sstable_datafile_test.cc b/test/boost/sstable_datafile_test.cc index bf0205eadf..a32e5d9f18 100644 --- a/test/boost/sstable_datafile_test.cc +++ b/test/boost/sstable_datafile_test.cc @@ -1925,7 +1925,7 @@ SEASTAR_TEST_CASE(test_repeated_tombstone_skipping) { for (auto&& mf : fragments) { mut.apply(mf); } - auto sst = make_sstable_easy(env, env.tempdir().path(), make_flat_mutation_reader_from_mutations_v2(table.schema(), std::move(permit), { std::move(mut) }), cfg, 1, version); + auto sst = make_sstable_easy(env, make_flat_mutation_reader_from_mutations_v2(table.schema(), std::move(permit), { std::move(mut) }), cfg, 1, version); auto ms = as_mutation_source(sst); for (uint32_t i = 3; i < seq; i++) { @@ -1974,7 +1974,7 @@ SEASTAR_TEST_CASE(test_skipping_using_index) { sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; // So that every fragment is indexed cfg.promoted_index_auto_scale_threshold = 0; // disable auto-scaling - auto sst = make_sstable_easy(env, env.tempdir().path(), make_flat_mutation_reader_from_mutations_v2(table.schema(), env.make_reader_permit(), partitions), cfg, 1, version); + auto sst = make_sstable_easy(env, make_flat_mutation_reader_from_mutations_v2(table.schema(), env.make_reader_permit(), partitions), cfg, 1, version); auto ms = as_mutation_source(sst); auto rd = ms.make_reader_v2(table.schema(), @@ -2650,7 +2650,7 @@ SEASTAR_TEST_CASE(sstable_run_identifier_correctness) { sstable_writer_config cfg = env.manager().configure_writer(); cfg.run_identifier = sstables::run_id::create_random_id(); - auto sst = make_sstable_easy(env, env.tempdir().path(), make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), { std::move(mut) }), cfg); + auto sst = make_sstable_easy(env, make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), { std::move(mut) }), cfg); BOOST_REQUIRE(sst->run_identifier() == cfg.run_identifier); }); @@ -2831,7 +2831,7 @@ SEASTAR_TEST_CASE(test_zero_estimated_partitions) { auto mr = make_flat_mutation_reader_from_mutations_v2(ss.schema(), env.make_reader_permit(), {mut}); sstable_writer_config cfg = env.manager().configure_writer(); - auto sst = make_sstable_easy(env, env.tempdir().path(), std::move(mr), cfg, 0, version, 0); + auto sst = make_sstable_easy(env, std::move(mr), cfg, 0, version, 0); auto sst_mr = sst->as_mutation_source().make_reader_v2(s, env.make_reader_permit(), query::full_partition_range, s->full_slice()); auto close_mr = deferred_close(sst_mr); @@ -2934,14 +2934,14 @@ SEASTAR_TEST_CASE(test_sstable_origin) { // Test empty sstable_origin. auto mr = make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), {mut}); sstable_writer_config cfg = env.manager().configure_writer(""); - auto sst = make_sstable_easy(env, env.tempdir().path(), std::move(mr), cfg, gen++, version, 0); + auto sst = make_sstable_easy(env, std::move(mr), cfg, gen++, version, 0); BOOST_REQUIRE_EQUAL(sst->get_origin(), ""); // Test that a random sstable_origin is stored and retrieved properly. mr = make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), {mut}); sstring origin = fmt::format("test-{}", tests::random::get_sstring()); cfg = env.manager().configure_writer(origin); - sst = make_sstable_easy(env, env.tempdir().path(), std::move(mr), cfg, gen++, version, 0); + sst = make_sstable_easy(env, std::move(mr), cfg, gen++, version, 0); BOOST_REQUIRE_EQUAL(sst->get_origin(), origin); } }); diff --git a/test/boost/sstable_mutation_test.cc b/test/boost/sstable_mutation_test.cc index f22433891a..16f2d4087c 100644 --- a/test/boost/sstable_mutation_test.cc +++ b/test/boost/sstable_mutation_test.cc @@ -943,7 +943,7 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic) { cfg.promoted_index_block_size = 1; cfg.promoted_index_auto_scale_threshold = 0; // disable auto-scaling - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg); + auto sst = make_sstable_easy(env, mt, cfg); assert_that(get_index_reader(sst, env.make_reader_permit())).has_monotonic_positions(*s); }); } @@ -979,7 +979,7 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_with_auto_scaling) { cfg.promoted_index_block_size = 1; cfg.promoted_index_auto_scale_threshold = 100; // set to a low value to trigger auto-scaling - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg); + auto sst = make_sstable_easy(env, mt, cfg); assert_that(get_index_reader(sst, env.make_reader_permit())).has_monotonic_positions(*s); }); } @@ -1022,7 +1022,7 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_compound_dense) { sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, mt, cfg, 1, version); { assert_that(get_index_reader(sst, env.make_reader_permit())).has_monotonic_positions(*s); @@ -1072,7 +1072,7 @@ SEASTAR_TEST_CASE(test_promoted_index_blocks_are_monotonic_non_compound_dense) { sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, mt, cfg, 1, version); { assert_that(get_index_reader(sst, env.make_reader_permit())).has_monotonic_positions(*s); @@ -1119,7 +1119,7 @@ SEASTAR_TEST_CASE(test_promoted_index_repeats_open_tombstones) { sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, generation, version); + auto sst = make_sstable_easy(env, mt, cfg, generation, version); { auto slice = partition_slice_builder(*s).with_range(query::clustering_range::make_starting_with({ck})).build(); @@ -1155,7 +1155,7 @@ SEASTAR_TEST_CASE(test_range_tombstones_are_correctly_seralized_for_non_compound mt->apply(m); sstable_writer_config cfg = env.manager().configure_writer(); - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, mt, cfg, 1, version); { auto slice = partition_slice_builder(*s).build(); @@ -1186,7 +1186,7 @@ SEASTAR_TEST_CASE(test_promoted_index_is_absent_for_schemas_without_clustering_k sstable_writer_config cfg = env.manager().configure_writer(); cfg.promoted_index_block_size = 1; - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg, 1, version); + auto sst = make_sstable_easy(env, mt, cfg, 1, version); assert_that(get_index_reader(sst, env.make_reader_permit())).is_empty(*s); } }); @@ -1224,7 +1224,7 @@ SEASTAR_TEST_CASE(test_writing_combined_stream_with_tombstones_at_the_same_posit auto combined_permit = env.make_reader_permit(); auto mr = make_combined_reader(s, combined_permit, mt1->make_flat_reader(s, combined_permit), mt2->make_flat_reader(s, combined_permit)); - auto sst = make_sstable_easy(env, env.tempdir().path(), std::move(mr), env.manager().configure_writer(), 1, version); + auto sst = make_sstable_easy(env, std::move(mr), env.manager().configure_writer(), 1, version); assert_that(sst->as_mutation_source().make_reader_v2(s, env.make_reader_permit())) .produces(m1 + m2) @@ -1294,7 +1294,7 @@ SEASTAR_TEST_CASE(test_key_count_estimation) { } auto _ = env.tempdir().make_sweeper(); - shared_sstable sst = make_sstable_easy(env, env.tempdir().path(), mt, env.manager().configure_writer(), 1, version, pks.size()); + shared_sstable sst = make_sstable_easy(env, mt, env.manager().configure_writer(), 1, version, pks.size()); auto max_est = sst->get_estimated_key_count(); testlog.trace("count = {}", count); @@ -1394,7 +1394,7 @@ SEASTAR_TEST_CASE(test_large_index_pages_do_not_cause_large_allocations) { } sstable_writer_config cfg = env.manager().configure_writer(); - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, cfg); + auto sst = make_sstable_easy(env, mt, cfg); auto pr = dht::partition_range::make_singular(small_keys[0]); @@ -1551,7 +1551,7 @@ SEASTAR_TEST_CASE(test_counter_header_size) { mt->apply(m); for (const auto version : writable_sstable_versions) { - auto sst = make_sstable_easy(env, env.tempdir().path(), mt, env.manager().configure_writer(), 1, version); + auto sst = make_sstable_easy(env, mt, env.manager().configure_writer(), 1, version); assert_that(sst->as_mutation_source().make_reader_v2(s, env.make_reader_permit())) .produces(m) .produces_end_of_stream(); diff --git a/test/boost/sstable_set_test.cc b/test/boost/sstable_set_test.cc index 8e9bf9cf7c..37ce25c783 100644 --- a/test/boost/sstable_set_test.cc +++ b/test/boost/sstable_set_test.cc @@ -31,7 +31,6 @@ SEASTAR_TEST_CASE(test_sstables_sstable_set_read_modify_write) { return test_env::do_with_async([] (test_env& env) { simple_schema ss; auto s = ss.schema(); - fs::path tmp = env.tempdir().path(); auto pk = tests::generate_partition_key(s); auto mut = mutation(s, pk); @@ -40,14 +39,14 @@ SEASTAR_TEST_CASE(test_sstables_sstable_set_read_modify_write) { auto mr = make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), {mut}); sstable_writer_config cfg = env.manager().configure_writer(""); - auto sst1 = make_sstable_easy(env, tmp, std::move(mr), cfg, gen++); + auto sst1 = make_sstable_easy(env, std::move(mr), cfg, gen++); auto ss1 = make_lw_shared(make_sstable_set(ss.schema(), make_lw_shared({sst1}))); BOOST_REQUIRE_EQUAL(ss1->all()->size(), 1); // Test that a random sstable_origin is stored and retrieved properly. mr = make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), {mut}); - auto sst2 = make_sstable_easy(env, tmp, std::move(mr), cfg, gen++); + auto sst2 = make_sstable_easy(env, std::move(mr), cfg, gen++); auto ss2 = make_lw_shared(*ss1); ss2->insert(sst2); @@ -60,7 +59,6 @@ SEASTAR_TEST_CASE(test_time_series_sstable_set_read_modify_write) { return test_env::do_with_async([] (test_env& env) { simple_schema ss; auto s = ss.schema(); - fs::path tmp = env.tempdir().path(); auto pk = tests::generate_partition_key(s); auto mut = mutation(s, pk); @@ -69,7 +67,7 @@ SEASTAR_TEST_CASE(test_time_series_sstable_set_read_modify_write) { sstable_writer_config cfg = env.manager().configure_writer(""); auto mr = make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), {mut}); - auto sst1 = make_sstable_easy(env, tmp, std::move(mr), cfg, gen++); + auto sst1 = make_sstable_easy(env, std::move(mr), cfg, gen++); auto ss1 = make_lw_shared(ss.schema()); ss1->insert(sst1); @@ -77,7 +75,7 @@ SEASTAR_TEST_CASE(test_time_series_sstable_set_read_modify_write) { // Test that a random sstable_origin is stored and retrieved properly. mr = make_flat_mutation_reader_from_mutations_v2(s, env.make_reader_permit(), {mut}); - auto sst2 = make_sstable_easy(env, tmp, std::move(mr), cfg, gen++); + auto sst2 = make_sstable_easy(env, std::move(mr), cfg, gen++); auto ss2 = make_lw_shared(*ss1); ss2->insert(sst2); diff --git a/test/lib/sstable_utils.cc b/test/lib/sstable_utils.cc index 43fecaa774..fb51ef7dd4 100644 --- a/test/lib/sstable_utils.cc +++ b/test/lib/sstable_utils.cc @@ -87,19 +87,19 @@ shared_sstable make_sstable(sstables::test_env& env, schema_ptr s, sstring dir, return sst; } -shared_sstable make_sstable_easy(test_env& env, const fs::path& path, flat_mutation_reader_v2 rd, sstable_writer_config cfg, +shared_sstable make_sstable_easy(test_env& env, flat_mutation_reader_v2 rd, sstable_writer_config cfg, int64_t generation, const sstables::sstable::version_types version, int expected_partition) { auto s = rd.schema(); - auto sst = env.make_sstable(s, path.string(), generation, version, sstable_format_types::big); + auto sst = env.make_sstable(s, generation, version, sstable_format_types::big); sst->write_components(std::move(rd), expected_partition, s, cfg, encoding_stats{}).get(); sst->load().get(); return sst; } -shared_sstable make_sstable_easy(test_env& env, const fs::path& path, lw_shared_ptr mt, sstable_writer_config cfg, +shared_sstable make_sstable_easy(test_env& env, lw_shared_ptr mt, sstable_writer_config cfg, unsigned long gen, const sstable::version_types v, int estimated_partitions, gc_clock::time_point query_time) { schema_ptr s = mt->schema(); - auto sst = env.make_sstable(s, path.string(), gen, v, sstable_format_types::big, default_sstable_buffer_size, query_time); + auto sst = env.make_sstable(s, gen, v, sstable_format_types::big, default_sstable_buffer_size, query_time); auto mr = mt->make_flat_reader(s, env.make_reader_permit()); sst->write_components(std::move(mr), estimated_partitions, s, cfg, mt->get_encoding_stats()).get(); sst->load().get(); diff --git a/test/lib/sstable_utils.hh b/test/lib/sstable_utils.hh index a4ee88a0ac..172990d1d8 100644 --- a/test/lib/sstable_utils.hh +++ b/test/lib/sstable_utils.hh @@ -288,7 +288,7 @@ future compact_sstables(compaction_manager& cm, sstables::com std::function creator, sstables::compaction_sstable_replacer_fn replacer = sstables::replacer_fn_no_op(), can_purge_tombstones can_purge = can_purge_tombstones::yes); -shared_sstable make_sstable_easy(test_env& env, const fs::path& path, flat_mutation_reader_v2 rd, sstable_writer_config cfg, +shared_sstable make_sstable_easy(test_env& env, flat_mutation_reader_v2 rd, sstable_writer_config cfg, int64_t generation = 1, const sstables::sstable::version_types version = sstables::get_highest_sstable_version(), int expected_partition = 1); -shared_sstable make_sstable_easy(test_env& env, const fs::path& path, lw_shared_ptr mt, sstable_writer_config cfg, +shared_sstable make_sstable_easy(test_env& env, lw_shared_ptr mt, sstable_writer_config cfg, unsigned long gen = 1, const sstable::version_types v = sstables::get_highest_sstable_version(), int estimated_partitions = 1, gc_clock::time_point = gc_clock::now());