service.h

Go to the documentation of this file.

 
#ifndef CPPSERVER_ASIO_SERVICE_H
#define CPPSERVER_ASIO_SERVICE_H
 
#include "asio.h"
#include "memory.h"
 
#include "threads/thread.h"
 
#include <atomic>
#include <cassert>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace CppServer {
namespace Asio {


class Service : public std::enable_shared_from_this<Service>
{
public:

    explicit Service(int threads = 1, bool pool = false);

    explicit Service(const std::shared_ptr<asio::io_context>& io_context, bool strands = false);
    Service(const Service&) = delete;
    Service(Service&&) = delete;
    virtual ~Service() = default;
 
    Service& operator=(const Service&) = delete;
    Service& operator=(Service&&) = delete;

    size_t threads() const noexcept { return _threads.size(); }

    bool IsStrandRequired() const noexcept { return _strand_required; }
    bool IsPolling() const noexcept { return _polling; }
    bool IsStarted() const noexcept { return _started; }


    virtual bool Start(bool polling = false);

    virtual bool Stop();

    virtual bool Restart();


    virtual std::shared_ptr<asio::io_context>& GetAsioContext() noexcept
    { return _io_contexts[++_round_robin_index % _io_contexts.size()]; }


    template <typename CompletionHandler>
    ASIO_INITFN_RESULT_TYPE(CompletionHandler, void()) Dispatch(ASIO_MOVE_ARG(CompletionHandler) handler)
    { if (_strand_required) return asio::dispatch(*_strand, handler); else return asio::dispatch(*_io_contexts[0], handler); }


    template <typename CompletionHandler>
    ASIO_INITFN_RESULT_TYPE(CompletionHandler, void()) Post(ASIO_MOVE_ARG(CompletionHandler) handler)
    { if (_strand_required) return asio::post(*_strand, handler); else return asio::post(*_io_contexts[0], handler); }
 
protected:

    virtual void onThreadInitialize() {}

    virtual void onThreadCleanup() {}

    virtual void onStarted() {}
    virtual void onStopped() {}

    virtual void onIdle() { CppCommon::Thread::Yield(); }


    virtual void onError(int error, const std::string& category, const std::string& message) {}
 
private:
    // Asio IO contexts
    std::vector<std::shared_ptr<asio::io_context>> _io_contexts;
    // Asio service working threads
    std::vector<std::thread> _threads;
    // Asio service strand for serialized handler execution
    std::shared_ptr<asio::io_context::strand> _strand;
    // Asio service strands required flag
    std::atomic<bool> _strand_required;
    // Asio service polling loop mode flag
    std::atomic<bool> _polling;
    // Asio service state
    std::atomic<bool> _started;
    std::atomic<size_t> _round_robin_index;

    static void ServiceThread(const std::shared_ptr<Service>& service, const std::shared_ptr<asio::io_context>& io_context);

    void SendError(std::error_code ec);
};

 
} // namespace Asio
} // namespace CppServer
 
#endif // CPPSERVER_ASIO_SERVICE_H