TCPServer.h

/*
╔══════════════════════════════════════════════════════════════════════════════╗
║                       SIMPLY POWERFUL TOOLKIT (SPTK)                         ║
╟──────────────────────────────────────────────────────────────────────────────╢
║  copyright            © 1999-2022 Alexey Parshin. All rights reserved.       ║
║  email                alexeyp@gmail.com                                      ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌──────────────────────────────────────────────────────────────────────────────┐
│   This library is free software; you can redistribute it and/or modify it    │
│   under the terms of the GNU Library General Public License as published by  │
│   the Free Software Foundation; either version 2 of the License, or (at your │
│   option) any later version.                                                 │
│                                                                              │
│   This library is distributed in the hope that it will be useful, but        │
│   WITHOUT ANY WARRANTY; without even the implied warranty of                 │
│   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library   │
│   General Public License for more details.                                   │
│                                                                              │
│   You should have received a copy of the GNU Library General Public License  │
│   along with this library; if not, write to the Free Software Foundation,    │
│   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.               │
│                                                                              │
│   Please report all bugs and problems to alexeyp@gmail.com.                  │
└──────────────────────────────────────────────────────────────────────────────┘
*/
 
#pragma once
 
#include <bitset>
#include <iostream>
#include <set>
#include <sptk5/Logger.h>
#include <sptk5/net/SSLKeys.h>
#include <sptk5/net/ServerConnection.h>
#include <sptk5/threads/SynchronizedQueue.h>
#include <sptk5/threads/ThreadPool.h>
 
namespace sptk {
 
class TCPServerListener;
 
class SP_EXPORT LogDetails
{
public:
    enum class MessageDetail : uint8_t
    {
        SERIAL_ID,
        SOURCE_IP,
        REQUEST_NAME,
        REQUEST_DURATION,
        REQUEST_DATA,
        RESPONSE_DATA,
        THREAD_POOLING,
        MAX_MESSAGE_DETAIL
    };
 
    using MessageDetails = std::set<MessageDetail>;
 
    LogDetails() = default;
 
    explicit LogDetails(const MessageDetails& details)
        : m_details(details)
    {
    }
 
    explicit LogDetails(const Strings& details);
 
    explicit LogDetails(std::initializer_list<MessageDetail> details)
    {
        for (auto detail: details)
        {
            m_details.insert(detail);
        }
    }
 
    String toString(const String& delimiter = ",") const;
 
    bool has(MessageDetail detail) const
    {
        return m_details.find(detail) != m_details.end();
    }
 
    bool empty() const
    {
        return m_details.empty();
    }
 
private:
    MessageDetails m_details; 
    static const std::map<String, MessageDetail> detailNames;
};
 
class SP_EXPORT TCPServer
    : public ThreadPool
{
    friend class TCPServerListener;
 
    friend class ServerConnection;
 
public:
    TCPServer(const String& listenerName, ServerConnection::Type connectionType, size_t threadLimit = 16, LogEngine* logEngine = nullptr,
              const LogDetails& logDetails = LogDetails());
 
    ~TCPServer() override;
 
    const Host& host() const;
 
    void listen(uint16_t port);
 
    void stop() override;
 
    bool active() const
    {
        return m_listenerThread != nullptr;
    }
 
    void log(LogPriority priority, const String& message) const
    {
        if (m_logger)
        {
            m_logger->log(priority, message);
        }
    }
 
    const LogDetails& logDetails() const
    {
        return m_logDetails;
    }
 
    void setSSLKeys(std::shared_ptr<SSLKeys> sslKeys);
 
    const SSLKeys& getSSLKeys() const;
 
    virtual void onConnection(const ServerConnection::Function& function);
 
protected:
    void host(const Host& host);
 
    virtual bool allowConnection(sockaddr_in* connectionRequest);
 
    virtual SServerConnection createConnection(SOCKET connectionSocket, const sockaddr_in* peer);
 
    void threadEvent(Thread* thread, ThreadEvent::Type eventType, SRunable runable) override;
 
private:
    mutable SharedMutex m_mutex;                         
    std::shared_ptr<TCPServerListener> m_listenerThread; 
    std::shared_ptr<Logger> m_logger;                    
    std::shared_ptr<SSLKeys> m_sslKeys;                  
    Host m_host;                                         
    LogDetails m_logDetails;                             
    ServerConnection::Type m_connectionType;             
    ServerConnection::Function m_connectionFunction;     
};
 
} // namespace sptk