martin 1.11.0

Blazing fast and lightweight tile server with PostGIS, MBTiles, and PMTiles support
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

pub mod content;
pub mod metadata;
pub mod process;

#[cfg(test)]
pub mod tests {
    use async_trait::async_trait;
    use martin_core::CacheZoomRange;
    use martin_core::tiles::{BoxedSource, MartinCoreError, MartinCoreResult, Source, UrlQuery};
    use martin_tile_utils::{Encoding, Format, TileCoord, TileData, TileInfo};
    use tilejson::{TileJSON, tilejson};

    #[derive(Debug, Clone)]
    pub struct TestSource {
        pub id: &'static str,
        pub tj: TileJSON,
        pub data: TileData,
        pub format: Format,
    }

    #[async_trait]
    impl Source for TestSource {
        fn get_id(&self) -> &str {
            self.id
        }

        fn get_tilejson(&self) -> &TileJSON {
            &self.tj
        }

        fn get_tile_info(&self) -> TileInfo {
            TileInfo::new(self.format, Encoding::Uncompressed)
        }

        fn clone_source(&self) -> BoxedSource {
            Box::new(self.clone())
        }

        fn cache_zoom(&self) -> CacheZoomRange {
            CacheZoomRange::default()
        }

        async fn get_tile(
            &self,
            _xyz: TileCoord,
            _url_query: Option<&UrlQuery>,
        ) -> MartinCoreResult<TileData> {
            Ok(self.data.clone())
        }
    }

    /// A test source that returns [`MartinCoreError::SourceNeedsReload`] on the first `get_tile`
    /// call and real data on every subsequent call.
    ///
    /// Used to verify that the tile-serving layer detects `SourceNeedsReload`, reloads the
    /// source, and retries the request rather than propagating the error to the caller.
    #[derive(Debug, Clone)]
    pub struct SourceNeedsReloadTestSource {
        id: &'static str,
        tilejson: TileJSON,
        data: TileData,
        call_count: u32,
    }

    impl SourceNeedsReloadTestSource {
        pub fn new(id: &'static str, data: TileData) -> Self {
            Self {
                id,
                tilejson: tilejson! { tiles: vec![] },
                data,
                call_count: 0,
            }
        }
    }

    #[async_trait]
    impl Source for SourceNeedsReloadTestSource {
        fn get_id(&self) -> &str {
            self.id
        }

        fn get_tilejson(&self) -> &TileJSON {
            &self.tilejson
        }

        fn get_tile_info(&self) -> TileInfo {
            TileInfo::new(Format::Mvt, Encoding::Uncompressed)
        }

        fn clone_source(&self) -> BoxedSource {
            Box::new(self.clone())
        }

        fn cache_zoom(&self) -> CacheZoomRange {
            CacheZoomRange::default()
        }

        async fn get_tile(
            &self,
            _xyz: TileCoord,
            _url_query: Option<&UrlQuery>,
        ) -> MartinCoreResult<TileData> {
            if self.call_count == 0 {
                Err(MartinCoreError::SourceNeedsReload)
            } else {
                Ok(self.data.clone())
            }
        }

        async fn try_reload(&self) -> MartinCoreResult<BoxedSource> {
            let mut reloaded = self.clone();
            reloaded.call_count += 1;
            Ok(Box::new(reloaded))
        }
    }

    /// A test source that serves pre-compressed MVT data with a configurable encoding.
    #[derive(Debug, Clone)]
    pub struct CompressedTestSource {
        pub id: &'static str,
        pub tj: TileJSON,
        pub data: TileData,
        pub encoding: Encoding,
    }

    #[async_trait]
    impl Source for CompressedTestSource {
        fn get_id(&self) -> &str {
            self.id
        }

        fn get_tilejson(&self) -> &TileJSON {
            &self.tj
        }

        fn get_tile_info(&self) -> TileInfo {
            TileInfo::new(Format::Mvt, self.encoding)
        }

        fn clone_source(&self) -> BoxedSource {
            Box::new(self.clone())
        }

        fn cache_zoom(&self) -> CacheZoomRange {
            CacheZoomRange::default()
        }

        async fn get_tile(
            &self,
            _xyz: TileCoord,
            _url_query: Option<&UrlQuery>,
        ) -> MartinCoreResult<TileData> {
            Ok(self.data.clone())
        }
    }
}