rise-deploy 0.16.1

A simple and powerful CLI for deploying containerized applications
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Project API request/response types and client functions

use serde::{Deserialize, Serialize};

/// Project status
#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub enum ProjectStatus {
    Running,
    Stopped,
    Deploying,
    Failed,
    Deleting,
}

impl std::fmt::Display for ProjectStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ProjectStatus::Running => write!(f, "Running"),
            ProjectStatus::Stopped => write!(f, "Stopped"),
            ProjectStatus::Deploying => write!(f, "Deploying"),
            ProjectStatus::Failed => write!(f, "Failed"),
            ProjectStatus::Deleting => write!(f, "Deleting"),
        }
    }
}

/// Project resource
#[derive(Debug, Deserialize, Serialize)]
pub struct Project {
    pub id: String,
    pub name: String,
    pub status: ProjectStatus,
    pub access_class: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub owner: Option<OwnerInfo>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_deployment_status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub primary_url: Option<String>,
    #[serde(default)]
    pub custom_domain_urls: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deployment_groups: Option<Vec<String>>,
    #[serde(default)]
    pub finalizers: Vec<String>,
    #[serde(default)]
    pub app_users: Vec<UserInfo>,
    #[serde(default)]
    pub app_teams: Vec<TeamInfo>,
}

/// User information in owner context
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct UserInfo {
    pub id: String,
    pub email: String,
}

/// Team information in owner context
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct TeamInfo {
    pub id: String,
    pub name: String,
}

/// Owner information (user or team)
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum OwnerInfo {
    User(UserInfo),
    Team(TeamInfo),
}

/// Error response from project API
#[derive(Debug, Deserialize)]
pub struct ProjectErrorResponse {
    pub error: String,
    pub suggestions: Option<Vec<String>>,
}

/// Response from project create endpoint
#[derive(Debug, Deserialize)]
pub struct CreateProjectResponse {
    pub project: Project,
}

/// Response from project update endpoint
#[derive(Debug, Deserialize)]
pub struct UpdateProjectResponse {
    pub project: Project,
}

/// Request for updating a project
#[derive(Debug, Serialize)]
pub struct UpdateProjectRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub access_class: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub owner: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_users: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_teams: Option<Vec<String>>,
}

/// Domain item in list response
#[derive(Debug, Deserialize)]
pub struct DomainItem {
    pub domain: String,
}

/// Response from domains list endpoint
#[derive(Debug, Deserialize)]
pub struct DomainsResponse {
    pub domains: Vec<DomainItem>,
}

/// Environment variable item
#[derive(Debug, Deserialize)]
pub struct EnvVarItem {
    pub key: String,
    pub is_secret: bool,
}

/// Response from env vars list endpoint
#[derive(Debug, Deserialize)]
pub struct EnvVarsResponse {
    pub env_vars: Vec<EnvVarItem>,
}

/// Current user information
#[derive(Debug, Deserialize)]
pub struct MeResponse {
    #[allow(dead_code)]
    pub id: String,
    #[allow(dead_code)]
    pub email: String,
}