gitops-agent 0.1.1

GitOps Agent - continuously monitors a remote git repository against local/any change, and performs actions (e.g. executes a provided command) - given a periodicity that is defined as a time intervals.
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

mod cli;
mod git;
mod radicle;
mod repos;
mod spy;

use crate::radicle::RadicleConfig;
use crate::repos::Repo;
use clap::Parser;
use cli::{Action::*, CommandLineArgs};

#[macro_use]
extern crate log;

use env_logger::{Builder, Env, Target};

fn main() -> anyhow::Result<()> {
    let CommandLineArgs { action } = CommandLineArgs::parse();

    match action {
        Spy {
            url,
            branch,
            delay,
            username,
            token,
            command,
            verbosity,
            exec_on_start,
            exit_on_first_diff,
            target_path,
            timeout,
        } => {
            let mut builder = Repo::builder(&url)
                .branch(branch)
                .delay(delay)
                .verbosity(verbosity)
                .exec_on_start(exec_on_start)
                .exit_on_first_diff(exit_on_first_diff)
                .timeout(timeout)
                .command(command);

            if let Some(u) = username {
                builder = builder.username(u);
            }
            if let Some(t) = token {
                builder = builder.token(t);
            }
            if let Some(p) = target_path {
                builder = builder.local_path(p);
            }

            let repo = builder.build();

            init_logger(verbosity);
            info!("starting");

            spy::spy_repo(repo)
        }

        Radicle {
            seed_url,
            rid,
            command,
            delay,
            verbosity,
            timeout,
            watch_patches,
            local_path,
        } => {
            let mut builder = RadicleConfig::builder(&seed_url, &rid)
                .delay(delay)
                .verbosity(verbosity)
                .timeout(timeout)
                .watch_patches(watch_patches)
                .command(command);

            if let Some(path) = local_path {
                builder = builder.local_path(path);
            }

            let config = builder.build();

            init_logger(verbosity);
            info!("starting radicle watcher");

            radicle::watch_radicle(config)
        }
    }?;

    Ok(())
}

fn init_logger(verbosity: u8) {
    let log_level = match verbosity {
        0 => "error",
        1 => "info",
        _ => "debug",
    };

    Builder::from_env(Env::default().default_filter_or(log_level))
        .target(Target::Stdout)
        .init();
}