mt_tcp_listener_mgr.h

Go to the documentation of this file.

// Copyright (C) 2022-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef MT_TCP_LISTENER_MGR_H
#define MT_TCP_LISTENER_MGR_H
 
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <asiolink/io_service_thread_pool.h>
#include <tcp/tcp_listener.h>
#include <thread>
#include <vector>
 
namespace isc {
namespace tcp {
 
const long TCP_IDLE_CONNECTION_TIMEOUT = 300 * 1000;
 
typedef std::function<
        TcpListenerPtr(const asiolink::IOServicePtr& io_service,
                       const asiolink::IOAddress& server_address,
                       const unsigned short server_port,
                       const asiolink::TlsContextPtr& tls_context,
                       const TcpListener::IdleTimeout& idle_timeout,
                       const TcpConnectionFilterCallback& connection_filter)
    > TcpListenerFactory;
 
class MtTcpListenerMgr {
public:
    MtTcpListenerMgr(TcpListenerFactory listener_factory,
                     const asiolink::IOAddress& address,
                     const uint16_t port,
                     const uint16_t thread_pool_size = 1,
                     asiolink::TlsContextPtr context = asiolink::TlsContextPtr(),
                     TcpConnectionFilterCallback connection_filter = 0);
 
    virtual ~MtTcpListenerMgr();
 
    void checkPermissions();
 
    void start();
 
    void pause();
 
    void resume();
 
    void stop();
 
    bool isRunning();
 
    bool isStopped();
 
    bool isPaused();
 
    isc::asiolink::IOAddress getAddress() const {
        return (address_);
    }
 
    uint16_t getPort() const {
        return (port_);
    }
 
    uint16_t getThreadPoolSize() const {
        return (thread_pool_size_);
    }
 
    asiolink::TlsContextPtr getTlsContext() const {
        return (tls_context_);
    }
 
    uint16_t getThreadCount() const {
        if (!thread_pool_) {
            return (0);
        }
 
        return (thread_pool_->getThreadCount());
    }
 
    asiolink::IOServicePtr getThreadIOService() const {
        return (thread_io_service_);
    }
 
    const TcpListenerPtr getTcpListener() {
        return(tcp_listener_);
    }
 
    void setIdleTimeout(long milliseconds) {
        idle_timeout_ = TcpListener::IdleTimeout(milliseconds);
    }
 
    long getIdleTimeout() {
        return (idle_timeout_.value_);
    }
 
private:
    TcpListenerFactory listener_factory_;
 
    isc::asiolink::IOAddress address_;
 
    uint16_t port_;
 
    isc::asiolink::IOServicePtr thread_io_service_;
 
    TcpListenerPtr tcp_listener_;
 
    std::size_t thread_pool_size_;
 
    asiolink::IoServiceThreadPoolPtr thread_pool_;
 
    asiolink::TlsContextPtr tls_context_;
 
    TcpConnectionFilterCallback connection_filter_;
 
    TcpListener::IdleTimeout idle_timeout_;
};
 
typedef boost::shared_ptr<MtTcpListenerMgr> MtTcpListenerMgrPtr;
 
} // namespace isc::tcp
} // namespace isc
 
#endif // MT_TCP_LISTENER_MGR_H