serve target: Move server-side helper methods in own library

1 files changed, 1 insertions, 261 deletions

diff --git a/src/buildtool/serve_api/serve_service/target.cpp b/src/buildtool/serve_api/serve_service/target.cpp
index 12ca64ad..b4a0968a 100644
--- a/src/buildtool/serve_api/serve_service/target.cpp
+++ b/src/buildtool/serve_api/serve_service/target.cpp
@@ -14,12 +14,7 @@
 
 #include "src/buildtool/serve_api/serve_service/target.hpp"
 
-#include <filesystem>
-#include <string>
-#include <utility>
-
 #include "fmt/core.h"
-#include "fmt/format.h"
 #include "nlohmann/json.hpp"
 #include "src/buildtool/build_engine/base_maps/entity_name.hpp"
 #include "src/buildtool/build_engine/base_maps/entity_name_data.hpp"
@@ -30,8 +25,6 @@
 #include "src/buildtool/build_engine/target_map/result_map.hpp"
 #include "src/buildtool/common/artifact.hpp"
 #include "src/buildtool/common/artifact_digest.hpp"
-#include "src/buildtool/file_system/git_cas.hpp"
-#include "src/buildtool/file_system/git_repo.hpp"
 #include "src/buildtool/file_system/object_type.hpp"
 #include "src/buildtool/graph_traverser/graph_traverser.hpp"
 #include "src/buildtool/main/analyse.hpp"
@@ -39,210 +32,12 @@
 #include "src/buildtool/multithreading/task_system.hpp"
 #include "src/buildtool/progress_reporting/progress_reporter.hpp"
 #include "src/buildtool/serve_api/remote/config.hpp"
+#include "src/buildtool/serve_api/serve_service/target_utils.hpp"
 #include "src/buildtool/storage/config.hpp"
 #include "src/buildtool/storage/storage.hpp"
 #include "src/buildtool/storage/target_cache_key.hpp"
 #include "src/utils/cpp/verify_hash.hpp"
 
-auto TargetService::IsTreeInRepo(std::string const& tree_id,
-                                 std::filesystem::path const& repo_path,
-                                 std::shared_ptr<Logger> const& logger)
-    -> bool {
-    if (auto git_cas = GitCAS::Open(repo_path)) {
-        if (auto repo = GitRepo::Open(git_cas)) {
-            // wrap logger for GitRepo call
-            auto wrapped_logger = std::make_shared<GitRepo::anon_logger_t>(
-                [logger, repo_path, tree_id](auto const& msg, bool fatal) {
-                    if (fatal) {
-                        auto err = fmt::format(
-                            "ServeTarget: While checking existence of tree {} "
-                            "in repository {}:\n{}",
-                            tree_id,
-                            repo_path.string(),
-                            msg);
-                        logger->Emit(LogLevel::Info, err);
-                    }
-                });
-            if (auto res = repo->CheckTreeExists(tree_id, wrapped_logger)) {
-                return *res;
-            }
-        }
-    }
-    return false;  // tree not found
-}
-
-auto TargetService::GetServingRepository(std::string const& tree_id,
-                                         std::shared_ptr<Logger> const& logger)
-    -> std::optional<std::filesystem::path> {
-    // try the Git cache repository
-    if (IsTreeInRepo(tree_id, StorageConfig::GitRoot(), logger)) {
-        return StorageConfig::GitRoot();
-    }
-    // check the known repositories
-    for (auto const& path : RemoteServeConfig::KnownRepositories()) {
-        if (IsTreeInRepo(tree_id, path, logger)) {
-            return path;
-        }
-    }
-    return std::nullopt;  // tree cannot be served
-}
-
-auto TargetService::DetermineRoots(
-    std::string const& main_repo,
-    std::filesystem::path const& repo_config_path,
-    gsl::not_null<RepositoryConfig*> const& repository_config,
-    std::shared_ptr<Logger> const& logger) -> std::optional<std::string> {
-    // parse repository configuration file
-    auto repos = nlohmann::json::object();
-    try {
-        std::ifstream fs(repo_config_path);
-        repos = nlohmann::json::parse(fs);
-        if (not repos.is_object()) {
-            return fmt::format(
-                "Repository configuration file {} does not contain a map.",
-                repo_config_path.string());
-        }
-    } catch (std::exception const& ex) {
-        return fmt::format("Parsing repository config file {} failed with:\n{}",
-                           repo_config_path.string(),
-                           ex.what());
-    }
-    if (not repos.contains(main_repo)) {
-        return fmt::format(
-            "Repository configuration does not contain expected main "
-            "repository {}",
-            main_repo);
-    }
-    // populate RepositoryConfig instance
-    std::string error_msg;
-    for (auto const& [repo, desc] : repos.items()) {
-        // root parser
-        auto parse_keyword_root =
-            [&desc = desc, &repo = repo, &error_msg = error_msg, logger](
-                std::string const& keyword) -> std::optional<FileRoot> {
-            auto it = desc.find(keyword);
-            if (it != desc.end()) {
-                if (auto parsed_root =
-                        FileRoot::ParseRoot(repo, keyword, *it, &error_msg)) {
-                    // check that root has absent-like format
-                    if (not parsed_root->first.IsAbsent()) {
-                        error_msg = fmt::format(
-                            "Expected {} to have absent Git tree format, but "
-                            "found {}",
-                            keyword,
-                            it->dump());
-                        return std::nullopt;
-                    }
-                    // find the serving repository for the root tree
-                    auto tree_id = *parsed_root->first.GetAbsentTreeId();
-                    auto repo_path = GetServingRepository(tree_id, logger);
-                    if (not repo_path) {
-                        error_msg = fmt::format(
-                            "{} tree {} is not known", keyword, tree_id);
-                        return std::nullopt;
-                    }
-                    // set the root as present
-                    if (auto root = FileRoot::FromGit(
-                            *repo_path,
-                            tree_id,
-                            parsed_root->first.IgnoreSpecial())) {
-                        return root;
-                    }
-                }
-                error_msg =
-                    fmt::format("Failed to parse {} {}", keyword, it->dump());
-                return std::nullopt;
-            }
-            error_msg =
-                fmt::format("Missing {} for repository {}", keyword, repo);
-            return std::nullopt;
-        };
-
-        std::optional<FileRoot> ws_root = parse_keyword_root("workspace_root");
-        if (not ws_root) {
-            return error_msg;
-        }
-        auto info = RepositoryConfig::RepositoryInfo{std::move(*ws_root)};
-
-        if (auto target_root = parse_keyword_root("target_root")) {
-            info.target_root = std::move(*target_root);
-        }
-        else {
-            return error_msg;
-        }
-
-        if (auto rule_root = parse_keyword_root("rule_root")) {
-            info.rule_root = std::move(*rule_root);
-        }
-        else {
-            return error_msg;
-        }
-
-        if (auto expression_root = parse_keyword_root("expression_root")) {
-            info.expression_root = std::move(*expression_root);
-        }
-        else {
-            return error_msg;
-        }
-
-        auto it_bindings = desc.find("bindings");
-        if (it_bindings != desc.end()) {
-            if (not it_bindings->is_object()) {
-                return fmt::format(
-                    "bindings has to be a string-string map, but found {}",
-                    it_bindings->dump());
-            }
-            for (auto const& [local_name, global_name] : it_bindings->items()) {
-                if (not repos.contains(global_name)) {
-                    return fmt::format(
-                        "Binding {} for {} in {} does not refer to a "
-                        "defined repository.",
-                        global_name,
-                        local_name,
-                        repo);
-                }
-                info.name_mapping[local_name] = global_name;
-            }
-        }
-        else {
-            return fmt::format("Missing bindings for repository {}", repo);
-        }
-
-        auto parse_keyword_file_name =
-            [&desc = desc, &repo = repo, &error_msg = error_msg](
-                std::string* keyword_file_name,
-                std::string const& keyword) -> bool {
-            auto it = desc.find(keyword);
-            if (it != desc.end()) {
-                *keyword_file_name = *it;
-                return true;
-            }
-            error_msg =
-                fmt::format("Missing {} for repository {}", keyword, repo);
-            return false;
-        };
-
-        if (not parse_keyword_file_name(&info.target_file_name,
-                                        "target_file_name")) {
-            return error_msg;
-        }
-
-        if (not parse_keyword_file_name(&info.rule_file_name,
-                                        "rule_file_name")) {
-            return error_msg;
-        }
-
-        if (not parse_keyword_file_name(&info.expression_file_name,
-                                        "expression_file_name")) {
-            return error_msg;
-        }
-
-        repository_config->SetInfo(repo, std::move(info));
-    }
-    // success
-    return std::nullopt;
-}
-
 auto TargetService::ServeTarget(
     ::grpc::ServerContext* /*context*/,
     const ::justbuild::just_serve::ServeTargetRequest* request,
@@ -577,61 +372,6 @@ auto TargetService::ServeTarget(
     return ::grpc::Status{::grpc::StatusCode::INTERNAL, msg};
 }
 
-auto TargetService::GetBlobContent(std::filesystem::path const& repo_path,
-                                   std::string const& tree_id,
-                                   std::string const& rel_path,
-                                   std::shared_ptr<Logger> const& logger)
-    -> std::optional<std::pair<bool, std::optional<std::string>>> {
-    if (auto git_cas = GitCAS::Open(repo_path)) {
-        if (auto repo = GitRepo::Open(git_cas)) {
-            // check if tree exists
-            auto wrapped_logger = std::make_shared<GitRepo::anon_logger_t>(
-                [logger, repo_path, tree_id](auto const& msg, bool fatal) {
-                    if (fatal) {
-                        auto err = fmt::format(
-                            "ServeTargetVariables: While checking if tree {} "
-                            "exists in repository {}:\n{}",
-                            tree_id,
-                            repo_path.string(),
-                            msg);
-                        logger->Emit(LogLevel::Debug, err);
-                    }
-                });
-            if (repo->CheckTreeExists(tree_id, wrapped_logger) == true) {
-                // get tree entry by path
-                if (auto entry_info =
-                        repo->GetObjectByPathFromTree(tree_id, rel_path)) {
-                    wrapped_logger = std::make_shared<GitRepo::anon_logger_t>(
-                        [logger, repo_path, blob_id = entry_info->id](
-                            auto const& msg, bool fatal) {
-                            if (fatal) {
-                                auto err = fmt::format(
-                                    "ServeTargetVariables: While retrieving "
-                                    "blob {} from repository {}:\n{}",
-                                    blob_id,
-                                    repo_path.string(),
-                                    msg);
-                                logger->Emit(LogLevel::Debug, err);
-                            }
-                        });
-                    // get blob content
-                    return repo->TryReadBlob(entry_info->id, wrapped_logger);
-                }
-                // trace failure to get entry
-                auto err = fmt::format(
-                    "ServeTargetVariables: Failed to retrieve entry {} in "
-                    "tree {} from repository {}",
-                    rel_path,
-                    tree_id,
-                    repo_path.string());
-                logger->Emit(LogLevel::Debug, err);
-                return std::pair(false, std::nullopt);  // could not read blob
-            }
-        }
-    }
-    return std::nullopt;  // tree not found or errors while retrieving tree
-}
-
 auto TargetService::ServeTargetVariables(
     ::grpc::ServerContext* /*context*/,
     const ::justbuild::just_serve::ServeTargetVariablesRequest* request,