utiles 0.8.0

Web map tile utils (aka utiles)
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

use crate::internal::globster::find_filepaths;
use crate::mbt::{MbtilesAsync, MbtilesClientAsync};
use crate::server::UtilesServerConfig;
use crate::server::state::{Datasets, MbtilesDataset};
use crate::{UtilesError, UtilesResult};
use futures::{StreamExt, stream};
use std::collections::BTreeMap;
use std::path::PathBuf;
use tracing::{debug, info, warn};

async fn check_mbtiles(fspath: &PathBuf) -> UtilesResult<MbtilesDataset> {
    let mbt = MbtilesClientAsync::open_readonly(fspath).await?;
    debug!("sanity check: {:?}", mbt.filepath());
    let is_valid = mbt.is_mbtiles().await;
    match &is_valid {
        Ok(is_mbt) => {
            if !is_mbt {
                warn!("{}: is not valid mbtiles", mbt.filepath());
                return Err(UtilesError::NotMbtilesLike(
                    fspath.to_string_lossy().to_string(),
                ));
            }
            info!("{}: is valid mbtiles", mbt.filepath());
            let tilejson = mbt.tilejson_ext().await?;
            let tilekind = mbt.query_tilekind().await?;
            Ok(MbtilesDataset {
                mbtiles: mbt,
                tilejson,
                tilekind,
            })
        }
        Err(e) => {
            warn!("{}: is not valid mbtiles: {:?}", mbt.filepath(), e);
            Err(UtilesError::NotMbtilesLike(
                fspath.to_string_lossy().to_string(),
            ))
        }
    }
}

pub(crate) async fn preflight(config: &UtilesServerConfig) -> UtilesResult<Datasets> {
    let now = std::time::Instant::now();
    info!("__PREFLIGHT__ ~ starting");
    debug!("preflight fspaths: {:?}", config.fspaths);

    let filepaths = find_filepaths(&config.fspaths)?;
    debug!("filepaths: {:?}", filepaths);

    let mut datasets = BTreeMap::new();
    let mbtiles_stream = stream::iter(filepaths)
        .map(|path| async move {
            let r = check_mbtiles(&path).await;
            match r {
                Ok(ds) => {
                    let filename =
                        ds.mbtiles.filename().to_string().replace(".mbtiles", "");
                    Ok((filename, ds))
                }
                Err(e) => {
                    warn!("{}: is not valid mbtiles: {:?}", path.to_string_lossy(), e);
                    Err(e)
                }
            }
        })
        .buffer_unordered(4);
    let mbtiles = mbtiles_stream.collect::<Vec<_>>().await;
    datasets.extend(mbtiles.into_iter().filter_map(Result::ok));
    // print the datasets
    for (k, ds) in &datasets {
        info!("{}: {}", k, ds.mbtiles.filepath());
    }
    let elapsed_duration = now.elapsed();
    match jiff::Span::try_from(elapsed_duration) {
        Ok(span) => {
            info!("__PREFLIGHT__ ~ done ({:#})", span);
        }
        Err(_) => {
            info!("__PREFLIGHT__ ~ done ({:?})", elapsed_duration);
        }
    }
    Ok(Datasets { mbtiles: datasets })
}
//
// async fn preflight_og(config: &UtilesServerConfig) -> UtilesResult<Datasets> {
//     warn!("__PREFLIGHT__");
//     debug!("preflight fspaths: {:?}", config.fspaths);
//
//     let filepaths = find_filepaths(&config.fspaths)?;
//     debug!("filepaths: {:?}", filepaths);
//
//     let mut datasets = BTreeMap::new();
//     // let mut tilejsons = HashMap::new();
//     for fspath in &filepaths {
//         let mbt = MbtilesClientAsync::open_readonly(fspath).await?;
//         debug!("sanity check: {:?}", mbt.filepath());
//         let is_valid = mbt.is_mbtiles().await;
//         match &is_valid {
//             Ok(is_mbt) => {
//                 if !is_mbt {
//                     warn!("{}: is not valid mbtiles", mbt.filepath());
//                     continue;
//                 }
//                 info!("{}: is valid mbtiles", mbt.filepath());
//                 let tilejson = mbt.tilejson_ext().await?;
//                 let filename = mbt.filename().to_string().replace(".mbtiles", "");
//                 let mbt_ds = MbtilesDataset {
//                     mbtiles: mbt,
//                     tilejson,
//                 };
//                 datasets.insert(filename, mbt_ds);
//             }
//             Err(e) => {
//                 warn!("{}: is not valid mbtiles: {:?}", mbt.filepath(), e);
//             }
//         }
//     }
//
//     // print the datasets
//     for (k, ds) in &datasets {
//         info!("{}: {}", k, ds.mbtiles.filepath());
//     }
//
//     info!("__PREFLIGHT_DONE__");
//
//     Ok(Datasets { mbtiles: datasets })
// }