Use (un)expected for CAS utils

5 files changed, 36 insertions, 38 deletions

diff --git a/src/buildtool/execution_api/execution_service/TARGETS b/src/buildtool/execution_api/execution_service/TARGETS
index 7f2b5e1c..e77fb6bf 100644
--- a/src/buildtool/execution_api/execution_service/TARGETS
+++ b/src/buildtool/execution_api/execution_service/TARGETS
@@ -159,6 +159,7 @@
     [ ["@", "grpc", "", "grpc++"]
     , ["src/buildtool/common", "bazel_types"]
     , ["src/buildtool/storage", "storage"]
+    , ["src/utils/cpp", "expected"]
     ]
   , "private-deps":
     [ ["@", "fmt", "", "fmt"]
diff --git a/src/buildtool/execution_api/execution_service/cas_server.cpp b/src/buildtool/execution_api/execution_service/cas_server.cpp
index 89597a38..c4cf8f6f 100644
--- a/src/buildtool/execution_api/execution_service/cas_server.cpp
+++ b/src/buildtool/execution_api/execution_service/cas_server.cpp
@@ -280,14 +280,14 @@ auto CASServiceImpl::SplitBlob(::grpc::ServerContext* /*context*/,
             ? CASUtils::SplitBlobIdentity(blob_digest, *storage_)
             : CASUtils::SplitBlobFastCDC(blob_digest, *storage_);
 
-    if (std::holds_alternative<grpc::Status>(split_result)) {
-        auto status = std::get<grpc::Status>(split_result);
+    if (not split_result) {
+        auto const& status = split_result.error();
         auto str = fmt::format("SplitBlob: {}", status.error_message());
         logger_.Emit(LogLevel::Error, "{}", str);
         return ::grpc::Status{status.error_code(), str};
     }
 
-    auto chunk_digests = std::get<std::vector<bazel_re::Digest>>(split_result);
+    auto const& chunk_digests = *split_result;
     logger_.Emit(LogLevel::Debug, [&blob_digest, &chunk_digests]() {
         std::stringstream ss{};
         ss << "Split blob " << blob_digest.hash() << ":"
@@ -346,13 +346,13 @@ auto CASServiceImpl::SpliceBlob(::grpc::ServerContext* /*context*/,
               std::back_inserter(chunk_digests));
     auto splice_result =
         CASUtils::SpliceBlob(blob_digest, chunk_digests, *storage_);
-    if (std::holds_alternative<grpc::Status>(splice_result)) {
-        auto status = std::get<grpc::Status>(splice_result);
+    if (not splice_result) {
+        auto const& status = splice_result.error();
         auto str = fmt::format("SpliceBlob: {}", status.error_message());
         logger_.Emit(LogLevel::Error, "{}", str);
         return ::grpc::Status{status.error_code(), str};
     }
-    auto digest = std::get<bazel_re::Digest>(splice_result);
+    auto const& digest = *splice_result;
     if (auto err = CheckDigestConsistency(blob_digest, digest)) {
         auto str = fmt::format("SpliceBlob: {}", *err);
         logger_.Emit(LogLevel::Error, "{}", str);
diff --git a/src/buildtool/execution_api/execution_service/cas_utils.cpp b/src/buildtool/execution_api/execution_service/cas_utils.cpp
index 7dee7dc7..592cd6ce 100644
--- a/src/buildtool/execution_api/execution_service/cas_utils.cpp
+++ b/src/buildtool/execution_api/execution_service/cas_utils.cpp
@@ -47,16 +47,16 @@ auto CASUtils::EnsureTreeInvariant(bazel_re::Digest const& digest,
 
 auto CASUtils::SplitBlobIdentity(bazel_re::Digest const& blob_digest,
                                  Storage const& storage) noexcept
-    -> std::variant<std::vector<bazel_re::Digest>, grpc::Status> {
+    -> expected<std::vector<bazel_re::Digest>, grpc::Status> {
 
     // Check blob existence.
     auto path = NativeSupport::IsTree(blob_digest.hash())
                     ? storage.CAS().TreePath(blob_digest)
                     : storage.CAS().BlobPath(blob_digest, false);
     if (not path) {
-        return grpc::Status{
-            grpc::StatusCode::NOT_FOUND,
-            fmt::format("blob not found {}", blob_digest.hash())};
+        return unexpected{
+            grpc::Status{grpc::StatusCode::NOT_FOUND,
+                         fmt::format("blob not found {}", blob_digest.hash())}};
     }
 
     // The split protocol states that each chunk that is returned by the
@@ -67,15 +67,16 @@ auto CASUtils::SplitBlobIdentity(bazel_re::Digest const& blob_digest,
     if (NativeSupport::IsTree(blob_digest.hash())) {
         auto tree_data = FileSystemManager::ReadFile(*path);
         if (not tree_data) {
-            return grpc::Status{
+            return unexpected{grpc::Status{
                 grpc::StatusCode::INTERNAL,
-                fmt::format("could read tree data {}", blob_digest.hash())};
+                fmt::format("could read tree data {}", blob_digest.hash())}};
         }
         auto digest = storage.CAS().StoreBlob(*tree_data, false);
         if (not digest) {
-            return grpc::Status{grpc::StatusCode::INTERNAL,
-                                fmt::format("could not store tree as blob {}",
-                                            blob_digest.hash())};
+            return unexpected{
+                grpc::Status{grpc::StatusCode::INTERNAL,
+                             fmt::format("could not store tree as blob {}",
+                                         blob_digest.hash())}};
         }
         chunk_digests.emplace_back(*digest);
         return chunk_digests;
@@ -86,7 +87,7 @@ auto CASUtils::SplitBlobIdentity(bazel_re::Digest const& blob_digest,
 
 auto CASUtils::SplitBlobFastCDC(bazel_re::Digest const& blob_digest,
                                 Storage const& storage) noexcept
-    -> std::variant<std::vector<bazel_re::Digest>, grpc::Status> {
+    -> expected<std::vector<bazel_re::Digest>, grpc::Status> {
     // Split blob into chunks:
     auto split = NativeSupport::IsTree(blob_digest.hash())
                      ? storage.CAS().SplitTree(blob_digest)
@@ -97,13 +98,13 @@ auto CASUtils::SplitBlobFastCDC(bazel_re::Digest const& blob_digest,
         return *std::move(split);
     }
     // Process errors
-    return ToGrpc(std::move(split).error());
+    return unexpected{ToGrpc(std::move(split).error())};
 }
 
 auto CASUtils::SpliceBlob(bazel_re::Digest const& blob_digest,
                           std::vector<bazel_re::Digest> const& chunk_digests,
                           Storage const& storage) noexcept
-    -> std::variant<bazel_re::Digest, grpc::Status> {
+    -> expected<bazel_re::Digest, grpc::Status> {
     // Splice blob from chunks:
     auto splice =
         NativeSupport::IsTree(blob_digest.hash())
@@ -114,5 +115,5 @@ auto CASUtils::SpliceBlob(bazel_re::Digest const& blob_digest,
     if (splice) {
         return *std::move(splice);
     }
-    return ToGrpc(std::move(splice).error());
+    return unexpected{ToGrpc(std::move(splice).error())};
 }
diff --git a/src/buildtool/execution_api/execution_service/cas_utils.hpp b/src/buildtool/execution_api/execution_service/cas_utils.hpp
index a244f3f6..a7aec9ed 100644
--- a/src/buildtool/execution_api/execution_service/cas_utils.hpp
+++ b/src/buildtool/execution_api/execution_service/cas_utils.hpp
@@ -17,12 +17,12 @@
 
 #include <optional>
 #include <string>
-#include <variant>
 #include <vector>
 
 #include "grpcpp/support/status.h"
 #include "src/buildtool/common/bazel_types.hpp"
 #include "src/buildtool/storage/storage.hpp"
+#include "src/utils/cpp/expected.hpp"
 
 class CASUtils {
   public:
@@ -34,18 +34,18 @@ class CASUtils {
     [[nodiscard]] static auto SplitBlobIdentity(
         bazel_re::Digest const& blob_digest,
         Storage const& storage) noexcept
-        -> std::variant<std::vector<bazel_re::Digest>, grpc::Status>;
+        -> expected<std::vector<bazel_re::Digest>, grpc::Status>;
 
     [[nodiscard]] static auto SplitBlobFastCDC(
         bazel_re::Digest const& blob_digest,
         Storage const& storage) noexcept
-        -> std::variant<std::vector<bazel_re::Digest>, grpc::Status>;
+        -> expected<std::vector<bazel_re::Digest>, grpc::Status>;
 
     [[nodiscard]] static auto SpliceBlob(
         bazel_re::Digest const& blob_digest,
         std::vector<bazel_re::Digest> const& chunk_digests,
         Storage const& storage) noexcept
-        -> std::variant<bazel_re::Digest, grpc::Status>;
+        -> expected<bazel_re::Digest, grpc::Status>;
 };
 
 #endif  // INCLUDED_SRC_BUILDTOOL_EXECUTION_API_EXECUTION_SERVICE_CAS_UTILS_HPP
diff --git a/src/buildtool/execution_api/local/local_api.hpp b/src/buildtool/execution_api/local/local_api.hpp
index 85547de1..f9eefb64 100644
--- a/src/buildtool/execution_api/local/local_api.hpp
+++ b/src/buildtool/execution_api/local/local_api.hpp
@@ -341,19 +341,17 @@ class LocalApi final : public IExecutionApi {
         Logger::Log(LogLevel::Debug, "SplitBlob({})", blob_digest.hash());
         auto split_result = CASUtils::SplitBlobFastCDC(
             static_cast<bazel_re::Digest>(blob_digest), *storage_);
-        if (std::holds_alternative<grpc::Status>(split_result)) {
-            auto* status = std::get_if<grpc::Status>(&split_result);
-            Logger::Log(LogLevel::Error, status->error_message());
+        if (not split_result) {
+            Logger::Log(LogLevel::Error, split_result.error().error_message());
             return std::nullopt;
         }
-        auto* chunk_digests =
-            std::get_if<std::vector<bazel_re::Digest>>(&split_result);
+        auto const& chunk_digests = *split_result;
         Logger::Log(LogLevel::Debug, [&blob_digest, &chunk_digests]() {
             std::stringstream ss{};
             ss << "Split blob " << blob_digest.hash() << ":"
-               << blob_digest.size() << " into " << chunk_digests->size()
+               << blob_digest.size() << " into " << chunk_digests.size()
                << " chunks: [ ";
-            for (auto const& chunk_digest : *chunk_digests) {
+            for (auto const& chunk_digest : chunk_digests) {
                 ss << chunk_digest.hash() << ":" << chunk_digest.size_bytes()
                    << " ";
             }
@@ -361,10 +359,10 @@ class LocalApi final : public IExecutionApi {
             return ss.str();
         });
         auto artifact_digests = std::vector<ArtifactDigest>{};
-        artifact_digests.reserve(chunk_digests->size());
+        artifact_digests.reserve(chunk_digests.size());
         std::transform(
-            chunk_digests->cbegin(),
-            chunk_digests->cend(),
+            chunk_digests.cbegin(),
+            chunk_digests.cend(),
             std::back_inserter(artifact_digests),
             [](auto const& digest) { return ArtifactDigest{digest}; });
         return artifact_digests;
@@ -393,13 +391,11 @@ class LocalApi final : public IExecutionApi {
             });
         auto splice_result = CASUtils::SpliceBlob(
             static_cast<bazel_re::Digest>(blob_digest), digests, *storage_);
-        if (std::holds_alternative<grpc::Status>(splice_result)) {
-            auto* status = std::get_if<grpc::Status>(&splice_result);
-            Logger::Log(LogLevel::Error, status->error_message());
+        if (not splice_result) {
+            Logger::Log(LogLevel::Error, splice_result.error().error_message());
             return std::nullopt;
         }
-        auto* digest = std::get_if<bazel_re::Digest>(&splice_result);
-        return ArtifactDigest{*digest};
+        return ArtifactDigest{*std::move(splice_result)};
     }
 
     [[nodiscard]] auto BlobSpliceSupport() const noexcept -> bool final {