komodo_client 2.1.0

Client for the Komodo build and deployment system
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

use mogh_resolver::Resolve;
use serde::{Deserialize, Serialize};
use typeshare::typeshare;

use crate::entities::{
  procedure::{_PartialProcedureConfig, Procedure},
  update::Update,
};

use super::KomodoWriteRequest;

//

#[cfg(feature = "utoipa")]
#[utoipa::path(
  post,
  path = "/CreateProcedure",
  description = "Create a procedure.",
  request_body(content = CreateProcedure),
  responses(
    (status = 200, description = "The new procedure", body = crate::entities::procedure::ProcedureSchema),
  ),
)]
pub fn create_procedure() {}

/// Create a procedure. Response: [Procedure].
#[typeshare]
#[derive(Serialize, Deserialize, Debug, Clone, Resolve)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
#[empty_traits(KomodoWriteRequest)]
#[response(CreateProcedureResponse)]
#[error(mogh_error::Error)]
pub struct CreateProcedure {
  /// The name given to newly created build.
  pub name: String,
  /// Optional partial config to initialize the procedure with.
  #[serde(default)]
  pub config: _PartialProcedureConfig,
}

#[typeshare]
pub type CreateProcedureResponse = Procedure;

//

/// Creates a new procedure with given `name` and the configuration
/// of the procedure at the given `id`. Response: [Procedure].
#[typeshare]
#[derive(Serialize, Deserialize, Debug, Clone, Resolve)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
#[empty_traits(KomodoWriteRequest)]
#[response(CopyProcedureResponse)]
#[error(mogh_error::Error)]
pub struct CopyProcedure {
  /// The name of the new procedure.
  pub name: String,
  /// The id of the procedure to copy.
  pub id: String,
}

#[typeshare]
pub type CopyProcedureResponse = Procedure;

//
//
#[cfg(feature = "utoipa")]
#[utoipa::path(
  post,
  path = "/CopyProcedure",
  description = "Copy a procedure.",
  request_body(content = CopyProcedure),
  responses(
    (status = 200, description = "The new procedure", body = crate::entities::procedure::ProcedureSchema),
  ),
)]
pub fn copy_procedure() {}

//
#[cfg(feature = "utoipa")]
#[utoipa::path(
  post,
  path = "/DeleteProcedure",
  description = "Delete a procedure.",
  request_body(content = DeleteProcedure),
  responses(
    (status = 200, description = "The deleted procedure", body = crate::entities::procedure::ProcedureSchema),
  ),
)]
pub fn delete_procedure() {}

/// Deletes the procedure at the given id, and returns the deleted procedure.
/// Response: [Procedure]
#[typeshare]
#[derive(Serialize, Deserialize, Debug, Clone, Resolve)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
#[empty_traits(KomodoWriteRequest)]
#[response(DeleteProcedureResponse)]
#[error(mogh_error::Error)]
pub struct DeleteProcedure {
  /// The id or name of the procedure to delete.
  pub id: String,
}

#[typeshare]
pub type DeleteProcedureResponse = Procedure;

//

#[cfg(feature = "utoipa")]
#[utoipa::path(
  post,
  path = "/UpdateProcedure",
  description = "Update a procedure.",
  request_body(content = UpdateProcedure),
  responses(
    (status = 200, description = "The updated procedure", body = crate::entities::procedure::ProcedureSchema),
  ),
)]
pub fn update_procedure() {}

/// Update the procedure at the given id, and return the updated procedure.
/// Response: [Procedure].
///
/// Note. This method updates only the fields which are set in the [_PartialProcedureConfig],
/// effectively merging diffs into the final document.
/// This is helpful when multiple users are using
/// the same resources concurrently by ensuring no unintentional
/// field changes occur from out of date local state.
#[typeshare]
#[derive(Serialize, Deserialize, Debug, Clone, Resolve)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
#[empty_traits(KomodoWriteRequest)]
#[response(UpdateProcedureResponse)]
#[error(mogh_error::Error)]
pub struct UpdateProcedure {
  /// The id of the procedure to update.
  pub id: String,
  /// The partial config update.
  pub config: _PartialProcedureConfig,
}

#[typeshare]
pub type UpdateProcedureResponse = Procedure;

//

#[cfg(feature = "utoipa")]
#[utoipa::path(
  post,
  path = "/RenameProcedure",
  description = "Rename a procedure.",
  request_body(content = RenameProcedure),
  responses(
    (status = 200, description = "The update", body = Update),
  ),
)]
pub fn rename_procedure() {}

/// Rename the Procedure at id to the given name.
/// Response: [Update].
#[typeshare]
#[derive(Serialize, Deserialize, Debug, Clone, Resolve)]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
#[empty_traits(KomodoWriteRequest)]
#[response(Update)]
#[error(mogh_error::Error)]
pub struct RenameProcedure {
  /// The id or name of the Procedure to rename.
  pub id: String,
  /// The new name.
  pub name: String,
}