async_docker 0.1.1

A Rust asynchronous interface for Docker API
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use representation::rep::ImageDetails;
use representation::rep::History;
use Error;
use Result;
use representation::rep::Status;
use serde_json::Value;
use std::borrow::Cow;
use errors::ErrorKind as EK;
use futures::Stream;
use transport::parse::parse_to_trait;
use futures::Future;
use futures::future;
use std::sync::Arc;
use transport::interact::InteractApi;
use transport::interact::InteractApiExt;
use hyper::Chunk;


/// Interface for accessing and manipulating a named docker image
pub struct Image<'b>
{
    interact: Arc<InteractApi>,
    name: Cow<'b, str>,
}

impl<'b> Image<'b>
{
    /// Exports an interface for operations that may be performed against a named image
    pub(crate) fn new<S>(interact: Arc<InteractApi>, name: S) -> Image<'b>
    where
        S: Into<Cow<'b, str>>,
    {
        Image {
            interact,
            name: name.into(),
        }
    }

    /// Inspects a named image's details
    pub fn inspect(&self) -> impl Future<Item=ImageDetails, Error=Error> + Send {
        let args = format!("/images/{}/json", self.name);

        parse_to_trait::<ImageDetails>(self.interact.get(args.as_str()))
    }

    /// Lists the history of the images set of changes
    pub fn history(&self) -> impl Future<Item=History, Error=Error> + Send {
        let args = format!("/images/{}/history", self.name);

        parse_to_trait::<History>(self.interact.get(args.as_str()))
    }

    /// Deletes an image
    pub fn delete(&self) -> impl Future<Item=Vec<Status>, Error=Error> + Send {

        fn parse_array(xs: Vec<Value>) -> Result<Vec<Status>> {
            xs
                .iter()
                .map(|j| {
                    let obj = j
                        .as_object()
                        .ok_or_else(|| Error::from(EK::JsonTypeError("<anonymous>", "Object")))?;


                    if let Some(sha) = obj.get("Untagged") {
                        sha.as_str()
                            .map(|s| Status::Untagged(s.to_owned()))
                            .ok_or_else(|| Error::from(EK::JsonTypeError("Untagged", "String")))
                    } else {
                        obj.get("Deleted")
                            .ok_or_else(|| Error::from(EK::JsonFieldMissing("Deleted' or 'Untagged")))
                            .and_then(|sha| {
                                sha.as_str()
                                    .map(|s| Status::Deleted(s.to_owned()))
                                    .ok_or_else(|| Error::from(EK::JsonTypeError("Deleted", "String")))
                            })
                    }
                })
                .collect()
        }

        let args = format!("/images/{}", self.name);

        parse_to_trait::<Value>(self.interact.delete(args.as_str()))
            .and_then(|val|
                match val {
                    Value::Array(xs) => future::result(parse_array(xs)),
                    _ => unreachable!(),
                }
            )
    }

    /// Export this image to a tarball
    pub fn export(&self) -> impl Stream<Item=Chunk, Error=Error> + Send {
        let path = format!("/images/{}/get", self.name);

        self.interact.get(path.as_str())
            .and_then(|a| a.map_err(Error::from))
            .and_then(|a| Ok(a.into_body().map_err(Error::from)))
            .flatten_stream()
    }
}