connection_plain.hpp

#pragma once
 
#include "connection.hpp"
#include "../../core/tcp/stream.hpp"
 
namespace malloy::server::http
{

    class connection_plain :
        public connection<connection_plain>,
        public std::enable_shared_from_this<connection_plain>
    {
        friend connection;
 
    public:
        // Create the session
        connection_plain(
            std::shared_ptr<spdlog::logger> logger,
            boost::asio::ip::tcp::socket&& socket,
            boost::beast::flat_buffer buffer,
            std::shared_ptr<const std::filesystem::path> doc_root,
            std::shared_ptr<handler> router
        ) :
            connection<connection_plain>(
                std::move(logger),
                std::move(buffer),
                std::move(router),
                std::move(doc_root)
            ),
            m_stream(std::move(socket))
        {
        }
 
        // Called by the base class
        [[nodiscard]]
        malloy::tcp::stream<>&
        stream()
        {
            return m_stream;
        }

        [[nodiscard]]
        malloy::tcp::stream<>
        release_stream()
        {
            return std::move(m_stream);
        }

        void
        run()
        {
            // We need to be executing within a strand to perform async operations
            // on the I/O objects in this session. Although not strictly necessary
            // for single-threaded contexts, this example code is written to be
            // thread-safe by default.
            boost::asio::dispatch(m_stream.get_executor(),
                boost::beast::bind_front_handler(
                    &connection_plain::do_read,
                    shared_from_this()
                )
            );
        }

        void
        do_close()
        {
            // Send a TCP shutdown
            boost::beast::error_code ec;
            m_stream.socket().shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
 
            // At this point the connection is closed gracefully
        }
 
    private:
        malloy::tcp::stream<> m_stream;
    };
 
}