podman_api/api/pods.rs
1use crate::{
2 api::ApiResource,
3 conn::{Headers, Payload},
4 models, opts, Result, Stream, Value,
5};
6
7use containers_api::url;
8
9impl_api_ty!(
10 Pod => id
11);
12
13impl Pod {
14 api_doc! {
15 Pod => StartLibpod
16 |
17 /// Start this pod.
18 ///
19 /// Parameters:
20 /// * detach_keys - Override the key sequence for detaching a pod. Format is a single
21 /// character [a-Z] or ctrl- where is one of: a-z, @, ^, [, , or _.
22 ///
23 /// Examples:
24 ///
25 /// ```no_run
26 /// async {
27 /// use podman_api::Podman;
28 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
29 ///
30 /// if let Err(e) = podman.pods().get("79c93f220e3e").start().await {
31 /// eprintln!("{}", e);
32 /// }
33 /// };
34 /// ```
35 pub async fn start(&self) -> Result<models::PodStartReport> {
36 self.podman
37 .post_json(
38 &format!("/libpod/pods/{}/start", &self.id),
39 Payload::empty(),
40 Headers::none(),
41 )
42 .await
43 }}
44
45 async fn _stop(&self, timeout: Option<usize>) -> Result<models::PodStopReport> {
46 let ep = url::construct_ep(
47 format!("/libpod/pods/{}/stop", &self.id),
48 timeout.map(|t| url::encoded_pair("t", t.to_string())),
49 );
50 self.podman
51 .post_json(&ep, Payload::empty(), Headers::none())
52 .await
53 }
54
55 api_doc! {
56 Pod => StopLibpod
57 |
58 /// Stop this pod.
59 ///
60 /// Examples:
61 ///
62 /// ```no_run
63 /// async {
64 /// use podman_api::Podman;
65 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
66 ///
67 /// if let Err(e) = podman.pods().get("79c93f220e3e").stop().await {
68 /// eprintln!("{}", e);
69 /// }
70 /// };
71 /// ```
72 pub async fn stop(&self) -> Result<models::PodStopReport> {
73 self._stop(None).await
74 }}
75
76 api_doc! {
77 Pod => StopLibpod
78 |
79 /// Stop this pod with a timeout.
80 ///
81 /// Examples:
82 ///
83 /// ```no_run
84 /// async {
85 /// use podman_api::Podman;
86 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
87 ///
88 /// if let Err(e) = podman.pods().get("79c93f220e3e").stop_with_timeout(10).await {
89 /// eprintln!("{}", e);
90 /// }
91 /// };
92 /// ```
93 pub async fn stop_with_timeout(&self, t: usize) -> Result<models::PodStopReport> {
94 self._stop(Some(t)).await
95 }}
96
97 api_doc! {
98 Pod => InspectLibpod
99 |
100 /// Return low-level information about this pod.
101 ///
102 /// Examples:
103 ///
104 /// ```no_run
105 /// async {
106 /// use podman_api::Podman;
107 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
108 ///
109 /// match podman.pods().get("79c93f220e3e").inspect().await {
110 /// Ok(info) => println!("{:?}", info),
111 /// Err(e) => eprintln!("{}", e),
112 /// }
113 /// };
114 /// ```
115 pub async fn inspect(&self) -> Result<models::PodInspectResponse> {
116 self.podman
117 .get_json(&format!("/libpod/pods/{}/json", &self.id))
118 .await
119 }}
120
121 api_doc! {
122 Pod => KillLibpod
123 |
124 /// Send a signal to this pod.
125 ///
126 /// Examples:
127 ///
128 /// ```no_run
129 /// async {
130 /// use podman_api::Podman;
131 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
132 ///
133 /// if let Err(e) = podman.pods().get("79c93f220e3e").send_signal("SIGINT").await {
134 /// eprintln!("{}", e);
135 /// }
136 /// };
137 /// ```
138 pub async fn send_signal(&self, signal: impl Into<String>) -> Result<models::PodKillReport> {
139 let ep = url::construct_ep(
140 format!("/libpod/pods/{}/kill", &self.id),
141 Some(url::encoded_pair("signal", signal.into())),
142 );
143 self.podman
144 .post_json(&ep, Payload::empty(), Headers::none())
145 .await
146 }}
147
148 api_doc! {
149 Pod => KillLibpod
150 |
151 /// Kill this pod.
152 ///
153 /// Examples:
154 ///
155 /// ```no_run
156 /// async {
157 /// use podman_api::Podman;
158 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
159 ///
160 /// if let Err(e) = podman.pods().get("79c93f220e3e").kill().await {
161 /// eprintln!("{}", e);
162 /// }
163 /// };
164 /// ```
165 pub async fn kill(&self) -> Result<models::PodKillReport> {
166 self.send_signal("SIGKILL").await
167 }}
168
169 api_doc! {
170 Pod => PauseLibpod
171 |
172 /// Pause this pod.
173 ///
174 /// Examples:
175 ///
176 /// ```no_run
177 /// async {
178 /// use podman_api::Podman;
179 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
180 ///
181 /// if let Err(e) = podman.pods().get("79c93f220e3e").pause().await {
182 /// eprintln!("{}", e);
183 /// }
184 /// };
185 /// ```
186 pub async fn pause(&self) -> Result<models::PodPauseReport> {
187 self.podman
188 .post_json(
189 &format!("/libpod/pods/{}/pause", &self.id),
190 Payload::empty(),
191 Headers::none(),
192 )
193 .await
194 }}
195
196 api_doc! {
197 Pod => UnpauseLibpod
198 |
199 /// Unpause this pod
200 ///
201 /// Examples:
202 ///
203 /// ```no_run
204 /// async {
205 /// use podman_api::Podman;
206 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
207 ///
208 /// if let Err(e) = podman.pods().get("79c93f220e3e").unpause().await {
209 /// eprintln!("{}", e);
210 /// }
211 /// };
212 /// ```
213 pub async fn unpause(&self) -> Result<models::PodUnpauseReport> {
214 self.podman
215 .post_json(
216 &format!("/libpod/pods/{}/unpause", &self.id),
217 Payload::empty(),
218 Headers::none(),
219 )
220 .await
221 }}
222
223 api_doc! {
224 Pod => RestartLibpod
225 |
226 /// Restart this pod.
227 ///
228 /// Examples:
229 ///
230 /// ```no_run
231 /// async {
232 /// use podman_api::Podman;
233 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
234 ///
235 /// if let Err(e) = podman.pods().get("79c93f220e3e").restart().await {
236 /// eprintln!("{}", e);
237 /// }
238 /// };
239 /// ```
240 pub async fn restart(&self) -> Result<models::PodRestartReport> {
241 let ep = format!("/libpod/pods/{}/restart", &self.id);
242 self.podman
243 .post_json(&ep, Payload::empty(), Headers::none())
244 .await
245 }}
246
247 async fn _delete(&self, force: bool) -> Result<models::PodRmReport> {
248 let ep = url::construct_ep(
249 format!("/libpod/pods/{}", &self.id),
250 Some(url::encoded_pair("force", force.to_string())),
251 );
252 self.podman.delete_json(&ep).await
253 }
254
255 api_doc! {
256 Pod => DeleteLibpod
257 |
258 /// Delete this pod.
259 ///
260 /// Examples:
261 ///
262 /// ```no_run
263 /// async {
264 /// use podman_api::Podman;
265 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
266 ///
267 /// if let Err(e) = podman.pods().get("79c93f220e3e").delete().await {
268 /// eprintln!("{}", e);
269 /// }
270 /// };
271 /// ```
272 pub async fn delete(&self) -> Result<models::PodRmReport> {
273 self._delete(false).await
274 }}
275
276 api_doc! {
277 Pod => DeleteLibpod
278 |
279 /// Force remove this pod.
280 ///
281 /// Examples:
282 ///
283 /// ```no_run
284 /// async {
285 /// use podman_api::Podman;
286 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
287 ///
288 /// if let Err(e) = podman.pods().get("79c93f220e3e").remove().await {
289 /// eprintln!("{}", e);
290 /// }
291 /// };
292 /// ```
293 pub async fn remove(&self) -> Result<models::PodRmReport> {
294 self._delete(true).await
295 }}
296
297 api_doc! {
298 Pod => ExistsLibpod
299 |
300 /// Quick way to determine if a pod exists by name or ID.
301 ///
302 /// Examples:
303 ///
304 /// ```no_run
305 /// async {
306 /// use podman_api::Podman;
307 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
308 ///
309 /// match podman.pods().get("79c93f220e3e").exists().await {
310 /// Ok(exists) => if exists {
311 /// println!("pod exists!");
312 /// } else {
313 /// println!("pod doesn't exists!");
314 /// },
315 /// Err(e) => eprintln!("check failed: {}", e),
316 /// }
317 /// };
318 /// ```
319 pub async fn exists(&self) -> Result<bool> {
320 self.podman
321 .resource_exists(ApiResource::Pods, &self.id)
322 .await
323 }}
324
325 api_doc! {
326 Pod => TopLibpod
327 |
328 /// List processes inside this pod.
329 ///
330 /// Examples:
331 ///
332 /// ```no_run
333 /// async {
334 /// use podman_api::Podman;
335 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
336 ///
337 /// match podman.pods().get("79c93f220e3e").top(&Default::default()).await {
338 /// Ok(info) => println!("{:?}", info),
339 /// Err(e) => eprintln!("{}", e),
340 /// }
341 /// };
342 /// ```
343 pub async fn top(&self, opts: &opts::PodTopOpts) -> Result<models::PodTopResponse> {
344 let ep = url::construct_ep(format!("/libpod/pods/{}/top", &self.id), opts.serialize());
345 self.podman.get_json(&ep).await
346 }}
347
348 api_doc! {
349 Pod => TopLibpod
350 |
351 /// List processes inside this pod.
352 ///
353 /// Only supported as of version > 4.0
354 ///
355 /// Examples:
356 ///
357 /// ```no_run
358 /// async {
359 /// use podman_api::Podman;
360 /// use futures_util::StreamExt;
361 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
362 ///
363 /// let pod = podman.pods().get("79c93f220e3e");
364 /// let mut stream = pod.top_stream(&Default::default());
365 /// while let Some(chunk) = stream.next().await {
366 /// match chunk{
367 /// Ok(chunk) => println!("{:?}", chunk),
368 /// Err(e) => eprintln!("{}", e),
369 /// }
370 /// }
371 /// };
372 /// ```
373 pub fn top_stream(
374 &self,
375 opts: &opts::PodTopOpts,
376 ) -> impl Stream<Item = Result<models::PodTopResponse>> + Unpin + '_ {
377 let ep = url::construct_ep(
378 format!("/libpod/pods/{}/top", &self.id),
379 opts.stream().serialize(),
380 );
381 Box::pin(self.podman.get_json_stream(ep))
382 }}
383
384 api_doc! {
385 Generate => SystemdLibpod
386 |
387 /// Generate Systemd Units based on this pod.
388 ///
389 /// Examples:
390 ///
391 /// ```no_run
392 /// async {
393 /// use podman_api::Podman;
394 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
395 ///
396 /// match podman
397 /// .pods()
398 /// .get("ea03584c0fd6")
399 /// .generate_systemd_units(&Default::default())
400 /// .await
401 /// {
402 /// Ok(info) => println!("{:?}", info),
403 /// Err(e) => eprintln!("{}", e),
404 /// }
405 /// };
406 /// ```
407 pub async fn generate_systemd_units(
408 &self,
409 opts: &opts::SystemdUnitsOpts,
410 ) -> Result<Value> {
411 self.podman.generate_systemd_units(opts, &self.id).await
412 }}
413
414 api_doc! {
415 Generate => KubeLibpod
416 |
417 /// Generate Kubernetes YAML based on this pod
418 ///
419 /// Parameters:
420 /// * service - Generate YAML for a Kubernetes service object.
421 ///
422 /// Examples:
423 ///
424 /// ```no_run
425 /// async {
426 /// use podman_api::Podman;
427 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
428 ///
429 /// match podman
430 /// .pods()
431 /// .get("fc93f220e3e")
432 /// .generate_kube_yaml(false)
433 /// .await
434 /// {
435 /// Ok(yaml) => println!("{:?}", yaml),
436 /// Err(e) => eprintln!("{}", e),
437 /// }
438 /// };
439 /// ```
440 pub async fn generate_kube_yaml(&self, service: bool) -> Result<String> {
441 self.podman.generate_kube_yaml(service, &self.id).await
442 }}
443}
444
445impl Pods {
446 api_doc! {
447 Pod => ListLibpod
448 |
449 /// Returns a list of pods.
450 ///
451 /// Examples:
452 ///
453 /// ```no_run
454 /// async {
455 /// use podman_api::Podman;
456 /// use podman_api::opts::{PodListOpts, PodListFilter};
457 /// use podman_api::models::PodStatus;
458 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
459 ///
460 /// for pod in podman
461 /// .pods()
462 /// .list(
463 /// &PodListOpts::builder()
464 /// .filter([PodListFilter::Status(PodStatus::Degraded)])
465 /// .build(),
466 /// )
467 /// .await
468 /// .unwrap()
469 /// {
470 /// println!("{:?}", pod);
471 /// }
472 /// };
473 /// ```
474 pub async fn list(&self, opts: &opts::PodListOpts) -> Result<Vec<models::ListPodsReport>> {
475 let ep = url::construct_ep("/libpod/pods/json", opts.serialize());
476 self.podman.get_json(&ep).await
477 }}
478
479 api_doc! {
480 Pod => ListLibpod
481 |
482 /// Returns a list of pods.
483 ///
484 /// Examples:
485 ///
486 /// ```no_run
487 /// async {
488 /// use podman_api::Podman;
489 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
490 ///
491 /// match podman.pods().prune().await {
492 /// Ok(info) => println!("{:?}", info),
493 /// Err(e) => eprintln!("{}", e),
494 /// }
495 /// };
496 /// ```
497 pub async fn prune(&self) -> Result<Vec<models::PodPruneReport>> {
498 self.podman.get_json("/libpod/pods/prune").await
499 }}
500
501 api_doc! {
502 Pod => StatsAllLibpod
503 |
504 /// Display a live stream of resource usage statistics for the containers in one or more pods.
505 ///
506 /// Examples:
507 ///
508 /// ```no_run
509 /// async {
510 /// use podman_api::Podman;
511 /// use podman_api::opts::PodStatsOpts;
512 /// use futures_util::StreamExt;
513 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
514 ///
515 /// let pods = podman.pods();
516 /// let mut stream = pods.stats(&PodStatsOpts::builder().all(true).build());
517 /// while let Some(chunk) = stream.next().await {
518 /// match chunk{
519 /// Ok(chunk) => println!("{:?}", chunk),
520 /// Err(e) => eprintln!("{}", e),
521 /// }
522 /// }
523 /// };
524 /// ```
525 pub fn stats(
526 &self,
527 opts: &opts::PodStatsOpts,
528 ) -> impl Stream<Item = Result<models::PodStatsResponse>> + Unpin + '_ {
529 let opts = opts.stream();
530 let ep = url::construct_ep("/libpod/pods/stats", opts.serialize());
531 Box::pin(self.podman.get_json_stream(ep))
532 }}
533
534 api_doc! {
535 Pod => CreateLibpod
536 |
537 /// Create a pod with specified options.
538 ///
539 /// Examples:
540 ///
541 /// ```no_run
542 /// async {
543 /// use podman_api::Podman;
544 /// use podman_api::opts::PodCreateOpts;
545 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
546 ///
547 /// match podman
548 /// .pods()
549 /// .create(&PodCreateOpts::builder().name("my-pod").build())
550 /// .await
551 /// {
552 /// Ok(pod) => { /* do something with the pod */ }
553 /// Err(e) => eprintln!("{}", e),
554 /// }
555 /// };
556 /// ```
557 pub async fn create(&self, opts: &opts::PodCreateOpts) -> Result<Pod> {
558 self.podman
559 .post_json(
560 &"/libpod/pods/create",
561 Payload::Json(opts.serialize_vec()?),
562 Headers::none(),
563 )
564 .await
565 .map(|resp: models::IdResponse| Pod::new(self.podman.clone(), resp.id))
566 }}
567}