martin-core 0.7.0

Basic building blocks of MapLibre's Martin tile server.
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

use actix_web::web::Bytes;

use crate::cache::{CacheKey, Cacheable, ResourceCache};

/// Sprite cache for storing generated sprite sheets.
pub type SpriteCache = ResourceCache<SpriteCacheKey, Bytes>;

/// Optional wrapper for [`SpriteCache`].
pub type OptSpriteCache = Option<SpriteCache>;

/// Constant representing no sprite cache configuration.
pub const NO_SPRITE_CACHE: OptSpriteCache = None;

/// Cache key for sprite data.
///
/// `ids` is the comma-joined list of sprite source IDs from the request path.
/// Invalidation by source ID matches by token (not substring): invalidating
/// `"foo"` does not invalidate entries keyed against `"foobar"`.
#[derive(Debug, Hash, PartialEq, Eq, Clone)]
pub struct SpriteCacheKey {
    ids: String,
    as_sdf: bool,
    as_json: bool,
}

impl SpriteCacheKey {
    /// Build a key from the request fields.
    #[must_use]
    pub fn new(ids: String, as_sdf: bool, as_json: bool) -> Self {
        Self {
            ids,
            as_sdf,
            as_json,
        }
    }
}

impl CacheKey for SpriteCacheKey {
    const CACHE_NAME: &'static str = "sprite";

    fn matches_source(&self, source_id: &str) -> bool {
        self.ids.split(',').any(|s| s == source_id)
    }

    fn record_outcome(&self, hit: bool) {
        #[cfg(feature = "metrics")]
        crate::metrics::CACHE_REQUESTS_TOTAL
            .with_label_values(&[Self::CACHE_NAME, crate::cache::hit_miss_label(hit)])
            .inc();
        #[expect(
            clippy::if_same_then_else,
            reason = "hotpath::gauge! requires a literal name argument"
        )]
        if hit {
            hotpath::gauge!("sprite_cache_hits").inc(1.0);
        } else {
            hotpath::gauge!("sprite_cache_misses").inc(1.0);
        }
    }
}

impl Cacheable for Bytes {
    fn weight(&self) -> u32 {
        self.len().try_into().unwrap_or(u32::MAX)
    }
}