connection.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) 2026 Cisco Systems
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "quicr/messages/ctrl_message_types.h"
#include "quicr/metrics.h"
#include "quicr/track_name.h"
#include "quicr/utilities/bytes.h"
#include "quicr/utilities/thread_safety.h"
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <vector>
 
namespace quicr {
 
    class PublishTrackHandler;
    class Stream;
    class SubscribeTrackHandler;
    class TrackHandler;
 
    enum class StreamClosedFlag : uint8_t
    {
        kFin,         
        kReset,       
        kStopSending, 
    };
 
    class Connection : public std::enable_shared_from_this<Connection>
    {
      public:
        enum class Protocol : std::uint8_t
        {
            kNativeQuic,   
            kWebTransport, 
        };
 
        enum class Status : std::uint8_t
        {
            kReady = 0,          
            kConnecting,         
            kRemoteRequestClose, 
            kDisconnected,       
            kIdleTimeout,        
            kShutdown,           
            kShuttingDown,       
        };
 
        class Delegate
        {
          public:
            virtual ~Delegate() = default;
 
            virtual void OnConnectionStatus(const std::shared_ptr<Connection>& connection, Status status) = 0;
 
            virtual void OnRecvDgram(const std::shared_ptr<Connection>& connection) = 0;
 
            virtual bool OnRecvStream(const std::shared_ptr<Stream>& stream) = 0;
 
            virtual void OnStreamClosed(const std::shared_ptr<Stream>& stream, StreamClosedFlag flag) = 0;
 
            virtual void OnConnectionMetricsSampled(const std::shared_ptr<Connection>& connection,
                                                    const MetricsTimeStamp sample_time,
                                                    const QuicConnectionMetrics& quic_connection_metrics) = 0;
 
            virtual void OnStreamMetricsStampled(const std::shared_ptr<Connection>& connection,
                                                 const MetricsTimeStamp sample_time,
                                                 std::uint64_t stream_id,
                                                 const QuicStreamMetrics& quic_stream_metrics,
                                                 bool is_final) = 0;
        };
 
      public:
        Connection(std::uint64_t id, Protocol protocol = Protocol::kNativeQuic);
 
        virtual ~Connection() = default;
 
        std::uint64_t GetID() const noexcept;
 
        Protocol GetProtocol() const noexcept;
 
        void SetStatus(Status new_status);
 
        Status GetStatus() const noexcept { return status_.load(std::memory_order_acquire); }
 
        void SetDelegate(const std::shared_ptr<Delegate>& session);
 
        virtual QuicMetricsSample TakeMetricsSample() = 0;
 
        virtual void ReportMetricsSample(const MetricsTimeStamp& sample_time, const QuicMetricsSample& sample) = 0;
 
        virtual void OnStatusChanged(Status status);
 
        virtual void OnRecvDgram();
 
        virtual bool OnRecvStream(const std::shared_ptr<Stream>& stream);
 
        virtual void OnStreamClosed(const std::shared_ptr<Stream>& stream, StreamClosedFlag flag);
 
        bool RecordSetupSent();
 
        bool RecordSetupReceived();
 
        bool IsSetupComplete() const;
 
        void SetRxControlStreamId(std::uint64_t stream_id);
 
        std::optional<std::uint64_t> GetRxControlStreamId() const;
 
        void SetTxControlStream(std::shared_ptr<Stream> stream);
 
        std::shared_ptr<Stream> GetTxControlStream() const;
 
        void SetFirstUnprocessedRequestId(std::uint64_t request_id);
 
        std::optional<std::uint64_t> GetFirstUnprocessedRequestId() const;
 
      public:
        ConnectionMetrics metrics{}; 
 
      protected:
        std::shared_ptr<Delegate> GetDelegate() const;
 
        std::uint64_t id{ 0 }; 
 
        Protocol protocol_{ Protocol::kNativeQuic };
 
        std::atomic<Status> status_; 
 
        mutable std::mutex mutex_;
 
        std::weak_ptr<Delegate> delegate_ QUICR_GUARDED_BY(mutex_);
 
        bool setup_sent_ QUICR_GUARDED_BY(mutex_){ false };
        bool setup_received_ QUICR_GUARDED_BY(mutex_){ false };
 
        std::optional<std::uint64_t> rx_ctrl_stream_id_ QUICR_GUARDED_BY(mutex_);
 
        std::shared_ptr<Stream> tx_ctrl_stream_ QUICR_GUARDED_BY(mutex_);
 
        std::optional<std::uint64_t> first_unprocessed_request_id_ QUICR_GUARDED_BY(mutex_);
    };
}