release: prepare for 5.2.3

Merge 'multishard_mutation_query: make reader_context::lookup_readers() exception safe' from Botond Dénes
With regards to closing the looked-up querier if an exception is thrown. In particular, this requires closing the querier if a semaphore mismatch is detected. Move the table lookup above the line where the querier is looked up, to avoid having to handle the exception from it. As a consequence of closing the querier on the error path, the lookup lambda has to be made a coroutine. This is sad, but this is executed once per page, so its cost should be insignificant when spread over an entire page worth of work. Also add a unit test checking that the mismatch is detected in the first place and that readers are closed. Fixes: #13784 Closes #13790 * github.com:scylladb/scylladb: test/boost/database_test: add unit test for semaphore mismatch on range scans partition_slice_builder: add set_specific_ranges() multishard_mutation_query: make reader_context::lookup_readers() exception safe multishard_mutation_query: lookup_readers(): make inner lambda a coroutine (cherry picked from commit 1c0e8c25ca)
2026-05-01 13:45:53 +00:00 · 2023-06-08 22:04:50 +03:00 · 2023-06-08 04:29:51 -04:00 · 2023-06-06 21:52:47 +03:00 · 2023-06-06 19:39:29 +03:00 · 2023-05-30 20:10:44 +03:00
1163 changed files with 19779 additions and 44898 deletions
--- a/.github/workflows/docs-pages.yaml
+++ b/.github/workflows/docs-pages.yaml
@@ -2,14 +2,10 @@ name: "Docs / Publish"
 # For more information,
 # see https://sphinx-theme.scylladb.com/stable/deployment/production.html#available-workflows

-env:
-  FLAG: ${{ github.repository == 'scylladb/scylla-enterprise' && 'enterprise' || 'opensource' }}
-
 on:
  push:
    branches:
-      - 'master'
-      - 'enterprise'
+      - master
    paths:
      - "docs/**"
  workflow_dispatch:
@@ -28,13 +24,12 @@ jobs:
        with:
          python-version: 3.7
      - name: Set up env
-        run: make -C docs FLAG="${{ env.FLAG }}" setupenv
+        run: make -C docs setupenv
      - name: Build docs
-        run: make -C docs FLAG="${{ env.FLAG }}" multiversion
+        run: make -C docs multiversion
      - name: Build redirects
-        run: make -C docs FLAG="${{ env.FLAG }}" redirects
+        run: make -C docs redirects
      - name: Deploy docs to GitHub Pages
        run: ./docs/_utils/deploy.sh
-        if: (github.ref_name == 'master' && env.FLAG == 'opensource') || (github.ref_name == 'enterprise' && env.FLAG == 'enterprise')
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/docs-pr.yaml
+++ b/.github/workflows/docs-pr.yaml
@@ -2,14 +2,10 @@ name: "Docs / Build PR"
 # For more information,
 # see https://sphinx-theme.scylladb.com/stable/deployment/production.html#available-workflows

-env:
-  FLAG: ${{ github.repository == 'scylladb/scylla-enterprise' && 'enterprise' || 'opensource' }}
-
 on:
  pull_request:
    branches:
      - master
-      - enterprise
    paths:
      - "docs/**"

@@ -27,6 +23,6 @@ jobs:
        with:
          python-version: 3.7
      - name: Set up env
-        run: make -C docs FLAG="${{ env.FLAG }}" setupenv
+        run: make -C docs setupenv
      - name: Build docs
-        run: make -C docs FLAG="${{ env.FLAG }}" test
+        run: make -C docs test
--- a/.gitignore
+++ b/.gitignore
@@ -32,3 +32,4 @@ compile_commands.json
 .ccls-cache/
 .mypy_cache
 .envrc
+rust/Cargo.lock
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,6 @@
 [submodule "seastar"]
 	path = seastar
-	url = ../seastar
+	url = ../scylla-seastar
 	ignore = dirty
 [submodule "swagger-ui"]
 	path = swagger-ui
@@ -15,6 +15,3 @@
 [submodule "scylla-python3"]
 	path = tools/python3
 	url = ../scylla-python3
-[submodule "tools/cqlsh"]
-	path = tools/cqlsh
-	url = ../scylla-cqlsh
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,200 +2,793 @@ cmake_minimum_required(VERSION 3.18)

 project(scylla)

-include(CTest)
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to 'Release' as none was specified.")
+  set(CMAKE_BUILD_TYPE "Release" CACHE
+      STRING "Choose the type of build." FORCE)
+  # Set the possible values of build type for cmake-gui
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
+    "Debug" "Release" "Dev" "Sanitize")
+endif()

-list(APPEND CMAKE_MODULE_PATH
-  ${CMAKE_CURRENT_SOURCE_DIR}/cmake
-  ${CMAKE_CURRENT_SOURCE_DIR}/seastar/cmake)
+if(CMAKE_BUILD_TYPE)
+    string(TOLOWER "${CMAKE_BUILD_TYPE}" BUILD_TYPE)
+else()
+    set(BUILD_TYPE "release")
+endif()
+
+function(default_target_arch arch)
+    set(x86_instruction_sets i386 i686 x86_64)
+    if(CMAKE_SYSTEM_PROCESSOR IN_LIST x86_instruction_sets)
+        set(${arch} "westmere" PARENT_SCOPE)
+    elseif(CMAKE_SYSTEM_PROCESSOR EQUAL "aarch64")
+        set(${arch} "armv8-a+crc+crypto" PARENT_SCOPE)
+    else()
+        set(${arch} "" PARENT_SCOPE)
+    endif()
+endfunction()
+default_target_arch(target_arch)
+if(target_arch)
+    set(target_arch_flag "-march=${target_arch}")
+endif()
+
+set(cxx_coro_flag)
+if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
+    set(cxx_coro_flag -fcoroutines)
+endif()

-set(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE
-    STRING "Choose the type of build." FORCE)
-# Set the possible values of build type for cmake-gui
-set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
-  "Debug" "Release" "Dev" "Sanitize")
-string(TOUPPER "${CMAKE_BUILD_TYPE}" build_mode)
-include(mode.${build_mode})
-include(mode.common)
-add_compile_definitions(
-    ${Seastar_DEFINITIONS_${build_mode}}
-    FMT_DEPRECATED_OSTREAM)
-include(limit_jobs)
 # Configure Seastar compile options to align with Scylla
-set(CMAKE_CXX_STANDARD "20" CACHE INTERNAL "")
-set(CMAKE_CXX_EXTENSIONS ON CACHE INTERNAL "")
-set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(Seastar_CXX_FLAGS ${cxx_coro_flag} ${target_arch_flag} CACHE INTERNAL "" FORCE)
+set(Seastar_CXX_DIALECT gnu++20 CACHE INTERNAL "" FORCE)

-set(Seastar_TESTING ON CACHE BOOL "" FORCE)
 add_subdirectory(seastar)

 # System libraries dependencies
-find_package(Boost REQUIRED
-    COMPONENTS filesystem program_options system thread regex unit_test_framework)
+find_package(Boost COMPONENTS filesystem program_options system thread regex REQUIRED)
 find_package(Lua REQUIRED)
 find_package(ZLIB REQUIRED)
-find_package(ICU COMPONENTS uc i18n REQUIRED)
-find_package(absl COMPONENTS hash raw_hash_set REQUIRED)
-find_package(libdeflate REQUIRED)
-find_package(libxcrypt REQUIRED)
-find_package(Snappy REQUIRED)
-find_package(RapidJSON REQUIRED)
-find_package(Thrift REQUIRED)
-find_package(xxHash REQUIRED)
+find_package(ICU COMPONENTS uc REQUIRED)
+find_package(Abseil REQUIRED)

-set(scylla_gen_build_dir "${CMAKE_BINARY_DIR}/gen")
-file(MAKE_DIRECTORY "${scylla_gen_build_dir}")
+set(scylla_build_dir "${CMAKE_BINARY_DIR}/build/${BUILD_TYPE}")
+set(scylla_gen_build_dir "${scylla_build_dir}/gen")
+file(MAKE_DIRECTORY "${scylla_build_dir}" "${scylla_gen_build_dir}")

+# Place libraries, executables and archives in ${buildroot}/build/${mode}/
+foreach(mode RUNTIME LIBRARY ARCHIVE)
+    set(CMAKE_${mode}_OUTPUT_DIRECTORY "${scylla_build_dir}")
+endforeach()

-add_library(scylla-main STATIC)
-target_sources(scylla-main
-  PRIVATE
+# Generate C++ source files from thrift definitions
+function(scylla_generate_thrift)
+    set(one_value_args TARGET VAR IN_FILE OUT_DIR SERVICE)
+    cmake_parse_arguments(args "" "${one_value_args}" "" ${ARGN})
+
+    get_filename_component(in_file_name ${args_IN_FILE} NAME_WE)
+
+    set(aux_out_file_name ${args_OUT_DIR}/${in_file_name})
+    set(outputs
+        ${aux_out_file_name}_types.cpp
+        ${aux_out_file_name}_types.h
+        ${aux_out_file_name}_constants.cpp
+        ${aux_out_file_name}_constants.h
+        ${args_OUT_DIR}/${args_SERVICE}.cpp
+        ${args_OUT_DIR}/${args_SERVICE}.h)
+
+    add_custom_command(
+        DEPENDS
+            ${args_IN_FILE}
+            thrift
+        OUTPUT ${outputs}
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${args_OUT_DIR}
+        COMMAND thrift -gen cpp:cob_style,no_skeleton -out "${args_OUT_DIR}" "${args_IN_FILE}")
+
+    add_custom_target(${args_TARGET}
+        DEPENDS ${outputs})
+
+    set(${args_VAR} ${outputs} PARENT_SCOPE)
+endfunction()
+
+scylla_generate_thrift(
+    TARGET scylla_thrift_gen_cassandra
+    VAR scylla_thrift_gen_cassandra_files
+    IN_FILE "${CMAKE_SOURCE_DIR}/interface/cassandra.thrift"
+    OUT_DIR ${scylla_gen_build_dir}
+    SERVICE Cassandra)
+
+# Parse antlr3 grammar files and generate C++ sources
+function(scylla_generate_antlr3)
+    set(one_value_args TARGET VAR IN_FILE OUT_DIR)
+    cmake_parse_arguments(args "" "${one_value_args}" "" ${ARGN})
+
+    get_filename_component(in_file_pure_name ${args_IN_FILE} NAME)
+    get_filename_component(stem ${in_file_pure_name} NAME_WE)
+
+    set(outputs
+        "${args_OUT_DIR}/${stem}Lexer.hpp"
+        "${args_OUT_DIR}/${stem}Lexer.cpp"
+        "${args_OUT_DIR}/${stem}Parser.hpp"
+        "${args_OUT_DIR}/${stem}Parser.cpp")
+
+    add_custom_command(
+        DEPENDS
+            ${args_IN_FILE}
+        OUTPUT ${outputs}
+        # Remove #ifdef'ed code from the grammar source code
+        COMMAND sed -e "/^#if 0/,/^#endif/d" "${args_IN_FILE}" > "${args_OUT_DIR}/${in_file_pure_name}"
+        COMMAND antlr3 "${args_OUT_DIR}/${in_file_pure_name}"
+        # We replace many local `ExceptionBaseType* ex` variables with a single function-scope one.
+        # Because we add such a variable to every function, and because `ExceptionBaseType` is not a global
+        # name, we also add a global typedef to avoid compilation errors.
+        COMMAND sed -i -e "/^.*On :.*$/d" "${args_OUT_DIR}/${stem}Lexer.hpp"
+        COMMAND sed -i -e "/^.*On :.*$/d" "${args_OUT_DIR}/${stem}Lexer.cpp"
+        COMMAND sed -i -e "/^.*On :.*$/d" "${args_OUT_DIR}/${stem}Parser.hpp"
+        COMMAND sed -i
+            -e "s/^\\( *\\)\\(ImplTraits::CommonTokenType\\* [a-zA-Z0-9_]* = NULL;\\)$/\\1const \\2/"
+            -e "/^.*On :.*$/d"
+            -e "1i using ExceptionBaseType = int;"
+            -e "s/^{/{ ExceptionBaseType\\* ex = nullptr;/; s/ExceptionBaseType\\* ex = new/ex = new/; s/exceptions::syntax_exception e/exceptions::syntax_exception\\& e/"
+            "${args_OUT_DIR}/${stem}Parser.cpp"
+        VERBATIM)
+
+    add_custom_target(${args_TARGET}
+        DEPENDS ${outputs})
+
+    set(${args_VAR} ${outputs} PARENT_SCOPE)
+endfunction()
+
+set(antlr3_grammar_files
+    cql3/Cql.g
+    alternator/expressions.g)
+
+set(antlr3_gen_files)
+
+foreach(f ${antlr3_grammar_files})
+    get_filename_component(grammar_file_name "${f}" NAME_WE)
+    get_filename_component(f_dir "${f}" DIRECTORY)
+    scylla_generate_antlr3(
+        TARGET scylla_antlr3_gen_${grammar_file_name}
+        VAR scylla_antlr3_gen_${grammar_file_name}_files
+        IN_FILE "${CMAKE_SOURCE_DIR}/${f}"
+        OUT_DIR ${scylla_gen_build_dir}/${f_dir})
+    list(APPEND antlr3_gen_files "${scylla_antlr3_gen_${grammar_file_name}_files}")
+endforeach()
+
+# Generate C++ sources from ragel grammar files
+seastar_generate_ragel(
+    TARGET scylla_ragel_gen_protocol_parser
+    VAR scylla_ragel_gen_protocol_parser_file
+    IN_FILE "${CMAKE_SOURCE_DIR}/redis/protocol_parser.rl"
+    OUT_FILE ${scylla_gen_build_dir}/redis/protocol_parser.hh)
+
+# Generate C++ sources from Swagger definitions
+set(swagger_files
+    api/api-doc/cache_service.json
+    api/api-doc/collectd.json
+    api/api-doc/column_family.json
+    api/api-doc/commitlog.json
+    api/api-doc/compaction_manager.json
+    api/api-doc/config.json
+    api/api-doc/endpoint_snitch_info.json
+    api/api-doc/error_injection.json
+    api/api-doc/failure_detector.json
+    api/api-doc/gossiper.json
+    api/api-doc/hinted_handoff.json
+    api/api-doc/lsa.json
+    api/api-doc/messaging_service.json
+    api/api-doc/storage_proxy.json
+    api/api-doc/storage_service.json
+    api/api-doc/stream_manager.json
+    api/api-doc/system.json
+    api/api-doc/task_manager.json
+    api/api-doc/task_manager_test.json
+    api/api-doc/utils.json)
+
+set(swagger_gen_files)
+
+foreach(f ${swagger_files})
+    get_filename_component(fname "${f}" NAME_WE)
+    get_filename_component(dir "${f}" DIRECTORY)
+    seastar_generate_swagger(
+        TARGET scylla_swagger_gen_${fname}
+        VAR scylla_swagger_gen_${fname}_files
+        IN_FILE "${CMAKE_SOURCE_DIR}/${f}"
+        OUT_DIR "${scylla_gen_build_dir}/${dir}")
+    list(APPEND swagger_gen_files "${scylla_swagger_gen_${fname}_files}")
+endforeach()
+
+# Create C++ bindings for IDL serializers
+function(scylla_generate_idl_serializer)
+    set(one_value_args TARGET VAR IN_FILE OUT_FILE)
+    cmake_parse_arguments(args "" "${one_value_args}" "" ${ARGN})
+    get_filename_component(out_dir ${args_OUT_FILE} DIRECTORY)
+    set(idl_compiler "${CMAKE_SOURCE_DIR}/idl-compiler.py")
+
+    find_package(Python3 COMPONENTS Interpreter)
+
+    add_custom_command(
+        DEPENDS
+            ${args_IN_FILE}
+            ${idl_compiler}
+        OUTPUT ${args_OUT_FILE}
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${out_dir}
+        COMMAND Python3::Interpreter ${idl_compiler} --ns ser -f ${args_IN_FILE} -o ${args_OUT_FILE})
+
+    add_custom_target(${args_TARGET}
+        DEPENDS ${args_OUT_FILE})
+
+    set(${args_VAR} ${args_OUT_FILE} PARENT_SCOPE)
+endfunction()
+
+set(idl_serializers
+    idl/cache_temperature.idl.hh
+    idl/commitlog.idl.hh
+    idl/consistency_level.idl.hh
+    idl/frozen_mutation.idl.hh
+    idl/frozen_schema.idl.hh
+    idl/gossip_digest.idl.hh
+    idl/hinted_handoff.idl.hh
+    idl/idl_test.idl.hh
+    idl/keys.idl.hh
+    idl/messaging_service.idl.hh
+    idl/mutation.idl.hh
+    idl/paging_state.idl.hh
+    idl/partition_checksum.idl.hh
+    idl/paxos.idl.hh
+    idl/query.idl.hh
+    idl/raft.idl.hh
+    idl/range.idl.hh
+    idl/read_command.idl.hh
+    idl/reconcilable_result.idl.hh
+    idl/replay_position.idl.hh
+    idl/result.idl.hh
+    idl/ring_position.idl.hh
+    idl/streaming.idl.hh
+    idl/token.idl.hh
+    idl/tracing.idl.hh
+    idl/truncation_record.idl.hh
+    idl/uuid.idl.hh
+    idl/view.idl.hh)
+
+set(idl_gen_files)
+
+foreach(f ${idl_serializers})
+    get_filename_component(idl_name "${f}" NAME)
+    get_filename_component(idl_target "${idl_name}" NAME_WE)
+    get_filename_component(idl_dir "${f}" DIRECTORY)
+    string(REPLACE ".idl.hh" ".dist.hh" idl_out_hdr_name "${idl_name}")
+    scylla_generate_idl_serializer(
+        TARGET scylla_idl_gen_${idl_target}
+        VAR scylla_idl_gen_${idl_target}_files
+        IN_FILE "${CMAKE_SOURCE_DIR}/${f}"
+        OUT_FILE ${scylla_gen_build_dir}/${idl_dir}/${idl_out_hdr_name})
+    list(APPEND idl_gen_files "${scylla_idl_gen_${idl_target}_files}")
+endforeach()
+
+set(scylla_sources
    absl-flat_hash_map.cc
+    alternator/auth.cc
+    alternator/conditions.cc
+    alternator/controller.cc
+    alternator/executor.cc
+    alternator/expressions.cc
+    alternator/serialization.cc
+    alternator/server.cc
+    alternator/stats.cc
+    alternator/streams.cc
+    api/api.cc
+    api/cache_service.cc
+    api/collectd.cc
+    api/column_family.cc
+    api/commitlog.cc
+    api/compaction_manager.cc
+    api/config.cc
+    api/endpoint_snitch.cc
+    api/error_injection.cc
+    api/failure_detector.cc
+    api/gossiper.cc
+    api/hinted_handoff.cc
+    api/lsa.cc
+    api/messaging_service.cc
+    api/storage_proxy.cc
+    api/storage_service.cc
+    api/stream_manager.cc
+    api/system.cc
+    api/task_manager.cc
+    api/task_manager_test.cc
+    atomic_cell.cc
+    auth/allow_all_authenticator.cc
+    auth/allow_all_authorizer.cc
+    auth/authenticated_user.cc
+    auth/authentication_options.cc
+    auth/authenticator.cc
+    auth/common.cc
+    auth/default_authorizer.cc
+    auth/password_authenticator.cc
+    auth/passwords.cc
+    auth/permission.cc
+    auth/permissions_cache.cc
+    auth/resource.cc
+    auth/role_or_anonymous.cc
+    auth/roles-metadata.cc
+    auth/sasl_challenge.cc
+    auth/service.cc
+    auth/standard_role_manager.cc
+    auth/transitional.cc
    bytes.cc
-    client_data.cc
+    caching_options.cc
+    canonical_mutation.cc
+    cdc/cdc_partitioner.cc
+    cdc/generation.cc
+    cdc/log.cc
+    cdc/metadata.cc
+    cdc/split.cc
    clocks-impl.cc
    collection_mutation.cc
+    compaction/compaction.cc
+    compaction/compaction_manager.cc
+    compaction/compaction_strategy.cc
+    compaction/leveled_compaction_strategy.cc
+    compaction/size_tiered_compaction_strategy.cc
+    compaction/time_window_compaction_strategy.cc
    compress.cc
    converting_mutation_partition_applier.cc
    counters.cc
-    direct_failure_detector/failure_detector.cc
+    cql3/abstract_marker.cc
+    cql3/attributes.cc
+    cql3/cf_name.cc
+    cql3/column_condition.cc
+    cql3/column_identifier.cc
+    cql3/column_specification.cc
+    cql3/constants.cc
+    cql3/cql3_type.cc
+    cql3/expr/expression.cc
+    cql3/expr/prepare_expr.cc
+    cql3/expr/restrictions.cc
+    cql3/functions/aggregate_fcts.cc
+    cql3/functions/castas_fcts.cc
+    cql3/functions/error_injection_fcts.cc
+    cql3/functions/functions.cc
+    cql3/functions/user_function.cc
+    cql3/index_name.cc
+    cql3/keyspace_element_name.cc
+    cql3/lists.cc
+    cql3/maps.cc
+    cql3/operation.cc
+    cql3/prepare_context.cc
+    cql3/query_options.cc
+    cql3/query_processor.cc
+    cql3/restrictions/statement_restrictions.cc
+    cql3/result_set.cc
+    cql3/role_name.cc
+    cql3/selection/abstract_function_selector.cc
+    cql3/selection/selectable.cc
+    cql3/selection/selection.cc
+    cql3/selection/selector.cc
+    cql3/selection/selector_factories.cc
+    cql3/selection/simple_selector.cc
+    cql3/sets.cc
+    cql3/statements/alter_keyspace_statement.cc
+    cql3/statements/alter_service_level_statement.cc
+    cql3/statements/alter_table_statement.cc
+    cql3/statements/alter_type_statement.cc
+    cql3/statements/alter_view_statement.cc
+    cql3/statements/attach_service_level_statement.cc
+    cql3/statements/authentication_statement.cc
+    cql3/statements/authorization_statement.cc
+    cql3/statements/batch_statement.cc
+    cql3/statements/cas_request.cc
+    cql3/statements/cf_prop_defs.cc
+    cql3/statements/cf_statement.cc
+    cql3/statements/create_aggregate_statement.cc
+    cql3/statements/create_function_statement.cc
+    cql3/statements/create_index_statement.cc
+    cql3/statements/create_keyspace_statement.cc
+    cql3/statements/create_service_level_statement.cc
+    cql3/statements/create_table_statement.cc
+    cql3/statements/create_type_statement.cc
+    cql3/statements/create_view_statement.cc
+    cql3/statements/delete_statement.cc
+    cql3/statements/detach_service_level_statement.cc
+    cql3/statements/drop_aggregate_statement.cc
+    cql3/statements/drop_function_statement.cc
+    cql3/statements/drop_index_statement.cc
+    cql3/statements/drop_keyspace_statement.cc
+    cql3/statements/drop_service_level_statement.cc
+    cql3/statements/drop_table_statement.cc
+    cql3/statements/drop_type_statement.cc
+    cql3/statements/drop_view_statement.cc
+    cql3/statements/function_statement.cc
+    cql3/statements/grant_statement.cc
+    cql3/statements/index_prop_defs.cc
+    cql3/statements/index_target.cc
+    cql3/statements/ks_prop_defs.cc
+    cql3/statements/list_permissions_statement.cc
+    cql3/statements/list_service_level_attachments_statement.cc
+    cql3/statements/list_service_level_statement.cc
+    cql3/statements/list_users_statement.cc
+    cql3/statements/modification_statement.cc
+    cql3/statements/permission_altering_statement.cc
+    cql3/statements/property_definitions.cc
+    cql3/statements/raw/parsed_statement.cc
+    cql3/statements/revoke_statement.cc
+    cql3/statements/role-management-statements.cc
+    cql3/statements/schema_altering_statement.cc
+    cql3/statements/select_statement.cc
+    cql3/statements/service_level_statement.cc
+    cql3/statements/sl_prop_defs.cc
+    cql3/statements/truncate_statement.cc
+    cql3/statements/update_statement.cc
+    cql3/statements/strongly_consistent_modification_statement.cc
+    cql3/statements/strongly_consistent_select_statement.cc
+    cql3/statements/use_statement.cc
+    cql3/type_json.cc
+    cql3/untyped_result_set.cc
+    cql3/update_parameters.cc
+    cql3/user_types.cc
+    cql3/util.cc
+    cql3/ut_name.cc
+    cql3/values.cc
+    data_dictionary/data_dictionary.cc
+    db/batchlog_manager.cc
+    db/commitlog/commitlog.cc
+    db/commitlog/commitlog_entry.cc
+    db/commitlog/commitlog_replayer.cc
+    db/config.cc
+    db/consistency_level.cc
+    db/cql_type_parser.cc
+    db/data_listeners.cc
+    db/extensions.cc
+    db/heat_load_balance.cc
+    db/hints/host_filter.cc
+    db/hints/manager.cc
+    db/hints/resource_manager.cc
+    db/hints/sync_point.cc
+    db/large_data_handler.cc
+    db/legacy_schema_migrator.cc
+    db/marshal/type_parser.cc
+    db/rate_limiter.cc
+    db/schema_tables.cc
+    db/size_estimates_virtual_reader.cc
+    db/snapshot-ctl.cc
+    db/sstables-format-selector.cc
+    db/system_distributed_keyspace.cc
+    db/system_keyspace.cc
+    db/view/row_locking.cc
+    db/view/view.cc
+    db/view/view_update_generator.cc
+    db/virtual_table.cc
+    dht/boot_strapper.cc
+    dht/i_partitioner.cc
+    dht/murmur3_partitioner.cc
+    dht/range_streamer.cc
+    dht/token.cc
+    replica/distributed_loader.cc
    duration.cc
    exceptions/exceptions.cc
+    readers/mutation_readers.cc
+    frozen_mutation.cc
    frozen_schema.cc
    generic_server.cc
-    debug.cc
+    gms/application_state.cc
+    gms/endpoint_state.cc
+    gms/failure_detector.cc
+    gms/feature_service.cc
+    gms/gossip_digest_ack2.cc
+    gms/gossip_digest_ack.cc
+    gms/gossip_digest_syn.cc
+    gms/gossiper.cc
+    gms/inet_address.cc
+    gms/versioned_value.cc
+    gms/version_generator.cc
+    hashers.cc
+    index/secondary_index.cc
+    index/secondary_index_manager.cc
    init.cc
    keys.cc
+    utils/lister.cc
+    locator/abstract_replication_strategy.cc
+    locator/azure_snitch.cc
+    locator/ec2_multi_region_snitch.cc
+    locator/ec2_snitch.cc
+    locator/everywhere_replication_strategy.cc
+    locator/gce_snitch.cc
+    locator/gossiping_property_file_snitch.cc
+    locator/local_strategy.cc
+    locator/network_topology_strategy.cc
+    locator/production_snitch_base.cc
+    locator/rack_inferring_snitch.cc
+    locator/simple_snitch.cc
+    locator/simple_strategy.cc
+    locator/snitch_base.cc
+    locator/token_metadata.cc
+    lang/lua.cc
+    main.cc
+    replica/memtable.cc
    message/messaging_service.cc
    multishard_mutation_query.cc
+    mutation.cc
+    mutation_fragment.cc
+    mutation_partition.cc
+    mutation_partition_serializer.cc
+    mutation_partition_view.cc
    mutation_query.cc
+    readers/mutation_reader.cc
+    mutation_writer/feed_writers.cc
+    mutation_writer/multishard_writer.cc
+    mutation_writer/partition_based_splitting_writer.cc
+    mutation_writer/shard_based_splitting_writer.cc
+    mutation_writer/timestamp_based_splitting_writer.cc
    partition_slice_builder.cc
+    partition_version.cc
    querier.cc
    query.cc
    query_ranges_to_vnodes.cc
    query-result-set.cc
+    raft/fsm.cc
+    raft/log.cc
+    raft/raft.cc
+    raft/server.cc
+    raft/tracker.cc
+    service/broadcast_tables/experimental/lang.cc
+    range_tombstone.cc
+    range_tombstone_list.cc
    tombstone_gc_options.cc
    tombstone_gc.cc
    reader_concurrency_semaphore.cc
+    redis/abstract_command.cc
+    redis/command_factory.cc
+    redis/commands.cc
+    redis/keyspace_utils.cc
+    redis/lolwut.cc
+    redis/mutation_utils.cc
+    redis/options.cc
+    redis/query_processor.cc
+    redis/query_utils.cc
+    redis/server.cc
+    redis/service.cc
+    redis/stats.cc
+    release.cc
+    repair/repair.cc
+    repair/row_level.cc
+    replica/database.cc
+    replica/table.cc
    row_cache.cc
+    schema.cc
    schema_mutations.cc
+    schema_registry.cc
    serializer.cc
-    sstables_loader.cc
+    service/client_state.cc
+    service/forward_service.cc
+    service/migration_manager.cc
+    service/misc_services.cc
+    service/pager/paging_state.cc
+    service/pager/query_pagers.cc
+    service/paxos/paxos_state.cc
+    service/paxos/prepare_response.cc
+    service/paxos/prepare_summary.cc
+    service/paxos/proposal.cc
+    service/priority_manager.cc
+    service/qos/qos_common.cc
+    service/qos/service_level_controller.cc
+    service/qos/standard_service_level_distributed_data_accessor.cc
+    service/raft/raft_group_registry.cc
+    service/raft/raft_rpc.cc
+    service/raft/raft_sys_table_storage.cc
+    service/raft/group0_state_machine.cc
+    service/storage_proxy.cc
+    service/storage_service.cc
+    sstables/compress.cc
+    sstables/integrity_checked_file_impl.cc
+    sstables/kl/reader.cc
+    sstables/metadata_collector.cc
+    sstables/m_format_read_helpers.cc
+    sstables/mx/reader.cc
+    sstables/mx/writer.cc
+    sstables/prepended_input_stream.cc
+    sstables/random_access_reader.cc
+    sstables/sstable_directory.cc
+    sstables/sstable_mutation_reader.cc
+    sstables/sstables.cc
+    sstables/sstable_set.cc
+    sstables/sstables_manager.cc
+    sstables/sstable_version.cc
+    sstables/writer.cc
+    streaming/consumer.cc
+    streaming/progress_info.cc
+    streaming/session_info.cc
+    streaming/stream_coordinator.cc
+    streaming/stream_manager.cc
+    streaming/stream_plan.cc
+    streaming/stream_reason.cc
+    streaming/stream_receive_task.cc
+    streaming/stream_request.cc
+    streaming/stream_result_future.cc
+    streaming/stream_session.cc
+    streaming/stream_session_state.cc
+    streaming/stream_summary.cc
+    streaming/stream_task.cc
+    streaming/stream_transfer_task.cc
    table_helper.cc
    tasks/task_manager.cc
+    thrift/controller.cc
+    thrift/handler.cc
+    thrift/server.cc
+    thrift/thrift_validation.cc
    timeout_config.cc
+    tools/scylla-sstable-index.cc
+    tools/scylla-types.cc
+    tracing/traced_file.cc
+    tracing/trace_keyspace_helper.cc
+    tracing/trace_state.cc
+    tracing/tracing_backend_registry.cc
+    tracing/tracing.cc
+    transport/controller.cc
+    transport/cql_protocol_extension.cc
+    transport/event.cc
+    transport/event_notifier.cc
+    transport/messages/result_message.cc
+    transport/server.cc
+    types.cc
    unimplemented.cc
+    utils/arch/powerpc/crc32-vpmsum/crc32_wrapper.cc
+    utils/array-search.cc
+    utils/ascii.cc
+    utils/base64.cc
+    utils/big_decimal.cc
+    utils/bloom_calculations.cc
+    utils/bloom_filter.cc
+    utils/buffer_input_stream.cc
+    utils/build_id.cc
+    utils/config_file.cc
+    utils/directories.cc
+    utils/disk-error-handler.cc
+    utils/dynamic_bitset.cc
+    utils/error_injection.cc
+    utils/exceptions.cc
+    utils/file_lock.cc
+    utils/generation-number.cc
+    utils/gz/crc_combine.cc
+    utils/gz/gen_crc_combine_table.cc
+    utils/human_readable.cc
+    utils/i_filter.cc
+    utils/large_bitset.cc
+    utils/like_matcher.cc
+    utils/limiting_data_source.cc
+    utils/logalloc.cc
+    utils/managed_bytes.cc
+    utils/multiprecision_int.cc
+    utils/murmur_hash.cc
+    utils/rate_limiter.cc
+    utils/rjson.cc
+    utils/runtime.cc
+    utils/updateable_value.cc
+    utils/utf8.cc
+    utils/uuid.cc
+    utils/UUID_gen.cc
    validation.cc
    vint-serialization.cc
    zstd.cc)
-target_link_libraries(scylla-main
-  PRIVATE
-    db
-    absl::hash
-    absl::raw_hash_set
-    Seastar::seastar
-    Snappy::snappy
-    systemd
-    ZLIB::ZLIB)
-add_subdirectory(api)
-add_subdirectory(alternator)
-add_subdirectory(db)
-add_subdirectory(auth)
-add_subdirectory(cdc)
-add_subdirectory(compaction)
-add_subdirectory(cql3)
-add_subdirectory(data_dictionary)
-add_subdirectory(dht)
-add_subdirectory(gms)
-add_subdirectory(idl)
-add_subdirectory(index)
-add_subdirectory(interface)
-add_subdirectory(lang)
-add_subdirectory(locator)
-add_subdirectory(mutation)
-add_subdirectory(mutation_writer)
-add_subdirectory(readers)
-add_subdirectory(redis)
-add_subdirectory(replica)
-add_subdirectory(raft)
-add_subdirectory(repair)
-add_subdirectory(rust)
-add_subdirectory(schema)
-add_subdirectory(service)
-add_subdirectory(sstables)
-add_subdirectory(streaming)
-add_subdirectory(test)
-add_subdirectory(thrift)
-add_subdirectory(tools)
-add_subdirectory(tracing)
-add_subdirectory(transport)
-add_subdirectory(types)
-add_subdirectory(utils)
-include(add_version_library)
-add_version_library(scylla_version
-    release.cc)
+
+set(scylla_gen_sources
+    "${scylla_thrift_gen_cassandra_files}"
+    "${scylla_ragel_gen_protocol_parser_file}"
+    "${swagger_gen_files}"
+    "${idl_gen_files}"
+    "${antlr3_gen_files}")

 add_executable(scylla
-  main.cc)
-target_link_libraries(scylla PRIVATE
-    scylla-main
-    api
-    auth
-    alternator
-    db
-    cdc
-    compaction
-    cql3
-    data_dictionary
-    dht
-    gms
-    idl
-    index
-    lang
-    locator
-    mutation
-    mutation_writer
-    raft
-    readers
-    redis
-    repair
-    replica
-    schema
-    scylla_version
-    service
-    sstables
-    streaming
-    test-perf
-    thrift
-    tools
-    tracing
-    transport
-    types
-    utils)
-target_link_libraries(Boost::regex
-  INTERFACE
-    ICU::i18n
-    ICU::uc)
+    ${scylla_sources}
+    ${scylla_gen_sources})

 target_link_libraries(scylla PRIVATE
    seastar
-    Boost::program_options)
-
-# Force SHA1 build-id generation
-set(default_linker_flags "-Wl,--build-id=sha1")
-include(CheckLinkerFlag)
-foreach(linker "lld" "gold")
-    set(linker_flag "-fuse-ld=${linker}")
-    check_linker_flag(CXX ${linker_flag} "CXX_LINKER_HAVE_${linker}")
-    if(CXX_LINKER_HAVE_${linker})
-        string(APPEND default_linker_flags " ${linker_flag}")
-        break()
-    endif()
-endforeach()
-
-set(CMAKE_EXE_LINKER_FLAGS "${default_linker_flags}" CACHE INTERNAL "")
+    # Boost dependencies
+    Boost::filesystem
+    Boost::program_options
+    Boost::system
+    Boost::thread
+    Boost::regex
+    Boost::headers
+    # Abseil libs
+    absl::hashtablez_sampler
+    absl::raw_hash_set
+    absl::synchronization
+    absl::graphcycles_internal
+    absl::stacktrace
+    absl::symbolize
+    absl::debugging_internal
+    absl::demangle_internal
+    absl::time
+    absl::time_zone
+    absl::int128
+    absl::city
+    absl::hash
+    absl::malloc_internal
+    absl::spinlock_wait
+    absl::base
+    absl::dynamic_annotations
+    absl::raw_logging_internal
+    absl::exponential_biased
+    absl::throw_delegate
+    # System libs
+    ZLIB::ZLIB
+    ICU::uc
+    systemd
+    zstd
+    snappy
+    ${LUA_LIBRARIES}
+    thrift
+    crypt)

+target_link_libraries(scylla PRIVATE
+    -Wl,--build-id=sha1 # Force SHA1 build-id generation
+    # TODO: Use lld linker if it's available, otherwise gold, else bfd
+    -fuse-ld=lld)
 # TODO: patch dynamic linker to match configure.py behavior

+target_compile_options(scylla PRIVATE
+    -std=gnu++20
+    ${cxx_coro_flag}
+    ${target_arch_flag})
+# Hacks needed to expose internal APIs for xxhash dependencies
+target_compile_definitions(scylla PRIVATE XXH_PRIVATE_API HAVE_LZ4_COMPRESS_DEFAULT)
+
 target_include_directories(scylla PRIVATE
    "${CMAKE_CURRENT_SOURCE_DIR}"
+    libdeflate
    "${scylla_gen_build_dir}")
+
+###
+### Create crc_combine_table helper executable.
+### Use it to generate crc_combine_table.cc to be used in scylla at build time.
+###
+add_executable(crc_combine_table utils/gz/gen_crc_combine_table.cc)
+target_link_libraries(crc_combine_table PRIVATE seastar)
+target_include_directories(crc_combine_table PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
+target_compile_options(crc_combine_table PRIVATE
+    -std=gnu++20
+    ${cxx_coro_flag}
+    ${target_arch_flag})
+add_dependencies(scylla crc_combine_table)
+
+# Generate an additional source file at build time that is needed for Scylla compilation
+add_custom_command(OUTPUT "${scylla_gen_build_dir}/utils/gz/crc_combine_table.cc"
+    COMMAND $<TARGET_FILE:crc_combine_table> > "${scylla_gen_build_dir}/utils/gz/crc_combine_table.cc"
+    DEPENDS crc_combine_table)
+target_sources(scylla PRIVATE "${scylla_gen_build_dir}/utils/gz/crc_combine_table.cc")
+
+###
+### Generate version file and supply appropriate compile definitions for release.cc
+###
+execute_process(COMMAND ${CMAKE_SOURCE_DIR}/SCYLLA-VERSION-GEN --output-dir "${CMAKE_BINARY_DIR}/gen" RESULT_VARIABLE scylla_version_gen_res)
+if(scylla_version_gen_res)
+    message(SEND_ERROR "Version file generation failed. Return code: ${scylla_version_gen_res}")
+endif()
+
+file(READ "${CMAKE_BINARY_DIR}/gen/SCYLLA-VERSION-FILE" scylla_version)
+string(STRIP "${scylla_version}" scylla_version)
+
+file(READ "${CMAKE_BINARY_DIR}/gen/SCYLLA-RELEASE-FILE" scylla_release)
+string(STRIP "${scylla_release}" scylla_release)
+
+get_property(release_cdefs SOURCE "${CMAKE_SOURCE_DIR}/release.cc" PROPERTY COMPILE_DEFINITIONS)
+list(APPEND release_cdefs "SCYLLA_VERSION=\"${scylla_version}\"" "SCYLLA_RELEASE=\"${scylla_release}\"")
+set_source_files_properties("${CMAKE_SOURCE_DIR}/release.cc" PROPERTIES COMPILE_DEFINITIONS "${release_cdefs}")
+
+###
+### Custom command for building libdeflate. Link the library to scylla.
+###
+set(libdeflate_lib "${scylla_build_dir}/libdeflate/libdeflate.a")
+add_custom_command(OUTPUT "${libdeflate_lib}"
+    COMMAND make -C "${CMAKE_SOURCE_DIR}/libdeflate"
+        BUILD_DIR=../build/${BUILD_TYPE}/libdeflate/
+        CC=${CMAKE_C_COMPILER}
+        "CFLAGS=${target_arch_flag}"
+        ../build/${BUILD_TYPE}/libdeflate//libdeflate.a) # Two backslashes are important!
+# Hack to force generating custom command to produce libdeflate.a
+add_custom_target(libdeflate DEPENDS "${libdeflate_lib}")
+target_link_libraries(scylla PRIVATE "${libdeflate_lib}")
+
+# TODO: create cmake/ directory and move utilities (generate functions etc) there
+# TODO: Build tests if BUILD_TESTING=on (using CTest module)
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,7 +2,7 @@

 ## Asking questions or requesting help

-Use the [ScyllaDB Community Forum](https://forum.scylladb.com) or the [Slack workspace](http://slack.scylladb.com) for general questions and help.
+Use the [Scylla Users mailing list](https://groups.google.com/g/scylladb-users) or the [Slack workspace](http://slack.scylladb.com) for general questions and help.

 Join the [Scylla Developers mailing list](https://groups.google.com/g/scylladb-dev) for deeper technical discussions and to discuss your ideas for contributions.

--- a/HACKING.md
+++ b/HACKING.md
@@ -195,7 +195,7 @@ $ # Edit configuration options as appropriate
 $ SCYLLA_HOME=$HOME/scylla build/release/scylla
 ```

-The `scylla.yaml` file in the repository by default writes all database data to `/var/lib/scylla`, which likely requires root access. Change the `data_file_directories`, `commitlog_directory` and `schema_commitlog_directory` fields as appropriate.
+The `scylla.yaml` file in the repository by default writes all database data to `/var/lib/scylla`, which likely requires root access. Change the `data_file_directories` and `commitlog_directory` fields as appropriate.

 Scylla has a number of requirements for the file-system and operating system to operate ideally and at peak performance. However, during development, these requirements can be relaxed with the `--developer-mode` flag.

--- a/README.md
+++ b/README.md
@@ -30,9 +30,9 @@ requirements - you just need to meet the frozen toolchain's prerequisites
 Building Scylla with the frozen toolchain `dbuild` is as easy as:

 ```bash
-$ git submodule update --init --force --recursive
-$ ./tools/toolchain/dbuild ./configure.py
-$ ./tools/toolchain/dbuild ninja build/release/scylla
+$ git submodule update --init --force --recursive
+$ ./tools/toolchain/dbuild ./configure.py
+$ ./tools/toolchain/dbuild ninja build/release/scylla
 ```

 For further information, please see:
@@ -60,7 +60,7 @@ Please note that you need to run Scylla with `dbuild` if you built it with the f
 For more run options, run:

 ```bash
-$ ./tools/toolchain/dbuild ./build/release/scylla --help
+$ ./tools/toolchain/dbuild ./build/release/scylla --help
 ```

 ## Testing
@@ -100,10 +100,10 @@ If you are a developer working on Scylla, please read the [developer guidelines]

 ## Contact

-* The [community forum] and [Slack channel] are for users to discuss configuration, management, and operations of the ScyllaDB open source.
+* The [users mailing list] and [Slack channel] are for users to discuss configuration, management, and operations of the ScyllaDB open source.
 * The [developers mailing list] is for developers and people interested in following the development of ScyllaDB to discuss technical topics.

-[Community forum]: https://forum.scylladb.com/
+[Users mailing list]: https://groups.google.com/forum/#!forum/scylladb-users

 [Slack channel]: http://slack.scylladb.com/

--- a/2
+++ b/2
@@ -72,7 +72,7 @@ fi

 # Default scylla product/version tags
 PRODUCT=scylla
-VERSION=5.3.0-dev
+VERSION=5.2.3

 if test -f version
 then
--- a/alternator/CMakeLists.txt
+++ b/alternator/CMakeLists.txt
@@ -1,30 +0,0 @@
-include(generate_cql_grammar)
-generate_cql_grammar(
-  GRAMMAR expressions.g
-  SOURCES cql_grammar_srcs)
-
-add_library(alternator STATIC)
-target_sources(alternator
-  PRIVATE
-    controller.cc
-    server.cc
-    executor.cc
-    stats.cc
-    serialization.cc
-    expressions.cc
-    conditions.cc
-    auth.cc
-    streams.cc
-    ttl.cc
-    ${cql_grammar_srcs})
-target_include_directories(alternator
-  PUBLIC
-    ${CMAKE_SOURCE_DIR}
-    ${CMAKE_BINARY_DIR}
-  PRIVATE
-    ${RAPIDJSON_INCLUDE_DIRS})
-target_link_libraries(alternator
-  cql3
-  idl
-  Seastar::seastar
-  xxHash::xxhash)
--- a/alternator/auth.cc
+++ b/alternator/auth.cc
@@ -10,6 +10,8 @@
 #include "log.hh"
 #include <string>
 #include <string_view>
+#include <gnutls/crypto.h>
+#include "hashers.hh"
 #include "bytes.hh"
 #include "alternator/auth.hh"
 #include <fmt/format.h>
@@ -27,6 +29,99 @@ namespace alternator {

 static logging::logger alogger("alternator-auth");

+static hmac_sha256_digest hmac_sha256(std::string_view key, std::string_view msg) {
+    hmac_sha256_digest digest;
+    int ret = gnutls_hmac_fast(GNUTLS_MAC_SHA256, key.data(), key.size(), msg.data(), msg.size(), digest.data());
+    if (ret) {
+        throw std::runtime_error(fmt::format("Computing HMAC failed ({}): {}", ret, gnutls_strerror(ret)));
+    }
+    return digest;
+}
+
+static hmac_sha256_digest get_signature_key(std::string_view key, std::string_view date_stamp, std::string_view region_name, std::string_view service_name) {
+    auto date = hmac_sha256("AWS4" + std::string(key), date_stamp);
+    auto region = hmac_sha256(std::string_view(date.data(), date.size()), region_name);
+    auto service = hmac_sha256(std::string_view(region.data(), region.size()), service_name);
+    auto signing = hmac_sha256(std::string_view(service.data(), service.size()), "aws4_request");
+    return signing;
+}
+
+static std::string apply_sha256(std::string_view msg) {
+    sha256_hasher hasher;
+    hasher.update(msg.data(), msg.size());
+    return to_hex(hasher.finalize());
+}
+
+static std::string apply_sha256(const std::vector<temporary_buffer<char>>& msg) {
+    sha256_hasher hasher;
+    for (const temporary_buffer<char>& buf : msg) {
+        hasher.update(buf.get(), buf.size());
+    }
+    return to_hex(hasher.finalize());
+}
+
+static std::string format_time_point(db_clock::time_point tp) {
+    time_t time_point_repr = db_clock::to_time_t(tp);
+    std::string time_point_str;
+    time_point_str.resize(17);
+    ::tm time_buf;
+    // strftime prints the terminating null character as well
+    std::strftime(time_point_str.data(), time_point_str.size(), "%Y%m%dT%H%M%SZ", ::gmtime_r(&time_point_repr, &time_buf));
+    time_point_str.resize(16);
+    return time_point_str;
+}
+
+void check_expiry(std::string_view signature_date) {
+    //FIXME: The default 15min can be changed with X-Amz-Expires header - we should honor it
+    std::string expiration_str = format_time_point(db_clock::now() - 15min);
+    std::string validity_str = format_time_point(db_clock::now() + 15min);
+    if (signature_date < expiration_str) {
+        throw api_error::invalid_signature(
+                fmt::format("Signature expired: {} is now earlier than {} (current time - 15 min.)",
+                signature_date, expiration_str));
+    }
+    if (signature_date > validity_str) {
+        throw api_error::invalid_signature(
+                fmt::format("Signature not yet current: {} is still later than {} (current time + 15 min.)",
+                signature_date, validity_str));
+    }
+}
+
+std::string get_signature(std::string_view access_key_id, std::string_view secret_access_key, std::string_view host, std::string_view method,
+        std::string_view orig_datestamp, std::string_view signed_headers_str, const std::map<std::string_view, std::string_view>& signed_headers_map,
+        const std::vector<temporary_buffer<char>>& body_content, std::string_view region, std::string_view service, std::string_view query_string) {
+    auto amz_date_it = signed_headers_map.find("x-amz-date");
+    if (amz_date_it == signed_headers_map.end()) {
+        throw api_error::invalid_signature("X-Amz-Date header is mandatory for signature verification");
+    }
+    std::string_view amz_date = amz_date_it->second;
+    check_expiry(amz_date);
+    std::string_view datestamp = amz_date.substr(0, 8);
+    if (datestamp != orig_datestamp) {
+        throw api_error::invalid_signature(
+                format("X-Amz-Date date does not match the provided datestamp. Expected {}, got {}",
+                        orig_datestamp, datestamp));
+    }
+    std::string_view canonical_uri = "/";
+
+    std::stringstream canonical_headers;
+    for (const auto& header : signed_headers_map) {
+        canonical_headers << fmt::format("{}:{}", header.first, header.second) << '\n';
+    }
+
+    std::string payload_hash = apply_sha256(body_content);
+    std::string canonical_request = fmt::format("{}\n{}\n{}\n{}\n{}\n{}", method, canonical_uri, query_string, canonical_headers.str(), signed_headers_str, payload_hash);
+
+    std::string_view algorithm = "AWS4-HMAC-SHA256";
+    std::string credential_scope = fmt::format("{}/{}/{}/aws4_request", datestamp, region, service);
+    std::string string_to_sign = fmt::format("{}\n{}\n{}\n{}", algorithm, amz_date, credential_scope,  apply_sha256(canonical_request));
+
+    hmac_sha256_digest signing_key = get_signature_key(secret_access_key, datestamp, region, service);
+    hmac_sha256_digest signature = hmac_sha256(std::string_view(signing_key.data(), signing_key.size()), string_to_sign);
+
+    return to_hex(bytes_view(reinterpret_cast<const int8_t*>(signature.data()), signature.size()));
+}
+
 future<std::string> get_key_from_roles(service::storage_proxy& proxy, std::string username) {
    schema_ptr schema = proxy.data_dictionary().find_schema("system_auth", "roles");
    partition_key pk = partition_key::from_single_value(*schema, utf8_type->decompose(username));
--- a/alternator/auth.hh
+++ b/alternator/auth.hh
@@ -20,8 +20,14 @@ class storage_proxy;

 namespace alternator {

+using hmac_sha256_digest = std::array<char, 32>;
+
 using key_cache = utils::loading_cache<std::string, std::string, 1>;

+std::string get_signature(std::string_view access_key_id, std::string_view secret_access_key, std::string_view host, std::string_view method,
+        std::string_view orig_datestamp, std::string_view signed_headers_str, const std::map<std::string_view, std::string_view>& signed_headers_map,
+        const std::vector<temporary_buffer<char>>& body_content, std::string_view region, std::string_view service, std::string_view query_string);
+
 future<std::string> get_key_from_roles(service::storage_proxy& proxy, std::string username);

 }
--- a/alternator/conditions.cc
+++ b/alternator/conditions.cc
@@ -232,14 +232,7 @@ bool check_BEGINS_WITH(const rjson::value* v1, const rjson::value& v2,
    if (it2->name == "S") {
        return rjson::to_string_view(it1->value).starts_with(rjson::to_string_view(it2->value));
    } else /* it2->name == "B" */ {
-        try {
-            return base64_begins_with(rjson::to_string_view(it1->value), rjson::to_string_view(it2->value));
-        } catch(std::invalid_argument&) {
-            // determine if any of the malformed values is from query and raise an exception if so
-            unwrap_bytes(it1->value, v1_from_query);
-            unwrap_bytes(it2->value, v2_from_query);
-            return false;
-        }
+        return base64_begins_with(rjson::to_string_view(it1->value), rjson::to_string_view(it2->value));
    }
 }

@@ -248,7 +241,7 @@ static bool is_set_of(const rjson::value& type1, const rjson::value& type2) {
 }

 // Check if two JSON-encoded values match with the CONTAINS relation
-bool check_CONTAINS(const rjson::value* v1, const rjson::value& v2, bool v1_from_query, bool v2_from_query) {
+bool check_CONTAINS(const rjson::value* v1, const rjson::value& v2) {
    if (!v1) {
        return false;
    }
@@ -257,12 +250,7 @@ bool check_CONTAINS(const rjson::value* v1, const rjson::value& v2, bool v1_from
    if (kv1.name == "S" && kv2.name == "S") {
        return rjson::to_string_view(kv1.value).find(rjson::to_string_view(kv2.value)) != std::string_view::npos;
    } else if (kv1.name == "B" && kv2.name == "B") {
-        auto d_kv1 = unwrap_bytes(kv1.value, v1_from_query);
-        auto d_kv2 = unwrap_bytes(kv2.value, v2_from_query);
-        if (!d_kv1 || !d_kv2) {
-            return false;
-        }
-        return d_kv1->find(*d_kv2) != bytes::npos;
+        return rjson::base64_decode(kv1.value).find(rjson::base64_decode(kv2.value)) != bytes::npos;
    } else if (is_set_of(kv1.name, kv2.name)) {
        for (auto i = kv1.value.Begin(); i != kv1.value.End(); ++i) {
            if (*i == kv2.value) {
@@ -285,11 +273,11 @@ bool check_CONTAINS(const rjson::value* v1, const rjson::value& v2, bool v1_from
 }

 // Check if two JSON-encoded values match with the NOT_CONTAINS relation
-static bool check_NOT_CONTAINS(const rjson::value* v1, const rjson::value& v2, bool v1_from_query, bool v2_from_query) {
+static bool check_NOT_CONTAINS(const rjson::value* v1, const rjson::value& v2) {
    if (!v1) {
        return false;
    }
-    return !check_CONTAINS(v1, v2, v1_from_query, v2_from_query);
+    return !check_CONTAINS(v1, v2);
 }

 // Check if a JSON-encoded value equals any element of an array, which must have at least one element.
@@ -386,12 +374,7 @@ bool check_compare(const rjson::value* v1, const rjson::value& v2, const Compara
                   std::string_view(kv2.value.GetString(), kv2.value.GetStringLength()));
    }
    if (kv1.name == "B") {
-        auto d_kv1 = unwrap_bytes(kv1.value, v1_from_query);
-        auto d_kv2 = unwrap_bytes(kv2.value, v2_from_query);
-        if(!d_kv1 || !d_kv2) {
-            return false;
-        }
-        return cmp(*d_kv1, *d_kv2);
+        return cmp(rjson::base64_decode(kv1.value), rjson::base64_decode(kv2.value));
    }
    // cannot reach here, as check_comparable_type() verifies the type is one
    // of the above options.
@@ -481,13 +464,7 @@ static bool check_BETWEEN(const rjson::value* v, const rjson::value& lb, const r
                             bounds_from_query);
    }
    if (kv_v.name == "B") {
-        auto d_kv_v = unwrap_bytes(kv_v.value, v_from_query);
-        auto d_kv_lb = unwrap_bytes(kv_lb.value, lb_from_query);
-        auto d_kv_ub = unwrap_bytes(kv_ub.value, ub_from_query);
-        if(!d_kv_v || !d_kv_lb || !d_kv_ub) {
-            return false;
-        }
-        return check_BETWEEN(*d_kv_v, *d_kv_lb, *d_kv_ub, bounds_from_query);
+        return check_BETWEEN(rjson::base64_decode(kv_v.value), rjson::base64_decode(kv_lb.value), rjson::base64_decode(kv_ub.value), bounds_from_query);
    }
    if (v_from_query) {
        throw api_error::validation(
@@ -580,7 +557,7 @@ static bool verify_expected_one(const rjson::value& condition, const rjson::valu
                            format("CONTAINS operator requires a single AttributeValue of type String, Number, or Binary, "
                                    "got {} instead", argtype));
                }
-                return check_CONTAINS(got, arg, false, true);
+                return check_CONTAINS(got, arg);
            }
        case comparison_operator_type::NOT_CONTAINS:
            {
@@ -594,7 +571,7 @@ static bool verify_expected_one(const rjson::value& condition, const rjson::valu
                            format("CONTAINS operator requires a single AttributeValue of type String, Number, or Binary, "
                                    "got {} instead", argtype));
                }
-                return check_NOT_CONTAINS(got, arg, false, true);
+                return check_NOT_CONTAINS(got, arg);
            }
        }
        throw std::logic_error(format("Internal error: corrupted operator enum: {}", int(op)));
--- a/alternator/conditions.hh
+++ b/alternator/conditions.hh
@@ -38,7 +38,7 @@ conditional_operator_type get_conditional_operator(const rjson::value& req);
 bool verify_expected(const rjson::value& req, const rjson::value* previous_item);
 bool verify_condition(const rjson::value& condition, bool require_all, const rjson::value* previous_item);

-bool check_CONTAINS(const rjson::value* v1, const rjson::value& v2, bool v1_from_query, bool v2_from_query);
+bool check_CONTAINS(const rjson::value* v1, const rjson::value& v2);
 bool check_BEGINS_WITH(const rjson::value* v1, const rjson::value& v2, bool v1_from_query, bool v2_from_query);

 bool verify_condition_expression(
--- a/alternator/executor.cc
+++ b/alternator/executor.cc
@@ -13,12 +13,12 @@
 #include <seastar/core/sleep.hh>
 #include "alternator/executor.hh"
 #include "log.hh"
-#include "schema/schema_builder.hh"
+#include "schema_builder.hh"
 #include "data_dictionary/keyspace_metadata.hh"
 #include "exceptions/exceptions.hh"
 #include "timestamp.hh"
 #include "types/map.hh"
-#include "schema/schema.hh"
+#include "schema.hh"
 #include "query-request.hh"
 #include "query-result-reader.hh"
 #include "cql3/selection/selection.hh"
@@ -41,7 +41,7 @@
 #include <boost/algorithm/cxx11/any_of.hpp>
 #include "collection_mutation.hh"
 #include "db/query_context.hh"
-#include "schema/schema.hh"
+#include "schema.hh"
 #include "db/tags/extension.hh"
 #include "db/tags/utils.hh"
 #include "alternator/rmw_operation.hh"
@@ -51,13 +51,11 @@
 #include <unordered_set>
 #include "service/storage_proxy.hh"
 #include "gms/gossiper.hh"
-#include "schema/schema_registry.hh"
+#include "schema_registry.hh"
 #include "utils/error_injection.hh"
 #include "db/schema_tables.hh"
 #include "utils/rjson.hh"

-using namespace std::chrono_literals;
-
 logging::logger elogger("alternator-executor");

 namespace alternator {
@@ -117,7 +115,8 @@ std::string json_string::to_json() const {
 void executor::supplement_table_info(rjson::value& descr, const schema& schema, service::storage_proxy& sp) {
    rjson::add(descr, "CreationDateTime", rjson::value(std::chrono::duration_cast<std::chrono::seconds>(gc_clock::now().time_since_epoch()).count()));
    rjson::add(descr, "TableStatus", "ACTIVE");
-    rjson::add(descr, "TableId", rjson::from_string(schema.id().to_sstring()));
+    auto schema_id_str = schema.id().to_sstring();
+    rjson::add(descr, "TableId", rjson::from_string(schema_id_str));

    executor::supplement_table_stream_info(descr, schema, sp);
 }
@@ -129,20 +128,6 @@ void executor::supplement_table_info(rjson::value& descr, const schema& schema,
 // See https://github.com/scylladb/scylla/issues/4480
 static constexpr int max_table_name_length = 222;

-static bool valid_table_name_chars(std::string_view name) {
-    for (auto c : name) {
-        if ((c < 'a' || c > 'z') &&
-            (c < 'A' || c > 'Z') &&
-            (c < '0' || c > '9') &&
-            c != '_' &&
-            c != '-' &&
-            c != '.') {
-            return false;
-        }
-    }
-    return true;
-}
-
 // The DynamoDB developer guide, https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.NamingRules
 // specifies that table names "names must be between 3 and 255 characters long
 // and can contain only the following characters: a-z, A-Z, 0-9, _ (underscore), - (dash), . (dot)
@@ -152,7 +137,8 @@ static void validate_table_name(const std::string& name) {
        throw api_error::validation(
                format("TableName must be at least 3 characters long and at most {} characters long", max_table_name_length));
    }
-    if (!valid_table_name_chars(name)) {
+    static const std::regex valid_table_name_chars ("[a-zA-Z0-9_.-]*");
+    if (!std::regex_match(name.c_str(), valid_table_name_chars)) {
        throw api_error::validation(
                "TableName must satisfy regular expression pattern: [a-zA-Z0-9_.-]+");
    }
@@ -168,10 +154,11 @@ static void validate_table_name(const std::string& name) {
 // The view_name() function assumes the table_name has already been validated
 // but validates the legality of index_name and the combination of both.
 static std::string view_name(const std::string& table_name, std::string_view index_name, const std::string& delim = ":") {
+    static const std::regex valid_index_name_chars ("[a-zA-Z0-9_.-]*");
    if (index_name.length() < 3) {
        throw api_error::validation("IndexName must be at least 3 characters long");
    }
-    if (!valid_table_name_chars(index_name)) {
+    if (!std::regex_match(index_name.data(), valid_index_name_chars)) {
        throw api_error::validation(
                format("IndexName '{}' must satisfy regular expression pattern: [a-zA-Z0-9_.-]+", index_name));
    }
@@ -774,6 +761,7 @@ future<executor::request_return_type> executor::tag_resource(client_state& clien
        co_return api_error::access_denied("Incorrect resource identifier");
    }
    schema_ptr schema = get_table_from_arn(_proxy, rjson::to_string_view(*arn));
+    std::map<sstring, sstring> tags_map = get_tags_of_table_or_throw(schema);
    const rjson::value* tags = rjson::find(request, "Tags");
    if (!tags || !tags->IsArray()) {
        co_return api_error::validation("Cannot parse tags");
@@ -781,9 +769,8 @@ future<executor::request_return_type> executor::tag_resource(client_state& clien
    if (tags->Size() < 1) {
        co_return api_error::validation("The number of tags must be at least 1") ;
    }
-    co_await db::modify_tags(_mm, schema->ks_name(), schema->cf_name(), [tags](std::map<sstring, sstring>& tags_map) {
-        update_tags_map(*tags, tags_map, update_tags_action::add_tags);
-    });
+    update_tags_map(*tags, tags_map,  update_tags_action::add_tags);
+    co_await db::update_tags(_mm, schema, std::move(tags_map));
    co_return json_string("");
 }

@@ -801,9 +788,9 @@ future<executor::request_return_type> executor::untag_resource(client_state& cli

    schema_ptr schema = get_table_from_arn(_proxy, rjson::to_string_view(*arn));

-    co_await db::modify_tags(_mm, schema->ks_name(), schema->cf_name(), [tags](std::map<sstring, sstring>& tags_map) {
-        update_tags_map(*tags, tags_map, update_tags_action::delete_tags);
-    });
+    std::map<sstring, sstring> tags_map = get_tags_of_table_or_throw(schema);
+    update_tags_map(*tags, tags_map, update_tags_action::delete_tags);
+    co_await db::update_tags(_mm, schema, std::move(tags_map));
    co_return json_string("");
 }

@@ -1545,7 +1532,7 @@ future<executor::request_return_type> rmw_operation::execute(service::storage_pr
            // This is the old, unsafe, read before write which does first
            // a read, then a write. TODO: remove this mode entirely.
            return get_previous_item(proxy, client_state, schema(), _pk, _ck, permit, stats).then(
-                    [this, &proxy, trace_state, permit = std::move(permit)] (std::unique_ptr<rjson::value> previous_item) mutable {
+                    [this, &client_state, &proxy, trace_state, permit = std::move(permit)] (std::unique_ptr<rjson::value> previous_item) mutable {
                std::optional<mutation> m = apply(std::move(previous_item), api::new_timestamp());
                if (!m) {
                    return make_ready_future<executor::request_return_type>(api_error::conditional_check_failed("Failed condition."));
@@ -3120,10 +3107,20 @@ future<executor::request_return_type> executor::get_item(client_state& client_st
    });
 }

+// is_big() checks approximately if the given JSON value is "bigger" than
+// the given big_size number of bytes. The goal is to *quickly* detect
+// oversized JSON that, for example, is too large to be serialized to a
+// contiguous string - we don't need an accurate size for that. Moreover,
+// as soon as we detect that the JSON is indeed "big", we can return true
+// and don't need to continue calculating its exact size.
+// For simplicity, we use a recursive implementation. This is fine because
+// Alternator limits the depth of JSONs it reads from inputs, and doesn't
+// add more than a couple of levels in its own output construction.
+
 static void check_big_object(const rjson::value& val, int& size_left);
 static void check_big_array(const rjson::value& val, int& size_left);

-bool is_big(const rjson::value& val, int big_size) {
+static bool is_big(const rjson::value& val, int big_size = 100'000) {
    if (val.IsString()) {
        return ssize_t(val.GetStringLength()) > big_size;
    } else if (val.IsObject()) {
@@ -3571,7 +3568,7 @@ public:
    }
 };

-static std::tuple<rjson::value, size_t> describe_items(const cql3::selection::selection& selection, std::unique_ptr<cql3::result_set> result_set, std::optional<attrs_to_get>&& attrs_to_get, filter&& filter) {
+static std::tuple<rjson::value, size_t> describe_items(schema_ptr schema, const query::partition_slice& slice, const cql3::selection::selection& selection, std::unique_ptr<cql3::result_set> result_set, std::optional<attrs_to_get>&& attrs_to_get, filter&& filter) {
    describe_items_visitor visitor(selection.get_columns(), attrs_to_get, filter);
    result_set->visit(visitor);
    auto scanned_count = visitor.get_scanned_count();
@@ -3621,7 +3618,7 @@ static rjson::value encode_paging_state(const schema& schema, const service::pag
    // We conditionally include these fields when reading CQL tables through alternator.
    if (!is_alternator_keyspace(schema.ks_name()) && (!pos.has_key() || pos.get_bound_weight() != bound_weight::equal)) {
        rjson::add_with_string_name(last_evaluated_key, scylla_paging_region, rjson::empty_object());
-        rjson::add(last_evaluated_key[scylla_paging_region.data()], "S", rjson::from_string(fmt::to_string(pos.region())));
+        rjson::add(last_evaluated_key[scylla_paging_region.data()], "S", rjson::from_string(to_string(pos.region())));
        rjson::add_with_string_name(last_evaluated_key, scylla_paging_weight, rjson::empty_object());
        rjson::add(last_evaluated_key[scylla_paging_weight.data()], "N", static_cast<int>(pos.get_bound_weight()));
    }
@@ -3685,7 +3682,7 @@ static future<executor::request_return_type> do_query(service::storage_proxy& pr
        }
        auto paging_state = rs->get_metadata().paging_state();
        bool has_filter = filter;
-        auto [items, size] = describe_items(*selection, std::move(rs), std::move(attrs_to_get), std::move(filter));
+        auto [items, size] = describe_items(schema, partition_slice, *selection, std::move(rs), std::move(attrs_to_get), std::move(filter));
        if (paging_state) {
            rjson::add(items, "LastEvaluatedKey", encode_paging_state(*schema, *paging_state));
        }
@@ -3694,7 +3691,8 @@ static future<executor::request_return_type> do_query(service::storage_proxy& pr
            // update our "filtered_row_matched_total" for all the rows matched, despited the filter
            cql_stats.filtered_rows_matched_total += size;
        }
-        if (is_big(items)) {
+        // TODO: better threshold
+        if (size > 10) {
            return make_ready_future<executor::request_return_type>(make_streamed(std::move(items)));
        }
        return make_ready_future<executor::request_return_type>(make_jsonable(std::move(items)));
--- a/alternator/executor.hh
+++ b/alternator/executor.hh
@@ -239,15 +239,4 @@ public:
    static void supplement_table_stream_info(rjson::value& descr, const schema& schema, service::storage_proxy& sp);
 };

-// is_big() checks approximately if the given JSON value is "bigger" than
-// the given big_size number of bytes. The goal is to *quickly* detect
-// oversized JSON that, for example, is too large to be serialized to a
-// contiguous string - we don't need an accurate size for that. Moreover,
-// as soon as we detect that the JSON is indeed "big", we can return true
-// and don't need to continue calculating its exact size.
-// For simplicity, we use a recursive implementation. This is fine because
-// Alternator limits the depth of JSONs it reads from inputs, and doesn't
-// add more than a couple of levels in its own output construction.
-bool is_big(const rjson::value& val, int big_size = 100'000);
-
 }
--- a/alternator/expressions.cc
+++ b/alternator/expressions.cc
@@ -634,8 +634,7 @@ std::unordered_map<std::string_view, function_handler_type*> function_handlers {
            }
            rjson::value v1 = calculate_value(f._parameters[0], caller, previous_item);
            rjson::value v2 = calculate_value(f._parameters[1], caller, previous_item);
-            return to_bool_json(check_CONTAINS(v1.IsNull() ? nullptr : &v1,  v2,
-                                    f._parameters[0].is_constant(), f._parameters[1].is_constant()));
+            return to_bool_json(check_CONTAINS(v1.IsNull() ? nullptr : &v1,  v2));
        }
    },
 };
--- a/alternator/expressions_types.hh
+++ b/alternator/expressions_types.hh
@@ -19,7 +19,7 @@
 /*
 * Parsed representation of expressions and their components.
 *
- * Types in alternator::parsed namespace are used for holding the parse
+ * Types in alternator::parse namespace are used for holding the parse
 * tree - objects generated by the Antlr rules after parsing an expression.
 * Because of the way Antlr works, all these objects are default-constructed
 * first, and then assigned when the rule is completed, so all these types
--- a/alternator/serialization.cc
+++ b/alternator/serialization.cc
@@ -14,7 +14,7 @@
 #include "rapidjson/writer.h"
 #include "concrete_types.hh"
 #include "cql3/type_json.hh"
-#include "mutation/position_in_partition.hh"
+#include "position_in_partition.hh"

 static logging::logger slogger("alternator-serialization");

@@ -59,9 +59,7 @@ struct from_json_visitor {
        bo.write(t.from_string(rjson::to_string_view(v)));
    }
    void operator()(const bytes_type_impl& t) const {
-        // FIXME: it's difficult at this point to get information if value was provided
-        // in request or comes from the storage, for now we assume it's user's fault.
-        bo.write(*unwrap_bytes(v, true));
+        bo.write(rjson::base64_decode(v));
    }
    void operator()(const boolean_type_impl& t) const {
        bo.write(boolean_type->decompose(v.GetBool()));
@@ -200,9 +198,7 @@ bytes get_key_from_typed_value(const rjson::value& key_typed_value, const column
                format("The AttributeValue for a key attribute cannot contain an empty string value. Key: {}", column.name_as_text()));
    }
    if (column.type == bytes_type) {
-        // FIXME: it's difficult at this point to get information if value was provided
-        // in request or comes from the storage, for now we assume it's user's fault.
-        return *unwrap_bytes(value, true);
+        return rjson::base64_decode(value);
    } else {
        return column.type->from_string(value_view);
    }
@@ -214,7 +210,7 @@ rjson::value json_key_column_value(bytes_view cell, const column_definition& col
        std::string b64 = base64_encode(cell);
        return rjson::from_string(b64);
    } if (column.type == utf8_type) {
-        return rjson::from_string(reinterpret_cast<const char*>(cell.data()), cell.size());
+        return rjson::from_string(std::string(reinterpret_cast<const char*>(cell.data()), cell.size()));
    } else if (column.type == decimal_type) {
        // FIXME: use specialized Alternator number type, not the more
        // general "decimal_type". A dedicated type can be more efficient
@@ -265,6 +261,7 @@ position_in_partition pos_from_json(const rjson::value& item, schema_ptr schema)
    if (bool(region_item) != bool(weight_item)) {
        throw api_error::validation("Malformed value object: region and weight has to be either both missing or both present");
    }
+    partition_region region;
    bound_weight weight;
    if (region_item) {
        auto region_view = rjson::to_string_view(get_typed_value(*region_item, "S", scylla_paging_region, "key region"));
@@ -322,17 +319,6 @@ std::optional<big_decimal> try_unwrap_number(const rjson::value& v) {
    }
 }

-std::optional<bytes> unwrap_bytes(const rjson::value& value, bool from_query) {
-    try {
-        return rjson::base64_decode(value);
-    } catch (...) {
-        if (from_query) {
-            throw api_error::serialization(format("Invalid base64 data"));
-        }
-        return std::nullopt;
-    }
-}
-
 const std::pair<std::string, const rjson::value*> unwrap_set(const rjson::value& v) {
    if (!v.IsObject() || v.MemberCount() != 1) {
        return {"", nullptr};
@@ -362,7 +348,7 @@ rjson::value number_add(const rjson::value& v1, const rjson::value& v2) {
    auto n1 = unwrap_number(v1, "UpdateExpression");
    auto n2 = unwrap_number(v2, "UpdateExpression");
    rjson::value ret = rjson::empty_object();
-    sstring str_ret = (n1 + n2).to_string();
+    std::string str_ret = std::string((n1 + n2).to_string());
    rjson::add(ret, "N", rjson::from_string(str_ret));
    return ret;
 }
@@ -371,7 +357,7 @@ rjson::value number_subtract(const rjson::value& v1, const rjson::value& v2) {
    auto n1 = unwrap_number(v1, "UpdateExpression");
    auto n2 = unwrap_number(v2, "UpdateExpression");
    rjson::value ret = rjson::empty_object();
-    sstring str_ret = (n1 - n2).to_string();
+    std::string str_ret = std::string((n1 - n2).to_string());
    rjson::add(ret, "N", rjson::from_string(str_ret));
    return ret;
 }
--- a/alternator/serialization.hh
+++ b/alternator/serialization.hh
@@ -11,8 +11,8 @@
 #include <string>
 #include <string_view>
 #include <optional>
-#include "types/types.hh"
-#include "schema/schema_fwd.hh"
+#include "types.hh"
+#include "schema_fwd.hh"
 #include "keys.hh"
 #include "utils/rjson.hh"
 #include "utils/big_decimal.hh"
@@ -62,11 +62,6 @@ big_decimal unwrap_number(const rjson::value& v, std::string_view diagnostic);
 // when the given v does not encode a number.
 std::optional<big_decimal> try_unwrap_number(const rjson::value& v);

-// unwrap_bytes decodes byte value, on decoding failure it either raises api_error::serialization
-// iff from_query is true or returns unset optional iff from_query is false.
-// Therefore it's safe to dereference returned optional when called with from_query equal true.
-std::optional<bytes> unwrap_bytes(const rjson::value& value, bool from_query);
-
 // Check if a given JSON object encodes a set (i.e., it is a {"SS": [...]}, or "NS", "BS"
 // and returns set's type and a pointer to that set. If the object does not encode a set,
 // returned value is {"", nullptr}
--- a/alternator/server.cc
+++ b/alternator/server.cc
@@ -24,7 +24,6 @@
 #include "gms/gossiper.hh"
 #include "utils/overloaded_functor.hh"
 #include "utils/fb_utilities.hh"
-#include "utils/aws_sigv4.hh"

 static logging::logger slogger("alternator-server");

@@ -146,7 +145,7 @@ public:
            std::unique_ptr<request> req, std::unique_ptr<reply> rep) override {
        handle_CORS(*req, *rep, false);
        return _f_handle(std::move(req), std::move(rep)).then(
-                [](std::unique_ptr<reply> rep) {
+                [this](std::unique_ptr<reply> rep) {
                    rep->set_mime_type("application/x-amz-json-1.0");
                    rep->done();
                    return make_ready_future<std::unique_ptr<reply>>(std::move(rep));
@@ -320,13 +319,8 @@ future<std::string> server::verify_signature(const request& req, const chunked_c
                                                    region = std::move(region),
                                                    service = std::move(service),
                                                    user_signature = std::move(user_signature)] (key_cache::value_ptr key_ptr) {
-        std::string signature;
-        try {
-            signature = utils::aws::get_signature(user, *key_ptr, std::string_view(host), "/", req._method,
-                datestamp, signed_headers_str, signed_headers_map, &content, region, service, "");
-        } catch (const std::exception& e) {
-            throw api_error::invalid_signature(e.what());
-        }
+        std::string signature = get_signature(user, *key_ptr, std::string_view(host), req._method,
+                datestamp, signed_headers_str, signed_headers_map, content, region, service, "");

        if (signature != std::string_view(user_signature)) {
            _key_cache.remove(user);
--- a/alternator/server.hh
+++ b/alternator/server.hh
@@ -30,8 +30,8 @@ class server {
            tracing::trace_state_ptr, service_permit, rjson::value, std::unique_ptr<http::request>)>;
    using alternator_callbacks_map = std::unordered_map<std::string_view, alternator_callback>;

-    httpd::http_server _http_server;
-    httpd::http_server _https_server;
+    http_server _http_server;
+    http_server _https_server;
    executor& _executor;
    service::storage_proxy& _proxy;
    gms::gossiper& _gossiper;
--- a/alternator/streams.cc
+++ b/alternator/streams.cc
@@ -27,14 +27,13 @@
 #include "cql3/result_set.hh"
 #include "cql3/type_json.hh"
 #include "cql3/column_identifier.hh"
-#include "schema/schema_builder.hh"
+#include "schema_builder.hh"
 #include "service/storage_proxy.hh"
 #include "gms/feature.hh"
 #include "gms/feature_service.hh"

 #include "executor.hh"
 #include "rmw_operation.hh"
-#include "data_dictionary/data_dictionary.hh"

 /**
 * Base template type to implement  rapidjson::internal::TypeHelper<...>:s
@@ -141,37 +140,23 @@ namespace alternator {
 future<alternator::executor::request_return_type> alternator::executor::list_streams(client_state& client_state, service_permit permit, rjson::value request) {
    _stats.api_operations.list_streams++;

-    auto limit = rjson::get_opt<int>(request, "Limit").value_or(100);
+    auto limit = rjson::get_opt<int>(request, "Limit").value_or(std::numeric_limits<int>::max());
    auto streams_start = rjson::get_opt<stream_arn>(request, "ExclusiveStartStreamArn");
    auto table = find_table(_proxy, request);
    auto db = _proxy.data_dictionary();
+    auto cfs = db.get_tables();

    if (limit < 1) {
        throw api_error::validation("Limit must be 1 or more");
    }

-    std::vector<data_dictionary::table> cfs;
-
-    if (table) {
-        auto log_name = cdc::log_name(table->cf_name());
-        try {
-            cfs.emplace_back(db.find_table(table->ks_name(), log_name));
-        } catch (data_dictionary::no_such_column_family&) {
-            cfs.clear();
-        }
-    } else {
-        cfs = db.get_tables();
-    }
-
    // # 12601 (maybe?) - sort the set of tables on ID. This should ensure we never
    // generate duplicates in a paged listing here. Can obviously miss things if they 
    // are added between paged calls and end up with a "smaller" UUID/ARN, but that 
    // is to be expected.
-    if (std::cmp_less(limit, cfs.size()) || streams_start) {
-        std::sort(cfs.begin(), cfs.end(), [](const data_dictionary::table& t1, const data_dictionary::table& t2) {
-            return t1.schema()->id().uuid() < t2.schema()->id().uuid();
-        });
-    }
+    std::sort(cfs.begin(), cfs.end(), [](const data_dictionary::table& t1, const data_dictionary::table& t2) {
+        return t1.schema()->id().uuid() < t2.schema()->id().uuid();
+    });

    auto i = cfs.begin();
    auto e = cfs.end();
@@ -201,7 +186,14 @@ future<alternator::executor::request_return_type> alternator::executor::list_str
        if (!is_alternator_keyspace(ks_name)) {
            continue;
        }
+        if (table && ks_name != table->ks_name()) {
+            continue;
+        }
        if (cdc::is_log_for_some_table(db.real_database(), ks_name, cf_name)) {
+            if (table && table != cdc::get_base_table(db.real_database(), *s)) {
+                continue;
+            }
+
            rjson::value new_entry = rjson::empty_object();

            last = i->schema()->id();
@@ -429,8 +421,6 @@ static std::chrono::seconds confidence_interval(data_dictionary::database db) {
    return std::chrono::seconds(db.get_config().alternator_streams_time_window_s());
 }

-using namespace std::chrono_literals;
-
 // Dynamo docs says no data shall live longer than 24h.
 static constexpr auto dynamodb_streams_max_window = 24h;

@@ -508,7 +498,7 @@ future<executor::request_return_type> executor::describe_stream(client_state& cl
    // filter out cdc generations older than the table or now() - cdc::ttl (typically dynamodb_streams_max_window - 24h)
    auto low_ts = std::max(as_timepoint(schema->id()), db_clock::now() - ttl);

-    return _sdks.cdc_get_versioned_streams(low_ts, { normal_token_owners }).then([db, shard_start, limit, ret = std::move(ret), stream_desc = std::move(stream_desc)] (std::map<db_clock::time_point, cdc::streams_version> topologies) mutable {
+    return _sdks.cdc_get_versioned_streams(low_ts, { normal_token_owners }).then([this, db, shard_start, limit, ret = std::move(ret), stream_desc = std::move(stream_desc)] (std::map<db_clock::time_point, cdc::streams_version> topologies) mutable {

        auto e = topologies.end();
        auto prev = e;
@@ -827,7 +817,7 @@ future<executor::request_return_type> executor::get_records(client_state& client
    }

    if (!schema || !base || !is_alternator_keyspace(schema->ks_name())) {
-        throw api_error::resource_not_found(fmt::to_string(iter.table));
+        throw api_error::resource_not_found(boost::lexical_cast<std::string>(iter.table));
    }

    tracing::add_table_name(trace_state, schema->ks_name(), schema->cf_name());
@@ -1027,7 +1017,7 @@ future<executor::request_return_type> executor::get_records(client_state& client
        // ugh. figure out if we are and end-of-shard
        auto normal_token_owners = _proxy.get_token_metadata_ptr()->count_normal_token_owners();

-        return _sdks.cdc_current_generation_timestamp({ normal_token_owners }).then([this, iter, high_ts, start_time, ret = std::move(ret)](db_clock::time_point ts) mutable {
+        return _sdks.cdc_current_generation_timestamp({ normal_token_owners }).then([this, iter, high_ts, start_time, ret = std::move(ret), nrecords](db_clock::time_point ts) mutable {
            auto& shard = iter.shard;            

            if (shard.time < ts && ts < high_ts) {
@@ -1044,7 +1034,8 @@ future<executor::request_return_type> executor::get_records(client_state& client
                rjson::add(ret, "NextShardIterator", iter);
            }
            _stats.api_operations.get_records_latency.add(std::chrono::steady_clock::now() - start_time);
-            if (is_big(ret)) {
+            // TODO: determine a better threshold...
+            if (nrecords > 10) {
                return make_ready_future<executor::request_return_type>(make_streamed(std::move(ret)));
            }
            return make_ready_future<executor::request_return_type>(make_jsonable(std::move(ret)));
--- a/alternator/ttl.cc
+++ b/alternator/ttl.cc
@@ -33,8 +33,8 @@
 #include "service/pager/query_pagers.hh"
 #include "gms/feature_service.hh"
 #include "sstables/types.hh"
-#include "mutation/mutation.hh"
-#include "types/types.hh"
+#include "mutation.hh"
+#include "types.hh"
 #include "types/map.hh"
 #include "utils/rjson.hh"
 #include "utils/big_decimal.hh"
@@ -94,25 +94,24 @@ future<executor::request_return_type> executor::update_time_to_live(client_state
    }
    sstring attribute_name(v->GetString(), v->GetStringLength());

-    co_await db::modify_tags(_mm, schema->ks_name(), schema->cf_name(), [&](std::map<sstring, sstring>& tags_map) {
-        if (enabled) {
-            if (tags_map.contains(TTL_TAG_KEY)) {
-                throw api_error::validation("TTL is already enabled");
-            }
-            tags_map[TTL_TAG_KEY] = attribute_name;
-        } else {
-            auto i = tags_map.find(TTL_TAG_KEY);
-            if (i == tags_map.end()) {
-                throw api_error::validation("TTL is already disabled");
-            } else if (i->second != attribute_name) {
-                throw api_error::validation(format(
-                    "Requested to disable TTL on attribute {}, but a different attribute {} is enabled.",
-                    attribute_name, i->second));
-            }
-            tags_map.erase(TTL_TAG_KEY);
+    std::map<sstring, sstring> tags_map = get_tags_of_table_or_throw(schema);
+    if (enabled) {
+        if (tags_map.contains(TTL_TAG_KEY)) {
+            co_return api_error::validation("TTL is already enabled");
        }
-    });
-
+        tags_map[TTL_TAG_KEY] = attribute_name;
+    } else {
+        auto i = tags_map.find(TTL_TAG_KEY);
+        if (i == tags_map.end()) {
+            co_return api_error::validation("TTL is already disabled");
+        } else if (i->second != attribute_name) {
+            co_return api_error::validation(format(
+                "Requested to disable TTL on attribute {}, but a different attribute {} is enabled.",
+                attribute_name, i->second));
+        }
+        tags_map.erase(TTL_TAG_KEY);
+    }
+    co_await db::update_tags(_mm, schema, std::move(tags_map));
    // Prepare the response, which contains a TimeToLiveSpecification
    // basically identical to the request's
    rjson::value response = rjson::empty_object();
--- a/api/CMakeLists.txt
+++ b/api/CMakeLists.txt
@@ -1,70 +0,0 @@
-# Generate C++ sources from Swagger definitions
-set(swagger_files
-  api-doc/authorization_cache.json
-  api-doc/cache_service.json
-  api-doc/collectd.json
-  api-doc/column_family.json
-  api-doc/commitlog.json
-  api-doc/compaction_manager.json
-  api-doc/config.json
-  api-doc/endpoint_snitch_info.json
-  api-doc/error_injection.json
-  api-doc/failure_detector.json
-  api-doc/gossiper.json
-  api-doc/hinted_handoff.json
-  api-doc/lsa.json
-  api-doc/messaging_service.json
-  api-doc/storage_proxy.json
-  api-doc/storage_service.json
-  api-doc/stream_manager.json
-  api-doc/system.json
-  api-doc/task_manager.json
-  api-doc/task_manager_test.json
-  api-doc/utils.json)
-
-foreach(f ${swagger_files})
-  get_filename_component(fname "${f}" NAME_WE)
-  get_filename_component(dir "${f}" DIRECTORY)
-  seastar_generate_swagger(
-    TARGET scylla_swagger_gen_${fname}
-    VAR scylla_swagger_gen_${fname}_files
-    IN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/${f}"
-    OUT_DIR "${scylla_gen_build_dir}/api/${dir}")
-  list(APPEND swagger_gen_files "${scylla_swagger_gen_${fname}_files}")
-endforeach()
-
-add_library(api)
-target_sources(api
-  PRIVATE
-    api.cc
-    cache_service.cc
-    collectd.cc
-    column_family.cc
-    commitlog.cc
-    compaction_manager.cc
-    config.cc
-    endpoint_snitch.cc
-    error_injection.cc
-    authorization_cache.cc
-    failure_detector.cc
-    gossiper.cc
-    hinted_handoff.cc
-    lsa.cc
-    messaging_service.cc
-    storage_proxy.cc
-    storage_service.cc
-    stream_manager.cc
-    system.cc
-    task_manager.cc
-    task_manager_test.cc
-    ${swagger_gen_files})
-target_include_directories(api
-  PUBLIC
-    ${CMAKE_SOURCE_DIR}
-    ${scylla_gen_build_dir})
-target_link_libraries(api
-  idl
-  wasmtime_bindings
-
-  Seastar::seastar
-  xxHash::xxhash)
--- a/api/api-doc/task_manager.json
+++ b/api/api-doc/task_manager.json
@@ -175,31 +175,7 @@
            ]
         }
      ]
-     },
-     {
-         "path":"/task_manager/ttl",
-         "operations":[
-            {
-               "method":"POST",
-               "summary":"Set ttl in seconds and get last value",
-               "type":"long",
-               "nickname":"get_and_update_ttl",
-               "produces":[
-                  "application/json"
-               ],
-               "parameters":[
-                  {
-                     "name":"ttl",
-                     "description":"The number of seconds for which the tasks will be kept in memory after it finishes",
-                     "required":true,
-                     "allowMultiple":false,
-                     "type":"long",
-                     "paramType":"query"
-                  }
-               ]
-            }
-         ]
-     }
+    }
    ],
    "models":{
       "task_stats" :{
--- a/api/api-doc/task_manager_test.json
+++ b/api/api-doc/task_manager_test.json
@@ -148,6 +148,30 @@
                ]
             }
          ]
-       }
+       },
+       {
+         "path":"/task_manager_test/ttl",
+         "operations":[
+            {
+               "method":"POST",
+               "summary":"Set ttl in seconds and get last value",
+               "type":"long",
+               "nickname":"get_and_update_ttl",
+               "produces":[
+                  "application/json"
+               ],
+               "parameters":[
+                  {
+                     "name":"ttl",
+                     "description":"The number of seconds for which the tasks will be kept in memory after it finishes",
+                     "required":true,
+                     "allowMultiple":false,
+                     "type":"long",
+                     "paramType":"query"
+                  }
+               ]
+            }
+         ]
+      }
    ]
 }
--- a/api/api.cc
+++ b/api/api.cc
@@ -35,7 +35,6 @@
 logging::logger apilog("api");

 namespace api {
-using namespace seastar::httpd;

 static std::unique_ptr<reply> exception_reply(std::exception_ptr eptr) {
    try {
@@ -166,15 +165,9 @@ future<> set_server_gossip(http_context& ctx, sharded<gms::gossiper>& g) {
                });
 }

-future<> set_server_load_sstable(http_context& ctx, sharded<db::system_keyspace>& sys_ks) {
+future<> set_server_load_sstable(http_context& ctx) {
    return register_api(ctx, "column_family",
-                "The column family API", [&sys_ks] (http_context& ctx, routes& r) {
-                    set_column_family(ctx, r, sys_ks);
-                });
-}
-
-future<> unset_server_load_sstable(http_context& ctx) {
-    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_column_family(ctx, r); });
+                "The column family API", set_column_family);
 }

 future<> set_server_messaging_service(http_context& ctx, sharded<netw::messaging_service>& ms) {
@@ -194,10 +187,6 @@ future<> set_server_storage_proxy(http_context& ctx, sharded<service::storage_se
                });
 }

-future<> unset_server_storage_proxy(http_context& ctx) {
-    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_storage_proxy(ctx, r); });
-}
-
 future<> set_server_stream_manager(http_context& ctx, sharded<streaming::stream_manager>& sm) {
    return register_api(ctx, "stream_manager",
                "The stream manager API", [&sm] (http_context& ctx, routes& r) {
@@ -264,25 +253,25 @@ future<> set_server_done(http_context& ctx) {
    });
 }

-future<> set_server_task_manager(http_context& ctx, lw_shared_ptr<db::config> cfg) {
+future<> set_server_task_manager(http_context& ctx) {
    auto rb = std::make_shared < api_registry_builder > (ctx.api_doc);

-    return ctx.http_server.set_routes([rb, &ctx, &cfg = *cfg](routes& r) {
+    return ctx.http_server.set_routes([rb, &ctx](routes& r) {
        rb->register_function(r, "task_manager",
                "The task manager API");
-        set_task_manager(ctx, r, cfg);
+        set_task_manager(ctx, r);
    });
 }

 #ifndef SCYLLA_BUILD_MODE_RELEASE

-future<> set_server_task_manager_test(http_context& ctx) {
+future<> set_server_task_manager_test(http_context& ctx, lw_shared_ptr<db::config> cfg) {
    auto rb = std::make_shared < api_registry_builder > (ctx.api_doc);

-    return ctx.http_server.set_routes([rb, &ctx](routes& r) mutable {
+    return ctx.http_server.set_routes([rb, &ctx, &cfg = *cfg](routes& r) mutable {
        rb->register_function(r, "task_manager_test",
                "The task manager test API");
-        set_task_manager_test(ctx, r);
+        set_task_manager_test(ctx, r, cfg);
    });
 }

--- a/api/api.hh
+++ b/api/api.hh
@@ -27,7 +27,7 @@ template<class T>
 std::vector<sstring> container_to_vec(const T& container) {
    std::vector<sstring> res;
    for (auto i : container) {
-        res.push_back(fmt::to_string(i));
+        res.push_back(boost::lexical_cast<std::string>(i));
    }
    return res;
 }
@@ -47,8 +47,8 @@ template<class T, class MAP>
 std::vector<T>& map_to_key_value(const MAP& map, std::vector<T>& res) {
    for (auto i : map) {
        T val;
-        val.key = fmt::to_string(i.first);
-        val.value = fmt::to_string(i.second);
+        val.key = boost::lexical_cast<std::string>(i.first);
+        val.value = boost::lexical_cast<std::string>(i.second);
        res.push_back(val);
    }
    return res;
@@ -65,7 +65,7 @@ template <typename MAP>
 std::vector<sstring> map_keys(const MAP& map) {
    std::vector<sstring> res;
    for (const auto& i : map) {
-        res.push_back(fmt::to_string(i.first));
+        res.push_back(boost::lexical_cast<std::string>(i.first));
    }
    return res;
 }
@@ -189,7 +189,7 @@ struct basic_ratio_holder : public json::jsonable {
 typedef basic_ratio_holder<double>  ratio_holder;
 typedef basic_ratio_holder<int64_t> integral_ratio_holder;

-class unimplemented_exception : public httpd::base_exception {
+class unimplemented_exception : public base_exception {
 public:
    unimplemented_exception()
            : base_exception("API call is not supported yet", reply::status_type::internal_server_error) {
@@ -238,7 +238,7 @@ public:
                value = T{boost::lexical_cast<Base>(param)};
            }
        } catch (boost::bad_lexical_cast&) {
-            throw httpd::bad_param_exception(format("{} ({}): type error - should be {}", name, param, boost::units::detail::demangle(typeid(Base).name())));
+            throw bad_param_exception(format("{} ({}): type error - should be {}", name, param, boost::units::detail::demangle(typeid(Base).name())));
        }
    }

@@ -306,6 +306,6 @@ public:
    }
 };

-httpd::utils_json::estimated_histogram time_to_json_histogram(const utils::time_estimated_histogram& val);
+utils_json::estimated_histogram time_to_json_histogram(const utils::time_estimated_histogram& val);

 }
--- a/api/api_init.hh
+++ b/api/api_init.hh
@@ -102,12 +102,10 @@ future<> unset_server_authorization_cache(http_context& ctx);
 future<> set_server_snapshot(http_context& ctx, sharded<db::snapshot_ctl>& snap_ctl);
 future<> unset_server_snapshot(http_context& ctx);
 future<> set_server_gossip(http_context& ctx, sharded<gms::gossiper>& g);
-future<> set_server_load_sstable(http_context& ctx, sharded<db::system_keyspace>& sys_ks);
-future<> unset_server_load_sstable(http_context& ctx);
+future<> set_server_load_sstable(http_context& ctx);
 future<> set_server_messaging_service(http_context& ctx, sharded<netw::messaging_service>& ms);
 future<> unset_server_messaging_service(http_context& ctx);
 future<> set_server_storage_proxy(http_context& ctx, sharded<service::storage_service>& ss);
-future<> unset_server_storage_proxy(http_context& ctx);
 future<> set_server_stream_manager(http_context& ctx, sharded<streaming::stream_manager>& sm);
 future<> unset_server_stream_manager(http_context& ctx);
 future<> set_hinted_handoff(http_context& ctx, sharded<gms::gossiper>& g);
@@ -116,7 +114,7 @@ future<> set_server_gossip_settle(http_context& ctx, sharded<gms::gossiper>& g);
 future<> set_server_cache(http_context& ctx);
 future<> set_server_compaction_manager(http_context& ctx);
 future<> set_server_done(http_context& ctx);
-future<> set_server_task_manager(http_context& ctx, lw_shared_ptr<db::config> cfg);
-future<> set_server_task_manager_test(http_context& ctx);
+future<> set_server_task_manager(http_context& ctx);
+future<> set_server_task_manager_test(http_context& ctx, lw_shared_ptr<db::config> cfg);

 }
--- a/api/authorization_cache.cc
+++ b/api/authorization_cache.cc
@@ -14,10 +14,9 @@

 namespace api {
 using namespace json;
-using namespace seastar::httpd;

 void set_authorization_cache(http_context& ctx, routes& r, sharded<auth::service> &auth_service) {
-    httpd::authorization_cache_json::authorization_cache_reset.set(r, [&auth_service] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    httpd::authorization_cache_json::authorization_cache_reset.set(r, [&auth_service] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        co_await auth_service.invoke_on_all([] (auth::service& auth) -> future<>  {
            auth.reset_authorization_cache();
            return make_ready_future<>();
--- a/api/authorization_cache.hh
+++ b/api/authorization_cache.hh
@@ -12,7 +12,7 @@

 namespace api {

-void set_authorization_cache(http_context& ctx, httpd::routes& r, sharded<auth::service> &auth_service);
-void unset_authorization_cache(http_context& ctx, httpd::routes& r);
+void set_authorization_cache(http_context& ctx, routes& r, sharded<auth::service> &auth_service);
+void unset_authorization_cache(http_context& ctx, routes& r);

 }
--- a/api/cache_service.cc
+++ b/api/cache_service.cc
@@ -12,128 +12,127 @@

 namespace api {
 using namespace json;
-using namespace seastar::httpd;
 namespace cs = httpd::cache_service_json;

 void set_cache_service(http_context& ctx, routes& r) {
-    cs::get_row_cache_save_period_in_seconds.set(r, [](std::unique_ptr<http::request> req) {
+    cs::get_row_cache_save_period_in_seconds.set(r, [](std::unique_ptr<request> req) {
        // We never save the cache
        // Origin uses 0 for never
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::set_row_cache_save_period_in_seconds.set(r, [](std::unique_ptr<http::request> req) {
+    cs::set_row_cache_save_period_in_seconds.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        auto period = req->get_query_param("period");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::get_key_cache_save_period_in_seconds.set(r, [](std::unique_ptr<http::request> req) {
+    cs::get_key_cache_save_period_in_seconds.set(r, [](std::unique_ptr<request> req) {
        // We never save the cache
        // Origin uses 0 for never
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::set_key_cache_save_period_in_seconds.set(r, [](std::unique_ptr<http::request> req) {
+    cs::set_key_cache_save_period_in_seconds.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        auto period = req->get_query_param("period");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::get_counter_cache_save_period_in_seconds.set(r, [](std::unique_ptr<http::request> req) {
+    cs::get_counter_cache_save_period_in_seconds.set(r, [](std::unique_ptr<request> req) {
        // We never save the cache
        // Origin uses 0 for never
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::set_counter_cache_save_period_in_seconds.set(r, [](std::unique_ptr<http::request> req) {
+    cs::set_counter_cache_save_period_in_seconds.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        auto ccspis = req->get_query_param("ccspis");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::get_row_cache_keys_to_save.set(r, [](std::unique_ptr<http::request> req) {
+    cs::get_row_cache_keys_to_save.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::set_row_cache_keys_to_save.set(r, [](std::unique_ptr<http::request> req) {
+    cs::set_row_cache_keys_to_save.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        auto rckts = req->get_query_param("rckts");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::get_key_cache_keys_to_save.set(r, [](std::unique_ptr<http::request> req) {
+    cs::get_key_cache_keys_to_save.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::set_key_cache_keys_to_save.set(r, [](std::unique_ptr<http::request> req) {
+    cs::set_key_cache_keys_to_save.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        auto kckts = req->get_query_param("kckts");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::get_counter_cache_keys_to_save.set(r, [](std::unique_ptr<http::request> req) {
+    cs::get_counter_cache_keys_to_save.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::set_counter_cache_keys_to_save.set(r, [](std::unique_ptr<http::request> req) {
+    cs::set_counter_cache_keys_to_save.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        auto cckts = req->get_query_param("cckts");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::invalidate_key_cache.set(r, [](std::unique_ptr<http::request> req) {
+    cs::invalidate_key_cache.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::invalidate_counter_cache.set(r, [](std::unique_ptr<http::request> req) {
+    cs::invalidate_counter_cache.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::set_row_cache_capacity_in_mb.set(r, [](std::unique_ptr<http::request> req) {
+    cs::set_row_cache_capacity_in_mb.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        auto capacity = req->get_query_param("capacity");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::set_key_cache_capacity_in_mb.set(r, [](std::unique_ptr<http::request> req) {
+    cs::set_key_cache_capacity_in_mb.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        auto period = req->get_query_param("period");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::set_counter_cache_capacity_in_mb.set(r, [](std::unique_ptr<http::request> req) {
+    cs::set_counter_cache_capacity_in_mb.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        auto capacity = req->get_query_param("capacity");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::save_caches.set(r, [](std::unique_ptr<http::request> req) {
+    cs::save_caches.set(r, [](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cs::get_key_capacity.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_key_capacity.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support keys cache,
@@ -141,7 +140,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_key_hits.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_key_hits.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support keys cache,
@@ -149,7 +148,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_key_requests.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_key_requests.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support keys cache,
@@ -157,7 +156,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_key_hit_rate.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_key_hit_rate.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support keys cache,
@@ -165,21 +164,21 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_key_hits_moving_avrage.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_key_hits_moving_avrage.set(r, [&ctx] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // See above
        return make_ready_future<json::json_return_type>(meter_to_json(utils::rate_moving_average()));
    });

-    cs::get_key_requests_moving_avrage.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_key_requests_moving_avrage.set(r, [&ctx] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // See above
        return make_ready_future<json::json_return_type>(meter_to_json(utils::rate_moving_average()));
    });

-    cs::get_key_size.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_key_size.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support keys cache,
@@ -187,7 +186,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_key_entries.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_key_entries.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support keys cache,
@@ -195,7 +194,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_row_capacity.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cs::get_row_capacity.set(r, [&ctx] (std::unique_ptr<request> req) {
        return ctx.db.map_reduce0([](replica::database& db) -> uint64_t {
            return db.row_cache_tracker().region().occupancy().used_space();
        }, uint64_t(0), std::plus<uint64_t>()).then([](const int64_t& res) {
@@ -203,26 +202,26 @@ void set_cache_service(http_context& ctx, routes& r) {
        });
    });

-    cs::get_row_hits.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cs::get_row_hits.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, uint64_t(0), [](const replica::column_family& cf) {
            return cf.get_row_cache().stats().hits.count();
        }, std::plus<uint64_t>());
    });

-    cs::get_row_requests.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cs::get_row_requests.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, uint64_t(0), [](const replica::column_family& cf) {
            return cf.get_row_cache().stats().hits.count() + cf.get_row_cache().stats().misses.count();
        }, std::plus<uint64_t>());
    });

-    cs::get_row_hit_rate.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cs::get_row_hit_rate.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, ratio_holder(), [](const replica::column_family& cf) {
            return ratio_holder(cf.get_row_cache().stats().hits.count() + cf.get_row_cache().stats().misses.count(),
                    cf.get_row_cache().stats().hits.count());
        }, std::plus<ratio_holder>());
    });

-    cs::get_row_hits_moving_avrage.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cs::get_row_hits_moving_avrage.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf_raw(ctx, utils::rate_moving_average(), [](const replica::column_family& cf) {
            return cf.get_row_cache().stats().hits.rate();
        }, std::plus<utils::rate_moving_average>()).then([](const utils::rate_moving_average& m) {
@@ -230,7 +229,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        });
    });

-    cs::get_row_requests_moving_avrage.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cs::get_row_requests_moving_avrage.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf_raw(ctx, utils::rate_moving_average(), [](const replica::column_family& cf) {
            return cf.get_row_cache().stats().hits.rate() + cf.get_row_cache().stats().misses.rate();
        }, std::plus<utils::rate_moving_average>()).then([](const utils::rate_moving_average& m) {
@@ -238,7 +237,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        });
    });

-    cs::get_row_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cs::get_row_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        // In origin row size is the weighted size.
        // We currently do not support weights, so we use num entries instead
        return ctx.db.map_reduce0([](replica::database& db) -> uint64_t {
@@ -248,7 +247,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        });
    });

-    cs::get_row_entries.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cs::get_row_entries.set(r, [&ctx] (std::unique_ptr<request> req) {
        return ctx.db.map_reduce0([](replica::database& db) -> uint64_t {
            return db.row_cache_tracker().partitions();
        }, uint64_t(0), std::plus<uint64_t>()).then([](const int64_t& res) {
@@ -256,7 +255,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        });
    });

-    cs::get_counter_capacity.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_counter_capacity.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support counter cache,
@@ -264,7 +263,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_counter_hits.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_counter_hits.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support counter cache,
@@ -272,7 +271,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_counter_requests.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_counter_requests.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support counter cache,
@@ -280,7 +279,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_counter_hit_rate.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_counter_hit_rate.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support counter cache,
@@ -288,21 +287,21 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_counter_hits_moving_avrage.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_counter_hits_moving_avrage.set(r, [&ctx] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // See above
        return make_ready_future<json::json_return_type>(meter_to_json(utils::rate_moving_average()));
    });

-    cs::get_counter_requests_moving_avrage.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_counter_requests_moving_avrage.set(r, [&ctx] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // See above
        return make_ready_future<json::json_return_type>(meter_to_json(utils::rate_moving_average()));
    });

-    cs::get_counter_size.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_counter_size.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support counter cache,
@@ -310,7 +309,7 @@ void set_cache_service(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(0);
    });

-    cs::get_counter_entries.set(r, [] (std::unique_ptr<http::request> req) {
+    cs::get_counter_entries.set(r, [] (std::unique_ptr<request> req) {
        // TBD
        // FIXME
        // we don't support counter cache,
--- a/api/cache_service.hh
+++ b/api/cache_service.hh
@@ -12,6 +12,6 @@

 namespace api {

-void set_cache_service(http_context& ctx, httpd::routes& r);
+void set_cache_service(http_context& ctx, routes& r);

 }
--- a/api/collectd.cc
+++ b/api/collectd.cc
@@ -52,7 +52,7 @@ static const char* str_to_regex(const sstring& v) {
 }

 void set_collectd(http_context& ctx, routes& r) {
-    cd::get_collectd.set(r, [](std::unique_ptr<request> req) {
+    cd::get_collectd.set(r, [&ctx](std::unique_ptr<request> req) {

        auto id = ::make_shared<scollectd::type_instance_id>(req->param["pluginid"],
                req->get_query_param("instance"), req->get_query_param("type"),
--- a/api/collectd.hh
+++ b/api/collectd.hh
@@ -12,6 +12,6 @@

 namespace api {

-void set_collectd(http_context& ctx, httpd::routes& r);
+void set_collectd(http_context& ctx, routes& r);

 }
--- a/api/column_family.cc
+++ b/api/column_family.cc
@@ -17,7 +17,6 @@
 #include "db/system_keyspace.hh"
 #include "db/data_listeners.hh"
 #include "storage_service.hh"
-#include "compaction/compaction_manager.hh"
 #include "unimplemented.hh"

 extern logging::logger apilog;
@@ -25,6 +24,7 @@ extern logging::logger apilog;
 namespace api {
 using namespace httpd;

+using namespace std;
 using namespace json;
 namespace cf = httpd::column_family_json;

@@ -56,7 +56,7 @@ const table_id& get_uuid(const sstring& name, const replica::database& db) {
    return get_uuid(ks, cf, db);
 }

-future<> foreach_column_family(http_context& ctx, const sstring& name, std::function<void(replica::column_family&)> f) {
+future<> foreach_column_family(http_context& ctx, const sstring& name, function<void(replica::column_family&)> f) {
    auto uuid = get_uuid(name, ctx.db.local());

    return ctx.db.invoke_on_all([f, uuid](replica::database& db) {
@@ -303,16 +303,16 @@ ratio_holder filter_recent_false_positive_as_ratio_holder(const sstables::shared
    return ratio_holder(f + sst->filter_get_recent_true_positive(), f);
 }

-void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace>& sys_ks) {
+void set_column_family(http_context& ctx, routes& r) {
    cf::get_column_family_name.set(r, [&ctx] (const_req req){
-        std::vector<sstring> res;
+        vector<sstring> res;
        for (auto i: ctx.db.local().get_column_families_mapping()) {
            res.push_back(i.first.first + ":" + i.first.second);
        }
        return res;
    });

-    cf::get_column_family.set(r, [&ctx] (std::unique_ptr<http::request> req){
+    cf::get_column_family.set(r, [&ctx] (std::unique_ptr<request> req){
            std::list<cf::column_family_info> res;
            for (auto i: ctx.db.local().get_column_families_mapping()) {
                cf::column_family_info info;
@@ -325,20 +325,20 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });

    cf::get_column_family_name_keyspace.set(r, [&ctx] (const_req req){
-        std::vector<sstring> res;
+        vector<sstring> res;
        for (auto i = ctx.db.local().get_keyspaces().cbegin(); i!=  ctx.db.local().get_keyspaces().cend(); i++) {
            res.push_back(i->first);
        }
        return res;
    });

-    cf::get_memtable_columns_count.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_memtable_columns_count.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], uint64_t{0}, [](replica::column_family& cf) {
            return boost::accumulate(cf.active_memtables() | boost::adaptors::transformed(std::mem_fn(&replica::memtable::partition_count)), uint64_t(0));
        }, std::plus<>());
    });

-    cf::get_all_memtable_columns_count.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_memtable_columns_count.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, uint64_t{0}, [](replica::column_family& cf) {
            return boost::accumulate(cf.active_memtables() | boost::adaptors::transformed(std::mem_fn(&replica::memtable::partition_count)), uint64_t(0));
        }, std::plus<>());
@@ -352,7 +352,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        return 0;
    });

-    cf::get_memtable_off_heap_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_memtable_off_heap_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], int64_t(0), [](replica::column_family& cf) {
            return boost::accumulate(cf.active_memtables() | boost::adaptors::transformed([] (replica::memtable* active_memtable) {
                return active_memtable->region().occupancy().total_space();
@@ -360,7 +360,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<int64_t>());
    });

-    cf::get_all_memtable_off_heap_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_memtable_off_heap_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, int64_t(0), [](replica::column_family& cf) {
            return boost::accumulate(cf.active_memtables() | boost::adaptors::transformed([] (replica::memtable* active_memtable) {
                return active_memtable->region().occupancy().total_space();
@@ -368,7 +368,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<int64_t>());
    });

-    cf::get_memtable_live_data_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_memtable_live_data_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], int64_t(0), [](replica::column_family& cf) {
            return boost::accumulate(cf.active_memtables() | boost::adaptors::transformed([] (replica::memtable* active_memtable) {
                return active_memtable->region().occupancy().used_space();
@@ -376,7 +376,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<int64_t>());
    });

-    cf::get_all_memtable_live_data_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_memtable_live_data_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, int64_t(0), [](replica::column_family& cf) {
            return boost::accumulate(cf.active_memtables() | boost::adaptors::transformed([] (replica::memtable* active_memtable) {
                return active_memtable->region().occupancy().used_space();
@@ -392,14 +392,14 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        return 0;
    });

-    cf::get_cf_all_memtables_off_heap_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_cf_all_memtables_off_heap_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        warn(unimplemented::cause::INDEXES);
        return map_reduce_cf(ctx, req->param["name"], int64_t(0), [](replica::column_family& cf) {
            return cf.occupancy().total_space();
        }, std::plus<int64_t>());
    });

-    cf::get_all_cf_all_memtables_off_heap_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_cf_all_memtables_off_heap_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        warn(unimplemented::cause::INDEXES);
        return ctx.db.map_reduce0([](const replica::database& db){
            return db.dirty_memory_region_group().real_memory_used();
@@ -408,14 +408,14 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::get_cf_all_memtables_live_data_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_cf_all_memtables_live_data_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        warn(unimplemented::cause::INDEXES);
        return map_reduce_cf(ctx, req->param["name"], int64_t(0), [](replica::column_family& cf) {
            return cf.occupancy().used_space();
        }, std::plus<int64_t>());
    });

-    cf::get_all_cf_all_memtables_live_data_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_cf_all_memtables_live_data_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        warn(unimplemented::cause::INDEXES);
        return map_reduce_cf(ctx, int64_t(0), [](replica::column_family& cf) {
            return boost::accumulate(cf.active_memtables() | boost::adaptors::transformed([] (replica::memtable* active_memtable) {
@@ -424,16 +424,16 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<int64_t>());
    });

-    cf::get_memtable_switch_count.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_memtable_switch_count.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats(ctx,req->param["name"] ,&replica::column_family_stats::memtable_switch_count);
    });

-    cf::get_all_memtable_switch_count.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_memtable_switch_count.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats(ctx, &replica::column_family_stats::memtable_switch_count);
    });

    // FIXME: this refers to partitions, not rows.
-    cf::get_estimated_row_size_histogram.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_estimated_row_size_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], utils::estimated_histogram(0), [](replica::column_family& cf) {
            utils::estimated_histogram res(0);
            for (auto sstables = cf.get_sstables(); auto& i : *sstables) {
@@ -445,7 +445,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
    });

    // FIXME: this refers to partitions, not rows.
-    cf::get_estimated_row_count.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_estimated_row_count.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], int64_t(0), [](replica::column_family& cf) {
            uint64_t res = 0;
            for (auto sstables = cf.get_sstables(); auto& i : *sstables) {
@@ -456,7 +456,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        std::plus<uint64_t>());
    });

-    cf::get_estimated_column_count_histogram.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_estimated_column_count_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], utils::estimated_histogram(0), [](replica::column_family& cf) {
            utils::estimated_histogram res(0);
            for (auto sstables = cf.get_sstables(); auto& i : *sstables) {
@@ -467,149 +467,149 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        utils::estimated_histogram_merge, utils_json::estimated_histogram());
    });

-    cf::get_all_compression_ratio.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_all_compression_ratio.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    cf::get_pending_flushes.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_pending_flushes.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats(ctx,req->param["name"] ,&replica::column_family_stats::pending_flushes);
    });

-    cf::get_all_pending_flushes.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_pending_flushes.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats(ctx, &replica::column_family_stats::pending_flushes);
    });

-    cf::get_read.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_read.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats_count(ctx,req->param["name"] ,&replica::column_family_stats::reads);
    });

-    cf::get_all_read.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_read.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats_count(ctx, &replica::column_family_stats::reads);
    });

-    cf::get_write.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_write.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats_count(ctx, req->param["name"] ,&replica::column_family_stats::writes);
    });

-    cf::get_all_write.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_write.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats_count(ctx, &replica::column_family_stats::writes);
    });

-    cf::get_read_latency_histogram_depricated.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_read_latency_histogram_depricated.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_histogram(ctx, req->param["name"], &replica::column_family_stats::reads);
    });

-    cf::get_read_latency_histogram.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_read_latency_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_rate_and_histogram(ctx, req->param["name"], &replica::column_family_stats::reads);
    });

-    cf::get_read_latency.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_read_latency.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats_sum(ctx,req->param["name"] ,&replica::column_family_stats::reads);
    });

-    cf::get_write_latency.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_write_latency.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats_sum(ctx, req->param["name"] ,&replica::column_family_stats::writes);
    });

-    cf::get_all_read_latency_histogram_depricated.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_read_latency_histogram_depricated.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_histogram(ctx, &replica::column_family_stats::writes);
    });

-    cf::get_all_read_latency_histogram.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_read_latency_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_rate_and_histogram(ctx, &replica::column_family_stats::writes);
    });

-    cf::get_write_latency_histogram_depricated.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_write_latency_histogram_depricated.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_histogram(ctx, req->param["name"], &replica::column_family_stats::writes);
    });

-    cf::get_write_latency_histogram.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_write_latency_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_rate_and_histogram(ctx, req->param["name"], &replica::column_family_stats::writes);
    });

-    cf::get_all_write_latency_histogram_depricated.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_write_latency_histogram_depricated.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_histogram(ctx, &replica::column_family_stats::writes);
    });

-    cf::get_all_write_latency_histogram.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_write_latency_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_rate_and_histogram(ctx, &replica::column_family_stats::writes);
    });

-    cf::get_pending_compactions.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_pending_compactions.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], int64_t(0), [](replica::column_family& cf) {
            return cf.estimate_pending_compactions();
        }, std::plus<int64_t>());
    });

-    cf::get_all_pending_compactions.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_pending_compactions.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, int64_t(0), [](replica::column_family& cf) {
            return cf.estimate_pending_compactions();
        }, std::plus<int64_t>());
    });

-    cf::get_live_ss_table_count.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_live_ss_table_count.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats(ctx, req->param["name"], &replica::column_family_stats::live_sstable_count);
    });

-    cf::get_all_live_ss_table_count.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_live_ss_table_count.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_stats(ctx, &replica::column_family_stats::live_sstable_count);
    });

-    cf::get_unleveled_sstables.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_unleveled_sstables.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_unleveled_sstables(ctx, req->param["name"]);
    });

-    cf::get_live_disk_space_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_live_disk_space_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return sum_sstable(ctx, req->param["name"], false);
    });

-    cf::get_all_live_disk_space_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_live_disk_space_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return sum_sstable(ctx, false);
    });

-    cf::get_total_disk_space_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_total_disk_space_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return sum_sstable(ctx, req->param["name"], true);
    });

-    cf::get_all_total_disk_space_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_total_disk_space_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return sum_sstable(ctx, true);
    });

    // FIXME: this refers to partitions, not rows.
-    cf::get_min_row_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_min_row_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], INT64_MAX, min_partition_size, min_int64);
    });

    // FIXME: this refers to partitions, not rows.
-    cf::get_all_min_row_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_min_row_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, INT64_MAX, min_partition_size, min_int64);
    });

    // FIXME: this refers to partitions, not rows.
-    cf::get_max_row_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_max_row_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], int64_t(0), max_partition_size, max_int64);
    });

    // FIXME: this refers to partitions, not rows.
-    cf::get_all_max_row_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_max_row_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, int64_t(0), max_partition_size, max_int64);
    });

    // FIXME: this refers to partitions, not rows.
-    cf::get_mean_row_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_mean_row_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        // Cassandra 3.x mean values are truncated as integrals.
        return map_reduce_cf(ctx, req->param["name"], integral_ratio_holder(), mean_partition_size, std::plus<integral_ratio_holder>());
    });

    // FIXME: this refers to partitions, not rows.
-    cf::get_all_mean_row_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_mean_row_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        // Cassandra 3.x mean values are truncated as integrals.
        return map_reduce_cf(ctx, integral_ratio_holder(), mean_partition_size, std::plus<integral_ratio_holder>());
    });

-    cf::get_bloom_filter_false_positives.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_bloom_filter_false_positives.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -618,7 +618,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_all_bloom_filter_false_positives.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_bloom_filter_false_positives.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -627,7 +627,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_recent_bloom_filter_false_positives.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_recent_bloom_filter_false_positives.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -636,7 +636,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_all_recent_bloom_filter_false_positives.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_recent_bloom_filter_false_positives.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -645,31 +645,31 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_bloom_filter_false_ratio.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_bloom_filter_false_ratio.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], ratio_holder(), [] (replica::column_family& cf) {
            return boost::accumulate(*cf.get_sstables() | boost::adaptors::transformed(filter_false_positive_as_ratio_holder), ratio_holder());
        }, std::plus<>());
    });

-    cf::get_all_bloom_filter_false_ratio.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_bloom_filter_false_ratio.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, ratio_holder(), [] (replica::column_family& cf) {
            return boost::accumulate(*cf.get_sstables() | boost::adaptors::transformed(filter_false_positive_as_ratio_holder), ratio_holder());
        }, std::plus<>());
    });

-    cf::get_recent_bloom_filter_false_ratio.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_recent_bloom_filter_false_ratio.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], ratio_holder(), [] (replica::column_family& cf) {
            return boost::accumulate(*cf.get_sstables() | boost::adaptors::transformed(filter_recent_false_positive_as_ratio_holder), ratio_holder());
        }, std::plus<>());
    });

-    cf::get_all_recent_bloom_filter_false_ratio.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_recent_bloom_filter_false_ratio.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, ratio_holder(), [] (replica::column_family& cf) {
            return boost::accumulate(*cf.get_sstables() | boost::adaptors::transformed(filter_recent_false_positive_as_ratio_holder), ratio_holder());
        }, std::plus<>());
    });

-    cf::get_bloom_filter_disk_space_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_bloom_filter_disk_space_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -678,7 +678,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_all_bloom_filter_disk_space_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_bloom_filter_disk_space_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -687,7 +687,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_bloom_filter_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_bloom_filter_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -696,7 +696,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_all_bloom_filter_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_bloom_filter_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -705,7 +705,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_index_summary_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_index_summary_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -714,7 +714,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_all_index_summary_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_index_summary_off_heap_memory_used.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, uint64_t(0), [] (replica::column_family& cf) {
            auto sstables = cf.get_sstables();
            return std::accumulate(sstables->begin(), sstables->end(), uint64_t(0), [](uint64_t s, auto& sst) {
@@ -723,7 +723,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        }, std::plus<uint64_t>());
    });

-    cf::get_compression_metadata_off_heap_memory_used.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_compression_metadata_off_heap_memory_used.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        // FIXME
        // We are missing the off heap memory calculation
@@ -733,33 +733,33 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        return make_ready_future<json::json_return_type>(0);
    });

-    cf::get_all_compression_metadata_off_heap_memory_used.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_all_compression_metadata_off_heap_memory_used.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    cf::get_speculative_retries.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_speculative_retries.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        //auto id = get_uuid(req->param["name"], ctx.db.local());
        return make_ready_future<json::json_return_type>(0);
    });

-    cf::get_all_speculative_retries.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_all_speculative_retries.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    cf::get_key_cache_hit_rate.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_key_cache_hit_rate.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        //auto id = get_uuid(req->param["name"], ctx.db.local());
        return make_ready_future<json::json_return_type>(0);
    });

-    cf::get_true_snapshots_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_true_snapshots_size.set(r, [&ctx] (std::unique_ptr<request> req) {
        auto uuid = get_uuid(req->param["name"], ctx.db.local());
        return ctx.db.local().find_column_family(uuid).get_snapshot_details().then([](
                const std::unordered_map<sstring, replica::column_family::snapshot_details>& sd) {
@@ -771,26 +771,26 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::get_all_true_snapshots_size.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_all_true_snapshots_size.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    cf::get_row_cache_hit_out_of_range.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_row_cache_hit_out_of_range.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        //auto id = get_uuid(req->param["name"], ctx.db.local());
        return make_ready_future<json::json_return_type>(0);
    });

-    cf::get_all_row_cache_hit_out_of_range.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_all_row_cache_hit_out_of_range.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    cf::get_row_cache_hit.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_row_cache_hit.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf_raw(ctx, req->param["name"], utils::rate_moving_average(), [](const replica::column_family& cf) {
            return cf.get_row_cache().stats().hits.rate();
        }, std::plus<utils::rate_moving_average>()).then([](const utils::rate_moving_average& m) {
@@ -798,7 +798,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::get_all_row_cache_hit.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_row_cache_hit.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf_raw(ctx, utils::rate_moving_average(), [](const replica::column_family& cf) {
            return cf.get_row_cache().stats().hits.rate();
        }, std::plus<utils::rate_moving_average>()).then([](const utils::rate_moving_average& m) {
@@ -806,7 +806,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::get_row_cache_miss.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_row_cache_miss.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf_raw(ctx, req->param["name"], utils::rate_moving_average(), [](const replica::column_family& cf) {
            return cf.get_row_cache().stats().misses.rate();
        }, std::plus<utils::rate_moving_average>()).then([](const utils::rate_moving_average& m) {
@@ -814,7 +814,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::get_all_row_cache_miss.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_all_row_cache_miss.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf_raw(ctx, utils::rate_moving_average(), [](const replica::column_family& cf) {
            return cf.get_row_cache().stats().misses.rate();
        }, std::plus<utils::rate_moving_average>()).then([](const utils::rate_moving_average& m) {
@@ -823,40 +823,40 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace

    });

-    cf::get_cas_prepare.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_cas_prepare.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const replica::column_family& cf) {
            return cf.get_stats().cas_prepare.histogram();
        });
    });

-    cf::get_cas_propose.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_cas_propose.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const replica::column_family& cf) {
            return cf.get_stats().cas_accept.histogram();
        });
    });

-    cf::get_cas_commit.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_cas_commit.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const replica::column_family& cf) {
            return cf.get_stats().cas_learn.histogram();
        });
    });

-    cf::get_sstables_per_read_histogram.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_sstables_per_read_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, req->param["name"], utils::estimated_histogram(0), [](replica::column_family& cf) {
            return cf.get_stats().estimated_sstable_per_read;
        },
        utils::estimated_histogram_merge, utils_json::estimated_histogram());
    });

-    cf::get_tombstone_scanned_histogram.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_tombstone_scanned_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_histogram(ctx, req->param["name"], &replica::column_family_stats::tombstone_scanned);
    });

-    cf::get_live_scanned_histogram.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::get_live_scanned_histogram.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cf_histogram(ctx, req->param["name"], &replica::column_family_stats::live_scanned);
    });

-    cf::get_col_update_time_delta_histogram.set(r, [] (std::unique_ptr<http::request> req) {
+    cf::get_col_update_time_delta_histogram.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        //auto id = get_uuid(req->param["name"], ctx.db.local());
@@ -870,7 +870,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        return !cf.is_auto_compaction_disabled_by_user();
    });

-    cf::enable_auto_compaction.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    cf::enable_auto_compaction.set(r, [&ctx](std::unique_ptr<request> req) {
        return ctx.db.invoke_on(0, [&ctx, req = std::move(req)] (replica::database& db) {
            auto g = replica::database::autocompaction_toggle_guard(db);
            return foreach_column_family(ctx, req->param["name"], [](replica::column_family &cf) {
@@ -881,7 +881,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::disable_auto_compaction.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    cf::disable_auto_compaction.set(r, [&ctx](std::unique_ptr<request> req) {
        return ctx.db.invoke_on(0, [&ctx, req = std::move(req)] (replica::database& db) {
            auto g = replica::database::autocompaction_toggle_guard(db);
            return foreach_column_family(ctx, req->param["name"], [](replica::column_family &cf) {
@@ -892,11 +892,11 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::get_built_indexes.set(r, [&ctx, &sys_ks](std::unique_ptr<http::request> req) {
+    cf::get_built_indexes.set(r, [&ctx](std::unique_ptr<request> req) {
        auto ks_cf = parse_fully_qualified_cf_name(req->param["name"]);
        auto&& ks = std::get<0>(ks_cf);
        auto&& cf_name = std::get<1>(ks_cf);
-        return sys_ks.local().load_view_build_progress().then([ks, cf_name, &ctx](const std::vector<db::system_keyspace_view_build_progress>& vb) mutable {
+        return db::system_keyspace::load_view_build_progress().then([ks, cf_name, &ctx](const std::vector<db::system_keyspace_view_build_progress>& vb) mutable {
            std::set<sstring> vp;
            for (auto b : vb) {
                if (b.view.first == ks) {
@@ -930,7 +930,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        return std::vector<sstring>();
    });

-    cf::get_compression_ratio.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    cf::get_compression_ratio.set(r, [&ctx](std::unique_ptr<request> req) {
        auto uuid = get_uuid(req->param["name"], ctx.db.local());

        return ctx.db.map_reduce(sum_ratio<double>(), [uuid](replica::database& db) {
@@ -941,19 +941,19 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::get_read_latency_estimated_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    cf::get_read_latency_estimated_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const replica::column_family& cf) {
            return cf.get_stats().reads.histogram();
        });
    });

-    cf::get_write_latency_estimated_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    cf::get_write_latency_estimated_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return map_reduce_cf_time_histogram(ctx, req->param["name"], [](const replica::column_family& cf) {
            return cf.get_stats().writes.histogram();
        });
    });

-    cf::set_compaction_strategy_class.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    cf::set_compaction_strategy_class.set(r, [&ctx](std::unique_ptr<request> req) {
        sstring strategy = req->get_query_param("class_name");
        return foreach_column_family(ctx, req->param["name"], [strategy](replica::column_family& cf) {
            cf.set_compaction_strategy(sstables::compaction_strategy::type(strategy));
@@ -966,19 +966,19 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        return ctx.db.local().find_column_family(get_uuid(req.param["name"], ctx.db.local())).get_compaction_strategy().name();
    });

-    cf::set_compression_parameters.set(r, [](std::unique_ptr<http::request> req) {
+    cf::set_compression_parameters.set(r, [&ctx](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cf::set_crc_check_chance.set(r, [](std::unique_ptr<http::request> req) {
+    cf::set_crc_check_chance.set(r, [&ctx](std::unique_ptr<request> req) {
        // TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cf::get_sstable_count_per_level.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    cf::get_sstable_count_per_level.set(r, [&ctx](std::unique_ptr<request> req) {
        return map_reduce_cf_raw(ctx, req->param["name"], std::vector<uint64_t>(), [](const replica::column_family& cf) {
            return cf.sstable_count_per_level();
        }, concat_sstable_count_per_level).then([](const std::vector<uint64_t>& res) {
@@ -986,7 +986,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::get_sstables_for_key.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    cf::get_sstables_for_key.set(r, [&ctx](std::unique_ptr<request> req) {
        auto key = req->get_query_param("key");
        auto uuid = get_uuid(req->param["name"], ctx.db.local());

@@ -1002,7 +1002,7 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
    });


-    cf::toppartitions.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cf::toppartitions.set(r, [&ctx] (std::unique_ptr<request> req) {
        auto name = req->param["name"];
        auto [ks, cf] = parse_fully_qualified_cf_name(name);

@@ -1018,127 +1018,15 @@ void set_column_family(http_context& ctx, routes& r, sharded<db::system_keyspace
        });
    });

-    cf::force_major_compaction.set(r, [&ctx](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    cf::force_major_compaction.set(r, [&ctx](std::unique_ptr<request> req) {
        if (req->get_query_param("split_output") != "") {
            fail(unimplemented::cause::API);
        }
-
-        auto [ks, cf] = parse_fully_qualified_cf_name(req->param["name"]);
-        auto keyspace = validate_keyspace(ctx, ks);
-        std::vector<table_id> table_infos = {ctx.db.local().find_uuid(ks, cf)};
-
-        auto& compaction_module = ctx.db.local().get_compaction_manager().get_task_manager_module();
-        auto task = co_await compaction_module.make_and_start_task<major_keyspace_compaction_task_impl>({}, std::move(keyspace), ctx.db, std::move(table_infos));
-        co_await task->done();
-        co_return json_void();
+        return foreach_column_family(ctx, req->param["name"], [](replica::column_family &cf) {
+            return cf.compact_all_sstables();
+        }).then([] {
+            return make_ready_future<json::json_return_type>(json_void());
+        });
    });
 }
-
-void unset_column_family(http_context& ctx, routes& r) {
-    cf::get_column_family_name.unset(r);
-    cf::get_column_family.unset(r);
-    cf::get_column_family_name_keyspace.unset(r);
-    cf::get_memtable_columns_count.unset(r);
-    cf::get_all_memtable_columns_count.unset(r);
-    cf::get_memtable_on_heap_size.unset(r);
-    cf::get_all_memtable_on_heap_size.unset(r);
-    cf::get_memtable_off_heap_size.unset(r);
-    cf::get_all_memtable_off_heap_size.unset(r);
-    cf::get_memtable_live_data_size.unset(r);
-    cf::get_all_memtable_live_data_size.unset(r);
-    cf::get_cf_all_memtables_on_heap_size.unset(r);
-    cf::get_all_cf_all_memtables_on_heap_size.unset(r);
-    cf::get_cf_all_memtables_off_heap_size.unset(r);
-    cf::get_all_cf_all_memtables_off_heap_size.unset(r);
-    cf::get_cf_all_memtables_live_data_size.unset(r);
-    cf::get_all_cf_all_memtables_live_data_size.unset(r);
-    cf::get_memtable_switch_count.unset(r);
-    cf::get_all_memtable_switch_count.unset(r);
-    cf::get_estimated_row_size_histogram.unset(r);
-    cf::get_estimated_row_count.unset(r);
-    cf::get_estimated_column_count_histogram.unset(r);
-    cf::get_all_compression_ratio.unset(r);
-    cf::get_pending_flushes.unset(r);
-    cf::get_all_pending_flushes.unset(r);
-    cf::get_read.unset(r);
-    cf::get_all_read.unset(r);
-    cf::get_write.unset(r);
-    cf::get_all_write.unset(r);
-    cf::get_read_latency_histogram_depricated.unset(r);
-    cf::get_read_latency_histogram.unset(r);
-    cf::get_read_latency.unset(r);
-    cf::get_write_latency.unset(r);
-    cf::get_all_read_latency_histogram_depricated.unset(r);
-    cf::get_all_read_latency_histogram.unset(r);
-    cf::get_write_latency_histogram_depricated.unset(r);
-    cf::get_write_latency_histogram.unset(r);
-    cf::get_all_write_latency_histogram_depricated.unset(r);
-    cf::get_all_write_latency_histogram.unset(r);
-    cf::get_pending_compactions.unset(r);
-    cf::get_all_pending_compactions.unset(r);
-    cf::get_live_ss_table_count.unset(r);
-    cf::get_all_live_ss_table_count.unset(r);
-    cf::get_unleveled_sstables.unset(r);
-    cf::get_live_disk_space_used.unset(r);
-    cf::get_all_live_disk_space_used.unset(r);
-    cf::get_total_disk_space_used.unset(r);
-    cf::get_all_total_disk_space_used.unset(r);
-    cf::get_min_row_size.unset(r);
-    cf::get_all_min_row_size.unset(r);
-    cf::get_max_row_size.unset(r);
-    cf::get_all_max_row_size.unset(r);
-    cf::get_mean_row_size.unset(r);
-    cf::get_all_mean_row_size.unset(r);
-    cf::get_bloom_filter_false_positives.unset(r);
-    cf::get_all_bloom_filter_false_positives.unset(r);
-    cf::get_recent_bloom_filter_false_positives.unset(r);
-    cf::get_all_recent_bloom_filter_false_positives.unset(r);
-    cf::get_bloom_filter_false_ratio.unset(r);
-    cf::get_all_bloom_filter_false_ratio.unset(r);
-    cf::get_recent_bloom_filter_false_ratio.unset(r);
-    cf::get_all_recent_bloom_filter_false_ratio.unset(r);
-    cf::get_bloom_filter_disk_space_used.unset(r);
-    cf::get_all_bloom_filter_disk_space_used.unset(r);
-    cf::get_bloom_filter_off_heap_memory_used.unset(r);
-    cf::get_all_bloom_filter_off_heap_memory_used.unset(r);
-    cf::get_index_summary_off_heap_memory_used.unset(r);
-    cf::get_all_index_summary_off_heap_memory_used.unset(r);
-    cf::get_compression_metadata_off_heap_memory_used.unset(r);
-    cf::get_all_compression_metadata_off_heap_memory_used.unset(r);
-    cf::get_speculative_retries.unset(r);
-    cf::get_all_speculative_retries.unset(r);
-    cf::get_key_cache_hit_rate.unset(r);
-    cf::get_true_snapshots_size.unset(r);
-    cf::get_all_true_snapshots_size.unset(r);
-    cf::get_row_cache_hit_out_of_range.unset(r);
-    cf::get_all_row_cache_hit_out_of_range.unset(r);
-    cf::get_row_cache_hit.unset(r);
-    cf::get_all_row_cache_hit.unset(r);
-    cf::get_row_cache_miss.unset(r);
-    cf::get_all_row_cache_miss.unset(r);
-    cf::get_cas_prepare.unset(r);
-    cf::get_cas_propose.unset(r);
-    cf::get_cas_commit.unset(r);
-    cf::get_sstables_per_read_histogram.unset(r);
-    cf::get_tombstone_scanned_histogram.unset(r);
-    cf::get_live_scanned_histogram.unset(r);
-    cf::get_col_update_time_delta_histogram.unset(r);
-    cf::get_auto_compaction.unset(r);
-    cf::enable_auto_compaction.unset(r);
-    cf::disable_auto_compaction.unset(r);
-    cf::get_built_indexes.unset(r);
-    cf::get_compression_metadata_off_heap_memory_used.unset(r);
-    cf::get_compression_parameters.unset(r);
-    cf::get_compression_ratio.unset(r);
-    cf::get_read_latency_estimated_histogram.unset(r);
-    cf::get_write_latency_estimated_histogram.unset(r);
-    cf::set_compaction_strategy_class.unset(r);
-    cf::get_compaction_strategy_class.unset(r);
-    cf::set_compression_parameters.unset(r);
-    cf::set_crc_check_chance.unset(r);
-    cf::get_sstable_count_per_level.unset(r);
-    cf::get_sstables_for_key.unset(r);
-    cf::toppartitions.unset(r);
-    cf::force_major_compaction.unset(r);
-}
 }
--- a/api/column_family.hh
+++ b/api/column_family.hh
@@ -14,14 +14,9 @@
 #include <seastar/core/future-util.hh>
 #include <any>

-namespace db {
-class system_keyspace;
-}
-
 namespace api {

-void set_column_family(http_context& ctx, httpd::routes& r, sharded<db::system_keyspace>& sys_ks);
-void unset_column_family(http_context& ctx, httpd::routes& r);
+void set_column_family(http_context& ctx, routes& r);

 const table_id& get_uuid(const sstring& name, const replica::database& db);
 future<> foreach_column_family(http_context& ctx, const sstring& name, std::function<void(replica::column_family&)> f);
--- a/api/commitlog.cc
+++ b/api/commitlog.cc
@@ -13,7 +13,6 @@
 #include <vector>

 namespace api {
-using namespace seastar::httpd;

 template<typename T>
 static auto acquire_cl_metric(http_context& ctx, std::function<T (db::commitlog*)> func) {
--- a/api/commitlog.hh
+++ b/api/commitlog.hh
@@ -12,6 +12,6 @@

 namespace api {

-void set_commitlog(http_context& ctx, httpd::routes& r);
+void set_commitlog(http_context& ctx, routes& r);

 }
--- a/api/compaction_manager.cc
+++ b/api/compaction_manager.cc
@@ -22,7 +22,6 @@ namespace api {

 namespace cm = httpd::compaction_manager_json;
 using namespace json;
-using namespace seastar::httpd;

 static future<json::json_return_type> get_cm_stats(http_context& ctx,
        int64_t compaction_manager::stats::*f) {
@@ -43,7 +42,7 @@ static std::unordered_map<std::pair<sstring, sstring>, uint64_t, utils::tuple_ha
 }

 void set_compaction_manager(http_context& ctx, routes& r) {
-    cm::get_compactions.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cm::get_compactions.set(r, [&ctx] (std::unique_ptr<request> req) {
        return ctx.db.map_reduce0([](replica::database& db) {
            std::vector<cm::summary> summaries;
            const compaction_manager& cm = db.get_compaction_manager();
@@ -65,9 +64,9 @@ void set_compaction_manager(http_context& ctx, routes& r) {
        });
    });

-    cm::get_pending_tasks_by_table.set(r, [&ctx] (std::unique_ptr<http::request> req) {
-        return ctx.db.map_reduce0([](replica::database& db) {
-            return do_with(std::unordered_map<std::pair<sstring, sstring>, uint64_t, utils::tuple_hash>(), [&db](std::unordered_map<std::pair<sstring, sstring>, uint64_t, utils::tuple_hash>& tasks) {
+    cm::get_pending_tasks_by_table.set(r, [&ctx] (std::unique_ptr<request> req) {
+        return ctx.db.map_reduce0([&ctx](replica::database& db) {
+            return do_with(std::unordered_map<std::pair<sstring, sstring>, uint64_t, utils::tuple_hash>(), [&ctx, &db](std::unordered_map<std::pair<sstring, sstring>, uint64_t, utils::tuple_hash>& tasks) {
                return do_for_each(db.get_column_families(), [&tasks](const std::pair<table_id, seastar::lw_shared_ptr<replica::table>>& i) -> future<> {
                    replica::table& cf = *i.second.get();
                    tasks[std::make_pair(cf.schema()->ks_name(), cf.schema()->cf_name())] = cf.estimate_pending_compactions();
@@ -91,14 +90,14 @@ void set_compaction_manager(http_context& ctx, routes& r) {
        });
    });

-    cm::force_user_defined_compaction.set(r, [] (std::unique_ptr<http::request> req) {
+    cm::force_user_defined_compaction.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        // FIXME
        warn(unimplemented::cause::API);
        return make_ready_future<json::json_return_type>(json_void());
    });

-    cm::stop_compaction.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cm::stop_compaction.set(r, [&ctx] (std::unique_ptr<request> req) {
        auto type = req->get_query_param("type");
        return ctx.db.invoke_on_all([type] (replica::database& db) {
            auto& cm = db.get_compaction_manager();
@@ -108,7 +107,7 @@ void set_compaction_manager(http_context& ctx, routes& r) {
        });
    });

-    cm::stop_keyspace_compaction.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    cm::stop_keyspace_compaction.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto ks_name = validate_keyspace(ctx, req->param);
        auto table_names = parse_tables(ks_name, ctx, req->query_parameters, "tables");
        if (table_names.empty()) {
@@ -127,35 +126,35 @@ void set_compaction_manager(http_context& ctx, routes& r) {
        co_return json_void();
    });

-    cm::get_pending_tasks.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cm::get_pending_tasks.set(r, [&ctx] (std::unique_ptr<request> req) {
        return map_reduce_cf(ctx, int64_t(0), [](replica::column_family& cf) {
            return cf.estimate_pending_compactions();
        }, std::plus<int64_t>());
    });

-    cm::get_completed_tasks.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    cm::get_completed_tasks.set(r, [&ctx] (std::unique_ptr<request> req) {
        return get_cm_stats(ctx, &compaction_manager::stats::completed_tasks);
    });

-    cm::get_total_compactions_completed.set(r, [] (std::unique_ptr<http::request> req) {
+    cm::get_total_compactions_completed.set(r, [] (std::unique_ptr<request> req) {
        // FIXME
        // We are currently dont have an API for compaction
        // so returning a 0 as the number of total compaction is ok
        return make_ready_future<json::json_return_type>(0);
    });

-    cm::get_bytes_compacted.set(r, [] (std::unique_ptr<http::request> req) {
+    cm::get_bytes_compacted.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        // FIXME
        warn(unimplemented::cause::API);
        return make_ready_future<json::json_return_type>(0);
    });

-    cm::get_compaction_history.set(r, [&ctx] (std::unique_ptr<http::request> req) {
-        std::function<future<>(output_stream<char>&&)> f = [&ctx](output_stream<char>&& s) {
-            return do_with(output_stream<char>(std::move(s)), true, [&ctx] (output_stream<char>& s, bool& first){
-                return s.write("[").then([&ctx, &s, &first] {
-                    return ctx.db.local().get_compaction_manager().get_compaction_history([&s, &first](const db::compaction_history_entry& entry) mutable {
+    cm::get_compaction_history.set(r, [] (std::unique_ptr<request> req) {
+        std::function<future<>(output_stream<char>&&)> f = [](output_stream<char>&& s) {
+            return do_with(output_stream<char>(std::move(s)), true, [] (output_stream<char>& s, bool& first){
+                return s.write("[").then([&s, &first] {
+                    return db::system_keyspace::get_compaction_history([&s, &first](const db::system_keyspace::compaction_history_entry& entry) mutable {
                        cm::history h;
                        h.id = entry.id.to_sstring();
                        h.ks = std::move(entry.ks);
@@ -185,7 +184,7 @@ void set_compaction_manager(http_context& ctx, routes& r) {
        return make_ready_future<json::json_return_type>(std::move(f));
    });

-    cm::get_compaction_info.set(r, [] (std::unique_ptr<http::request> req) {
+    cm::get_compaction_info.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        // FIXME
        warn(unimplemented::cause::API);
--- a/api/compaction_manager.hh
+++ b/api/compaction_manager.hh
@@ -12,6 +12,6 @@

 namespace api {

-void set_compaction_manager(http_context& ctx, httpd::routes& r);
+void set_compaction_manager(http_context& ctx, routes& r);

 }
--- a/api/config.cc
+++ b/api/config.cc
@@ -13,7 +13,6 @@
 #include <boost/algorithm/string/replace.hpp>

 namespace api {
-using namespace seastar::httpd;

 template<class T>
 json::json_return_type get_json_return_type(const T& val) {
--- a/api/config.hh
+++ b/api/config.hh
@@ -13,5 +13,5 @@

 namespace api {

-void set_config(std::shared_ptr<httpd::api_registry_builder20> rb, http_context& ctx, httpd::routes& r, const db::config& cfg);
+void set_config(std::shared_ptr<api_registry_builder20> rb, http_context& ctx, routes& r, const db::config& cfg);
 }
--- a/api/endpoint_snitch.cc
+++ b/api/endpoint_snitch.cc
@@ -15,7 +15,6 @@
 #include "utils/fb_utilities.hh"

 namespace api {
-using namespace seastar::httpd;

 void set_endpoint_snitch(http_context& ctx, routes& r, sharded<locator::snitch_ptr>& snitch) {
    static auto host_or_broadcast = [](const_req req) {
@@ -29,7 +28,7 @@ void set_endpoint_snitch(http_context& ctx, routes& r, sharded<locator::snitch_p
        if (!topology.has_endpoint(ep)) {
            // Cannot return error here, nodetool status can race, request
            // info about just-left node and not handle it nicely
-            return locator::endpoint_dc_rack::default_location.dc;
+            return sstring(locator::production_snitch_base::default_dc);
        }
        return topology.get_datacenter(ep);
    });
@@ -40,7 +39,7 @@ void set_endpoint_snitch(http_context& ctx, routes& r, sharded<locator::snitch_p
        if (!topology.has_endpoint(ep)) {
            // Cannot return error here, nodetool status can race, request
            // info about just-left node and not handle it nicely
-            return locator::endpoint_dc_rack::default_location.rack;
+            return sstring(locator::production_snitch_base::default_rack);
        }
        return topology.get_rack(ep);
    });
--- a/api/endpoint_snitch.hh
+++ b/api/endpoint_snitch.hh
@@ -16,7 +16,7 @@ class snitch_ptr;

 namespace api {

-void set_endpoint_snitch(http_context& ctx, httpd::routes& r, sharded<locator::snitch_ptr>&);
-void unset_endpoint_snitch(http_context& ctx, httpd::routes& r);
+void set_endpoint_snitch(http_context& ctx, routes& r, sharded<locator::snitch_ptr>&);
+void unset_endpoint_snitch(http_context& ctx, routes& r);

 }
--- a/api/error_injection.cc
+++ b/api/error_injection.cc
@@ -15,7 +15,6 @@
 #include <seastar/core/future-util.hh>

 namespace api {
-using namespace seastar::httpd;

 namespace hf = httpd::error_injection_json;

--- a/api/error_injection.hh
+++ b/api/error_injection.hh
@@ -12,6 +12,6 @@

 namespace api {

-void set_error_injection(http_context& ctx, httpd::routes& r);
+void set_error_injection(http_context& ctx, routes& r);

 }
--- a/api/failure_detector.cc
+++ b/api/failure_detector.cc
@@ -8,11 +8,10 @@

 #include "failure_detector.hh"
 #include "api/api-doc/failure_detector.json.hh"
+#include "gms/failure_detector.hh"
 #include "gms/application_state.hh"
 #include "gms/gossiper.hh"
-
 namespace api {
-using namespace seastar::httpd;

 namespace fd = httpd::failure_detector_json;

@@ -21,18 +20,18 @@ void set_failure_detector(http_context& ctx, routes& r, gms::gossiper& g) {
        std::vector<fd::endpoint_state> res;
        for (auto i : g.get_endpoint_states()) {
            fd::endpoint_state val;
-            val.addrs = fmt::to_string(i.first);
+            val.addrs = boost::lexical_cast<std::string>(i.first);
            val.is_alive = i.second.is_alive();
-            val.generation = i.second.get_heart_beat_state().get_generation().value();
-            val.version = i.second.get_heart_beat_state().get_heart_beat_version().value();
+            val.generation = i.second.get_heart_beat_state().get_generation();
+            val.version = i.second.get_heart_beat_state().get_heart_beat_version();
            val.update_time = i.second.get_update_timestamp().time_since_epoch().count();
            for (auto a : i.second.get_application_state_map()) {
                fd::version_value version_val;
                // We return the enum index and not it's name to stay compatible to origin
                // method that the state index are static but the name can be changed.
                version_val.application_state = static_cast<std::underlying_type<gms::application_state>::type>(a.first);
-                version_val.value = a.second.value();
-                version_val.version = a.second.version().value();
+                version_val.value = a.second.value;
+                version_val.version = a.second.version;
                val.application_state.push(version_val);
            }
            res.push_back(val);
@@ -63,9 +62,7 @@ void set_failure_detector(http_context& ctx, routes& r, gms::gossiper& g) {
    });

    fd::set_phi_convict_threshold.set(r, [](std::unique_ptr<request> req) {
-        // TBD
-        unimplemented();
-        std::ignore = atof(req->get_query_param("phi").c_str());
+        double phi = atof(req->get_query_param("phi").c_str());
        return make_ready_future<json::json_return_type>("");
    });

@@ -80,9 +77,15 @@ void set_failure_detector(http_context& ctx, routes& r, gms::gossiper& g) {
    });

    fd::get_endpoint_phi_values.set(r, [](std::unique_ptr<request> req) {
-        // We no longer have a phi failure detector,
-        // just returning the empty value is good enough.
+        std::map<gms::inet_address, gms::arrival_window> map;
        std::vector<fd::endpoint_phi_value> res;
+        auto now = gms::arrival_window::clk::now();
+        for (auto& p : map) {
+            fd::endpoint_phi_value val;
+            val.endpoint = p.first.to_sstring();
+            val.phi = p.second.phi(now);
+            res.emplace_back(std::move(val));
+        }
        return make_ready_future<json::json_return_type>(res);
    });
 }
--- a/api/failure_detector.hh
+++ b/api/failure_detector.hh
@@ -18,6 +18,6 @@ class gossiper;

 namespace api {

-void set_failure_detector(http_context& ctx, httpd::routes& r, gms::gossiper& g);
+void set_failure_detector(http_context& ctx, routes& r, gms::gossiper& g);

 }
--- a/api/gossiper.cc
+++ b/api/gossiper.cc
@@ -11,7 +11,6 @@
 #include "gms/gossiper.hh"

 namespace api {
-using namespace seastar::httpd;
 using namespace json;

 void set_gossiper(http_context& ctx, routes& r, gms::gossiper& g) {
@@ -20,11 +19,9 @@ void set_gossiper(http_context& ctx, routes& r, gms::gossiper& g) {
        return container_to_vec(res);
    });

-
-    httpd::gossiper_json::get_live_endpoint.set(r, [&g] (std::unique_ptr<request> req) {
-        return g.get_live_members_synchronized().then([] (auto res) {
-            return make_ready_future<json::json_return_type>(container_to_vec(res));
-        });
+    httpd::gossiper_json::get_live_endpoint.set(r, [&g] (const_req req) {
+        auto res = g.get_live_members();
+        return container_to_vec(res);
    });

    httpd::gossiper_json::get_endpoint_downtime.set(r, [&g] (const_req req) {
@@ -32,21 +29,21 @@ void set_gossiper(http_context& ctx, routes& r, gms::gossiper& g) {
        return g.get_endpoint_downtime(ep);
    });

-    httpd::gossiper_json::get_current_generation_number.set(r, [&g] (std::unique_ptr<http::request> req) {
+    httpd::gossiper_json::get_current_generation_number.set(r, [&g] (std::unique_ptr<request> req) {
        gms::inet_address ep(req->param["addr"]);
-        return g.get_current_generation_number(ep).then([] (gms::generation_type res) {
-            return make_ready_future<json::json_return_type>(res.value());
+        return g.get_current_generation_number(ep).then([] (int res) {
+            return make_ready_future<json::json_return_type>(res);
        });
    });

-    httpd::gossiper_json::get_current_heart_beat_version.set(r, [&g] (std::unique_ptr<http::request> req) {
+    httpd::gossiper_json::get_current_heart_beat_version.set(r, [&g] (std::unique_ptr<request> req) {
        gms::inet_address ep(req->param["addr"]);
-        return g.get_current_heart_beat_version(ep).then([] (gms::version_type res) {
-            return make_ready_future<json::json_return_type>(res.value());
+        return g.get_current_heart_beat_version(ep).then([] (int res) {
+            return make_ready_future<json::json_return_type>(res);
        });
    });

-    httpd::gossiper_json::assassinate_endpoint.set(r, [&g](std::unique_ptr<http::request> req) {
+    httpd::gossiper_json::assassinate_endpoint.set(r, [&g](std::unique_ptr<request> req) {
        if (req->get_query_param("unsafe") != "True") {
            return g.assassinate_endpoint(req->param["addr"]).then([] {
                return make_ready_future<json::json_return_type>(json_void());
@@ -57,7 +54,7 @@ void set_gossiper(http_context& ctx, routes& r, gms::gossiper& g) {
        });
    });

-    httpd::gossiper_json::force_remove_endpoint.set(r, [&g](std::unique_ptr<http::request> req) {
+    httpd::gossiper_json::force_remove_endpoint.set(r, [&g](std::unique_ptr<request> req) {
        gms::inet_address ep(req->param["addr"]);
        return g.force_remove_endpoint(ep).then([] {
            return make_ready_future<json::json_return_type>(json_void());
--- a/api/gossiper.hh
+++ b/api/gossiper.hh
@@ -18,6 +18,6 @@ class gossiper;

 namespace api {

-void set_gossiper(http_context& ctx, httpd::routes& r, gms::gossiper& g);
+void set_gossiper(http_context& ctx, routes& r, gms::gossiper& g);

 }
--- a/api/hinted_handoff.cc
+++ b/api/hinted_handoff.cc
@@ -19,11 +19,10 @@
 namespace api {

 using namespace json;
-using namespace seastar::httpd;
 namespace hh = httpd::hinted_handoff_json;

 void set_hinted_handoff(http_context& ctx, routes& r, gms::gossiper& g) {
-    hh::create_hints_sync_point.set(r, [&ctx, &g] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    hh::create_hints_sync_point.set(r, [&ctx, &g] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto parse_hosts_list = [&g] (sstring arg) {
            std::vector<sstring> hosts_str = split(arg, ",");
            std::vector<gms::inet_address> hosts;
@@ -53,7 +52,7 @@ void set_hinted_handoff(http_context& ctx, routes& r, gms::gossiper& g) {
        });
    });

-    hh::get_hints_sync_point.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    hh::get_hints_sync_point.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        db::hints::sync_point sync_point;
        const sstring encoded = req->get_query_param("id");
        try {
@@ -94,42 +93,42 @@ void set_hinted_handoff(http_context& ctx, routes& r, gms::gossiper& g) {
        });
    });

-    hh::list_endpoints_pending_hints.set(r, [] (std::unique_ptr<http::request> req) {
+    hh::list_endpoints_pending_hints.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        std::vector<sstring> res;
        return make_ready_future<json::json_return_type>(res);
    });

-    hh::truncate_all_hints.set(r, [] (std::unique_ptr<http::request> req) {
+    hh::truncate_all_hints.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        sstring host = req->get_query_param("host");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    hh::schedule_hint_delivery.set(r, [] (std::unique_ptr<http::request> req) {
+    hh::schedule_hint_delivery.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        sstring host = req->get_query_param("host");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    hh::pause_hints_delivery.set(r, [] (std::unique_ptr<http::request> req) {
+    hh::pause_hints_delivery.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        sstring pause = req->get_query_param("pause");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    hh::get_create_hint_count.set(r, [] (std::unique_ptr<http::request> req) {
+    hh::get_create_hint_count.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        sstring host = req->get_query_param("host");
        return make_ready_future<json::json_return_type>(0);
    });

-    hh::get_not_stored_hints_count.set(r, [] (std::unique_ptr<http::request> req) {
+    hh::get_not_stored_hints_count.set(r, [] (std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        sstring host = req->get_query_param("host");
--- a/api/hinted_handoff.hh
+++ b/api/hinted_handoff.hh
@@ -18,7 +18,7 @@ class gossiper;

 namespace api {

-void set_hinted_handoff(http_context& ctx, httpd::routes& r, gms::gossiper& g);
-void unset_hinted_handoff(http_context& ctx, httpd::routes& r);
+void set_hinted_handoff(http_context& ctx, routes& r, gms::gossiper& g);
+void unset_hinted_handoff(http_context& ctx, routes& r);

 }
--- a/api/lsa.cc
+++ b/api/lsa.cc
@@ -16,7 +16,6 @@
 #include "replica/database.hh"

 namespace api {
-using namespace seastar::httpd;

 static logging::logger alogger("lsa-api");

--- a/api/lsa.hh
+++ b/api/lsa.hh
@@ -12,6 +12,6 @@

 namespace api {

-void set_lsa(http_context& ctx, httpd::routes& r);
+void set_lsa(http_context& ctx, routes& r);

 }
--- a/api/messaging_service.cc
+++ b/api/messaging_service.cc
@@ -13,7 +13,6 @@
 #include <iostream>
 #include <sstream>

-using namespace seastar::httpd;
 using namespace httpd::messaging_service_json;
 using namespace netw;

@@ -29,7 +28,7 @@ std::vector<message_counter> map_to_message_counters(
    std::vector<message_counter> res;
    for (auto i : map) {
        res.push_back(message_counter());
-        res.back().key = fmt::to_string(i.first);
+        res.back().key = boost::lexical_cast<sstring>(i.first);
        res.back().value = i.second;
    }
    return res;
--- a/api/messaging_service.hh
+++ b/api/messaging_service.hh
@@ -14,7 +14,7 @@ namespace netw { class messaging_service; }

 namespace api {

-void set_messaging_service(http_context& ctx, httpd::routes& r, sharded<netw::messaging_service>& ms);
-void unset_messaging_service(http_context& ctx, httpd::routes& r);
+void set_messaging_service(http_context& ctx, routes& r, sharded<netw::messaging_service>& ms);
+void unset_messaging_service(http_context& ctx, routes& r);

 }
--- a/api/storage_proxy.cc
+++ b/api/storage_proxy.cc
@@ -20,7 +20,6 @@ namespace api {

 namespace sp = httpd::storage_proxy_json;
 using proxy = service::storage_proxy;
-using namespace seastar::httpd;
 using namespace json;

 utils::time_estimated_histogram timed_rate_moving_average_summary_merge(utils::time_estimated_histogram a, const utils::timed_rate_moving_average_summary_and_histogram& b) {
@@ -185,75 +184,75 @@ sum_timer_stats_storage_proxy(distributed<proxy>& d,
 }

 void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_service>& ss) {
-    sp::get_total_hints.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::get_total_hints.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    sp::get_hinted_handoff_enabled.set(r, [&ctx](std::unique_ptr<http::request> req)  {
-        const auto& filter = ctx.sp.local().get_hints_host_filter();
+    sp::get_hinted_handoff_enabled.set(r, [&ctx](std::unique_ptr<request> req)  {
+        const auto& filter = service::get_storage_proxy().local().get_hints_host_filter();
        return make_ready_future<json::json_return_type>(!filter.is_disabled_for_all());
    });

-    sp::set_hinted_handoff_enabled.set(r, [&ctx](std::unique_ptr<http::request> req)  {
+    sp::set_hinted_handoff_enabled.set(r, [](std::unique_ptr<request> req)  {
        auto enable = req->get_query_param("enable");
        auto filter = (enable == "true" || enable == "1")
                ? db::hints::host_filter(db::hints::host_filter::enabled_for_all_tag {})
                : db::hints::host_filter(db::hints::host_filter::disabled_for_all_tag {});
-        return ctx.sp.invoke_on_all([filter = std::move(filter)] (service::storage_proxy& sp) {
+        return service::get_storage_proxy().invoke_on_all([filter = std::move(filter)] (service::storage_proxy& sp) {
            return sp.change_hints_host_filter(filter);
        }).then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });

-    sp::get_hinted_handoff_enabled_by_dc.set(r, [&ctx](std::unique_ptr<http::request> req)  {
+    sp::get_hinted_handoff_enabled_by_dc.set(r, [](std::unique_ptr<request> req)  {
        std::vector<sstring> res;
-        const auto& filter = ctx.sp.local().get_hints_host_filter();
+        const auto& filter = service::get_storage_proxy().local().get_hints_host_filter();
        const auto& dcs = filter.get_dcs();
        res.reserve(res.size());
        std::copy(dcs.begin(), dcs.end(), std::back_inserter(res));
        return make_ready_future<json::json_return_type>(res);
    });

-    sp::set_hinted_handoff_enabled_by_dc_list.set(r, [&ctx](std::unique_ptr<http::request> req)  {
+    sp::set_hinted_handoff_enabled_by_dc_list.set(r, [](std::unique_ptr<request> req)  {
        auto dcs = req->get_query_param("dcs");
        auto filter = db::hints::host_filter::parse_from_dc_list(std::move(dcs));
-        return ctx.sp.invoke_on_all([filter = std::move(filter)] (service::storage_proxy& sp) {
+        return service::get_storage_proxy().invoke_on_all([filter = std::move(filter)] (service::storage_proxy& sp) {
            return sp.change_hints_host_filter(filter);
        }).then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });

-    sp::get_max_hint_window.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::get_max_hint_window.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    sp::set_max_hint_window.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::set_max_hint_window.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        auto enable = req->get_query_param("ms");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    sp::get_max_hints_in_progress.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::get_max_hints_in_progress.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(1);
    });

-    sp::set_max_hints_in_progress.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::set_max_hints_in_progress.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        auto enable = req->get_query_param("qs");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    sp::get_hints_in_progress.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::get_hints_in_progress.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
@@ -263,7 +262,7 @@ void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_se
        return ctx.db.local().get_config().request_timeout_in_ms()/1000.0;
    });

-    sp::set_rpc_timeout.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::set_rpc_timeout.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        auto enable = req->get_query_param("timeout");
@@ -274,7 +273,7 @@ void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_se
        return ctx.db.local().get_config().read_request_timeout_in_ms()/1000.0;
    });

-    sp::set_read_rpc_timeout.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::set_read_rpc_timeout.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        auto enable = req->get_query_param("timeout");
@@ -285,7 +284,7 @@ void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_se
        return ctx.db.local().get_config().write_request_timeout_in_ms()/1000.0;
    });

-    sp::set_write_rpc_timeout.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::set_write_rpc_timeout.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        auto enable = req->get_query_param("timeout");
@@ -296,7 +295,7 @@ void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_se
        return ctx.db.local().get_config().counter_write_request_timeout_in_ms()/1000.0;
    });

-    sp::set_counter_write_rpc_timeout.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::set_counter_write_rpc_timeout.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        auto enable = req->get_query_param("timeout");
@@ -307,7 +306,7 @@ void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_se
        return ctx.db.local().get_config().cas_contention_timeout_in_ms()/1000.0;
    });

-    sp::set_cas_contention_timeout.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::set_cas_contention_timeout.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        auto enable = req->get_query_param("timeout");
@@ -318,7 +317,7 @@ void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_se
        return ctx.db.local().get_config().range_request_timeout_in_ms()/1000.0;
    });

-    sp::set_range_rpc_timeout.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::set_range_rpc_timeout.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        auto enable = req->get_query_param("timeout");
@@ -329,32 +328,32 @@ void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_se
        return ctx.db.local().get_config().truncate_request_timeout_in_ms()/1000.0;
    });

-    sp::set_truncate_rpc_timeout.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::set_truncate_rpc_timeout.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        auto enable = req->get_query_param("timeout");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    sp::reload_trigger_classes.set(r, [](std::unique_ptr<http::request> req)  {
+    sp::reload_trigger_classes.set(r, [](std::unique_ptr<request> req)  {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(json_void());
    });

-    sp::get_read_repair_attempted.set(r, [&ctx](std::unique_ptr<http::request> req)  {
+    sp::get_read_repair_attempted.set(r, [&ctx](std::unique_ptr<request> req)  {
        return sum_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::read_repair_attempts);
    });

-    sp::get_read_repair_repaired_blocking.set(r, [&ctx](std::unique_ptr<http::request> req)  {
+    sp::get_read_repair_repaired_blocking.set(r, [&ctx](std::unique_ptr<request> req)  {
        return sum_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::read_repair_repaired_blocking);
    });

-    sp::get_read_repair_repaired_background.set(r, [&ctx](std::unique_ptr<http::request> req)  {
+    sp::get_read_repair_repaired_background.set(r, [&ctx](std::unique_ptr<request> req)  {
        return sum_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::read_repair_repaired_background);
    });

-    sp::get_schema_versions.set(r, [&ss](std::unique_ptr<http::request> req)  {
+    sp::get_schema_versions.set(r, [&ss](std::unique_ptr<request> req)  {
        return ss.local().describe_schema_versions().then([] (auto result) {
            std::vector<sp::mapper_list> res;
            for (auto e : result) {
@@ -367,122 +366,122 @@ void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_se
        });
    });

-    sp::get_cas_read_timeouts.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_read_timeouts.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &proxy::stats::cas_read_timeouts);
    });

-    sp::get_cas_read_unavailables.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_read_unavailables.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &proxy::stats::cas_read_unavailables);
    });

-    sp::get_cas_write_timeouts.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_write_timeouts.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &proxy::stats::cas_write_timeouts);
    });

-    sp::get_cas_write_unavailables.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_write_unavailables.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &proxy::stats::cas_write_unavailables);
    });

-    sp::get_cas_write_metrics_unfinished_commit.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_write_metrics_unfinished_commit.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_stats(ctx.sp, &proxy::stats::cas_write_unfinished_commit);
    });

-    sp::get_cas_write_metrics_contention.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_write_metrics_contention.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_estimated_histogram(ctx, &proxy::stats::cas_write_contention);
    });

-    sp::get_cas_write_metrics_condition_not_met.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_write_metrics_condition_not_met.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_stats(ctx.sp, &proxy::stats::cas_write_condition_not_met);
    });

-    sp::get_cas_write_metrics_failed_read_round_optimization.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_write_metrics_failed_read_round_optimization.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_stats(ctx.sp, &proxy::stats::cas_failed_read_round_optimization);
    });

-    sp::get_cas_read_metrics_unfinished_commit.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_read_metrics_unfinished_commit.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_stats(ctx.sp, &proxy::stats::cas_read_unfinished_commit);
    });

-    sp::get_cas_read_metrics_contention.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_read_metrics_contention.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_estimated_histogram(ctx, &proxy::stats::cas_read_contention);
    });

-    sp::get_read_metrics_timeouts.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_read_metrics_timeouts.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &service::storage_proxy_stats::stats::read_timeouts);
    });

-    sp::get_read_metrics_unavailables.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_read_metrics_unavailables.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &service::storage_proxy_stats::stats::read_unavailables);
    });

-    sp::get_range_metrics_timeouts.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_range_metrics_timeouts.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &service::storage_proxy_stats::stats::range_slice_timeouts);
    });

-    sp::get_range_metrics_unavailables.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_range_metrics_unavailables.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &service::storage_proxy_stats::stats::range_slice_unavailables);
    });

-    sp::get_write_metrics_timeouts.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_write_metrics_timeouts.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &service::storage_proxy_stats::stats::write_timeouts);
    });

-    sp::get_write_metrics_unavailables.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_write_metrics_unavailables.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_long(ctx.sp, &service::storage_proxy_stats::stats::write_unavailables);
    });

-    sp::get_read_metrics_timeouts_rates.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_read_metrics_timeouts_rates.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_obj(ctx.sp, &service::storage_proxy_stats::stats::read_timeouts);
    });

-    sp::get_read_metrics_unavailables_rates.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_read_metrics_unavailables_rates.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_obj(ctx.sp, &service::storage_proxy_stats::stats::read_unavailables);
    });

-    sp::get_range_metrics_timeouts_rates.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_range_metrics_timeouts_rates.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_obj(ctx.sp, &service::storage_proxy_stats::stats::range_slice_timeouts);
    });

-    sp::get_range_metrics_unavailables_rates.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_range_metrics_unavailables_rates.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_obj(ctx.sp, &service::storage_proxy_stats::stats::range_slice_unavailables);
    });

-    sp::get_write_metrics_timeouts_rates.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_write_metrics_timeouts_rates.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_obj(ctx.sp, &service::storage_proxy_stats::stats::write_timeouts);
    });

-    sp::get_write_metrics_unavailables_rates.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_write_metrics_unavailables_rates.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timed_rate_as_obj(ctx.sp, &service::storage_proxy_stats::stats::write_unavailables);
    });

-    sp::get_range_metrics_latency_histogram_depricated.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_range_metrics_latency_histogram_depricated.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_histogram_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::range);
    });

-    sp::get_write_metrics_latency_histogram_depricated.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_write_metrics_latency_histogram_depricated.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_histogram_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::write);
    });

-    sp::get_read_metrics_latency_histogram_depricated.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_read_metrics_latency_histogram_depricated.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_histogram_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::read);
    });

-    sp::get_range_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_range_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timer_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::range);
    });

-    sp::get_write_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_write_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timer_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::write);
    });
-    sp::get_cas_write_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_write_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timer_stats(ctx.sp, &proxy::stats::cas_write);
    });

-    sp::get_cas_read_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_cas_read_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timer_stats(ctx.sp, &proxy::stats::cas_read);
    });

-    sp::get_view_write_metrics_latency_histogram.set(r, [](std::unique_ptr<http::request> req) {
+    sp::get_view_write_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        //TBD
        // FIXME
        // No View metrics are available, so just return empty moving average
@@ -490,101 +489,32 @@ void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_se
        return make_ready_future<json::json_return_type>(get_empty_moving_average());
    });

-    sp::get_read_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_read_metrics_latency_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timer_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::read);
    });

-    sp::get_read_estimated_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_read_estimated_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_estimated_histogram(ctx, &service::storage_proxy_stats::stats::read);
    });

-    sp::get_read_latency.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_read_latency.set(r, [&ctx](std::unique_ptr<request> req) {
        return total_latency(ctx, &service::storage_proxy_stats::stats::read);
    });
-    sp::get_write_estimated_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_write_estimated_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_estimated_histogram(ctx, &service::storage_proxy_stats::stats::write);
    });

-    sp::get_write_latency.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_write_latency.set(r, [&ctx](std::unique_ptr<request> req) {
        return total_latency(ctx, &service::storage_proxy_stats::stats::write);
    });

-    sp::get_range_estimated_histogram.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_range_estimated_histogram.set(r, [&ctx](std::unique_ptr<request> req) {
        return sum_timer_stats_storage_proxy(ctx.sp, &service::storage_proxy_stats::stats::range);
    });

-    sp::get_range_latency.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    sp::get_range_latency.set(r, [&ctx](std::unique_ptr<request> req) {
        return total_latency(ctx, &service::storage_proxy_stats::stats::range);
    });
 }

-void unset_storage_proxy(http_context& ctx, routes& r) {
-    sp::get_total_hints.unset(r);
-    sp::get_hinted_handoff_enabled.unset(r);
-    sp::set_hinted_handoff_enabled.unset(r);
-    sp::get_hinted_handoff_enabled_by_dc.unset(r);
-    sp::set_hinted_handoff_enabled_by_dc_list.unset(r);
-    sp::get_max_hint_window.unset(r);
-    sp::set_max_hint_window.unset(r);
-    sp::get_max_hints_in_progress.unset(r);
-    sp::set_max_hints_in_progress.unset(r);
-    sp::get_hints_in_progress.unset(r);
-    sp::get_rpc_timeout.unset(r);
-    sp::set_rpc_timeout.unset(r);
-    sp::get_read_rpc_timeout.unset(r);
-    sp::set_read_rpc_timeout.unset(r);
-    sp::get_write_rpc_timeout.unset(r);
-    sp::set_write_rpc_timeout.unset(r);
-    sp::get_counter_write_rpc_timeout.unset(r);
-    sp::set_counter_write_rpc_timeout.unset(r);
-    sp::get_cas_contention_timeout.unset(r);
-    sp::set_cas_contention_timeout.unset(r);
-    sp::get_range_rpc_timeout.unset(r);
-    sp::set_range_rpc_timeout.unset(r);
-    sp::get_truncate_rpc_timeout.unset(r);
-    sp::set_truncate_rpc_timeout.unset(r);
-    sp::reload_trigger_classes.unset(r);
-    sp::get_read_repair_attempted.unset(r);
-    sp::get_read_repair_repaired_blocking.unset(r);
-    sp::get_read_repair_repaired_background.unset(r);
-    sp::get_schema_versions.unset(r);
-    sp::get_cas_read_timeouts.unset(r);
-    sp::get_cas_read_unavailables.unset(r);
-    sp::get_cas_write_timeouts.unset(r);
-    sp::get_cas_write_unavailables.unset(r);
-    sp::get_cas_write_metrics_unfinished_commit.unset(r);
-    sp::get_cas_write_metrics_contention.unset(r);
-    sp::get_cas_write_metrics_condition_not_met.unset(r);
-    sp::get_cas_write_metrics_failed_read_round_optimization.unset(r);
-    sp::get_cas_read_metrics_unfinished_commit.unset(r);
-    sp::get_cas_read_metrics_contention.unset(r);
-    sp::get_read_metrics_timeouts.unset(r);
-    sp::get_read_metrics_unavailables.unset(r);
-    sp::get_range_metrics_timeouts.unset(r);
-    sp::get_range_metrics_unavailables.unset(r);
-    sp::get_write_metrics_timeouts.unset(r);
-    sp::get_write_metrics_unavailables.unset(r);
-    sp::get_read_metrics_timeouts_rates.unset(r);
-    sp::get_read_metrics_unavailables_rates.unset(r);
-    sp::get_range_metrics_timeouts_rates.unset(r);
-    sp::get_range_metrics_unavailables_rates.unset(r);
-    sp::get_write_metrics_timeouts_rates.unset(r);
-    sp::get_write_metrics_unavailables_rates.unset(r);
-    sp::get_range_metrics_latency_histogram_depricated.unset(r);
-    sp::get_write_metrics_latency_histogram_depricated.unset(r);
-    sp::get_read_metrics_latency_histogram_depricated.unset(r);
-    sp::get_range_metrics_latency_histogram.unset(r);
-    sp::get_write_metrics_latency_histogram.unset(r);
-    sp::get_cas_write_metrics_latency_histogram.unset(r);
-    sp::get_cas_read_metrics_latency_histogram.unset(r);
-    sp::get_view_write_metrics_latency_histogram.unset(r);
-    sp::get_read_metrics_latency_histogram.unset(r);
-    sp::get_read_estimated_histogram.unset(r);
-    sp::get_read_latency.unset(r);
-    sp::get_write_estimated_histogram.unset(r);
-    sp::get_write_latency.unset(r);
-    sp::get_range_estimated_histogram.unset(r);
-    sp::get_range_latency.unset(r);
-}
-
 }
--- a/api/storage_proxy.hh
+++ b/api/storage_proxy.hh
@@ -15,7 +15,6 @@ namespace service { class storage_service; }

 namespace api {

-void set_storage_proxy(http_context& ctx, httpd::routes& r, sharded<service::storage_service>& ss);
-void unset_storage_proxy(http_context& ctx, httpd::routes& r);
+void set_storage_proxy(http_context& ctx, routes& r, sharded<service::storage_service>& ss);

 }
--- a/api/storage_service.cc
+++ b/api/storage_service.cc
@@ -47,16 +47,12 @@
 #include "sstables_loader.hh"
 #include "db/view/view_builder.hh"

-using namespace seastar::httpd;
-using namespace std::chrono_literals;
-
 extern logging::logger apilog;

 namespace std {

 std::ostream& operator<<(std::ostream& os, const api::table_info& ti) {
-    fmt::print(os, "table{{name={}, id={}}}", ti.name, ti.id);
-    return os;
+    return os << "table{name=" << ti.name << ", id=" << ti.id << "}";
 }

 } // namespace std
@@ -169,7 +165,7 @@ static ss::token_range token_range_endpoints_to_json(const dht::token_range_endp
    r.rpc_endpoints = d._rpc_endpoints;
    for (auto det : d._endpoint_details) {
        ss::endpoint_detail ed;
-        ed.host = fmt::to_string(det._host);
+        ed.host = boost::lexical_cast<std::string>(det._host);
        ed.datacenter = det._datacenter;
        if (det._rack != "") {
            ed.rack = det._rack;
@@ -179,10 +175,10 @@ static ss::token_range token_range_endpoints_to_json(const dht::token_range_endp
    return r;
 }

-using ks_cf_func = std::function<future<json::json_return_type>(http_context&, std::unique_ptr<http::request>, sstring, std::vector<table_info>)>;
+using ks_cf_func = std::function<future<json::json_return_type>(http_context&, std::unique_ptr<request>, sstring, std::vector<table_info>)>;

 static auto wrap_ks_cf(http_context &ctx, ks_cf_func f) {
-    return [&ctx, f = std::move(f)](std::unique_ptr<http::request> req) {
+    return [&ctx, f = std::move(f)](std::unique_ptr<request> req) {
        auto keyspace = validate_keyspace(ctx, req->param);
        auto table_infos = parse_table_infos(keyspace, ctx, req->query_parameters, "cf");
        return f(ctx, std::move(req), std::move(keyspace), std::move(table_infos));
@@ -247,7 +243,7 @@ future<json::json_return_type> set_tables_autocompaction(http_context& ctx, cons
 }

 void set_transport_controller(http_context& ctx, routes& r, cql_transport::controller& ctl) {
-    ss::start_native_transport.set(r, [&ctl](std::unique_ptr<http::request> req) {
+    ss::start_native_transport.set(r, [&ctl](std::unique_ptr<request> req) {
        return smp::submit_to(0, [&] {
            return ctl.start_server();
        }).then([] {
@@ -255,7 +251,7 @@ void set_transport_controller(http_context& ctx, routes& r, cql_transport::contr
        });
    });

-    ss::stop_native_transport.set(r, [&ctl](std::unique_ptr<http::request> req) {
+    ss::stop_native_transport.set(r, [&ctl](std::unique_ptr<request> req) {
        return smp::submit_to(0, [&] {
            return ctl.request_stop_server();
        }).then([] {
@@ -263,7 +259,7 @@ void set_transport_controller(http_context& ctx, routes& r, cql_transport::contr
        });
    });

-    ss::is_native_transport_running.set(r, [&ctl] (std::unique_ptr<http::request> req) {
+    ss::is_native_transport_running.set(r, [&ctl] (std::unique_ptr<request> req) {
        return smp::submit_to(0, [&] {
            return !ctl.listen_addresses().empty();
        }).then([] (bool running) {
@@ -279,7 +275,7 @@ void unset_transport_controller(http_context& ctx, routes& r) {
 }

 void set_rpc_controller(http_context& ctx, routes& r, thrift_controller& ctl) {
-    ss::stop_rpc_server.set(r, [&ctl](std::unique_ptr<http::request> req) {
+    ss::stop_rpc_server.set(r, [&ctl](std::unique_ptr<request> req) {
        return smp::submit_to(0, [&] {
            return ctl.request_stop_server();
        }).then([] {
@@ -287,7 +283,7 @@ void set_rpc_controller(http_context& ctx, routes& r, thrift_controller& ctl) {
        });
    });

-    ss::start_rpc_server.set(r, [&ctl](std::unique_ptr<http::request> req) {
+    ss::start_rpc_server.set(r, [&ctl](std::unique_ptr<request> req) {
        return smp::submit_to(0, [&] {
            return ctl.start_server();
        }).then([] {
@@ -295,7 +291,7 @@ void set_rpc_controller(http_context& ctx, routes& r, thrift_controller& ctl) {
        });
    });

-    ss::is_rpc_server_running.set(r, [&ctl] (std::unique_ptr<http::request> req) {
+    ss::is_rpc_server_running.set(r, [&ctl] (std::unique_ptr<request> req) {
        return smp::submit_to(0, [&] {
            return !ctl.listen_addresses().empty();
        }).then([] (bool running) {
@@ -311,7 +307,7 @@ void unset_rpc_controller(http_context& ctx, routes& r) {
 }

 void set_repair(http_context& ctx, routes& r, sharded<repair_service>& repair) {
-    ss::repair_async.set(r, [&ctx, &repair](std::unique_ptr<http::request> req) {
+    ss::repair_async.set(r, [&ctx, &repair](std::unique_ptr<request> req) {
        static std::vector<sstring> options = {"primaryRange", "parallelism", "incremental",
                "jobThreads", "ranges", "columnFamilies", "dataCenters", "hosts", "ignore_nodes", "trace",
                "startToken", "endToken" };
@@ -333,13 +329,13 @@ void set_repair(http_context& ctx, routes& r, sharded<repair_service>& repair) {
                });
    });

-    ss::get_active_repair_async.set(r, [&repair] (std::unique_ptr<http::request> req) {
+    ss::get_active_repair_async.set(r, [&repair] (std::unique_ptr<request> req) {
        return repair.local().get_active_repairs().then([] (std::vector<int> res) {
            return make_ready_future<json::json_return_type>(res);
        });
    });

-    ss::repair_async_status.set(r, [&repair] (std::unique_ptr<http::request> req) {
+    ss::repair_async_status.set(r, [&repair] (std::unique_ptr<request> req) {
        return repair.local().get_status(boost::lexical_cast<int>( req->get_query_param("id")))
                .then_wrapped([] (future<repair_status>&& fut) {
            ss::ns_repair_async_status::return_type_wrapper res;
@@ -352,7 +348,7 @@ void set_repair(http_context& ctx, routes& r, sharded<repair_service>& repair) {
        });
    });

-    ss::repair_await_completion.set(r, [&repair] (std::unique_ptr<http::request> req) {
+    ss::repair_await_completion.set(r, [&repair] (std::unique_ptr<request> req) {
        int id;
        using clock = std::chrono::steady_clock;
        clock::time_point expire;
@@ -385,13 +381,13 @@ void set_repair(http_context& ctx, routes& r, sharded<repair_service>& repair) {
        });
    });

-    ss::force_terminate_all_repair_sessions.set(r, [&repair] (std::unique_ptr<http::request> req) {
+    ss::force_terminate_all_repair_sessions.set(r, [&repair] (std::unique_ptr<request> req) {
        return repair.local().abort_all().then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });

-    ss::force_terminate_all_repair_sessions_new.set(r, [&repair] (std::unique_ptr<http::request> req) {
+    ss::force_terminate_all_repair_sessions_new.set(r, [&repair] (std::unique_ptr<request> req) {
        return repair.local().abort_all().then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
@@ -409,7 +405,7 @@ void unset_repair(http_context& ctx, routes& r) {
 }

 void set_sstables_loader(http_context& ctx, routes& r, sharded<sstables_loader>& sst_loader) {
-    ss::load_new_ss_tables.set(r, [&ctx, &sst_loader](std::unique_ptr<http::request> req) {
+    ss::load_new_ss_tables.set(r, [&ctx, &sst_loader](std::unique_ptr<request> req) {
        auto ks = validate_keyspace(ctx, req->param);
        auto cf = req->get_query_param("cf");
        auto stream = req->get_query_param("load_and_stream");
@@ -440,7 +436,7 @@ void unset_sstables_loader(http_context& ctx, routes& r) {
 }

 void set_view_builder(http_context& ctx, routes& r, sharded<db::view::view_builder>& vb) {
-    ss::view_build_statuses.set(r, [&ctx, &vb] (std::unique_ptr<http::request> req) {
+    ss::view_build_statuses.set(r, [&ctx, &vb] (std::unique_ptr<request> req) {
        auto keyspace = validate_keyspace(ctx, req->param);
        auto view = req->param["view"];
        return vb.local().view_build_statuses(std::move(keyspace), std::move(view)).then([] (std::unordered_map<sstring, sstring> status) {
@@ -459,30 +455,22 @@ static future<json::json_return_type> describe_ring_as_json(sharded<service::sto
    co_return json::json_return_type(stream_range_as_array(co_await ss.local().describe_ring(keyspace), token_range_endpoints_to_json));
 }

-static std::vector<table_id> get_table_ids(const std::vector<table_info>& table_infos) {
-    std::vector<table_id> table_ids{table_infos.size()};
-    boost::transform(table_infos, table_ids.begin(), [] (const auto& ti) {
-        return ti.id;
-    });
-    return table_ids;
-}
-
 void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_service>& ss, gms::gossiper& g, sharded<cdc::generation_service>& cdc_gs, sharded<db::system_keyspace>& sys_ks) {
-    ss::local_hostid.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::local_hostid.set(r, [&ctx](std::unique_ptr<request> req) {
        auto id = ctx.db.local().get_config().host_id;
        return make_ready_future<json::json_return_type>(id.to_sstring());
    });

-    ss::get_tokens.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    ss::get_tokens.set(r, [&ctx] (std::unique_ptr<request> req) {
        return make_ready_future<json::json_return_type>(stream_range_as_array(ctx.get_token_metadata().sorted_tokens(), [](const dht::token& i) {
-           return fmt::to_string(i);
+           return boost::lexical_cast<std::string>(i);
        }));
    });

-    ss::get_node_tokens.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    ss::get_node_tokens.set(r, [&ctx] (std::unique_ptr<request> req) {
        gms::inet_address addr(req->param["endpoint"]);
        return make_ready_future<json::json_return_type>(stream_range_as_array(ctx.get_token_metadata().get_tokens(addr), [](const dht::token& i) {
-           return fmt::to_string(i);
+           return boost::lexical_cast<std::string>(i);
       }));
    });

@@ -490,16 +478,16 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return ctx.db.local().commitlog()->active_config().commit_log_location;
    });

-    ss::get_token_endpoint.set(r, [&ss] (std::unique_ptr<http::request> req) {
+    ss::get_token_endpoint.set(r, [&ss] (std::unique_ptr<request> req) {
        return make_ready_future<json::json_return_type>(stream_range_as_array(ss.local().get_token_to_endpoint_map(), [](const auto& i) {
            storage_service_json::mapper val;
-            val.key = fmt::to_string(i.first);
-            val.value = fmt::to_string(i.second);
+            val.key = boost::lexical_cast<std::string>(i.first);
+            val.value = boost::lexical_cast<std::string>(i.second);
            return val;
        }));
    });

-    ss::toppartitions_generic.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    ss::toppartitions_generic.set(r, [&ctx] (std::unique_ptr<request> req) {
        bool filters_provided = false;

        std::unordered_set<std::tuple<sstring, sstring>, utils::tuple_hash> table_filters {};
@@ -562,7 +550,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        auto points = ctx.get_token_metadata().get_bootstrap_tokens();
        std::unordered_set<sstring> addr;
        for (auto i: points) {
-            addr.insert(fmt::to_string(i.second));
+            addr.insert(boost::lexical_cast<std::string>(i.second));
        }
        return container_to_vec(addr);
    });
@@ -586,7 +574,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return ctx.db.local().get_config().saved_caches_directory();
    });

-    ss::get_range_to_endpoint_map.set(r, [&ctx, &ss](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    ss::get_range_to_endpoint_map.set(r, [&ctx, &ss](std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto keyspace = validate_keyspace(ctx, req->param);
        std::vector<ss::maplist_mapper> res;
        co_return stream_range_as_array(co_await ss.local().get_range_to_address_map(keyspace),
@@ -609,7 +597,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::get_pending_range_to_endpoint_map.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::get_pending_range_to_endpoint_map.set(r, [&ctx](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto keyspace = validate_keyspace(ctx, req->param);
@@ -617,7 +605,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return make_ready_future<json::json_return_type>(res);
    });

-    ss::describe_any_ring.set(r, [&ctx, &ss](std::unique_ptr<http::request> req) {
+    ss::describe_any_ring.set(r, [&ctx, &ss](std::unique_ptr<request> req) {
        // Find an arbitrary non-system keyspace.
        auto keyspaces = ctx.db.local().get_non_local_strategy_keyspaces();
        if (keyspaces.empty()) {
@@ -627,7 +615,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return describe_ring_as_json(ss, ks);
    });

-    ss::describe_ring.set(r, [&ctx, &ss](std::unique_ptr<http::request> req) {
+    ss::describe_ring.set(r, [&ctx, &ss](std::unique_ptr<request> req) {
        return describe_ring_as_json(ss, validate_keyspace(ctx, req->param));
    });

@@ -636,11 +624,11 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return map_to_key_value(ctx.get_token_metadata().get_endpoint_to_host_id_map_for_reading(), res);
    });

-    ss::get_load.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::get_load.set(r, [&ctx](std::unique_ptr<request> req) {
        return get_cf_stats(ctx, &replica::column_family_stats::live_disk_space_used);
    });

-    ss::get_load_map.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    ss::get_load_map.set(r, [&ctx] (std::unique_ptr<request> req) {
        return ctx.lmeter.get_load_map().then([] (auto&& load_map) {
            std::vector<ss::map_string_double> res;
            for (auto i : load_map) {
@@ -653,10 +641,10 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::get_current_generation_number.set(r, [&g](std::unique_ptr<http::request> req) {
+    ss::get_current_generation_number.set(r, [&g](std::unique_ptr<request> req) {
        gms::inet_address ep(utils::fb_utilities::get_broadcast_address());
-        return g.get_current_generation_number(ep).then([](gms::generation_type res) {
-            return make_ready_future<json::json_return_type>(res.value());
+        return g.get_current_generation_number(ep).then([](int res) {
+            return make_ready_future<json::json_return_type>(res);
        });
    });

@@ -666,7 +654,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
                req.get_query_param("key")));
    });

-    ss::cdc_streams_check_and_repair.set(r, [&cdc_gs] (std::unique_ptr<http::request> req) {
+    ss::cdc_streams_check_and_repair.set(r, [&ctx, &cdc_gs] (std::unique_ptr<request> req) {
        if (!cdc_gs.local_is_initialized()) {
            throw std::runtime_error("get_cdc_generation_service: not initialized yet");
        }
@@ -675,25 +663,35 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::force_keyspace_compaction.set(r, [&ctx](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    ss::force_keyspace_compaction.set(r, [&ctx](std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto& db = ctx.db;
        auto keyspace = validate_keyspace(ctx, req->param);
        auto table_infos = parse_table_infos(keyspace, ctx, req->query_parameters, "cf");
        apilog.debug("force_keyspace_compaction: keyspace={} tables={}", keyspace, table_infos);
-
-        auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
-        auto task = co_await compaction_module.make_and_start_task<major_keyspace_compaction_task_impl>({}, std::move(keyspace), db, get_table_ids(table_infos));
        try {
-            co_await task->done();
+            co_await db.invoke_on_all([&] (replica::database& db) -> future<> {
+                auto local_tables = table_infos;
+                // major compact smaller tables first, to increase chances of success if low on space.
+                std::ranges::sort(local_tables, std::less<>(), [&] (const table_info& ti) {
+                    try {
+                        return db.find_column_family(ti.id).get_stats().live_disk_space_used;
+                    } catch (const replica::no_such_column_family& e) {
+                        return int64_t(-1);
+                    }
+                });
+                co_await run_on_existing_tables("force_keyspace_compaction", db, keyspace, local_tables, [] (replica::table& t) {
+                    return t.compact_all_sstables();
+                });
+            });
        } catch (...) {
-            apilog.error("force_keyspace_compaction: keyspace={} tables={} failed: {}", task->get_status().keyspace, table_infos, std::current_exception());
+            apilog.error("force_keyspace_compaction: keyspace={} tables={} failed: {}", keyspace, table_infos, std::current_exception());
            throw;
        }

        co_return json_void();
    });

-    ss::force_keyspace_cleanup.set(r, [&ctx, &ss](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    ss::force_keyspace_cleanup.set(r, [&ctx, &ss](std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto& db = ctx.db;
        auto keyspace = validate_keyspace(ctx, req->param);
        auto table_infos = parse_table_infos(keyspace, ctx, req->query_parameters, "cf");
@@ -703,44 +701,64 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
            apilog.warn("force_keyspace_cleanup: keyspace={} tables={}: {}", keyspace, table_infos, msg);
            co_await coroutine::return_exception(std::runtime_error(msg));
        }
-
-        auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
-        auto task = co_await compaction_module.make_and_start_task<cleanup_keyspace_compaction_task_impl>({}, std::move(keyspace), db, get_table_ids(table_infos));
        try {
-            co_await task->done();
+            co_await db.invoke_on_all([&] (replica::database& db) -> future<> {
+                auto local_tables = table_infos;
+                // cleanup smaller tables first, to increase chances of success if low on space.
+                std::ranges::sort(local_tables, std::less<>(), [&] (const table_info& ti) {
+                    try {
+                        return db.find_column_family(ti.id).get_stats().live_disk_space_used;
+                    } catch (const replica::no_such_column_family& e) {
+                        return int64_t(-1);
+                    }
+                });
+                auto& cm = db.get_compaction_manager();
+                auto owned_ranges_ptr = compaction::make_owned_ranges_ptr(db.get_keyspace_local_ranges(keyspace));
+                co_await run_on_existing_tables("force_keyspace_cleanup", db, keyspace, local_tables, [&] (replica::table& t) {
+                    return t.perform_cleanup_compaction(owned_ranges_ptr);
+                });
+            });
        } catch (...) {
-            apilog.error("force_keyspace_cleanup: keyspace={} tables={} failed: {}", task->get_status().keyspace, table_infos, std::current_exception());
+            apilog.error("force_keyspace_cleanup: keyspace={} tables={} failed: {}", keyspace, table_infos, std::current_exception());
            throw;
        }

        co_return json::json_return_type(0);
    });

-    ss::perform_keyspace_offstrategy_compaction.set(r, wrap_ks_cf(ctx, [] (http_context& ctx, std::unique_ptr<http::request> req, sstring keyspace, std::vector<table_info> table_infos) -> future<json::json_return_type> {
+    ss::perform_keyspace_offstrategy_compaction.set(r, wrap_ks_cf(ctx, [] (http_context& ctx, std::unique_ptr<request> req, sstring keyspace, std::vector<table_info> table_infos) -> future<json::json_return_type> {
        apilog.info("perform_keyspace_offstrategy_compaction: keyspace={} tables={}", keyspace, table_infos);
        bool res = false;
-        auto& compaction_module = ctx.db.local().get_compaction_manager().get_task_manager_module();
-        auto task = co_await compaction_module.make_and_start_task<offstrategy_keyspace_compaction_task_impl>({}, std::move(keyspace), ctx.db, get_table_ids(table_infos), res);
        try {
-            co_await task->done();
+            res = co_await ctx.db.map_reduce0([&] (replica::database& db) -> future<bool> {
+                bool needed = false;
+                co_await run_on_existing_tables("perform_keyspace_offstrategy_compaction", db, keyspace, table_infos, [&needed] (replica::table& t) -> future<> {
+                    needed |= co_await t.perform_offstrategy_compaction();
+                });
+                co_return needed;
+            }, false, std::plus<bool>());
        } catch (...) {
-            apilog.error("perform_keyspace_offstrategy_compaction: keyspace={} tables={} failed: {}", task->get_status().keyspace, table_infos, std::current_exception());
+            apilog.error("perform_keyspace_offstrategy_compaction: keyspace={} tables={} failed: {}", keyspace, table_infos, std::current_exception());
            throw;
        }

        co_return json::json_return_type(res);
    }));

-    ss::upgrade_sstables.set(r, wrap_ks_cf(ctx, [] (http_context& ctx, std::unique_ptr<http::request> req, sstring keyspace, std::vector<table_info> table_infos) -> future<json::json_return_type> {
+    ss::upgrade_sstables.set(r, wrap_ks_cf(ctx, [] (http_context& ctx, std::unique_ptr<request> req, sstring keyspace, std::vector<table_info> table_infos) -> future<json::json_return_type> {
        auto& db = ctx.db;
        bool exclude_current_version = req_param<bool>(*req, "exclude_current_version", false);

        apilog.info("upgrade_sstables: keyspace={} tables={} exclude_current_version={}", keyspace, table_infos, exclude_current_version);
-
-        auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
-        auto task = co_await compaction_module.make_and_start_task<upgrade_sstables_compaction_task_impl>({}, std::move(keyspace), db, get_table_ids(table_infos), exclude_current_version);
        try {
-            co_await task->done();
+            co_await db.invoke_on_all([&] (replica::database& db) -> future<> {
+                auto owned_ranges_ptr = compaction::make_owned_ranges_ptr(db.get_keyspace_local_ranges(keyspace));
+                co_await run_on_existing_tables("upgrade_sstables", db, keyspace, table_infos, [&] (replica::table& t) {
+                    return t.parallel_foreach_table_state([&] (compaction::table_state& ts) {
+                        return t.get_compaction_manager().perform_sstable_upgrade(owned_ranges_ptr, ts, exclude_current_version);
+                    });
+                });
+            });
        } catch (...) {
            apilog.error("upgrade_sstables: keyspace={} tables={} failed: {}", keyspace, table_infos, std::current_exception());
            throw;
@@ -749,7 +767,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        co_return json::json_return_type(0);
    }));

-    ss::force_keyspace_flush.set(r, [&ctx](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    ss::force_keyspace_flush.set(r, [&ctx](std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto keyspace = validate_keyspace(ctx, req->param);
        auto column_families = parse_tables(keyspace, ctx, req->query_parameters, "cf");
        apilog.info("perform_keyspace_flush: keyspace={} tables={}", keyspace, column_families);
@@ -763,21 +781,21 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
    });


-    ss::decommission.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::decommission.set(r, [&ss](std::unique_ptr<request> req) {
        apilog.info("decommission");
        return ss.local().decommission().then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });

-    ss::move.set(r, [&ss] (std::unique_ptr<http::request> req) {
+    ss::move.set(r, [&ss] (std::unique_ptr<request> req) {
        auto new_token = req->get_query_param("new_token");
        return ss.local().move(new_token).then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });

-    ss::remove_node.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::remove_node.set(r, [&ss](std::unique_ptr<request> req) {
        auto host_id = validate_host_id(req->get_query_param("host_id"));
        std::vector<sstring> ignore_nodes_strs= split(req->get_query_param("ignore_nodes"), ",");
        apilog.info("remove_node: host_id={} ignore_nodes={}", host_id, ignore_nodes_strs);
@@ -803,19 +821,19 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::get_removal_status.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::get_removal_status.set(r, [&ss](std::unique_ptr<request> req) {
        return ss.local().get_removal_status().then([] (auto status) {
            return make_ready_future<json::json_return_type>(status);
        });
    });

-    ss::force_remove_completion.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::force_remove_completion.set(r, [&ss](std::unique_ptr<request> req) {
        return ss.local().force_remove_completion().then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });

-    ss::set_logging_level.set(r, [](std::unique_ptr<http::request> req) {
+    ss::set_logging_level.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto class_qualifier = req->get_query_param("class_qualifier");
@@ -823,7 +841,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::get_logging_levels.set(r, [](std::unique_ptr<http::request> req) {
+    ss::get_logging_levels.set(r, [](std::unique_ptr<request> req) {
        std::vector<ss::mapper> res;
        for (auto i : logging::logger_registry().get_all_logger_names()) {
            ss::mapper log;
@@ -834,19 +852,19 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return make_ready_future<json::json_return_type>(res);
    });

-    ss::get_operation_mode.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::get_operation_mode.set(r, [&ss](std::unique_ptr<request> req) {
        return ss.local().get_operation_mode().then([] (auto mode) {
            return make_ready_future<json::json_return_type>(format("{}", mode));
        });
    });

-    ss::is_starting.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::is_starting.set(r, [&ss](std::unique_ptr<request> req) {
        return ss.local().get_operation_mode().then([] (auto mode) {
            return make_ready_future<json::json_return_type>(mode <= service::storage_service::mode::STARTING);
        });
    });

-    ss::get_drain_progress.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::get_drain_progress.set(r, [&ctx](std::unique_ptr<request> req) {
        return ctx.db.map_reduce(adder<replica::database::drain_progress>(), [] (auto& db) {
            return db.get_drain_progress();
        }).then([] (auto&& progress) {
@@ -855,13 +873,13 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::drain.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::drain.set(r, [&ss](std::unique_ptr<request> req) {
        apilog.info("drain");
        return ss.local().drain().then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });
-    ss::truncate.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::truncate.set(r, [&ctx](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto keyspace = validate_keyspace(ctx, req->param);
@@ -879,34 +897,34 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return map_keys(ctx.db.local().get_keyspaces());
    });

-    ss::stop_gossiping.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::stop_gossiping.set(r, [&ss](std::unique_ptr<request> req) {
        apilog.info("stop_gossiping");
        return ss.local().stop_gossiping().then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });

-    ss::start_gossiping.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::start_gossiping.set(r, [&ss](std::unique_ptr<request> req) {
        apilog.info("start_gossiping");
        return ss.local().start_gossiping().then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });

-    ss::is_gossip_running.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::is_gossip_running.set(r, [&ss](std::unique_ptr<request> req) {
        return ss.local().is_gossip_running().then([] (bool running){
            return make_ready_future<json::json_return_type>(running);
        });
    });


-    ss::stop_daemon.set(r, [](std::unique_ptr<http::request> req) {
+    ss::stop_daemon.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::is_initialized.set(r, [&ss, &g](std::unique_ptr<http::request> req) {
+    ss::is_initialized.set(r, [&ss, &g](std::unique_ptr<request> req) {
        return ss.local().get_operation_mode().then([&g] (auto mode) {
            bool is_initialized = mode >= service::storage_service::mode::STARTING;
            if (mode == service::storage_service::mode::NORMAL) {
@@ -916,42 +934,42 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::join_ring.set(r, [](std::unique_ptr<http::request> req) {
+    ss::join_ring.set(r, [](std::unique_ptr<request> req) {
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::is_joined.set(r, [&ss] (std::unique_ptr<http::request> req) {
+    ss::is_joined.set(r, [&ss] (std::unique_ptr<request> req) {
        return ss.local().get_operation_mode().then([] (auto mode) {
            return make_ready_future<json::json_return_type>(mode >= service::storage_service::mode::JOINING);
        });
    });

-    ss::set_stream_throughput_mb_per_sec.set(r, [](std::unique_ptr<http::request> req) {
+    ss::set_stream_throughput_mb_per_sec.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto value = req->get_query_param("value");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::get_stream_throughput_mb_per_sec.set(r, [](std::unique_ptr<http::request> req) {
+    ss::get_stream_throughput_mb_per_sec.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    ss::get_compaction_throughput_mb_per_sec.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::get_compaction_throughput_mb_per_sec.set(r, [&ctx](std::unique_ptr<request> req) {
        int value = ctx.db.local().get_config().compaction_throughput_mb_per_sec();
        return make_ready_future<json::json_return_type>(value);
    });

-    ss::set_compaction_throughput_mb_per_sec.set(r, [](std::unique_ptr<http::request> req) {
+    ss::set_compaction_throughput_mb_per_sec.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto value = req->get_query_param("value");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::is_incremental_backups_enabled.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::is_incremental_backups_enabled.set(r, [&ctx](std::unique_ptr<request> req) {
        // If this is issued in parallel with an ongoing change, we may see values not agreeing.
        // Reissuing is asking for trouble, so we will just return true upon seeing any true value.
        return ctx.db.map_reduce(adder<bool>(), [] (replica::database& db) {
@@ -967,7 +985,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::set_incremental_backups_enabled.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::set_incremental_backups_enabled.set(r, [&ctx](std::unique_ptr<request> req) {
        auto val_str = req->get_query_param("value");
        bool value = (val_str == "True") || (val_str == "true") || (val_str == "1");
        return ctx.db.invoke_on_all([value] (replica::database& db) {
@@ -988,7 +1006,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::rebuild.set(r, [&ss](std::unique_ptr<http::request> req) {
+    ss::rebuild.set(r, [&ss](std::unique_ptr<request> req) {
        auto source_dc = req->get_query_param("source_dc");
        apilog.info("rebuild: source_dc={}", source_dc);
        return ss.local().rebuild(std::move(source_dc)).then([] {
@@ -996,43 +1014,44 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::bulk_load.set(r, [](std::unique_ptr<http::request> req) {
+    ss::bulk_load.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto path = req->param["path"];
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::bulk_load_async.set(r, [](std::unique_ptr<http::request> req) {
+    ss::bulk_load_async.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto path = req->param["path"];
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::reschedule_failed_deletions.set(r, [](std::unique_ptr<http::request> req) {
+    ss::reschedule_failed_deletions.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::sample_key_range.set(r, [](std::unique_ptr<http::request> req) {
+    ss::sample_key_range.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        std::vector<sstring> res;
        return make_ready_future<json::json_return_type>(res);
    });

-    ss::reset_local_schema.set(r, [&ctx, &sys_ks](std::unique_ptr<http::request> req) {
+    ss::reset_local_schema.set(r, [&sys_ks](std::unique_ptr<request> req) {
        // FIXME: We should truncate schema tables if more than one node in the cluster.
-        auto& fs = ctx.sp.local().features();
+        auto& sp = service::get_storage_proxy();
+        auto& fs = sp.local().features();
        apilog.info("reset_local_schema");
-        return db::schema_tables::recalculate_schema_version(sys_ks, ctx.sp, fs).then([] {
+        return db::schema_tables::recalculate_schema_version(sys_ks, sp, fs).then([] {
            return make_ready_future<json::json_return_type>(json_void());
        });
    });

-    ss::set_trace_probability.set(r, [](std::unique_ptr<http::request> req) {
+    ss::set_trace_probability.set(r, [](std::unique_ptr<request> req) {
        auto probability = req->get_query_param("probability");
        apilog.info("set_trace_probability: probability={}", probability);
        return futurize_invoke([probability] {
@@ -1054,7 +1073,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::get_trace_probability.set(r, [](std::unique_ptr<http::request> req) {
+    ss::get_trace_probability.set(r, [](std::unique_ptr<request> req) {
        return make_ready_future<json::json_return_type>(tracing::tracing::get_local_tracing_instance().get_trace_probability());
    });

@@ -1067,7 +1086,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return res;
    });

-    ss::set_slow_query.set(r, [](std::unique_ptr<http::request> req) {
+    ss::set_slow_query.set(r, [](std::unique_ptr<request> req) {
        auto enable = req->get_query_param("enable");
        auto ttl = req->get_query_param("ttl");
        auto threshold = req->get_query_param("threshold");
@@ -1095,7 +1114,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        }
    });

-    ss::enable_auto_compaction.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::enable_auto_compaction.set(r, [&ctx](std::unique_ptr<request> req) {
        auto keyspace = validate_keyspace(ctx, req->param);
        auto tables = parse_tables(keyspace, ctx, req->query_parameters, "cf");

@@ -1103,7 +1122,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return set_tables_autocompaction(ctx, keyspace, tables, true);
    });

-    ss::disable_auto_compaction.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::disable_auto_compaction.set(r, [&ctx](std::unique_ptr<request> req) {
        auto keyspace = validate_keyspace(ctx, req->param);
        auto tables = parse_tables(keyspace, ctx, req->query_parameters, "cf");

@@ -1111,7 +1130,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return set_tables_autocompaction(ctx, keyspace, tables, false);
    });

-    ss::deliver_hints.set(r, [](std::unique_ptr<http::request> req) {
+    ss::deliver_hints.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto host = req->get_query_param("host");
@@ -1126,53 +1145,53 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return g.get_partitioner_name();
    });

-    ss::get_tombstone_warn_threshold.set(r, [](std::unique_ptr<http::request> req) {
+    ss::get_tombstone_warn_threshold.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    ss::set_tombstone_warn_threshold.set(r, [](std::unique_ptr<http::request> req) {
+    ss::set_tombstone_warn_threshold.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto debug_threshold = req->get_query_param("debug_threshold");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::get_tombstone_failure_threshold.set(r, [](std::unique_ptr<http::request> req) {
+    ss::get_tombstone_failure_threshold.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    ss::set_tombstone_failure_threshold.set(r, [](std::unique_ptr<http::request> req) {
+    ss::set_tombstone_failure_threshold.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto debug_threshold = req->get_query_param("debug_threshold");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::get_batch_size_failure_threshold.set(r, [](std::unique_ptr<http::request> req) {
+    ss::get_batch_size_failure_threshold.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    ss::set_batch_size_failure_threshold.set(r, [](std::unique_ptr<http::request> req) {
+    ss::set_batch_size_failure_threshold.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto threshold = req->get_query_param("threshold");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::set_hinted_handoff_throttle_in_kb.set(r, [](std::unique_ptr<http::request> req) {
+    ss::set_hinted_handoff_throttle_in_kb.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        auto debug_threshold = req->get_query_param("throttle");
        return make_ready_future<json::json_return_type>(json_void());
    });

-    ss::get_metrics_load.set(r, [&ctx](std::unique_ptr<http::request> req) {
+    ss::get_metrics_load.set(r, [&ctx](std::unique_ptr<request> req) {
        return get_cf_stats(ctx, &replica::column_family_stats::live_disk_space_used);
    });

@@ -1180,26 +1199,26 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        return ss.local().get_exception_count();
    });

-    ss::get_total_hints_in_progress.set(r, [](std::unique_ptr<http::request> req) {
+    ss::get_total_hints_in_progress.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    ss::get_total_hints.set(r, [](std::unique_ptr<http::request> req) {
+    ss::get_total_hints.set(r, [](std::unique_ptr<request> req) {
        //TBD
        unimplemented();
        return make_ready_future<json::json_return_type>(0);
    });

-    ss::get_ownership.set(r, [&ss] (std::unique_ptr<http::request> req) {
+    ss::get_ownership.set(r, [&ss] (std::unique_ptr<request> req) {
        return ss.local().get_ownership().then([] (auto&& ownership) {
            std::vector<storage_service_json::mapper> res;
            return make_ready_future<json::json_return_type>(map_to_key_value(ownership, res));
        });
    });

-    ss::get_effective_ownership.set(r, [&ctx, &ss] (std::unique_ptr<http::request> req) {
+    ss::get_effective_ownership.set(r, [&ctx, &ss] (std::unique_ptr<request> req) {
        auto keyspace_name = req->param["keyspace"] == "null" ? "" : validate_keyspace(ctx, req->param);
        return ss.local().effective_ownership(keyspace_name).then([] (auto&& ownership) {
            std::vector<storage_service_json::mapper> res;
@@ -1207,7 +1226,7 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
        });
    });

-    ss::sstable_info.set(r, [&ctx] (std::unique_ptr<http::request> req) {
+    ss::sstable_info.set(r, [&ctx] (std::unique_ptr<request> req) {
        auto ks = api::req_param<sstring>(*req, "keyspace", {}).value;
        auto cf = api::req_param<sstring>(*req, "cf", {}).value;

@@ -1342,7 +1361,7 @@ enum class scrub_status {
 };

 void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_ctl) {
-    ss::get_snapshot_details.set(r, [&snap_ctl](std::unique_ptr<http::request> req) {
+    ss::get_snapshot_details.set(r, [&snap_ctl](std::unique_ptr<request> req) {
        return snap_ctl.local().get_snapshot_details().then([] (std::unordered_map<sstring, std::vector<db::snapshot_ctl::snapshot_details>>&& result) {
            std::function<future<>(output_stream<char>&&)> f = [result = std::move(result)](output_stream<char>&& s) {
                return do_with(output_stream<char>(std::move(s)), true, [&result] (output_stream<char>& s, bool& first){
@@ -1379,7 +1398,7 @@ void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_
        });
    });

-    ss::take_snapshot.set(r, [&ctx, &snap_ctl](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    ss::take_snapshot.set(r, [&ctx, &snap_ctl](std::unique_ptr<request> req) -> future<json::json_return_type> {
        apilog.info("take_snapshot: {}", req->query_parameters);
        auto tag = req->get_query_param("tag");
        auto column_families = split(req->get_query_param("cf"), ",");
@@ -1412,7 +1431,7 @@ void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_
        }
    });

-    ss::del_snapshot.set(r, [&snap_ctl](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    ss::del_snapshot.set(r, [&snap_ctl](std::unique_ptr<request> req) -> future<json::json_return_type> {
        apilog.info("del_snapshot: {}", req->query_parameters);
        auto tag = req->get_query_param("tag");
        auto column_family = req->get_query_param("cf");
@@ -1427,13 +1446,13 @@ void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_
        }
    });

-    ss::true_snapshots_size.set(r, [&snap_ctl](std::unique_ptr<http::request> req) {
+    ss::true_snapshots_size.set(r, [&snap_ctl](std::unique_ptr<request> req) {
        return snap_ctl.local().true_snapshots_size().then([] (int64_t size) {
            return make_ready_future<json::json_return_type>(size);
        });
    });

-    ss::scrub.set(r, [&ctx, &snap_ctl] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    ss::scrub.set(r, [&ctx, &snap_ctl] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto& db = ctx.db;
        auto rp = req_params({
            {"keyspace", {mandatory::yes}},
--- a/api/storage_service.hh
+++ b/api/storage_service.hh
@@ -36,13 +36,9 @@ class gossiper;

 namespace api {

-// verify that the keyspace is found, otherwise a bad_param_exception exception is thrown
-// containing the description of the respective keyspace error.
-sstring validate_keyspace(http_context& ctx, sstring ks_name);
-
 // verify that the keyspace parameter is found, otherwise a bad_param_exception exception is thrown
 // containing the description of the respective keyspace error.
-sstring validate_keyspace(http_context& ctx, const httpd::parameters& param);
+sstring validate_keyspace(http_context& ctx, const parameters& param);

 // splits a request parameter assumed to hold a comma-separated list of table names
 // verify that the tables are found, otherwise a bad_param_exception exception is thrown
@@ -63,19 +59,19 @@ struct table_info {
 // if the parameter is not found or is empty, returns a list of all table infos in the keyspace.
 std::vector<table_info> parse_table_infos(const sstring& ks_name, http_context& ctx, const std::unordered_map<sstring, sstring>& query_params, sstring param_name);

-void set_storage_service(http_context& ctx, httpd::routes& r, sharded<service::storage_service>& ss, gms::gossiper& g, sharded<cdc::generation_service>& cdc_gs, sharded<db::system_keyspace>& sys_ls);
-void set_sstables_loader(http_context& ctx, httpd::routes& r, sharded<sstables_loader>& sst_loader);
-void unset_sstables_loader(http_context& ctx, httpd::routes& r);
-void set_view_builder(http_context& ctx, httpd::routes& r, sharded<db::view::view_builder>& vb);
-void unset_view_builder(http_context& ctx, httpd::routes& r);
-void set_repair(http_context& ctx, httpd::routes& r, sharded<repair_service>& repair);
-void unset_repair(http_context& ctx, httpd::routes& r);
-void set_transport_controller(http_context& ctx, httpd::routes& r, cql_transport::controller& ctl);
-void unset_transport_controller(http_context& ctx, httpd::routes& r);
-void set_rpc_controller(http_context& ctx, httpd::routes& r, thrift_controller& ctl);
-void unset_rpc_controller(http_context& ctx, httpd::routes& r);
-void set_snapshot(http_context& ctx, httpd::routes& r, sharded<db::snapshot_ctl>& snap_ctl);
-void unset_snapshot(http_context& ctx, httpd::routes& r);
+void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_service>& ss, gms::gossiper& g, sharded<cdc::generation_service>& cdc_gs, sharded<db::system_keyspace>& sys_ls);
+void set_sstables_loader(http_context& ctx, routes& r, sharded<sstables_loader>& sst_loader);
+void unset_sstables_loader(http_context& ctx, routes& r);
+void set_view_builder(http_context& ctx, routes& r, sharded<db::view::view_builder>& vb);
+void unset_view_builder(http_context& ctx, routes& r);
+void set_repair(http_context& ctx, routes& r, sharded<repair_service>& repair);
+void unset_repair(http_context& ctx, routes& r);
+void set_transport_controller(http_context& ctx, routes& r, cql_transport::controller& ctl);
+void unset_transport_controller(http_context& ctx, routes& r);
+void set_rpc_controller(http_context& ctx, routes& r, thrift_controller& ctl);
+void unset_rpc_controller(http_context& ctx, routes& r);
+void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_ctl);
+void unset_snapshot(http_context& ctx, routes& r);
 seastar::future<json::json_return_type> run_toppartitions_query(db::toppartitions_query& q, http_context &ctx, bool legacy_request = false);

 } // namespace api
--- a/api/stream_manager.cc
+++ b/api/stream_manager.cc
@@ -14,7 +14,6 @@
 #include "gms/gossiper.hh"

 namespace api {
-using namespace seastar::httpd;

 namespace hs = httpd::stream_manager_json;

@@ -22,7 +21,7 @@ static void set_summaries(const std::vector<streaming::stream_summary>& from,
        json::json_list<hs::stream_summary>& to) {
    if (!from.empty()) {
        hs::stream_summary res;
-        res.cf_id = fmt::to_string(from.front().cf_id);
+        res.cf_id = boost::lexical_cast<std::string>(from.front().cf_id);
        // For each stream_session, we pretend we are sending/receiving one
        // file, to make it compatible with nodetool.
        res.files = 1;
@@ -39,7 +38,7 @@ static hs::progress_info get_progress_info(const streaming::progress_info& info)
    res.current_bytes = info.current_bytes;
    res.direction = info.dir;
    res.file_name = info.file_name;
-    res.peer = fmt::to_string(info.peer);
+    res.peer = boost::lexical_cast<std::string>(info.peer);
    res.session_index = 0;
    res.total_bytes = info.total_bytes;
    return res;
@@ -62,7 +61,7 @@ static hs::stream_state get_state(
    state.plan_id = result_future.plan_id.to_sstring();
    for (auto info : result_future.get_coordinator().get()->get_all_session_info()) {
        hs::stream_info si;
-        si.peer = fmt::to_string(info.peer);
+        si.peer = boost::lexical_cast<std::string>(info.peer);
        si.session_index = 0;
        si.state = info.state;
        si.connecting = si.peer;
--- a/api/stream_manager.hh
+++ b/api/stream_manager.hh
@@ -12,7 +12,7 @@

 namespace api {

-void set_stream_manager(http_context& ctx, httpd::routes& r, sharded<streaming::stream_manager>& sm);
-void unset_stream_manager(http_context& ctx, httpd::routes& r);
+void set_stream_manager(http_context& ctx, routes& r, sharded<streaming::stream_manager>& sm);
+void unset_stream_manager(http_context& ctx, routes& r);

 }
--- a/api/system.cc
+++ b/api/system.cc
@@ -17,7 +17,6 @@
 extern logging::logger apilog;

 namespace api {
-using namespace seastar::httpd;

 namespace hs = httpd::system_json;

--- a/api/system.hh
+++ b/api/system.hh
@@ -12,6 +12,6 @@

 namespace api {

-void set_system(http_context& ctx, httpd::routes& r);
+void set_system(http_context& ctx, routes& r);

 }
--- a/api/task_manager.cc
+++ b/api/task_manager.cc
@@ -22,7 +22,6 @@ namespace api {

 namespace tm = httpd::task_manager_json;
 using namespace json;
-using namespace seastar::httpd;

 inline bool filter_tasks(tasks::task_manager::task_ptr task, std::unordered_map<sstring, sstring>& query_params) {
    return (!query_params.contains("keyspace") || query_params["keyspace"] == task->get_status().keyspace) &&
@@ -108,13 +107,13 @@ future<full_task_status> retrieve_status(const tasks::task_manager::foreign_task
    co_return s;
 }

-void set_task_manager(http_context& ctx, routes& r, db::config& cfg) {
-    tm::get_modules.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+void set_task_manager(http_context& ctx, routes& r) {
+    tm::get_modules.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        std::vector<std::string> v = boost::copy_range<std::vector<std::string>>(ctx.tm.local().get_modules() | boost::adaptors::map_keys);
        co_return v;
    });

-    tm::get_tasks.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    tm::get_tasks.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        using chunked_stats = utils::chunked_vector<task_stats>;
        auto internal = tasks::is_internal{req_param<bool>(*req, "internal", false)};
        std::vector<chunked_stats> res = co_await ctx.tm.map([&req, internal] (tasks::task_manager& tm) {
@@ -148,7 +147,7 @@ void set_task_manager(http_context& ctx, routes& r, db::config& cfg) {
        co_return std::move(f);
    });

-    tm::get_task_status.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    tm::get_task_status.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto id = tasks::task_id{utils::UUID{req->param["task_id"]}};
        auto task = co_await tasks::task_manager::invoke_on_task(ctx.tm, id, std::function([] (tasks::task_manager::task_ptr task) -> future<tasks::task_manager::foreign_task_ptr> {
            auto state = task->get_status().state;
@@ -161,7 +160,7 @@ void set_task_manager(http_context& ctx, routes& r, db::config& cfg) {
        co_return make_status(s);
    });

-    tm::abort_task.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    tm::abort_task.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto id = tasks::task_id{utils::UUID{req->param["task_id"]}};
        co_await tasks::task_manager::invoke_on_task(ctx.tm, id, [] (tasks::task_manager::task_ptr task) -> future<> {
            if (!task->is_abortable()) {
@@ -172,7 +171,7 @@ void set_task_manager(http_context& ctx, routes& r, db::config& cfg) {
        co_return json_void();
    });

-    tm::wait_task.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    tm::wait_task.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto id = tasks::task_id{utils::UUID{req->param["task_id"]}};
        auto task = co_await tasks::task_manager::invoke_on_task(ctx.tm, id, std::function([] (tasks::task_manager::task_ptr task) {
            return task->done().then_wrapped([task] (auto f) {
@@ -185,7 +184,7 @@ void set_task_manager(http_context& ctx, routes& r, db::config& cfg) {
        co_return make_status(s);
    });

-    tm::get_task_status_recursively.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    tm::get_task_status_recursively.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto& _ctx = ctx;
        auto id = tasks::task_id{utils::UUID{req->param["task_id"]}};
        std::queue<tasks::task_manager::foreign_task_ptr> q;
@@ -205,7 +204,7 @@ void set_task_manager(http_context& ctx, routes& r, db::config& cfg) {
        while (!q.empty()) {
            auto& current = q.front();
            res.push_back(co_await retrieve_status(current));
-            for (size_t i = 0; i < current->get_children().size(); ++i) {
+            for (auto i = 0; i < current->get_children().size(); ++i) {
                q.push(co_await current->get_children()[i].copy());
            }
            q.pop();
@@ -225,12 +224,6 @@ void set_task_manager(http_context& ctx, routes& r, db::config& cfg) {
        };
        co_return f;
    });
-
-    tm::get_and_update_ttl.set(r, [&cfg] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
-        uint32_t ttl = cfg.task_ttl_seconds();
-        co_await cfg.task_ttl_seconds.set_value_on_all_shards(req->query_parameters["ttl"], utils::config_file::config_source::API);
-        co_return json::json_return_type(ttl);
-    });
 }

 }
--- a/api/task_manager.hh
+++ b/api/task_manager.hh
@@ -9,10 +9,9 @@
 #pragma once

 #include "api.hh"
-#include "db/config.hh"

 namespace api {

-void set_task_manager(http_context& ctx, httpd::routes& r, db::config& cfg);
+void set_task_manager(http_context& ctx, routes& r);

 }
--- a/api/task_manager_test.cc
+++ b/api/task_manager_test.cc
@@ -18,10 +18,9 @@ namespace api {

 namespace tmt = httpd::task_manager_test_json;
 using namespace json;
-using namespace seastar::httpd;

-void set_task_manager_test(http_context& ctx, routes& r) {
-    tmt::register_test_module.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+void set_task_manager_test(http_context& ctx, routes& r, db::config& cfg) {
+    tmt::register_test_module.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        co_await ctx.tm.invoke_on_all([] (tasks::task_manager& tm) {
            auto m = make_shared<tasks::test_module>(tm);
            tm.register_module("test", m);
@@ -29,7 +28,7 @@ void set_task_manager_test(http_context& ctx, routes& r) {
        co_return json_void();
    });

-    tmt::unregister_test_module.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    tmt::unregister_test_module.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        co_await ctx.tm.invoke_on_all([] (tasks::task_manager& tm) -> future<> {
            auto module_name = "test";
            auto module = tm.find_module(module_name);
@@ -38,7 +37,7 @@ void set_task_manager_test(http_context& ctx, routes& r) {
        co_return json_void();
    });

-    tmt::register_test_task.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    tmt::register_test_task.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        sharded<tasks::task_manager>& tms = ctx.tm;
        auto it = req->query_parameters.find("task_id");
        auto id = it != req->query_parameters.end() ? tasks::task_id{utils::UUID{it->second}} : tasks::task_id::create_null_id();
@@ -69,7 +68,7 @@ void set_task_manager_test(http_context& ctx, routes& r) {
        co_return id.to_sstring();
    });

-    tmt::unregister_test_task.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    tmt::unregister_test_task.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto id = tasks::task_id{utils::UUID{req->query_parameters["task_id"]}};
        co_await tasks::task_manager::invoke_on_task(ctx.tm, id, [] (tasks::task_manager::task_ptr task) -> future<> {
            tasks::test_task test_task{task};
@@ -78,7 +77,7 @@ void set_task_manager_test(http_context& ctx, routes& r) {
        co_return json_void();
    });

-    tmt::finish_test_task.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+    tmt::finish_test_task.set(r, [&ctx] (std::unique_ptr<request> req) -> future<json::json_return_type> {
        auto id = tasks::task_id{utils::UUID{req->param["task_id"]}};
        auto it = req->query_parameters.find("error");
        bool fail = it != req->query_parameters.end();
@@ -95,6 +94,12 @@ void set_task_manager_test(http_context& ctx, routes& r) {
        });
        co_return json_void();
    });
+
+    tmt::get_and_update_ttl.set(r, [&ctx, &cfg] (std::unique_ptr<request> req) -> future<json::json_return_type> {
+        uint32_t ttl = cfg.task_ttl_seconds();
+        co_await cfg.task_ttl_seconds.set_value_on_all_shards(req->query_parameters["ttl"], utils::config_file::config_source::API);
+        co_return json::json_return_type(ttl);
+    });
 }

 }
--- a/api/task_manager_test.hh
+++ b/api/task_manager_test.hh
@@ -11,10 +11,11 @@
 #pragma once

 #include "api.hh"
+#include "db/config.hh"

 namespace api {

-void set_task_manager_test(http_context& ctx, httpd::routes& r);
+void set_task_manager_test(http_context& ctx, routes& r, db::config& cfg);

 }

--- a/mutation/atomic_cell.cc
+++ b/mutation/atomic_cell.cc
@@ -9,7 +9,7 @@
 #include "atomic_cell.hh"
 #include "atomic_cell_or_collection.hh"
 #include "counters.hh"
-#include "types/types.hh"
+#include "types.hh"

 atomic_cell atomic_cell::make_dead(api::timestamp_type timestamp, gc_clock::time_point deletion_time) {
    return atomic_cell_type::make_dead(timestamp, deletion_time);
@@ -194,13 +194,14 @@ operator<<(std::ostream& os, const atomic_cell_view::printer& acvp) {
        std::ostringstream cell_value_string_builder;
        if (type.is_counter()) {
            if (acv.is_counter_update()) {
-                fmt::print(cell_value_string_builder, "counter_update_value={}", acv.counter_update_value());
+                cell_value_string_builder << "counter_update_value=" << acv.counter_update_value();
            } else {
+                cell_value_string_builder << "shards: ";
                auto ccv = counter_cell_view(acv);
-                fmt::print(cell_value_string_builder, "shards: {}", fmt::join(ccv.shards(), ", "));
+                cell_value_string_builder << ::join(", ", ccv.shards());
            }
        } else {
-            fmt::print(cell_value_string_builder, "{}", type.to_string(to_bytes(acv.value())));
+            cell_value_string_builder << type.to_string(to_bytes(acv.value()));
        }
        fmt::print(os, "atomic_cell{{{},ts={:d},expiry={:d},ttl={:d}}}",
            cell_value_string_builder.str(),
--- a/mutation/atomic_cell.hh
+++ b/mutation/atomic_cell.hh
@@ -10,7 +10,7 @@

 #include "bytes.hh"
 #include "timestamp.hh"
-#include "mutation/tombstone.hh"
+#include "tombstone.hh"
 #include "gc_clock.hh"
 #include "utils/managed_bytes.hh"
 #include <seastar/net//byteorder.hh>
--- a/mutation/atomic_cell_hash.hh
+++ b/mutation/atomic_cell_hash.hh
@@ -10,11 +10,11 @@

 // Not part of atomic_cell.hh to avoid cyclic dependency between types.hh and atomic_cell.hh

-#include "types/types.hh"
+#include "types.hh"
 #include "types/collection.hh"
 #include "atomic_cell.hh"
 #include "atomic_cell_or_collection.hh"
-#include "utils/hashing.hh"
+#include "hashing.hh"
 #include "counters.hh"

 template<>
--- a/mutation/atomic_cell_or_collection.hh
+++ b/mutation/atomic_cell_or_collection.hh
@@ -10,7 +10,7 @@

 #include "atomic_cell.hh"
 #include "collection_mutation.hh"
-#include "schema/schema.hh"
+#include "schema.hh"

 // A variant type that can hold either an atomic_cell, or a serialized collection.
 // Which type is stored is determined by the schema.
--- a/auth/CMakeLists.txt
+++ b/auth/CMakeLists.txt
@@ -1,35 +0,0 @@
-include(add_whole_archive)
-
-add_library(scylla_auth STATIC)
-target_sources(scylla_auth
-  PRIVATE
-    allow_all_authenticator.cc
-    allow_all_authorizer.cc
-    authenticated_user.cc
-    authenticator.cc
-    common.cc
-    default_authorizer.cc
-    password_authenticator.cc
-    passwords.cc
-    permission.cc
-    permissions_cache.cc
-    resource.cc
-    role_or_anonymous.cc
-    roles-metadata.cc
-    sasl_challenge.cc
-    service.cc
-    standard_role_manager.cc
-    transitional.cc)
-target_include_directories(scylla_auth
-  PUBLIC
-    ${CMAKE_SOURCE_DIR})
-target_link_libraries(scylla_auth
-  PUBLIC
-    Seastar::seastar
-    xxHash::xxhash
-  PRIVATE
-    cql3
-    idl
-    wasmtime_bindings)
-
-add_whole_archive(auth scylla_auth)
--- a/auth/authenticated_user.cc
+++ b/auth/authenticated_user.cc
@@ -10,12 +10,24 @@

 #include "auth/authenticated_user.hh"

+#include <iostream>
+
 namespace auth {

 authenticated_user::authenticated_user(std::string_view name)
        : name(sstring(name)) {
 }

+std::ostream& operator<<(std::ostream& os, const authenticated_user& u) {
+    if (!u.name) {
+        os << "anonymous";
+    } else {
+        os << *u.name;
+    }
+
+    return os;
+}
+
 static const authenticated_user the_anonymous_user{};

 const authenticated_user& anonymous_user() noexcept {
--- a/auth/authenticated_user.hh
+++ b/auth/authenticated_user.hh
@@ -12,6 +12,7 @@

 #include <string_view>
 #include <functional>
+#include <iosfwd>
 #include <optional>

 #include <seastar/core/sstring.hh>
@@ -37,6 +38,11 @@ public:
    explicit authenticated_user(std::string_view name);
 };

+///
+/// The user name, or "anonymous".
+///
+std::ostream& operator<<(std::ostream&, const authenticated_user&);
+
 inline bool operator==(const authenticated_user& u1, const authenticated_user& u2) noexcept {
    return u1.name == u2.name;
 }
@@ -53,21 +59,6 @@ inline bool is_anonymous(const authenticated_user& u) noexcept {

 }

-///
-/// The user name, or "anonymous".
-///
-template <>
-struct fmt::formatter<auth::authenticated_user> : fmt::formatter<std::string_view> {
-    template <typename FormatContext>
-    auto format(const auth::authenticated_user& u, FormatContext& ctx) const {
-        if (u.name) {
-            return fmt::format_to(ctx.out(), "{}", *u.name);
-        } else {
-            return fmt::format_to(ctx.out(), "{}", "anonymous");
-        }
-    }
-};
-
 namespace std {

 template <>
--- a/auth/authentication_options.cc
+++ b/auth/authentication_options.cc
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2018-present ScyllaDB
+ */
+
+/*
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+#include "auth/authentication_options.hh"
+
+#include <iostream>
+
+namespace auth {
+
+std::ostream& operator<<(std::ostream& os, authentication_option a) {
+    switch (a) {
+        case authentication_option::password: os << "PASSWORD"; break;
+        case authentication_option::options: os << "OPTIONS"; break;
+    }
+
+    return os;
+}
+
+}
--- a/auth/authentication_options.hh
+++ b/auth/authentication_options.hh
@@ -26,6 +26,8 @@ enum class authentication_option {
    options
 };

+std::ostream& operator<<(std::ostream&, authentication_option);
+
 using authentication_option_set = std::unordered_set<authentication_option>;

 using custom_options = std::unordered_map<sstring, sstring>;
@@ -47,18 +49,3 @@ public:
 };

 }
-
-template <>
-struct fmt::formatter<auth::authentication_option> : fmt::formatter<std::string_view> {
-    template <typename FormatContext>
-    auto format(const auth::authentication_option a, FormatContext& ctx) const {
-        using enum auth::authentication_option;
-        switch (a) {
-        case password:
-            return formatter<std::string_view>::format("PASSWORD", ctx);
-        case options:
-            return formatter<std::string_view>::format("OPTIONS", ctx);
-        }
-        std::abort();
-    }
-};
--- a/auth/common.cc
+++ b/auth/common.cc
@@ -14,7 +14,7 @@
 #include "cql3/query_processor.hh"
 #include "cql3/statements/create_table_statement.hh"
 #include "replica/database.hh"
-#include "schema/schema_builder.hh"
+#include "schema_builder.hh"
 #include "service/migration_manager.hh"
 #include "timeout_config.hh"

--- a/auth/common.hh
+++ b/auth/common.hh
@@ -30,6 +30,8 @@ namespace replica {
 class database;
 }

+class timeout_config;
+
 namespace service {
 class migration_manager;
 }
--- a/auth/default_authorizer.cc
+++ b/auth/default_authorizer.cc
@@ -74,7 +74,7 @@ future<bool> default_authorizer::any_granted() const {
            query,
            db::consistency_level::LOCAL_ONE,
            {},
-            cql3::query_processor::cache_internal::yes).then([](::shared_ptr<cql3::untyped_result_set> results) {
+            cql3::query_processor::cache_internal::yes).then([this](::shared_ptr<cql3::untyped_result_set> results) {
        return !results->empty();
    });
 }
--- a/auth/passwords.cc
+++ b/auth/passwords.cc
@@ -18,7 +18,7 @@ extern "C" {

 namespace auth::passwords {

-static thread_local crypt_data tlcrypt = {};
+static thread_local crypt_data tlcrypt = { 0, };

 namespace detail {

--- a/auth/permission.cc
+++ b/auth/permission.cc
@@ -21,8 +21,7 @@ const auth::permission_set auth::permissions::ALL = auth::permission_set::of<
        auth::permission::SELECT,
        auth::permission::MODIFY,
        auth::permission::AUTHORIZE,
-        auth::permission::DESCRIBE,
-        auth::permission::EXECUTE>();
+        auth::permission::DESCRIBE>();

 const auth::permission_set auth::permissions::NONE;

@@ -35,8 +34,7 @@ static const std::unordered_map<sstring, auth::permission> permission_names({
        {"SELECT", auth::permission::SELECT},
        {"MODIFY", auth::permission::MODIFY},
        {"AUTHORIZE", auth::permission::AUTHORIZE},
-        {"DESCRIBE", auth::permission::DESCRIBE},
-        {"EXECUTE", auth::permission::EXECUTE}});
+        {"DESCRIBE", auth::permission::DESCRIBE}});

 const sstring& auth::permissions::to_string(permission p) {
    for (auto& v : permission_names) {
--- a/auth/permission.hh
+++ b/auth/permission.hh
@@ -38,8 +38,6 @@ enum class permission {
    AUTHORIZE, // required for GRANT and REVOKE.
    DESCRIBE, // required on the root-level role resource to list all roles.

-    // function/aggregate/procedure calls
-    EXECUTE,
 };

 typedef enum_set<
@@ -53,8 +51,7 @@ typedef enum_set<
                permission::SELECT,
                permission::MODIFY,
                permission::AUTHORIZE,
-                permission::DESCRIBE,
-                permission::EXECUTE>> permission_set;
+                permission::DESCRIBE>> permission_set;

 bool operator<(const permission_set&, const permission_set&);

--- a/auth/resource.cc
+++ b/auth/resource.cc
@@ -16,26 +16,30 @@

 #include <boost/algorithm/string/join.hpp>
 #include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/classification.hpp>

 #include "service/storage_proxy.hh"
-#include "data_dictionary/user_types_metadata.hh"
-#include "cql3/util.hh"
-#include "db/marshal/type_parser.hh"

 namespace auth {

+std::ostream& operator<<(std::ostream& os, resource_kind kind) {
+    switch (kind) {
+        case resource_kind::data: os << "data"; break;
+        case resource_kind::role: os << "role"; break;
+        case resource_kind::service_level: os << "service_level"; break;
+    }
+
+    return os;
+}
+
 static const std::unordered_map<resource_kind, std::string_view> roots{
        {resource_kind::data, "data"},
        {resource_kind::role, "roles"},
-        {resource_kind::service_level, "service_levels"},
-        {resource_kind::functions, "functions"}};
+        {resource_kind::service_level, "service_levels"}};

 static const std::unordered_map<resource_kind, std::size_t> max_parts{
        {resource_kind::data, 2},
        {resource_kind::role, 1},
-        {resource_kind::service_level, 0},
-        {resource_kind::functions, 2}};
+        {resource_kind::service_level, 0}};

 static permission_set applicable_permissions(const data_resource_view& dv) {
    if (dv.table()) {
@@ -78,15 +82,6 @@ static permission_set applicable_permissions(const service_level_resource_view &
            permission::AUTHORIZE>();
 }

-static permission_set applicable_permissions(const functions_resource_view& fv) {
-    return permission_set::of<
-            permission::CREATE,
-            permission::ALTER,
-            permission::DROP,
-            permission::AUTHORIZE,
-            permission::EXECUTE>();
-}
-
 resource::resource(resource_kind kind) : _kind(kind) {
    _parts.emplace_back(roots.at(kind));
 }
@@ -111,31 +106,6 @@ resource::resource(role_resource_t, std::string_view role) : resource(resource_k
 resource::resource(service_level_resource_t): resource(resource_kind::service_level) {
 }

-resource::resource(functions_resource_t) : resource(resource_kind::functions) {
-}
-
-resource::resource(functions_resource_t, std::string_view keyspace) : resource(resource_kind::functions) {
-    _parts.emplace_back(keyspace);
-}
-
-resource::resource(functions_resource_t, std::string_view keyspace, std::string_view function_signature) : resource(resource_kind::functions) {
-    _parts.emplace_back(keyspace);
-    _parts.emplace_back(function_signature);
-}
-
-resource::resource(functions_resource_t, std::string_view keyspace, std::string_view function_name, std::vector<::shared_ptr<cql3::cql3_type::raw>> function_args) : resource(resource_kind::functions) {
-    _parts.emplace_back(keyspace);
-    _parts.emplace_back(function_name);
-    if (function_args.empty()) {
-        _parts.emplace_back("");
-        return;
-    }
-    for (auto& arg_type : function_args) {
-        // We can't validate the UDTs here, so we just use the raw cql type names.
-        _parts.emplace_back(arg_type->to_string());
-    }
-}
-
 sstring resource::name() const {
    return boost::algorithm::join(_parts, "/");
 }
@@ -157,7 +127,6 @@ permission_set resource::applicable_permissions() const {
        case resource_kind::data: ps = ::auth::applicable_permissions(data_resource_view(*this)); break;
        case resource_kind::role: ps = ::auth::applicable_permissions(role_resource_view(*this)); break;
        case resource_kind::service_level: ps = ::auth::applicable_permissions(service_level_resource_view(*this)); break;
-        case resource_kind::functions: ps = ::auth::applicable_permissions(functions_resource_view(*this)); break;
    }

    return ps;
@@ -180,7 +149,6 @@ std::ostream& operator<<(std::ostream& os, const resource& r) {
        case resource_kind::data: return os << data_resource_view(r);
        case resource_kind::role: return os << role_resource_view(r);
        case resource_kind::service_level: return os << service_level_resource_view(r);
-        case resource_kind::functions: return os << functions_resource_view(r);
    }

    return os;
@@ -197,109 +165,6 @@ std::ostream &operator<<(std::ostream &os, const service_level_resource_view &v)
    return os;
 }

-sstring encode_signature(std::string_view name, std::vector<data_type> args) {
-    return format("{}[{}]", name,
-            fmt::join(args | boost::adaptors::transformed([] (const data_type t) {
-                return t->name();
-            }), "^"));
-}
-
-std::pair<sstring, std::vector<data_type>> decode_signature(std::string_view encoded_signature) {
-    auto name_delim = encoded_signature.find_last_of('[');
-    std::string_view function_name = encoded_signature.substr(0, name_delim);
-    encoded_signature.remove_prefix(name_delim + 1);
-    encoded_signature.remove_suffix(1);
-    if (encoded_signature.empty()) {
-        return {sstring(function_name), {}};
-    }
-    std::vector<std::string_view> raw_types;
-    boost::split(raw_types, encoded_signature, boost::is_any_of("^"));
-    std::vector<data_type> decoded_types = boost::copy_range<std::vector<data_type>>(
-        raw_types | boost::adaptors::transformed([] (std::string_view raw_type) {
-            return db::marshal::type_parser::parse(raw_type);
-        })
-    );
-    return {sstring(function_name), decoded_types};
-}
-
-// Purely for Cassandra compatibility, types in the function signature are
-// decoded from their verbose form (org.apache.cassandra.db.marshal.Int32Type)
-// to the short form (int)
-static sstring decoded_signature_string(std::string_view encoded_signature) {
-    auto [function_name, arg_types] = decode_signature(encoded_signature);
-    return format("{}({})", cql3::util::maybe_quote(sstring(function_name)),
-            boost::algorithm::join(arg_types | boost::adaptors::transformed([] (data_type t) {
-                return t->cql3_type_name();
-            }), ", "));
-}
-
-std::ostream &operator<<(std::ostream &os, const functions_resource_view &v) {
-    const auto keyspace = v.keyspace();
-    const auto function_signature = v.function_signature();
-    const auto name = v.function_name();
-    const auto args = v.function_args();
-
-    if (!keyspace) {
-        os << "<all functions>";
-    } else if (name) {
-        os << "<function " << *keyspace << '.' << cql3::util::maybe_quote(sstring(*name)) << '(';
-        for (auto arg : *args) {
-            os << arg << ',';
-        }
-        os << ")>";
-    } else if (!function_signature) {
-        os << "<all functions in " << *keyspace << '>';
-    } else {
-        os << "<function " << *keyspace << '.' << decoded_signature_string(*function_signature) << '>';
-    }
-    return os;
-}
-
-functions_resource_view::functions_resource_view(const resource& r) : _resource(r) {
-    if (r._kind != resource_kind::functions) {
-        throw resource_kind_mismatch(resource_kind::functions, r._kind);
-    }
-}
-
-std::optional<std::string_view> functions_resource_view::keyspace() const {
-    if (_resource._parts.size() == 1) {
-        return {};
-    }
-
-    return _resource._parts[1];
-}
-
-std::optional<std::string_view> functions_resource_view::function_signature() const {
-    if (_resource._parts.size() <= 2 || _resource._parts.size() > 3) {
-        return {};
-    }
-
-    return _resource._parts[2];
-}
-
-std::optional<std::string_view> functions_resource_view::function_name() const {
-    if (_resource._parts.size() <= 3) {
-        return {};
-    }
-
-    return _resource._parts[2];
-}
-
-std::optional<std::vector<std::string_view>> functions_resource_view::function_args() const {
-    if (_resource._parts.size() <= 3) {
-        return {};
-    }
-
-    std::vector<std::string_view> parts;
-    if (_resource._parts[3] == "") {
-        return {};
-    }
-    for (size_t i = 3; i < _resource._parts.size(); i++) {
-        parts.push_back(_resource._parts[i]);
-    }
-    return parts;
-}
-
 data_resource_view::data_resource_view(const resource& r) : _resource(r) {
    if (r._kind != resource_kind::data) {
        throw resource_kind_mismatch(resource_kind::data, r._kind);
--- a/auth/resource.hh
+++ b/auth/resource.hh
@@ -18,7 +18,6 @@
 #include <vector>
 #include <unordered_set>

-#include <boost/range/adaptor/transformed.hpp>
 #include <seastar/core/print.hh>
 #include <seastar/core/sstring.hh>

@@ -26,7 +25,6 @@
 #include "seastarx.hh"
 #include "utils/hash.hh"
 #include "utils/small_vector.hh"
-#include "cql3/cql3_type.hh"

 namespace auth {

@@ -38,9 +36,11 @@ public:
 };

 enum class resource_kind {
-    data, role, service_level, functions
+    data, role, service_level
 };

+std::ostream& operator<<(std::ostream&, resource_kind);
+
 ///
 /// Type tag for constructing data resources.
 ///
@@ -56,15 +56,10 @@ struct role_resource_t final {};
 ///
 struct service_level_resource_t final {};

-///
-/// Type tag for constructing function resources.
-///
-struct functions_resource_t final {};
-
 ///
 /// Resources are entities that users can be granted permissions on.
 ///
-/// There are data (keyspaces and tables), role and function resources. There may be other kinds of resources in the future.
+/// There are data (keyspaces and tables) and role resources. There may be other kinds of resources in the future.
 ///
 /// When they are stored as system metadata, resources have the form `root/part_0/part_1/.../part_n`. Each kind of
 /// resource has a specific root prefix, followed by a maximum of `n` parts (where `n` is distinct for each kind of
@@ -88,11 +83,6 @@ public:
    resource(data_resource_t, std::string_view keyspace, std::string_view table);
    resource(role_resource_t, std::string_view role);
    resource(service_level_resource_t);
-    explicit resource(functions_resource_t);
-    resource(functions_resource_t, std::string_view keyspace);
-    resource(functions_resource_t, std::string_view keyspace, std::string_view function_signature);
-    resource(functions_resource_t, std::string_view keyspace, std::string_view function_name,
-            std::vector<::shared_ptr<cql3::cql3_type::raw>> function_args);

    resource_kind kind() const noexcept {
        return _kind;
@@ -114,7 +104,6 @@ private:
    friend class data_resource_view;
    friend class role_resource_view;
    friend class service_level_resource_view;
-    friend class functions_resource_view;

    friend bool operator<(const resource&, const resource&);
    friend bool operator==(const resource&, const resource&);
@@ -193,25 +182,6 @@ public:

 std::ostream& operator<<(std::ostream&, const service_level_resource_view&);

-///
-/// A "function" view of \ref resource.
-///
-class functions_resource_view final {
-    const resource& _resource;
-public:
-    ///
-    /// \throws \ref resource_kind_mismatch if the argument is not a "function" resource.
-    ///
-    explicit functions_resource_view(const resource&);
-
-    std::optional<std::string_view> keyspace() const;
-    std::optional<std::string_view> function_signature() const;
-    std::optional<std::string_view> function_name() const;
-    std::optional<std::vector<std::string_view>> function_args() const;
-};
-
-std::ostream& operator<<(std::ostream&, const functions_resource_view&);
-
 ///
 /// Parse a resource from its name.
 ///
@@ -240,49 +210,8 @@ inline resource make_service_level_resource() {
    return resource(service_level_resource_t{});
 }

-const resource& root_function_resource();
-
-inline resource make_functions_resource() {
-    return resource(functions_resource_t{});
 }

-inline resource make_functions_resource(std::string_view keyspace) {
-    return resource(functions_resource_t{}, keyspace);
-}
-
-inline resource make_functions_resource(std::string_view keyspace, std::string_view function_signature) {
-    return resource(functions_resource_t{}, keyspace, function_signature);
-}
-
-inline resource make_functions_resource(std::string_view keyspace, std::string_view function_name, std::vector<::shared_ptr<cql3::cql3_type::raw>> function_signature) {
-    return resource(functions_resource_t{}, keyspace, function_name, function_signature);
-}
-
-sstring encode_signature(std::string_view name, std::vector<data_type> args);
-
-std::pair<sstring, std::vector<data_type>> decode_signature(std::string_view encoded_signature);
-
-}
-
-template <>
-struct fmt::formatter<auth::resource_kind> : fmt::formatter<std::string_view> {
-    template <typename FormatContext>
-    auto format(const auth::resource_kind kind, FormatContext& ctx) const {
-        using enum auth::resource_kind;
-        switch (kind) {
-        case data:
-            return formatter<std::string_view>::format("data", ctx);
-        case role:
-            return formatter<std::string_view>::format("role", ctx);
-        case service_level:
-            return formatter<std::string_view>::format("service_level", ctx);
-        case functions:
-            return formatter<std::string_view>::format("functions", ctx);
-        }
-        std::abort();
-    }
-};
-
 namespace std {

 template <>
@@ -299,10 +228,6 @@ struct hash<auth::resource> {
            return utils::tuple_hash()(std::make_tuple(auth::resource_kind::service_level));
    }

-    static size_t hash_function(const auth::functions_resource_view& fv) {
-        return utils::tuple_hash()(std::make_tuple(auth::resource_kind::functions, fv.keyspace(), fv.function_signature()));
-    }
-
    size_t operator()(const auth::resource& r) const {
        std::size_t value;

@@ -310,7 +235,6 @@ struct hash<auth::resource> {
        case auth::resource_kind::data: value = hash_data(auth::data_resource_view(r)); break;
        case auth::resource_kind::role: value = hash_role(auth::role_resource_view(r)); break;
        case auth::resource_kind::service_level: value = hash_service_level(auth::service_level_resource_view(r)); break;
-        case auth::resource_kind::functions: value = hash_function(auth::functions_resource_view(r)); break;
        }

        return value;
--- a/auth/roles-metadata.cc
+++ b/auth/roles-metadata.cc
@@ -55,6 +55,7 @@ future<bool> default_role_row_satisfies(
        return qp.execute_internal(
                query,
                db::consistency_level::ONE,
+                internal_distributed_query_state(),
                {meta::DEFAULT_SUPERUSER_NAME},
                cql3::query_processor::cache_internal::yes).then([&qp, &p](::shared_ptr<cql3::untyped_result_set> results) {
            if (results->empty()) {
--- a/auth/service.cc
+++ b/auth/service.cc
@@ -20,19 +20,17 @@
 #include "auth/allow_all_authorizer.hh"
 #include "auth/common.hh"
 #include "auth/role_or_anonymous.hh"
-#include "cql3/functions/functions.hh"
 #include "cql3/query_processor.hh"
 #include "cql3/untyped_result_set.hh"
 #include "db/config.hh"
 #include "db/consistency_level_type.hh"
-#include "db/functions/function_name.hh"
 #include "exceptions/exceptions.hh"
 #include "log.hh"
 #include "service/migration_manager.hh"
 #include "utils/class_registrator.hh"
 #include "locator/abstract_replication_strategy.hh"
 #include "data_dictionary/keyspace_metadata.hh"
-#include "mutation/mutation.hh"
+#include "mutation.hh"

 namespace auth {

@@ -348,22 +346,6 @@ future<bool> service::exists(const resource& r) const {
        }
        case resource_kind::service_level:
            return make_ready_future<bool>(true);
-
-        case resource_kind::functions: {
-            const auto& db = _qp.db();
-
-            functions_resource_view v(r);
-            const auto keyspace = v.keyspace();
-            if (!keyspace) {
-                return make_ready_future<bool>(true);
-            }
-            const auto function_signature = v.function_signature();
-            if (!function_signature) {
-                return make_ready_future<bool>(db.has_keyspace(sstring(*keyspace)));
-            }
-            auto [name, function_args] = auth::decode_signature(*function_signature);
-            return make_ready_future<bool>(cql3::functions::functions::find(db::functions::function_name{sstring(*keyspace), name}, function_args));
-        }
    }

    return make_ready_future<bool>(false);
--- a/auth/standard_role_manager.cc
+++ b/auth/standard_role_manager.cc
@@ -470,7 +470,7 @@ standard_role_manager::grant(std::string_view grantee_name, std::string_view rol

 future<>
 standard_role_manager::revoke(std::string_view revokee_name, std::string_view role_name) {
-    return this->exists(role_name).then([role_name](bool role_exists) {
+    return this->exists(role_name).then([this, revokee_name, role_name](bool role_exists) {
        if (!role_exists) {
            throw nonexistant_role(sstring(role_name));
        }
--- a/build_mode.hh
+++ b/build_mode.hh
@@ -14,7 +14,7 @@
 #endif

 #ifndef STRINGIFY
-// We need two levels of indirection
+// We need to levels of indirection
 // to make a string out of the macro name.
 // The outer level expands the macro
 // and the inner level makes a string out of the expanded macro.
--- a/bytes.cc
+++ b/bytes.cc
@@ -50,7 +50,15 @@ bytes from_hex(sstring_view s) {
 }

 sstring to_hex(bytes_view b) {
-    return fmt::to_string(fmt_hex(b));
+    static char digits[] = "0123456789abcdef";
+    sstring out = uninitialized_string(b.size() * 2);
+    unsigned end = b.size();
+    for (unsigned i = 0; i != end; ++i) {
+        uint8_t x = b[i];
+        out[2*i] = digits[x >> 4];
+        out[2*i+1] = digits[x & 0xf];
+    }
+    return out;
 }

 sstring to_hex(const bytes& b) {
@@ -62,14 +70,12 @@ sstring to_hex(const bytes_opt& b) {
 }

 std::ostream& operator<<(std::ostream& os, const bytes& b) {
-    fmt::print(os, "{}", b);
-    return os;
+    return os << to_hex(b);
 }

 std::ostream& operator<<(std::ostream& os, const bytes_opt& b) {
    if (b) {
-        fmt::print(os, "{}", *b);
-        return os;
+        return os << *b;
    }
    return os << "null";
 }
@@ -77,13 +83,11 @@ std::ostream& operator<<(std::ostream& os, const bytes_opt& b) {
 namespace std {

 std::ostream& operator<<(std::ostream& os, const bytes_view& b) {
-    fmt::print(os, "{}", fmt_hex(b));
-    return os;
+    return os << to_hex(b);
 }

 }

 std::ostream& operator<<(std::ostream& os, const fmt_hex& b) {
-    fmt::print(os, "{}", b);
-    return os;
+    return os << to_hex(b.v);
 }
--- a/bytes.hh
+++ b/bytes.hh
@@ -9,9 +9,8 @@
 #pragma once

 #include "seastarx.hh"
-#include <fmt/format.h>
 #include <seastar/core/sstring.hh>
-#include "utils/hashing.hh"
+#include "hashing.hh"
 #include <optional>
 #include <iosfwd>
 #include <functional>
@@ -38,8 +37,8 @@ inline bytes_view to_bytes_view(sstring_view view) {
 }

 struct fmt_hex {
-    const bytes_view& v;
-    fmt_hex(const bytes_view& v) noexcept : v(v) {}
+    bytes_view& v;
+    fmt_hex(bytes_view& v) noexcept : v(v) {}
 };

 std::ostream& operator<<(std::ostream& os, const fmt_hex& hex);
@@ -52,89 +51,6 @@ sstring to_hex(const bytes_opt& b);
 std::ostream& operator<<(std::ostream& os, const bytes& b);
 std::ostream& operator<<(std::ostream& os, const bytes_opt& b);

-template <>
-struct fmt::formatter<fmt_hex> {
-    size_t _group_size_in_bytes = 0;
-    char _delimiter = ' ';
-public:
-    // format_spec := [group_size[delimeter]]
-    // group_size := a char from '0' to '9'
-    // delimeter := a char other than '{'  or '}'
-    //
-    // by default, the given bytes are printed without delimeter, just
-    // like a string. so a string view of {0x20, 0x01, 0x0d, 0xb8} is
-    // printed like:
-    // "20010db8".
-    //
-    // but the format specifier can be used to customize how the bytes
-    // are printed. for instance, to print an bytes_view like IPv6. so
-    // the format specfier would be "{:2:}", where
-    // - "2": bytes are printed in groups of 2 bytes
-    // - ":": each group is delimeted by ":"
-    // and the formatted output will look like:
-    // "2001:0db8:0000"
-    //
-    // or we can mimic how the default format of used by hexdump using
-    // "{:2 }", where
-    // - "2": bytes are printed in group of 2 bytes
-    // - " ": each group is delimeted by " "
-    // and the formatted output will look like:
-    // "2001 0db8 0000"
-    //
-    // or we can just print each bytes and separate them by a dash using
-    // "{:1-}"
-    // and the formatted output will look like:
-    // "20-01-0b-b8-00-00"
-    constexpr auto parse(fmt::format_parse_context& ctx) {
-        // get the delimeter if any
-        auto it = ctx.begin();
-        auto end = ctx.end();
-        if (it != end) {
-            int group_size = *it++ - '0';
-            if (group_size < 0 ||
-                static_cast<size_t>(group_size) > sizeof(uint64_t)) {
-                throw format_error("invalid group_size");
-            }
-            _group_size_in_bytes = group_size;
-            if (it != end) {
-                // optional delimiter
-                _delimiter = *it++;
-            }
-        }
-        if (it != end && *it != '}') {
-            throw format_error("invalid format");
-        }
-        return it;
-    }
-    template <typename FormatContext>
-    auto format(const ::fmt_hex& s, FormatContext& ctx) const {
-        auto out = ctx.out();
-        const auto& v = s.v;
-        if (_group_size_in_bytes > 0) {
-            for (size_t i = 0, size = v.size(); i < size; i++) {
-                if (i != 0 && i % _group_size_in_bytes == 0) {
-                    fmt::format_to(out, "{}{:02x}", _delimiter, std::byte(v[i]));
-                } else {
-                    fmt::format_to(out, "{:02x}", std::byte(v[i]));
-                }
-            }
-        } else {
-            for (auto b : v) {
-                fmt::format_to(out, "{:02x}", std::byte(b));
-            }
-        }
-        return out;
-    }
-};
-
-template <>
-struct fmt::formatter<bytes> : fmt::formatter<fmt_hex> {
-    template <typename FormatContext>
-    auto format(const ::bytes& s, FormatContext& ctx) const {
-        return fmt::formatter<::fmt_hex>::format(::fmt_hex(bytes_view(s)), ctx);
-    }
-};
-
 namespace std {

 // Must be in std:: namespace, or ADL fails
--- a/bytes_ostream.hh
+++ b/bytes_ostream.hh
@@ -12,7 +12,7 @@

 #include "bytes.hh"
 #include "utils/managed_bytes.hh"
-#include "utils/hashing.hh"
+#include "hashing.hh"
 #include <seastar/core/simple-stream.hh>
 #include <seastar/core/loop.hh>
 #include <bit>
--- a/cache_flat_mutation_reader.hh
+++ b/cache_flat_mutation_reader.hh
@@ -10,10 +10,10 @@

 #include <vector>
 #include "row_cache.hh"
-#include "mutation/mutation_fragment.hh"
+#include "mutation_fragment.hh"
 #include "query-request.hh"
 #include "partition_snapshot_row_cursor.hh"
-#include "mutation/range_tombstone_assembler.hh"
+#include "range_tombstone_assembler.hh"
 #include "read_context.hh"
 #include "readers/delegating_v2.hh"
 #include "clustering_key_filter.hh"
@@ -41,7 +41,7 @@ class cache_flat_mutation_reader final : public flat_mutation_reader_v2::impl {
        move_to_underlying,

        // Invariants:
-        // - Upper bound of the read is *_underlying_upper_bound
+        // - Upper bound of the read is min(_next_row.position(), _upper_bound)
        // - _next_row_in_range = _next.position() < _upper_bound
        // - _last_row points at a direct predecessor of the next row which is going to be read.
        //   Used for populating continuity.
@@ -51,6 +51,46 @@ class cache_flat_mutation_reader final : public flat_mutation_reader_v2::impl {

        end_of_stream
    };
+    enum class source {
+        cache = 0,
+        underlying = 1,
+    };
+    // Merges range tombstone change streams coming from underlying and the cache.
+    // Ensures no range tombstone change fragment is emitted when there is no
+    // actual change in the effective tombstone.
+    class range_tombstone_change_merger {
+        const schema& _schema;
+        position_in_partition _pos;
+        tombstone _current_tombstone;
+        std::array<tombstone, 2> _tombstones;
+    private:
+        std::optional<range_tombstone_change> do_flush(position_in_partition pos, bool end_of_range) {
+            std::optional<range_tombstone_change> ret;
+            position_in_partition::tri_compare cmp(_schema);
+            const auto res = cmp(_pos, pos);
+            const auto should_flush = end_of_range ? res <= 0 : res < 0;
+            if (should_flush) {
+                auto merged_tomb = std::max(_tombstones.front(), _tombstones.back());
+                if (merged_tomb != _current_tombstone) {
+                    _current_tombstone = merged_tomb;
+                    ret.emplace(_pos, _current_tombstone);
+                }
+                _pos = std::move(pos);
+            }
+            return ret;
+        }
+    public:
+        range_tombstone_change_merger(const schema& s) : _schema(s), _pos(position_in_partition::before_all_clustered_rows()), _tombstones{}
+        { }
+        std::optional<range_tombstone_change> apply(source src, range_tombstone_change&& rtc) {
+            auto ret = do_flush(rtc.position(), false);
+            _tombstones[static_cast<size_t>(src)] = rtc.tombstone();
+            return ret;
+        }
+        std::optional<range_tombstone_change> flush(position_in_partition_view pos, bool end_of_range) {
+            return do_flush(position_in_partition(pos), end_of_range);
+        }
+    };
    partition_snapshot_ptr _snp;

    query::clustering_key_filter_ranges _ck_ranges; // Query schema domain, reversed reads use native order
@@ -63,11 +103,8 @@ class cache_flat_mutation_reader final : public flat_mutation_reader_v2::impl {

    // Holds the lower bound of a position range which hasn't been processed yet.
    // Only rows with positions < _lower_bound have been emitted, and only
-    // range_tombstone_changes with positions <= _lower_bound.
-    //
-    // Invariant: !_lower_bound.is_clustering_row()
+    // range_tombstones with positions <= _lower_bound.
    position_in_partition _lower_bound; // Query schema domain
-    // Invariant: !_upper_bound.is_clustering_row()
    position_in_partition_view _upper_bound; // Query schema domain
    std::optional<position_in_partition> _underlying_upper_bound; // Query schema domain

@@ -84,19 +121,22 @@ class cache_flat_mutation_reader final : public flat_mutation_reader_v2::impl {
    read_context& _read_context;
    partition_snapshot_row_cursor _next_row;

-    // Holds the currently active range tombstone of the output mutation fragment stream.
-    // While producing the stream, at any given time, _current_tombstone applies to the
-    // key range which extends at least to _lower_bound. When consuming subsequent interval,
-    // which will advance _lower_bound further, be it from underlying or from cache,
-    // a decision is made whether the range tombstone in the next interval is the same as
-    // the current one or not. If it is different, then range_tombstone_change is emitted
-    // with the old _lower_bound value (start of the next interval).
-    tombstone _current_tombstone;
+    range_tombstone_change_generator _rt_gen; // cache -> reader
+    range_tombstone_assembler _rt_assembler; // underlying -> cache
+    range_tombstone_change_merger _rt_merger; // {cache, underlying} -> reader
+
+    // When the read moves to the underlying, the read range will be
+    // (_lower_bound, x], where x is either _next_row.position() or _upper_bound.
+    // In the former case (x is _next_row.position()), underlying can emit
+    // a range tombstone change for after_key(x), which is outside the range.
+    // We can't push this fragment into the buffer straight away, the cache may
+    // have fragments with smaller position. So we save it here and flush it when
+    // a fragment with a larger position is seen.
+    std::optional<mutation_fragment_v2> _queued_underlying_fragment;

    state _state = state::before_static_row;

    bool _next_row_in_range = false;
-    bool _has_rt = false;

    // True iff current population interval, since the previous clustering row, starts before all clustered rows.
    // We cannot just look at _lower_bound, because emission of range tombstones changes _lower_bound and
@@ -105,6 +145,11 @@ class cache_flat_mutation_reader final : public flat_mutation_reader_v2::impl {
    // Valid when _state == reading_from_underlying.
    bool _population_range_starts_before_all_rows;

+    // Whether _lower_bound was changed within current fill_buffer().
+    // If it did not then we cannot break out of it (e.g. on preemption) because
+    // forward progress is not guaranteed in case iterators are getting constantly invalidated.
+    bool _lower_bound_changed = false;
+
    // Points to the underlying reader conforming to _schema,
    // either to *_underlying_holder or _read_context.underlying().underlying().
    flat_mutation_reader_v2* _underlying = nullptr;
@@ -118,11 +163,14 @@ class cache_flat_mutation_reader final : public flat_mutation_reader_v2::impl {
    void move_to_next_range();
    void move_to_range(query::clustering_row_ranges::const_iterator);
    void move_to_next_entry();
-    void maybe_drop_last_entry(tombstone) noexcept;
+    void maybe_drop_last_entry() noexcept;
+    void flush_tombstones(position_in_partition_view, bool end_of_range = false);
    void add_to_buffer(const partition_snapshot_row_cursor&);
    void add_clustering_row_to_buffer(mutation_fragment_v2&&);
-    void add_to_buffer(range_tombstone_change&&);
-    void offer_from_underlying(mutation_fragment_v2&&);
+    void add_to_buffer(range_tombstone_change&&, source);
+    void do_add_to_buffer(range_tombstone_change&&);
+    void add_range_tombstone_to_buffer(range_tombstone&&);
+    void add_to_buffer(mutation_fragment_v2&&);
    future<> read_from_underlying();
    void start_reading_from_underlying();
    bool after_current_range(position_in_partition_view position);
@@ -141,7 +189,7 @@ class cache_flat_mutation_reader final : public flat_mutation_reader_v2::impl {
    bool ensure_population_lower_bound();
    void maybe_add_to_cache(const mutation_fragment_v2& mf);
    void maybe_add_to_cache(const clustering_row& cr);
-    bool maybe_add_to_cache(const range_tombstone_change& rtc);
+    void maybe_add_to_cache(const range_tombstone_change& rtc);
    void maybe_add_to_cache(const static_row& sr);
    void maybe_set_static_row_continuous();
    void finish_reader() {
@@ -196,6 +244,8 @@ public:
        , _read_context_holder()
        , _read_context(ctx)    // ctx is owned by the caller, who's responsible for closing it.
        , _next_row(*_schema, *_snp, false, _read_context.is_reversed())
+        , _rt_gen(*_schema)
+        , _rt_merger(*_schema)
    {
        clogger.trace("csm {}: table={}.{}, reversed={}, snap={}", fmt::ptr(this), _schema->ks_name(), _schema->cf_name(), _read_context.is_reversed(),
                      fmt::ptr(&*_snp));
@@ -323,31 +373,13 @@ future<> cache_flat_mutation_reader::do_fill_buffer() {
        }
        _state = state::reading_from_underlying;
        _population_range_starts_before_all_rows = _lower_bound.is_before_all_clustered_rows(*_schema) && !_read_context.is_reversed();
-        _underlying_upper_bound = _next_row_in_range ? position_in_partition::before_key(_next_row.position())
-                                                     : position_in_partition(_upper_bound);
        if (!_read_context.partition_exists()) {
-            clogger.trace("csm {}: partition does not exist", fmt::ptr(this));
-            if (_current_tombstone) {
-                clogger.trace("csm {}: move_to_underlying: emit rtc({}, null)", fmt::ptr(this), _lower_bound);
-                push_mutation_fragment(mutation_fragment_v2(*_schema, _permit, range_tombstone_change(_lower_bound, {})));
-                _current_tombstone = {};
-            }
            return read_from_underlying();
        }
+        _underlying_upper_bound = _next_row_in_range ? position_in_partition(_next_row.position())
+                                      : position_in_partition(_upper_bound);
        return _underlying->fast_forward_to(position_range{_lower_bound, *_underlying_upper_bound}).then([this] {
-            if (!_current_tombstone) {
-                return read_from_underlying();
-            }
-            return _underlying->peek().then([this] (mutation_fragment_v2* mf) {
-                position_in_partition::equal_compare eq(*_schema);
-                if (!mf || !mf->is_range_tombstone_change()
-                        || !eq(mf->as_range_tombstone_change().position(), _lower_bound)) {
-                    clogger.trace("csm {}: move_to_underlying: emit rtc({}, null)", fmt::ptr(this), _lower_bound);
-                    push_mutation_fragment(mutation_fragment_v2(*_schema, _permit, range_tombstone_change(_lower_bound, {})));
-                    _current_tombstone = {};
-                }
-                return read_from_underlying();
-            });
+            return read_from_underlying();
        });
    }
    if (_state == state::reading_from_underlying) {
@@ -356,8 +388,8 @@ future<> cache_flat_mutation_reader::do_fill_buffer() {
    // assert(_state == state::reading_from_cache)
    return _lsa_manager.run_in_read_section([this] {
        auto next_valid = _next_row.iterators_valid();
-        clogger.trace("csm {}: reading_from_cache, range=[{}, {}), next={}, valid={}, rt={}", fmt::ptr(this), _lower_bound,
-            _upper_bound, _next_row.position(), next_valid, _current_tombstone);
+        clogger.trace("csm {}: reading_from_cache, range=[{}, {}), next={}, valid={}", fmt::ptr(this), _lower_bound,
+            _upper_bound, _next_row.position(), next_valid);
        // We assume that if there was eviction, and thus the range may
        // no longer be continuous, the cursor was invalidated.
        if (!next_valid) {
@@ -371,9 +403,13 @@ future<> cache_flat_mutation_reader::do_fill_buffer() {
        }
        _next_row.maybe_refresh();
        clogger.trace("csm {}: next={}", fmt::ptr(this), _next_row);
+        _lower_bound_changed = false;
        while (_state == state::reading_from_cache) {
            copy_from_cache_to_buffer();
-            if (need_preempt() || is_buffer_full()) {
+            // We need to check _lower_bound_changed even if is_buffer_full() because
+            // we may have emitted only a range tombstone which overlapped with _lower_bound
+            // and thus didn't cause _lower_bound to change.
+            if ((need_preempt() || is_buffer_full()) && _lower_bound_changed) {
                break;
            }
        }
@@ -387,38 +423,37 @@ future<> cache_flat_mutation_reader::read_from_underlying() {
        [this] { return _state != state::reading_from_underlying || is_buffer_full(); },
        [this] (mutation_fragment_v2 mf) {
            _read_context.cache().on_row_miss();
-            offer_from_underlying(std::move(mf));
+            maybe_add_to_cache(mf);
+            add_to_buffer(std::move(mf));
        },
        [this] {
-            _lower_bound = std::move(*_underlying_upper_bound);
            _underlying_upper_bound.reset();
            _state = state::reading_from_cache;
            _lsa_manager.run_in_update_section([this] {
                auto same_pos = _next_row.maybe_refresh();
-                clogger.trace("csm {}: underlying done, in_range={}, same={}, next={}", fmt::ptr(this), _next_row_in_range, same_pos, _next_row);
                if (!same_pos) {
-                    _read_context.cache().on_mispopulate(); // FIXME: Insert dummy entry at _lower_bound.
+                    _read_context.cache().on_mispopulate(); // FIXME: Insert dummy entry at _upper_bound.
                    _next_row_in_range = !after_current_range(_next_row.position());
                    if (!_next_row.continuous()) {
-                        _last_row = nullptr; // We did not populate the full range up to _lower_bound, break continuity
                        start_reading_from_underlying();
                    }
                    return;
                }
                if (_next_row_in_range) {
                    maybe_update_continuity();
+                    if (!_next_row.dummy()) {
+                        _lower_bound = position_in_partition::before_key(_next_row.key());
+                    } else {
+                        _lower_bound = _next_row.position();
+                    }
                } else {
-                    if (can_populate()) {
+                    if (no_clustering_row_between(*_schema, _upper_bound, _next_row.position())) {
+                        this->maybe_update_continuity();
+                    } else if (can_populate()) {
                        const schema& table_s = table_schema();
                        rows_entry::tri_compare cmp(table_s);
                        auto& rows = _snp->version()->partition().mutable_clustered_rows();
                        if (query::is_single_row(*_schema, *_ck_ranges_curr)) {
-                            // If there are range tombstones which apply to the row then
-                            // we cannot insert an empty entry here because if those range
-                            // tombstones got evicted by now, we will insert an entry
-                            // with missing range tombstone information.
-                            // FIXME: try to set the range tombstone when possible.
-                            if (!_has_rt) {
                            with_allocator(_snp->region().allocator(), [&] {
                                auto e = alloc_strategy_unique_ptr<rows_entry>(
                                    current_allocator().construct<rows_entry>(_ck_ranges_curr->start()->value()));
@@ -431,10 +466,9 @@ future<> cache_flat_mutation_reader::read_from_underlying() {
                                    // Also works in reverse read mode.
                                    // It preserves the continuity of the range the entry falls into.
                                    it->set_continuous(next->continuous());
-                                    clogger.trace("csm {}: inserted empty row at {}, cont={}, rt={}", fmt::ptr(this), it->position(), it->continuous(), it->range_tombstone());
+                                    clogger.trace("csm {}: inserted empty row at {}, cont={}", fmt::ptr(this), it->position(), it->continuous());
                                }
                            });
-                            }
                        } else if (ensure_population_lower_bound()) {
                            with_allocator(_snp->region().allocator(), [&] {
                                auto e = alloc_strategy_unique_ptr<rows_entry>(
@@ -442,19 +476,17 @@ future<> cache_flat_mutation_reader::read_from_underlying() {
                                // Use _next_row iterator only as a hint, because there could be insertions after _upper_bound.
                                auto insert_result = rows.insert_before_hint(_next_row.get_iterator_in_latest_version(), std::move(e), cmp);
                                if (insert_result.second) {
-                                    clogger.trace("csm {}: L{}: inserted dummy at {}", fmt::ptr(this), __LINE__, _upper_bound);
+                                    clogger.trace("csm {}: inserted dummy at {}", fmt::ptr(this), _upper_bound);
                                    _snp->tracker()->insert(*insert_result.first);
                                }
                                if (_read_context.is_reversed()) [[unlikely]] {
-                                    clogger.trace("csm {}: set_continuous({}), prev={}, rt={}", fmt::ptr(this), _last_row.position(), insert_result.first->position(), _current_tombstone);
+                                    clogger.trace("csm {}: set_continuous({})", fmt::ptr(this), _last_row.position());
                                    _last_row->set_continuous(true);
-                                    _last_row->set_range_tombstone(_current_tombstone);
                                } else {
-                                    clogger.trace("csm {}: set_continuous({}), prev={}, rt={}", fmt::ptr(this), insert_result.first->position(), _last_row.position(), _current_tombstone);
+                                    clogger.trace("csm {}: set_continuous({})", fmt::ptr(this), insert_result.first->position());
                                    insert_result.first->set_continuous(true);
-                                    insert_result.first->set_range_tombstone(_current_tombstone);
                                }
-                                maybe_drop_last_entry(_current_tombstone);
+                                maybe_drop_last_entry();
                            });
                        }
                    } else {
@@ -483,103 +515,55 @@ bool cache_flat_mutation_reader::ensure_population_lower_bound() {
    // Continuity flag we will later set for the upper bound extends to the previous row in the same version,
    // so we need to ensure we have an entry in the latest version.
    if (!_last_row.is_in_latest_version()) {
-        rows_entry::tri_compare cmp(*_schema);
-        partition_snapshot_row_cursor cur(*_schema, *_snp, false, _read_context.is_reversed());
-
-        if (!cur.advance_to(_last_row.position())) {
-            return false;
-        }
-
-        if (cmp(cur.position(), _last_row.position()) != 0) {
-            return false;
-        }
-
-        auto res = with_allocator(_snp->region().allocator(), [&] {
-            return cur.ensure_entry_in_latest();
+        with_allocator(_snp->region().allocator(), [&] {
+            auto& rows = _snp->version()->partition().mutable_clustered_rows();
+            rows_entry::tri_compare cmp(table_schema());
+            // FIXME: Avoid the copy by inserting an incomplete clustering row
+            auto e = alloc_strategy_unique_ptr<rows_entry>(
+                current_allocator().construct<rows_entry>(table_schema(), *_last_row));
+            e->set_continuous(false);
+            auto insert_result = rows.insert_before_hint(rows.end(), std::move(e), cmp);
+            if (insert_result.second) {
+                auto it = insert_result.first;
+                clogger.trace("csm {}: inserted lower bound dummy at {}", fmt::ptr(this), it->position());
+                _snp->tracker()->insert(*it);
+            }
+            _last_row.set_latest(insert_result.first);
        });
-
-        _last_row.set_latest(res.it);
-        if (res.inserted) {
-            clogger.trace("csm {}: inserted lower bound dummy at {}", fmt::ptr(this), _last_row.position());
-        }
    }
-
    return true;
 }

 inline
 void cache_flat_mutation_reader::maybe_update_continuity() {
-    position_in_partition::equal_compare eq(*_schema);
-    if (can_populate()
-            && ensure_population_lower_bound()
-            && !eq(_last_row.position(), _next_row.position())) {
+    if (can_populate() && ensure_population_lower_bound()) {
        with_allocator(_snp->region().allocator(), [&] {
            rows_entry& e = _next_row.ensure_entry_in_latest().row;
-            auto& rows = _snp->version()->partition().mutable_clustered_rows();
-            const schema& table_s = table_schema();
-            rows_entry::tri_compare table_cmp(table_s);
-
            if (_read_context.is_reversed()) [[unlikely]] {
-                if (_current_tombstone != _last_row->range_tombstone() && !_last_row->dummy()) {
-                    with_allocator(_snp->region().allocator(), [&] {
-                        auto e2 = alloc_strategy_unique_ptr<rows_entry>(
-                                current_allocator().construct<rows_entry>(table_s,
-                                                                          position_in_partition_view::before_key(_last_row->position()),
-                                                                          is_dummy::yes,
-                                                                          is_continuous::yes));
-                        auto insert_result = rows.insert(std::move(e2), table_cmp);
-                        if (insert_result.second) {
-                            clogger.trace("csm {}: L{}: inserted dummy at {}", fmt::ptr(this), __LINE__, insert_result.first->position());
-                            _snp->tracker()->insert(*insert_result.first);
-                        }
-                        clogger.trace("csm {}: set_continuous({}), prev={}, rt={}", fmt::ptr(this), insert_result.first->position(),
-                                      _last_row.position(), _current_tombstone);
-                        insert_result.first->set_continuous(true);
-                        insert_result.first->set_range_tombstone(_current_tombstone);
-                        clogger.trace("csm {}: set_continuous({})", fmt::ptr(this), _last_row.position());
-                        _last_row->set_continuous(true);
-                    });
-                } else {
-                    clogger.trace("csm {}: set_continuous({}), rt={}", fmt::ptr(this), _last_row.position(), _current_tombstone);
-                    _last_row->set_continuous(true);
-                    _last_row->set_range_tombstone(_current_tombstone);
-                }
+                clogger.trace("csm {}: set_continuous({})", fmt::ptr(this), _last_row.position());
+                _last_row->set_continuous(true);
            } else {
-                if (_current_tombstone != e.range_tombstone() && !e.dummy()) {
-                    with_allocator(_snp->region().allocator(), [&] {
-                        auto e2 = alloc_strategy_unique_ptr<rows_entry>(
-                                current_allocator().construct<rows_entry>(table_s,
-                                                                          position_in_partition_view::before_key(e.position()),
-                                                                          is_dummy::yes,
-                                                                          is_continuous::yes));
-                        // Use _next_row iterator only as a hint because there could be insertions before
-                        // _next_row.get_iterator_in_latest_version(), either from concurrent reads,
-                        // from _next_row.ensure_entry_in_latest().
-                        auto insert_result = rows.insert_before_hint(_next_row.get_iterator_in_latest_version(), std::move(e2), table_cmp);
-                        if (insert_result.second) {
-                            clogger.trace("csm {}: L{}: inserted dummy at {}", fmt::ptr(this), __LINE__, insert_result.first->position());
-                            _snp->tracker()->insert(*insert_result.first);
-                        }
-                        clogger.trace("csm {}: set_continuous({}), prev={}, rt={}", fmt::ptr(this), insert_result.first->position(),
-                                      _last_row.position(), _current_tombstone);
-                        insert_result.first->set_continuous(true);
-                        insert_result.first->set_range_tombstone(_current_tombstone);
-                        clogger.trace("csm {}: set_continuous({})", fmt::ptr(this), e.position());
-                        e.set_continuous(true);
-                    });
-                } else {
-                    clogger.trace("csm {}: set_continuous({}), rt={}", fmt::ptr(this), e.position(), _current_tombstone);
-                    e.set_range_tombstone(_current_tombstone);
-                    e.set_continuous(true);
-                }
+                clogger.trace("csm {}: set_continuous({})", fmt::ptr(this), e.position());
+                e.set_continuous(true);
            }
-            maybe_drop_last_entry(_current_tombstone);
+            maybe_drop_last_entry();
        });
    } else {
        _read_context.cache().on_mispopulate();
    }
 }

+inline
+void cache_flat_mutation_reader::maybe_add_to_cache(const mutation_fragment_v2& mf) {
+    if (mf.is_range_tombstone_change()) {
+        maybe_add_to_cache(mf.as_range_tombstone_change());
+    } else {
+        assert(mf.is_clustering_row());
+        const clustering_row& cr = mf.as_clustering_row();
+        maybe_add_to_cache(cr);
+    }
+}
+
 inline
 void cache_flat_mutation_reader::maybe_add_to_cache(const clustering_row& cr) {
    if (!can_populate()) {
@@ -588,9 +572,16 @@ void cache_flat_mutation_reader::maybe_add_to_cache(const clustering_row& cr) {
        _read_context.cache().on_mispopulate();
        return;
    }
-    clogger.trace("csm {}: populate({}), rt={}", fmt::ptr(this), clustering_row::printer(*_schema, cr), _current_tombstone);
-    _lsa_manager.run_in_update_section_with_allocator([this, &cr] {
-        mutation_partition_v2& mp = _snp->version()->partition();
+    auto rt_opt = _rt_assembler.flush(*_schema, position_in_partition::after_key(*_schema, cr.key()));
+    clogger.trace("csm {}: populate({})", fmt::ptr(this), clustering_row::printer(*_schema, cr));
+    _lsa_manager.run_in_update_section_with_allocator([this, &cr, &rt_opt] {
+        mutation_partition& mp = _snp->version()->partition();
+
+        if (rt_opt) {
+            clogger.trace("csm {}: populate flushed rt({})", fmt::ptr(this), *rt_opt);
+            mp.mutable_row_tombstones().apply_monotonically(table_schema(), to_table_domain(range_tombstone(*rt_opt)));
+        }
+
        rows_entry::tri_compare cmp(table_schema());

        if (_read_context.digest_requested()) {
@@ -599,7 +590,6 @@ void cache_flat_mutation_reader::maybe_add_to_cache(const clustering_row& cr) {
        auto new_entry = alloc_strategy_unique_ptr<rows_entry>(
            current_allocator().construct<rows_entry>(table_schema(), cr.key(), cr.as_deletable_row()));
        new_entry->set_continuous(false);
-        new_entry->set_range_tombstone(_current_tombstone);
        auto it = _next_row.iterators_valid() ? _next_row.get_iterator_in_latest_version()
                                              : mp.clustered_rows().lower_bound(cr.key(), cmp);
        auto insert_result = mp.mutable_clustered_rows().insert_before_hint(it, std::move(new_entry), cmp);
@@ -613,14 +603,9 @@ void cache_flat_mutation_reader::maybe_add_to_cache(const clustering_row& cr) {
            if (_read_context.is_reversed()) [[unlikely]] {
                clogger.trace("csm {}: set_continuous({})", fmt::ptr(this), _last_row.position());
                _last_row->set_continuous(true);
-                // _current_tombstone must also apply to _last_row itself (if it's non-dummy)
-                // because otherwise there would be a rtc after it, either creating a different entry,
-                // or clearing _last_row if population did not happen.
-                _last_row->set_range_tombstone(_current_tombstone);
            } else {
                clogger.trace("csm {}: set_continuous({})", fmt::ptr(this), e.position());
                e.set_continuous(true);
-                e.set_range_tombstone(_current_tombstone);
            }
        } else {
            _read_context.cache().on_mispopulate();
@@ -632,72 +617,6 @@ void cache_flat_mutation_reader::maybe_add_to_cache(const clustering_row& cr) {
    });
 }

-inline
-bool cache_flat_mutation_reader::maybe_add_to_cache(const range_tombstone_change& rtc) {
-    rows_entry::tri_compare q_cmp(*_schema);
-
-    clogger.trace("csm {}: maybe_add_to_cache({})", fmt::ptr(this), rtc);
-
-    // Don't emit the closing range tombstone change, we may continue from cache with the same tombstone.
-    // The following relies on !_underlying_upper_bound->is_clustering_row()
-    if (q_cmp(rtc.position(), *_underlying_upper_bound) == 0) {
-        _lower_bound = rtc.position();
-        return false;
-    }
-
-    auto prev = std::exchange(_current_tombstone, rtc.tombstone());
-    if (_current_tombstone == prev) {
-        return false;
-    }
-
-    if (!can_populate()) {
-        // _current_tombstone is now invalid and remains so for this reader. No need to change it.
-        _last_row = nullptr;
-        _population_range_starts_before_all_rows = false;
-        _read_context.cache().on_mispopulate();
-        return true;
-    }
-
-    _lsa_manager.run_in_update_section_with_allocator([&] {
-        mutation_partition_v2& mp = _snp->version()->partition();
-        rows_entry::tri_compare cmp(table_schema());
-
-        auto new_entry = alloc_strategy_unique_ptr<rows_entry>(
-                current_allocator().construct<rows_entry>(table_schema(), to_table_domain(rtc.position()), is_dummy::yes, is_continuous::no));
-        auto it = _next_row.iterators_valid() ? _next_row.get_iterator_in_latest_version()
-                                              : mp.clustered_rows().lower_bound(to_table_domain(rtc.position()), cmp);
-        auto insert_result = mp.mutable_clustered_rows().insert_before_hint(it, std::move(new_entry), cmp);
-        it = insert_result.first;
-        if (insert_result.second) {
-            _snp->tracker()->insert(*it);
-        }
-
-        rows_entry& e = *it;
-        if (ensure_population_lower_bound()) {
-            // underlying may emit range_tombstone_change fragments with the same position.
-            // In such case, the range to which the tombstone from the first fragment applies is empty and should be ignored.
-            if (q_cmp(_last_row.position(), it->position()) < 0) {
-                if (_read_context.is_reversed()) [[unlikely]] {
-                    clogger.trace("csm {}: set_continuous({}), rt={}", fmt::ptr(this), _last_row.position(), prev);
-                    _last_row->set_continuous(true);
-                    _last_row->set_range_tombstone(prev);
-                } else {
-                    clogger.trace("csm {}: set_continuous({}), rt={}", fmt::ptr(this), e.position(), prev);
-                    e.set_continuous(true);
-                    e.set_range_tombstone(prev);
-                }
-            }
-        } else {
-            _read_context.cache().on_mispopulate();
-        }
-        with_allocator(standard_allocator(), [&] {
-            _last_row = partition_snapshot_row_weakref(*_snp, it, true);
-        });
-        _population_range_starts_before_all_rows = false;
-    });
-    return true;
-}
-
 inline
 bool cache_flat_mutation_reader::after_current_range(position_in_partition_view p) {
    position_in_partition::tri_compare cmp(*_schema);
@@ -713,35 +632,19 @@ void cache_flat_mutation_reader::start_reading_from_underlying() {

 inline
 void cache_flat_mutation_reader::copy_from_cache_to_buffer() {
-    clogger.trace("csm {}: copy_from_cache, next_row_in_range={}, next={}", fmt::ptr(this), _next_row_in_range, _next_row);
+    clogger.trace("csm {}: copy_from_cache, next={}, next_row_in_range={}", fmt::ptr(this), _next_row.position(), _next_row_in_range);
    _next_row.touch();
-
-    if (_next_row.range_tombstone() != _current_tombstone) {
-        position_in_partition::equal_compare eq(*_schema);
-        auto upper_bound = _next_row_in_range ? position_in_partition_view::before_key(_next_row.position()) : _upper_bound;
-        if (!eq(_lower_bound, upper_bound)) {
-            position_in_partition new_lower_bound(upper_bound);
-            auto tomb = _next_row.range_tombstone();
-            clogger.trace("csm {}: rtc({}, {}) ...{}", fmt::ptr(this), _lower_bound, tomb, new_lower_bound);
-            push_mutation_fragment(mutation_fragment_v2(*_schema, _permit, range_tombstone_change(_lower_bound, tomb)));
-            _current_tombstone = tomb;
-            _lower_bound = std::move(new_lower_bound);
-            _read_context.cache()._tracker.on_range_tombstone_read();
-        }
+    auto next_lower_bound = position_in_partition_view::after_key(table_schema(), _next_row.position());
+    auto upper_bound = _next_row_in_range ? next_lower_bound.view : _upper_bound;
+    if (_snp->range_tombstones(_lower_bound, upper_bound, [&] (range_tombstone rts) {
+        add_range_tombstone_to_buffer(std::move(rts));
+        return stop_iteration(_lower_bound_changed && is_buffer_full());
+    }, _read_context.is_reversed()) == stop_iteration::no) {
+        return;
    }
-
    // We add the row to the buffer even when it's full.
    // This simplifies the code. For more info see #3139.
    if (_next_row_in_range) {
-        if (_next_row.range_tombstone_for_row() != _current_tombstone) [[unlikely]] {
-            auto tomb = _next_row.range_tombstone_for_row();
-            auto new_lower_bound = position_in_partition::before_key(_next_row.position());
-            clogger.trace("csm {}: rtc({}, {})", fmt::ptr(this), new_lower_bound, tomb);
-            push_mutation_fragment(mutation_fragment_v2(*_schema, _permit, range_tombstone_change(new_lower_bound, tomb)));
-            _lower_bound = std::move(new_lower_bound);
-            _current_tombstone = tomb;
-            _read_context.cache()._tracker.on_range_tombstone_read();
-        }
        add_to_buffer(_next_row);
        move_to_next_entry();
    } else {
@@ -757,11 +660,10 @@ void cache_flat_mutation_reader::move_to_end() {

 inline
 void cache_flat_mutation_reader::move_to_next_range() {
-    if (_current_tombstone) {
-        clogger.trace("csm {}: move_to_next_range: emit rtc({}, null)", fmt::ptr(this), _upper_bound);
-        push_mutation_fragment(mutation_fragment_v2(*_schema, _permit, range_tombstone_change(_upper_bound, {})));
-        _current_tombstone = {};
+    if (_queued_underlying_fragment) {
+        add_to_buffer(*std::exchange(_queued_underlying_fragment, {}));
    }
+    flush_tombstones(position_in_partition::for_range_end(*_ck_ranges_curr), true);
    auto next_it = std::next(_ck_ranges_curr);
    if (next_it == _ck_ranges_end) {
        move_to_end();
@@ -778,6 +680,8 @@ void cache_flat_mutation_reader::move_to_range(query::clustering_row_ranges::con
    _last_row = nullptr;
    _lower_bound = std::move(lb);
    _upper_bound = std::move(ub);
+    _rt_gen.trim(_lower_bound);
+    _lower_bound_changed = true;
    _ck_ranges_curr = next_it;
    auto adjacent = _next_row.advance_to(_lower_bound);
    _next_row_in_range = !after_current_range(_next_row.position());
@@ -818,7 +722,7 @@ void cache_flat_mutation_reader::move_to_range(query::clustering_row_ranges::con
 // _next_row must have a greater position than _last_row.
 // Invalidates references but keeps the _next_row valid.
 inline
-void cache_flat_mutation_reader::maybe_drop_last_entry(tombstone rt) noexcept {
+void cache_flat_mutation_reader::maybe_drop_last_entry() noexcept {
    // Drop dummy entry if it falls inside a continuous range.
    // This prevents unnecessary dummy entries from accumulating in cache and slowing down scans.
    //
@@ -829,12 +733,9 @@ void cache_flat_mutation_reader::maybe_drop_last_entry(tombstone rt) noexcept {
            && !_read_context.is_reversed() // FIXME
            && _last_row->dummy()
            && _last_row->continuous()
-            && _last_row->range_tombstone() == rt
            && _snp->at_latest_version()
            && _snp->at_oldest_version()) {

-        clogger.trace("csm {}: dropping unnecessary dummy at {}", fmt::ptr(this), _last_row->position());
-
        with_allocator(_snp->region().allocator(), [&] {
            cache_tracker& tracker = _read_context.cache()._tracker;
            tracker.get_lru().remove(*_last_row);
@@ -868,38 +769,57 @@ void cache_flat_mutation_reader::move_to_next_entry() {
        if (!_next_row.continuous()) {
            start_reading_from_underlying();
        } else {
-            maybe_drop_last_entry(_next_row.range_tombstone());
+            maybe_drop_last_entry();
        }
    }
 }

+void cache_flat_mutation_reader::flush_tombstones(position_in_partition_view pos_, bool end_of_range) {
+    // Ensure position is appropriate for range tombstone bound
+    auto pos = position_in_partition_view::after_key(*_schema, pos_);
+    clogger.trace("csm {}: flush_tombstones({}) end_of_range: {}", fmt::ptr(this), pos.view, end_of_range);
+    _rt_gen.flush(pos.view, [this] (range_tombstone_change&& rtc) {
+        add_to_buffer(std::move(rtc), source::cache);
+    }, end_of_range);
+    if (auto rtc_opt = _rt_merger.flush(pos.view, end_of_range)) {
+        do_add_to_buffer(std::move(*rtc_opt));
+    }
+}
+
 inline
-void cache_flat_mutation_reader::offer_from_underlying(mutation_fragment_v2&& mf) {
-    clogger.trace("csm {}: offer_from_underlying({})", fmt::ptr(this), mutation_fragment_v2::printer(*_schema, mf));
+void cache_flat_mutation_reader::add_to_buffer(mutation_fragment_v2&& mf) {
+    clogger.trace("csm {}: add_to_buffer({})", fmt::ptr(this), mutation_fragment_v2::printer(*_schema, mf));
+    position_in_partition::less_compare less(*_schema);
+    if (_underlying_upper_bound && less(*_underlying_upper_bound, mf.position())) {
+        _queued_underlying_fragment = std::move(mf);
+        return;
+    }
+    flush_tombstones(mf.position());
    if (mf.is_clustering_row()) {
-        maybe_add_to_cache(mf.as_clustering_row());
        add_clustering_row_to_buffer(std::move(mf));
    } else {
        assert(mf.is_range_tombstone_change());
-        auto& chg = mf.as_range_tombstone_change();
-        if (maybe_add_to_cache(chg)) {
-            add_to_buffer(std::move(mf).as_range_tombstone_change());
-        }
+        add_to_buffer(std::move(mf).as_range_tombstone_change(), source::underlying);
    }
 }

 inline
 void cache_flat_mutation_reader::add_to_buffer(const partition_snapshot_row_cursor& row) {
    position_in_partition::less_compare less(*_schema);
+    if (_queued_underlying_fragment && less(_queued_underlying_fragment->position(), row.position())) {
+        add_to_buffer(*std::exchange(_queued_underlying_fragment, {}));
+    }
    if (!row.dummy()) {
        _read_context.cache().on_row_hit();
        if (_read_context.digest_requested()) {
            row.latest_row().cells().prepare_hash(table_schema(), column_kind::regular_column);
        }
+        flush_tombstones(position_in_partition_view::for_key(row.key()));
        add_clustering_row_to_buffer(mutation_fragment_v2(*_schema, _permit, row.row()));
    } else {
        if (less(_lower_bound, row.position())) {
            _lower_bound = row.position();
+            _lower_bound_changed = true;
        }
        _read_context.cache()._tracker.on_dummy_row_hit();
    }
@@ -915,21 +835,64 @@ void cache_flat_mutation_reader::add_clustering_row_to_buffer(mutation_fragment_
    auto new_lower_bound = position_in_partition::after_key(*_schema, row.key());
    push_mutation_fragment(std::move(mf));
    _lower_bound = std::move(new_lower_bound);
+    _lower_bound_changed = true;
    if (row.tomb()) {
        _read_context.cache()._tracker.on_row_tombstone_read();
    }
 }

 inline
-void cache_flat_mutation_reader::add_to_buffer(range_tombstone_change&& rtc) {
+void cache_flat_mutation_reader::add_to_buffer(range_tombstone_change&& rtc, source src) {
    clogger.trace("csm {}: add_to_buffer({})", fmt::ptr(this), rtc);
-    _has_rt = true;
+    if (auto rtc_opt = _rt_merger.apply(src, std::move(rtc))) {
+        do_add_to_buffer(std::move(*rtc_opt));
+    }
+}
+
+inline
+void cache_flat_mutation_reader::do_add_to_buffer(range_tombstone_change&& rtc) {
+    clogger.trace("csm {}: push({})", fmt::ptr(this), rtc);
    position_in_partition::less_compare less(*_schema);
+    auto lower_bound_changed = less(_lower_bound, rtc.position());
    _lower_bound = position_in_partition(rtc.position());
+    _lower_bound_changed = lower_bound_changed;
    push_mutation_fragment(*_schema, _permit, std::move(rtc));
    _read_context.cache()._tracker.on_range_tombstone_read();
 }

+inline
+void cache_flat_mutation_reader::add_range_tombstone_to_buffer(range_tombstone&& rt) {
+    position_in_partition::less_compare less(*_schema);
+    if (_queued_underlying_fragment && less(_queued_underlying_fragment->position(), rt.position())) {
+        add_to_buffer(*std::exchange(_queued_underlying_fragment, {}));
+    }
+    clogger.trace("csm {}: add_to_buffer({})", fmt::ptr(this), rt);
+    if (!less(_lower_bound, rt.position())) {
+        rt.set_start(_lower_bound);
+    }
+    flush_tombstones(rt.position());
+    _rt_gen.consume(std::move(rt));
+}
+
+inline
+void cache_flat_mutation_reader::maybe_add_to_cache(const range_tombstone_change& rtc) {
+    clogger.trace("csm {}: maybe_add_to_cache({})", fmt::ptr(this), rtc);
+    auto rt_opt = _rt_assembler.consume(*_schema, range_tombstone_change(rtc));
+    if (!rt_opt) {
+        return;
+    }
+    const auto& rt = *rt_opt;
+    if (can_populate()) {
+        clogger.trace("csm {}: maybe_add_to_cache({})", fmt::ptr(this), rt);
+        _lsa_manager.run_in_update_section_with_allocator([&] {
+            _snp->version()->partition().mutable_row_tombstones().apply_monotonically(
+                    table_schema(), to_table_domain(rt));
+        });
+    } else {
+        _read_context.cache().on_mispopulate();
+    }
+}
+
 inline
 void cache_flat_mutation_reader::maybe_add_to_cache(const static_row& sr) {
    if (can_populate()) {
--- a/schema/caching_options.cc
+++ b/schema/caching_options.cc
--- a/schema/caching_options.hh
+++ b/schema/caching_options.hh
--- a/mutation/canonical_mutation.cc
+++ b/mutation/canonical_mutation.cc
--- a/mutation/canonical_mutation.hh
+++ b/mutation/canonical_mutation.hh
@@ -9,7 +9,7 @@
 #pragma once

 #include "bytes.hh"
-#include "schema/schema_fwd.hh"
+#include "schema_fwd.hh"
 #include "replica/database_fwd.hh"
 #include "bytes_ostream.hh"
 #include <iosfwd>
--- a/cdc/CMakeLists.txt
+++ b/cdc/CMakeLists.txt
@@ -1,17 +0,0 @@
-add_library(cdc STATIC)
-target_sources(cdc
-  PRIVATE
-    cdc_partitioner.cc
-    generation.cc
-    log.cc
-    metadata.cc
-    split.cc)
-target_include_directories(cdc
-  PUBLIC
-    ${CMAKE_SOURCE_DIR})
-target_link_libraries(cdc
-  PUBLIC
-    Seastar::seastar
-    xxHash::xxhash
-  PRIVATE
-    replica)
--- a/Show More
+++ b/Show More