initial implementation

Author: olevski

Cargo.lock

@@ -6,8 +6,8 @@ version = "0.1.0-nightly"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/SwissDatascienceCenter/renku-cli"
-keywords = [ "renku", "cli" ]
-categories = [ "command-line-utilities" ]
+keywords = ["renku", "cli"]
+categories = ["command-line-utilities"]
 build = "build.rs"
 
 # See more keys and their definitions at
@@ -16,11 +16,15 @@ build = "build.rs"
 [dependencies]
 clap = { version = "4.5.13", features = ["derive", "wrap_help"] }
 clap_complete = "4.5.13"
-console = {version = "0.15.8"}
+console = { version = "0.15.8" }
 env_logger = { version = "0.11.5" }
 log = { version = "0.4.22" }
 openssl = { version = "0.10.64", optional = true }
-reqwest = { version = "0.12.7", default-features = false, features = ["json", "multipart"] }
+reqwest = { version = "0.12.7", default-features = false, features = [
+  "json",
+  "multipart",
+  "stream",
+] }
 serde = { version = "1.0.210", features = ["derive"] }
 serde_json = "1.0.128"
 snafu = { version = "0.8.5" }
@@ -31,21 +35,37 @@ futures = { version = "0.3" }
 regex = { version = "1.11.0" }
 iso8601-timestamp = { version = "0.2.17" }
 toml = { version = "0.8.19" }
-git2 = { version = "0.19.0", default-features = false, features = [ "vendored-libgit2", "https", "ssh" ]}
+git2 = { version = "0.19.0", default-features = false, features = [
+  "vendored-libgit2",
+  "https",
+  "ssh",
+] }
 url = { version = "2.5.1" }
-openidconnect = { version = "3.5.0", default-features = false, features = [ "reqwest" ] }
+mime_guess = "2.0"
+openidconnect = { version = "3.5.0", default-features = false, features = [
+  "reqwest",
+] }
 directories = { version = "5.0" }
 comrak = { version = "0.28.0", optional = true }
 
 [features]
 default = ["reqwest/default-tls"] # link against system library
-rustls = ["reqwest/rustls-tls", "openidconnect/rustls-tls"] # include rustls, ssl library written in rust
+rustls = [
+  "reqwest/rustls-tls",
+  "openidconnect/rustls-tls",
+] # include rustls, ssl library written in rust
 vendored-openssl = ["openssl/vendored"] # include compiled openssl library
-user-doc = [ "dep:comrak" ]
+user-doc = ["dep:comrak"]
 
 [dev-dependencies]
 assert_cmd = "2.0.16"
 predicates = "3.1.2"
 
 [build-dependencies]
-vergen = { version = "8.3.2", features = ["build", "git", "gitcl", "rustc", "cargo"] }
+vergen = { version = "8.3.2", features = [
+  "build",
+  "git",
+  "gitcl",
+  "rustc",
+  "cargo",
+] }

Cargo.toml

@@ -1,11 +1,9 @@
 pub mod deposit;
 pub mod zenodo;
 
-use std::env::args;
-
 use super::Context;
 use clap::Parser;
-use snafu::{ResultExt, Snafu};
+use snafu::Snafu;
 
 #[derive(Debug, Snafu)]
 pub enum Error {
@@ -33,3 +31,11 @@ pub enum DepositCommand {
     #[command()]
     CopyFiles(deposit::CopyInput),
 }
+
+impl Input {
+    pub async fn exec(&self, ctx: Context) -> Result<(), Error> {
+        match self.subcmd {
+            DatasetCommand::Deposit { cmd: _ } => Ok(print!("Hi")),
+        }
+    }
+}

src/cli/cmd/dataset.rs

@@ -1,18 +1,22 @@
 use super::zenodo;
 use super::Context;
-use crate::httpclient::Error as HttpError;
-use clap::Parser;
+use clap::{Parser, ValueEnum};
 use snafu::{ResultExt, Snafu};
-use url::Url;
+use std::env::VarError;
+use std::path::PathBuf;
 
+#[derive(Debug, Clone, ValueEnum)]
 enum Provider {
     Zenodo,
 }
 
 #[derive(Debug, Snafu)]
 pub enum Error {
     #[snafu(display("A dataset deposit error occured: {}", source))]
-    HttpClient { source: HttpError },
+    Zenodo { source: zenodo::Error },
+
+    #[snafu(display("Env variable error: {}", source))]
+    EnvVarMissing { source: VarError },
 }
 
 /// Copies the data from a location into a data deposit
@@ -32,12 +36,14 @@ pub struct CopyInput {
 }
 
 impl CopyInput {
-    pub async fn exec(&self, ctx: Context) -> Result<(), Error> {
+    pub async fn exec(&self, _ctx: Context) -> Result<(), Error> {
         match self.provider {
             Provider::Zenodo => {
-                let token = std::env::var("ZENODO_API_KEY")?;
+                let token = std::env::var("ZENODO_API_KEY").context(EnvVarMissingSnafu)?;
                 let clnt = zenodo::ZenodoClient::new(token);
-                clnt.upload_files(self.deposit_id, self.source_dir).await?;
+                clnt.upload_files(&self.deposit_id, &self.source_dir)
+                    .await
+                    .context(ZenodoSnafu)
             }
         }
     }

src/cli/cmd/dataset/deposit.rs

@@ -1,33 +1,46 @@
-use crate::httpclient::{Error as HttpError, HttpSnafu, UrlParseSnafu};
+use mime_guess::from_path;
 use reqwest;
 use serde::de::DeserializeOwned;
 use snafu::{ResultExt, Snafu};
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use tokio::fs::File;
 use tokio_util::codec::{BytesCodec, FramedRead};
-use url::Url;
+use url::{ParseError, Url};
 use walkdir::WalkDir;
 
+use std::io;
+use std::sync::LazyLock;
 pub struct ZenodoClient {
     http_client: reqwest::Client,
     base_url: Url,
     token: String,
 }
 
-const BASE_URL: Url = Url::parse("https://zenodo.org").unwrap();
+static BASE_URL: LazyLock<Url> =
+    LazyLock::new(|| Url::parse("https://zenodo.org").expect("Invalid Base URL config"));
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Deposition {
-    pub search: SearchServiceVersion,
-    pub data: SimpleVersion,
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(display("A zendoo client error occured: {}", source))]
+    Reqwest { source: reqwest::Error },
+    #[snafu(display("A directory listing error occured: {}", source))]
+    DirWalk { source: walkdir::Error },
+    #[snafu(display("An error occured reading the response: {}", source))]
+    DeserializeResp { source: reqwest::Error },
+    #[snafu(display("An error occured reading the response: {}", source))]
+    FileReading { source: io::Error },
+    #[snafu(display("An error occured parsing the file path: {}", fp.to_string_lossy()))]
+    FileParsing { fp: PathBuf },
+    #[snafu(display("An error occured parsing the url {}", source))]
+    UrlParse { source: ParseError },
 }
 
 impl ZenodoClient {
     pub fn new(token: String) -> ZenodoClient {
         let http_client = reqwest::Client::new();
         return ZenodoClient {
             http_client,
-            base_url: BASE_URL,
+            base_url: BASE_URL.clone(),
             token,
         };
     }
@@ -36,55 +49,76 @@ impl ZenodoClient {
         return self.base_url.join(path).context(UrlParseSnafu);
     }
 
-    pub async fn get_deposition<R: DeserializeOwned>(&self, id: &str) -> Result<R, Error> {
-        let endpoint = self.make_url(format!("/api/deposit/depositions/{id}"));
+    pub async fn get_deposition<R: DeserializeOwned>(
+        &self,
+        deposition_id: &str,
+    ) -> Result<R, Error> {
+        let endpoint = self.make_url(&format!("/api/deposit/depositions/{deposition_id}"))?;
         let res = self
             .http_client
-            .get(enpdoint)
+            .get(endpoint)
             .send()
             .await
-            .context(HttpSnafu { url: endpoint })?;
-        res.error_for_status()?;
-        return res.json();
+            .context(ReqwestSnafu)?;
+        // res.error_for_status().context(ReqwestSnafu)?;
+        return res.json::<R>().await.context(DeserializeRespSnafu);
     }
 
     pub async fn upload_files(&self, deposition_id: &str, source_path: &Path) -> Result<(), Error> {
         for f in WalkDir::new(source_path) {
-            self.upload_file(deposition_id, f?.path()).await?;
+            self.upload_file::<()>(deposition_id, f.context(DirWalkSnafu)?.path())
+                .await?;
         }
+        Ok(())
     }
 
     pub async fn list_files<R: DeserializeOwned>(&self, deposition_id: &str) -> Result<R, Error> {
-        let endpoint = self.make_url(format!("/api/deposit/depositions/{id}/files"));
+        let endpoint = self.make_url(&format!("/api/deposit/depositions/{deposition_id}/files"))?;
         let res = self
             .http_client
-            .get(enpdoint)
+            .get(endpoint)
             .send()
             .await
-            .context(HttpSnafu { url: endpoint })?;
-        res.error_for_status()?;
-        return res.json();
+            .context(ReqwestSnafu)?;
+        // res.error_for_status().context(ReqwestSnafu)?;
+        return res.json::<R>().await.context(DeserializeRespSnafu);
     }
 
     async fn upload_file<R: DeserializeOwned>(
         &self,
         deposition_id: &str,
         file_path: &Path,
     ) -> Result<R, Error> {
-        let file = File::open(file_path).await?;
-        let endpoint = self.make_url(format!("/api/deposit/depositions/{id}/files"));
+        let file = File::open(file_path).await.context(FileReadingSnafu)?;
+        let endpoint = self.make_url(&format!("/api/deposit/depositions/{deposition_id}/files"))?;
         let stream = FramedRead::new(file, BytesCodec::new());
+        let file_name = file_path
+            .file_name()
+            .ok_or(Error::FileParsing {
+                fp: file_path.to_path_buf(),
+            })?
+            .to_str()
+            .ok_or(Error::FileParsing {
+                fp: file_path.to_path_buf(),
+            })?;
+        let mime_type = from_path(file_path).first_or_octet_stream();
         let form = reqwest::multipart::Form::new()
-            .text("name", file_path.file_name()?.to_str()?)
-            .part("file", stream);
+            .text("name", file_name.to_owned())
+            .part(
+                "file",
+                reqwest::multipart::Part::stream(reqwest::Body::wrap_stream(stream))
+                    .file_name(file_name.to_owned())
+                    .mime_str(mime_type.as_ref())
+                    .context(ReqwestSnafu)?,
+            );
         let res = self
             .http_client
             .post(endpoint)
             .multipart(form)
             .send()
             .await
-            .context(HttpSnafu { url: endpoint })?;
-        res.error_for_status()?;
-        return res.json();
+            .context(ReqwestSnafu)?;
+        // res.error_for_status().context(ReqwestSnafu)?;
+        return res.json::<R>().await.context(DeserializeRespSnafu);
     }
 }