server.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/detail/messages.h"
#include <quicr/config.h>
#include <quicr/detail/attributes.h>
#include <quicr/detail/transport.h>
#include <quicr/object.h>
#include <quicr/publish_fetch_handler.h>
#include <quicr/track_name.h>
 
namespace quicr {
    using namespace quicr;

    class Server : public Transport
    {
      public:
        struct ClientSetupResponse
        {};

        struct AnnounceResponse
        {
            enum class ReasonCode : uint8_t
            {
                kOk = 0,
                kInternalError
            };
            ReasonCode reason_code;
 
            std::optional<messages::ReasonPhrase> error_reason;
        };

        Server(const ServerConfig& cfg)
          : Transport(cfg, std::make_shared<ThreadedTickService>(cfg.tick_service_sleep_delay_us))
        {
        }
 
        Server(const ServerConfig& cfg, std::shared_ptr<ThreadedTickService> tick_service)
          : Transport(cfg, tick_service)
        {
        }
 
        ~Server() = default;

        Status Start();

        void Stop();

        void BindPublisherTrack(ConnectionHandle connection_handle,
                                ConnectionHandle src_id,
                                uint64_t request_id,
                                const std::shared_ptr<PublishTrackHandler>& track_handler,
                                bool ephemeral = false);

        void UnbindPublisherTrack(ConnectionHandle connection_handle,
                                  ConnectionHandle src_id,
                                  const std::shared_ptr<PublishTrackHandler>& track_handler);

        void BindFetchTrack(TransportConnId conn_id, std::shared_ptr<PublishFetchHandler> track_handler);

        void UnbindFetchTrack(ConnectionHandle conn_id, const std::shared_ptr<PublishFetchHandler>& track_handler);

        virtual void ResolveSubscribe(ConnectionHandle connection_handle,
                                      uint64_t request_id,
                                      uint64_t track_alias,
                                      const SubscribeResponse& subscribe_response);

        virtual void ResolvePublish(ConnectionHandle connection_handle,
                                    uint64_t request_id,
                                    bool forward,
                                    messages::SubscriberPriority priority,
                                    messages::GroupOrder group_order,
                                    const PublishResponse& publish_response);
 
        // --BEGIN CALLBACKS ----------------------------------------------------------------------------------

        void NewConnectionAccepted(ConnectionHandle connection_handle, const ConnectionRemoteInfo& remote) override;

        void ConnectionStatusChanged(ConnectionHandle connection_handle, ConnectionStatus status) override;

        void MetricsSampled(ConnectionHandle connection_handle, const ConnectionMetrics& metrics) override;

        virtual ClientSetupResponse ClientSetupReceived(ConnectionHandle connection_handle,
                                                        const ClientSetupAttributes& client_setup_attributes) = 0;

        virtual void AnnounceReceived(ConnectionHandle connection_handle,
                                      const TrackNamespace& track_namespace,
                                      const PublishAnnounceAttributes& publish_announce_attributes);

        void ResolveAnnounce(ConnectionHandle connection_handle,
                             uint64_t request_id,
                             const TrackNamespace& track_namespace,
                             const std::vector<ConnectionHandle>& subscribers,
                             const AnnounceResponse& announce_response);

        virtual std::vector<ConnectionHandle> UnannounceReceived(ConnectionHandle connection_handle,
                                                                 const TrackNamespace& track_namespace) = 0;

        virtual void UnsubscribeAnnouncesReceived(ConnectionHandle connection_handle,
                                                  const TrackNamespace& prefix_namespace) = 0;

        using SubscribeAnnouncesResponse =
          std::pair<std::optional<messages::SubscribeNamespaceErrorCode>, std::vector<TrackNamespace>>;
 
        virtual SubscribeAnnouncesResponse SubscribeAnnouncesReceived(
          ConnectionHandle connection_handle,
          const TrackNamespace& prefix_namespace,
          const PublishAnnounceAttributes& announce_attributes);

        virtual void SubscribeReceived(ConnectionHandle connection_handle,
                                       uint64_t request_id,
                                       messages::FilterType filter_type,
                                       const FullTrackName& track_full_name,
                                       const messages::SubscribeAttributes& subscribe_attributes);

        virtual void UnsubscribeReceived(ConnectionHandle connection_handle, uint64_t request_id) = 0;

        virtual std::optional<messages::Location> GetLargestAvailable(const FullTrackName& track_name);

        virtual bool FetchReceived(ConnectionHandle connection_handle,
                                   uint64_t request_id,
                                   const FullTrackName& track_full_name,
                                   const quicr::messages::FetchAttributes& attributes) override;

        virtual bool OnFetchOk(ConnectionHandle connection_handle,
                               uint64_t request_id,
                               const FullTrackName& track_full_name,
                               const messages::FetchAttributes& attributes);

        virtual void FetchCancelReceived(ConnectionHandle connection_handle, uint64_t request_id) = 0;

        virtual void PublishReceived(ConnectionHandle connection_handle,
                                     uint64_t request_id,
                                     const FullTrackName& track_full_name,
                                     const messages::PublishAttributes& publish_attributes) = 0;

        virtual void SubscribeDoneReceived(ConnectionHandle connection_handle, uint64_t request_id) = 0;

        // --END OF CALLBACKS ----------------------------------------------------------------------------------
 
      private:
        bool ProcessCtrlMessage(ConnectionContext& conn_ctx, BytesSpan msg_bytes) override;
        PublishTrackHandler::PublishObjectStatus SendFetchObject(PublishFetchHandler& track_handler,
                                                                 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) const;
 
        bool stop_{ false };
    };
 
} // namespace moq