Server/SourceFiles/Core/Network/TcpSession.cpp - master - Shymer123/LumenServer

Server/SourceFiles/Core/Network/TcpSession.cpp
99 строк3 KB
Shymer123
Initial commit: LumenServer
20 июн 2026, 12:43
20 июн 2026, 12:43173f14c
#include "TcpSession.h"
#include "Router.h"
#include <boost/asio/error.hpp>
#include <boost/asio/write.hpp>
#include <iostream>

namespace Core::Network {

    TcpSession::TcpSession(boost::asio::ip::tcp::socket socket, Router& router)
        : m_socket(std::move(socket)),
          m_parser([this](const Packages::Packet& packet){ handlePacket(packet); }),
          m_router(router)
    {}

    void TcpSession::start(EndHandler endHandler)
    {
        m_endHandler = endHandler;
        doRead();
    }

    void TcpSession::stop()
    {
        if(m_stopped) return;
        m_stopped = true;

        if(m_socket.is_open())
        {
            boost::system::error_code ec;
            m_socket.shutdown(boost::asio::socket_base::shutdown_both, ec);
            m_socket.close();

            if(m_endHandler)
            {
                m_endHandler();
            }
        }
    }

    void TcpSession::doWrite(const Packages::Packet& packet)
    {
        auto data = packet.serialize();
        auto self(shared_from_this());
        boost::asio::async_write(m_socket,
                                 boost::asio::buffer(data),
            [this, self](boost::system::error_code ec, std::size_t)
        {
            if(ec) stop();
        });
    }

    void TcpSession::doRead()
    {
        auto self(shared_from_this());
        m_socket.async_read_some(boost::asio::buffer(m_readBuffer, MAX_BUF),
            [this, self](boost::system::error_code ec, std::size_t length)
        {
            if(!ec)
            {
                std::string receivedData(reinterpret_cast<const char*>(m_readBuffer), length);
                std::cout << "Length: " << length << " bytes\n";
                m_parser.onData(m_readBuffer, length);
                doRead();
            }
            else
            {
                stop();
            }
        });
    }

    void TcpSession::handlePacket(const Core::Network::Packages::Packet& packet)
    {
        auto self = shared_from_this();
        switch (packet.header.type)
        {
            case Packages::MessageType::JSON: {
                m_router.routeJson(packet.payload, self);
                break;
            }
            case Packages::MessageType::FILE: {
                m_router.routeFile(packet.payload, packet.fileData, self);
                break;
            }
            default:
                std::cout << "[TcpSession] Unknown package type" << std::endl;
        }
    }

    void TcpSession::sendPacket(const Packages::Packet& packet)
    {
        doWrite(packet);
    }

    boost::asio::ip::tcp::socket::executor_type TcpSession::get_executor()
    {
        return m_socket.get_executor();
    }

} // namespace Core::Network