From 2e5a8854bcb076f6c03d553427861efb97e0dc53 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bastian=20K=C3=B6cher?= <info@kchr.de>
Date: Thu, 9 Jun 2022 22:18:20 +0200
Subject: [PATCH] wasm-builder: Fix constant re-running of `build.rs` scripts.

Recently we added the wasm binaries to the `rerun-if-changed` list. The problem with that is that
they have a later mtime than the `invoked.timestamp` file and this file's mtime is used to determine
if the `build.rs` script needs to be re-run. The solution to this is that we copy the mtime of this
`invoked.timestamp` file and add it to the wasm binaries. Then cargo/rustc doesn't constantly wants
to rerun the `build.rs` script.
---
 Cargo.lock                             | 13 +++++++++++
 utils/wasm-builder/Cargo.toml          |  1 +
 utils/wasm-builder/src/wasm_project.rs | 32 ++++++++++++++++++++++++++
 3 files changed, 46 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 42accdb455cef..bcd70b19e2d4f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2007,6 +2007,18 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "filetime"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0408e2626025178a6a7f7ffc05a25bc47103229f19c113755de7bf63816290c"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "redox_syscall",
+ "winapi",
+]
+
 [[package]]
 name = "finality-grandpa"
 version = "0.15.0"
@@ -10601,6 +10613,7 @@ dependencies = [
  "ansi_term",
  "build-helper",
  "cargo_metadata",
+ "filetime",
  "sp-maybe-compressed-blob",
  "strum",
  "tempfile",
diff --git a/utils/wasm-builder/Cargo.toml b/utils/wasm-builder/Cargo.toml
index 0cd1249628f22..8f887e45ec176 100644
--- a/utils/wasm-builder/Cargo.toml
+++ b/utils/wasm-builder/Cargo.toml
@@ -22,3 +22,4 @@ toml = "0.5.4"
 walkdir = "2.3.2"
 wasm-gc-api = "0.1.11"
 sp-maybe-compressed-blob = { version = "4.1.0-dev", path = "../../primitives/maybe-compressed-blob" }
+filetime = "0.2.16"
diff --git a/utils/wasm-builder/src/wasm_project.rs b/utils/wasm-builder/src/wasm_project.rs
index 4316f9041f11d..be84f2fecfb53 100644
--- a/utils/wasm-builder/src/wasm_project.rs
+++ b/utils/wasm-builder/src/wasm_project.rs
@@ -152,9 +152,41 @@ pub(crate) fn create_and_compile(
 		&bloaty,
 	);
 
+	if let Err(err) = adjust_mtime(&bloaty, final_wasm_binary.as_ref()) {
+		build_helper::warning!("Error while adjusting the mtime of the wasm binaries: {}", err)
+	}
+
 	(final_wasm_binary, bloaty)
 }
 
+/// Adjust the mtime of the bloaty and compressed/compact wasm files.
+///
+/// We add the bloaty and the compressed/compact wasm file to the `rerun-if-changed` files.
+/// Cargo/Rustc determines based on the timestamp of the `invoked.timestamp` file that can be found
+/// in the `OUT_DIR/..`, if it needs to rerun a `build.rs` script. The problem is that this
+/// `invoked.timestamp` is created when the `build.rs` is executed and the wasm binaries are created
+/// later. This leads to them having a later mtime than the `invoked.timestamp` file and thus,
+/// cargo/rustc always re-executes the `build.rs` script. To hack around this, we copy the mtime of
+/// the `invoked.timestamp` to the wasm binaries.
+fn adjust_mtime(
+	bloaty_wasm: &WasmBinaryBloaty,
+	compressed_or_compact_wasm: Option<&WasmBinary>,
+) -> std::io::Result<()> {
+	let out_dir = build_helper::out_dir();
+	let invoked_timestamp = out_dir.join("../invoked.timestamp");
+
+	// Get the mtime of the `invoked.timestamp`
+	let metadata = fs::metadata(invoked_timestamp)?;
+	let mtime = filetime::FileTime::from_last_modification_time(&metadata);
+
+	filetime::set_file_mtime(bloaty_wasm.wasm_binary_bloaty_path(), mtime)?;
+	if let Some(binary) = compressed_or_compact_wasm.as_ref() {
+		filetime::set_file_mtime(binary.wasm_binary_path(), mtime)?;
+	}
+
+	Ok(())
+}
+
 /// Find the `Cargo.lock` relative to the `OUT_DIR` environment variable.
 ///
 /// If the `Cargo.lock` cannot be found, we emit a warning and return `None`.