feat: add conda/outputs backend protocol

Cargo.toml

@@ -69,6 +69,7 @@ pep508_rs = "0.9.2"
 percent-encoding = "2.3.1"
 pin-project-lite = "0.2.16"
 pyproject-toml = "0.13.4"
+rand = { version = "0.9.1", default-features = false }
 regex = "1.11.1"
 reqwest = { version = "0.12.12", default-features = false }
 reqwest-middleware = "0.4"

crates/pixi_build_discovery/src/backend_spec.rs

@@ -1,7 +1,8 @@
 use std::str::FromStr;
 
+use pixi_spec::BinarySpec;
 use pixi_spec_containers::DependencyMap;
-use rattler_conda_types::{Channel, ChannelConfig, ChannelUrl, NamelessMatchSpec};
+use rattler_conda_types::{Channel, ChannelConfig, ChannelUrl};
 use url::Url;
 
 /// Describes how a backend should be instantiated.
@@ -54,21 +55,21 @@ pub struct SystemCommandSpec {
 #[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
 pub struct EnvironmentSpec {
     /// The main requirement
-    pub requirement: (rattler_conda_types::PackageName, NamelessMatchSpec),
+    pub requirement: (rattler_conda_types::PackageName, BinarySpec),
 
     /// The requirements for the environment.
     #[cfg_attr(
         feature = "serde",
         serde(skip_serializing_if = "DependencyMap::is_empty")
     )]
-    pub additional_requirements: DependencyMap<rattler_conda_types::PackageName, NamelessMatchSpec>,
+    pub additional_requirements: DependencyMap<rattler_conda_types::PackageName, BinarySpec>,
 
     /// Additional constraints to apply to the environment
     #[cfg_attr(
         feature = "serde",
         serde(skip_serializing_if = "DependencyMap::is_empty")
     )]
-    pub constraints: DependencyMap<rattler_conda_types::PackageName, NamelessMatchSpec>,
+    pub constraints: DependencyMap<rattler_conda_types::PackageName, BinarySpec>,
 
     /// The channels to use for solving
     pub channels: Vec<ChannelUrl>,
@@ -92,10 +93,7 @@ impl JsonRpcBackendSpec {
         Self {
             name: DEFAULT_BUILD_TOOL.to_string(),
             command: CommandSpec::EnvironmentSpec(Box::new(EnvironmentSpec {
-                requirement: (
-                    DEFAULT_BUILD_TOOL.parse().unwrap(),
-                    NamelessMatchSpec::default(),
-                ),
+                requirement: (DEFAULT_BUILD_TOOL.parse().unwrap(), BinarySpec::any()),
                 additional_requirements: Default::default(),
                 constraints: Default::default(),
                 channels: vec![conda_forge_channel, backends_channel],

crates/pixi_build_discovery/src/discovery.rs

@@ -193,21 +193,12 @@ impl DiscoveredBackend {
         let build_system = package_manifest.build.clone();
         let requirement = (
             build_system.backend.name.clone(),
-            build_system
-                .backend
-                .spec
-                .clone()
-                .try_into_nameless_match_spec(channel_config)?,
+            build_system.backend.spec.clone(),
         );
         let additional_requirements = build_system
             .additional_dependencies
             .iter()
-            .map(|(name, spec)| {
-                Ok((
-                    name.clone(),
-                    spec.clone().try_into_nameless_match_spec(channel_config)?,
-                ))
-            })
+            .map(|(name, spec)| Ok((name.clone(), spec.clone())))
             .collect::<Result<_, SpecConversionError>>()?;
 
         // Figure out the channels to use

crates/pixi_build_discovery/tests/snapshots/discovery__direct_recipe.snap

@@ -9,7 +9,7 @@ backend-spec:
     type: environment-spec
     requirement:
       - pixi-build-rattler-build
-      - {}
+      - "*"
     channels:
       - "https://conda.anaconda.org/conda-forge"
       - "https://prefix.dev/pixi-build-backends"

crates/pixi_build_discovery/tests/snapshots/discovery__discovery@nested_recipe_yml.snap

@@ -10,7 +10,7 @@ backend-spec:
     type: environment-spec
     requirement:
       - pixi-build-rattler-build
-      - {}
+      - "*"
     channels:
       - "https://conda.anaconda.org/conda-forge"
       - "https://prefix.dev/pixi-build-backends"

crates/pixi_build_discovery/tests/snapshots/discovery__discovery@recipe_yaml.snap

@@ -10,7 +10,7 @@ backend-spec:
     type: environment-spec
     requirement:
       - pixi-build-rattler-build
-      - {}
+      - "*"
     channels:
       - "https://conda.anaconda.org/conda-forge"
       - "https://prefix.dev/pixi-build-backends"

crates/pixi_build_discovery/tests/snapshots/discovery__discovery@recipe_yml.snap

@@ -10,7 +10,7 @@ backend-spec:
     type: environment-spec
     requirement:
       - pixi-build-rattler-build
-      - {}
+      - "*"
     channels:
       - "https://conda.anaconda.org/conda-forge"
       - "https://prefix.dev/pixi-build-backends"

crates/pixi_build_frontend/src/backend/json_rpc.rs

@@ -3,6 +3,13 @@ use std::{
     sync::Arc,
 };
 
+use super::stderr::{stderr_buffer, stream_stderr};
+use crate::{
+    backend::BackendOutputStream,
+    error::BackendError,
+    jsonrpc::{RpcParams, stdio_transport},
+    tool::Tool,
+};
 use jsonrpsee::{
     async_client::{Client, ClientBuilder},
     core::{
@@ -12,8 +19,9 @@ use jsonrpsee::{
     types::ErrorCode,
 };
 use miette::Diagnostic;
+use pixi_build_types::procedures::conda_outputs::{CondaOutputsParams, CondaOutputsResult};
 use pixi_build_types::{
-    FrontendCapabilities, ProjectModelV1, VersionedProjectModel, procedures,
+    BackendCapabilities, FrontendCapabilities, ProjectModelV1, VersionedProjectModel, procedures,
     procedures::{
         conda_build::{CondaBuildParams, CondaBuildResult},
         conda_metadata::{CondaMetadataParams, CondaMetadataResult},
@@ -28,14 +36,6 @@ use tokio::{
     sync::{Mutex, oneshot},
 };
 
-use super::stderr::{stderr_buffer, stream_stderr};
-use crate::{
-    backend::BackendOutputStream,
-    error::BackendError,
-    jsonrpc::{RpcParams, stdio_transport},
-    tool::Tool,
-};
-
 #[derive(Debug, Error, Diagnostic)]
 pub enum BuildBackendSetupError {
     #[error("an unexpected io error occurred while communicating with the pixi build backend")]
@@ -120,6 +120,8 @@ impl CommunicationError {
 pub struct JsonRpcBackend {
     /// The identifier of the backend.
     backend_identifier: String,
+    /// The capabilities of the backend.
+    backend_capabilities: BackendCapabilities,
     /// The JSON-RPC client to communicate with the backend.
     client: Client,
     /// The path to the manifest that is passed to the backend.
@@ -209,7 +211,7 @@ impl JsonRpcBackend {
             .build_with_tokio(sender, receiver);
 
         // Negotiate the capabilities with the backend.
-        let _negotiate_result: NegotiateCapabilitiesResult = client
+        let negotiate_result: NegotiateCapabilitiesResult = client
             .request(
                 procedures::negotiate_capabilities::METHOD_NAME,
                 RpcParams::from(NegotiateCapabilitiesParams {
@@ -253,6 +255,7 @@ impl JsonRpcBackend {
         Ok(Self {
             client,
             backend_identifier,
+            backend_capabilities: negotiate_result.capabilities,
             manifest_path,
             stderr: stderr.map(Mutex::new).map(Arc::new),
         })
@@ -360,8 +363,64 @@ impl JsonRpcBackend {
         })
     }
 
+    /// Call the `conda/outputs` method on the backend.
+    pub async fn conda_outputs(
+        &self,
+        request: CondaOutputsParams,
+    ) -> Result<CondaOutputsResult, CommunicationError> {
+        // Capture all of stderr and discard it
+        let stderr = self.stderr.as_ref().map(|stderr| {
+            // Cancellation signal
+            let (cancel_tx, cancel_rx) = oneshot::channel();
+            // Spawn the stderr forwarding task
+            let handle = tokio::spawn(stderr_buffer(stderr.clone(), cancel_rx));
+            (cancel_tx, handle)
+        });
+
+        let result = self
+            .client
+            .request(
+                procedures::conda_outputs::METHOD_NAME,
+                RpcParams::from(request),
+            )
+            .await;
+
+        // Wait for the stderr sink to finish, by signaling it to stop
+        let backend_output = if let Some((cancel_tx, handle)) = stderr {
+            // Cancel the stderr forwarding. Ignore any error because that means the
+            // tasks also finished.
+            let _err = cancel_tx.send(());
+            let lines = handle.await.map_or_else(
+                |e| match e.try_into_panic() {
+                    Ok(panic) => std::panic::resume_unwind(panic),
+                    Err(_) => Err(CommunicationError::StdErrPipeStopped),
+                },
+                |e| e.map_err(|_| CommunicationError::StdErrPipeStopped),
+            )?;
+
+            Some(lines)
+        } else {
+            None
+        };
+
+        result.map_err(|err| {
+            CommunicationError::from_client_error(
+                self.backend_identifier.clone(),
+                err,
+                procedures::conda_metadata::METHOD_NAME,
+                self.manifest_path.parent().unwrap_or(&self.manifest_path),
+                backend_output,
+            )
+        })
+    }
+
     /// Returns the backend identifier.
     pub fn identifier(&self) -> &str {
         &self.backend_identifier
     }
+
+    /// Returns the advertised capabilities of the backend.
+    pub fn capabilities(&self) -> &BackendCapabilities {
+        &self.backend_capabilities
+    }
 }

crates/pixi_build_frontend/src/backend/mod.rs

@@ -1,31 +1,60 @@
-use pixi_build_types::procedures::{
-    conda_build::{CondaBuildParams, CondaBuildResult},
-    conda_metadata::{CondaMetadataParams, CondaMetadataResult},
+use pixi_build_types::{
+    BackendCapabilities, PixiBuildApiVersion,
+    procedures::{
+        conda_build::{CondaBuildParams, CondaBuildResult},
+        conda_metadata::{CondaMetadataParams, CondaMetadataResult},
+        conda_outputs::{CondaOutputsParams, CondaOutputsResult},
+    },
 };
+
 mod stderr;
 
 use crate::json_rpc::CommunicationError;
 
 pub mod json_rpc;
 
-pub enum Backend {
+pub struct Backend {
+    /// The backend that is used to communicate with the build server.
+    inner: BackendImplementation,
+
+    /// The API version that the backend supports.
+    pub api_version: PixiBuildApiVersion,
+}
+
+pub enum BackendImplementation {
     /// The backend is a JSON-RPC backend.
     JsonRpc(json_rpc::JsonRpcBackend),
 }
 
+impl From<json_rpc::JsonRpcBackend> for BackendImplementation {
+    fn from(json_rpc: json_rpc::JsonRpcBackend) -> Self {
+        BackendImplementation::JsonRpc(json_rpc)
+    }
+}
+
 impl Backend {
+    pub fn new(inner: BackendImplementation, api_version: PixiBuildApiVersion) -> Self {
+        Self { inner, api_version }
+    }
+
     pub fn identifier(&self) -> String {
-        match self {
-            Backend::JsonRpc(json_rpc) => json_rpc.identifier().to_string(),
+        match &self.inner {
+            BackendImplementation::JsonRpc(json_rpc) => json_rpc.identifier().to_string(),
+        }
+    }
+
+    pub fn capabilities(&self) -> &BackendCapabilities {
+        match &self.inner {
+            BackendImplementation::JsonRpc(json_rpc) => json_rpc.capabilities(),
         }
     }
 
     pub async fn conda_get_metadata(
         &self,
         params: CondaMetadataParams,
     ) -> Result<CondaMetadataResult, CommunicationError> {
-        match self {
-            Backend::JsonRpc(json_rpc) => json_rpc.conda_get_metadata(params).await,
+        match &self.inner {
+            BackendImplementation::JsonRpc(json_rpc) => json_rpc.conda_get_metadata(params).await,
         }
     }
 
@@ -34,8 +63,24 @@ impl Backend {
         params: CondaBuildParams,
         output_stream: W,
     ) -> Result<CondaBuildResult, CommunicationError> {
-        match self {
-            Backend::JsonRpc(json_rpc) => json_rpc.conda_build(params, output_stream).await,
+        match &self.inner {
+            BackendImplementation::JsonRpc(json_rpc) => {
+                json_rpc.conda_build(params, output_stream).await
+            }
+        }
+    }
+
+    /// Returns the outputs that this backend can produce.
+    pub async fn conda_outputs(
+        &self,
+        params: CondaOutputsParams,
+    ) -> Result<CondaOutputsResult, CommunicationError> {
+        assert!(
+            self.api_version.supports_conda_outputs(),
+            "This backend does not support the conda outputs procedure"
+        );
+        match &self.inner {
+            BackendImplementation::JsonRpc(json_rpc) => json_rpc.conda_outputs(params).await,
         }
     }
 }