Auto merge of #11044 - Eh2406:file_hash, r=weihanglo

Cache index files based on contents hash

Since #10507 Cargo has known how to read registry cached files whose index version starts with the hash of the file contents. Git makes it very cheap to determine the hash of a file. This PR switches cargo to start writing the new format.

Cargoes from before #10507 will not know how to read, and therefore overwrite, cached files written by Cargos after this PR.

Cargos after this PR can still read, and will consider up-to-date cached files written by all older Cargos.

As I'm writing this out I'm thinking that there may not be any point in writing a file that has both. An alternative implementation just writes the file contents hash. 🤔

src/cargo/sources/registry/remote.rs

@@ -163,10 +163,9 @@ impl<'cfg> RegistryData for RemoteRegistry<'cfg> {
     // Older versions of Cargo used the single value of the hash of the HEAD commit as a `index_version`.
     // This is technically correct but a little too conservative. If a new commit is fetched all cached
     // files need to be regenerated even if a particular file was not changed.
-    // Cargo now reads the `index_version` in two parts the cache file is considered valid if `index_version`
-    // ends with the hash of the HEAD commit OR if it starts with the hash of the file's contents.
-    // In the future cargo can write cached files with `index_version` = `git_file_hash + ":" + `git_commit_hash`,
-    // but for now it still uses `git_commit_hash` to be compatible with older Cargoes.
+    // However if an old cargo has written such a file we still know how to read it, as long as we check for that hash value.
+    //
+    // Cargo now uses a hash of the file's contents as provided by git.
     fn load(
         &mut self,
         _root: &Path,
@@ -178,10 +177,9 @@ impl<'cfg> RegistryData for RemoteRegistry<'cfg> {
         }
         // Check if the cache is valid.
         let git_commit_hash = self.current_version();
-        if let (Some(c), Some(i)) = (git_commit_hash, index_version) {
-            if i.ends_with(c.as_str()) {
-                return Poll::Ready(Ok(LoadResponse::CacheValid));
-            }
+        if index_version.is_some() && index_version == git_commit_hash.as_deref() {
+            // This file was written by an old version of cargo, but it is still up-to-date.
+            return Poll::Ready(Ok(LoadResponse::CacheValid));
         }
         // Note that the index calls this method and the filesystem is locked
         // in the index, so we don't need to worry about an `update_index`
@@ -190,18 +188,16 @@ impl<'cfg> RegistryData for RemoteRegistry<'cfg> {
             registry: &RemoteRegistry<'_>,
             path: &Path,
             index_version: Option<&str>,
-            git_commit_hash: Option<&str>,
         ) -> CargoResult<LoadResponse> {
             let repo = registry.repo()?;
             let tree = registry.tree()?;
             let entry = tree.get_path(path);
             let entry = entry?;
-            let git_file_hash = entry.id().to_string();
+            let git_file_hash = Some(entry.id().to_string());
 
-            if let Some(i) = index_version {
-                if i.starts_with(git_file_hash.as_str()) {
-                    return Ok(LoadResponse::CacheValid);
-                }
+            // Check if the cache is valid.
+            if index_version.is_some() && index_version == git_file_hash.as_deref() {
+                return Ok(LoadResponse::CacheValid);
             }
 
             let object = entry.to_object(repo)?;
@@ -212,13 +208,11 @@ impl<'cfg> RegistryData for RemoteRegistry<'cfg> {
 
             Ok(LoadResponse::Data {
                 raw_data: blob.content().to_vec(),
-                index_version: git_commit_hash.map(String::from),
-                // TODO: When the reading code has been stable for long enough (Say 8/2022)
-                // change to `git_file_hash + ":" + git_commit_hash`
+                index_version: git_file_hash,
             })
         }
 
-        match load_helper(&self, path, index_version, git_commit_hash.as_deref()) {
+        match load_helper(&self, path, index_version) {
             Ok(result) => Poll::Ready(Ok(result)),
             Err(_) if !self.updated => {
                 // If git returns an error and we haven't updated the repo, return