Revert build config

Author: charliermarsh

Cargo.lock

@@ -2,7 +2,7 @@
 name = "install-wheel-rs"
 version = "0.0.1"
 publish = false
-description = "Takes a wheel and installs it, either in a venv or for monotrail"
+description = "Takes a wheel and installs it."
 keywords = ["wheel", "python"]
 
 edition = { workspace = true }

crates/install-wheel-rs/Cargo.toml

@@ -16,4 +16,6 @@ workspace = true
 fs-err = { workspace = true }
 schemars = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"] }
+thiserror = { workspace = true }
 toml = { workspace = true }
+tracing = { workspace = true }

crates/install-wheel-rs/Readme.md

@@ -1,27 +1,37 @@
-use crate::commit_info::Commit;
+use crate::commit_info::CacheCommit;
 use crate::timestamp::Timestamp;
 
 use serde::Deserialize;
 use std::cmp::max;
 use std::io;
 use std::path::{Path, PathBuf};
+use tracing::debug;
 
+/// The information used to determine whether a built distribution is up-to-date, based on the
+/// timestamps of relevant files, the current commit of a repository, etc.
 #[derive(Default, Debug, Clone, Hash, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
 #[serde(rename_all = "kebab-case")]
 #[serde(try_from = "CacheInfoWire")]
 pub struct CacheInfo {
+    /// The timestamp of the most recent `ctime` of any relevant files, at the time of the build.
+    /// The timestamp will typically be the maximum of the `ctime` values of the `pyproject.toml`,
+    /// `setup.py`, and `setup.cfg` files, if they exist; however, users can provide additional
+    /// files to timestamp via the `cache-keys` field.
     timestamp: Option<Timestamp>,
-    commit: Option<Commit>,
+    /// The commit at which the distribution was built.
+    commit: Option<CacheCommit>,
 }
 
 impl CacheInfo {
+    /// Return the [`CacheInfo`] for a given timestamp.
     pub fn from_timestamp(timestamp: Timestamp) -> Self {
         Self {
             timestamp: Some(timestamp),
             ..Self::default()
         }
     }
 
+    /// Compute the cache info for a given path, which may be a file or a directory.
     pub fn from_path(path: &Path) -> io::Result<Self> {
         let metadata = fs_err::metadata(path)?;
         if metadata.is_file() {
@@ -31,6 +41,7 @@ impl CacheInfo {
         }
     }
 
+    /// Compute the cache info for a given directory.
     pub fn from_directory(directory: &Path) -> io::Result<Self> {
         let mut commit = None;
 
@@ -93,16 +104,21 @@ impl CacheInfo {
                             .map(Timestamp::from_metadata),
                     );
                 }
-                CacheKey::Git { git: true } => {
-                    commit = Commit::from_repository(directory);
-                }
+                CacheKey::Git { git: true } => match CacheCommit::from_repository(directory) {
+                    Ok(commit_info) => commit = Some(commit_info),
+                    Err(err) => {
+                        debug!("Failed to read the current commit: {err}");
+                    }
+                },
                 CacheKey::Git { git: false } => {}
             }
         }
 
         Ok(Self { timestamp, commit })
     }
 
+    /// Compute the cache info for a given file, assumed to be a binary or source distribution
+    /// represented as (e.g.) a `.whl` or `.tar.gz` archive.
     pub fn from_file(path: impl AsRef<Path>) -> Result<Self, io::Error> {
         let metadata = fs_err::metadata(path.as_ref())?;
         let timestamp = Timestamp::from_metadata(&metadata);
@@ -120,13 +136,16 @@ impl CacheInfo {
 #[derive(Debug, serde::Deserialize)]
 struct TimestampCommit {
     timestamp: Option<Timestamp>,
-    commit: Option<Commit>,
+    commit: Option<CacheCommit>,
 }
 
 #[derive(Debug, serde::Deserialize)]
 #[serde(untagged)]
 enum CacheInfoWire {
+    /// For backwards-compatibility, enable deserializing [`CacheInfo`] structs that are solely
+    /// represented by a timestamp.
     Timestamp(Timestamp),
+    /// A [`CacheInfo`] struct that includes both a timestamp and a commit.
     TimestampCommit(TimestampCommit),
 }
 

crates/uv-cache-info/Cargo.toml

@@ -1,35 +1,64 @@
 use std::path::{Path, PathBuf};
 
-/// The current commit for a repository.
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum CacheCommitError {
+    #[error("The repository at {0} is missing a `.git` directory")]
+    MissingGitDir(PathBuf),
+    #[error("The repository at {0} is missing a `HEAD` file")]
+    MissingHead(PathBuf),
+    #[error("The repository at {0} has an invalid reference: `{1}`")]
+    InvalidRef(PathBuf, String),
+    #[error("The discovered commit has an invalid length (expected 40 characters): `{0}`")]
+    WrongLength(String),
+    #[error("The discovered commit has an invalid character (expected hexadecimal): `{0}`")]
+    WrongDigit(String),
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+}
+
+/// The current commit for a repository (i.e., a 40-character hexadecimal string).
 #[derive(Default, Debug, Clone, Hash, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
-pub(crate) struct Commit(String);
+pub(crate) struct CacheCommit(String);
 
-impl Commit {
-    /// Return the [`Commit`] for the repository at the given path.
-    pub(crate) fn from_repository(path: &Path) -> Option<Self> {
+impl CacheCommit {
+    /// Return the [`CacheCommit`] for the repository at the given path.
+    pub(crate) fn from_repository(path: &Path) -> Result<Self, CacheCommitError> {
         // Find the `.git` directory, searching through parent directories if necessary.
         let git_dir = path
             .ancestors()
             .map(|ancestor| ancestor.join(".git"))
-            .find(|git_dir| git_dir.exists())?;
+            .find(|git_dir| git_dir.exists())
+            .ok_or_else(|| CacheCommitError::MissingGitDir(path.to_path_buf()))?;
 
-        let git_head_path = git_head(&git_dir)?;
-        let git_head_contents = fs_err::read_to_string(git_head_path).ok()?;
+        let git_head_path =
+            git_head(&git_dir).ok_or_else(|| CacheCommitError::MissingHead(git_dir.clone()))?;
+        let git_head_contents = fs_err::read_to_string(git_head_path)?;
 
         // The contents are either a commit or a reference in the following formats
         // - "<commit>" when the head is detached
         // - "ref <ref>" when working on a branch
         // If a commit, checking if the HEAD file has changed is sufficient
         // If a ref, we need to add the head file for that ref to rebuild on commit
         let mut git_ref_parts = git_head_contents.split_whitespace();
-        let commit_or_ref = git_ref_parts.next()?;
-        if let Some(git_ref) = git_ref_parts.next() {
+        let commit_or_ref = git_ref_parts.next().ok_or_else(|| {
+            CacheCommitError::InvalidRef(git_dir.clone(), git_head_contents.clone())
+        })?;
+        let commit = if let Some(git_ref) = git_ref_parts.next() {
             let git_ref_path = git_dir.join(git_ref);
-            let commit = fs_err::read_to_string(git_ref_path).ok()?;
-            Some(Self(commit))
+            fs_err::read_to_string(git_ref_path)?
         } else {
-            Some(Self(commit_or_ref.to_string()))
+            commit_or_ref.to_string()
+        };
+
+        // The commit should be 40 hexadecimal characters.
+        if commit.len() != 40 {
+            return Err(CacheCommitError::WrongLength(commit));
         }
+        if commit.chars().any(|c| !c.is_ascii_hexdigit()) {
+            return Err(CacheCommitError::WrongDigit(commit));
+        }
+
+        Ok(Self(commit))
     }
 }
 

crates/uv-cache-info/src/cache_info.rs

@@ -223,7 +223,6 @@ impl<'a> BuildContext for BuildDispatch<'a> {
             &BuildOptions::default(),
             self.hasher,
             self.index_locations,
-            self.config_settings,
             self.cache(),
             venv,
             &markers,

crates/uv-cache-info/src/commit_info.rs

@@ -13,7 +13,6 @@ license = { workspace = true }
 workspace = true
 
 [dependencies]
-cache-key = { workspace = true }
 distribution-filename = { workspace = true }
 distribution-types = { workspace = true }
 install-wheel-rs = { workspace = true }

crates/uv-dispatch/src/lib.rs

@@ -7,7 +7,6 @@ use distribution_types::{
 use platform_tags::Tags;
 use uv_cache::{Cache, CacheBucket, CacheShard, WheelCache};
 use uv_cache_info::CacheInfo;
-use uv_configuration::ConfigSettings;
 use uv_fs::symlinks;
 use uv_types::HashStrategy;
 
@@ -17,22 +16,15 @@ pub struct BuiltWheelIndex<'a> {
     cache: &'a Cache,
     tags: &'a Tags,
     hasher: &'a HashStrategy,
-    build_configuration: &'a ConfigSettings,
 }
 
 impl<'a> BuiltWheelIndex<'a> {
     /// Initialize an index of built distributions.
-    pub fn new(
-        cache: &'a Cache,
-        tags: &'a Tags,
-        hasher: &'a HashStrategy,
-        build_configuration: &'a ConfigSettings,
-    ) -> Self {
+    pub fn new(cache: &'a Cache, tags: &'a Tags, hasher: &'a HashStrategy) -> Self {
         Self {
             cache,
             tags,
             hasher,
-            build_configuration,
         }
     }
 
@@ -61,13 +53,6 @@ impl<'a> BuiltWheelIndex<'a> {
 
         let cache_shard = cache_shard.shard(revision.id());
 
-        // If there are build settings, we need to scope to a cache shard.
-        let cache_shard = if self.build_configuration.is_empty() {
-            cache_shard
-        } else {
-            cache_shard.shard(cache_key::cache_digest(self.build_configuration))
-        };
-
         Ok(self.find(&cache_shard))
     }
     /// Return the most compatible [`CachedWheel`] for a given source distribution at a local path.
@@ -98,13 +83,6 @@ impl<'a> BuiltWheelIndex<'a> {
 
         let cache_shard = cache_shard.shard(revision.id());
 
-        // If there are build settings, we need to scope to a cache shard.
-        let cache_shard = if self.build_configuration.is_empty() {
-            cache_shard
-        } else {
-            cache_shard.shard(cache_key::cache_digest(self.build_configuration))
-        };
-
         Ok(self
             .find(&cache_shard)
             .map(|wheel| wheel.with_cache_info(cache_info)))
@@ -147,13 +125,6 @@ impl<'a> BuiltWheelIndex<'a> {
 
         let cache_shard = cache_shard.shard(revision.id());
 
-        // If there are build settings, we need to scope to a cache shard.
-        let cache_shard = if self.build_configuration.is_empty() {
-            cache_shard
-        } else {
-            cache_shard.shard(cache_key::cache_digest(self.build_configuration))
-        };
-
         Ok(self
             .find(&cache_shard)
             .map(|wheel| wheel.with_cache_info(cache_info)))
@@ -173,13 +144,6 @@ impl<'a> BuiltWheelIndex<'a> {
             WheelCache::Git(&source_dist.url, &git_sha.to_short_string()).root(),
         );
 
-        // If there are build settings, we need to scope to a cache shard.
-        let cache_shard = if self.build_configuration.is_empty() {
-            cache_shard
-        } else {
-            cache_shard.shard(cache_key::cache_digest(self.build_configuration))
-        };
-
         self.find(&cache_shard)
     }