session_callbacks.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/errors.h"
#include "quicr/reply.h"
#include "quicr/session.h"
#include "quicr/utilities/expected.h"
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace quicr {
 
    class SubscribeNamespaceHandler;
 
    enum class RequestErrorCode : uint8_t
    {
        kInternalError = 1,       
        kUnauthorized,            
        kTimeout,                 
        kNotSupported,            
        kMalformedAuthToken,      
        kExpiredAuthToken,        
        kDoesNotExist,            
        kInvalidRange,            
        kMalformedTrack,          
        kDuplicateSubscription,   
        kUninterested,            
        kPrefixOverlap,           
        kInvalidJoiningRequestId, 
        kRedirect,                
        kGoingAway,               
    };
 
    enum class PublishErrorCode : std::uint8_t
    {
        kInternalError = 1, 
        kNotSupported,      
        kNotAuthorized,     
        kRejected,          
    };
 
    struct PublishResponse
    {
        const PublishOkAttributes attributes; 
 
        std::shared_ptr<SubscribeTrackHandler>
          handler; 
    };
 
    enum class PublishNamespaceErrorCode : uint8_t
    {
        kOk = 0,       
        kInternalError 
    };
 
    enum class FetchErrorCode : uint8_t
    {
        kOk = 0,        
        kInvalidRange,  
        kNoObjects,     
        kInternalError, 
        // TODO: Expand reasons.
    };
 
    struct Session::Callbacks
    {
        virtual ~Callbacks() = default;
 
        virtual Expected<void, Error<ErrorCode>> SetupReceived(const std::shared_ptr<Session>& session,
                                                               const SetupAttributes& setup_attributes);
 
        virtual void OnStreamClosed(std::uint64_t stream_id, StreamClosedFlag flag);
 
        virtual void StatusChanged(const std::shared_ptr<Session>& session, Status status);
 
        virtual void MetricsSampled(const std::shared_ptr<Session>& session, const ConnectionMetrics& metrics);
 
        virtual Reply<const PublishResponse, PublishErrorCode> PublishReceived(
          const std::shared_ptr<Session>& session,
          std::uint64_t request_id,
          const PublishAttributes& publish_attributes,
          std::weak_ptr<SubscribeNamespaceHandler> sub_ns_handler);
 
        virtual Reply<void, PublishNamespaceErrorCode> PublishNamespaceReceived(
          const std::shared_ptr<Session>& session,
          const TrackNamespace& track_namespace,
          const PublishNamespaceAttributes& publish_namespace_attributes);
 
        virtual Reply<const FetchResponse, FetchErrorCode> StandaloneFetchReceived(
          const std::shared_ptr<Session>& session,
          std::uint64_t request_id,
          const FullTrackName& track_full_name,
          const StandaloneFetchAttributes& attributes);
 
        virtual Reply<const FetchResponse, FetchErrorCode> JoiningFetchReceived(
          const std::shared_ptr<Session>& session,
          std::uint64_t request_id,
          const FullTrackName& track_full_name,
          const JoiningFetchAttributes& attributes);
 
        virtual Reply<void, FetchErrorCode> FetchCancelReceived(const std::shared_ptr<Session>& session,
                                                                std::uint64_t request_id);
 
        virtual Reply<TrackStatusResponse, RequestErrorCode> TrackStatusReceived(
          const std::shared_ptr<Session>& session,
          const FullTrackName& track_full_name);
    };
 
    struct Session::ClientCallbacks : public Session::Callbacks
    {
        virtual ~ClientCallbacks() = default;
 
        virtual Reply<void, ErrorCode> UnpublishedSubscribeReceived(const std::shared_ptr<Session>& session,
                                                                    const FullTrackName& track_full_name,
                                                                    const SubscribeAttributes& subscribe_attributes);
    };
 
    struct Session::ServerCallbacks : public Session::Callbacks
    {
        virtual ~ServerCallbacks() = default;
 
        virtual void OnStreamClosed(std::uint64_t stream_id, StreamClosedFlag flag);
 
        virtual Reply<std::vector<TrackNamespace>, RequestErrorCode> SubscribeNamespaceReceived(
          const std::shared_ptr<Session>& session,
          const TrackNamespace& prefix_namespace,
          const SubscribeNamespaceAttributes& attributes);
 
        virtual Reply<std::vector<TrackNamespace>, RequestErrorCode> SubscribeTracksReceived(
          const std::shared_ptr<Session>& session,
          const TrackNamespace& prefix_namespace,
          const SubscribeNamespaceAttributes& attributes);
 
        virtual Reply<SubscribeResponse, RequestErrorCode> SubscribeReceived(
          const std::shared_ptr<Session>& session,
          std::uint64_t request_id,
          const FullTrackName& track_full_name,
          const SubscribeAttributes& subscribe_attributes);
 
        virtual Reply<void, ErrorCode> NewGroupRequested(const FullTrackName& track_full_name, std::uint64_t group_id);
 
        virtual void PublishNamespaceDoneReceived(const std::shared_ptr<Session>& session, std::uint64_t request_id);
 
        virtual void UnsubscribeNamespaceReceived(const std::shared_ptr<Session>& session,
                                                  const TrackNamespace& prefix_namespace);
 
        virtual void UnsubscribeReceived(const std::shared_ptr<Session>& session, std::uint64_t request_id);
 
        virtual void PublishDoneReceived(const std::shared_ptr<Session>& session, std::uint64_t request_id);
    };
}