use a default backend when recipe.yaml is discovered

Author: wolfv

crates/pixi_build_frontend/src/protocol.rs

@@ -34,6 +34,7 @@ pub enum DiscoveryError {
     NotADirectory,
     #[error("failed to discover a valid project manifest, the source path '{}' could not be found", .0.display())]
     NotFound(PathBuf),
+
     #[error("unable to discover communication protocol, the source directory does not contain a supported manifest")]
     #[diagnostic(help(
         "Ensure that the source directory contains a valid pixi.toml or meta.yaml file."

crates/pixi_build_frontend/src/protocols/builders/rattler_build.rs

@@ -4,7 +4,7 @@ use miette::Diagnostic;
 use pixi_manifest::Manifest;
 
 // pub use protocol::Protocol;
-use rattler_conda_types::ChannelConfig;
+use rattler_conda_types::{ChannelConfig, MatchSpec};
 use thiserror::Error;
 
 use super::pixi::{self, ProtocolBuildError as PixiProtocolBuildError};
@@ -19,9 +19,11 @@ use crate::{
 pub enum FinishError {
     #[error(transparent)]
     Tool(#[from] ToolCacheError),
+
     #[error(transparent)]
     #[diagnostic(transparent)]
     Init(#[from] InitializeError),
+
     #[error("failed to setup a build backend, the project manifest at {0} does not contain a [build] section")]
     NoBuildSection(PathBuf),
 }
@@ -45,7 +47,7 @@ pub struct ProtocolBuilder {
     recipe_dir: PathBuf,
 
     /// The path to the manifest file.
-    manifest_path: PathBuf,
+    manifest_path: Option<PathBuf>,
 
     /// The backend tool to install.
     backend_spec: Option<ToolSpec>,
@@ -63,25 +65,27 @@ impl ProtocolBuilder {
         // first we need to discover that pixi protocol also can be built.
         // it is used to get the manifest
 
-        // Ignore the error if we cannot find the pixi protocol.
-        let pixi_protocol = match pixi::ProtocolBuilder::discover(source_dir) {
-            Ok(inner_value) => inner_value,
-            Err(_) => return Ok(None), // Handle the case where the Option is None
-        };
+        // // Ignore the error if we cannot find the pixi protocol.
+        // let pixi_protocol = match pixi::ProtocolBuilder::discover(source_dir) {
+        //     Ok(inner_value) => inner_value,
+        //     Err(_) => return Ok(None), // Handle the case where the Option is None
+        // };
 
-        // we cannot find pixi protocol, so we cannot build rattler-build protocol.
-        let manifest = if let Some(pixi_protocol) = pixi_protocol {
-            pixi_protocol.manifest().clone()
-        } else {
-            return Ok(None);
-        };
+        // // we cannot find pixi protocol, so we cannot build rattler-build protocol.
+        // let manifest = if let Some(pixi_protocol) = pixi_protocol {
+        //     pixi_protocol.manifest().clone()
+        // } else {
+        //     return Ok(None);
+        // };
+
+        let manifest = None;
 
         let recipe_dir = source_dir.join("recipe");
 
         let protocol = if source_dir.join("recipe.yaml").is_file() {
-            Self::new(source_dir, source_dir, &manifest)
+            Self::new(source_dir, source_dir, manifest)
         } else if recipe_dir.join("recipe.yaml").is_file() {
-            Self::new(source_dir, &recipe_dir, &manifest)
+            Self::new(source_dir, &recipe_dir, manifest)
         } else {
             return Ok(None);
         };
@@ -90,15 +94,19 @@ impl ProtocolBuilder {
     }
 
     /// Constructs a new instance from a manifest.
-    pub fn new(source_dir: &Path, recipe_dir: &Path, manifest: &Manifest) -> Self {
-        let backend_spec = manifest
-            .build_section()
-            .map(IsolatedToolSpec::from_build_section);
+    pub fn new(source_dir: &Path, recipe_dir: &Path, manifest: Option<Manifest>) -> Self {
+        let backend_spec = if let Some(manifest) = &manifest {
+            manifest
+                .build_section()
+                .map(IsolatedToolSpec::from_build_section)
+        } else {
+            None
+        };
 
         Self {
             source_dir: source_dir.to_path_buf(),
             recipe_dir: recipe_dir.to_path_buf(),
-            manifest_path: manifest.path.clone(),
+            manifest_path: manifest.map(|m| m.path.clone()),
             backend_spec: backend_spec.map(Into::into),
             _channel_config: ChannelConfig::default_with_root_dir(PathBuf::new()),
             cache_dir: None,
@@ -134,15 +142,27 @@ impl ProtocolBuilder {
         tool: &ToolCache,
         build_id: usize,
     ) -> Result<JsonRPCBuildProtocol, FinishError> {
-        let tool_spec = self
-            .backend_spec
-            .ok_or(FinishError::NoBuildSection(self.manifest_path.clone()))?;
+        let tool_spec = self.backend_spec.unwrap_or_else(|| {
+            ToolSpec::Isolated(IsolatedToolSpec::from_specs(["pixi-build-rattler-build"
+                .parse()
+                .unwrap()]).with_command("pixi-build-rattler-build"))
+        });
 
         let tool = tool
             .instantiate(tool_spec)
             .await
             .map_err(FinishError::Tool)?;
 
+        tracing::warn!("Tool instantiated .... {:?}", tool);
+
+        tracing::warn!("Cache dir / build id: {:?} / {:?}", self.cache_dir, build_id);
+        if let Some(cache_dir) = self.cache_dir.as_ref() {
+            let _ = std::fs::create_dir_all(cache_dir).map_err(|e| {
+                tracing::warn!("Failed to create cache dir: {:?}", e);
+                e
+            });
+        }
+
         Ok(JsonRPCBuildProtocol::setup(
             self.source_dir,
             self.recipe_dir.join("recipe.yaml"),