passivized_docker_engine_client 0.0.10-alpha

Docker Engine Client - manage and run containers, images, and volumes.
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

use hyper::StatusCode;

use crate::DockerEngineClient;
use crate::errors::DecUseError;
use crate::imp::content_type;
use crate::model::Tar;
use crate::responses::FileSystemChange;

pub struct DecContainerFiles<'a> {
    pub(super) client: &'a DockerEngineClient,
    pub(super) container_id: &'a String
}

impl <'a> DecContainerFiles<'a> {

    /// Get a list of changes to a container's file system.
    ///
    /// # Example
    ///
    /// ```rust
    /// use passivized_docker_engine_client::DockerEngineClient;
    /// use passivized_docker_engine_client::errors::DecError;
    ///
    /// async fn example() -> Result<(), DecError> {
    ///     let dec = DockerEngineClient::new()?;
    ///
    ///     let changes = dec.container("example").files().changes().await?;
    ///
    ///     for change in changes {
    ///         println!("{:?}", change);
    ///     }
    ///
    ///     Ok(())
    /// }
    /// ```
    pub async fn changes(&self) -> Result<Vec<FileSystemChange>, DecUseError> {
        let uri = self.client.url.containers().files(self.container_id).changes();
        let response = self.client.http.get(uri)?.execute().await?;

        let result: Option<Vec<FileSystemChange>> = response
            .assert_item_status(StatusCode::OK)?
            .parse()?;

        Ok(result.unwrap_or_default())
    }

    /// Get files from inside the container, described by the path, and assemble them into a tar file.
    pub async fn get<P: Into<String>>(&self, path: P) -> Result<Tar, DecUseError> {
        let uri = self.client.url.containers().files(self.container_id).get(path);
        let response = self.client.http.get(uri)?.execute().await?;

        response
            .assert_item_status(StatusCode::OK)?
            .assert_content_type(content_type::TAR)?
            .parse_with(|r| Ok(Tar(r.body.to_vec())))
    }

    #[cfg(not(windows))]
    pub async fn put<P: Into<String>>(&self, path: P, content: Tar) -> Result<(), DecUseError> {
        let uri = self.client.url.containers().files(self.container_id).put(path);
        let response = self.client.http.put(uri, "application/x-tar", content.0)?.execute().await?;

        response
            .assert_unit_status(StatusCode::OK)
    }
}