Pass HashFunction to BazelNetwork

7 files changed, 69 insertions, 39 deletions

diff --git a/src/buildtool/execution_api/remote/TARGETS b/src/buildtool/execution_api/remote/TARGETS
index e45af2f1..4bce410e 100644
--- a/src/buildtool/execution_api/remote/TARGETS
+++ b/src/buildtool/execution_api/remote/TARGETS
@@ -37,6 +37,7 @@
     , ["src/buildtool/common/remote", "port"]
     , ["src/buildtool/common/remote", "retry_config"]
     , ["src/buildtool/file_system", "git_repo"]
+    , ["src/buildtool/crypto", "hash_function"]
     ]
   , "proto":
     [ ["@", "bazel_remote_apis", "", "remote_execution_proto"]
@@ -52,7 +53,6 @@
     , ["src/buildtool/execution_api/common", "common_api"]
     , ["src/buildtool/execution_api/utils", "outputscheck"]
     , ["src/buildtool/compatibility", "compatibility"]
-    , ["src/buildtool/crypto", "hash_function"]
     , ["@", "grpc", "", "grpc++"]
     , ["src/buildtool/common/remote", "retry"]
     , ["src/buildtool/execution_api/common", "message_limits"]
@@ -87,6 +87,7 @@
     , ["src/buildtool/file_system", "object_type"]
     , ["src/buildtool/logging", "log_level"]
     , ["src/buildtool/storage", "fs_utils"]
+    , ["src/buildtool/crypto", "hash_function"]
     ]
   }
 , "config":
diff --git a/src/buildtool/execution_api/remote/bazel/bazel_api.cpp b/src/buildtool/execution_api/remote/bazel/bazel_api.cpp
index f3635a5f..f4751df3 100644
--- a/src/buildtool/execution_api/remote/bazel/bazel_api.cpp
+++ b/src/buildtool/execution_api/remote/bazel/bazel_api.cpp
@@ -28,6 +28,7 @@
 #include "src/buildtool/auth/authentication.hpp"
 #include "src/buildtool/common/bazel_types.hpp"
 #include "src/buildtool/compatibility/compatibility.hpp"
+#include "src/buildtool/crypto/hash_function.hpp"
 #include "src/buildtool/execution_api/bazel_msg/bazel_blob_container.hpp"
 #include "src/buildtool/execution_api/bazel_msg/bazel_common.hpp"
 #include "src/buildtool/execution_api/bazel_msg/bazel_msg_factory.hpp"
@@ -194,8 +195,13 @@ BazelApi::BazelApi(std::string const& instance_name,
                    gsl::not_null<Auth const*> const& auth,
                    gsl::not_null<RetryConfig const*> const& retry_config,
                    ExecutionConfiguration const& exec_config) noexcept {
-    network_ = std::make_shared<BazelNetwork>(
-        instance_name, host, port, auth, retry_config, exec_config);
+    network_ = std::make_shared<BazelNetwork>(instance_name,
+                                              host,
+                                              port,
+                                              auth,
+                                              retry_config,
+                                              exec_config,
+                                              HashFunction::Instance());
 }
 
 // implement move constructor in cpp, where all members are complete types
diff --git a/src/buildtool/execution_api/remote/bazel/bazel_network.cpp b/src/buildtool/execution_api/remote/bazel/bazel_network.cpp
index b5fafd5b..5fff6305 100644
--- a/src/buildtool/execution_api/remote/bazel/bazel_network.cpp
+++ b/src/buildtool/execution_api/remote/bazel/bazel_network.cpp
@@ -27,7 +27,8 @@ BazelNetwork::BazelNetwork(
     Port port,
     gsl::not_null<Auth const*> const& auth,
     gsl::not_null<RetryConfig const*> const& retry_config,
-    ExecutionConfiguration const& exec_config) noexcept
+    ExecutionConfiguration const& exec_config,
+    HashFunction hash_function) noexcept
     : instance_name_{std::move(instance_name)},
       cas_{std::make_unique<BazelCasClient>(host, port, auth, retry_config)},
       ac_{std::make_unique<BazelAcClient>(host, port, auth, retry_config)},
@@ -35,7 +36,8 @@ BazelNetwork::BazelNetwork(
                                                    port,
                                                    auth,
                                                    retry_config)},
-      exec_config_{exec_config} {}
+      exec_config_{exec_config},
+      hash_function_{hash_function} {}
 
 auto BazelNetwork::IsAvailable(bazel_re::Digest const& digest) const noexcept
     -> bool {
@@ -141,7 +143,7 @@ auto BazelNetwork::ExecuteBazelActionSync(
 }
 
 auto BazelNetwork::CreateReader() const noexcept -> BazelNetworkReader {
-    return BazelNetworkReader{instance_name_, cas_.get()};
+    return BazelNetworkReader{instance_name_, cas_.get(), hash_function_};
 }
 
 auto BazelNetwork::GetCachedActionResult(
diff --git a/src/buildtool/execution_api/remote/bazel/bazel_network.hpp b/src/buildtool/execution_api/remote/bazel/bazel_network.hpp
index 33fbf713..645b403d 100644
--- a/src/buildtool/execution_api/remote/bazel/bazel_network.hpp
+++ b/src/buildtool/execution_api/remote/bazel/bazel_network.hpp
@@ -27,6 +27,7 @@
 #include "src/buildtool/common/bazel_types.hpp"
 #include "src/buildtool/common/remote/port.hpp"
 #include "src/buildtool/common/remote/retry_config.hpp"
+#include "src/buildtool/crypto/hash_function.hpp"
 #include "src/buildtool/execution_api/bazel_msg/bazel_blob_container.hpp"
 #include "src/buildtool/execution_api/bazel_msg/bazel_msg_factory.hpp"
 #include "src/buildtool/execution_api/common/execution_api.hpp"
@@ -43,7 +44,8 @@ class BazelNetwork {
                           Port port,
                           gsl::not_null<Auth const*> const& auth,
                           gsl::not_null<RetryConfig const*> const& retry_config,
-                          ExecutionConfiguration const& exec_config) noexcept;
+                          ExecutionConfiguration const& exec_config,
+                          HashFunction hash_function) noexcept;
 
     /// \brief Check if digest exists in CAS
     /// \param[in]  digest  The digest to look up
@@ -79,6 +81,9 @@ class BazelNetwork {
         -> std::optional<BazelExecutionClient::ExecutionOutput>;
 
     [[nodiscard]] auto CreateReader() const noexcept -> BazelNetworkReader;
+    [[nodiscard]] auto GetHashFunction() const noexcept -> HashFunction {
+        return hash_function_;
+    }
 
     [[nodiscard]] auto GetCachedActionResult(
         bazel_re::Digest const& action,
@@ -91,6 +96,7 @@ class BazelNetwork {
     std::unique_ptr<BazelAcClient> ac_{};
     std::unique_ptr<BazelExecutionClient> exec_{};
     ExecutionConfiguration exec_config_{};
+    HashFunction const hash_function_;
 
     template <class T_Iter>
     [[nodiscard]] auto DoUploadBlobs(T_Iter const& first,
diff --git a/src/buildtool/execution_api/remote/bazel/bazel_network_reader.cpp b/src/buildtool/execution_api/remote/bazel/bazel_network_reader.cpp
index 135cfd52..8416189b 100644
--- a/src/buildtool/execution_api/remote/bazel/bazel_network_reader.cpp
+++ b/src/buildtool/execution_api/remote/bazel/bazel_network_reader.cpp
@@ -16,23 +16,28 @@
 
 #include <algorithm>
 
-#include "src/buildtool/crypto/hash_function.hpp"
 #include "src/buildtool/execution_api/bazel_msg/bazel_msg_factory.hpp"
 #include "src/buildtool/execution_api/common/message_limits.hpp"
 #include "src/buildtool/file_system/file_system_manager.hpp"
 #include "src/buildtool/logging/log_level.hpp"
 #include "src/buildtool/logging/logger.hpp"
+#include "src/utils/cpp/gsl.hpp"
 #include "src/utils/cpp/path.hpp"
 
 BazelNetworkReader::BazelNetworkReader(
     std::string instance_name,
-    gsl::not_null<BazelCasClient const*> const& cas) noexcept
-    : instance_name_{std::move(instance_name)}, cas_(*cas) {}
+    gsl::not_null<BazelCasClient const*> const& cas,
+    HashFunction hash_function) noexcept
+    : instance_name_{std::move(instance_name)},
+      cas_{*cas},
+      hash_function_{hash_function} {}
 
 BazelNetworkReader::BazelNetworkReader(
     BazelNetworkReader&& other,
     std::optional<ArtifactDigest> request_remote_tree) noexcept
-    : instance_name_{other.instance_name_}, cas_(other.cas_) {
+    : instance_name_{other.instance_name_},
+      cas_{other.cas_},
+      hash_function_{other.hash_function_} {
     if (Compatibility::IsCompatible() and request_remote_tree) {
         // Query full tree from remote CAS. Note that this is currently not
         // supported by Buildbarn revision c3c06bbe2a.
@@ -62,6 +67,9 @@ auto BazelNetworkReader::ReadDirectory(ArtifactDigest const& digest)
 
 auto BazelNetworkReader::ReadGitTree(ArtifactDigest const& digest)
     const noexcept -> std::optional<GitRepo::tree_entries_t> {
+    ExpectsAudit(hash_function_.GetHashType() ==
+                 HashFunction::JustHash::Native);
+
     auto read_blob = ReadSingleBlob(digest);
     if (not read_blob) {
         Logger::Log(LogLevel::Debug, "Tree {} not found in CAS", digest.hash());
@@ -91,7 +99,7 @@ auto BazelNetworkReader::ReadGitTree(ArtifactDigest const& digest)
     std::string const& content = *read_blob->data;
     return GitRepo::ReadTreeData(
         content,
-        HashFunction::Instance().ComputeTreeHash(content).Bytes(),
+        hash_function_.ComputeTreeHash(content).Bytes(),
         check_symlinks,
         /*is_hex_id=*/false);
 }
@@ -132,16 +140,18 @@ auto BazelNetworkReader::DumpBlob(Artifact::ObjectInfo const& info,
 }
 
 auto BazelNetworkReader::MakeAuxiliaryMap(
-    std::vector<bazel_re::Directory>&& full_tree) noexcept
+    std::vector<bazel_re::Directory>&& full_tree) const noexcept
     -> std::optional<DirectoryMap> {
+    ExpectsAudit(hash_function_.GetHashType() ==
+                 HashFunction::JustHash::Compatible);
+
     DirectoryMap result;
     result.reserve(full_tree.size());
     for (auto& dir : full_tree) {
         try {
-            result.emplace(
-                ArtifactDigest::Create<ObjectType::File>(
-                    HashFunction::Instance(), dir.SerializeAsString()),
-                std::move(dir));
+            result.emplace(ArtifactDigest::Create<ObjectType::File>(
+                               hash_function_, dir.SerializeAsString()),
+                           std::move(dir));
         } catch (...) {
             return std::nullopt;
         }
@@ -152,7 +162,7 @@ auto BazelNetworkReader::MakeAuxiliaryMap(
 auto BazelNetworkReader::ReadSingleBlob(ArtifactDigest const& digest)
     const noexcept -> std::optional<ArtifactBlob> {
     auto blob = cas_.ReadSingleBlob(instance_name_, digest);
-    if (blob and BazelNetworkReader::Validate(*blob)) {
+    if (blob and Validate(*blob)) {
         return ArtifactBlob{
             ArtifactDigest{blob->digest}, blob->data, blob->is_exec};
     }
@@ -170,9 +180,9 @@ auto BazelNetworkReader::BatchReadBlobs(
     std::vector<BazelBlob> result =
         cas_.BatchReadBlobs(instance_name_, blobs.begin(), blobs.end());
 
-    auto it =
-        std::remove_if(result.begin(), result.end(), [](BazelBlob const& blob) {
-            return not BazelNetworkReader::Validate(blob);
+    auto it = std::remove_if(
+        result.begin(), result.end(), [this](BazelBlob const& blob) {
+            return not Validate(blob);
         });
     result.erase(it, result.end());
 
@@ -189,12 +199,13 @@ auto BazelNetworkReader::BatchReadBlobs(
     return artifacts;
 }
 
-auto BazelNetworkReader::Validate(BazelBlob const& blob) noexcept -> bool {
+auto BazelNetworkReader::Validate(BazelBlob const& blob) const noexcept
+    -> bool {
     ArtifactDigest const rehashed_digest =
         NativeSupport::IsTree(blob.digest.hash())
-            ? ArtifactDigest::Create<ObjectType::Tree>(HashFunction::Instance(),
+            ? ArtifactDigest::Create<ObjectType::Tree>(hash_function_,
                                                        *blob.data)
-            : ArtifactDigest::Create<ObjectType::File>(HashFunction::Instance(),
+            : ArtifactDigest::Create<ObjectType::File>(hash_function_,
                                                        *blob.data);
     if (rehashed_digest == ArtifactDigest{blob.digest}) {
         return true;
diff --git a/src/buildtool/execution_api/remote/bazel/bazel_network_reader.hpp b/src/buildtool/execution_api/remote/bazel/bazel_network_reader.hpp
index 2955fa57..be16f211 100644
--- a/src/buildtool/execution_api/remote/bazel/bazel_network_reader.hpp
+++ b/src/buildtool/execution_api/remote/bazel/bazel_network_reader.hpp
@@ -28,6 +28,7 @@
 #include "src/buildtool/common/artifact.hpp"
 #include "src/buildtool/common/artifact_digest.hpp"
 #include "src/buildtool/common/bazel_types.hpp"
+#include "src/buildtool/crypto/hash_function.hpp"
 #include "src/buildtool/execution_api/bazel_msg/bazel_blob_container.hpp"
 #include "src/buildtool/execution_api/common/artifact_blob_container.hpp"
 #include "src/buildtool/execution_api/remote/bazel/bazel_cas_client.hpp"
@@ -39,9 +40,9 @@ class BazelNetworkReader final {
   public:
     using DumpCallback = std::function<bool(std::string const&)>;
 
-    explicit BazelNetworkReader(
-        std::string instance_name,
-        gsl::not_null<BazelCasClient const*> const& cas) noexcept;
+    explicit BazelNetworkReader(std::string instance_name,
+                                gsl::not_null<BazelCasClient const*> const& cas,
+                                HashFunction hash_function) noexcept;
 
     BazelNetworkReader(
         BazelNetworkReader&& other,
@@ -73,17 +74,18 @@ class BazelNetworkReader final {
 
     std::string const instance_name_;
     BazelCasClient const& cas_;
+    HashFunction const hash_function_;
     std::optional<DirectoryMap> auxiliary_map_;
 
-    [[nodiscard]] static auto MakeAuxiliaryMap(
-        std::vector<bazel_re::Directory>&& full_tree) noexcept
+    [[nodiscard]] auto MakeAuxiliaryMap(
+        std::vector<bazel_re::Directory>&& full_tree) const noexcept
         -> std::optional<DirectoryMap>;
 
     [[nodiscard]] auto BatchReadBlobs(
         std::vector<bazel_re::Digest> const& blobs) const noexcept
         -> std::vector<ArtifactBlob>;
 
-    [[nodiscard]] static auto Validate(BazelBlob const& blob) noexcept -> bool;
+    [[nodiscard]] auto Validate(BazelBlob const& blob) const noexcept -> bool;
 };
 
 class BazelNetworkReader::IncrementalReader final {
diff --git a/src/buildtool/execution_api/remote/bazel/bazel_response.cpp b/src/buildtool/execution_api/remote/bazel/bazel_response.cpp
index 0cb860a3..7db88a08 100644
--- a/src/buildtool/execution_api/remote/bazel/bazel_response.cpp
+++ b/src/buildtool/execution_api/remote/bazel/bazel_response.cpp
@@ -28,11 +28,11 @@
 
 namespace {
 
-auto ProcessDirectoryMessage(bazel_re::Directory const& dir) noexcept
+auto ProcessDirectoryMessage(HashFunction hash_function,
+                             bazel_re::Directory const& dir) noexcept
     -> std::optional<BazelBlob> {
     auto data = dir.SerializeAsString();
-    auto digest = ArtifactDigest::Create<ObjectType::File>(
-        HashFunction::Instance(), data);
+    auto digest = ArtifactDigest::Create<ObjectType::File>(hash_function, data);
     return BazelBlob{std::move(digest), std::move(data), /*is_exec=*/false};
 }
 
@@ -102,7 +102,7 @@ auto BazelResponse::Populate() noexcept -> bool {
                 link.path(),
                 Artifact::ObjectInfo{
                     .digest = ArtifactDigest::Create<ObjectType::File>(
-                        HashFunction::Instance(), link.target()),
+                        network_->GetHashFunction(), link.target()),
                     .type = ObjectType::Symlink});
         } catch (...) {
             return false;
@@ -114,7 +114,7 @@ auto BazelResponse::Populate() noexcept -> bool {
                 link.path(),
                 Artifact::ObjectInfo{
                     .digest = ArtifactDigest::Create<ObjectType::File>(
-                        HashFunction::Instance(), link.target()),
+                        network_->GetHashFunction(), link.target()),
                     .type = ObjectType::Symlink});
             dir_symlinks.emplace(link.path());  // add it to set
         } catch (...) {
@@ -129,7 +129,7 @@ auto BazelResponse::Populate() noexcept -> bool {
                 link.path(),
                 Artifact::ObjectInfo{
                     .digest = ArtifactDigest::Create<ObjectType::File>(
-                        HashFunction::Instance(), link.target()),
+                        network_->GetHashFunction(), link.target()),
                     .type = ObjectType::Symlink});
         } catch (...) {
             return false;
@@ -141,7 +141,7 @@ auto BazelResponse::Populate() noexcept -> bool {
                 link.path(),
                 Artifact::ObjectInfo{
                     .digest = ArtifactDigest::Create<ObjectType::File>(
-                        HashFunction::Instance(), link.target()),
+                        network_->GetHashFunction(), link.target()),
                     .type = ObjectType::Symlink});
         } catch (...) {
             return false;
@@ -215,7 +215,8 @@ auto BazelResponse::UploadTreeMessageDirectories(
     bazel_re::Tree const& tree) const -> std::optional<ArtifactDigest> {
     BazelBlobContainer dir_blobs{};
 
-    auto rootdir_blob = ProcessDirectoryMessage(tree.root());
+    auto rootdir_blob =
+        ProcessDirectoryMessage(network_->GetHashFunction(), tree.root());
     if (not rootdir_blob) {
         return std::nullopt;
     }
@@ -234,7 +235,8 @@ auto BazelResponse::UploadTreeMessageDirectories(
     }
 
     for (auto const& subdir : tree.children()) {
-        auto subdir_blob = ProcessDirectoryMessage(subdir);
+        auto subdir_blob =
+            ProcessDirectoryMessage(network_->GetHashFunction(), subdir);
         if (not subdir_blob) {
             return std::nullopt;
         }