Stopper.hpp

#pragma once
 
#include "cluster/Concepts.hpp"
#include "data/BackendInterface.hpp"
#include "data/LedgerCacheSaver.hpp"
#include "etl/ETLServiceInterface.hpp"
#include "etl/LoadBalancerInterface.hpp"
#include "feed/SubscriptionManagerInterface.hpp"
#include "util/CoroutineGroup.hpp"
#include "util/log/Logger.hpp"
#include "web/interface/Concepts.hpp"
 
#include <boost/asio/executor_work_guard.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/spawn.hpp>
 
#include <functional>
#include <thread>
 
namespace app {

class Stopper {
    boost::asio::io_context ctx_;
    std::thread worker_;
    std::function<void()> onCompleteCallback_;
 
public:
    ~Stopper();

    void
    setOnStop(std::function<void(boost::asio::yield_context)> cb);

    void
    setOnComplete(std::function<void()> cb);

    void
    stop();

    template <
        web::SomeServer ServerType,
        data::SomeLedgerCacheSaver LedgerCacheSaverType,
        cluster::SomeClusterCommunicationService ClusterCommunicationServiceType>
    static std::function<void(boost::asio::yield_context)>
    makeOnStopCallback(
        ServerType& server,
        etl::LoadBalancerInterface& balancer,
        etl::ETLServiceInterface& etl,
        feed::SubscriptionManagerInterface& subscriptions,
        data::BackendInterface& backend,
        LedgerCacheSaverType& cacheSaver,
        ClusterCommunicationServiceType& clusterCommunicationService,
        boost::asio::io_context& ioc
    )
    {
        return [&](boost::asio::yield_context yield) {
            cacheSaver.save();
 
            util::CoroutineGroup coroutineGroup{yield};
            coroutineGroup.spawn(yield, [&server](auto innerYield) {
                server.stop(innerYield);
                LOG(util::LogService::info()) << "Server stopped";
            });
            coroutineGroup.spawn(yield, [&balancer](auto innerYield) {
                balancer.stop(innerYield);
                LOG(util::LogService::info()) << "LoadBalancer stopped";
            });
            coroutineGroup.asyncWait(yield);
 
            clusterCommunicationService.stop();
 
            etl.stop();
            LOG(util::LogService::info()) << "ETL stopped";
 
            subscriptions.stop();
            LOG(util::LogService::info()) << "SubscriptionManager stopped";
 
            backend.waitForWritesToFinish();
            LOG(util::LogService::info()) << "Backend writes finished";
 
            cacheSaver.waitToFinish();
 
            ioc.stop();
            LOG(util::LogService::info()) << "io_context stopped";
 
            util::LogService::shutdown();
        };
    }
};
 
}  // namespace app