|
| 1 | +use std::{collections::HashMap, ffi::OsString, path::Path}; |
| 2 | + |
| 3 | +use miette::{IntoDiagnostic, NamedSource, Report}; |
| 4 | +use pixi_conda_script::{ |
| 5 | + CondaScriptManifest, |
| 6 | + shell::{ShellContext, execute_sequence, parse_sequence}, |
| 7 | +}; |
| 8 | +use pixi_core::{ |
| 9 | + Workspace, |
| 10 | + environment::sanity_check_workspace, |
| 11 | + lock_file::{ReinstallPackages, UpdateLockFileOptions, UpdateMode}, |
| 12 | + workspace::virtual_packages::{ |
| 13 | + EnvironmentRunnability, classify_environment_runnability, |
| 14 | + verify_current_platform_can_run_environment, verify_run_platform, |
| 15 | + }, |
| 16 | +}; |
| 17 | +use pixi_manifest::WithWarnings; |
| 18 | +use pixi_task::get_task_env; |
| 19 | +use tracing::Level; |
| 20 | + |
| 21 | +use crate::{process_exit, run::Args, shared::install_platform::resolve_install_platform}; |
| 22 | + |
| 23 | +/// Reads the `conda-script` block of a local `--script` file. |
| 24 | +/// |
| 25 | +/// Returns `Ok(None)` when the file has no block, so the caller falls back to |
| 26 | +/// the PEP 723 path. |
| 27 | +pub(crate) fn detect(path: &Path) -> miette::Result<Option<CondaScriptManifest>> { |
| 28 | + CondaScriptManifest::from_path(path).map_err(Report::new) |
| 29 | +} |
| 30 | + |
| 31 | +/// Solves and installs the environment of a `conda-script` file, then runs |
| 32 | +/// its entrypoint through the mini-shell with the CLI arguments appended. |
| 33 | +pub(crate) async fn execute_run( |
| 34 | + manifest: CondaScriptManifest, |
| 35 | + args: Args, |
| 36 | + config: pixi_config::Config, |
| 37 | +) -> miette::Result<()> { |
| 38 | + let script_path = manifest.path().to_owned(); |
| 39 | + let entrypoint = manifest.metadata().entrypoint.clone(); |
| 40 | + |
| 41 | + let WithWarnings { |
| 42 | + value: workspace, |
| 43 | + warnings, |
| 44 | + } = Workspace::from_conda_script(manifest, config)?; |
| 45 | + for warning in warnings { |
| 46 | + tracing::warn!("{warning}"); |
| 47 | + } |
| 48 | + sanity_check_workspace(&workspace).await?; |
| 49 | + |
| 50 | + let environment = workspace.default_environment(); |
| 51 | + let allow_installs = args.lock_and_install_config.allow_installs(); |
| 52 | + let user_platform = resolve_install_platform(&workspace, args.platform.as_ref())?; |
| 53 | + let run_platform = user_platform |
| 54 | + .clone() |
| 55 | + .or_else(|| environment.installed_resolved_platform_name()); |
| 56 | + let best_declared_platform = environment.named_or_best_declared_platform(run_platform.as_ref()); |
| 57 | + if allow_installs |
| 58 | + && best_declared_platform.is_none() |
| 59 | + && let Some(name) = user_platform.as_ref() |
| 60 | + { |
| 61 | + return Err(miette::miette!( |
| 62 | + "platform '{}' is not part of environment '{}'", |
| 63 | + name, |
| 64 | + environment.name(), |
| 65 | + )); |
| 66 | + } |
| 67 | + if allow_installs { |
| 68 | + environment.emit_emulation_warning(); |
| 69 | + } |
| 70 | + |
| 71 | + // Select and parse the entrypoint before solving, so a syntax error or a |
| 72 | + // missing platform key surfaces without waiting for the environment. |
| 73 | + let activation_platform = best_declared_platform |
| 74 | + .cloned() |
| 75 | + .unwrap_or_else(|| environment.activation_platform()); |
| 76 | + let subdir = activation_platform.subdir(); |
| 77 | + let Some(command) = entrypoint.select(subdir) else { |
| 78 | + return Err(miette::miette!( |
| 79 | + help = "add a matching key to the `entrypoint` table, for example `unix`, `win` or the exact platform", |
| 80 | + "the entrypoint has no command for platform '{subdir}'" |
| 81 | + )); |
| 82 | + }; |
| 83 | + let sequence = parse_sequence(command).map_err(|error| { |
| 84 | + Report::new(error).with_source_code(NamedSource::new("entrypoint", command.to_owned())) |
| 85 | + })?; |
| 86 | + |
| 87 | + let progress = pixi_reporters::TopLevelProgress::from_global(); |
| 88 | + let mut lock_file = workspace |
| 89 | + .resolve_lock_file( |
| 90 | + Some(progress.clone()), |
| 91 | + UpdateLockFileOptions { |
| 92 | + lock_file_usage: args.lock_and_install_config.lock_file_usage()?, |
| 93 | + no_install: args.lock_and_install_config.no_install(), |
| 94 | + max_concurrent_solves: workspace.config().max_concurrent_solves(), |
| 95 | + ..Default::default() |
| 96 | + }, |
| 97 | + ) |
| 98 | + .await? |
| 99 | + .0; |
| 100 | + lock_file.target_platform = user_platform.clone(); |
| 101 | + |
| 102 | + if allow_installs && user_platform.is_none() { |
| 103 | + let runnability = |
| 104 | + classify_environment_runnability(&environment, Some(lock_file.as_lock_file())); |
| 105 | + if runnability == EnvironmentRunnability::Unsupported { |
| 106 | + return Err( |
| 107 | + match verify_current_platform_can_run_environment( |
| 108 | + &environment, |
| 109 | + Some(lock_file.as_lock_file()), |
| 110 | + ) { |
| 111 | + Err(err) => err.into(), |
| 112 | + Ok(()) => environment.unsupported_platform_error().into(), |
| 113 | + }, |
| 114 | + ); |
| 115 | + } |
| 116 | + } |
| 117 | + |
| 118 | + if allow_installs { |
| 119 | + lock_file |
| 120 | + .prefix( |
| 121 | + &environment, |
| 122 | + UpdateMode::QuickValidate, |
| 123 | + &ReinstallPackages::default(), |
| 124 | + &pixi_core::environment::InstallFilter::default(), |
| 125 | + ) |
| 126 | + .await?; |
| 127 | + verify_run_platform(&environment, user_platform.as_ref())?; |
| 128 | + } |
| 129 | + progress.on_clear(); |
| 130 | + lock_file.command_dispatcher.clear_filesystem_caches().await; |
| 131 | + |
| 132 | + let command_env = get_task_env( |
| 133 | + &environment, |
| 134 | + &activation_platform, |
| 135 | + args.clean_env, |
| 136 | + Some(lock_file.as_lock_file()), |
| 137 | + workspace.config().force_activate(), |
| 138 | + workspace.config().experimental_activation_cache_usage(), |
| 139 | + ) |
| 140 | + .await?; |
| 141 | + |
| 142 | + if args.dry_run { |
| 143 | + pixi_progress::println!( |
| 144 | + "{}{}\n\n", |
| 145 | + console::Emoji("🌵 ", ""), |
| 146 | + console::style("Dry-run mode enabled - no tasks will be executed.") |
| 147 | + .yellow() |
| 148 | + .bold() |
| 149 | + ); |
| 150 | + } |
| 151 | + |
| 152 | + if tracing::enabled!(Level::WARN) { |
| 153 | + let file_name = script_path |
| 154 | + .file_name() |
| 155 | + .expect("an absolute script path always has a file name") |
| 156 | + .to_string_lossy(); |
| 157 | + pixi_progress::println!( |
| 158 | + "{}{}{}{}{}", |
| 159 | + console::Emoji("✨ ", ""), |
| 160 | + console::style("Pixi script (").bold(), |
| 161 | + console::style(file_name).green().bold(), |
| 162 | + console::style("): ").bold(), |
| 163 | + command, |
| 164 | + ); |
| 165 | + } |
| 166 | + |
| 167 | + if args.dry_run { |
| 168 | + return Ok(()); |
| 169 | + } |
| 170 | + |
| 171 | + let cache_dir = workspace.pixi_dir().join("cache"); |
| 172 | + fs_err::create_dir_all(&cache_dir).into_diagnostic()?; |
| 173 | + let script = script_path |
| 174 | + .into_os_string() |
| 175 | + .into_string() |
| 176 | + .map_err(|_| miette::miette!("the script path must contain only valid UTF-8 characters"))?; |
| 177 | + let cache = cache_dir |
| 178 | + .into_os_string() |
| 179 | + .into_string() |
| 180 | + .map_err(|_| miette::miette!("the cache path must contain only valid UTF-8 characters"))?; |
| 181 | + |
| 182 | + let context = ShellContext { |
| 183 | + variables: HashMap::from([("SCRIPT".to_owned(), script), ("CACHE".to_owned(), cache)]), |
| 184 | + env: command_env |
| 185 | + .into_iter() |
| 186 | + .map(|(key, value)| (OsString::from(key), OsString::from(value))) |
| 187 | + .collect(), |
| 188 | + cwd: std::env::current_dir().into_diagnostic()?, |
| 189 | + }; |
| 190 | + let code = execute_sequence(&sequence, &args.task, &context) |
| 191 | + .await |
| 192 | + .map_err(Report::new)?; |
| 193 | + if code != 0 { |
| 194 | + process_exit::exit_with_code(code); |
| 195 | + } |
| 196 | + Ok(()) |
| 197 | +} |
0 commit comments