mod add;
mod bind;
mod cache;
mod config_edit;
mod json;
mod progress;
mod query;
mod render;
mod sync;
mod trust;
#[cfg(test)]
mod tests;
#[cfg(test)]
use {
crate::config::{Host, LayoutKind},
crate::sync::inspect::ArtifactState,
add::{
AddRequest, MissingTarget, MissingTargetDecider, add_to_default_target, add_with_binds,
insert_source_with_ref, run_add,
},
render::state_label,
};
use config_edit::BindRefinement;
pub(crate) use query::PreviewSelectors;
#[cfg(test)]
pub(crate) use {
query::{PreviewPlan, preview_plan},
render::{render_preview_json, render_preview_tree},
};
pub use add::{AddTarget, insert_source, parse_add_url};
pub use config_edit::remove_source;
pub use query::{
ArtifactStatus, CheckMatchReport, SourceResolution, SourceRow, SourceSummary, TargetDetail,
TargetListing, TargetRow, WhereFilter, WhereMatch, check_match_cmd, list_statuses,
source_listing, source_summary, target_detail, target_listing, targets_receiving, where_cmd,
};
pub use sync::{load_locks, write_locks};
use std::collections::BTreeMap;
use std::io::{IsTerminal, Write};
use std::path::{Path, PathBuf};
use clap::{Parser, Subcommand};
use crate::config::{Config, ParsedSource, merge_configs};
use crate::error::{Error, Result};
use crate::paths::state_root_for;
use crate::projection::model::TargetName;
use crate::source::SourceName;
use crate::source::{GitBackend, HttpBackend, RouterBackend};
use crate::sync::state::ProjectId;
use crate::sync::state::{FileStateStore, StateError, StateLock, StateStore};
use crate::sync::{Conflict, ConflictResolver, Resolution};
use std::str::FromStr;
use std::time::Duration;
#[derive(Parser, Debug)]
#[command(
name = "phora",
version,
about = "A git-based artifact package manager and multiplexer for content-addressed file distribution"
)]
pub struct Cli {
#[arg(short = 'C', long, global = true, value_name = "DIRECTORY")]
pub directory: Option<PathBuf>,
#[arg(
long,
global = true,
value_name = "SECONDS",
env = "PHORA_LOCK_TIMEOUT",
default_value = "120",
value_parser = parse_seconds
)]
pub lock_timeout: Duration,
#[command(subcommand)]
pub command: Command,
}
#[derive(Subcommand, Debug)]
pub enum Command {
Add {
url: String,
#[arg(long = "to")]
to: Vec<String>,
#[arg(long)]
name: Option<String>,
#[arg(long)]
branch: Option<String>,
#[arg(long)]
tag: Option<String>,
#[arg(long)]
root: Option<String>,
#[arg(long = "include")]
include: Vec<String>,
#[arg(long = "exclude")]
exclude: Vec<String>,
#[arg(long = "yes", short = 'y')]
assume_yes: bool,
#[arg(long)]
local: bool,
#[arg(long)]
symlink: bool,
#[arg(long, conflicts_with_all = ["local", "symlink", "root", "include", "exclude"])]
history: bool,
#[arg(long = "as")]
r#as: Option<String>,
},
Rm { name: String },
Sync {
#[arg(long)]
prune: bool,
#[arg(long)]
force: bool,
#[arg(long)]
no_hooks: bool,
#[arg(long)]
no_transitive_hooks: bool,
#[arg(long)]
frozen: bool,
#[arg(long)]
fast_forward: bool,
#[arg(long)]
no_progress: bool,
#[arg(long)]
json: bool,
#[arg(long, short = 'j')]
jobs: Option<usize>,
},
Update {
source: Option<String>,
#[arg(long)]
prune: bool,
#[arg(long)]
fast_forward: bool,
},
List {
#[arg(long)]
plan: bool,
#[arg(long)]
orphans: bool,
},
Verify,
Where {
#[arg(long)]
digest: Option<String>,
#[arg(long)]
source: Option<String>,
#[arg(long)]
artifact: Option<String>,
#[arg(long)]
commit: Option<String>,
},
Eject {
artifact: String,
#[arg(long)]
source: String,
#[arg(long)]
target: String,
},
Uneject {
artifact: String,
#[arg(long)]
source: String,
#[arg(long)]
target: String,
},
RebuildRegistry,
CheckMatch {
#[arg(long)]
source: String,
path: String,
},
Source {
#[command(subcommand)]
cmd: SourceCmd,
},
Target {
#[command(subcommand)]
cmd: TargetCmd,
},
Cache {
#[command(subcommand)]
cmd: cache::CacheCmd,
},
Bind {
#[arg(required = true)]
sources: Vec<String>,
#[arg(long, required = true)]
to: Vec<String>,
#[arg(long)]
local: bool,
#[arg(long, conflicts_with_all = ["root", "take"])]
history: bool,
#[arg(long = "as")]
r#as: Option<String>,
#[arg(long)]
root: Option<String>,
#[arg(long = "take")]
take: Vec<String>,
#[arg(long)]
branch: Option<String>,
#[arg(long)]
tag: Option<String>,
#[arg(long)]
rev: Option<String>,
#[arg(long)]
offer: Option<String>,
},
Unbind {
#[arg(required = true)]
sources: Vec<String>,
#[arg(long)]
from: String,
#[arg(long)]
local: bool,
},
Trust {
source: Option<String>,
#[arg(long)]
list: bool,
#[arg(long)]
revoke: bool,
#[arg(long, value_name = "PATH")]
show: Option<String>,
},
Preview {
#[arg(long)]
source: Option<String>,
#[arg(long)]
target: Option<String>,
#[arg(long)]
files: bool,
#[arg(long)]
json: bool,
},
Explain {
target: String,
source: String,
path: Option<String>,
},
}
#[derive(Subcommand, Debug)]
pub enum SourceCmd {
Add {
url: String,
#[arg(long)]
name: Option<String>,
#[arg(long)]
branch: Option<String>,
#[arg(long)]
tag: Option<String>,
#[arg(long)]
root: Option<String>,
#[arg(long = "include")]
include: Vec<String>,
#[arg(long = "exclude")]
exclude: Vec<String>,
#[arg(long)]
local: bool,
#[arg(long)]
symlink: bool,
},
Rm { name: String },
List,
Show { name: String },
}
#[derive(Subcommand, Debug)]
pub enum TargetCmd {
Add {
name: String,
#[arg(long)]
path: String,
#[arg(long)]
layout: Option<String>,
#[arg(long)]
local: bool,
},
Rm {
name: String,
#[arg(long)]
local: bool,
#[arg(long)]
force: bool,
},
List,
Show { name: String },
}
#[must_use]
pub fn exit_code(err: &Error) -> i32 {
match err {
Error::StateCtx(StateError::Lock(_)) => 75,
_ => 1,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CliOutcome {
Success,
Failure,
}
impl CliOutcome {
#[must_use]
pub fn exit_code(self) -> i32 {
match self {
Self::Success => 0,
Self::Failure => 1,
}
}
}
fn parse_seconds(raw: &str) -> std::result::Result<Duration, std::num::ParseIntError> {
raw.parse().map(Duration::from_secs)
}
fn completed(result: Result<()>) -> Result<CliOutcome> {
result.map(|()| CliOutcome::Success)
}
pub fn run(cli: Cli) -> Result<()> {
run_with_outcome(cli).map(drop)
}
pub fn run_with_outcome(cli: Cli) -> Result<CliOutcome> {
if let Some(directory) = cli.directory {
std::env::set_current_dir(&directory).map_err(|error| {
Error::Config(format!("enter project {}: {error}", directory.display()))
})?;
}
match cli.command {
cmd @ Command::Add { .. } => completed(dispatch_add(cmd)),
Command::Rm { name } => completed(run_source_rm(&name)),
cmd @ (Command::Sync { .. } | Command::Update { .. }) => {
dispatch_sync(cmd, cli.lock_timeout)
}
Command::List { plan, orphans } => {
completed(query::run_list(query::ListView::from_flags(plan, orphans)))
}
Command::Verify => run_verify(),
Command::Where {
digest,
source,
artifact,
commit,
} => {
let filter = WhereFilter {
digest,
source,
artifact,
commit,
};
let config = load_config()?;
let matches = where_cmd(&open_project_registry(&config)?, &filter)?;
render::print_where_matches(&matches, &filter);
Ok(CliOutcome::Success)
}
Command::Eject {
artifact,
source,
target,
} => {
let config = merge_configs(load_config()?, load_local_config(Path::new("."))?);
let (registry, _guard) = lock_project_registry(&config, cli.lock_timeout)?;
let cwd = std::env::current_dir()?;
let cache_git =
crate::paths::cache_root_for(config.paths.cache.as_deref(), &cwd)?.join("git");
let backend = GitBackend::new(cache_git);
match crate::sync::eject(&config, ®istry, &artifact, &source, &target, &backend)? {
Some(clone) => println!(
"ejected {source}/{artifact} from {target} into a standalone clone at {}; \
add it to .gitignore or make it a submodule",
clone.display()
),
None => println!("ejected {source}/{artifact} from {target} (files kept)"),
}
Ok(CliOutcome::Success)
}
Command::Uneject {
artifact,
source,
target,
} => {
let config = merge_configs(load_config()?, load_local_config(Path::new("."))?);
let (registry, _guard) = lock_project_registry(&config, cli.lock_timeout)?;
crate::sync::uneject(&config, ®istry, &artifact, &source, &target)?;
println!("unejected {source}/{artifact} in {target}");
Ok(CliOutcome::Success)
}
Command::RebuildRegistry => completed(sync::run_rebuild_registry(cli.lock_timeout)),
Command::CheckMatch { source, path } => {
let source = load_source(&source)?;
let report = check_match_cmd(&source, &path);
render::print_check_match(&source, &path, &report);
Ok(CliOutcome::Success)
}
Command::Source { cmd } => completed(run_source(cmd)),
Command::Target { cmd } => completed(run_target(cmd)),
Command::Cache { cmd } => completed(cache::run_cache(cmd)),
cmd @ Command::Bind { .. } => completed(dispatch_bind(cmd)),
Command::Unbind {
sources,
from,
local,
} => completed(bind::run_unbind(&sources, &from, local)),
cmd @ Command::Trust { .. } => completed(dispatch_trust(cmd, cli.lock_timeout)),
Command::Preview {
source,
target,
files,
json,
} => completed(query::run_preview(
&PreviewSelectors {
source,
target,
files,
},
json,
)),
Command::Explain {
target,
source,
path,
} => completed(query::run_explain(&target, &source, path.as_deref())),
}
}
fn dispatch_sync(cmd: Command, lock_timeout: Duration) -> Result<CliOutcome> {
match cmd {
Command::Sync {
prune,
force,
no_hooks,
no_transitive_hooks,
frozen,
fast_forward,
no_progress,
json,
jobs,
} => sync::run_sync(
prune,
force,
no_hooks,
no_transitive_hooks,
frozen,
fast_forward,
no_progress,
json,
None,
jobs,
lock_timeout,
),
Command::Update {
source,
prune,
fast_forward,
} => sync::run_update(source.as_deref(), fast_forward, prune, lock_timeout),
_ => unreachable!("dispatch_sync only receives Sync or Update"),
}
}
fn dispatch_add(cmd: Command) -> Result<()> {
let Command::Add {
url,
to,
name,
branch,
tag,
root,
include,
exclude,
assume_yes,
local,
symlink,
history,
r#as,
} = cmd
else {
unreachable!("dispatch_add only handles Command::Add")
};
let refinement = BindRefinement {
r#as,
history,
..BindRefinement::default()
};
add::run_add(add::AddRequest {
url: &url,
targets: &to,
name,
branch,
tag,
root,
include,
exclude,
local,
symlink,
assume_yes,
refinement: &refinement,
})
}
fn run_verify() -> Result<CliOutcome> {
let cwd = std::env::current_dir()?;
let base = load_config()?;
let local = load_local_config(&cwd)?;
let mut config = crate::config::merge_configs(base, local);
let registry = open_project_registry(&config)?;
let (base_lock, local_lock) = load_locks(&cwd)?;
let lock = base_lock.map_or_else(
|| local_lock.clone(),
|base| Some(crate::lock::merge_locks(&base, local_lock.as_ref())),
);
let cache_git = crate::paths::cache_root_for(config.paths.cache.as_deref(), &cwd)?.join("git");
let backend = build_router(&config, cache_git)?;
let mut parsed = config.parsed_sources()?;
let mut remotes = crate::sync::resolved_remotes(&config, &parsed)?;
crate::sync::inject_composed_graph(
&mut config,
&mut parsed,
&mut remotes,
&backend,
lock.as_ref(),
);
let report = crate::sync::verify(&config, ®istry, lock.as_ref(), &backend)?;
render::print_verify(&report);
if report.is_clean() {
Ok(CliOutcome::Success)
} else {
Ok(CliOutcome::Failure)
}
}
fn dispatch_trust(cmd: Command, lock_timeout: Duration) -> Result<()> {
let Command::Trust {
source,
list,
revoke,
show,
} = cmd
else {
unreachable!("dispatch_trust only handles Command::Trust")
};
trust::run_trust(
source.as_deref(),
list,
revoke,
show.as_deref(),
lock_timeout,
)
}
fn dispatch_bind(cmd: Command) -> Result<()> {
let Command::Bind {
sources,
to,
local,
history,
r#as,
root,
take,
branch,
tag,
rev,
offer,
} = cmd
else {
unreachable!("dispatch_bind only handles Command::Bind")
};
bind::run_bind(
&sources,
&to,
local,
&BindRefinement {
r#as,
root,
branch,
tag,
rev,
take: take
.iter()
.map(|t| config_edit::TakeArg::parse(t))
.collect(),
history,
offer,
},
)
}
fn run_source(cmd: SourceCmd) -> Result<()> {
match cmd {
SourceCmd::Add {
url,
name,
branch,
tag,
root,
include,
exclude,
local,
symlink,
} => add::run_add(add::AddRequest {
url: &url,
targets: &[],
name,
branch,
tag,
root,
include,
exclude,
local,
symlink,
assume_yes: false,
refinement: &BindRefinement::default(),
}),
SourceCmd::Rm { name } => run_source_rm(&name),
SourceCmd::List => {
render::print_source_rows(&source_listing(&load_config()?)?);
Ok(())
}
SourceCmd::Show { name } => {
render::print_source_summary(&source_summary(&load_config()?, &name)?);
Ok(())
}
}
}
fn read_config_text(path: &str) -> Result<String> {
match std::fs::read_to_string(path) {
Ok(text) => Ok(text),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok("version = 1\n".to_owned()),
Err(e) => Err(Error::Config(format!("read {path}: {e}"))),
}
}
fn run_source_rm(name: &str) -> Result<()> {
let main = read_config_text("phora.toml")?;
let local = read_config_text("phora.local.toml")?;
let result = config_edit::remove_source(&main, &local, name)?;
if result.main != main {
std::fs::write("phora.toml", &result.main)?;
}
if result.local != local {
std::fs::write("phora.local.toml", &result.local)?;
}
render::print_source_removed(name);
Ok(())
}
fn run_target(cmd: TargetCmd) -> Result<()> {
match cmd {
TargetCmd::Add {
name,
path,
layout,
local,
} => run_target_add(&name, &path, layout.as_deref(), local),
TargetCmd::Rm { name, local, force } => run_target_rm(&name, local, force),
TargetCmd::List => {
render::print_target_rows(&target_listing(&load_config()?));
Ok(())
}
TargetCmd::Show { name } => {
let config = load_config()?;
let cwd = std::env::current_dir()?;
let cache_git =
crate::paths::cache_root_for(config.paths.cache.as_deref(), &cwd)?.join("git");
let backend = GitBackend::new(cache_git);
render::print_target_detail(&target_detail(
&config,
&open_project_registry(&config)?,
&backend,
&name,
)?);
Ok(())
}
}
}
fn target_config_file(local: bool) -> &'static str {
if local {
"phora.local.toml"
} else {
"phora.toml"
}
}
fn run_target_add(name: &str, path: &str, layout: Option<&str>, local: bool) -> Result<()> {
TargetName::from_str(name)?;
let file = target_config_file(local);
let text = read_config_text(file)?;
let updated = config_edit::upsert_target(&text, name, path, layout)?;
std::fs::write(file, &updated)?;
render::print_target_added(name, path);
Ok(())
}
fn run_target_rm(name: &str, local: bool, force: bool) -> Result<()> {
if !force {
let config = merge_configs(load_config()?, load_local_config(Path::new("."))?);
let registry = open_project_registry(&config)?;
let deployed = registry.target_artifacts(name)?;
if !deployed.is_empty() {
return Err(Error::Config(render::target_rm_refusal(name, &deployed)));
}
}
let file = target_config_file(local);
let text = read_config_text(file)?;
let updated = config_edit::remove_target(&text, name)?;
std::fs::write(file, &updated)?;
render::print_target_removed(name);
Ok(())
}
fn build_router(
config: &Config,
git_dir: std::path::PathBuf,
) -> Result<RouterBackend<GitBackend, HttpBackend>> {
std::fs::create_dir_all(&git_dir)
.map_err(|e| Error::Config(format!("create mirror dir {}: {e}", git_dir.display())))?;
let mut digests = BTreeMap::new();
for (name, source) in &config.parsed_sources()? {
if let Some(digest) = source.digest() {
digests.insert(SourceName::trusted(name.clone()), digest);
}
}
let git = GitBackend::new(git_dir.clone());
let http = HttpBackend::new(git_dir, digests);
Ok(RouterBackend::new(git, http))
}
enum DropSources {
All,
One(String),
}
fn drop_sources(lock: Option<&mut crate::lock::Lock>, drop: &DropSources) {
let Some(lock) = lock else { return };
match drop {
DropSources::All => lock.sources.clear(),
DropSources::One(name) => lock
.sources
.retain(|s| &s.name != name && s.instance.is_none()),
}
}
fn load_local_config(cwd: &Path) -> Result<Option<Config>> {
let path = cwd.join("phora.local.toml");
match std::fs::read_to_string(&path) {
Ok(text) => {
let config = Config::parse_local(&text)?;
for warning in config.migration_warnings(cwd) {
eprintln!("phora: phora.local.toml: {warning}");
}
Ok(Some(config))
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
Err(e) => Err(Error::Config(format!("read {}: {e}", path.display()))),
}
}
pub(super) fn effective_auto_target() -> bool {
let cwd = Path::new(".");
let Ok(base) = load_config_from(cwd) else {
return true;
};
let local = load_local_config(cwd).ok().flatten();
merge_configs(base, local).defaults.auto_target()
}
pub(super) struct TtyMissingTarget {
pub(super) assume_yes: bool,
}
impl add::MissingTargetDecider for TtyMissingTarget {
fn decide(&self, name: &str, path: &str) -> add::MissingTarget {
add::missing_target_decision(
Path::new(path).is_dir(),
self.assume_yes,
std::io::stdin().is_terminal(),
|| prompt_yes_on_stdin(&format!("phora: create target '{name}' at {path}? "), true),
)
}
}
pub(crate) fn prompt_yes_on_stdin(prompt: &str, default_yes: bool) -> bool {
use std::io::Write as _;
eprint!("{prompt}{} ", if default_yes { "[Y/n]" } else { "[y/N]" });
let _ = std::io::stderr().flush();
let mut line = String::new();
match std::io::stdin().read_line(&mut line) {
Ok(0) | Err(_) => false,
Ok(_) => match line.trim() {
"" => default_yes,
typed => typed.eq_ignore_ascii_case("y") || typed.eq_ignore_ascii_case("yes"),
},
}
}
pub(crate) struct TtyTrustPrompt;
impl crate::sync::TrustPrompt for TtyTrustPrompt {
fn confirm(&self, request: &crate::sync::TrustRequest<'_>) -> bool {
prompt_yes_on_stdin(
&format!(
"phora: composed dep `{}` wants to run on_change hook `{}` — trust it? ",
request.dep_instance, request.command
),
false,
)
}
}
struct TtyResolver;
impl ConflictResolver for TtyResolver {
fn resolve(&self, conflict: &Conflict) -> Resolution {
loop {
eprint!(
"phora: conflict at {}/{} in {} — [s]kip/[o]verwrite/[e]ject/[a]bort? ",
conflict.source, conflict.artifact, conflict.target
);
let _ = std::io::stderr().flush();
let mut line = String::new();
match std::io::stdin().read_line(&mut line) {
Ok(0) | Err(_) => return Resolution::Skip,
Ok(_) => {
if let Some(resolution) = line.chars().next().and_then(resolution_from_char) {
return resolution;
}
}
}
}
}
}
fn open_project_registry(config: &Config) -> Result<FileStateStore> {
let cwd = std::env::current_dir()?;
let project = ProjectId::for_path(&cwd)?;
let registry_root = state_root_for(config.paths.state.as_deref(), &cwd)?
.join("projects")
.join(project.as_str());
Ok(FileStateStore::open(registry_root)?)
}
fn lock_project_registry(
config: &Config,
lock_timeout: Duration,
) -> Result<(FileStateStore, StateLock)> {
let registry = open_project_registry(config)?
.with_lock_timeout(lock_timeout)
.on_lock_wait(announce_lock_wait);
let guard = registry.acquire_lock()?;
Ok((registry, guard))
}
fn announce_lock_wait() {
eprintln!("phora: waiting for another phora process (state.lock held)");
}
fn load_config() -> Result<Config> {
load_config_from(Path::new("."))
}
fn load_config_from(dir: &Path) -> Result<Config> {
let path = dir.join("phora.toml");
let text = std::fs::read_to_string(&path)
.map_err(|e| Error::Config(format!("read {}: {e}", path.display())))?;
let config = Config::parse(&text)?;
for warning in config.migration_warnings(dir) {
eprintln!("phora: {warning}");
}
Ok(config)
}
fn load_source(name: &str) -> Result<ParsedSource> {
let source = load_config()?
.sources
.remove(name)
.ok_or_else(|| Error::Config(format!("source `{name}` not found in phora.toml")))?;
ParsedSource::parse(name, &source)
}
#[must_use]
pub fn resolution_from_char(c: char) -> Option<Resolution> {
match c {
's' => Some(Resolution::Skip),
'o' => Some(Resolution::Overwrite),
'e' => Some(Resolution::Eject),
'a' => Some(Resolution::Abort),
_ => None,
}
}