2025-01-29 20:42:57 +00:00
22 changed files with 3238 additions and 1147 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -1402,6 +1402,7 @@ dependencies = [
 "nom",
 "opentelemetry",
 "opentelemetry-prometheus",
 "paste",
 "percent-encoding",
 "pin-project",
 "prometheus",
--- a/Cargo.nix
+++ b/Cargo.nix
@ -35,7 +35,7 @@ args@{
  ignoreLockHash,
 }:
 let
-  nixifiedLockHash = "d13a40f6a67a6a1075dbb5a948d7bfceea51958a0b5b6182ad56a9e39ab4dfd0";
+  nixifiedLockHash = "cc8c069ebe713e8225c166aa2bba5cc6e5016f007c6e7b7af36dd49452c859cc";
  workspaceSrc = if args.workspaceSrc == null then ./. else args.workspaceSrc;
  currentLockHash = builtins.hashFile "sha256" (workspaceSrc + /Cargo.lock);
  lockHashIgnored = if ignoreLockHash
@ -2042,6 +2042,7 @@ in
      nom = (rustPackages."registry+https://github.com/rust-lang/crates.io-index".nom."7.1.3" { inherit profileName; }).out;
      opentelemetry = (rustPackages."registry+https://github.com/rust-lang/crates.io-index".opentelemetry."0.17.0" { inherit profileName; }).out;
      ${ if rootFeatures' ? "garage/default" || rootFeatures' ? "garage/metrics" || rootFeatures' ? "garage_api/metrics" || rootFeatures' ? "garage_api/opentelemetry-prometheus" then "opentelemetry_prometheus" else null } = (rustPackages."registry+https://github.com/rust-lang/crates.io-index".opentelemetry-prometheus."0.10.0" { inherit profileName; }).out;
      paste = (buildRustPackages."registry+https://github.com/rust-lang/crates.io-index".paste."1.0.14" { profileName = "__noProfile"; }).out;
      percent_encoding = (rustPackages."registry+https://github.com/rust-lang/crates.io-index".percent-encoding."2.3.1" { inherit profileName; }).out;
      pin_project = (rustPackages."registry+https://github.com/rust-lang/crates.io-index".pin-project."1.1.4" { inherit profileName; }).out;
      ${ if rootFeatures' ? "garage/default" || rootFeatures' ? "garage/metrics" || rootFeatures' ? "garage_api/metrics" || rootFeatures' ? "garage_api/prometheus" then "prometheus" else null } = (rustPackages."registry+https://github.com/rust-lang/crates.io-index".prometheus."0.13.3" { inherit profileName; }).out;
--- a/Cargo.toml
+++ b/Cargo.toml
@ -62,6 +62,7 @@ mktemp = "0.5"
 nix = { version = "0.29", default-features = false, features = ["fs"] }
 nom = "7.1"
 parse_duration = "2.1"
 paste = "1.0"
 pin-project = "1.0.12"
 pnet_datalink = "0.34"
 rand = "0.8"
--- a/doc/api/garage-admin-v2.html
+++ b/doc/api/garage-admin-v2.html
@ -0,0 +1,24 @@
 <!DOCTYPE html>
 <html>
  <head>
    <title>Garage Adminstration API v0</title>
    <!-- needed for adaptive design -->
    <meta charset="utf-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link href="./css/redoc.css" rel="stylesheet">
    <!--
    Redoc doesn't change outer page styles
    -->
    <style>
      body {
        margin: 0;
        padding: 0;
      }
    </style>
  </head>
  <body>
    <redoc spec-url='./garage-admin-v2.yml'></redoc>
    <script src="./redoc.standalone.js"> </script>
  </body>
 </html>
--- a/doc/api/garage-admin-v2.yml
+++ b/doc/api/garage-admin-v2.yml
--- a/doc/drafts/admin-api.md
+++ b/doc/drafts/admin-api.md
@ -13,8 +13,9 @@ We will bump the version numbers prefixed to each API endpoint each time the syn
 or semantics change, meaning that code that relies on these endpoints will break
 when changes are introduced.
-The Garage administration API was introduced in version 0.7.2, this document
+The Garage administration API was introduced in version 0.7.2, and was
-does not apply to older versions of Garage.
+changed several times.
 This document applies only to the Garage v2 API (starting with Garage v2.0.0).
 ## Access control
@ -52,11 +53,18 @@ Returns an HTTP status 200 if the node is ready to answer user's requests,
 and an HTTP status 503 (Service Unavailable) if there are some partitions
 for which a quorum of nodes is not available.
 A simple textual message is also returned in a body with content-type `text/plain`.
-See `/v1/health` for an API that also returns JSON output.
+See `/v2/GetClusterHealth` for an API that also returns JSON output.
 ### Other special endpoints
 #### CheckDomain `GET /check?domain=<domain>`
 Checks whether this Garage cluster serves a website for domain `<domain>`.
 Returns HTTP 200 Ok if yes, or HTTP 4xx if no website is available for this domain.
 ### Cluster operations
-#### GetClusterStatus `GET /v1/status`
+#### GetClusterStatus `GET /v2/GetClusterStatus`
 Returns the cluster's current status in JSON, including:
@ -70,7 +78,7 @@ Example response body:
 ```json
 {
  "node": "b10c110e4e854e5aa3f4637681befac755154b20059ec163254ddbfae86b09df",
-  "garageVersion": "v1.0.1",
+  "garageVersion": "v2.0.0",
  "garageFeatures": [
    "k2v",
    "lmdb",
@ -169,7 +177,7 @@ Example response body:
 }
 ```
-#### GetClusterHealth `GET /v1/health`
+#### GetClusterHealth `GET /v2/GetClusterHealth`
 Returns the cluster's current health in JSON format, with the following variables:
@ -202,7 +210,7 @@ Example response body:
 }
 ```
-#### ConnectClusterNodes `POST /v1/connect`
+#### ConnectClusterNodes `POST /v2/ConnectClusterNodes`
 Instructs this Garage node to connect to other Garage nodes at specified addresses.
@ -232,7 +240,7 @@ Example response:
 ]
 ```
-#### GetClusterLayout `GET /v1/layout`
+#### GetClusterLayout `GET /v2/GetClusterLayout`
 Returns the cluster's current layout in JSON, including:
@ -293,7 +301,7 @@ Example response body:
 }
 ```
-#### UpdateClusterLayout `POST /v1/layout`
+#### UpdateClusterLayout `POST /v2/UpdateClusterLayout`
 Send modifications to the cluster layout. These modifications will
 be included in the staged role changes, visible in subsequent calls
@ -330,7 +338,7 @@ This returns the new cluster layout with the proposed staged changes,
 as returned by GetClusterLayout.
-#### ApplyClusterLayout `POST /v1/layout/apply`
+#### ApplyClusterLayout `POST /v2/ApplyClusterLayout`
 Applies to the cluster the layout changes currently registered as
 staged layout changes.
@ -350,7 +358,7 @@ existing layout in the cluster.
 This returns the message describing all the calculations done to compute the new
 layout, as well as the description of the layout as returned by GetClusterLayout.
-#### RevertClusterLayout `POST /v1/layout/revert`
+#### RevertClusterLayout `POST /v2/RevertClusterLayout`
 Clears all of the staged layout changes.
@ -374,7 +382,7 @@ as returned by GetClusterLayout.
 ### Access key operations
-#### ListKeys `GET /v1/key`
+#### ListKeys `GET /v2/ListKeys`
 Returns all API access keys in the cluster.
@ -393,8 +401,8 @@ Example response:
 ]
 ```
-#### GetKeyInfo `GET /v1/key?id=<acces key id>`
+#### GetKeyInfo `GET /v2/GetKeyInfo?id=<acces key id>`
-#### GetKeyInfo `GET /v1/key?search=<pattern>`
+#### GetKeyInfo `GET /v2/GetKeyInfo?search=<pattern>`
 Returns information about the requested API access key.
@ -468,7 +476,7 @@ Example response:
 }
 ```
-#### CreateKey `POST /v1/key`
+#### CreateKey `POST /v2/CreateKey`
 Creates a new API access key.
@ -483,7 +491,7 @@ Request body format:
 This returns the key info, including the created secret key,
 in the same format as the result of GetKeyInfo.
-#### ImportKey `POST /v1/key/import`
+#### ImportKey `POST /v2/ImportKey`
 Imports an existing API key.
 This will check that the imported key is in the valid format, i.e.
@ -501,7 +509,7 @@ Request body format:
 This returns the key info in the same format as the result of GetKeyInfo.
-#### UpdateKey `POST /v1/key?id=<acces key id>`
+#### UpdateKey `POST /v2/UpdateKey?id=<acces key id>`
 Updates information about the specified API access key.
@ -523,14 +531,14 @@ The possible flags in `allow` and `deny` are: `createBucket`.
 This returns the key info in the same format as the result of GetKeyInfo.
-#### DeleteKey `DELETE /v1/key?id=<acces key id>`
+#### DeleteKey `POST /v2/DeleteKey?id=<acces key id>`
 Deletes an API access key.
 ### Bucket operations
-#### ListBuckets `GET /v1/bucket`
+#### ListBuckets `GET /v2/ListBuckets`
 Returns all storage buckets in the cluster.
@ -572,8 +580,8 @@ Example response:
 ]
 ```
-#### GetBucketInfo `GET /v1/bucket?id=<bucket id>`
+#### GetBucketInfo `GET /v2/GetBucketInfo?id=<bucket id>`
-#### GetBucketInfo `GET /v1/bucket?globalAlias=<alias>`
+#### GetBucketInfo `GET /v2/GetBucketInfo?globalAlias=<alias>`
 Returns information about the requested storage bucket.
@ -616,7 +624,7 @@ Example response:
 }
 ```
-#### CreateBucket `POST /v1/bucket`
+#### CreateBucket `POST /v2/CreateBucket`
 Creates a new storage bucket.
@ -656,7 +664,7 @@ or no alias at all.
 Technically, you can also specify both `globalAlias` and `localAlias` and that would create
 two aliases, but I don't see why you would want to do that.
-#### UpdateBucket `PUT /v1/bucket?id=<bucket id>`
+#### UpdateBucket `POST /v2/UpdateBucket?id=<bucket id>`
 Updates configuration of the given bucket.
@ -688,7 +696,7 @@ In `quotas`: new values of `maxSize` and `maxObjects` must both be specified, or
 to remove the quotas. An absent value will be considered the same as a `null`. It is not possible
 to change only one of the two quotas.
-#### DeleteBucket `DELETE /v1/bucket?id=<bucket id>`
+#### DeleteBucket `POST /v2/DeleteBucket?id=<bucket id>`
 Deletes a storage bucket. A bucket cannot be deleted if it is not empty.
@ -697,7 +705,7 @@ Warning: this will delete all aliases associated with the bucket!
 ### Operations on permissions for keys on buckets
-#### BucketAllowKey `POST /v1/bucket/allow`
+#### AllowBucketKey `POST /v2/AllowBucketKey`
 Allows a key to do read/write/owner operations on a bucket.
@ -718,7 +726,7 @@ Request body format:
 Flags in `permissions` which have the value `true` will be activated.
 Other flags will remain unchanged.
-#### BucketDenyKey `POST /v1/bucket/deny`
+#### DenyBucketKey `POST /v2/DenyBucketKey`
 Denies a key from doing read/write/owner operations on a bucket.
@ -742,19 +750,35 @@ Other flags will remain unchanged.
 ### Operations on bucket aliases
-#### GlobalAliasBucket `PUT /v1/bucket/alias/global?id=<bucket id>&alias=<global alias>`
+#### AddBucketAlias `POST /v2/AddBucketAlias`
-Empty body. Creates a global alias for a bucket.
+Creates an alias for a bucket in the namespace of a specific access key.
 To create a global alias, specify the `globalAlias` field.
 To create a local alias, specify the `localAlias` and `accessKeyId` fields.
-#### GlobalUnaliasBucket `DELETE /v1/bucket/alias/global?id=<bucket id>&alias=<global alias>`
+Request body format:
-Removes a global alias for a bucket.
+```json
 {
    "bucketId": "e6a14cd6a27f48684579ec6b381c078ab11697e6bc8513b72b2f5307e25fff9b",
    "globalAlias": "my-bucket"
 }
 ```
-#### LocalAliasBucket `PUT /v1/bucket/alias/local?id=<bucket id>&accessKeyId=<access key ID>&alias=<local alias>`
+or:
-Empty body. Creates a local alias for a bucket in the namespace of a specific access key.
+```json
 {
    "bucketId": "e6a14cd6a27f48684579ec6b381c078ab11697e6bc8513b72b2f5307e25fff9b",
    "accessKeyId": "GK31c2f218a2e44f485b94239e",
    "localAlias": "my-bucket"
 }
 ```
-#### LocalUnaliasBucket `DELETE /v1/bucket/alias/local?id=<bucket id>&accessKeyId<access key ID>&alias=<local alias>`
+#### RemoveBucketAlias `POST /v2/RemoveBucketAlias`
-Removes a local alias for a bucket in the namespace of a specific access key.
+Removes an alias for a bucket in the namespace of a specific access key.
 To remove a global alias, specify the `globalAlias` field.
 To remove a local alias, specify the `localAlias` and `accessKeyId` fields.
 Request body format: same as AddBucketAlias.
--- a/src/api/Cargo.toml
+++ b/src/api/Cargo.toml
@ -38,6 +38,7 @@ idna.workspace = true
 tracing.workspace = true
 md-5.workspace = true
 nom.workspace = true
 paste.workspace = true
 pin-project.workspace = true
 sha1.workspace = true
 sha2.workspace = true
--- a/src/api/admin/api.rs
+++ b/src/api/admin/api.rs
@ -0,0 +1,565 @@
 use std::net::SocketAddr;
 use std::sync::Arc;
 use async_trait::async_trait;
 use paste::paste;
 use serde::{Deserialize, Serialize};
 use garage_model::garage::Garage;
 use crate::admin::error::Error;
 use crate::admin::macros::*;
 use crate::admin::EndpointHandler;
 use crate::helpers::is_default;
 // This generates the following:
 //
 // - An enum AdminApiRequest that contains a variant for all endpoints
 //
 // - An enum AdminApiResponse that contains a variant for all non-special endpoints.
 //   This enum is serialized in api_server.rs, without the enum tag,
 //   which gives directly the JSON response corresponding to the API call.
 //   This enum does not implement Deserialize as its meaning can be ambiguous.
 //
 // - An enum TaggedAdminApiResponse that contains the same variants, but
 //   serializes as a tagged enum. This allows it to be transmitted through
 //   Garage RPC and deserialized correctly upon receival.
 //   Conversion from untagged to tagged can be done using the `.tagged()` method.
 //
 // - AdminApiRequest::name() that returns the name of the endpoint
 //
 // - impl EndpointHandler for AdminApiHandler, that uses the impl EndpointHandler
 //   of each request type below for non-special endpoints
 admin_endpoints![
 	// Special endpoints of the Admin API
 	@special Options,
 	@special CheckDomain,
 	@special Health,
 	@special Metrics,
 	// Cluster operations
 	GetClusterStatus,
 	GetClusterHealth,
 	ConnectClusterNodes,
 	GetClusterLayout,
 	UpdateClusterLayout,
 	ApplyClusterLayout,
 	RevertClusterLayout,
 	// Access key operations
 	ListKeys,
 	GetKeyInfo,
 	CreateKey,
 	ImportKey,
 	UpdateKey,
 	DeleteKey,
 	// Bucket operations
 	ListBuckets,
 	GetBucketInfo,
 	CreateBucket,
 	UpdateBucket,
 	DeleteBucket,
 	// Operations on permissions for keys on buckets
 	AllowBucketKey,
 	DenyBucketKey,
 	// Operations on bucket aliases
 	AddBucketAlias,
 	RemoveBucketAlias,
 ];
 // **********************************************
 //      Special endpoints
 //
 // These endpoints don't have associated *Response structs
 // because they directly produce an http::Response
 // **********************************************
 #[derive(Serialize, Deserialize)]
 pub struct OptionsRequest;
 #[derive(Serialize, Deserialize)]
 pub struct CheckDomainRequest {
 	pub domain: String,
 }
 #[derive(Serialize, Deserialize)]
 pub struct HealthRequest;
 #[derive(Serialize, Deserialize)]
 pub struct MetricsRequest;
 // **********************************************
 //      Cluster operations
 // **********************************************
 // ---- GetClusterStatus ----
 #[derive(Serialize, Deserialize)]
 pub struct GetClusterStatusRequest;
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetClusterStatusResponse {
 	pub node: String,
 	pub garage_version: String,
 	pub garage_features: Option<Vec<String>>,
 	pub rust_version: String,
 	pub db_engine: String,
 	pub layout_version: u64,
 	pub nodes: Vec<NodeResp>,
 }
 #[derive(Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct NodeResp {
 	pub id: String,
 	pub role: Option<NodeRoleResp>,
 	pub addr: Option<SocketAddr>,
 	pub hostname: Option<String>,
 	pub is_up: bool,
 	pub last_seen_secs_ago: Option<u64>,
 	pub draining: bool,
 	#[serde(skip_serializing_if = "Option::is_none")]
 	pub data_partition: Option<FreeSpaceResp>,
 	#[serde(skip_serializing_if = "Option::is_none")]
 	pub metadata_partition: Option<FreeSpaceResp>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct NodeRoleResp {
 	pub id: String,
 	pub zone: String,
 	pub capacity: Option<u64>,
 	pub tags: Vec<String>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FreeSpaceResp {
 	pub available: u64,
 	pub total: u64,
 }
 // ---- GetClusterHealth ----
 #[derive(Serialize, Deserialize)]
 pub struct GetClusterHealthRequest;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetClusterHealthResponse {
 	pub status: String,
 	pub known_nodes: usize,
 	pub connected_nodes: usize,
 	pub storage_nodes: usize,
 	pub storage_nodes_ok: usize,
 	pub partitions: usize,
 	pub partitions_quorum: usize,
 	pub partitions_all_ok: usize,
 }
 // ---- ConnectClusterNodes ----
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ConnectClusterNodesRequest(pub Vec<String>);
 #[derive(Serialize, Deserialize)]
 pub struct ConnectClusterNodesResponse(pub Vec<ConnectNodeResponse>);
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ConnectNodeResponse {
 	pub success: bool,
 	pub error: Option<String>,
 }
 // ---- GetClusterLayout ----
 #[derive(Serialize, Deserialize)]
 pub struct GetClusterLayoutRequest;
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetClusterLayoutResponse {
 	pub version: u64,
 	pub roles: Vec<NodeRoleResp>,
 	pub staged_role_changes: Vec<NodeRoleChange>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct NodeRoleChange {
 	pub id: String,
 	#[serde(flatten)]
 	pub action: NodeRoleChangeEnum,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum NodeRoleChangeEnum {
 	#[serde(rename_all = "camelCase")]
 	Remove { remove: bool },
 	#[serde(rename_all = "camelCase")]
 	Update {
 		zone: String,
 		capacity: Option<u64>,
 		tags: Vec<String>,
 	},
 }
 // ---- UpdateClusterLayout ----
 #[derive(Serialize, Deserialize)]
 pub struct UpdateClusterLayoutRequest(pub Vec<NodeRoleChange>);
 #[derive(Serialize, Deserialize)]
 pub struct UpdateClusterLayoutResponse(pub GetClusterLayoutResponse);
 // ---- ApplyClusterLayout ----
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ApplyClusterLayoutRequest {
 	pub version: u64,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ApplyClusterLayoutResponse {
 	pub message: Vec<String>,
 	pub layout: GetClusterLayoutResponse,
 }
 // ---- RevertClusterLayout ----
 #[derive(Serialize, Deserialize)]
 pub struct RevertClusterLayoutRequest;
 #[derive(Serialize, Deserialize)]
 pub struct RevertClusterLayoutResponse(pub GetClusterLayoutResponse);
 // **********************************************
 //      Access key operations
 // **********************************************
 // ---- ListKeys ----
 #[derive(Serialize, Deserialize)]
 pub struct ListKeysRequest;
 #[derive(Serialize, Deserialize)]
 pub struct ListKeysResponse(pub Vec<ListKeysResponseItem>);
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListKeysResponseItem {
 	pub id: String,
 	pub name: String,
 }
 // ---- GetKeyInfo ----
 #[derive(Serialize, Deserialize)]
 pub struct GetKeyInfoRequest {
 	pub id: Option<String>,
 	pub search: Option<String>,
 	pub show_secret_key: bool,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetKeyInfoResponse {
 	pub name: String,
 	pub access_key_id: String,
 	#[serde(skip_serializing_if = "is_default")]
 	pub secret_access_key: Option<String>,
 	pub permissions: KeyPerm,
 	pub buckets: Vec<KeyInfoBucketResponse>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct KeyPerm {
 	#[serde(default)]
 	pub create_bucket: bool,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct KeyInfoBucketResponse {
 	pub id: String,
 	pub global_aliases: Vec<String>,
 	pub local_aliases: Vec<String>,
 	pub permissions: ApiBucketKeyPerm,
 }
 #[derive(Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct ApiBucketKeyPerm {
 	#[serde(default)]
 	pub read: bool,
 	#[serde(default)]
 	pub write: bool,
 	#[serde(default)]
 	pub owner: bool,
 }
 // ---- CreateKey ----
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateKeyRequest {
 	pub name: Option<String>,
 }
 #[derive(Serialize, Deserialize)]
 pub struct CreateKeyResponse(pub GetKeyInfoResponse);
 // ---- ImportKey ----
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ImportKeyRequest {
 	pub access_key_id: String,
 	pub secret_access_key: String,
 	pub name: Option<String>,
 }
 #[derive(Serialize, Deserialize)]
 pub struct ImportKeyResponse(pub GetKeyInfoResponse);
 // ---- UpdateKey ----
 #[derive(Serialize, Deserialize)]
 pub struct UpdateKeyRequest {
 	pub id: String,
 	pub body: UpdateKeyRequestBody,
 }
 #[derive(Serialize, Deserialize)]
 pub struct UpdateKeyResponse(pub GetKeyInfoResponse);
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct UpdateKeyRequestBody {
 	pub name: Option<String>,
 	pub allow: Option<KeyPerm>,
 	pub deny: Option<KeyPerm>,
 }
 // ---- DeleteKey ----
 #[derive(Serialize, Deserialize)]
 pub struct DeleteKeyRequest {
 	pub id: String,
 }
 #[derive(Serialize, Deserialize)]
 pub struct DeleteKeyResponse;
 // **********************************************
 //      Bucket operations
 // **********************************************
 // ---- ListBuckets ----
 #[derive(Serialize, Deserialize)]
 pub struct ListBucketsRequest;
 #[derive(Serialize, Deserialize)]
 pub struct ListBucketsResponse(pub Vec<ListBucketsResponseItem>);
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListBucketsResponseItem {
 	pub id: String,
 	pub global_aliases: Vec<String>,
 	pub local_aliases: Vec<BucketLocalAlias>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BucketLocalAlias {
 	pub access_key_id: String,
 	pub alias: String,
 }
 // ---- GetBucketInfo ----
 #[derive(Serialize, Deserialize)]
 pub struct GetBucketInfoRequest {
 	pub id: Option<String>,
 	pub global_alias: Option<String>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetBucketInfoResponse {
 	pub id: String,
 	pub global_aliases: Vec<String>,
 	pub website_access: bool,
 	#[serde(default)]
 	pub website_config: Option<GetBucketInfoWebsiteResponse>,
 	pub keys: Vec<GetBucketInfoKey>,
 	pub objects: i64,
 	pub bytes: i64,
 	pub unfinished_uploads: i64,
 	pub unfinished_multipart_uploads: i64,
 	pub unfinished_multipart_upload_parts: i64,
 	pub unfinished_multipart_upload_bytes: i64,
 	pub quotas: ApiBucketQuotas,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetBucketInfoWebsiteResponse {
 	pub index_document: String,
 	pub error_document: Option<String>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetBucketInfoKey {
 	pub access_key_id: String,
 	pub name: String,
 	pub permissions: ApiBucketKeyPerm,
 	pub bucket_local_aliases: Vec<String>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ApiBucketQuotas {
 	pub max_size: Option<u64>,
 	pub max_objects: Option<u64>,
 }
 // ---- CreateBucket ----
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateBucketRequest {
 	pub global_alias: Option<String>,
 	pub local_alias: Option<CreateBucketLocalAlias>,
 }
 #[derive(Serialize, Deserialize)]
 pub struct CreateBucketResponse(pub GetBucketInfoResponse);
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateBucketLocalAlias {
 	pub access_key_id: String,
 	pub alias: String,
 	#[serde(default)]
 	pub allow: ApiBucketKeyPerm,
 }
 // ---- UpdateBucket ----
 #[derive(Serialize, Deserialize)]
 pub struct UpdateBucketRequest {
 	pub id: String,
 	pub body: UpdateBucketRequestBody,
 }
 #[derive(Serialize, Deserialize)]
 pub struct UpdateBucketResponse(pub GetBucketInfoResponse);
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct UpdateBucketRequestBody {
 	pub website_access: Option<UpdateBucketWebsiteAccess>,
 	pub quotas: Option<ApiBucketQuotas>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct UpdateBucketWebsiteAccess {
 	pub enabled: bool,
 	pub index_document: Option<String>,
 	pub error_document: Option<String>,
 }
 // ---- DeleteBucket ----
 #[derive(Serialize, Deserialize)]
 pub struct DeleteBucketRequest {
 	pub id: String,
 }
 #[derive(Serialize, Deserialize)]
 pub struct DeleteBucketResponse;
 // **********************************************
 //      Operations on permissions for keys on buckets
 // **********************************************
 // ---- AllowBucketKey ----
 #[derive(Serialize, Deserialize)]
 pub struct AllowBucketKeyRequest(pub BucketKeyPermChangeRequest);
 #[derive(Serialize, Deserialize)]
 pub struct AllowBucketKeyResponse(pub GetBucketInfoResponse);
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BucketKeyPermChangeRequest {
 	pub bucket_id: String,
 	pub access_key_id: String,
 	pub permissions: ApiBucketKeyPerm,
 }
 // ---- DenyBucketKey ----
 #[derive(Serialize, Deserialize)]
 pub struct DenyBucketKeyRequest(pub BucketKeyPermChangeRequest);
 #[derive(Serialize, Deserialize)]
 pub struct DenyBucketKeyResponse(pub GetBucketInfoResponse);
 // **********************************************
 //      Operations on bucket aliases
 // **********************************************
 // ---- AddBucketAlias ----
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct AddBucketAliasRequest {
 	pub bucket_id: String,
 	#[serde(flatten)]
 	pub alias: BucketAliasEnum,
 }
 #[derive(Serialize, Deserialize)]
 pub struct AddBucketAliasResponse(pub GetBucketInfoResponse);
 #[derive(Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum BucketAliasEnum {
 	#[serde(rename_all = "camelCase")]
 	Global { global_alias: String },
 	#[serde(rename_all = "camelCase")]
 	Local {
 		local_alias: String,
 		access_key_id: String,
 	},
 }
 // ---- RemoveBucketAlias ----
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RemoveBucketAliasRequest {
 	pub bucket_id: String,
 	#[serde(flatten)]
 	pub alias: BucketAliasEnum,
 }
 #[derive(Serialize, Deserialize)]
 pub struct RemoveBucketAliasResponse(pub GetBucketInfoResponse);
--- a/src/api/admin/api_server.rs
+++ b/src/api/admin/api_server.rs
@ -1,10 +1,10 @@
-use std::collections::HashMap;
+use std::borrow::Cow;
 use std::sync::Arc;
 use argon2::password_hash::PasswordHash;
 use async_trait::async_trait;
-use http::header::{ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN, ALLOW};
+use http::header::{HeaderValue, ACCESS_CONTROL_ALLOW_ORIGIN, AUTHORIZATION};
 use hyper::{body::Incoming as IncomingBody, Request, Response, StatusCode};
 use tokio::sync::watch;
@ -16,18 +16,17 @@ use opentelemetry_prometheus::PrometheusExporter;
 use prometheus::{Encoder, TextEncoder};
 use garage_model::garage::Garage;
 use garage_rpc::system::ClusterHealthStatus;
 use garage_util::error::Error as GarageError;
 use garage_util::socket_address::UnixOrTCPSocketAddress;
 use crate::generic_server::*;
-use crate::admin::bucket::*;
+use crate::admin::api::*;
 use crate::admin::cluster::*;
 use crate::admin::error::*;
 use crate::admin::key::*;
 use crate::admin::router_v0;
-use crate::admin::router_v1::{Authorization, Endpoint};
+use crate::admin::router_v1;
 use crate::admin::Authorization;
 use crate::admin::EndpointHandler;
 use crate::helpers::*;
 pub type ResBody = BoxBody<Error>;
@ -40,6 +39,11 @@ pub struct AdminApiServer {
 	admin_token: Option<String>,
 }
 pub enum Endpoint {
 	Old(router_v1::Endpoint),
 	New(String),
 }
 impl AdminApiServer {
 	pub fn new(
 		garage: Arc<Garage>,
@ -68,130 +72,6 @@ impl AdminApiServer {
 			.await
 	}
 	fn handle_options(&self, _req: &Request<IncomingBody>) -> Result<Response<ResBody>, Error> {
 		Ok(Response::builder()
 			.status(StatusCode::NO_CONTENT)
 			.header(ALLOW, "OPTIONS, GET, POST")
 			.header(ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS, GET, POST")
 			.header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
 			.body(empty_body())?)
 	}
 	async fn handle_check_domain(
 		&self,
 		req: Request<IncomingBody>,
 	) -> Result<Response<ResBody>, Error> {
 		let query_params: HashMap<String, String> = req
 			.uri()
 			.query()
 			.map(|v| {
 				url::form_urlencoded::parse(v.as_bytes())
 					.into_owned()
 					.collect()
 			})
 			.unwrap_or_else(HashMap::new);
 		let has_domain_key = query_params.contains_key("domain");
 		if !has_domain_key {
 			return Err(Error::bad_request("No domain query string found"));
 		}
 		let domain = query_params
 			.get("domain")
 			.ok_or_internal_error("Could not parse domain query string")?;
 		if self.check_domain(domain).await? {
 			Ok(Response::builder()
 				.status(StatusCode::OK)
 				.body(string_body(format!(
 					"Domain '{domain}' is managed by Garage"
 				)))?)
 		} else {
 			Err(Error::bad_request(format!(
 				"Domain '{domain}' is not managed by Garage"
 			)))
 		}
 	}
 	async fn check_domain(&self, domain: &str) -> Result<bool, Error> {
 		// Resolve bucket from domain name, inferring if the website must be activated for the
 		// domain to be valid.
 		let (bucket_name, must_check_website) = if let Some(bname) = self
 			.garage
 			.config
 			.s3_api
 			.root_domain
 			.as_ref()
 			.and_then(|rd| host_to_bucket(domain, rd))
 		{
 			(bname.to_string(), false)
 		} else if let Some(bname) = self
 			.garage
 			.config
 			.s3_web
 			.as_ref()
 			.and_then(|sw| host_to_bucket(domain, sw.root_domain.as_str()))
 		{
 			(bname.to_string(), true)
 		} else {
 			(domain.to_string(), true)
 		};
 		let bucket_id = match self
 			.garage
 			.bucket_helper()
 			.resolve_global_bucket_name(&bucket_name)
 			.await?
 		{
 			Some(bucket_id) => bucket_id,
 			None => return Ok(false),
 		};
 		if !must_check_website {
 			return Ok(true);
 		}
 		let bucket = self
 			.garage
 			.bucket_helper()
 			.get_existing_bucket(bucket_id)
 			.await?;
 		let bucket_state = bucket.state.as_option().unwrap();
 		let bucket_website_config = bucket_state.website_config.get();
 		match bucket_website_config {
 			Some(_v) => Ok(true),
 			None => Ok(false),
 		}
 	}
 	fn handle_health(&self) -> Result<Response<ResBody>, Error> {
 		let health = self.garage.system.health();
 		let (status, status_str) = match health.status {
 			ClusterHealthStatus::Healthy => (StatusCode::OK, "Garage is fully operational"),
 			ClusterHealthStatus::Degraded => (
 				StatusCode::OK,
 				"Garage is operational but some storage nodes are unavailable",
 			),
 			ClusterHealthStatus::Unavailable => (
 				StatusCode::SERVICE_UNAVAILABLE,
 				"Quorum is not available for some/all partitions, reads and writes will fail",
 			),
 		};
 		let status_str = format!(
 			"{}\nConsult the full health check API endpoint at /v1/health for more details\n",
 			status_str
 		);
 		Ok(Response::builder()
 			.status(status)
 			.header(http::header::CONTENT_TYPE, "text/plain")
 			.body(string_body(status_str))?)
 	}
 	fn handle_metrics(&self) -> Result<Response<ResBody>, Error> {
 		#[cfg(feature = "metrics")]
 		{
@ -232,9 +112,13 @@ impl ApiHandler for AdminApiServer {
 	fn parse_endpoint(&self, req: &Request<IncomingBody>) -> Result<Endpoint, Error> {
 		if req.uri().path().starts_with("/v0/") {
 			let endpoint_v0 = router_v0::Endpoint::from_request(req)?;
-			Endpoint::from_v0(endpoint_v0)
+			let endpoint_v1 = router_v1::Endpoint::from_v0(endpoint_v0)?;
 			Ok(Endpoint::Old(endpoint_v1))
 		} else if req.uri().path().starts_with("/v1/") {
 			let endpoint_v1 = router_v1::Endpoint::from_request(req)?;
 			Ok(Endpoint::Old(endpoint_v1))
 		} else {
-			Endpoint::from_request(req)
+			Ok(Endpoint::New(req.uri().path().to_string()))
 		}
 	}
@ -243,8 +127,15 @@ impl ApiHandler for AdminApiServer {
 		req: Request<IncomingBody>,
 		endpoint: Endpoint,
 	) -> Result<Response<ResBody>, Error> {
 		let auth_header = req.headers().get(AUTHORIZATION).cloned();
 		let request = match endpoint {
 			Endpoint::Old(endpoint_v1) => AdminApiRequest::from_v1(endpoint_v1, req).await?,
 			Endpoint::New(_) => AdminApiRequest::from_request(req).await?,
 		};
 		let required_auth_hash =
-			match endpoint.authorization_type() {
+			match request.authorization_type() {
 				Authorization::None => None,
 				Authorization::MetricsToken => self.metrics_token.as_deref(),
 				Authorization::AdminToken => match self.admin_token.as_deref() {
@ -256,7 +147,7 @@ impl ApiHandler for AdminApiServer {
 			};
 		if let Some(password_hash) = required_auth_hash {
-			match req.headers().get("Authorization") {
+			match auth_header {
 				None => return Err(Error::forbidden("Authorization token must be provided")),
 				Some(authorization) => {
 					verify_bearer_token(&authorization, password_hash)?;
@ -264,72 +155,28 @@ impl ApiHandler for AdminApiServer {
 			}
 		}
-		match endpoint {
+		match request {
-			Endpoint::Options => self.handle_options(&req),
+			AdminApiRequest::Options(req) => req.handle(&self.garage).await,
-			Endpoint::CheckDomain => self.handle_check_domain(req).await,
+			AdminApiRequest::CheckDomain(req) => req.handle(&self.garage).await,
-			Endpoint::Health => self.handle_health(),
+			AdminApiRequest::Health(req) => req.handle(&self.garage).await,
-			Endpoint::Metrics => self.handle_metrics(),
+			AdminApiRequest::Metrics(_req) => self.handle_metrics(),
-			Endpoint::GetClusterStatus => handle_get_cluster_status(&self.garage).await,
+			req => {
-			Endpoint::GetClusterHealth => handle_get_cluster_health(&self.garage).await,
+				let res = req.handle(&self.garage).await?;
-			Endpoint::ConnectClusterNodes => handle_connect_cluster_nodes(&self.garage, req).await,
+				let mut res = json_ok_response(&res)?;
-			// Layout
+				res.headers_mut()
-			Endpoint::GetClusterLayout => handle_get_cluster_layout(&self.garage).await,
+					.insert(ACCESS_CONTROL_ALLOW_ORIGIN, HeaderValue::from_static("*"));
-			Endpoint::UpdateClusterLayout => handle_update_cluster_layout(&self.garage, req).await,
+				Ok(res)
 			Endpoint::ApplyClusterLayout => handle_apply_cluster_layout(&self.garage, req).await,
 			Endpoint::RevertClusterLayout => handle_revert_cluster_layout(&self.garage).await,
 			// Keys
 			Endpoint::ListKeys => handle_list_keys(&self.garage).await,
 			Endpoint::GetKeyInfo {
 				id,
 				search,
 				show_secret_key,
 			} => {
 				let show_secret_key = show_secret_key.map(|x| x == "true").unwrap_or(false);
 				handle_get_key_info(&self.garage, id, search, show_secret_key).await
 			}
 			Endpoint::CreateKey => handle_create_key(&self.garage, req).await,
 			Endpoint::ImportKey => handle_import_key(&self.garage, req).await,
 			Endpoint::UpdateKey { id } => handle_update_key(&self.garage, id, req).await,
 			Endpoint::DeleteKey { id } => handle_delete_key(&self.garage, id).await,
 			// Buckets
 			Endpoint::ListBuckets => handle_list_buckets(&self.garage).await,
 			Endpoint::GetBucketInfo { id, global_alias } => {
 				handle_get_bucket_info(&self.garage, id, global_alias).await
 			}
 			Endpoint::CreateBucket => handle_create_bucket(&self.garage, req).await,
 			Endpoint::DeleteBucket { id } => handle_delete_bucket(&self.garage, id).await,
 			Endpoint::UpdateBucket { id } => handle_update_bucket(&self.garage, id, req).await,
 			// Bucket-key permissions
 			Endpoint::BucketAllowKey => {
 				handle_bucket_change_key_perm(&self.garage, req, true).await
 			}
 			Endpoint::BucketDenyKey => {
 				handle_bucket_change_key_perm(&self.garage, req, false).await
 			}
 			// Bucket aliasing
 			Endpoint::GlobalAliasBucket { id, alias } => {
 				handle_global_alias_bucket(&self.garage, id, alias).await
 			}
 			Endpoint::GlobalUnaliasBucket { id, alias } => {
 				handle_global_unalias_bucket(&self.garage, id, alias).await
 			}
 			Endpoint::LocalAliasBucket {
 				id,
 				access_key_id,
 				alias,
 			} => handle_local_alias_bucket(&self.garage, id, access_key_id, alias).await,
 			Endpoint::LocalUnaliasBucket {
 				id,
 				access_key_id,
 				alias,
 			} => handle_local_unalias_bucket(&self.garage, id, access_key_id, alias).await,
 		}
 	}
 }
 impl ApiEndpoint for Endpoint {
-	fn name(&self) -> &'static str {
+	fn name(&self) -> Cow<'static, str> {
-		Endpoint::name(self)
+		match self {
 			Self::Old(endpoint_v1) => Cow::Borrowed(endpoint_v1.name()),
 			Self::New(path) => Cow::Owned(path.clone()),
 		}
 	}
 	fn add_span_attributes(&self, _span: SpanRef<'_>) {}
--- a/src/api/admin/bucket.rs
+++ b/src/api/admin/bucket.rs
@ -1,8 +1,7 @@
 use std::collections::HashMap;
 use std::sync::Arc;
-use hyper::{body::Incoming as IncomingBody, Request, Response, StatusCode};
+use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use garage_util::crdt::*;
 use garage_util::data::*;
@ -17,13 +16,16 @@ use garage_model::permission::*;
 use garage_model::s3::mpu_table;
 use garage_model::s3::object_table::*;
-use crate::admin::api_server::ResBody;
+use crate::admin::api::*;
 use crate::admin::error::*;
-use crate::admin::key::ApiBucketKeyPerm;
+use crate::admin::EndpointHandler;
 use crate::common_error::CommonError;
 use crate::helpers::*;
-pub async fn handle_list_buckets(garage: &Arc<Garage>) -> Result<Response<ResBody>, Error> {
+#[async_trait]
 impl EndpointHandler for ListBucketsRequest {
 	type Response = ListBucketsResponse;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<ListBucketsResponse, Error> {
 		let buckets = garage
 			.bucket_table
 			.get_range(
@ -39,7 +41,7 @@ pub async fn handle_list_buckets(garage: &Arc<Garage>) -> Result<Response<ResBod
 			.into_iter()
 			.map(|b| {
 				let state = b.state.as_option().unwrap();
-			ListBucketResultItem {
+				ListBucketsResponseItem {
 					id: hex::encode(b.id),
 					global_aliases: state
 						.aliases
@ -62,37 +64,16 @@ pub async fn handle_list_buckets(garage: &Arc<Garage>) -> Result<Response<ResBod
 			})
 			.collect::<Vec<_>>();
-	Ok(json_ok_response(&res)?)
+		Ok(ListBucketsResponse(res))
 	}
 }
-#[derive(Serialize)]
+#[async_trait]
-#[serde(rename_all = "camelCase")]
+impl EndpointHandler for GetBucketInfoRequest {
-struct ListBucketResultItem {
+	type Response = GetBucketInfoResponse;
 	id: String,
 	global_aliases: Vec<String>,
 	local_aliases: Vec<BucketLocalAlias>,
 }
-#[derive(Serialize)]
+	async fn handle(self, garage: &Arc<Garage>) -> Result<GetBucketInfoResponse, Error> {
-#[serde(rename_all = "camelCase")]
+		let bucket_id = match (self.id, self.global_alias) {
 struct BucketLocalAlias {
 	access_key_id: String,
 	alias: String,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct ApiBucketQuotas {
 	max_size: Option<u64>,
 	max_objects: Option<u64>,
 }
 pub async fn handle_get_bucket_info(
 	garage: &Arc<Garage>,
 	id: Option<String>,
 	global_alias: Option<String>,
 ) -> Result<Response<ResBody>, Error> {
 	let bucket_id = match (id, global_alias) {
 			(Some(id), None) => parse_bucket_id(&id)?,
 			(None, Some(ga)) => garage
 				.bucket_helper()
@ -108,11 +89,12 @@ pub async fn handle_get_bucket_info(
 		bucket_info_results(garage, bucket_id).await
 	}
 }
 async fn bucket_info_results(
 	garage: &Arc<Garage>,
 	bucket_id: Uuid,
-) -> Result<Response<ResBody>, Error> {
+) -> Result<GetBucketInfoResponse, Error> {
 	let bucket = garage
 		.bucket_helper()
 		.get_existing_bucket(bucket_id)
@ -175,8 +157,7 @@ async fn bucket_info_results(
 	let state = bucket.state.as_option().unwrap();
 	let quotas = state.quotas.get();
-	let res =
+	let res = GetBucketInfoResponse {
 		GetBucketInfoResult {
 		id: hex::encode(bucket.id),
 		global_aliases: state
 			.aliases
@ -187,7 +168,7 @@ async fn bucket_info_results(
 			.collect::<Vec<_>>(),
 		website_access: state.website_config.get().is_some(),
 		website_config: state.website_config.get().clone().map(|wsc| {
-				GetBucketInfoWebsiteResult {
+			GetBucketInfoWebsiteResponse {
 				index_document: wsc.index_document,
 				error_document: wsc.error_document,
 			}
@ -230,52 +211,17 @@ async fn bucket_info_results(
 		},
 	};
-	Ok(json_ok_response(&res)?)
+	Ok(res)
 }
-#[derive(Serialize)]
+#[async_trait]
-#[serde(rename_all = "camelCase")]
+impl EndpointHandler for CreateBucketRequest {
-struct GetBucketInfoResult {
+	type Response = CreateBucketResponse;
 	id: String,
 	global_aliases: Vec<String>,
 	website_access: bool,
 	#[serde(default)]
 	website_config: Option<GetBucketInfoWebsiteResult>,
 	keys: Vec<GetBucketInfoKey>,
 	objects: i64,
 	bytes: i64,
 	unfinished_uploads: i64,
 	unfinished_multipart_uploads: i64,
 	unfinished_multipart_upload_parts: i64,
 	unfinished_multipart_upload_bytes: i64,
 	quotas: ApiBucketQuotas,
 }
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct GetBucketInfoWebsiteResult {
 	index_document: String,
 	error_document: Option<String>,
 }
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct GetBucketInfoKey {
 	access_key_id: String,
 	name: String,
 	permissions: ApiBucketKeyPerm,
 	bucket_local_aliases: Vec<String>,
 }
 pub async fn handle_create_bucket(
 	garage: &Arc<Garage>,
 	req: Request<IncomingBody>,
 ) -> Result<Response<ResBody>, Error> {
 	let req = parse_json_body::<CreateBucketRequest, _, Error>(req).await?;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<CreateBucketResponse, Error> {
 		let helper = garage.locked_helper().await;
-	if let Some(ga) = &req.global_alias {
+		if let Some(ga) = &self.global_alias {
 			if !is_valid_bucket_name(ga) {
 				return Err(Error::bad_request(format!(
 					"{}: {}",
@ -290,7 +236,7 @@ pub async fn handle_create_bucket(
 			}
 		}
-	if let Some(la) = &req.local_alias {
+		if let Some(la) = &self.local_alias {
 			if !is_valid_bucket_name(&la.alias) {
 				return Err(Error::bad_request(format!(
 					"{}: {}",
@ -308,11 +254,11 @@ pub async fn handle_create_bucket(
 		let bucket = Bucket::new();
 		garage.bucket_table.insert(&bucket).await?;
-	if let Some(ga) = &req.global_alias {
+		if let Some(ga) = &self.global_alias {
 			helper.set_global_bucket_alias(bucket.id, ga).await?;
 		}
-	if let Some(la) = &req.local_alias {
+		if let Some(la) = &self.local_alias {
 			helper
 				.set_local_bucket_alias(bucket.id, &la.access_key_id, &la.alias)
 				.await?;
@ -333,32 +279,20 @@ pub async fn handle_create_bucket(
 			}
 		}
-	bucket_info_results(garage, bucket.id).await
+		Ok(CreateBucketResponse(
 			bucket_info_results(garage, bucket.id).await?,
 		))
 	}
 }
-#[derive(Deserialize)]
+#[async_trait]
-#[serde(rename_all = "camelCase")]
+impl EndpointHandler for DeleteBucketRequest {
-struct CreateBucketRequest {
+	type Response = DeleteBucketResponse;
 	global_alias: Option<String>,
 	local_alias: Option<CreateBucketLocalAlias>,
 }
-#[derive(Deserialize)]
+	async fn handle(self, garage: &Arc<Garage>) -> Result<DeleteBucketResponse, Error> {
 #[serde(rename_all = "camelCase")]
 struct CreateBucketLocalAlias {
 	access_key_id: String,
 	alias: String,
 	#[serde(default)]
 	allow: ApiBucketKeyPerm,
 }
 pub async fn handle_delete_bucket(
 	garage: &Arc<Garage>,
 	id: String,
 ) -> Result<Response<ResBody>, Error> {
 		let helper = garage.locked_helper().await;
-	let bucket_id = parse_bucket_id(&id)?;
+		let bucket_id = parse_bucket_id(&self.id)?;
 		let mut bucket = helper.bucket().get_existing_bucket(bucket_id).await?;
 		let state = bucket.state.as_option().unwrap();
@ -396,18 +330,16 @@ pub async fn handle_delete_bucket(
 		bucket.state = Deletable::delete();
 		garage.bucket_table.insert(&bucket).await?;
-	Ok(Response::builder()
+		Ok(DeleteBucketResponse)
-		.status(StatusCode::NO_CONTENT)
+	}
 		.body(empty_body())?)
 }
-pub async fn handle_update_bucket(
+#[async_trait]
-	garage: &Arc<Garage>,
+impl EndpointHandler for UpdateBucketRequest {
-	id: String,
+	type Response = UpdateBucketResponse;
-	req: Request<IncomingBody>,
+
-) -> Result<Response<ResBody>, Error> {
+	async fn handle(self, garage: &Arc<Garage>) -> Result<UpdateBucketResponse, Error> {
-	let req = parse_json_body::<UpdateBucketRequest, _, Error>(req).await?;
+		let bucket_id = parse_bucket_id(&self.id)?;
 	let bucket_id = parse_bucket_id(&id)?;
 		let mut bucket = garage
 			.bucket_helper()
@ -416,7 +348,7 @@ pub async fn handle_update_bucket(
 		let state = bucket.state.as_option_mut().unwrap();
-	if let Some(wa) = req.website_access {
+		if let Some(wa) = self.body.website_access {
 			if wa.enabled {
 				state.website_config.update(Some(WebsiteConfig {
 					index_document: wa.index_document.ok_or_bad_request(
@ -434,7 +366,7 @@ pub async fn handle_update_bucket(
 			}
 		}
-	if let Some(q) = req.quotas {
+		if let Some(q) = self.body.quotas {
 			state.quotas.update(BucketQuotas {
 				max_size: q.max_size,
 				max_objects: q.max_objects,
@ -443,33 +375,39 @@ pub async fn handle_update_bucket(
 		garage.bucket_table.insert(&bucket).await?;
-	bucket_info_results(garage, bucket_id).await
+		Ok(UpdateBucketResponse(
 			bucket_info_results(garage, bucket_id).await?,
 		))
 	}
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct UpdateBucketRequest {
 	website_access: Option<UpdateBucketWebsiteAccess>,
 	quotas: Option<ApiBucketQuotas>,
 }
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct UpdateBucketWebsiteAccess {
 	enabled: bool,
 	index_document: Option<String>,
 	error_document: Option<String>,
 }
 // ---- BUCKET/KEY PERMISSIONS ----
 #[async_trait]
 impl EndpointHandler for AllowBucketKeyRequest {
 	type Response = AllowBucketKeyResponse;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<AllowBucketKeyResponse, Error> {
 		let res = handle_bucket_change_key_perm(garage, self.0, true).await?;
 		Ok(AllowBucketKeyResponse(res))
 	}
 }
 #[async_trait]
 impl EndpointHandler for DenyBucketKeyRequest {
 	type Response = DenyBucketKeyResponse;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<DenyBucketKeyResponse, Error> {
 		let res = handle_bucket_change_key_perm(garage, self.0, false).await?;
 		Ok(DenyBucketKeyResponse(res))
 	}
 }
 pub async fn handle_bucket_change_key_perm(
 	garage: &Arc<Garage>,
-	req: Request<IncomingBody>,
+	req: BucketKeyPermChangeRequest,
 	new_perm_flag: bool,
-) -> Result<Response<ResBody>, Error> {
+) -> Result<GetBucketInfoResponse, Error> {
 	let req = parse_json_body::<BucketKeyPermChangeRequest, _, Error>(req).await?;
 	let helper = garage.locked_helper().await;
 	let bucket_id = parse_bucket_id(&req.bucket_id)?;
@ -502,76 +440,68 @@ pub async fn handle_bucket_change_key_perm(
 	bucket_info_results(garage, bucket.id).await
 }
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct BucketKeyPermChangeRequest {
 	bucket_id: String,
 	access_key_id: String,
 	permissions: ApiBucketKeyPerm,
 }
 // ---- BUCKET ALIASES ----
-pub async fn handle_global_alias_bucket(
+#[async_trait]
-	garage: &Arc<Garage>,
+impl EndpointHandler for AddBucketAliasRequest {
-	bucket_id: String,
+	type Response = AddBucketAliasResponse;
-	alias: String,
+
-) -> Result<Response<ResBody>, Error> {
+	async fn handle(self, garage: &Arc<Garage>) -> Result<AddBucketAliasResponse, Error> {
-	let bucket_id = parse_bucket_id(&bucket_id)?;
+		let bucket_id = parse_bucket_id(&self.bucket_id)?;
 	let helper = garage.locked_helper().await;
 	helper.set_global_bucket_alias(bucket_id, &alias).await?;
 	bucket_info_results(garage, bucket_id).await
 }
 pub async fn handle_global_unalias_bucket(
 	garage: &Arc<Garage>,
 	bucket_id: String,
 	alias: String,
 ) -> Result<Response<ResBody>, Error> {
 	let bucket_id = parse_bucket_id(&bucket_id)?;
 	let helper = garage.locked_helper().await;
 	helper.unset_global_bucket_alias(bucket_id, &alias).await?;
 	bucket_info_results(garage, bucket_id).await
 }
 pub async fn handle_local_alias_bucket(
 	garage: &Arc<Garage>,
 	bucket_id: String,
 	access_key_id: String,
 	alias: String,
 ) -> Result<Response<ResBody>, Error> {
 	let bucket_id = parse_bucket_id(&bucket_id)?;
 		let helper = garage.locked_helper().await;
 		match self.alias {
 			BucketAliasEnum::Global { global_alias } => {
 				helper
-		.set_local_bucket_alias(bucket_id, &access_key_id, &alias)
+					.set_global_bucket_alias(bucket_id, &global_alias)
 					.await?;
-
+			}
-	bucket_info_results(garage, bucket_id).await
+			BucketAliasEnum::Local {
 				local_alias,
 				access_key_id,
 			} => {
 				helper
 					.set_local_bucket_alias(bucket_id, &access_key_id, &local_alias)
 					.await?;
 			}
 		}
-pub async fn handle_local_unalias_bucket(
+		Ok(AddBucketAliasResponse(
-	garage: &Arc<Garage>,
+			bucket_info_results(garage, bucket_id).await?,
-	bucket_id: String,
+		))
-	access_key_id: String,
+	}
-	alias: String,
+}
-) -> Result<Response<ResBody>, Error> {
+
-	let bucket_id = parse_bucket_id(&bucket_id)?;
+#[async_trait]
 impl EndpointHandler for RemoveBucketAliasRequest {
 	type Response = RemoveBucketAliasResponse;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<RemoveBucketAliasResponse, Error> {
 		let bucket_id = parse_bucket_id(&self.bucket_id)?;
 		let helper = garage.locked_helper().await;
 		match self.alias {
 			BucketAliasEnum::Global { global_alias } => {
 				helper
-		.unset_local_bucket_alias(bucket_id, &access_key_id, &alias)
+					.unset_global_bucket_alias(bucket_id, &global_alias)
 					.await?;
 			}
 			BucketAliasEnum::Local {
 				local_alias,
 				access_key_id,
 			} => {
 				helper
 					.unset_local_bucket_alias(bucket_id, &access_key_id, &local_alias)
 					.await?;
 			}
 		}
-	bucket_info_results(garage, bucket_id).await
+		Ok(RemoveBucketAliasResponse(
 			bucket_info_results(garage, bucket_id).await?,
 		))
 	}
 }
 // ---- HELPER ----
--- a/src/api/admin/cluster.rs
+++ b/src/api/admin/cluster.rs
@ -1,9 +1,7 @@
 use std::collections::HashMap;
 use std::net::SocketAddr;
 use std::sync::Arc;
-use hyper::{body::Incoming as IncomingBody, Request, Response};
+use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use garage_util::crdt::*;
 use garage_util::data::*;
@ -12,11 +10,15 @@ use garage_rpc::layout;
 use garage_model::garage::Garage;
-use crate::admin::api_server::ResBody;
+use crate::admin::api::*;
 use crate::admin::error::*;
-use crate::helpers::{json_ok_response, parse_json_body};
+use crate::admin::EndpointHandler;
-pub async fn handle_get_cluster_status(garage: &Arc<Garage>) -> Result<Response<ResBody>, Error> {
+#[async_trait]
 impl EndpointHandler for GetClusterStatusRequest {
 	type Response = GetClusterStatusResponse;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<GetClusterStatusResponse, Error> {
 		let layout = garage.system.cluster_layout();
 		let mut nodes = garage
 			.system
@ -31,12 +33,11 @@ pub async fn handle_get_cluster_status(garage: &Arc<Garage>) -> Result<Response<
 						hostname: i.status.hostname,
 						is_up: i.is_up,
 						last_seen_secs_ago: i.last_seen_secs_ago,
-					data_partition: i
+						data_partition: i.status.data_disk_avail.map(|(avail, total)| {
-						.status
+							FreeSpaceResp {
 						.data_disk_avail
 						.map(|(avail, total)| FreeSpaceResp {
 								available: avail,
 								total,
 							}
 						}),
 						metadata_partition: i.status.meta_disk_avail.map(|(avail, total)| {
 							FreeSpaceResp {
@ -102,28 +103,33 @@ pub async fn handle_get_cluster_status(garage: &Arc<Garage>) -> Result<Response<
 		let mut nodes = nodes.into_values().collect::<Vec<_>>();
 		nodes.sort_by(|x, y| x.id.cmp(&y.id));
-	let res = GetClusterStatusResponse {
+		Ok(GetClusterStatusResponse {
 			node: hex::encode(garage.system.id),
-		garage_version: garage_util::version::garage_version(),
+			garage_version: garage_util::version::garage_version().to_string(),
-		garage_features: garage_util::version::garage_features(),
+			garage_features: garage_util::version::garage_features()
-		rust_version: garage_util::version::rust_version(),
+				.map(|features| features.iter().map(ToString::to_string).collect()),
 			rust_version: garage_util::version::rust_version().to_string(),
 			db_engine: garage.db.engine(),
 			layout_version: layout.current().version,
 			nodes,
-	};
+		})
-
+	}
 	Ok(json_ok_response(&res)?)
 }
-pub async fn handle_get_cluster_health(garage: &Arc<Garage>) -> Result<Response<ResBody>, Error> {
+#[async_trait]
 impl EndpointHandler for GetClusterHealthRequest {
 	type Response = GetClusterHealthResponse;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<GetClusterHealthResponse, Error> {
 		use garage_rpc::system::ClusterHealthStatus;
 		let health = garage.system.health();
-	let health = ClusterHealth {
+		let health = GetClusterHealthResponse {
 			status: match health.status {
 				ClusterHealthStatus::Healthy => "healthy",
 				ClusterHealthStatus::Degraded => "degraded",
 				ClusterHealthStatus::Unavailable => "unavailable",
-		},
+			}
 			.to_string(),
 			known_nodes: health.known_nodes,
 			connected_nodes: health.connected_nodes,
 			storage_nodes: health.storage_nodes,
@ -132,37 +138,42 @@ pub async fn handle_get_cluster_health(garage: &Arc<Garage>) -> Result<Response<
 			partitions_quorum: health.partitions_quorum,
 			partitions_all_ok: health.partitions_all_ok,
 		};
-	Ok(json_ok_response(&health)?)
+		Ok(health)
 	}
 }
-pub async fn handle_connect_cluster_nodes(
+#[async_trait]
-	garage: &Arc<Garage>,
+impl EndpointHandler for ConnectClusterNodesRequest {
-	req: Request<IncomingBody>,
+	type Response = ConnectClusterNodesResponse;
 ) -> Result<Response<ResBody>, Error> {
 	let req = parse_json_body::<Vec<String>, _, Error>(req).await?;
-	let res = futures::future::join_all(req.iter().map(|node| garage.system.connect(node)))
+	async fn handle(self, garage: &Arc<Garage>) -> Result<ConnectClusterNodesResponse, Error> {
 		let res = futures::future::join_all(self.0.iter().map(|node| garage.system.connect(node)))
 			.await
 			.into_iter()
 			.map(|r| match r {
-			Ok(()) => ConnectClusterNodesResponse {
+				Ok(()) => ConnectNodeResponse {
 					success: true,
 					error: None,
 				},
-			Err(e) => ConnectClusterNodesResponse {
+				Err(e) => ConnectNodeResponse {
 					success: false,
 					error: Some(format!("{}", e)),
 				},
 			})
 			.collect::<Vec<_>>();
-
+		Ok(ConnectClusterNodesResponse(res))
-	Ok(json_ok_response(&res)?)
+	}
 }
-pub async fn handle_get_cluster_layout(garage: &Arc<Garage>) -> Result<Response<ResBody>, Error> {
+#[async_trait]
-	let res = format_cluster_layout(garage.system.cluster_layout().inner());
+impl EndpointHandler for GetClusterLayoutRequest {
 	type Response = GetClusterLayoutResponse;
-	Ok(json_ok_response(&res)?)
+	async fn handle(self, garage: &Arc<Garage>) -> Result<GetClusterLayoutResponse, Error> {
 		Ok(format_cluster_layout(
 			garage.system.cluster_layout().inner(),
 		))
 	}
 }
 fn format_cluster_layout(layout: &layout::LayoutHistory) -> GetClusterLayoutResponse {
@ -212,99 +223,19 @@ fn format_cluster_layout(layout: &layout::LayoutHistory) -> GetClusterLayoutResp
 // ----
 #[derive(Debug, Clone, Copy, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ClusterHealth {
 	status: &'static str,
 	known_nodes: usize,
 	connected_nodes: usize,
 	storage_nodes: usize,
 	storage_nodes_ok: usize,
 	partitions: usize,
 	partitions_quorum: usize,
 	partitions_all_ok: usize,
 }
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct GetClusterStatusResponse {
 	node: String,
 	garage_version: &'static str,
 	garage_features: Option<&'static [&'static str]>,
 	rust_version: &'static str,
 	db_engine: String,
 	layout_version: u64,
 	nodes: Vec<NodeResp>,
 }
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct ApplyClusterLayoutResponse {
 	message: Vec<String>,
 	layout: GetClusterLayoutResponse,
 }
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct ConnectClusterNodesResponse {
 	success: bool,
 	error: Option<String>,
 }
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct GetClusterLayoutResponse {
 	version: u64,
 	roles: Vec<NodeRoleResp>,
 	staged_role_changes: Vec<NodeRoleChange>,
 }
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct NodeRoleResp {
 	id: String,
 	zone: String,
 	capacity: Option<u64>,
 	tags: Vec<String>,
 }
 #[derive(Serialize, Default)]
 #[serde(rename_all = "camelCase")]
 struct FreeSpaceResp {
 	available: u64,
 	total: u64,
 }
 #[derive(Serialize, Default)]
 #[serde(rename_all = "camelCase")]
 struct NodeResp {
 	id: String,
 	role: Option<NodeRoleResp>,
 	addr: Option<SocketAddr>,
 	hostname: Option<String>,
 	is_up: bool,
 	last_seen_secs_ago: Option<u64>,
 	draining: bool,
 	#[serde(skip_serializing_if = "Option::is_none")]
 	data_partition: Option<FreeSpaceResp>,
 	#[serde(skip_serializing_if = "Option::is_none")]
 	metadata_partition: Option<FreeSpaceResp>,
 }
 // ---- update functions ----
-pub async fn handle_update_cluster_layout(
+#[async_trait]
-	garage: &Arc<Garage>,
+impl EndpointHandler for UpdateClusterLayoutRequest {
-	req: Request<IncomingBody>,
+	type Response = UpdateClusterLayoutResponse;
 ) -> Result<Response<ResBody>, Error> {
 	let updates = parse_json_body::<UpdateClusterLayoutRequest, _, Error>(req).await?;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<UpdateClusterLayoutResponse, Error> {
 		let mut layout = garage.system.cluster_layout().inner().clone();
 		let mut roles = layout.current().roles.clone();
 		roles.merge(&layout.staging.get().roles);
-	for change in updates {
+		for change in self.0 {
 			let node = hex::decode(&change.id).ok_or_bad_request("Invalid node identifier")?;
 			let node = Uuid::try_from(&node).ok_or_bad_request("Invalid node identifier")?;
@ -336,17 +267,17 @@ pub async fn handle_update_cluster_layout(
 			.await?;
 		let res = format_cluster_layout(&layout);
-	Ok(json_ok_response(&res)?)
+		Ok(UpdateClusterLayoutResponse(res))
 	}
 }
-pub async fn handle_apply_cluster_layout(
+#[async_trait]
-	garage: &Arc<Garage>,
+impl EndpointHandler for ApplyClusterLayoutRequest {
-	req: Request<IncomingBody>,
+	type Response = ApplyClusterLayoutResponse;
 ) -> Result<Response<ResBody>, Error> {
 	let param = parse_json_body::<ApplyLayoutRequest, _, Error>(req).await?;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<ApplyClusterLayoutResponse, Error> {
 		let layout = garage.system.cluster_layout().inner().clone();
-	let (layout, msg) = layout.apply_staged_changes(Some(param.version))?;
+		let (layout, msg) = layout.apply_staged_changes(Some(self.version))?;
 		garage
 			.system
@ -354,16 +285,18 @@ pub async fn handle_apply_cluster_layout(
 			.update_cluster_layout(&layout)
 			.await?;
-	let res = ApplyClusterLayoutResponse {
+		Ok(ApplyClusterLayoutResponse {
 			message: msg,
 			layout: format_cluster_layout(&layout),
-	};
+		})
-	Ok(json_ok_response(&res)?)
+	}
 }
-pub async fn handle_revert_cluster_layout(
+#[async_trait]
-	garage: &Arc<Garage>,
+impl EndpointHandler for RevertClusterLayoutRequest {
-) -> Result<Response<ResBody>, Error> {
+	type Response = RevertClusterLayoutResponse;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<RevertClusterLayoutResponse, Error> {
 		let layout = garage.system.cluster_layout().inner().clone();
 		let layout = layout.revert_staged_changes()?;
 		garage
@ -373,38 +306,6 @@ pub async fn handle_revert_cluster_layout(
 			.await?;
 		let res = format_cluster_layout(&layout);
-	Ok(json_ok_response(&res)?)
+		Ok(RevertClusterLayoutResponse(res))
 	}
 // ----
 type UpdateClusterLayoutRequest = Vec<NodeRoleChange>;
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct ApplyLayoutRequest {
 	version: u64,
 }
 // ----
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct NodeRoleChange {
 	id: String,
 	#[serde(flatten)]
 	action: NodeRoleChangeEnum,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(untagged)]
 enum NodeRoleChangeEnum {
 	#[serde(rename_all = "camelCase")]
 	Remove { remove: bool },
 	#[serde(rename_all = "camelCase")]
 	Update {
 		zone: String,
 		capacity: Option<u64>,
 		tags: Vec<String>,
 	},
 }
--- a/src/api/admin/key.rs
+++ b/src/api/admin/key.rs
@ -1,19 +1,22 @@
 use std::collections::HashMap;
 use std::sync::Arc;
-use hyper::{body::Incoming as IncomingBody, Request, Response, StatusCode};
+use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use garage_table::*;
 use garage_model::garage::Garage;
 use garage_model::key_table::*;
-use crate::admin::api_server::ResBody;
+use crate::admin::api::*;
 use crate::admin::error::*;
-use crate::helpers::*;
+use crate::admin::EndpointHandler;
-pub async fn handle_list_keys(garage: &Arc<Garage>) -> Result<Response<ResBody>, Error> {
+#[async_trait]
 impl EndpointHandler for ListKeysRequest {
 	type Response = ListKeysResponse;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<ListKeysResponse, Error> {
 		let res = garage
 			.key_table
 			.get_range(
@ -25,110 +28,96 @@ pub async fn handle_list_keys(garage: &Arc<Garage>) -> Result<Response<ResBody>,
 			)
 			.await?
 			.iter()
-		.map(|k| ListKeyResultItem {
+			.map(|k| ListKeysResponseItem {
 				id: k.key_id.to_string(),
 				name: k.params().unwrap().name.get().clone(),
 			})
 			.collect::<Vec<_>>();
-	Ok(json_ok_response(&res)?)
+		Ok(ListKeysResponse(res))
 	}
 }
-#[derive(Serialize)]
+#[async_trait]
-#[serde(rename_all = "camelCase")]
+impl EndpointHandler for GetKeyInfoRequest {
-struct ListKeyResultItem {
+	type Response = GetKeyInfoResponse;
 	id: String,
 	name: String,
 }
-pub async fn handle_get_key_info(
+	async fn handle(self, garage: &Arc<Garage>) -> Result<GetKeyInfoResponse, Error> {
-	garage: &Arc<Garage>,
+		let key = match (self.id, self.search) {
-	id: Option<String>,
+			(Some(id), None) => garage.key_helper().get_existing_key(&id).await?,
-	search: Option<String>,
+			(None, Some(search)) => {
 	show_secret_key: bool,
 ) -> Result<Response<ResBody>, Error> {
 	let key = if let Some(id) = id {
 		garage.key_helper().get_existing_key(&id).await?
 	} else if let Some(search) = search {
 				garage
 					.key_helper()
 					.get_existing_matching_key(&search)
 					.await?
-	} else {
+			}
-		unreachable!();
+			_ => {
 				return Err(Error::bad_request(
 					"Either id or search must be provided (but not both)",
 				));
 			}
 		};
-	key_info_results(garage, key, show_secret_key).await
+		Ok(key_info_results(garage, key, self.show_secret_key).await?)
 	}
 }
-pub async fn handle_create_key(
+#[async_trait]
-	garage: &Arc<Garage>,
+impl EndpointHandler for CreateKeyRequest {
-	req: Request<IncomingBody>,
+	type Response = CreateKeyResponse;
 ) -> Result<Response<ResBody>, Error> {
 	let req = parse_json_body::<CreateKeyRequest, _, Error>(req).await?;
-	let key = Key::new(req.name.as_deref().unwrap_or("Unnamed key"));
+	async fn handle(self, garage: &Arc<Garage>) -> Result<CreateKeyResponse, Error> {
 		let key = Key::new(self.name.as_deref().unwrap_or("Unnamed key"));
 		garage.key_table.insert(&key).await?;
-	key_info_results(garage, key, true).await
+		Ok(CreateKeyResponse(
 			key_info_results(garage, key, true).await?,
 		))
 	}
 }
-#[derive(Deserialize)]
+#[async_trait]
-#[serde(rename_all = "camelCase")]
+impl EndpointHandler for ImportKeyRequest {
-struct CreateKeyRequest {
+	type Response = ImportKeyResponse;
 	name: Option<String>,
 }
-pub async fn handle_import_key(
+	async fn handle(self, garage: &Arc<Garage>) -> Result<ImportKeyResponse, Error> {
-	garage: &Arc<Garage>,
+		let prev_key = garage.key_table.get(&EmptyKey, &self.access_key_id).await?;
 	req: Request<IncomingBody>,
 ) -> Result<Response<ResBody>, Error> {
 	let req = parse_json_body::<ImportKeyRequest, _, Error>(req).await?;
 	let prev_key = garage.key_table.get(&EmptyKey, &req.access_key_id).await?;
 		if prev_key.is_some() {
-		return Err(Error::KeyAlreadyExists(req.access_key_id.to_string()));
+			return Err(Error::KeyAlreadyExists(self.access_key_id.to_string()));
 		}
 		let imported_key = Key::import(
-		&req.access_key_id,
+			&self.access_key_id,
-		&req.secret_access_key,
+			&self.secret_access_key,
-		req.name.as_deref().unwrap_or("Imported key"),
+			self.name.as_deref().unwrap_or("Imported key"),
 		)
 		.ok_or_bad_request("Invalid key format")?;
 		garage.key_table.insert(&imported_key).await?;
-	key_info_results(garage, imported_key, false).await
+		Ok(ImportKeyResponse(
 			key_info_results(garage, imported_key, false).await?,
 		))
 	}
 }
-#[derive(Deserialize)]
+#[async_trait]
-#[serde(rename_all = "camelCase")]
+impl EndpointHandler for UpdateKeyRequest {
-struct ImportKeyRequest {
+	type Response = UpdateKeyResponse;
 	access_key_id: String,
 	secret_access_key: String,
 	name: Option<String>,
 }
-pub async fn handle_update_key(
+	async fn handle(self, garage: &Arc<Garage>) -> Result<UpdateKeyResponse, Error> {
-	garage: &Arc<Garage>,
+		let mut key = garage.key_helper().get_existing_key(&self.id).await?;
 	id: String,
 	req: Request<IncomingBody>,
 ) -> Result<Response<ResBody>, Error> {
 	let req = parse_json_body::<UpdateKeyRequest, _, Error>(req).await?;
 	let mut key = garage.key_helper().get_existing_key(&id).await?;
 		let key_state = key.state.as_option_mut().unwrap();
-	if let Some(new_name) = req.name {
+		if let Some(new_name) = self.body.name {
 			key_state.name.update(new_name);
 		}
-	if let Some(allow) = req.allow {
+		if let Some(allow) = self.body.allow {
 			if allow.create_bucket {
 				key_state.allow_create_bucket.update(true);
 			}
 		}
-	if let Some(deny) = req.deny {
+		if let Some(deny) = self.body.deny {
 			if deny.create_bucket {
 				key_state.allow_create_bucket.update(false);
 			}
@ -136,37 +125,32 @@ pub async fn handle_update_key(
 		garage.key_table.insert(&key).await?;
-	key_info_results(garage, key, false).await
+		Ok(UpdateKeyResponse(
 			key_info_results(garage, key, false).await?,
 		))
 	}
 }
-#[derive(Deserialize)]
+#[async_trait]
-#[serde(rename_all = "camelCase")]
+impl EndpointHandler for DeleteKeyRequest {
-struct UpdateKeyRequest {
+	type Response = DeleteKeyResponse;
 	name: Option<String>,
 	allow: Option<KeyPerm>,
 	deny: Option<KeyPerm>,
 }
-pub async fn handle_delete_key(
+	async fn handle(self, garage: &Arc<Garage>) -> Result<DeleteKeyResponse, Error> {
 	garage: &Arc<Garage>,
 	id: String,
 ) -> Result<Response<ResBody>, Error> {
 		let helper = garage.locked_helper().await;
-	let mut key = helper.key().get_existing_key(&id).await?;
+		let mut key = helper.key().get_existing_key(&self.id).await?;
 		helper.delete_key(&mut key).await?;
-	Ok(Response::builder()
+		Ok(DeleteKeyResponse)
-		.status(StatusCode::NO_CONTENT)
+	}
 		.body(empty_body())?)
 }
 async fn key_info_results(
 	garage: &Arc<Garage>,
 	key: Key,
 	show_secret: bool,
-) -> Result<Response<ResBody>, Error> {
+) -> Result<GetKeyInfoResponse, Error> {
 	let mut relevant_buckets = HashMap::new();
 	let key_state = key.state.as_option().unwrap();
@ -192,7 +176,7 @@ async fn key_info_results(
 		}
 	}
-	let res = GetKeyInfoResult {
+	let res = GetKeyInfoResponse {
 		name: key_state.name.get().clone(),
 		access_key_id: key.key_id.clone(),
 		secret_access_key: if show_secret {
@ -207,7 +191,7 @@ async fn key_info_results(
 			.into_values()
 			.map(|bucket| {
 				let state = bucket.state.as_option().unwrap();
-				KeyInfoBucketResult {
+				KeyInfoBucketResponse {
 					id: hex::encode(bucket.id),
 					global_aliases: state
 						.aliases
@ -237,43 +221,5 @@ async fn key_info_results(
 			.collect::<Vec<_>>(),
 	};
-	Ok(json_ok_response(&res)?)
+	Ok(res)
 }
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct GetKeyInfoResult {
 	name: String,
 	access_key_id: String,
 	#[serde(skip_serializing_if = "is_default")]
 	secret_access_key: Option<String>,
 	permissions: KeyPerm,
 	buckets: Vec<KeyInfoBucketResult>,
 }
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct KeyPerm {
 	#[serde(default)]
 	create_bucket: bool,
 }
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 struct KeyInfoBucketResult {
 	id: String,
 	global_aliases: Vec<String>,
 	local_aliases: Vec<String>,
 	permissions: ApiBucketKeyPerm,
 }
 #[derive(Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct ApiBucketKeyPerm {
 	#[serde(default)]
 	pub(crate) read: bool,
 	#[serde(default)]
 	pub(crate) write: bool,
 	#[serde(default)]
 	pub(crate) owner: bool,
 }
--- a/src/api/admin/macros.rs
+++ b/src/api/admin/macros.rs
@ -0,0 +1,76 @@
 macro_rules! admin_endpoints {
    [
        $(@special $special_endpoint:ident,)*
        $($endpoint:ident,)*
    ] => {
        paste! {
            #[derive(Serialize, Deserialize)]
            pub enum AdminApiRequest {
                $(
                    $special_endpoint( [<$special_endpoint Request>] ),
                )*
                $(
                    $endpoint( [<$endpoint Request>] ),
                )*
            }
            #[derive(Serialize)]
            #[serde(untagged)]
            pub enum AdminApiResponse {
                $(
                    $endpoint( [<$endpoint Response>] ),
                )*
            }
            #[derive(Serialize, Deserialize)]
            pub enum TaggedAdminApiResponse {
                $(
                    $endpoint( [<$endpoint Response>] ),
                )*
            }
            impl AdminApiRequest {
                pub fn name(&self) -> &'static str {
                    match self {
                        $(
                            Self::$special_endpoint(_) => stringify!($special_endpoint),
                        )*
                        $(
                            Self::$endpoint(_) => stringify!($endpoint),
                        )*
                    }
                }
            }
            impl AdminApiResponse {
                fn tagged(self) -> TaggedAdminApiResponse {
                    match self {
                        $(
                            Self::$endpoint(res) => TaggedAdminApiResponse::$endpoint(res),
                        )*
                    }
                }
            }
            #[async_trait]
            impl EndpointHandler for AdminApiRequest {
                type Response = AdminApiResponse;
                async fn handle(self, garage: &Arc<Garage>) -> Result<AdminApiResponse, Error> {
                    Ok(match self {
                        $(
                            AdminApiRequest::$special_endpoint(_) => panic!(
                                concat!(stringify!($special_endpoint), " needs to go through a special handler")
                            ),
                        )*
                        $(
                            AdminApiRequest::$endpoint(req) => AdminApiResponse::$endpoint(req.handle(garage).await?),
                        )*
                    })
                }
            }
        }
    };
 }
 pub(crate) use admin_endpoints;
--- a/src/api/admin/mod.rs
+++ b/src/api/admin/mod.rs
@ -1,8 +1,32 @@
 pub mod api_server;
 mod error;
 mod macros;
 pub mod api;
 mod router_v0;
 mod router_v1;
 mod router_v2;
 mod bucket;
 mod cluster;
 mod key;
 mod special;
 use std::sync::Arc;
 use async_trait::async_trait;
 use garage_model::garage::Garage;
 pub enum Authorization {
 	None,
 	MetricsToken,
 	AdminToken,
 }
 #[async_trait]
 pub trait EndpointHandler {
 	type Response;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<Self::Response, error::Error>;
 }
--- a/src/api/admin/router_v1.rs
+++ b/src/api/admin/router_v1.rs
@ -6,12 +6,6 @@ use crate::admin::error::*;
 use crate::admin::router_v0;
 use crate::router_macros::*;
 pub enum Authorization {
 	None,
 	MetricsToken,
 	AdminToken,
 }
 router_match! {@func
 /// List of all Admin API endpoints.
@ -210,15 +204,6 @@ impl Endpoint {
 			))),
 		}
 	}
 	/// Get the kind of authorization which is required to perform the operation.
 	pub fn authorization_type(&self) -> Authorization {
 		match self {
 			Self::Health => Authorization::None,
 			Self::CheckDomain => Authorization::None,
 			Self::Metrics => Authorization::MetricsToken,
 			_ => Authorization::AdminToken,
 		}
 	}
 }
 generateQueryParameters! {
--- a/src/api/admin/router_v2.rs
+++ b/src/api/admin/router_v2.rs
@ -0,0 +1,249 @@
 use std::borrow::Cow;
 use hyper::body::Incoming as IncomingBody;
 use hyper::{Method, Request};
 use paste::paste;
 use crate::admin::api::*;
 use crate::admin::error::*;
 use crate::admin::router_v1;
 use crate::admin::Authorization;
 use crate::helpers::*;
 use crate::router_macros::*;
 impl AdminApiRequest {
 	/// Determine which S3 endpoint a request is for using the request, and a bucket which was
 	/// possibly extracted from the Host header.
 	/// Returns Self plus bucket name, if endpoint is not Endpoint::ListBuckets
 	pub async fn from_request(req: Request<IncomingBody>) -> Result<Self, Error> {
 		let uri = req.uri().clone();
 		let path = uri.path();
 		let query = uri.query();
 		let method = req.method().clone();
 		let mut query = QueryParameters::from_query(query.unwrap_or_default())?;
 		let res = router_match!(@gen_path_parser_v2 (&method, path, "/v2/", query, req) [
 			@special OPTIONS _ => Options (),
 			@special GET "/check" => CheckDomain (query::domain),
 			@special GET "/health" => Health (),
 			@special GET "/metrics" => Metrics (),
 			// Cluster endpoints
 			GET GetClusterStatus (),
 			GET GetClusterHealth (),
 			POST ConnectClusterNodes (body),
 			// Layout endpoints
 			GET GetClusterLayout (),
 			POST UpdateClusterLayout (body),
 			POST ApplyClusterLayout (body),
 			POST RevertClusterLayout (),
 			// API key endpoints
 			GET GetKeyInfo (query_opt::id, query_opt::search, parse_default(false)::show_secret_key),
 			POST UpdateKey (body_field, query::id),
 			POST CreateKey (body),
 			POST ImportKey (body),
 			POST DeleteKey (query::id),
 			GET ListKeys (),
 			// Bucket endpoints
 			GET GetBucketInfo (query_opt::id, query_opt::global_alias),
 			GET ListBuckets (),
 			POST CreateBucket (body),
 			POST DeleteBucket (query::id),
 			POST UpdateBucket (body_field, query::id),
 			// Bucket-key permissions
 			POST AllowBucketKey (body),
 			POST DenyBucketKey (body),
 			// Bucket aliases
 			POST AddBucketAlias (body),
 			POST RemoveBucketAlias (body),
 		]);
 		if let Some(message) = query.nonempty_message() {
 			debug!("Unused query parameter: {}", message)
 		}
 		Ok(res)
 	}
 	/// Some endpoints work exactly the same in their v2/ version as they did in their v1/ version.
 	/// For these endpoints, we can convert a v1/ call to its equivalent as if it was made using
 	/// its v2/ URL.
 	pub async fn from_v1(
 		v1_endpoint: router_v1::Endpoint,
 		req: Request<IncomingBody>,
 	) -> Result<Self, Error> {
 		use router_v1::Endpoint;
 		match v1_endpoint {
 			Endpoint::GetClusterStatus => {
 				Ok(AdminApiRequest::GetClusterStatus(GetClusterStatusRequest))
 			}
 			Endpoint::GetClusterHealth => {
 				Ok(AdminApiRequest::GetClusterHealth(GetClusterHealthRequest))
 			}
 			Endpoint::ConnectClusterNodes => {
 				let req = parse_json_body::<ConnectClusterNodesRequest, _, Error>(req).await?;
 				Ok(AdminApiRequest::ConnectClusterNodes(req))
 			}
 			// Layout
 			Endpoint::GetClusterLayout => {
 				Ok(AdminApiRequest::GetClusterLayout(GetClusterLayoutRequest))
 			}
 			Endpoint::UpdateClusterLayout => {
 				let updates = parse_json_body::<UpdateClusterLayoutRequest, _, Error>(req).await?;
 				Ok(AdminApiRequest::UpdateClusterLayout(updates))
 			}
 			Endpoint::ApplyClusterLayout => {
 				let param = parse_json_body::<ApplyClusterLayoutRequest, _, Error>(req).await?;
 				Ok(AdminApiRequest::ApplyClusterLayout(param))
 			}
 			Endpoint::RevertClusterLayout => Ok(AdminApiRequest::RevertClusterLayout(
 				RevertClusterLayoutRequest,
 			)),
 			// Keys
 			Endpoint::ListKeys => Ok(AdminApiRequest::ListKeys(ListKeysRequest)),
 			Endpoint::GetKeyInfo {
 				id,
 				search,
 				show_secret_key,
 			} => {
 				let show_secret_key = show_secret_key.map(|x| x == "true").unwrap_or(false);
 				Ok(AdminApiRequest::GetKeyInfo(GetKeyInfoRequest {
 					id,
 					search,
 					show_secret_key,
 				}))
 			}
 			Endpoint::CreateKey => {
 				let req = parse_json_body::<CreateKeyRequest, _, Error>(req).await?;
 				Ok(AdminApiRequest::CreateKey(req))
 			}
 			Endpoint::ImportKey => {
 				let req = parse_json_body::<ImportKeyRequest, _, Error>(req).await?;
 				Ok(AdminApiRequest::ImportKey(req))
 			}
 			Endpoint::UpdateKey { id } => {
 				let body = parse_json_body::<UpdateKeyRequestBody, _, Error>(req).await?;
 				Ok(AdminApiRequest::UpdateKey(UpdateKeyRequest { id, body }))
 			}
 			// DeleteKey semantics changed:
 			// - in v1/ : HTTP DELETE => HTTP 204 No Content
 			// - in v2/ : HTTP POST => HTTP 200 Ok
 			// Endpoint::DeleteKey { id } => Ok(AdminApiRequest::DeleteKey(DeleteKeyRequest { id })),
 			// Buckets
 			Endpoint::ListBuckets => Ok(AdminApiRequest::ListBuckets(ListBucketsRequest)),
 			Endpoint::GetBucketInfo { id, global_alias } => {
 				Ok(AdminApiRequest::GetBucketInfo(GetBucketInfoRequest {
 					id,
 					global_alias,
 				}))
 			}
 			Endpoint::CreateBucket => {
 				let req = parse_json_body::<CreateBucketRequest, _, Error>(req).await?;
 				Ok(AdminApiRequest::CreateBucket(req))
 			}
 			// DeleteBucket semantics changed::
 			// - in v1/ : HTTP DELETE => HTTP 204 No Content
 			// - in v2/ : HTTP POST => HTTP 200 Ok
 			// Endpoint::DeleteBucket { id } => {
 			// 	Ok(AdminApiRequest::DeleteBucket(DeleteBucketRequest { id }))
 			// }
 			Endpoint::UpdateBucket { id } => {
 				let body = parse_json_body::<UpdateBucketRequestBody, _, Error>(req).await?;
 				Ok(AdminApiRequest::UpdateBucket(UpdateBucketRequest {
 					id,
 					body,
 				}))
 			}
 			// Bucket-key permissions
 			Endpoint::BucketAllowKey => {
 				let req = parse_json_body::<BucketKeyPermChangeRequest, _, Error>(req).await?;
 				Ok(AdminApiRequest::AllowBucketKey(AllowBucketKeyRequest(req)))
 			}
 			Endpoint::BucketDenyKey => {
 				let req = parse_json_body::<BucketKeyPermChangeRequest, _, Error>(req).await?;
 				Ok(AdminApiRequest::DenyBucketKey(DenyBucketKeyRequest(req)))
 			}
 			// Bucket aliasing
 			Endpoint::GlobalAliasBucket { id, alias } => {
 				Ok(AdminApiRequest::AddBucketAlias(AddBucketAliasRequest {
 					bucket_id: id,
 					alias: BucketAliasEnum::Global {
 						global_alias: alias,
 					},
 				}))
 			}
 			Endpoint::GlobalUnaliasBucket { id, alias } => Ok(AdminApiRequest::RemoveBucketAlias(
 				RemoveBucketAliasRequest {
 					bucket_id: id,
 					alias: BucketAliasEnum::Global {
 						global_alias: alias,
 					},
 				},
 			)),
 			Endpoint::LocalAliasBucket {
 				id,
 				access_key_id,
 				alias,
 			} => Ok(AdminApiRequest::AddBucketAlias(AddBucketAliasRequest {
 				bucket_id: id,
 				alias: BucketAliasEnum::Local {
 					local_alias: alias,
 					access_key_id,
 				},
 			})),
 			Endpoint::LocalUnaliasBucket {
 				id,
 				access_key_id,
 				alias,
 			} => Ok(AdminApiRequest::RemoveBucketAlias(
 				RemoveBucketAliasRequest {
 					bucket_id: id,
 					alias: BucketAliasEnum::Local {
 						local_alias: alias,
 						access_key_id,
 					},
 				},
 			)),
 			// For endpoints that have different body content syntax, issue
 			// deprecation warning
 			_ => Err(Error::bad_request(format!(
 				"v1/ endpoint is no longer supported: {}",
 				v1_endpoint.name()
 			))),
 		}
 	}
 	/// Get the kind of authorization which is required to perform the operation.
 	pub fn authorization_type(&self) -> Authorization {
 		match self {
 			Self::Options(_) => Authorization::None,
 			Self::Health(_) => Authorization::None,
 			Self::CheckDomain(_) => Authorization::None,
 			Self::Metrics(_) => Authorization::MetricsToken,
 			_ => Authorization::AdminToken,
 		}
 	}
 }
 generateQueryParameters! {
 	keywords: [],
 	fields: [
 		"domain" => domain,
 		"format" => format,
 		"id" => id,
 		"search" => search,
 		"globalAlias" => global_alias,
 		"alias" => alias,
 		"accessKeyId" => access_key_id,
 		"showSecretKey" => show_secret_key
 	]
 }
--- a/src/api/admin/special.rs
+++ b/src/api/admin/special.rs
@ -0,0 +1,132 @@
 use std::sync::Arc;
 use async_trait::async_trait;
 use http::header::{
 	ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN, ALLOW,
 };
 use hyper::{Response, StatusCode};
 use garage_model::garage::Garage;
 use garage_rpc::system::ClusterHealthStatus;
 use crate::admin::api::{CheckDomainRequest, HealthRequest, OptionsRequest};
 use crate::admin::api_server::ResBody;
 use crate::admin::error::*;
 use crate::admin::EndpointHandler;
 use crate::helpers::*;
 #[async_trait]
 impl EndpointHandler for OptionsRequest {
 	type Response = Response<ResBody>;
 	async fn handle(self, _garage: &Arc<Garage>) -> Result<Response<ResBody>, Error> {
 		Ok(Response::builder()
 			.status(StatusCode::OK)
 			.header(ALLOW, "OPTIONS,GET,POST")
 			.header(ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS,GET,POST")
 			.header(ACCESS_CONTROL_ALLOW_HEADERS, "authorization,content-type")
 			.header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
 			.body(empty_body())?)
 	}
 }
 #[async_trait]
 impl EndpointHandler for CheckDomainRequest {
 	type Response = Response<ResBody>;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<Response<ResBody>, Error> {
 		if check_domain(garage, &self.domain).await? {
 			Ok(Response::builder()
 				.status(StatusCode::OK)
 				.body(string_body(format!(
 					"Domain '{}' is managed by Garage",
 					self.domain
 				)))?)
 		} else {
 			Err(Error::bad_request(format!(
 				"Domain '{}' is not managed by Garage",
 				self.domain
 			)))
 		}
 	}
 }
 async fn check_domain(garage: &Arc<Garage>, domain: &str) -> Result<bool, Error> {
 	// Resolve bucket from domain name, inferring if the website must be activated for the
 	// domain to be valid.
 	let (bucket_name, must_check_website) = if let Some(bname) = garage
 		.config
 		.s3_api
 		.root_domain
 		.as_ref()
 		.and_then(|rd| host_to_bucket(domain, rd))
 	{
 		(bname.to_string(), false)
 	} else if let Some(bname) = garage
 		.config
 		.s3_web
 		.as_ref()
 		.and_then(|sw| host_to_bucket(domain, sw.root_domain.as_str()))
 	{
 		(bname.to_string(), true)
 	} else {
 		(domain.to_string(), true)
 	};
 	let bucket_id = match garage
 		.bucket_helper()
 		.resolve_global_bucket_name(&bucket_name)
 		.await?
 	{
 		Some(bucket_id) => bucket_id,
 		None => return Ok(false),
 	};
 	if !must_check_website {
 		return Ok(true);
 	}
 	let bucket = garage
 		.bucket_helper()
 		.get_existing_bucket(bucket_id)
 		.await?;
 	let bucket_state = bucket.state.as_option().unwrap();
 	let bucket_website_config = bucket_state.website_config.get();
 	match bucket_website_config {
 		Some(_v) => Ok(true),
 		None => Ok(false),
 	}
 }
 #[async_trait]
 impl EndpointHandler for HealthRequest {
 	type Response = Response<ResBody>;
 	async fn handle(self, garage: &Arc<Garage>) -> Result<Response<ResBody>, Error> {
 		let health = garage.system.health();
 		let (status, status_str) = match health.status {
 			ClusterHealthStatus::Healthy => (StatusCode::OK, "Garage is fully operational"),
 			ClusterHealthStatus::Degraded => (
 				StatusCode::OK,
 				"Garage is operational but some storage nodes are unavailable",
 			),
 			ClusterHealthStatus::Unavailable => (
 				StatusCode::SERVICE_UNAVAILABLE,
 				"Quorum is not available for some/all partitions, reads and writes will fail",
 			),
 		};
 		let status_str = format!(
 			"{}\nConsult the full health check API endpoint at /v2/GetClusterHealth for more details\n",
 			status_str
 		);
 		Ok(Response::builder()
 			.status(status)
 			.header(http::header::CONTENT_TYPE, "text/plain")
 			.body(string_body(status_str))?)
 	}
 }
--- a/src/api/generic_server.rs
+++ b/src/api/generic_server.rs
@ -1,3 +1,4 @@
 use std::borrow::Cow;
 use std::convert::Infallible;
 use std::fs::{self, Permissions};
 use std::os::unix::fs::PermissionsExt;
@ -37,7 +38,7 @@ use garage_util::socket_address::UnixOrTCPSocketAddress;
 use crate::helpers::{BoxBody, ErrorBody};
 pub(crate) trait ApiEndpoint: Send + Sync + 'static {
-	fn name(&self) -> &'static str;
+	fn name(&self) -> Cow<'static, str>;
 	fn add_span_attributes(&self, span: SpanRef<'_>);
 }
--- a/src/api/k2v/api_server.rs
+++ b/src/api/k2v/api_server.rs
@ -1,3 +1,4 @@
 use std::borrow::Cow;
 use std::sync::Arc;
 use async_trait::async_trait;
@ -181,8 +182,8 @@ impl ApiHandler for K2VApiServer {
 }
 impl ApiEndpoint for K2VApiEndpoint {
-	fn name(&self) -> &'static str {
+	fn name(&self) -> Cow<'static, str> {
-		self.endpoint.name()
+		Cow::Borrowed(self.endpoint.name())
 	}
 	fn add_span_attributes(&self, span: SpanRef<'_>) {
--- a/src/api/router_macros.rs
+++ b/src/api/router_macros.rs
@ -44,6 +44,68 @@ macro_rules! router_match {
            }
        }
    }};
    (@gen_path_parser_v2 ($method:expr, $reqpath:expr, $pathprefix:literal, $query:expr, $req:expr)
     [
     $(@special $spec_meth:ident $spec_path:pat =>  $spec_api:ident $spec_params:tt,)*
     $($meth:ident $api:ident $params:tt,)*
     ]) => {{
        {
            #[allow(unused_parens)]
            match ($method, $reqpath) {
                $(
                    (&Method::$spec_meth, $spec_path) => AdminApiRequest::$spec_api (
                        router_match!(@@gen_parse_request $spec_api, $spec_params, $query, $req)
                    ),
                )*
                $(
                    (&Method::$meth, concat!($pathprefix, stringify!($api)))
                    => AdminApiRequest::$api (
                        router_match!(@@gen_parse_request $api, $params, $query, $req)
                        ),
                )*
                (m, p) => {
                    return Err(Error::bad_request(format!(
                        "Unknown API endpoint: {} {}",
                        m, p
                    )))
                }
            }
        }
    }};
    (@@gen_parse_request $api:ident, (), $query: expr, $req:expr) => {{
        paste!(
            [< $api Request >]
        )
    }};
    (@@gen_parse_request $api:ident, (body), $query: expr, $req:expr) => {{
        paste!({
            parse_json_body::< [<$api Request>], _, Error>($req).await?
        })
    }};
    (@@gen_parse_request $api:ident, (body_field, $($conv:ident $(($conv_arg:expr))? :: $param:ident),*), $query: expr, $req:expr)
        =>
    {{
        paste!({
            let body = parse_json_body::< [<$api RequestBody>], _, Error>($req).await?;
            [< $api Request >] {
                body,
                $(
                    $param: router_match!(@@parse_param $query, $conv $(($conv_arg))?, $param),
                )+
            }
        })
    }};
    (@@gen_parse_request $api:ident, ($($conv:ident $(($conv_arg:expr))? :: $param:ident),*), $query: expr, $req:expr)
        =>
    {{
        paste!({
            [< $api Request >] {
                $(
                    $param: router_match!(@@parse_param $query, $conv $(($conv_arg))?, $param),
                )+
            }
        })
    }};
    (@gen_parser ($keyword:expr, $key:ident, $query:expr, $header:expr),
        key: [$($kw_k:ident $(if $required_k:ident)? $(header $header_k:expr)? => $api_k:ident $(($($conv_k:ident :: $param_k:ident),*))?,)*],
        no_key: [$($kw_nk:ident $(if $required_nk:ident)? $(if_header $header_nk:expr)? => $api_nk:ident $(($($conv_nk:ident :: $param_nk:ident),*))?,)*]) => {{
@ -84,7 +146,10 @@ macro_rules! router_match {
    }};
    (@@parse_param $query:expr, query, $param:ident) => {{
        // extract mendatory query parameter
-        $query.$param.take().ok_or_bad_request("Missing argument for endpoint")?.into_owned()
+        $query.$param.take()
            .ok_or_bad_request(
                format!("Missing argument `{}` for endpoint", stringify!($param))
            )?.into_owned()
    }};
    (@@parse_param $query:expr, opt_parse, $param:ident) => {{
        // extract and parse optional query parameter
@ -98,10 +163,22 @@ macro_rules! router_match {
    (@@parse_param $query:expr, parse, $param:ident) => {{
        // extract and parse mandatory query parameter
        // both missing and un-parseable parameters are reported as errors
-        $query.$param.take().ok_or_bad_request("Missing argument for endpoint")?
+        $query.$param.take()
            .ok_or_bad_request(
                format!("Missing argument `{}` for endpoint", stringify!($param))
            )?
            .parse()
            .map_err(|_| Error::bad_request("Failed to parse query parameter"))?
    }};
    (@@parse_param $query:expr, parse_default($default:expr), $param:ident) => {{
        // extract and parse optional query parameter
        // using provided value as default if paramter is missing
        $query.$param.take().map(|x| x
            .parse()
            .map_err(|_| Error::bad_request("Failed to parse query parameter")))
            .transpose()?
            .unwrap_or($default)
    }};
    (@func
    $(#[$doc:meta])*
     pub enum Endpoint {
@ -185,6 +262,7 @@ macro_rules! generateQueryParameters {
                            },
                        )*
                        $(
                            // FIXME: remove if !v.is_empty() ?
                            $f_param => if !v.is_empty() {
                                if res.$f_name.replace(v).is_some() {
                                    return Err(Error::bad_request(format!(
--- a/src/api/s3/api_server.rs
+++ b/src/api/s3/api_server.rs
@ -1,3 +1,4 @@
 use std::borrow::Cow;
 use std::sync::Arc;
 use async_trait::async_trait;
@ -356,8 +357,8 @@ impl ApiHandler for S3ApiServer {
 }
 impl ApiEndpoint for S3ApiEndpoint {
-	fn name(&self) -> &'static str {
+	fn name(&self) -> Cow<'static, str> {
-		self.endpoint.name()
+		Cow::Borrowed(self.endpoint.name())
 	}
 	fn add_span_attributes(&self, span: SpanRef<'_>) {
--- a/src/garage/tests/s3/website.rs
+++ b/src/garage/tests/s3/website.rs
@ -427,12 +427,18 @@ async fn test_website_check_domain() {
 		res_body,
 		json!({
 			"code": "InvalidRequest",
-			"message": "Bad request: No domain query string found",
+			"message": "Bad request: Missing argument `domain` for endpoint",
 			"region": "garage-integ-test",
 			"path": "/check",
 		})
 	);
 	// FIXME: Edge case with empty domain
 	// Currently, empty domain is interpreted as an absent parameter
 	// due to logic in router_macros.rs, so this test fails.
 	// Maybe we want empty parameters to be acceptable? But that might
 	// break a lot of S3 stuff.
 	/*
 	let admin_req = || {
 		Request::builder()
 			.method("GET")
@ -456,6 +462,7 @@ async fn test_website_check_domain() {
 			"path": "/check",
 		})
 	);
 	*/
 	let admin_req = || {
 		Request::builder()