bollard/swarm.rs
1//! Swarm API: Docker swarm is a container orchestration tool, meaning that it allows the user to manage multiple containers deployed across multiple host machines.
2
3use crate::docker::BodyType;
4
5use hyper::Method;
6
7use bytes::Bytes;
8use http::request::Builder;
9use http_body_util::Full;
10
11use super::Docker;
12use crate::errors::Error;
13
14use crate::models::*;
15
16impl Docker {
17 /// ---
18 ///
19 /// # Init Swarm
20 ///
21 /// Initialize a new swarm.
22 ///
23 /// # Arguments
24 ///
25 /// - [SwarmInitRequest](SwarmInitRequest) struct.
26 ///
27 /// # Returns
28 ///
29 /// - A String wrapped in a Future.
30 ///
31 /// # Examples
32 ///
33 /// ```rust
34 /// # use bollard::Docker;
35 /// # let docker = Docker::connect_with_http_defaults().unwrap();
36 /// use bollard::models::SwarmInitRequest;
37 ///
38 /// use std::default::Default;
39 ///
40 /// let config = SwarmInitRequest {
41 /// advertise_addr: Some("127.0.0.1".to_string()),
42 /// listen_addr: Some("0.0.0.0:2377".to_string()),
43 /// ..Default::default()
44 /// };
45 ///
46 /// docker.init_swarm(config);
47 /// ```
48 pub async fn init_swarm(&self, config: SwarmInitRequest) -> Result<String, Error> {
49 let url = "/swarm/init";
50
51 let req = self.build_request(
52 url,
53 Builder::new().method(Method::POST),
54 None::<String>,
55 Docker::serialize_payload(Some(config)),
56 );
57
58 self.process_into_value(req).await
59 }
60
61 /// ---
62 ///
63 /// # Inspect Swarm
64 ///
65 /// Inspect swarm.
66 ///
67 /// # Arguments
68 ///
69 /// # Returns
70 ///
71 /// - [Swarm](Swarm) struct, wrapped in a Future.
72 ///
73 /// # Examples
74 ///
75 /// ```rust
76 /// # use bollard::Docker;
77 /// # let docker = Docker::connect_with_http_defaults().unwrap();
78 ///
79 /// docker.inspect_swarm();
80 /// ```
81 pub async fn inspect_swarm(&self) -> Result<Swarm, Error> {
82 let url = "/swarm";
83
84 let req = self.build_request(
85 url,
86 Builder::new().method(Method::GET),
87 None::<String>,
88 Ok(BodyType::Left(Full::new(Bytes::new()))),
89 );
90
91 self.process_into_value(req).await
92 }
93
94 /// ---
95 ///
96 /// # Join a Swarm
97 ///
98 /// # Arguments
99 ///
100 /// - [SwarmJoinRequest](SwarmJoinRequest) struct.
101 ///
102 /// # Returns
103 ///
104 /// - unit type `()`, wrapped in a Future.
105 ///
106 /// # Examples
107 ///
108 /// ```rust
109 /// # use bollard::Docker;
110 /// # let docker = Docker::connect_with_http_defaults().unwrap();
111 /// use bollard::models::SwarmJoinRequest;
112 ///
113 /// let config = SwarmJoinRequest {
114 /// advertise_addr: Some("127.0.0.1".to_string()),
115 /// join_token: Some("token".to_string()),
116 /// ..Default::default()
117 /// };
118 /// docker.join_swarm(config);
119 /// ```
120 pub async fn join_swarm(&self, config: SwarmJoinRequest) -> Result<(), Error> {
121 let url = "/swarm/join";
122
123 let req = self.build_request(
124 url,
125 Builder::new().method(Method::POST),
126 None::<String>,
127 Docker::serialize_payload(Some(config)),
128 );
129
130 self.process_into_unit(req).await
131 }
132
133 /// ---
134 ///
135 /// # Leave a Swarm
136 ///
137 /// # Arguments
138 ///
139 /// - Optional [LeaveSwarmOptions](crate::query_parameters::LeaveSwarmOptions) struct.
140 ///
141 /// # Returns
142 ///
143 /// - unit type `()`, wrapped in a Future.
144 ///
145 /// # Examples
146 ///
147 /// ```rust
148 /// # use bollard::Docker;
149 /// # use bollard::query_parameters::LeaveSwarmOptionsBuilder;
150 /// # let docker = Docker::connect_with_http_defaults().unwrap();
151 ///
152 /// let options = LeaveSwarmOptionsBuilder::default()
153 /// .force(true)
154 /// .build();
155 ///
156 /// docker.leave_swarm(Some(options));
157 /// ```
158 pub async fn leave_swarm(
159 &self,
160 options: Option<crate::query_parameters::LeaveSwarmOptions>,
161 ) -> Result<(), Error> {
162 let url = "/swarm/leave";
163
164 let req = self.build_request(
165 url,
166 Builder::new().method(Method::POST),
167 options,
168 Ok(BodyType::Left(Full::new(Bytes::new()))),
169 );
170
171 self.process_into_unit(req).await
172 }
173
174 /// ---
175 ///
176 /// # Update a Swarm
177 ///
178 /// Update a swarm's configuration.
179 ///
180 /// # Arguments
181 ///
182 /// - [SwarmSpec](SwarmSpec) struct.
183 /// - [UpdateSwarmOptions](crate::query_parameters::UpdateSwarmOptions) struct.
184 ///
185 /// # Returns
186 ///
187 /// - unit type `()`, wrapped in a Future.
188 ///
189 /// # Examples
190 ///
191 /// ```rust
192 /// # use bollard::Docker;
193 /// # let docker = Docker::connect_with_http_defaults().unwrap();
194 /// use bollard::query_parameters::UpdateSwarmOptionsBuilder;
195 ///
196 /// let result = async move {
197 /// let swarm = docker.inspect_swarm().await?;
198 /// let version = swarm.version.unwrap().index.unwrap();
199 /// let spec = swarm.spec.unwrap();
200 ///
201 /// let options = UpdateSwarmOptionsBuilder::default()
202 /// .version(version as i64)
203 /// .build();
204 ///
205 /// docker.update_swarm(spec, options).await
206 /// };
207 /// ```
208 pub async fn update_swarm(
209 &self,
210 swarm_spec: SwarmSpec,
211 options: crate::query_parameters::UpdateSwarmOptions,
212 ) -> Result<(), Error> {
213 let url = "/swarm/update";
214
215 let req = self.build_request(
216 url,
217 Builder::new().method(Method::POST),
218 Some(options),
219 Docker::serialize_payload(Some(swarm_spec)),
220 );
221
222 self.process_into_unit(req).await
223 }
224}