Fix object download to file (#105)

The ObjectContent::to_file() function was not working properly,
as it could not write in a temporary file (created with tokio::fs::File::open(),
which opens a file in read-only mode).

To solve this issue, modified the way temporary files are opened to be
able to write inside of it.

* Add an example to download a file

This new example demonstrates how to download an object and store its
content into a file.

---------

Co-authored-by: Henk-Jan Lebbink <henkjan.lebbink@gmail.com>
Co-authored-by: Jean Sainctavit <jean.sainctavit@qarnot-computing.com>

Cargo.toml

@@ -63,5 +63,8 @@ quickcheck = "1.0.3"
 [[example]]
 name = "file_uploader"
 
+[[example]]
+name = "file_downloader"
+
 [[example]]
 name = "object_prompt"

README.md

@@ -15,6 +15,10 @@ Run the examples from the command line with:
 * [Upload a file to MinIO](examples/file_uploader)
 * [Upload a file to MinIO with CLI](examples/put_object)
 
+### file_downloader.rs
+
+* [Download af file from MinIO](examples/file_downloader.rs)
+
 ### object_prompt.rs 
 
 * [Prompt a file on MinIO](examples/object_prompt)

examples/file_downloader.rs

@@ -0,0 +1,75 @@
+use minio::s3::args::{BucketExistsArgs, MakeBucketArgs};
+use minio::s3::builders::ObjectContent;
+use minio::s3::client::ClientBuilder;
+use minio::s3::creds::StaticProvider;
+use minio::s3::http::BaseUrl;
+use minio::s3::types::S3Api;
+use std::path::Path;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    env_logger::init(); // Note: set environment variable RUST_LOG="INFO" to log info and higher
+
+    let base_url = "https://play.min.io".parse::<BaseUrl>()?;
+    log::info!("Trying to connect to MinIO at: `{:?}`", base_url);
+
+    let static_provider = StaticProvider::new(
+        "Q3AM3UQ867SPQQA43P2F",
+        "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG",
+        None,
+    );
+
+    let client = ClientBuilder::new(base_url.clone())
+        .provider(Some(Box::new(static_provider)))
+        .build()?;
+
+    let bucket_name: &str = "file-download-rust-bucket";
+    let object_name: &str = "cat.png";
+
+    // File we are going to upload to the bucket
+    let filename: &Path = Path::new("./examples/cat.png");
+    let download_path: &str = &format!("/tmp/downloads/{object_name}");
+
+    // Check 'bucket_name' bucket exist or not.
+    let exists: bool = client
+        .bucket_exists(&BucketExistsArgs::new(bucket_name).unwrap())
+        .await
+        .unwrap();
+
+    // Make 'bucket_name' bucket if not exist.
+    if !exists {
+        client
+            .make_bucket(&MakeBucketArgs::new(bucket_name).unwrap())
+            .await
+            .unwrap();
+    }
+
+    if filename.exists() {
+        log::info!("File '{}' exists.", &filename.to_str().unwrap());
+    } else {
+        log::error!("File '{}' does not exist.", &filename.to_str().unwrap());
+        return Ok(());
+    }
+
+    let content = ObjectContent::from(filename);
+    client
+        .put_object_content(bucket_name, object_name, content)
+        .send()
+        .await?;
+
+    log::info!(
+        "file '{}' is successfully uploaded as object '{object_name}' to bucket '{bucket_name}'.",
+        filename.display()
+    );
+
+    let get_object = client.get_object(bucket_name, object_name).send().await?;
+
+    get_object
+        .content
+        .to_file(&Path::new(download_path))
+        .await?;
+
+    log::info!("Object '{object_name}' is successfully downloaded to file '{download_path}'.");
+
+    Ok(())
+}

src/s3/builders/object_content.rs

@@ -201,19 +201,21 @@ impl ObjectContent {
             .join(Path::new(tmp_file_name.as_os_str()));
 
         let mut total = 0;
-        {
-            let mut fp = fs::File::open(&tmp_file_path).await?;
-            let (mut r, _) = self.to_stream().await?;
-            while let Some(bytes) = r.next().await {
-                let bytes = bytes?;
-                if bytes.is_empty() {
-                    break;
-                }
-                total += bytes.len() as u64;
-                fp.write_all(&bytes).await?;
+        let mut fp = fs::OpenOptions::new()
+            .write(true)
+            .create(true)
+            .open(&tmp_file_path)
+            .await?;
+        let (mut r, _) = self.to_stream().await?;
+        while let Some(bytes) = r.next().await {
+            let bytes = bytes?;
+            if bytes.is_empty() {
+                break;
             }
-            fp.flush().await?;
+            total += bytes.len() as u64;
+            fp.write_all(&bytes).await?;
         }
+        fp.flush().await?;
         fs::rename(&tmp_file_path, file_path).await?;
         Ok(total)
     }