Source image name from local yaml file (#33)

* Source image name from local yaml file

Signed-off-by: Tom Fay <[email protected]>

* Remove stray comment

Signed-off-by: Tom Fay <[email protected]>

* Correct key in doc

Signed-off-by: Tom Fay <[email protected]>

* Fix case where floki is run from a subdirectory

Signed-off-by: Tom Fay <[email protected]>

* Change error message

Signed-off-by: Tom Fay <[email protected]>

Author: tofay

Cargo.lock

@@ -14,6 +14,7 @@ serde_derive = "1.0"
 serde_yaml = "0.7"
 structopt = "0.2"
 uuid = { version = "0.6", features = ["v4"] }
+yaml-rust = "0.4.3"
 
 [dev-dependencies]
 tempdir = "0.3.7"

Cargo.toml

@@ -16,7 +16,7 @@ The ideal workflow is
 
 # Container images
 
-`floki` offers a couple of ways t configure the container image to use.
+`floki` offers a couple of ways to configure the container image to use.
 
 ## Prebuilt images
 
@@ -40,6 +40,16 @@ image:
     context: .                   # Defaults to .
 ```
 
+## Referencing a key in another yaml file
+`floki` can use an image referenced in another yaml file. This can help keep local development environments sync'd with a CI environment.
+
+```
+image:
+  yaml:
+    file: .gitlab-ci.yaml
+    key: variables.RUST-IMAGE
+```
+
 ## Updating an image
 
 `floki pull` pulls the container under the `image` key again. While it is better to version images, this can be used when working against e.g. a `latest` tag.

docs/content/intro/feature-overview.md

@@ -57,13 +57,32 @@ impl FlokiConfig {
             error: e,
         })?;
 
-        let config = serde_yaml::from_reader(f).map_err(|e| {
+        let mut config: FlokiConfig = serde_yaml::from_reader(f).map_err(|e| {
             errors::FlokiError::ProblemParsingConfigYaml {
                 name: file.display().to_string(),
                 error: e,
             }
         })?;
 
+        // Ensure the path to an external yaml file is correct.
+        // If the image.yaml.path file is relative, then it should
+        // be relative to the floki config file. At this point we
+        // already have the path to the floki config file, so we
+        // just prepend that to image.yaml.path.
+        if let image::Image::Yaml { ref mut yaml } = config.image {
+            if yaml.file.is_relative() {
+                yaml.file = file
+                    .parent()
+                    .ok_or_else(|| errors::FlokiInternalError::InternalAssertionFailed {
+                        description: format!(
+                            "could not constuct path to external yaml file '{:?}'",
+                            &yaml.file
+                        ),
+                    })?
+                    .join(yaml.file.clone());
+            }
+        }
+
         Ok(config)
     }
 }

src/config.rs

@@ -53,6 +53,9 @@ pub enum FlokiError {
     #[fail(display = "Failed to check existance of image '{}': {}", image, error)]
     FailedToCheckForImage { image: String, error: io::Error },
 
+    #[fail(display = "Failed to find the key '{}' in file '{}'", key, file)]
+    FailedToFindYamlKey { key: String, file: String },
+
     #[fail(display = "Running container failed: {}", exit_status)]
     RunContainerFailed {
         exit_status: FlokiSubprocessExitStatus,

src/errors.rs

@@ -1,6 +1,9 @@
 use failure::Error;
 use quicli::prelude::*;
+use std::fs;
+use std::path::PathBuf;
 use std::process::{Command, Stdio};
+use yaml_rust::YamlLoader;
 
 use crate::errors::{FlokiError, FlokiSubprocessExitStatus};
 
@@ -13,6 +16,12 @@ pub struct BuildSpec {
     context: String,
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct YamlSpec {
+    pub file: PathBuf,
+    key: String,
+}
+
 fn default_dockerfile() -> String {
     "Dockerfile".into()
 }
@@ -26,14 +35,39 @@ fn default_context() -> String {
 pub enum Image {
     Name(String),
     Build { build: BuildSpec },
+    Yaml { yaml: YamlSpec },
 }
 
 impl Image {
     /// Name of the image
-    pub fn name(&self) -> String {
+    pub fn name(&self) -> Result<String, Error> {
         match *self {
-            Image::Name(ref s) => s.clone(),
-            Image::Build { ref build } => build.name.clone() + ":floki",
+            Image::Name(ref s) => Ok(s.clone()),
+            Image::Build { ref build } => Ok(build.name.clone() + ":floki"),
+            Image::Yaml { ref yaml } => {
+                let contents = fs::read_to_string(&yaml.file)?;
+                let raw = YamlLoader::load_from_str(&contents)?;
+                let path = yaml.key.split('.').collect::<Vec<_>>();
+                let mut val = &raw[0];
+
+                for key in &path {
+                    // Yaml arrays and maps with scalar keys can both be indexed by
+                    // usize, so heuristically prefer a usize index to a &str index.
+                    val = match key.parse::<usize>() {
+                        Ok(x) => &val[x],
+                        Err(_) => &val[*key],
+                    };
+                }
+                val.as_str()
+                    .map(std::string::ToString::to_string)
+                    .ok_or_else(|| {
+                        FlokiError::FailedToFindYamlKey {
+                            key: yaml.key.to_string(),
+                            file: yaml.file.display().to_string(),
+                        }
+                        .into()
+                    })
+            }
         }
     }
 
@@ -46,17 +80,17 @@ impl Image {
                 let exit_status = Command::new("docker")
                     .arg("build")
                     .arg("-t")
-                    .arg(self.name())
+                    .arg(self.name()?)
                     .arg("-f")
                     .arg(&build.dockerfile)
                     .arg(&build.context)
                     .spawn()?
                     .wait()?;
                 if exit_status.success() {
-                    Ok(self.name())
+                    Ok(self.name()?)
                 } else {
                     Err(FlokiError::FailedToBuildImage {
-                        image: self.name(),
+                        image: self.name()?,
                         exit_status: FlokiSubprocessExitStatus {
                             process_description: "docker build".into(),
                             exit_status: exit_status,
@@ -65,7 +99,7 @@ impl Image {
                 }
             }
             // All other cases we just return the name
-            _ => Ok(self.name()),
+            _ => Ok(self.name()?),
         }
     }
 }
@@ -94,15 +128,15 @@ pub fn pull_image(name: String) -> Result<(), Error> {
 }
 
 /// Determine whether an image exists locally
-pub fn image_exists_locally(name: String) -> Result<bool, Error> {
+pub fn image_exists_locally(name: &str) -> Result<bool, Error> {
     let ret = Command::new("docker")
         .args(&["history", "docker:stable-dind"])
         .stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::null())
         .status()
         .map_err(|e| FlokiError::FailedToCheckForImage {
-            image: name.clone(),
+            image: name.to_string(),
             error: e,
         })?;
 

src/image.rs

@@ -15,7 +15,7 @@ pub(crate) fn run_container(
     config: &FlokiConfig,
     command: &str,
 ) -> Result<(), Error> {
-    let (mut cmd, mut dind) = build_basic_command(&floki_root, &config);
+    let (mut cmd, mut dind) = build_basic_command(&floki_root, &config)?;
 
     cmd = configure_dind(cmd, &config, &mut dind)?;
     cmd = configure_floki_user_env(cmd, &environ);
@@ -144,17 +144,17 @@ fn get_mount_specification<'a, 'b>(
 fn build_basic_command(
     floki_root: &path::Path,
     config: &FlokiConfig,
-) -> (DockerCommandBuilder, Dind) {
+) -> Result<(DockerCommandBuilder, Dind), Error> {
     let mount = get_mount_specification(&floki_root, &config);
 
     // Assign a container for docker-in-docker - we don't spawn it yet
     let dind = Dind::new(mount);
 
-    let image = &config.image.name();
+    let image = &config.image.name()?;
     let outer_shell = config.shell.outer_shell();
     let cmd = command::DockerCommandBuilder::new(image, outer_shell).add_volume(mount);
 
-    (cmd, dind)
+    Ok((cmd, dind))
 }
 
 #[cfg(test)]

src/interpret.rs

@@ -58,8 +58,8 @@ fn run_floki_from_args(args: &Cli) -> Result<(), Error> {
         // Pull the image in the configuration file
         Some(Subcommand::Pull {}) => {
             debug!("Trying to pull image {:?}", &config.image);
-            debug!("Pulling image: {}", config.image.name());
-            image::pull_image(config.image.name())
+            debug!("Pulling image: {}", config.image.name()?);
+            image::pull_image(config.image.name()?)
         }
 
         // Run a command in the floki container