stream_transport.h

Go to the documentation of this file.

#pragma once
 
#include "fl/task/promise.h"
#include "fl/stl/function.h"
#include "fl/stl/optional.h"
#include "fl/stl/shared_ptr.h"
#include "fl/stl/span.h"
#include "fl/stl/string.h"
#include "fl/stl/flat_map.h"
#include "fl/stl/vector.h"
#include "fl/stl/asio/http/connection.h"
#include "fl/net/http/chunked_encoding.h"
#include "fl/stl/noexcept.h"
 
namespace fl {
namespace net {
namespace http {
 
class HttpStreamTransport;  // IWYU pragma: keep

class StreamHandle {
public:
    StreamHandle() FL_NO_EXCEPT = default;

    StreamHandle& onData(fl::function<void(const fl::json&)> cb) FL_NO_EXCEPT;

    StreamHandle& then(fl::function<void(const fl::json&)> cb) FL_NO_EXCEPT;

    StreamHandle& catch_(fl::function<void(const fl::task::Error&)> cb) FL_NO_EXCEPT;

    fl::task::Promise<fl::json>& promise() FL_NO_EXCEPT;

    bool valid() const FL_NO_EXCEPT;
 
private:
    friend class HttpStreamTransport;
    StreamHandle(fl::task::Promise<fl::json> p,
                 fl::shared_ptr<fl::function<void(const fl::json&)>> updateCb) FL_NO_EXCEPT;
 
    fl::task::Promise<fl::json> mPromise;
    fl::shared_ptr<fl::function<void(const fl::json&)>> mUpdateCallback;
};

class HttpStreamTransport {
public:
    using StateCallback = fl::function<void()>;

    HttpStreamTransport(const fl::string& host, u16 port, u32 heartbeatIntervalMs = 30000) FL_NO_EXCEPT;

    virtual ~HttpStreamTransport() FL_NO_EXCEPT;
 
    // Connection Management

    virtual bool connect() FL_NO_EXCEPT = 0;

    virtual void disconnect() FL_NO_EXCEPT = 0;

    virtual bool isConnected() const FL_NO_EXCEPT = 0;
 
    // RequestSource Implementation (for Remote)

    fl::optional<fl::json> readRequest() FL_NO_EXCEPT;
 
    // ResponseSink Implementation (for Remote)

    void writeResponse(const fl::json& response) FL_NO_EXCEPT;
 
    // Promise-based RPC API

    fl::task::Promise<fl::json> rpc(const fl::string& method, const fl::json& params) FL_NO_EXCEPT;

    fl::task::Promise<fl::json> rpc(const fl::json& fullRequest) FL_NO_EXCEPT;

    StreamHandle rpcStream(const fl::string& method, const fl::json& params) FL_NO_EXCEPT;

    StreamHandle rpcStream(const fl::json& fullRequest) FL_NO_EXCEPT;
 
    // Update Loop

    void update(u32 currentTimeMs) FL_NO_EXCEPT;
 
    // Callbacks

    void setOnConnect(StateCallback callback) FL_NO_EXCEPT;

    void setOnDisconnect(StateCallback callback) FL_NO_EXCEPT;
 
    // Configuration

    void setHeartbeatInterval(u32 intervalMs) FL_NO_EXCEPT;

    u32 getHeartbeatInterval() const FL_NO_EXCEPT;

    void setTimeout(u32 timeoutMs) FL_NO_EXCEPT;

    u32 getTimeout() const FL_NO_EXCEPT;
 
protected:
    // Abstract methods for subclasses

    virtual int sendData(fl::span<const u8> data) FL_NO_EXCEPT = 0;

    virtual int recvData(fl::span<u8> buffer) FL_NO_EXCEPT = 0;

    virtual u32 getCurrentTimeMs() const FL_NO_EXCEPT;

    virtual void triggerReconnect() FL_NO_EXCEPT;
 
    // Connection management
    HttpConnection mConnection;
 
private:
    // Pending call state (for rpc())
    struct PendingCall {
        fl::task::Promise<fl::json> promise;
        bool ackReceived = false;
    };
 
    // Pending stream state (for rpcStream())
    struct PendingStream {
        fl::task::Promise<fl::json> promise;
        fl::shared_ptr<fl::function<void(const fl::json&)>> updateCallback;
        bool ackReceived = false;
    };
 
    // Chunked encoding
    ChunkedReader mReader;
    ChunkedWriter mWriter;
 
    // Heartbeat tracking
    u32 mLastHeartbeatSent;
    u32 mLastHeartbeatReceived;
    u32 mHeartbeatInterval;
    u32 mTimeoutMs;
 
    // Connection state
    bool mWasConnected;
 
    // Callbacks
    StateCallback mOnConnect;
    StateCallback mOnDisconnect;
 
    // Promise-based call tracking
    fl::flat_map<fl::string, PendingCall, fl::StringFastLess> mPendingCalls;
    fl::flat_map<fl::string, PendingStream, fl::StringFastLess> mPendingStreams;
    fl::vector<fl::json> mIncomingQueue;
    int mNextCallId = 1;
 
    // Internal methods
    void sendHeartbeat() FL_NO_EXCEPT;
    void checkHeartbeatTimeout(u32 currentTimeMs) FL_NO_EXCEPT;
    bool processIncomingData() FL_NO_EXCEPT;
    void handleConnectionStateChange(u32 currentTimeMs) FL_NO_EXCEPT;
    void parseChunkedMessages() FL_NO_EXCEPT;
    bool resolveRpc(const fl::json& msg, const fl::string& idKey) FL_NO_EXCEPT;
    bool resolveRpcStream(const fl::json& msg, const fl::string& idKey) FL_NO_EXCEPT;
    static fl::string idToString(const fl::json& id) FL_NO_EXCEPT;
};
 
}  // namespace http
}  // namespace net
}  // namespace fl