podman_api/api/networks.rs
1use crate::{
2 api::ApiResource,
3 conn::{Headers, Payload},
4 models, opts, Result,
5};
6
7use containers_api::url;
8
9impl_api_ty!(
10 Network => name
11);
12
13impl Network {
14 api_doc! {
15 Network => DeleteLibpod
16 |
17 /// Delete this container. To delete this network forcefully use
18 /// [`Network::remove`](Network::remove).
19 ///
20 /// Examples:
21 ///
22 /// ```no_run
23 /// async {
24 /// use podman_api::Podman;
25 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
26 ///
27 /// match podman.networks().get("some-network").delete().await {
28 /// Ok(info) => println!("{:?}", info),
29 /// Err(e) => eprintln!("{}", e),
30 /// }
31 /// };
32 /// ```
33 pub async fn delete(&self) -> Result<Vec<models::NetworkRmReport>> {
34 self.podman
35 .delete_json(&format!("/libpod/networks/{}", &self.name))
36 .await
37 }}
38
39 api_doc! {
40 Network => DeleteLibpod
41 |
42 /// Force remove this network removing associated containers. To delete network normally use
43 /// [`Network::delete`](Network::delete).
44 ///
45 /// Examples:
46 ///
47 /// ```no_run
48 /// async {
49 /// use podman_api::Podman;
50 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
51 ///
52 /// match podman.networks().get("some-network").remove().await {
53 /// Ok(info) => println!("{:?}", info),
54 /// Err(e) => eprintln!("{}", e),
55 /// }
56 /// };
57 /// ```
58 pub async fn remove(&self) -> Result<Vec<models::NetworkRmReport>> {
59 let ep = url::construct_ep(
60 format!("/libpod/networks/{}", &self.name),
61 Some(url::encoded_pair("force", true.to_string())),
62 );
63 self.podman.delete_json(&ep).await
64 }}
65
66 api_doc! {
67 Network => ExistsLibpod
68 |
69 /// Quick way to determine if a network exists by name or id.
70 ///
71 /// Examples:
72 ///
73 /// ```no_run
74 /// async {
75 /// use podman_api::Podman;
76 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
77 ///
78 /// match podman.networks().get("some-network").exists().await {
79 /// Ok(exists) => if exists {
80 /// println!("network exists!");
81 /// } else {
82 /// println!("network doesn't exists!");
83 /// },
84 /// Err(e) => eprintln!("check failed: {}", e),
85 /// }
86 /// };
87 /// ```
88 pub async fn exists(&self) -> Result<bool> {
89 self.podman
90 .resource_exists(ApiResource::Networks, &self.name)
91 .await
92 }}
93
94 api_doc! {
95 Network => InspectLibpod
96 |
97 /// Display low level configuration for this CNI network.
98 ///
99 /// Examples:
100 ///
101 /// ```no_run
102 /// async {
103 /// use podman_api::Podman;
104 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
105 ///
106 /// match podman.networks().get("some-network").inspect().await {
107 /// Ok(info) => println!("{:?}", info),
108 /// Err(e) => eprintln!("{}", e),
109 /// }
110 /// };
111 /// ```
112 pub async fn inspect(&self) -> Result<models::Network> {
113 self.podman
114 .get_json(&format!("/libpod/networks/{}/json", &self.name))
115 .await
116 }}
117
118 api_doc! {
119 Network => DisconnectLibpod
120 |
121 /// Disconnect a container from this network.
122 ///
123 /// Examples:
124 ///
125 /// ```no_run
126 /// async {
127 /// use podman_api::Podman;
128 /// use podman_api::opts::NetworkDisconnectOpts;
129 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
130 ///
131 /// match podman
132 /// .networks()
133 /// .get("some-network")
134 /// .disconnect_container(
135 /// &NetworkDisconnectOpts::builder()
136 /// .container("containerid")
137 /// .force(true)
138 /// .build()
139 /// )
140 /// .await {
141 /// Ok(info) => println!("{:?}", info),
142 /// Err(e) => eprintln!("{}", e),
143 /// }
144 /// };
145 /// ```
146 pub async fn disconnect_container(&self, opts: &opts::NetworkDisconnectOpts) -> Result<()> {
147 self.podman
148 .post(
149 &format!("/libpod/networks/{}/disconnect", &self.name),
150 Payload::Json(opts.serialize_vec()?),
151 Headers::none(),
152 )
153 .await
154 .map(|_| ())
155 }}
156
157 api_doc! {
158 Network => ConnectLibpod
159 |
160 /// Connect a container to this network.
161 ///
162 /// Examples:
163 ///
164 /// ```no_run
165 /// async {
166 /// use podman_api::Podman;
167 /// use podman_api::opts::NetworkConnectOpts;
168 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
169 ///
170 /// match podman
171 /// .networks()
172 /// .get("some-network")
173 /// .connect_container(
174 /// &NetworkConnectOpts::builder()
175 /// .container("containerid")
176 /// .interface_name("eno128")
177 /// .build()
178 /// )
179 /// .await {
180 /// Ok(info) => println!("{:?}", info),
181 /// Err(e) => eprintln!("{}", e),
182 /// }
183 /// };
184 /// ```
185 pub async fn connect_container(&self, opts: &opts::NetworkConnectOpts) -> Result<()> {
186 self.podman
187 .post(
188 &format!("/libpod/networks/{}/connect", &self.name),
189 Payload::Json(opts.serialize_vec()?),
190 Headers::none(),
191 )
192 .await
193 .map(|_| ())
194 }}
195}
196
197impl Networks {
198 api_doc! {
199 Network => CreateLibpod
200 |
201 /// Quick way to determine if a network exists by name or id.
202 ///
203 /// Examples:
204 ///
205 /// ```no_run
206 /// async {
207 /// use podman_api::Podman;
208 /// use podman_api::opts::NetworkCreateOpts;
209 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
210 ///
211 /// match podman
212 /// .networks()
213 /// .create(&NetworkCreateOpts::builder().name("test-network").build())
214 /// .await
215 /// {
216 /// Ok(info) => println!("{:?}", info),
217 /// Err(e) => eprintln!("{}", e),
218 /// }
219 /// };
220 /// ```
221 pub async fn create(&self, opts: &opts::NetworkCreateOpts) -> Result<models::Network> {
222 self.podman
223 .post_json(
224 "/libpod/networks/create",
225 Payload::Json(opts.serialize_vec()?),
226 Headers::none(),
227 )
228 .await
229 }}
230
231 api_doc! {
232 Network => ListLibpod
233 |
234 /// List network configurations.
235 ///
236 /// Examples:
237 ///
238 /// ```no_run
239 /// async {
240 /// use podman_api::Podman;
241 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
242 ///
243 /// match podman.networks().list(&Default::default()).await {
244 /// Ok(networks) => println!("{:?}", networks),
245 /// Err(e) => eprintln!("{}", e),
246 /// }
247 /// };
248 /// ```
249 pub async fn list(&self, opts: &opts::NetworkListOpts) -> Result<Vec<models::Network>> {
250 let ep = url::construct_ep("/libpod/networks/json", opts.serialize());
251 self.podman.get_json(&ep).await
252 }}
253
254 api_doc! {
255 Network => PruneLibpod
256 |
257 /// Delete unused networks.
258 ///
259 /// Examples:
260 ///
261 /// ```no_run
262 /// async {
263 /// use podman_api::Podman;
264 /// let podman = Podman::unix("/run/user/1000/podman/podman.sock");
265 ///
266 /// match podman.networks().prune(&Default::default()).await {
267 /// Ok(report) => println!("{:?}", report),
268 /// Err(e) => eprintln!("{}", e),
269 /// }
270 /// };
271 /// ```
272 pub async fn prune(
273 &self,
274 opts: &opts::NetworkPruneOpts,
275 ) -> Result<Vec<models::NetworkPruneReport>> {
276 let ep = url::construct_ep("/libpod/networks/prune", opts.serialize());
277 self.podman
278 .post_json(&ep, Payload::empty(), Headers::none())
279 .await
280 }}
281}