mountpoint-s3-fs 0.9.3

Mountpoint S3 main library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use crate::{data_cache::DataCache, sync::Arc};

use mountpoint_s3_client::ObjectClient;

use crate::{Runtime, mem_limiter::MemoryLimiter};

use super::caching_stream::CachingPartStream;
use super::part_stream::{ClientPartStream, PartStream};
use super::{Prefetcher, PrefetcherConfig};

/// A builder for [Prefetcher] instances.
pub struct PrefetcherBuilder<Client> {
    inner: Box<dyn PrefetcherBuild<Client>>,
}

impl<Client> PrefetcherBuilder<Client>
where
    Client: ObjectClient + Clone + Send + Sync + 'static,
{
    /// Creates an instance of the default [Prefetcher] builder.
    pub fn default_builder(client: Client) -> Self {
        Self {
            inner: Box::new(DefaultPrefetcherBuilder { client }),
        }
    }

    /// Creates an instance of a caching [Prefetcher] builder.
    pub fn caching_builder<Cache>(cache: Cache, client: Client) -> Self
    where
        Cache: DataCache + Send + Sync + 'static,
    {
        Self {
            inner: Box::new(CachingPrefetcherBuilder { cache, client }),
        }
    }

    /// Build a [Prefetcher] instance.
    pub fn build(
        self,
        runtime: Runtime,
        mem_limiter: Arc<MemoryLimiter>,
        prefetcher_config: PrefetcherConfig,
    ) -> Prefetcher<Client> {
        self.inner.build(runtime, mem_limiter, prefetcher_config)
    }
}

/// Internal trait to abstract over default and caching prefetcher implementations.
///
/// This is always wrapped in the public [PrefetcherBuilder] struct to hide the
/// cumbersome boxing due to handling trait objects with:
/// * a generic [ObjectClient] parameter,
/// * a build method that consumes `self`.
trait PrefetcherBuild<Client>
where
    Client: ObjectClient + Clone + Send + Sync + 'static,
{
    fn build(
        self: Box<Self>,
        runtime: Runtime,
        mem_limiter: Arc<MemoryLimiter>,
        prefetcher_config: PrefetcherConfig,
    ) -> Prefetcher<Client>;
}

struct DefaultPrefetcherBuilder<Client> {
    client: Client,
}

impl<Client> PrefetcherBuild<Client> for DefaultPrefetcherBuilder<Client>
where
    Client: ObjectClient + Clone + Send + Sync + 'static,
{
    fn build(
        self: Box<Self>,
        runtime: Runtime,
        mem_limiter: Arc<MemoryLimiter>,
        prefetcher_config: PrefetcherConfig,
    ) -> Prefetcher<Client> {
        let part_stream = ClientPartStream::new(runtime, self.client, mem_limiter.clone());
        Prefetcher::new(PartStream::new(part_stream), prefetcher_config, mem_limiter)
    }
}

struct CachingPrefetcherBuilder<Cache, Client> {
    cache: Cache,
    client: Client,
}

impl<Cache, Client> PrefetcherBuild<Client> for CachingPrefetcherBuilder<Cache, Client>
where
    Cache: DataCache + Send + Sync + 'static,
    Client: ObjectClient + Clone + Send + Sync + 'static,
{
    fn build(
        self: Box<Self>,
        runtime: Runtime,
        mem_limiter: Arc<MemoryLimiter>,
        prefetcher_config: PrefetcherConfig,
    ) -> Prefetcher<Client> {
        let part_stream = CachingPartStream::new(runtime, self.client, mem_limiter.clone(), self.cache);
        Prefetcher::new(PartStream::new(part_stream), prefetcher_config, mem_limiter)
    }
}