quickcfg 0.6.3

Do basic configuration of a system, declaratively and quickly.
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

use crate::{
    config, environment as e,
    system::SystemInput,
    template::Template,
    unit::{GitClone, GitUpdate, SystemUnit},
};
use anyhow::{anyhow, Error};
use std::fmt;
use std::time::Duration;

const DEFAULT_REFRESH: u64 = 3600 * 24;

system_struct! {
    #[doc = "Checkout a git repository to the given path."]
    GitSync {
        #[doc="Path to check out the repo."]
        pub path: Template,
        #[doc="Remote to keep in sync with."]
        pub remote: String,
        #[serde(
            default = "default_refresh",
            deserialize_with = "config::human_duration"
        )]
        pub refresh: Duration,
    }
}

/// Get default refresh.
fn default_refresh() -> Duration {
    Duration::from_secs(DEFAULT_REFRESH)
}

impl GitSync {
    system_defaults!(translate);

    /// Copy one directory to another.
    pub fn apply<E>(&self, input: SystemInput<E>) -> Result<Vec<SystemUnit>, Error>
    where
        E: Copy + e::Environment,
    {
        let SystemInput {
            root,
            base_dirs,
            allocator,
            file_system,
            state,
            facts,
            environment,
            now,
            opts,
            git_system,
            ..
        } = input;

        let id = self.id.as_ref().ok_or_else(|| anyhow!("missing `id`"))?;

        let id = format!("git-sync/{}", id);

        let mut units = Vec::new();

        let path = match self.path.as_path(root, base_dirs, facts, environment)? {
            Some(path) => path,
            None => return Ok(units),
        };

        if let Some(last_update) = state.last_update(&id) {
            let duration = now.duration_since(*last_update)?;

            if duration < self.refresh {
                return Ok(units);
            }
        };

        if !git_system.test()? {
            log::warn!("no working git command found");
            return Ok(units);
        }

        if path.is_dir() {
            let git_update = allocator.unit(GitUpdate {
                id,
                path,
                force: opts.force,
            });

            units.push(git_update);
            return Ok(units);
        }

        // Initial clone.
        let parent_dir = match path.parent() {
            Some(parent) if !parent.is_dir() => {
                units.extend(file_system.create_dir_all(parent)?);
                Some(file_system.dir_dependency(parent)?)
            }
            _ => None,
        };

        let dir_dependencies = file_system.dir_dependency(&path)?;

        let mut git_clone = allocator.unit(GitClone {
            id,
            path,
            remote: self.remote.to_string(),
        });

        git_clone.dependencies.extend(parent_dir);
        git_clone.provides.push(dir_dependencies);

        units.push(git_clone);
        Ok(units)
    }
}

impl fmt::Display for GitSync {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "syncing remote `{}` to `{}`", self.remote, self.path)
    }
}