Write renku config when cloning

Cargo.toml

@@ -28,6 +28,7 @@ tokio = { version = "1", features = ["full"] }
 futures = { version = "0.3" }
 regex = { version = "1.10.5" }
 iso8601-timestamp = { version = "0.2.17" }
+toml = { version = "0.8.12" }
 git2 = "0.19.0"
 comrak = { version = "0.24.1", optional = true }
 

src/cli/cmd/project/clone.rs

@@ -1,3 +1,4 @@
+use crate::config::{ConfigError, ProjectInfo, RenkuProjectConfig};
 use crate::httpclient::data::ProjectDetails;
 
 use super::Context;
@@ -9,7 +10,7 @@ use std::sync::Arc;
 use clap::Parser;
 use git2::{Error as GitError, Repository};
 use snafu::{ResultExt, Snafu};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use tokio::task::{JoinError, JoinSet};
 
 /// Clone a project.
@@ -53,6 +54,9 @@ pub enum Error {
 
     #[snafu(display("Error in task: {}", source))]
     TaskJoin { source: JoinError },
+
+    #[snafu(display("Error creating config file: {}", source))]
+    RenkuConfig { source: ConfigError },
 }
 
 impl Input {
@@ -72,6 +76,14 @@ impl Input {
         };
         if let Some(details) = opt_details {
             let target = self.target_dir()?.join(&details.slug);
+            let renku_project_cfg = RenkuProjectConfig {
+                renku_url: ctx.renku_url.clone(),
+                project: ProjectInfo {
+                    id: details.id.clone(),
+                    namespace: details.namespace.clone(),
+                    slug: details.slug.clone(),
+                },
+            };
             ctx.write_err(&SimpleMessage {
                 message: format!(
                     "Cloning {} ({}) into {}...",
@@ -83,6 +95,8 @@ impl Input {
             .await
             .context(WriteResultSnafu)?;
 
+            write_config(renku_project_cfg, &target).await?;
+
             let ctx = clone_project(ctx, &details, target).await?;
             ctx.write_result(&details).await.context(WriteResultSnafu)?;
         } else {
@@ -176,3 +190,10 @@ async fn clone_repository(
     }
     Ok(())
 }
+
+async fn write_config(data: RenkuProjectConfig, local_dir: &Path) -> Result<(), Error> {
+    let target = local_dir.join(".renku").join("config.toml");
+    tokio::task::spawn_blocking(move || data.write(&target).context(RenkuConfigSnafu))
+        .await
+        .context(TaskJoinSnafu)?
+}

src/config.rs

@@ -0,0 +1,97 @@
+use serde::{Deserialize, Serialize};
+use snafu::Snafu;
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Snafu)]
+pub enum ConfigError {
+    #[snafu(display("Unable to read config file {}: {}", path.display(), source))]
+    ReadFile {
+        source: std::io::Error,
+        path: PathBuf,
+    },
+    #[snafu(display("Unable to write config file {}: {}", path.display(), source))]
+    WriteFile {
+        source: std::io::Error,
+        path: PathBuf,
+    },
+    #[snafu(display("Unable to parse file {}: {}", path.display(), source))]
+    ParseFile {
+        source: toml::de::Error,
+        path: PathBuf,
+    },
+    #[snafu(display("The config file could not be serialized"))]
+    WriteToml {
+        source: toml::ser::Error,
+        path: PathBuf,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub struct RenkuProjectConfig {
+    /// The base url to the renku platform.
+    pub renku_url: String,
+
+    /// Information about the project
+    pub project: ProjectInfo,
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub struct ProjectInfo {
+    pub id: String,
+    pub namespace: String,
+    pub slug: String,
+}
+
+impl RenkuProjectConfig {
+    pub fn read(file: &Path) -> Result<RenkuProjectConfig, ConfigError> {
+        let cnt = std::fs::read_to_string(file).map_err(|e| ConfigError::ReadFile {
+            source: e,
+            path: file.to_path_buf(),
+        });
+        cnt.and_then(|c| {
+            toml::from_str(&c).map_err(|e| ConfigError::ParseFile {
+                source: e,
+                path: file.to_path_buf(),
+            })
+        })
+    }
+
+    pub fn write(&self, file: &Path) -> Result<(), ConfigError> {
+        if !file.exists() {
+            if let Some(dir) = file.parent() {
+                std::fs::create_dir_all(dir).map_err(|e| ConfigError::WriteFile {
+                    source: e,
+                    path: file.to_path_buf(),
+                })?;
+            }
+        }
+        let cnt = toml::to_string(self).map_err(|e| ConfigError::WriteToml {
+            source: e,
+            path: file.to_path_buf(),
+        });
+
+        cnt.and_then(|c| {
+            std::fs::write(file, c).map_err(|e| ConfigError::WriteFile {
+                source: e,
+                path: file.to_path_buf(),
+            })
+        })
+    }
+}
+
+#[test]
+fn write_and_read_config() {
+    let data = RenkuProjectConfig {
+        renku_url: "http://renkulab.io".into(),
+        project: ProjectInfo {
+            id: "abc123".into(),
+            namespace: "my-ns".into(),
+            slug: "projecta".into(),
+        },
+    };
+    let target: PathBuf = "test.conf".into();
+    data.write(&target).unwrap();
+    let from_file = RenkuProjectConfig::read(&target).unwrap();
+    std::fs::remove_file(&target).unwrap();
+    assert_eq!(data, from_file);
+}

src/lib.rs

@@ -1,4 +1,5 @@
 pub mod cli;
+pub mod config;
 pub mod error;
 pub mod httpclient;
 pub mod util;