SimpleWebSocketWorker.hpp

Go to the documentation of this file.

#pragma once
#ifndef _KURLYK_SIMPLE_WEB_SOCKET_WORKER_HPP_INCLUDED
#define _KURLYK_SIMPLE_WEB_SOCKET_WORKER_HPP_INCLUDED

 
namespace kurlyk {

    class SimpleWebSocketWorker {
    public:

        static SimpleWebSocketWorker& get_instance() {
            static SimpleWebSocketWorker instance;
            return instance;
        }

        std::shared_ptr<SimpleWeb::io_context> get_io_context() {
            return m_io_context;
        }

        void notify() {
            std::lock_guard<std::mutex> locker(m_notify_mutex);
            m_notify_condition.notify_one();
            m_notify = true;
        }

        void start() {
            std::unique_lock<std::mutex> locker(m_is_worker_started_mutex);
            if (m_is_worker_started) return;
            m_is_worker_started = true;
            locker.unlock();
 
            m_future = std::async(std::launch::async,
                    [this] {
                while (!m_shutdown) {
                    std::unique_lock<std::mutex> locker(m_notify_mutex);
                    m_notify_condition.wait(locker, [this](){
                        return m_notify;
                    });
                    m_notify = false;
                    locker.unlock();
 
                    try {
                        m_io_context->run();
                    } catch (...) {}
 
                    if (m_shutdown) break;
 
                    try {
                        m_io_context->restart();
                    } catch (...) {}
                }
                m_work_guard.reset();
            }).share();
        }

        void stop() {
            std::lock_guard<std::mutex> locker(m_is_worker_started_mutex);
            if (!m_future.valid()) return;
            m_shutdown = true;
            m_io_context->stop();
            notify();
            try {
                m_future.wait();
                m_future.get();
            } catch(...) {};
        }
 
    private:
#       ifdef ASIO_STANDALONE
        using work_guard_t = asio::executor_work_guard<asio::io_context::executor_type>;
#       else
        using work_guard_t = boost::asio::executor_work_guard<boost::asio::io_context::executor_type>;
#       endif
 
        using io_context_t = std::shared_ptr<SimpleWeb::io_context>;
        io_context_t                m_io_context;
        work_guard_t                m_work_guard;
 
        std::mutex                  m_is_worker_started_mutex;          
        bool                        m_is_worker_started = false;        
 
        std::mutex                  m_notify_mutex;                     
        std::condition_variable     m_notify_condition;                 
        bool                        m_notify = false;                   
 
        std::shared_future<void>    m_future;
        std::atomic<bool>           m_shutdown = ATOMIC_VAR_INIT(false);

        SimpleWebSocketWorker() :
                m_io_context(std::make_shared<SimpleWeb::io_context>()),
#           ifdef ASIO_STANDALONE
            m_work_guard(asio::make_work_guard(*m_io_context)) {
#           else
            m_work_guard(boost::asio::make_work_guard(*m_io_context)) {
#           endif
        }

        ~SimpleWebSocketWorker() {
            stop();
        }
 
        // Delete copy constructor and assignment operator to enforce singleton pattern
        SimpleWebSocketWorker(const SimpleWebSocketWorker&) = delete;
        SimpleWebSocketWorker& operator=(const SimpleWebSocketWorker&) = delete;
 
    }; // SimpleWebSocketWorker
 
}; // namespace kurlyk
 
#endif // _KURLYK_SIMPLE_WEB_SOCKET_WORKER_HPP_INCLUDED