network_stream.hpp

Go to the documentation of this file.

#pragma once
 
// Network Stream backends: TCP sockets and HTTP response bodies.
//
// These wrap the existing `Socket` and `http_get`/`http_post` helpers so
// that higher-level code can treat them uniformly with `FileStream`,
// `MemoryStream`, and `PipeStream` — and, layered under `AsyncStream`,
// gain non-blocking semantics without any network-specific plumbing.
 
#include <pulp/runtime/stream.hpp>
#include <pulp/runtime/socket.hpp>
#include <pulp/runtime/http.hpp>
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace pulp::runtime {

class TcpStream : public Stream {
public:
    TcpStream() = default;
    explicit TcpStream(Socket&& connected);
    ~TcpStream() override;
 
    TcpStream(TcpStream&&) noexcept;
    TcpStream& operator=(TcpStream&&) noexcept;
 
    bool connect(std::string_view host, std::uint16_t port);
 
    StreamResult read(std::uint8_t* buffer, std::size_t size) override;
    StreamResult write(const std::uint8_t* buffer, std::size_t size) override;
    void shutdown();
    void close() override;
    bool is_open() const override { return open_.load(); }

    Socket& socket() { return socket_; }
 
private:
    Socket socket_;
    std::atomic<bool> open_{false};
};

class HttpStream : public Stream {
public:
    struct Request {
        std::string url;
        std::string method = "GET";      
        std::string body;                
        std::string content_type = "application/json";
        int timeout_seconds = 30;
    };
 
    HttpStream() = default;
    explicit HttpStream(const Request& request);

    bool fetch(const Request& request);

    static std::unique_ptr<HttpStream> get(std::string_view url,
                                           int timeout_seconds = 30);

    static std::unique_ptr<HttpStream> post(std::string_view url,
                                            std::string_view body,
                                            std::string_view content_type = "application/json",
                                            int timeout_seconds = 30);
 
    StreamResult read(std::uint8_t* buffer, std::size_t size) override;
    StreamResult write(const std::uint8_t* buffer, std::size_t size) override;
    void close() override;
    bool is_open() const override;

    int status_code() const { return response_.status_code; }

    const std::map<std::string, std::string>& headers() const { return response_.headers; }

    const std::string& transport_error() const { return response_.error; }

    bool eof() const;
 
private:
    HttpResponse response_;
    std::size_t read_pos_ = 0;
    bool closed_ = false;
};
 
}  // namespace pulp::runtime