chore: initial implementation

chore: fix linting

Author: olevski

Cargo.lock

@@ -28,6 +28,8 @@ serde = { version = "1.0.210", features = ["derive"] }
 serde_json = "1.0.128"
 snafu = { version = "0.8.5" }
 tokio = { version = "1", features = ["full"] }
+tokio-util = { version = "0.7", features = ["codec"] }
+walkdir = "2"
 futures = { version = "0.3" }
 regex = { version = "1.12.3" }
 iso8601-timestamp = { version = "0.2.17" }

Cargo.toml

@@ -25,6 +25,8 @@ pub async fn execute_cmd(opts: MainOpts) -> Result<(), CmdError> {
 
         #[cfg(feature = "user-doc")]
         SubCommand::UserDoc(input) => input.exec(ctx).await?,
+
+        SubCommand::Dataset(input) => input.exec(ctx).await?,
     };
     Ok(())
 }

src/cli.rs

@@ -1,3 +1,4 @@
+pub mod dataset;
 pub mod login;
 pub mod project;
 pub mod update;
@@ -109,6 +110,9 @@ pub enum CmdError {
     #[cfg(feature = "user-doc")]
     #[snafu(display("UserDoc - {}", source))]
     UserDoc { source: userdoc::Error },
+
+    #[snafu(display("Dataset - {}", source))]
+    Dataset { source: dataset::Error },
 }
 
 impl From<version::Error> for CmdError {
@@ -140,3 +144,9 @@ impl From<login::Error> for CmdError {
         CmdError::Login { source }
     }
 }
+
+impl From<dataset::Error> for CmdError {
+    fn from(source: dataset::Error) -> Self {
+        CmdError::Dataset { source }
+    }
+}

src/cli/cmd.rs

@@ -0,0 +1,44 @@
+pub mod deposit;
+pub mod zenodo;
+
+use super::Context;
+use clap::Parser;
+use snafu::Snafu;
+
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(display("Error with deposit: {}", source))]
+    Deposit { source: deposit::Error },
+}
+
+/// Sub command for managing datasets
+#[derive(Parser, Debug)]
+pub struct Input {
+    #[command(subcommand)]
+    pub subcmd: DatasetCommand,
+}
+
+#[derive(Parser, Debug)]
+pub enum DatasetCommand {
+    Deposit {
+        #[command(subcommand)]
+        cmd: DepositCommand,
+    },
+}
+
+#[derive(Parser, Debug)]
+pub enum DepositCommand {
+    #[command()]
+    CopyFiles(deposit::CopyInput),
+}
+
+impl Input {
+    pub async fn exec(&self, _ctx: Context) -> Result<(), Error> {
+        match self.subcmd {
+            DatasetCommand::Deposit { cmd: _ } => {
+                print!("Hi");
+                Ok(())
+            }
+        }
+    }
+}

src/cli/cmd/dataset.rs

@@ -0,0 +1,50 @@
+use super::zenodo;
+use super::Context;
+use clap::{Parser, ValueEnum};
+use snafu::{ResultExt, Snafu};
+use std::env::VarError;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, ValueEnum)]
+pub enum Provider {
+    Zenodo,
+}
+
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(display("A dataset deposit error occured: {}", source))]
+    Zenodo { source: zenodo::Error },
+
+    #[snafu(display("Env variable error: {}", source))]
+    EnvVarMissing { source: VarError },
+}
+
+/// Copies the data from a location into a data deposit
+#[derive(Parser, Debug)]
+pub struct CopyInput {
+    /// The id of the deposit the data should be copied to.
+    #[arg()]
+    pub deposit_id: String,
+
+    /// The provider for the dataset
+    #[arg()]
+    pub provider: Provider,
+
+    /// The source directory where the files to be copied can be found.
+    #[arg()]
+    pub source_dir: PathBuf,
+}
+
+impl CopyInput {
+    pub async fn exec(&self, _ctx: Context) -> Result<(), Error> {
+        match self.provider {
+            Provider::Zenodo => {
+                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
+                    .context(ZenodoSnafu)
+            }
+        }
+    }
+}

src/cli/cmd/dataset/deposit.rs

@@ -0,0 +1,126 @@
+use mime_guess::from_path;
+use reqwest;
+use serde::de::DeserializeOwned;
+use snafu::{ResultExt, Snafu};
+use std::path::{Path, PathBuf};
+use tokio::fs::File;
+use tokio_util::codec::{BytesCodec, FramedRead};
+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,
+}
+
+static BASE_URL: LazyLock<Url> =
+    LazyLock::new(|| Url::parse("https://zenodo.org").expect("Invalid Base URL config"));
+
+#[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();
+        ZenodoClient {
+            http_client,
+            base_url: BASE_URL.clone(),
+            token,
+        }
+    }
+
+    fn make_url(&self, path: &str) -> Result<Url, Error> {
+        self.base_url.join(path).context(UrlParseSnafu)
+    }
+
+    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(endpoint)
+            .bearer_auth(&self.token)
+            .send()
+            .await
+            .context(ReqwestSnafu)?;
+        // res.error_for_status().context(ReqwestSnafu)?;
+        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.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/{deposition_id}/files"))?;
+        let res = self
+            .http_client
+            .get(endpoint)
+            .bearer_auth(&self.token)
+            .send()
+            .await
+            .context(ReqwestSnafu)?;
+        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.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_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)
+            .bearer_auth(&self.token)
+            .multipart(form)
+            .send()
+            .await
+            .context(ReqwestSnafu)?;
+        res.json::<R>().await.context(DeserializeRespSnafu)
+    }
+}

src/cli/cmd/dataset/zenodo.rs

@@ -68,7 +68,7 @@ enum Steps<'a> {
     Complete,
 }
 impl Input {
-    fn get_steps(&self) -> Steps<'_> {
+    fn get_steps(&'_ self) -> Steps<'_> {
         if let Some(p) = &self.continue_from {
             Steps::Continue(p)
         } else if self.user_code_only {

src/cli/cmd/login.rs

@@ -58,7 +58,7 @@ pub struct Versions<'a> {
     pub renku_url: &'a str,
 }
 impl Versions<'_> {
-    pub fn create(server: VersionInfo, renku_url: &str) -> Versions<'_> {
+    pub fn create(server: VersionInfo, renku_url: &'_ str) -> Versions<'_> {
         Versions {
             client: BuildInfo::default(),
             server,

src/cli/cmd/version.rs

@@ -63,6 +63,9 @@ pub enum SubCommand {
 
     #[cfg(feature = "user-doc")]
     UserDoc(userdoc::Input),
+
+    #[command()]
+    Dataset(dataset::Input),
 }
 
 /// This is the command line interface to the Renku platform. Main