use crate::{generate::format_rust, names::GeneratedNames, Generator};
use anyhow::{bail, Context, Result};
use fs2::FileExt;
use std::{
fs::{self, OpenOptions},
io::Write,
path::{Path, PathBuf},
time::{SystemTime, UNIX_EPOCH},
};
struct Change {
path: PathBuf,
before: Option<Vec<u8>>,
after: Vec<u8>,
}
pub fn make_job(root: &Path, name: &str) -> Result<Vec<PathBuf>> {
make_job_with(root, name, |file, path, existing| {
if existing {
file.persist(path).map(|_| ()).map_err(|e| e.error.into())
} else {
file.persist_noclobber(path)
.map(|_| ())
.map_err(|e| e.error.into())
}
})
}
fn make_job_with(
root: &Path,
name: &str,
mut persist: impl FnMut(tempfile::NamedTempFile, &Path, bool) -> Result<()>,
) -> Result<Vec<PathBuf>> {
let names = GeneratedNames::new(name)?;
reject_symlinks(root, &root.join(".capy-generator.lock"))?;
let lock = OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.open(root.join(".capy-generator.lock"))?;
lock.lock_exclusive()
.context("Cannot lock the Capy generator registry")?;
let first = !root.join("app/jobs/mod.rs").exists();
let mut registry = if first {
include_str!("../templates/jobs.rs.txt").to_owned()
} else {
read(root, "app/jobs/mod.rs")?
};
names.check_registry(®istry, &names.module, Generator::Controller)?;
if registry.matches("// capy:modules").count() != 1
|| registry.matches("// capy:jobs").count() != 1
{
bail!("Restore // capy:modules and // capy:jobs in app/jobs/mod.rs before generating; no files changed.");
}
registry = registry
.replace(
"// capy:modules",
&format!("pub mod {};\n// capy:modules", names.module),
)
.replace(
"// capy:jobs",
&format!(
".register::<{}::{}>()\n// capy:jobs",
names.module, names.ty
),
);
let mut changes = Vec::new();
let mut add = |relative: &str, after: String, existing: bool| -> Result<()> {
let path = root.join(relative);
reject_symlinks(root, &path)?;
let before = match fs::read(&path) {
Ok(bytes) => Some(bytes),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
Err(e) => return Err(e.into()),
};
if before.is_some() != existing {
bail!(
"{} {}. Capy never overwrites generated code.",
path.display(),
if existing {
"is missing"
} else {
"already exists"
}
);
}
let after = if relative.ends_with(".rs") {
format_rust(&after)?
} else {
after
};
changes.push(Change {
path,
before,
after: after.into_bytes(),
});
Ok(())
};
add(
&format!("app/jobs/{}.rs", names.module),
include_str!("../templates/job.rs.txt")
.replace("{{name}}", &names.module)
.replace("{{type}}", &names.ty),
false,
)?;
add("app/jobs/mod.rs", registry, !first)?;
if first {
let app = read(root, "app/mod.rs")?;
GeneratedNames::new("Jobs")?.check_registry(&app, "jobs", Generator::Controller)?;
add("app/mod.rs", format!("{app}\npub mod jobs;\n"), true)?;
let main = read(root, "src/main.rs")?;
if main.matches("App::new()").count() != 1
|| !main.contains("as application;")
|| main.contains(".jobs(")
{
bail!("Job installation needs the conventional App::new() builder and application alias in src/main.rs. Install jobs manually for a customized entry point; no files changed.");
}
add(
"src/main.rs",
main.replace(
"App::new()",
"App::new().jobs(application::app::jobs::jobs())",
),
true,
)?;
let mut manifest = read(root, "Cargo.toml")?.parse::<toml_edit::DocumentMut>()?;
let dependency = manifest["dependencies"]["capy"]
.as_table_like_mut()
.context("Use a table-style capy-framework dependency before installing jobs.")?;
let mut features = dependency
.get("features")
.and_then(|v| v.as_array())
.cloned()
.unwrap_or_default();
if !features.iter().any(|v| v.as_str() == Some("jobs")) {
features.push("jobs");
}
dependency.insert("features", toml_edit::value(features));
add("Cargo.toml", manifest.to_string(), true)?;
add("config/jobs.toml", "# Separate worker: capy queue:work. SQLite requires concurrency = 1.\nconcurrency = 1\npoll_interval_ms = 1000\nlease_seconds = 60\nshutdown_timeout_seconds = 30\n".into(), false)?;
let migration = format!(
"m{}_create_jobs",
SystemTime::now().duration_since(UNIX_EPOCH)?.as_nanos()
);
add(&format!("database/migrations/{migration}.rs"), "//! Durable queue schema, applied explicitly by capy migrate.\npub use capy::jobs::migration::JobsMigration as Migration;\n".into(), false)?;
let migrations = read(root, "database/migrations/mod.rs")?;
if migrations.matches("// capy:modules").count() != 1
|| migrations.matches("// capy:migrations").count() != 1
{
bail!(
"Restore the migration registry markers before installing jobs; no files changed."
);
}
add(
"database/migrations/mod.rs",
migrations
.replace(
"// capy:modules",
&format!("mod {migration};\n// capy:modules"),
)
.replace(
"// capy:migrations",
&format!("Box::new({migration}::Migration),\n// capy:migrations"),
),
true,
)?;
}
let mut staged = Vec::new();
for change in &changes {
let mut file = tempfile::NamedTempFile::new_in(root)?;
if change.before.is_some() {
file.as_file()
.set_permissions(fs::metadata(&change.path)?.permissions())?;
}
file.write_all(&change.after)?;
file.as_file().sync_all()?;
staged.push(file);
}
let directory = root.join("app/jobs");
let created_directory = !directory.exists();
if created_directory {
fs::create_dir(&directory)?;
}
for (index, (file, change)) in staged.into_iter().zip(&changes).enumerate() {
if let Err(error) = persist(file, &change.path, change.before.is_some()) {
for previous in changes[..index].iter().rev() {
if let Some(bytes) = &previous.before {
let mut restored = tempfile::NamedTempFile::new_in(root)?;
restored
.as_file()
.set_permissions(fs::metadata(&previous.path)?.permissions())?;
restored.write_all(bytes)?;
restored.as_file().sync_all()?;
restored
.persist(&previous.path)
.map_err(|e| e.error)
.context(
"Job generator rollback failed; inspect partially installed files",
)?;
} else {
fs::remove_file(&previous.path)?;
}
}
if created_directory {
fs::remove_dir(&directory)?;
}
return Err(error.context("Job generation failed; committed changes were rolled back"));
}
}
Ok(changes.into_iter().map(|c| c.path).collect())
}
fn read(root: &Path, relative: &str) -> Result<String> {
let path = root.join(relative);
reject_symlinks(root, &path)?;
fs::read_to_string(&path).with_context(|| format!("Cannot read {}", path.display()))
}
fn reject_symlinks(root: &Path, path: &Path) -> Result<()> {
for ancestor in path.ancestors().take_while(|p| *p != root) {
if let Ok(metadata) = fs::symlink_metadata(ancestor) {
if metadata.file_type().is_symlink() {
bail!("Job generator refuses symlink {}", ancestor.display());
}
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn failed_install_restores_original_files_and_removes_directory() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path().join("app");
crate::new_project_with_frontend(&root, "app", crate::FrontendDriver::None).unwrap();
let before = fs::read(root.join("app/mod.rs")).unwrap();
let mut writes = 0;
let result = make_job_with(&root, "SendWelcome", |file, path, _| {
writes += 1;
if writes == 5 {
bail!("simulated write failure");
}
file.persist(path).map(|_| ()).map_err(|e| e.error.into())
});
assert!(format!("{:#}", result.unwrap_err()).contains("rolled back"));
assert_eq!(fs::read(root.join("app/mod.rs")).unwrap(), before);
assert!(!root.join("app/jobs").exists());
assert!(!fs::read_to_string(root.join("src/main.rs"))
.unwrap()
.contains(".jobs("));
}
#[test]
fn repeated_generation_registers_once_and_rejects_collisions() {
let temp = tempfile::tempdir().unwrap();
let root = temp.path().join("app");
crate::new_project_with_frontend(&root, "app", crate::FrontendDriver::None).unwrap();
make_job(&root, "SendWelcome").unwrap();
make_job(&root, "GenerateReport").unwrap();
let before = fs::read(root.join("app/jobs/mod.rs")).unwrap();
assert!(make_job(&root, "SendWelcome").is_err());
assert!(make_job(&root, "Jobs").is_err());
assert_eq!(fs::read(root.join("app/jobs/mod.rs")).unwrap(), before);
assert_eq!(
fs::read_to_string(root.join("src/main.rs"))
.unwrap()
.matches(".jobs(")
.count(),
1
);
}
}