feat: add solve command and create platform option (#2528)

pavelzw · web-flow · commit 47bde0760501 · 2026-06-25T10:18:59.000+02:00
diff --git a/crates/rattler-bin/src/commands/create.rs b/crates/rattler-bin/src/commands/create.rs
@@ -24,6 +24,7 @@ use rattler_solve::{
     libsolv_c::{self},
     resolvo,
 };
+use rattler_virtual_packages::{VirtualPackageOverrides, VirtualPackages};
 
 use crate::{
     commands::progress::{wrap_in_async_progress, wrap_in_progress},
@@ -47,13 +48,13 @@ pub struct Opt {
     #[clap(required = true)]
     specs: Vec<String>,
 
-    /// Simulute command without installation
+    /// Simulate command without installation
     #[clap(long)]
     dry_run: bool,
 
-    /// Target platform (e.g., linux-64, osx-arm64)
-    #[clap(long)]
-    platform: Option<String>,
+    /// The platform to create the environment for.
+    #[clap(long, default_value_t = Platform::current())]
+    platform: Platform,
 
     #[clap(long)]
     virtual_package: Option<Vec<String>>,
@@ -130,14 +131,9 @@ pub async fn create(opt: Opt) -> miette::Result<()> {
     // Make the target prefix absolute
     let target_prefix = std::path::absolute(opt.target_prefix).into_diagnostic()?;
 
-    // Determine the platform we're going to install for
-    let install_platform = if let Some(platform) = opt.platform {
-        Platform::from_str(&platform).into_diagnostic()?
-    } else {
-        Platform::current()
-    };
+    let install_platform = opt.platform;
 
-    println!("Installing for platform: {install_platform:?}");
+    println!("Installing for platform: {install_platform}");
 
     // Parse the specs from the command line. We do this explicitly instead of allow
     // clap to deal with this because we need to parse the `channel_config` when
@@ -241,15 +237,11 @@ pub async fn create(opt: Opt) -> miette::Result<()> {
                 })
                 .collect::<miette::Result<Vec<_>>>()?)
         } else {
-            rattler_virtual_packages::VirtualPackage::detect(
-                &rattler_virtual_packages::VirtualPackageOverrides::from_env(),
+            VirtualPackages::detect_for_platform(
+                install_platform,
+                &VirtualPackageOverrides::from_env(),
             )
-            .map(|vpkgs| {
-                vpkgs
-                    .iter()
-                    .map(|vpkg| GenericVirtualPackage::from(vpkg.clone()))
-                    .collect::<Vec<_>>()
-            })
+            .map(|vpkgs| vpkgs.into_generic_virtual_packages().collect::<Vec<_>>())
             .into_diagnostic()
         }
     })?;
diff --git a/crates/rattler-bin/src/commands/mod.rs b/crates/rattler-bin/src/commands/mod.rs
@@ -15,4 +15,5 @@ pub mod progress;
 pub mod run;
 pub mod search;
 pub mod shell_hook;
+pub mod solve;
 pub mod virtual_packages;
diff --git a/crates/rattler-bin/src/commands/solve.rs b/crates/rattler-bin/src/commands/solve.rs
@@ -0,0 +1,270 @@
+use std::{
+    collections::HashMap,
+    env,
+    str::FromStr,
+    time::{Duration, Instant},
+};
+
+use clap::ValueEnum;
+use itertools::Itertools;
+use miette::{Context, IntoDiagnostic};
+use rattler::{default_cache_dir, package_cache::PackageCache};
+use rattler_conda_types::{
+    Channel, ChannelConfig, GenericVirtualPackage, MatchSpec, Matches, PackageName,
+    ParseMatchSpecOptions, Platform, RepoDataRecord, Version,
+};
+use rattler_repodata_gateway::{Gateway, RepoData, SourceConfig};
+use rattler_solve::{
+    SolverImpl, SolverTask,
+    libsolv_c::{self},
+    resolvo,
+};
+use rattler_virtual_packages::{VirtualPackageOverrides, VirtualPackages};
+
+use crate::{
+    commands::progress::{wrap_in_async_progress, wrap_in_progress},
+    exclude_newer::ExcludeNewer,
+};
+
+/// Solve a conda environment without installing it.
+///
+/// Resolves the specified package specs for a target platform and prints the
+/// resulting package set.
+#[derive(Debug, clap::Parser)]
+pub struct Opt {
+    /// Channel to search for packages.
+    ///
+    /// Example: -c conda-forge -c main
+    #[clap(short, long = "channel")]
+    channels: Option<Vec<String>>,
+
+    /// Package specs to solve.
+    #[clap(required = true)]
+    specs: Vec<String>,
+
+    /// The platform to solve the environment for.
+    #[clap(long, default_value_t = Platform::current())]
+    platform: Platform,
+
+    /// Virtual packages to use for solving, e.g. __glibc=2.28.
+    #[clap(long)]
+    virtual_package: Option<Vec<String>>,
+
+    /// SAT Solver backend to use.
+    #[clap(long)]
+    solver: Option<Solver>,
+
+    /// Request solver timeout in milliseconds.
+    #[clap(long)]
+    timeout: Option<u64>,
+
+    /// Solver strategy to use.
+    #[clap(long)]
+    strategy: Option<SolveStrategy>,
+
+    /// Only include dependencies of package specs in the output.
+    #[clap(long, group = "deps_mode")]
+    only_deps: bool,
+
+    /// Only include package specifications without dependencies in the output.
+    #[clap(long, group = "deps_mode")]
+    no_deps: bool,
+
+    /// Exclude packages that have been published after the specified timestamp.
+    /// Can be specified as a timestamp (e.g., "2006-12-02T02:07:43Z") or as a date (e.g., "2006-12-02").
+    /// When using a date, packages from the entire day are included.
+    #[clap(long)]
+    exclude_newer: Option<ExcludeNewer>,
+}
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub enum SolveStrategy {
+    /// Resolve the highest compatible version for every package.
+    Highest,
+
+    /// Resolve the lowest compatible version for every package.
+    Lowest,
+
+    /// Resolve the lowest compatible version for direct dependencies but the
+    /// highest compatible for transitive dependencies.
+    LowestDirect,
+}
+
+#[derive(Default, Debug, Clone, Copy, ValueEnum)]
+pub enum Solver {
+    #[default]
+    Resolvo,
+    #[value(name = "libsolv")]
+    LibSolv,
+}
+
+impl From<SolveStrategy> for rattler_solve::SolveStrategy {
+    fn from(value: SolveStrategy) -> Self {
+        match value {
+            SolveStrategy::Highest => rattler_solve::SolveStrategy::Highest,
+            SolveStrategy::Lowest => rattler_solve::SolveStrategy::LowestVersion,
+            SolveStrategy::LowestDirect => rattler_solve::SolveStrategy::LowestVersionDirect,
+        }
+    }
+}
+
+pub async fn solve(opt: Opt) -> miette::Result<()> {
+    let channel_config =
+        ChannelConfig::default_with_root_dir(env::current_dir().into_diagnostic()?);
+
+    println!("Solving for platform: {}", opt.platform);
+
+    let match_spec_options = ParseMatchSpecOptions::strict()
+        .with_extras(true)
+        .with_conditionals(true)
+        .with_flags(true);
+
+    let specs = opt
+        .specs
+        .iter()
+        .map(|spec| MatchSpec::from_str(spec, match_spec_options))
+        .collect::<Result<Vec<_>, _>>()
+        .into_diagnostic()?;
+
+    let cache_dir = default_cache_dir()
+        .map_err(|e| miette::miette!("could not determine default cache directory: {}", e))?;
+    rattler_cache::ensure_cache_dir(&cache_dir)
+        .map_err(|e| miette::miette!("could not create cache directory: {}", e))?;
+
+    let channels = opt
+        .channels
+        .unwrap_or_else(|| vec![String::from("conda-forge")])
+        .into_iter()
+        .map(|channel_str| Channel::from_str(channel_str, &channel_config))
+        .collect::<Result<Vec<_>, _>>()
+        .into_diagnostic()?;
+
+    let download_client = super::client::create_client_with_middleware()?;
+
+    let gateway = Gateway::builder()
+        .with_cache_dir(cache_dir.join(rattler_cache::REPODATA_CACHE_DIR))
+        .with_package_cache(PackageCache::new(
+            cache_dir.join(rattler_cache::PACKAGE_CACHE_DIR),
+        ))
+        .with_client(download_client)
+        .with_channel_config(rattler_repodata_gateway::ChannelConfig {
+            default: SourceConfig {
+                sharded_enabled: true,
+                ..SourceConfig::default()
+            },
+            per_channel: HashMap::new(),
+        })
+        .finish();
+
+    let start_load_repo_data = Instant::now();
+    let repo_data = wrap_in_async_progress(
+        "loading repodata",
+        gateway
+            .query(channels, [opt.platform, Platform::NoArch], specs.clone())
+            .recursive(true),
+    )
+    .await
+    .into_diagnostic()
+    .context("failed to load repodata")?;
+
+    let total_records: usize = repo_data.iter().map(RepoData::len).sum();
+    println!(
+        "Loaded {} records in {:?}",
+        total_records,
+        start_load_repo_data.elapsed()
+    );
+
+    let virtual_packages = wrap_in_progress("determining virtual packages", || {
+        if let Some(virtual_packages) = &opt.virtual_package {
+            parse_virtual_packages(virtual_packages)
+        } else {
+            VirtualPackages::detect_for_platform(opt.platform, &VirtualPackageOverrides::from_env())
+                .map(|vpkgs| vpkgs.into_generic_virtual_packages().collect::<Vec<_>>())
+                .into_diagnostic()
+        }
+    })?;
+
+    println!(
+        "Virtual packages:\n{}\n",
+        virtual_packages
+            .iter()
+            .format_with("\n", |i, f| f(&format_args!("  - {i}",)))
+    );
+
+    let solver_task = SolverTask {
+        virtual_packages,
+        specs: specs.clone(),
+        timeout: opt.timeout.map(Duration::from_millis),
+        strategy: opt.strategy.map_or_else(Default::default, Into::into),
+        exclude_newer: opt.exclude_newer.map(Into::into),
+        ..SolverTask::from_iter(&repo_data)
+    };
+
+    let solver_result = wrap_in_progress("solving", || match opt.solver.unwrap_or_default() {
+        Solver::Resolvo => resolvo::Solver.solve(solver_task),
+        Solver::LibSolv => libsolv_c::Solver.solve(solver_task),
+    })
+    .into_diagnostic()?;
+
+    let mut solved_packages: Vec<RepoDataRecord> = solver_result.records;
+
+    if opt.no_deps {
+        solved_packages.retain(|r| specs.iter().any(|s| s.matches(&r.package_record)));
+    } else if opt.only_deps {
+        solved_packages.retain(|r| !specs.iter().any(|s| s.matches(&r.package_record)));
+    }
+
+    if solved_packages.is_empty() {
+        println!("No packages solved");
+    } else {
+        println!("Solved {} packages:", solved_packages.len());
+        print_records(&solved_packages, solver_result.extras);
+    }
+
+    Ok(())
+}
+
+fn parse_virtual_packages(
+    virtual_packages: &[String],
+) -> miette::Result<Vec<GenericVirtualPackage>> {
+    virtual_packages
+        .iter()
+        .map(|virt_pkg| {
+            let elems = virt_pkg.split('=').collect::<Vec<&str>>();
+            Ok(GenericVirtualPackage {
+                name: elems[0].try_into().into_diagnostic()?,
+                version: elems
+                    .get(1)
+                    .map_or(Version::from_str("0"), |s| Version::from_str(s))
+                    .into_diagnostic()?,
+                build_string: (*elems.get(2).unwrap_or(&"")).to_string(),
+            })
+        })
+        .collect::<miette::Result<Vec<_>>>()
+}
+
+fn print_records(records: &[RepoDataRecord], features: HashMap<PackageName, Vec<String>>) {
+    for record in records {
+        let direct_url_print = record.channel.clone().unwrap_or_default();
+        if let Some(features) = features.get(&record.package_record.name) {
+            println!(
+                "{}[{}] {} {} {} {}",
+                record.package_record.name.as_normalized(),
+                features.join(", "),
+                record.package_record.version,
+                record.package_record.build,
+                record.package_record.subdir,
+                direct_url_print,
+            );
+        } else {
+            println!(
+                "{} {} {} {} {}",
+                record.package_record.name.as_normalized(),
+                record.package_record.version,
+                record.package_record.build,
+                record.package_record.subdir,
+                direct_url_print,
+            );
+        }
+    }
+}
diff --git a/crates/rattler-bin/src/main.rs b/crates/rattler-bin/src/main.rs
@@ -48,6 +48,7 @@ enum Command {
     FetchFile(commands::fetch_file::Opt),
     Inspect(commands::inspect::Opt),
     Search(commands::search::Opt),
+    Solve(commands::solve::Opt),
     ShellHook(commands::shell_hook::Opt),
     VirtualPackages(commands::virtual_packages::Opt),
     InstallMenu(commands::menu::InstallOpt),
@@ -114,6 +115,7 @@ async fn async_main() -> miette::Result<()> {
         Command::FetchFile(opts) => commands::fetch_file::fetch_file(opts).await,
         Command::Inspect(opts) => commands::inspect::inspect(opts).await,
         Command::Search(opts) => commands::search::search(opts).await,
+        Command::Solve(opts) => commands::solve::solve(opts).await,
         Command::List(opts) => commands::list::list(opts).await,
         Command::ShellHook(opts) => commands::shell_hook::shell_hook(opts).await,
         Command::VirtualPackages(opts) => commands::virtual_packages::virtual_packages(opts),
