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/detail/messages.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,
 
            kPaused
        };

        enum class Status : uint8_t
        {
            kOk = 0,
            kNotConnected,
            kNotAnnounced,
            kPendingAnnounceResponse,
            kAnnounceNotAuthorized,
            kNoSubscribers,
            kSendingUnannounce, 
            kSubscriptionUpdated,
            kNewGroupRequested,
            kPendingPublishOk,
            kPaused,
        };
 
      protected:
        PublishTrackHandler(const FullTrackName& full_track_name,
                            TrackMode track_mode,
                            uint8_t default_priority,
                            uint32_t default_ttl,
                            std::optional<messages::StreamHeaderType> stream_mode = std::nullopt)
          : BaseTrackHandler(full_track_name)
          , default_track_mode_(track_mode)
          , default_priority_(default_priority)
          , default_ttl_(default_ttl)
        {
            switch (track_mode) {
                case TrackMode::kDatagram:
                    if (stream_mode.has_value()) {
                        throw std::invalid_argument("Datagram track mode should not specify a stream mode");
                    }
                    break;
                case TrackMode::kStream:
                    // TODO: Is a default acceptable, or enforce?
                    stream_mode_ = stream_mode.has_value()
                                     ? stream_mode.value()
                                     : messages::StreamHeaderType::kSubgroup0NotEndOfGroupWithExtensions;
                    break;
            }
        }
 
      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));
        }
 
        // TODO: Is this all the info needed for an alias calculation?
 
        // --------------------------------------------------------------------------
        // 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; }

        constexpr uint8_t GetDefaultPriority() const noexcept { return default_priority_; }

        void SetDefaultTTL(const uint32_t ttl) noexcept { default_ttl_ = ttl; }

        void SetDefaultTrackMode(const TrackMode track_mode) noexcept { default_track_mode_ = track_mode; }

        constexpr messages::StreamHeaderType GetStreamMode() const noexcept { return stream_mode_; }

        constexpr Status GetStatus() const noexcept { return publish_status_; }

        constexpr bool UsingAnnounce() const noexcept { return use_announce; }

        constexpr void SetUseAnnounce(bool use) noexcept { use_announce = use; }
 
        // --------------------------------------------------------------------------
        // Methods that normally do not need to be overridden
        // --------------------------------------------------------------------------

        constexpr bool CanPublish() const noexcept
        {
            switch (publish_status_) {
                case Status::kOk:
                case Status::kNewGroupRequested:
                case Status::kSubscriptionUpdated:
                    return true;
                default:
                    return false;
            }
        }

        void SetTrackAlias(uint64_t track_alias) { track_alias_ = track_alias; }

        std::optional<uint64_t> GetTrackAlias() const noexcept { return track_alias_; }

        virtual 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
        // --------------------------------------------------------------------------
      protected:
        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_;
        messages::StreamHeaderType stream_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
 
        uint64_t latest_group_id_{ 0 };
        uint64_t latest_sub_group_id_{ 0 };
        uint64_t latest_object_id_{ 0 };
        uint64_t object_payload_remaining_length_{ 0 };
        std::optional<uint64_t> track_alias_;
 
        // Used to indicate if the first object has been seen or not (start of publish)
        bool seen_first_object_{ false };
 
        Bytes object_msg_buffer_; // TODO(tievens): Review shrink/resize
 
        bool use_announce{ false }; // Indicates to use announce publish flow if true, otherwise use publish flow
 
        friend class Transport;
        friend class Client;
        friend class Server;
    };
 
} // namespace moq