publish_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 <functional>
#include <quicr/detail/base_track_handler.h>
#include <quicr/metrics.h>
#include <quicr/object.h>
 
namespace quicr {
 
    class PublishTrackHandler : public BaseTrackHandler
    {
      public:
        enum class PublishObjectStatus : uint8_t
        {
            kOk = 0,
            kInternalError,
            kNotAuthorized,
            kNotAnnounced,
            kNoSubscribers,
            kObjectPayloadLengthExceeded,
            kPreviousObjectTruncated,
 
            kNoPreviousObject,
            kObjectDataComplete,
            kObjectContinuationDataNeeded,
            kObjectDataIncomplete, 
 
            kObjectDataTooLarge,
 
            kPreviousObjectNotCompleteMustStartNewGroup,
 
            kPreviousObjectNotCompleteMustStartNewTrack,
        };
 
        enum class Status : uint8_t
        {
            kOk = 0,
            kNotConnected,
            kNotAnnounced,
            kPendingAnnounceResponse,
            kAnnounceNotAuthorized,
            kNoSubscribers,
            kSendingUnannounce, 
            kSubscriptionUpdated,
            kNewGroupRequested,
        };
 
      protected:
        PublishTrackHandler(const FullTrackName& full_track_name,
                            TrackMode track_mode,
                            uint8_t default_priority,
                            uint32_t default_ttl)
          : BaseTrackHandler(full_track_name)
          , default_track_mode_(track_mode)
          , default_priority_(default_priority)
          , default_ttl_(default_ttl)
        {
        }
 
      public:
        static std::shared_ptr<PublishTrackHandler> Create(const FullTrackName& full_track_name,
                                                           TrackMode track_mode,
                                                           uint8_t default_priority,
                                                           uint32_t default_ttl)
        {
            return std::shared_ptr<PublishTrackHandler>(
              new PublishTrackHandler(full_track_name, track_mode, default_priority, default_ttl));
        }
 
        // --------------------------------------------------------------------------
        // Public Virtual API callback event methods
        // --------------------------------------------------------------------------
 
 
        virtual void StatusChanged(Status status);
 
        virtual void MetricsSampled(const PublishTrackMetrics& metrics);
 
 
        // --------------------------------------------------------------------------
        // Various getter/setters
        // --------------------------------------------------------------------------
        void SetDefaultPriority(const uint8_t priority) noexcept { default_priority_ = priority; }
 
        void SetDefaultTTL(const uint32_t ttl) noexcept { default_ttl_ = ttl; }
 
        void SetDefaultTrackMode(const TrackMode track_mode) noexcept { default_track_mode_ = track_mode; }
 
        constexpr Status GetStatus() const noexcept { return publish_status_; }
 
        // --------------------------------------------------------------------------
        // Methods that normally do not need to be overridden
        // --------------------------------------------------------------------------
 
        PublishObjectStatus PublishObject(const ObjectHeaders& object_headers, BytesSpan data);
 
        PublishObjectStatus ForwardPublishedData(bool is_new_stream, std::shared_ptr<const std::vector<uint8_t>> data);
 
        PublishObjectStatus PublishPartialObject(const ObjectHeaders& object_headers, BytesSpan data);
 
        // --------------------------------------------------------------------------
        // Metrics
        // --------------------------------------------------------------------------
 
        PublishTrackMetrics publish_track_metrics_;
 
        // --------------------------------------------------------------------------
        // Internals
        // --------------------------------------------------------------------------
      private:
        using PublishObjFunction = std::function<PublishObjectStatus(uint8_t priority,
                                                                     uint32_t ttl,
                                                                     bool stream_header_needed,
                                                                     uint64_t group_id,
                                                                     uint64_t subgroup_id,
                                                                     uint64_t object_id,
                                                                     std::optional<Extensions> extensions,
                                                                     BytesSpan data)>;
 
        using ForwardDataFunction =
          std::function<PublishObjectStatus(uint8_t priority,
                                            uint32_t ttl,
                                            bool stream_header_needed,
                                            std::shared_ptr<const std::vector<uint8_t>> data)>;
 
        void SetDataContextId(uint64_t data_ctx_id) noexcept { publish_data_ctx_id_ = data_ctx_id; };
 
        constexpr uint64_t GetDataContextId() const noexcept { return publish_data_ctx_id_; };
 
        void SetStatus(Status status) noexcept
        {
            publish_status_ = status;
            StatusChanged(status);
        }
 
        // --------------------------------------------------------------------------
        // Member variables
        // --------------------------------------------------------------------------
        Status publish_status_{ Status::kNotAnnounced };
        TrackMode default_track_mode_;
        uint8_t default_priority_; // Set by caller and is used when priority is not specified
        uint32_t default_ttl_;     // Set by caller and is used when TTL is not specified
 
        uint64_t publish_data_ctx_id_;                  // set byte the transport; publishing data context ID
        PublishObjFunction publish_object_func_;        // set by the transport
        ForwardDataFunction forward_publish_data_func_; // set by the transport
 
        uint64_t prev_object_group_id_{ 0 };
        uint64_t prev_sub_group_id_{ 0 };
        uint64_t prev_object_id_{ 0 };
        uint64_t object_payload_remaining_length_{ 0 };
        bool sent_first_header_{ false }; // Used to indicate if the first stream has sent the header or not
 
        Bytes object_msg_buffer_; // TODO(tievens): Review shrink/resize
 
        friend class Transport;
        friend class Client;
        friend class Server;
    };
 
} // namespace moq