smokeping-config 0.1.1

SmokePing config builder — render Targets files from a committable patch YAML on top of a versioned base catalogue
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

use std::fs::{self, OpenOptions};
use std::io::Write;
use std::path::Path;

use crate::base_resolver::bundled_version;
use crate::patch::{PATCH_SCHEMA, Patch, patch_to_yaml};
use crate::types::CatalogVersion;

pub fn run_init(out: &str, force: bool) -> i32 {
    let version = bundled_version().unwrap_or(CatalogVersion {
        date: "unknown".to_string(),
        sha: "unknown".to_string(),
    });

    let starter = Patch {
        schema: PATCH_SCHEMA,
        base_version: version.clone(),
        language: None,
        root: None,
        excluded: None,
        overrides: None,
        custom: None,
    };

    let body = match patch_to_yaml(&starter) {
        Ok(y) => y,
        Err(e) => {
            eprintln!("smokeping-config: {}", e);
            return 1;
        }
    };

    let header = "\
# SmokePing config builder — patch file.
#
# Pin: this patch was initialised against the catalogue snapshot identified
# by `baseVersion`. Running `smokeping-config render <this-file>` applies the
# patch on top of that base. When upstream evolves, `smokeping-config diff-base`
# reports which of your paths drifted.
#
# Example edits — uncomment and adjust:
#
# excluded:
#   - /CDN/Akamai
#
# overrides:
#   /CDN/Cloudflare:
#     host: 1.1.1.1
#
# custom:
#   - parentPath: null
#     node:
#       type: category
#       name: MyStuff
#       menu: My Stuff
#       title: Personal targets

";

    let abs = if Path::new(out).is_absolute() {
        out.to_string()
    } else {
        std::env::current_dir()
            .unwrap()
            .join(out)
            .to_string_lossy()
            .to_string()
    };

    if !force {
        match OpenOptions::new().write(true).create_new(true).open(&abs) {
            Ok(mut f) => {
                let content = format!("{}{}", header, body);
                if let Err(e) = f.write_all(content.as_bytes()) {
                    eprintln!("smokeping-config: {}", e);
                    return 1;
                }
            }
            Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
                eprintln!("init: {} already exists (pass --force to overwrite)", out);
                return 1;
            }
            Err(e) => {
                eprintln!("smokeping-config: {}", e);
                return 1;
            }
        }
    } else {
        let content = format!("{}{}", header, body);
        if let Err(e) = fs::write(&abs, &content) {
            eprintln!("smokeping-config: {}", e);
            return 1;
        }
    }

    eprintln!(
        "init: wrote {} pinned to {} @ {}",
        out, version.date, version.sha
    );
    0
}