cepler 0.7.15

(Capricious Environment Propagator)-ler
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

use crate::{config::*, repo::*, workspace::StateId};
use anyhow::*;
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use std::path::Path;

pub mod check;
pub mod ci_in;
pub mod ci_out;

#[derive(Clone, Debug, Deserialize, Serialize)]
struct ResourceConfig<P: DeserializeOwned + Serialize> {
    #[serde(bound = "P: DeserializeOwned")]
    params: Option<P>,
    source: Source,
    version: Option<Version>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
struct Source {
    uri: String,
    branch: String,
    gates_branch: Option<String>,
    gates_file: Option<String>,
    private_key: String,
    environment: Option<String>,
    #[serde(default = "bool::default")]
    ignore_queue: bool,
    #[serde(default = "default_config_path")]
    config: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
struct Version {
    trigger: String,
    version: Option<String>,
}
impl From<StateId> for Version {
    fn from(id: StateId) -> Self {
        Self {
            trigger: id.head_commit,
            version: Some(id.version.to_string()),
        }
    }
}

#[derive(Clone, Debug, Deserialize, Serialize)]
struct OutParams {
    repository: String,
    environment: Option<String>,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
struct InParams {
    #[serde(default = "bool_true")]
    prepare: bool,
}

fn bool_true() -> bool {
    true
}

#[derive(Debug, Deserialize, Serialize)]
pub struct DiffElem {
    name: String,
    value: String,
}

#[derive(Debug, Deserialize, Serialize)]
struct ResourceData {
    version: Version,
    metadata: Vec<DiffElem>,
}

fn default_config_path() -> String {
    "cepler.yml".to_string()
}

fn get_gate(
    gates_file: Option<&String>,
    gates_branch: Option<&String>,
    env: &str,
    repo: &Repo,
) -> Result<Option<String>> {
    let gates = match (gates_file, gates_branch) {
        (Some(gates_file), Some(gates_branch)) => {
            if let Some(file) =
                repo.get_file_from_branch(gates_branch, Path::new(&gates_file), |bytes| {
                    GatesConfig::from_reader(bytes)
                })?
            {
                Ok(Some(file))
            } else {
                Err(anyhow!("Couldn't read gates file"))
            }
        }
        (Some(gates_file), _) => Ok(Some(GatesConfig::from_file(gates_file)?)),

        (_, Some(_)) => Err(anyhow!("Missing gates_file in source")),
        _ => Ok(None),
    }?;

    let gate = if let Some(gates) = gates {
        gates.get_gate(env)?
    } else {
        None
    };
    Ok(gate)
}