use std::collections::VecDeque;
use std::env::consts::DLL_EXTENSION;
use std::io::{BufRead, BufReader};
use std::net::{TcpListener, TcpStream};
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::mpsc;
use std::time::{Duration, Instant};
use notify::{Config as NotifyConfig, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
use telar_project::protocol::{
DEVTOOLS_VAR, Frontend, HOT_LIB_VAR, HOT_PORT_VAR, HOT_REPLIES_LINE, HOT_TOKEN_VAR, HotEvent,
HotOutcome, HotReply, PREVIEW_VAR, RENDERER_BACKEND_VAR, TARGET_VAR, TEST_TARGET_DIR_VAR,
WORKSPACE_DIR_VAR, dev_window_env, encode_flag,
};
use telar_project::{AssetKind, DEVTOOLS_PACKAGE, ManifestError, TelarManifest, WORKSHOP_PACKAGE};
use super::android::{android_install_and_launch, make_android_cmd};
use super::artifacts::{self, build_with_diagnostics, with_json_messages};
use super::config::{
ResolvedPackage, TelarSection, missing_devtools_note, resolve_package, split_android_flag,
warn_if_tooling_unlocked,
};
use super::workshop_channel::WorkshopChannel;
fn inject_feature(args: &mut Vec<String>, feature: &str) {
args.push("--features".to_string());
args.push(feature.to_string());
}
fn make_lib_build_args(args: &[String], features: &[&str]) -> Vec<String> {
let mut lib_build_args = vec!["build".to_string(), "--lib".to_string()];
lib_build_args.extend(args.iter().cloned());
for feature in features {
inject_feature(&mut lib_build_args, feature);
}
with_json_messages(&mut lib_build_args);
lib_build_args
}
fn is_asset_extension(ext: &str) -> bool {
AssetKind::ALL
.into_iter()
.any(|kind| kind.extensions().contains(&ext))
}
pub(crate) struct WatchSet {
dirs: Vec<PathBuf>,
manifests: Vec<PathBuf>,
}
impl WatchSet {
pub(crate) fn collect(workspace_root: &Path) -> Result<Self, ManifestError> {
let canonical = |path: PathBuf| path.canonicalize().unwrap_or(path);
Ok(Self {
dirs: collect_watch_dirs(workspace_root)?
.into_iter()
.map(canonical)
.collect(),
manifests: collect_watch_manifests(workspace_root)
.into_iter()
.map(|manifest| match (manifest.parent(), manifest.file_name()) {
(Some(parent), Some(name)) => canonical(parent.to_path_buf()).join(name),
_ => manifest,
})
.collect(),
})
}
}
impl WatchScope for WatchSet {
fn wants(&self, event: ¬ify::Event) -> bool {
if !matches!(
event.kind,
EventKind::Modify(_) | EventKind::Create(_) | EventKind::Remove(_)
) {
return false;
}
event.paths.iter().any(|p| {
if self.manifests.contains(p) {
return true;
}
let ext = p.extension().and_then(|e| e.to_str()).unwrap_or("");
self.dirs.iter().any(|dir| p.starts_with(dir))
&& (matches!(ext, "rs" | "rsx" | "toml") || is_asset_extension(ext))
})
}
fn watches(&self) -> Vec<(PathBuf, RecursiveMode)> {
let mut parents: Vec<PathBuf> = self
.manifests
.iter()
.filter_map(|manifest| manifest.parent().map(Path::to_path_buf))
.filter(|parent| parent.is_dir())
.filter(|parent| !self.dirs.iter().any(|dir| parent.starts_with(dir)))
.collect();
parents.sort();
parents.dedup();
self.dirs
.iter()
.map(|dir| (dir.clone(), RecursiveMode::Recursive))
.chain(
parents
.into_iter()
.map(|parent| (parent, RecursiveMode::NonRecursive)),
)
.collect()
}
}
fn collect_watch_manifests(workspace_root: &Path) -> Vec<PathBuf> {
let mut manifests: Vec<PathBuf> = telar_project::workspace_member_dirs(workspace_root)
.into_iter()
.chain(std::iter::once(workspace_root.to_path_buf()))
.map(|dir| dir.join(telar_project::MANIFEST_FILENAME))
.collect();
manifests.sort();
manifests.dedup();
manifests
}
fn collect_watch_dirs(workspace_root: &Path) -> Result<Vec<PathBuf>, ManifestError> {
let mut dirs = Vec::new();
for member in telar_project::workspace_member_dirs(workspace_root) {
let telar = TelarManifest::load(&member)?.telar;
dirs.push(member.join("src"));
dirs.push(telar.assets_root(&member));
dirs.extend(telar.locales_root(&member));
dirs.extend(telar.icons.and_then(|icons| icons.svg_dir(&member)));
}
dirs.retain(|dir| dir.is_dir());
dirs.sort();
dirs.dedup();
let nested: Vec<PathBuf> = dirs
.iter()
.filter(|dir| {
dirs.iter()
.any(|other| *dir != other && dir.starts_with(other))
})
.cloned()
.collect();
dirs.retain(|dir| !nested.contains(dir));
Ok(dirs)
}
struct HotChannel {
adopted: mpsc::Receiver<TcpStream>,
stream: Option<TcpStream>,
port: u16,
token: String,
reloads: Reloads,
}
impl HotChannel {
fn bind() -> Self {
let listener = TcpListener::bind(("127.0.0.1", 0))
.expect("[cargo-telar] failed to bind hot reload port");
let port = listener
.local_addr()
.expect("[cargo-telar] failed to read hot reload port")
.port();
let token = hot_token();
let (handed, adopted) = mpsc::channel();
let (heard_tx, heard) = mpsc::channel();
let expected = token.clone();
std::thread::Builder::new()
.name("cargo-telar-hot-accept".to_string())
.spawn(move || adopt_first_authenticated(listener, &expected, &handed, &heard_tx))
.expect("[cargo-telar] failed to start the hot reload listener");
HotChannel {
adopted,
stream: None,
port,
token,
reloads: Reloads::new(heard),
}
}
fn notify_hot_reload(&mut self, lib_path: &Path) {
if self.send(&HotEvent::Reload(lib_path.to_path_buf())) {
self.reloads
.sent(&lib_path.to_string_lossy(), Instant::now());
}
}
fn notify_build_error(&mut self, message: &str) {
self.send(&HotEvent::BuildError(message.to_owned()));
}
fn send(&mut self, event: &HotEvent) -> bool {
let line = match event.line() {
Ok(line) => line,
Err(error) => {
eprintln!("[cargo-telar] Not sent to the app: {error}.");
return false;
}
};
self.accept_waiting();
if self.stream.is_none() {
eprintln!("[cargo-telar] App not connected to the hot reload channel.");
return false;
}
self.write_line(&line)
}
fn deliver(&mut self, event: &HotEvent) -> bool {
match event.line() {
Ok(line) => self.write_line(&line),
Err(_) => true,
}
}
fn write_line(&mut self, message: &str) -> bool {
use std::io::Write;
self.accept_waiting();
let Some(stream) = &mut self.stream else {
return false;
};
match writeln!(stream, "{message}") {
Ok(()) => true,
Err(e) => {
eprintln!("[cargo-telar] Failed to write to hot reload channel: {e}");
self.stream = None;
false
}
}
}
fn accept_waiting(&mut self) {
if let Ok(stream) = self.adopted.try_recv() {
self.stream = Some(stream);
}
}
}
const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(2);
fn hot_token() -> String {
let mut bytes = [0u8; 32];
getrandom::fill(&mut bytes)
.expect("[cargo-telar] could not draw the hot reload token from the system's randomness");
bytes.iter().map(|byte| format!("{byte:02x}")).collect()
}
fn adopt_first_authenticated(
listener: TcpListener,
token: &str,
handed: &mpsc::Sender<TcpStream>,
heard_tx: &mpsc::Sender<Heard>,
) {
let Some(stream) = listener
.incoming()
.flatten()
.find(|stream| opens_with(stream, token))
else {
return;
};
drop(listener);
let reader = stream.try_clone();
if handed.send(stream).is_err() {
return;
}
match reader {
Ok(reader) => hear_out(reader, heard_tx),
Err(e) => eprintln!(
"[cargo-telar] warning: the app's answers to reloads cannot be read ({e}); whether a reload loads will not be known."
),
}
}
#[derive(Debug, PartialEq)]
enum Heard {
AnswersReloads,
Reply(HotReply),
}
fn heard_from(line: &str) -> Option<Heard> {
if line == HOT_REPLIES_LINE {
return Some(Heard::AnswersReloads);
}
HotReply::parse(line).map(Heard::Reply)
}
fn hear_out(stream: TcpStream, heard_tx: &mpsc::Sender<Heard>) {
for line in BufReader::new(stream).lines() {
let Ok(line) = line else { break };
if let Some(heard) = heard_from(&line)
&& heard_tx.send(heard).is_err()
{
break;
}
}
}
const REPLY_TIMEOUT: Duration = Duration::from_secs(10);
#[derive(Debug, PartialEq)]
enum ReloadOutcome {
Answered(HotOutcome),
Unanswered { app_answers: bool },
ChannelClosed,
}
impl ReloadOutcome {
fn message(&self) -> String {
match self {
ReloadOutcome::Answered(HotOutcome::Loaded) => "Hot reloaded.".to_owned(),
ReloadOutcome::Answered(HotOutcome::Panicked(report)) => {
format!("The rebuilt library loaded, but the app panicked while starting: {report}")
}
ReloadOutcome::Answered(HotOutcome::Refused(reason)) => {
format!("Hot reload refused, the app keeps running the build before: {reason}")
}
ReloadOutcome::Answered(HotOutcome::Unreadable(report)) => format!(
"The rebuilt library loaded, but the app cannot read what it answers, so nothing of it runs; restart `cargo telar` to build both from the same sources: {report}"
),
ReloadOutcome::Unanswered { app_answers: true } => format!(
"The app has not said within {}s whether it loaded the rebuilt library; its answer is printed when it comes.",
REPLY_TIMEOUT.as_secs()
),
ReloadOutcome::Unanswered { app_answers: false } => "Rebuilt library sent; this app does not say whether it loads one (it is built against a telar from before reload answers).".to_owned(),
ReloadOutcome::ChannelClosed => "The hot reload channel closed before the app said whether it loaded the rebuilt library.".to_owned(),
}
}
}
struct PendingReload {
library: String,
deadline: Instant,
overdue: bool,
}
struct Reloads {
heard: mpsc::Receiver<Heard>,
app_answers: bool,
pending: VecDeque<PendingReload>,
}
impl Reloads {
fn new(heard: mpsc::Receiver<Heard>) -> Self {
Self {
heard,
app_answers: false,
pending: VecDeque::new(),
}
}
fn sent(&mut self, library: &str, now: Instant) {
self.pending.push_back(PendingReload {
library: library.to_owned(),
deadline: now + REPLY_TIMEOUT,
overdue: false,
});
}
fn settle(&mut self, now: Instant) -> Vec<ReloadOutcome> {
let mut outcomes = Vec::new();
loop {
match self.heard.try_recv() {
Ok(Heard::AnswersReloads) => self.app_answers = true,
Ok(Heard::Reply(reply)) => {
self.answered(&reply.library);
outcomes.push(ReloadOutcome::Answered(reply.outcome));
}
Err(mpsc::TryRecvError::Empty) => break,
Err(mpsc::TryRecvError::Disconnected) => {
self.give_up(&mut outcomes);
return outcomes;
}
}
}
for reload in &mut self.pending {
if !reload.overdue && now >= reload.deadline {
reload.overdue = true;
outcomes.push(ReloadOutcome::Unanswered {
app_answers: self.app_answers,
});
}
}
if !self.app_answers {
self.pending.retain(|reload| !reload.overdue);
}
outcomes
}
fn finish(&mut self) -> Vec<ReloadOutcome> {
let mut outcomes = self.settle(Instant::now());
self.give_up(&mut outcomes);
outcomes
}
fn answered(&mut self, library: &str) {
if let Some(index) = self
.pending
.iter()
.position(|reload| reload.library == library)
{
self.pending.remove(index);
}
}
fn give_up(&mut self, outcomes: &mut Vec<ReloadOutcome>) {
if !self.pending.is_empty() {
outcomes.push(ReloadOutcome::ChannelClosed);
}
self.pending.clear();
}
}
fn report_reloads(outcomes: Vec<ReloadOutcome>) {
for outcome in outcomes {
eprintln!("[cargo-telar] {}", outcome.message());
}
}
fn opens_with(mut stream: &TcpStream, token: &str) -> bool {
use std::io::Read;
if stream.set_read_timeout(Some(HANDSHAKE_TIMEOUT)).is_err() {
return false;
}
let mut line = Vec::with_capacity(token.len());
let mut byte = [0u8];
while line.len() <= token.len() {
match stream.read(&mut byte) {
Ok(1) if byte[0] == b'\n' => break,
Ok(1) => line.push(byte[0]),
_ => return false,
}
}
let matches = line.len() == token.len()
&& line
.iter()
.zip(token.as_bytes())
.fold(0, |differ, (a, b)| differ | (a ^ b))
== 0;
matches && stream.set_read_timeout(None).is_ok()
}
const DEBOUNCE: Duration = Duration::from_millis(200);
const POLL: Duration = Duration::from_millis(50);
pub(crate) trait WatchScope {
fn watches(&self) -> Vec<(PathBuf, RecursiveMode)>;
fn wants(&self, event: ¬ify::Event) -> bool;
}
pub(crate) struct ChangeFeed<S> {
scope: S,
messages: mpsc::Receiver<notify::Result<notify::Event>>,
_watcher: RecommendedWatcher,
}
impl<S: WatchScope> ChangeFeed<S> {
pub(crate) fn start(scope: S) -> notify::Result<Self> {
let (tx, messages) = mpsc::channel();
let mut watcher = RecommendedWatcher::new(tx, NotifyConfig::default())?;
for (dir, mode) in scope.watches() {
if let Err(error) = watcher.watch(&dir, mode) {
let error = match error.paths.is_empty() {
true => error.add_path(dir),
false => error,
};
eprintln!("[cargo-telar] {}", watch_failure(&error));
}
}
Ok(Self {
scope,
messages,
_watcher: watcher,
})
}
pub(crate) fn wait(&self) {
loop {
match self.messages.recv() {
Ok(message) if self.is_change(&message) => return,
Ok(_) => {}
Err(_) => {
eprintln!(
"[cargo-telar] warning: the file watcher stopped; edits are no longer picked up."
);
idle();
}
}
}
}
pub(crate) fn changed_within(&self, timeout: Duration) -> bool {
let deadline = Instant::now() + timeout;
while let Some(left) = deadline.checked_duration_since(Instant::now()) {
match self.messages.recv_timeout(left) {
Ok(message) if self.is_change(&message) => return true,
Ok(_) => {}
Err(_) => return false,
}
}
false
}
pub(crate) fn drain(&self) -> bool {
let mut changed = false;
for message in self.messages.try_iter() {
changed |= self.is_change(&message);
}
changed
}
pub(crate) fn settle(&self, quiet: Duration) {
while let Ok(message) = self.messages.recv_timeout(quiet) {
self.is_change(&message);
}
}
fn is_change(&self, message: ¬ify::Result<notify::Event>) -> bool {
match message {
Ok(event) if event.need_rescan() => {
eprintln!(
"[cargo-telar] The file watcher lost events; rebuilding in case one was an edit."
);
true
}
Ok(event) => self.scope.wants(event),
Err(error) => {
eprintln!("[cargo-telar] {}", watch_failure(error));
false
}
}
}
}
fn watch_failure(error: ¬ify::Error) -> String {
let reason = match &error.kind {
notify::ErrorKind::Generic(message) => message.clone(),
notify::ErrorKind::Io(io) => io.to_string(),
notify::ErrorKind::PathNotFound => "it does not exist".to_string(),
notify::ErrorKind::WatchNotFound => "it is not being watched".to_string(),
notify::ErrorKind::InvalidConfig(config) => {
format!("the watcher configuration {config:?} is invalid")
}
notify::ErrorKind::MaxFilesWatch => {
let limit = max_user_watches().map_or_else(String::new, |limit| format!(" ({limit})"));
format!(
"the system limit on watched directories{limit} is reached; raise `fs.inotify.max_user_watches` with sysctl"
)
}
};
let paths: Vec<String> = error
.paths
.iter()
.map(|path| path.display().to_string())
.collect();
match paths.is_empty() {
true => format!(
"warning: the file watcher failed: {reason}. Some edits may not trigger a rebuild."
),
false => format!(
"warning: could not watch {}: {reason}. Edits there will not trigger a rebuild.",
paths.join(", ")
),
}
}
fn max_user_watches() -> Option<String> {
std::fs::read_to_string("/proc/sys/fs/inotify/max_user_watches")
.ok()
.map(|limit| limit.trim().to_string())
}
pub(crate) fn idle() -> ! {
loop {
std::thread::park();
}
}
struct HotLaunch {
package_dir: PathBuf,
bin_path: PathBuf,
lib_path: PathBuf,
args: Vec<String>,
envs: Vec<(String, String)>,
}
fn watch_and_hot_reload(
build_args: Vec<String>,
launch: HotLaunch,
mut channel: HotChannel,
workshop: Option<WorkshopChannel>,
changes: ChangeFeed<WatchSet>,
) -> ! {
let HotLaunch {
package_dir,
bin_path,
lib_path,
args,
envs,
} = launch;
eprintln!("[cargo-telar] Starting with hot reload...");
let mut child = Command::new(&bin_path)
.args(&args)
.env(HOT_LIB_VAR, lib_path.to_str().unwrap_or_default())
.env(HOT_PORT_VAR, channel.port.to_string())
.env(HOT_TOKEN_VAR, &channel.token)
.envs(envs.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.spawn()
.expect("[cargo-telar] failed to spawn app binary");
let mut last_event = Instant::now();
let mut pending_rebuild = false;
let mut waiting = None;
loop {
match child.try_wait() {
Ok(Some(status)) => {
report_reloads(channel.reloads.finish());
if status.success() {
eprintln!("[cargo-telar] App exited.");
} else {
eprintln!("[cargo-telar] App exited abnormally ({status}).");
}
drop(workshop);
std::process::exit(if status.success() { 0 } else { 1 });
}
Ok(None) => {}
Err(e) => eprintln!("[cargo-telar] error: {e}"),
}
if let Some(workshop) = &workshop {
waiting = workshop.take(waiting);
if waiting.as_ref().is_some_and(|event| channel.deliver(event)) {
waiting = None;
}
}
report_reloads(channel.reloads.settle(Instant::now()));
if changes.drain() {
last_event = Instant::now();
pending_rebuild = true;
}
if pending_rebuild && last_event.elapsed() >= DEBOUNCE {
pending_rebuild = false;
eprintln!("[cargo-telar] Change detected, rebuilding...");
super::bake::bake_workspace();
super::transpile::transpile_workspace();
let mut cmd = Command::new("cargo");
cmd.args(&build_args)
.envs(envs.iter().map(|(k, v)| (k.as_str(), v.as_str())));
let (succeeded, report) = build_with_diagnostics(&mut cmd);
match (
succeeded,
artifacts::cdylib(report.artifacts(), &package_dir, DLL_EXTENSION),
) {
(true, Some(rebuilt)) => {
channel.notify_hot_reload(&rebuilt);
}
(true, None) => eprintln!(
"[cargo-telar] The rebuild succeeded but cargo reported no dynamic library for the package in {}, so nothing was reloaded.",
package_dir.display()
),
(false, _) => {
eprintln!("[cargo-telar] Build failed, waiting for changes...");
channel.notify_build_error(&report.render(false));
}
}
}
if changes.changed_within(POLL) {
last_event = Instant::now();
pending_rebuild = true;
}
}
}
fn watch_and_run(
cargo_args: Vec<String>,
envs: Vec<(String, String)>,
changes: ChangeFeed<WatchSet>,
) -> ! {
loop {
eprintln!("[cargo-telar] Starting...");
super::bake::bake_workspace();
super::transpile::transpile_workspace();
let mut child = Command::new("cargo")
.args(&cargo_args)
.envs(envs.iter().map(|(k, v)| (k.as_str(), v.as_str())))
.spawn()
.expect("[cargo-telar] failed to spawn cargo");
let mut last_event = Instant::now();
let mut pending_restart = false;
'watch: loop {
match child.try_wait() {
Ok(Some(status)) => {
let Some(code) = status.code() else {
std::process::exit(130);
};
if code == 0 {
std::process::exit(0);
}
eprintln!("[cargo-telar] Process exited ({code}). Watching for changes...");
changes.wait();
changes.settle(DEBOUNCE);
eprintln!("[cargo-telar] Change detected, restarting...");
break 'watch;
}
Ok(None) => {}
Err(e) => eprintln!("[cargo-telar] error: {e}"),
}
if changes.drain() {
last_event = Instant::now();
pending_restart = true;
}
if pending_restart && last_event.elapsed() >= DEBOUNCE {
eprintln!("[cargo-telar] Change detected, restarting...");
child.kill().ok();
child.wait().ok();
break 'watch;
}
if changes.changed_within(POLL) {
last_event = Instant::now();
pending_restart = true;
}
}
}
}
pub(crate) enum HotMode {
Dev,
Preview,
}
impl HotMode {
fn is_preview(&self) -> bool {
matches!(self, HotMode::Preview)
}
fn features(&self) -> &'static [&'static str] {
match self {
HotMode::Dev => &["telar/dev"],
HotMode::Preview => &["telar/preview", "telar/dev"],
}
}
fn hot_features(&self) -> &'static [&'static str] {
match self {
HotMode::Dev => &["telar/dev", "telar/hot-reload"],
HotMode::Preview => &["telar/preview", "telar/dev", "telar/hot-reload"],
}
}
fn web_features(&self) -> &'static [&'static str] {
match self {
HotMode::Dev => &[],
HotMode::Preview => &["telar/preview"],
}
}
}
fn devtools_feature(resolved: &ResolvedPackage, config: &TelarSection) -> Option<String> {
if config.dev.devtools == Some(false) {
return None;
}
let package = resolved.name.clone();
if !telar_project::declares_optional_dependency(&resolved.package_dir, DEVTOOLS_PACKAGE) {
eprintln!("[cargo-telar] {}", missing_devtools_note(&package));
return None;
}
Some(format!("{package}/{DEVTOOLS_PACKAGE}"))
}
fn workshop_feature(mode: &HotMode, resolved: &ResolvedPackage) -> Option<String> {
mode.is_preview()
.then(|| format!("{}/{WORKSHOP_PACKAGE}", resolved.name.clone()))
}
fn with_tooling<'a>(features: &[&'a str], tooling: &[&'a str]) -> Vec<&'a str> {
features.iter().chain(tooling).copied().collect()
}
pub(crate) fn with_web_features(mode: &HotMode, mut args: Vec<String>) -> Vec<String> {
warn_if_tooling_unlocked(&args, mode.web_features());
let workshop = workshop_feature(
mode,
&resolve_package(&args).unwrap_or_else(|error| error.exit()),
);
for feature in mode
.web_features()
.iter()
.copied()
.chain(workshop.as_deref())
{
inject_feature(&mut args, feature);
}
args
}
pub(crate) struct HotLoopOpts {
pub(crate) args: Vec<String>,
pub(crate) app_args: Vec<String>,
pub(crate) config: TelarSection,
pub(crate) no_hot_reload: bool,
pub(crate) terminal: bool,
pub(crate) envs: Vec<(String, String)>,
pub(crate) workshop: Option<WorkshopChannel>,
}
fn with_app_args(mut cargo_args: Vec<String>, app_args: &[String]) -> Vec<String> {
if app_args.is_empty() {
return cargo_args;
}
if !cargo_args.iter().any(|arg| arg == "--") {
cargo_args.push("--".to_string());
}
cargo_args.extend(app_args.iter().cloned());
cargo_args
}
fn launch_envs(
config: &TelarSection,
workspace_root: &Path,
is_preview: bool,
terminal: bool,
extra: Vec<(String, String)>,
) -> Vec<(String, String)> {
let backend = config.backend.unwrap_or_default().as_str();
let mut envs = vec![(RENDERER_BACKEND_VAR.to_string(), backend.to_string())];
if is_preview {
envs.push((PREVIEW_VAR.to_string(), encode_flag(true).to_string()));
envs.push((
WORKSPACE_DIR_VAR.to_string(),
workspace_root.display().to_string(),
));
envs.push((
TEST_TARGET_DIR_VAR.to_string(),
telar_project::find_target_dir(workspace_root)
.display()
.to_string(),
));
}
if terminal {
envs.push((TARGET_VAR.to_string(), Frontend::Tui.as_str().to_string()));
}
if config.dev.devtools == Some(false) {
envs.push((DEVTOOLS_VAR.to_string(), encode_flag(false).to_string()));
}
if let Some(window) = &config.dev.window {
envs.extend(
dev_window_env(window)
.into_iter()
.map(|(var, value)| (var.to_string(), value)),
);
}
envs.extend(extra);
envs
}
pub(crate) fn run_hot_loop(mode: HotMode, opts: HotLoopOpts) -> ! {
let HotLoopOpts {
args,
app_args,
config,
no_hot_reload,
terminal,
envs,
workshop,
} = opts;
let (android, rest) = split_android_flag(args);
let resolved = resolve_package(&rest).unwrap_or_else(|error| error.exit());
let tooling_features: Vec<String> = devtools_feature(&resolved, &config)
.into_iter()
.chain(workshop_feature(&mode, &resolved))
.collect();
let tooling: Vec<&str> = tooling_features.iter().map(String::as_str).collect();
let features = with_tooling(mode.features(), &tooling);
let backend_value = config.backend.unwrap_or_default().as_str();
let is_preview = mode.is_preview();
if android {
warn_if_tooling_unlocked(&rest, mode.features());
let mut build_args = vec!["apk".to_string(), "build".to_string(), "--lib".to_string()];
build_args.extend(rest.iter().cloned());
for feature in &features {
inject_feature(&mut build_args, feature);
}
let status = make_android_cmd(build_args, config)
.status()
.expect("[cargo-telar] failed to invoke cargo");
if !status.success() {
std::process::exit(status.code().unwrap_or(1));
}
android_install_and_launch(&rest);
std::process::exit(0);
}
let launch_envs = launch_envs(
&config,
&resolved.workspace_root,
is_preview,
terminal,
envs,
);
let mut cargo_args = vec!["run".to_string()];
cargo_args.extend(rest.clone());
for feature in &features {
inject_feature(&mut cargo_args, feature);
}
let workspace_root = resolved.workspace_root.clone();
let hot_reload = !no_hot_reload && resolved.produces_cdylib;
if !no_hot_reload && !hot_reload {
eprintln!(
"[cargo-telar] Hot reload off: `{}` declares no `[lib] crate-type = [\"cdylib\", ..]`. Restarting the process on change instead.",
resolved.name.clone()
);
}
warn_if_tooling_unlocked(
&rest,
if hot_reload {
mode.hot_features()
} else {
mode.features()
},
);
let watched = match WatchSet::collect(&workspace_root) {
Ok(watched) => watched,
Err(e) => {
eprintln!("[cargo-telar] error: {e}");
drop(workshop);
std::process::exit(1);
}
};
let changes = match ChangeFeed::start(watched) {
Ok(changes) => changes,
Err(e) => {
eprintln!("[cargo-telar] could not watch for changes: {e}");
drop(workshop);
std::process::exit(1);
}
};
if hot_reload {
let hot_features = with_tooling(mode.hot_features(), &tooling);
let mut build_args = vec!["build".to_string()];
build_args.extend(rest.clone());
for feature in &hot_features {
inject_feature(&mut build_args, feature);
}
with_json_messages(&mut build_args);
let build_app = || {
let mut build_cmd = Command::new("cargo");
build_cmd
.args(&build_args)
.env(RENDERER_BACKEND_VAR, backend_value);
let (succeeded, report) = build_with_diagnostics(&mut build_cmd);
succeeded.then_some(report)
};
eprintln!("[cargo-telar] Building...");
let report = match build_app() {
Some(report) => report,
None => {
eprintln!("[cargo-telar] Initial build failed. Watching for changes...");
rebuild_until_built(&changes, || {
super::bake::bake_workspace();
super::transpile::transpile_workspace();
build_app()
})
}
};
let built = report.artifacts();
let package_dir = resolved.package_dir.clone();
let lib_path = artifacts::cdylib(built, &package_dir, DLL_EXTENSION);
match (
artifacts::binary(built, &package_dir, resolved.default_run.as_deref()),
lib_path,
) {
(Ok(bin_path), Some(lib_path)) => watch_and_hot_reload(
make_lib_build_args(&rest, &hot_features),
HotLaunch {
package_dir,
bin_path,
lib_path,
args: app_args,
envs: launch_envs,
},
HotChannel::bind(),
workshop,
changes,
),
(Err(e), _) => eprintln!(
"[cargo-telar] Hot reload off: the build succeeded, but {e} Restarting the process on change instead."
),
(Ok(_), None) => eprintln!(
"[cargo-telar] Hot reload off: the build succeeded, but cargo reported no dynamic library for the package in {}. Restarting the process on change instead.",
package_dir.display()
),
}
}
drop(workshop);
watch_and_run(with_app_args(cargo_args, &app_args), launch_envs, changes);
}
fn rebuild_until_built<T>(
changes: &ChangeFeed<impl WatchScope>,
mut rebuild: impl FnMut() -> Option<T>,
) -> T {
loop {
changes.wait();
changes.settle(DEBOUNCE);
eprintln!("[cargo-telar] Change detected, rebuilding...");
if let Some(built) = rebuild() {
return built;
}
eprintln!("[cargo-telar] Build failed, waiting for changes...");
}
}
#[cfg(test)]
#[path = "watch.test.rs"]
mod tests;