WsSession.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2017 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//

#ifndef COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER__WS_SESSION
#define COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER__WS_SESSION


#include <Balau/Network/Http/Server/WsWebApp.hpp>
#include <Balau/Network/Http/Server/HttpServerConfiguration.hpp>
#include <Balau/Util/DateTime.hpp>

// Avoid false positive (due to std::make_shared).
#pragma clang diagnostic push
#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"

namespace Balau::Network::Http {

class WsSession final : public std::enable_shared_from_this<WsSession> {
    public: WsSession(std::shared_ptr<HttpServerConfiguration> serverConfiguration_,
                      TCP::socket && socket_,
                      std::string path_)
        : serverConfiguration(std::move(serverConfiguration_))
        , strand(socket_.get_executor())
        , socket(std::move(socket_))
        , path(std::move(path_)) {}

    public: HttpServerConfiguration & configuration() const {
        return *serverConfiguration;
    }

    public: template <typename Body, typename AllocatorT>
    void doAccept(HTTP::request<Body, HTTP::basic_fields<AllocatorT>> req) {


        // TODO
//      ws.control_callback(
//          std::bind(
//              &WsSession::onControl,
//              this,
//              std::placeholders::_1,
//              std::placeholders::_2));

        socket.async_accept(
            req,
            boost::asio::bind_executor(
                strand,
                std::bind(
                    &WsSession::onAccept,
                    shared_from_this(),
                    std::placeholders::_1)));

        // TODO
    }

    public: void run() {
        socket.async_accept(
            boost::asio::bind_executor(
                strand, std::bind(&WsSession::onAccept, shared_from_this(), std::placeholders::_1)
            )
        );
    }

    public: void onControl(WsFrame frameType, boost::beast::string_view payload) {
        boost::ignore_unused(payload);

        switch (frameType) {
            case WsFrame::close: {
                serverConfiguration->wsHandler->handleClose(*this, path); // TODO
                break;
            }

            case WsFrame::ping: {
                serverConfiguration->wsHandler->handlePing(*this, path); // TODO
                break;
            }

            case WsFrame::pong: {
                serverConfiguration->wsHandler->handlePong(*this, path); // TODO
                break;
            }
        }
    }

    public: void onAccept(boost::system::error_code ec) {
        checkError(ec);
        doRead();
    }

    public: void doRead() {
        socket.async_read(
            buffer,
            boost::asio::bind_executor(
                strand,
                std::bind(
                    &WsSession::onRead,
                    shared_from_this(),
                    std::placeholders::_1,
                    std::placeholders::_2)));
    }

    public: void onRead(boost::system::error_code ec, std::size_t bytes_transferred) {
        boost::ignore_unused(bytes_transferred);

        if (ec == WS::error::closed) {
            return;
        }

        checkError(ec);

        // Echo the message
        socket.text(socket.got_text());

        socket.async_write(
              buffer.data()
            , boost::asio::bind_executor(
                strand, std::bind(&WsSession::onWrite, shared_from_this(), std::placeholders::_1, std::placeholders::_2)
            )
        );
    }

    public: void onWrite(boost::system::error_code ec, std::size_t bytes_transferred) {
        boost::ignore_unused(bytes_transferred);

        checkError(ec);
        buffer.consume(buffer.size());
        doRead();
    }


    private: void checkError(const boost::system::error_code & errorCode) {
        if (errorCode) {
            ThrowBalauException(Exception::NetworkException, errorCode.message());
        }
    }

    private: std::shared_ptr<HttpServerConfiguration> serverConfiguration;
    private: boost::asio::strand<boost::asio::io_context::executor_type> strand;
    private: WS::stream<TCP::socket> socket;
    private: const std::string path;
    private: boost::beast::multi_buffer buffer;
};

} // namespace Balau::Network::Http

#pragma clang diagnostic pop

#endif // COM_BORA_SOFTWARE__BALAU_NETWORK_HTTP_SERVER__WS_SESSION