tcp_server.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_TCP_TCP_SERVER_HPP__
#define NEFORCE_NETWORK_TCP_TCP_SERVER_HPP__

 
#include "NeForce/core/async/shared_mutex.hpp"
#include "NeForce/core/async/thread_pool.hpp"
#include "NeForce/core/system/pipe.hpp"
#include "NeForce/network/ssl/ssl_acceptor.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API tcp_server_base {
public:
    using client_handler_t = function<void(unique_ptr<tcp_socket>)>; 
    using exception_handler_t = function<void(const exception&)>;    
 
protected:
    unique_ptr<tcp_acceptor> acceptor_; 
    ports port_;                        
    atomic<bool> running_{false};       
    vector<thread> worker_threads_;     
    thread_pool client_pool_;           
    size_t worker_count_;               
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    ::WSAEVENT wake_event_{WSA_INVALID_EVENT};
#else
    pipe wake_pipe_;
#endif
    mutable shared_mutex handler_mutex_;
 
    client_handler_t client_handler_;       
    exception_handler_t exception_handler_; 
    mutex acceptor_mutex_;                  

    void notify_stop() noexcept;

    void accept_loop();

    virtual void handle_client(unique_ptr<tcp_socket> client) {
        if (client_handler_) {
            client_handler_(move(client));
        }
    }

    virtual optional<unique_ptr<tcp_socket>> accept_one() = 0;

    virtual void create_acceptor(const ip_address& endpoint, int backlog) = 0;
 
public:
    explicit tcp_server_base(ports port, size_t worker_count = thread_pool::max_thread_threshhold());

    virtual ~tcp_server_base() { stop(); }
 
    tcp_server_base(const tcp_server_base&) = delete;
    tcp_server_base& operator=(const tcp_server_base&) = delete;
 
    tcp_server_base(tcp_server_base&& other) noexcept = delete;
    tcp_server_base& operator=(tcp_server_base&& other) noexcept = delete;

    bool set_client_handler(client_handler_t handler);

    bool set_exception_handler(exception_handler_t handler);

    virtual bool start(int backlog = SOMAXCONN) noexcept;

    void stop();

    NEFORCE_NODISCARD bool is_running() const noexcept { return running_; }

    NEFORCE_NODISCARD ports port() const noexcept { return port_; }
};

class NEFORCE_API tcp_server final : public tcp_server_base {
private:
    void create_acceptor(const ip_address& endpoint, int backlog) override;
    optional<unique_ptr<tcp_socket>> accept_one() override;
 
public:
    using tcp_server_base::tcp_server_base;
};
 // TCP


class NEFORCE_API ssl_server final : public tcp_server_base {
private:
    ssl_context ssl_ctx_; 
 
private:
    void create_acceptor(const ip_address& endpoint, int backlog) override;
    optional<unique_ptr<tcp_socket>> accept_one() override;
 
public:
    explicit ssl_server(ports port, size_t worker_count = thread_pool::max_thread_threshhold());

    bool load_certificate(const string& cert_file, const string& key_file);

    void set_ssl_context(ssl_context ctx);

    NEFORCE_NODISCARD ssl_context& get_ssl_context() noexcept { return ssl_ctx_; }

    NEFORCE_NODISCARD const ssl_context& get_ssl_context() const noexcept { return ssl_ctx_; }

    bool start(int backlog = SOMAXCONN) noexcept override;
};
 // SSL/TLS
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_TCP_TCP_SERVER_HPP__