new: added validate command

Author: evilsocket

README.md

@@ -107,6 +107,19 @@ robopages create --name my_first_page.yml --template docker-image
 robopages create --name my_first_page.yml --template docker-build
 ```
 
+Validate one or more files:
+
+```bash
+# validate all pages in  ~/.robopages
+robopages validate
+
+# validate a specific page
+robopages validate --path my_first_page.yml
+
+# do not attempt to pull or build containers
+robopages validate --skip-docker
+```
+
 Start the REST API:
 
 > [!IMPORTANT]

src/book/mod.rs

@@ -56,6 +56,8 @@ pub struct Container {
     #[serde(default = "default_preserve_app")]
     #[serde(skip_serializing_if = "is_false")]
     pub preserve_app: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub platform: Option<String>,
 }
 
 fn is_false(b: &bool) -> bool {
@@ -107,6 +109,10 @@ impl Container {
 
         Ok(dockerized)
     }
+
+    pub async fn resolve(&self) -> anyhow::Result<()> {
+        self.source.resolve(self.platform.clone()).await
+    }
 }
 
 // TODO: add optional parsers to reduce output tokens
@@ -143,9 +149,12 @@ impl Page {
     }
 
     pub fn from_path(path: &Utf8PathBuf) -> anyhow::Result<Self> {
-        let text = std::fs::read_to_string(path)?;
-        let text = Self::preprocess(path, text)?;
-        let page = serde_yaml::from_str(&text)?;
+        let text = std::fs::read_to_string(path)
+            .map_err(|e| anyhow::anyhow!("error while reading {:?}: {}", path, e))?;
+        let text = Self::preprocess(path, text)
+            .map_err(|e| anyhow::anyhow!("error while preprocessing {:?}: {}", path, e))?;
+        let page = serde_yaml::from_str(&text)
+            .map_err(|e| anyhow::anyhow!("error while parsing {:?}: {}", path, e))?;
         Ok(page)
     }
 }
@@ -163,7 +172,9 @@ impl Book {
             shellexpand::full(path.as_str())
                 .map_err(|e| anyhow::anyhow!("failed to expand path: {}", e))?
                 .into_owned(),
-        );
+        )
+        .canonicalize_utf8()
+        .map_err(|e| anyhow::anyhow!("failed to canonicalize path: {}", e))?;
 
         if path.is_file() {
             eval_if_in_filter!(path, filter, page_paths.push(path.to_path_buf()));
@@ -194,6 +205,7 @@ impl Book {
         let mut function_names = HashMap::new();
 
         for page_path in page_paths {
+            let page_path = page_path.canonicalize_utf8()?;
             let mut page = Page::from_path(&page_path)?;
 
             // if name is not set, use the file name
@@ -370,6 +382,7 @@ mod tests {
             volumes: None,
             force: false,
             preserve_app: true,
+            platform: None,
         };
 
         let original_cmdline = CommandLine {

src/cli/mod.rs

@@ -7,12 +7,14 @@ mod create;
 mod install;
 mod run;
 mod serve;
+mod validate;
 mod view;
 
 pub(crate) use create::*;
 pub(crate) use install::*;
 pub(crate) use run::*;
 pub(crate) use serve::*;
+pub(crate) use validate::*;
 pub(crate) use view::*;
 
 use crate::book::templates::Template;
@@ -39,6 +41,8 @@ pub(crate) enum Command {
     Serve(ServeArgs),
     /// Execute a function from the robopages.
     Run(RunArgs),
+    /// Validate a robopage YML file.
+    Validate(ValidateArgs),
 }
 
 #[derive(Debug, Args)]
@@ -106,6 +110,16 @@ pub(crate) struct RunArgs {
     auto: bool,
 }
 
+#[derive(Debug, Args)]
+pub(crate) struct ValidateArgs {
+    /// Path to the robopage YML file or files to validate.
+    #[clap(long, short = 'P', default_value = DEFAULT_PATH)]
+    path: Utf8PathBuf,
+    /// Do not attempt to pull or build containers.
+    #[clap(long)]
+    skip_docker: bool,
+}
+
 /// Parse a single key-value pair
 fn parse_key_val<T, U>(s: &str) -> Result<(T, U), Box<dyn Error + Send + Sync + 'static>>
 where

src/cli/serve.rs

@@ -82,7 +82,7 @@ pub(crate) async fn serve(args: ServeArgs) -> anyhow::Result<()> {
             for (func_name, func) in page.functions.iter() {
                 if let Some(container) = &func.container {
                     log::info!("pre building container for function {} ...", func_name);
-                    container.source.resolve().await?;
+                    container.resolve().await?;
                 }
             }
         }

src/cli/validate.rs

@@ -0,0 +1,148 @@
+use crate::{book::Book, runtime::CommandLine};
+
+use super::ValidateArgs;
+
+pub(crate) async fn validate(args: ValidateArgs) -> anyhow::Result<()> {
+    let book = Book::from_path(args.path.clone(), None)?;
+
+    // we need at least one page
+    if book.pages.is_empty() {
+        return Err(anyhow::anyhow!("no pages found in {:?}", &args.path));
+    }
+
+    for (page_path, page) in book.pages {
+        log::info!("validating {:?} ...", page_path);
+
+        // and at least one function per page, at least what's the point of the page?
+        if page.functions.is_empty() {
+            return Err(anyhow::anyhow!("no functions found in {:?}", page_path));
+        } else if page.name.is_empty() {
+            // set by Book::from_path if not specified
+            return Err(anyhow::anyhow!("page name is empty in {:?}", page_path));
+        } else if page.categories.is_empty() {
+            // set by Book::from_path if not specified
+            return Err(anyhow::anyhow!(
+                "page categories are empty in {:?}",
+                page_path
+            ));
+        }
+
+        for (func_name, func) in page.functions {
+            // the model needs at least a name and a description
+            if func_name.is_empty() {
+                return Err(anyhow::anyhow!("function name is empty in {:?}", page_path));
+            } else if func.description.is_empty() {
+                return Err(anyhow::anyhow!(
+                    "function description is empty in {:?}",
+                    page_path
+                ));
+            }
+
+            if func.parameters.is_empty() {
+                return Err(anyhow::anyhow!(
+                    "function {} parameters are empty in {:?}",
+                    func_name,
+                    page_path
+                ));
+            }
+
+            // make sure the function resolves to a valid command line
+            let cmdline = func.execution.get_command_line().map_err(|e| {
+                anyhow::anyhow!(
+                    "error while getting command line for function {}: {}",
+                    func_name,
+                    e
+                )
+            })?;
+
+            if cmdline.is_empty() {
+                return Err(anyhow::anyhow!(
+                    "command line is empty for function {} in {:?}",
+                    func_name,
+                    page_path
+                ));
+            }
+
+            let cmdline = CommandLine::from_vec(&cmdline).map_err(|e| {
+                anyhow::anyhow!(
+                    "error while parsing command line for function {}: {}",
+                    func_name,
+                    e
+                )
+            })?;
+
+            // validate container requirements - a container is required if:
+            let container = if !cmdline.app_in_path {
+                // the binary is not in $PATH
+                if let Some(container) = &func.container {
+                    Some(container)
+                } else {
+                    return Err(anyhow::anyhow!(
+                        "binary for function {} in {:?} not in $PATH and container not specified",
+                        func_name,
+                        page_path
+                    ));
+                }
+            } else if func.container.is_some() && func.container.as_ref().unwrap().force {
+                // it's set and forced
+                Some(func.container.as_ref().unwrap())
+            } else {
+                None
+            };
+
+            // validate the container if any
+            if let Some(container) = container {
+                if args.skip_docker {
+                    // or not :P
+                    log::warn!("skipping container resolution for function {}", func_name);
+                } else {
+                    // this will pull or build the image
+                    container.resolve().await.map_err(|e| {
+                        anyhow::anyhow!(
+                            "error while resolving container for function {} in {}: {}",
+                            func_name,
+                            page_path,
+                            e
+                        )
+                    })?;
+
+                    // if volumes are defined make sure they exist
+                    if let Some(volumes) = &container.volumes {
+                        for volume in volumes {
+                            let (on_host, on_guest) =
+                                volume.split_once(':').unwrap_or((volume, volume));
+
+                            let on_host = shellexpand::full(on_host)
+                                .map_err(|e| {
+                                    anyhow::anyhow!(
+                                        "error while expanding volume path for function {}: {}",
+                                        func_name,
+                                        e
+                                    )
+                                })?
+                                .to_string();
+
+                            if !std::path::Path::new(&on_host).exists() {
+                                return Err(anyhow::anyhow!(
+                                    "page {}, function {}, path {} for volume '{}' does not exist",
+                                    page_path,
+                                    func_name,
+                                    on_host,
+                                    on_guest
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+
+            log::info!("  {} - ok", func_name);
+            log::debug!("    cmdline = {:?}", cmdline);
+            if let Some(container) = container {
+                log::debug!("    container = {:?}", container);
+            }
+        }
+    }
+
+    Ok(())
+}

src/main.rs

@@ -29,6 +29,7 @@ async fn main() -> anyhow::Result<()> {
         cli::Command::View(args) => cli::view(args).await,
         cli::Command::Serve(args) => cli::serve(args).await,
         cli::Command::Run(args) => cli::run(args).await,
+        cli::Command::Validate(args) => cli::validate(args).await,
     };
 
     if let Err(e) = result {

src/runtime/docker.rs

@@ -19,9 +19,9 @@ pub enum ContainerSource {
 }
 
 impl ContainerSource {
-    pub async fn resolve(&self) -> anyhow::Result<()> {
+    pub async fn resolve(&self, platform: Option<String>) -> anyhow::Result<()> {
         match self {
-            Self::Image(image) => pull_image(image).await,
+            Self::Image(image) => pull_image(image, platform).await,
             Self::Build { name, path } => build_image(name, path).await,
         }
     }
@@ -72,12 +72,19 @@ async fn run_command(command: &str, args: &[&str]) -> anyhow::Result<()> {
     }
 }
 
-pub(crate) async fn pull_image(image: &str) -> anyhow::Result<()> {
+pub(crate) async fn pull_image(image: &str, platform: Option<String>) -> anyhow::Result<()> {
     run_command(
         "sh",
         &[
             "-c",
-            &format!("docker images -q '{image}' | grep -q . || docker pull '{image}'"),
+            &format!(
+                "docker images -q '{image}' | grep -q . || docker pull {}'{image}'",
+                if let Some(platform) = platform {
+                    format!("--platform '{}' ", platform)
+                } else {
+                    "".to_string()
+                }
+            ),
         ],
     )
     .await

src/runtime/mod.rs

@@ -102,7 +102,7 @@ pub(crate) async fn execute_call(
         log::debug!("using container: {:?}", container);
 
         // build or pull the image if needed
-        container.source.resolve().await?;
+        container.resolve().await?;
 
         // wrap the command line
         container.wrap(command_line)?