track_handler.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) 2024 Cisco Systems
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "quicr/attributes.h"
#include "quicr/errors.h"
#include "quicr/messages/message_serialisation.h"
#include "quicr/messages/parameters.h"
#include "quicr/reply.h"
#include "quicr/track_name.h"
#include "quicr/utilities/thread_safety.h"
 
#include <cstdint>
#include <memory>
#include <mutex>
#include <optional>
#include <span>
#include <vector>
 
namespace quicr {
    class Connection;
    class Session;
 
    class Stream;
 
    class TrackHandler : public std::enable_shared_from_this<TrackHandler>
    {
      public:
        struct Binding
        {
            std::uint64_t connection_id{ 0 };
            std::optional<std::uint64_t> request_id;
            std::shared_ptr<Stream> request_stream;
        };
 
        friend class Session;
 
        friend class SubscribeTrackHandler;
 
        virtual ~TrackHandler() = default;
 
        // --------------------------------------------------------------------------
        // Public API methods that normally should not be overridden
        // --------------------------------------------------------------------------
 
        TrackHandler() = delete;
 
      protected:
        TrackHandler(const FullTrackName& full_track_name)
          : full_track_name_(full_track_name)
        {
        }
 
        FullTrackName full_track_name_;
 
        // --------------------------------------------------------------------------
        // Public Virtual API callback event methods to be overridden
        // --------------------------------------------------------------------------
      public:
        template<typename T>
            requires std::is_base_of_v<TrackHandler, T>
        std::shared_ptr<T> Get()
        {
            return std::dynamic_pointer_cast<T>(shared_from_this());
        }
 
        void SetRequestId(std::optional<uint64_t> request_id)
        {
            std::lock_guard lock(request_stream_mutex_);
            request_id_ = request_id;
        }
 
        std::optional<uint64_t> GetRequestId() const noexcept
        {
            std::lock_guard lock(request_stream_mutex_);
            return request_id_;
        }
 
        std::optional<uint64_t> GetRequestStreamId() const;
 
        FullTrackName GetFullTrackName() const noexcept { return { full_track_name_ }; }
 
        uint64_t GetConnectionId() const noexcept
        {
            std::lock_guard lock(request_stream_mutex_);
            return connection_id_;
        }
 
        std::shared_ptr<Connection> GetConnection() const;
 
        Binding GetBinding() const
        {
            std::lock_guard lock(request_stream_mutex_);
            return { connection_id_, request_id_, request_stream_ };
        }
 
        virtual Reply<messages::Parameters, ErrorCode> RequestUpdateReceived(const messages::Parameters& params) = 0;
 
        virtual void RequestError(ErrorCode error_code, std::string reason);
 
      protected:
        virtual void RequestOkReceived(const messages::Parameters& params) = 0;
 
        void SetTransport(std::shared_ptr<Session> transport);
 
        const std::weak_ptr<Session>& GetSession() const noexcept;
 
        std::mutex binding_operation_mutex_;
 
        // --------------------------------------------------------------------------
        // Internal
        // --------------------------------------------------------------------------
      private:
        void SetConnectionId(uint64_t connection_id)
        {
            std::lock_guard lock(request_stream_mutex_);
            connection_id_ = connection_id;
        };
 
        void SetBinding(Binding binding)
        {
            std::lock_guard lock(request_stream_mutex_);
            connection_id_ = binding.connection_id;
            request_id_ = binding.request_id;
            request_stream_ = std::move(binding.request_stream);
        }
 
        void SetRequestStream(const std::shared_ptr<Stream>& request_stream)
        {
            std::lock_guard lock(request_stream_mutex_);
            request_stream_ = request_stream;
        }
 
        std::shared_ptr<Stream> GetRequestStream() const
        {
            std::lock_guard lock(request_stream_mutex_);
            return request_stream_;
        }
 
        // --------------------------------------------------------------------------
        // Member variables
        // --------------------------------------------------------------------------
        std::uint64_t connection_id_{ 0 }; // QUIC transport connection ID
 
        std::optional<uint64_t> request_id_;
 
        std::shared_ptr<Stream> request_stream_ QUICR_GUARDED_BY(request_stream_mutex_);
 
        mutable std::mutex request_stream_mutex_; 
 
        std::weak_ptr<Session> session_;
    };
 
} // namespace moq