Implement tile caching

martin/benches/bench.rs

@@ -45,8 +45,8 @@ impl Source for NullSource {
 
     async fn get_tile(
         &self,
-        _xyz: &TileCoord,
-        _query: &Option<UrlQuery>,
+        _xyz: TileCoord,
+        _url_query: Option<&UrlQuery>,
     ) -> MartinResult<TileData> {
         Ok(Vec::new())
     }

martin/src/args/srv.rs

@@ -10,6 +10,9 @@ pub struct SrvArgs {
     /// Number of web server workers
     #[arg(short = 'W', long)]
     pub workers: Option<usize>,
+    /// Cache size (in MB) for the tile cache
+    #[arg(short = 'c', long)]
+    pub cache_size: Option<u64>,
 }
 
 impl SrvArgs {
@@ -24,5 +27,8 @@ impl SrvArgs {
         if self.workers.is_some() {
             srv_config.worker_processes = self.workers;
         }
+        if self.cache_size.is_some() {
+            srv_config.cache_size_mb = self.cache_size;
+        }
     }
 }

martin/src/bin/martin-cp.rs

@@ -311,7 +311,8 @@ async fn run_tile_copy(args: CopyArgs, state: ServerState) -> MartinCpResult<()>
                 .try_for_each_concurrent(concurrency, |xyz| {
                     let tx = tx.clone();
                     async move {
-                        let tile = get_tile_content(sources, info, &xyz, query, encodings).await?;
+                        let tile =
+                            get_tile_content(sources, info, xyz, query, encodings, None).await?;
                         let data = tile.data;
                         tx.send(TileXyz { xyz, data })
                             .await

martin/src/mbtiles/mod.rs

@@ -105,8 +105,8 @@ impl Source for MbtSource {
 
     async fn get_tile(
         &self,
-        xyz: &TileCoord,
-        _url_query: &Option<UrlQuery>,
+        xyz: TileCoord,
+        _url_query: Option<&UrlQuery>,
     ) -> MartinResult<TileData> {
         if let Some(tile) = self
             .mbtiles

martin/src/pg/configurator.rs

@@ -214,7 +214,7 @@ impl PgBuilder {
                     continue;
                 }
                 Ok((id, pg_sql, src_inf)) => {
-                    debug!("{id} query: {}", pg_sql.query);
+                    debug!("{id} query: {}", pg_sql.sql_query);
                     self.add_func_src(&mut res, id.clone(), &src_inf, pg_sql.clone());
                     info_map.insert(id, src_inf);
                 }
@@ -252,7 +252,7 @@ impl PgBuilder {
             warn_on_rename(id, &id2, "Function");
             let signature = &pg_sql.signature;
             info!("Configured {dup}source {id2} from the function {signature}");
-            debug!("{id2} query: {}", pg_sql.query);
+            debug!("{id2} query: {}", pg_sql.sql_query);
             info_map.insert(id2, merged_inf);
         }
 
@@ -285,7 +285,7 @@ impl PgBuilder {
                     let id2 = self.resolve_id(&source_id, &db_inf);
                     self.add_func_src(&mut res, id2.clone(), &db_inf, pg_sql.clone());
                     info!("Discovered source {id2} from function {}", pg_sql.signature);
-                    debug!("{id2} query: {}", pg_sql.query);
+                    debug!("{id2} query: {}", pg_sql.sql_query);
                     info_map.insert(id2, db_inf);
                 }
             }
@@ -302,11 +302,11 @@ impl PgBuilder {
         &self,
         sources: &mut TileInfoSources,
         id: String,
-        info: &impl PgInfo,
-        sql: PgSqlInfo,
+        pg_info: &impl PgInfo,
+        sql_info: PgSqlInfo,
     ) {
-        let tilejson = info.to_tilejson(id.clone());
-        let source = PgSource::new(id, sql, tilejson, self.pool.clone());
+        let tilejson = pg_info.to_tilejson(id.clone());
+        let source = PgSource::new(id, sql_info, tilejson, self.pool.clone());
         sources.push(Box::new(source));
     }
 }

martin/src/pg/errors.rs

@@ -61,6 +61,6 @@ pub enum PgError {
     #[error(r#"Unable to get tile {2:#} from {1}: {0}"#)]
     GetTileError(#[source] TokioPgError, String, TileCoord),
 
-    #[error(r#"Unable to get tile {2:#} with {:?} params from {1}: {0}"#, query_to_json(.3))]
-    GetTileWithQueryError(#[source] TokioPgError, String, TileCoord, UrlQuery),
+    #[error(r#"Unable to get tile {2:#} with {:?} params from {1}: {0}"#, query_to_json(.3.as_ref()))]
+    GetTileWithQueryError(#[source] TokioPgError, String, TileCoord, Option<UrlQuery>),
 }

martin/src/pg/pg_source.rs

@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use async_trait::async_trait;
 use deadpool_postgres::tokio_postgres::types::{ToSql, Type};
 use log::debug;
@@ -58,35 +56,32 @@ impl Source for PgSource {
 
     async fn get_tile(
         &self,
-        xyz: &TileCoord,
-        url_query: &Option<UrlQuery>,
+        xyz: TileCoord,
+        url_query: Option<&UrlQuery>,
     ) -> MartinResult<TileData> {
-        let empty_query = HashMap::new();
-        let url_query = url_query.as_ref().unwrap_or(&empty_query);
         let conn = self.pool.get().await?;
-
         let param_types: &[Type] = if self.support_url_query() {
             &[Type::INT2, Type::INT8, Type::INT8, Type::JSON]
         } else {
             &[Type::INT2, Type::INT8, Type::INT8]
         };
 
-        let query = &self.info.query;
+        let sql = &self.info.sql_query;
         let prep_query = conn
-            .prepare_typed_cached(query, param_types)
+            .prepare_typed_cached(sql, param_types)
             .await
             .map_err(|e| {
                 PrepareQueryError(
                     e,
                     self.id.to_string(),
                     self.info.signature.to_string(),
-                    self.info.query.to_string(),
+                    self.info.sql_query.to_string(),
                 )
             })?;
 
         let tile = if self.support_url_query() {
             let json = query_to_json(url_query);
-            debug!("SQL: {query} [{xyz}, {json:?}]");
+            debug!("SQL: {sql} [{xyz}, {json:?}]");
             let params: &[&(dyn ToSql + Sync)] = &[
                 &i16::from(xyz.z),
                 &i64::from(xyz.x),
@@ -95,7 +90,7 @@ impl Source for PgSource {
             ];
             conn.query_opt(&prep_query, params).await
         } else {
-            debug!("SQL: {query} [{xyz}]");
+            debug!("SQL: {sql} [{xyz}]");
             conn.query_opt(
                 &prep_query,
                 &[&i16::from(xyz.z), &i64::from(xyz.x), &i64::from(xyz.y)],
@@ -107,9 +102,9 @@ impl Source for PgSource {
             .map(|row| row.and_then(|r| r.get::<_, Option<TileData>>(0)))
             .map_err(|e| {
                 if self.support_url_query() {
-                    GetTileWithQueryError(e, self.id.to_string(), *xyz, url_query.clone())
+                    GetTileWithQueryError(e, self.id.to_string(), xyz, url_query.cloned())
                 } else {
-                    GetTileError(e, self.id.to_string(), *xyz)
+                    GetTileError(e, self.id.to_string(), xyz)
                 }
             })?
             .unwrap_or_default();
@@ -120,7 +115,7 @@ impl Source for PgSource {
 
 #[derive(Clone, Debug)]
 pub struct PgSqlInfo {
-    pub query: String,
+    pub sql_query: String,
     pub use_url_query: bool,
     pub signature: String,
 }
@@ -129,7 +124,7 @@ impl PgSqlInfo {
     #[must_use]
     pub fn new(query: String, has_query_params: bool, signature: String) -> Self {
         Self {
-            query,
+            sql_query: query,
             use_url_query: has_query_params,
             signature,
         }

martin/src/pg/utils.rs

@@ -85,13 +85,15 @@ pub fn patch_json(target: TileJSON, patch: &Option<serde_json::Value>) -> TileJS
 }
 
 #[must_use]
-pub fn query_to_json(query: &UrlQuery) -> Json<HashMap<String, serde_json::Value>> {
+pub fn query_to_json(query: Option<&UrlQuery>) -> Json<HashMap<String, serde_json::Value>> {
     let mut query_as_json = HashMap::new();
-    for (k, v) in query {
-        let json_value: serde_json::Value =
-            serde_json::from_str(v).unwrap_or_else(|_| serde_json::Value::String(v.clone()));
+    if let Some(query) = query {
+        for (k, v) in query {
+            let json_value: serde_json::Value =
+                serde_json::from_str(v).unwrap_or_else(|_| serde_json::Value::String(v.clone()));
 
-        query_as_json.insert(k.clone(), json_value);
+            query_as_json.insert(k.clone(), json_value);
+        }
     }
 
     Json(query_as_json)

martin/src/pmtiles/mod.rs

@@ -264,8 +264,8 @@ macro_rules! impl_pmtiles_source {
 
             async fn get_tile(
                 &self,
-                xyz: &TileCoord,
-                _url_query: &Option<UrlQuery>,
+                xyz: TileCoord,
+                _url_query: Option<&UrlQuery>,
             ) -> MartinResult<TileData> {
                 // TODO: optimize to return Bytes
                 if let Some(t) = self

martin/src/source.rs

@@ -113,7 +113,11 @@ pub trait Source: Send + Debug {
         false
     }
 
-    async fn get_tile(&self, xyz: &TileCoord, query: &Option<UrlQuery>) -> MartinResult<TileData>;
+    async fn get_tile(
+        &self,
+        xyz: TileCoord,
+        url_query: Option<&UrlQuery>,
+    ) -> MartinResult<TileData>;
 
     fn is_valid_zoom(&self, zoom: u8) -> bool {
         let tj = self.get_tilejson();

martin/src/srv/config.rs

@@ -9,6 +9,7 @@ pub struct SrvConfig {
     pub keep_alive: Option<u64>,
     pub listen_addresses: Option<String>,
     pub worker_processes: Option<usize>,
+    pub cache_size_mb: Option<u64>,
 }
 
 #[cfg(test)]
@@ -25,12 +26,14 @@ mod tests {
                 keep_alive: 75
                 listen_addresses: '0.0.0.0:3000'
                 worker_processes: 8
+                tile_cache_size_mb: 100
             "})
             .unwrap(),
             SrvConfig {
                 keep_alive: Some(75),
                 listen_addresses: some("0.0.0.0:3000"),
                 worker_processes: Some(8),
+                cache_size_mb: Some(100),
             }
         );
     }