BaseHttpSocket.h

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program 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 General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef TRINITYCORE_BASE_HTTP_SOCKET_H
#define TRINITYCORE_BASE_HTTP_SOCKET_H
 
#include "AsyncCallbackProcessor.h"
#include "DatabaseEnvFwd.h"
#include "HttpCommon.h"
#include "HttpSessionState.h"
#include "Optional.h"
#include "QueryCallback.h"
#include "Socket.h"
#include <boost/asio/buffers_iterator.hpp>
#include <boost/beast/http/parser.hpp>
#include <boost/beast/http/string_body.hpp>
#include <boost/uuid/uuid_io.hpp>
 
namespace Trinity::Net::Http
{
using RequestParser = boost::beast::http::request_parser<RequestBody>;
 
class TC_SHARED_API AbstractSocket
{
public:
    AbstractSocket() = default;
    AbstractSocket(AbstractSocket const& other) = default;
    AbstractSocket(AbstractSocket&& other) = default;
    AbstractSocket& operator=(AbstractSocket const& other) = default;
    AbstractSocket& operator=(AbstractSocket&& other) = default;
    virtual ~AbstractSocket() = default;
 
    static bool ParseRequest(MessageBuffer& packet, RequestParser& parser);
 
    static std::string SerializeRequest(Request const& request);
    static MessageBuffer SerializeResponse(Request const& request, Response& response);
 
    virtual void SendResponse(RequestContext& context) = 0;
 
    virtual void QueueQuery(QueryCallback&& queryCallback) = 0;
 
    virtual std::string GetClientInfo() const = 0;
 
    virtual Optional<boost::uuids::uuid> GetSessionId() const = 0;
};
 
template<typename Derived, typename Stream>
class BaseSocket : public ::Socket<Derived, Stream>, public AbstractSocket
{
    using Base = ::Socket<Derived, Stream>;
 
public:
    template<typename... Args>
    explicit BaseSocket(boost::asio::ip::tcp::socket&& socket, Args&&... args)
        : Base(std::move(socket), std::forward<Args>(args)...) { }
 
    BaseSocket(BaseSocket const& other) = delete;
    BaseSocket(BaseSocket&& other) = delete;
    BaseSocket& operator=(BaseSocket const& other) = delete;
    BaseSocket& operator=(BaseSocket&& other) = delete;
 
    ~BaseSocket() = default;
 
    void ReadHandler() override
    {
        if (!this->IsOpen())
            return;
 
        MessageBuffer& packet = this->GetReadBuffer();
        while (packet.GetActiveSize() > 0)
        {
            if (!ParseRequest(packet, *_httpParser))
            {
                // Couldn't receive the whole data this time.
                break;
            }
 
            if (!HandleMessage(_httpParser->get()))
            {
                this->CloseSocket();
                break;
            }
 
            this->ResetHttpParser();
        }
 
        this->AsyncRead();
    }
 
    bool HandleMessage(Request& request)
    {
        RequestContext context { .request = std::move(request) };
 
        if (!_state)
            _state = this->ObtainSessionState(context);
 
        RequestHandlerResult status = this->RequestHandler(context);
 
        if (status != RequestHandlerResult::Async)
            this->SendResponse(context);
 
        return status != RequestHandlerResult::Error;
    }
 
    virtual RequestHandlerResult RequestHandler(RequestContext& context) = 0;
 
    void SendResponse(RequestContext& context) override
    {
        MessageBuffer buffer = SerializeResponse(context.request, context.response);
 
        TC_LOG_DEBUG("server.http", "{} Request {} {} done, status {}", this->GetClientInfo(), ToStdStringView(context.request.method_string()),
            ToStdStringView(context.request.target()), context.response.result_int());
        if (sLog->ShouldLog("server.http", LOG_LEVEL_TRACE))
        {
            sLog->OutMessage("server.http", LOG_LEVEL_TRACE, "{} Request: {}", this->GetClientInfo(),
                CanLogRequestContent(context) ? SerializeRequest(context.request) : "<REDACTED>");
            sLog->OutMessage("server.http", LOG_LEVEL_TRACE, "{} Response: {}", this->GetClientInfo(),
                CanLogResponseContent(context) ? std::string_view(reinterpret_cast<char const*>(buffer.GetBasePointer()), buffer.GetActiveSize()) : "<REDACTED>");
        }
 
        this->QueuePacket(std::move(buffer));
 
        if (!context.response.keep_alive())
            this->DelayedCloseSocket();
    }
 
    void QueueQuery(QueryCallback&& queryCallback) override
    {
        this->_queryProcessor.AddCallback(std::move(queryCallback));
    }
 
    bool Update() override
    {
        if (!this->Base::Update())
            return false;
 
        this->_queryProcessor.ProcessReadyCallbacks();
        return true;
    }
 
    std::string GetClientInfo() const override
    {
        std::string info;
        info.reserve(500);
        auto itr = StringFormatTo(std::back_inserter(info), "[{}:{}", this->GetRemoteIpAddress().to_string(), this->GetRemotePort());
        if (_state)
            itr = StringFormatTo(itr, ", Session Id: {}", boost::uuids::to_string(_state->Id));
 
        StringFormatTo(itr, "]");
        return info;
    }
 
    Optional<boost::uuids::uuid> GetSessionId() const final
    {
        if (this->_state)
            return this->_state->Id;
 
        return {};
    }
 
protected:
    void ResetHttpParser()
    {
        this->_httpParser.reset();
        this->_httpParser.emplace();
        this->_httpParser->eager(true);
    }
 
    virtual std::shared_ptr<SessionState> ObtainSessionState(RequestContext& context) const = 0;
 
    QueryCallbackProcessor _queryProcessor;
    Optional<RequestParser> _httpParser;
    std::shared_ptr<SessionState> _state;
};
}
 
#endif // TRINITYCORE_BASE_HTTP_SOCKET_H