From af24b63cd374e95f5a3dac8378a41e6b0b675ba9 Mon Sep 17 00:00:00 2001 From: John Spray Date: Thu, 16 May 2024 09:26:55 +0100 Subject: [PATCH] s/top_n/top/ --- libs/pageserver_api/src/models.rs | 14 ++++++------ pageserver/client/src/mgmt_api.rs | 8 +++---- pageserver/src/http/routes.rs | 24 ++++++++++----------- pageserver/src/tenant.rs | 6 +++--- storage_controller/src/pageserver_client.rs | 12 +++++------ storage_controller/src/service.rs | 8 +++---- 6 files changed, 36 insertions(+), 36 deletions(-) diff --git a/libs/pageserver_api/src/models.rs b/libs/pageserver_api/src/models.rs index d76fcdec91..76dc0b5962 100644 --- a/libs/pageserver_api/src/models.rs +++ b/libs/pageserver_api/src/models.rs @@ -819,21 +819,21 @@ pub struct TenantScanRemoteStorageResponse { #[derive(Serialize, Deserialize, Debug, Clone)] #[serde(rename_all = "lowercase")] -pub enum TopNSorting { +pub enum TenantSorting { ResidentSize, MaxLogicalSize, } -impl Default for TopNSorting { +impl Default for TenantSorting { fn default() -> Self { Self::ResidentSize } } #[derive(Serialize, Deserialize, Debug, Clone)] -pub struct TopNTenantShardsRequest { +pub struct TopTenantShardsRequest { // How would you like to sort the tenants? - pub order_by: TopNSorting, + pub order_by: TenantSorting, // How many results? pub limit: usize, @@ -848,7 +848,7 @@ pub struct TopNTenantShardsRequest { } #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)] -pub struct TopNTenantShardItem { +pub struct TopTenantShardItem { pub id: TenantShardId, /// Total size of layers on local disk for all timelines in this tenant @@ -862,8 +862,8 @@ pub struct TopNTenantShardItem { } #[derive(Serialize, Deserialize, Debug, Default)] -pub struct TopNTenantShardsResponse { - pub shards: Vec, +pub struct TopTenantShardsResponse { + pub shards: Vec, } pub mod virtual_file { diff --git a/pageserver/client/src/mgmt_api.rs b/pageserver/client/src/mgmt_api.rs index d4470bd25f..5904713da9 100644 --- a/pageserver/client/src/mgmt_api.rs +++ b/pageserver/client/src/mgmt_api.rs @@ -486,11 +486,11 @@ impl Client { .map_err(Error::ReceiveBody) } - pub async fn top_n_tenant_shards( + pub async fn top_tenant_shards( &self, - request: TopNTenantShardsRequest, - ) -> Result { - let uri = format!("{}/v1/top_n_tenants", self.mgmt_api_endpoint); + request: TopTenantShardsRequest, + ) -> Result { + let uri = format!("{}/v1/top_tenants", self.mgmt_api_endpoint); self.request(Method::POST, uri, request) .await? .json() diff --git a/pageserver/src/http/routes.rs b/pageserver/src/http/routes.rs index f797b3229f..2469e2776d 100644 --- a/pageserver/src/http/routes.rs +++ b/pageserver/src/http/routes.rs @@ -26,11 +26,11 @@ use pageserver_api::models::TenantScanRemoteStorageShard; use pageserver_api::models::TenantShardLocation; use pageserver_api::models::TenantShardSplitRequest; use pageserver_api::models::TenantShardSplitResponse; +use pageserver_api::models::TenantSorting; use pageserver_api::models::TenantState; -use pageserver_api::models::TopNSorting; -use pageserver_api::models::TopNTenantShardItem; -use pageserver_api::models::TopNTenantShardsRequest; -use pageserver_api::models::TopNTenantShardsResponse; +use pageserver_api::models::TopTenantShardItem; +use pageserver_api::models::TopTenantShardsRequest; +use pageserver_api::models::TopTenantShardsResponse; use pageserver_api::models::{ DownloadRemoteLayersTaskSpawnRequest, LocationConfigMode, TenantAttachRequest, TenantLoadRequest, TenantLocationConfigRequest, @@ -2361,25 +2361,25 @@ async fn get_utilization( /// Report on the largest tenants on this pageserver, for the storage controller to identify /// candidates for splitting -async fn post_top_n_tenants( +async fn post_top_tenants( mut r: Request, _cancel: CancellationToken, ) -> Result, ApiError> { check_permission(&r, None)?; - let request: TopNTenantShardsRequest = json_request(&mut r).await?; + let request: TopTenantShardsRequest = json_request(&mut r).await?; let state = get_state(&r); - fn get_size_metric(sizes: &TopNTenantShardItem, order_by: &TopNSorting) -> u64 { + fn get_size_metric(sizes: &TopTenantShardItem, order_by: &TenantSorting) -> u64 { match order_by { - TopNSorting::ResidentSize => sizes.resident_size, - TopNSorting::MaxLogicalSize => sizes.max_logical_size, + TenantSorting::ResidentSize => sizes.resident_size, + TenantSorting::MaxLogicalSize => sizes.max_logical_size, } } #[derive(Eq, PartialEq)] struct HeapItem { metric: u64, - sizes: TopNTenantShardItem, + sizes: TopTenantShardItem, } impl PartialOrd for HeapItem { @@ -2444,7 +2444,7 @@ async fn post_top_n_tenants( json_response( StatusCode::OK, - TopNTenantShardsResponse { + TopTenantShardsResponse { shards: top_n.into_iter().map(|i| i.sizes).collect(), }, ) @@ -2736,6 +2736,6 @@ pub fn make_router( ) .put("/v1/io_engine", |r| api_handler(r, put_io_engine_handler)) .get("/v1/utilization", |r| api_handler(r, get_utilization)) - .post("/v1/top_n_tenants", |r| api_handler(r, post_top_n_tenants)) + .post("/v1/top_tenants", |r| api_handler(r, post_top_tenants)) .any(handler_404)) } diff --git a/pageserver/src/tenant.rs b/pageserver/src/tenant.rs index 340545e621..a38e1d56c9 100644 --- a/pageserver/src/tenant.rs +++ b/pageserver/src/tenant.rs @@ -21,7 +21,7 @@ use futures::FutureExt; use futures::StreamExt; use pageserver_api::models; use pageserver_api::models::TimelineState; -use pageserver_api::models::TopNTenantShardItem; +use pageserver_api::models::TopTenantShardItem; use pageserver_api::models::WalRedoManagerStatus; use pageserver_api::shard::ShardIdentity; use pageserver_api::shard::ShardStripeSize; @@ -2214,8 +2214,8 @@ impl Tenant { Ok(()) } - pub(crate) fn get_sizes(&self) -> TopNTenantShardItem { - let mut result = TopNTenantShardItem { + pub(crate) fn get_sizes(&self) -> TopTenantShardItem { + let mut result = TopTenantShardItem { id: self.tenant_shard_id, resident_size: 0, physical_size: 0, diff --git a/storage_controller/src/pageserver_client.rs b/storage_controller/src/pageserver_client.rs index 16f6861115..769aba80ca 100644 --- a/storage_controller/src/pageserver_client.rs +++ b/storage_controller/src/pageserver_client.rs @@ -2,7 +2,7 @@ use pageserver_api::{ models::{ LocationConfig, LocationConfigListResponse, PageserverUtilization, SecondaryProgress, TenantScanRemoteStorageResponse, TenantShardSplitRequest, TenantShardSplitResponse, - TimelineCreateRequest, TimelineInfo, TopNTenantShardsRequest, TopNTenantShardsResponse, + TimelineCreateRequest, TimelineInfo, TopTenantShardsRequest, TopTenantShardsResponse, }, shard::TenantShardId, }; @@ -235,15 +235,15 @@ impl PageserverClient { ) } - pub(crate) async fn top_n_tenant_shards( + pub(crate) async fn top_tenant_shards( &self, - request: TopNTenantShardsRequest, - ) -> Result { + request: TopTenantShardsRequest, + ) -> Result { measured_request!( - "top_n_tenants", + "top_tenants", crate::metrics::Method::Post, &self.node_id_label, - self.inner.top_n_tenant_shards(request).await + self.inner.top_tenant_shards(request).await ) } } diff --git a/storage_controller/src/service.rs b/storage_controller/src/service.rs index 865cd1f887..f914f4e0bb 100644 --- a/storage_controller/src/service.rs +++ b/storage_controller/src/service.rs @@ -32,7 +32,7 @@ use pageserver_api::{ TenantPolicyRequest, TenantShardMigrateRequest, TenantShardMigrateResponse, UtilizationScore, }, - models::{SecondaryProgress, TenantConfigRequest, TopNTenantShardsRequest}, + models::{SecondaryProgress, TenantConfigRequest, TopTenantShardsRequest}, }; use reqwest::StatusCode; use tracing::{instrument, Instrument}; @@ -4788,12 +4788,12 @@ impl Service { let mut top_n = Vec::new(); // Call into each node to look for big tenants - let top_n_request = TopNTenantShardsRequest { + let top_n_request = TopTenantShardsRequest { // We currently split based on logical size, for simplicity: logical size is a signal of // the user's intent to run a large database, whereas physical/resident size can be symptoms // of compaction issues. Eventually we should switch to using resident size to bound the // disk space impact of one shard. - order_by: models::TopNSorting::MaxLogicalSize, + order_by: models::TenantSorting::MaxLogicalSize, limit: 10, where_shards_lt: Some(SPLIT_TO_MAX), where_gt: Some(split_threshold), @@ -4804,7 +4804,7 @@ impl Service { .with_client_retries( |client| async move { let request = request_ref.clone(); - client.top_n_tenant_shards(request.clone()).await + client.top_tenant_shards(request.clone()).await }, &self.config.jwt_token, 3,