use crate::environment::ProjectEnvironment;
use std::fs::{self, OpenOptions};
use std::io::{self, BufRead, BufReader, Read, Write};
#[cfg(unix)]
use std::os::unix::process::CommandExt;
#[cfg(windows)]
use std::os::windows::process::CommandExt;
use std::path::Path;
use std::process::{Child, Command, Stdio};
use std::thread;
use std::time::Duration;
pub(super) struct DevProcesses {
api: Child,
web: Child,
logs: Vec<thread::JoinHandle<()>>,
}
impl DevProcesses {
pub(super) fn spawn(
project: &Path,
environment: &ProjectEnvironment,
database_url: &str,
api_port: u16,
web_port: u16,
) -> io::Result<Self> {
let api_url = format!("http://127.0.0.1:{api_port}");
let web_url = format!("http://127.0.0.1:{web_port}");
let api = start_api(project, environment, database_url, api_port, &web_url)?;
let web = match start_web(project, environment, web_port, &api_url) {
Ok(web) => web,
Err(error) => {
let mut api = api;
terminate(&mut api);
return Err(error);
}
};
let mut api = api;
let mut web = web;
let log_path = prepare_log(project)?;
let logs = vec![
log_pipe("api", api.stdout.take(), Some(log_path.clone())),
log_pipe("api", api.stderr.take(), Some(log_path.clone())),
log_pipe("web", web.stdout.take(), Some(log_path.clone())),
log_pipe("web", web.stderr.take(), Some(log_path)),
]
.into_iter()
.flatten()
.collect();
Ok(Self { api, web, logs })
}
pub(super) fn restart_api(
&mut self,
project: &Path,
environment: &ProjectEnvironment,
database_url: &str,
api_port: u16,
web_port: u16,
) -> io::Result<()> {
terminate(&mut self.api);
let mut api = start_api(
project,
environment,
database_url,
api_port,
&format!("http://127.0.0.1:{web_port}"),
)?;
self.logs.extend(
[
log_pipe("api", api.stdout.take(), prepare_log(project).ok()),
log_pipe("api", api.stderr.take(), prepare_log(project).ok()),
]
.into_iter()
.flatten(),
);
self.api = api;
Ok(())
}
pub(super) fn restart(
&mut self,
project: &Path,
environment: &ProjectEnvironment,
database_url: &str,
api_port: u16,
web_port: u16,
) -> io::Result<()> {
self.stop();
*self = Self::spawn(project, environment, database_url, api_port, web_port)?;
Ok(())
}
pub(super) fn failure(&mut self) -> io::Result<Option<String>> {
if let Some(status) = self.api.try_wait()? {
return Ok(Some(format!("API exited with {status}")));
}
if let Some(status) = self.web.try_wait()? {
return Ok(Some(format!("web server exited with {status}")));
}
Ok(None)
}
pub(super) fn stop(&mut self) {
terminate(&mut self.web);
terminate(&mut self.api);
for handle in self.logs.drain(..) {
let _ = handle.join();
}
}
}
fn start_api(
project: &Path,
environment: &ProjectEnvironment,
database_url: &str,
api_port: u16,
web_url: &str,
) -> io::Result<Child> {
let mut command = Command::new(
project
.join(".appstruct/cache/backend-target/debug")
.join(crate::build::backend_binary_name(project)?),
);
command
.current_dir(project)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
environment.apply(&mut command);
command
.env("DATABASE_URL", database_url)
.env("APPSTRUCT_BIND", format!("127.0.0.1:{api_port}"))
.env(
"APPSTRUCT_ALLOWED_ORIGIN",
environment
.get("APPSTRUCT_ALLOWED_ORIGIN")
.unwrap_or_else(|| web_url.to_owned()),
)
.env(
"APPSTRUCT_FRONTEND_URL",
environment
.get("APPSTRUCT_FRONTEND_URL")
.unwrap_or_else(|| web_url.to_owned()),
);
isolate_process_group(&mut command);
command.spawn()
}
fn start_web(
project: &Path,
environment: &ProjectEnvironment,
web_port: u16,
api_url: &str,
) -> io::Result<Child> {
let mut command = Command::new("pnpm");
command
.current_dir(project.join("generated/web"))
.args([
"run",
"dev",
"--host",
"127.0.0.1",
"--port",
&web_port.to_string(),
"--strict-port",
])
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
environment.apply(&mut command);
command.env(
"PUBLIC_API_URL",
environment
.get("PUBLIC_API_URL")
.or_else(|| environment.get("VITE_API_URL"))
.unwrap_or_else(|| api_url.to_owned()),
);
isolate_process_group(&mut command);
command.spawn()
}
impl Drop for DevProcesses {
fn drop(&mut self) {
self.stop();
}
}
pub(super) struct ManagedDatabase {
project: Option<std::path::PathBuf>,
environment: Option<ProjectEnvironment>,
started: bool,
}
impl ManagedDatabase {
pub(super) fn external() -> Self {
Self {
project: None,
environment: None,
started: false,
}
}
pub(super) fn start(project: &Path, environment: &ProjectEnvironment) -> io::Result<Self> {
let mut inspect = Command::new("docker");
inspect
.current_dir(project)
.args(["compose", "ps", "--status", "running", "--services"]);
environment.apply(&mut inspect);
let output = inspect.output()?;
let already_running = output.status.success()
&& String::from_utf8_lossy(&output.stdout)
.lines()
.any(|service| service == "postgres");
if !already_running {
let mut start = Command::new("docker");
start
.current_dir(project)
.args(["compose", "up", "-d", "postgres"]);
environment.apply(&mut start);
let status = start.status()?;
if !status.success() {
return Err(io::Error::other(format!(
"docker compose exited with {status}"
)));
}
}
Ok(Self {
project: Some(project.to_path_buf()),
environment: Some(environment.clone()),
started: !already_running,
})
}
pub(super) fn stop(&mut self) -> io::Result<()> {
if !self.started {
return Ok(());
}
let project = self.project.as_ref().expect("managed database has project");
let mut stop = Command::new("docker");
stop.current_dir(project)
.args(["compose", "stop", "postgres"]);
self.environment
.as_ref()
.expect("managed database has environment")
.apply(&mut stop);
let status = stop.status()?;
if status.success() {
self.started = false;
Ok(())
} else {
Err(io::Error::other(format!(
"docker compose stop exited with {status}"
)))
}
}
pub(super) fn update_environment(&mut self, environment: ProjectEnvironment) {
if self.project.is_some() {
self.environment = Some(environment);
}
}
}
impl Drop for ManagedDatabase {
fn drop(&mut self) {
let _ = self.stop();
}
}
fn log_pipe(
service: &'static str,
pipe: Option<impl Read + Send + 'static>,
log_path: Option<std::path::PathBuf>,
) -> Option<thread::JoinHandle<()>> {
let pipe = pipe?;
Some(thread::spawn(move || {
let mut log =
log_path.and_then(|path| OpenOptions::new().create(true).append(true).open(path).ok());
for line in BufReader::new(pipe).lines().map_while(Result::ok) {
eprintln!("[{service}] {line}");
if let Some(log) = &mut log {
let _ = writeln!(log, "[{service}] {line}");
}
}
}))
}
fn prepare_log(project: &Path) -> io::Result<std::path::PathBuf> {
let directory = project.join(".appstruct/logs");
fs::create_dir_all(&directory)?;
let path = directory.join("dev.log");
if fs::metadata(&path).is_ok_and(|metadata| metadata.len() > 5 * 1024 * 1024) {
OpenOptions::new().write(true).truncate(true).open(&path)?;
}
Ok(path)
}
fn terminate(child: &mut Child) {
if child.try_wait().ok().flatten().is_some() {
return;
}
#[cfg(unix)]
{
let process_group = format!("-{}", child.id());
let signaled = Command::new("kill")
.args(["-TERM", "--", &process_group])
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()
.is_ok_and(|status| status.success());
if !signaled {
let _ = child.kill();
let _ = child.wait();
return;
}
for _ in 0..20 {
let parent_exited = child.try_wait().ok().flatten().is_some();
if parent_exited && !process_group_alive(&process_group) {
return;
}
thread::sleep(Duration::from_millis(50));
}
let _ = Command::new("kill")
.args(["-KILL", "--", &process_group])
.stdout(Stdio::null())
.stderr(Stdio::null())
.status();
let _ = child.wait();
}
#[cfg(windows)]
{
let pid = child.id().to_string();
let _ = Command::new("taskkill")
.args(["/PID", &pid, "/T", "/F"])
.stdout(Stdio::null())
.stderr(Stdio::null())
.status();
let _ = child.wait();
}
#[cfg(not(any(unix, windows)))]
{
let _ = child.kill();
let _ = child.wait();
}
}
#[cfg(unix)]
fn process_group_alive(process_group: &str) -> bool {
Command::new("kill")
.args(["-0", "--", process_group])
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()
.is_ok_and(|status| status.success())
}
#[cfg(unix)]
fn isolate_process_group(command: &mut Command) {
command.process_group(0);
}
#[cfg(windows)]
fn isolate_process_group(command: &mut Command) {
const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200;
command.creation_flags(CREATE_NEW_PROCESS_GROUP);
}
#[cfg(not(any(unix, windows)))]
fn isolate_process_group(_command: &mut Command) {}
#[cfg(test)]
mod tests;