http2_server_stream.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "frame.h"
#include "hpack.h"
#include "http2_client.h"
#include "http2_request.h"
#include "kcenon/network/detail/utils/result_types.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string_view>
#include <vector>
 
namespace kcenon::network::protocols::http2
{
    // Forward declaration
    class http2_connection;
 
    class http2_server_stream
    {
    public:
        using frame_sender_t = std::function<VoidResult(const frame&)>;
 
        http2_server_stream(uint32_t stream_id,
                            http2_request request,
                            std::shared_ptr<hpack_encoder> encoder,
                            frame_sender_t frame_sender,
                            uint32_t max_frame_size = 16384);
 
        ~http2_server_stream() = default;
 
        // Non-copyable, non-movable (contains mutex)
        http2_server_stream(const http2_server_stream&) = delete;
        http2_server_stream& operator=(const http2_server_stream&) = delete;
        http2_server_stream(http2_server_stream&&) = delete;
        http2_server_stream& operator=(http2_server_stream&&) = delete;
 
        auto send_headers(int status_code,
                          const std::vector<http_header>& headers,
                          bool end_stream = false) -> VoidResult;
 
        auto send_data(const std::vector<uint8_t>& data,
                       bool end_stream = false) -> VoidResult;
 
        auto send_data(std::string_view data, bool end_stream = false) -> VoidResult;
 
        auto start_response(int status_code,
                            const std::vector<http_header>& headers) -> VoidResult;
 
        auto write(const std::vector<uint8_t>& chunk) -> VoidResult;
 
        auto end_response() -> VoidResult;
 
        auto reset(uint32_t err_code = static_cast<uint32_t>(error_code::cancel))
            -> VoidResult;
 
        [[nodiscard]] auto stream_id() const -> uint32_t;
 
        [[nodiscard]] auto method() const -> std::string_view;
 
        [[nodiscard]] auto path() const -> std::string_view;
 
        [[nodiscard]] auto headers() const -> const std::vector<http_header>&;
 
        [[nodiscard]] auto request() const -> const http2_request&;
 
        [[nodiscard]] auto is_open() const -> bool;
 
        [[nodiscard]] auto headers_sent() const -> bool;
 
        [[nodiscard]] auto state() const -> stream_state;
 
        auto update_window(int32_t increment) -> void;
 
        [[nodiscard]] auto window_size() const -> int32_t;
 
    private:
        auto build_response_headers(int status_code,
                                    const std::vector<http_header>& additional)
            -> std::vector<http_header>;
 
        uint32_t stream_id_;                          
        http2_request request_;                       
        std::shared_ptr<hpack_encoder> encoder_;      
        frame_sender_t frame_sender_;                 
        uint32_t max_frame_size_;                     
 
        stream_state state_{stream_state::open};      
        bool headers_sent_{false};                    
        int32_t window_size_{65535};                  
 
        mutable std::mutex mutex_;                    
    };
 
} // namespace kcenon::network::protocols::http2