polling_initializer.hpp

#pragma once
 
#include "../../data_interfaces/source/ifdv2_initializer.hpp"
 
#include <launchdarkly/async/promise.hpp>
#include <launchdarkly/data_model/selector.hpp>
#include <launchdarkly/logging/logger.hpp>
#include <launchdarkly/network/requester.hpp>
#include <launchdarkly/server_side/config/built/all_built.hpp>
 
#include <boost/asio/any_io_executor.hpp>
 
#include <memory>
#include <optional>
#include <string>
 
namespace launchdarkly::server_side::data_systems {
 
class FDv2PollingInitializer final : public data_interfaces::IFDv2Initializer {
   public:
    FDv2PollingInitializer(boost::asio::any_io_executor const& executor,
                           Logger const& logger,
                           std::string const& polling_base_url,
                           config::built::HttpProperties const& http_properties,
                           data_model::Selector selector,
                           std::optional<std::string> filter_key);
 
    ~FDv2PollingInitializer() override;
 
    async::Future<data_interfaces::FDv2SourceResult> Run() override;
 
    void Close() override;
 
    [[nodiscard]] std::string const& Identity() const override;
 
   private:
    // State needed by async callbacks. Shared so callbacks can safely
    // outlive 'this'.
    struct State {
        // Logger is itself thread-safe.
        Logger logger;
 
        explicit State(Logger logger) : logger(std::move(logger)) {}
    };
 
    static data_interfaces::FDv2SourceResult HandlePollResult(
        std::shared_ptr<State> state,
        network::HttpResult const& res);
 
    // Immutable state
    network::HttpRequest const request_;
    network::Requester const requester_;
 
    // Resolved when Close() is called (or this object is destroyed),
    // cancelling any outstanding Run().
    async::Promise<std::monostate> close_promise_;
 
    // Shared with async callbacks.
    std::shared_ptr<State> state_;
};
 
}  // namespace launchdarkly::server_side::data_systems