catalog-protos: check hashes of object definitions files

This commit changes the existing hash checking logic meant to ensure
that the versioned proto files never change to check the new Rust source
files instead.

Author: teskje

src/catalog-protos/build.rs

@@ -9,47 +9,46 @@
 
 use std::collections::BTreeMap;
 use std::fs;
-use std::io::{BufReader, Write};
+use std::io::Write;
+use std::path::PathBuf;
 
 use anyhow::Context;
 use md5::{Digest, Md5};
 use serde::{Deserialize, Serialize};
 
-/// The path of a protobuf file and its [`md5`] hash.
+/// The path of an object definition file and its [`md5`] hash.
 ///
 /// We store a hash of all the files to make sure they don't accidentally change, which would
 /// invalidate our snapshotted types, and could silently introduce bugs.
 #[derive(Debug, Clone, Deserialize, Serialize)]
-struct ProtoHash {
+struct ObjectsHash {
     name: String,
     md5: String,
 }
 
-const PROTO_DIRECTORY: &str = "protos";
-const PROTO_HASHES: &str = "protos/hashes.json";
+const OBJECTS_HASHES: &str = "objects_hashes.json";
 
 fn main() -> anyhow::Result<()> {
-    println!("cargo:rerun-if-changed={PROTO_DIRECTORY}");
+    let crate_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
 
     // Read in the persisted hashes from disk.
-    let hashes = fs::File::open(PROTO_HASHES).context("opening proto hashes")?;
-    let reader = BufReader::new(&hashes);
-    let hashes: Vec<ProtoHash> = serde_json::from_reader(reader)?;
+    let hashes_path = crate_root.join(OBJECTS_HASHES);
+    let hashes_json = fs::read_to_string(&hashes_path)?;
+    let hashes: Vec<ObjectsHash> = serde_json::from_str(&hashes_json)?;
     let mut persisted: BTreeMap<String, String> =
         hashes.into_iter().map(|e| (e.name, e.md5)).collect();
 
-    // Discover all of the protobuf files on disk.
-    let protos: BTreeMap<String, String> = fs::read_dir(PROTO_DIRECTORY)?
+    // Discover all of the object definition files on disk.
+    let src_dir = crate_root.join("src");
+    let objects: BTreeMap<String, String> = fs::read_dir(src_dir)?
         // If we fail to read one file, fail everything.
         .collect::<Result<Vec<_>, _>>()?
         .into_iter()
-        // Filter to only files with the .proto extension.
+        // Filter to only files with the of the form `objects*.rs`.
         .filter(|entry| {
-            entry
-                .path()
-                .extension()
-                .map(|e| e.to_string_lossy().contains("proto"))
-                .unwrap_or(false)
+            let name = entry.file_name();
+            let s = name.to_string_lossy();
+            s.starts_with("objects") && s.ends_with(".rs")
         })
         .map(|file| {
             let path = file.path();
@@ -71,34 +70,34 @@ fn main() -> anyhow::Result<()> {
         })
         .collect();
 
-    // After validating our hashes we'll re-write the file if any new protos
+    // After validating our hashes we'll re-write the file if any new object definitions
     // have been added.
-    let mut to_persist: Vec<ProtoHash> = Vec::new();
+    let mut to_persist: Vec<ObjectsHash> = Vec::new();
     let mut any_new = false;
 
     // Check the persisted hashes against what we just read in from disk.
-    for (name, hash) in protos {
+    for (name, hash) in objects {
         match persisted.remove(&name) {
             // Hashes have changed!
             Some(og_hash) if hash != og_hash => {
                 anyhow::bail!(error_message(og_hash, hash, name));
             }
-            // Found a proto file on disk that we didn't have persisted, we'll just persist it.
+            // Found an objects file on disk that we didn't have persisted, we'll just persist it.
             None => {
-                to_persist.push(ProtoHash { name, md5: hash });
+                to_persist.push(ObjectsHash { name, md5: hash });
                 any_new = true;
             }
             // We match!
-            Some(_) => to_persist.push(ProtoHash { name, md5: hash }),
+            Some(_) => to_persist.push(ObjectsHash { name, md5: hash }),
         }
     }
 
-    // Check if there are any proto files we should have had hashes for, but didn't exist.
+    // Check if there are any objects files we should have had hashes for, but didn't exist.
     if !persisted.is_empty() {
         anyhow::bail!("Have persisted hashes, but no files on disk? {persisted:#?}");
     }
 
-    // Write the hashes back out to disk if and only if there are new protos. We
+    // Write the hashes back out to disk if and only if there are new object definitions. We
     // don't do this unconditionally or we'll get stuck in a rebuild loop:
     // executing this build script will change the mtime on the hashes file,
     // which will force the next compile to rebuild the crate, even if nothing
@@ -107,7 +106,7 @@ fn main() -> anyhow::Result<()> {
         let mut file = fs::File::options()
             .write(true)
             .truncate(true)
-            .open(PROTO_HASHES)
+            .open(hashes_path)
             .context("opening hashes file to write")?;
         serde_json::to_writer_pretty(&mut file, &to_persist).context("persisting hashes")?;
         write!(&mut file, "\n").context("writing newline")?;
@@ -198,12 +197,12 @@ fn main() -> anyhow::Result<()> {
 
 /// A (hopefully) helpful error message that describes what to do when the hashes differ.
 fn error_message(og_hash: String, hash: String, filename: String) -> String {
-    let title = "Hashes changed for the persisted protobuf files!";
+    let title = "Hashes changed for the persisted object definition files!";
     let body1 = format!(
-        "If you changed '{filename}' without first making a snapshot, then you need to copy '{filename}' and rename it with a suffix like '_vX.proto'."
+        "If you changed '{filename}' without first making a snapshot, then you need to copy '{filename}' and rename it with a suffix like '_vX.rs'."
     );
     let body2 = format!(
-        "Otherwise you can update the hash for '{filename}' in '{PROTO_HASHES}' to be '{hash}'."
+        "Otherwise you can update the hash for '{filename}' in '{OBJECTS_HASHES}' to be '{hash}'."
     );
     let hashes = format!("persisted_hash({og_hash}) != current_hash({hash})\nFile: {filename}");
 

src/catalog-protos/objects_hashes.json

@@ -0,0 +1,54 @@
+[
+  {
+    "name": "objects.rs",
+    "md5": "26ae04e683a5462c3998d8f9d8d6a0fa"
+  },
+  {
+    "name": "objects_v67.rs",
+    "md5": "6f9b22cb3147dd2a685fe27b4cd016ee"
+  },
+  {
+    "name": "objects_v68.rs",
+    "md5": "d218ef6aabce8dc418ffde99d27dec03"
+  },
+  {
+    "name": "objects_v69.rs",
+    "md5": "55cb125ee8c1348acc1e129f41903931"
+  },
+  {
+    "name": "objects_v70.rs",
+    "md5": "767b231f11679065126c8d83ae6a763b"
+  },
+  {
+    "name": "objects_v71.rs",
+    "md5": "767b231f11679065126c8d83ae6a763b"
+  },
+  {
+    "name": "objects_v72.rs",
+    "md5": "767b231f11679065126c8d83ae6a763b"
+  },
+  {
+    "name": "objects_v73.rs",
+    "md5": "6e2c445773820d0579ff3d66f1fac7e8"
+  },
+  {
+    "name": "objects_v74.rs",
+    "md5": "b87d99e30098642f98b0bb1927516baa"
+  },
+  {
+    "name": "objects_v75.rs",
+    "md5": "67a4a7da3e3f7cb1fd01963d5b118b01"
+  },
+  {
+    "name": "objects_v76.rs",
+    "md5": "26ae04e683a5462c3998d8f9d8d6a0fa"
+  },
+  {
+    "name": "objects_v77.rs",
+    "md5": "26ae04e683a5462c3998d8f9d8d6a0fa"
+  },
+  {
+    "name": "objects_v78.rs",
+    "md5": "26ae04e683a5462c3998d8f9d8d6a0fa"
+  }
+]