[ADD] working test

src/main.rs

@@ -35,30 +35,40 @@ fn main() {
     rt::run(rt::lazy(|| {
         // let c = get_local_default_server();
         let c = minio::Client::get_play_client();
-        let bucket = "yyy";
+        let bucket = "000";
+        let file = "lulu";
 
-        let region_req = c
+        // let region_req = c
-            .get_bucket_location(bucket)
+        //     .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
+        //     .delete_bucket(bucket)
+        //     .map(|_| println!("Deleted!"))
+        //     .map_err(|err| println!("del err: {:?}", err));
 
-        let del_req = c
+        // let buc_exists_req = c
-            .delete_bucket(bucket)
+        //     .bucket_exists(bucket)
-            .map(|_| println!("Deleted!"))
+        //     .map(move |e| println!("Bucket {} exists: {}", bucket, e))
-            .map_err(|err| println!("del err: {:?}", err));
+        //     .map_err(|err| println!("exists err: {:?}", err));
+        //
+        // let make_bucket_req = c
+        //     .make_bucket(bucket)
+        //     .map(move |_| println!("Bucket {} created", bucket))
+        //     .map_err(move |err| println!("Bucket create for {} failed with {:?}", bucket, err));
+        //
+        // let download_req = c
+        //     .get_object_req(bucket, "issue", vec![])
+        //     .and_then(|g| {
+        //         println!("issue: {} {} {:?}", g.object_size, g.etag, g.content_type);
+        //         g.get_object_stream().concat2()
+        //     })
+        //     .map(|c| println!("get obj res: {:?}", c))
+        //     .map_err(|c| println!("err res: {:?}", c));
 
-        let buc_exists_req = c
+        let upload_req = c
-            .bucket_exists(bucket)
+            .put_object_req(bucket, file, vec![], "ca marche lulu!!".as_bytes().to_vec())
-            .map(move |e| println!("Bucket {} exists: {}", bucket, e))
-            .map_err(|err| println!("exists err: {:?}", err));
-
-        let make_bucket_req = c
-            .make_bucket(bucket)
-            .map(move |_| println!("Bucket {} created", bucket))
-            .map_err(move |err| println!("Bucket create for {} failed with {:?}", bucket, err));
-
-        let download_req = c
-            .get_object_req(bucket, "issue", vec![])
             .and_then(|g| {
                 println!("issue: {} {} {:?}", g.object_size, g.etag, g.content_type);
                 g.get_object_stream().concat2()
@@ -66,28 +76,29 @@ fn main() {
             .map(|c| println!("get obj res: {:?}", c))
             .map_err(|c| println!("err res: {:?}", c));
 
-        let list_buckets_req = c
+        // let list_buckets_req = c
-            .list_buckets()
+        //     .list_buckets()
-            .map(|buckets| {
+        //     .map(|buckets| {
-                println!(
+        //         println!(
-                    "{:?}",
+        //             "{:?}",
-                    buckets
+        //             buckets
-                        .iter()
+        //                 .iter()
-                        .map(|bucket: &BucketInfo| bucket.name.clone())
+        //                 .map(|bucket: &BucketInfo| bucket.name.clone())
-                        .collect::<Vec<String>>()
+        //                 .collect::<Vec<String>>()
-                )
+        //         )
-            })
+        //     })
-            .map_err(|err| println!("{:?}", err));
+        //     .map_err(|err| println!("{:?}", err));
 
-        let list_objects_req = c
+        // let list_objects_req = c
-            .list_objects(bucket, None, None, None, None)
+        //     .list_objects(bucket, None, None, None, None)
-            .map(|l_obj_resp| println!("{:?} {:?}", l_obj_resp, l_obj_resp.object_infos.len()))
+        //     .map(|l_obj_resp| println!("{:?} {:?}", l_obj_resp, l_obj_resp.object_infos.len()))
-            .map_err(|err| println!("{:?}", err));
+        //     .map_err(|err| println!("{:?}", err));
 
-        del_req
+        // del_req
-            .join5(make_bucket_req, region_req, buc_exists_req, download_req)
+        //     .join2(upload_req)
-            .map(|_| ())
+        //     .map(|_| ())
-            .and_then(|_| list_buckets_req)
+        //     .and_then(|_| list_buckets_req)
-            .then(|_| list_objects_req)
+        //     .then(|_| list_objects_req)
+        upload_req
     }));
 }

src/minio.rs

@@ -180,9 +180,12 @@ impl Client {
                 s3_req.body = body;
                 let sign_hdrs = sign::sign_v4(&s3_req, creds, region);
                 debug!("signout: {:?}", sign_hdrs);
-                api::mk_request(&s3_req, &server_addr, &sign_hdrs)
+                api::mk_request(s3_req, &server_addr, &sign_hdrs)
+            })
+            .and_then(move |req| {
+                println!("{:?}", req);
+                conn_client.make_req(req).map_err(|e| Err::HyperErr(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() {
@@ -303,6 +306,37 @@ impl Client {
             .and_then(GetObjectResp::new)
     }
 
+    pub fn put_object_req(
+        &self,
+        bucket_name: &str,
+        key: &str,
+        get_obj_opts: Vec<(HeaderName, HeaderValue)>,
+        data: Vec<u8>,
+    ) -> impl Future<Item = GetObjectResp, Error = Err> {
+        let mut h = HeaderMap::new();
+        get_obj_opts
+            .iter()
+            .map(|(x, y)| (x.clone(), y.clone()))
+            .for_each(|(k, v)| {
+                h.insert(k, v);
+            });
+
+        let s3_req = S3Req {
+            method: Method::PUT,
+            bucket: Some(bucket_name.to_string()),
+            object: Some(key.to_string()),
+            headers: h,
+            query: Values::new(),
+            body: Body::from(data.clone()),
+            ts: time::now_utc(),
+        };
+
+        println!("BBBBBBBBBODAAAAAAAAAYY: {:?}", Body::from(data.clone()));
+
+        self.signed_req_future(s3_req, Ok(Body::from(data)))
+            .and_then(GetObjectResp::new)
+    }
+
     pub fn make_bucket(&self, bucket_name: &str) -> impl Future<Item = (), Error = Err> {
         let xml_body_res = xml::get_mk_bucket_body();
         let bucket = bucket_name.clone().to_string();

src/minio/api.rs

@@ -20,14 +20,14 @@ use hyper::{header::HeaderName, header::HeaderValue, Body, Request};
 use log::debug;
 
 pub fn mk_request(
-    r: &minio::S3Req,
+    r: minio::S3Req,
     svr_str: &str,
     sign_hdrs: &Vec<(HeaderName, HeaderValue)>,
 ) -> Result<Request<Body>, minio::Err> {
     let mut request = Request::builder();
     let uri_str = svr_str.trim_end_matches('/');
     debug!("uri_str: {}", uri_str);
-    let upd_uri = format!("{}{}?{}", uri_str, r.mk_path(), r.mk_query());
+    let upd_uri = format!("{}{}?{}", uri_str, &r.mk_path(), &r.mk_query());
     debug!("upd_uri: {}", upd_uri);
 
     request.uri(&upd_uri).method(&r.method);
@@ -40,6 +40,6 @@ pub fn mk_request(
         request.header(hdr.0, hdr.1);
     }
     request
-        .body(Body::empty())
+        .body(r.body)
         .map_err(|err| minio::Err::HttpErr(err))
 }