feat: verify graph before rendering

Author: michiel

README.md

@@ -7,6 +7,34 @@
 ```
 xattr -d com.apple.quarantine ./layercake
 ```
+## Usage
+
+### Example
+
+Using the sample project,
+
+```
+# Generate the sample project
+$ layercake generate sample kvm_control_flow
+INFO layercake::generate_commands: Sample project generated successfully at: "kvm_control_flow"
+
+# Run the sample project with a plan, this will generate the output files
+$ layercake run -p kvm_control_flow/plan.yaml 
+INFO layercake: Running plan: kvm_control_flow/plan.yaml
+
+# Run the sample project with a plan, re-run the plan on input changes
+$ layercake run -p kvm_control_flow/plan.yaml -w
+```
+
+
+#### Example linux using inotifywait
+
+```bash
+while true; \
+  do inotifywait -e close_write out/kvm_control_flow.dot && \
+  dot -Tpng out/kvm_control_flow.dot -o out/kvm_control_flow.png; \
+done
+```
 
 ## Development
 

sample/attack_tree/plan.yaml

@@ -9,19 +9,19 @@ import:
 
 export:
   profiles:
-    - filename: "out/kvm-control-flow.gml"
+    - filename: "out/attack-tree.gml"
       exporter: "GML"
-    - filename: "out/kvm-control-flow.puml"
+    - filename: "out/attack-tree.puml"
       exporter: "PlantUML"
-    - filename: "out/kvm-control-flow.mermaid"
+    - filename: "out/attack-tree.mermaid"
       exporter: "Mermaid"
-    - filename: "out/kvm-control-flow.dot"
+    - filename: "out/attack-tree.dot"
       exporter: "DOT"
-    - filename: "out/kvm-control-flow-nodes-full.csv"
+    - filename: "out/attack-tree-nodes-full.csv"
       exporter: "CSVNodes"
-    - filename: "out/kvm-control-flow-edges-full.csv"
+    - filename: "out/attack-tree-edges-full.csv"
       exporter: "CSVEdges"
-    # - filename: "out/kvm-control-flow-custom.dot"
+    # - filename: "out/attack-tree-custom.dot"
     #   exporter: !Custom
     #     template: "sample/attack_tree/custom.hbs"
     #     # partials:

src/graph.rs

@@ -2,7 +2,7 @@ use polars::frame::row::Row;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
-use tracing::error;
+use tracing::{info, warn};
 
 #[derive(Serialize, Deserialize, Clone, Debug, Default)]
 pub struct Graph {
@@ -114,24 +114,44 @@ impl Graph {
         serde_json::json!(tree)
     }
 
-    pub fn verify_graph_integrity(&self) -> Result<(), String> {
-        // TODO verify that all nodes in edges are present in nodes
+    pub fn verify_graph_integrity(&self) -> Result<(), Vec<String>> {
         // TODO verify graph integrity
-        //
+        // TODO verify that all nodes have unique ids
+
         let node_ids: HashSet<String> = self.nodes.iter().map(|n| n.id.clone()).collect();
+        let mut errors = Vec::new();
 
+        let mut all_edges_have_nodes = true;
         for edge in &self.edges {
             if !node_ids.contains(&edge.source) {
-                let err = format!("Edge source {:?} not found in nodes", edge.source);
-                error!(err);
+                all_edges_have_nodes = false;
+                let err = format!(
+                    "Edge id:[{}] source {:?} not found in nodes",
+                    edge.id, edge.source
+                );
+                errors.push(err);
             }
             if !node_ids.contains(&edge.target) {
-                let err = format!("Target source {:?} not found in nodes", edge.target);
-                error!(err);
+                all_edges_have_nodes = false;
+                let err = format!(
+                    "Edge id:[{}] target {:?} not found in nodes",
+                    edge.id, edge.target
+                );
+                errors.push(err);
             }
         }
 
-        Ok(())
+        if all_edges_have_nodes {
+            info!("All edges have valid source and target nodes");
+        } else {
+            warn!("Some edges have missing source and/or target nodes");
+        }
+
+        if errors.is_empty() {
+            Ok(())
+        } else {
+            Err(errors)
+        }
     }
 }
 

src/plan_execution.rs

@@ -1,10 +1,9 @@
 use crate::data_loader;
 use crate::graph::{Edge, Graph, Layer, Node};
 use crate::plan::{ExportFileType, ImportFileType, Plan};
-use notify::{Config, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
+use notify::{Config, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
 use std::sync::mpsc::channel;
-use std::time::Duration;
-use tracing::{debug, error, info};
+use tracing::{debug, error, info, warn};
 
 use anyhow::Result;
 use polars::prelude::*;
@@ -98,34 +97,34 @@ fn run_plan(plan: Plan, plan_file_path: &std::path::Path) -> Result<()> {
 
     match graph.verify_graph_integrity() {
         Ok(_) => {
-            info!("Graph integrity verified");
+            info!("Graph integrity verified : ok - rendering exports");
+            plan.export.profiles.iter().for_each(|profile| {
+                info!(
+                    "Exporting file: {} using exporter {:?}",
+                    profile.filename, profile.exporter
+                );
+                let output = match profile.exporter.clone() {
+                    ExportFileType::GML => super::export::to_gml::render(graph.clone()),
+                    ExportFileType::DOT => super::export::to_dot::render(graph.clone()),
+                    ExportFileType::CSVNodes => "".to_string(),
+                    ExportFileType::CSVEdges => "".to_string(),
+                    ExportFileType::PlantUML => super::export::to_plantuml::render(graph.clone()),
+                    ExportFileType::Mermaid => super::export::to_mermaid::render(graph.clone()),
+                    ExportFileType::Custom(template) => {
+                        super::export::to_custom::render(graph.clone(), template)
+                    }
+                };
+
+                super::common::write_string_to_file(&profile.filename, &output).unwrap();
+            });
         }
-        Err(e) => {
-            error!("Error: {}", e);
-            // return Err(e.into());
+        Err(errors) => {
+            warn!("Identified {} graph integrity error(s)", errors.len());
+            errors.iter().for_each(|e| warn!("{}", e));
+            warn!("Not rendering exports");
         }
     }
 
-    plan.export.profiles.iter().for_each(|profile| {
-        info!(
-            "Exporting file: {} using exporter {:?}",
-            profile.filename, profile.exporter
-        );
-        let output = match profile.exporter.clone() {
-            ExportFileType::GML => super::export::to_gml::render(graph.clone()),
-            ExportFileType::DOT => super::export::to_dot::render(graph.clone()),
-            ExportFileType::CSVNodes => "".to_string(),
-            ExportFileType::CSVEdges => "".to_string(),
-            ExportFileType::PlantUML => super::export::to_plantuml::render(graph.clone()),
-            ExportFileType::Mermaid => super::export::to_mermaid::render(graph.clone()),
-            ExportFileType::Custom(template) => {
-                super::export::to_custom::render(graph.clone(), template)
-            }
-        };
-
-        super::common::write_string_to_file(&profile.filename, &output).unwrap();
-    });
-
     debug!("Graph: {:?}", graph);
 
     Ok(())