pezkuwi-sdk/bizinikiwi/utils/wasm-builder/src/prerequisites.rs

// This file is part of Bizinikiwi.

// Copyright (C) Parity Technologies (UK) Ltd. and Dijital Kurdistan Tech Institute
// SPDX-License-Identifier: Apache-2.0

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// 	http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use crate::{write_file_if_changed, CargoCommand, CargoCommandVersioned, RuntimeTarget};

use console::style;
use std::{
	fs,
	path::{Path, PathBuf},
	process::Command,
};

use tempfile::tempdir;

/// Colorizes an error message, if color output is enabled.
fn colorize_error_message(message: &str) -> String {
	if super::color_output_enabled() {
		style(message).red().bold().to_string()
	} else {
		message.into()
	}
}

/// Colorizes an auxiliary message, if color output is enabled.
fn colorize_aux_message(message: &str) -> String {
	if super::color_output_enabled() {
		style(message).yellow().bold().to_string()
	} else {
		message.into()
	}
}

/// Checks that all prerequisites are installed.
///
/// Returns the versioned cargo command on success.
pub(crate) fn check(target: RuntimeTarget) -> Result<CargoCommandVersioned, String> {
	let cargo_command = crate::get_cargo_command(target);
	match target {
		RuntimeTarget::Wasm => {
			if !cargo_command.supports_bizinikiwi_runtime_env(target) {
				return Err(colorize_error_message(
					"Cannot compile a WASM runtime: no compatible Rust compiler found!\n\
					 Install at least Rust 1.68.0 or a recent nightly version.",
				));
			}

			check_wasm_toolchain_installed(cargo_command)
		},
		RuntimeTarget::Riscv => {
			if !cargo_command.supports_bizinikiwi_runtime_env(target) {
				return Err(colorize_error_message(
					"Cannot compile a RISC-V runtime: no compatible Rust compiler found!\n\
					 Install a toolchain from here and try again: https://github.com/paritytech/rustc-rv32e-toolchain",
				));
			}

			let dummy_crate = DummyCrate::new(&cargo_command, target, false);
			let version = dummy_crate.get_rustc_version();
			Ok(CargoCommandVersioned::new(cargo_command, version))
		},
	}
}

pub(crate) struct DummyCrate<'a> {
	cargo_command: &'a CargoCommand,
	temp: tempfile::TempDir,
	manifest_path: PathBuf,
	target: RuntimeTarget,
	ignore_target: bool,
}

impl<'a> DummyCrate<'a> {
	/// Creates a minimal dummy crate.
	pub(crate) fn new(
		cargo_command: &'a CargoCommand,
		target: RuntimeTarget,
		ignore_target: bool,
	) -> Self {
		let temp = tempdir().expect("Creating temp dir does not fail; qed");
		let project_dir = temp.path();
		fs::create_dir_all(project_dir.join("src")).expect("Creating src dir does not fail; qed");

		let manifest_path = project_dir.join("Cargo.toml");
		match target {
			RuntimeTarget::Wasm => {
				write_file_if_changed(
					&manifest_path,
					r#"
						[package]
						name = "dummy-crate"
						version = "1.0.0"
						edition = "2021"

						[lib]
						crate-type = ["cdylib"]

						[workspace]
					"#,
				);

				write_file_if_changed(
					project_dir.join("src/lib.rs"),
					r#"
						#![no_std]

						#[panic_handler]
						fn panic(_: &core::panic::PanicInfo<'_>) -> ! {
							loop {}
						}
					"#,
				);
			},
			RuntimeTarget::Riscv => {
				write_file_if_changed(
					&manifest_path,
					r#"
						[package]
						name = "dummy-crate"
						version = "1.0.0"
						edition = "2021"

						[workspace]
					"#,
				);

				write_file_if_changed(
					project_dir.join("src/main.rs"),
					"#![allow(missing_docs)] fn main() {}",
				);
			},
		}

		DummyCrate { cargo_command, temp, manifest_path, target, ignore_target }
	}

	fn prepare_command(&self, subcommand: &str) -> Command {
		let mut cmd = self.cargo_command.command();
		// Chdir to temp to avoid including project's .cargo/config.toml
		// by accident - it can happen in some CI environments.
		cmd.current_dir(&self.temp);
		cmd.arg(subcommand);
		if !self.ignore_target {
			cmd.arg(format!("--target={}", self.target.rustc_target(self.cargo_command)));
		}
		cmd.args(&["--manifest-path", &self.manifest_path.display().to_string()]);

		if super::color_output_enabled() {
			cmd.arg("--color=always");
		}

		// manually set the `CARGO_TARGET_DIR` to prevent a cargo deadlock
		let target_dir = self.temp.path().join("target").display().to_string();
		cmd.env("CARGO_TARGET_DIR", &target_dir);

		// Make sure the host's flags aren't used here, e.g. if an alternative linker is specified
		// in the RUSTFLAGS then the check we do here will break unless we clear these.
		cmd.env_remove("CARGO_ENCODED_RUSTFLAGS");
		cmd.env_remove("RUSTFLAGS");
		// Make sure if we're called from within a `build.rs` the host toolchain won't override a
		// rustup toolchain we've picked.
		cmd.env_remove("RUSTC");
		cmd
	}

	fn get_rustc_version(&self) -> String {
		let mut run_cmd = self.prepare_command("rustc");
		run_cmd.args(&["-q", "--", "--version"]);
		run_cmd
			.output()
			.ok()
			.and_then(|o| String::from_utf8(o.stdout).ok())
			.unwrap_or_else(|| "unknown rustc version".into())
	}

	fn get_sysroot(&self) -> Option<String> {
		let mut sysroot_cmd = self.prepare_command("rustc");
		sysroot_cmd.args(&["-q", "--", "--print", "sysroot"]);
		sysroot_cmd.output().ok().and_then(|o| String::from_utf8(o.stdout).ok())
	}

	fn get_toolchain(&self) -> Option<String> {
		let sysroot = self.get_sysroot()?;
		Path::new(sysroot.trim())
			.file_name()
			.and_then(|s| s.to_str())
			.map(|s| s.to_string())
	}

	pub(crate) fn is_target_installed(&self, target: &str) -> Option<bool> {
		let sysroot = self.get_sysroot()?;
		let target_libdir_path =
			Path::new(sysroot.trim()).join("lib").join("rustlib").join(target).join("lib");
		Some(target_libdir_path.exists())
	}

	fn try_build(&self) -> Result<(), Option<String>> {
		let Ok(result) = self.prepare_command("build").output() else { return Err(None) };
		if !result.status.success() {
			return Err(Some(String::from_utf8_lossy(&result.stderr).into()));
		}
		Ok(())
	}
}

fn check_wasm_toolchain_installed(
	cargo_command: CargoCommand,
) -> Result<CargoCommandVersioned, String> {
	let target = RuntimeTarget::Wasm;
	let rustc_target = target.rustc_target(&cargo_command);

	let dummy_crate = DummyCrate::new(&cargo_command, target, false);
	let toolchain = dummy_crate.get_toolchain().unwrap_or("<unknown>".to_string());

	if let Err(error) = dummy_crate.try_build() {
		let basic_error_message = colorize_error_message(
			&format!("Rust WASM target for toolchain {toolchain} is not properly installed; please install it!")
		);
		return match error {
			None => Err(basic_error_message),
			Some(error) if error.contains(&format!("the `{rustc_target}` target may not be installed")) => {
				Err(colorize_error_message(&format!("Cannot compile the WASM runtime: the `{rustc_target}` target is not installed!\n\
				                         You can install it with `rustup target add {rustc_target} --toolchain {toolchain}` if you're using `rustup`.")))
			},
			// Apparently this can happen when we're running on a non Tier 1 platform.
			Some(ref error) if error.contains("linker `rust-lld` not found") =>
				Err(colorize_error_message("Cannot compile the WASM runtime: `rust-lld` not found!")),
			Some(error) => Err(format!(
				"{}\n\n{}\n{}\n{}{}\n",
				basic_error_message,
				colorize_aux_message("Further error information:"),
				colorize_aux_message(&"-".repeat(60)),
				error,
				colorize_aux_message(&"-".repeat(60)),
			))
		};
	}

	let version = dummy_crate.get_rustc_version();

	let target = RuntimeTarget::new();
	assert!(target == RuntimeTarget::Wasm);
	if target.rustc_target_build_std(&cargo_command).is_some() {
		if let Some(sysroot) = dummy_crate.get_sysroot() {
			let src_path =
				Path::new(sysroot.trim()).join("lib").join("rustlib").join("src").join("rust");
			if !src_path.exists() {
				let toolchain = dummy_crate.get_toolchain().unwrap_or("<toolchain>".to_string());
				return Err(colorize_error_message(
					&format!("Cannot compile the WASM runtime: no standard library sources found at {}!\n\
					 You can install them with `rustup component add rust-src --toolchain {toolchain}` if you're using `rustup`.", src_path.display()),
				));
			}
		}
	}

	if cargo_command.supports_wasm32v1_none_target()
		&& !cargo_command.is_wasm32v1_none_target_installed()
	{
		build_helper::warning!("You are building WASM runtime using `wasm32-unknown-unknown` target, although Rust >= 1.84 supports `wasm32v1-none` target!");
		build_helper::warning!("You can install it with `rustup target add wasm32v1-none --toolchain {toolchain}` if you're using `rustup`.");
		build_helper::warning!("After installing `wasm32v1-none` target, you must rebuild WASM runtime from scratch, use `cargo clean` before building.");
	}

	Ok(CargoCommandVersioned::new(cargo_command, version))
}