rust/neon
1
0
Fork 0
mirror of https://github.com/neondatabase/neon.git synced 2026-01-15 17:32:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

s/top_n/top/

Browse Source
This commit is contained in:
John Spray
2024-05-16 09:26:55 +01:00
parent df8d888d90
commit af24b63cd3
6 changed files with 36 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
libs/pageserver_api/src/models.rs
View File

@@ -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<TopNTenantShardItem>,
pub struct TopTenantShardsResponse {
pub shards: Vec<TopTenantShardItem>,
}
pub mod virtual_file {

8
pageserver/client/src/mgmt_api.rs
View File

@@ -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<TopNTenantShardsResponse> {
let uri = format!("{}/v1/top_n_tenants", self.mgmt_api_endpoint);
request: TopTenantShardsRequest,
) -> Result<TopTenantShardsResponse> {
let uri = format!("{}/v1/top_tenants", self.mgmt_api_endpoint);
self.request(Method::POST, uri, request)
.await?
.json()

24
pageserver/src/http/routes.rs
View File

@@ -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<Body>,
_cancel: CancellationToken,
) -> Result<Response<Body>, 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))
}

6
pageserver/src/tenant.rs
View File

@@ -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,

12
storage_controller/src/pageserver_client.rs
View File

@@ -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<TopNTenantShardsResponse> {
request: TopTenantShardsRequest,
) -> Result<TopTenantShardsResponse> {
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
)
}
}

8
storage_controller/src/service.rs
View File

@@ -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,