TcpSession.hpp

// SPDX-FileCopyrightText: 2025 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <chrono>
#include <memory>
#include <queue>
#include <string>
 
// Project includes
#include <dfx-fdwatch/BorrowedFd.hpp>
#include <dfx-fdwatch/PollerFd.hpp>
#include <dfx-fdwatch/Events.hpp>
#include <dfx-utilities/CopyMoveControl.hpp>
 
namespace dfx::FdWatch
{
class Poller;
} // !namespace dfx::FdWatch
 
namespace dfx::Server
{
class TcpServer;

class TcpSession : public std::enable_shared_from_this<TcpSession>
{
public:
    enum class TimeoutPolicy
    {
        Disabled,     
        Manual,       
        ResetOnRead,  
        ResetOnWrite, 
        ResetOnAny,   
    };
 
public:
    TcpSession(std::string host, std::string serv,
               TcpServer & server, std::chrono::milliseconds initialTimeout);

    DISABLE_COPY_AND_MOVE(TcpSession);

    virtual ~TcpSession() = default;

    FdWatch::BorrowedFd socket() const noexcept { return _socket.borrow(); }
    std::string const & host() const noexcept   { return _host; }
    std::string const & serv() const noexcept   { return _serv; }
 
public:
    void init(FdWatch::OwnedFd socket, FdWatch::Poller & poller);
 
public:
    bool subtractTimeAndCheckTimeout(std::chrono::milliseconds time);

    std::chrono::milliseconds initialTimeout() const noexcept { return _initialTimeout; }

    void setInitialTimeout(std::chrono::milliseconds timeout);

    void sendMessage(std::vector<uint8_t> const & message);
 
protected:
    void resetTimeout();

    void terminate();

    void setMaxDataQueueSize(std::size_t size);

    std::size_t maxDataQueueSize() const noexcept { return _maxPendingDataQueueSize; }
 
protected:
    virtual void handleMessage(std::vector<uint8_t> message) = 0;
 
private:
    void _onSocketReady(FdWatch::EventTriggers events);
    void _onSocketReadyRead();
    void _onSocketReadyWrite();
 
protected:
    std::string _host;
    std::string _serv;

    TimeoutPolicy _timeoutPolicy = TimeoutPolicy::ResetOnAny;
 
private:
    TcpServer & _server;
    FdWatch::PollerFd _socket;
 
    std::chrono::milliseconds _initialTimeout;
    std::chrono::milliseconds _timeBeforeTimeout{0};
 
private:
    bool _canSendMessage = true;
    std::vector<uint8_t> _nextDataToWrite;
    std::queue<std::vector<uint8_t>> _pendingDataQueue;
    std::size_t _maxPendingDataQueueSize = 1024;
};

using TcpSessionPtr  = std::shared_ptr<TcpSession>;
using TcpSessionWPtr = std::weak_ptr<TcpSession>;
} // !namespace dfx::Server