add proxy-config, activate https/http proxy for pixi commands

Author: gzm55

crates/pixi_config/src/lib.rs

@@ -646,6 +646,11 @@ pub struct Config {
     #[serde(skip_serializing_if = "ConcurrencyConfig::is_default")]
     pub concurrency: ConcurrencyConfig,
 
+    /// Https/Http proxy configuration for pixi
+    #[serde(default)]
+    #[serde(skip_serializing_if = "ProxyConfig::is_default")]
+    pub proxy_config: ProxyConfig,
+
     //////////////////////
     // Deprecated fields //
     //////////////////////
@@ -676,6 +681,7 @@ impl Default for Config {
             shell: ShellConfig::default(),
             experimental: ExperimentalConfig::default(),
             concurrency: ConcurrencyConfig::default(),
+            proxy_config: ProxyConfig::default(),
 
             // Deprecated fields
             change_ps1: None,
@@ -778,6 +784,40 @@ impl ShellConfig {
     }
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize, Default, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct ProxyConfig {
+    /// https proxy.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub https: Option<Url>,
+    /// http proxy.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub http: Option<Url>,
+    /// A list of no proxy pattern
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub no_proxy_domains: Vec<String>,
+}
+
+impl ProxyConfig {
+    pub fn is_default(&self) -> bool {
+        self.https.is_none() && self.https.is_none() && self.no_proxy_domains.is_empty()
+    }
+    pub fn merge(&self, other: Self) -> Self {
+        Self {
+            https: other.https.as_ref().or(self.https.as_ref()).cloned(),
+            http: other.http.as_ref().or(self.http.as_ref()).cloned(),
+            no_proxy_domains: if other.is_default() {
+                self.no_proxy_domains.clone()
+            } else {
+                other.no_proxy_domains.clone()
+            },
+        }
+    }
+}
+
 #[derive(thiserror::Error, Debug)]
 pub enum ConfigError {
     #[error("no file was found at {0}")]
@@ -1042,6 +1082,10 @@ impl Config {
             "s3-options.<bucket>.region",
             "s3-options.<bucket>.force-path-style",
             "experimental.use-environment-activation-cache",
+            "proxy-config",
+            "proxy-config.https",
+            "proxy-config.http",
+            "proxy-config.no-proxy-domains",
         ]
     }
 
@@ -1082,6 +1126,8 @@ impl Config {
             // Make other take precedence over self to allow for setting the value through the CLI
             concurrency: self.concurrency.merge(other.concurrency),
 
+            proxy_config: self.proxy_config.merge(other.proxy_config),
+
             // Deprecated fields that we can ignore as we handle them inside `shell.` field
             change_ps1: None,
             force_activate: None,
@@ -1157,6 +1203,57 @@ impl Config {
         self.concurrency.downloads
     }
 
+    pub fn activate_proxy_envs(&self) {
+        if self.proxy_config.https.is_none() && self.proxy_config.http.is_none() {
+            if !self.proxy_config.no_proxy_domains.is_empty() {
+                tracing::info!("proxy_config.no_proxy_domains is ignored")
+            }
+            return;
+        }
+
+        // detect proxy env vars like curl: https://curl.se/docs/manpage.html
+        let env_https_proxy = ["https_proxy", "HTTPS_PROXY", "all_proxy", "ALL_PROXY"]
+            .iter()
+            .find_map(|&k| std::env::var(k).ok().filter(|v| !v.is_empty()));
+        let env_http_proxy = ["http_proxy", "all_proxy", "ALL_PROXY"]
+            .iter()
+            .find_map(|&k| std::env::var(k).ok().filter(|v| !v.is_empty()));
+        let env_no_proxy = ["no_proxy", "NO_PROXY"]
+            .iter()
+            .find_map(|&k| std::env::var(k).ok().filter(|v| !v.is_empty()));
+
+        let config_no_proxy =
+            Some(self.proxy_config.no_proxy_domains.iter().join(",")).filter(|v| !v.is_empty());
+
+        if env_https_proxy.is_some() || env_http_proxy.is_some() {
+            if env_https_proxy.as_deref() != self.proxy_config.https.as_ref().map(Url::as_str)
+                || env_http_proxy.as_deref() != self.proxy_config.http.as_ref().map(Url::as_str)
+                || env_no_proxy != config_no_proxy
+            {
+                tracing::info!("proxy configs are overridden by proxy environment vars.")
+            }
+            return;
+        }
+
+        if let Some(url) = &self.proxy_config.https {
+            std::env::set_var("https_proxy", url.as_str());
+            tracing::debug!("use https proxy: {}", url.as_str());
+        }
+        if let Some(url) = &self.proxy_config.http {
+            std::env::set_var("http_proxy", url.as_str());
+            tracing::debug!("use http proxy: {}", url.as_str());
+        }
+
+        if config_no_proxy != env_no_proxy {
+            if let Some(no_proxy_str) = &config_no_proxy {
+                std::env::set_var("no_proxy", no_proxy_str);
+                tracing::debug!("no proxy hosts: {}", no_proxy_str);
+            } else {
+                std::env::remove_var("no_proxy");
+            }
+        }
+    }
+
     /// Modify this config with the given key and value
     ///
     /// # Note
@@ -1421,6 +1518,42 @@ impl Config {
                     _ => return Err(err),
                 }
             }
+            key if key.starts_with("proxy-config") => {
+                if key == "proxy-config" {
+                    if let Some(value) = value {
+                        self.proxy_config = serde_json::de::from_str(&value).into_diagnostic()?;
+                    } else {
+                        self.proxy_config = ProxyConfig::default();
+                    }
+                    return Ok(());
+                } else if !key.starts_with("proxy-config.") {
+                    return Err(err);
+                }
+
+                let subkey = key.strip_prefix("proxy-config.").unwrap();
+                match subkey {
+                    "https" => {
+                        self.proxy_config.https = value
+                            .map(|v| Url::parse(&v))
+                            .transpose()
+                            .into_diagnostic()?;
+                    }
+                    "http" => {
+                        self.proxy_config.http = value
+                            .map(|v| Url::parse(&v))
+                            .transpose()
+                            .into_diagnostic()?;
+                    }
+                    "no-proxy-domains" => {
+                        self.proxy_config.no_proxy_domains = value
+                            .map(|v| serde_json::de::from_str(&v))
+                            .transpose()
+                            .into_diagnostic()?
+                            .unwrap_or_default();
+                    }
+                    _ => return Err(err),
+                }
+            }
             _ => return Err(err),
         }
 
@@ -1725,6 +1858,7 @@ UNUSED = "unused"
                     RepodataChannelConfig::default(),
                 )]),
             },
+            proxy_config: ProxyConfig::default(),
             // Deprecated keys
             change_ps1: None,
             force_activate: None,
@@ -2145,4 +2279,25 @@ UNUSED = "unused"
         assert_eq!(anaconda_config.disable_zstd, Some(false));
         assert_eq!(anaconda_config.disable_sharded, None);
     }
+
+    #[test]
+    fn test_proxy_config_parse() {
+        let toml = r#"
+            [proxy-config]
+            https = "http://proxy-for-https"
+            http = "http://proxy-for-http"
+            no-proxy-domains = [ "a.com" ]
+        "#;
+        let (config, _) = Config::from_toml(toml, None).unwrap();
+        assert_eq!(
+            config.proxy_config.https,
+            Some(Url::parse("http://proxy-for-https").unwrap())
+        );
+        assert_eq!(
+            config.proxy_config.http,
+            Some(Url::parse("http://proxy-for-http").unwrap())
+        );
+        assert_eq!(config.proxy_config.no_proxy_domains.len(), 1);
+        assert_eq!(config.proxy_config.no_proxy_domains[0], "a.com");
+    }
 }

crates/pixi_config/src/snapshots/pixi_config__tests__config_merge_multiple.snap

@@ -133,6 +133,11 @@ Config {
         solves: 1,
         downloads: 50,
     },
+    proxy_config: ProxyConfig {
+        https: None,
+        http: None,
+        no_proxy_domains: [],
+    },
     change_ps1: None,
     force_activate: None,
 }

src/cli/add.rs

@@ -99,6 +99,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .locate()?
         .with_cli_config(prefix_update_config.config.clone());
 
+    workspace.activate_proxy_envs();
+
     sanity_check_project(&workspace).await?;
 
     let mut workspace = workspace.modify()?;

src/cli/build.rs

@@ -89,6 +89,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .locate()?
         .with_cli_config(args.config_cli);
 
+    workspace.activate_proxy_envs();
+
     // TODO: Implement logic to take the source code from a VCS instead of from a
     // local channel so that that information is also encoded in the manifest.
 

src/cli/exec.rs

@@ -54,6 +54,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
     let config = Config::with_cli_config(&args.config);
     let cache_dir = pixi_config::get_cache_dir().context("failed to determine cache directory")?;
 
+    config.activate_proxy_envs();
+
     let mut command_args = args.command.iter();
     let command = command_args.next().ok_or_else(|| miette::miette!(help ="i.e when specifying specs explicitly use a command at the end: `pixi exec -s python==3.12 python`", "missing required command to execute",))?;
     let (_, client) = build_reqwest_clients(Some(&config), None)?;

src/cli/global/expose.rs

@@ -76,6 +76,8 @@ pub async fn add(args: AddArgs) -> miette::Result<()> {
         .await?
         .with_cli_config(config.clone());
 
+    project_original.activate_proxy_envs();
+
     async fn apply_changes(
         args: &AddArgs,
         project: &mut global::Project,

src/cli/global/install.rs

@@ -86,6 +86,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .await?
         .with_cli_config(config.clone());
 
+    project_original.activate_proxy_envs();
+
     let env_names = match &args.environment {
         Some(env_name) => Vec::from([env_name.clone()]),
         None => args

src/cli/global/remove.rs

@@ -47,6 +47,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         miette::bail!("Environment {} doesn't exist. You can create a new environment with `pixi global install`.", env_name);
     }
 
+    project_original.activate_proxy_envs();
+
     async fn apply_changes(
         env_name: &EnvironmentName,
         specs: &[MatchSpec],

src/cli/global/sync.rs

@@ -17,6 +17,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .await?
         .with_cli_config(config.clone());
 
+    project.activate_proxy_envs();
+
     let mut has_changed = false;
 
     // Prune environments that are not listed

src/cli/global/update.rs

@@ -23,6 +23,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .await?
         .with_cli_config(config.clone());
 
+    project_original.activate_proxy_envs();
+
     async fn apply_changes(
         env_name: &EnvironmentName,
         project: &mut Project,

src/cli/install.rs

@@ -47,6 +47,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .locate()?
         .with_cli_config(args.config);
 
+    workspace.activate_proxy_envs();
+
     // Install either:
     //
     // 1. specific environments

src/cli/lock.rs

@@ -26,6 +26,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .with_search_start(args.workspace_config.workspace_locator_start())
         .locate()?;
 
+    workspace.activate_proxy_envs();
+
     // Save the original lockfile to compare with the new one.
     let original_lock_file = workspace.load_lock_file().await?;
     let new_lock_file = workspace

src/cli/mod.rs

@@ -2,6 +2,7 @@ use clap::Parser;
 use clap_verbosity_flag::Verbosity;
 use indicatif::ProgressDrawTarget;
 use miette::IntoDiagnostic;
+use pixi_config::Config;
 use pixi_consts::consts;
 use pixi_progress::global_multi_progress;
 use pixi_utils::indicatif::IndicatifWriter;
@@ -249,7 +250,10 @@ pub async fn execute_command(command: Command) -> miette::Result<()> {
         Command::Clean(cmd) => clean::execute(cmd).await,
         Command::Run(cmd) => run::execute(cmd).await,
         Command::Global(cmd) => global::execute(cmd).await,
-        Command::Auth(cmd) => rattler::cli::auth::execute(cmd).await.into_diagnostic(),
+        Command::Auth(cmd) => {
+            Config::load_global().activate_proxy_envs();
+            rattler::cli::auth::execute(cmd).await.into_diagnostic()
+        }
         Command::Install(cmd) => install::execute(cmd).await,
         Command::Shell(cmd) => shell::execute(cmd).await,
         Command::ShellHook(cmd) => shell_hook::execute(cmd).await,

src/cli/remove.rs

@@ -108,6 +108,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
     // TODO: update all environments touched by this feature defined.
     // updating prefix after removing from toml
     if !prefix_update_config.no_lockfile_update {
+        workspace.activate_proxy_envs();
+
         get_update_lock_file_and_prefix(
             &workspace.default_environment(),
             UpdateMode::Revalidate,

src/cli/run.rs

@@ -94,6 +94,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .locate()?
         .with_cli_config(cli_config);
 
+    workspace.activate_proxy_envs();
+
     // Extract the passed in environment name.
     let environment = workspace.environment_from_name_or_env_var(args.environment.clone())?;
 

src/cli/search.rs

@@ -147,6 +147,10 @@ pub async fn execute_impl<W: Write>(
 
     let config = Config::load_global();
 
+    project
+        .map_or(&config, |p| p.config())
+        .activate_proxy_envs();
+
     // Fetch the all names from the repodata using gateway
     let gateway = config.gateway(client.clone());
 

src/cli/self_update.rs

@@ -4,6 +4,7 @@ use flate2::read::GzDecoder;
 use tar::Archive;
 
 use miette::IntoDiagnostic;
+use pixi_config::Config;
 use pixi_consts::consts;
 use reqwest::redirect::Policy;
 use reqwest::Client;
@@ -110,6 +111,8 @@ async fn latest_version() -> miette::Result<Version> {
 }
 
 pub async fn execute(args: Args) -> miette::Result<()> {
+    Config::load_global().activate_proxy_envs();
+
     // Get the target version, without 'v' prefix
     let target_version = match &args.version {
         Some(version) => version,

src/cli/shell.rs

@@ -263,6 +263,8 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .locate()?
         .with_cli_config(config);
 
+    workspace.activate_proxy_envs();
+
     let environment = workspace.environment_from_name_or_env_var(args.environment)?;
 
     // Make sure environment is up-to-date, default to install, users can avoid this with frozen or locked.