satkit 0.3.14

Satellite Toolkit
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

use super::download_file_async;
use super::download_to_string;
use crate::skerror;
use crate::utils::datadir;
use crate::SKResult;
use json::JsonValue;
use std::path::PathBuf;
use std::thread::JoinHandle;

fn download_from_url_json(json_url: String, basedir: &std::path::PathBuf) -> SKResult<()> {
    let json_base: JsonValue = json::parse(download_to_string(json_url.as_str())?.as_str())?;
    let vresult: Vec<std::thread::JoinHandle<SKResult<bool>>> = json_base
        .members()
        .map(|url| -> JoinHandle<SKResult<bool>> {
            download_file_async(url.to_string(), basedir, true)
        })
        .collect();
    // Wait for all the threads to funish
    for jh in vresult {
        jh.join().unwrap()?;
    }

    Ok(())
}

fn download_from_json(
    v: &JsonValue,
    basedir: std::path::PathBuf,
    baseurl: String,
    overwrite: &bool,
    thandles: &mut Vec<JoinHandle<SKResult<bool>>>,
) -> SKResult<()> {
    if v.is_object() {
        let r1: Vec<SKResult<()>> = v
            .entries()
            .map(|entry: (&str, &JsonValue)| -> SKResult<()> {
                let pbnew = basedir.join(entry.0);
                if !pbnew.is_dir() {
                    std::fs::create_dir_all(pbnew.clone())?;
                }
                let mut newurl = baseurl.clone();
                newurl.push_str(format!("/{}", entry.0).as_str());
                download_from_json(entry.1, pbnew.clone(), newurl, overwrite, thandles)?;
                Ok(())
            })
            .filter(|res| match res {
                Ok(_) => false,
                Err(_) => true,
            })
            .collect();
        if r1.len() > 0 {
            return skerror!("Could not parse entries");
        }
    } else if v.is_array() {
        let r2: Vec<SKResult<()>> = v
            .members()
            .map(|val| -> SKResult<()> {
                download_from_json(val, basedir.clone(), baseurl.clone(), overwrite, thandles)?;
                Ok(())
            })
            .filter(|res| match res {
                Ok(_) => false,
                Err(_) => true,
            })
            .collect();
        if r2.len() > 0 {
            return skerror!("could not parse array entries");
        }
    } else if v.is_string() {
        let mut newurl = baseurl.clone();
        newurl.push_str(format!("/{}", v).as_str());
        thandles.push(download_file_async(newurl, &basedir, overwrite.clone()));
    } else {
        return skerror!("invalid json for downloading files??!!");
    }

    Ok(())
}

fn download_datadir(basedir: PathBuf, baseurl: String, overwrite: &bool) -> SKResult<()> {
    if !basedir.is_dir() {
        std::fs::create_dir_all(basedir.clone())?;
    }

    let mut fileurl = baseurl.clone();
    fileurl.push_str("/files.json");

    let json_base: JsonValue = json::parse(download_to_string(fileurl.as_str())?.as_str())?;
    let mut thandles: Vec<JoinHandle<SKResult<bool>>> = Vec::new();
    download_from_json(&json_base, basedir, baseurl, overwrite, &mut thandles)?;
    // Wait for all the threads to funish
    for jh in thandles {
        jh.join().unwrap()?;
    }
    Ok(())
}

pub fn update_datafiles(dir: Option<PathBuf>, overwrite_if_exists: bool) -> SKResult<()> {
    let downloaddir = match dir {
        Some(d) => d,
        None => datadir()?,
    };
    if downloaddir.metadata()?.permissions().readonly() {
        return skerror!(
            r#"
            Data directory is read-only.
            Try setting SATKIT_DATA environment
            variable to a writeable directory and re-starting
            "#
        );
    }

    println!(
        "Downloading data files to {}",
        downloaddir.clone().to_str().unwrap()
    );
    // Download old files
    download_datadir(
        downloaddir.clone(),
        String::from("https://storage.googleapis.com/astrokit-astro-data"),
        &overwrite_if_exists,
    )?;

    println!("Now downloading files that are regularly updated:");
    println!("  Space Weather & Earth Orientation Parameters");
    // Get a list of files that are updated with new data, and download them
    download_from_url_json(
        String::from("https://storage.googleapis.com/astrokit-astro-data/files_refresh.json"),
        &downloaddir,
    )?;
    Ok(())
}

/*
#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn update_data() {
        match update_datafiles(None, false) {
            Ok(()) => (),
            Err(e) => {
                println!("Error: {}", e.to_string());
                assert!(1 == 0);
            }
        }
    }
}
*/