mod add_config;
pub mod analyzers;
mod build;
pub mod cache_cmd;
mod clean;
mod doctor;
mod graph;
pub mod processor;
mod product;
pub mod sloc;
pub mod smart;
pub mod symlink_install;
pub mod tools;
pub use add_config::{add_analyzer, add_processor};
use crate::analyzers::DepAnalyzer;
use crate::cli::{BuildPhase, DisplayOptions};
use crate::color;
use crate::config::{Config, ProcessorConfig, find_registry_entry, registry_entries};
use crate::deps_cache::DepsCache;
use crate::errors;
use crate::file_index::FileIndex;
use crate::graph::BuildGraph;
use crate::object_store::{ObjectStore, ObjectStoreOptions};
use crate::processor::{Discovery, Processor, ProcessorMap};
use crate::remote_cache;
use crate::tool_lock;
use anyhow::{Context as _, Result};
use std::borrow::Cow;
use std::collections::HashMap;
use std::path::PathBuf;
use std::time::{Duration, Instant};
pub type PhaseTimings = Vec<(String, Duration)>;
struct GraphBuild {
graph: BuildGraph,
phase_timings: PhaseTimings,
analysis: Option<crate::analyzers::Analysis>,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum GraphBuildMode {
Normal,
ForClean,
ForRepair,
}
fn sorted_keys<V>(map: &HashMap<String, V>) -> Vec<&String> {
let mut keys: Vec<&String> = map.keys().collect();
keys.sort();
keys
}
fn phases_debug() -> bool {
crate::runtime_flags::phases_debug()
}
#[derive(Debug, Clone, Copy)]
pub enum GraphSnapshot {
Start,
AfterDiscover,
AfterAddDependencies,
AfterApplyToolHashes,
AfterResolve,
AfterClassify,
AfterExecute,
}
impl GraphSnapshot {
const fn name(self) -> &'static str {
match self {
Self::Start => "START",
Self::AfterDiscover => "AFTER_DISCOVER",
Self::AfterAddDependencies => "AFTER_ADD_DEPENDENCIES",
Self::AfterApplyToolHashes => "AFTER_APPLY_TOOL_HASHES",
Self::AfterResolve => "AFTER_RESOLVE",
Self::AfterClassify => "AFTER_CLASSIFY",
Self::AfterExecute => "AFTER_EXECUTE",
}
}
}
pub fn print_graph_stats(snapshot: GraphSnapshot, graph: &BuildGraph) {
if !crate::runtime_flags::graph_stats() {
return;
}
let products = graph.products().len();
let edges: usize = graph
.products()
.iter()
.map(|p| graph.get_dependencies(p.id).len())
.sum();
let inputs: usize = graph.products().iter().map(|p| p.inputs.len()).sum();
eprintln!(
"[graph-stats] {:<24} products={} edges={} inputs={}",
snapshot.name(),
products,
edges,
inputs,
);
}
struct ProductStatusLabels<'a> {
current: (Cow<'a, str>, &'static str),
restorable: (Cow<'a, str>, &'static str),
stale: (Cow<'a, str>, &'static str),
new: (Cow<'a, str>, &'static str),
}
struct StatusPrintOptions<'a> {
labels: &'a ProductStatusLabels<'a>,
explain: bool,
display_opts: DisplayOptions,
verbose: bool,
all_processor_names: &'a [&'a str],
}
pub fn create_processor_for_instance(
type_name: &str,
config_toml: &toml::Value,
) -> anyhow::Result<Option<Box<dyn Processor>>> {
if let Some(entry) = find_registry_entry(type_name) {
let mut resolved = config_toml.clone();
let mut prov = crate::config::ProvenanceMap::new();
crate::registries::apply_all_defaults(&entry.pname(), &mut resolved, &mut prov);
return (entry.create)(&resolved).map(Some);
}
Ok(None)
}
fn stanza_error(
config: &crate::config::Config,
path: &[String],
section: &str,
error: &anyhow::Error,
) -> anyhow::Error {
let location = config
.sources
.locate(path)
.map_or_else(String::new, |location| format!("{location}: "));
crate::exit_code::config_error(format!(
"Invalid config:\n {location}[{section}]: {error:#}"
))
}
fn processor_stanza_path(instance_name: &str) -> Vec<String> {
let Some(parsed) = crate::registries::parse_name(instance_name) else {
return Vec::new();
};
let mut path = vec![
"processor".to_string(),
parsed.processor_type.as_str().to_string(),
parsed.short.to_string(),
];
path.extend(parsed.instance.map(str::to_string));
path
}
fn analyzer_stanza_path(inst: &crate::config::AnalyzerInstance) -> Vec<String> {
let mut path = vec!["analyzer".to_string(), inst.type_name.clone()];
path.extend(
inst.instance_name
.strip_prefix(inst.type_name.as_str())
.and_then(|rest| rest.strip_prefix('.'))
.map(str::to_string),
);
path
}
pub fn create_processors_of(config: &crate::config::Config) -> Result<ProcessorMap> {
let mut processors: ProcessorMap = HashMap::new();
for inst in &config.processor.instances {
match create_processor_for_instance(&inst.pname, &inst.config_toml) {
Ok(Some(proc)) => {
processors.insert(inst.instance_name.clone(), proc);
}
Ok(None) => {
anyhow::bail!("Unknown processor type: '{}'", inst.pname);
}
Err(e) => {
return Err(stanza_error(
config,
&processor_stanza_path(&inst.instance_name),
&inst.instance_name,
&e,
));
}
}
}
Ok(processors)
}
pub fn create_analyzers_of(
config: &crate::config::Config,
verbose: bool,
) -> Result<Vec<(String, Box<dyn DepAnalyzer>)>> {
let mut analyzers = Vec::new();
for inst in &config.analyzer.instances {
let plugin = crate::registries::find_analyzer_plugin(&inst.type_name)
.ok_or_else(|| anyhow::anyhow!("Unknown analyzer type '{}'", inst.type_name))?;
let analyzer = (plugin.create)(&inst.config_toml, verbose).map_err(|e| {
stanza_error(
config,
&analyzer_stanza_path(inst),
&format!("analyzer.{}", inst.instance_name),
&e,
)
})?;
analyzers.push((inst.instance_name.clone(), analyzer));
}
Ok(analyzers)
}
pub fn create_all_default_processors() -> Result<ProcessorMap> {
let mut processors: ProcessorMap = HashMap::new();
for entry in registry_entries() {
let pname = entry.pname();
let processor = create_default_processor(entry)?;
processors.insert(pname, processor);
}
Ok(processors)
}
pub fn default_processor_tools(
entry: &crate::registries::processor::ProcessorPlugin,
) -> Result<Vec<String>> {
let mut tools = create_default_processor(entry)?.required_tools();
tools.sort();
tools.dedup();
Ok(tools)
}
fn create_default_processor(
entry: &crate::registries::processor::ProcessorPlugin,
) -> Result<Box<dyn crate::processor::Processor>> {
let pname = entry.pname();
let mut empty_toml = toml::Value::Table(toml::map::Map::new());
let mut provenance = crate::config::ProvenanceMap::new();
crate::registries::apply_all_defaults(&pname, &mut empty_toml, &mut provenance);
(entry.create)(&empty_toml)
.with_context(|| format!("Failed to create processor '{pname}' with default config"))
}
pub struct Builder {
object_store: ObjectStore,
config: Config,
file_index: FileIndex,
}
impl Builder {
fn apply_config_to_context(&self, ctx: &crate::build_context::BuildContext) {
ctx.set_mtime_check_from_config(self.config.cache.mtime_check);
ctx.set_webcache_ttl_secs(self.config.cache.webcache_ttl_secs);
}
pub fn new(ctx: &crate::build_context::BuildContext) -> Result<Self> {
Self::new_with_overrides(ctx, &[], &[])
}
pub fn new_with_overrides(
ctx: &crate::build_context::BuildContext,
iset: &[String],
pset: &[String],
) -> Result<Self> {
Config::require_config()?;
let mut config = Config::load()?;
config.apply_overrides(iset, pset)?;
let restore_method = config.cache.restore_method.resolve();
let remote_backend = match &config.cache.remote {
Some(url) => Some(remote_cache::create_backend(url)?),
None => None,
};
let object_store = ObjectStore::new(ObjectStoreOptions {
restore_method,
compression: config.cache.compression,
remote: remote_backend,
remote_push: config.cache.remote_push,
remote_pull: config.cache.remote_pull,
})?;
let (exclude_roots, force_dirs) = config.file_index_walk_dirs();
let force_refs: Vec<&str> = force_dirs.iter().map(String::as_str).collect();
let file_index = FileIndex::build_with_force_dirs(
&force_refs,
&exclude_roots,
config.build.warn_symlinks,
)?;
let builder = Self {
object_store,
config,
file_index,
};
builder.apply_config_to_context(ctx);
Ok(builder)
}
pub fn create_processors(&self) -> Result<ProcessorMap> {
create_processors_of(&self.config)
}
fn detect_config_changes(&self, processors: &ProcessorMap, show_all: bool) {
let print = !crate::json_output::is_json_mode() && !crate::runtime_flags::quiet();
for name in sorted_keys(processors) {
let processor = processors.get(name).expect(errors::PROCESSOR_NOT_IN_MAP);
let Some(config_json) = processor.config_json() else {
continue;
};
let config_json = if show_all {
config_json
} else {
Self::filter_checksum_fields(name, &config_json)
};
let stored = match self.object_store.store_processor_config(name, &config_json) {
Ok(stored) => stored,
Err(e) => {
crate::output::warn(&format!(
"could not record the config of [{name}] for change detection: {e:#}"
));
None
}
};
if let Some(old_json) = stored
&& print
{
if let Some(diff) = ObjectStore::diff_configs(&old_json, &config_json) {
println!(
"{}",
color::yellow(&format!("Config changed for [{name}]:"))
);
println!("{diff}");
}
}
}
}
fn filter_checksum_fields(processor_name: &str, json: &str) -> String {
let checksum_fields = ProcessorConfig::checksum_fields_for(processor_name);
let Ok(value) = serde_json::from_str::<serde_json::Value>(json) else {
return json.to_string();
};
let Some(obj) = value.as_object() else {
return json.to_string();
};
match checksum_fields {
Some(fields) => {
let filtered: serde_json::Map<String, serde_json::Value> = obj
.iter()
.filter(|(k, _)| fields.contains(&k.as_str()))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
serde_json::to_string(&filtered).unwrap_or_else(|_| json.to_string())
}
None => json.to_string(),
}
}
pub(crate) fn create_analyzers(
&self,
verbose: bool,
) -> Result<HashMap<String, Box<dyn DepAnalyzer>>> {
Ok(create_analyzers_of(&self.config, verbose)?
.into_iter()
.filter(|(_, analyzer)| analyzer.enabled())
.collect())
}
fn run_analyzers(
&self,
ctx: &crate::build_context::BuildContext,
graph: &mut BuildGraph,
file_index: FileIndex,
verbose: bool,
) -> Result<crate::analyzers::Analysis> {
let analyzers = self.create_analyzers(verbose)?;
let active_analyzers: Vec<(String, Box<dyn DepAnalyzer>)> = analyzers
.into_iter()
.filter(|(_, analyzer)| analyzer.auto_detect(&file_index))
.collect();
let mut analysis =
crate::analyzers::Analysis::new(ctx, active_analyzers, DepsCache::open()?, file_index)?;
if analysis.is_empty() {
return Ok(analysis);
}
let product_refs = analysis.count_matches(graph);
let unique_pairs = analysis.unique_sources(graph);
let unique_count = unique_pairs.len();
let suppress = crate::json_output::is_json_mode() || crate::runtime_flags::quiet();
if unique_count > 0 && !suppress {
if product_refs > unique_count {
println!(
"[deps] {unique_count} files to check (consumed by {product_refs} products)",
);
} else {
println!("[deps] {unique_count} files to check");
}
}
let mut mtime_hits: usize = 0;
let mut content_hits: usize = 0;
let mut misses: usize = 0;
for (index, source) in &unique_pairs {
match analysis.classify(ctx, *index, source) {
crate::deps_cache::ClassifyResult::MtimeHit => mtime_hits += 1,
crate::deps_cache::ClassifyResult::ContentHit => content_hits += 1,
crate::deps_cache::ClassifyResult::Miss => misses += 1,
}
}
if unique_count > 0 && !suppress {
let cached = mtime_hits + content_hits;
println!(
"[deps] {misses} to rescan ({cached} cached: {mtime_hits} mtime, {content_hits} checksum)",
);
}
let hidden = verbose || crate::json_output::is_json_mode() || crate::runtime_flags::quiet();
let pb = crate::progress::create_bar(product_refs as u64, hidden);
analysis.analyze_graph(ctx, graph, &pb)?;
pb.finish_and_clear();
let stats = analysis.stats();
if unique_count > 0 && !suppress {
println!(
"[deps] summary: {} rescanned ({} cache hits: {} mtime, {} checksum)",
stats.misses, stats.hits, stats.mtime_hits, stats.content_hits,
);
}
Ok(analysis)
}
fn complete_graph(
&self,
ctx: &crate::build_context::BuildContext,
processors: &ProcessorMap,
mode: GraphBuildMode,
) -> Result<BuildGraph> {
let built =
self.build_graph_with_processors_impl(ctx, processors, mode, BuildPhase::Build, false)?;
Ok(built.graph)
}
fn build_graph_with_processors(
&self,
ctx: &crate::build_context::BuildContext,
processors: &ProcessorMap,
) -> Result<BuildGraph> {
self.complete_graph(ctx, processors, GraphBuildMode::Normal)
}
fn build_graph_for_repair_with_processors(
&self,
ctx: &crate::build_context::BuildContext,
processors: &ProcessorMap,
) -> Result<BuildGraph> {
self.complete_graph(ctx, processors, GraphBuildMode::ForRepair)
}
fn build_graph_for_clean_with_processors(
&self,
ctx: &crate::build_context::BuildContext,
processors: &ProcessorMap,
) -> Result<BuildGraph> {
self.complete_graph(ctx, processors, GraphBuildMode::ForClean)
}
pub fn detected_processors(&self) -> Result<std::collections::HashSet<String>> {
let processors = create_all_default_processors()?;
let mut detected = std::collections::HashSet::new();
for (name, proc) in &processors {
if proc.auto_detect(&self.file_index) {
detected.insert(name.clone());
}
}
Ok(detected)
}
pub fn detected_and_available_processors(&self) -> Result<std::collections::HashSet<String>> {
let processors = create_all_default_processors()?;
let mut available = std::collections::HashSet::new();
for (name, proc) in &processors {
if !proc.auto_detect(&self.file_index) {
continue;
}
let tools = proc.required_tools();
if tools.iter().all(|t| which::which(t).is_ok()) {
available.insert(name.clone());
}
}
Ok(available)
}
pub fn no_file_processors(
&self,
ctx: &crate::build_context::BuildContext,
) -> Result<Vec<String>> {
let processors = self.create_processors()?;
let graph = self.build_graph_for_repair_with_processors(ctx, &processors)?;
let mut has_products: std::collections::HashSet<&str> = std::collections::HashSet::new();
for product in graph.products() {
has_products.insert(product.processor.as_str());
}
let mut empty: Vec<String> = sorted_keys(&processors)
.into_iter()
.filter(|name| processors[name.as_str()].scan_config().enabled)
.filter(|name| !has_products.contains(name.as_str()))
.cloned()
.collect();
empty.sort();
Ok(empty)
}
fn is_processor_active(&self, _name: &str, processor: &dyn Processor) -> bool {
processor.scan_config().enabled
}
fn discover_products(
&self,
graph: &mut BuildGraph,
processors: &ProcessorMap,
active: &[impl AsRef<str>],
mode: GraphBuildMode,
) -> Result<FileIndex> {
let for_clean = mode == GraphBuildMode::ForClean;
let mut file_index = self.file_index.clone();
let debug = phases_debug();
let max_passes = self.config.build.max_discovery_passes;
let mut routed: Option<FileIndex> = None;
for pass in 0..=max_passes {
let before = graph.products().len();
for name in active {
let name = name.as_ref();
let processor = &processors[name];
if !processor.scan_config().enabled {
continue;
}
let view = match (&routed, processor.discovery()) {
(Some(new_files), Discovery::PerFile) => new_files,
_ => &file_index,
};
if for_clean {
processor.discover_for_clean(graph, view, name)?;
} else {
processor.discover(graph, view, name)?;
}
}
let after = graph.products().len();
if after == before {
break;
}
if pass == max_passes {
let mut culprits: Vec<&str> = graph.products()[before..after]
.iter()
.map(|p| p.processor.as_str())
.collect();
culprits.sort_unstable();
culprits.dedup();
return Err(crate::exit_code::RsconstructError::new(
crate::exit_code::RsconstructExitCode::GraphError,
format!(
"discovery did not converge after {max_passes} passes; still adding products: {} (raise [build] max_discovery_passes if this chain is intentional)",
culprits.join(", ")
),
).into());
}
let outputs: Vec<PathBuf> = graph.products()[before..after]
.iter()
.flat_map(|p| p.outputs.iter().cloned())
.collect();
let added = file_index.add_virtual_files(&outputs);
if added.is_empty() {
break;
}
if debug {
eprintln!(
"{}",
color::dim(&format!(
" discover pass {}: {} new products, {} virtual files added",
pass + 1,
after - before,
added.len()
))
);
}
routed = Some(FileIndex::from_paths(added));
}
let mut missing_dirs: Vec<String> = Vec::new();
let mut missing_files: Vec<String> = Vec::new();
for name in active {
let name = name.as_ref();
let scan = processors[name].scan_config();
if !scan.enabled {
continue;
}
for dir in scan.src_dirs() {
if dir.is_empty() || dir == "." {
continue;
}
if std::path::Path::new(dir).is_dir() {
continue;
}
let prefix = std::path::PathBuf::from(dir);
let covered_by_virtual = file_index.files().iter().any(|f| f.starts_with(&prefix));
if !covered_by_virtual {
missing_dirs.push(format!(
" [{name}] src_dirs entry '{dir}' does not exist or is not a directory"
));
}
}
for file in scan.src_files() {
if std::path::Path::new(file).is_file() {
continue;
}
let path = std::path::PathBuf::from(file);
let covered_by_virtual = file_index.files().contains(&path);
if !covered_by_virtual {
missing_files.push(format!(
" [{name}] src_files entry '{file}' does not exist or is not a file"
));
}
}
}
let tolerant = mode != GraphBuildMode::Normal;
if tolerant || self.config.build.allow_missing_src_dirs {
if debug {
for entry in &missing_dirs {
eprintln!(
"{}",
color::dim(&format!(" {} (skipped)", entry.trim_start()))
);
}
}
missing_dirs.clear();
}
if tolerant {
if debug {
for entry in &missing_files {
eprintln!(
"{}",
color::dim(&format!(" {} (skipped)", entry.trim_start()))
);
}
}
missing_files.clear();
}
let mut missing_inputs: Vec<String> = Vec::new();
if !tolerant {
let explicit_prefix = format!("{}.", crate::processor::names::EXPLICIT);
for product in graph.products() {
if !product.processor.starts_with(&explicit_prefix) {
continue;
}
for input in &product.inputs {
if input.is_file() || file_index.contains(input) {
continue;
}
missing_inputs.push(format!(
" [{}] inputs entry '{}' does not exist and no processor declares it as an output",
product.processor,
input.display()
));
}
}
for name in active {
let name = name.as_ref();
if name != crate::processor::names::EXPLICIT && !name.starts_with(&explicit_prefix)
{
continue;
}
let processor = &processors[name];
if !processor.scan_config().enabled || !processor.auto_detect(&file_index) {
continue;
}
if !graph.products().iter().any(|p| p.processor == name) {
missing_inputs.push(format!(
" [{name}] no input: its inputs and input_globs resolve to no file, so \
the stanza would never run"
));
}
}
}
if missing_dirs.is_empty() && missing_files.is_empty() && missing_inputs.is_empty() {
return Ok(file_index);
}
let mut missing = missing_dirs;
missing.extend(missing_files);
missing.extend(missing_inputs);
Err(crate::exit_code::config_error(format!(
"Invalid config:\n{}\nEvery src_dirs entry must name a directory that exists, and every \
src_files entry and every explicit inputs entry a file that exists (or a path an \
upstream processor declares as its output), and every explicit stanza must have at \
least one input — fix the path or remove the entry; \
[build] allow_missing_src_dirs = true skips absent directories as before, never \
absent files",
missing.join("\n")
)))
}
fn processors_keyed_by_input_paths(&self) -> std::collections::HashSet<String> {
self.config
.processor
.instances
.iter()
.filter(|inst| {
inst.config_toml
.get(crate::config::OUTPUT_DEPENDS_ON_INPUT_NAME)
.and_then(toml::Value::as_bool)
== Some(true)
})
.map(|inst| inst.instance_name.clone())
.collect()
}
fn apply_python_env(&self, graph: &mut BuildGraph, processors: &ProcessorMap) -> Result<()> {
let cwd = std::env::current_dir().context("Failed to read the current directory")?;
let venv = cwd.join(crate::python_env::VENV_DIR);
let Some(fingerprint) = crate::python_env::fingerprint(&venv) else {
return Ok(());
};
let explicit: std::collections::HashMap<&str, bool> = self
.config
.processor
.instances
.iter()
.filter_map(|inst| {
inst.config_toml
.get(crate::config::HASH_PYTHON_ENV)
.and_then(toml::Value::as_bool)
.map(|v| (inst.instance_name.as_str(), v))
})
.collect();
let keyed = crate::python_env::processors_keyed_by_python_env(
processors,
&|name| tools::instance_enabled(processors, name),
&|name| explicit.get(name).copied(),
&venv,
);
graph.apply_python_env(&keyed, &fingerprint);
Ok(())
}
fn build_graph_with_processors_impl(
&self,
ctx: &crate::build_context::BuildContext,
processors: &ProcessorMap,
mode: GraphBuildMode,
stop_after: BuildPhase,
verbose: bool,
) -> Result<GraphBuild> {
if phases_debug() {
eprintln!("{}", color::bold("Phase: Building dependency graph..."));
}
let mut graph = BuildGraph::new();
let mut phase_timings = PhaseTimings::new();
let mut analysis = None;
print_graph_stats(GraphSnapshot::Start, &graph);
let active_processors: Vec<&String> = sorted_keys(processors)
.into_iter()
.filter(|name| self.is_processor_active(name, processors[*name].as_ref()))
.collect();
if phases_debug() {
crate::output::diagnostic(&color::dim(" Phase: discover"));
}
let t = Instant::now();
let file_index =
self.discover_products(&mut graph, processors, &active_processors, mode)?;
graph.key_by_input_paths(&self.processors_keyed_by_input_paths());
phase_timings.push(("discover".to_string(), t.elapsed()));
print_graph_stats(GraphSnapshot::AfterDiscover, &graph);
if stop_after == BuildPhase::Discover {
return Ok(GraphBuild {
graph,
phase_timings,
analysis,
});
}
if mode == GraphBuildMode::Normal {
if phases_debug() {
crate::output::diagnostic(&color::dim(" Phase: add_dependencies"));
}
let t = Instant::now();
analysis = Some(self.run_analyzers(ctx, &mut graph, file_index, verbose)?);
phase_timings.push(("add_dependencies".to_string(), t.elapsed()));
print_graph_stats(GraphSnapshot::AfterAddDependencies, &graph);
}
if stop_after == BuildPhase::AddDependencies {
return Ok(GraphBuild {
graph,
phase_timings,
analysis,
});
}
if phases_debug() {
crate::output::diagnostic(&color::dim(" Phase: apply_tool_version_hashes"));
}
let t = Instant::now();
if self.config.build.hash_tool_versions {
let tool_hashes = tool_lock::processor_tool_hashes(processors, &|name| {
tools::instance_enabled(processors, name)
});
if !tool_hashes.is_empty() {
graph.apply_tool_version_hashes(&tool_hashes);
}
}
phase_timings.push(("tool_version_hashes".to_string(), t.elapsed()));
let t = Instant::now();
if self.config.build.hash_python_env {
self.apply_python_env(&mut graph, processors)?;
}
phase_timings.push(("python_env".to_string(), t.elapsed()));
print_graph_stats(GraphSnapshot::AfterApplyToolHashes, &graph);
if phases_debug() {
crate::output::diagnostic(&color::dim(" Phase: resolve_dependencies"));
}
let t = Instant::now();
graph.resolve_dependencies();
phase_timings.push(("resolve".to_string(), t.elapsed()));
print_graph_stats(GraphSnapshot::AfterResolve, &graph);
let t = Instant::now();
let validation_errors = graph.validate(&self.config.graph);
if !validation_errors.is_empty() {
anyhow::bail!("Graph validation failed:\n{}", validation_errors.join("\n"));
}
phase_timings.push(("validate".to_string(), t.elapsed()));
Ok(GraphBuild {
graph,
phase_timings,
analysis,
})
}
fn build_graph(&self, ctx: &crate::build_context::BuildContext) -> Result<BuildGraph> {
let processors = self.create_processors()?;
self.build_graph_with_processors(ctx, &processors)
}
pub fn build_graph_for_cache(
&self,
ctx: &crate::build_context::BuildContext,
) -> Result<BuildGraph> {
self.build_graph(ctx)
}
pub fn valid_cache_keys(
&self,
ctx: &crate::build_context::BuildContext,
) -> Result<std::collections::HashSet<String>> {
let graph = self.build_graph_for_cache(ctx)?;
for product in graph.products() {
if let Some(absent) = product
.inputs
.iter()
.find(|input| graph.path_owner(input).is_some() && !input.exists())
{
anyhow::bail!(
"cannot tell which cache entries are stale: {} is generated by another product and is not on disk, \
so the cache key of [{}] {} is unknown. Run a build first.",
absent.display(),
product.processor,
product.primary_input().display(),
);
}
}
graph
.products()
.iter()
.map(|product| {
let input_checksum =
crate::checksum::combined_input_checksum(ctx, &product.inputs)?;
Ok(product.descriptor_key(&input_checksum))
})
.collect()
}
pub const fn object_store(&self) -> &ObjectStore {
&self.object_store
}
pub fn output_dir(&self) -> &str {
&self.config.build.output_dir
}
pub fn watch_paths(&self) -> Vec<PathBuf> {
let mut paths: Vec<PathBuf> = Vec::new();
for name in ["rsconstruct.toml", crate::config::LOCAL_CONFIG_FILE] {
let config_path = PathBuf::from(name);
if config_path.exists() {
paths.push(config_path);
}
}
for dir in self.config.processor.src_dirs() {
let full = PathBuf::from(&dir);
if full.exists() {
paths.push(full);
}
}
for name in &["pyproject.toml", "config"] {
let p = PathBuf::from(name);
if p.exists() {
paths.push(p);
}
}
paths.sort();
paths.dedup();
paths
}
}