WebSocketService.h

/* Copyright (C) 2015 by Laurentiu-Gheorghe Crisan
   Copyright (C) 2026 by Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_HTTP_WEBSOCKETSERVICE_H
#define PT_HTTP_WEBSOCKETSERVICE_H
 
#include <Pt/Http/Api.h>
#include <Pt/Http/Service.h>
#include <Pt/Http/WebSocketSession.h>
#include <Pt/Allocator.h>
#include <Pt/Connectable.h>
#include <cstddef>
 
namespace Pt {
 
namespace System {
class EventLoop;
}
 
namespace Http {
 
class Request;
class Responder;
class Stream;
class WebSocketServlet;

class PT_HTTP_API WebSocketService : public Service
                                   , public Connectable
{
    friend class WebSocketResponder;
 
    public:
        WebSocketService();

        ~WebSocketService();

        std::size_t maxSockets() const;

        void setMaxSockets(std::size_t n);

        std::size_t idleTimeout() const;

        void setIdleTimeout(std::size_t ms);

        std::size_t maxMessageSize() const;

        void setMaxMessageSize(std::size_t n);
 
    protected:
        virtual Responder* onGetResponder(const Request&);

        virtual void onReleaseResponder(Responder* responder);

        virtual WebSocketSession* onGetSession(WebSocketServlet& servlet,
                                               System::EventLoop& loop,
                                               Stream& stream) = 0;

        virtual void onReleaseSession(WebSocketSession* session) = 0;

        virtual void onUpgrade(Stream& stream) final;
 
    private:
        friend class WebSocketServlet;

        std::size_t sessionCount() const;
 
        void registerServlet(WebSocketServlet& servlet);
 
        void unregisterServlet(WebSocketServlet& servlet);
 
        WebSocketServlet* _servlet;
        std::size_t _maxSockets;
        std::size_t _idleTimeout;
        std::size_t _maxMessageSize;
};

template <typename S, typename Alloc = Allocator>
class BasicWebSocketService : public WebSocketService
{
    public:
        BasicWebSocketService()
        { }

        ~BasicWebSocketService()
        { }
 
    protected:
        virtual WebSocketSession* onGetSession(WebSocketServlet& servlet,
                                               System::EventLoop& loop,
                                               Stream& stream)
        {
            void* memory = _alloc.allocate(sizeof(S));
            return new(memory) S(servlet, loop, stream);
        }
 
        virtual void onReleaseSession(WebSocketSession* session)
        {
            session->~WebSocketSession();
            _alloc.deallocate(session, sizeof(S));
        }
 
    private:
        Alloc _alloc;
};
 
} // namespace Http
 
} // namespace Pt
 
#endif