mirrors/minio-rs
1
0
Fork 0
mirror of https://github.com/minio/minio-rs.git synced 2026-01-22 23:52:07 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add bucket exists API

Browse Source
This commit is contained in:
Aditya Manthramurthy 2019-05-30 17:27:35 -07:00
parent b63c820c66
commit a40a6e15ed
2 changed files with 56 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/main.rs
View File

@ -17,17 +17,23 @@ fn main() {
rt::run(rt::lazy(|| { rt::run(rt::lazy(|| {
// let c = get_local_default_server(); // let c = get_local_default_server();
let c = minio::Client::get_play_client(); let c = minio::Client::get_play_client();
let bucket = "yyy";
let region_req = c let region_req = c
.get_bucket_location("yyy") .get_bucket_location(bucket)
.map(|res| println!("{}", res.to_string())) .map(|res| println!("{}", res.to_string()))
.map_err(|err| println!("{:?}", err)); .map_err(|err| println!("{:?}", err));
let del_req = c let del_req = c
.delete_bucket("yyy") .delete_bucket(bucket)
.map(|_| println!("Deleted!")) .map(|_| println!("Deleted!"))
.map_err(|err| println!("del err: {:?}", err)); .map_err(|err| println!("del err: {:?}", err));
del_req.join(region_req).map(|_| ()) let buc_exists_req = c
.bucket_exists(bucket)
.map(move |e| println!("Bucket {} exists: {}", bucket, e))
.map_err(|err| println!("exists err: {:?}", err));
del_req.join3(region_req, buc_exists_req).map(|_| ())
})); }));
} }

75
src/minio.rs
View File

@ -146,7 +146,32 @@ impl Client {
println!("signout: {:?}", sign_hdrs); println!("signout: {:?}", sign_hdrs);
let req_result = api::mk_request(&s3_req, &self, &sign_hdrs); let req_result = api::mk_request(&s3_req, &self, &sign_hdrs);
let conn_client = self.conn_client.clone(); let conn_client = self.conn_client.clone();
run_req_future(req_result, conn_client) future::result(req_result)
.map_err(|e| Err::HttpErr(e))
.and_then(move |req| conn_client.make_req(req).map_err(|e| Err::HyperErr(e)))
.and_then(|resp| {
let st = resp.status();
if st.is_success() {
Ok(resp)
} else {
Err(Err::RawSvcErr(st, resp))
}
})
.or_else(|err| {
future::err(err)
.or_else(|x| match x {
Err::RawSvcErr(st, resp) => Ok((st, resp)),
other_err => Err(other_err),
})
.and_then(|(st, resp)| {
resp.into_body()
.concat2()
.map_err(|err| Err::HyperErr(err))
.and_then(move |chunk| {
Err(Err::FailStatusCodeErr(st, chunk.into_bytes()))
})
})
})
} }
pub fn get_bucket_location(&self, b: &str) -> impl Future<Item = Region, Error = Err> { pub fn get_bucket_location(&self, b: &str) -> impl Future<Item = Region, Error = Err> {
@ -184,36 +209,30 @@ impl Client {
}; };
self.signed_req_future(s3_req).and_then(|_| Ok(())) self.signed_req_future(s3_req).and_then(|_| Ok(()))
} }
}
fn run_req_future( pub fn bucket_exists(&self, b: &str) -> impl Future<Item = bool, Error = Err> {
req_result: http::Result<Request<Body>>, let s3_req = S3Req {
c: ConnClient, method: Method::HEAD,
) -> impl Future<Item = Response<Body>, Error = Err> { bucket: Some(b.to_string()),
future::result(req_result) object: None,
.map_err(|e| Err::HttpErr(e)) headers: HeaderMap::new(),
.and_then(move |req| c.make_req(req).map_err(|e| Err::HyperErr(e))) query: HashMap::new(),
.and_then(|resp| { body: Body::empty(),
let st = resp.status(); ts: time::now_utc(),
if st.is_success() { };
Ok(resp) self.signed_req_future(s3_req).then(|res| match res {
} else { Ok(_) => Ok(true),
Err(Err::RawSvcErr(st, resp)) Err(Err::FailStatusCodeErr(st, b)) => {
let code = st.as_u16();
if code == 404 {
Ok(false)
} else {
Err(Err::FailStatusCodeErr(st, b))
}
} }
Err(err) => Err(err),
}) })
.or_else(|err| { }
future::err(err)
.or_else(|x| match x {
Err::RawSvcErr(st, resp) => Ok((st, resp)),
other_err => Err(other_err),
})
.and_then(|(st, resp)| {
resp.into_body()
.concat2()
.map_err(|err| Err::HyperErr(err))
.and_then(move |chunk| Err(Err::FailStatusCodeErr(st, chunk.into_bytes())))
})
})
} }
fn b2s(b: Bytes) -> Result<String, Err> { fn b2s(b: Bytes) -> Result<String, Err> {