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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
//! Transports for communicating with the docker daemon
extern crate hyper;
use hyper::Client;
use hyper::client::Body;
use hyper::client::response::Response;
use hyper::header;
use hyper::mime;
use self::super::{Error, Result};
use self::hyper::buffer::BufReader;
use self::hyper::header::ContentType;
use self::hyper::status::StatusCode;
use hyper::method::Method;
use std::fmt;
use std::io::Read;
use hyperlocal::DomainUrl;
use rustc_serialize::json;
pub fn tar() -> ContentType {
ContentType(mime::Mime(
mime::TopLevel::Application,
mime::SubLevel::Ext(String::from("tar")),
vec![],
))
}
/// Transports are types which define the means of communication
/// with the docker daemon
pub enum Transport {
/// A network tcp interface
Tcp { client: Client, host: String },
/// A Unix domain socket
Unix { client: Client, path: String },
}
impl fmt::Debug for Transport {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Transport::Tcp { ref host, .. } => write!(f, "Tcp({})", host),
Transport::Unix { ref path, .. } => write!(f, "Unix({})", path),
}
}
}
impl Transport {
pub fn request<'a, B>(
&'a self,
method: Method,
endpoint: &str,
body: Option<(B, ContentType)>,
) -> Result<String>
where
B: Into<Body<'a>>,
{
let mut res = self.stream(method, endpoint, body)?;
let mut body = String::new();
res.read_to_string(&mut body)?;
debug!("{} raw response: {}", endpoint, body);
Ok(body)
}
pub fn stream<'c, B>(
&'c self,
method: Method,
endpoint: &str,
body: Option<(B, ContentType)>,
) -> Result<Box<Read>>
where
B: Into<Body<'c>>,
{
let headers = {
let mut headers = header::Headers::new();
headers.set(header::Host {
hostname: "".to_owned(),
port: None,
});
headers
};
let req = match *self {
Transport::Tcp {
ref client,
ref host,
} => client.request(method, &format!("{}{}", host, endpoint)[..]),
Transport::Unix {
ref client,
ref path,
} => client.request(method, DomainUrl::new(&path, endpoint)),
}.headers(headers);
let embodied = match body {
Some((b, c)) => req.header(c).body(b),
_ => req,
};
let mut res = embodied.send()?;
match res.status {
StatusCode::Ok |
StatusCode::Created |
StatusCode::SwitchingProtocols => Ok(Box::new(res)),
StatusCode::NoContent => Ok(Box::new(BufReader::new("".as_bytes()))),
// todo: constantize these
StatusCode::BadRequest => {
Err(Error::Fault {
code: res.status,
message: get_error_message(&mut res).unwrap_or("bad parameter".to_owned()),
})
}
StatusCode::NotFound => {
Err(Error::Fault {
code: res.status,
message: get_error_message(&mut res).unwrap_or("not found".to_owned()),
})
}
StatusCode::NotAcceptable => {
Err(Error::Fault {
code: res.status,
message: get_error_message(&mut res).unwrap_or("not acceptable".to_owned()),
})
}
StatusCode::Conflict => {
Err(Error::Fault {
code: res.status,
message: get_error_message(&mut res).unwrap_or("conflict found".to_owned()),
})
}
StatusCode::InternalServerError => {
Err(Error::Fault {
code: res.status,
message: get_error_message(&mut res).unwrap_or(
"internal server error"
.to_owned(),
),
})
}
_ => unreachable!(),
}
}
}
/// Extract the error message content from an HTTP response that
/// contains a Docker JSON error structure.
fn get_error_message(res: &mut Response) -> Option<String> {
let mut output = String::new();
if res.read_to_string(&mut output).is_ok() {
let json_response = json::Json::from_str(output.as_str()).ok();
let message = json_response
.as_ref()
.and_then(|x| x.as_object())
.and_then(|x| x.get("message"))
.and_then(|x| x.as_string())
.map(|x| x.to_owned());
message
} else {
None
}
}
|
