Fully cut over to tokio

Cut over to [email protected]. Much more simple interface, and works
quite nicely with the async ecosystem.

Cut over to axum for web server. Much better!

The updated server stack is now more intelligently handling 404s. This
is a common issue where users may end up making a request for some
non-html static asset, but they get their path slightly wrong and are
served the index.html instead of a 404.

This typically results in users struggling to find the problem, and
often times users have opened issues in GH. This updated algorithm will
now evaluate 404s more closely and only respond with the index.html when
the `accept` header allows for text/html or */*.

Add to changelog:
- all download utils have been make fully async.
- added a subcommand to clean cached tools (wasm-bindgen & wasm-opt).
  This may be useful if there are ever issues with old tools which need
  to be removed.
- resolves #198 (more
  intelligent 404s & index.html).
- cut over to tokio 1.x.
- cut over to axum for web server.

Todo:
- [ ] ensure the shutdown broadcaster is closed as soon as a signal is
  received, else ^C too early will cause the signal to be missed and
  other parts of the app which have not initialized will not see the
  drop.

Author: thedodd

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "trunk"
-version = "0.12.1"
+version = "0.13.0"
 edition = "2018"
 description = "Build, bundle & ship your Rust WASM application to the web."
 license = "MIT/Apache-2.0"
@@ -18,34 +18,38 @@ panic = "abort"
 [dependencies]
 ansi_term = "0.12"
 anyhow = "1"
-async-process = "1"
-async-std = { version = "1.9", default-features = false, features = ["attributes", "std", "unstable"] }
-async-tungstenite = { version = "0.10", default-features = false, features = ["async-std-runtime"] }
+async-compression = { version = "0.3", default-features = false, features = ["deflate", "futures-io", "gzip", "tokio"] }
+axum = { version = "0.1", features = ["ws"] }
+bytes = "1"
 cargo-lock = "6"
 cargo_metadata = "0.12"
 console = "0.14"
 directories-next = "2"
 dunce = "1"
 envy = "0.4"
-flate2 = "1"
 fs_extra = "1"
 futures = "0.3"
-http-types = "2"
+http = "0.2"
+hyper = "0.14"
+hyper-staticfile = "0.6"
 lazy_static = "1"
-nipper = "0.1.9"
-notify = "4"
+nipper = "0.1"
+notify = "5.0.0-pre.11"
 open = "1"
 remove_dir_all = "0.6"
+reqwest = { version = "0.11", default-features = false, features = ["rustls-tls", "stream", "trust-dns"] }
 sass-rs = "0.2"
 seahash = "4"
 serde = { version = "1", features = ["derive"] }
 structopt = "0.3"
 structopt-derive = "0.4"
-surf = "2"
-tar = "0.4"
-tide = { version = "0.16.0", default-features = false, features = ["h1-server", "sessions", "unstable"] }
-tide-websockets = "0.3.0"
+# See https://docs.rs/tokio/latest/tokio/#feature-flags - we basically use all of the features.
+tokio = { version = "1", default-features = false, features = ["full"] }
+tokio-stream = { version = "0.1", default-features = false, features = ["fs", "time", "net", "signal", "sync"] }
+tokio-tar = "0.3"
+tokio-tungstenite = "0.14"
 toml = "0.5"
+tower-http = { version = "0.1", features = ["trace"] }
 tracing = "0.1"
 tracing-subscriber = "0.2"
 which = "4"

Cargo.toml

@@ -11,8 +11,8 @@ dist = "dist"
 public_url = "/"
 
 [watch]
-# Paths to watch, defaults to build target parent folder.
-path = ["src"]
+# Paths to watch. The `build.target`'s parent folder is watched by default.
+watch = []
 # Paths to ignore.
 ignore = []
 

Trunk.toml

@@ -1,3 +1,22 @@
 [build]
 target = "index.html"
 dist = "dist"
+public_url = "/static/"
+
+[[proxy]]
+# This WebSocket proxy example has a backend and ws field. This example will listen for
+# WebSocket connections at `/api/ws` and proxy them to `ws://localhost:9000/api/ws`.
+backend = "ws://localhost:9090/api/ws"
+ws = true
+
+[[proxy]]
+# This proxy example has a backend and a rewrite field. Requests received on `rewrite` will be
+# proxied to the backend after rewriting the `rewrite` prefix to the `backend`'s URI prefix.
+# E.G., `/api/v1/resource/x/y/z` -> `/resource/x/y/z`
+rewrite = "/api/v1/"
+backend = "http://localhost:9090/"
+
+[[proxy]]
+# This proxy specifies only the backend, which is the only required field. In this example,
+# request URIs are not modified when proxied.
+backend = "http://localhost:9090/api/v2/"

examples/yew/Trunk.toml

@@ -4,9 +4,10 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use anyhow::{Context, Result};
-use async_std::fs;
-use futures::channel::mpsc::Sender;
-use futures::stream::StreamExt;
+use futures::prelude::*;
+use tokio::fs;
+use tokio::sync::mpsc;
+use tokio_stream::wrappers::ReadDirStream;
 
 use crate::common::{remove_dir_all, BUILDING, ERROR, SUCCESS};
 use crate::config::{RtcBuild, STAGE_DIR};
@@ -30,7 +31,7 @@ impl BuildSystem {
     ///
     /// Reducing the number of assumptions here should help us to stay flexible when adding new
     /// commands, refactoring and the like.
-    pub async fn new(cfg: Arc<RtcBuild>, ignore_chan: Option<Sender<PathBuf>>) -> Result<Self> {
+    pub async fn new(cfg: Arc<RtcBuild>, ignore_chan: Option<mpsc::Sender<PathBuf>>) -> Result<Self> {
         let html_pipeline = Arc::new(HtmlPipeline::new(cfg.clone(), ignore_chan)?);
         Ok(Self { cfg, html_pipeline })
     }
@@ -69,6 +70,7 @@ impl BuildSystem {
             .clone()
             .spawn()
             .await
+            .context("error joining HTML pipeline")?
             .context("error from HTML pipeline")?;
 
         // Move distribution from staging dist to final dist
@@ -117,6 +119,7 @@ impl BuildSystem {
 
         let mut entries = fs::read_dir(&staging_dist)
             .await
+            .map(ReadDirStream::new)
             .context("error reading staging dist dir")?;
         while let Some(entry) = entries.next().await {
             let entry = entry.context("error reading contents of staging dist dir")?;
@@ -133,7 +136,10 @@ impl BuildSystem {
     async fn clean_final(&self) -> Result<()> {
         let final_dist = self.cfg.final_dist.clone();
 
-        let mut entries = fs::read_dir(&final_dist).await.context("error reading final dist dir")?;
+        let mut entries = fs::read_dir(&final_dist)
+            .await
+            .map(ReadDirStream::new)
+            .context("error reading final dist dir")?;
         while let Some(entry) = entries.next().await {
             let entry = entry.context("error reading contents of final dist dir")?;
             if entry.file_name() == STAGE_DIR {
@@ -145,9 +151,7 @@ impl BuildSystem {
                 .await
                 .context("error reading metadata of file in final dist dir")?;
             if file_type.is_dir() {
-                remove_dir_all(entry.path().into())
-                    .await
-                    .context("error cleaning final dist")?;
+                remove_dir_all(entry.path()).await.context("error cleaning final dist")?;
             } else if file_type.is_symlink() || file_type.is_file() {
                 fs::remove_file(entry.path()).await.context("error cleaning final dist")?;
             }

src/build.rs

@@ -1,18 +1,26 @@
 use std::path::PathBuf;
+use std::process::Stdio;
 
-use anyhow::{ensure, Result};
-use async_process::{Command, Stdio};
+use anyhow::{ensure, Context, Result};
 use structopt::StructOpt;
+use tokio::process::Command;
 
 use crate::common::remove_dir_all;
 use crate::config::{ConfigOpts, ConfigOptsClean};
+use crate::tools::cache_dir;
 
 /// Clean output artifacts.
 #[derive(StructOpt)]
 #[structopt(name = "clean")]
 pub struct Clean {
     #[structopt(flatten)]
     pub clean: ConfigOptsClean,
+    /// Optionally clean any cached tools used by Trunk
+    ///
+    /// These tools are cached in a platform dependent "projects" dir. Removing them will cause
+    /// them to be downloaded by Trunk next time they are needed.
+    #[structopt(short, long)]
+    pub tools: bool,
 }
 
 impl Clean {
@@ -21,6 +29,7 @@ impl Clean {
         let cfg = ConfigOpts::rtc_clean(self.clean, config)?;
         let _ = remove_dir_all(cfg.dist.clone()).await;
         if cfg.cargo {
+            tracing::debug!("cleaning cargo dir");
             let output = Command::new("cargo")
                 .arg("clean")
                 .stdout(Stdio::piped())
@@ -29,6 +38,11 @@ impl Clean {
                 .await?;
             ensure!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
         }
+        if self.tools {
+            tracing::debug!("cleaning trunk tools cache dir");
+            let path = cache_dir().await.context("error getting cache dir path")?;
+            remove_dir_all(path).await?;
+        }
         Ok(())
     }
 }

src/cmd/clean.rs

@@ -1,7 +1,8 @@
 use std::path::PathBuf;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use structopt::StructOpt;
+use tokio::sync::broadcast;
 
 use crate::config::{ConfigOpts, ConfigOptsBuild, ConfigOptsServe, ConfigOptsWatch};
 use crate::serve::ServeSystem;
@@ -21,9 +22,16 @@ pub struct Serve {
 impl Serve {
     #[tracing::instrument(level = "trace", skip(self, config))]
     pub async fn run(self, config: Option<PathBuf>) -> Result<()> {
+        let (shutdown_tx, _shutdown_rx) = broadcast::channel(1);
         let cfg = ConfigOpts::rtc_serve(self.build, self.watch, self.serve, config)?;
-        let system = ServeSystem::new(cfg).await?;
-        system.run().await?;
+        let system = ServeSystem::new(cfg, shutdown_tx.clone()).await?;
+
+        let system_handle = tokio::spawn(system.run());
+        let _res = tokio::signal::ctrl_c().await.context("error awaiting shutdown signal")?;
+        tracing::debug!("received shutdown signal");
+        let _res = shutdown_tx.send(());
+        system_handle.await.context("error awaiting system shutdown")??;
+
         Ok(())
     }
 }

src/cmd/serve.rs

@@ -1,7 +1,8 @@
 use std::path::PathBuf;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use structopt::StructOpt;
+use tokio::sync::broadcast;
 
 use crate::config::{ConfigOpts, ConfigOptsBuild, ConfigOptsWatch};
 use crate::watch::WatchSystem;
@@ -19,10 +20,17 @@ pub struct Watch {
 impl Watch {
     #[tracing::instrument(level = "trace", skip(self, config))]
     pub async fn run(self, config: Option<PathBuf>) -> Result<()> {
+        let (shutdown_tx, _shutdown_rx) = broadcast::channel(1);
         let cfg = ConfigOpts::rtc_watch(self.build, self.watch, config)?;
-        let mut system = WatchSystem::new(cfg).await?;
-        system.build().await;
-        system.run().await;
+        let mut system = WatchSystem::new(cfg, shutdown_tx.clone()).await?;
+
+        let _res = system.build().await;
+        let system_handle = tokio::spawn(system.run());
+        let _res = tokio::signal::ctrl_c().await.context("error awaiting shutdown signal")?;
+        tracing::debug!("received shutdown signal");
+        let _res = shutdown_tx.send(());
+        system_handle.await.context("error awaiting system shutdown")?;
+
         Ok(())
     }
 }

src/cmd/watch.rs

@@ -1,12 +1,13 @@
 //! Common functionality and types.
 
+use std::fs::Metadata;
 use std::path::{Path, PathBuf};
+use std::process::Stdio;
 use std::{ffi::OsStr, io::ErrorKind};
 
 use anyhow::{anyhow, bail, Context, Result};
-use async_process::{Command, Stdio};
-use async_std::fs;
-use async_std::task::spawn_blocking;
+use tokio::fs;
+use tokio::process::Command;
 
 use console::Emoji;
 
@@ -32,7 +33,7 @@ pub async fn copy_dir_recursive(from_dir: PathBuf, to_dir: PathBuf) -> Result<()
         return Err(anyhow!("directory can not be copied as it does not exist {:?}", &from_dir));
     }
 
-    spawn_blocking(move || -> Result<()> {
+    tokio::task::spawn_blocking(move || -> Result<()> {
         let opts = fs_extra::dir::CopyOptions {
             overwrite: true,
             content_only: true,
@@ -42,6 +43,7 @@ pub async fn copy_dir_recursive(from_dir: PathBuf, to_dir: PathBuf) -> Result<()
         Ok(())
     })
     .await
+    .context("error awaiting spawned copy dir call")?
     .context("error copying directory")
 }
 
@@ -53,21 +55,38 @@ pub async fn remove_dir_all(from_dir: PathBuf) -> Result<()> {
     if !path_exists(&from_dir).await? {
         return Ok(());
     }
-    spawn_blocking(move || {
+    tokio::task::spawn_blocking(move || {
         ::remove_dir_all::remove_dir_all(from_dir.as_path()).context("error removing directory")?;
         Ok(())
     })
     .await
+    .context("error awaiting spawned remove dir call")?
 }
 
 /// Checks if path exists.
 pub async fn path_exists(path: impl AsRef<Path>) -> Result<bool> {
-    let exists = fs::metadata(path.as_ref())
+    fs::metadata(path.as_ref())
         .await
         .map(|_| true)
         .or_else(|error| if error.kind() == ErrorKind::NotFound { Ok(false) } else { Err(error) })
-        .with_context(|| format!("error checking for existance of path at {:?}", path.as_ref()))?;
-    Ok(exists)
+        .with_context(|| format!("error checking for existance of path at {:?}", path.as_ref()))
+}
+
+/// Check whether a given path exists, is a file and marked as executable.
+pub async fn is_executable(path: impl AsRef<Path>) -> Result<bool> {
+    #[cfg(unix)]
+    let has_executable_flag = |meta: Metadata| {
+        use std::os::unix::fs::PermissionsExt;
+        meta.permissions().mode() & 0o100 != 0
+    };
+    #[cfg(not(unix))]
+    let has_executable_flag = |meta: Metadata| true;
+
+    fs::metadata(path.as_ref())
+        .await
+        .map(|meta| meta.is_file() && has_executable_flag(meta))
+        .or_else(|error| if error.kind() == ErrorKind::NotFound { Ok(false) } else { Err(error) })
+        .with_context(|| format!("error checking file mode for file {:?}", path.as_ref()))
 }
 
 /// Strip the CWD prefix from the given path.
@@ -90,7 +109,7 @@ pub async fn run_command(name: &str, path: &Path, args: &[impl AsRef<OsStr>]) ->
         .stderr(Stdio::inherit())
         .spawn()
         .with_context(|| format!("error spawning {} call", name))?
-        .status()
+        .wait()
         .await
         .with_context(|| format!("error during {} call", name))?;
     if !status.success() {

src/common.rs

@@ -1,8 +1,8 @@
 use std::path::Path;
 
 use anyhow::{Context, Result};
-use async_std::task::spawn_blocking;
 use cargo_metadata::{Metadata, MetadataCommand, Package};
+use tokio::task::spawn_blocking;
 
 /// A wrapper around the cargo project's metadata.
 #[derive(Clone, Debug)]
@@ -22,6 +22,7 @@ impl CargoMetadata {
         cmd.manifest_path(dunce::simplified(manifest));
         let metadata = spawn_blocking(move || cmd.exec())
             .await
+            .context("error awaiting spawned cargo metadata task")?
             .context("error getting cargo metadata")?;
 
         let package = metadata