orcs 0.0.8

Microservices monorepo orchestration tool
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

use std::error;
use std::fmt;
use std::io;

#[derive(Debug)]
pub enum Error {
    CheckProjectError(&'static str, String),
    CreateError(&'static str, String),
    CreateProjectError(&'static str, String),
    CreateServiceError(&'static str, String),
    CreateRecipeError(&'static str, String),
    GetActionError(&'static str, String),
    GetParameterError(&'static str, String),
    InitProjectError(&'static str),
    LoadContextError(&'static str),
    LoadProjectError(&'static str),
    LoadStoreError(&'static str),
    RenderTemplateError(&'static str, String),
    RunStageError(&'static str, String),
    SetParameterError(&'static str, String),

    GitError(git2::Error),
    HandlebarsError(handlebars::TemplateRenderError),
    IOError(std::io::Error),
    JsonError(serde_json::Error),
    PathError(std::path::StripPrefixError),
    TomlDeError(toml::de::Error),
    TomlSerError(toml::ser::Error),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::CheckProjectError(msg, item) => {
                write!(f, "Project file validation failed: {} ({})", msg, item)
            }
            Self::CreateError(msg, item) => {
                write!(f, "Unable to create resource {}: {}", item, msg)
            }
            Self::CreateProjectError(msg, item) => {
                write!(f, "Unable to create project {}: {}", item, msg)
            }
            Self::CreateServiceError(msg, item) => {
                write!(f, "Unable to create service {}: {}", item, msg)
            }
            Self::CreateRecipeError(msg, item) => {
                write!(f, "Unable to create recipe {}: {}", item, msg)
            }
            Self::GetParameterError(msg, item) => {
                write!(f, "Failed to retrieve parameter: {} ({})", msg, item)
            }
            Self::GetActionError(msg, item) => {
                write!(f, "Failed to retrieve action {}: {}", item, msg)
            }
            Self::InitProjectError(msg) => write!(f, "Failed to initialize the project: {}", msg),
            Self::LoadContextError(msg) => write!(f, "Failed to load context: {}", msg),
            Self::LoadProjectError(msg) => write!(f, "Could not load project: {}", msg),
            Self::LoadStoreError(msg) => write!(f, "Could not load parameter store: {}", msg),
            Self::RenderTemplateError(msg, item) => {
                write!(f, "Failed to render template {}: {}", item, msg)
            }
            Self::RunStageError(msg, item) => write!(f, "Could not run stage {}: {}", item, msg),
            Self::SetParameterError(msg, item) => {
                write!(f, "Failed to store parameter {}: {}", item, msg)
            }

            Self::GitError(err) => err.fmt(f),
            Self::HandlebarsError(err) => err.fmt(f),
            Self::IOError(err) => err.fmt(f),
            Self::JsonError(err) => err.fmt(f),
            Self::PathError(err) => err.fmt(f),
            Self::TomlDeError(err) => err.fmt(f),
            Self::TomlSerError(err) => err.fmt(f),
        }
    }
}

impl error::Error for Error {}

impl From<git2::Error> for Error {
    fn from(err: git2::Error) -> Self {
        Self::GitError(err)
    }
}

impl From<handlebars::TemplateRenderError> for Error {
    fn from(err: handlebars::TemplateRenderError) -> Self {
        Self::HandlebarsError(err)
    }
}

impl From<io::Error> for Error {
    fn from(err: io::Error) -> Self {
        Self::IOError(err)
    }
}

impl From<std::path::StripPrefixError> for Error {
    fn from(err: std::path::StripPrefixError) -> Self {
        Self::PathError(err)
    }
}

impl From<serde_json::Error> for Error {
    fn from(err: serde_json::Error) -> Self {
        Self::JsonError(err)
    }
}

impl From<toml::de::Error> for Error {
    fn from(err: toml::de::Error) -> Self {
        Self::TomlDeError(err)
    }
}

impl From<toml::ser::Error> for Error {
    fn from(err: toml::ser::Error) -> Self {
        Self::TomlSerError(err)
    }
}