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/transport.h>
#include <quicr/object.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<Bytes> reason_phrase;
        };
 
        Server(const ServerConfig& cfg)
          : Transport(cfg, std::make_shared<ThreadedTickService>())
        {
        }
 
        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,
                                uint64_t subscribe_id,
                                const std::shared_ptr<PublishTrackHandler>& track_handler,
                                bool ephemeral = false);
 
        void UnbindPublisherTrack(ConnectionHandle connection_handle,
                                  const std::shared_ptr<PublishTrackHandler>& track_handler);
 
        virtual void ResolveSubscribe(ConnectionHandle connection_handle,
                                      uint64_t subscribe_id,
                                      const SubscribeResponse& subscribe_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,
                             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::SubscribeAnnouncesErrorCode>, 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 subscribe_id,
                                       uint64_t proposed_track_alias,
                                       quicr::messages::FilterType filter_type,
                                       const FullTrackName& track_full_name,
                                       const SubscribeAttributes& subscribe_attributes);
 
        virtual void UnsubscribeReceived(ConnectionHandle connection_handle, uint64_t subscribe_id) = 0;
 
        virtual bool FetchReceived(ConnectionHandle connection_handle,
                                   uint64_t subscribe_id,
                                   const FullTrackName& track_full_name,
                                   const FetchAttributes& attributes);
 
        virtual void OnFetchOk(ConnectionHandle connection_handle,
                               uint64_t subscribe_id,
                               const FullTrackName& track_full_name,
                               const FetchAttributes& attributes);
 
        virtual void FetchCancelReceived(ConnectionHandle connection_handle, uint64_t subscribe_id) = 0;
 
        virtual void NewGroupRequested(ConnectionHandle connection_handle, uint64_t subscribe_id, uint64_t track_alias);
 
        // --END OF CALLBACKS ----------------------------------------------------------------------------------
 
      private:
        bool ProcessCtrlMessage(ConnectionContext& conn_ctx, BytesSpan msg_bytes) override;
 
        bool stop_{ false };
    };
 
} // namespace moq