./github/scripts/auto-backport.py: don't remove backport label when backport process has an error

Today, when the `Fixes` prefix is missing or the developer is not a collaborator with `scylladbbot` we remove the backport labels to prevent the process from starting and notifying the developers.

Developers are worried that removing these backport labels will cause us to forget we need to do these backports. @nyh suggested to add a `scylladbbot/backport_error` label instead

Applied those changes, so when a `Fixes` prefix is missing we will add a `scylladbbot/backport_error` label and stop the process

When a user doesn't accept the invite we will still open the PR but he will not be assigned and will not be able to edit the branch when we have conflicts

Fixes: https://github.com/scylladb/scylla-pkg/issues/4898
Fixes: https://github.com/scylladb/scylla-pkg/issues/4897

.github/CODEOWNERS

@@ -1,5 +1,5 @@
 # AUTH
-auth/* @nuivall @ptrsmrn
+auth/* @nuivall @ptrsmrn @KrzaQ
 
 # CACHE
 row_cache* @tgrabiec
@@ -25,15 +25,15 @@ compaction/* @raphaelsc
 transport/*
 
 # CQL QUERY LANGUAGE
-cql3/* @tgrabiec @nuivall @ptrsmrn
+cql3/* @tgrabiec @nuivall @ptrsmrn @KrzaQ
 
 # COUNTERS
-counters* @nuivall @ptrsmrn
-tests/counter_test* @nuivall @ptrsmrn
+counters* @nuivall @ptrsmrn @KrzaQ
+tests/counter_test* @nuivall @ptrsmrn @KrzaQ
 
 # DOCS
 docs/* @annastuchlik @tzach
-docs/alternator @annastuchlik @tzach @nyh
+docs/alternator @annastuchlik @tzach @nyh @nuivall @ptrsmrn @KrzaQ
 
 # GOSSIP
 gms/* @tgrabiec @asias @kbr-scylla
@@ -74,8 +74,8 @@ streaming/* @tgrabiec @asias
 service/storage_service.* @tgrabiec @asias
 
 # ALTERNATOR
-alternator/* @nyh
-test/alternator/* @nyh
+alternator/* @nyh @nuivall @ptrsmrn @KrzaQ
+test/alternator/* @nyh @nuivall @ptrsmrn @KrzaQ
 
 # HINTED HANDOFF
 db/hints/* @piodul @vladzcloudius @eliransin

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,86 +1,15 @@
-name: "Report a bug"
-description: "File a bug report."
-title: "[Bug]: "
-type: "bug"
-labels: bug
-body:
-  - type: checkboxes
-    id: terms
-    attributes:
-      label: Code of Conduct
-      description: "This is Scylla's bug tracker, to be used for reporting bugs only.
+This is Scylla's bug tracker, to be used for reporting bugs only.
 If you have a question about Scylla, and not a bug, please ask it in
-our forum at https://forum.scylladb.com/ or in our slack channel https://slack.scylladb.com/ "
-      options:
-        - label: I have read the disclaimer above and am reporting a suspected malfunction in Scylla.
-          required: true
+our mailing-list at scylladb-dev@googlegroups.com or in our slack channel.
 
-  - type: input
-    id: product-version
-    attributes:
-      label: product version
-      description: Scylla version (or git commit hash)
-      placeholder: ex. scylla-6.1.1
-    validations:
-      required: true
-      
-  - type: input
-    id: cluster-size
-    attributes:
-      label: Cluster Size
-    validations:
-      required: true  
-      
-  - type: input
-    id: os
-    attributes:
-      label: OS
-      placeholder: RHEL/CentOS/Ubuntu/AWS AMI
-    validations:
-      required: true
-      
-  - type: textarea
-    id: additional-data
-    attributes:
-      label: Additional Environmental Data
-      #description: 
-      placeholder: Add additional data
-      value: "Platform (physical/VM/cloud instance type/docker):\n
-Hardware: sockets=   cores=   hyperthreading=   memory=\n
-Disks: (SSD/HDD, count)"
-    validations:
-      required: false
-      
-  - type: textarea
-    id: reproducer-steps
-    attributes:
-      label: Reproduction Steps
-      placeholder: Describe how to reproduce the problem
-      value: "The steps to reproduce the problem are:"
-    validations:
-      required: true
-      
-  - type: textarea
-    id: the-problem
-    attributes:
-      label: What is the problem?
-      placeholder: Describe the problem you found
-      value: "The problem is that"
-    validations:
-      required: true
-      
-  - type: textarea
-    id: what-happened
-    attributes:
-      label: Expected behavior?
-      placeholder: Describe what should have happened
-      value: "I expected that "
-    validations:
-      required: true
-      
-  - type: textarea
-    id: logs
-    attributes:
-      label: Relevant log output
-      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
-      render: shell
+- [] I have read the disclaimer above, and I am reporting a suspected malfunction in Scylla.
+
+*Installation details*
+Scylla version (or git commit hash):
+Cluster size:
+OS (RHEL/CentOS/Ubuntu/AWS AMI):
+
+*Hardware details (for performance issues)*          Delete if unneeded
+Platform (physical/VM/cloud instance type/docker):
+Hardware: sockets= cores= hyperthreading= memory=
+Disks: (SSD/HDD, count)

.github/scripts/auto-backport.py

@@ -47,29 +47,13 @@ def create_pull_request(repo, new_branch_name, base_branch_name, pr, backport_pr
             draft=is_draft
         )
         logging.info(f"Pull request created: {backport_pr.html_url}")
-        labels_to_add = []
-        priority_labels = {"P0", "P1"}
-        parent_pr_labels = [label.name for label in pr.labels]
-        for label in priority_labels:
-            if label in parent_pr_labels:
-                labels_to_add.append(label)
-                labels_to_add.append("force_on_cloud")
-                logging.info(f"Adding {label} and force_on_cloud labels from parent PR to backport PR")
-                break  # Only apply the highest priority label
-        
         if is_collaborator:
             backport_pr.add_to_assignees(pr.user)
         if is_draft:
-            labels_to_add.append("conflicts")
+            backport_pr.add_to_labels("conflicts")
             pr_comment = f"@{pr.user.login} - This PR was marked as draft because it has conflicts\n"
-            pr_comment += "Please resolve them and remove the 'conflicts' label. The PR will be made ready for review automatically."
+            pr_comment += "Please resolve them and mark this PR as ready for review"
             backport_pr.create_issue_comment(pr_comment)
-        
-        # Apply all labels at once if we have any
-        if labels_to_add:
-            backport_pr.add_to_labels(*labels_to_add)
-            logging.info(f"Added labels to backport PR: {labels_to_add}")
-
         logging.info(f"Assigned PR to original author: {pr.user}")
         return backport_pr
     except GithubException as e:
@@ -128,45 +112,29 @@ def backport(repo, pr, version, commits, backport_base_branch, is_collaborator):
                     is_draft = True
                     repo_local.git.add(A=True)
                     repo_local.git.cherry_pick('--continue')
-            # Check if the branch already exists in the remote fork
-            remote_refs = repo_local.git.ls_remote('--heads', fork_repo, new_branch_name)
-            if not remote_refs:
-                # Branch does not exist, create it with a regular push
-                repo_local.git.push(fork_repo, new_branch_name)
-                create_pull_request(repo, new_branch_name, backport_base_branch, pr, backport_pr_title, commits,
-                                    is_draft, is_collaborator)
-            else:
-                logging.info(f"Remote branch {new_branch_name} already exists in fork. Skipping push.")
+            repo_local.git.push(fork_repo, new_branch_name, force=True)
+            create_pull_request(repo, new_branch_name, backport_base_branch, pr, backport_pr_title, commits,
+                                is_draft, is_collaborator)
+
         except GitCommandError as e:
             logging.warning(f"GitCommandError: {e}")
 
 
 def with_github_keyword_prefix(repo, pr):
-    # GitHub issue pattern: #123, scylladb/scylladb#123, or full GitHub URLs
-    github_pattern = rf"(?:fix(?:|es|ed))\s*:?\s*(?:(?:(?:{repo.full_name})?#)|https://github\.com/{repo.full_name}/issues/)(\d+)"
-    
-    # JIRA issue pattern: PKG-92 or https://scylladb.atlassian.net/browse/PKG-92
-    jira_pattern = r"(?:fix(?:|es|ed))\s*:?\s*(?:(?:https://scylladb\.atlassian\.net/browse/)?([A-Z]+-\d+))"
-    
-    # Check PR body for GitHub issues
-    github_match = re.findall(github_pattern, pr.body, re.IGNORECASE)
-    # Check PR body for JIRA issues
-    jira_match = re.findall(jira_pattern, pr.body, re.IGNORECASE)
-    
-    match = github_match or jira_match
-
-    if match:
+    pattern = rf"(?:fix(?:|es|ed))\s*:?\s*(?:(?:(?:{repo.full_name})?#)|https://github\.com/{repo.full_name}/issues/)(\d+)"
+    match = re.findall(pattern, pr.body, re.IGNORECASE)
+    if not match:
+        for commit in pr.get_commits():
+            match = re.findall(pattern, commit.commit.message, re.IGNORECASE)
+            if match:
+                print(f'{pr.number} has a valid close reference in commit message {commit.sha}')
+                break
+    if not match:
+        print(f'No valid close reference for {pr.number}')
+        return False
+    else:
         return True
 
-    for commit in pr.get_commits():
-        github_match = re.findall(github_pattern, commit.commit.message, re.IGNORECASE)
-        jira_match = re.findall(jira_pattern, commit.commit.message, re.IGNORECASE)
-        if github_match or jira_match:
-            print(f'{pr.number} has a valid close reference in commit message {commit.sha}')
-            return True
-
-    print(f'No valid close reference for {pr.number}')
-    return False
 
 def main():
     args = parse_args()

.github/scripts/sync_labels.py

@@ -30,13 +30,8 @@ def copy_labels_from_linked_issues(repo, pr_number):
             try:
                 issue = repo.get_issue(int(issue_number))
                 for label in issue.labels:
-                    # Copy ALL labels from issues to PR when PR is opened
                     pr.add_to_labels(label.name)
-                    print(f"Copied label '{label.name}' from issue #{issue_number} to PR #{pr_number}")
-                    if label.name in ['P0', 'P1']:
-                        pr.add_to_labels('force_on_cloud')
-                        print(f"Added force_on_cloud label to PR #{pr_number} due to {label.name} label")
-                print(f"All labels from issue #{issue_number} copied to PR #{pr_number}")
+                print(f"Labels from issue #{issue_number} copied to PR #{pr_number}")
             except Exception as e:
                 print(f"Error processing issue #{issue_number}: {e}")
 
@@ -79,22 +74,9 @@ def sync_labels(repo, number, label, action, is_issue=False):
             target = repo.get_issue(int(pr_or_issue_number))
         if action == 'labeled':
             target.add_to_labels(label)
-            if label in ['P0', 'P1'] and is_issue:
-                # Only add force_on_cloud to PRs when P0/P1 is added to an issue
-                target.add_to_labels('force_on_cloud')
-                print(f"Added 'force_on_cloud' label to PR #{pr_or_issue_number} due to {label} label")
             print(f"Label '{label}' successfully added.")
         elif action == 'unlabeled':
             target.remove_from_labels(label)
-            if label in ['P0', 'P1'] and is_issue:
-                # Check if any other P0/P1 labels remain before removing force_on_cloud
-                remaining_priority_labels = [l.name for l in target.labels if l.name in ['P0', 'P1']]
-                if not remaining_priority_labels:
-                    try:
-                        target.remove_from_labels('force_on_cloud')
-                        print(f"Removed 'force_on_cloud' label from PR #{pr_or_issue_number} as no P0/P1 labels remain")
-                    except Exception as e:
-                        print(f"Warning: Could not remove force_on_cloud label: {e}")
             print(f"Label '{label}' successfully removed.")
         elif action == 'opened':
             copy_labels_from_linked_issues(repo, number)

.github/seastar-bad-include.json

@@ -1,16 +0,0 @@
-{
-    "problemMatcher": [
-        {
-            "owner": "seastar-bad-include",
-            "severity": "error",
-            "pattern": [
-                {
-                    "regexp": "^(.+):(\\d+):(.+)$",
-                    "file": 1,
-                    "line": 2,
-                    "message": 3
-                }
-            ]
-        }
-    ]
-}

.github/workflows/add-label-when-promoted.yaml

@@ -54,13 +54,10 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.AUTO_BACKPORT_TOKEN }}
         run: python .github/scripts/auto-backport.py --repo ${{ github.repository }} --base-branch ${{ github.ref }} --commits ${{ github.event.before }}..${{ github.sha }}
       - name: Check if a valid backport label exists and no backport_error
-        env:
-          LABELS_JSON: ${{ toJson(github.event.pull_request.labels) }}
         id: check_label
         run: |
-          labels_json="$LABELS_JSON"
-          echo "Checking labels:"
-          echo "$labels_json" | jq -r '.[].name'
+          labels_json='${{ toJson(github.event.pull_request.labels) }}'
+          echo "Checking labels: $(echo "$labels_json" | jq -r '.[].name')"
 
           # Check if a valid backport label exists
           if echo "$labels_json" | jq -e 'any(.[] | .name; test("backport/[0-9]+\\.[0-9]+$"))' > /dev/null; then

.github/workflows/backport-pr-fixes-validation.yaml

@@ -18,7 +18,7 @@ jobs:
             
             // Regular expression pattern to check for "Fixes" prefix
             // Adjusted to dynamically insert the repository full name
-            const pattern = `Fixes:? ((?:#|${repo.replace('/', '\\/')}#|https://github\\.com/${repo.replace('/', '\\/')}/issues/)(\\d+)|(?:https://scylladb\\.atlassian\\.net/browse/)?([A-Z]+-\\d+))`;
+            const pattern = `Fixes:? (?:#|${repo.replace('/', '\\/')}#|https://github\\.com/${repo.replace('/', '\\/')}/issues/)(\\d+)`;
             const regex = new RegExp(pattern);
             
             if (!regex.test(body)) {

.github/workflows/call_backport_with_jira.yaml

@@ -1,53 +0,0 @@
-name: Backport with Jira Integration
-
-on:
-  push:
-    branches:
-      - master
-      - next-*.*
-      - branch-*.*
-  pull_request_target:
-    types: [labeled, closed]
-    branches: 
-      - master
-      - next
-      - next-*.*
-      - branch-*.*
-
-jobs:
-  backport-on-push:
-    if: github.event_name == 'push'
-    uses: scylladb/github-automation/.github/workflows/backport-with-jira.yaml@main
-    with:
-      event_type: 'push'
-      base_branch: ${{ github.ref }}
-      commits: ${{ github.event.before }}..${{ github.sha }}
-    secrets:
-      gh_token: ${{ secrets.AUTO_BACKPORT_TOKEN }}
-      jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
-
-  backport-on-label:
-    if: github.event_name == 'pull_request_target' && github.event.action == 'labeled'
-    uses: scylladb/github-automation/.github/workflows/backport-with-jira.yaml@main
-    with:
-      event_type: 'labeled'
-      base_branch: refs/heads/${{ github.event.pull_request.base.ref }}
-      pull_request_number: ${{ github.event.pull_request.number }}
-      head_commit: ${{ github.event.pull_request.base.sha }}
-      label_name: ${{ github.event.label.name }}
-      pr_state: ${{ github.event.pull_request.state }}
-    secrets:
-      gh_token: ${{ secrets.AUTO_BACKPORT_TOKEN }}
-      jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
-
-  backport-chain:
-    if: github.event_name == 'pull_request_target' && github.event.action == 'closed' && github.event.pull_request.merged == true
-    uses: scylladb/github-automation/.github/workflows/backport-with-jira.yaml@main
-    with:
-      event_type: 'chain'
-      base_branch: refs/heads/${{ github.event.pull_request.base.ref }}
-      pull_request_number: ${{ github.event.pull_request.number }}
-      pr_body: ${{ github.event.pull_request.body }}
-    secrets:
-      gh_token: ${{ secrets.AUTO_BACKPORT_TOKEN }}
-      jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}

.github/workflows/call_jira_status_in_progress.yml

@@ -1,12 +0,0 @@
-name: Call Jira Status In Progress
-
-on:
-  pull_request_target:
-    types: [opened]
-
-jobs:
-  call-jira-status-in-progress:
-    uses: scylladb/github-automation/.github/workflows/main_update_jira_status_to_in_progress.yml@main
-    secrets:
-      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
-

.github/workflows/call_jira_status_in_review.yml

@@ -1,12 +0,0 @@
-name: Call Jira Status In Review
-
-on:
-  pull_request_target:
-    types: [ready_for_review, review_requested]
-
-jobs:
-  call-jira-status-in-review:
-    uses: scylladb/github-automation/.github/workflows/main_update_jira_status_to_in_review.yml@main
-    secrets:
-      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
-

.github/workflows/call_jira_status_ready_for_merge.yml

@@ -1,12 +0,0 @@
-name: Call Jira Status Ready For Merge
-
-on:
-  pull_request_target:
-    types: [labeled]
-
-jobs:
-  call-jira-status-update:
-    uses: scylladb/github-automation/.github/workflows/main_update_jira_status_to_ready_for_merge.yml@main
-    secrets:
-      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
-

.github/workflows/conflict_reminder.yaml

@@ -1,16 +1,9 @@
 name: Notify PR Authors of Conflicts
 
-permissions:
-  issues: write
-  pull-requests: write
-
 on:
-  push:
-    branches:
-      - 'master'
-      - 'branch-*'
   schedule:
-    - cron: '0 10 * * 1'  # Runs every Monday at 10:00am
+    - cron: '0 10 * * 1,4'  # Runs every Monday and Thursday at 10:00am
+  workflow_dispatch:      # Manual trigger for testing
 
 jobs:
   notify_conflict_prs:
@@ -21,134 +14,32 @@ jobs:
         uses: actions/github-script@v7
         with:
           script: |
-            console.log("Starting conflict reminder script...");
-            // Print trigger event
-            if (process.env.GITHUB_EVENT_NAME) {
-              console.log(`Workflow triggered by: ${process.env.GITHUB_EVENT_NAME}`);
-            } else {
-              console.log("Could not determine workflow trigger event.");
-            }
-            const isPushEvent = process.env.GITHUB_EVENT_NAME === 'push';
-            console.log(`isPushEvent: ${isPushEvent}`);
-            const twoMonthsAgo = new Date();
-            twoMonthsAgo.setMonth(twoMonthsAgo.getMonth() - 2);
             const prs = await github.paginate(github.rest.pulls.list, {
               owner: context.repo.owner,
               repo: context.repo.repo,
               state: 'open',
               per_page: 100
             });
-            console.log(`Fetched ${prs.length} open PRs`);
-            const recentPrs = prs.filter(pr => new Date(pr.created_at) >= twoMonthsAgo);
-            const validBaseBranches = ['master'];
             const branchPrefix = 'branch-';
-            const oneWeekAgo = new Date();
-            const conflictLabel = 'conflicts';
-            oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);
-            console.log(`One week ago: ${oneWeekAgo.toISOString()}`);
-
-            for (const pr of recentPrs) {
-              console.log(`Checking PR #${pr.number} on base branch '${pr.base.ref}'`);
-              const isBranchX = pr.base.ref.startsWith(branchPrefix);
-              const isMaster = validBaseBranches.includes(pr.base.ref);
-              if (!(isBranchX || isMaster)) {
-                console.log(`PR #${pr.number} skipped: base branch is not 'master' or does not start with '${branchPrefix}'`);
-                continue;
-              }
+            const threeDaysAgo = new Date();
+            const conflictLabel = 'conflicts';          
+            threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
+            for (const pr of prs) {
+              if (!pr.base.ref.startsWith(branchPrefix)) continue;
+              const hasConflictLabel = pr.labels.some(label => label.name === conflictLabel);
+              if (!hasConflictLabel) continue;
               const updatedDate = new Date(pr.updated_at);
-              console.log(`PR #${pr.number} last updated at: ${updatedDate.toISOString()}`);
-              if (!isPushEvent && updatedDate >= oneWeekAgo) {
-                console.log(`PR #${pr.number} skipped: updated within last week`);
-                continue;
-              }
-              if (pr.assignee === null) {
-                console.log(`PR #${pr.number} skipped: no assignee`);
-                continue;
-              }
-
-              // Fetch PR details to check mergeability
-              let { data: prDetails } = await github.rest.pulls.get({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                pull_number: pr.number,
-              });
-              console.log(`PR #${pr.number} mergeable: ${prDetails.mergeable}`);
-
-              // Wait and re-fetch if mergeable is null
-              if (prDetails.mergeable === null) {
-                console.log(`PR #${pr.number} mergeable is null, waiting 2 seconds and retrying...`);
-                await new Promise(resolve => setTimeout(resolve, 2000)); // wait 2 seconds
-                prDetails = (await github.rest.pulls.get({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  pull_number: pr.number,
-                })).data;
-                console.log(`PR #${pr.number} mergeable after retry: ${prDetails.mergeable}`);
-              }
-
-              if (prDetails.mergeable === false) {
-                const hasConflictLabel = pr.labels.some(label => label.name === conflictLabel);
-                console.log(`PR #${pr.number} has conflict label: ${hasConflictLabel}`);
-
-                // Fetch comments to check for existing notifications
-                const comments = await github.paginate(github.rest.issues.listComments, {
+              if (updatedDate >= threeDaysAgo) continue;
+              if (pr.assignee === null) continue;
+              const assignee = pr.assignee.login;
+              if (assignee) {
+                await github.rest.issues.createComment({
                   owner: context.repo.owner,
                   repo: context.repo.repo,
                   issue_number: pr.number,
-                  per_page: 100,
+                  body: `@${assignee}, this PR has been open with conflicts. Please resolve the conflicts so we can merge it.`,
                 });
-                
-                // Find last notification comment from the bot
-                const notificationPrefix = `@${pr.assignee.login}, this PR has merge conflicts with the base branch.`;
-                const lastNotification = comments
-                  .filter(c =>
-                    c.user.type === "Bot" &&
-                    c.body.startsWith(notificationPrefix)
-                  )
-                  .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))[0];
-
-                // Check if we should skip notification based on recent notification
-                let shouldSkipNotification = false;
-                if (lastNotification) {
-                  const lastNotified = new Date(lastNotification.created_at);
-                  if (lastNotified >= oneWeekAgo) {
-                    console.log(`PR #${pr.number} skipped: last notification was less than 1 week ago`);
-                    shouldSkipNotification = true;
-                  }
-                }
-
-                // Additional check for push events on draft PRs with conflict labels
-                if (
-                  isPushEvent &&
-                  pr.draft === true &&
-                  hasConflictLabel &&
-                  shouldSkipNotification
-                ) {
-                  continue;
-                }
-
-                if (!hasConflictLabel) {
-                  await github.rest.issues.addLabels({
-                    owner: context.repo.owner,
-                    repo: context.repo.repo,
-                    issue_number: pr.number,
-                    labels: [conflictLabel],
-                  });
-                  console.log(`Added 'conflicts' label to PR #${pr.number}`);
-                }
-                
-                const assignee = pr.assignee.login;
-                if (assignee && !shouldSkipNotification) {
-                  await github.rest.issues.createComment({
-                    owner: context.repo.owner,
-                    repo: context.repo.repo,
-                    issue_number: pr.number,
-                    body: `@${assignee}, this PR has merge conflicts with the base branch. Please resolve the conflicts so we can merge it.`,
-                  });
-                  console.log(`Notified @${assignee} for PR #${pr.number}`);
-                }
-              } else {
-                console.log(`PR #${pr.number} is mergeable, no action needed.`);
-              }
+                console.log(`Notified @${assignee} for PR #${pr.number}`);
+              } 
             }
             console.log(`Total PRs checked: ${prs.length}`);

.github/workflows/iwyu.yaml

@@ -11,8 +11,7 @@ env:
   CLEANER_OUTPUT_PATH: build/clang-include-cleaner.log
   # the "idl" subdirectory does not contain C++ source code. the .hh files in it are
   # supposed to be processed by idl-compiler.py, so we don't check them using the cleaner
-  CLEANER_DIRS: test/unit exceptions alternator api auth cdc compaction db dht gms index lang message mutation mutation_writer node_ops raft redis replica service
-  SEASTAR_BAD_INCLUDE_OUTPUT_PATH: build/seastar-bad-include.log
+  CLEANER_DIRS: test/unit exceptions alternator api auth cdc compaction db dht gms index lang message mutation mutation_writer node_ops redis replica
 
 permissions: {}
 
@@ -81,24 +80,7 @@ jobs:
           done
       - run: |
           echo "::remove-matcher owner=clang-include-cleaner::"
-      - run: |
-          echo "::add-matcher::.github/seastar-bad-include.json"
-      - name: check for seastar includes
-        run: |
-          git -c safe.directory="$PWD"    \
-            grep -nE '#include +"seastar/' \
-            | tee "$SEASTAR_BAD_INCLUDE_OUTPUT_PATH"
-      - run: |
-          echo "::remove-matcher owner=seastar-bad-include::"
       - uses: actions/upload-artifact@v4
         with:
-          name: Logs
-          path: |
-            ${{ env.CLEANER_OUTPUT_PATH }}
-            ${{ env.SEASTAR_BAD_INCLUDE_OUTPUT_PATH }}
-      - name: fail if seastar headers are included as an internal library
-        run: |
-          if [ -s "$SEASTAR_BAD_INCLUDE_OUTPUT_PATH" ]; then
-            echo "::error::Found #include \"seastar/ in the source code. Use angle brackets instead."
-            exit 1
-          fi
+          name: Logs (clang-include-cleaner)
+          path: "./${{ env.CLEANER_OUTPUT_PATH }}"

.github/workflows/make-pr-ready-for-review.yaml

@@ -16,13 +16,6 @@ jobs:
       pull-requests: write
 
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          repository: ${{ github.repository }}
-          ref: ${{ env.DEFAULT_BRANCH }}
-          token: ${{ secrets.AUTO_BACKPORT_TOKEN }}
-          fetch-depth: 1
       - name: Mark pull request as ready for review
         run:  gh pr ready "${{ github.event.pull_request.number }}"
         env:

.github/workflows/pr-require-backport-label.yaml

@@ -13,8 +13,6 @@ jobs:
       issues: write
       pull-requests: write
     steps:
-      - name: Wait for label to be added
-        run: sleep 1m
       - uses: mheap/github-action-required-labels@v5
         with:
           mode: minimum

.github/workflows/sync-labels.yaml

@@ -37,13 +37,13 @@ jobs:
         run: python .github/scripts/sync_labels.py --repo ${{ github.repository }} --number ${{ github.event.number }} --action ${{ github.event.action }}
 
       - name: Pull request labeled or unlabeled event
-        if: github.event_name == 'pull_request_target' && (startsWith(github.event.label.name, 'backport/') || github.event.label.name == 'P0' || github.event.label.name == 'P1')
+        if: github.event_name == 'pull_request_target' && startsWith(github.event.label.name, 'backport/')
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: python .github/scripts/sync_labels.py --repo ${{ github.repository }} --number ${{ github.event.number }} --action ${{ github.event.action }} --label ${{ github.event.label.name }}
 
       - name: Issue labeled or unlabeled event
-        if: github.event_name == 'issues' && (startsWith(github.event.label.name, 'backport/') || github.event.label.name == 'P0' || github.event.label.name == 'P1')
+        if: github.event_name == 'issues' && startsWith(github.event.label.name, 'backport/')
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: python .github/scripts/sync_labels.py --repo ${{ github.repository }} --number ${{ github.event.issue.number }} --action ${{ github.event.action }} --is_issue --label ${{ github.event.label.name }}

.github/workflows/trigger-scylla-ci.yaml

@@ -1,65 +0,0 @@
-name: Trigger Scylla CI Route
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_target:
-    types:
-      - unlabeled
-
-jobs:
-  trigger-jenkins:
-    if: (github.event_name == 'issue_comment' && github.event.comment.user.login != 'scylladbbot') || github.event.label.name == 'conflicts'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Verify Org Membership
-        id: verify_author
-        env:
-          EVENT_NAME: ${{ github.event_name }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
-          PR_ASSOCIATION: ${{ github.event.pull_request.author_association }}
-          COMMENT_AUTHOR: ${{ github.event.comment.user.login }}
-          COMMENT_ASSOCIATION: ${{ github.event.comment.author_association }}
-        shell: bash
-        run: |
-          if [[ "$EVENT_NAME" == "pull_request_target" ]]; then
-            AUTHOR="$PR_AUTHOR"
-            ASSOCIATION="$PR_ASSOCIATION"
-          else
-            AUTHOR="$COMMENT_AUTHOR"
-            ASSOCIATION="$COMMENT_ASSOCIATION"
-          fi
-          ORG="scylladb"
-          if gh api "/orgs/${ORG}/members/${AUTHOR}" --silent 2>/dev/null; then
-            echo "member=true" >> $GITHUB_OUTPUT
-          else
-            echo "::warning::${AUTHOR} is not a member of ${ORG}; skipping CI trigger."
-            echo "member=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Validate Comment Trigger
-        if: github.event_name == 'issue_comment'
-        id: verify_comment
-        env:
-          COMMENT_BODY: ${{ github.event.comment.body }}
-        shell: bash
-        run: |
-          CLEAN_BODY=$(echo "$COMMENT_BODY" | grep -v '^[[:space:]]*>')
-
-          if echo "$CLEAN_BODY" | grep -qi '@scylladbbot' && echo "$CLEAN_BODY" | grep -qi 'trigger-ci'; then
-            echo "trigger=true" >> $GITHUB_OUTPUT
-          else
-            echo "trigger=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Trigger Scylla-CI-Route Jenkins Job
-        if: steps.verify_author.outputs.member == 'true' && (github.event_name == 'pull_request_target' || steps.verify_comment.outputs.trigger == 'true')
-        env:
-          JENKINS_USER: ${{ secrets.JENKINS_USERNAME }}
-          JENKINS_API_TOKEN: ${{ secrets.JENKINS_TOKEN }}
-          JENKINS_URL: "https://jenkins.scylladb.com"
-          PR_NUMBER: "${{ github.event.issue.number || github.event.pull_request.number }}"
-          PR_REPO_NAME: "${{ github.event.repository.full_name }}"
-        run: |
-          curl -X POST "$JENKINS_URL/job/releng/job/Scylla-CI-Route/buildWithParameters?PR_NUMBER=$PR_NUMBER&PR_REPO_NAME=$PR_REPO_NAME" \
-            --user "$JENKINS_USER:$JENKINS_API_TOKEN" --fail

.github/workflows/urgent_issue_reminder.yml

@@ -2,7 +2,7 @@ name: Urgent Issue Reminder
 
 on:
   schedule:
-    - cron: '10 8 * * *' # Runs daily at 8 AM
+    - cron: '10 8 * * 1' # Runs every Monday at 8 AM
 
 jobs:
   reminder:

.gitignore

@@ -35,5 +35,3 @@ compile_commands.json
 .envrc
 clang_build
 .idea/
-nuke
-rust/target

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "seastar"]
 	path = seastar
-	url = ../scylla-seastar
+	url = ../seastar
 	ignore = dirty
 [submodule "swagger-ui"]
 	path = swagger-ui
@@ -9,6 +9,9 @@
 [submodule "abseil"]
 	path = abseil
 	url = ../abseil-cpp
+[submodule "scylla-tools"]
+	path = tools/java
+	url = ../scylla-tools-java
 [submodule "scylla-python3"]
 	path = tools/python3
 	url = ../scylla-python3

CMakeLists.txt

@@ -90,13 +90,13 @@ if(is_multi_config)
     add_dependencies(Seastar::seastar_testing Seastar)
 else()
     set(Seastar_TESTING ON CACHE BOOL "" FORCE)
-    set(Seastar_API_LEVEL 8 CACHE STRING "" FORCE)
+    set(Seastar_API_LEVEL 7 CACHE STRING "" FORCE)
     set(Seastar_DEPRECATED_OSTREAM_FORMATTERS OFF CACHE BOOL "" FORCE)
     set(Seastar_APPS ON CACHE BOOL "" FORCE)
     set(Seastar_EXCLUDE_APPS_FROM_ALL ON CACHE BOOL "" FORCE)
     set(Seastar_EXCLUDE_TESTS_FROM_ALL ON CACHE BOOL "" FORCE)
     set(Seastar_IO_URING ON CACHE BOOL "" FORCE)
-    set(Seastar_SCHEDULING_GROUPS_COUNT 20 CACHE STRING "" FORCE)
+    set(Seastar_SCHEDULING_GROUPS_COUNT 19 CACHE STRING "" FORCE)
     set(Seastar_UNUSED_RESULT_ERROR ON CACHE BOOL "" FORCE)
     add_subdirectory(seastar)
     target_compile_definitions (seastar
@@ -163,6 +163,14 @@ file(MAKE_DIRECTORY "${scylla_gen_build_dir}")
 include(add_version_library)
 generate_scylla_version()
 
+add_library(scylla-zstd STATIC
+    zstd.cc)
+target_link_libraries(scylla-zstd
+  PRIVATE
+    db
+    Seastar::seastar
+    zstd::libzstd)
+
 add_library(scylla-main STATIC)
 target_sources(scylla-main
   PRIVATE
@@ -170,24 +178,32 @@ target_sources(scylla-main
     bytes.cc
     client_data.cc
     clocks-impl.cc
-    sstable_dict_autotrainer.cc
+    collection_mutation.cc
+    compress.cc
+    converting_mutation_partition_applier.cc
+    counters.cc
+    direct_failure_detector/failure_detector.cc
+    duration.cc
     exceptions/exceptions.cc
+    frozen_schema.cc
+    generic_server.cc
     debug.cc
     init.cc
-    keys/keys.cc
+    keys.cc
+    multishard_mutation_query.cc
     mutation_query.cc
     node_ops/task_manager_module.cc
     partition_slice_builder.cc
     querier.cc
-    query/query.cc
+    query.cc
     query_ranges_to_vnodes.cc
-    query/query-result-set.cc
+    query-result-set.cc
     tombstone_gc_options.cc
     tombstone_gc.cc
     reader_concurrency_semaphore.cc
     reader_concurrency_semaphore_group.cc
+    schema_mutations.cc
     serializer.cc
-    service/direct_failure_detector/failure_detector.cc
     sstables_loader.cc
     table_helper.cc
     tasks/task_handler.cc
@@ -198,6 +214,7 @@ target_sources(scylla-main
     vint-serialization.cc)
 target_link_libraries(scylla-main
   PRIVATE
+    "$<LINK_LIBRARY:WHOLE_ARCHIVE,scylla-zstd>"
     db
     absl::headers
     absl::btree
@@ -263,6 +280,7 @@ add_subdirectory(mutation)
 add_subdirectory(mutation_writer)
 add_subdirectory(node_ops)
 add_subdirectory(readers)
+add_subdirectory(redis)
 add_subdirectory(replica)
 add_subdirectory(raft)
 add_subdirectory(repair)
@@ -277,7 +295,6 @@ add_subdirectory(tracing)
 add_subdirectory(transport)
 add_subdirectory(types)
 add_subdirectory(utils)
-add_subdirectory(vector_search)
 add_version_library(scylla_version
     release.cc)
 
@@ -307,6 +324,7 @@ set(scylla_libs
     mutation_writer
     raft
     readers
+    redis
     repair
     replica
     schema
@@ -319,8 +337,7 @@ set(scylla_libs
     tracing
     transport
     types
-    utils
-    vector_search)
+    utils)
 target_link_libraries(scylla PRIVATE
     ${scylla_libs})
 
@@ -354,6 +371,3 @@ endif()
 if(Scylla_BUILD_INSTRUMENTED)
   add_subdirectory(pgo)
 endif()
-
-add_executable(patchelf
-  tools/patchelf.cc)

HACKING.md

@@ -220,9 +220,28 @@ On a development machine, one might run Scylla as
 $ SCYLLA_HOME=$HOME/scylla build/release/scylla --overprovisioned --developer-mode=yes
 ```
 
-To interact with scylla it is recommended to build our version of
-cqlsh. It is available at
-https://github.com/scylladb/scylla-cqlsh and is available as a submodule.
+To interact with scylla it is recommended to build our versions of
+cqlsh and nodetool. They are available at
+https://github.com/scylladb/scylla-tools-java and can be built with
+
+```bash
+$ sudo ./install-dependencies.sh
+$ ant jar
+```
+
+cqlsh should work out of the box, but nodetool depends on a running
+scylla-jmx (https://github.com/scylladb/scylla-jmx). It can be build
+with
+
+```bash
+$ mvn package
+```
+
+and must be started with
+
+```bash
+$ ./scripts/scylla-jmx
+```
 
 ### Branches and tags
 

NOTICE.txt

@@ -1,6 +1,9 @@
 This project includes code developed by the Apache Software Foundation (http://www.apache.org/),
 especially Apache Cassandra.
 
+It includes files from https://github.com/antonblanchard/crc32-vpmsum (author Anton Blanchard <anton@au.ibm.com>, IBM).
+These files are located in utils/arch/powerpc/crc32-vpmsum. Their license may be found in licenses/LICENSE-crc32-vpmsum.TXT.
+
 It includes modified code from https://gitbox.apache.org/repos/asf?p=cassandra-dtest.git (owned by The Apache Software Foundation)
 
 It includes modified tests from https://github.com/etcd-io/etcd.git (owned by The etcd Authors)

SCYLLA-VERSION-GEN

@@ -78,7 +78,7 @@ fi
 
 # Default scylla product/version tags
 PRODUCT=scylla
-VERSION=2025.4.6
+VERSION=2025.2.0-dev
 
 if test -f version
 then

alternator/CMakeLists.txt

@@ -17,7 +17,6 @@ target_sources(alternator
     streams.cc
     consumed_capacity.cc
     ttl.cc
-    parsed_expression_cache.cc
     ${cql_grammar_srcs})
 target_include_directories(alternator
   PUBLIC

alternator/consumed_capacity.cc

@@ -24,7 +24,7 @@ static constexpr uint64_t KB = 1024ULL;
 static constexpr uint64_t RCU_BLOCK_SIZE_LENGTH = 4*KB;
 static constexpr uint64_t WCU_BLOCK_SIZE_LENGTH = 1*KB;
 
-bool consumed_capacity_counter::should_add_capacity(const rjson::value& request) {
+static bool should_add_capacity(const rjson::value& request) {
     const rjson::value* return_consumed = rjson::find(request, "ReturnConsumedCapacity");
     if (!return_consumed) {
         return false;
@@ -62,22 +62,15 @@ static uint64_t calculate_half_units(uint64_t unit_block_size, uint64_t total_by
 rcu_consumed_capacity_counter::rcu_consumed_capacity_counter(const rjson::value& request, bool is_quorum) :
         consumed_capacity_counter(should_add_capacity(request)),_is_quorum(is_quorum) {
 }
-uint64_t rcu_consumed_capacity_counter::get_half_units(uint64_t total_bytes, bool is_quorum) noexcept {
-    return calculate_half_units(RCU_BLOCK_SIZE_LENGTH, total_bytes, is_quorum);
-}
 
 uint64_t rcu_consumed_capacity_counter::get_half_units() const noexcept {
-    return get_half_units(_total_bytes, _is_quorum);
+    return calculate_half_units(RCU_BLOCK_SIZE_LENGTH, _total_bytes, _is_quorum);
 }
 
 uint64_t wcu_consumed_capacity_counter::get_half_units() const noexcept {
     return calculate_half_units(WCU_BLOCK_SIZE_LENGTH, _total_bytes, true);
 }
 
-uint64_t wcu_consumed_capacity_counter::get_units(uint64_t total_bytes) noexcept {
-    return calculate_half_units(WCU_BLOCK_SIZE_LENGTH, total_bytes, true) * HALF_UNIT_MULTIPLIER;
-}
-
 wcu_consumed_capacity_counter::wcu_consumed_capacity_counter(const rjson::value& request) :
         consumed_capacity_counter(should_add_capacity(request)) {
 }

alternator/consumed_capacity.hh

@@ -42,25 +42,21 @@ public:
      */
     virtual uint64_t get_half_units() const noexcept = 0;
     uint64_t _total_bytes = 0;
-    static bool should_add_capacity(const rjson::value& request);
 protected:
     bool _should_add_to_reponse = false;
 };
 
 class rcu_consumed_capacity_counter : public consumed_capacity_counter {
+    virtual uint64_t get_half_units() const noexcept;
     bool _is_quorum = false;
 public:
     rcu_consumed_capacity_counter(const rjson::value& request, bool is_quorum);
-    rcu_consumed_capacity_counter(): consumed_capacity_counter(false), _is_quorum(false){}
-    virtual uint64_t get_half_units() const noexcept;
-    static uint64_t get_half_units(uint64_t total_bytes, bool is_quorum) noexcept;
 };
 
 class wcu_consumed_capacity_counter : public consumed_capacity_counter {
     virtual uint64_t get_half_units() const noexcept;
 public:
     wcu_consumed_capacity_counter(const rjson::value& request);
-    static uint64_t get_units(uint64_t total_bytes) noexcept;
 };
 
 }

alternator/controller.cc

@@ -136,7 +136,6 @@ future<> controller::start_server() {
                 [this, addr, alternator_port, alternator_https_port, creds = std::move(creds)] (server& server) mutable {
             return server.init(addr, alternator_port, alternator_https_port, creds,
                     _config.alternator_enforce_authorization,
-                    _config.alternator_warn_authorization,
                     &_memory_limiter.local().get_semaphore(),
                     _config.max_concurrent_requests_per_shard);
         }).handle_exception([this, addr, alternator_port, alternator_https_port] (std::exception_ptr ep) {
@@ -168,8 +167,4 @@ future<> controller::request_stop_server() {
     });
 }
 
-future<utils::chunked_vector<client_data>> controller::get_client_data() {
-    return _server.local().get_client_data();
-}
-
 }

alternator/controller.hh

@@ -11,7 +11,7 @@
 #include <seastar/core/sharded.hh>
 #include <seastar/core/smp.hh>
 
-#include "transport/protocol_server.hh"
+#include "protocol_server.hh"
 
 namespace service {
 class storage_proxy;
@@ -90,10 +90,6 @@ public:
     virtual future<> start_server() override;
     virtual future<> stop_server() override;
     virtual future<> request_stop_server() override;
-    // This virtual function is called (on each shard separately) when the
-    // virtual table "system.clients" is read. It is expected to generate a
-    // list of clients connected to this server (on this shard).
-    virtual future<utils::chunked_vector<client_data>> get_client_data() override;
 };
 
 }

alternator/executor.hh

@@ -10,8 +10,8 @@
 
 #include <seastar/core/future.hh>
 #include "seastarx.hh"
+#include <seastar/json/json_elements.hh>
 #include <seastar/core/sharded.hh>
-#include <seastar/util/noncopyable_function.hh>
 
 #include "service/migration_manager.hh"
 #include "service/client_state.hh"
@@ -40,7 +40,6 @@ namespace cql3::selection {
 
 namespace service {
     class storage_proxy;
-    class cas_shard;
 }
 
 namespace cdc {
@@ -58,7 +57,33 @@ class schema_builder;
 namespace alternator {
 
 class rmw_operation;
-class put_or_delete_item;
+
+struct make_jsonable : public json::jsonable {
+    rjson::value _value;
+public:
+    explicit make_jsonable(rjson::value&& value);
+    std::string to_json() const override;
+};
+
+/**
+ * Make return type for serializing the object "streamed",
+ * i.e. direct to HTTP output stream. Note: only useful for
+ * (very) large objects as there are overhead issues with this
+ * as well, but for massive lists of return objects this can
+ * help avoid large allocations/many re-allocs
+ */
+json::json_return_type make_streamed(rjson::value&&);
+
+struct json_string : public json::jsonable {
+    std::string _value;
+public:
+    explicit json_string(std::string&& value);
+    std::string to_json() const override;
+};
+
+namespace parsed {
+class path;
+};
 
 schema_ptr get_table(service::storage_proxy& proxy, const rjson::value& request);
 bool is_alternator_keyspace(const sstring& ks_name);
@@ -130,9 +155,6 @@ using attrs_to_get_node = attribute_path_map_node<std::monostate>;
 // optional means we should get all attributes, not specific ones.
 using attrs_to_get = attribute_path_map<std::monostate>;
 
-namespace parsed {
-class expression_cache;
-}
 
 class executor : public peering_sharded_service<executor> {
     gms::gossiper& _gossiper;
@@ -141,32 +163,14 @@ class executor : public peering_sharded_service<executor> {
     db::system_distributed_keyspace& _sdks;
     cdc::metadata& _cdc_metadata;
     utils::updateable_value<bool> _enforce_authorization;
-    utils::updateable_value<bool> _warn_authorization;
     // An smp_service_group to be used for limiting the concurrency when
     // forwarding Alternator request between shards - if necessary for LWT.
     smp_service_group _ssg;
 
-    std::unique_ptr<parsed::expression_cache> _parsed_expression_cache;
-
 public:
     using client_state = service::client_state;
-    // request_return_type is the return type of the executor methods, which
-    // can be one of:
-    // 1. A string, which is the response body for the request.
-    // 2. A body_writer, an asynchronous function (returning future<>) that
-    //    takes an output_stream and writes the response body into it.
-    // 3. An api_error, which is an error response that should be returned to
-    //    the client.
-    // The body_writer is used for streaming responses, where the response body
-    // is written in chunks to the output_stream. This allows for efficient
-    // handling of large responses without needing to allocate a large buffer
-    // in memory.
-    using body_writer = noncopyable_function<future<>(output_stream<char>&&)>;
-    using request_return_type = std::variant<std::string, body_writer, api_error>;
+    using request_return_type = std::variant<json::json_return_type, api_error>;
     stats _stats;
-    // The metric_groups object holds this stat object's metrics registered
-    // as long as the stats object is alive.
-    seastar::metrics::metric_groups _metrics;
     static constexpr auto ATTRS_COLUMN_NAME = ":attrs";
     static constexpr auto KEYSPACE_NAME_PREFIX = "alternator_";
     static constexpr std::string_view INTERNAL_TABLE_PREFIX = ".scylla.alternator.";
@@ -178,7 +182,6 @@ public:
              cdc::metadata& cdc_metadata,
              smp_service_group ssg,
              utils::updateable_value<uint32_t> default_timeout_in_ms);
-    ~executor();
 
     future<request_return_type> create_table(client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value request);
     future<request_return_type> describe_table(client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value request);
@@ -206,33 +209,26 @@ public:
     future<request_return_type> describe_continuous_backups(client_state& client_state, service_permit permit, rjson::value request);
 
     future<> start();
-    future<> stop();
+    future<> stop() {
+        // disconnect from the value source, but keep the value unchanged.
+        s_default_timeout_in_ms = utils::updateable_value<uint32_t>{s_default_timeout_in_ms()};
+        return make_ready_future<>();
+    }
 
     static sstring table_name(const schema&);
     static db::timeout_clock::time_point default_timeout();
 private:
     static thread_local utils::updateable_value<uint32_t> s_default_timeout_in_ms;
 public:
-    static schema_ptr find_table(service::storage_proxy&, std::string_view table_name);
     static schema_ptr find_table(service::storage_proxy&, const rjson::value& request);
 
 private:
     friend class rmw_operation;
 
-    static void describe_key_schema(rjson::value& parent, const schema&, std::unordered_map<std::string,std::string> * = nullptr, const std::map<sstring, sstring> *tags = nullptr);
-
-    future<> do_batch_write(
-        std::vector<std::pair<schema_ptr, put_or_delete_item>> mutation_builders,
-        service::client_state& client_state,
-        tracing::trace_state_ptr trace_state,
-        service_permit permit);
-
-    future<> cas_write(schema_ptr schema, service::cas_shard cas_shard, const dht::decorated_key& dk,
-        const std::vector<put_or_delete_item>& mutation_builders, service::client_state& client_state,
-        tracing::trace_state_ptr trace_state, service_permit permit);
+    static void describe_key_schema(rjson::value& parent, const schema&, std::unordered_map<std::string,std::string> * = nullptr);
 
 public:
-    static void describe_key_schema(rjson::value& parent, const schema& schema, std::unordered_map<std::string,std::string>&, const std::map<sstring, sstring> *tags = nullptr);
+    static void describe_key_schema(rjson::value& parent, const schema& schema, std::unordered_map<std::string,std::string>&);
 
     static std::optional<rjson::value> describe_single_item(schema_ptr,
         const query::partition_slice&,
@@ -241,15 +237,11 @@ public:
         const std::optional<attrs_to_get>&,
         uint64_t* = nullptr);
 
-    // Converts a multi-row selection result to JSON compatible with DynamoDB.
-    // For each row, this method calls item_callback, which takes the size of
-    // the item as the parameter.
     static future<std::vector<rjson::value>> describe_multi_item(schema_ptr schema,
         const query::partition_slice&& slice,
         shared_ptr<cql3::selection::selection> selection,
         foreign_ptr<lw_shared_ptr<query::result>> query_result,
-        shared_ptr<const std::optional<attrs_to_get>> attrs_to_get,
-        noncopyable_function<void(uint64_t)> item_callback = {});
+        shared_ptr<const std::optional<attrs_to_get>> attrs_to_get);
 
     static void describe_single_item(const cql3::selection::selection&,
         const std::vector<managed_bytes_opt>&,
@@ -258,7 +250,7 @@ public:
         uint64_t* item_length_in_bytes = nullptr,
         bool = false);
 
-    static bool add_stream_options(const rjson::value& stream_spec, schema_builder&, service::storage_proxy& sp);
+    static void add_stream_options(const rjson::value& stream_spec, schema_builder&, service::storage_proxy& sp);
     static void supplement_table_info(rjson::value& descr, const schema& schema, service::storage_proxy& sp);
     static void supplement_table_stream_info(rjson::value& descr, const schema& schema, const service::storage_proxy& sp);
 };
@@ -277,15 +269,6 @@ bool is_big(const rjson::value& val, int big_size = 100'000);
 // Check CQL's Role-Based Access Control (RBAC) permission (MODIFY,
 // SELECT, DROP, etc.) on the given table. When permission is denied an
 // appropriate user-readable api_error::access_denied is thrown.
-future<> verify_permission(bool enforce_authorization, bool warn_authorization, const service::client_state&, const schema_ptr&, auth::permission, alternator::stats& stats);
-
-/**
- * Make return type for serializing the object "streamed",
- * i.e. direct to HTTP output stream. Note: only useful for
- * (very) large objects as there are overhead issues with this
- * as well, but for massive lists of return objects this can
- * help avoid large allocations/many re-allocs
- */
-executor::body_writer make_streamed(rjson::value&&);
+future<> verify_permission(bool enforce_authorization, const service::client_state&, const schema_ptr&, auth::permission);
 
 }

alternator/expressions.cc

@@ -165,9 +165,7 @@ static std::optional<std::string> resolve_path_component(const std::string& colu
                     fmt::format("ExpressionAttributeNames missing entry '{}' required by expression", column_name));
         }
         used_attribute_names.emplace(column_name);
-        auto result = std::string(rjson::to_string_view(*value));
-        validate_attr_name_length("", result.size(), false, "ExpressionAttributeNames contains invalid value: ");
-        return result;
+        return std::string(rjson::to_string_view(*value));
     }
     return std::nullopt;
 }
@@ -739,26 +737,6 @@ rjson::value calculate_value(const parsed::set_rhs& rhs,
     return rjson::null_value();
 }
 
-void validate_attr_name_length(std::string_view supplementary_context, size_t attr_name_length, bool is_key, std::string_view error_msg_prefix) {
-    constexpr const size_t DYNAMODB_KEY_ATTR_NAME_SIZE_MAX = 255;
-    constexpr const size_t DYNAMODB_NONKEY_ATTR_NAME_SIZE_MAX = 65535;
-
-    const size_t max_length = is_key ? DYNAMODB_KEY_ATTR_NAME_SIZE_MAX : DYNAMODB_NONKEY_ATTR_NAME_SIZE_MAX;
-    if (attr_name_length > max_length) {
-        std::string error_msg;
-        if (!error_msg_prefix.empty()) {
-            error_msg += error_msg_prefix;
-        }
-        if (!supplementary_context.empty()) {
-            error_msg += "in ";
-            error_msg += supplementary_context;
-            error_msg += " - ";
-        }
-        error_msg += fmt::format("Attribute name is too large, must be less than {} bytes", std::to_string(max_length + 1));
-        throw api_error::validation(error_msg);
-    }
-}
-
 } // namespace alternator
 
 auto fmt::formatter<alternator::parsed::path>::format(const alternator::parsed::path& p, fmt::format_context& ctx) const

alternator/expressions.g

@@ -91,18 +91,6 @@ options {
         throw expressions_syntax_error(format("{} at char {}", err,
             ex->get_charPositionInLine()));
     }
-
-    // ANTLR3 tries to recover missing tokens - it tries to finish parsing
-    // and create valid objects, as if the missing token was there.
-    // But it has a bug and leaks these tokens.
-    // We override offending method and handle abandoned pointers.
-    std::vector<std::unique_ptr<TokenType>> _missing_tokens;
-    TokenType* getMissingSymbol(IntStreamType* istream, ExceptionBaseType* e,
-                                ANTLR_UINT32 expectedTokenType, BitsetListType* follow) {
-        auto token = BaseType::getMissingSymbol(istream, e, expectedTokenType, follow);
-        _missing_tokens.emplace_back(token);
-        return token;
-    }
 }
 @lexer::context {
     void displayRecognitionError(ANTLR_UINT8** token_names, ExceptionBaseType* ex) {
@@ -196,13 +184,7 @@ path_component: NAME | NAMEREF;
 path returns [parsed::path p]:
     root=path_component           { $p.set_root($root.text); }
     (   '.' name=path_component   { $p.add_dot($name.text); }
-      | '[' INTEGER ']'           {
-                try {
-                    $p.add_index(std::stoi($INTEGER.text));
-                } catch(std::out_of_range&) {
-                    throw expressions_syntax_error("list index out of integer range");
-                }
-            }
+      | '[' INTEGER ']'           { $p.add_index(std::stoi($INTEGER.text)); }
     )*;
 
 /* See comment above why the "depth" counter was needed here */
@@ -248,7 +230,7 @@ update_expression_clause returns [parsed::update_expression e]:
 // Note the "EOF" token at the end of the update expression. We want to the
 //  parser to match the entire string given to it - not just its beginning!
 update_expression returns [parsed::update_expression e]:
-    (update_expression_clause { e.append($update_expression_clause.e); })+ EOF;
+    (update_expression_clause { e.append($update_expression_clause.e); })* EOF;
 
 projection_expression returns [std::vector<parsed::path> v]:
     p=path      { $v.push_back(std::move($p.p)); }
@@ -275,13 +257,6 @@ primitive_condition returns [parsed::primitive_condition c]:
          (',' v=value[0] { $c.add_value(std::move($v.v)); })*
          ')'
       )?
-      {
-          // Post-parse check to reject non-function single values
-          if ($c._op == parsed::primitive_condition::type::VALUE &&
-              !$c._values.front().is_func()) {
-              throw expressions_syntax_error("Single value must be a function");
-          }
-      }
     ;
 
 // The following rules for parsing boolean expressions are verbose and

alternator/expressions.hh

@@ -18,8 +18,6 @@
 
 #include "expressions_types.hh"
 #include "utils/rjson.hh"
-#include "utils/updateable_value.hh"
-#include "stats.hh"
 
 namespace alternator {
 
@@ -28,26 +26,6 @@ public:
     using runtime_error::runtime_error;
 };
 
-namespace parsed {
-class expression_cache_impl;
-class expression_cache {
-    std::unique_ptr<expression_cache_impl> _impl;
-public:
-    struct config {
-        utils::updateable_value<uint32_t> max_cache_entries;
-    };
-    expression_cache(config cfg, stats& stats);
-    ~expression_cache();
-    // stop background tasks, if any
-    future<> stop();
-
-    update_expression parse_update_expression(std::string_view query);
-    std::vector<path> parse_projection_expression(std::string_view query);
-    condition_expression parse_condition_expression(std::string_view query, const char* caller);
-};
-} // namespace parsed
-
-// Preferably use parsed::expression_cache instance instead of this free functions.
 parsed::update_expression parse_update_expression(std::string_view query);
 std::vector<parsed::path> parse_projection_expression(std::string_view query);
 parsed::condition_expression parse_condition_expression(std::string_view query, const char* caller);
@@ -113,7 +91,5 @@ rjson::value calculate_value(const parsed::value& v,
 rjson::value calculate_value(const parsed::set_rhs& rhs,
         const rjson::value* previous_item);
 
-void validate_attr_name_length(std::string_view supplementary_context, size_t attr_name_length, bool is_key, std::string_view error_msg_prefix = {});
-
 
 } /* namespace alternator */

alternator/expressions_types.hh

@@ -209,7 +209,9 @@ public:
 //    function is supported).
 // 2. Ternary operator - v1 BETWEEN v2 and v3 (means v1 >= v2 AND v1 <= v3).
 // 3. N-ary operator - v1 IN ( v2, v3, ... )
-// 4. A single function call (attribute_exists etc.).
+// 4. A single function call (attribute_exists etc.). The parser actually
+//    accepts a more general "value" here but later stages reject a value
+//    which is not a function call (because DynamoDB does it too).
 class primitive_condition {
 public:
     enum class type {

alternator/extract_from_attrs.hh

@@ -13,7 +13,7 @@
 
 #include "utils/rjson.hh"
 #include "serialization.hh"
-#include "schema/column_computation.hh"
+#include "column_computation.hh"
 #include "db/view/regular_column_transformation.hh"
 
 namespace alternator {

alternator/parsed_expression_cache.cc

@@ -1,109 +0,0 @@
-/*
- * Copyright 2025-present ScyllaDB
- */
-
-/*
- * SPDX-License-Identifier: LicenseRef-ScyllaDB-Source-Available-1.0
- */
-
-#include "expressions.hh"
-#include "utils/log.hh"
-
-#include "utils/lru_string_map.hh"
-#include <variant>
-
-static logging::logger logger_("parsed-expression-cache");
-
-namespace alternator::parsed {
-
-struct expression_cache_impl {
-    stats& _stats;
-
-    using cached_expressions_types = std::variant<
-        update_expression,
-        condition_expression,
-        std::vector<path>
-    >;
-    sized_lru_string_map<cached_expressions_types> _cached_entries;
-    utils::observable<uint32_t>::observer _max_cache_entries_observer;
-
-    expression_cache_impl(expression_cache::config cfg, stats& stats);
-
-    // to define the specialized return type of `get_or_create()`
-    template <typename Func, typename... Args>
-    using ParseResult = std::invoke_result_t<Func, std::string_view, Args...>;
-
-    // Caching layer for parsed expressions
-    // The expression type is determined by the type of the parsing function passed as a parameter,
-    // and the return type is exactly the same as the return type of this parsing function.
-    // StatsType is used only to update appropriate statistics - currently it is aligned with the expression type,
-    // but it could be extended in the future if needed, e.g. split per operation.
-    template <stats::expression_types StatsType, typename Func, typename... Args>
-    ParseResult<Func, Args...> get_or_create(std::string_view query, Func&& parse_func, Args&&... other_args) {
-        if (_cached_entries.disabled()) {
-            return parse_func(query, std::forward<Args>(other_args)...);
-        }
-        if (!_cached_entries.sanity_check()) {
-            _stats.expression_cache.requests[StatsType].misses++;
-            return parse_func(query, std::forward<Args>(other_args)...);
-        }
-        auto value = _cached_entries.find(query);
-        if (value) {
-            logger_.trace("Cache hit for query: {}", query);
-            _stats.expression_cache.requests[StatsType].hits++;
-            try {
-                return std::get<ParseResult<Func, Args...>>(value->get());
-            } catch (const std::bad_variant_access&) {
-                // User can reach this code, by sending the same query string as a different expression type.
-                // In practice valid queries are different enough to not collide.
-                // Entries in cache are only valid queries.
-                // This request will fail at parsing below.
-                // If, by any chance this is a valid query, it will be updated below with the new value.
-                logger_.trace("Cache hit for '{}', but type mismatch.", query);
-                _stats.expression_cache.requests[StatsType].hits--;
-            }
-        } else {
-            logger_.trace("Cache miss for query: {}", query);
-        }
-        ParseResult<Func, Args...> expr = parse_func(query, std::forward<Args>(other_args)...);
-        // Invalid query will throw here ^
-
-        _stats.expression_cache.requests[StatsType].misses++;
-        if (value) [[unlikely]] {
-            value->get() = cached_expressions_types{expr};
-        } else {
-            _cached_entries.insert(query, cached_expressions_types{expr});
-        }
-        return expr;
-    }
-};
-
-expression_cache_impl::expression_cache_impl(expression_cache::config cfg, stats& stats) : 
-    _stats(stats), _cached_entries(logger_, _stats.expression_cache.evictions),
-    _max_cache_entries_observer(cfg.max_cache_entries.observe([this] (uint32_t max_value) {
-        _cached_entries.set_max_size(max_value);
-    })) {
-    _cached_entries.set_max_size(cfg.max_cache_entries());
-}
-
-expression_cache::expression_cache(expression_cache::config cfg, stats& stats) : 
-    _impl(std::make_unique<expression_cache_impl>(std::move(cfg), stats)) {
-}
-expression_cache::~expression_cache() = default;
-future<> expression_cache::stop() {
-    return _impl->_cached_entries.stop();
-}
-
-update_expression expression_cache::parse_update_expression(std::string_view query) {
-    return _impl->get_or_create<stats::expression_types::UPDATE_EXPRESSION>(query, alternator::parse_update_expression);
-}
-
-std::vector<path> expression_cache::parse_projection_expression(std::string_view query) {
-    return _impl->get_or_create<stats::expression_types::PROJECTION_EXPRESSION>(query, alternator::parse_projection_expression);
-}
-
-condition_expression expression_cache::parse_condition_expression(std::string_view query, const char* caller) {
-    return _impl->get_or_create<stats::expression_types::CONDITION_EXPRESSION>(query, alternator::parse_condition_expression, caller);
-}
-
-} // namespace alternator::parsed

alternator/rmw_operation.hh

@@ -10,12 +10,11 @@
 
 #include "seastarx.hh"
 #include "service/paxos/cas_request.hh"
-#include "service/cas_shard.hh"
 #include "utils/rjson.hh"
 #include "consumed_capacity.hh"
 #include "executor.hh"
 #include "tracing/trace_state.hh"
-#include "keys/keys.hh"
+#include "keys.hh"
 
 namespace alternator {
 
@@ -115,15 +114,13 @@ public:
     const rjson::value& request() const { return _request; }
     rjson::value&& move_request() && { return std::move(_request); }
     future<executor::request_return_type> execute(service::storage_proxy& proxy,
-            std::optional<service::cas_shard> cas_shard,
             service::client_state& client_state,
             tracing::trace_state_ptr trace_state,
             service_permit permit,
             bool needs_read_before_write,
-            stats& global_stats,
-            stats& per_table_stats,
+            stats& stats,
             uint64_t& wcu_total);
-    std::optional<service::cas_shard> shard_for_execute(bool needs_read_before_write);
+    std::optional<shard_id> shard_for_execute(bool needs_read_before_write);
 };
 
 } // namespace alternator

alternator/serialization.cc

@@ -11,7 +11,7 @@
 #include "utils/log.hh"
 #include "serialization.hh"
 #include "error.hh"
-#include "types/concrete_types.hh"
+#include "concrete_types.hh"
 #include "cql3/type_json.hh"
 #include "mutation/position_in_partition.hh"
 
@@ -282,23 +282,15 @@ std::string type_to_string(data_type type) {
     return it->second;
 }
 
-std::optional<bytes> try_get_key_column_value(const rjson::value& item, const column_definition& column) {
+bytes get_key_column_value(const rjson::value& item, const column_definition& column) {
     std::string column_name = column.name_as_text();
     const rjson::value* key_typed_value = rjson::find(item, column_name);
     if (!key_typed_value) {
-        return std::nullopt;
+        throw api_error::validation(fmt::format("Key column {} not found", column_name));
     }
     return get_key_from_typed_value(*key_typed_value, column);
 }
 
-bytes get_key_column_value(const rjson::value& item, const column_definition& column) {
-    auto value = try_get_key_column_value(item, column);
-    if (!value) {
-        throw api_error::validation(fmt::format("Key column {} not found", column.name_as_text()));
-    }
-    return std::move(*value);
-}
-
 // Parses the JSON encoding for a key value, which is a map with a single
 // entry whose key is the type and the value is the encoded value.
 // If this type does not match the desired "type_str", an api_error::validation
@@ -388,38 +380,20 @@ clustering_key ck_from_json(const rjson::value& item, schema_ptr schema) {
         return clustering_key::make_empty();
     }
     std::vector<bytes> raw_ck;
-    // Note: it's possible to get more than one clustering column here, as
-    // Alternator can be used to read scylla internal tables.
+    // FIXME: this is a loop, but we really allow only one clustering key column.
     for (const column_definition& cdef : schema->clustering_key_columns()) {
-        auto raw_value = get_key_column_value(item,  cdef);
+        bytes raw_value = get_key_column_value(item,  cdef);
         raw_ck.push_back(std::move(raw_value));
     }
 
     return clustering_key::from_exploded(raw_ck);
 }
 
-clustering_key_prefix ck_prefix_from_json(const rjson::value& item, schema_ptr schema) {
-    if (schema->clustering_key_size() == 0) {
-        return clustering_key_prefix::make_empty();
-    }
-    std::vector<bytes> raw_ck;
-    for (const column_definition& cdef : schema->clustering_key_columns()) {
-        auto raw_value = try_get_key_column_value(item,  cdef);
-        if (!raw_value) {
-            break;
-        }
-        raw_ck.push_back(std::move(*raw_value));
-    }
-
-    return clustering_key_prefix::from_exploded(raw_ck);
-}
-
 position_in_partition pos_from_json(const rjson::value& item, schema_ptr schema) {
-    const bool is_alternator_ks = is_alternator_keyspace(schema->ks_name());
-    if (is_alternator_ks) {
-        return position_in_partition::for_key(ck_from_json(item, schema));
+    auto ck = ck_from_json(item, schema);
+    if (is_alternator_keyspace(schema->ks_name())) {
+        return position_in_partition::for_key(std::move(ck));
     }
-    
     const auto region_item = rjson::find(item, scylla_paging_region);
     const auto weight_item = rjson::find(item, scylla_paging_weight);
     if (bool(region_item) != bool(weight_item)) {
@@ -439,9 +413,8 @@ position_in_partition pos_from_json(const rjson::value& item, schema_ptr schema)
         } else {
             throw std::runtime_error(fmt::format("Invalid value for weight: {}", weight_view));
         }
-        return position_in_partition(region, weight, region == partition_region::clustered ? std::optional(ck_prefix_from_json(item, schema)) : std::nullopt);
+        return position_in_partition(region, weight, region == partition_region::clustered ? std::optional(std::move(ck)) : std::nullopt);
     }
-    auto ck = ck_from_json(item, schema);
     if (ck.is_empty()) {
         return position_in_partition::for_partition_start();
     }

alternator/serialization.hh

@@ -13,7 +13,7 @@
 #include <optional>
 #include "types/types.hh"
 #include "schema/schema_fwd.hh"
-#include "keys/keys.hh"
+#include "keys.hh"
 #include "utils/rjson.hh"
 #include "utils/big_decimal.hh"
 

alternator/server.cc

@@ -13,6 +13,7 @@
 #include <seastar/http/function_handlers.hh>
 #include <seastar/http/short_streams.hh>
 #include <seastar/core/coroutine.hh>
+#include <seastar/json/json_elements.hh>
 #include <seastar/util/defer.hh>
 #include <seastar/util/short_streams.hh>
 #include "seastarx.hh"
@@ -30,8 +31,6 @@
 #include "gms/gossiper.hh"
 #include "utils/overloaded_functor.hh"
 #include "utils/aws_sigv4.hh"
-#include "client_data.hh"
-#include "utils/updateable_value.hh"
 
 static logging::logger slogger("alternator-server");
 
@@ -101,13 +100,6 @@ static void handle_CORS(const request& req, reply& rep, bool preflight) {
 // the user directly. Other exceptions are unexpected, and reported as
 // Internal Server Error.
 class api_handler : public handler_base {
-    // Although the the DynamoDB API responses are JSON, additional
-    // conventions apply to these responses. For this reason, DynamoDB uses
-    // the content type "application/x-amz-json-1.0" instead of the standard
-    // "application/json". Some other AWS services use later versions instead
-    // of "1.0", but DynamoDB currently uses "1.0". Note that this content
-    // type applies to all replies, both success and error.
-    static constexpr const char* REPLY_CONTENT_TYPE = "application/x-amz-json-1.0";
 public:
     api_handler(const std::function<future<executor::request_return_type>(std::unique_ptr<request> req)>& _handle) : _f_handle(
          [this, _handle](std::unique_ptr<request> req, std::unique_ptr<reply> rep) {
@@ -132,19 +124,22 @@ public:
              }
              auto res = resf.get();
              std::visit(overloaded_functor {
-                [&] (std::string&& str) {
-                    // Note that despite the move, there is a copy here -
-                    // as str is std::string and rep->_content is sstring.
-                    rep->_content = std::move(str);
-                    rep->set_content_type(REPLY_CONTENT_TYPE);
-                },
-                [&] (executor::body_writer&& body_writer) {
-                    rep->write_body(REPLY_CONTENT_TYPE, std::move(body_writer));
-                },
-                [&] (const api_error& err) {
-                    generate_error_reply(*rep, err);
-                }
-             }, std::move(res));
+                 [&] (const json::json_return_type& json_return_value) {
+                     slogger.trace("api_handler success case");
+                     if (json_return_value._body_writer) {
+                         // Unfortunately, write_body() forces us to choose
+                         // from a fixed and irrelevant list of "mime-types"
+                         // at this point. But we'll override it with the
+                         // one (application/x-amz-json-1.0) below.
+                         rep->write_body("json", std::move(json_return_value._body_writer));
+                     } else {
+                         rep->_content += json_return_value._res;
+                     }
+                 },
+                 [&] (const api_error& err) {
+                     generate_error_reply(*rep, err);
+                 }
+             }, res);
 
              return make_ready_future<std::unique_ptr<reply>>(std::move(rep));
          });
@@ -156,6 +151,7 @@ public:
         handle_CORS(*req, *rep, false);
         return _f_handle(std::move(req), std::move(rep)).then(
                 [](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));
                 });
@@ -171,7 +167,6 @@ protected:
         rjson::add(results, "message", err._msg);
         rep._content = rjson::print(std::move(results));
         rep._status = err._http_code;
-        rep.set_content_type(REPLY_CONTENT_TYPE);
         slogger.trace("api_handler error case: {}", rep._content);
     }
 
@@ -233,8 +228,9 @@ protected:
         // If the rack does not exist, we return an empty list - not an error.
         sstring query_rack = req->get_query_param("rack");
         for (auto& id : local_dc_nodes) {
+            auto ip = _gossiper.get_address_map().get(id);
             if (!query_rack.empty()) {
-                auto rack = _gossiper.get_application_state_value(id, gms::application_state::RACK);
+                auto rack = _gossiper.get_application_state_value(ip, gms::application_state::RACK);
                 if (rack != query_rack) {
                     continue;
                 }
@@ -242,10 +238,10 @@ protected:
             // Note that it's not enough for the node to be is_alive() - a
             // node joining the cluster is also "alive" but not responsive to
             // requests. We alive *and* normal. See #19694, #21538.
-            if (_gossiper.is_alive(id) && _gossiper.is_normal(id)) {
+            if (_gossiper.is_alive(ip) && _gossiper.is_normal(ip)) {
                 // Use the gossiped broadcast_rpc_address if available instead
                 // of the internal IP address "ip". See discussion in #18711.
-                rjson::push_back(results, rjson::from_string(_gossiper.get_rpc_address(id)));
+                rjson::push_back(results, rjson::from_string(_gossiper.get_rpc_address(ip)));
             }
         }
         rep->set_status(reply::status_type::ok);
@@ -271,57 +267,24 @@ protected:
     }
 };
 
-// This function increments the authentication_failures counter, and may also
-// log a warn-level message and/or throw an exception, depending on what
-// enforce_authorization and warn_authorization are set to.
-// The username and client address are only used for logging purposes -
-// they are not included in the error message returned to the client, since
-// the client knows who it is.
-// Note that if enforce_authorization is false, this function will return
-// without throwing. So a caller that doesn't want to continue after an
-// authentication_error must explicitly return after calling this function.
-template<typename Exception>
-static void authentication_error(alternator::stats& stats, bool enforce_authorization, bool warn_authorization, Exception&& e, std::string_view user, gms::inet_address client_address) {
-    stats.authentication_failures++;
-    if (enforce_authorization) {
-        if (warn_authorization) {
-            slogger.warn("alternator_warn_authorization=true: {} for user {}, client address {}", e.what(), user, client_address);
-        }
-        throw std::move(e);
-    } else {
-        if (warn_authorization) {
-            slogger.warn("If you set alternator_enforce_authorization=true the following will be enforced: {} for user {}, client address {}", e.what(), user, client_address);
-        }
-    }
-}
-
 future<std::string> server::verify_signature(const request& req, const chunked_content& content) {
-    if (!_enforce_authorization.get() && !_warn_authorization.get()) {
+    if (!_enforce_authorization) {
         slogger.debug("Skipping authorization");
         return make_ready_future<std::string>();
     }
     auto host_it = req._headers.find("Host");
     if (host_it == req._headers.end()) {
-        authentication_error(_executor._stats, _enforce_authorization.get(), _warn_authorization.get(),
-            api_error::invalid_signature("Host header is mandatory for signature verification"), 
-            "", req.get_client_address());
-        return make_ready_future<std::string>();
+        throw api_error::invalid_signature("Host header is mandatory for signature verification");
     }
     auto authorization_it = req._headers.find("Authorization");
     if (authorization_it == req._headers.end()) {
-        authentication_error(_executor._stats, _enforce_authorization.get(), _warn_authorization.get(),
-            api_error::missing_authentication_token("Authorization header is mandatory for signature verification"),
-            "", req.get_client_address());
-        return make_ready_future<std::string>();
+        throw api_error::missing_authentication_token("Authorization header is mandatory for signature verification");
     }
     std::string host = host_it->second;
     std::string_view authorization_header = authorization_it->second;
     auto pos = authorization_header.find_first_of(' ');
     if (pos == std::string_view::npos || authorization_header.substr(0, pos) != "AWS4-HMAC-SHA256") {
-        authentication_error(_executor._stats, _enforce_authorization.get(), _warn_authorization.get(),
-            api_error::invalid_signature(fmt::format("Authorization header must use AWS4-HMAC-SHA256 algorithm: {}", authorization_header)),
-            "", req.get_client_address());
-        return make_ready_future<std::string>();
+        throw api_error::invalid_signature(fmt::format("Authorization header must use AWS4-HMAC-SHA256 algorithm: {}", authorization_header));
     }
     authorization_header.remove_prefix(pos+1);
     std::string credential;
@@ -356,9 +319,7 @@ future<std::string> server::verify_signature(const request& req, const chunked_c
 
     std::vector<std::string_view> credential_split = split(credential, '/');
     if (credential_split.size() != 5) {
-        authentication_error(_executor._stats, _enforce_authorization.get(), _warn_authorization.get(),
-            api_error::validation(fmt::format("Incorrect credential information format: {}", credential)), "", req.get_client_address());
-        return make_ready_future<std::string>();
+        throw api_error::validation(fmt::format("Incorrect credential information format: {}", credential));
     }
     std::string user(credential_split[0]);
     std::string datestamp(credential_split[1]);
@@ -382,7 +343,7 @@ future<std::string> server::verify_signature(const request& req, const chunked_c
     auto cache_getter = [&proxy = _proxy, &as = _auth_service] (std::string username) {
         return get_key_from_roles(proxy, as, std::move(username));
     };
-    return _key_cache.get_ptr(user, cache_getter).then_wrapped([this, &req, &content,
+    return _key_cache.get_ptr(user, cache_getter).then([this, &req, &content,
                                                     user = std::move(user),
                                                     host = std::move(host),
                                                     datestamp = std::move(datestamp),
@@ -390,32 +351,18 @@ future<std::string> server::verify_signature(const request& req, const chunked_c
                                                     signed_headers_map = std::move(signed_headers_map),
                                                     region = std::move(region),
                                                     service = std::move(service),
-                                                    user_signature = std::move(user_signature)] (future<key_cache::value_ptr> key_ptr_fut) {
-        key_cache::value_ptr key_ptr(nullptr);
-        try {
-            key_ptr = key_ptr_fut.get();
-        } catch (const api_error& e) {
-            authentication_error(_executor._stats, _enforce_authorization.get(), _warn_authorization.get(),
-                e, user, req.get_client_address());
-            return std::string();
-        }
+                                                    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) {
-            authentication_error(_executor._stats, _enforce_authorization.get(), _warn_authorization.get(),
-                api_error::invalid_signature(fmt::format("invalid signature: {}", e.what())),
-                user, req.get_client_address());
-            return std::string();
+            throw api_error::invalid_signature(e.what());
         }
 
         if (signature != std::string_view(user_signature)) {
             _key_cache.remove(user);
-            authentication_error(_executor._stats, _enforce_authorization.get(), _warn_authorization.get(),
-                api_error::unrecognized_client("wrong signature"),
-                user, req.get_client_address());
-            return std::string();
+            throw api_error::unrecognized_client("The security token included in the request is invalid.");
         }
         return user;
     });
@@ -485,13 +432,6 @@ future<executor::request_return_type> server::handle_api_request(std::unique_ptr
     SCYLLA_ASSERT(req->content_stream);
     chunked_content content = co_await util::read_entire_stream(*req->content_stream);
     auto username = co_await verify_signature(*req, content);
-    // As long as the system_clients_entry object is alive, this request will
-    // be visible in the "system.clients" virtual table. When requested, this
-    // entry will be formatted by server::ongoing_request::make_client_data().
-    auto system_clients_entry = _ongoing_requests.emplace(
-        req->get_client_address(), req->get_header("User-Agent"),
-        username, current_scheduling_group(),
-        req->get_protocol_name() == "https");
 
     if (slogger.is_enabled(log_level::trace)) {
         std::string buf;
@@ -523,9 +463,6 @@ future<executor::request_return_type> server::handle_api_request(std::unique_ptr
             client_state = std::move(client_state), trace_state = std::move(trace_state),
             units = std::move(units), req = std::move(req)] () mutable -> future<executor::request_return_type> {
                 rjson::value json_request = co_await _json_parser.parse(std::move(content));
-                if (!json_request.IsObject()) {
-                    co_return api_error::validation("Request content must be an object");
-                }
                 co_return co_await callback(_executor, client_state, trace_state,
                     make_service_permit(std::move(units)), std::move(json_request), std::move(req));
     };
@@ -568,7 +505,7 @@ server::server(executor& exec, service::storage_proxy& proxy, gms::gossiper& gos
         , _key_cache(1024, 1min, slogger)
         , _enforce_authorization(false)
         , _enabled_servers{}
-        , _pending_requests("alternator::server::pending_requests")
+        , _pending_requests{}
         , _timeout_config(_proxy.data_dictionary().get_config())
       , _callbacks{
         {"CreateTable", [] (executor& e, executor::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit, rjson::value json_request, std::unique_ptr<request> req) {
@@ -647,11 +584,9 @@ server::server(executor& exec, service::storage_proxy& proxy, gms::gossiper& gos
 }
 
 future<> server::init(net::inet_address addr, std::optional<uint16_t> port, std::optional<uint16_t> https_port, std::optional<tls::credentials_builder> creds,
-        utils::updateable_value<bool> enforce_authorization, utils::updateable_value<bool> warn_authorization,
-        semaphore* memory_limiter, utils::updateable_value<uint32_t> max_concurrent_requests) {
+        utils::updateable_value<bool> enforce_authorization, semaphore* memory_limiter, utils::updateable_value<uint32_t> max_concurrent_requests) {
     _memory_limiter = memory_limiter;
     _enforce_authorization = std::move(enforce_authorization);
-    _warn_authorization = std::move(warn_authorization);
     _max_concurrent_requests = std::move(max_concurrent_requests);
     if (!port && !https_port) {
         return make_exception_future<>(std::runtime_error("Either regular port or TLS port"
@@ -744,37 +679,6 @@ future<> server::json_parser::stop() {
     return std::move(_run_parse_json_thread);
 }
 
-// Convert an entry in the server's list of ongoing Alternator requests
-// (_ongoing_requests) into a client_data object. This client_data object
-// will then be used to produce a row for the "system.clients" virtual table.
-client_data server::ongoing_request::make_client_data() const {
-    client_data cd;
-    cd.ct = client_type::alternator;
-    cd.ip = _client_address.addr();
-    cd.port = _client_address.port();
-    cd.shard_id = this_shard_id();
-    cd.connection_stage = client_connection_stage::established;
-    cd.username = _username;
-    cd.scheduling_group_name = _scheduling_group.name();
-    cd.ssl_enabled = _is_https;
-    // For now, we save the full User-Agent header as the "driver name"
-    // and keep "driver_version" unset.
-    cd.driver_name = _user_agent;
-    // Leave "protocol_version" unset, it has no meaning in Alternator.
-    // Leave "hostname", "ssl_protocol" and "ssl_cipher_suite" unset.
-    // As reported in issue #9216, we never set these fields in CQL
-    // either (see cql_server::connection::make_client_data()).
-    return cd;
-}
-
-future<utils::chunked_vector<client_data>> server::get_client_data() {
-    utils::chunked_vector<client_data> ret;
-    co_await _ongoing_requests.for_each_gently([&ret] (const ongoing_request& r) {
-        ret.emplace_back(r.make_client_data());
-    });
-    co_return ret;
-}
-
 const char* api_error::what() const noexcept {
     if (_what_string.empty()) {
         _what_string = fmt::format("{} {}: {}", std::to_underlying(_http_code), _type, _msg);

alternator/server.hh

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "alternator/executor.hh"
-#include "utils/scoped_item_list.hh"
 #include <seastar/core/future.hh>
 #include <seastar/core/condition-variable.hh>
 #include <seastar/http/httpd.hh>
@@ -21,8 +20,6 @@
 #include "utils/updateable_value.hh"
 #include <seastar/core/units.hh>
 
-struct client_data;
-
 namespace alternator {
 
 using chunked_content = rjson::chunked_content;
@@ -43,9 +40,8 @@ class server : public peering_sharded_service<server> {
 
     key_cache _key_cache;
     utils::updateable_value<bool> _enforce_authorization;
-    utils::updateable_value<bool> _warn_authorization;
     utils::small_vector<std::reference_wrapper<seastar::httpd::http_server>, 2> _enabled_servers;
-    named_gate _pending_requests;
+    gate _pending_requests;
     // In some places we will need a CQL updateable_timeout_config object even
     // though it isn't really relevant for Alternator which defines its own
     // timeouts separately. We can create this object only once.
@@ -78,31 +74,12 @@ class server : public peering_sharded_service<server> {
     };
     json_parser _json_parser;
 
-    // The server maintains a list of ongoing requests, that are being handled
-    // by handle_api_request(). It uses this list in get_client_data(), which
-    // is called when reading the "system.clients" virtual table.
-    struct ongoing_request {
-        socket_address _client_address;
-        sstring _user_agent;
-        sstring _username;
-        scheduling_group _scheduling_group;
-        bool _is_https;
-        client_data make_client_data() const;
-    };
-    utils::scoped_item_list<ongoing_request> _ongoing_requests;
-
 public:
     server(executor& executor, service::storage_proxy& proxy, gms::gossiper& gossiper, auth::service& service, qos::service_level_controller& sl_controller);
 
     future<> init(net::inet_address addr, std::optional<uint16_t> port, std::optional<uint16_t> https_port, std::optional<tls::credentials_builder> creds,
-            utils::updateable_value<bool> enforce_authorization, utils::updateable_value<bool> warn_authorization,
-            semaphore* memory_limiter, utils::updateable_value<uint32_t> max_concurrent_requests);
+            utils::updateable_value<bool> enforce_authorization, semaphore* memory_limiter, utils::updateable_value<uint32_t> max_concurrent_requests);
     future<> stop();
-    // get_client_data() is called (on each shard separately) when the virtual
-    // table "system.clients" is read. It is expected to generate a list of
-    // clients connected to this server (on this shard). This function is
-    // called by alternator::controller::get_client_data().
-    future<utils::chunked_vector<client_data>> get_client_data();
 private:
     void set_routes(seastar::httpd::routes& r);
     // If verification succeeds, returns the authenticated user's username

alternator/stats.cc

@@ -14,58 +14,28 @@
 namespace alternator {
 
 const char* ALTERNATOR_METRICS = "alternator";
-static seastar::metrics::histogram estimated_histogram_to_metrics(const utils::estimated_histogram& histogram) {
-    seastar::metrics::histogram res;
-    res.buckets.resize(histogram.bucket_offsets.size());
-    uint64_t cumulative_count = 0;
-    res.sample_count = histogram._count;
-    res.sample_sum = histogram._sample_sum;
-    for (size_t i = 0; i < res.buckets.size(); i++) {
-        auto& v = res.buckets[i];
-        v.upper_bound = histogram.bucket_offsets[i];
-        cumulative_count += histogram.buckets[i];
-        v.count = cumulative_count;
-    }
-    return res;
-}
-
-static seastar::metrics::label column_family_label("cf");
-static seastar::metrics::label keyspace_label("ks");
-
-
-static void register_metrics_with_optional_table(seastar::metrics::metric_groups& metrics, const stats& stats, const sstring& ks, const sstring& table) {
 
+stats::stats() : api_operations{} {
     // Register the
     seastar::metrics::label op("op");
-    bool has_table = table.length();
-    std::vector<seastar::metrics::label> aggregate_labels;
-    std::vector<seastar::metrics::label_instance> labels = {alternator_label};
-    sstring group_name = (has_table)? "alternator_table" : "alternator";
-    if (has_table) {
-        labels.push_back(column_family_label(table));
-        labels.push_back(keyspace_label(ks));
-        aggregate_labels.push_back(seastar::metrics::shard_label);
-    }
-    metrics.add_group(group_name, {
-#define OPERATION(name, CamelCaseName) \
-                seastar::metrics::make_total_operations("operation", stats.api_operations.name, \
-                        seastar::metrics::description("number of operations via Alternator API"), labels)(basic_level)(op(CamelCaseName)).aggregate(aggregate_labels).set_skip_when_empty(),
-#define OPERATION_LATENCY(name, CamelCaseName) \
-		metrics.add_group(group_name, { \
-                seastar::metrics::make_histogram("op_latency", \
-                        seastar::metrics::description("Latency histogram of an operation via Alternator API"), labels, [&stats]{return to_metrics_histogram(stats.api_operations.name.histogram());})(op(CamelCaseName))(basic_level).aggregate({seastar::metrics::shard_label}).set_skip_when_empty()}); \
-            if (!has_table) {\
-            	metrics.add_group("alternator", { \
-				seastar::metrics::make_summary("op_latency_summary", \
-						                        seastar::metrics::description("Latency summary of an operation via Alternator API"), [&stats]{return to_metrics_summary(stats.api_operations.name.summary());})(op(CamelCaseName))(basic_level)(alternator_label).set_skip_when_empty()}); \
-            }
 
+    _metrics.add_group("alternator", {
+#define OPERATION(name, CamelCaseName) \
+                seastar::metrics::make_total_operations("operation", api_operations.name, \
+                        seastar::metrics::description("number of operations via Alternator API"), {op(CamelCaseName), alternator_label, basic_level}).set_skip_when_empty(),
+#define OPERATION_LATENCY(name, CamelCaseName) \
+                seastar::metrics::make_histogram("op_latency", \
+                        seastar::metrics::description("Latency histogram of an operation via Alternator API"), {op(CamelCaseName), alternator_label, basic_level}, [this]{return to_metrics_histogram(api_operations.name.histogram());}).aggregate({seastar::metrics::shard_label}).set_skip_when_empty(), \
+				seastar::metrics::make_summary("op_latency_summary", \
+						                        seastar::metrics::description("Latency summary of an operation via Alternator API"), [this]{return to_metrics_summary(api_operations.name.summary());})(op(CamelCaseName))(basic_level)(alternator_label).set_skip_when_empty(),
             OPERATION(batch_get_item, "BatchGetItem")
             OPERATION(batch_write_item, "BatchWriteItem")
             OPERATION(create_backup, "CreateBackup")
             OPERATION(create_global_table, "CreateGlobalTable")
+            OPERATION(create_table, "CreateTable")
             OPERATION(delete_backup, "DeleteBackup")
             OPERATION(delete_item, "DeleteItem")
+            OPERATION(delete_table, "DeleteTable")
             OPERATION(describe_backup, "DescribeBackup")
             OPERATION(describe_continuous_backups, "DescribeContinuousBackups")
             OPERATION(describe_endpoints, "DescribeEndpoints")
@@ -94,105 +64,55 @@ static void register_metrics_with_optional_table(seastar::metrics::metric_groups
             OPERATION(update_item, "UpdateItem")
             OPERATION(update_table, "UpdateTable")
             OPERATION(update_time_to_live, "UpdateTimeToLive")
+            OPERATION_LATENCY(put_item_latency, "PutItem")
+            OPERATION_LATENCY(get_item_latency, "GetItem")
+            OPERATION_LATENCY(delete_item_latency, "DeleteItem")
+            OPERATION_LATENCY(update_item_latency, "UpdateItem")
+            OPERATION_LATENCY(batch_write_item_latency, "BatchWriteItem")
+            OPERATION_LATENCY(batch_get_item_latency, "BatchGetItem")
             OPERATION(list_streams, "ListStreams")
             OPERATION(describe_stream, "DescribeStream")
             OPERATION(get_shard_iterator, "GetShardIterator")
             OPERATION(get_records, "GetRecords")
+            OPERATION_LATENCY(get_records_latency, "GetRecords")
     });
-    OPERATION_LATENCY(put_item_latency, "PutItem")
-    OPERATION_LATENCY(get_item_latency, "GetItem")
-    OPERATION_LATENCY(delete_item_latency, "DeleteItem")
-    OPERATION_LATENCY(update_item_latency, "UpdateItem")
-    OPERATION_LATENCY(batch_write_item_latency, "BatchWriteItem")
-    OPERATION_LATENCY(batch_get_item_latency, "BatchGetItem")
-    OPERATION_LATENCY(get_records_latency, "GetRecords")
-    if (!has_table) {
-        // Create and delete operations are not applicable to a per-table metrics
-        // only register it for the global metrics
-        metrics.add_group("alternator", {
-            OPERATION(create_table, "CreateTable")
-            OPERATION(delete_table, "DeleteTable")
-
-        });
-    }
-    metrics.add_group(group_name, {
-            seastar::metrics::make_total_operations("unsupported_operations", stats.unsupported_operations,
-                    seastar::metrics::description("number of unsupported operations via Alternator API"), labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("total_operations", stats.total_operations,
-                    seastar::metrics::description("number of total operations via Alternator API"), labels)(basic_level).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("reads_before_write", stats.reads_before_write,
-                    seastar::metrics::description("number of performed read-before-write operations"), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("write_using_lwt", stats.write_using_lwt,
-                    seastar::metrics::description("number of writes that used LWT"), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("shard_bounce_for_lwt", stats.shard_bounce_for_lwt,
-                    seastar::metrics::description("number writes that had to be bounced from this shard because of LWT requirements"), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("requests_blocked_memory", stats.requests_blocked_memory,
-                    seastar::metrics::description("Counts a number of requests blocked due to memory pressure."), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("requests_shed", stats.requests_shed,
-                    seastar::metrics::description("Counts a number of requests shed due to overload."), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("filtered_rows_read_total", stats.cql_stats.filtered_rows_read_total,
-                    seastar::metrics::description("number of rows read during filtering operations"), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("filtered_rows_matched_total", stats.cql_stats.filtered_rows_matched_total,
-                    seastar::metrics::description("number of rows read and matched during filtering operations"), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_counter("rcu_total", [&stats]{return 0.5 * stats.rcu_half_units_total;},
-                    seastar::metrics::description("total number of consumed read units"), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_counter("wcu_total", stats.wcu_total[stats::wcu_types::PUT_ITEM],
-                    seastar::metrics::description("total number of consumed write units"), labels)(op("PutItem")).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_counter("wcu_total", stats.wcu_total[stats::wcu_types::DELETE_ITEM],
-                    seastar::metrics::description("total number of consumed write units"), labels)(op("DeleteItem")).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_counter("wcu_total", stats.wcu_total[stats::wcu_types::UPDATE_ITEM],
-                    seastar::metrics::description("total number of consumed write units"), labels)(op("UpdateItem")).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_counter("wcu_total", stats.wcu_total[stats::wcu_types::INDEX],
-                    seastar::metrics::description("total number of consumed write units"), labels)(op("Index")).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("filtered_rows_dropped_total", [&stats] { return stats.cql_stats.filtered_rows_read_total - stats.cql_stats.filtered_rows_matched_total; },
-                    seastar::metrics::description("number of rows read and dropped during filtering operations"), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_counter("batch_item_count", seastar::metrics::description("The total number of items processed across all batches"), labels,
-                    stats.api_operations.batch_write_item_batch_total)(op("BatchWriteItem")).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_counter("batch_item_count", seastar::metrics::description("The total number of items processed across all batches"), labels,
-                    stats.api_operations.batch_get_item_batch_total)(op("BatchGetItem")).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_histogram("batch_item_count_histogram", seastar::metrics::description("Histogram of the number of items in a batch request"), labels,
-                    [&stats]{ return estimated_histogram_to_metrics(stats.api_operations.batch_get_item_histogram);})(op("BatchGetItem")).aggregate({seastar::metrics::shard_label}).set_skip_when_empty(),
-            seastar::metrics::make_histogram("batch_item_count_histogram", seastar::metrics::description("Histogram of the number of items in a batch request"), labels,
-                    [&stats]{ return estimated_histogram_to_metrics(stats.api_operations.batch_write_item_histogram);})(op("BatchWriteItem")).aggregate({seastar::metrics::shard_label}).set_skip_when_empty(),
+    _metrics.add_group("alternator", {
+            seastar::metrics::make_total_operations("unsupported_operations", unsupported_operations,
+                    seastar::metrics::description("number of unsupported operations via Alternator API"))(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_total_operations("total_operations", total_operations,
+                    seastar::metrics::description("number of total operations via Alternator API"))(basic_level)(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_total_operations("reads_before_write", reads_before_write,
+                    seastar::metrics::description("number of performed read-before-write operations"))(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_total_operations("write_using_lwt", write_using_lwt,
+                    seastar::metrics::description("number of writes that used LWT"))(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_total_operations("shard_bounce_for_lwt", shard_bounce_for_lwt,
+                    seastar::metrics::description("number writes that had to be bounced from this shard because of LWT requirements"))(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_total_operations("requests_blocked_memory", requests_blocked_memory,
+                    seastar::metrics::description("Counts a number of requests blocked due to memory pressure."))(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_total_operations("requests_shed", requests_shed,
+                    seastar::metrics::description("Counts a number of requests shed due to overload."))(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_total_operations("filtered_rows_read_total", cql_stats.filtered_rows_read_total,
+                    seastar::metrics::description("number of rows read during filtering operations"))(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_total_operations("filtered_rows_matched_total", cql_stats.filtered_rows_matched_total,
+                    seastar::metrics::description("number of rows read and matched during filtering operations")),
+            seastar::metrics::make_counter("rcu_total", rcu_total,
+                    seastar::metrics::description("total number of consumed read units, counted as half units"))(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_counter("wcu_total", wcu_total[wcu_types::PUT_ITEM],
+                    seastar::metrics::description("total number of consumed write units, counted as half units"),{op("PutItem")})(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_counter("wcu_total", wcu_total[wcu_types::DELETE_ITEM],
+                    seastar::metrics::description("total number of consumed write units, counted as half units"),{op("DeleteItem")})(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_counter("wcu_total", wcu_total[wcu_types::UPDATE_ITEM],
+                    seastar::metrics::description("total number of consumed write units, counted as half units"),{op("UpdateItem")})(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_counter("wcu_total", wcu_total[wcu_types::INDEX],
+                    seastar::metrics::description("total number of consumed write units, counted as half units"),{op("Index")})(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_total_operations("filtered_rows_dropped_total", [this] { return cql_stats.filtered_rows_read_total - cql_stats.filtered_rows_matched_total; },
+                    seastar::metrics::description("number of rows read and dropped during filtering operations"))(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_counter("batch_item_count", seastar::metrics::description("The total number of items processed across all batches"),{op("BatchWriteItem")},
+                    api_operations.batch_write_item_batch_total)(alternator_label).set_skip_when_empty(),
+            seastar::metrics::make_counter("batch_item_count", seastar::metrics::description("The total number of items processed across all batches"),{op("BatchGetItem")},
+                    api_operations.batch_get_item_batch_total)(alternator_label).set_skip_when_empty(),
     });
-
-    seastar::metrics::label expression_label("expression");
-    metrics.add_group(group_name, {
-            seastar::metrics::make_total_operations("expression_cache_evictions", stats.expression_cache.evictions,
-                    seastar::metrics::description("Counts number of entries evicted from expressions cache"), labels).aggregate(aggregate_labels).set_skip_when_empty(),
-
-            seastar::metrics::make_total_operations("expression_cache_hits", stats.expression_cache.requests[stats::expression_types::UPDATE_EXPRESSION].hits,
-                    seastar::metrics::description("Counts number of hits of cached expressions"), labels)(expression_label("UpdateExpression")).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("expression_cache_misses", stats.expression_cache.requests[stats::expression_types::UPDATE_EXPRESSION].misses,
-                    seastar::metrics::description("Counts number of misses of cached expressions"), labels)(expression_label("UpdateExpression")).aggregate(aggregate_labels).set_skip_when_empty(),
-            
-            seastar::metrics::make_total_operations("expression_cache_hits", stats.expression_cache.requests[stats::expression_types::CONDITION_EXPRESSION].hits,
-                    seastar::metrics::description("Counts number of hits of cached expressions"), labels)(expression_label("ConditionExpression")).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("expression_cache_misses", stats.expression_cache.requests[stats::expression_types::CONDITION_EXPRESSION].misses,
-                    seastar::metrics::description("Counts number of misses of cached expressions"), labels)(expression_label("ConditionExpression")).aggregate(aggregate_labels).set_skip_when_empty(),
-
-            seastar::metrics::make_total_operations("expression_cache_hits", stats.expression_cache.requests[stats::expression_types::PROJECTION_EXPRESSION].hits,
-                    seastar::metrics::description("Counts number of hits of cached expressions"), labels)(expression_label("ProjectionExpression")).aggregate(aggregate_labels).set_skip_when_empty(),
-            seastar::metrics::make_total_operations("expression_cache_misses", stats.expression_cache.requests[stats::expression_types::PROJECTION_EXPRESSION].misses,
-                    seastar::metrics::description("Counts number of misses of cached expressions"), labels)(expression_label("ProjectionExpression")).aggregate(aggregate_labels).set_skip_when_empty()
-    });
-
-    // Only register the following metrics for the global metrics, not per-table
-    if (!has_table) {
-        metrics.add_group("alternator", {
-            seastar::metrics::make_counter("authentication_failures", stats.authentication_failures,
-                seastar::metrics::description("total number of authentication failures"), labels).aggregate({seastar::metrics::shard_label}).set_skip_when_empty(),
-            seastar::metrics::make_counter("authorization_failures", stats.authorization_failures,
-                seastar::metrics::description("total number of authorization failures"), labels).aggregate({seastar::metrics::shard_label}).set_skip_when_empty(),
-        });
-    }
 }
 
-void register_metrics(seastar::metrics::metric_groups& metrics, const stats& stats) {
-    register_metrics_with_optional_table(metrics, stats, "", "");
-}
-table_stats::table_stats(const sstring& ks, const sstring& table) {
-    _stats = make_lw_shared<stats>();
-    register_metrics_with_optional_table(_metrics, *_stats, ks, table);
-}
+
 }

alternator/stats.hh

@@ -12,7 +12,6 @@
 
 #include <seastar/core/metrics_registration.hh>
 #include "utils/histogram.hh"
-#include "utils/estimated_histogram.hh"
 #include "cql3/stats.hh"
 
 namespace alternator {
@@ -22,6 +21,7 @@ namespace alternator {
 // visible by the metrics REST API, with the "alternator" prefix.
 class stats {
 public:
+    stats();
     // Count of DynamoDB API operations by types
     struct {
         uint64_t batch_get_item = 0;
@@ -75,21 +75,7 @@ public:
         utils::timed_rate_moving_average_summary_and_histogram batch_write_item_latency;
         utils::timed_rate_moving_average_summary_and_histogram batch_get_item_latency;
         utils::timed_rate_moving_average_summary_and_histogram get_records_latency;
-
-        utils::estimated_histogram batch_get_item_histogram{22}; // a histogram that covers the range 1 - 100
-        utils::estimated_histogram batch_write_item_histogram{22}; // a histogram that covers the range 1 - 100
     } api_operations;
-    // Count of authentication and authorization failures, counted if either
-    // alternator_enforce_authorization or alternator_warn_authorization are
-    // set to true. If both are false, no authentication or authorization
-    // checks are performed, so failures are not recognized or counted.
-    // "authentication" failure means the request was not signed with a valid
-    // user and key combination. "authorization" failure means the request was
-    // authenticated to a valid user - but this user did not have permissions
-    // to perform the operation (considering RBAC settings and the user's
-    // superuser status).
-    uint64_t authentication_failures = 0;
-    uint64_t authorization_failures = 0;
     // Miscellaneous event counters
     uint64_t total_operations = 0;
     uint64_t unsupported_operations = 0;
@@ -98,7 +84,7 @@ public:
     uint64_t shard_bounce_for_lwt = 0;
     uint64_t requests_blocked_memory = 0;
     uint64_t requests_shed = 0;
-    uint64_t rcu_half_units_total = 0;
+    uint64_t rcu_total = 0;
     // wcu can results from put, update, delete and index
     // Index related will be done on top of the operation it comes with
     enum wcu_types {
@@ -112,29 +98,10 @@ public:
     uint64_t wcu_total[NUM_TYPES] = {0};
     // CQL-derived stats
     cql3::cql_stats cql_stats;
-
-    // Enumeration of expression types only for stats
-    // if needed it can be extended e.g. per operation 
-    enum expression_types {
-        UPDATE_EXPRESSION,
-        CONDITION_EXPRESSION,
-        PROJECTION_EXPRESSION,
-        NUM_EXPRESSION_TYPES
-    };
-    struct {
-        struct {
-            uint64_t hits = 0;
-            uint64_t misses = 0;
-        } requests[NUM_EXPRESSION_TYPES];
-        uint64_t evictions = 0;
-    } expression_cache;
-};
-
-struct table_stats {
-    table_stats(const sstring& ks, const sstring& table);
+private:
+    // The metric_groups object holds this stat object's metrics registered
+    // as long as the stats object is alive.
     seastar::metrics::metric_groups _metrics;
-    lw_shared_ptr<stats> _stats;
 };
-void register_metrics(seastar::metrics::metric_groups& metrics, const stats& stats);
 
 }

alternator/streams.cc

@@ -32,7 +32,6 @@
 
 #include "executor.hh"
 #include "data_dictionary/data_dictionary.hh"
-#include "utils/rjson.hh"
 
 /**
  * Base template type to implement  rapidjson::internal::TypeHelper<...>:s
@@ -218,7 +217,7 @@ future<alternator::executor::request_return_type> alternator::executor::list_str
         rjson::add(ret, "LastEvaluatedStreamArn", *last);
     }
 
-    return make_ready_future<executor::request_return_type>(rjson::print(std::move(ret)));
+    return make_ready_future<executor::request_return_type>(make_jsonable(std::move(ret)));
 }
 
 struct shard_id {
@@ -492,7 +491,7 @@ future<executor::request_return_type> executor::describe_stream(client_state& cl
 
     if (!opts.enabled()) {
         rjson::add(ret, "StreamDescription", std::move(stream_desc));
-        return make_ready_future<executor::request_return_type>(rjson::print(std::move(ret)));
+        return make_ready_future<executor::request_return_type>(make_jsonable(std::move(ret)));
     }
 
     // TODO: label
@@ -618,7 +617,7 @@ future<executor::request_return_type> executor::describe_stream(client_state& cl
         rjson::add(stream_desc, "Shards", std::move(shards));
         rjson::add(ret, "StreamDescription", std::move(stream_desc));
             
-        return make_ready_future<executor::request_return_type>(rjson::print(std::move(ret)));
+        return make_ready_future<executor::request_return_type>(make_jsonable(std::move(ret)));
     });
 }
 
@@ -771,7 +770,7 @@ future<executor::request_return_type> executor::get_shard_iterator(client_state&
     auto ret = rjson::empty_object();
     rjson::add(ret, "ShardIterator", iter);
 
-    return make_ready_future<executor::request_return_type>(rjson::print(std::move(ret)));
+    return make_ready_future<executor::request_return_type>(make_jsonable(std::move(ret)));
 }
 
 struct event_id {
@@ -809,9 +808,6 @@ future<executor::request_return_type> executor::get_records(client_state& client
     if (limit < 1) {
         throw api_error::validation("Limit must be 1 or more");
     }
-    if (limit > 1000) {
-        throw api_error::validation("Limit must be less than or equal to 1000");
-    }
 
     auto db = _proxy.data_dictionary();
     schema_ptr schema, base;
@@ -828,7 +824,7 @@ future<executor::request_return_type> executor::get_records(client_state& client
 
     tracing::add_table_name(trace_state, schema->ks_name(), schema->cf_name());
 
-    co_await verify_permission(_enforce_authorization, _warn_authorization, client_state, schema, auth::permission::SELECT, _stats);
+    co_await verify_permission(_enforce_authorization, client_state, schema, auth::permission::SELECT);
 
     db::consistency_level cl = db::consistency_level::LOCAL_QUORUM;
     partition_key pk = iter.shard.id.to_partition_key(*schema);
@@ -872,12 +868,10 @@ future<executor::request_return_type> executor::get_records(client_state& client
 
     std::transform(pks.begin(), pks.end(), std::back_inserter(columns), [](auto& c) { return &c; });
     std::transform(cks.begin(), cks.end(), std::back_inserter(columns), [](auto& c) { return &c; });
-    auto regular_column_start_idx = columns.size();
-    auto regular_column_filter = std::views::filter([](const column_definition& cdef) { return cdef.name() == op_column_name || cdef.name() == eor_column_name || !cdc::is_cdc_metacolumn_name(cdef.name_as_text()); });
-    std::ranges::transform(schema->regular_columns() | regular_column_filter, std::back_inserter(columns), [](auto& c) { return &c; });
 
-    auto regular_columns = std::ranges::subrange(columns.begin() + regular_column_start_idx, columns.end())
-        | std::views::transform(&column_definition::id)
+    auto regular_columns = schema->regular_columns()
+        | std::views::filter([](const column_definition& cdef) { return cdef.name() == op_column_name || cdef.name() == eor_column_name || !cdc::is_cdc_metacolumn_name(cdef.name_as_text()); })
+        | std::views::transform([&] (const column_definition& cdef) { columns.emplace_back(&cdef); return cdef.id; })
         | std::ranges::to<query::column_id_vector>()
     ;
 
@@ -928,7 +922,6 @@ future<executor::request_return_type> executor::get_records(client_state& client
         std::optional<utils::UUID> timestamp;
         auto dynamodb = rjson::empty_object();
         auto record = rjson::empty_object();
-        const auto dc_name = _proxy.get_token_metadata_ptr()->get_topology().get_datacenter();
 
         using op_utype = std::underlying_type_t<cdc::operation>;
 
@@ -938,10 +931,9 @@ future<executor::request_return_type> executor::get_records(client_state& client
                 dynamodb = rjson::empty_object();
             }
             if (!record.ObjectEmpty()) {
-                rjson::add(record, "awsRegion", rjson::from_string(dc_name));
+                // TODO: awsRegion?
                 rjson::add(record, "eventID", event_id(iter.shard.id, *timestamp));
                 rjson::add(record, "eventSource", "scylladb:alternator");
-                rjson::add(record, "eventVersion", "1.0");
                 rjson::push_back(records, std::move(record));
                 record = rjson::empty_object();
                 --limit;
@@ -960,7 +952,7 @@ future<executor::request_return_type> executor::get_records(client_state& client
                 rjson::add(dynamodb, "ApproximateCreationDateTime", utils::UUID_gen::unix_timestamp_in_sec(ts).count());
                 rjson::add(dynamodb, "SequenceNumber", sequence_number(ts));
                 rjson::add(dynamodb, "StreamViewType", type);
-                // TODO: SizeBytes
+                //TODO: SizeInBytes
             }
 
             /**
@@ -1026,7 +1018,7 @@ future<executor::request_return_type> executor::get_records(client_state& client
             // will notice end end of shard and not return NextShardIterator.
             rjson::add(ret, "NextShardIterator", next_iter);
             _stats.api_operations.get_records_latency.mark(std::chrono::steady_clock::now() - start_time);
-            return make_ready_future<executor::request_return_type>(rjson::print(std::move(ret)));
+            return make_ready_future<executor::request_return_type>(make_jsonable(std::move(ret)));
         }
 
         // ugh. figure out if we are and end-of-shard
@@ -1052,12 +1044,12 @@ future<executor::request_return_type> executor::get_records(client_state& client
             if (is_big(ret)) {
                 return make_ready_future<executor::request_return_type>(make_streamed(std::move(ret)));
             }
-            return make_ready_future<executor::request_return_type>(rjson::print(std::move(ret)));
+            return make_ready_future<executor::request_return_type>(make_jsonable(std::move(ret)));
         });
     });
 }
 
-bool executor::add_stream_options(const rjson::value& stream_specification, schema_builder& builder, service::storage_proxy& sp) {
+void executor::add_stream_options(const rjson::value& stream_specification, schema_builder& builder, service::storage_proxy& sp) {
     auto stream_enabled = rjson::find(stream_specification, "StreamEnabled");
     if (!stream_enabled || !stream_enabled->IsBool()) {
         throw api_error::validation("StreamSpecification needs boolean StreamEnabled");
@@ -1091,12 +1083,10 @@ bool executor::add_stream_options(const rjson::value& stream_specification, sche
                 break;
         }
         builder.with_cdc_options(opts);
-        return true;
     } else {
         cdc::options opts;
         opts.enabled(false);
         builder.with_cdc_options(opts);
-        return false;
     }
 }
 

alternator/ttl.cc

@@ -27,7 +27,7 @@
 #include "replica/database.hh"
 #include "service/client_state.hh"
 #include "service_permit.hh"
-#include "mutation/timestamp.hh"
+#include "timestamp.hh"
 #include "service/storage_proxy.hh"
 #include "service/pager/paging_state.hh"
 #include "service/pager/query_pagers.hh"
@@ -56,14 +56,14 @@ static logging::logger tlogger("alternator_ttl");
 
 namespace alternator {
 
-// We write the expiration-time attribute enabled on a table in a
+// We write the expiration-time attribute enabled on a table using a
 // tag TTL_TAG_KEY.
 // Currently, the *value* of this tag is simply the name of the attribute,
 // and the expiration scanner interprets it as an Alternator attribute name -
 // It can refer to a real column or if that doesn't exist, to a member of
 // the ":attrs" map column. Although this is designed for Alternator, it may
 // be good enough for CQL as well (there, the ":attrs" column won't exist).
-extern const sstring TTL_TAG_KEY;
+static const sstring TTL_TAG_KEY("system:ttl_attribute");
 
 future<executor::request_return_type> executor::update_time_to_live(client_state& client_state, service_permit permit, rjson::value request) {
     _stats.api_operations.update_time_to_live++;
@@ -81,6 +81,11 @@ future<executor::request_return_type> executor::update_time_to_live(client_state
         co_return api_error::validation("UpdateTimeToLive requires boolean Enabled");
     }
     bool enabled = v->GetBool();
+    // Alternator TTL doesn't yet work when the table uses tablets (#16567)
+    if (enabled && _proxy.local_db().find_keyspace(schema->ks_name()).get_replication_strategy().uses_tablets()) {
+        co_return api_error::validation("TTL not yet supported on a table using tablets (issue #16567). "
+            "Create a table with the tag 'experimental:initial_tablets' set to 'none' to use vnodes.");
+    }
     v = rjson::find(*spec, "AttributeName");
     if (!v || !v->IsString()) {
         co_return api_error::validation("UpdateTimeToLive requires string AttributeName");
@@ -94,7 +99,7 @@ future<executor::request_return_type> executor::update_time_to_live(client_state
     }
     sstring attribute_name(v->GetString(), v->GetStringLength());
 
-    co_await verify_permission(_enforce_authorization, _warn_authorization, client_state, schema, auth::permission::ALTER, _stats);
+    co_await verify_permission(_enforce_authorization, client_state, schema, auth::permission::ALTER);
     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)) {
@@ -118,7 +123,7 @@ future<executor::request_return_type> executor::update_time_to_live(client_state
     // basically identical to the request's
     rjson::value response = rjson::empty_object();
     rjson::add(response, "TimeToLiveSpecification", std::move(*spec));
-    co_return rjson::print(std::move(response));
+    co_return make_jsonable(std::move(response));
 }
 
 future<executor::request_return_type> executor::describe_time_to_live(client_state& client_state, service_permit permit, rjson::value request) {
@@ -135,7 +140,7 @@ future<executor::request_return_type> executor::describe_time_to_live(client_sta
     }
     rjson::value response = rjson::empty_object();
     rjson::add(response, "TimeToLiveDescription", std::move(desc));
-    co_return rjson::print(std::move(response));
+    co_return make_jsonable(std::move(response));
 }
 
 // expiration_service is a sharded service responsible for cleaning up expired
@@ -286,7 +291,7 @@ static future<> expire_item(service::storage_proxy& proxy,
         auto ck = clustering_key::from_exploded(exploded_ck);
         m.partition().clustered_row(*schema, ck).apply(tombstone(ts, gc_clock::now()));
     }
-    utils::chunked_vector<mutation> mutations;
+    std::vector<mutation> mutations;
     mutations.push_back(std::move(m));
     return proxy.mutate(std::move(mutations),
         db::consistency_level::LOCAL_QUORUM,
@@ -310,10 +315,8 @@ static size_t random_offset(size_t min, size_t max) {
 // this range's primary node is down. For this we need to return not just
 // a list of this node's secondary ranges - but also the primary owner of
 // each of those ranges.
-//
-// The function is to be used with vnodes only
 static future<std::vector<std::pair<dht::token_range, locator::host_id>>> get_secondary_ranges(
-        const locator::effective_replication_map* erm,
+        const locator::effective_replication_map_ptr& erm,
         locator::host_id ep) {
     const auto& tm = *erm->get_token_metadata_ptr();
     const auto& sorted_tokens = tm.sorted_tokens();
@@ -324,7 +327,6 @@ static future<std::vector<std::pair<dht::token_range, locator::host_id>>> get_se
     auto prev_tok = sorted_tokens.back();
     for (const auto& tok : sorted_tokens) {
         co_await coroutine::maybe_yield();
-        // FIXME: pass is_vnode=true to get_natural_replicas since the token is in tm.sorted_tokens()
         host_id_vector_replica_set eps = erm->get_natural_replicas(tok);
         if (eps.size() <= 1 || eps[1] != ep) {
             prev_tok = tok;
@@ -394,7 +396,7 @@ class ranges_holder_primary {
     dht::token_range_vector _token_ranges;
 public:
     explicit ranges_holder_primary(dht::token_range_vector token_ranges) : _token_ranges(std::move(token_ranges)) {}
-    static future<ranges_holder_primary> make(const locator::vnode_effective_replication_map* erm, locator::host_id ep) {
+    static future<ranges_holder_primary> make(const locator::vnode_effective_replication_map_ptr& erm, locator::host_id ep) {
         co_return ranges_holder_primary(co_await erm->get_primary_ranges(ep));
     }
     std::size_t size() const { return _token_ranges.size(); }
@@ -414,7 +416,7 @@ public:
     explicit ranges_holder_secondary(std::vector<std::pair<dht::token_range, locator::host_id>> token_ranges, const gms::gossiper& g)
         : _token_ranges(std::move(token_ranges))
         , _gossiper(g) {}
-    static future<ranges_holder_secondary> make(const locator::vnode_effective_replication_map* erm, locator::host_id ep, const gms::gossiper& g) {
+    static future<ranges_holder_secondary> make(const locator::effective_replication_map_ptr& erm, locator::host_id ep, const gms::gossiper& g) {
         co_return ranges_holder_secondary(co_await get_secondary_ranges(erm, ep), g);
     }
     std::size_t size() const { return _token_ranges.size(); }
@@ -427,8 +429,6 @@ public:
     }
 };
 
-// The token_ranges_owned_by_this_shard class is only used for vnodes, where the vnodes give a partition range for the entire node
-// and such range still needs to be divided between the shards.
 template<class primary_or_secondary_t>
 class token_ranges_owned_by_this_shard {
     schema_ptr _s;
@@ -522,7 +522,7 @@ struct scan_ranges_context {
         // should be possible (and a must for issue #7751!).
         lw_shared_ptr<service::pager::paging_state> paging_state = nullptr;
         auto regular_columns =
-            s->regular_columns() | std::views::transform(&column_definition::id)
+            s->regular_columns() | std::views::transform([] (const column_definition& cdef) { return cdef.id; })
             | std::ranges::to<query::column_id_vector>();
         selection = cql3::selection::selection::wildcard(s);
         query::partition_slice::option_set opts = selection->get_query_options();
@@ -655,17 +655,6 @@ static future<> scan_table_ranges(
     }
 }
 
-static future<> scan_tablet(locator::tablet_id tablet, service::storage_proxy& proxy, abort_source& abort_source, named_semaphore& page_sem,
-            expiration_service::stats& expiration_stats, const scan_ranges_context& scan_ctx, const locator::tablet_map& tablet_map) {
-    auto tablet_token_range = tablet_map.get_token_range(tablet);
-    dht::ring_position tablet_start(tablet_token_range.start()->value(), dht::ring_position::token_bound::start),
-                       tablet_end(tablet_token_range.end()->value(), dht::ring_position::token_bound::end);
-    auto partition_range = dht::partition_range::make(std::move(tablet_start), std::move(tablet_end));
-    // Note that because of issue #9167 we need to run a separate query on each partition range, and can't pass
-    // several of them into one partition_range_vector that is passed to scan_table_ranges().
-    return scan_table_ranges(proxy, scan_ctx, {partition_range}, abort_source, page_sem, expiration_stats);
-}
-
 // scan_table() scans, in one table, data "owned" by this shard, looking for
 // expired items and deleting them.
 // We consider each node to "own" its primary token ranges, i.e., the tokens
@@ -741,69 +730,34 @@ static future<bool> scan_table(
     expiration_stats.scan_table++;
     // FIXME: need to pace the scan, not do it all at once.
     scan_ranges_context scan_ctx{s, proxy, std::move(column_name), std::move(member)};
-
-    if (s->table().uses_tablets()) {
-        locator::effective_replication_map_ptr erm = s->table().get_effective_replication_map();
-        auto my_host_id = erm->get_topology().my_host_id();
-        const auto &tablet_map = erm->get_token_metadata().tablets().get_tablet_map(s->id());
-        for (std::optional tablet = tablet_map.first_tablet(); tablet; tablet = tablet_map.next_tablet(*tablet)) {
-            auto tablet_primary_replica = tablet_map.get_primary_replica(*tablet, erm->get_topology());
-            // check if this is the primary replica for the current tablet
-            if (tablet_primary_replica.host == my_host_id && tablet_primary_replica.shard == this_shard_id()) {
-                co_await scan_tablet(*tablet, proxy, abort_source, page_sem, expiration_stats, scan_ctx, tablet_map);
-            } else if(erm->get_replication_factor() > 1) {
-                // Check if this is the secondary replica for the current tablet
-                // and if the primary replica is down which means we will take over this work.
-                // If each node only scans its own primary ranges, then when any node is
-                // down part of the token range will not get scanned. This can be viewed
-                // as acceptable (when the comes back online, it will resume its scan),
-                // but as noted in issue #9787, we can allow more prompt expiration
-                // by tasking another node to take over scanning of the dead node's primary
-                // ranges. What we do here is that this node will also check expiration
-                // on its *secondary* ranges - but only those whose primary owner is down.
-                auto tablet_secondary_replica = tablet_map.get_secondary_replica(*tablet); // throws if no secondary replica
-                if (tablet_secondary_replica.host == my_host_id && tablet_secondary_replica.shard == this_shard_id()) {
-                    if (!gossiper.is_alive(tablet_primary_replica.host)) {
-                        co_await scan_tablet(*tablet, proxy, abort_source, page_sem, expiration_stats, scan_ctx, tablet_map);
-                    }
-                }
-            }
-        }
-    } else {  // VNodes
-        locator::static_effective_replication_map_ptr ermp =
-                db.real_database().find_keyspace(s->ks_name()).get_static_effective_replication_map();
-        auto* erm = ermp->maybe_as_vnode_effective_replication_map();
-        if (!erm) {
-            on_internal_error(tlogger, format("Keyspace {} is local", s->ks_name()));
-        }
-        auto my_host_id = erm->get_topology().my_host_id();
-        token_ranges_owned_by_this_shard my_ranges(s, co_await ranges_holder_primary::make(erm, my_host_id));
-        while (std::optional<dht::partition_range> range = my_ranges.next_partition_range()) {
-            // Note that because of issue #9167 we need to run a separate
-            // query on each partition range, and can't pass several of
-            // them into one partition_range_vector.
-            dht::partition_range_vector partition_ranges;
-            partition_ranges.push_back(std::move(*range));
-            // FIXME: if scanning a single range fails, including network errors,
-            // we fail the entire scan (and rescan from the beginning). Need to
-            // reconsider this. Saving the scan position might be a good enough
-            // solution for this problem.
-            co_await scan_table_ranges(proxy, scan_ctx, std::move(partition_ranges), abort_source, page_sem, expiration_stats);
-        }
-        // If each node only scans its own primary ranges, then when any node is
-        // down part of the token range will not get scanned. This can be viewed
-        // as acceptable (when the comes back online, it will resume its scan),
-        // but as noted in issue #9787, we can allow more prompt expiration
-        // by tasking another node to take over scanning of the dead node's primary
-        // ranges. What we do here is that this node will also check expiration
-        // on its *secondary* ranges - but only those whose primary owner is down.
-        token_ranges_owned_by_this_shard my_secondary_ranges(s, co_await ranges_holder_secondary::make(erm, my_host_id, gossiper));
-        while (std::optional<dht::partition_range> range = my_secondary_ranges.next_partition_range()) {
-            expiration_stats.secondary_ranges_scanned++;
-            dht::partition_range_vector partition_ranges;
-            partition_ranges.push_back(std::move(*range));
-            co_await scan_table_ranges(proxy, scan_ctx, std::move(partition_ranges), abort_source, page_sem, expiration_stats);
-        }
+    auto erm = db.real_database().find_keyspace(s->ks_name()).get_vnode_effective_replication_map();
+    auto my_host_id = erm->get_topology().my_host_id();
+    token_ranges_owned_by_this_shard my_ranges(s, co_await ranges_holder_primary::make(erm, my_host_id));
+    while (std::optional<dht::partition_range> range = my_ranges.next_partition_range()) {
+        // Note that because of issue #9167 we need to run a separate
+        // query on each partition range, and can't pass several of
+        // them into one partition_range_vector.
+        dht::partition_range_vector partition_ranges;
+        partition_ranges.push_back(std::move(*range));
+        // FIXME: if scanning a single range fails, including network errors,
+        // we fail the entire scan (and rescan from the beginning). Need to
+        // reconsider this. Saving the scan position might be a good enough
+        // solution for this problem.
+        co_await scan_table_ranges(proxy, scan_ctx, std::move(partition_ranges), abort_source, page_sem, expiration_stats);
+    }
+    // If each node only scans its own primary ranges, then when any node is
+    // down part of the token range will not get scanned. This can be viewed
+    // as acceptable (when the comes back online, it will resume its scan),
+    // but as noted in issue #9787, we can allow more prompt expiration
+    // by tasking another node to take over scanning of the dead node's primary
+    // ranges. What we do here is that this node will also check expiration
+    // on its *secondary* ranges - but only those whose primary owner is down.
+    token_ranges_owned_by_this_shard my_secondary_ranges(s, co_await ranges_holder_secondary::make(erm, my_host_id, gossiper));
+    while (std::optional<dht::partition_range> range = my_secondary_ranges.next_partition_range()) {
+        expiration_stats.secondary_ranges_scanned++;
+        dht::partition_range_vector partition_ranges;
+        partition_ranges.push_back(std::move(*range));
+        co_await scan_table_ranges(proxy, scan_ctx, std::move(partition_ranges), abort_source, page_sem, expiration_stats);
     }
     co_return true;
 }

api/api-doc/compaction_manager.json

@@ -246,24 +246,6 @@
             }
          }
       },
-      "sstableinfo":{
-         "id":"sstableinfo",
-         "description":"Compacted sstable information",
-         "properties":{
-            "generation":{
-               "type": "string",
-               "description":"Generation of the sstable"
-            },
-            "origin":{
-               "type":"string",
-               "description":"Origin of the sstable"
-            },
-            "size":{
-               "type":"long",
-               "description":"Size of the sstable"
-            }
-         }
-      },
       "compaction_info" :{
           "id": "compaction_info",
           "description":"A key value mapping",
@@ -345,10 +327,6 @@
                "type":"string",
                "description":"The UUID"
             },
-            "shard_id":{
-               "type":"int",
-               "description":"The shard id the compaction was executed on"
-            },
             "cf":{
                "type":"string",
                "description":"The column family name"
@@ -357,17 +335,9 @@
                "type":"string",
                "description":"The keyspace name"
             },
-            "compaction_type":{
-               "type":"string",
-               "description":"Type of compaction"
-            },
-            "started_at":{
-               "type":"long",
-               "description":"The time compaction started"
-            },
             "compacted_at":{
                "type":"long",
-               "description":"The time compaction completed"
+               "description":"The time of compaction"
             },
             "bytes_in":{
                "type":"long",
@@ -383,32 +353,6 @@
                   "type":"row_merged"
                },
                "description":"The merged rows"
-            },
-            "sstables_in": {
-               "type":"array",
-               "items":{
-                  "type":"sstableinfo"
-               },
-               "description":"List of input sstables for compaction"
-            },
-            "sstables_out": {
-               "type":"array",
-               "items":{
-                  "type":"sstableinfo"
-               },
-               "description":"List of output sstables from compaction"
-            },
-            "total_tombstone_purge_attempt":{
-               "type":"long",
-               "description":"Total number of tombstone purge attempts"
-            },
-            "total_tombstone_purge_failure_due_to_overlapping_with_memtable":{
-               "type":"long",
-               "description":"Number of tombstone purge failures due to data overlapping with memtables"
-            },
-            "total_tombstone_purge_failure_due_to_overlapping_with_uncompacting_sstable":{
-               "type":"long",
-               "description":"Number of tombstone purge failures due to data overlapping with non-compacting sstables"
             }
         }
       }

api/api-doc/gossiper.json

@@ -136,6 +136,14 @@
                      "allowMultiple":false,
                      "type":"string",
                      "paramType":"path"
+                  },
+                  {
+                     "name":"unsafe",
+                     "description":"Set to True to perform an unsafe assassination",
+                     "required":false,
+                     "allowMultiple":false,
+                     "type":"boolean",
+                     "paramType":"query"
                   }
                ]
             }

api/api-doc/storage_service.json

@@ -898,14 +898,6 @@
                           "type":"string",
                           "paramType":"query",
                           "enum": ["all", "dc", "rack", "node"]
-                      },
-                      {
-                         "name":"primary_replica_only",
-                         "description":"Load the sstables and stream to the primary replica node within the scope, if one is specified. If not, stream to the global primary replica.",
-                         "required":false,
-                         "allowMultiple":false,
-                         "type":"boolean",
-                         "paramType":"query"
                       }
                   ]
               }
@@ -992,7 +984,7 @@
          ]
       },
       {
-         "path":"/storage_service/cleanup_all/",
+         "path":"/storage_service/cleanup_all",
          "operations":[
             {
                "method":"POST",
@@ -1002,30 +994,6 @@
                "produces":[
                   "application/json"
                ],
-               "parameters":[
-                    {
-                     "name":"global",
-                     "description":"true if cleanup of entire cluster is requested",
-                     "required":false,
-                     "allowMultiple":false,
-                     "type":"boolean",
-                     "paramType":"query"
-                  }
-               ]
-            }
-         ]
-      },
-      {
-         "path":"/storage_service/mark_node_as_clean",
-         "operations":[
-            {
-               "method":"POST",
-               "summary":"Mark the node as clean. After that the node will not be considered as needing cleanup during automatic cleanup which is triggered by some topology operations",
-               "type":"void",
-               "nickname":"reset_cleanup_needed",
-               "produces":[
-                  "application/json"
-               ],
                "parameters":[]
             }
          ]
@@ -2176,31 +2144,6 @@
                      "allowMultiple":false,
                      "type":"string",
                      "paramType":"query"
-                  },
-                  {
-                     "name":"skip_cleanup",
-                     "description":"Don't cleanup keys from loaded sstables. Invalid if load_and_stream is true",
-                     "required":false,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query"
-                  },
-                  {
-                     "name":"skip_reshape",
-                     "description":"Don't reshape the loaded sstables. Invalid if load_and_stream is true",
-                     "required":false,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query"
-                  },
-                  {
-                     "name":"scope",
-                     "description":"Defines the set of nodes to which mutations can be streamed",
-                     "required":false,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query",
-                     "enum": ["all", "dc", "rack", "node"]
                   }
                ]
             }
@@ -2953,14 +2896,6 @@
                      "allowMultiple":false,
                      "type":"string",
                      "paramType":"query"
-                  },
-                  {
-                     "name":"incremental_mode",
-                     "description":"Set the incremental repair mode. Can be 'disabled', 'incremental', or 'full'. 'incremental': The incremental repair logic is enabled. Unrepaired sstables will be included for repair. Repaired sstables will be skipped. The incremental repair states will be updated after repair. 'full': The incremental repair logic is enabled. Both repaired and unrepaired sstables will be included for repair. The incremental repair states will be updated after repair. 'disabled': The incremental repair logic is disabled completely. The incremental repair states, e.g., repaired_at in sstables and sstables_repaired_at in the system.tablets table, will not be updated after repair. When the option is not provided, it defaults to 'disabled' mode.",
-                     "required":false,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query"
                   }
                ]
             }
@@ -3092,73 +3027,6 @@
             }
          ]
       },
-      {
-         "path":"/storage_service/retrain_dict",
-         "operations":[
-            {
-               "method":"POST",
-               "summary":"Retrain the SSTable compression dictionary for the target table.",
-               "type":"void",
-               "nickname":"retrain_dict",
-               "produces":[
-                  "application/json"
-               ],
-               "parameters":[
-                  {
-                     "name":"keyspace",
-                     "description":"Name of the keyspace containing the target table.",
-                     "required":true,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query"
-                  },
-                  {
-                     "name":"cf",
-                     "description":"Name of the target table.",
-                     "required":true,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query"
-                  }
-               ]
-            }
-         ]
-      },
-      {
-         "path":"/storage_service/estimate_compression_ratios",
-         "operations":[
-            {
-               "method":"GET",
-               "summary":"Compute an estimated compression ratio for SSTables of the given table, for various compression configurations.",
-               "type":"array",
-               "items":{
-                  "type":"compression_config_result"
-               },
-               "nickname":"estimate_compression_ratios",
-               "produces":[
-                  "application/json"
-               ],
-               "parameters":[
-                  {
-                     "name":"keyspace",
-                     "description":"Name of the keyspace containing the target table.",
-                     "required":true,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query"
-                  },
-                  {
-                     "name":"cf",
-                     "description":"Name of the target table.",
-                     "required":true,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query"
-                  }
-               ]
-            }
-         ]
-      },
       {
          "path":"/storage_service/raft_topology/reload",
          "operations":[
@@ -3201,54 +3069,6 @@
                ]
             }
          ]
-      },
-      {
-         "path":"/storage_service/raft_topology/cmd_rpc_status",
-         "operations":[
-            {
-               "method":"GET",
-               "summary":"Get information about currently running topology cmd rpc",
-               "type":"string",
-               "nickname":"raft_topology_get_cmd_status",
-               "produces":[
-                  "application/json"
-               ],
-               "parameters":[
-               ]
-            }
-         ]
-      },
-      {
-         "path":"/storage_service/drop_quarantined_sstables",
-         "operations":[
-            {
-               "method":"POST",
-               "summary":"Drops all quarantined sstables in all keyspaces or specified keyspace and tables",
-               "type":"void",
-               "nickname":"drop_quarantined_sstables",
-               "produces":[
-                  "application/json"
-               ],
-               "parameters":[
-                  {
-                     "name":"keyspace",
-                     "description":"The keyspace name to drop quarantined sstables from.",
-                     "required":false,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query"
-                  },
-                  {
-                     "name":"tables",
-                     "description":"Comma-separated table names to drop quarantined sstables from.",
-                     "required":false,
-                     "allowMultiple":false,
-                     "type":"string",
-                     "paramType":"query"
-                  }
-               ]
-            }
-         ]
       }
    ],
    "models":{
@@ -3385,11 +3205,11 @@
          "properties":{
             "start_token":{
                "type":"string",
-               "description":"The range start token (exclusive)"
+               "description":"The range start token"
             },
             "end_token":{
                "type":"string",
-               "description":"The range end token (inclusive)"
+               "description":"The range start token"
             },
             "endpoints":{
                "type":"array",
@@ -3462,7 +3282,7 @@
             "version":{
                "type":"string",
                "enum":[
-                  "ka", "la", "mc", "md", "me", "ms"
+                  "ka", "la", "mc", "md", "me"
                ],
                "description":"SSTable version"
             },
@@ -3508,32 +3328,6 @@
                 "type":"string"
             }
         }
-      },
-      "compression_config_result":{
-         "id":"compression_config_result",
-         "description":"Compression ratio estimation result for one config",
-         "properties":{
-            "level":{
-               "type":"long",
-               "description":"The used value of `compression_level`"
-            },
-            "chunk_length_in_kb":{
-               "type":"long",
-               "description":"The used value of `chunk_length_in_kb`"
-            },
-            "dict":{
-               "type":"string",
-               "description":"The used dictionary: `none`, `past` (== current), or `future`"
-            },
-            "sstable_compression":{
-               "type":"string",
-               "description":"The used compressor name (aka `sstable_compression`)"
-            },
-            "ratio":{
-               "type":"float",
-               "description":"The resulting compression ratio (estimated on a random sample of files)"
-            }
-         }
       }
    }
 }

api/api-doc/task_manager.json

@@ -447,7 +447,7 @@
                "description":"The number of units completed so far"
             },
             "children_ids":{
-               "type":"chunked_array",
+               "type":"array",
                "items":{
                   "type":"task_identity"
                },

api/api-doc/tasks.json

@@ -42,14 +42,6 @@
                      "allowMultiple":false,
                      "type":"boolean",
                      "paramType":"query"
-                  },
-                  {
-                     "name":"consider_only_existing_data",
-                     "description":"Set to \"true\" to flush all memtables and force tombstone garbage collection to check only the sstables being compacted (false by default). The memtable, commitlog and other uncompacted sstables will not be checked during tombstone garbage collection.",
-                     "required":false,
-                     "allowMultiple":false,
-                     "type":"boolean",
-                     "paramType":"query"
                   }
                ]
             }

api/api.cc

@@ -137,6 +137,14 @@ future<> unset_load_meter(http_context& ctx) {
     return ctx.http_server.set_routes([&ctx] (routes& r) { unset_load_meter(ctx, r); });
 }
 
+future<> set_format_selector(http_context& ctx, db::sstables_format_selector& sel) {
+    return ctx.http_server.set_routes([&ctx, &sel] (routes& r) { set_format_selector(ctx, r, sel); });
+}
+
+future<> unset_format_selector(http_context& ctx) {
+    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_format_selector(ctx, r); });
+}
+
 future<> set_server_sstables_loader(http_context& ctx, sharded<sstables_loader>& sst_loader) {
     return ctx.http_server.set_routes([&ctx, &sst_loader] (routes& r) { set_sstables_loader(ctx, r, sst_loader); });
 }
@@ -216,22 +224,15 @@ future<> unset_server_gossip(http_context& ctx) {
     });
 }
 
-future<> set_server_column_family(http_context& ctx, sharded<replica::database>& db, sharded<db::system_keyspace>& sys_ks) {
-    co_await register_api(ctx, "column_family",
-                "The column family API", [&db, &sys_ks] (http_context& ctx, routes& r) {
-                    set_column_family(ctx, r, db, sys_ks);
-                });
-    co_await register_api(ctx, "cache_service",
-            "The cache service API", [&db] (http_context& ctx, routes& r) {
-                    set_cache_service(ctx, db, r);
+future<> set_server_column_family(http_context& ctx, sharded<db::system_keyspace>& sys_ks) {
+    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_column_family(http_context& ctx) {
-    return ctx.http_server.set_routes([&ctx] (routes& r) {
-        unset_column_family(ctx, r);
-        unset_cache_service(ctx, r);
-    });
+    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_column_family(ctx, r); });
 }
 
 future<> set_server_messaging_service(http_context& ctx, sharded<netw::messaging_service>& ms) {
@@ -263,6 +264,15 @@ future<> unset_server_stream_manager(http_context& ctx) {
     return ctx.http_server.set_routes([&ctx] (routes& r) { unset_stream_manager(ctx, r); });
 }
 
+future<> set_server_cache(http_context& ctx) {
+    return register_api(ctx, "cache_service",
+            "The cache service API", set_cache_service);
+}
+
+future<> unset_server_cache(http_context& ctx) {
+    return ctx.http_server.set_routes([&ctx] (routes& r) { unset_cache_service(ctx, r); });
+}
+
 future<> set_hinted_handoff(http_context& ctx, sharded<service::storage_proxy>& proxy, sharded<gms::gossiper>& g) {
     return register_api(ctx, "hinted_handoff",
                 "The hinted handoff API", [&proxy, &g] (http_context& ctx, routes& r) {
@@ -274,7 +284,7 @@ future<> unset_hinted_handoff(http_context& ctx) {
     return ctx.http_server.set_routes([&ctx] (routes& r) { unset_hinted_handoff(ctx, r); });
 }
 
-future<> set_server_compaction_manager(http_context& ctx, sharded<compaction::compaction_manager>& cm) {
+future<> set_server_compaction_manager(http_context& ctx, sharded<compaction_manager>& cm) {
     return register_api(ctx, "compaction_manager", "The Compaction manager API", [&cm] (http_context& ctx, routes& r) {
         set_compaction_manager(ctx, r, cm);
     });
@@ -381,5 +391,32 @@ future<> unset_server_raft(http_context& ctx) {
     return ctx.http_server.set_routes([&ctx] (routes& r) { unset_raft(ctx, r); });
 }
 
+void req_params::process(const request& req) {
+    // Process mandatory parameters
+    for (auto& [name, ent] : params) {
+        if (!ent.is_mandatory) {
+            continue;
+        }
+        try {
+            ent.value = req.get_path_param(name);
+        } catch (std::out_of_range&) {
+            throw httpd::bad_param_exception(fmt::format("Mandatory parameter '{}' was not provided", name));
+        }
+    }
+
+    // Process optional parameters
+    for (auto& [name, value] : req.query_parameters) {
+        try {
+            auto& ent = params.at(name);
+            if (ent.is_mandatory) {
+                throw httpd::bad_param_exception(fmt::format("Parameter '{}' is expected to be provided as part of the request url", name));
+            }
+            ent.value = value;
+        } catch (std::out_of_range&) {
+            throw httpd::bad_param_exception(fmt::format("Unsupported optional parameter '{}'", name));
+        }
+    }
+}
+
 }
 

api/api.hh

@@ -23,6 +23,17 @@
 
 namespace api {
 
+template<class T>
+std::vector<sstring> container_to_vec(const T& container) {
+    std::vector<sstring> res;
+    res.reserve(std::size(container));
+
+    for (const auto& i : container) {
+        res.push_back(fmt::to_string(i));
+    }
+    return res;
+}
+
 template<class T>
 std::vector<T> map_to_key_value(const std::map<sstring, sstring>& map) {
     std::vector<T> res;
@@ -56,6 +67,17 @@ T map_sum(T&& dest, const S& src) {
     return std::move(dest);
 }
 
+template <typename MAP>
+std::vector<sstring> map_keys(const MAP& map) {
+    std::vector<sstring> res;
+    res.reserve(std::size(map));
+
+    for (const auto& i : map) {
+        res.push_back(fmt::to_string(i.first));
+    }
+    return res;
+}
+
 /**
  * General sstring splitting function
  */
@@ -73,7 +95,7 @@ inline std::vector<sstring> split(const sstring& text, const char* separator) {
  *
  */
 template<class T, class F, class V>
-future<json::json_return_type>  sum_stats(sharded<T>& d, V F::*f) {
+future<json::json_return_type>  sum_stats(distributed<T>& d, V F::*f) {
     return d.map_reduce0([f](const T& p) {return p.get_stats().*f;}, 0,
             std::plus<V>()).then([](V val) {
         return make_ready_future<json::json_return_type>(val);
@@ -106,7 +128,7 @@ httpd::utils_json::rate_moving_average_and_histogram timer_to_json(const utils::
 }
 
 template<class T, class F>
-future<json::json_return_type>  sum_histogram_stats(sharded<T>& d, utils::timed_rate_moving_average_and_histogram F::*f) {
+future<json::json_return_type>  sum_histogram_stats(distributed<T>& d, utils::timed_rate_moving_average_and_histogram F::*f) {
 
     return d.map_reduce0([f](const T& p) {return (p.get_stats().*f).hist;}, utils::ihistogram(),
             std::plus<utils::ihistogram>()).then([](const utils::ihistogram& val) {
@@ -115,7 +137,7 @@ future<json::json_return_type>  sum_histogram_stats(sharded<T>& d, utils::timed_
 }
 
 template<class T, class F>
-future<json::json_return_type>  sum_timer_stats(sharded<T>& d, utils::timed_rate_moving_average_and_histogram F::*f) {
+future<json::json_return_type>  sum_timer_stats(distributed<T>& d, utils::timed_rate_moving_average_and_histogram F::*f) {
 
     return d.map_reduce0([f](const T& p) {return (p.get_stats().*f).rate();}, utils::rate_moving_average_and_histogram(),
             std::plus<utils::rate_moving_average_and_histogram>()).then([](const utils::rate_moving_average_and_histogram& val) {
@@ -124,7 +146,7 @@ future<json::json_return_type>  sum_timer_stats(sharded<T>& d, utils::timed_rate
 }
 
 template<class T, class F>
-future<json::json_return_type>  sum_timer_stats(sharded<T>& d, utils::timed_rate_moving_average_summary_and_histogram F::*f) {
+future<json::json_return_type>  sum_timer_stats(distributed<T>& d, utils::timed_rate_moving_average_summary_and_histogram F::*f) {
     return d.map_reduce0([f](const T& p) {return (p.get_stats().*f).rate();}, utils::rate_moving_average_and_histogram(),
             std::plus<utils::rate_moving_average_and_histogram>()).then([](const utils::rate_moving_average_and_histogram& val) {
         return make_ready_future<json::json_return_type>(timer_to_json(val));
@@ -230,6 +252,67 @@ public:
     operator T() const { return value; }
 };
 
+using mandatory = bool_class<struct mandatory_tag>;
+
+class req_params {
+public:
+    struct def {
+        std::optional<sstring> value;
+        mandatory is_mandatory = mandatory::no;
+
+        def(std::optional<sstring> value_ = std::nullopt, mandatory is_mandatory_ = mandatory::no)
+            : value(std::move(value_))
+            , is_mandatory(is_mandatory_)
+        { }
+
+        def(mandatory is_mandatory_)
+            : is_mandatory(is_mandatory_)
+        { }
+    };
+
+private:
+    std::unordered_map<sstring, def> params;
+
+public:
+    req_params(std::initializer_list<std::pair<sstring, def>> l) {
+        for (const auto& [name, ent] : l) {
+            add(std::move(name), std::move(ent));
+        }
+    }
+
+    void add(sstring name, def ent) {
+        params.emplace(std::move(name), std::move(ent));
+    }
+
+    void process(const request& req);
+
+    const std::optional<sstring>& get(const char* name) const {
+        return params.at(name).value;
+    }
+
+    template <typename T = sstring>
+    const std::optional<T> get_as(const char* name) const {
+        return get(name);
+    }
+
+    template <typename T = sstring>
+    requires std::same_as<T, bool>
+    const std::optional<bool> get_as(const char* name) const {
+        auto value = get(name);
+        if (!value) {
+            return std::nullopt;
+        }
+        std::transform(value->begin(), value->end(), value->begin(), ::tolower);
+        if (value == "true" || value == "yes" || value == "1") {
+            return true;
+        }
+        if (value == "false" || value == "no" || value == "0") {
+            return false;
+        }
+        throw boost::bad_lexical_cast{};
+    }
+};
+
 httpd::utils_json::estimated_histogram time_to_json_histogram(const utils::time_estimated_histogram& val);
 
 }

api/api_init.hh

@@ -18,9 +18,7 @@
 using request = http::request;
 using reply = http::reply;
 
-namespace compaction {
 class compaction_manager;
-}
 
 namespace service {
 
@@ -85,9 +83,9 @@ struct http_context {
     sstring api_dir;
     sstring api_doc;
     httpd::http_server_control http_server;
-    sharded<replica::database>& db;
+    distributed<replica::database>& db;
 
-    http_context(sharded<replica::database>& _db)
+    http_context(distributed<replica::database>& _db)
             : db(_db)
     {
     }
@@ -118,7 +116,7 @@ future<> set_server_token_metadata(http_context& ctx, sharded<locator::shared_to
 future<> unset_server_token_metadata(http_context& ctx);
 future<> set_server_gossip(http_context& ctx, sharded<gms::gossiper>& g);
 future<> unset_server_gossip(http_context& ctx);
-future<> set_server_column_family(http_context& ctx, sharded<replica::database>& db, sharded<db::system_keyspace>& sys_ks);
+future<> set_server_column_family(http_context& ctx, sharded<db::system_keyspace>& sys_ks);
 future<> unset_server_column_family(http_context& ctx);
 future<> set_server_messaging_service(http_context& ctx, sharded<netw::messaging_service>& ms);
 future<> unset_server_messaging_service(http_context& ctx);
@@ -128,7 +126,9 @@ future<> set_server_stream_manager(http_context& ctx, sharded<streaming::stream_
 future<> unset_server_stream_manager(http_context& ctx);
 future<> set_hinted_handoff(http_context& ctx, sharded<service::storage_proxy>& p, sharded<gms::gossiper>& g);
 future<> unset_hinted_handoff(http_context& ctx);
-future<> set_server_compaction_manager(http_context& ctx, sharded<compaction::compaction_manager>& cm);
+future<> set_server_cache(http_context& ctx);
+future<> unset_server_cache(http_context& ctx);
+future<> set_server_compaction_manager(http_context& ctx, sharded<compaction_manager>& cm);
 future<> unset_server_compaction_manager(http_context& ctx);
 future<> set_server_done(http_context& ctx);
 future<> set_server_task_manager(http_context& ctx, sharded<tasks::task_manager>& tm, lw_shared_ptr<db::config> cfg, sharded<gms::gossiper>& gossiper);
@@ -141,6 +141,8 @@ future<> set_server_raft(http_context&, sharded<service::raft_group_registry>&);
 future<> unset_server_raft(http_context&);
 future<> set_load_meter(http_context& ctx, service::load_meter& lm);
 future<> unset_load_meter(http_context& ctx);
+future<> set_format_selector(http_context& ctx, db::sstables_format_selector& sel);
+future<> unset_format_selector(http_context& ctx);
 future<> set_server_cql_server_test(http_context& ctx, cql_transport::controller& ctl);
 future<> unset_server_cql_server_test(http_context& ctx);
 future<> set_server_service_levels(http_context& ctx, cql_transport::controller& ctl, sharded<cql3::query_processor>& qp);

api/cache_service.cc

@@ -16,7 +16,7 @@ using namespace json;
 using namespace seastar::httpd;
 namespace cs = httpd::cache_service_json;
 
-void set_cache_service(http_context& ctx, sharded<replica::database>& db, routes& r) {
+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) {
         // We never save the cache
         // Origin uses 0 for never
@@ -204,53 +204,53 @@ void set_cache_service(http_context& ctx, sharded<replica::database>& db, routes
         });
     });
 
-    cs::get_row_hits.set(r, [&db] (std::unique_ptr<http::request> req) {
-        return map_reduce_cf(db, uint64_t(0), [](const replica::column_family& cf) {
+    cs::get_row_hits.set(r, [&ctx] (std::unique_ptr<http::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, [&db] (std::unique_ptr<http::request> req) {
-        return map_reduce_cf(db, uint64_t(0), [](const replica::column_family& cf) {
+    cs::get_row_requests.set(r, [&ctx] (std::unique_ptr<http::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, [&db] (std::unique_ptr<http::request> req) {
-        return map_reduce_cf(db, ratio_holder(), [](const replica::column_family& cf) {
+    cs::get_row_hit_rate.set(r, [&ctx] (std::unique_ptr<http::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, [&db] (std::unique_ptr<http::request> req) {
-        return map_reduce_cf_raw(db, utils::rate_moving_average(), [](const replica::column_family& cf) {
+    cs::get_row_hits_moving_avrage.set(r, [&ctx] (std::unique_ptr<http::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) {
             return make_ready_future<json::json_return_type>(meter_to_json(m));
         });
     });
 
-    cs::get_row_requests_moving_avrage.set(r, [&db] (std::unique_ptr<http::request> req) {
-        return map_reduce_cf_raw(db, utils::rate_moving_average(), [](const replica::column_family& cf) {
+    cs::get_row_requests_moving_avrage.set(r, [&ctx] (std::unique_ptr<http::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) {
             return make_ready_future<json::json_return_type>(meter_to_json(m));
         });
     });
 
-    cs::get_row_size.set(r, [&db] (std::unique_ptr<http::request> req) {
+    cs::get_row_size.set(r, [&ctx] (std::unique_ptr<http::request> req) {
         // In origin row size is the weighted size.
         // We currently do not support weights, so we use raw size in bytes instead
-        return db.map_reduce0([](replica::database& db) -> uint64_t {
+        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) {
             return make_ready_future<json::json_return_type>(res);
         });
     });
 
-    cs::get_row_entries.set(r, [&db] (std::unique_ptr<http::request> req) {
-        return db.map_reduce0([](replica::database& db) -> uint64_t {
+    cs::get_row_entries.set(r, [&ctx] (std::unique_ptr<http::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) {
             return make_ready_future<json::json_return_type>(res);

api/cache_service.hh

@@ -7,20 +7,15 @@
  */
 
 #pragma once
-#include <seastar/core/sharded.hh>
 
 namespace seastar::httpd {
 class routes;
 }
 
-namespace replica {
-class database;
-}
-
 namespace api {
 
 struct http_context;
-void set_cache_service(http_context& ctx, seastar::sharded<replica::database>& db, seastar::httpd::routes& r);
+void set_cache_service(http_context& ctx, seastar::httpd::routes& r);
 void unset_cache_service(http_context& ctx, seastar::httpd::routes& r);
 
 }

api/column_family.hh

@@ -19,23 +19,19 @@ class system_keyspace;
 
 namespace api {
 
-void set_column_family(http_context& ctx, httpd::routes& r, sharded<replica::database>& db, sharded<db::system_keyspace>& sys_ks);
+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);
 
 table_info parse_table_info(const sstring& name, const replica::database& db);
 
 template<class Mapper, class I, class Reducer>
-future<I> map_reduce_cf_raw(sharded<replica::database>& db, const sstring& name, I init,
+future<I> map_reduce_cf_raw(http_context& ctx, const sstring& name, I init,
         Mapper mapper, Reducer reducer) {
-    auto uuid = parse_table_info(name, db.local()).id;
-    using mapper_type = std::function<future<std::unique_ptr<std::any>>(replica::database&)>;
+    auto uuid = parse_table_info(name, ctx.db.local()).id;
+    using mapper_type = std::function<std::unique_ptr<std::any>(replica::database&)>;
     using reducer_type = std::function<std::unique_ptr<std::any>(std::unique_ptr<std::any>, std::unique_ptr<std::any>)>;
-    return db.map_reduce0(mapper_type([mapper, uuid](replica::database& db) {
-        return futurize_invoke([mapper, &db, uuid] {
-            return mapper(db.find_column_family(uuid));
-        }).then([] (auto result) {
-            return std::make_unique<std::any>(I(std::move(result)));
-        });
+    return ctx.db.map_reduce0(mapper_type([mapper, uuid](replica::database& db) {
+        return std::make_unique<std::any>(I(mapper(db.find_column_family(uuid))));
     }), std::make_unique<std::any>(std::move(init)), reducer_type([reducer = std::move(reducer)] (std::unique_ptr<std::any> a, std::unique_ptr<std::any> b) mutable {
         return std::make_unique<std::any>(I(reducer(std::any_cast<I>(std::move(*a)), std::any_cast<I>(std::move(*b)))));
     })).then([] (std::unique_ptr<std::any> r) {
@@ -45,30 +41,33 @@ future<I> map_reduce_cf_raw(sharded<replica::database>& db, const sstring& name,
 
 
 template<class Mapper, class I, class Reducer>
-future<json::json_return_type> map_reduce_cf(sharded<replica::database>& db, const sstring& name, I init,
+future<json::json_return_type> map_reduce_cf(http_context& ctx, const sstring& name, I init,
         Mapper mapper, Reducer reducer) {
-    return map_reduce_cf_raw(db, name, init, mapper, reducer).then([](const I& res) {
+    return map_reduce_cf_raw(ctx, name, init, mapper, reducer).then([](const I& res) {
         return make_ready_future<json::json_return_type>(res);
     });
 }
 
 template<class Mapper, class I, class Reducer, class Result>
-future<json::json_return_type> map_reduce_cf(sharded<replica::database>& db, const sstring& name, I init,
+future<json::json_return_type> map_reduce_cf(http_context& ctx, const sstring& name, I init,
         Mapper mapper, Reducer reducer, Result result) {
-    return map_reduce_cf_raw(db, name, init, mapper, reducer).then([result](const I& res) mutable {
+    return map_reduce_cf_raw(ctx, name, init, mapper, reducer).then([result](const I& res) mutable {
         result = res;
         return make_ready_future<json::json_return_type>(result);
     });
 }
 
+future<json::json_return_type> map_reduce_cf_time_histogram(http_context& ctx, const sstring& name, std::function<utils::time_estimated_histogram(const replica::column_family&)> f);
+
 struct map_reduce_column_families_locally {
     std::any init;
-    std::function<future<std::unique_ptr<std::any>>(replica::column_family&)> mapper;
+    std::function<std::unique_ptr<std::any>(replica::column_family&)> mapper;
     std::function<std::unique_ptr<std::any>(std::unique_ptr<std::any>, std::unique_ptr<std::any>)> reducer;
     future<std::unique_ptr<std::any>> operator()(replica::database& db) const {
         auto res = seastar::make_lw_shared<std::unique_ptr<std::any>>(std::make_unique<std::any>(init));
-        return db.get_tables_metadata().for_each_table_gently([res, this] (table_id, seastar::lw_shared_ptr<replica::table> table) -> future<> {
-            *res = reducer(std::move(*res), co_await mapper(*table.get()));
+        return db.get_tables_metadata().for_each_table_gently([res, this] (table_id, seastar::lw_shared_ptr<replica::table> table) {
+            *res = reducer(std::move(*res), mapper(*table.get()));
+            return make_ready_future();
         }).then([res] () {
             return std::move(*res);
         });
@@ -76,21 +75,17 @@ struct map_reduce_column_families_locally {
 };
 
 template<class Mapper, class I, class Reducer>
-future<I> map_reduce_cf_raw(sharded<replica::database>& db, I init,
+future<I> map_reduce_cf_raw(http_context& ctx, I init,
         Mapper mapper, Reducer reducer) {
-    using mapper_type = std::function<future<std::unique_ptr<std::any>>(replica::column_family&)>;
+    using mapper_type = std::function<std::unique_ptr<std::any>(replica::column_family&)>;
     using reducer_type = std::function<std::unique_ptr<std::any>(std::unique_ptr<std::any>, std::unique_ptr<std::any>)>;
     auto wrapped_mapper = mapper_type([mapper = std::move(mapper)] (replica::column_family& cf) mutable {
-        return futurize_invoke([&cf, mapper] {
-            return mapper(cf);
-        }).then([] (auto result) {
-            return std::make_unique<std::any>(I(std::move(result)));
-        });
+        return std::make_unique<std::any>(I(mapper(cf)));
     });
     auto wrapped_reducer = reducer_type([reducer = std::move(reducer)] (std::unique_ptr<std::any> a, std::unique_ptr<std::any> b) mutable {
         return std::make_unique<std::any>(I(reducer(std::any_cast<I>(std::move(*a)), std::any_cast<I>(std::move(*b)))));
     });
-    return db.map_reduce0(map_reduce_column_families_locally{init,
+    return ctx.db.map_reduce0(map_reduce_column_families_locally{init,
             std::move(wrapped_mapper), wrapped_reducer}, std::make_unique<std::any>(init), wrapped_reducer).then([] (std::unique_ptr<std::any> res) {
         return std::any_cast<I>(std::move(*res));
     });
@@ -98,13 +93,20 @@ future<I> map_reduce_cf_raw(sharded<replica::database>& db, I init,
 
 
 template<class Mapper, class I, class Reducer>
-future<json::json_return_type> map_reduce_cf(sharded<replica::database>& db, I init,
+future<json::json_return_type> map_reduce_cf(http_context& ctx, I init,
         Mapper mapper, Reducer reducer) {
-    return map_reduce_cf_raw(db, init, mapper, reducer).then([](const I& res) {
+    return map_reduce_cf_raw(ctx, init, mapper, reducer).then([](const I& res) {
         return make_ready_future<json::json_return_type>(res);
     });
 }
 
+future<json::json_return_type>  get_cf_stats(http_context& ctx, const sstring& name,
+        int64_t replica::column_family_stats::*f);
+
+future<json::json_return_type>  get_cf_stats(http_context& ctx,
+        int64_t replica::column_family_stats::*f);
+
+
 std::tuple<sstring, sstring> parse_fully_qualified_cf_name(sstring name);
 
 }

api/compaction_manager.cc

@@ -14,7 +14,6 @@
 #include "api/api.hh"
 #include "api/api-doc/compaction_manager.json.hh"
 #include "api/api-doc/storage_service.json.hh"
-#include "db/compaction_history_entry.hh"
 #include "db/system_keyspace.hh"
 #include "column_family.hh"
 #include "unimplemented.hh"
@@ -29,9 +28,9 @@ namespace ss = httpd::storage_service_json;
 using namespace json;
 using namespace seastar::httpd;
 
-static future<json::json_return_type> get_cm_stats(sharded<compaction::compaction_manager>& cm,
-        int64_t compaction::compaction_manager::stats::*f) {
-    return cm.map_reduce0([f](compaction::compaction_manager& cm) {
+static future<json::json_return_type> get_cm_stats(sharded<compaction_manager>& cm,
+        int64_t compaction_manager::stats::*f) {
+    return cm.map_reduce0([f](compaction_manager& cm) {
         return cm.get_stats().*f;
     }, int64_t(0), std::plus<int64_t>()).then([](const int64_t& res) {
         return make_ready_future<json::json_return_type>(res);
@@ -47,9 +46,9 @@ static std::unordered_map<std::pair<sstring, sstring>, uint64_t, utils::tuple_ha
     return std::move(a);
 }
 
-void set_compaction_manager(http_context& ctx, routes& r, sharded<compaction::compaction_manager>& cm) {
+void set_compaction_manager(http_context& ctx, routes& r, sharded<compaction_manager>& cm) {
     cm::get_compactions.set(r, [&cm] (std::unique_ptr<http::request> req) {
-        return cm.map_reduce0([](compaction::compaction_manager& cm) {
+        return cm.map_reduce0([](compaction_manager& cm) {
             std::vector<cm::summary> summaries;
 
             for (const auto& c : cm.get_compactions()) {
@@ -58,7 +57,7 @@ void set_compaction_manager(http_context& ctx, routes& r, sharded<compaction::co
                 s.ks = c.ks_name;
                 s.cf = c.cf_name;
                 s.unit = "keys";
-                s.task_type = compaction::compaction_name(c.type);
+                s.task_type = sstables::compaction_name(c.type);
                 s.completed = c.total_keys_written;
                 s.total = c.total_partitions;
                 summaries.push_back(std::move(s));
@@ -72,9 +71,10 @@ void set_compaction_manager(http_context& ctx, routes& r, sharded<compaction::co
     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) {
-                return db.get_tables_metadata().for_each_table_gently([&tasks] (table_id, lw_shared_ptr<replica::table> table) -> future<> {
+                return db.get_tables_metadata().for_each_table_gently([&tasks] (table_id, lw_shared_ptr<replica::table> table) {
                     replica::table& cf = *table.get();
-                    tasks[std::make_pair(cf.schema()->ks_name(), cf.schema()->cf_name())] = co_await cf.estimate_pending_compactions();
+                    tasks[std::make_pair(cf.schema()->ks_name(), cf.schema()->cf_name())] = cf.estimate_pending_compactions();
+                    return make_ready_future<>();
                 }).then([&tasks] {
                     return std::move(tasks);
                 });
@@ -103,20 +103,23 @@ void set_compaction_manager(http_context& ctx, routes& r, sharded<compaction::co
 
     cm::stop_compaction.set(r, [&cm] (std::unique_ptr<http::request> req) {
         auto type = req->get_query_param("type");
-        return cm.invoke_on_all([type] (compaction::compaction_manager& cm) {
+        return cm.invoke_on_all([type] (compaction_manager& cm) {
             return cm.stop_compaction(type);
         }).then([] {
             return make_ready_future<json::json_return_type>(json_void());
         });
     });
 
-    cm::stop_keyspace_compaction.set(r, [&ctx, &cm] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
-        auto [ks_name, tables] = parse_table_infos(ctx, *req, "tables");
+    cm::stop_keyspace_compaction.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
+        auto ks_name = validate_keyspace(ctx, req);
+        auto tables = parse_table_infos(ks_name, ctx, req->query_parameters, "tables");
         auto type = req->get_query_param("type");
-        co_await cm.invoke_on_all([&] (compaction::compaction_manager& cm) {
+        co_await ctx.db.invoke_on_all([&] (replica::database& db) {
+            auto& cm = db.get_compaction_manager();
             return parallel_for_each(tables, [&] (const table_info& ti) {
-                return cm.stop_compaction(type, [id = ti.id] (const compaction::compaction_group_view* x) {
-                    return x->schema()->id() == id;
+                auto& t = db.find_column_family(ti.id);
+                return t.parallel_foreach_table_state([&] (compaction::table_state& ts) {
+                    return cm.stop_compaction(type, &ts);
                 });
             });
         });
@@ -124,13 +127,13 @@ void set_compaction_manager(http_context& ctx, routes& r, sharded<compaction::co
     });
 
     cm::get_pending_tasks.set(r, [&ctx] (std::unique_ptr<http::request> req) {
-        return map_reduce_cf(ctx.db, int64_t(0), [](replica::column_family& cf) {
+        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, [&cm] (std::unique_ptr<http::request> req) {
-        return get_cm_stats(cm, &compaction::compaction_manager::stats::completed_tasks);
+        return get_cm_stats(cm, &compaction_manager::stats::completed_tasks);
     });
 
     cm::get_total_compactions_completed.set(r, [] (std::unique_ptr<http::request> req) {
@@ -148,7 +151,7 @@ void set_compaction_manager(http_context& ctx, routes& r, sharded<compaction::co
     });
 
     cm::get_compaction_history.set(r, [&cm] (std::unique_ptr<http::request> req) {
-        noncopyable_function<future<>(output_stream<char>&&)> f = [&cm] (output_stream<char>&& out) -> future<> {
+        std::function<future<>(output_stream<char>&&)> f = [&cm] (output_stream<char>&& out) -> future<> {
             auto s = std::move(out);
             bool first = true;
             std::exception_ptr ex;
@@ -157,11 +160,8 @@ void set_compaction_manager(http_context& ctx, routes& r, sharded<compaction::co
                 co_await cm.local().get_compaction_history([&s, &first](const db::compaction_history_entry& entry) mutable -> future<> {
                         cm::history h;
                         h.id = fmt::to_string(entry.id);
-                        h.shard_id = entry.shard_id;
                         h.ks = std::move(entry.ks);
                         h.cf = std::move(entry.cf);
-                        h.compaction_type = entry.compaction_type;
-                        h.started_at = entry.started_at;
                         h.compacted_at = entry.compacted_at;
                         h.bytes_in = entry.bytes_in;
                         h.bytes_out =  entry.bytes_out;
@@ -173,24 +173,6 @@ void set_compaction_manager(http_context& ctx, routes& r, sharded<compaction::co
                             e.value = it.second;
                             h.rows_merged.push(std::move(e));
                         }
-                        for (const auto& data : entry.sstables_in) {
-                            httpd::compaction_manager_json::sstableinfo sstable;
-                            sstable.generation = fmt::to_string(data.generation),
-                            sstable.origin = data.origin,
-                            sstable.size = data.size,
-                            h.sstables_in.push(std::move(sstable));
-                        }
-                        for (const auto& data : entry.sstables_out) {
-                            httpd::compaction_manager_json::sstableinfo sstable;
-                            sstable.generation = fmt::to_string(data.generation),
-                            sstable.origin = data.origin,
-                            sstable.size = data.size,
-                            h.sstables_out.push(std::move(sstable));
-                        }
-                        h.total_tombstone_purge_attempt = entry.total_tombstone_purge_attempt;
-                        h.total_tombstone_purge_failure_due_to_overlapping_with_memtable = entry.total_tombstone_purge_failure_due_to_overlapping_with_memtable;
-                        h.total_tombstone_purge_failure_due_to_overlapping_with_uncompacting_sstable = entry.total_tombstone_purge_failure_due_to_overlapping_with_uncompacting_sstable;
-
                         if (!first) {
                             co_await s.write(", ");
                         }

api/compaction_manager.hh

@@ -13,13 +13,11 @@ namespace seastar::httpd {
 class routes;
 }
 
-namespace compaction {
 class compaction_manager;
-}
 
 namespace api {
 struct http_context;
-void set_compaction_manager(http_context& ctx, seastar::httpd::routes& r, seastar::sharded<compaction::compaction_manager>& cm);
+void set_compaction_manager(http_context& ctx, seastar::httpd::routes& r, seastar::sharded<compaction_manager>& cm);
 void unset_compaction_manager(http_context& ctx, seastar::httpd::routes& r);
 
 }

api/config.cc

@@ -23,6 +23,22 @@ using namespace seastar::httpd;
 namespace sp = httpd::storage_proxy_json;
 namespace ss = httpd::storage_service_json;
 
+template<class T>
+json::json_return_type get_json_return_type(const T& val) {
+    return json::json_return_type(val);
+}
+
+/*
+ * As commented on db::seed_provider_type is not used
+ * and probably never will.
+ *
+ * Just in case, we will return its name
+ */
+template<>
+json::json_return_type get_json_return_type(const db::seed_provider_type& val) {
+    return json::json_return_type(val.class_name);
+}
+
 std::string_view format_type(std::string_view type) {
     if (type == "int") {
         return "integer";
@@ -171,7 +187,7 @@ void set_config(std::shared_ptr < api_registry_builder20 > rb, http_context& ctx
     });
 
     ss::get_all_data_file_locations.set(r, [&cfg](const_req req) {
-        return cfg.data_file_directories();
+        return container_to_vec(cfg.data_file_directories());
     });
 
     ss::get_saved_caches_location.set(r, [&cfg](const_req req) {

api/failure_detector.cc

@@ -22,10 +22,10 @@ void set_failure_detector(http_context& ctx, routes& r, gms::gossiper& g) {
         return g.container().invoke_on(0, [] (gms::gossiper& g) {
             std::vector<fd::endpoint_state> res;
             res.reserve(g.num_endpoints());
-            g.for_each_endpoint_state([&] (const gms::endpoint_state& eps) {
+            g.for_each_endpoint_state([&] (const gms::inet_address& addr, const gms::endpoint_state& eps) {
                 fd::endpoint_state val;
-                val.addrs = fmt::to_string(eps.get_ip());
-                val.is_alive = g.is_alive(eps.get_host_id());
+                val.addrs = fmt::to_string(addr);
+                val.is_alive = g.is_alive(addr);
                 val.generation = eps.get_heart_beat_state().get_generation().value();
                 val.version = eps.get_heart_beat_state().get_heart_beat_version().value();
                 val.update_time = eps.get_update_timestamp().time_since_epoch().count();
@@ -40,9 +40,7 @@ void set_failure_detector(http_context& ctx, routes& r, gms::gossiper& g) {
                 }
                 res.emplace_back(std::move(val));
             });
-            return make_ready_future<json::json_return_type>(json::stream_range_as_array(res, [](const fd::endpoint_state& i){
-                return i;
-            }));
+            return make_ready_future<json::json_return_type>(res);
         });
     });
 
@@ -66,15 +64,11 @@ void set_failure_detector(http_context& ctx, routes& r, gms::gossiper& g) {
 
     fd::get_simple_states.set(r, [&g] (std::unique_ptr<request> req) {
         return g.container().invoke_on(0, [] (gms::gossiper& g) {
-            std::vector<fd::mapper> nodes_status;
-            nodes_status.reserve(g.num_endpoints());
-            g.for_each_endpoint_state([&] (const gms::endpoint_state& es) {
-                fd::mapper val;
-                val.key = fmt::to_string(es.get_ip());
-                val.value = g.is_alive(es.get_host_id()) ? "UP" : "DOWN";
-                nodes_status.emplace_back(std::move(val));
+            std::map<sstring, sstring> nodes_status;
+            g.for_each_endpoint_state([&] (const gms::inet_address& node, const gms::endpoint_state&) {
+                nodes_status.emplace(fmt::to_string(node), g.is_alive(node) ? "UP" : "DOWN");
             });
-            return make_ready_future<json::json_return_type>(std::move(nodes_status));
+            return make_ready_future<json::json_return_type>(map_to_key_value<fd::mapper>(nodes_status));
         });
     });
 
@@ -87,7 +81,7 @@ void set_failure_detector(http_context& ctx, routes& r, gms::gossiper& g) {
 
     fd::get_endpoint_state.set(r, [&g] (std::unique_ptr<request> req) {
         return g.container().invoke_on(0, [req = std::move(req)] (gms::gossiper& g) {
-            auto state = g.get_endpoint_state_ptr(g.get_host_id(gms::inet_address(req->get_path_param("addr"))));
+            auto state = g.get_endpoint_state_ptr(gms::inet_address(req->get_path_param("addr")));
             if (!state) {
                 return make_ready_future<json::json_return_type>(format("unknown endpoint {}", req->get_path_param("addr")));
             }

api/gossiper.cc

@@ -21,45 +21,51 @@ using namespace json;
 void set_gossiper(http_context& ctx, routes& r, gms::gossiper& g) {
     httpd::gossiper_json::get_down_endpoint.set(r, [&g] (std::unique_ptr<request> req) -> future<json::json_return_type> {
         auto res = co_await g.get_unreachable_members_synchronized();
-        co_return json::json_return_type(res | std::views::transform([] (auto& ep) { return fmt::to_string(ep); }) | std::ranges::to<std::vector>());
+        co_return json::json_return_type(container_to_vec(res));
     });
 
 
-    httpd::gossiper_json::get_live_endpoint.set(r, [&g] (std::unique_ptr<request> req) -> future<json::json_return_type> {
-        auto res = co_await g.get_live_members_synchronized();
-        co_return json::json_return_type(res | std::views::transform([] (auto& ep) { return fmt::to_string(ep); }) | std::ranges::to<std::vector>());
+    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_endpoint_downtime.set(r, [&g] (std::unique_ptr<request> req) -> future<json::json_return_type> {
         gms::inet_address ep(req->get_path_param("addr"));
         // synchronize unreachable_members on all shards
         co_await g.get_unreachable_members_synchronized();
-        co_return g.get_endpoint_downtime(g.get_host_id(ep));
+        co_return g.get_endpoint_downtime(ep);
     });
 
     httpd::gossiper_json::get_current_generation_number.set(r, [&g] (std::unique_ptr<http::request> req) {
         gms::inet_address ep(req->get_path_param("addr"));
-        return g.get_current_generation_number(g.get_host_id(ep)).then([] (gms::generation_type res) {
+        return g.get_current_generation_number(ep).then([] (gms::generation_type res) {
             return make_ready_future<json::json_return_type>(res.value());
         });
     });
 
     httpd::gossiper_json::get_current_heart_beat_version.set(r, [&g] (std::unique_ptr<http::request> req) {
         gms::inet_address ep(req->get_path_param("addr"));
-        return g.get_current_heart_beat_version(g.get_host_id(ep)).then([] (gms::version_type res) {
+        return g.get_current_heart_beat_version(ep).then([] (gms::version_type res) {
             return make_ready_future<json::json_return_type>(res.value());
         });
     });
 
     httpd::gossiper_json::assassinate_endpoint.set(r, [&g](std::unique_ptr<http::request> req) {
-        return g.assassinate_endpoint(req->get_path_param("addr")).then([] {
+        if (req->get_query_param("unsafe") != "True") {
+            return g.assassinate_endpoint(req->get_path_param("addr")).then([] {
+                return make_ready_future<json::json_return_type>(json_void());
+            });
+        }
+        return g.unsafe_assassinate_endpoint(req->get_path_param("addr")).then([] {
             return make_ready_future<json::json_return_type>(json_void());
         });
     });
 
     httpd::gossiper_json::force_remove_endpoint.set(r, [&g](std::unique_ptr<http::request> req) {
         gms::inet_address ep(req->get_path_param("addr"));
-        return g.force_remove_endpoint(g.get_host_id(ep), gms::null_permit_id).then([] () {
+        return g.force_remove_endpoint(ep, gms::null_permit_id).then([] {
             return make_ready_future<json::json_return_type>(json_void());
         });
     });

api/messaging_service.cc

@@ -148,7 +148,7 @@ void set_messaging_service(http_context& ctx, routes& r, sharded<netw::messaging
     hf::inject_disconnect.set(r, [&ms] (std::unique_ptr<request> req) -> future<json::json_return_type> {
         auto ip = msg_addr(req->get_path_param("ip"));
         co_await ms.invoke_on_all([ip] (netw::messaging_service& ms) {
-            ms.remove_rpc_client(ip, std::nullopt);
+            ms.remove_rpc_client(ip);
         });
         co_return json::json_void();
     });

api/raft.cc

@@ -71,7 +71,7 @@ void set_raft(http_context&, httpd::routes& r, sharded<service::raft_group_regis
         co_return json_void{};
     });
     r::get_leader_host.set(r, [&raft_gr] (std::unique_ptr<http::request> req) -> future<json_return_type> {
-        if (req->get_query_param("group_id").empty()) {
+        if (!req->query_parameters.contains("group_id")) {
             const auto leader_id = co_await raft_gr.invoke_on(0, [] (service::raft_group_registry& raft_gr) {
                 auto& srv = raft_gr.group0();
                 return srv.current_leader();
@@ -100,7 +100,7 @@ void set_raft(http_context&, httpd::routes& r, sharded<service::raft_group_regis
     r::read_barrier.set(r, [&raft_gr] (std::unique_ptr<http::request> req) -> future<json_return_type> {
         auto timeout = get_request_timeout(*req);
 
-        if (req->get_query_param("group_id").empty()) {
+        if (!req->query_parameters.contains("group_id")) {
             // Read barrier on group 0 by default
             co_await raft_gr.invoke_on(0, [timeout] (service::raft_group_registry& raft_gr) -> future<> {
                 co_await raft_gr.group0_with_timeouts().read_barrier(nullptr, timeout);
@@ -131,7 +131,7 @@ void set_raft(http_context&, httpd::routes& r, sharded<service::raft_group_regis
         const auto stepdown_timeout_ticks = dur / service::raft_tick_interval;
         auto timeout_dur = raft::logical_clock::duration(stepdown_timeout_ticks);
 
-        if (req->get_query_param("group_id").empty()) {
+        if (!req->query_parameters.contains("group_id")) {
             // Stepdown on group 0 by default
             co_await raft_gr.invoke_on(0, [timeout_dur] (service::raft_group_registry& raft_gr) {
                 apilog.info("Triggering stepdown for group0");

api/service_levels.cc

@@ -11,7 +11,7 @@
 #include "cql3/query_processor.hh"
 #include "cql3/untyped_result_set.hh"
 #include "db/consistency_level_type.hh"
-#include <seastar/json/json_elements.hh>
+#include "seastar/json/json_elements.hh"
 #include "transport/controller.hh"
 #include <unordered_map>
 

api/storage_proxy.cc

@@ -39,7 +39,7 @@ utils::time_estimated_histogram timed_rate_moving_average_summary_merge(utils::t
  * @return A future that resolves to the result of the aggregation.
  */
 template<typename V, typename Reducer, typename InnerMapper>
-future<V> two_dimensional_map_reduce(sharded<service::storage_proxy>& d,
+future<V> two_dimensional_map_reduce(distributed<service::storage_proxy>& d,
         InnerMapper mapper, Reducer reducer, V initial_value) {
     return d.map_reduce0( [mapper, reducer, initial_value] (const service::storage_proxy& sp) {
         return map_reduce_scheduling_group_specific<service::storage_proxy_stats::stats>(
@@ -59,7 +59,7 @@ future<V> two_dimensional_map_reduce(sharded<service::storage_proxy>& d,
  * @return A future that resolves to the result of the aggregation.
  */
 template<typename V, typename Reducer, typename F, typename C>
-future<V> two_dimensional_map_reduce(sharded<service::storage_proxy>& d,
+future<V> two_dimensional_map_reduce(distributed<service::storage_proxy>& d,
         C F::*f, Reducer reducer, V initial_value) {
     return two_dimensional_map_reduce(d, [f] (F& stats) -> V {
         return stats.*f;
@@ -75,20 +75,20 @@ future<V> two_dimensional_map_reduce(sharded<service::storage_proxy>& d,
  *
  */
 template<typename V, typename F>
-future<json::json_return_type>  sum_stats_storage_proxy(sharded<proxy>& d, V F::*f) {
+future<json::json_return_type>  sum_stats_storage_proxy(distributed<proxy>& d, V F::*f) {
     return two_dimensional_map_reduce(d, [f] (F& stats) { return stats.*f; }, std::plus<V>(), V(0)).then([] (V val) {
         return make_ready_future<json::json_return_type>(val);
     });
 }
 
 
-static future<utils::rate_moving_average>  sum_timed_rate(sharded<proxy>& d, utils::timed_rate_moving_average service::storage_proxy_stats::stats::*f) {
+static future<utils::rate_moving_average>  sum_timed_rate(distributed<proxy>& d, utils::timed_rate_moving_average service::storage_proxy_stats::stats::*f) {
     return two_dimensional_map_reduce(d, [f] (service::storage_proxy_stats::stats& stats) {
         return (stats.*f).rate();
     }, std::plus<utils::rate_moving_average>(), utils::rate_moving_average());
 }
 
-static future<json::json_return_type>  sum_timed_rate_as_obj(sharded<proxy>& d, utils::timed_rate_moving_average service::storage_proxy_stats::stats::*f) {
+static future<json::json_return_type>  sum_timed_rate_as_obj(distributed<proxy>& d, utils::timed_rate_moving_average service::storage_proxy_stats::stats::*f) {
     return sum_timed_rate(d, f).then([](const utils::rate_moving_average& val) {
         httpd::utils_json::rate_moving_average m;
         m = val;
@@ -100,7 +100,7 @@ httpd::utils_json::rate_moving_average_and_histogram get_empty_moving_average()
     return timer_to_json(utils::rate_moving_average_and_histogram());
 }
 
-static future<json::json_return_type>  sum_timed_rate_as_long(sharded<proxy>& d, utils::timed_rate_moving_average service::storage_proxy_stats::stats::*f) {
+static future<json::json_return_type>  sum_timed_rate_as_long(distributed<proxy>& d, utils::timed_rate_moving_average service::storage_proxy_stats::stats::*f) {
     return sum_timed_rate(d, f).then([](const utils::rate_moving_average& val) {
         return make_ready_future<json::json_return_type>(val.count);
     });
@@ -152,7 +152,7 @@ static future<json::json_return_type>  total_latency(sharded<service::storage_pr
  */
 template<typename F>
 future<json::json_return_type>
-sum_histogram_stats_storage_proxy(sharded<proxy>& d,
+sum_histogram_stats_storage_proxy(distributed<proxy>& d,
         utils::timed_rate_moving_average_summary_and_histogram F::*f) {
     return two_dimensional_map_reduce(d, [f] (service::storage_proxy_stats::stats& stats) {
         return (stats.*f).hist;
@@ -172,7 +172,7 @@ sum_histogram_stats_storage_proxy(sharded<proxy>& d,
  */
 template<typename F>
 future<json::json_return_type>
-sum_timer_stats_storage_proxy(sharded<proxy>& d,
+sum_timer_stats_storage_proxy(distributed<proxy>& d,
         utils::timed_rate_moving_average_summary_and_histogram F::*f) {
 
     return two_dimensional_map_reduce(d, [f] (service::storage_proxy_stats::stats& stats) {

api/storage_service.cc

@@ -14,13 +14,9 @@
 #include "api/scrub_status.hh"
 #include "db/config.hh"
 #include "db/schema_tables.hh"
-#include "gms/feature_service.hh"
-#include "schema/schema_builder.hh"
-#include "sstables/sstables_manager.hh"
 #include "utils/hash.hh"
 #include <optional>
 #include <sstream>
-#include <stdexcept>
 #include <time.h>
 #include <algorithm>
 #include <functional>
@@ -33,7 +29,6 @@
 #include "service/raft/raft_group0_client.hh"
 #include "service/storage_service.hh"
 #include "service/load_meter.hh"
-#include "gms/feature_service.hh"
 #include "gms/gossiper.hh"
 #include "db/system_keyspace.hh"
 #include <seastar/http/exception.hh>
@@ -60,7 +55,6 @@
 #include "db/view/view_builder.hh"
 #include "utils/rjson.hh"
 #include "utils/user_provided_param.hh"
-#include "sstable_dict_autotrainer.hh"
 
 using namespace seastar::httpd;
 using namespace std::chrono_literals;
@@ -128,26 +122,37 @@ bool validate_bool(const sstring& param) {
     }
 }
 
-bool validate_bool_x(const sstring& param, bool default_value) {
-    if (param.empty()) {
-        return default_value;
-    }
-
-    if (strcasecmp(param.c_str(), "true") == 0 || strcasecmp(param.c_str(), "yes") == 0 || param == "1") {
-        return true;
-    }
-    if (strcasecmp(param.c_str(), "false") == 0 || strcasecmp(param.c_str(), "no") == 0 || param == "0") {
-        return false;
-    }
-
-    throw std::runtime_error("Invalid boolean parameter value");
-}
-
 static
 int64_t validate_int(const sstring& param) {
     return std::atoll(param.c_str());
 }
 
+// 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
+// containing the description of the respective no_such_column_family error.
+static std::vector<sstring> parse_tables(const sstring& ks_name, const http_context& ctx, sstring value) {
+    if (value.empty()) {
+        return map_keys(ctx.db.local().find_keyspace(ks_name).metadata().get()->cf_meta_data());
+    }
+    std::vector<sstring> names = split(value, ",");
+    try {
+        for (const auto& table_name : names) {
+            ctx.db.local().find_column_family(ks_name, table_name);
+        }
+    } catch (const replica::no_such_column_family& e) {
+        throw bad_param_exception(e.what());
+    }
+    return names;
+}
+
+static std::vector<sstring> parse_tables(const sstring& ks_name, const http_context& ctx, const std::unordered_map<sstring, sstring>& query_params, sstring param_name) {
+    auto it = query_params.find(param_name);
+    if (it == query_params.end()) {
+        return {};
+    }
+    return parse_tables(ks_name, ctx, it->second);
+}
+
 std::vector<table_info> parse_table_infos(const sstring& ks_name, const http_context& ctx, sstring value) {
     std::vector<table_info> res;
     try {
@@ -173,10 +178,9 @@ std::vector<table_info> parse_table_infos(const sstring& ks_name, const http_con
     return res;
 }
 
-std::pair<sstring, std::vector<table_info>> parse_table_infos(const http_context& ctx, const http::request& req, sstring cf_param_name) {
-    auto keyspace = validate_keyspace(ctx, req);
-    auto tis = parse_table_infos(keyspace, ctx, req.get_query_param(cf_param_name));
-    return std::make_pair(std::move(keyspace), std::move(tis));
+std::vector<table_info> parse_table_infos(const sstring& ks_name, const http_context& ctx, const std::unordered_map<sstring, sstring>& query_params, sstring param_name) {
+    auto it = query_params.find(param_name);
+    return parse_table_infos(ks_name, ctx, it != query_params.end() ? it->second : "");
 }
 
 static ss::token_range token_range_endpoints_to_json(const dht::token_range_endpoints& d) {
@@ -197,7 +201,17 @@ static ss::token_range token_range_endpoints_to_json(const dht::token_range_endp
     return r;
 }
 
-seastar::future<json::json_return_type> run_toppartitions_query(db::toppartitions_query& q, bool legacy_request) {
+using ks_cf_func = std::function<future<json::json_return_type>(http_context&, std::unique_ptr<http::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) {
+        auto keyspace = validate_keyspace(ctx, req);
+        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));
+    };
+}
+
+seastar::future<json::json_return_type> run_toppartitions_query(db::toppartitions_query& q, http_context &ctx, bool legacy_request) {
     return q.scatter().then([&q, legacy_request] {
         return sleep(q.duration()).then([&q, legacy_request] {
             return q.gather(q.capacity()).then([&q, legacy_request] (auto topk_results) {
@@ -227,36 +241,48 @@ seastar::future<json::json_return_type> run_toppartitions_query(db::toppartition
     });
 }
 
-scrub_info parse_scrub_options(const http_context& ctx, std::unique_ptr<http::request> req) {
+future<scrub_info> parse_scrub_options(const http_context& ctx, sharded<db::snapshot_ctl>& snap_ctl, std::unique_ptr<http::request> req) {
     scrub_info info;
-    auto [ keyspace, table_infos ] = parse_table_infos(ctx, *req, "cf");
-    info.keyspace = std::move(keyspace);
-    info.column_families = table_infos | std::views::transform(&table_info::name) | std::ranges::to<std::vector>();
-    auto scrub_mode_str = req->get_query_param("scrub_mode");
-    auto scrub_mode = compaction::compaction_type_options::scrub::mode::abort;
+    auto rp = req_params({
+        {"keyspace", {mandatory::yes}},
+        {"cf", {""}},
+        {"scrub_mode", {}},
+        {"skip_corrupted", {}},
+        {"disable_snapshot", {}},
+        {"quarantine_mode", {}},
+    });
+    rp.process(*req);
+    info.keyspace = validate_keyspace(ctx, *rp.get("keyspace"));
+    info.column_families = parse_tables(info.keyspace, ctx, *rp.get("cf"));
+    auto scrub_mode_opt = rp.get("scrub_mode");
+    auto scrub_mode = sstables::compaction_type_options::scrub::mode::abort;
 
-    if (scrub_mode_str.empty()) {
-        const auto skip_corrupted = validate_bool_x(req->get_query_param("skip_corrupted"), false);
+    if (!scrub_mode_opt) {
+        const auto skip_corrupted = rp.get_as<bool>("skip_corrupted").value_or(false);
 
         if (skip_corrupted) {
-            scrub_mode = compaction::compaction_type_options::scrub::mode::skip;
+            scrub_mode = sstables::compaction_type_options::scrub::mode::skip;
         }
     } else {
+        auto scrub_mode_str = *scrub_mode_opt;
         if (scrub_mode_str == "ABORT") {
-            scrub_mode = compaction::compaction_type_options::scrub::mode::abort;
+            scrub_mode = sstables::compaction_type_options::scrub::mode::abort;
         } else if (scrub_mode_str == "SKIP") {
-            scrub_mode = compaction::compaction_type_options::scrub::mode::skip;
+            scrub_mode = sstables::compaction_type_options::scrub::mode::skip;
         } else if (scrub_mode_str == "SEGREGATE") {
-            scrub_mode = compaction::compaction_type_options::scrub::mode::segregate;
+            scrub_mode = sstables::compaction_type_options::scrub::mode::segregate;
         } else if (scrub_mode_str == "VALIDATE") {
-            scrub_mode = compaction::compaction_type_options::scrub::mode::validate;
+            scrub_mode = sstables::compaction_type_options::scrub::mode::validate;
         } else {
             throw httpd::bad_param_exception(fmt::format("Unknown argument for 'scrub_mode' parameter: {}", scrub_mode_str));
         }
     }
 
-    if (!req_param<bool>(*req, "disable_snapshot", false) && !info.column_families.empty()) {
-        info.snapshot_tag = format("pre-scrub-{:d}", db_clock::now().time_since_epoch().count());
+    if (!req_param<bool>(*req, "disable_snapshot", false)) {
+        auto tag = format("pre-scrub-{:d}", db_clock::now().time_since_epoch().count());
+        co_await coroutine::parallel_for_each(info.column_families, [&snap_ctl, keyspace = info.keyspace, tag](sstring cf) {
+            return snap_ctl.local().take_column_family_snapshot(keyspace, cf, tag, db::snapshot_ctl::skip_flush::no);
+        });
     }
 
     info.opts = {
@@ -264,16 +290,16 @@ scrub_info parse_scrub_options(const http_context& ctx, std::unique_ptr<http::re
     };
     const sstring quarantine_mode_str = req_param<sstring>(*req, "quarantine_mode", "INCLUDE");
     if (quarantine_mode_str == "INCLUDE") {
-        info.opts.quarantine_operation_mode = compaction::compaction_type_options::scrub::quarantine_mode::include;
+        info.opts.quarantine_operation_mode = sstables::compaction_type_options::scrub::quarantine_mode::include;
     } else if (quarantine_mode_str == "EXCLUDE") {
-        info.opts.quarantine_operation_mode = compaction::compaction_type_options::scrub::quarantine_mode::exclude;
+        info.opts.quarantine_operation_mode = sstables::compaction_type_options::scrub::quarantine_mode::exclude;
     } else if (quarantine_mode_str == "ONLY") {
-        info.opts.quarantine_operation_mode = compaction::compaction_type_options::scrub::quarantine_mode::only;
+        info.opts.quarantine_operation_mode = sstables::compaction_type_options::scrub::quarantine_mode::only;
     } else {
         throw httpd::bad_param_exception(fmt::format("Unknown argument for 'quarantine_mode' parameter: {}", quarantine_mode_str));
     }
 
-    return info;
+    co_return info;
 }
 
 void set_transport_controller(http_context& ctx, routes& r, cql_transport::controller& ctl) {
@@ -330,7 +356,7 @@ void set_repair(http_context& ctx, routes& r, sharded<repair_service>& repair, s
         // Nodetool still sends those unsupported options. Ignore them to avoid failing nodetool repair.
         static std::unordered_set<sstring> legacy_options_to_ignore = {"pullRepair", "ignoreUnreplicatedKeyspaces"};
 
-        for (auto& x : req->get_query_params()) {
+        for (auto& x : req->query_parameters) {
             if (legacy_options_to_ignore.contains(x.first)) {
                 continue;
             }
@@ -357,9 +383,6 @@ void set_repair(http_context& ctx, routes& r, sharded<repair_service>& repair, s
             // if the option is not sane, repair_start() throws immediately, so
             // convert the exception to an HTTP error
             throw httpd::bad_param_exception(e.what());
-        } catch (const tablets_unsupported& e) {
-            throw base_exception("Cannot repair tablet keyspace. Use /storage_service/tablets/repair to repair tablet keyspaces.",
-                    http::reply::status_type::forbidden);
         }
     });
 
@@ -460,27 +483,17 @@ void set_sstables_loader(http_context& ctx, routes& r, sharded<sstables_loader>&
         auto cf = req->get_query_param("cf");
         auto stream = req->get_query_param("load_and_stream");
         auto primary_replica = req->get_query_param("primary_replica_only");
-        auto skip_cleanup_p = req->get_query_param("skip_cleanup");
         boost::algorithm::to_lower(stream);
         boost::algorithm::to_lower(primary_replica);
         bool load_and_stream = stream == "true" || stream == "1";
         bool primary_replica_only = primary_replica == "true" || primary_replica == "1";
-        bool skip_cleanup = skip_cleanup_p == "true" || skip_cleanup_p == "1";
-        auto scope = parse_stream_scope(req->get_query_param("scope"));
-        auto skip_reshape_p = req->get_query_param("skip_reshape");
-        auto skip_reshape = skip_reshape_p == "true" || skip_reshape_p == "1";
-
-        if (scope != sstables_loader::stream_scope::all && !load_and_stream) {
-            throw httpd::bad_param_exception("scope takes no effect without load-and-stream");
-        }
-
         // No need to add the keyspace, since all we want is to avoid always sending this to the same
         // CPU. Even then I am being overzealous here. This is not something that happens all the time.
         auto coordinator = std::hash<sstring>()(cf) % smp::count;
         return sst_loader.invoke_on(coordinator,
                 [ks = std::move(ks), cf = std::move(cf),
-                load_and_stream, primary_replica_only, skip_cleanup, skip_reshape, scope] (sstables_loader& loader) {
-            return loader.load_new_sstables(ks, cf, load_and_stream, primary_replica_only, skip_cleanup, skip_reshape, scope);
+                load_and_stream, primary_replica_only] (sstables_loader& loader) {
+            return loader.load_new_sstables(ks, cf, load_and_stream, primary_replica_only, sstables_loader::stream_scope::all);
         }).then_wrapped([] (auto&& f) {
             if (f.failed()) {
                 auto msg = fmt::format("Failed to load new sstables: {}", f.get_exception());
@@ -497,7 +510,6 @@ void set_sstables_loader(http_context& ctx, routes& r, sharded<sstables_loader>&
         auto bucket = req->get_query_param("bucket");
         auto prefix = req->get_query_param("prefix");
         auto scope = parse_stream_scope(req->get_query_param("scope"));
-        auto primary_replica_only = validate_bool_x(req->get_query_param("primary_replica_only"), false);
 
         // TODO: the http_server backing the API does not use content streaming
         // should use it for better performance
@@ -508,7 +520,7 @@ void set_sstables_loader(http_context& ctx, routes& r, sharded<sstables_loader>&
         auto sstables = parsed.GetArray() |
             std::views::transform([] (const auto& s) { return sstring(rjson::to_string_view(s)); }) |
             std::ranges::to<std::vector>();
-        auto task_id = co_await sst_loader.local().download_new_sstables(keyspace, table, prefix, std::move(sstables), endpoint, bucket, scope, primary_replica_only);
+        auto task_id = co_await sst_loader.local().download_new_sstables(keyspace, table, prefix, std::move(sstables), endpoint, bucket, scope);
         co_return json::json_return_type(fmt::to_string(task_id));
     });
 
@@ -554,8 +566,10 @@ rest_get_token_endpoint(http_context& ctx, sharded<service::storage_service>& ss
             token_endpoints = ss.local().get_token_to_endpoint_map();
         } else if (!keyspace_name.empty() && !table_name.empty()) {
             auto& db = ctx.db.local();
-            auto tid = validate_table(db, keyspace_name, table_name);
-            token_endpoints = co_await ss.local().get_tablet_to_endpoint_map(tid);
+            if (!db.has_schema(keyspace_name, table_name)) {
+                throw bad_param_exception(fmt::format("Failed to find table {}.{}", keyspace_name, table_name));
+            }
+            token_endpoints = co_await ss.local().get_tablet_to_endpoint_map(db.find_schema(keyspace_name, table_name)->id());
         } else {
             throw bad_param_exception("Either provide both keyspace and table (for tablet table) or neither (for vnodes)");
         }
@@ -574,8 +588,9 @@ rest_toppartitions_generic(http_context& ctx, std::unique_ptr<http::request> req
         bool filters_provided = false;
 
         std::unordered_set<std::tuple<sstring, sstring>, utils::tuple_hash> table_filters {};
-        if (auto filters = req->get_query_param("table_filters"); !filters.empty()) {
+        if (req->query_parameters.contains("table_filters")) {
             filters_provided = true;
+            auto filters = req->get_query_param("table_filters");
             std::stringstream ss { filters };
             std::string filter;
             while (!filters.empty() && ss.good()) {
@@ -585,8 +600,9 @@ rest_toppartitions_generic(http_context& ctx, std::unique_ptr<http::request> req
         }
 
         std::unordered_set<sstring> keyspace_filters {};
-        if (auto filters = req->get_query_param("keyspace_filters"); !filters.empty()) {
+        if (req->query_parameters.contains("keyspace_filters")) {
             filters_provided = true;
+            auto filters = req->get_query_param("keyspace_filters");
             std::stringstream ss { filters };
             std::string filter;
             while (!filters.empty() && ss.good()) {
@@ -613,8 +629,8 @@ rest_toppartitions_generic(http_context& ctx, std::unique_ptr<http::request> req
         apilog.info("toppartitions query: #table_filters={} #keyspace_filters={} duration={} list_size={} capacity={}",
             !table_filters.empty() ? std::to_string(table_filters.size()) : "all", !keyspace_filters.empty() ? std::to_string(keyspace_filters.size()) : "all", duration.value, list_size.value, capacity.value);
 
-        return seastar::do_with(db::toppartitions_query(ctx.db, std::move(table_filters), std::move(keyspace_filters), duration.value, list_size, capacity), [] (db::toppartitions_query& q) {
-            return run_toppartitions_query(q);
+        return seastar::do_with(db::toppartitions_query(ctx.db, std::move(table_filters), std::move(keyspace_filters), duration.value, list_size, capacity), [&ctx] (db::toppartitions_query& q) {
+            return run_toppartitions_query(q, ctx);
         });
 }
 
@@ -641,16 +657,21 @@ future<json::json_return_type>
 rest_get_range_to_endpoint_map(http_context& ctx, sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
         auto keyspace = validate_keyspace(ctx, req);
         auto table = req->get_query_param("cf");
-        std::optional<table_id> table_id;
 
-        if (table.empty()) {
-            ensure_tablets_disabled(ctx, keyspace, "storage_service/range_to_endpoint_map");
-        } else {
-            table_id = validate_table(ctx.db.local(), keyspace, table);
-        }
+        auto erm = std::invoke([&]() -> locator::effective_replication_map_ptr {
+            auto& ks = ctx.db.local().find_keyspace(keyspace);
+            if (table.empty()) {
+                ensure_tablets_disabled(ctx, keyspace, "storage_service/range_to_endpoint_map");
+                return ks.get_vnode_effective_replication_map();
+            } else {
+                auto table_id = validate_table(ctx.db.local(), keyspace, table);
+                auto& cf = ctx.db.local().find_column_family(table_id);
+                return cf.get_effective_replication_map();
+            }
+        });
 
         std::vector<ss::maplist_mapper> res;
-        co_return stream_range_as_array(co_await ss.local().get_range_to_address_map(keyspace, table_id),
+        co_return stream_range_as_array(co_await ss.local().get_range_to_address_map(erm),
                 [](const std::pair<dht::token_range, inet_address_vector_replica_set>& entry){
             ss::maplist_mapper m;
             if (entry.first.start()) {
@@ -695,10 +716,16 @@ rest_describe_ring(http_context& ctx, sharded<service::storage_service>& ss, std
         return describe_ring_as_json(ss, validate_keyspace(ctx, req));
 }
 
+static
+future<json::json_return_type>
+rest_get_load(http_context& ctx, std::unique_ptr<http::request> req) {
+        return get_cf_stats(ctx, &replica::column_family_stats::live_disk_space_used);
+}
+
 static
 future<json::json_return_type>
 rest_get_current_generation_number(sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
-        auto ep = ss.local().get_token_metadata().get_topology().my_host_id();
+        auto ep = ss.local().get_token_metadata().get_topology().my_address();
         return ss.local().gossiper().get_current_generation_number(ep).then([](gms::generation_type res) {
             return make_ready_future<json::json_return_type>(res.value());
         });
@@ -708,8 +735,8 @@ static
 json::json_return_type
 rest_get_natural_endpoints(http_context& ctx, sharded<service::storage_service>& ss, const_req req) {
         auto keyspace = validate_keyspace(ctx, req);
-        auto res = ss.local().get_natural_endpoints(keyspace, req.get_query_param("cf"), req.get_query_param("key"));
-        return res | std::views::transform([] (auto& ep) { return fmt::to_string(ep); }) | std::ranges::to<std::vector>();
+        return container_to_vec(ss.local().get_natural_endpoints(keyspace, req.get_query_param("cf"),
+                req.get_query_param("key")));
 }
 
 static
@@ -724,15 +751,103 @@ rest_cdc_streams_check_and_repair(sharded<service::storage_service>& ss, std::un
 
 static
 future<json::json_return_type>
-rest_cleanup_all(http_context& ctx, sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
-        bool global = true;
-        if (auto global_param = req->get_query_param("global"); !global_param.empty()) {
-            global = validate_bool(global_param);
+rest_force_compaction(http_context& ctx, std::unique_ptr<http::request> req) {
+        auto& db = ctx.db;
+        auto params = req_params({
+            std::pair("flush_memtables", mandatory::no),
+            std::pair("consider_only_existing_data", mandatory::no),
+        });
+        params.process(*req);
+        auto flush = params.get_as<bool>("flush_memtables").value_or(true);
+        auto consider_only_existing_data = params.get_as<bool>("consider_only_existing_data").value_or(false);
+        apilog.info("force_compaction: flush={} consider_only_existing_data={}", flush, consider_only_existing_data);
+
+        auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
+        std::optional<flush_mode> fmopt;
+        if (!flush && !consider_only_existing_data) {
+            fmopt = flush_mode::skip;
+        }
+        auto task = co_await compaction_module.make_and_start_task<global_major_compaction_task_impl>({}, db, fmopt, consider_only_existing_data);
+        try {
+            co_await task->done();
+        } catch (...) {
+            apilog.error("force_compaction failed: {}", std::current_exception());
+            throw;
         }
 
-        apilog.info("cleanup_all global={}", global);
+        co_return json_void();
+}
 
-        auto done = !global ? false : co_await ss.invoke_on(0, [] (service::storage_service& ss) -> future<bool> {
+static
+future<json::json_return_type>
+rest_force_keyspace_compaction(http_context& ctx, std::unique_ptr<http::request> req) {
+        auto& db = ctx.db;
+        auto params = req_params({
+            std::pair("keyspace", mandatory::yes),
+            std::pair("cf", mandatory::no),
+            std::pair("flush_memtables", mandatory::no),
+            std::pair("consider_only_existing_data", mandatory::no),
+        });
+        params.process(*req);
+        auto keyspace = validate_keyspace(ctx, *params.get("keyspace"));
+        auto table_infos = parse_table_infos(keyspace, ctx, params.get("cf").value_or(""));
+        auto flush = params.get_as<bool>("flush_memtables").value_or(true);
+        auto consider_only_existing_data = params.get_as<bool>("consider_only_existing_data").value_or(false);
+        apilog.info("force_keyspace_compaction: keyspace={} tables={}, flush={} consider_only_existing_data={}", keyspace, table_infos, flush, consider_only_existing_data);
+
+        auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
+        std::optional<flush_mode> fmopt;
+        if (!flush && !consider_only_existing_data) {
+            fmopt = flush_mode::skip;
+        }
+        auto task = co_await compaction_module.make_and_start_task<major_keyspace_compaction_task_impl>({}, std::move(keyspace), tasks::task_id::create_null_id(), db, table_infos, fmopt, consider_only_existing_data);
+        try {
+            co_await task->done();
+        } catch (...) {
+            apilog.error("force_keyspace_compaction: keyspace={} tables={} failed: {}", task->get_status().keyspace, table_infos, std::current_exception());
+            throw;
+        }
+
+        co_return json_void();
+}
+
+static
+future<json::json_return_type>
+rest_force_keyspace_cleanup(http_context& ctx, sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
+        auto& db = ctx.db;
+        auto keyspace = validate_keyspace(ctx, req);
+        auto table_infos = parse_table_infos(keyspace, ctx, req->query_parameters, "cf");
+        const auto& rs = db.local().find_keyspace(keyspace).get_replication_strategy();
+        if (rs.get_type() == locator::replication_strategy_type::local || !rs.is_vnode_based()) {
+            auto reason = rs.get_type() == locator::replication_strategy_type::local ? "require" : "support";
+            apilog.info("Keyspace {} does not {} cleanup", keyspace, reason);
+            co_return json::json_return_type(0);
+        }
+        apilog.info("force_keyspace_cleanup: keyspace={} tables={}", keyspace, table_infos);
+        if (!co_await ss.local().is_cleanup_allowed(keyspace)) {
+            auto msg = "Can not perform cleanup operation when topology changes";
+            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, table_infos, flush_mode::all_tables, tasks::is_user_task::yes);
+        try {
+            co_await task->done();
+        } catch (...) {
+            apilog.error("force_keyspace_cleanup: keyspace={} tables={} failed: {}", task->get_status().keyspace, table_infos, std::current_exception());
+            throw;
+        }
+
+        co_return json::json_return_type(0);
+}
+
+static
+future<json::json_return_type>
+rest_cleanup_all(http_context& ctx, sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
+        apilog.info("cleanup_all");
+        auto done = co_await ss.invoke_on(0, [] (service::storage_service& ss) -> future<bool> {
             if (!ss.is_topology_coordinator_enabled()) {
                 co_return false;
             }
@@ -742,33 +857,54 @@ rest_cleanup_all(http_context& ctx, sharded<service::storage_service>& ss, std::
         if (done) {
             co_return json::json_return_type(0);
         }
-        // fall back to the local cleanup if topology coordinator is not enabled or local cleanup is requested
+        // fall back to the local global cleanup if topology coordinator is not enabled
         auto& db = ctx.db;
         auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
-        auto task = co_await compaction_module.make_and_start_task<compaction::global_cleanup_compaction_task_impl>({}, db);
-        co_await task->done();
-
-        // Mark this node as clean
-        co_await ss.invoke_on(0, [] (service::storage_service& ss) -> future<> {
-            if (ss.is_topology_coordinator_enabled()) {
-                co_await ss.reset_cleanup_needed();
-            }
-        });
-
+        auto task = co_await compaction_module.make_and_start_task<global_cleanup_compaction_task_impl>({}, db);
+        try {
+            co_await task->done();
+        } catch (...) {
+            apilog.error("cleanup_all failed: {}", std::current_exception());
+            throw;
+        }
         co_return json::json_return_type(0);
 }
 
 static
 future<json::json_return_type>
-rest_reset_cleanup_needed(http_context& ctx, sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
-        apilog.info("reset_cleanup_needed");
-        co_await ss.invoke_on(0, [] (service::storage_service& ss) {
-            if (!ss.is_topology_coordinator_enabled()) {
-                throw std::runtime_error("mark_node_as_clean is only supported when topology over raft is enabled");
-            }
-            return ss.reset_cleanup_needed();
-        });
-        co_return json_void();
+rest_perform_keyspace_offstrategy_compaction(http_context& ctx, std::unique_ptr<http::request> req, sstring keyspace, std::vector<table_info> table_infos) {
+        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, table_infos, &res);
+        try {
+            co_await task->done();
+        } catch (...) {
+            apilog.error("perform_keyspace_offstrategy_compaction: keyspace={} tables={} failed: {}", task->get_status().keyspace, table_infos, std::current_exception());
+            throw;
+        }
+
+        co_return json::json_return_type(res);
+}
+
+static
+future<json::json_return_type>
+rest_upgrade_sstables(http_context& ctx, std::unique_ptr<http::request> req, sstring keyspace, std::vector<table_info> table_infos) {
+        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, table_infos, exclude_current_version);
+        try {
+            co_await task->done();
+        } catch (...) {
+            apilog.error("upgrade_sstables: keyspace={} tables={} failed: {}", keyspace, table_infos, std::current_exception());
+            throw;
+        }
+
+        co_return json::json_return_type(0);
 }
 
 static
@@ -784,10 +920,15 @@ rest_force_flush(http_context& ctx, std::unique_ptr<http::request> req) {
 static
 future<json::json_return_type>
 rest_force_keyspace_flush(http_context& ctx, std::unique_ptr<http::request> req) {
-        auto [keyspace, table_infos] = parse_table_infos(ctx, *req);
-        apilog.info("perform_keyspace_flush: keyspace={} tables={}", keyspace, table_infos);
+        auto keyspace = validate_keyspace(ctx, req);
+        auto column_families = parse_tables(keyspace, ctx, req->query_parameters, "cf");
+        apilog.info("perform_keyspace_flush: keyspace={} tables={}", keyspace, column_families);
         auto& db = ctx.db;
-        co_await replica::database::flush_tables_on_all_shards(db, std::move(table_infos));
+        if (column_families.empty()) {
+            co_await replica::database::flush_keyspace_on_all_shards(db, keyspace);
+        } else {
+            co_await replica::database::flush_tables_on_all_shards(db, keyspace, std::move(column_families));
+        }
         co_return json_void();
 }
 
@@ -890,9 +1031,9 @@ rest_is_starting(sharded<service::storage_service>& ss, std::unique_ptr<http::re
 
 static
 future<json::json_return_type>
-rest_get_drain_progress(sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
-        return ss.map_reduce(adder<replica::database::drain_progress>(), [] (auto& ss) {
-            return ss.get_database().get_drain_progress();
+rest_get_drain_progress(http_context& ctx, std::unique_ptr<http::request> req) {
+        return ctx.db.map_reduce(adder<replica::database::drain_progress>(), [] (auto& db) {
+            return db.get_drain_progress();
         }).then([] (auto&& progress) {
             auto progress_str = format("Drained {}/{} ColumnFamilies", progress.remaining_cfs, progress.total_cfs);
             return make_ready_future<json::json_return_type>(std::move(progress_str));
@@ -908,6 +1049,28 @@ rest_drain(sharded<service::storage_service>& ss, std::unique_ptr<http::request>
         });
 }
 
+static
+json::json_return_type
+rest_get_keyspaces(http_context& ctx, const_req req) {
+        auto type = req.get_query_param("type");
+        auto replication = req.get_query_param("replication");
+        std::vector<sstring> keyspaces;
+        if (type == "user") {
+            keyspaces = ctx.db.local().get_user_keyspaces();
+        } else if (type == "non_local_strategy") {
+            keyspaces = ctx.db.local().get_non_local_strategy_keyspaces();
+        } else {
+            keyspaces = map_keys(ctx.db.local().get_keyspaces());
+        }
+        if (replication.empty() || replication == "all") {
+            return keyspaces;
+        }
+        const auto want_tablets = replication == "tablets";
+        return keyspaces | std::views::filter([&ctx, want_tablets] (const sstring& ks) {
+            return ctx.db.local().find_keyspace(ks).get_replication_strategy().uses_tablets() == want_tablets;
+        }) | std::ranges::to<std::vector>();
+}
+
 static
 future<json::json_return_type>
 rest_stop_gossiping(sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
@@ -1224,6 +1387,12 @@ rest_set_hinted_handoff_throttle_in_kb(std::unique_ptr<http::request> req) {
         return make_ready_future<json::json_return_type>(json_void());
 }
 
+static
+future<json::json_return_type>
+rest_get_metrics_load(http_context& ctx, std::unique_ptr<http::request> req) {
+        return get_cf_stats(ctx, &replica::column_family_stats::live_disk_space_used);
+}
+
 static
 json::json_return_type
 rest_get_exceptions(sharded<service::storage_service>& ss, const_req req) {
@@ -1279,95 +1448,6 @@ rest_get_effective_ownership(http_context& ctx, sharded<service::storage_service
         });
 }
 
-static
-future<json::json_return_type>
-rest_estimate_compression_ratios(http_context& ctx, sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
-    if (!ss.local().get_feature_service().sstable_compression_dicts) {
-        apilog.warn("estimate_compression_ratios: called before the cluster feature was enabled");
-        throw std::runtime_error("estimate_compression_ratios requires all nodes to support the SSTABLE_COMPRESSION_DICTS cluster feature");
-    }
-    auto ticket = get_units(ss.local().get_do_sample_sstables_concurrency_limiter(), 1);
-    auto ks = api::req_param<sstring>(*req, "keyspace", {}).value;
-    auto cf = api::req_param<sstring>(*req, "cf", {}).value;
-    apilog.debug("estimate_compression_ratios: called with ks={} cf={}", ks, cf);
-
-    auto s = ctx.db.local().find_column_family(ks, cf).schema();
-
-    auto training_sample = co_await ss.local().do_sample_sstables(s->id(), 4096, 4096);
-    auto validation_sample = co_await ss.local().do_sample_sstables(s->id(), 16*1024, 1024);
-    apilog.debug("estimate_compression_ratios: got training sample with {} blocks and validation sample with {}", training_sample.size(), validation_sample.size());
-
-    auto dict = co_await ss.local().train_dict(std::move(training_sample));
-    apilog.debug("estimate_compression_ratios: got dict of size {}", dict.size());
-
-    std::vector<ss::compression_config_result> res;
-    auto make_result = [](std::string_view name, int chunk_length_kb, std::string_view dict, int level, float ratio) -> ss::compression_config_result {
-        ss::compression_config_result x;
-        x.sstable_compression = sstring(name);
-        x.chunk_length_in_kb = chunk_length_kb;
-        x.dict = sstring(dict);
-        x.level = level;
-        x.ratio = ratio;
-        return x;
-    };
-
-    using algorithm = compression_parameters::algorithm;
-    for (const auto& algo : {algorithm::lz4_with_dicts, algorithm::zstd_with_dicts}) {
-        for (const auto& chunk_size_kb : {1, 4, 16}) {
-            std::vector<int> levels;
-            if (algo == compressor::algorithm::zstd_with_dicts) {
-                for (int i = 1; i <= 5; ++i) {
-                    levels.push_back(i);
-                }
-            } else {
-                levels.push_back(1);
-            }
-            for (auto level : levels) {
-                auto algo_name = compression_parameters::algorithm_to_name(algo);
-                auto m = std::map<sstring, sstring>{
-                    {compression_parameters::CHUNK_LENGTH_KB, std::to_string(chunk_size_kb)},
-                    {compression_parameters::SSTABLE_COMPRESSION, sstring(algo_name)},
-                };
-                if (algo == compressor::algorithm::zstd_with_dicts) {
-                    m.insert(decltype(m)::value_type{sstring("compression_level"), sstring(std::to_string(level))});
-                }
-                auto params = compression_parameters(std::move(m));
-                auto ratio_with_no_dict = co_await try_one_compression_config({}, s, params, validation_sample);
-                auto ratio_with_past_dict = co_await try_one_compression_config(ctx.db.local().get_user_sstables_manager().get_compressor_factory(), s, params, validation_sample);
-                auto ratio_with_future_dict = co_await try_one_compression_config(dict, s, params, validation_sample);
-                res.push_back(make_result(algo_name, chunk_size_kb, "none", level, ratio_with_no_dict));
-                res.push_back(make_result(algo_name, chunk_size_kb, "past", level, ratio_with_past_dict));
-                res.push_back(make_result(algo_name, chunk_size_kb, "future", level, ratio_with_future_dict));
-            }
-        }
-    }
-
-    co_return res;
-}
-
-static
-future<json::json_return_type>
-rest_retrain_dict(http_context& ctx, sharded<service::storage_service>& ss, service::raft_group0_client& group0_client, std::unique_ptr<http::request> req) {
-    if (!ss.local().get_feature_service().sstable_compression_dicts) {
-        apilog.warn("retrain_dict: called before the cluster feature was enabled");
-        throw std::runtime_error("retrain_dict requires all nodes to support the SSTABLE_COMPRESSION_DICTS cluster feature");
-    }
-    auto ticket = get_units(ss.local().get_do_sample_sstables_concurrency_limiter(), 1);
-    auto ks = api::req_param<sstring>(*req, "keyspace", {}).value;
-    auto cf = api::req_param<sstring>(*req, "cf", {}).value;
-    apilog.debug("retrain_dict: called with ks={} cf={}", ks, cf);
-    const auto t_id = ctx.db.local().find_column_family(ks, cf).schema()->id();
-    constexpr uint64_t chunk_size = 4096;
-    constexpr uint64_t n_chunks = 4096;
-    auto sample = co_await ss.local().do_sample_sstables(t_id, chunk_size, n_chunks);
-    apilog.debug("retrain_dict: got sample with {} blocks", sample.size());
-    auto dict = co_await ss.local().train_dict(std::move(sample));
-    apilog.debug("retrain_dict: got dict of size {}", dict.size());
-    co_await ss.local().publish_new_sstable_dict(t_id, dict, group0_client);
-    apilog.debug("retrain_dict: published new dict");
-    co_return json_void();
-}
-
 static
 future<json::json_return_type>
 rest_sstable_info(http_context& ctx, std::unique_ptr<http::request> req) {
@@ -1429,23 +1509,21 @@ rest_sstable_info(http_context& ctx, std::unique_ptr<http::request> req) {
                             info.version = sstable->get_version();
 
                             if (sstable->has_component(sstables::component_type::CompressionInfo)) {
-                                const auto& cp = sstable->get_compression().get_compressor();
+                                auto& c = sstable->get_compression();
+                                auto cp = sstables::get_sstable_compressor(c);
 
                                 ss::named_maps nm;
                                 nm.group = "compression_parameters";
-                                for (auto& p : cp.options()) {
-                                    if (compressor::is_hidden_option_name(p.first)) {
-                                        continue;
-                                    }
+                                for (auto& p : cp->options()) {
                                     ss::mapper e;
                                     e.key = p.first;
                                     e.value = p.second;
                                     nm.attributes.push(std::move(e));
                                 }
-                                if (!cp.options().contains(compression_parameters::SSTABLE_COMPRESSION)) {
+                                if (!cp->options().contains(compression_parameters::SSTABLE_COMPRESSION)) {
                                     ss::mapper e;
                                     e.key = compression_parameters::SSTABLE_COMPRESSION;
-                                    e.value = sstring(cp.name());
+                                    e.value = cp->name();
                                     nm.attributes.push(std::move(e));
                                 }
                                 info.extended_properties.push(std::move(nm));
@@ -1532,18 +1610,6 @@ rest_raft_topology_upgrade_status(sharded<service::storage_service>& ss, std::un
         co_return sstring(format("{}", ustate));
 }
 
-static
-future<json::json_return_type>
-rest_raft_topology_get_cmd_status(sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
-        const auto status = co_await ss.invoke_on(0, [] (auto& ss) {
-            return ss.get_topology_cmd_status();
-        });
-        if (status.active_dst.empty()) {
-            co_return sstring("none");
-        }
-        co_return sstring(fmt::format("{}[{}]: {}", status.current, status.index, fmt::join(status.active_dst, ",")));
-}
-
 static
 future<json::json_return_type>
 rest_move_tablet(http_context& ctx, sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
@@ -1574,7 +1640,7 @@ rest_add_tablet_replica(http_context& ctx, sharded<service::storage_service>& ss
         auto token = dht::token::from_int64(validate_int(req->get_query_param("token")));
         auto ks = req->get_query_param("ks");
         auto table = req->get_query_param("table");
-        auto table_id = validate_table(ctx.db.local(), ks, table);
+        auto table_id = ctx.db.local().find_column_family(ks, table).schema()->id();
         auto force_str = req->get_query_param("force");
         auto force = service::loosen_constraints(force_str == "" ? false : validate_bool(force_str));
 
@@ -1593,7 +1659,7 @@ rest_del_tablet_replica(http_context& ctx, sharded<service::storage_service>& ss
         auto token = dht::token::from_int64(validate_int(req->get_query_param("token")));
         auto ks = req->get_query_param("ks");
         auto table = req->get_query_param("table");
-        auto table_id = validate_table(ctx.db.local(), ks, table);
+        auto table_id = ctx.db.local().find_column_family(ks, table).schema()->id();
         auto force_str = req->get_query_param("force");
         auto force = service::loosen_constraints(force_str == "" ? false : validate_bool(force_str));
 
@@ -1624,10 +1690,6 @@ rest_repair_tablet(http_context& ctx, sharded<service::storage_service>& ss, std
         if (!await.empty()) {
             await_completion = validate_bool(await);
         }
-
-        // Use regular mode if the incremental_mode option is not provided by user.
-        auto incremental = req->get_query_param("incremental_mode");
-        auto incremental_mode = incremental.empty() ? locator::default_tablet_repair_incremental_mode : locator::tablet_repair_incremental_mode_from_string(incremental);
         auto table_id = validate_table(ctx.db.local(), ks, table);
         std::variant<utils::chunked_vector<dht::token>, service::storage_service::all_tokens_tag> tokens_variant;
         if (all_tokens) {
@@ -1650,12 +1712,8 @@ rest_repair_tablet(http_context& ctx, sharded<service::storage_service>& ss, std
             }) | std::ranges::to<std::unordered_set>();
         }
         auto dcs_filter = locator::tablet_task_info::deserialize_repair_dcs_filter(dcs);
-        try {
-            auto res = co_await ss.local().add_repair_tablet_request(table_id, tokens_variant, hosts_filter, dcs_filter, await_completion, incremental_mode);
-            co_return json::json_return_type(res);
-        } catch (std::invalid_argument& e) {
-            throw httpd::bad_param_exception(e.what());
-        }
+        auto res = co_await ss.local().add_repair_tablet_request(table_id, tokens_variant, hosts_filter, dcs_filter, await_completion);
+        co_return json::json_return_type(res);
 }
 
 static
@@ -1678,7 +1736,6 @@ future<json::json_return_type>
 rest_get_schema_versions(sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
         return ss.local().describe_schema_versions().then([] (auto result) {
             std::vector<sp::mapper_list> res;
-            res.reserve(result.size());
             for (auto e : result) {
                 sp::mapper_list entry;
                 entry.key = std::move(e.first);
@@ -1689,35 +1746,6 @@ rest_get_schema_versions(sharded<service::storage_service>& ss, std::unique_ptr<
         });
 }
 
-static
-future<json::json_return_type>
-rest_drop_quarantined_sstables(http_context& ctx, sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
-    auto keyspace = req->get_query_param("keyspace");
-    try {
-        if (!keyspace.empty()) {
-            keyspace = validate_keyspace(ctx, keyspace);
-            auto table_infos = parse_table_infos(keyspace, ctx, req->get_query_param("tables"));
-
-            co_await ctx.db.invoke_on_all([&table_infos](replica::database& db) -> future<> {
-                return parallel_for_each(table_infos, [&db](const auto& table) -> future<> {
-                    const auto& [table_name, table_id] = table;
-                    return db.find_column_family(table_id).drop_quarantined_sstables();
-                });
-            });
-        } else {
-            co_await ctx.db.invoke_on_all([](replica::database& db) -> future<> {
-                return db.get_tables_metadata().parallel_for_each_table([](table_id, lw_shared_ptr<replica::table> t) -> future<> {
-                    return t->drop_quarantined_sstables();
-                });
-            });
-        }
-    } catch (...) {
-        apilog.error("drop_quarantined_sstables: failed with exception: {}", std::current_exception());
-        throw;
-    }
-
-    co_return json_void();
-}
 
 // Disambiguate between a function that returns a future and a function that returns a plain value, also
 // add std::ref() as a courtesy. Also handles ks_cf_func signatures.
@@ -1739,6 +1767,12 @@ rest_bind(FuncType func, BindArgs&... args) {
     return std::bind_front(func, std::ref(args)...);
 }
 
+static
+seastar::httpd::future_json_function
+rest_bind(ks_cf_func func, http_context& ctx) {
+    return wrap_ks_cf(ctx, func);
+}
+
 void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_service>& ss, service::raft_group0_client& group0_client) {
     ss::get_token_endpoint.set(r, rest_bind(rest_get_token_endpoint, ctx, ss));
     ss::toppartitions_generic.set(r, rest_bind(rest_toppartitions_generic, ctx));
@@ -1748,11 +1782,16 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
     ss::get_range_to_endpoint_map.set(r, rest_bind(rest_get_range_to_endpoint_map, ctx, ss));
     ss::get_pending_range_to_endpoint_map.set(r, rest_bind(rest_get_pending_range_to_endpoint_map, ctx));
     ss::describe_ring.set(r, rest_bind(rest_describe_ring, ctx, ss));
+    ss::get_load.set(r, rest_bind(rest_get_load, ctx));
     ss::get_current_generation_number.set(r, rest_bind(rest_get_current_generation_number, ss));
     ss::get_natural_endpoints.set(r, rest_bind(rest_get_natural_endpoints, ctx, ss));
     ss::cdc_streams_check_and_repair.set(r, rest_bind(rest_cdc_streams_check_and_repair, ss));
+    ss::force_compaction.set(r, rest_bind(rest_force_compaction, ctx));
+    ss::force_keyspace_compaction.set(r, rest_bind(rest_force_keyspace_compaction, ctx));
+    ss::force_keyspace_cleanup.set(r, rest_bind(rest_force_keyspace_cleanup, ctx, ss));
     ss::cleanup_all.set(r, rest_bind(rest_cleanup_all, ctx, ss));
-    ss::reset_cleanup_needed.set(r, rest_bind(rest_reset_cleanup_needed, ctx, ss));
+    ss::perform_keyspace_offstrategy_compaction.set(r, rest_bind(rest_perform_keyspace_offstrategy_compaction, ctx));
+    ss::upgrade_sstables.set(r, rest_bind(rest_upgrade_sstables, ctx));
     ss::force_flush.set(r, rest_bind(rest_force_flush, ctx));
     ss::force_keyspace_flush.set(r, rest_bind(rest_force_keyspace_flush, ctx));
     ss::decommission.set(r, rest_bind(rest_decommission, ss));
@@ -1764,8 +1803,9 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
     ss::get_logging_levels.set(r, rest_bind(rest_get_logging_levels));
     ss::get_operation_mode.set(r, rest_bind(rest_get_operation_mode, ss));
     ss::is_starting.set(r, rest_bind(rest_is_starting, ss));
-    ss::get_drain_progress.set(r, rest_bind(rest_get_drain_progress, ss));
+    ss::get_drain_progress.set(r, rest_bind(rest_get_drain_progress, ctx));
     ss::drain.set(r, rest_bind(rest_drain, ss));
+    ss::get_keyspaces.set(r, rest_bind(rest_get_keyspaces, ctx));
     ss::stop_gossiping.set(r, rest_bind(rest_stop_gossiping, ss));
     ss::start_gossiping.set(r, rest_bind(rest_start_gossiping, ss));
     ss::is_gossip_running.set(r, rest_bind(rest_is_gossip_running, ss));
@@ -1795,18 +1835,16 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
     ss::get_batch_size_failure_threshold.set(r, rest_bind(rest_get_batch_size_failure_threshold));
     ss::set_batch_size_failure_threshold.set(r, rest_bind(rest_set_batch_size_failure_threshold));
     ss::set_hinted_handoff_throttle_in_kb.set(r, rest_bind(rest_set_hinted_handoff_throttle_in_kb));
+    ss::get_metrics_load.set(r, rest_bind(rest_get_metrics_load, ctx));
     ss::get_exceptions.set(r, rest_bind(rest_get_exceptions, ss));
     ss::get_total_hints_in_progress.set(r, rest_bind(rest_get_total_hints_in_progress));
     ss::get_total_hints.set(r, rest_bind(rest_get_total_hints));
     ss::get_ownership.set(r, rest_bind(rest_get_ownership, ctx, ss));
     ss::get_effective_ownership.set(r, rest_bind(rest_get_effective_ownership, ctx, ss));
-    ss::retrain_dict.set(r, rest_bind(rest_retrain_dict, ctx, ss, group0_client));
-    ss::estimate_compression_ratios.set(r, rest_bind(rest_estimate_compression_ratios, ctx, ss));
     ss::sstable_info.set(r, rest_bind(rest_sstable_info, ctx));
     ss::reload_raft_topology_state.set(r, rest_bind(rest_reload_raft_topology_state, ss, group0_client));
     ss::upgrade_to_raft_topology.set(r, rest_bind(rest_upgrade_to_raft_topology, ss));
     ss::raft_topology_upgrade_status.set(r, rest_bind(rest_raft_topology_upgrade_status, ss));
-    ss::raft_topology_get_cmd_status.set(r, rest_bind(rest_raft_topology_get_cmd_status, ss));
     ss::move_tablet.set(r, rest_bind(rest_move_tablet, ctx, ss));
     ss::add_tablet_replica.set(r, rest_bind(rest_add_tablet_replica, ctx, ss));
     ss::del_tablet_replica.set(r, rest_bind(rest_del_tablet_replica, ctx, ss));
@@ -1814,7 +1852,6 @@ void set_storage_service(http_context& ctx, routes& r, sharded<service::storage_
     ss::tablet_balancing_enable.set(r, rest_bind(rest_tablet_balancing_enable, ss));
     ss::quiesce_topology.set(r, rest_bind(rest_quiesce_topology, ss));
     sp::get_schema_versions.set(r, rest_bind(rest_get_schema_versions, ss));
-    ss::drop_quarantined_sstables.set(r, rest_bind(rest_drop_quarantined_sstables, ctx, ss));
 }
 
 void unset_storage_service(http_context& ctx, routes& r) {
@@ -1826,11 +1863,16 @@ void unset_storage_service(http_context& ctx, routes& r) {
     ss::get_range_to_endpoint_map.unset(r);
     ss::get_pending_range_to_endpoint_map.unset(r);
     ss::describe_ring.unset(r);
+    ss::get_load.unset(r);
     ss::get_current_generation_number.unset(r);
     ss::get_natural_endpoints.unset(r);
     ss::cdc_streams_check_and_repair.unset(r);
+    ss::force_compaction.unset(r);
+    ss::force_keyspace_compaction.unset(r);
+    ss::force_keyspace_cleanup.unset(r);
     ss::cleanup_all.unset(r);
-    ss::reset_cleanup_needed.unset(r);
+    ss::perform_keyspace_offstrategy_compaction.unset(r);
+    ss::upgrade_sstables.unset(r);
     ss::force_flush.unset(r);
     ss::force_keyspace_flush.unset(r);
     ss::decommission.unset(r);
@@ -1844,6 +1886,7 @@ void unset_storage_service(http_context& ctx, routes& r) {
     ss::is_starting.unset(r);
     ss::get_drain_progress.unset(r);
     ss::drain.unset(r);
+    ss::get_keyspaces.unset(r);
     ss::stop_gossiping.unset(r);
     ss::start_gossiping.unset(r);
     ss::is_gossip_running.unset(r);
@@ -1873,6 +1916,7 @@ void unset_storage_service(http_context& ctx, routes& r) {
     ss::get_batch_size_failure_threshold.unset(r);
     ss::set_batch_size_failure_threshold.unset(r);
     ss::set_hinted_handoff_throttle_in_kb.unset(r);
+    ss::get_metrics_load.unset(r);
     ss::get_exceptions.unset(r);
     ss::get_total_hints_in_progress.unset(r);
     ss::get_total_hints.unset(r);
@@ -1882,7 +1926,6 @@ void unset_storage_service(http_context& ctx, routes& r) {
     ss::reload_raft_topology_state.unset(r);
     ss::upgrade_to_raft_topology.unset(r);
     ss::raft_topology_upgrade_status.unset(r);
-    ss::raft_topology_get_cmd_status.unset(r);
     ss::move_tablet.unset(r);
     ss::add_tablet_replica.unset(r);
     ss::del_tablet_replica.unset(r);
@@ -1890,7 +1933,6 @@ void unset_storage_service(http_context& ctx, routes& r) {
     ss::tablet_balancing_enable.unset(r);
     ss::quiesce_topology.unset(r);
     sp::get_schema_versions.unset(r);
-    ss::drop_quarantined_sstables.unset(r);
 }
 
 void set_load_meter(http_context& ctx, routes& r, service::load_meter& lm) {
@@ -1914,7 +1956,7 @@ void unset_load_meter(http_context& ctx, routes& r) {
 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) -> future<json::json_return_type> {
         auto result = co_await snap_ctl.local().get_snapshot_details();
-        co_return noncopyable_function<future<> (output_stream<char>&&)>([res = std::move(result)] (output_stream<char>&& o) -> future<> {
+        co_return std::function([res = std::move(result)] (output_stream<char>&& o) -> future<> {
             std::exception_ptr ex;
             output_stream<char> out = std::move(o);
             try {
@@ -1954,7 +1996,7 @@ void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_
     });
 
     ss::take_snapshot.set(r, [&snap_ctl](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
-        apilog.info("take_snapshot: {}", req->get_query_params());
+        apilog.info("take_snapshot: {}", req->query_parameters);
         auto tag = req->get_query_param("tag");
         auto column_families = split(req->get_query_param("cf"), ",");
         auto sfopt = req->get_query_param("sf");
@@ -1981,7 +2023,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> {
-        apilog.info("del_snapshot: {}", req->get_query_params());
+        apilog.info("del_snapshot: {}", req->query_parameters);
         auto tag = req->get_query_param("tag");
         auto column_family = req->get_query_param("cf");
 
@@ -2003,21 +2045,17 @@ void set_snapshot(http_context& ctx, routes& r, sharded<db::snapshot_ctl>& snap_
 
     ss::scrub.set(r, [&ctx, &snap_ctl] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
         auto& db = ctx.db;
-        auto info = parse_scrub_options(ctx, std::move(req));
+        auto info = co_await parse_scrub_options(ctx, snap_ctl, std::move(req));
 
-        if (!info.snapshot_tag.empty()) {
-            co_await snap_ctl.local().take_column_family_snapshot(info.keyspace, info.column_families, info.snapshot_tag, db::snapshot_ctl::skip_flush::no);
-        }
-
-        compaction::compaction_stats stats;
+        sstables::compaction_stats stats;
         auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
-        auto task = co_await compaction_module.make_and_start_task<compaction::scrub_sstables_compaction_task_impl>({}, info.keyspace, db, info.column_families, info.opts, &stats);
+        auto task = co_await compaction_module.make_and_start_task<scrub_sstables_compaction_task_impl>({}, info.keyspace, db, info.column_families, info.opts, &stats);
         try {
             co_await task->done();
             if (stats.validation_errors) {
                 co_return json::json_return_type(static_cast<int>(scrub_status::validation_errors));
             }
-        } catch (const compaction::compaction_aborted_exception&) {
+        } catch (const sstables::compaction_aborted_exception&) {
             co_return json::json_return_type(static_cast<int>(scrub_status::aborted));
         } catch (...) {
             apilog.error("scrub keyspace={} tables={} failed: {}", info.keyspace, info.column_families, std::current_exception());

api/storage_service.hh

@@ -52,19 +52,17 @@ table_id validate_table(const replica::database& db, sstring ks_name, sstring ta
 // containing the description of the respective no_such_column_family error.
 // Returns a vector of all table infos given by the parameter, or
 // 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, const http_context& ctx, const std::unordered_map<sstring, sstring>& query_params, sstring param_name);
 
 std::vector<table_info> parse_table_infos(const sstring& ks_name, const http_context& ctx, sstring value);
 
-std::pair<sstring, std::vector<table_info>> parse_table_infos(const http_context& ctx, const http::request& req, sstring cf_param_name = "cf");
-
 struct scrub_info {
-    compaction::compaction_type_options::scrub opts;
+    sstables::compaction_type_options::scrub opts;
     sstring keyspace;
     std::vector<sstring> column_families;
-    sstring snapshot_tag;
 };
 
-scrub_info parse_scrub_options(const http_context& ctx, std::unique_ptr<http::request> req);
+future<scrub_info> parse_scrub_options(const http_context& ctx, sharded<db::snapshot_ctl>& snap_ctl, std::unique_ptr<http::request> req);
 
 void set_storage_service(http_context& ctx, httpd::routes& r, sharded<service::storage_service>& ss, service::raft_group0_client&);
 void unset_storage_service(http_context& ctx, httpd::routes& r);
@@ -82,13 +80,6 @@ void set_snapshot(http_context& ctx, httpd::routes& r, sharded<db::snapshot_ctl>
 void unset_snapshot(http_context& ctx, httpd::routes& r);
 void set_load_meter(http_context& ctx, httpd::routes& r, service::load_meter& lm);
 void unset_load_meter(http_context& ctx, httpd::routes& r);
-seastar::future<json::json_return_type> run_toppartitions_query(db::toppartitions_query& q, bool legacy_request = false);
-
-// converts string value of boolean parameter into bool
-// maps (case insensitively)
-//     "true", "yes" and "1" into true
-//     "false", "no" and "0" into false
-// otherwise throws runtime_error
-bool validate_bool_x(const sstring& param, bool default_value);
+seastar::future<json::json_return_type> run_toppartitions_query(db::toppartitions_query& q, http_context &ctx, bool legacy_request = false);
 
 } // namespace api

api/system.cc

@@ -10,7 +10,7 @@
 #include "api/api-doc/system.json.hh"
 #include "api/api-doc/metrics.json.hh"
 #include "replica/database.hh"
-#include "sstables/sstables_manager.hh"
+#include "db/sstables-format-selector.hh"
 
 #include <rapidjson/document.h>
 #include <boost/lexical_cast.hpp>
@@ -184,13 +184,18 @@ void set_system(http_context& ctx, routes& r) {
         apilog.info("Profile dumped to {}", profile_dest);
         return make_ready_future<json::json_return_type>(json::json_return_type(json::json_void()));
     }) ;
+}
 
-    hs::get_highest_supported_sstable_version.set(r, [&ctx] (std::unique_ptr<request> req) {
-        return smp::submit_to(0, [&ctx] {
-            auto format = ctx.db.local().get_user_sstables_manager().get_highest_supported_format();
-            return make_ready_future<json::json_return_type>(seastar::to_sstring(format));
+void set_format_selector(http_context& ctx, routes& r, db::sstables_format_selector& sel) {
+    hs::get_highest_supported_sstable_version.set(r, [&sel] (std::unique_ptr<request> req) {
+        return smp::submit_to(0, [&sel] {
+            return make_ready_future<json::json_return_type>(seastar::to_sstring(sel.selected_format()));
         });
     });
 }
 
+void unset_format_selector(http_context& ctx, routes& r) {
+    hs::get_highest_supported_sstable_version.unset(r);
+}
+
 }

api/system.hh

@@ -12,9 +12,14 @@ namespace seastar::httpd {
 class routes;
 }
 
+namespace db { class sstables_format_selector; }
+
 namespace api {
 
 struct http_context;
 void set_system(http_context& ctx, seastar::httpd::routes& r);
 
+void set_format_selector(http_context& ctx, seastar::httpd::routes& r, db::sstables_format_selector& sel);
+void unset_format_selector(http_context& ctx, seastar::httpd::routes& r);
+
 }

api/task_manager.cc

@@ -6,7 +6,6 @@
  * SPDX-License-Identifier: LicenseRef-ScyllaDB-Source-Available-1.0
  */
 
-#include <seastar/core/chunked_fifo.hh>
 #include <seastar/core/coroutine.hh>
 #include <seastar/coroutine/exception.hh>
 #include <seastar/http/exception.hh>
@@ -35,9 +34,8 @@ static ::tm get_time(db_clock::time_point tp) {
 }
 
 tm::task_status make_status(tasks::task_status status, sharded<gms::gossiper>& gossiper) {
-    chunked_fifo<tm::task_identity> tis;
-    tis.reserve(status.children.size());
-    for (const auto& child : status.children) {
+    std::vector<tm::task_identity> tis{status.children.size()};
+    std::ranges::transform(status.children, tis.begin(), [&gossiper] (const auto& child) {
         tm::task_identity ident;
         gms::inet_address addr{};
         if (gossiper.local_is_initialized()) {
@@ -45,8 +43,8 @@ tm::task_status make_status(tasks::task_status status, sharded<gms::gossiper>& g
         }
         ident.task_id = child.task_id.to_sstring();
         ident.node = fmt::format("{}", addr);
-        tis.push_back(std::move(ident));
-    }
+        return ident;
+    });
 
     tm::task_status res{};
     res.id = status.task_id.to_sstring();
@@ -107,11 +105,11 @@ void set_task_manager(http_context& ctx, routes& r, sharded<tasks::task_manager>
                 throw bad_param_exception(fmt::format("{}", std::current_exception()));
             }
 
-            if (auto param = req->get_query_param("keyspace"); !param.empty()) {
-                keyspace = param;
+            if (auto it = req->query_parameters.find("keyspace"); it != req->query_parameters.end()) {
+                keyspace = it->second;
             }
-            if (auto param = req->get_query_param("table"); !param.empty()) {
-                table = param;
+            if (auto it = req->query_parameters.find("table"); it != req->query_parameters.end()) {
+                table = it->second;
             }
 
             return module->get_stats(internal, [keyspace = std::move(keyspace), table = std::move(table)] (std::string& ks, std::string& t) {
@@ -119,7 +117,7 @@ void set_task_manager(http_context& ctx, routes& r, sharded<tasks::task_manager>
             });
         });
 
-        noncopyable_function<future<>(output_stream<char>&&)> f = [r = std::move(res)] (output_stream<char>&& os) -> future<> {
+        std::function<future<>(output_stream<char>&&)> f = [r = std::move(res)] (output_stream<char>&& os) -> future<> {
             auto s = std::move(os);
             std::exception_ptr ex;
             try {
@@ -175,8 +173,8 @@ void set_task_manager(http_context& ctx, routes& r, sharded<tasks::task_manager>
         auto id = tasks::task_id{utils::UUID{req->get_path_param("task_id")}};
         tasks::task_status status;
         std::optional<std::chrono::seconds> timeout = std::nullopt;
-        if (auto param = req->get_query_param("timeout"); !param.empty()) {
-            timeout = std::chrono::seconds(boost::lexical_cast<uint32_t>(param));
+        if (auto it = req->query_parameters.find("timeout"); it != req->query_parameters.end()) {
+            timeout = std::chrono::seconds(boost::lexical_cast<uint32_t>(it->second));
         }
         try {
             auto task = tasks::task_handler{tm.local(), id};
@@ -196,7 +194,7 @@ void set_task_manager(http_context& ctx, routes& r, sharded<tasks::task_manager>
             auto task = tasks::task_handler{tm.local(), id};
             auto res = co_await task.get_status_recursively(true);
 
-            noncopyable_function<future<>(output_stream<char>&&)> f = [r = std::move(res), &gossiper] (output_stream<char>&& os) -> future<> {
+            std::function<future<>(output_stream<char>&&)> f = [r = std::move(res), &gossiper] (output_stream<char>&& os) -> future<> {
                 auto s = std::move(os);
                 auto res = std::move(r);
                 co_await s.write("[");
@@ -217,7 +215,7 @@ void set_task_manager(http_context& ctx, routes& r, sharded<tasks::task_manager>
     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();
         try {
-            co_await cfg.task_ttl_seconds.set_value_on_all_shards(req->get_query_param("ttl"), utils::config_file::config_source::API);
+            co_await cfg.task_ttl_seconds.set_value_on_all_shards(req->query_parameters["ttl"], utils::config_file::config_source::API);
         } catch (...) {
             throw bad_param_exception(fmt::format("{}", std::current_exception()));
         }
@@ -232,7 +230,7 @@ void set_task_manager(http_context& ctx, routes& r, sharded<tasks::task_manager>
     tm::get_and_update_user_ttl.set(r, [&cfg] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
         uint32_t user_ttl = cfg.user_task_ttl_seconds();
         try {
-            co_await cfg.user_task_ttl_seconds.set_value_on_all_shards(req->get_query_param("user_ttl"), utils::config_file::config_source::API);
+            co_await cfg.user_task_ttl_seconds.set_value_on_all_shards(req->query_parameters["user_ttl"], utils::config_file::config_source::API);
         } catch (...) {
             throw bad_param_exception(fmt::format("{}", std::current_exception()));
         }

api/task_manager_test.cc

@@ -57,16 +57,20 @@ void set_task_manager_test(http_context& ctx, routes& r, sharded<tasks::task_man
 
     tmt::register_test_task.set(r, [&tm] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
         sharded<tasks::task_manager>& tms = tm;
-        const auto id_param = req->get_query_param("task_id");
-        auto id = !id_param.empty() ? tasks::task_id{utils::UUID{id_param}} : tasks::task_id::create_null_id();
-        const auto shard_param = req->get_query_param("shard");
-        unsigned shard = shard_param.empty() ? 0 : boost::lexical_cast<unsigned>(shard_param);
-        std::string keyspace = req->get_query_param("keyspace");
-        std::string table = req->get_query_param("table");
-        std::string entity = req->get_query_param("entity");
+        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();
+        it = req->query_parameters.find("shard");
+        unsigned shard = it != req->query_parameters.end() ? boost::lexical_cast<unsigned>(it->second) : 0;
+        it = req->query_parameters.find("keyspace");
+        std::string keyspace = it != req->query_parameters.end() ? it->second : "";
+        it = req->query_parameters.find("table");
+        std::string table = it != req->query_parameters.end() ? it->second : "";
+        it = req->query_parameters.find("entity");
+        std::string entity = it != req->query_parameters.end() ? it->second : "";
+        it = req->query_parameters.find("parent_id");
         tasks::task_info data;
-        if (auto parent_id = req->get_query_param("parent_id"); !parent_id.empty()) {
-            data.id = tasks::task_id{utils::UUID{parent_id}};
+        if (it != req->query_parameters.end()) {
+            data.id = tasks::task_id{utils::UUID{it->second}};
             auto parent_ptr = co_await tasks::task_manager::lookup_task_on_all_shards(tm, data.id);
             data.shard = parent_ptr->get_status().shard;
         }
@@ -84,7 +88,7 @@ void set_task_manager_test(http_context& ctx, routes& r, sharded<tasks::task_man
     });
 
     tmt::unregister_test_task.set(r, [&tm] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
-        auto id = tasks::task_id{utils::UUID{req->get_query_param("task_id")}};
+        auto id = tasks::task_id{utils::UUID{req->query_parameters["task_id"]}};
         try {
             co_await tasks::task_manager::invoke_on_task(tm, id, [] (tasks::task_manager::task_variant task_v, tasks::virtual_task_hint) -> future<> {
                 return std::visit(overloaded_functor{
@@ -105,8 +109,9 @@ void set_task_manager_test(http_context& ctx, routes& r, sharded<tasks::task_man
 
     tmt::finish_test_task.set(r, [&tm] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
         auto id = tasks::task_id{utils::UUID{req->get_path_param("task_id")}};
-        std::string error = req->get_query_param("error");
-        bool fail = !error.empty();
+        auto it = req->query_parameters.find("error");
+        bool fail = it != req->query_parameters.end();
+        std::string error = fail ? it->second : "";
 
         try {
             co_await tasks::task_manager::invoke_on_task(tm, id, [fail, error = std::move(error)] (tasks::task_manager::task_variant task_v, tasks::virtual_task_hint) -> future<> {

api/tasks.cc

@@ -12,7 +12,6 @@
 #include "api/api.hh"
 #include "api/storage_service.hh"
 #include "api/api-doc/tasks.json.hh"
-#include "api/api-doc/storage_service.json.hh"
 #include "compaction/compaction_manager.hh"
 #include "compaction/task_manager_module.hh"
 #include "service/storage_service.hh"
@@ -26,163 +25,96 @@ extern logging::logger apilog;
 namespace api {
 
 namespace t = httpd::tasks_json;
-namespace ss = httpd::storage_service_json;
 using namespace json;
 
 using ks_cf_func = std::function<future<json::json_return_type>(http_context&, std::unique_ptr<http::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) {
-        auto [keyspace, table_infos] = parse_table_infos(ctx, *req);
+        auto keyspace = validate_keyspace(ctx, req);
+        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));
     };
 }
 
-static future<shared_ptr<compaction::major_keyspace_compaction_task_impl>> force_keyspace_compaction(http_context& ctx, std::unique_ptr<http::request> req) {
-    auto& db = ctx.db;
-    auto [ keyspace, table_infos ] = parse_table_infos(ctx, *req, "cf");
-    auto flush = validate_bool_x(req->get_query_param("flush_memtables"), true);
-    auto consider_only_existing_data = validate_bool_x(req->get_query_param("consider_only_existing_data"), false);
-    apilog.info("force_keyspace_compaction: keyspace={} tables={}, flush={} consider_only_existing_data={}", keyspace, table_infos, flush, consider_only_existing_data);
-
-    auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
-    std::optional<compaction::flush_mode> fmopt;
-    if (!flush && !consider_only_existing_data) {
-        fmopt = compaction::flush_mode::skip;
-    }
-    return compaction_module.make_and_start_task<compaction::major_keyspace_compaction_task_impl>({}, std::move(keyspace), tasks::task_id::create_null_id(), db, table_infos, fmopt, consider_only_existing_data);
-}
-
-static future<shared_ptr<compaction::upgrade_sstables_compaction_task_impl>> upgrade_sstables(http_context& ctx, std::unique_ptr<http::request> req, sstring keyspace, std::vector<table_info> table_infos) {
-    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();
-    return compaction_module.make_and_start_task<compaction::upgrade_sstables_compaction_task_impl>({}, std::move(keyspace), db, table_infos, exclude_current_version);
-}
-
-static future<shared_ptr<compaction::cleanup_keyspace_compaction_task_impl>> force_keyspace_cleanup(http_context& ctx, sharded<service::storage_service>& ss, std::unique_ptr<http::request> req) {
-    auto& db = ctx.db;
-    auto [keyspace, table_infos] = parse_table_infos(ctx, *req);
-    const auto& rs = db.local().find_keyspace(keyspace).get_replication_strategy();
-    if (rs.is_local() || !rs.is_vnode_based()) {
-        auto reason = rs.is_local() ? "require" : "support";
-        apilog.info("Keyspace {} does not {} cleanup", keyspace, reason);
-        co_return nullptr;
-    }
-    apilog.info("force_keyspace_cleanup: keyspace={} tables={}", keyspace, table_infos);
-    if (!co_await ss.local().is_cleanup_allowed(keyspace)) {
-        auto msg = "Can not perform cleanup operation when topology changes";
-        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();
-    co_return co_await compaction_module.make_and_start_task<compaction::cleanup_keyspace_compaction_task_impl>(
-        {}, std::move(keyspace), db, table_infos, compaction::flush_mode::all_tables, tasks::is_user_task::yes);
-}
-
 void set_tasks_compaction_module(http_context& ctx, routes& r, sharded<service::storage_service>& ss, sharded<db::snapshot_ctl>& snap_ctl) {
     t::force_keyspace_compaction_async.set(r, [&ctx](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
-        auto task = co_await force_keyspace_compaction(ctx, std::move(req));
+        auto& db = ctx.db;
+        auto params = req_params({
+            std::pair("keyspace", mandatory::yes),
+            std::pair("cf", mandatory::no),
+            std::pair("flush_memtables", mandatory::no),
+        });
+        params.process(*req);
+        auto keyspace = validate_keyspace(ctx, *params.get("keyspace"));
+        auto table_infos = parse_table_infos(keyspace, ctx, params.get("cf").value_or(""));
+        auto flush = params.get_as<bool>("flush_memtables").value_or(true);
+        apilog.debug("force_keyspace_compaction_async: keyspace={} tables={}, flush={}", keyspace, table_infos, flush);
+
+        auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
+        std::optional<flush_mode> fmopt;
+        if (!flush) {
+            fmopt = flush_mode::skip;
+        }
+        auto task = co_await compaction_module.make_and_start_task<major_keyspace_compaction_task_impl>({}, std::move(keyspace), tasks::task_id::create_null_id(), db, table_infos, fmopt);
+
         co_return json::json_return_type(task->get_status().id.to_sstring());
     });
 
-    ss::force_keyspace_compaction.set(r, [&ctx](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
-        auto task = co_await force_keyspace_compaction(ctx, std::move(req));
-        co_await task->done();
-        co_return json_void();
-    });
-
     t::force_keyspace_cleanup_async.set(r, [&ctx, &ss](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
-        tasks::task_id id = tasks::task_id::create_null_id();
-        auto task = co_await force_keyspace_cleanup(ctx, ss, std::move(req));
-        if (task) {
-            id = task->get_status().id;
+        auto& db = ctx.db;
+        auto keyspace = validate_keyspace(ctx, req);
+        auto table_infos = parse_table_infos(keyspace, ctx, req->query_parameters, "cf");
+        apilog.info("force_keyspace_cleanup_async: keyspace={} tables={}", keyspace, table_infos);
+        if (!co_await ss.local().is_cleanup_allowed(keyspace)) {
+            auto msg = "Can not perform cleanup operation when topology changes";
+            apilog.warn("force_keyspace_cleanup_async: keyspace={} tables={}: {}", keyspace, table_infos, msg);
+            co_await coroutine::return_exception(std::runtime_error(msg));
         }
-        co_return json::json_return_type(id.to_sstring());
-    });
 
-    ss::force_keyspace_cleanup.set(r, [&ctx, &ss](std::unique_ptr<http::request> req) -> future<json::json_return_type> {
-        auto task = co_await force_keyspace_cleanup(ctx, ss, std::move(req));
-        if (task) {
-            co_await task->done();
-        }
-        co_return json::json_return_type(0);
+        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, table_infos, flush_mode::all_tables, tasks::is_user_task::yes);
+
+        co_return json::json_return_type(task->get_status().id.to_sstring());
     });
 
     t::perform_keyspace_offstrategy_compaction_async.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> {
         apilog.info("perform_keyspace_offstrategy_compaction: keyspace={} tables={}", keyspace, table_infos);
         auto& compaction_module = ctx.db.local().get_compaction_manager().get_task_manager_module();
-        auto task = co_await compaction_module.make_and_start_task<compaction::offstrategy_keyspace_compaction_task_impl>({}, std::move(keyspace), ctx.db, table_infos, nullptr);
+        auto task = co_await compaction_module.make_and_start_task<offstrategy_keyspace_compaction_task_impl>({}, std::move(keyspace), ctx.db, table_infos, nullptr);
 
         co_return json::json_return_type(task->get_status().id.to_sstring());
     }));
 
-    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> {
-        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<compaction::offstrategy_keyspace_compaction_task_impl>({}, std::move(keyspace), ctx.db, table_infos, &res);
-        co_await task->done();
-        co_return json::json_return_type(res);
-    }));
-
     t::upgrade_sstables_async.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> {
-        auto task = co_await upgrade_sstables(ctx, std::move(req), std::move(keyspace), std::move(table_infos));
-        co_return json::json_return_type(task->get_status().id.to_sstring());
-    }));
+        auto& db = ctx.db;
+        bool exclude_current_version = req_param<bool>(*req, "exclude_current_version", false);
 
-    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> {
-        auto task = co_await upgrade_sstables(ctx, std::move(req), std::move(keyspace), std::move(table_infos));
-        co_await task->done();
-        co_return json::json_return_type(0);
+        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, table_infos, exclude_current_version);
+
+        co_return json::json_return_type(task->get_status().id.to_sstring());
     }));
 
     t::scrub_async.set(r, [&ctx, &snap_ctl] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
         auto& db = ctx.db;
-        auto info = parse_scrub_options(ctx, std::move(req));
-
-        if (!info.snapshot_tag.empty()) {
-            co_await snap_ctl.local().take_column_family_snapshot(info.keyspace, info.column_families, info.snapshot_tag, db::snapshot_ctl::skip_flush::no);
-        }
+        auto info = co_await parse_scrub_options(ctx, snap_ctl, std::move(req));
 
         auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
-        auto task = co_await compaction_module.make_and_start_task<compaction::scrub_sstables_compaction_task_impl>({}, std::move(info.keyspace), db, std::move(info.column_families), info.opts, nullptr);
+        auto task = co_await compaction_module.make_and_start_task<scrub_sstables_compaction_task_impl>({}, std::move(info.keyspace), db, std::move(info.column_families), info.opts, nullptr);
 
         co_return json::json_return_type(task->get_status().id.to_sstring());
     });
-
-    ss::force_compaction.set(r, [&ctx] (std::unique_ptr<http::request> req) -> future<json::json_return_type> {
-        auto& db = ctx.db;
-        auto flush = validate_bool_x(req->get_query_param("flush_memtables"), true);
-        auto consider_only_existing_data = validate_bool_x(req->get_query_param("consider_only_existing_data"), false);
-        apilog.info("force_compaction: flush={} consider_only_existing_data={}", flush, consider_only_existing_data);
-
-        auto& compaction_module = db.local().get_compaction_manager().get_task_manager_module();
-        std::optional<compaction::flush_mode> fmopt;
-        if (!flush && !consider_only_existing_data) {
-            fmopt = compaction::flush_mode::skip;
-        }
-        auto task = co_await compaction_module.make_and_start_task<compaction::global_major_compaction_task_impl>({}, db, fmopt, consider_only_existing_data);
-        co_await task->done();
-        co_return json_void();
-    });
 }
 
 void unset_tasks_compaction_module(http_context& ctx, httpd::routes& r) {
     t::force_keyspace_compaction_async.unset(r);
-    ss::force_keyspace_compaction.unset(r);
     t::force_keyspace_cleanup_async.unset(r);
-    ss::force_keyspace_cleanup.unset(r);
     t::perform_keyspace_offstrategy_compaction_async.unset(r);
-    ss::perform_keyspace_offstrategy_compaction.unset(r);
     t::upgrade_sstables_async.unset(r);
-    ss::upgrade_sstables.unset(r);
     t::scrub_async.unset(r);
-    ss::force_compaction.unset(r);
 }
 
 }

api/token_metadata.cc

@@ -54,12 +54,12 @@ void set_token_metadata(http_context& ctx, routes& r, sharded<locator::shared_to
         for (const auto host_id: leaving_host_ids) {
             eps.insert(g.local().get_address_map().get(host_id));
         }
-        return eps | std::views::transform([] (auto& i) { return fmt::to_string(i); }) | std::ranges::to<std::vector>();
+        return container_to_vec(eps);
     });
 
     ss::get_moving_nodes.set(r, [](const_req req) {
         std::unordered_set<sstring> addr;
-        return addr | std::ranges::to<std::vector>();
+        return container_to_vec(addr);
     });
 
     ss::get_joining_nodes.set(r, [&tm, &g](const_req req) {
@@ -70,21 +70,15 @@ void set_token_metadata(http_context& ctx, routes& r, sharded<locator::shared_to
         for (const auto& [token, host_id]: points) {
             eps.insert(g.local().get_address_map().get(host_id));
         }
-        return eps | std::views::transform([] (auto& i) { return fmt::to_string(i); }) | std::ranges::to<std::vector>();
+        return container_to_vec(eps);
     });
 
     ss::get_host_id_map.set(r, [&tm, &g](const_req req) {
-        if (!g.local().is_enabled()) {
-            throw std::runtime_error("The gossiper is not ready yet");
-        }
-        return tm.local().get()->get_host_ids()
-            | std::views::transform([&g] (locator::host_id id) {
-                ss::mapper m;
-                m.key = fmt::to_string(g.local().get_address_map().get(id));
-                m.value = fmt::to_string(id);
-                return m;
-            })
-            | std::ranges::to<std::vector<ss::mapper>>();
+        std::vector<ss::mapper> res;
+        auto map = tm.local().get()->get_host_ids() |
+            std::views::transform([&g] (locator::host_id id) { return std::make_pair(g.local().get_address_map().get(id), id); }) |
+            std::ranges::to<std::unordered_map>();
+        return map_to_key_value(std::move(map), res);
     });
 
     static auto host_or_broadcast = [&tm](const_req req) {

audit/audit.cc

@@ -209,11 +209,6 @@ future<> audit::log(const audit_info* audit_info, service::query_state& query_st
     static const sstring anonymous_username("anonymous");
     const sstring& username = client_state.user() ? client_state.user()->name.value_or(anonymous_username) : no_username;
     socket_address client_ip = client_state.get_client_address().addr();
-    if (logger.is_enabled(logging::log_level::debug)) {
-        logger.debug("Log written: node_ip {} category {} cl {} error {} keyspace {} query '{}' client_ip {} table {} username {}",
-            node_ip, audit_info->category_string(), cl, error, audit_info->keyspace(),
-            audit_info->query(), client_ip, audit_info->table(), username);
-    }
     return futurize_invoke(std::mem_fn(&storage_helper::write), _storage_helper_ptr, audit_info, node_ip, client_ip, cl, username, error)
         .handle_exception([audit_info, node_ip, client_ip, cl, username, error] (auto ep) {
             logger.error("Unexpected exception when writing log with: node_ip {} category {} cl {} error {} keyspace {} query '{}' client_ip {} table {} username {} exception {}",
@@ -224,10 +219,6 @@ future<> audit::log(const audit_info* audit_info, service::query_state& query_st
 
 future<> audit::log_login(const sstring& username, socket_address client_ip, bool error) noexcept {
     socket_address node_ip = _token_metadata.get()->get_topology().my_address().addr();
-    if (logger.is_enabled(logging::log_level::debug)) {
-        logger.debug("Login log written: node_ip {}, client_ip {}, username {}, error {}",
-            node_ip, client_ip, username, error ? "true" : "false");
-    }
     return futurize_invoke(std::mem_fn(&storage_helper::write_login), _storage_helper_ptr, username, node_ip, client_ip, error)
         .handle_exception([username, node_ip, client_ip, error] (auto ep) {
             logger.error("Unexpected exception when writing login log with: node_ip {} client_ip {} username {} error {} exception {}",

audit/audit_syslog_storage_helper.cc

@@ -33,6 +33,20 @@ namespace audit {
 
 namespace {
 
+future<> syslog_send_helper(net::datagram_channel& sender,
+                            const socket_address& address,
+                            const sstring& msg) {
+    return sender.send(address, net::packet{msg.data(), msg.size()}).handle_exception([address](auto&& exception_ptr) {
+        auto error_msg = seastar::format(
+            "Syslog audit backend failed (sending a message to {} resulted in {}).",
+            address,
+            exception_ptr
+        );
+        logger.error("{}", error_msg);
+        throw audit_exception(std::move(error_msg));
+    });
+}
+
 static auto syslog_address_helper(const db::config& cfg)
 {
     return cfg.audit_unix_socket_path.is_set()
@@ -40,40 +54,11 @@ static auto syslog_address_helper(const db::config& cfg)
         : unix_domain_addr(_PATH_LOG);
 }
 
-static std::string json_escape(std::string_view str) {
-    std::string result;
-    result.reserve(str.size() * 1.2);
-    for (auto c : str) {
-        if (c == '"' || c == '\\') {
-            result.push_back('\\');
-        }
-        result.push_back(c);
-    }
-    return result;
-}
-
-}
-
-future<> audit_syslog_storage_helper::syslog_send_helper(const sstring& msg) {
-    try {
-        auto lock = co_await get_units(_semaphore, 1, std::chrono::hours(1));
-        co_await _sender.send(_syslog_address, net::packet{msg.data(), msg.size()});
-    }
-    catch (const std::exception& e) {
-        auto error_msg = seastar::format(
-            "Syslog audit backend failed (sending a message to {} resulted in {}).",
-            _syslog_address,
-            e
-        );
-        logger.error("{}", error_msg);
-        throw audit_exception(std::move(error_msg));
-    }
 }
 
 audit_syslog_storage_helper::audit_syslog_storage_helper(cql3::query_processor& qp, service::migration_manager&) :
     _syslog_address(syslog_address_helper(qp.db().get_config())),
-    _sender(make_unbound_datagram_channel(AF_UNIX)),
-    _semaphore(1) {
+    _sender(make_unbound_datagram_channel(AF_UNIX)) {
 }
 
 audit_syslog_storage_helper::~audit_syslog_storage_helper() {
@@ -88,10 +73,10 @@ audit_syslog_storage_helper::~audit_syslog_storage_helper() {
  */
 future<> audit_syslog_storage_helper::start(const db::config& cfg) {
     if (this_shard_id() != 0) {
-        co_return;
+        return make_ready_future();
     }
 
-    co_await syslog_send_helper("Initializing syslog audit backend.");
+    return syslog_send_helper(_sender, _syslog_address, "Initializing syslog audit backend.");
 }
 
 future<> audit_syslog_storage_helper::stop() {
@@ -108,7 +93,7 @@ future<> audit_syslog_storage_helper::write(const audit_info* audit_info,
     auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
     tm time;
     localtime_r(&now, &time);
-    sstring msg = seastar::format(R"(<{}>{:%h %e %T} scylla-audit: node="{}", category="{}", cl="{}", error="{}", keyspace="{}", query="{}", client_ip="{}", table="{}", username="{}")",
+    sstring msg = seastar::format("<{}>{:%h %e %T} scylla-audit: \"{}\", \"{}\", \"{}\", \"{}\", \"{}\", \"{}\", \"{}\", \"{}\", \"{}\"",
                                     LOG_NOTICE | LOG_USER,
                                     time,
                                     node_ip,
@@ -116,12 +101,12 @@ future<> audit_syslog_storage_helper::write(const audit_info* audit_info,
                                     cl,
                                     (error ? "true" : "false"),
                                     audit_info->keyspace(),
-                                    json_escape(audit_info->query()),
+                                    audit_info->query(),
                                     client_ip,
                                     audit_info->table(),
                                     username);
 
-    co_await syslog_send_helper(msg);
+    return syslog_send_helper(_sender, _syslog_address, msg);
 }
 
 future<> audit_syslog_storage_helper::write_login(const sstring& username,
@@ -132,15 +117,15 @@ future<> audit_syslog_storage_helper::write_login(const sstring& username,
     auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
     tm time;
     localtime_r(&now, &time);
-    sstring msg = seastar::format(R"(<{}>{:%h %e %T} scylla-audit: node="{}", category="AUTH", cl="", error="{}", keyspace="", query="", client_ip="{}", table="", username="{}")",
+    sstring msg = seastar::format("<{}>{:%h %e %T} scylla-audit: \"{}\", \"AUTH\", \"\", \"\", \"\", \"\", \"{}\", \"{}\", \"{}\"",
                                     LOG_NOTICE | LOG_USER,
                                     time,
                                     node_ip,
-                                    (error ? "true" : "false"),
                                     client_ip,
-                                    username);
+                                    username,
+                                    (error ? "true" : "false"));
 
-    co_await syslog_send_helper(msg.c_str());
+    co_await syslog_send_helper(_sender, _syslog_address, msg.c_str());
 }
 
 using registry = class_registrator<storage_helper, audit_syslog_storage_helper, cql3::query_processor&, service::migration_manager&>;

audit/audit_syslog_storage_helper.hh

@@ -24,9 +24,6 @@ namespace audit {
 class audit_syslog_storage_helper : public storage_helper {
     socket_address _syslog_address;
     net::datagram_channel _sender;
-    seastar::semaphore _semaphore;
-
-    future<> syslog_send_helper(const sstring& msg);
 public:
     explicit audit_syslog_storage_helper(cql3::query_processor&, service::migration_manager&);
     virtual ~audit_syslog_storage_helper();

auth/allow_all_authenticator.cc

@@ -9,7 +9,6 @@
 #include "auth/allow_all_authenticator.hh"
 
 #include "service/migration_manager.hh"
-#include "utils/alien_worker.hh"
 #include "utils/class_registrator.hh"
 
 namespace auth {
@@ -22,7 +21,6 @@ static const class_registrator<
         allow_all_authenticator,
         cql3::query_processor&,
         ::service::raft_group0_client&,
-        ::service::migration_manager&,
-        utils::alien_worker&> registration("org.apache.cassandra.auth.AllowAllAuthenticator");
+        ::service::migration_manager&> registration("org.apache.cassandra.auth.AllowAllAuthenticator");
 
 }

auth/allow_all_authenticator.hh

@@ -13,7 +13,6 @@
 #include "auth/authenticated_user.hh"
 #include "auth/authenticator.hh"
 #include "auth/common.hh"
-#include "utils/alien_worker.hh"
 
 namespace cql3 {
 class query_processor;
@@ -29,7 +28,7 @@ extern const std::string_view allow_all_authenticator_name;
 
 class allow_all_authenticator final : public authenticator {
 public:
-    allow_all_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&, utils::alien_worker&) {
+    allow_all_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&) {
     }
 
     virtual future<> start() override {

auth/certificate_authenticator.cc

@@ -33,14 +33,13 @@ static const class_registrator<auth::authenticator
     , auth::certificate_authenticator
     , cql3::query_processor&
     , ::service::raft_group0_client&
-    , ::service::migration_manager&
-    , utils::alien_worker&> cert_auth_reg(CERT_AUTH_NAME);
+    , ::service::migration_manager&> cert_auth_reg(CERT_AUTH_NAME);
 
 enum class auth::certificate_authenticator::query_source {
     subject, altname
 };
 
-auth::certificate_authenticator::certificate_authenticator(cql3::query_processor& qp, ::service::raft_group0_client&, ::service::migration_manager&, utils::alien_worker&)
+auth::certificate_authenticator::certificate_authenticator(cql3::query_processor& qp, ::service::raft_group0_client&, ::service::migration_manager&)
     : _queries([&] {
         auto& conf = qp.db().get_config();
         auto queries = conf.auth_certificate_role_queries();

auth/certificate_authenticator.hh

@@ -10,7 +10,6 @@
 #pragma once
 
 #include "auth/authenticator.hh"
-#include "utils/alien_worker.hh"
 #include <boost/regex_fwd.hpp>  // IWYU pragma: keep
 
 namespace cql3 {
@@ -32,7 +31,7 @@ class certificate_authenticator : public authenticator {
     enum class query_source;
     std::vector<std::pair<query_source, boost::regex>> _queries;
 public:
-    certificate_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&, utils::alien_worker&);
+    certificate_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&);
     ~certificate_authenticator();
 
     future<> start() override;

auth/common.cc

@@ -15,7 +15,7 @@
 
 #include "mutation/canonical_mutation.hh"
 #include "schema/schema_fwd.hh"
-#include "mutation/timestamp.hh"
+#include "timestamp.hh"
 #include "utils/assert.hh"
 #include "utils/exponential_backoff_retry.hh"
 #include "cql3/query_processor.hh"
@@ -119,14 +119,9 @@ future<> create_legacy_metadata_table_if_missing(
     return qs;
 }
 
-::service::raft_timeout get_raft_timeout() noexcept {
-    auto dur = internal_distributed_query_state().get_client_state().get_timeout_config().other_timeout;
-    return ::service::raft_timeout{.value = lowres_clock::now() + dur};
-}
-
 static future<> announce_mutations_with_guard(
         ::service::raft_group0_client& group0_client,
-        utils::chunked_vector<canonical_mutation> muts,
+        std::vector<canonical_mutation> muts,
         ::service::group0_guard group0_guard,
         seastar::abort_source& as,
         std::optional<::service::raft_timeout> timeout) {
@@ -154,7 +149,7 @@ future<> announce_mutations_with_batching(
     });
 
     size_t memory_usage = 0;
-    utils::chunked_vector<canonical_mutation> muts;
+    std::vector<canonical_mutation> muts;
 
     // guard has to be taken before we execute code in gen as
     // it can do read-before-write and we want announce_mutations
@@ -204,7 +199,7 @@ future<> announce_mutations(
             internal_distributed_query_state(),
             timestamp,
             std::move(values));
-    utils::chunked_vector<canonical_mutation> cmuts = {muts.begin(), muts.end()};
+    std::vector<canonical_mutation> cmuts = {muts.begin(), muts.end()};
     co_await announce_mutations_with_guard(group0_client, std::move(cmuts), std::move(group0_guard), as, timeout);
 }
 

auth/common.hh

@@ -17,7 +17,6 @@
 
 #include "types/types.hh"
 #include "service/raft/raft_group0_client.hh"
-#include "timeout_config.hh"
 
 using namespace std::chrono_literals;
 
@@ -78,8 +77,6 @@ future<> create_legacy_metadata_table_if_missing(
 ///
 ::service::query_state& internal_distributed_query_state() noexcept;
 
-::service::raft_timeout get_raft_timeout() noexcept;
-
 // Execute update query via group0 mechanism, mutations will be applied on all nodes.
 // Use this function when need to perform read before write on a single guard or if
 // you have more than one mutation and potentially exceed single command size limit.

auth/ldap_role_manager.cc

@@ -233,9 +233,9 @@ future<role_set> ldap_role_manager::query_granted(std::string_view grantee_name,
 }
 
 future<role_to_directly_granted_map>
-ldap_role_manager::query_all_directly_granted(::service::query_state& qs) {
+ldap_role_manager::query_all_directly_granted() {
     role_to_directly_granted_map result;
-    auto roles = co_await query_all(qs);
+    auto roles = co_await query_all();
     for (auto& role: roles) {
         auto granted_set = co_await query_granted(role, recursive_role_query::no);
         for (auto& granted: granted_set) {
@@ -247,8 +247,8 @@ ldap_role_manager::query_all_directly_granted(::service::query_state& qs) {
     co_return result;
 }
 
-future<role_set> ldap_role_manager::query_all(::service::query_state& qs) {
-    return _std_mgr.query_all(qs);
+future<role_set> ldap_role_manager::query_all() {
+    return _std_mgr.query_all();
 }
 
 future<> ldap_role_manager::create_role(std::string_view role_name) {
@@ -311,12 +311,12 @@ future<bool> ldap_role_manager::can_login(std::string_view role_name) {
 }
 
 future<std::optional<sstring>> ldap_role_manager::get_attribute(
-        std::string_view role_name, std::string_view attribute_name, ::service::query_state& qs) {
-    return _std_mgr.get_attribute(role_name, attribute_name, qs);
+        std::string_view role_name, std::string_view attribute_name) {
+    return _std_mgr.get_attribute(role_name, attribute_name);
 }
 
-future<role_manager::attribute_vals> ldap_role_manager::query_attribute_for_all(std::string_view attribute_name, ::service::query_state& qs) {
-    return _std_mgr.query_attribute_for_all(attribute_name, qs);
+future<role_manager::attribute_vals> ldap_role_manager::query_attribute_for_all(std::string_view attribute_name) {
+    return _std_mgr.query_attribute_for_all(attribute_name);
 }
 
 future<> ldap_role_manager::set_attribute(
@@ -338,7 +338,8 @@ future<std::vector<cql3::description>> ldap_role_manager::describe_role_grants()
 }
 
 future<> ldap_role_manager::ensure_superuser_is_created() {
-    return _std_mgr.ensure_superuser_is_created();
+    // ldap is responsible for users
+    co_return;
 }
 
 } // namespace auth

auth/ldap_role_manager.hh

@@ -75,9 +75,9 @@ class ldap_role_manager : public role_manager {
 
     future<role_set> query_granted(std::string_view, recursive_role_query) override;
 
-    future<role_to_directly_granted_map> query_all_directly_granted(::service::query_state&) override;
+    future<role_to_directly_granted_map> query_all_directly_granted() override;
 
-    future<role_set> query_all(::service::query_state&) override;
+    future<role_set> query_all() override;
 
     future<bool> exists(std::string_view) override;
 
@@ -85,9 +85,9 @@ class ldap_role_manager : public role_manager {
 
     future<bool> can_login(std::string_view) override;
 
-    future<std::optional<sstring>> get_attribute(std::string_view, std::string_view, ::service::query_state&) override;
+    future<std::optional<sstring>> get_attribute(std::string_view, std::string_view) override;
 
-    future<role_manager::attribute_vals> query_attribute_for_all(std::string_view, ::service::query_state&) override;
+    future<role_manager::attribute_vals> query_attribute_for_all(std::string_view) override;
 
     future<> set_attribute(std::string_view, std::string_view, std::string_view, ::service::group0_batch& mc) override;
 

auth/maintenance_socket_role_manager.cc

@@ -78,11 +78,11 @@ future<role_set> maintenance_socket_role_manager::query_granted(std::string_view
     return operation_not_supported_exception<role_set>("QUERY GRANTED");
 }
 
-future<role_to_directly_granted_map> maintenance_socket_role_manager::query_all_directly_granted(::service::query_state&) {
+future<role_to_directly_granted_map> maintenance_socket_role_manager::query_all_directly_granted() {
     return operation_not_supported_exception<role_to_directly_granted_map>("QUERY ALL DIRECTLY GRANTED");
 }
 
-future<role_set> maintenance_socket_role_manager::query_all(::service::query_state&) {
+future<role_set> maintenance_socket_role_manager::query_all() {
     return operation_not_supported_exception<role_set>("QUERY ALL");
 }
 
@@ -98,11 +98,11 @@ future<bool> maintenance_socket_role_manager::can_login(std::string_view role_na
     return make_ready_future<bool>(true);
 }
 
-future<std::optional<sstring>> maintenance_socket_role_manager::get_attribute(std::string_view role_name, std::string_view attribute_name, ::service::query_state&) {
+future<std::optional<sstring>> maintenance_socket_role_manager::get_attribute(std::string_view role_name, std::string_view attribute_name) {
     return operation_not_supported_exception<std::optional<sstring>>("GET ATTRIBUTE");
 }
 
-future<role_manager::attribute_vals> maintenance_socket_role_manager::query_attribute_for_all(std::string_view attribute_name, ::service::query_state&) {
+future<role_manager::attribute_vals> maintenance_socket_role_manager::query_attribute_for_all(std::string_view attribute_name) {
     return operation_not_supported_exception<role_manager::attribute_vals>("QUERY ATTRIBUTE");
 }
 

auth/maintenance_socket_role_manager.hh

@@ -53,9 +53,9 @@ public:
 
     virtual future<role_set> query_granted(std::string_view grantee_name, recursive_role_query) override;
 
-    virtual future<role_to_directly_granted_map> query_all_directly_granted(::service::query_state&) override;
+    virtual future<role_to_directly_granted_map> query_all_directly_granted() override;
 
-    virtual future<role_set> query_all(::service::query_state&) override;
+    virtual future<role_set> query_all() override;
 
     virtual future<bool> exists(std::string_view role_name) override;
 
@@ -63,9 +63,9 @@ public:
 
     virtual future<bool> can_login(std::string_view role_name) override;
 
-    virtual future<std::optional<sstring>> get_attribute(std::string_view role_name, std::string_view attribute_name, ::service::query_state&) override;
+    virtual future<std::optional<sstring>> get_attribute(std::string_view role_name, std::string_view attribute_name) override;
 
-    virtual future<role_manager::attribute_vals> query_attribute_for_all(std::string_view attribute_name, ::service::query_state&) override;
+    virtual future<role_manager::attribute_vals> query_attribute_for_all(std::string_view attribute_name) override;
 
     virtual future<> set_attribute(std::string_view role_name, std::string_view attribute_name, std::string_view attribute_value, ::service::group0_batch& mc) override;
 

auth/password_authenticator.cc

@@ -48,14 +48,14 @@ static const class_registrator<
         password_authenticator,
         cql3::query_processor&,
         ::service::raft_group0_client&,
-        ::service::migration_manager&,
-        utils::alien_worker&> password_auth_reg("org.apache.cassandra.auth.PasswordAuthenticator");
+        ::service::migration_manager&> password_auth_reg("org.apache.cassandra.auth.PasswordAuthenticator");
 
 static thread_local auto rng_for_salt = std::default_random_engine(std::random_device{}());
 
 static std::string_view get_config_value(std::string_view value, std::string_view def) {
     return value.empty() ? def : value;
 }
+
 std::string password_authenticator::default_superuser(const db::config& cfg) {
     return std::string(get_config_value(cfg.auth_superuser_name(), DEFAULT_USER_NAME));
 }
@@ -63,13 +63,12 @@ std::string password_authenticator::default_superuser(const db::config& cfg) {
 password_authenticator::~password_authenticator() {
 }
 
-password_authenticator::password_authenticator(cql3::query_processor& qp, ::service::raft_group0_client& g0, ::service::migration_manager& mm, utils::alien_worker& hashing_worker)
+password_authenticator::password_authenticator(cql3::query_processor& qp, ::service::raft_group0_client& g0, ::service::migration_manager& mm)
     : _qp(qp)
     , _group0_client(g0)
     , _migration_manager(mm)
     , _stopped(make_ready_future<>()) 
     , _superuser(default_superuser(qp.db().get_config()))
-    , _hashing_worker(hashing_worker)
 {}
 
 static bool has_salted_hash(const cql3::untyped_result_set_row& row) {
@@ -102,11 +101,7 @@ future<> password_authenticator::migrate_legacy_metadata() const {
         return do_for_each(*results, [this](const cql3::untyped_result_set_row& row) {
             auto username = row.get_as<sstring>("username");
             auto salted_hash = row.get_as<sstring>(SALTED_HASH);
-            static const auto query = seastar::format("UPDATE {}.{} SET {} = ? WHERE {} = ?",
-                    meta::legacy::AUTH_KS,
-                    meta::roles_table::name,
-                    SALTED_HASH,
-                    meta::roles_table::role_col_name);
+            static const auto query = update_row_query();
             return _qp.execute_internal(
                     query,
                     consistency_for_user(username),
@@ -122,111 +117,42 @@ future<> password_authenticator::migrate_legacy_metadata() const {
     });
 }
 
-future<> password_authenticator::legacy_create_default_if_missing() {
-    const auto exists = co_await legacy::default_role_row_satisfies(_qp, &has_salted_hash, _superuser);
+future<> password_authenticator::create_default_if_missing() {
+    const auto exists = co_await default_role_row_satisfies(_qp, &has_salted_hash, _superuser);
     if (exists) {
         co_return;
     }
     std::string salted_pwd(get_config_value(_qp.db().get_config().auth_superuser_salted_password(), ""));
     if (salted_pwd.empty()) {
-        salted_pwd = passwords::hash(DEFAULT_USER_PASSWORD, rng_for_salt, _scheme);
+        salted_pwd = passwords::hash(DEFAULT_USER_PASSWORD, rng_for_salt);
     }
-    const auto query = seastar::format("UPDATE {}.{} SET {} = ? WHERE {} = ?",
-            meta::legacy::AUTH_KS,
-            meta::roles_table::name,
-            SALTED_HASH,
-            meta::roles_table::role_col_name);
-    co_await _qp.execute_internal(
+    const auto query = update_row_query();
+    if (legacy_mode(_qp)) {
+        co_await _qp.execute_internal(
             query,
             db::consistency_level::QUORUM,
             internal_distributed_query_state(),
             {salted_pwd, _superuser},
             cql3::query_processor::cache_internal::no);
-    plogger.info("Created default superuser authentication record.");
-}
-
-future<> password_authenticator::maybe_create_default_password() {
-    auto needs_password = [this] () -> future<bool> {
-        const sstring query = seastar::format("SELECT * FROM {}.{} WHERE is_superuser = true ALLOW FILTERING", get_auth_ks_name(_qp), meta::roles_table::name);
-        auto results = co_await _qp.execute_internal(query,
-                db::consistency_level::LOCAL_ONE,
-                internal_distributed_query_state(), cql3::query_processor::cache_internal::yes);
-        // Don't add default password if
-        // - there is no default superuser
-        // - there is a superuser with a password.
-        bool has_default = false;
-        bool has_superuser_with_password = false;
-        for (auto& result : *results) {
-            if (result.get_as<sstring>(meta::roles_table::role_col_name) == _superuser) {
-                has_default = true;
-            }
-            if (has_salted_hash(result)) {
-                has_superuser_with_password = true;
-            }
-        }
-        co_return has_default && !has_superuser_with_password;
-    };
-    if (!co_await needs_password()) {
-        co_return;
-    }
-    // We don't want to start operation earlier to avoid quorum requirement in
-    // a common case.
-    ::service::group0_batch batch(
-            co_await _group0_client.start_operation(_as, get_raft_timeout()));
-    // Check again as the state may have changed before we took the guard (batch).
-    if (!co_await needs_password()) {
-        co_return;
-    }
-    // Set default superuser's password.
-    std::string salted_pwd(get_config_value(_qp.db().get_config().auth_superuser_salted_password(), ""));
-    if (salted_pwd.empty()) {
-        salted_pwd = passwords::hash(DEFAULT_USER_PASSWORD, rng_for_salt, _scheme);
-    }
-    const auto update_query = update_row_query();
-    co_await collect_mutations(_qp, batch, update_query, {salted_pwd, _superuser});
-    co_await std::move(batch).commit(_group0_client, _as, get_raft_timeout());
-    plogger.info("Created default superuser authentication record.");
-}
-
-future<> password_authenticator::maybe_create_default_password_with_retries() {
-    size_t retries = _migration_manager.get_concurrent_ddl_retries();
-    while (true)  {
-        try {
-            co_return co_await maybe_create_default_password();
-        } catch (const ::service::group0_concurrent_modification& ex) {
-            plogger.warn("Failed to execute maybe_create_default_password due to guard conflict.{}.", retries ? " Retrying" : " Number of retries exceeded, giving up");
-            if (retries--) {
-                continue;
-            }
-            // Log error but don't crash the whole node startup sequence.
-            plogger.error("Failed to create default superuser password due to guard conflict.");
-            co_return;
-        } catch (const ::service::raft_operation_timeout_error& ex) {
-            plogger.error("Failed to create default superuser password due to exception: {}", ex.what());
-            co_return;
-        }
+        plogger.info("Created default superuser authentication record.");
+    } else {
+        co_await announce_mutations(_qp, _group0_client, query,
+            {salted_pwd, _superuser}, _as, ::service::raft_timeout{});
+        plogger.info("Created default superuser authentication record.");
     }
 }
 
 future<> password_authenticator::start() {
     return once_among_shards([this] {
-        // Verify that at least one hashing scheme is supported.
-        passwords::detail::verify_scheme(_scheme);
-        plogger.info("Using password hashing scheme: {}", passwords::detail::prefix_for_scheme(_scheme));
-
         _stopped = do_after_system_ready(_as, [this] {
             return async([this] {
                 if (legacy_mode(_qp)) {
                     if (!_superuser_created_promise.available()) {
-                        // Counterintuitively, we mark promise as ready before any startup work
-                        // because wait_for_schema_agreement() below will block indefinitely
-                        // without cluster majority. In that case, blocking node startup
-                        // would lead to a cluster deadlock.
                         _superuser_created_promise.set_value();
                     }
                     _migration_manager.wait_for_schema_agreement(_qp.db().real_database(), db::timeout_clock::time_point::max(), &_as).get();
 
-                    if (legacy::any_nondefault_role_row_satisfies(_qp, &has_salted_hash, _superuser).get()) {
+                    if (any_nondefault_role_row_satisfies(_qp, &has_salted_hash, _superuser).get()) {
                         if (legacy_metadata_exists()) {
                             plogger.warn("Ignoring legacy authentication metadata since nondefault data already exist.");
                         }
@@ -238,34 +164,20 @@ future<> password_authenticator::start() {
                         migrate_legacy_metadata().get();
                         return;
                     }
-                    legacy_create_default_if_missing().get();
                 }
                 utils::get_local_injector().inject("password_authenticator_start_pause", utils::wait_for_message(5min)).get();
+                create_default_if_missing().get();
                 if (!legacy_mode(_qp)) {
-                    maybe_create_default_password_with_retries().get();
-                    if (!_superuser_created_promise.available()) {
-                        _superuser_created_promise.set_value();
-                    }
+                    _superuser_created_promise.set_value();
                 }
             });
         });
 
         if (legacy_mode(_qp)) {
-            static const sstring create_roles_query = fmt::format(
-                    "CREATE TABLE {}.{} ("
-                    "  {} text PRIMARY KEY,"
-                    "  can_login boolean,"
-                    "  is_superuser boolean,"
-                    "  member_of set<text>,"
-                    "  salted_hash text"
-                    ")",
-                    meta::legacy::AUTH_KS,
-                    meta::roles_table::name,
-                    meta::roles_table::role_col_name);
             return create_legacy_metadata_table_if_missing(
                     meta::roles_table::name,
                     _qp,
-                    create_roles_query,
+                    meta::roles_table::creation_query(),
                     _migration_manager);
         }
         return make_ready_future<>();
@@ -316,13 +228,7 @@ future<authenticated_user> password_authenticator::authenticate(
 
     try {
         const std::optional<sstring> salted_hash = co_await get_password_hash(username);
-        if (!salted_hash) {
-            throw exceptions::authentication_exception("Username and/or password are incorrect");
-        }
-        const bool password_match = co_await _hashing_worker.submit<bool>([password = std::move(password), salted_hash = std::move(salted_hash)]{
-            return passwords::check(password, *salted_hash);
-        });
-        if (!password_match) {
+        if (!salted_hash || !passwords::check(password, *salted_hash)) {
             throw exceptions::authentication_exception("Username and/or password are incorrect");
         }
         co_return username;
@@ -346,7 +252,7 @@ future<> password_authenticator::create(std::string_view role_name, const authen
     auto maybe_hash = options.credentials.transform([&] (const auto& creds) -> sstring {
         return std::visit(make_visitor(
                 [&] (const password_option& opt) {
-                    return passwords::hash(opt.password, rng_for_salt, _scheme);
+                    return passwords::hash(opt.password, rng_for_salt);
                 },
                 [] (const hashed_password_option& opt) {
                     return opt.hashed_password;
@@ -389,11 +295,11 @@ future<> password_authenticator::alter(std::string_view role_name, const authent
                 query,
                 consistency_for_user(role_name),
                 internal_distributed_query_state(),
-                {passwords::hash(password, rng_for_salt, _scheme), sstring(role_name)},
+                {passwords::hash(password, rng_for_salt), sstring(role_name)},
                 cql3::query_processor::cache_internal::no).discard_result();
     } else {
         co_await collect_mutations(_qp, mc, query,
-                {passwords::hash(password, rng_for_salt, _scheme), sstring(role_name)});
+                {passwords::hash(password, rng_for_salt), sstring(role_name)});
     }
 }
 

auth/password_authenticator.hh

@@ -15,9 +15,7 @@
 
 #include "db/consistency_level_type.hh"
 #include "auth/authenticator.hh"
-#include "auth/passwords.hh"
 #include "service/raft/raft_group0_client.hh"
-#include "utils/alien_worker.hh"
 
 namespace db {
     class config;
@@ -43,17 +41,14 @@ class password_authenticator : public authenticator {
     ::service::migration_manager& _migration_manager;
     future<> _stopped;
     abort_source _as;
-    std::string _superuser; // default superuser name from the config (may or may not be present in roles table)
+    std::string _superuser;
     shared_promise<> _superuser_created_promise;
-    // We used to also support bcrypt, SHA-256, and MD5 (ref. scylladb#24524).
-    constexpr static auth::passwords::scheme _scheme = passwords::scheme::sha_512;
-    utils::alien_worker& _hashing_worker;
 
 public:
     static db::consistency_level consistency_for_user(std::string_view role_name);
     static std::string default_superuser(const db::config&);
 
-    password_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&, utils::alien_worker&);
+    password_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&);
 
     ~password_authenticator();
 
@@ -94,10 +89,7 @@ private:
 
     future<> migrate_legacy_metadata() const;
 
-    future<> legacy_create_default_if_missing();
-
-    future<> maybe_create_default_password();
-    future<> maybe_create_default_password_with_retries();
+    future<> create_default_if_missing();
 
     sstring update_row_query() const;
 };

auth/passwords.cc

@@ -21,14 +21,18 @@ static thread_local crypt_data tlcrypt = {};
 
 namespace detail {
 
-void verify_scheme(scheme scheme) {
+scheme identify_best_supported_scheme() {
+    const auto all_schemes = { scheme::bcrypt_y, scheme::bcrypt_a, scheme::sha_512, scheme::sha_256, scheme::md5 };
+    // "Random", for testing schemes.
     const sstring random_part_of_salt = "aaaabbbbccccdddd";
 
-    const sstring salt = sstring(prefix_for_scheme(scheme)) + random_part_of_salt;
-    const char* e = crypt_r("fisk", salt.c_str(), &tlcrypt);
+    for (scheme c : all_schemes) {
+        const sstring salt = sstring(prefix_for_scheme(c)) + random_part_of_salt;
+        const char* e = crypt_r("fisk", salt.c_str(), &tlcrypt);
 
-    if (e && (e[0] != '*')) {
-        return;
+        if (e && (e[0] != '*')) {
+            return c;
+        }
     }
 
     throw no_supported_schemes();

auth/passwords.hh

@@ -21,11 +21,10 @@ class no_supported_schemes : public std::runtime_error {
 public:
     no_supported_schemes();
 };
+
 ///
-/// Apache Cassandra uses a library to provide the bcrypt scheme. In ScyllaDB, we use SHA-512
-/// instead of bcrypt for performance and for historical reasons (see scylladb#24524).
-/// Currently, SHA-512 is always chosen as the hashing scheme for new passwords, but the other
-/// algorithms remain supported for CREATE ROLE WITH HASHED PASSWORD and backward compatibility.
+/// Apache Cassandra uses a library to provide the bcrypt scheme. Many Linux implementations do not support bcrypt, so
+/// we support alternatives. The cost is loss of direct compatibility with Apache Cassandra system tables.
 ///
 enum class scheme {
     bcrypt_y,
@@ -52,11 +51,11 @@ sstring generate_random_salt_bytes(RandomNumberEngine& g) {
 }
 
 ///
-/// Test given hashing scheme on the current system.
+/// Test each allowed hashing scheme and report the best supported one on the current system.
 ///
-/// \throws \ref no_supported_schemes when scheme is unsupported.
+/// \throws \ref no_supported_schemes when none of the known schemes is supported.
 ///
-void verify_scheme(scheme scheme);
+scheme identify_best_supported_scheme();
 
 std::string_view prefix_for_scheme(scheme) noexcept;
 
@@ -68,7 +67,8 @@ std::string_view prefix_for_scheme(scheme) noexcept;
 /// \throws \ref no_supported_schemes when no known hashing schemes are supported on the system.
 ///
 template <typename RandomNumberEngine>
-sstring generate_salt(RandomNumberEngine& g, scheme scheme) {
+sstring generate_salt(RandomNumberEngine& g) {
+    static const scheme scheme = identify_best_supported_scheme();
     static const sstring prefix = sstring(prefix_for_scheme(scheme));
     return prefix + generate_random_salt_bytes(g);
 }
@@ -93,8 +93,8 @@ sstring hash_with_salt(const sstring& pass, const sstring& salt);
 /// \throws \ref std::system_error when the implementation-specific implementation fails to hash the cleartext.
 ///
 template <typename RandomNumberEngine>
-sstring hash(const sstring& pass, RandomNumberEngine& g, scheme scheme) {
-    return detail::hash_with_salt(pass, detail::generate_salt(g, scheme));
+sstring hash(const sstring& pass, RandomNumberEngine& g) {
+    return detail::hash_with_salt(pass, detail::generate_salt(g));
 }
 
 ///

auth/permission.cc

@@ -36,8 +36,7 @@ static const std::unordered_map<sstring, auth::permission> permission_names({
         {"MODIFY", auth::permission::MODIFY},
         {"AUTHORIZE", auth::permission::AUTHORIZE},
         {"DESCRIBE", auth::permission::DESCRIBE},
-        {"EXECUTE", auth::permission::EXECUTE},
-        {"VECTOR_SEARCH_INDEXING", auth::permission::VECTOR_SEARCH_INDEXING}});
+        {"EXECUTE", auth::permission::EXECUTE}});
 
 const sstring& auth::permissions::to_string(permission p) {
     for (auto& v : permission_names) {

auth/permission.hh

@@ -33,7 +33,6 @@ enum class permission {
     // data access
     SELECT, // required for SELECT.
     MODIFY, // required for INSERT, UPDATE, DELETE, TRUNCATE.
-    VECTOR_SEARCH_INDEXING, // required for SELECT from tables with vector indexes if SELECT permission is not granted.
 
     // permission management
     AUTHORIZE, // required for GRANT and REVOKE.
@@ -55,8 +54,7 @@ typedef enum_set<
                 permission::MODIFY,
                 permission::AUTHORIZE,
                 permission::DESCRIBE,
-                permission::EXECUTE,
-                permission::VECTOR_SEARCH_INDEXING>> permission_set;
+                permission::EXECUTE>> permission_set;
 
 bool operator<(const permission_set&, const permission_set&);
 

auth/resource.cc

@@ -41,26 +41,22 @@ static const std::unordered_map<resource_kind, std::size_t> max_parts{
         {resource_kind::functions, 2}};
 
 static permission_set applicable_permissions(const data_resource_view& dv) {
-    
-    // We only support VECTOR_SEARCH_INDEXING permission for ALL KEYSPACES.
-
-    auto set = permission_set::of<
+    if (dv.table()) {
+        return permission_set::of<
                 permission::ALTER,
                 permission::DROP,
                 permission::SELECT,
                 permission::MODIFY,
                 permission::AUTHORIZE>();
-
-    if (!dv.table()) {
-        set.add(permission_set::of<permission::CREATE>());
     }
 
-    if (!dv.table() && !dv.keyspace()) {
-        set.add(permission_set::of<permission::VECTOR_SEARCH_INDEXING>());
-    }
-
-    return set;
-        
+    return permission_set::of<
+            permission::CREATE,
+            permission::ALTER,
+            permission::DROP,
+            permission::SELECT,
+            permission::MODIFY,
+            permission::AUTHORIZE>();
 }
 
 static permission_set applicable_permissions(const role_resource_view& rv) {
@@ -197,7 +193,9 @@ service_level_resource_view::service_level_resource_view(const resource &r) {
 
 sstring encode_signature(std::string_view name, std::vector<data_type> args) {
     return seastar::format("{}[{}]", name,
-            fmt::join(args | std::views::transform(&abstract_type::name), "^"));
+            fmt::join(args | std::views::transform([] (const data_type t) {
+                return t->name();
+            }), "^"));
 }
 
 std::pair<sstring, std::vector<data_type>> decode_signature(std::string_view encoded_signature) {
@@ -223,7 +221,9 @@ std::pair<sstring, std::vector<data_type>> decode_signature(std::string_view enc
 static sstring decoded_signature_string(std::string_view encoded_signature) {
     auto [function_name, arg_types] = decode_signature(encoded_signature);
     return seastar::format("{}({})", cql3::util::maybe_quote(sstring(function_name)),
-            fmt::join(arg_types | std::views::transform(&abstract_type::cql3_type_name), ", "));
+            fmt::join(arg_types | std::views::transform([] (data_type t) {
+                return t->cql3_type_name();
+            }), ", "));
 }
 
 resource make_functions_resource(const cql3::functions::function& f) {

auth/role_manager.hh

@@ -17,17 +17,12 @@
 #include <seastar/core/format.hh>
 #include <seastar/core/sstring.hh>
 
-#include "auth/common.hh"
 #include "auth/resource.hh"
 #include "cql3/description.hh"
 #include "seastarx.hh"
 #include "exceptions/exceptions.hh"
 #include "service/raft/raft_group0_client.hh"
 
-namespace service {
-class query_state;
-};
-
 namespace auth {
 
 struct role_config final {
@@ -172,9 +167,9 @@ public:
     ///   (role2, role3)
     /// }
     ///  
-    virtual future<role_to_directly_granted_map> query_all_directly_granted(::service::query_state& = internal_distributed_query_state()) = 0;
+    virtual future<role_to_directly_granted_map> query_all_directly_granted() = 0;
 
-    virtual future<role_set> query_all(::service::query_state& = internal_distributed_query_state()) = 0;
+    virtual future<role_set> query_all() = 0;
 
     virtual future<bool> exists(std::string_view role_name) = 0;
 
@@ -191,12 +186,12 @@ public:
     ///
     /// \returns the value of the named attribute, if one is set.
     ///
-    virtual future<std::optional<sstring>> get_attribute(std::string_view role_name, std::string_view attribute_name, ::service::query_state& = internal_distributed_query_state()) = 0;
+    virtual future<std::optional<sstring>> get_attribute(std::string_view role_name, std::string_view attribute_name) = 0;
 
     ///
     /// \returns a mapping of each role's value for the named attribute, if one is set for the role.
     ///
-    virtual future<attribute_vals> query_attribute_for_all(std::string_view attribute_name, ::service::query_state& = internal_distributed_query_state()) = 0;
+    virtual future<attribute_vals> query_attribute_for_all(std::string_view attribute_name) = 0;
 
     /// Sets `attribute_name` with `attribute_value` for `role_name`.
     /// \returns an exceptional future with nonexistant_role if the role does not exist.

auth/roles-metadata.cc

@@ -18,21 +18,43 @@
 
 namespace auth {
 
-namespace legacy {
+namespace meta {
+
+namespace roles_table {
+
+std::string_view creation_query() {
+    static const sstring instance = fmt::format(
+            "CREATE TABLE {}.{} ("
+            "  {} text PRIMARY KEY,"
+            "  can_login boolean,"
+            "  is_superuser boolean,"
+            "  member_of set<text>,"
+            "  salted_hash text"
+            ")",
+            meta::legacy::AUTH_KS,
+            name,
+            role_col_name);
+
+    return instance;
+}
+
+} // namespace roles_table
+
+} // namespace meta
 
 future<bool> default_role_row_satisfies(
         cql3::query_processor& qp,
         std::function<bool(const cql3::untyped_result_set_row&)> p,
         std::optional<std::string> rolename) {
     const sstring query = seastar::format("SELECT * FROM {}.{} WHERE {} = ?",
-            auth::meta::legacy::AUTH_KS,
+            get_auth_ks_name(qp),
             meta::roles_table::name,
             meta::roles_table::role_col_name);
 
     for (auto cl : { db::consistency_level::ONE, db::consistency_level::QUORUM }) {
         auto results = co_await qp.execute_internal(query, cl
             , internal_distributed_query_state()
-            , {rolename.value_or(std::string(auth::meta::DEFAULT_SUPERUSER_NAME))}
+            , {rolename.value_or(std::string(meta::DEFAULT_SUPERUSER_NAME))}
             , cql3::query_processor::cache_internal::yes
             );
         if (!results->empty()) {
@@ -46,7 +68,7 @@ future<bool> any_nondefault_role_row_satisfies(
         cql3::query_processor& qp,
         std::function<bool(const cql3::untyped_result_set_row&)> p,
         std::optional<std::string> rolename) {
-    const sstring query = seastar::format("SELECT * FROM {}.{}", auth::meta::legacy::AUTH_KS, meta::roles_table::name);
+    const sstring query = seastar::format("SELECT * FROM {}.{}", get_auth_ks_name(qp), meta::roles_table::name);
 
     auto results = co_await qp.execute_internal(query, db::consistency_level::QUORUM
         , internal_distributed_query_state(), cql3::query_processor::cache_internal::no
@@ -63,6 +85,4 @@ future<bool> any_nondefault_role_row_satisfies(
     });
 }
 
-} // namespace legacy
-
-} // namespace auth
+}

auth/roles-metadata.hh

@@ -27,15 +27,15 @@ namespace meta {
 
 namespace roles_table {
 
+std::string_view creation_query();
+
 constexpr std::string_view name{"roles", 5};
 
 constexpr std::string_view role_col_name{"role", 4};
 
-} // namespace roles_table
+}
 
-} // namespace meta
-
-namespace legacy {
+}
 
 ///
 /// Check that the default role satisfies a predicate, or `false` if the default role does not exist.
@@ -55,6 +55,4 @@ future<bool> any_nondefault_role_row_satisfies(
         std::optional<std::string> rolename = {}
         );
 
-} // namespace legacy
-
-} // namespace auth
+}

auth/saslauthd_authenticator.cc

@@ -34,10 +34,9 @@ static const class_registrator<
         saslauthd_authenticator,
         cql3::query_processor&,
         ::service::raft_group0_client&,
-        ::service::migration_manager&,
-        utils::alien_worker&> saslauthd_auth_reg("com.scylladb.auth.SaslauthdAuthenticator");
+        ::service::migration_manager&> saslauthd_auth_reg("com.scylladb.auth.SaslauthdAuthenticator");
 
-saslauthd_authenticator::saslauthd_authenticator(cql3::query_processor& qp, ::service::raft_group0_client&, ::service::migration_manager&, utils::alien_worker&)
+saslauthd_authenticator::saslauthd_authenticator(cql3::query_processor& qp, ::service::raft_group0_client&, ::service::migration_manager&)
     : _socket_path(qp.db().get_config().saslauthd_socket_path())
 {}
 
@@ -182,7 +181,7 @@ future<> saslauthd_authenticator::alter(std::string_view role_name, const authen
 }
 
 future<> saslauthd_authenticator::drop(std::string_view name, ::service::group0_batch& mc) {
-    return make_ready_future<>();
+    throw exceptions::authentication_exception("Cannot delete passwords with SaslauthdAuthenticator");
 }
 
 future<custom_options> saslauthd_authenticator::query_custom_options(std::string_view role_name) const {

auth/saslauthd_authenticator.hh

@@ -11,7 +11,6 @@
 #pragma once
 
 #include "auth/authenticator.hh"
-#include "utils/alien_worker.hh"
 
 namespace cql3 {
 class query_processor;
@@ -29,7 +28,7 @@ namespace auth {
 class saslauthd_authenticator : public authenticator {
     sstring _socket_path; ///< Path to the domain socket on which saslauthd is listening.
 public:
-    saslauthd_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&, utils::alien_worker&);
+    saslauthd_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&);
 
     future<> start() override;