add howcreated

Author: gtfierro

lib/src/config.rs

@@ -172,3 +172,24 @@ impl Config {
         Ok(config)
     }
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum HowCreated {
+    New,
+    SameConfig,
+    RecreatedDifferentConfig,
+    RecreatedFlag,
+}
+
+impl std::fmt::Display for HowCreated {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            HowCreated::New => write!(f, "New Environment"),
+            HowCreated::SameConfig => write!(f, "Same Config. Reusing existing environment."),
+            HowCreated::RecreatedDifferentConfig => {
+                write!(f, "Recreated environment due to different config")
+            }
+            HowCreated::RecreatedFlag => write!(f, "Recreated environment due to 'recreate' flag"),
+        }
+    }
+}

lib/src/lib.rs

@@ -10,7 +10,7 @@ pub mod policy;
 pub mod util;
 pub mod transform;
 
-use crate::config::Config;
+use crate::config::{Config, HowCreated};
 use crate::doctor::{Doctor, DuplicateOntology, OntologyDeclaration};
 use crate::ontology::{GraphIdentifier, Ontology, OntologyLocation};
 use anyhow::Result;
@@ -63,6 +63,8 @@ pub struct EnvironmentStatus {
     last_updated: Option<DateTime<Utc>>,
     // size of the oxigraph store, in bytes
     store_size: u64,
+    // how this environment was last created
+    how_created: HowCreated,
 }
 
 // impl Display pretty print for EnvironmentStatus
@@ -81,9 +83,11 @@ impl std::fmt::Display for EnvironmentStatus {
         write!(
             f,
             "Environment Status\n\
+            How Created: {}\n\
             Number of Ontologies: {}\n\
             Last Updated: {}\n\
             Store Size: {} bytes",
+            self.how_created,
             self.num_ontologies,
             last_updated,
             pretty_bytes(self.store_size as f64),
@@ -99,6 +103,7 @@ pub struct OntoEnv {
     dependency_graph: DiGraph<GraphIdentifier, (), petgraph::Directed>,
     #[serde(skip)]
     read_only: bool,
+    how_created: HowCreated,
 }
 
 // probably need some graph "identifier" that incorporates location and version..
@@ -111,27 +116,38 @@ impl OntoEnv {
         // is created
         let ontoenv_dir = config.root.join(".ontoenv");
         let config_path = ontoenv_dir.join("ontoenv.json");
+        let mut how_created = HowCreated::New;
+        info!("Creating OntoEnv with config: {:?}", config);
 
         // test if the config in the ontoenv_dir is different from the current config.
         // If it is, replace the config with the current config and turn 'recreate' on
-        if ontoenv_dir.exists() && config_path.exists() {
-            println!(
+        if ontoenv_dir.exists() && config_path.exists() && !recreate {
+            info!(
                 "OntoEnv directory exists: {:?}. Checking config",
                 ontoenv_dir
             );
+            how_created = HowCreated::SameConfig;
             let file = std::fs::File::open(&config_path)?;
             let reader = BufReader::new(file);
-            let env: OntoEnv = serde_json::from_reader(reader)?;
+            let mut env: OntoEnv = serde_json::from_reader(reader)?;
             // print old and new config
-            println!("Old config: {:?}", env.config);
-            println!("New config: {:?}", config);
             if env.config != config {
                 info!("OntoEnv configuration has changed. Recreating environment.");
                 fs::remove_dir_all(&ontoenv_dir)?;
-                return Self::new(config, true);
+                env = Self::new(config, true)?;
+                env.how_created = HowCreated::RecreatedDifferentConfig;
+                return Ok(env);
             }
         }
 
+        if recreate {
+            info!("Recreating environment");
+            if ontoenv_dir.exists() {
+                fs::remove_dir_all(&ontoenv_dir)?;
+            }
+            how_created = HowCreated::RecreatedFlag;
+        }
+
         // if recreate is False, raise an error if the directory already exists
         //if ontoenv_dir.exists() && !recreate {
         //    return Err(anyhow::anyhow!(
@@ -148,6 +164,7 @@ impl OntoEnv {
             ontologies: HashMap::new(),
             dependency_graph: DiGraph::new(),
             read_only: false,
+            how_created,
         })
     }
 
@@ -178,6 +195,10 @@ impl OntoEnv {
         Ok(size)
     }
 
+    pub fn get_how_created(&self) -> HowCreated {
+        self.how_created.clone()
+    }
+
     /// Calculates and returns the environment status
     pub fn status(&self) -> Result<EnvironmentStatus> {
         let store = self.store()?;
@@ -191,6 +212,7 @@ impl OntoEnv {
             num_ontologies,
             last_updated: Some(last_updated),
             store_size: size,
+            how_created: self.how_created.clone(),
         })
     }
 

lib/tests/ontoenv_test.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use ontoenv::config::Config;
+use ontoenv::config::{Config, HowCreated};
 use ontoenv::ontology::OntologyLocation;
 use ontoenv::OntoEnv;
 use oxigraph::model::NamedNodeRef;
@@ -81,6 +81,20 @@ fn default_config(dir: &TempDir) -> Config {
     .unwrap()
 }
 
+fn default_config_ttl_only(dir: &TempDir) -> Config {
+    Config::new(
+        dir.path().into(),
+        Some(vec![dir.path().into()]),
+        &["*.ttl"],
+        &[""],
+        false,
+        true,
+        true,
+        "default".to_string(),
+    )
+    .unwrap()
+}
+
 fn default_config_with_subdir(dir: &TempDir, path: &str) -> Config {
     Config::new(
         dir.path().into(),
@@ -210,13 +224,23 @@ fn test_recreate() -> Result<()> {
                    "fixtures/ont4.ttl" => "ont4.ttl" });
     let cfg = default_config(&dir);
     let env = OntoEnv::new(cfg, false)?;
-    // create a new env, like above, but make sure it raises an error
+    env.save_to_directory()?;
+    assert_eq!(env.get_how_created(), HowCreated::New);
+    // create a new env with the same config. This should still work.
     let cfg = default_config(&dir);
-    let env = OntoEnv::new(cfg, false);
-    assert!(env.is_err());
-
+    let env = OntoEnv::new(cfg, false)?;
+    env.save_to_directory()?;
+    assert_eq!(env.get_how_created(), HowCreated::SameConfig);
+    // change the config; this should trigger a recreation of the environment
+    let cfg = default_config_ttl_only(&dir);
+    let env = OntoEnv::new(cfg, false)?;
+    env.save_to_directory()?;
+    assert_eq!(env.get_how_created(), HowCreated::RecreatedDifferentConfig);
+    // now try to recreate the env with the same config but with recreate set to true
     let cfg = default_config(&dir);
     let env = OntoEnv::new(cfg, true)?;
+    env.save_to_directory()?;
+    assert_eq!(env.get_how_created(), HowCreated::RecreatedFlag);
 
     teardown(dir);
     Ok(())