Work towards using resolvo for spk commands

jrray · jrray · commit 44114dc8e93c · 2025-02-09T17:23:48.000-08:00
Change the solver factory to return an `impl AbstractSolver` instead of
a concrete `spk_solve::Solver`. This leads to trouble with the different
way to run the solver, so `downcast_ref` is used to get back the
original type.

Signed-off-by: J Robert Ray &lt;jrray@jrray.org&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/spk-build/src/build/binary.rs b/crates/spk-build/src/build/binary.rs
@@ -37,7 +37,7 @@ use spk_schema::{
 };
 use spk_solve::graph::Graph;
 use spk_solve::solution::Solution;
-use spk_solve::{BoxedResolverCallback, Named, ResolverCallback, Solver};
+use spk_solve::{AbstractSolver, BoxedResolverCallback, Named, ResolverCallback, Solver};
 use spk_storage as storage;
 
 use crate::report::{BuildOutputReport, BuildReport, BuildSetupReport};
diff --git a/crates/spk-cli/cmd-env/src/cmd_env.rs b/crates/spk-cli/cmd-env/src/cmd_env.rs
@@ -11,6 +11,7 @@ use spfs::tracking::SpecFile;
 use spfs_cli_common::Progress;
 use spk_cli_common::{build_required_packages, flags, CommandArgs, Run};
 use spk_exec::setup_runtime_with_reporter;
+use spk_solve::AbstractSolver;
 #[cfg(feature = "statsd")]
 use spk_solve::{get_metrics_client, SPK_RUN_TIME_METRIC};
 
@@ -86,8 +87,13 @@ impl Run for Env {
             solver.add_request(request)
         }
 
-        let formatter = self.formatter_settings.get_formatter(self.verbose)?;
-        let (solution, _) = formatter.run_and_print_resolve(&solver).await?;
+        let solution = if let Some(solver) = solver.as_any().downcast_ref::<spk_solve::Solver>() {
+            let formatter = self.formatter_settings.get_formatter(self.verbose)?;
+            let (solution, _) = formatter.run_and_print_resolve(&solver).await?;
+            solution
+        } else {
+            solver.solve().await?
+        };
 
         let solution = build_required_packages(&solution).await?;
 
diff --git a/crates/spk-cli/cmd-explain/Cargo.toml b/crates/spk-cli/cmd-explain/Cargo.toml
@@ -17,6 +17,7 @@ miette = { workspace = true, features = ["fancy"] }
 async-trait = { workspace = true }
 clap = { workspace = true }
 spk-cli-common = { workspace = true }
+spk-solve = { workspace = true }
 # The dependency on spfs can be removed after the deprecated runtime flags are
 # removed.
 spfs = { workspace = true }
diff --git a/crates/spk-cli/cmd-explain/src/cmd_explain.rs b/crates/spk-cli/cmd-explain/src/cmd_explain.rs
@@ -5,6 +5,7 @@
 use clap::Args;
 use miette::Result;
 use spk_cli_common::{flags, CommandArgs, Run};
+use spk_solve::AbstractSolver;
 
 /// Show the resolve process for a set of packages.
 #[derive(Args)]
@@ -80,12 +81,17 @@ impl Run for Explain {
         }
 
         // Always show the solution packages for the solve
-        let formatter = self
-            .formatter_settings
-            .get_formatter_builder(self.verbose + 1)?
-            .with_solution(true)
-            .build();
-        formatter.run_and_print_resolve(&solver).await?;
+        if let Some(solver) = solver.as_any().downcast_ref::<spk_solve::Solver>() {
+            let formatter = self
+                .formatter_settings
+                .get_formatter_builder(self.verbose + 1)?
+                .with_solution(true)
+                .build();
+            formatter.run_and_print_resolve(&solver).await?;
+        } else {
+            // TODO: print the solve
+            solver.solve().await?;
+        }
 
         Ok(0)
     }
diff --git a/crates/spk-cli/cmd-install/Cargo.toml b/crates/spk-cli/cmd-install/Cargo.toml
@@ -21,4 +21,5 @@ futures = { workspace = true }
 spk-cli-common = { workspace = true }
 spk-exec = { workspace = true }
 spk-schema = { workspace = true }
+spk-solve = { workspace = true }
 tokio = { workspace = true, features = ["rt"] }
diff --git a/crates/spk-cli/cmd-install/src/cmd_install.rs b/crates/spk-cli/cmd-install/src/cmd_install.rs
@@ -14,6 +14,7 @@ use spk_exec::setup_current_runtime;
 use spk_schema::foundation::format::FormatIdent;
 use spk_schema::foundation::spec_ops::Named;
 use spk_schema::Package;
+use spk_solve::AbstractSolver;
 
 /// Install a package into the current environment
 #[derive(Args)]
@@ -62,12 +63,16 @@ impl Run for Install {
             solver.add_request(request);
         }
 
-        let formatter = self.formatter_settings.get_formatter(self.verbose)?;
-        let (solution, _) = formatter.run_and_print_resolve(&solver).await?;
+        let solution = if let Some(solver) = solver.as_any().downcast_ref::<spk_solve::Solver>() {
+            let formatter = self.formatter_settings.get_formatter(self.verbose)?;
+            let (solution, _) = formatter.run_and_print_resolve(&solver).await?;
+            solution
+        } else {
+            solver.solve().await?
+        };
 
         println!("The following packages will be installed:\n");
         let requested: HashSet<_> = solver
-            .get_initial_state()
             .get_pkg_requests()
             .iter()
             .map(|r| r.pkg.name.clone())
diff --git a/crates/spk-cli/cmd-render/Cargo.toml b/crates/spk-cli/cmd-render/Cargo.toml
@@ -20,6 +20,7 @@ dunce = { workspace = true }
 spfs = { workspace = true }
 spk-cli-common = { workspace = true }
 spk-exec = { workspace = true }
+spk-solve = { workspace = true }
 spk-storage = { workspace = true }
 tokio = { workspace = true, features = ["rt"] }
 tracing = { workspace = true }
diff --git a/crates/spk-cli/cmd-render/src/cmd_render.rs b/crates/spk-cli/cmd-render/src/cmd_render.rs
@@ -9,6 +9,7 @@ use miette::{bail, Context, IntoDiagnostic, Result};
 use spfs::storage::fallback::FallbackProxy;
 use spk_cli_common::{build_required_packages, flags, CommandArgs, Run};
 use spk_exec::resolve_runtime_layers;
+use spk_solve::AbstractSolver;
 
 /// Output the contents of an spk environment (/spfs) to a folder
 #[derive(Args)]
@@ -51,8 +52,13 @@ impl Run for Render {
             solver.add_request(name);
         }
 
-        let formatter = self.formatter_settings.get_formatter(self.verbose)?;
-        let (solution, _) = formatter.run_and_print_resolve(&solver).await?;
+        let solution = if let Some(solver) = solver.as_any().downcast_ref::<spk_solve::Solver>() {
+            let formatter = self.formatter_settings.get_formatter(self.verbose)?;
+            let (solution, _) = formatter.run_and_print_resolve(&solver).await?;
+            solution
+        } else {
+            solver.solve().await?
+        };
 
         let solution = build_required_packages(&solution).await?;
         let stack = resolve_runtime_layers(true, &solution).await?;
diff --git a/crates/spk-cli/cmd-test/src/test/build.rs b/crates/spk-cli/cmd-test/src/test/build.rs
@@ -15,7 +15,7 @@ use spk_schema::foundation::option_map::OptionMap;
 use spk_schema::ident::{PkgRequest, PreReleasePolicy, RangeIdent, Request, RequestedBy};
 use spk_schema::{AnyIdent, Recipe, SpecRecipe};
 use spk_solve::solution::Solution;
-use spk_solve::{BoxedResolverCallback, DefaultResolver, ResolverCallback, Solver};
+use spk_solve::{AbstractSolver, BoxedResolverCallback, DefaultResolver, ResolverCallback, Solver};
 use spk_storage as storage;
 
 use super::Tester;
diff --git a/crates/spk-cli/cmd-test/src/test/install.rs b/crates/spk-cli/cmd-test/src/test/install.rs
@@ -12,7 +12,7 @@ use spk_schema::foundation::option_map::OptionMap;
 use spk_schema::ident::{PkgRequest, PreReleasePolicy, RangeIdent, Request, RequestedBy};
 use spk_schema::ident_build::Build;
 use spk_schema::{Recipe, SpecRecipe, Variant, VariantExt};
-use spk_solve::{BoxedResolverCallback, DefaultResolver, ResolverCallback, Solver};
+use spk_solve::{AbstractSolver, BoxedResolverCallback, DefaultResolver, ResolverCallback, Solver};
 use spk_storage as storage;
 
 use super::Tester;
diff --git a/crates/spk-cli/cmd-test/src/test/sources.rs b/crates/spk-cli/cmd-test/src/test/sources.rs
@@ -13,7 +13,7 @@ use spk_schema::foundation::ident_component::Component;
 use spk_schema::foundation::option_map::OptionMap;
 use spk_schema::ident::{PkgRequest, PreReleasePolicy, RangeIdent, Request, RequestedBy};
 use spk_schema::{Recipe, SpecRecipe};
-use spk_solve::{BoxedResolverCallback, DefaultResolver, ResolverCallback, Solver};
+use spk_solve::{AbstractSolver, BoxedResolverCallback, DefaultResolver, ResolverCallback, Solver};
 use spk_storage as storage;
 
 use super::Tester;
diff --git a/crates/spk-cli/common/src/flags.rs b/crates/spk-cli/common/src/flags.rs
@@ -34,6 +34,7 @@ use spk_schema::ident::{
 };
 use spk_schema::option_map::HOST_OPTIONS;
 use spk_schema::{Recipe, SpecFileData, SpecRecipe, Template, TestStage, VariantExt};
+use spk_solve::AbstractSolver;
 #[cfg(feature = "statsd")]
 use spk_solve::{get_metrics_client, SPK_RUN_TIME_METRIC};
 use spk_workspace::FindPackageTemplateResult;
@@ -257,10 +258,11 @@ pub struct Solver {
 }
 
 impl Solver {
-    pub async fn get_solver(&self, options: &Options) -> Result<solve::Solver> {
+    pub async fn get_solver(&self, options: &Options) -> Result<impl AbstractSolver> {
         let option_map = options.get_options()?;
 
-        let mut solver = solve::Solver::default();
+        //let mut solver = solve::Solver::default();
+        let mut solver = solve::cdcl_solver::Solver::default();
         solver.update_options(option_map);
 
         for (name, repo) in self.repos.get_repos_for_non_destructive_operation().await? {
diff --git a/crates/spk-cli/group1/src/cmd_bake.rs b/crates/spk-cli/group1/src/cmd_bake.rs
@@ -10,6 +10,7 @@ use spk_cli_common::{current_env, flags, CommandArgs, Run};
 use spk_schema::ident::RequestedBy;
 use spk_schema::Package;
 use spk_solve::solution::{get_spfs_layers_to_packages, LayerPackageAndComponents, PackageSource};
+use spk_solve::AbstractSolver;
 
 #[cfg(test)]
 #[path = "./cmd_bake_test.rs"]
@@ -237,8 +238,13 @@ impl Bake {
             solver.add_request(request)
         }
 
-        let formatter = self.formatter_settings.get_formatter(self.verbose)?;
-        let (solution, _) = formatter.run_and_print_resolve(&solver).await?;
+        let solution = if let Some(solver) = solver.as_any().downcast_ref::<spk_solve::Solver>() {
+            let formatter = self.formatter_settings.get_formatter(self.verbose)?;
+            let (solution, _) = formatter.run_and_print_resolve(&solver).await?;
+            solution
+        } else {
+            solver.solve().await?
+        };
 
         // The solution order is the order things were found during
         // the solve. Need to reverse it to match up with the spfs
diff --git a/crates/spk-cli/group4/src/cmd_view.rs b/crates/spk-cli/group4/src/cmd_view.rs
@@ -34,7 +34,7 @@ use spk_schema::{
     VersionIdent,
 };
 use spk_solve::solution::{get_spfs_layers_to_packages, LayerPackageAndComponents};
-use spk_solve::Recipe;
+use spk_solve::{AbstractSolver, Recipe};
 use spk_storage;
 use strum::{Display, EnumString, IntoEnumIterator, VariantNames};
 
@@ -595,7 +595,7 @@ impl View {
     async fn get_package_versions(
         &self,
         name: &PkgNameBuf,
-        repos: &Vec<std::sync::Arc<spk_solve::RepositoryHandle>>,
+        repos: &[std::sync::Arc<spk_solve::RepositoryHandle>],
     ) -> Result<Vec<Version>> {
         let mut versions = Vec::new();
         for repo in repos {
@@ -637,37 +637,39 @@ impl View {
             _ => bail!("Not a package request: {request:?}"),
         };
 
-        let mut runtime = solver.run();
-
-        let formatter = self.formatter_settings.get_formatter(self.verbose)?;
-
-        let result = formatter.run_and_print_decisions(&mut runtime).await;
-        let solution = match result {
-            Ok((s, _)) => s,
-            Err(err) => {
-                println!("{}", err.to_string().red());
-                match self.verbose {
-                    0 => eprintln!("{}", "try '--verbose' for more info".yellow().dimmed(),),
-                    v if v < 2 => {
-                        eprintln!("{}", "try '-vv' for even more info".yellow().dimmed(),)
-                    }
-                    _v => {
-                        let graph = runtime.graph();
-                        let graph = graph.read().await;
-                        // Iter much?
-                        let mut graph_walk = graph.walk();
-                        let walk_iter = graph_walk.iter().map(Ok);
-                        let mut decision_iter = formatter.formatted_decisions_iter(walk_iter);
-                        let iter = decision_iter.iter();
-                        tokio::pin!(iter);
-                        while let Some(line) = iter.try_next().await? {
-                            println!("{line}");
+        let solution = if let Some(solver) = solver.as_any().downcast_ref::<spk_solve::Solver>() {
+            let mut runtime = solver.run();
+            let formatter = self.formatter_settings.get_formatter(self.verbose)?;
+            let result = formatter.run_and_print_decisions(&mut runtime).await;
+            match result {
+                Ok((s, _)) => s,
+                Err(err) => {
+                    println!("{}", err.to_string().red());
+                    match self.verbose {
+                        0 => eprintln!("{}", "try '--verbose' for more info".yellow().dimmed(),),
+                        v if v < 2 => {
+                            eprintln!("{}", "try '-vv' for even more info".yellow().dimmed(),)
+                        }
+                        _v => {
+                            let graph = runtime.graph();
+                            let graph = graph.read().await;
+                            // Iter much?
+                            let mut graph_walk = graph.walk();
+                            let walk_iter = graph_walk.iter().map(Ok);
+                            let mut decision_iter = formatter.formatted_decisions_iter(walk_iter);
+                            let iter = decision_iter.iter();
+                            tokio::pin!(iter);
+                            while let Some(line) = iter.try_next().await? {
+                                println!("{line}");
+                            }
                         }
                     }
-                }
 
-                return Ok(1);
+                    return Ok(1);
+                }
             }
+        } else {
+            solver.solve().await?
         };
 
         for item in solution.items() {
diff --git a/crates/spk-exec/src/exec_test.rs b/crates/spk-exec/src/exec_test.rs
@@ -9,7 +9,7 @@ use rstest::{fixture, rstest};
 use spk_cmd_build::build_package;
 use spk_schema::foundation::fixtures::*;
 use spk_schema::ident::build_ident;
-use spk_solve::{DecisionFormatterBuilder, Solver};
+use spk_solve::{AbstractSolver, DecisionFormatterBuilder, Solver};
 use spk_solve_macros::request;
 use spk_storage::fixtures::*;
 
diff --git a/crates/spk-solve/src/abstract_solver.rs b/crates/spk-solve/src/abstract_solver.rs
@@ -5,6 +5,7 @@
 use std::sync::Arc;
 
 use enum_dispatch::enum_dispatch;
+use spk_schema::ident::PkgRequest;
 use spk_schema::{OptionMap, Request};
 use spk_solve_solution::Solution;
 use spk_storage::RepositoryHandle;
@@ -19,8 +20,9 @@ pub(crate) enum SolverImpl {
     Cdcl(crate::cdcl_solver::Solver),
 }
 
+#[async_trait::async_trait]
 #[enum_dispatch]
-pub(crate) trait AbstractSolver {
+pub trait AbstractSolver {
     /// Add a repository where the solver can get packages.
     fn add_repository<R>(&mut self, repo: R)
     where
@@ -29,6 +31,14 @@ pub(crate) trait AbstractSolver {
     /// Add a request to this solver.
     fn add_request(&mut self, request: Request);
 
+    fn as_any(&self) -> &dyn std::any::Any;
+
+    /// Return the PkgRequests added to the solver.
+    fn get_pkg_requests(&self) -> Vec<PkgRequest>;
+
+    /// Return a reference to the solver's list of repositories.
+    fn repositories(&self) -> &[Arc<RepositoryHandle>];
+
     /// Put this solver back into its default state
     fn reset(&mut self);
 
diff --git a/crates/spk-solve/src/cdcl_solver/mod.rs b/crates/spk-solve/src/cdcl_solver/mod.rs
@@ -52,6 +52,7 @@ impl Solver {
     }
 }
 
+#[async_trait::async_trait]
 impl AbstractSolver for Solver {
     fn add_repository<R>(&mut self, repo: R)
     where
@@ -64,6 +65,22 @@ impl AbstractSolver for Solver {
         self.requests.push(request);
     }
 
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn get_pkg_requests(&self) -> Vec<PkgRequest> {
+        self.requests
+            .iter()
+            .filter_map(|r| r.pkg_ref())
+            .cloned()
+            .collect()
+    }
+
+    fn repositories(&self) -> &[Arc<RepositoryHandle>] {
+        &self.repos
+    }
+
     fn reset(&mut self) {
         self.repos.truncate(0);
         self.requests.truncate(0);
diff --git a/crates/spk-solve/src/io.rs b/crates/spk-solve/src/io.rs
diff --git a/crates/spk-solve/src/lib.rs b/crates/spk-solve/src/lib.rs
diff --git a/crates/spk-solve/src/solver.rs b/crates/spk-solve/src/solver.rs
