chaud 0.1.0

A hot-reloading library for Cargo workspaces designed for ease of use. Unix only.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

#![allow(
    clippy::expect_used,
    clippy::missing_panics_doc,
    reason = "less restrictions on internal tests"
)]

use std::fs::FileTimes;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::time::SystemTime;
use std::{env, fs};
use walkdir::WalkDir;

fn main() {
    let tmp = PathBuf::from(env!("CARGO_TARGET_TMPDIR"));
    let target = tmp.join("demo_target");
    let dst = tmp.join("demo_dst");

    let mut root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    root.pop();

    let demo = root.join("demo");
    let chaud = root.join("chaud");
    let chaud = chaud.as_os_str().to_str().expect("not-utf8 root");

    let dirs = Dirs { chaud, demo: &demo, dst: &dst, target: &target };

    eprintln!("\n---\nSELFTEST: `cargo chaud`\n---");
    selftest(&dirs, &["chaud", "-Fselftest"], &[]);

    eprintln!("\n---\nSELFTEST: `cargo chaud --release`\n---");
    selftest(&dirs, &["chaud", "-Fselftest", "--release"], &[]);

    eprintln!("\n---\nSELFTEST: `RUSTC_WRAPPER=\"...\" cargo run`\n---");
    selftest(
        &dirs,
        &["run", "-Fselftest,chaud/unsafe-hot-reload"],
        &[("RUSTC_WRAPPER", "chaud-rustc")],
    );

    eprintln!("\n---\nSELFTEST: `RUSTC_WRAPPER=\"...\" cargo run --release`\n---");
    selftest(
        &dirs,
        &["run", "-Fselftest,chaud/unsafe-hot-reload", "--release"],
        &[("RUSTC_WRAPPER", "chaud-rustc")],
    );
}

struct Dirs<'a> {
    chaud: &'a str,
    demo: &'a Path,
    dst: &'a Path,
    target: &'a Path,
}

fn selftest(dirs: &Dirs, args: &[&str], env: &[(&str, &str)]) {
    sync(dirs.demo, dirs.dst);

    let manifest = dirs.dst.join("Cargo.toml");

    let mani = fs::read_to_string(&manifest).expect("failed to read manifest");
    let mani = mani.replace("../chaud", dirs.chaud);
    fs::write(&manifest, mani).expect("failed to write manifest");

    run(dirs, args, env);
}

fn run(dirs: &Dirs, args: &[&str], env: &[(&str, &str)]) {
    let mut cmd = Command::new("cargo");
    cmd.stdin(Stdio::null())
        .stderr(Stdio::inherit())
        .stdout(Stdio::inherit())
        .args(args)
        .env("CARGO_TARGET_DIR", dirs.target)
        .envs(env.iter().copied())
        .current_dir(dirs.dst);

    let status = cmd.status().expect("cargo failed");
    assert!(status.success(), "cargo failed: {status}");
}

fn sync(src: &Path, dst: &Path) {
    if dst.exists() {
        fs::remove_dir_all(dst).expect("remove dst failed");
    }
    if let Some(parent) = dst.parent() {
        fs::create_dir_all(parent).expect("create dst parent failed");
    }

    let mut buf = PathBuf::new();

    let times = FileTimes::new().set_modified(SystemTime::now());

    for entry in WalkDir::new(src) {
        let entry = entry.expect("walking src failed");
        let rel = entry
            .path()
            .strip_prefix(src)
            .expect("src not parent of entry");

        buf.clear();
        buf.push(dst);
        buf.push(rel);

        if entry.file_type().is_dir() {
            fs::create_dir(&buf).expect("create dir in dst failed");
            continue;
        }
        assert!(entry.file_type().is_file());

        fs::copy(entry.path(), &buf).expect("copy file to dst failed");
        let f = fs::OpenOptions::new()
            .create(false)
            .append(true)
            .open(&buf)
            .expect("open file in dst failed");

        // `fs::copy` copies mtimes. We need to update the mtime, otherwise
        // the mtime moves back in time from Cargo's perspective, which breaks
        // dirty detection.
        f.set_times(times).expect("set times in dst failed");
    }
}