diff --git a/pageserver/src/tenant.rs b/pageserver/src/tenant.rs index 9f7e7ff451..ba8f6348ad 100644 --- a/pageserver/src/tenant.rs +++ b/pageserver/src/tenant.rs @@ -72,7 +72,6 @@ use crate::tenant::remote_timeline_client::index::IndexPart; use crate::tenant::remote_timeline_client::MaybeDeletedIndexPart; use crate::tenant::storage_layer::DeltaLayer; use crate::tenant::storage_layer::ImageLayer; -use crate::tenant::storage_layer::Layer; use crate::InitializationOrder; use crate::tenant::timeline::delete::DeleteTimelineFlow; diff --git a/pageserver/src/tenant/layer_map.rs b/pageserver/src/tenant/layer_map.rs index 59813b19d5..b8185da010 100644 --- a/pageserver/src/tenant/layer_map.rs +++ b/pageserver/src/tenant/layer_map.rs @@ -50,7 +50,6 @@ use crate::context::RequestContext; use crate::keyspace::KeyPartitioning; use crate::repository::Key; use crate::tenant::storage_layer::InMemoryLayer; -use crate::tenant::storage_layer::Layer; use anyhow::Result; use std::collections::VecDeque; use std::ops::Range; diff --git a/pageserver/src/tenant/storage_layer.rs b/pageserver/src/tenant/storage_layer.rs index 4107161aa1..ef40cb4258 100644 --- a/pageserver/src/tenant/storage_layer.rs +++ b/pageserver/src/tenant/storage_layer.rs @@ -344,23 +344,6 @@ impl LayerAccessStats { /// are used in (timeline). #[async_trait::async_trait] pub trait Layer: std::fmt::Debug + std::fmt::Display + Send + Sync + 'static { - /// Range of keys that this layer covers - fn get_key_range(&self) -> Range; - - /// Inclusive start bound of the LSN range that this layer holds - /// Exclusive end bound of the LSN range that this layer holds. - /// - /// - For an open in-memory layer, this is MAX_LSN. - /// - For a frozen in-memory layer or a delta layer, this is a valid end bound. - /// - An image layer represents snapshot at one LSN, so end_lsn is always the snapshot LSN + 1 - fn get_lsn_range(&self) -> Range; - - /// Does this layer only contain some data for the key-range (incremental), - /// or does it contain a version of every page? This is important to know - /// for garbage collecting old layers: an incremental layer depends on - /// the previous non-incremental layer. - fn is_incremental(&self) -> bool; - /// /// Return data needed to reconstruct given page at LSN. /// @@ -380,9 +363,6 @@ pub trait Layer: std::fmt::Debug + std::fmt::Display + Send + Sync + 'static { reconstruct_data: &mut ValueReconstructState, ctx: &RequestContext, ) -> Result; - - /// Dump summary of the contents of the layer to stdout - async fn dump(&self, verbose: bool, ctx: &RequestContext) -> Result<()>; } /// Get a layer descriptor from a layer. diff --git a/pageserver/src/tenant/storage_layer/delta_layer.rs b/pageserver/src/tenant/storage_layer/delta_layer.rs index 6094a7db52..620c3726a3 100644 --- a/pageserver/src/tenant/storage_layer/delta_layer.rs +++ b/pageserver/src/tenant/storage_layer/delta_layer.rs @@ -239,8 +239,54 @@ impl std::fmt::Debug for DeltaLayerInner { #[async_trait::async_trait] impl Layer for DeltaLayer { - /// debugging function to print out the contents of the layer - async fn dump(&self, verbose: bool, ctx: &RequestContext) -> Result<()> { + async fn get_value_reconstruct_data( + &self, + key: Key, + lsn_range: Range, + reconstruct_state: &mut ValueReconstructState, + ctx: &RequestContext, + ) -> anyhow::Result { + self.get_value_reconstruct_data(key, lsn_range, reconstruct_state, ctx) + .await + } +} +/// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. +impl std::fmt::Display for DeltaLayer { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.layer_desc().short_id()) + } +} + +impl AsLayerDesc for DeltaLayer { + fn layer_desc(&self) -> &PersistentLayerDesc { + &self.desc + } +} + +impl PersistentLayer for DeltaLayer { + fn downcast_delta_layer(self: Arc) -> Option> { + Some(self) + } + + fn local_path(&self) -> Option { + self.local_path() + } + + fn delete_resident_layer_file(&self) -> Result<()> { + self.delete_resident_layer_file() + } + + fn info(&self, reset: LayerAccessStatsReset) -> HistoricLayerInfo { + self.info(reset) + } + + fn access_stats(&self) -> &LayerAccessStats { + self.access_stats() + } +} + +impl DeltaLayer { + pub(crate) async fn dump(&self, verbose: bool, ctx: &RequestContext) -> Result<()> { println!( "----- delta layer for ten {} tli {} keys {}-{} lsn {}-{} size {} ----", self.desc.tenant_id, @@ -312,7 +358,7 @@ impl Layer for DeltaLayer { Ok(()) } - async fn get_value_reconstruct_data( + pub(crate) async fn get_value_reconstruct_data( &self, key: Key, lsn_range: Range, @@ -331,52 +377,19 @@ impl Layer for DeltaLayer { .await } - /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. - fn get_key_range(&self) -> Range { - self.layer_desc().key_range.clone() - } - - /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. - fn get_lsn_range(&self) -> Range { - self.layer_desc().lsn_range.clone() - } - - /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. - fn is_incremental(&self) -> bool { - self.layer_desc().is_incremental - } -} -/// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. -impl std::fmt::Display for DeltaLayer { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.layer_desc().short_id()) - } -} - -impl AsLayerDesc for DeltaLayer { - fn layer_desc(&self) -> &PersistentLayerDesc { - &self.desc - } -} - -impl PersistentLayer for DeltaLayer { - fn downcast_delta_layer(self: Arc) -> Option> { - Some(self) - } - - fn local_path(&self) -> Option { + pub(crate) fn local_path(&self) -> Option { Some(self.path()) } - fn delete_resident_layer_file(&self) -> Result<()> { + pub(crate) fn delete_resident_layer_file(&self) -> Result<()> { // delete underlying file fs::remove_file(self.path())?; Ok(()) } - fn info(&self, reset: LayerAccessStatsReset) -> HistoricLayerInfo { - let layer_file_name = self.filename().file_name(); - let lsn_range = self.get_lsn_range(); + pub(crate) fn info(&self, reset: LayerAccessStatsReset) -> HistoricLayerInfo { + let layer_file_name = self.layer_desc().filename().file_name(); + let lsn_range = self.layer_desc().lsn_range.clone(); let access_stats = self.access_stats.as_api_model(reset); @@ -390,12 +403,10 @@ impl PersistentLayer for DeltaLayer { } } - fn access_stats(&self) -> &LayerAccessStats { + pub(crate) fn access_stats(&self) -> &LayerAccessStats { &self.access_stats } -} -impl DeltaLayer { fn path_for( path_or_conf: &PathOrConf, tenant_id: &TenantId, diff --git a/pageserver/src/tenant/storage_layer/image_layer.rs b/pageserver/src/tenant/storage_layer/image_layer.rs index 3fe600e5ff..da5fabd83a 100644 --- a/pageserver/src/tenant/storage_layer/image_layer.rs +++ b/pageserver/src/tenant/storage_layer/image_layer.rs @@ -169,8 +169,52 @@ impl std::fmt::Debug for ImageLayerInner { #[async_trait::async_trait] impl Layer for ImageLayer { - /// debugging function to print out the contents of the layer - async fn dump(&self, verbose: bool, ctx: &RequestContext) -> Result<()> { + /// Look up given page in the file + async fn get_value_reconstruct_data( + &self, + key: Key, + lsn_range: Range, + reconstruct_state: &mut ValueReconstructState, + ctx: &RequestContext, + ) -> anyhow::Result { + self.get_value_reconstruct_data(key, lsn_range, reconstruct_state, ctx) + .await + } +} + +/// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. +impl std::fmt::Display for ImageLayer { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.layer_desc().short_id()) + } +} + +impl AsLayerDesc for ImageLayer { + fn layer_desc(&self) -> &PersistentLayerDesc { + &self.desc + } +} + +impl PersistentLayer for ImageLayer { + fn local_path(&self) -> Option { + self.local_path() + } + + fn delete_resident_layer_file(&self) -> Result<()> { + self.delete_resident_layer_file() + } + + fn info(&self, reset: LayerAccessStatsReset) -> HistoricLayerInfo { + self.info(reset) + } + + fn access_stats(&self) -> &LayerAccessStats { + self.access_stats() + } +} + +impl ImageLayer { + pub(crate) async fn dump(&self, verbose: bool, ctx: &RequestContext) -> Result<()> { println!( "----- image layer for ten {} tli {} key {}-{} at {} is_incremental {} size {} ----", self.desc.tenant_id, @@ -203,8 +247,7 @@ impl Layer for ImageLayer { Ok(()) } - /// Look up given page in the file - async fn get_value_reconstruct_data( + pub(crate) async fn get_value_reconstruct_data( &self, key: Key, lsn_range: Range, @@ -225,65 +268,33 @@ impl Layer for ImageLayer { .with_context(|| format!("read {}", self.path().display())) } - /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. - fn get_key_range(&self) -> Range { - self.layer_desc().key_range.clone() - } - - /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. - fn get_lsn_range(&self) -> Range { - self.layer_desc().lsn_range.clone() - } - - /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. - fn is_incremental(&self) -> bool { - self.layer_desc().is_incremental - } -} - -/// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. -impl std::fmt::Display for ImageLayer { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.layer_desc().short_id()) - } -} - -impl AsLayerDesc for ImageLayer { - fn layer_desc(&self) -> &PersistentLayerDesc { - &self.desc - } -} - -impl PersistentLayer for ImageLayer { - fn local_path(&self) -> Option { + pub(crate) fn local_path(&self) -> Option { Some(self.path()) } - fn delete_resident_layer_file(&self) -> Result<()> { + pub(crate) fn delete_resident_layer_file(&self) -> Result<()> { // delete underlying file fs::remove_file(self.path())?; Ok(()) } - fn info(&self, reset: LayerAccessStatsReset) -> HistoricLayerInfo { - let layer_file_name = self.filename().file_name(); - let lsn_range = self.get_lsn_range(); + pub(crate) fn info(&self, reset: LayerAccessStatsReset) -> HistoricLayerInfo { + let layer_file_name = self.layer_desc().filename().file_name(); + let lsn_start = self.layer_desc().image_layer_lsn(); HistoricLayerInfo::Image { layer_file_name, layer_file_size: self.desc.file_size, - lsn_start: lsn_range.start, + lsn_start, remote: false, access_stats: self.access_stats.as_api_model(reset), } } - fn access_stats(&self) -> &LayerAccessStats { + pub(crate) fn access_stats(&self) -> &LayerAccessStats { &self.access_stats } -} -impl ImageLayer { fn path_for( path_or_conf: &PathOrConf, timeline_id: TimelineId, diff --git a/pageserver/src/tenant/storage_layer/inmemory_layer.rs b/pageserver/src/tenant/storage_layer/inmemory_layer.rs index d3ec78887d..f8d47124cc 100644 --- a/pageserver/src/tenant/storage_layer/inmemory_layer.rs +++ b/pageserver/src/tenant/storage_layer/inmemory_layer.rs @@ -85,11 +85,11 @@ impl std::fmt::Debug for InMemoryLayerInner { } impl InMemoryLayer { - pub fn get_timeline_id(&self) -> TimelineId { + pub(crate) fn get_timeline_id(&self) -> TimelineId { self.timeline_id } - pub fn info(&self) -> InMemoryLayerInfo { + pub(crate) fn info(&self) -> InMemoryLayerInfo { let lsn_start = self.start_lsn; if let Some(&lsn_end) = self.end_lsn.get() { @@ -99,32 +99,22 @@ impl InMemoryLayer { } } - fn assert_writable(&self) { + pub(crate) fn assert_writable(&self) { assert!(self.end_lsn.get().is_none()); } - fn end_lsn_or_max(&self) -> Lsn { + pub(crate) fn end_lsn_or_max(&self) -> Lsn { self.end_lsn.get().copied().unwrap_or(Lsn::MAX) } -} -#[async_trait::async_trait] -impl Layer for InMemoryLayer { - fn get_key_range(&self) -> Range { - Key::MIN..Key::MAX - } - - fn get_lsn_range(&self) -> Range { + pub(crate) fn get_lsn_range(&self) -> Range { self.start_lsn..self.end_lsn_or_max() } - fn is_incremental(&self) -> bool { - // in-memory layer is always considered incremental. - true - } - /// debugging function to print out the contents of the layer - async fn dump(&self, verbose: bool, _ctx: &RequestContext) -> Result<()> { + /// + /// this is likely completly unused + pub async fn dump(&self, verbose: bool, _ctx: &RequestContext) -> Result<()> { let inner = self.inner.read().await; let end_str = self.end_lsn_or_max(); @@ -171,7 +161,7 @@ impl Layer for InMemoryLayer { } /// Look up given value in the layer. - async fn get_value_reconstruct_data( + pub(crate) async fn get_value_reconstruct_data( &self, key: Key, lsn_range: Range, @@ -221,6 +211,20 @@ impl Layer for InMemoryLayer { } } +#[async_trait::async_trait] +impl Layer for InMemoryLayer { + async fn get_value_reconstruct_data( + &self, + key: Key, + lsn_range: Range, + reconstruct_data: &mut ValueReconstructState, + ctx: &RequestContext, + ) -> Result { + self.get_value_reconstruct_data(key, lsn_range, reconstruct_data, ctx) + .await + } +} + impl std::fmt::Display for InMemoryLayer { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let end_lsn = self.end_lsn_or_max(); @@ -317,7 +321,7 @@ impl InMemoryLayer { /// Write this frozen in-memory layer to disk. /// /// Returns a new delta layer with all the same data as this in-memory layer - pub async fn write_to_disk(&self) -> Result { + pub(crate) async fn write_to_disk(&self) -> Result { // Grab the lock in read-mode. We hold it over the I/O, but because this // layer is not writeable anymore, no one should be trying to acquire the // write lock on it, so we shouldn't block anyone. There's one exception diff --git a/pageserver/src/tenant/storage_layer/layer_desc.rs b/pageserver/src/tenant/storage_layer/layer_desc.rs index 42c3925b73..030a88e806 100644 --- a/pageserver/src/tenant/storage_layer/layer_desc.rs +++ b/pageserver/src/tenant/storage_layer/layer_desc.rs @@ -19,16 +19,22 @@ use serde::{Deserialize, Serialize}; pub struct PersistentLayerDesc { pub tenant_id: TenantId, pub timeline_id: TimelineId, + /// Range of keys that this layer covers pub key_range: Range, - /// For image layer, this is `[lsn, lsn+1)`. + /// Inclusive start, exclusive end of the LSN range that this layer holds. + /// + /// - For an open in-memory layer, the end bound is MAX_LSN + /// - For a frozen in-memory layer or a delta layer, the end bound is a valid lsn after the + /// range start + /// - An image layer represents snapshot at one LSN, so end_lsn is always the snapshot LSN + 1 pub lsn_range: Range, /// Whether this is a delta layer. pub is_delta: bool, - /// Whether this layer only contains page images for part of the keys in the range. In the current implementation, this should - /// always be equal to `is_delta`. If we land the partial image layer PR someday, image layer could also be - /// incremental. + /// Does this layer only contain some data for the key-range (incremental), + /// or does it contain a version of every page? This is important to know + /// for garbage collecting old layers: an incremental layer depends on + /// the previous non-incremental layer. pub is_incremental: bool, - /// File size pub file_size: u64, } diff --git a/pageserver/src/tenant/storage_layer/remote_layer.rs b/pageserver/src/tenant/storage_layer/remote_layer.rs index 36a6593779..9de13b4af3 100644 --- a/pageserver/src/tenant/storage_layer/remote_layer.rs +++ b/pageserver/src/tenant/storage_layer/remote_layer.rs @@ -76,39 +76,6 @@ impl Layer for RemoteLayer { ) -> Result { bail!("layer {self} needs to be downloaded"); } - - /// debugging function to print out the contents of the layer - async fn dump(&self, _verbose: bool, _ctx: &RequestContext) -> Result<()> { - println!( - "----- remote layer for ten {} tli {} keys {}-{} lsn {}-{} is_delta {} is_incremental {} size {} ----", - self.desc.tenant_id, - self.desc.timeline_id, - self.desc.key_range.start, - self.desc.key_range.end, - self.desc.lsn_range.start, - self.desc.lsn_range.end, - self.desc.is_delta, - self.desc.is_incremental, - self.desc.file_size, - ); - - Ok(()) - } - - /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. - fn get_key_range(&self) -> Range { - self.layer_desc().key_range.clone() - } - - /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. - fn get_lsn_range(&self) -> Range { - self.layer_desc().lsn_range.clone() - } - - /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. - fn is_incremental(&self) -> bool { - self.layer_desc().is_incremental - } } /// Boilerplate to implement the Layer trait, always use layer_desc for persistent layers. @@ -142,8 +109,8 @@ impl PersistentLayer for RemoteLayer { } fn info(&self, reset: LayerAccessStatsReset) -> HistoricLayerInfo { - let layer_file_name = self.filename().file_name(); - let lsn_range = self.get_lsn_range(); + let layer_file_name = self.layer_desc().filename().file_name(); + let lsn_range = self.layer_desc().lsn_range.clone(); if self.desc.is_delta { HistoricLayerInfo::Delta { @@ -217,7 +184,7 @@ impl RemoteLayer { } /// Create a Layer struct representing this layer, after it has been downloaded. - pub fn create_downloaded_layer( + pub(crate) fn create_downloaded_layer( &self, layer_map_lock_held_witness: &LayerManager, conf: &'static PageServerConf, diff --git a/pageserver/src/tenant/timeline.rs b/pageserver/src/tenant/timeline.rs index 6863e052df..23b4da3818 100644 --- a/pageserver/src/tenant/timeline.rs +++ b/pageserver/src/tenant/timeline.rs @@ -95,7 +95,7 @@ use super::config::TenantConf; use super::remote_timeline_client::index::IndexPart; use super::remote_timeline_client::RemoteTimelineClient; use super::storage_layer::{ - AsLayerDesc, DeltaLayer, ImageLayer, Layer, LayerAccessStatsReset, PersistentLayerDesc, + AsLayerDesc, DeltaLayer, ImageLayer, LayerAccessStatsReset, PersistentLayerDesc, }; #[derive(Debug, PartialEq, Eq, Clone, Copy)] diff --git a/pageserver/src/tenant/timeline/layer_manager.rs b/pageserver/src/tenant/timeline/layer_manager.rs index 40212265cf..25df8a4f52 100644 --- a/pageserver/src/tenant/timeline/layer_manager.rs +++ b/pageserver/src/tenant/timeline/layer_manager.rs @@ -12,7 +12,7 @@ use crate::{ tenant::{ layer_map::{BatchedUpdates, LayerMap}, storage_layer::{ - AsLayerDesc, DeltaLayer, ImageLayer, InMemoryLayer, Layer, PersistentLayer, + AsLayerDesc, DeltaLayer, ImageLayer, InMemoryLayer, PersistentLayer, PersistentLayerDesc, PersistentLayerKey, RemoteLayer, }, timeline::compare_arced_layers, @@ -20,30 +20,30 @@ use crate::{ }; /// Provides semantic APIs to manipulate the layer map. -pub struct LayerManager { +pub(crate) struct LayerManager { layer_map: LayerMap, layer_fmgr: LayerFileManager, } /// After GC, the layer map changes will not be applied immediately. Users should manually apply the changes after /// scheduling deletes in remote client. -pub struct ApplyGcResultGuard<'a>(BatchedUpdates<'a>); +pub(crate) struct ApplyGcResultGuard<'a>(BatchedUpdates<'a>); impl ApplyGcResultGuard<'_> { - pub fn flush(self) { + pub(crate) fn flush(self) { self.0.flush(); } } impl LayerManager { - pub fn create() -> Self { + pub(crate) fn create() -> Self { Self { layer_map: LayerMap::default(), layer_fmgr: LayerFileManager::new(), } } - pub fn get_from_desc(&self, desc: &PersistentLayerDesc) -> Arc { + pub(crate) fn get_from_desc(&self, desc: &PersistentLayerDesc) -> Arc { self.layer_fmgr.get_from_desc(desc) } @@ -51,18 +51,12 @@ impl LayerManager { /// /// We expect users only to be able to get an immutable layer map. If users want to make modifications, /// they should use the below semantic APIs. This design makes us step closer to immutable storage state. - pub fn layer_map(&self) -> &LayerMap { + pub(crate) fn layer_map(&self) -> &LayerMap { &self.layer_map } - /// Get a mutable reference to the layer map. This function will be removed once `flush_frozen_layer` - /// gets a refactor. - pub fn layer_map_mut(&mut self) -> &mut LayerMap { - &mut self.layer_map - } - /// Replace layers in the layer file manager, used in evictions and layer downloads. - pub fn replace_and_verify( + pub(crate) fn replace_and_verify( &mut self, expected: Arc, new: Arc, @@ -73,7 +67,7 @@ impl LayerManager { /// Called from `load_layer_map`. Initialize the layer manager with: /// 1. all on-disk layers /// 2. next open layer (with disk disk_consistent_lsn LSN) - pub fn initialize_local_layers( + pub(crate) fn initialize_local_layers( &mut self, on_disk_layers: Vec>, next_open_layer_at: Lsn, @@ -87,11 +81,11 @@ impl LayerManager { } /// Initialize when creating a new timeline, called in `init_empty_layer_map`. - pub fn initialize_empty(&mut self, next_open_layer_at: Lsn) { + pub(crate) fn initialize_empty(&mut self, next_open_layer_at: Lsn) { self.layer_map.next_open_layer_at = Some(next_open_layer_at); } - pub fn initialize_remote_layers( + pub(crate) fn initialize_remote_layers( &mut self, corrupted_local_layers: Vec>, remote_layers: Vec>, @@ -108,7 +102,7 @@ impl LayerManager { /// Open a new writable layer to append data if there is no open layer, otherwise return the current open layer, /// called within `get_layer_for_write`. - pub fn get_layer_for_write( + pub(crate) fn get_layer_for_write( &mut self, lsn: Lsn, last_record_lsn: Lsn, @@ -163,7 +157,7 @@ impl LayerManager { } /// Called from `freeze_inmem_layer`, returns true if successfully frozen. - pub async fn try_freeze_in_memory_layer( + pub(crate) async fn try_freeze_in_memory_layer( &mut self, Lsn(last_record_lsn): Lsn, last_freeze_at: &AtomicLsn, @@ -185,7 +179,7 @@ impl LayerManager { } /// Add image layers to the layer map, called from `create_image_layers`. - pub fn track_new_image_layers(&mut self, image_layers: Vec) { + pub(crate) fn track_new_image_layers(&mut self, image_layers: Vec) { let mut updates = self.layer_map.batch_update(); for layer in image_layers { Self::insert_historic_layer(Arc::new(layer), &mut updates, &mut self.layer_fmgr); @@ -194,7 +188,7 @@ impl LayerManager { } /// Flush a frozen layer and add the written delta layer to the layer map. - pub fn finish_flush_l0_layer( + pub(crate) fn finish_flush_l0_layer( &mut self, delta_layer: Option, frozen_layer_for_check: &Arc, @@ -214,7 +208,7 @@ impl LayerManager { } /// Called when compaction is completed. - pub fn finish_compact_l0( + pub(crate) fn finish_compact_l0( &mut self, layer_removal_cs: Arc>, compact_from: Vec>, @@ -242,7 +236,7 @@ impl LayerManager { } /// Called when garbage collect the timeline. Returns a guard that will apply the updates to the layer map. - pub fn finish_gc_timeline( + pub(crate) fn finish_gc_timeline( &mut self, layer_removal_cs: Arc>, gc_layers: Vec>, @@ -313,7 +307,7 @@ impl LayerManager { } } -pub struct LayerFileManager( +pub(crate) struct LayerFileManager( HashMap>, );