Merge pull request #94 from PLUS-POSTECH/fileentry-improvements

Refactor FileEntry

Author: KSAlpha

Cargo.lock

@@ -8,7 +8,7 @@ edition = "2018"
 [dependencies]
 bollard = "0.1.3"
 clap = "~2.32.0"
-crossterm = "0.5.4"
+crossterm = "0.5.5"
 dirs = "1.0.4"
 failure = "0.1.5"
 flate2 = "1.0.6"
@@ -17,18 +17,20 @@ fs_extra = "1.1.0"
 futures = "0.1.25"
 git2 = "0.8.0"
 handlebars = "1.1.0"
-hyper = "0.12.21"
-question = "0.2.2"
+hyper = "0.12.23"
 remove_dir_all = "0.5.1"
 serde = { version = "1.0.85", features = ["derive"] }
 serde_cbor = "0.9.0"
 tar = "0.4.20"
 tempfile = "3.0.5"
-tokio = "0.1.14"
+tokio = "0.1.15"
 toml = "0.4.10"
 url = "1.7.2"
 whoami = "0.4.1"
 
+[dev-dependencies]
+serde_test = "1.0.85"
+
 [lib]
 name = "soma"
 path = "src/lib.rs"

Cargo.toml

@@ -28,24 +28,25 @@ soma fetch simple-bof  # this will copy public files to the current working dire
 
 ### For problem setters
 
-*This section contains a few commands that are under development.*
+*This section contains some features that are under development.*
 
 Add `soma.toml` to your project root directory that describes your problem.
 The config file below shows an example of it.
 
 ```toml
 name = "simple-bof"
 
-[[executable]]
+[binary]
+os = "ubuntu:16.04"
+cmd = "./simple-bof"
+
+[[binary.executable]]
 path = "build/simple-bof"
 public = true
 
-[[readonly]]
+[[binary.readonly]]
 path = "flag"
 
-[binary]
-os = "ubuntu:16.04"
-entry = "./simple-bof"
 ```
 
 That's all! Soma gets enough information to run your binary from these 12 lines of configuration.
@@ -65,10 +66,10 @@ Soma team is hoping to ship it in the first quarter of 2019.
 
 ### Roadmap
 
-- [ ] Implement core commands. ([#4][issue #4] and [#66][issue #66]) (priority: high)
+- [x] ~~Implement core commands. ([#4][issue #4] and [#66][issue #66]) (priority: high)~~
 - [x] ~~Write tests. (priority: high)~~
 - [ ] Better documentation of features. (priority: medium)
-- [ ] Support multiple problems in a single repository. (priority: medium)
+- [ ] Support multiple problems in a single repository. ([#36][issue #36]) (priority: medium)
 - [ ] Support multiple containers for a single problem. (priority: medium)
 - [ ] Support cloud deployment such as AWS, GCP, Azure as well as local deployment. (priority: low)
 
@@ -83,6 +84,7 @@ Soma team is hoping to ship it in the first quarter of 2019.
     * `rustup component add rustfmt`
 * Copy files in `hooks` directory to `.git/hooks`.
 
+
 ### Testing, Building, and Running
 
 Soma is written with Rust and utilizes Cargo as a building and testing system.
@@ -110,5 +112,6 @@ Unless you explicitly state otherwise, any contribution intentionally submitted
 
 
 [issue #4]: https://github.com/PLUS-POSTECH/soma/issues/4
+[issue #36]: https://github.com/PLUS-POSTECH/soma/issues/36
 [issue #66]: https://github.com/PLUS-POSTECH/soma/issues/66
 [`0.1.0` milestone]: https://github.com/PLUS-POSTECH/soma/milestone/1

README.md

@@ -6,7 +6,6 @@ use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
 use fs2::FileExt;
-use question::{Answer, Question};
 
 use crate::prelude::*;
 
@@ -34,15 +33,8 @@ impl DataDirectory {
         };
 
         if !path.exists() {
-            if let Answer::NO = Question::new(&format!(
-                "It seems that you use Soma for the first time\nThe data directory will be initialized at {:?} [y/n]\n",
-                path.as_os_str(),
-            ))
-                .confirm()
-            {
-                Err(SomaError::DataDirectoryAccessError)?;
-            }
             fs::create_dir_all(&path)?;
+            println!("Created Soma data directory at: {}", path.to_string_lossy());
         }
 
         DataDirectory::initialize_and_lock(path)

src/data_dir.rs

@@ -84,8 +84,9 @@ pub fn fetch(
     let repo_path = repository.local_path();
 
     let manifest = load_manifest(repo_path.join(MANIFEST_FILE_NAME))?;
-    let executables = manifest.executable().iter();
-    let readonly = manifest.readonly().iter();
+    let binary = manifest.binary();
+    let executables = binary.executable().iter();
+    let readonly = binary.readonly().iter();
 
     executables
         .chain(readonly)
@@ -261,7 +262,7 @@ pub fn stop(
     }
 
     let container_list = docker::containers_from_repo(container_list, problem_name);
-    let states_to_stop = vec!["paused", "restarting", "running"];
+    let states_to_stop = &["paused", "restarting", "running"];
 
     let containers_to_stop = container_list
         .iter()

src/ops.rs

@@ -6,6 +6,8 @@ use std::path::{Path, PathBuf};
 use fs_extra::dir::{copy, CopyOptions};
 use git2::{BranchType, ObjectType, Repository as GitRepository, ResetType};
 use remove_dir_all::remove_dir_all;
+use serde::de::{self, Deserializer, Unexpected, Visitor};
+use serde::ser::Serializer;
 use serde::{Deserialize, Serialize};
 
 use crate::prelude::*;
@@ -103,25 +105,57 @@ impl<'a> Repository<'a> {
 pub struct Manifest {
     name: String,
     work_dir: Option<PathBuf>,
-    executable: Vec<FileEntry>,
-    readonly: Vec<FileEntry>,
     binary: BinaryConfig,
 }
 
 #[derive(Serialize)]
 pub struct SolidManifest {
     name: String,
     work_dir: PathBuf,
-    executable: Vec<SolidFileEntry>,
-    readonly: Vec<SolidFileEntry>,
-    binary: BinaryConfig,
+    binary: SolidBinaryConfig,
 }
 
 impl Manifest {
     pub fn name(&self) -> &String {
         &self.name
     }
 
+    pub fn binary(&self) -> &BinaryConfig {
+        &self.binary
+    }
+
+    pub fn solidify(&self) -> SomaResult<SolidManifest> {
+        let work_dir = match &self.work_dir {
+            Some(path) => path.clone(),
+            None => PathBuf::from(format!("/home/{}", self.name)),
+        };
+
+        let binary = self.binary.solidify(&work_dir)?;
+
+        Ok(SolidManifest {
+            name: self.name.clone(),
+            work_dir,
+            binary,
+        })
+    }
+}
+
+#[derive(Deserialize)]
+pub struct BinaryConfig {
+    os: String,
+    cmd: String,
+    executable: Vec<FileEntry>,
+    readonly: Vec<FileEntry>,
+}
+
+#[derive(Serialize)]
+struct SolidBinaryConfig {
+    os: String,
+    cmd: String,
+    file_entries: Vec<SolidFileEntry>,
+}
+
+impl BinaryConfig {
     pub fn executable(&self) -> &Vec<FileEntry> {
         &self.executable
     }
@@ -130,32 +164,81 @@ impl Manifest {
         &self.readonly
     }
 
-    pub fn solidify(&self) -> SomaResult<SolidManifest> {
-        let work_dir = match &self.work_dir {
-            Some(path) => path.clone(),
-            None => PathBuf::from(format!("/home/{}", self.name)),
-        };
+    fn solidify(&self, work_dir: impl AsRef<Path>) -> SomaResult<SolidBinaryConfig> {
         let executable = self
             .executable
             .iter()
-            .map(|file| file.solidify(&work_dir))
-            .collect::<SomaResult<Vec<_>>>()?;
+            .map(|file| file.solidify(&work_dir, FilePermissions::Executable));
         let readonly = self
             .readonly
             .iter()
-            .map(|file| file.solidify(&work_dir))
-            .collect::<SomaResult<Vec<_>>>()?;
+            .map(|file| file.solidify(&work_dir, FilePermissions::ReadOnly));
+        let file_entries = executable.chain(readonly).collect::<SomaResult<Vec<_>>>()?;
 
-        Ok(SolidManifest {
-            name: self.name.clone(),
-            work_dir,
-            executable,
-            readonly,
-            binary: self.binary.clone(),
+        Ok(SolidBinaryConfig {
+            os: self.os.clone(),
+            cmd: self.cmd.clone(),
+            file_entries,
         })
     }
 }
 
+#[derive(Debug, PartialEq)]
+enum FilePermissions {
+    Custom(u16),
+    Executable,
+    ReadOnly,
+    // Reserved: FetchOnly, ReadWrite
+}
+
+impl Serialize for FilePermissions {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let permissions_string = match self {
+            FilePermissions::Custom(permissions) => format!("{:o}", permissions),
+            FilePermissions::Executable => "550".to_owned(),
+            FilePermissions::ReadOnly => "440".to_owned(),
+        };
+        serializer.serialize_str(&permissions_string)
+    }
+}
+
+impl<'de> Deserialize<'de> for FilePermissions {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(PermissionsString)
+    }
+}
+
+struct PermissionsString;
+
+impl<'de> Visitor<'de> for PermissionsString {
+    type Value = FilePermissions;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            formatter,
+            "a file permissions string in octal number format"
+        )
+    }
+
+    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        let permissions = u16::from_str_radix(s, 8);
+        match permissions {
+            // Support sticky bits later
+            Ok(permissions) if permissions <= 0o777 => Ok(FilePermissions::Custom(permissions)),
+            _ => Err(de::Error::invalid_value(Unexpected::Str(s), &self)),
+        }
+    }
+}
+
 // target_path is defined as String instead of PathBuf to support Windows
 #[derive(Deserialize)]
 pub struct FileEntry {
@@ -165,10 +248,11 @@ pub struct FileEntry {
 }
 
 #[derive(Serialize)]
-pub struct SolidFileEntry {
+struct SolidFileEntry {
     path: PathBuf,
     public: bool,
     target_path: String,
+    permissions: FilePermissions,
 }
 
 impl FileEntry {
@@ -180,11 +264,11 @@ impl FileEntry {
         self.public.unwrap_or(false)
     }
 
-    pub fn target_path(&self) -> &Option<String> {
-        &self.target_path
-    }
-
-    pub fn solidify(&self, work_dir: impl AsRef<Path>) -> SomaResult<SolidFileEntry> {
+    fn solidify(
+        &self,
+        work_dir: impl AsRef<Path>,
+        permissions: FilePermissions,
+    ) -> SomaResult<SolidFileEntry> {
         let target_path = match &self.target_path {
             Some(path) => path.clone(),
             None => {
@@ -206,16 +290,11 @@ impl FileEntry {
             path: self.path.clone(),
             public: self.public.unwrap_or(false),
             target_path,
+            permissions,
         })
     }
 }
 
-#[derive(Clone, Deserialize, Serialize)]
-struct BinaryConfig {
-    os: String,
-    entry: String,
-}
-
 fn read_file_contents(path: impl AsRef<Path>) -> SomaResult<Vec<u8>> {
     let mut file = File::open(path)?;
     let mut contents = Vec::new();
@@ -226,3 +305,27 @@ fn read_file_contents(path: impl AsRef<Path>) -> SomaResult<Vec<u8>> {
 pub fn load_manifest(manifest_path: impl AsRef<Path>) -> SomaResult<Manifest> {
     Ok(toml::from_slice(&read_file_contents(manifest_path)?)?)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_test::{assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, Token};
+
+    #[test]
+    fn test_file_permissions_ser() {
+        assert_ser_tokens(&FilePermissions::Executable, &[Token::Str("550")]);
+        assert_ser_tokens(&FilePermissions::ReadOnly, &[Token::Str("440")]);
+        assert_ser_tokens(&FilePermissions::Custom(0o777), &[Token::Str("777")]);
+    }
+
+    #[test]
+    fn test_file_permissions_de() {
+        assert_de_tokens(&FilePermissions::Custom(0o550), &[Token::Str("550")]);
+        assert_de_tokens(&FilePermissions::Custom(0o440), &[Token::Str("440")]);
+        assert_de_tokens(&FilePermissions::Custom(0o777), &[Token::Str("777")]);
+        assert_de_tokens_error::<FilePermissions>(&[
+                Token::Str("1000")
+            ], "invalid value: string \"1000\", expected a file permissions string in octal number format"
+        );
+    }
+}

src/repo.rs

@@ -13,9 +13,9 @@ pub enum Templates {
 }
 
 impl Templates {
-    fn templates(&self) -> Vec<(&'static str, &'static str)> {
+    fn templates(&self) -> &[(&str, &str)] {
         match self {
-            Templates::Binary => vec![
+            Templates::Binary => &[
                 ("Dockerfile", include_str!("../templates/binary/Dockerfile")),
                 ("start.sh", include_str!("../templates/binary/start.sh")),
             ],