rs_docker_api_rs/api/
swarm.rs

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
//! Control and manage clusters of engines also known as Swarm

use crate::{
    conn::{Headers, Payload},
    models,
    opts::{SwarmInitOpts, SwarmJoinOpts},
    Docker, Result,
};

api_doc! { Swarm
|
pub struct Swarm {
    docker: Docker,
}
}

impl Swarm {
    pub fn new(docker: Docker) -> Self {
        Self { docker }
    }

    impl_api_ep! {_swarm: Swarm, resp
        Inspect -> "/swarm", rs_docker_api_stubs::models::Swarm
    }

    api_doc! { Swarm => Unlockkey
    |
    /// Get the unlock key.
    pub async fn get_unlock_key(&self) -> Result<models::SwarmUnlockkey200Response> {
        self.docker.get_json("/swarm/unlockkey").await
    }}

    api_doc! { Swarm => Unlock
    |
    /// Unlock a locked manager.
    pub async fn unlock_manager(&self, key: &models::SwarmUnlockBodyParam) -> Result<()> {
        self.docker
            .post("/swarm/unlock", Payload::Json(serde_json::to_string(key)?), Headers::none())
            .await
            .map(|_| ())
    }}

    api_doc! { Swarm => Init
    |
    /// Initialize a new swarm.
    pub async fn initialize(&self, opts: &SwarmInitOpts) -> Result<()> {
        self.docker
            .post("/swarm/init", Payload::Json(opts.serialize_vec()?), Headers::none())
            .await
            .map(|_| ())
    }}

    api_doc! { Swarm => Join
    |
    /// Join an existing swarm.
    pub async fn join(&self, opts: &SwarmJoinOpts) -> Result<()> {
        self.docker
            .post("/swarm/join", Payload::Json(opts.serialize_vec()?), Headers::none())
            .await
            .map(|_| ())
    }}

    api_doc! { Swarm => Leave
    |
    /// Leave the current swarm.
    pub async fn leave(&self) -> Result<()> {
        self.docker
            .post("/swarm/leave?force=false", Payload::empty(), Headers::none())
            .await
            .map(|_| ())
    }}

    api_doc! { Swarm => Leave
    |
    /// Leave the current swarm forcefully, even if this is the last manager or that it will break the cluster.
    pub async fn force_leave(&self) -> Result<()> {
        self.docker
            .post("/swarm/leave?force=true", Payload::empty(), Headers::none())
            .await
            .map(|_| ())
    }}
}