MigratorsRegister.hpp

#pragma once
 
#include "data/BackendInterface.hpp"
#include "migration/MigratiorStatus.hpp"
#include "migration/impl/Spec.hpp"
#include "util/Assert.hpp"
#include "util/Concepts.hpp"
#include "util/config/ObjectView.hpp"
#include "util/log/Logger.hpp"
 
#include <algorithm>
#include <array>
#include <iterator>
#include <memory>
#include <optional>
#include <ranges>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>
 
namespace migration::impl {

template <typename BackendType, typename MigratorType>
concept MigrationBackend =
    requires { requires std::same_as<typename MigratorType::Backend, BackendType>; };
 
template <typename Backend, typename... MigratorType>
concept BackendMatchAllMigrators = (MigrationBackend<Backend, MigratorType> && ...);
 
template <typename T>
concept HasCanBlockClio = requires(T t) {
    { t.kCAN_BLOCK_CLIO };
};

template <typename Backend, typename... MigratorType>
    requires AllMigratorSpec<MigratorType...>
class MigratorsRegister {
    static_assert(util::hasNoDuplicateNames<MigratorType...>());
 
    util::Logger log_{"Migration"};
    std::shared_ptr<Backend> backend_;
 
    template <typename Migrator>
    void
    callMigration(std::string const& name, util::config::ObjectView const& config)
    {
        if (name == Migrator::kNAME) {
            LOG(log_.info()) << "Running migration: " << name;
            Migrator::runMigration(backend_, config);
            backend_->writeMigratorStatus(
                name, MigratorStatus(MigratorStatus::Migrated).toString()
            );
            LOG(log_.info()) << "Finished migration: " << name;
        }
    }
 
    template <typename T>
    static constexpr std::string_view
    getDescriptionIfMatch(std::string_view targetName)
    {
        return (T::kNAME == targetName) ? T::kDESCRIPTION : "";
    }
 
    template <typename First, typename... Rest>
    static constexpr bool
    canBlockClioHelper(std::string_view targetName)
    {
        if (targetName == First::kNAME) {
            if constexpr (HasCanBlockClio<First>) {
                return First::kCAN_BLOCK_CLIO;
            }
            return false;
        }
        if constexpr (sizeof...(Rest) > 0) {
            return canBlockClioHelper<Rest...>(targetName);
        }
        ASSERT(false, "The migrator name is not found");
        std::unreachable();
    }
 
public:
    using BackendType = Backend;

    MigratorsRegister(std::shared_ptr<BackendType> backend) : backend_{std::move(backend)}
    {
    }

    void
    runMigrator(std::string const& name, util::config::ObjectView const& config)
        requires BackendMatchAllMigrators<BackendType, MigratorType...>
    {
        (callMigration<MigratorType>(name, config), ...);
    }

    std::vector<std::tuple<std::string, MigratorStatus>>
    getMigratorsStatus() const
    {
        auto const fullList = getMigratorNames();
 
        std::vector<std::tuple<std::string, MigratorStatus>> status;
 
        std::ranges::transform(fullList, std::back_inserter(status), [&](auto const& migratorName) {
            auto const migratorNameStr = std::string(migratorName);
            return std::make_tuple(migratorNameStr, getMigratorStatus(migratorNameStr));
        });
        return status;
    }

    MigratorStatus
    getMigratorStatus(std::string const& name) const
    {
        auto const fullList = getMigratorNames();
        if (std::ranges::find(fullList, name) == fullList.end()) {
            return MigratorStatus::NotKnown;
        }
        auto const statusStringOpt = data::synchronous([&](auto yield) {
            return backend_->fetchMigratorStatus(name, yield);
        });
 
        return statusStringOpt ? MigratorStatus::fromString(statusStringOpt.value())
                               : MigratorStatus::NotMigrated;
    }

    constexpr auto
    getMigratorNames() const
    {
        return std::array<std::string_view, sizeof...(MigratorType)>{MigratorType::kNAME...};
    }

    std::string
    getMigratorDescription(std::string const& name) const
    {
        if constexpr (sizeof...(MigratorType) == 0) {
            return "No Description";
        } else {
            // Fold expression to search through all types
            std::string const result = ([](std::string const& name) {
                return std::string(getDescriptionIfMatch<MigratorType>(name));
            }(name) + ...);
 
            return result.empty() ? "No Description" : result;
        }
    }

    std::optional<bool>
    canMigratorBlockClio(std::string_view name) const
    {
        if constexpr (sizeof...(MigratorType) == 0) {
            return std::nullopt;
        } else {
            auto const migratiors = getMigratorNames();
            if (std::ranges::find(migratiors, name) == migratiors.end())
                return std::nullopt;
 
            return canBlockClioHelper<MigratorType...>(name);
        }
    }
};
 
}  // namespace migration::impl