Update MoQT version to draft-13. Adopt new TRACK_STATUS/OK/ERROR framework -- messages are exactly like SUBSCRIBE. This change ended up propagating into the TrackPublisher/Session interface, where specific enums for Status codes are gone. APIs for retrieving track information are now safe if the data is being retrieved upstream. PiperOrigin-RevId: 794588585
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc index 15a00d2..c70164c 100644 --- a/quiche/quic/moqt/moqt_framer.cc +++ b/quiche/quic/moqt/moqt_framer.cc
@@ -399,7 +399,7 @@ } quiche::QuicheBuffer MoqtFramer::SerializeSubscribe( - const MoqtSubscribe& message) { + const MoqtSubscribe& message, MoqtMessageType message_type) { KeyValuePairList parameters; VersionSpecificParametersToKeyValuePairList(message.parameters, parameters); if (!ValidateVersionSpecificParameters(parameters, @@ -434,7 +434,7 @@ return quiche::QuicheBuffer(); } return SerializeControlMessage( - MoqtMessageType::kSubscribe, WireVarInt62(message.request_id), + message_type, WireVarInt62(message.request_id), WireFullTrackName(message.full_track_name), WireUint8(message.subscriber_priority), WireDeliveryOrder(message.group_order), WireBoolean(message.forward), @@ -445,7 +445,7 @@ } quiche::QuicheBuffer MoqtFramer::SerializeSubscribeOk( - const MoqtSubscribeOk& message) { + const MoqtSubscribeOk& message, MoqtMessageType message_type) { KeyValuePairList parameters; VersionSpecificParametersToKeyValuePairList(message.parameters, parameters); if (!ValidateVersionSpecificParameters(parameters, @@ -456,7 +456,7 @@ } if (message.largest_location.has_value()) { return SerializeControlMessage( - MoqtMessageType::kSubscribeOk, WireVarInt62(message.request_id), + message_type, WireVarInt62(message.request_id), WireVarInt62(message.track_alias), WireVarInt62(message.expires.ToMilliseconds()), WireDeliveryOrder(message.group_order), WireUint8(1), @@ -464,18 +464,18 @@ WireVarInt62(message.largest_location->object), WireKeyValuePairList(parameters)); } - return SerializeControlMessage( - MoqtMessageType::kSubscribeOk, WireVarInt62(message.request_id), - WireVarInt62(message.track_alias), - WireVarInt62(message.expires.ToMilliseconds()), - WireDeliveryOrder(message.group_order), WireUint8(0), - WireKeyValuePairList(parameters)); + return SerializeControlMessage(message_type, WireVarInt62(message.request_id), + WireVarInt62(message.track_alias), + WireVarInt62(message.expires.ToMilliseconds()), + WireDeliveryOrder(message.group_order), + WireUint8(0), + WireKeyValuePairList(parameters)); } quiche::QuicheBuffer MoqtFramer::SerializeSubscribeError( - const MoqtSubscribeError& message) { + const MoqtSubscribeError& message, MoqtMessageType message_type) { return SerializeControlMessage( - MoqtMessageType::kSubscribeError, WireVarInt62(message.request_id), + message_type, WireVarInt62(message.request_id), WireVarInt62(message.error_code), WireStringWithVarInt62Length(message.reason_phrase)); } @@ -558,38 +558,19 @@ WireStringWithVarInt62Length(message.error_reason)); } -quiche::QuicheBuffer MoqtFramer::SerializeTrackStatusRequest( - const MoqtTrackStatusRequest& message) { - KeyValuePairList parameters; - VersionSpecificParametersToKeyValuePairList(message.parameters, parameters); - if (!ValidateVersionSpecificParameters( - parameters, MoqtMessageType::kTrackStatusRequest)) { - QUICHE_BUG(QUICHE_BUG_invalid_parameters) - << "Serializing invalid MoQT parameters"; - return quiche::QuicheBuffer(); - } - return SerializeControlMessage(MoqtMessageType::kTrackStatusRequest, - WireVarInt62(message.request_id), - WireFullTrackName(message.full_track_name), - WireKeyValuePairList(parameters)); -} - quiche::QuicheBuffer MoqtFramer::SerializeTrackStatus( const MoqtTrackStatus& message) { - KeyValuePairList parameters; - VersionSpecificParametersToKeyValuePairList(message.parameters, parameters); - if (!ValidateVersionSpecificParameters(parameters, - MoqtMessageType::kTrackStatus)) { - QUICHE_BUG(QUICHE_BUG_invalid_parameters) - << "Serializing invalid MoQT parameters"; - return quiche::QuicheBuffer(); - } - return SerializeControlMessage(MoqtMessageType::kTrackStatus, - WireVarInt62(message.request_id), - WireVarInt62(message.status_code), - WireVarInt62(message.largest_location.group), - WireVarInt62(message.largest_location.object), - WireKeyValuePairList(parameters)); + return SerializeSubscribe(message, MoqtMessageType::kTrackStatus); +} + +quiche::QuicheBuffer MoqtFramer::SerializeTrackStatusOk( + const MoqtTrackStatusOk& message) { + return SerializeSubscribeOk(message, MoqtMessageType::kTrackStatusOk); +} + +quiche::QuicheBuffer MoqtFramer::SerializeTrackStatusError( + const MoqtTrackStatusError& message) { + return SerializeSubscribeError(message, MoqtMessageType::kTrackStatusError); } quiche::QuicheBuffer MoqtFramer::SerializeGoAway(const MoqtGoAway& message) {
diff --git a/quiche/quic/moqt/moqt_framer.h b/quiche/quic/moqt/moqt_framer.h index b053255..650d75e 100644 --- a/quiche/quic/moqt/moqt_framer.h +++ b/quiche/quic/moqt/moqt_framer.h
@@ -39,10 +39,15 @@ quiche::QuicheBuffer SerializeClientSetup(const MoqtClientSetup& message); quiche::QuicheBuffer SerializeServerSetup(const MoqtServerSetup& message); // Returns an empty buffer if there is an illegal combination of locations. - quiche::QuicheBuffer SerializeSubscribe(const MoqtSubscribe& message); - quiche::QuicheBuffer SerializeSubscribeOk(const MoqtSubscribeOk& message); + quiche::QuicheBuffer SerializeSubscribe( + const MoqtSubscribe& message, + MoqtMessageType message_type = MoqtMessageType::kSubscribe); + quiche::QuicheBuffer SerializeSubscribeOk( + const MoqtSubscribeOk& message, + MoqtMessageType message_type = MoqtMessageType::kSubscribeOk); quiche::QuicheBuffer SerializeSubscribeError( - const MoqtSubscribeError& message); + const MoqtSubscribeError& message, + MoqtMessageType message_type = MoqtMessageType::kSubscribeError); quiche::QuicheBuffer SerializeUnsubscribe(const MoqtUnsubscribe& message); quiche::QuicheBuffer SerializeSubscribeDone(const MoqtSubscribeDone& message); quiche::QuicheBuffer SerializeSubscribeUpdate( @@ -53,9 +58,10 @@ quiche::QuicheBuffer SerializeUnannounce(const MoqtUnannounce& message); quiche::QuicheBuffer SerializeAnnounceCancel( const MoqtAnnounceCancel& message); - quiche::QuicheBuffer SerializeTrackStatusRequest( - const MoqtTrackStatusRequest& message); quiche::QuicheBuffer SerializeTrackStatus(const MoqtTrackStatus& message); + quiche::QuicheBuffer SerializeTrackStatusOk(const MoqtTrackStatusOk& message); + quiche::QuicheBuffer SerializeTrackStatusError( + const MoqtTrackStatusError& message); quiche::QuicheBuffer SerializeGoAway(const MoqtGoAway& message); quiche::QuicheBuffer SerializeSubscribeNamespace( const MoqtSubscribeNamespace& message);
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc index 1d9d547..2da7139 100644 --- a/quiche/quic/moqt/moqt_framer_test.cc +++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -39,13 +39,14 @@ MoqtMessageType::kSubscribeError, MoqtMessageType::kUnsubscribe, MoqtMessageType::kSubscribeDone, - MoqtMessageType::kAnnounceCancel, - MoqtMessageType::kTrackStatusRequest, - MoqtMessageType::kTrackStatus, MoqtMessageType::kAnnounce, MoqtMessageType::kAnnounceOk, MoqtMessageType::kAnnounceError, MoqtMessageType::kUnannounce, + MoqtMessageType::kAnnounceCancel, + MoqtMessageType::kTrackStatus, + MoqtMessageType::kTrackStatusOk, + MoqtMessageType::kTrackStatusError, MoqtMessageType::kGoAway, MoqtMessageType::kSubscribeNamespace, MoqtMessageType::kSubscribeNamespaceOk, @@ -150,22 +151,26 @@ auto data = std::get<MoqtAnnounceError>(structured_data); return framer_.SerializeAnnounceError(data); } - case moqt::MoqtMessageType::kAnnounceCancel: { - auto data = std::get<MoqtAnnounceCancel>(structured_data); - return framer_.SerializeAnnounceCancel(data); - } - case moqt::MoqtMessageType::kTrackStatusRequest: { - auto data = std::get<MoqtTrackStatusRequest>(structured_data); - return framer_.SerializeTrackStatusRequest(data); - } case MoqtMessageType::kUnannounce: { auto data = std::get<MoqtUnannounce>(structured_data); return framer_.SerializeUnannounce(data); } + case moqt::MoqtMessageType::kAnnounceCancel: { + auto data = std::get<MoqtAnnounceCancel>(structured_data); + return framer_.SerializeAnnounceCancel(data); + } case moqt::MoqtMessageType::kTrackStatus: { auto data = std::get<MoqtTrackStatus>(structured_data); return framer_.SerializeTrackStatus(data); } + case moqt::MoqtMessageType::kTrackStatusOk: { + auto data = std::get<MoqtTrackStatusOk>(structured_data); + return framer_.SerializeTrackStatusOk(data); + } + case moqt::MoqtMessageType::kTrackStatusError: { + auto data = std::get<MoqtTrackStatusError>(structured_data); + return framer_.SerializeTrackStatusError(data); + } case moqt::MoqtMessageType::kGoAway: { auto data = std::get<MoqtGoAway>(structured_data); return framer_.SerializeGoAway(data);
diff --git a/quiche/quic/moqt/moqt_integration_test.cc b/quiche/quic/moqt/moqt_integration_test.cc index 3325c2e..8c6b55c 100644 --- a/quiche/quic/moqt/moqt_integration_test.cc +++ b/quiche/quic/moqt/moqt_integration_test.cc
@@ -510,6 +510,10 @@ MockSubscribeRemoteTrackVisitor client_visitor; std::optional<absl::string_view> expected_reason = std::nullopt; bool received_ok = false; + ON_CALL(*track_publisher, expiration) + .WillByDefault(Return(quic::QuicTimeDelta::Zero())); + ON_CALL(*track_publisher, delivery_order) + .WillByDefault(Return(MoqtDeliveryOrder::kAscending)); EXPECT_CALL(*track_publisher, AddObjectListener) .WillOnce([&](MoqtObjectListener* listener) { listener->OnSubscribeAccepted(); @@ -536,6 +540,10 @@ MockSubscribeRemoteTrackVisitor client_visitor; std::optional<absl::string_view> expected_reason = std::nullopt; bool received_ok = false; + ON_CALL(*track_publisher, expiration) + .WillByDefault(Return(quic::QuicTimeDelta::Zero())); + ON_CALL(*track_publisher, delivery_order) + .WillByDefault(Return(MoqtDeliveryOrder::kAscending)); EXPECT_CALL(*track_publisher, AddObjectListener) .WillOnce([&](MoqtObjectListener* listener) { listener->OnSubscribeAccepted(); @@ -562,6 +570,10 @@ MockSubscribeRemoteTrackVisitor client_visitor; std::optional<absl::string_view> expected_reason = std::nullopt; bool received_ok = false; + ON_CALL(*track_publisher, expiration) + .WillByDefault(Return(quic::QuicTimeDelta::Zero())); + ON_CALL(*track_publisher, delivery_order) + .WillByDefault(Return(MoqtDeliveryOrder::kAscending)); EXPECT_CALL(*track_publisher, AddObjectListener) .WillOnce([&](MoqtObjectListener* listener) { listener->OnSubscribeAccepted(); @@ -597,7 +609,8 @@ MoqtKnownTrackPublisher publisher; server_->session()->set_publisher(&publisher); auto queue = std::make_shared<MoqtLiveRelayQueue>( - full_track_name, MoqtForwardingPreference::kSubgroup); + full_track_name, MoqtForwardingPreference::kSubgroup, + MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite()); publisher.Add(queue); MockSubscribeRemoteTrackVisitor client_visitor; @@ -669,6 +682,10 @@ VersionSpecificParameters parameters; parameters.oack_window_size = quic::QuicTimeDelta::FromMilliseconds(100); + ON_CALL(*track_publisher, expiration) + .WillByDefault(Return(quic::QuicTimeDelta::Zero())); + ON_CALL(*track_publisher, delivery_order) + .WillByDefault(Return(MoqtDeliveryOrder::kAscending)); client_->session()->SubscribeCurrentObject(full_track_name, &client_visitor, parameters); EXPECT_CALL(monitoring, OnObjectAckSupportKnown(parameters.oack_window_size)); @@ -694,6 +711,7 @@ server_->session()->set_publisher(&publisher); auto queue = std::make_shared<MoqtLiveRelayQueue>( full_track_name, MoqtForwardingPreference::kSubgroup, + MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite(), test_harness_.simulator().GetClock()); auto track_publisher = std::make_shared<MockTrackPublisher>(full_track_name); publisher.Add(queue); @@ -743,6 +761,7 @@ server_->session()->UseAlternateDeliveryTimeout(); auto queue = std::make_shared<MoqtLiveRelayQueue>( full_track_name, MoqtForwardingPreference::kSubgroup, + MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite(), test_harness_.simulator().GetClock()); auto track_publisher = std::make_shared<MockTrackPublisher>(full_track_name); publisher.Add(queue); @@ -755,6 +774,10 @@ VersionSpecificParameters parameters; // Set delivery timeout to ~ 1 RTT: any loss is fatal. parameters.delivery_timeout = quic::QuicTimeDelta::FromMilliseconds(100); + ON_CALL(*track_publisher, expiration) + .WillByDefault(Return(quic::QuicTimeDelta::Zero())); + ON_CALL(*track_publisher, delivery_order) + .WillByDefault(Return(MoqtDeliveryOrder::kAscending)); client_->session()->SubscribeCurrentObject(full_track_name, &client_visitor, parameters); bool success =
diff --git a/quiche/quic/moqt/moqt_live_relay_queue.cc b/quiche/quic/moqt/moqt_live_relay_queue.cc index 3468192..050a740 100644 --- a/quiche/quic/moqt/moqt_live_relay_queue.cc +++ b/quiche/quic/moqt/moqt_live_relay_queue.cc
@@ -7,16 +7,12 @@ #include <cstdint> #include <memory> #include <optional> -#include <vector> #include "absl/base/attributes.h" -#include "absl/status/statusor.h" #include "absl/strings/string_view.h" #include "quiche/quic/moqt/moqt_cached_object.h" #include "quiche/quic/moqt/moqt_messages.h" -#include "quiche/quic/moqt/moqt_priority.h" #include "quiche/quic/moqt/moqt_publisher.h" -#include "quiche/quic/moqt/moqt_subscribe_windows.h" #include "quiche/common/platform/api/quiche_logging.h" #include "quiche/common/quiche_buffer_allocator.h" #include "quiche/common/quiche_callbacks.h" @@ -27,11 +23,9 @@ namespace moqt { bool MoqtLiveRelayQueue::AddFin(Location sequence, uint64_t subgroup) { - switch (forwarding_preference_) { - case MoqtForwardingPreference::kDatagram: - return false; - case MoqtForwardingPreference::kSubgroup: - break; + if (!forwarding_preference_.has_value() || + *forwarding_preference_ == MoqtForwardingPreference::kDatagram) { + return false; } auto group_it = queue_.find(sequence.group); if (group_it == queue_.end()) { @@ -39,8 +33,7 @@ return false; } Group& group = group_it->second; - auto subgroup_it = - group.subgroups.find(SubgroupPriority{publisher_priority_, subgroup}); + auto subgroup_it = group.subgroups.find(subgroup); if (subgroup_it == group.subgroups.end()) { // Subgroup does not exist. return false; @@ -61,29 +54,27 @@ } bool MoqtLiveRelayQueue::OnStreamReset( - Location sequence, uint64_t subgroup_id, + uint64_t group_id, uint64_t subgroup_id, webtransport::StreamErrorCode error_code) { - switch (forwarding_preference_) { - case MoqtForwardingPreference::kDatagram: - return false; - case MoqtForwardingPreference::kSubgroup: - break; + if (!forwarding_preference_.has_value() || + *forwarding_preference_ == MoqtForwardingPreference::kDatagram) { + return false; } - auto group_it = queue_.find(sequence.group); + auto group_it = queue_.find(group_id); if (group_it == queue_.end()) { // Group does not exist. return false; } Group& group = group_it->second; - auto subgroup_it = - group.subgroups.find(SubgroupPriority{publisher_priority_, subgroup_id}); + auto subgroup_it = group.subgroups.find(subgroup_id); if (subgroup_it == group.subgroups.end()) { // Subgroup does not exist. return false; } for (MoqtObjectListener* listener : listeners_) { - listener->OnSubgroupAbandoned(sequence.group, subgroup_id, error_code); + listener->OnSubgroupAbandoned(group_id, subgroup_id, error_code); } + group.subgroups.erase(subgroup_id); return true; } @@ -134,12 +125,15 @@ return false; } } - // TODO: use `metadata.publisher_priority` instead. - auto subgroup_it = group.subgroups.try_emplace( - SubgroupPriority{publisher_priority_, metadata.subgroup}); + auto subgroup_it = group.subgroups.try_emplace(metadata.subgroup); auto& subgroup = subgroup_it.first->second; if (!subgroup.empty()) { // Check if the new object is valid CachedObject& last_object = subgroup.rbegin()->second; + if (last_object.metadata.publisher_priority != + metadata.publisher_priority) { + QUICHE_DLOG(INFO) << "Publisher priority changing in a subgroup"; + return false; + } if (last_object.fin_after_this) { QUICHE_DLOG(INFO) << "Skipping object because it is after the end of the " << "subgroup"; @@ -184,21 +178,21 @@ subgroup.emplace(sequence.object, CachedObject{metadata, slice, last_object_in_stream}); for (MoqtObjectListener* listener : listeners_) { - listener->OnNewObjectAvailable(sequence, metadata.subgroup); + listener->OnNewObjectAvailable(sequence, metadata.subgroup, + metadata.publisher_priority); } return true; } std::optional<PublishedObject> MoqtLiveRelayQueue::GetCachedObject( - uint64_t group_id, uint64_t subgroup_id, uint64_t object_id) const { + uint64_t group_id, uint64_t subgroup_id, uint64_t min_object_id) const { auto group_it = queue_.find(group_id); if (group_it == queue_.end()) { // Group does not exist. return std::nullopt; } const Group& group = group_it->second; - auto subgroup_it = - group.subgroups.find(SubgroupPriority{publisher_priority_, subgroup_id}); + auto subgroup_it = group.subgroups.find(subgroup_id); if (subgroup_it == group.subgroups.end()) { // Subgroup does not exist. return std::nullopt; @@ -207,8 +201,8 @@ if (subgroup.empty()) { return std::nullopt; // There are no objects. } - // Find an object with ID of at least sequence.object. - auto object_it = subgroup.lower_bound(object_id); + // Find an object with ID of at least min_object_id. + auto object_it = subgroup.lower_bound(min_object_id); if (object_it == subgroup.end()) { // No object after the last one received. return std::nullopt; @@ -227,18 +221,10 @@ } } -absl::StatusOr<MoqtTrackStatusCode> MoqtLiveRelayQueue::GetTrackStatus() const { - if (end_of_track_.has_value()) { - return MoqtTrackStatusCode::kFinished; - } +std::optional<Location> MoqtLiveRelayQueue::largest_location() const { if (queue_.empty()) { - // TODO(martinduke): Retrieve the track status from upstream. - return MoqtTrackStatusCode::kNotYetBegun; + return std::nullopt; } - return MoqtTrackStatusCode::kInProgress; -} - -Location MoqtLiveRelayQueue::GetLargestLocation() const { return Location{next_sequence_.group, next_sequence_.object - 1}; }
diff --git a/quiche/quic/moqt/moqt_live_relay_queue.h b/quiche/quic/moqt/moqt_live_relay_queue.h index eb81b52..2417835 100644 --- a/quiche/quic/moqt/moqt_live_relay_queue.h +++ b/quiche/quic/moqt/moqt_live_relay_queue.h
@@ -14,10 +14,10 @@ #include "absl/container/btree_map.h" #include "absl/container/flat_hash_set.h" #include "absl/status/status.h" -#include "absl/status/statusor.h" #include "absl/strings/string_view.h" #include "quiche/quic/core/quic_clock.h" #include "quiche/quic/core/quic_default_clock.h" +#include "quiche/quic/core/quic_time.h" #include "quiche/quic/moqt/moqt_cached_object.h" #include "quiche/quic/moqt/moqt_failed_fetch.h" #include "quiche/quic/moqt/moqt_messages.h" @@ -41,11 +41,16 @@ class MoqtLiveRelayQueue : public MoqtTrackPublisher { public: MoqtLiveRelayQueue( - FullTrackName track, MoqtForwardingPreference forwarding_preference, + FullTrackName track, + std::optional<MoqtForwardingPreference> forwarding_preference, + std::optional<MoqtDeliveryOrder> delivery_order, + std::optional<quic::QuicTime> expiration = quic::QuicTime::Infinite(), const quic::QuicClock* clock = quic::QuicDefaultClock::Get()) : clock_(clock), track_(std::move(track)), forwarding_preference_(forwarding_preference), + delivery_order_(delivery_order), + expiration_(expiration), next_sequence_(0, 0) {} MoqtLiveRelayQueue(const MoqtLiveRelayQueue&) = delete; @@ -83,16 +88,15 @@ return AddObject(metadata, object, fin); } - // Record a received FIN that did not come with the last object. + // Record a received FIN from upstream that did not come with the last object. // If the forwarding preference is kDatagram or kTrack, |sequence| is ignored. // Otherwise, |sequence| is used to determine which stream is being FINed. If // the object ID does not match the last object ID in the stream, no action // is taken. bool AddFin(Location sequence, uint64_t subgroup_id); - // Record a received RESET_STREAM. |sequence| encodes the group and subgroup - // of the stream that is being reset. Returns false on datagram tracks, or if - // the stream does not exist. - bool OnStreamReset(Location sequence, uint64_t subgroup_id, + // Record a received RESET_STREAM from upstream. Returns false on datagram + // tracks, or if the stream does not exist. + bool OnStreamReset(uint64_t group_id, uint64_t subgroup_id, webtransport::StreamErrorCode error_code); // MoqtTrackPublisher implementation. @@ -107,30 +111,41 @@ void RemoveObjectListener(MoqtObjectListener* listener) override { listeners_.erase(listener); } - absl::StatusOr<MoqtTrackStatusCode> GetTrackStatus() const override; - Location GetLargestLocation() const override; - MoqtForwardingPreference GetForwardingPreference() const override { + std::optional<Location> largest_location() const override; + std::optional<MoqtForwardingPreference> forwarding_preference() + const override { return forwarding_preference_; } - MoqtPriority GetPublisherPriority() const override { - return publisher_priority_; - } - MoqtDeliveryOrder GetDeliveryOrder() const override { + std::optional<MoqtDeliveryOrder> delivery_order() const override { return delivery_order_; } + std::optional<quic::QuicTimeDelta> expiration() const override { + if (!expiration_.has_value()) { + return std::nullopt; + } + if (expiration_ == quic::QuicTime::Infinite()) { + return quic::QuicTimeDelta::Zero(); + } + if (expiration_ < clock_->Now()) { + // TODO(martinduke): Tear everything down; the track is expired. + return quic::QuicTimeDelta::Zero(); + } + return clock_->Now() - *expiration_; + } std::unique_ptr<MoqtFetchTask> StandaloneFetch( Location /*start*/, Location /*end*/, - MoqtDeliveryOrder /*order*/) override { + std::optional<MoqtDeliveryOrder> /*order*/) override { return std::make_unique<MoqtFailedFetch>( absl::UnimplementedError("Fetch not implemented")); } std::unique_ptr<MoqtFetchTask> RelativeFetch( - uint64_t /*group_diff*/, MoqtDeliveryOrder /*order*/) override { + uint64_t /*group_diff*/, + std::optional<MoqtDeliveryOrder> /*order*/) override { return std::make_unique<MoqtFailedFetch>( absl::UnimplementedError("Fetch not implemented")); } std::unique_ptr<MoqtFetchTask> AbsoluteFetch( - uint64_t /*group*/, MoqtDeliveryOrder /*order*/) override { + uint64_t /*group*/, std::optional<MoqtDeliveryOrder> /*order*/) override { return std::make_unique<MoqtFailedFetch>( absl::UnimplementedError("Fetch not implemented")); } @@ -159,14 +174,14 @@ struct Group { uint64_t next_object = 0; bool complete = false; // If true, kEndOfGroup has been received. - absl::btree_map<SubgroupPriority, Subgroup> subgroups; + absl::btree_map<uint64_t, Subgroup> subgroups; // Ordered by subgroup id. }; const quic::QuicClock* clock_; FullTrackName track_; - MoqtForwardingPreference forwarding_preference_; - MoqtPriority publisher_priority_ = 128; - MoqtDeliveryOrder delivery_order_ = MoqtDeliveryOrder::kAscending; + std::optional<MoqtForwardingPreference> forwarding_preference_; + std::optional<MoqtDeliveryOrder> delivery_order_; + std::optional<quic::QuicTime> expiration_; absl::btree_map<uint64_t, Group> queue_; // Ordered by group id. absl::flat_hash_set<MoqtObjectListener*> listeners_; std::optional<Location> end_of_track_;
diff --git a/quiche/quic/moqt/moqt_live_relay_queue_test.cc b/quiche/quic/moqt/moqt_live_relay_queue_test.cc index 3ddc2a9..aaee1ac 100644 --- a/quiche/quic/moqt/moqt_live_relay_queue_test.cc +++ b/quiche/quic/moqt/moqt_live_relay_queue_test.cc
@@ -8,8 +8,10 @@ #include <optional> #include "absl/strings/string_view.h" +#include "quiche/quic/core/quic_time.h" #include "quiche/quic/moqt/moqt_cached_object.h" #include "quiche/quic/moqt/moqt_messages.h" +#include "quiche/quic/moqt/moqt_priority.h" #include "quiche/quic/moqt/moqt_publisher.h" #include "quiche/quic/moqt/moqt_subscribe_windows.h" #include "quiche/common/platform/api/quiche_logging.h" @@ -24,12 +26,14 @@ public MoqtObjectListener { public: TestMoqtLiveRelayQueue() - : MoqtLiveRelayQueue(FullTrackName{"test", "track"}, - MoqtForwardingPreference::kSubgroup) { + : MoqtLiveRelayQueue( + FullTrackName{"test", "track"}, MoqtForwardingPreference::kSubgroup, + MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite()) { AddObjectListener(this); } - void OnNewObjectAvailable(Location sequence, uint64_t subgroup_id) { + void OnNewObjectAvailable(Location sequence, uint64_t subgroup_id, + MoqtPriority /*publisher_priority*/) { std::optional<PublishedObject> object = GetCachedObject(sequence.group, subgroup_id, sequence.object); QUICHE_CHECK(object.has_value()); @@ -64,8 +68,8 @@ void GetObjectsFromPast(const SubscribeWindow& window) { ForAllObjects([&](const CachedObject& object) { if (window.InWindow(object.metadata.location)) { - OnNewObjectAvailable(object.metadata.location, - object.metadata.subgroup); + OnNewObjectAvailable(object.metadata.location, object.metadata.subgroup, + object.metadata.publisher_priority); } }); } @@ -86,9 +90,7 @@ MOCK_METHOD(void, CloseTrack, (), ()); MOCK_METHOD(void, OnTrackPublisherGone, (), (override)); MOCK_METHOD(void, OnSubscribeAccepted, (), (override)); - MOCK_METHOD(void, OnSubscribeRejected, - (MoqtSubscribeErrorReason reason, - std::optional<uint64_t> track_alias), + MOCK_METHOD(void, OnSubscribeRejected, (MoqtSubscribeErrorReason reason), (override)); }; @@ -466,7 +468,7 @@ EXPECT_CALL(queue, OnSubgroupAbandoned(0, 0, 0x1)); } EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); - EXPECT_TRUE(queue.OnStreamReset(Location{0, 0}, 0, 0x1)); + EXPECT_TRUE(queue.OnStreamReset(0, 0, 0x1)); } } // namespace
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc index 64e706e..4fb893c 100644 --- a/quiche/quic/moqt/moqt_messages.cc +++ b/quiche/quic/moqt/moqt_messages.cc
@@ -176,14 +176,14 @@ const std::array<MoqtMessageType, 8> kAllowsAuthorization = { MoqtMessageType::kClientSetup, MoqtMessageType::kServerSetup, MoqtMessageType::kSubscribe, MoqtMessageType::kSubscribeNamespace, - MoqtMessageType::kAnnounce, MoqtMessageType::kTrackStatusRequest, + MoqtMessageType::kAnnounce, MoqtMessageType::kTrackStatus, MoqtMessageType::kFetch, MoqtMessageType::kPublish}; const std::array<MoqtMessageType, 6> kAllowsDeliveryTimeout = { MoqtMessageType::kSubscribe, MoqtMessageType::kSubscribeOk, - MoqtMessageType::kSubscribeUpdate, MoqtMessageType::kTrackStatus, + MoqtMessageType::kSubscribeUpdate, MoqtMessageType::kTrackStatusOk, MoqtMessageType::kPublish, MoqtMessageType::kPublishOk}; const std::array<MoqtMessageType, 4> kAllowsMaxCacheDuration = { - MoqtMessageType::kSubscribeOk, MoqtMessageType::kTrackStatus, + MoqtMessageType::kSubscribeOk, MoqtMessageType::kTrackStatusOk, MoqtMessageType::kFetchOk, MoqtMessageType::kPublish}; bool ValidateVersionSpecificParameters(const KeyValuePairList& parameters, MoqtMessageType message_type) { @@ -232,10 +232,12 @@ return "SUBSCRIBE_UPDATE"; case MoqtMessageType::kAnnounceCancel: return "ANNOUNCE_CANCEL"; - case MoqtMessageType::kTrackStatusRequest: - return "TRACK_STATUS_REQUEST"; case MoqtMessageType::kTrackStatus: return "TRACK_STATUS"; + case MoqtMessageType::kTrackStatusOk: + return "TRACK_STATUS_OK"; + case MoqtMessageType::kTrackStatusError: + return "TRACK_STATUS_ERROR"; case MoqtMessageType::kAnnounce: return "ANNOUNCE"; case MoqtMessageType::kAnnounceOk:
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h index 2838975..310778a 100644 --- a/quiche/quic/moqt/moqt_messages.h +++ b/quiche/quic/moqt/moqt_messages.h
@@ -41,11 +41,11 @@ } enum class MoqtVersion : uint64_t { - kDraft12 = 0xff00000c, + kDraft13 = 0xff00000d, kUnrecognizedVersionForTests = 0xfe0000ff, }; -inline constexpr MoqtVersion kDefaultMoqtVersion = MoqtVersion::kDraft12; +inline constexpr MoqtVersion kDefaultMoqtVersion = MoqtVersion::kDraft13; inline constexpr uint64_t kDefaultInitialMaxRequestId = 100; // TODO(martinduke): Implement an auth token cache. inline constexpr uint64_t kDefaultMaxAuthTokenCacheSize = 0; @@ -129,7 +129,8 @@ static std::optional<MoqtDataStreamType> FromValue(uint64_t value) { MoqtDataStreamType stream_type(value); if (stream_type.IsFetch() || stream_type.IsPadding() || - stream_type.IsSubgroup()) { + (!((value & kSubgroupIdFlag) && (value & kFirstObjectIdFlag)) && + stream_type.IsSubgroup())) { return stream_type; } return std::nullopt; @@ -161,8 +162,9 @@ bool IsFetch() const { return value_ == kFetch; } bool IsPadding() const { return value_ == kPadding; } bool IsSubgroup() const { - return (value_ & kSubgroupFlag) && (value_ & ~0x1f) == 0 && - !((value_ & kSubgroupIdFlag) && (value_ & kFirstObjectIdFlag)); + QUICHE_CHECK( + !((value_ & kSubgroupIdFlag) && (value_ & kFirstObjectIdFlag))); + return (value_ & kSubgroupFlag) && (value_ & ~0x1f) == 0; } bool IsSubgroupPresent() const { return IsSubgroup() && (value_ & kSubgroupIdFlag); @@ -240,8 +242,9 @@ kUnsubscribe = 0x0a, kSubscribeDone = 0x0b, kAnnounceCancel = 0x0c, - kTrackStatusRequest = 0x0d, - kTrackStatus = 0x0e, + kTrackStatus = 0x0d, + kTrackStatusOk = 0x0e, + kTrackStatusError = 0x0f, kGoAway = 0x10, kSubscribeNamespace = 0x11, kSubscribeNamespaceOk = 0x12, @@ -323,7 +326,7 @@ max_cache_duration(max_cache_duration) {} VersionSpecificParameters(AuthTokenType token_type, absl::string_view token) { authorization_token.emplace_back(token_type, token); - }; + } VersionSpecificParameters(quic::QuicTimeDelta delivery_timeout, AuthTokenType token_type, absl::string_view token) : delivery_timeout(delivery_timeout) { @@ -725,38 +728,21 @@ std::string error_reason; }; -enum class QUICHE_EXPORT MoqtTrackStatusCode : uint64_t { - kInProgress = 0x0, - kDoesNotExist = 0x1, - kNotYetBegun = 0x2, - kFinished = 0x3, - kStatusNotAvailable = 0x4, +struct QUICHE_EXPORT MoqtTrackStatus : public MoqtSubscribe { + MoqtTrackStatus() = default; + MoqtTrackStatus(MoqtSubscribe subscribe) : MoqtSubscribe(subscribe) {} }; -inline bool DoesTrackStatusImplyHavingData(MoqtTrackStatusCode code) { - switch (code) { - case MoqtTrackStatusCode::kInProgress: - case MoqtTrackStatusCode::kFinished: - return true; - case MoqtTrackStatusCode::kDoesNotExist: - case MoqtTrackStatusCode::kNotYetBegun: - case MoqtTrackStatusCode::kStatusNotAvailable: - return false; - } - return false; -} - -struct QUICHE_EXPORT MoqtTrackStatusRequest { - uint64_t request_id; - FullTrackName full_track_name; - VersionSpecificParameters parameters; +struct QUICHE_EXPORT MoqtTrackStatusOk : public MoqtSubscribeOk { + MoqtTrackStatusOk() = default; + MoqtTrackStatusOk(MoqtSubscribeOk subscribe_ok) + : MoqtSubscribeOk(subscribe_ok) {} }; -struct QUICHE_EXPORT MoqtTrackStatus { - uint64_t request_id; - MoqtTrackStatusCode status_code; - Location largest_location; - VersionSpecificParameters parameters; +struct QUICHE_EXPORT MoqtTrackStatusError : public MoqtSubscribeError { + MoqtTrackStatusError() = default; + MoqtTrackStatusError(MoqtSubscribeError subscribe_error) + : MoqtSubscribeError(subscribe_error) {} }; struct QUICHE_EXPORT MoqtGoAway {
diff --git a/quiche/quic/moqt/moqt_outgoing_queue.cc b/quiche/quic/moqt/moqt_outgoing_queue.cc index 63e0140..8e434e3 100644 --- a/quiche/quic/moqt/moqt_outgoing_queue.cc +++ b/quiche/quic/moqt/moqt_outgoing_queue.cc
@@ -82,7 +82,8 @@ clock_->ApproximateNow()}, std::make_shared<quiche::QuicheMemSlice>(std::move(payload)), fin}); for (MoqtObjectListener* listener : listeners_) { - listener->OnNewObjectAvailable(sequence, /*subgroup=*/0); + listener->OnNewObjectAvailable(sequence, /*subgroup=*/0, + publisher_priority_); } } @@ -126,27 +127,15 @@ return sequences; } -absl::StatusOr<MoqtTrackStatusCode> MoqtOutgoingQueue::GetTrackStatus() const { - if (closed_) { - return MoqtTrackStatusCode::kFinished; - } +std::optional<Location> MoqtOutgoingQueue::largest_location() const { if (queue_.empty()) { - return MoqtTrackStatusCode::kNotYetBegun; - } - return MoqtTrackStatusCode::kInProgress; -} - -Location MoqtOutgoingQueue::GetLargestLocation() const { - if (queue_.empty()) { - QUICHE_BUG(MoqtOutgoingQueue_GetLargestLocation_not_begun) - << "Calling GetLargestLocation() on a track that hasn't begun"; - return Location{0, 0}; + return std::nullopt; } return Location{current_group_id_, queue_.back().size() - 1}; } std::unique_ptr<MoqtFetchTask> MoqtOutgoingQueue::StandaloneFetch( - Location start, Location end, MoqtDeliveryOrder order) { + Location start, Location end, std::optional<MoqtDeliveryOrder> order) { if (queue_.empty()) { return std::make_unique<MoqtFailedFetch>( absl::NotFoundError("No objects available on the track")); @@ -169,21 +158,15 @@ Location adjusted_end = std::min(end, last_available_object); std::vector<Location> objects = GetCachedObjectsInRange(adjusted_start, adjusted_end); + // Default to ascending order. if (order == MoqtDeliveryOrder::kDescending) { - absl::c_reverse(objects); - for (auto it = objects.begin(); it != objects.end();) { - auto start_it = it; - while (it != objects.end() && it->group == start_it->group) { - ++it; - } - std::reverse(start_it, it); - } + ObjectsInDescendingOrder(objects); } return std::make_unique<FetchTask>(this, std::move(objects)); } std::unique_ptr<MoqtFetchTask> MoqtOutgoingQueue::RelativeFetch( - uint64_t group_diff, MoqtDeliveryOrder order) { + uint64_t group_diff, std::optional<MoqtDeliveryOrder> order) { if (queue_.empty()) { return std::make_unique<MoqtFailedFetch>( absl::NotFoundError("No objects available on the track")); @@ -204,7 +187,7 @@ } std::unique_ptr<MoqtFetchTask> MoqtOutgoingQueue::AbsoluteFetch( - uint64_t group, MoqtDeliveryOrder order) { + uint64_t group, std::optional<MoqtDeliveryOrder> order) { if (queue_.empty()) { return std::make_unique<MoqtFailedFetch>( absl::NotFoundError("No objects available on the track"));
diff --git a/quiche/quic/moqt/moqt_outgoing_queue.h b/quiche/quic/moqt/moqt_outgoing_queue.h index 1034792..cadd11c 100644 --- a/quiche/quic/moqt/moqt_outgoing_queue.h +++ b/quiche/quic/moqt/moqt_outgoing_queue.h
@@ -15,9 +15,9 @@ #include "absl/container/flat_hash_set.h" #include "absl/container/inlined_vector.h" #include "absl/status/status.h" -#include "absl/status/statusor.h" #include "quiche/quic/core/quic_clock.h" #include "quiche/quic/core/quic_default_clock.h" +#include "quiche/quic/core/quic_time.h" #include "quiche/quic/moqt/moqt_cached_object.h" #include "quiche/quic/moqt/moqt_messages.h" #include "quiche/quic/moqt/moqt_priority.h" @@ -63,23 +63,26 @@ void RemoveObjectListener(MoqtObjectListener* listener) override { listeners_.erase(listener); } - absl::StatusOr<MoqtTrackStatusCode> GetTrackStatus() const override; - Location GetLargestLocation() const override; - MoqtForwardingPreference GetForwardingPreference() const override { + + std::optional<Location> largest_location() const override; + std::optional<MoqtForwardingPreference> forwarding_preference() + const override { return forwarding_preference_; } - MoqtPriority GetPublisherPriority() const override { - return publisher_priority_; - } - MoqtDeliveryOrder GetDeliveryOrder() const override { + std::optional<MoqtDeliveryOrder> delivery_order() const override { return delivery_order_; } + std::optional<quic::QuicTimeDelta> expiration() const override { + return quic::QuicTimeDelta::Zero(); + } + std::unique_ptr<MoqtFetchTask> StandaloneFetch( - Location start, Location end, MoqtDeliveryOrder order) override; + Location start, Location end, + std::optional<MoqtDeliveryOrder> order) override; std::unique_ptr<MoqtFetchTask> RelativeFetch( - uint64_t group_diff, MoqtDeliveryOrder order) override; + uint64_t group_diff, std::optional<MoqtDeliveryOrder> order) override; std::unique_ptr<MoqtFetchTask> AbsoluteFetch( - uint64_t group, MoqtDeliveryOrder order) override; + uint64_t group, std::optional<MoqtDeliveryOrder> order) override; bool HasSubscribers() const { return !listeners_.empty(); } void SetDeliveryOrder(MoqtDeliveryOrder order) { @@ -102,6 +105,9 @@ std::vector<Location> GetCachedObjectsInRange(Location start, Location end) const; + protected: + MoqtPriority publisher_priority() const { return publisher_priority_; } + private: // The number of recent groups to keep around for newly joined subscribers. static constexpr size_t kMaxQueuedGroups = 3; @@ -144,7 +150,7 @@ ok.end_location = *(objects_.cbegin()); } ok.end_of_track = - queue_->closed_ && ok.end_location == queue_->GetLargestLocation(); + queue_->closed_ && ok.end_location == queue_->largest_location(); std::move(callback)(ok); }
diff --git a/quiche/quic/moqt/moqt_outgoing_queue_test.cc b/quiche/quic/moqt/moqt_outgoing_queue_test.cc index 841179c..d08897b 100644 --- a/quiche/quic/moqt/moqt_outgoing_queue_test.cc +++ b/quiche/quic/moqt/moqt_outgoing_queue_test.cc
@@ -47,7 +47,8 @@ AddObjectListener(this); } - void OnNewObjectAvailable(Location sequence, uint64_t subgroup) override { + void OnNewObjectAvailable(Location sequence, uint64_t subgroup, + MoqtPriority publisher_priority) override { std::optional<PublishedObject> object = GetCachedObject(sequence.group, subgroup, sequence.object); ASSERT_THAT(object, @@ -66,11 +67,14 @@ } void GetObjectsFromPast(const SubscribeWindow& window) { + if (!largest_location().has_value()) { + return; + } std::vector<Location> objects = - GetCachedObjectsInRange(Location(0, 0), GetLargestLocation()); + GetCachedObjectsInRange(Location(0, 0), *largest_location()); for (Location object : objects) { if (window.InWindow(object)) { - OnNewObjectAvailable(object, 0); + OnNewObjectAvailable(object, 0, publisher_priority()); } } } @@ -87,9 +91,7 @@ ()); MOCK_METHOD(void, OnTrackPublisherGone, (), (override)); MOCK_METHOD(void, OnSubscribeAccepted, (), (override)); - MOCK_METHOD(void, OnSubscribeRejected, - (MoqtSubscribeErrorReason reason, - std::optional<uint64_t> track_alias), + MOCK_METHOD(void, OnSubscribeRejected, (MoqtSubscribeErrorReason reason), (override)); }; @@ -448,7 +450,7 @@ EXPECT_EQ(end_location, Location(1, 0)); queue.Close(); // Create (2, 0) - EXPECT_EQ(queue.GetLargestLocation(), Location(2, 0)); + EXPECT_EQ(queue.largest_location(), Location(2, 0)); fetch = queue.StandaloneFetch(Location{0, 0}, Location{1, kMaxObjectId}, MoqtDeliveryOrder::kAscending); // end_of_track is false if the fetch does not include the last object.
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc index e7f4a7d..6af3e37 100644 --- a/quiche/quic/moqt/moqt_parser.cc +++ b/quiche/quic/moqt/moqt_parser.cc
@@ -246,18 +246,21 @@ case MoqtMessageType::kAnnounceError: bytes_read = ProcessAnnounceError(reader); break; - case MoqtMessageType::kAnnounceCancel: - bytes_read = ProcessAnnounceCancel(reader); - break; - case MoqtMessageType::kTrackStatusRequest: - bytes_read = ProcessTrackStatusRequest(reader); - break; case MoqtMessageType::kUnannounce: bytes_read = ProcessUnannounce(reader); break; + case MoqtMessageType::kAnnounceCancel: + bytes_read = ProcessAnnounceCancel(reader); + break; case MoqtMessageType::kTrackStatus: bytes_read = ProcessTrackStatus(reader); break; + case MoqtMessageType::kTrackStatusOk: + bytes_read = ProcessTrackStatusOk(reader); + break; + case MoqtMessageType::kTrackStatusError: + bytes_read = ProcessTrackStatusError(reader); + break; case MoqtMessageType::kGoAway: bytes_read = ProcessGoAway(reader); break; @@ -374,7 +377,8 @@ return reader.PreviouslyReadPayload().length(); } -size_t MoqtControlParser::ProcessSubscribe(quic::QuicDataReader& reader) { +size_t MoqtControlParser::ProcessSubscribe(quic::QuicDataReader& reader, + MoqtMessageType message_type) { MoqtSubscribe subscribe; uint64_t filter, group, object; uint8_t group_order, forward; @@ -434,11 +438,16 @@ subscribe.parameters)) { return 0; } - visitor_.OnSubscribeMessage(subscribe); + if (message_type == MoqtMessageType::kTrackStatus) { + visitor_.OnTrackStatusMessage(subscribe); + } else { + visitor_.OnSubscribeMessage(subscribe); + } return reader.PreviouslyReadPayload().length(); } -size_t MoqtControlParser::ProcessSubscribeOk(quic::QuicDataReader& reader) { +size_t MoqtControlParser::ProcessSubscribeOk(quic::QuicDataReader& reader, + MoqtMessageType message_type) { MoqtSubscribeOk subscribe_ok; uint64_t milliseconds; uint8_t group_order; @@ -449,6 +458,8 @@ !reader.ReadUInt8(&content_exists)) { return 0; } + // TODO(martinduke): If track_alias > 0 is an error for TrackStatusOk, then + // throw an error here. if (content_exists > 1) { ParseError("SUBSCRIBE_OK ContentExists has invalid value"); return 0; @@ -479,11 +490,16 @@ subscribe_ok.parameters)) { return 0; } - visitor_.OnSubscribeOkMessage(subscribe_ok); + if (message_type == MoqtMessageType::kTrackStatusOk) { + visitor_.OnTrackStatusOkMessage(subscribe_ok); + } else { + visitor_.OnSubscribeOkMessage(subscribe_ok); + } return reader.PreviouslyReadPayload().length(); } -size_t MoqtControlParser::ProcessSubscribeError(quic::QuicDataReader& reader) { +size_t MoqtControlParser::ProcessSubscribeError(quic::QuicDataReader& reader, + MoqtMessageType message_type) { MoqtSubscribeError subscribe_error; uint64_t error_code; if (!reader.ReadVarInt62(&subscribe_error.request_id) || @@ -492,7 +508,11 @@ return 0; } subscribe_error.error_code = static_cast<RequestErrorCode>(error_code); - visitor_.OnSubscribeErrorMessage(subscribe_error); + if (message_type == MoqtMessageType::kTrackStatusError) { + visitor_.OnTrackStatusErrorMessage(subscribe_error); + } else { + visitor_.OnSubscribeErrorMessage(subscribe_error); + } return reader.PreviouslyReadPayload().length(); } @@ -605,6 +625,15 @@ return reader.PreviouslyReadPayload().length(); } +size_t MoqtControlParser::ProcessUnannounce(quic::QuicDataReader& reader) { + MoqtUnannounce unannounce; + if (!ReadTrackNamespace(reader, unannounce.track_namespace)) { + return 0; + } + visitor_.OnUnannounceMessage(unannounce); + return reader.PreviouslyReadPayload().length(); +} + size_t MoqtControlParser::ProcessAnnounceCancel(quic::QuicDataReader& reader) { MoqtAnnounceCancel announce_cancel; if (!ReadTrackNamespace(reader, announce_cancel.track_namespace)) { @@ -620,66 +649,17 @@ return reader.PreviouslyReadPayload().length(); } -size_t MoqtControlParser::ProcessTrackStatusRequest( - quic::QuicDataReader& reader) { - MoqtTrackStatusRequest track_status_request; - if (!reader.ReadVarInt62(&track_status_request.request_id)) { - return 0; - } - if (!ReadFullTrackName(reader, track_status_request.full_track_name)) { - return 0; - } - KeyValuePairList parameters; - if (!ParseKeyValuePairList(reader, parameters)) { - return 0; - } - if (!ValidateVersionSpecificParameters( - parameters, MoqtMessageType::kTrackStatusRequest)) { - ParseError("TRACK_STATUS_REQUEST message contains invalid parameters"); - return 0; - } - if (!KeyValuePairListToVersionSpecificParameters( - parameters, track_status_request.parameters)) { - return 0; - } - visitor_.OnTrackStatusRequestMessage(track_status_request); - return reader.PreviouslyReadPayload().length(); -} - -size_t MoqtControlParser::ProcessUnannounce(quic::QuicDataReader& reader) { - MoqtUnannounce unannounce; - if (!ReadTrackNamespace(reader, unannounce.track_namespace)) { - return 0; - } - visitor_.OnUnannounceMessage(unannounce); - return reader.PreviouslyReadPayload().length(); -} - size_t MoqtControlParser::ProcessTrackStatus(quic::QuicDataReader& reader) { - MoqtTrackStatus track_status; - uint64_t status_code; - if (!reader.ReadVarInt62(&track_status.request_id) || - !reader.ReadVarInt62(&status_code) || - !reader.ReadVarInt62(&track_status.largest_location.group) || - !reader.ReadVarInt62(&track_status.largest_location.object)) { - return 0; - } - track_status.status_code = static_cast<MoqtTrackStatusCode>(status_code); - KeyValuePairList parameters; - if (!ParseKeyValuePairList(reader, parameters)) { - return 0; - } - if (!ValidateVersionSpecificParameters(parameters, - MoqtMessageType::kTrackStatus)) { - ParseError("TRACK_STATUS message contains invalid parameters"); - return 0; - } - if (!KeyValuePairListToVersionSpecificParameters(parameters, - track_status.parameters)) { - return 0; - } - visitor_.OnTrackStatusMessage(track_status); - return reader.PreviouslyReadPayload().length(); + return ProcessSubscribe(reader, MoqtMessageType::kTrackStatus); +} + +size_t MoqtControlParser::ProcessTrackStatusOk(quic::QuicDataReader& reader) { + return ProcessSubscribeOk(reader, MoqtMessageType::kTrackStatusOk); +} + +size_t MoqtControlParser::ProcessTrackStatusError( + quic::QuicDataReader& reader) { + return ProcessSubscribeError(reader, MoqtMessageType::kTrackStatusError); } size_t MoqtControlParser::ProcessGoAway(quic::QuicDataReader& reader) {
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h index f331b9f..aa4d367 100644 --- a/quiche/quic/moqt/moqt_parser.h +++ b/quiche/quic/moqt/moqt_parser.h
@@ -43,11 +43,12 @@ virtual void OnAnnounceMessage(const MoqtAnnounce& message) = 0; virtual void OnAnnounceOkMessage(const MoqtAnnounceOk& message) = 0; virtual void OnAnnounceErrorMessage(const MoqtAnnounceError& message) = 0; - virtual void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) = 0; - virtual void OnTrackStatusRequestMessage( - const MoqtTrackStatusRequest& message) = 0; virtual void OnUnannounceMessage(const MoqtUnannounce& message) = 0; + virtual void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) = 0; virtual void OnTrackStatusMessage(const MoqtTrackStatus& message) = 0; + virtual void OnTrackStatusOkMessage(const MoqtTrackStatusOk& message) = 0; + virtual void OnTrackStatusErrorMessage( + const MoqtTrackStatusError& message) = 0; virtual void OnGoAwayMessage(const MoqtGoAway& message) = 0; virtual void OnSubscribeNamespaceMessage( const MoqtSubscribeNamespace& message) = 0; @@ -112,19 +113,28 @@ // otherwise. size_t ProcessClientSetup(quic::QuicDataReader& reader); size_t ProcessServerSetup(quic::QuicDataReader& reader); - size_t ProcessSubscribe(quic::QuicDataReader& reader); - size_t ProcessSubscribeOk(quic::QuicDataReader& reader); - size_t ProcessSubscribeError(quic::QuicDataReader& reader); + // Subscribe formats are used for TrackStatus as well, so take the message + // type as an argument, defaulting to the subscribe version. + size_t ProcessSubscribe( + quic::QuicDataReader& reader, + MoqtMessageType message_type = MoqtMessageType::kSubscribe); + size_t ProcessSubscribeOk( + quic::QuicDataReader& reader, + MoqtMessageType message_type = MoqtMessageType::kSubscribeOk); + size_t ProcessSubscribeError( + quic::QuicDataReader& reader, + MoqtMessageType message_type = MoqtMessageType::kSubscribeError); size_t ProcessUnsubscribe(quic::QuicDataReader& reader); size_t ProcessSubscribeDone(quic::QuicDataReader& reader); size_t ProcessSubscribeUpdate(quic::QuicDataReader& reader); size_t ProcessAnnounce(quic::QuicDataReader& reader); size_t ProcessAnnounceOk(quic::QuicDataReader& reader); size_t ProcessAnnounceError(quic::QuicDataReader& reader); - size_t ProcessAnnounceCancel(quic::QuicDataReader& reader); - size_t ProcessTrackStatusRequest(quic::QuicDataReader& reader); size_t ProcessUnannounce(quic::QuicDataReader& reader); + size_t ProcessAnnounceCancel(quic::QuicDataReader& reader); size_t ProcessTrackStatus(quic::QuicDataReader& reader); + size_t ProcessTrackStatusOk(quic::QuicDataReader& reader); + size_t ProcessTrackStatusError(quic::QuicDataReader& reader); size_t ProcessGoAway(quic::QuicDataReader& reader); size_t ProcessSubscribeNamespace(quic::QuicDataReader& reader); size_t ProcessSubscribeNamespaceOk(quic::QuicDataReader& reader);
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc index 1ef7ec5..24e5657 100644 --- a/quiche/quic/moqt/moqt_parser_test.cc +++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -39,8 +39,9 @@ MoqtMessageType::kUnsubscribe, MoqtMessageType::kSubscribeDone, MoqtMessageType::kAnnounceCancel, - MoqtMessageType::kTrackStatusRequest, MoqtMessageType::kTrackStatus, + MoqtMessageType::kTrackStatusOk, + MoqtMessageType::kTrackStatusError, MoqtMessageType::kAnnounce, MoqtMessageType::kAnnounceOk, MoqtMessageType::kAnnounceError,
diff --git a/quiche/quic/moqt/moqt_publisher.h b/quiche/quic/moqt/moqt_publisher.h index a3f2ebc..acd3587 100644 --- a/quiche/quic/moqt/moqt_publisher.h +++ b/quiche/quic/moqt/moqt_publisher.h
@@ -50,14 +50,13 @@ virtual void OnSubscribeAccepted() = 0; // Called when the publisher is sure that it cannot serve the subscription. // This could happen synchronously or asynchronously. - virtual void OnSubscribeRejected( - MoqtSubscribeErrorReason reason, - std::optional<uint64_t> track_alias = std::nullopt) = 0; + virtual void OnSubscribeRejected(MoqtSubscribeErrorReason reason) = 0; // Notifies that a new object is available on the track. The object payload // itself may be retrieved via GetCachedObject method of the associated track // publisher. - virtual void OnNewObjectAvailable(Location sequence, uint64_t subgroup) = 0; + virtual void OnNewObjectAvailable(Location sequence, uint64_t subgroup, + MoqtPriority publisher_priority) = 0; // Notifies that a pure FIN has arrived following |sequence|. Should not be // called unless all objects have already been delivered. If not delivered, // instead set the fin_after_this flag in the PublishedObject. @@ -159,31 +158,24 @@ virtual void AddObjectListener(MoqtObjectListener* listener) = 0; virtual void RemoveObjectListener(MoqtObjectListener* listener) = 0; - virtual absl::StatusOr<MoqtTrackStatusCode> GetTrackStatus() const = 0; - - // Returns the largest (group, object) pair that has been published so far. - // This method may only be called if - // DoesTrackStatusImplyHavingData(GetTrackStatus()) is true. - virtual Location GetLargestLocation() const = 0; - - // Returns the forwarding preference of the track. - // This method may only be called if - // DoesTrackStatusImplyHavingData(GetTrackStatus()) is true. - virtual MoqtForwardingPreference GetForwardingPreference() const = 0; - - // Returns the current forwarding priority of the track. - virtual MoqtPriority GetPublisherPriority() const = 0; - - // Returns the publisher-preferred delivery order for the track. - virtual MoqtDeliveryOrder GetDeliveryOrder() const = 0; + // Methods to return various track properties. Returns nullopt if the value is + // not yet available. Guaranteed to be non-null if an object is available + // and/or OnSubscribeAccepted() has been called. + // Track alias is not present because MoqtSession always uses locally + // generated values. + virtual std::optional<Location> largest_location() const = 0; + virtual std::optional<MoqtForwardingPreference> forwarding_preference() + const = 0; + virtual std::optional<MoqtDeliveryOrder> delivery_order() const = 0; + virtual std::optional<quic::QuicTimeDelta> expiration() const = 0; // Performs a fetch for the specified range of objects. virtual std::unique_ptr<MoqtFetchTask> StandaloneFetch( - Location start, Location end, MoqtDeliveryOrder order) = 0; + Location start, Location end, std::optional<MoqtDeliveryOrder> order) = 0; virtual std::unique_ptr<MoqtFetchTask> RelativeFetch( - uint64_t group_diff, MoqtDeliveryOrder order) = 0; + uint64_t group_diff, std::optional<MoqtDeliveryOrder> order) = 0; virtual std::unique_ptr<MoqtFetchTask> AbsoluteFetch( - uint64_t group, MoqtDeliveryOrder order) = 0; + uint64_t group, std::optional<MoqtDeliveryOrder> order) = 0; }; // MoqtPublisher is an interface to a publisher that allows it to publish
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc index d68578d..ffa88a1 100644 --- a/quiche/quic/moqt/moqt_session.cc +++ b/quiche/quic/moqt/moqt_session.cc
@@ -6,11 +6,11 @@ #include <algorithm> #include <array> -#include <cstddef> #include <cstdint> #include <memory> #include <optional> #include <string> +#include <tuple> #include <utility> #include <variant> #include <vector> @@ -63,11 +63,6 @@ // send group is always the same. constexpr webtransport::SendGroupId kMoqtSendGroupId = 0; -bool PublisherHasData(const MoqtTrackPublisher& publisher) { - absl::StatusOr<MoqtTrackStatusCode> status = publisher.GetTrackStatus(); - return status.ok() && DoesTrackStatusImplyHavingData(*status); -} - std::optional<SubscribeWindow> SubscribeMessageToWindow( const MoqtSubscribe& subscribe) { if (!subscribe.forward || @@ -1264,6 +1259,12 @@ session_->outgoing_announces_.erase(it2); } +void MoqtSession::ControlStream::OnUnannounceMessage( + const MoqtUnannounce& message) { + session_->callbacks_.incoming_announce_callback(message.track_namespace, + std::nullopt); +} + void MoqtSession::ControlStream::OnAnnounceCancelMessage( const MoqtAnnounceCancel& message) { // The spec currently says that if a later SUBSCRIBE arrives for this @@ -1281,38 +1282,36 @@ session_->outgoing_announces_.erase(it); } -void MoqtSession::ControlStream::OnTrackStatusRequestMessage( - const MoqtTrackStatusRequest& message) { +void MoqtSession::ControlStream::OnTrackStatusMessage( + const MoqtTrackStatus& message) { if (!session_->ValidateRequestId(message.request_id)) { return; } if (session_->sent_goaway_) { QUIC_DLOG(INFO) << ENDPOINT << "Received a TRACK_STATUS_REQUEST after GOAWAY"; - SendOrBufferMessage(session_->framer_.SerializeTrackStatus( - MoqtTrackStatus(message.request_id, MoqtTrackStatusCode::kDoesNotExist, - Location(0, 0)))); + MoqtTrackStatusError error; + error.request_id = message.request_id; + error.error_code = RequestErrorCode::kUnauthorized; + error.reason_phrase = "TRACK_STATUS_REQUEST after GOAWAY"; + SendOrBufferMessage(session_->framer_.SerializeTrackStatusError(error)); return; } // TODO(martinduke): Handle authentication. absl::StatusOr<std::shared_ptr<MoqtTrackPublisher>> track = session_->publisher_->GetTrack(message.full_track_name); if (!track.ok()) { - SendOrBufferMessage(session_->framer_.SerializeTrackStatus( - MoqtTrackStatus(message.request_id, MoqtTrackStatusCode::kDoesNotExist, - Location(0, 0)))); + MoqtTrackStatusError error; + error.request_id = message.request_id; + error.error_code = RequestErrorCode::kTrackDoesNotExist; + error.reason_phrase = "Track does not exist"; + SendOrBufferMessage(session_->framer_.SerializeTrackStatusError(error)); return; } - session_->incoming_track_status_.emplace( - std::pair<uint64_t, DownstreamTrackStatus>( - message.request_id, - DownstreamTrackStatus(message.request_id, session_, track->get()))); -} - -void MoqtSession::ControlStream::OnUnannounceMessage( - const MoqtUnannounce& message) { - session_->callbacks_.incoming_announce_callback(message.track_namespace, - std::nullopt); + auto [it, inserted] = session_->incoming_track_status_.emplace( + message.request_id, std::make_unique<DownstreamTrackStatus>( + message.request_id, session_, track->get())); + track->get()->AddObjectListener(it->second.get()); } void MoqtSession::ControlStream::OnGoAwayMessage(const MoqtGoAway& message) { @@ -1467,8 +1466,7 @@ fetch = (*track_publisher) ->StandaloneFetch(standalone_fetch.start_location, standalone_fetch.end_location, - message.group_order.value_or( - (*track_publisher)->GetDeliveryOrder())); + message.group_order); } else { // Joining Fetch processing. uint64_t joining_request_id = @@ -1504,18 +1502,14 @@ QUIC_DLOG(INFO) << ENDPOINT << "Received a Relative Joining FETCH for " << track_name; fetch = it->second->publisher().RelativeFetch( - relative_fetch.joining_start, - message.group_order.value_or( - it->second->publisher().GetDeliveryOrder())); + relative_fetch.joining_start, message.group_order); } else { const JoiningFetchAbsolute& absolute_fetch = std::get<JoiningFetchAbsolute>(message.fetch); QUIC_DLOG(INFO) << ENDPOINT << "Received a Absolute Joining FETCH for " << track_name; fetch = it->second->publisher().AbsoluteFetch( - absolute_fetch.joining_start, - message.group_order.value_or( - it->second->publisher().GetDeliveryOrder())); + absolute_fetch.joining_start, message.group_order); } } if (!fetch->GetStatus().ok()) { @@ -1940,8 +1934,7 @@ // knowing the forwarding preference in advance, and it might not be known // when the subscription is first created. if (!lazily_initialized_stream_map_.has_value()) { - QUICHE_DCHECK( - DoesTrackStatusImplyHavingData(*track_publisher_->GetTrackStatus())); + QUICHE_DCHECK(track_publisher_->largest_location().has_value()); lazily_initialized_stream_map_.emplace(); } return *lazily_initialized_stream_map_; @@ -1987,9 +1980,8 @@ void MoqtSession::PublishedSubscription::OnSubscribeAccepted() { std::optional<Location> largest_location; ControlStream* stream = session_->GetControlStream(); - if (PublisherHasData(*track_publisher_)) { - largest_location = track_publisher_->GetLargestLocation(); - QUICHE_CHECK(largest_location.has_value()); + largest_location = track_publisher_->largest_location(); + if (largest_location.has_value()) { if (forward_) { switch (filter_type_) { case MoqtFilterType::kLatestObject: @@ -2010,23 +2002,29 @@ MoqtSubscribeOk subscribe_ok; subscribe_ok.request_id = request_id_; subscribe_ok.track_alias = session_->next_local_track_alias_++; - subscribe_ok.group_order = track_publisher_->GetDeliveryOrder(); + QUICHE_BUG_IF(quic_bug_subscribe_ok_no_expiration, + !track_publisher_->expiration().has_value()) + << "Request accepted without expiration"; + subscribe_ok.expires = + track_publisher_->expiration().value_or(quic::QuicTimeDelta::Zero()); + QUICHE_BUG_IF(quic_bug_subscribe_ok_no_delivery_order, + !track_publisher_->delivery_order().has_value()) + << "Request accepted without delivery order"; + subscribe_ok.group_order = track_publisher_->delivery_order().value_or( + MoqtDeliveryOrder::kAscending); subscribe_ok.largest_location = largest_location; track_alias_.emplace(subscribe_ok.track_alias); // TODO(martinduke): Support sending DELIVERY_TIMEOUT parameter as the // publisher. stream->SendOrBufferMessage( session_->framer_.SerializeSubscribeOk(subscribe_ok)); - if (!PublisherHasData(*track_publisher_)) { - return; - } // TODO(martinduke): If we buffer objects that arrived previously, the arrival // of the track alias disambiguates what subscription they belong to. Send // them. } void MoqtSession::PublishedSubscription::OnSubscribeRejected( - MoqtSubscribeErrorReason reason, std::optional<uint64_t> track_alias) { + MoqtSubscribeErrorReason reason) { session_->GetControlStream()->SendSubscribeError( request_id_, reason.error_code, reason.reason_phrase); session_->published_subscriptions_.erase(request_id_); @@ -2034,20 +2032,20 @@ } void MoqtSession::PublishedSubscription::OnNewObjectAvailable( - Location sequence, uint64_t subgroup) { - if (!InWindow(sequence)) { + Location location, uint64_t subgroup, MoqtPriority publisher_priority) { + if (!InWindow(location)) { return; } - DataStreamIndex index(sequence.group, subgroup); + DataStreamIndex index(location.group, subgroup); if (reset_subgroups_.contains(index)) { // This subgroup has already been reset, ignore. return; } if (session_->alternate_delivery_timeout_ && !delivery_timeout_.IsInfinite() && largest_sent_.has_value() && - sequence.group >= largest_sent_->group) { + location.group >= largest_sent_->group) { // Start the delivery timeout timer on all previous groups. - for (uint64_t group = first_active_group_; group < sequence.group; + for (uint64_t group = first_active_group_; group < location.group; ++group) { for (webtransport::StreamId stream_id : stream_map().GetStreamsForGroup(group)) { @@ -2063,12 +2061,15 @@ } } } - QUICHE_DCHECK_GE(sequence.group, first_active_group_); + QUICHE_DCHECK_GE(location.group, first_active_group_); - MoqtForwardingPreference forwarding_preference = - track_publisher_->GetForwardingPreference(); - if (forwarding_preference == MoqtForwardingPreference::kDatagram) { - SendDatagram(sequence); + std::optional<MoqtForwardingPreference> forwarding_preference = + track_publisher_->forwarding_preference(); + if (!forwarding_preference.has_value()) { + return; + } + if (*forwarding_preference == MoqtForwardingPreference::kDatagram) { + SendDatagram(location); return; } @@ -2079,8 +2080,8 @@ raw_stream = session_->session_->GetStreamById(*stream_id); } else { raw_stream = session_->OpenOrQueueDataStream( - request_id_, - NewStreamParameters(sequence.group, subgroup, sequence.object)); + request_id_, NewStreamParameters(location.group, subgroup, + location.object, publisher_priority)); } if (raw_stream == nullptr) { return; @@ -2188,13 +2189,20 @@ } webtransport::SendOrder MoqtSession::PublishedSubscription::GetSendOrder( - Location sequence, uint64_t subgroup) const { + Location sequence, uint64_t subgroup, + MoqtPriority publisher_priority) const { + QUICHE_BUG_IF(GetSendOrder_no_forwarding_preference, + !track_publisher_->forwarding_preference().has_value()) + << "No forwarding preference"; MoqtForwardingPreference forwarding_preference = - track_publisher_->GetForwardingPreference(); - - MoqtPriority publisher_priority = track_publisher_->GetPublisherPriority(); - MoqtDeliveryOrder delivery_order = subscriber_delivery_order().value_or( - track_publisher_->GetDeliveryOrder()); + track_publisher_->forwarding_preference().value_or( + MoqtForwardingPreference::kSubgroup); + QUICHE_BUG_IF(GetSendOrder_no_delivery_order, + !track_publisher_->delivery_order().has_value()) + << "No delivery order"; + MoqtDeliveryOrder delivery_order = + track_publisher_->delivery_order().value_or( + MoqtDeliveryOrder::kAscending); if (forwarding_preference == MoqtForwardingPreference::kDatagram) { return SendOrderForDatagram(subscriber_priority_, publisher_priority, sequence.group, sequence.object, @@ -2213,7 +2221,7 @@ : queued_outgoing_data_streams_.rbegin()->first; webtransport::SendOrder send_order = GetSendOrder(Location(parameters.index.group, parameters.first_object), - parameters.index.subgroup); + parameters.index.subgroup, parameters.publisher_priority); // Zero out the subscriber priority bits, since these will be added when // updating the session. queued_outgoing_data_streams_.emplace( @@ -2233,7 +2241,7 @@ QUICHE_BUG(NextQueuedOutgoingDataStream_no_stream) << "NextQueuedOutgoingDataStream called when there are no streams " "pending."; - return NewStreamParameters(0, 0, 0); + return NewStreamParameters(0, 0, 0, 0); } auto it = queued_outgoing_data_streams_.rbegin(); webtransport::SendOrder old_send_order = FinalizeSendOrder(it->first); @@ -2280,6 +2288,7 @@ stream_(stream), subscription_id_(subscription.request_id()), index_(parameters.index), + publisher_priority_(parameters.publisher_priority), // Always include extension header length, because it's difficult to know // a priori if they're going to appear on a stream. stream_type_(MoqtDataStreamType::Subgroup( @@ -2335,14 +2344,8 @@ } PublishedSubscription* subscription = it->second.get(); - MoqtTrackPublisher& publisher = subscription->publisher(); - absl::StatusOr<MoqtTrackStatusCode> status = publisher.GetTrackStatus(); - if (!status.ok()) { - // TODO: clean up the subscription. - return nullptr; - } - if (!DoesTrackStatusImplyHavingData(*status)) { - QUICHE_BUG(GetSubscriptionIfValid_InvalidTrackStatus) + if (!subscription->publisher().largest_location().has_value()) { + QUICHE_BUG(GetSubscriptionIfValid_InvalidTrackStatusOk) << "The track publisher returned a status indicating that no objects " "are available, but a stream for those objects exists."; session_->Error(MoqtError::kInternalError, @@ -2367,7 +2370,7 @@ QUICHE_DCHECK_EQ(object->metadata.location.group, index_.group); QUICHE_DCHECK(object->metadata.subgroup == index_.subgroup); - QUICHE_DCHECK(subscription.publisher().GetForwardingPreference() == + QUICHE_DCHECK(subscription.publisher().forwarding_preference() == MoqtForwardingPreference::kSubgroup); if (!subscription.InWindow(object->metadata.location)) { // It is possible that the next object became irrelevant due to a @@ -2531,7 +2534,7 @@ stream_->SetPriority(webtransport::StreamPriority{ /*send_group_id=*/kMoqtSendGroupId, subscription.GetSendOrder(Location(index_.group, next_object_), - index_.subgroup)}); + index_.subgroup, publisher_priority_)}); } void MoqtSession::OutgoingDataStream::CreateAndSetAlarm(
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h index 252267e..15d1d62 100644 --- a/quiche/quic/moqt/moqt_session.h +++ b/quiche/quic/moqt/moqt_session.h
@@ -35,6 +35,7 @@ #include "quiche/quic/moqt/moqt_track.h" #include "quiche/quic/moqt/namespace_tree.h" #include "quiche/common/platform/api/quiche_export.h" +#include "quiche/common/platform/api/quiche_logging.h" #include "quiche/common/quiche_buffer_allocator.h" #include "quiche/common/quiche_mem_slice.h" #include "quiche/common/quiche_weak_ptr.h" @@ -219,10 +220,13 @@ struct NewStreamParameters { DataStreamIndex index; uint64_t first_object; + MoqtPriority publisher_priority; NewStreamParameters(uint64_t group, uint64_t subgroup, - uint64_t first_object) - : index(group, subgroup), first_object(first_object) {} + uint64_t first_object, MoqtPriority publisher_priority) + : index(group, subgroup), + first_object(first_object), + publisher_priority(publisher_priority) {} }; class QUICHE_EXPORT ControlStream : public webtransport::StreamVisitor, @@ -250,11 +254,12 @@ void OnAnnounceMessage(const MoqtAnnounce& message) override; void OnAnnounceOkMessage(const MoqtAnnounceOk& message) override; void OnAnnounceErrorMessage(const MoqtAnnounceError& message) override; - void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override; - void OnTrackStatusRequestMessage( - const MoqtTrackStatusRequest& message) override; void OnUnannounceMessage(const MoqtUnannounce& /*message*/) override; - void OnTrackStatusMessage(const MoqtTrackStatus& message) override {} + void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override; + void OnTrackStatusMessage(const MoqtTrackStatus& message) override; + void OnTrackStatusOkMessage(const MoqtTrackStatusOk& message) override {} + void OnTrackStatusErrorMessage( + const MoqtTrackStatusError& message) override {} void OnGoAwayMessage(const MoqtGoAway& /*message*/) override; void OnSubscribeNamespaceMessage( const MoqtSubscribeNamespace& message) override; @@ -376,11 +381,10 @@ // MoqtObjectListener implementation. void OnSubscribeAccepted() override; - void OnSubscribeRejected( - MoqtSubscribeErrorReason reason, - std::optional<uint64_t> track_alias = std::nullopt) override; + void OnSubscribeRejected(MoqtSubscribeErrorReason reason) override; // This is only called for objects that have just arrived. - void OnNewObjectAvailable(Location location, uint64_t subgroup) override; + void OnNewObjectAvailable(Location location, uint64_t subgroup, + MoqtPriority publisher_priority) override; void OnTrackPublisherGone() override; void OnNewFinAvailable(Location location, uint64_t subgroup) override; void OnSubgroupAbandoned(uint64_t group, uint64_t subgroup, @@ -419,8 +423,8 @@ std::vector<webtransport::StreamId> GetAllStreams() const; - webtransport::SendOrder GetSendOrder(Location sequence, - uint64_t subgroup) const; + webtransport::SendOrder GetSendOrder(Location sequence, uint64_t subgroup, + MoqtPriority publisher_priority) const; void AddQueuedOutgoingDataStream(const NewStreamParameters& parameters); // Pops the pending outgoing data stream, with the highest send order. @@ -553,6 +557,7 @@ webtransport::Stream* stream_; uint64_t subscription_id_; DataStreamIndex index_; + const MoqtPriority publisher_priority_; MoqtDataStreamType stream_type_; // Minimum object ID that should go out next. The session doesn't know the // exact ID of the next object in the stream because the next object could @@ -622,43 +627,53 @@ DownstreamTrackStatus(uint64_t request_id, MoqtSession* absl_nonnull session, MoqtTrackPublisher* absl_nonnull publisher) - : request_id_(request_id), session_(session), publisher_(publisher) { - publisher_->AddObjectListener(this); - } + : request_id_(request_id), session_(session), publisher_(publisher) {} ~DownstreamTrackStatus() { if (publisher_ != nullptr) { publisher_->RemoveObjectListener(this); } } + DownstreamTrackStatus(const DownstreamTrackStatus&) = delete; + DownstreamTrackStatus(DownstreamTrackStatus&&) = delete; void OnSubscribeAccepted() override { - MoqtTrackStatus track_status; - track_status.request_id = request_id_; - QUICHE_CHECK(publisher_ != nullptr); - absl::StatusOr<MoqtTrackStatusCode> status = publisher_->GetTrackStatus(); - if (!status.ok()) { - session_->Error(MoqtError::kInternalError, - "Failed to get track status"); + if (publisher_ == nullptr) { + QUICHE_NOTREACHED(); return; } - track_status.status_code = *status; - if (*status != MoqtTrackStatusCode::kDoesNotExist && - *status != MoqtTrackStatusCode::kNotYetBegun) { - track_status.largest_location = publisher_->GetLargestLocation(); - } // Else, leave it at (0,0). + MoqtTrackStatusOk track_status_ok; + track_status_ok.request_id = request_id_; + track_status_ok.track_alias = 0; + QUICHE_BUG_IF(quic_bug_track_status_ok_no_expiration, + !publisher_->expiration().has_value()) + << "Request accepted without expiration"; + track_status_ok.expires = + publisher_->expiration().value_or(quic::QuicTimeDelta::Zero()); + QUICHE_BUG_IF(quic_bug_track_status_ok_no_delivery_order, + !publisher_->delivery_order().has_value()) + << "Request accepted without delivery order"; + track_status_ok.group_order = + publisher_->delivery_order().value_or(MoqtDeliveryOrder::kAscending); + track_status_ok.largest_location = publisher_->largest_location(); session_->SendControlMessage( - session_->framer_.SerializeTrackStatus(track_status)); + session_->framer_.SerializeTrackStatusOk(track_status_ok)); session_->incoming_track_status_.erase(request_id_); // No class access below this line! } - // TODO(martinduke): In draft-13, this will trigger TRACK_STATUS_ERROR. - void OnSubscribeRejected(MoqtSubscribeErrorReason /*error_code*/, - std::optional<uint64_t> /*track_alias*/) override { - OnSubscribeAccepted(); + void OnSubscribeRejected(MoqtSubscribeErrorReason error_reason) override { + MoqtTrackStatusError track_status_error; + track_status_error.request_id = request_id_; + track_status_error.error_code = error_reason.error_code; + track_status_error.reason_phrase = error_reason.reason_phrase; + session_->SendControlMessage( + session_->framer_.SerializeTrackStatusError(track_status_error)); + session_->incoming_track_status_.erase(request_id_); + // No class access below this line! } - void OnNewObjectAvailable(Location sequence, uint64_t subgroup) override {} + void OnNewObjectAvailable(Location sequence, uint64_t subgroup, + MoqtPriority publisher_priority) override {} void OnNewFinAvailable(Location location, uint64_t subgroup) override {} void OnSubgroupAbandoned( uint64_t group, uint64_t subgroup, @@ -666,13 +681,8 @@ void OnGroupAbandoned(uint64_t group_id) override {} void OnTrackPublisherGone() override { publisher_ = nullptr; - MoqtTrackStatus track_status; - track_status.request_id = request_id_; - track_status.status_code = MoqtTrackStatusCode::kDoesNotExist; - track_status.largest_location = Location(0, 0); - session_->SendControlMessage( - session_->framer_.SerializeTrackStatus(track_status)); - session_->incoming_track_status_.erase(request_id_); + OnSubscribeRejected(MoqtSubscribeErrorReason( + RequestErrorCode::kTrackDoesNotExist, "Track publisher gone")); } private: @@ -825,7 +835,8 @@ absl::flat_hash_map<uint64_t, std::shared_ptr<PublishedFetch>> incoming_fetches_; - absl::flat_hash_map<uint64_t, DownstreamTrackStatus> incoming_track_status_; + absl::flat_hash_map<uint64_t, std::unique_ptr<DownstreamTrackStatus>> + incoming_track_status_; // Monitoring interfaces for expected incoming subscriptions. absl::flat_hash_map<FullTrackName, MoqtPublishingMonitorInterface*>
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc index adfb917..c328160 100644 --- a/quiche/quic/moqt/moqt_session_test.cc +++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -14,7 +14,6 @@ #include <utility> #include "absl/status/status.h" -#include "absl/status/statusor.h" #include "absl/strings/match.h" #include "absl/strings/string_view.h" #include "absl/types/span.h" @@ -27,6 +26,7 @@ #include "quiche/quic/moqt/moqt_parser.h" #include "quiche/quic/moqt/moqt_priority.h" #include "quiche/quic/moqt/moqt_publisher.h" +#include "quiche/quic/moqt/moqt_subscribe_windows.h" #include "quiche/quic/moqt/moqt_track.h" #include "quiche/quic/moqt/test_tools/moqt_framer_utils.h" #include "quiche/quic/moqt/test_tools/moqt_session_peer.h" @@ -59,6 +59,7 @@ constexpr uint64_t kDefaultPeerRequestId = 1; const MoqtDataStreamType kDefaultSubgroupStreamType = MoqtDataStreamType::Subgroup(2, 4, false); +constexpr MoqtPriority kDefaultPublisherPriority = 0x80; FullTrackName kDefaultTrackName() { return FullTrackName("foo", "bar"); } @@ -106,12 +107,14 @@ FullTrackName track_name, MoqtForwardingPreference forwarding_preference, Location largest_sequence) { auto publisher = std::make_shared<MockTrackPublisher>(std::move(track_name)); - ON_CALL(*publisher, GetTrackStatus()) - .WillByDefault(Return(MoqtTrackStatusCode::kInProgress)); - ON_CALL(*publisher, GetForwardingPreference()) - .WillByDefault(Return(forwarding_preference)); - ON_CALL(*publisher, GetLargestLocation()) + ON_CALL(*publisher, largest_location()) .WillByDefault(Return(largest_sequence)); + ON_CALL(*publisher, forwarding_preference()) + .WillByDefault(Return(forwarding_preference)); + ON_CALL(*publisher, delivery_order) + .WillByDefault(Return(MoqtDeliveryOrder::kAscending)); + ON_CALL(*publisher, expiration()) + .WillByDefault(Return(quic::QuicTimeDelta::Zero())); return publisher; } @@ -136,19 +139,20 @@ MockTrackPublisher* CreateTrackPublisher() { auto publisher = std::make_shared<MockTrackPublisher>(kDefaultTrackName()); publisher_.Add(publisher); - ON_CALL(*publisher, GetTrackStatus()) - .WillByDefault(Return(MoqtTrackStatusCode::kNotYetBegun)); - ON_CALL(*publisher, GetForwardingPreference()) - .WillByDefault(Return(MoqtForwardingPreference::kSubgroup)); - ON_CALL(*publisher, GetDeliveryOrder) + ON_CALL(*publisher, largest_location()).WillByDefault(Return(std::nullopt)); + ON_CALL(*publisher, forwarding_preference()) + .WillByDefault(Return(std::nullopt)); + ON_CALL(*publisher, delivery_order) .WillByDefault(Return(MoqtDeliveryOrder::kAscending)); + ON_CALL(*publisher, expiration()) + .WillByDefault(Return(quic::QuicTimeDelta::Zero())); return publisher.get(); } void SetLargestId(MockTrackPublisher* publisher, Location largest_id) { - ON_CALL(*publisher, GetTrackStatus()) - .WillByDefault(Return(MoqtTrackStatusCode::kInProgress)); - ON_CALL(*publisher, GetLargestLocation()).WillByDefault(Return(largest_id)); + ON_CALL(*publisher, largest_location()).WillByDefault(Return(largest_id)); + ON_CALL(*publisher, forwarding_preference) + .WillByDefault(Return(MoqtForwardingPreference::kSubgroup)); } // The publisher receives SUBSCRIBE and synchronously announces it will @@ -162,19 +166,14 @@ listener_ptr = listener; listener->OnSubscribeAccepted(); }); - absl::StatusOr<MoqtTrackStatusCode> track_status = - publisher->GetTrackStatus(); - if (!track_status.ok()) { - return nullptr; - } MoqtSubscribeOk expected_ok = { /*request_id=*/subscribe.request_id, track_alias, - /*expires=*/quic::QuicTimeDelta::FromMilliseconds(0), - /*group_order=*/MoqtDeliveryOrder::kAscending, - (*track_status == MoqtTrackStatusCode::kInProgress) - ? std::make_optional(publisher->GetLargestLocation()) - : std::optional<Location>(), + /*expires=*/ + publisher->expiration().value_or(quic::QuicTimeDelta::Zero()), + /*group_order=*/ + publisher->delivery_order().value_or(MoqtDeliveryOrder::kAscending), + publisher->largest_location(), /*parameters=*/VersionSpecificParameters(), }; EXPECT_CALL(mock_stream_, Writev(SerializedControlMessage(expected_ok), _)); @@ -530,6 +529,25 @@ nullptr); } +TEST_F(MoqtSessionTest, SynchronousSubscribeReturnsError) { + std::unique_ptr<MoqtControlParserVisitor> stream_input = + MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); + MoqtSubscribe request = DefaultSubscribe(); + MockTrackPublisher* track = CreateTrackPublisher(); + EXPECT_CALL(*track, AddObjectListener) + .WillOnce(Invoke([&](MoqtObjectListener* listener) { + EXPECT_CALL( + mock_stream_, + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _)); + EXPECT_CALL(*track, RemoveObjectListener); + listener->OnSubscribeRejected(MoqtSubscribeErrorReason( + RequestErrorCode::kInternalError, "Test error")); + })); + stream_input->OnSubscribeMessage(request); + EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId), + nullptr); +} + TEST_F(MoqtSessionTest, SubscribeForPast) { std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); @@ -546,14 +564,12 @@ MoqtSubscribe request = DefaultSubscribe(); request.forward = false; request.filter_type = MoqtFilterType::kLatestObject; - EXPECT_CALL(*track, GetTrackStatus) - .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun)); MoqtObjectListener* listener = ReceiveSubscribeSynchronousOk(track, request, stream_input.get()); // forward=false, so incoming objects are ignored. EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .Times(0); - listener->OnNewObjectAvailable(Location(0, 0), 0); + listener->OnNewObjectAvailable(Location(0, 0), 0, kDefaultPublisherPriority); } TEST_F(MoqtSessionTest, SubscribeAbsoluteStartNoDataYet) { @@ -562,14 +578,12 @@ MockTrackPublisher* track = CreateTrackPublisher(); MoqtSubscribe request = DefaultSubscribe(); request.start = Location(1, 0); - EXPECT_CALL(*track, GetTrackStatus) - .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun)); MoqtObjectListener* listener = ReceiveSubscribeSynchronousOk(track, request, stream_input.get()); // Window was not set to (0, 0) by SUBSCRIBE acceptance. EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .Times(0); - listener->OnNewObjectAvailable(Location(0, 0), 0); + listener->OnNewObjectAvailable(Location(0, 0), 0, kDefaultPublisherPriority); } TEST_F(MoqtSessionTest, SubscribeNextGroup) { @@ -584,11 +598,12 @@ // Later objects in group 10 ignored. EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .Times(0); - listener->OnNewObjectAvailable(Location(10, 21), 0); + listener->OnNewObjectAvailable(Location(10, 21), 0, + kDefaultPublisherPriority); // Group 11 is sent. EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillOnce(Return(false)); - listener->OnNewObjectAvailable(Location(11, 0), 0); + listener->OnNewObjectAvailable(Location(11, 0), 0, kDefaultPublisherPriority); } TEST_F(MoqtSessionTest, TwoSubscribesForTrack) { @@ -1266,7 +1281,8 @@ EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] { return std::optional<PublishedObject>(); }); - subscription->OnNewObjectAvailable(Location(5, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); EXPECT_TRUE(correct_message); EXPECT_FALSE(fin); EXPECT_EQ(MoqtSessionPeer::LargestSentForSubscription(&session_, 0), @@ -1319,7 +1335,8 @@ EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] { return std::optional<PublishedObject>(); }); - subscription->OnNewObjectAvailable(Location(5, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); EXPECT_TRUE(correct_message); EXPECT_TRUE(fin); } @@ -1370,7 +1387,8 @@ EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] { return std::optional<PublishedObject>(); }); - subscription->OnNewObjectAvailable(Location(5, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); EXPECT_TRUE(correct_message); EXPECT_TRUE(fin); @@ -1435,7 +1453,8 @@ EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] { return std::optional<PublishedObject>(); }); - subscription->OnNewObjectAvailable(Location(5, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); EXPECT_TRUE(correct_message); EXPECT_TRUE(fin); @@ -1502,7 +1521,8 @@ EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] { return std::optional<PublishedObject>(); }); - subscription->OnNewObjectAvailable(Location(5, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); EXPECT_TRUE(correct_message); EXPECT_TRUE(fin); EXPECT_CALL(mock_stream_, ResetWithUserCode(kResetCodeDeliveryTimeout)); @@ -1555,7 +1575,8 @@ EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] { return std::optional<PublishedObject>(); }); - subscription->OnNewObjectAvailable(Location(5, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); EXPECT_TRUE(correct_message); EXPECT_FALSE(fin); fin = false; @@ -1615,13 +1636,15 @@ EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] { return std::optional<PublishedObject>(); }); - subscription->OnNewObjectAvailable(Location(5, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); EXPECT_FALSE(fin); // Try to deliver (5,1), but fail. EXPECT_CALL(mock_stream_, CanWrite()).WillRepeatedly([&] { return false; }); EXPECT_CALL(*track, GetCachedObject).Times(0); EXPECT_CALL(mock_stream_, Writev).Times(0); - subscription->OnNewObjectAvailable(Location(5, 1), 0); + subscription->OnNewObjectAvailable(Location(5, 1), 0, + kDefaultPublisherPriority); // Notify that FIN arrived, but do nothing with it because (5, 1) isn't sent. EXPECT_CALL(mock_stream_, Writev).Times(0); subscription->OnNewFinAvailable(Location(5, 1), 0); @@ -1699,7 +1722,8 @@ EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] { return std::optional<PublishedObject>(); }); - subscription->OnNewObjectAvailable(Location(5, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); // Abandon the subgroup. EXPECT_CALL(mock_stream_, ResetWithUserCode(0x1)).Times(1); @@ -1718,7 +1742,8 @@ // Queue the outgoing stream. EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillOnce(Return(false)); - subscription->OnNewObjectAvailable(Location(5, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); // Unblock the session, and cause the queued stream to be sent. EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) @@ -1762,8 +1787,10 @@ // Queue the outgoing stream. EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillRepeatedly(Return(false)); - subscription->OnNewObjectAvailable(Location(5, 0), 0); - subscription->OnNewObjectAvailable(Location(6, 0), 0); + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); + subscription->OnNewObjectAvailable(Location(6, 0), 0, + kDefaultPublisherPriority); subscription->OnGroupAbandoned(5); // Unblock the session, and cause the queued stream to be sent. There should @@ -1836,14 +1863,15 @@ EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillOnce([] { return std::optional<PublishedObject>(); }); - subscription->OnNewObjectAvailable(Location(5, 0), 0); - + subscription->OnNewObjectAvailable(Location(5, 0), 0, + kDefaultPublisherPriority); // Now that the stream exists and is recorded within subscription, make it // disappear by returning nullptr. EXPECT_CALL(mock_session_, GetStreamById(kOutgoingUniStreamId)) .WillRepeatedly(Return(nullptr)); EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).Times(0); - subscription->OnNewObjectAvailable(Location(5, 1), 0); + subscription->OnNewObjectAvailable(Location(5, 1), 0, + kDefaultPublisherPriority); } TEST_F(MoqtSessionTest, OneBidirectionalStreamClient) { @@ -1954,7 +1982,7 @@ 128}, quiche::QuicheMemSlice::Copy("deadbeef")}; }); - listener->OnNewObjectAvailable(Location(5, 0), 0); + listener->OnNewObjectAvailable(Location(5, 0), 0, kDefaultPublisherPriority); EXPECT_TRUE(correct_message); } @@ -2065,19 +2093,20 @@ FullTrackName ftn("foo", "bar"); auto track = SetupPublisher(ftn, MoqtForwardingPreference::kSubgroup, Location(0, 0)); - EXPECT_CALL(*track, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun)); MoqtObjectListener* subscription = MoqtSessionPeer::AddSubscription(&session_, track, 0, 14, 0, 0); EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillOnce(Return(false)) .WillOnce(Return(false)) .WillOnce(Return(false)); - EXPECT_CALL(*track, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress)); - subscription->OnNewObjectAvailable(Location(1, 0), 0); - subscription->OnNewObjectAvailable(Location(0, 0), 0); - subscription->OnNewObjectAvailable(Location(2, 0), 0); + EXPECT_CALL(*track, forwarding_preference()) + .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); + subscription->OnNewObjectAvailable(Location(1, 0), 0, + kDefaultPublisherPriority); + subscription->OnNewObjectAvailable(Location(0, 0), 0, + kDefaultPublisherPriority); + subscription->OnNewObjectAvailable(Location(2, 0), 0, + kDefaultPublisherPriority); // These should be opened in the sequence (0, 0), (1, 0), (2, 0). EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillRepeatedly(Return(true)); @@ -2160,15 +2189,14 @@ FullTrackName ftn("foo", "bar"); auto track = SetupPublisher(ftn, MoqtForwardingPreference::kSubgroup, Location(0, 0)); - EXPECT_CALL(*track, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun)); MoqtObjectListener* subscription = MoqtSessionPeer::AddSubscription(&session_, track, 0, 14, 0, 0); EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillOnce(Return(false)); - EXPECT_CALL(*track, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress)); - subscription->OnNewObjectAvailable(Location(0, 0), 0); + EXPECT_CALL(*track, forwarding_preference()) + .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); + subscription->OnNewObjectAvailable(Location(0, 0), 0, + kDefaultPublisherPriority); // Delete the subscription, then grant stream credit. MoqtSessionPeer::DeleteSubscription(&session_, 0); @@ -2185,10 +2213,6 @@ FullTrackName ftn2("dead", "beef"); auto track2 = SetupPublisher(ftn2, MoqtForwardingPreference::kSubgroup, Location(0, 0)); - EXPECT_CALL(*track1, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun)); - EXPECT_CALL(*track2, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun)); MoqtObjectListener* subscription0 = MoqtSessionPeer::AddSubscription(&session_, track1, 0, 14, 0, 0); MoqtObjectListener* subscription1 = @@ -2202,14 +2226,18 @@ .WillOnce(Return(false)) .WillOnce(Return(false)) .WillOnce(Return(false)); - EXPECT_CALL(*track1, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress)); - EXPECT_CALL(*track2, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress)); - subscription0->OnNewObjectAvailable(Location(0, 0), 0); - subscription1->OnNewObjectAvailable(Location(0, 0), 0); - subscription0->OnNewObjectAvailable(Location(1, 0), 0); - subscription1->OnNewObjectAvailable(Location(1, 0), 0); + EXPECT_CALL(*track1, forwarding_preference()) + .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); + EXPECT_CALL(*track2, forwarding_preference()) + .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); + subscription0->OnNewObjectAvailable(Location(0, 0), 0, + kDefaultPublisherPriority); + subscription1->OnNewObjectAvailable(Location(0, 0), 0, + kDefaultPublisherPriority); + subscription0->OnNewObjectAvailable(Location(1, 0), 0, + kDefaultPublisherPriority); + subscription1->OnNewObjectAvailable(Location(1, 0), 0, + kDefaultPublisherPriority); // Allow one stream to be opened. It will be group 0, subscription 0. EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) @@ -2830,7 +2858,7 @@ [&](std::unique_ptr<MoqtFetchTask> task) { fetch_task = std::move(task); }, - Location(0, 0), 4, std::nullopt, 128, std::nullopt, + Location(0, 0), 4, std::nullopt, kDefaultPublisherPriority, std::nullopt, VersionSpecificParameters()); MoqtFetchOk ok = { /*request_id=*/0, @@ -2860,7 +2888,7 @@ [&](std::unique_ptr<MoqtFetchTask> task) { fetch_task = std::move(task); }, - Location(0, 0), 4, std::nullopt, 128, std::nullopt, + Location(0, 0), 4, std::nullopt, kDefaultPublisherPriority, std::nullopt, VersionSpecificParameters()); MoqtFetchError error = { /*request_id=*/0, @@ -2898,7 +2926,7 @@ } while (result != MoqtFetchTask::GetNextObjectResult::kPending); }); }, - Location(0, 0), 4, std::nullopt, 128, std::nullopt, + Location(0, 0), 4, std::nullopt, kDefaultPublisherPriority, std::nullopt, VersionSpecificParameters()); // Build queue of packets to arrive. std::queue<quiche::QuicheBuffer> headers; @@ -2969,7 +2997,7 @@ fetch_task->SetObjectAvailableCallback( [&]() { objects_available = true; }); }, - Location(0, 0), 4, std::nullopt, 128, std::nullopt, + Location(0, 0), 4, std::nullopt, kDefaultPublisherPriority, std::nullopt, VersionSpecificParameters()); // Build queue of packets to arrive. std::queue<quiche::QuicheBuffer> headers; @@ -3111,8 +3139,8 @@ TEST_F(MoqtSessionTest, DeliveryTimeoutExpiredOnArrival) { auto track_publisher = std::make_shared<MockTrackPublisher>(FullTrackName("foo", "bar")); - EXPECT_CALL(*track_publisher, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress)); + EXPECT_CALL(*track_publisher, forwarding_preference()) + .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); MoqtObjectListener* subscription = MoqtSessionPeer::AddSubscription(&session_, track_publisher, 1, 2, 0, 0); ASSERT_NE(subscription, nullptr); @@ -3120,7 +3148,7 @@ quic::QuicTimeDelta::FromSeconds(1)); webtransport::test::MockStream data_mock; - EXPECT_CALL(*track_publisher, GetForwardingPreference()) + EXPECT_CALL(*track_publisher, forwarding_preference()) .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillOnce(Return(true)); @@ -3154,13 +3182,21 @@ stream_visitor.reset(); })); // Arrival time is very old; reset immediately. - subscription->OnNewObjectAvailable(Location(0, 0), 0); + ON_CALL(*track_publisher, largest_location) + .WillByDefault(Return(Location(0, 0))); + subscription->OnNewObjectAvailable(Location(0, 0), 0, + kDefaultPublisherPriority); // Subsequent objects for that subgroup are ignored. EXPECT_CALL(*track_publisher, GetCachedObject).Times(0); EXPECT_CALL(mock_session_, GetStreamById(_)).Times(0); EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .Times(0); - subscription->OnNewObjectAvailable(Location(0, 1), 0); + EXPECT_CALL(*track_publisher, forwarding_preference()) + .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); + ON_CALL(*track_publisher, largest_location) + .WillByDefault(Return(Location(0, 1))); + subscription->OnNewObjectAvailable(Location(0, 1), 0, + kDefaultPublisherPriority); // Check that reset_subgroups_ is pruned. EXPECT_TRUE(MoqtSessionPeer::SubgroupHasBeenReset(subscription, DataStreamIndex(0, 0))); @@ -3172,8 +3208,8 @@ TEST_F(MoqtSessionTest, DeliveryTimeoutAfterIntegratedFin) { auto track_publisher = std::make_shared<MockTrackPublisher>(FullTrackName("foo", "bar")); - EXPECT_CALL(*track_publisher, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress)); + EXPECT_CALL(*track_publisher, forwarding_preference()) + .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); MoqtObjectListener* subscription = MoqtSessionPeer::AddSubscription(&session_, track_publisher, 1, 2, 0, 0); ASSERT_NE(subscription, nullptr); @@ -3181,7 +3217,7 @@ quic::QuicTimeDelta::FromSeconds(1)); webtransport::test::MockStream data_mock; - EXPECT_CALL(*track_publisher, GetForwardingPreference()) + EXPECT_CALL(*track_publisher, forwarding_preference()) .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillOnce(Return(true)); @@ -3208,7 +3244,10 @@ .WillOnce(Return(std::nullopt)); EXPECT_CALL(data_mock, Writev(_, _)).WillOnce(Return(absl::OkStatus())); EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout)).Times(0); - subscription->OnNewObjectAvailable(Location(0, 0), 0); + ON_CALL(*track_publisher, largest_location) + .WillByDefault(Return(Location(0, 0))); + subscription->OnNewObjectAvailable(Location(0, 0), 0, + kDefaultPublisherPriority); auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>( MoqtSessionPeer::GetAlarm(stream_visitor.get())); EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout)) @@ -3221,8 +3260,8 @@ TEST_F(MoqtSessionTest, DeliveryTimeoutAfterSeparateFin) { auto track_publisher = std::make_shared<MockTrackPublisher>(FullTrackName("foo", "bar")); - EXPECT_CALL(*track_publisher, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress)); + EXPECT_CALL(*track_publisher, forwarding_preference()) + .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); MoqtObjectListener* subscription = MoqtSessionPeer::AddSubscription(&session_, track_publisher, 1, 2, 0, 0); ASSERT_NE(subscription, nullptr); @@ -3230,7 +3269,7 @@ quic::QuicTimeDelta::FromSeconds(1)); webtransport::test::MockStream data_mock; - EXPECT_CALL(*track_publisher, GetForwardingPreference()) + EXPECT_CALL(*track_publisher, forwarding_preference()) .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillOnce(Return(true)); @@ -3258,7 +3297,10 @@ quiche::QuicheMemSlice(), false})) .WillOnce(Return(std::nullopt)); EXPECT_CALL(data_mock, Writev(_, _)).WillOnce(Return(absl::OkStatus())); - subscription->OnNewObjectAvailable(Location(0, 0), 0); + ON_CALL(*track_publisher, largest_location()) + .WillByDefault(Return(Location(0, 0))); + subscription->OnNewObjectAvailable(Location(0, 0), 0, + kDefaultPublisherPriority); EXPECT_CALL(data_mock, Writev(_, _)).WillOnce(Return(absl::OkStatus())); subscription->OnNewFinAvailable(Location(0, 0), 0); @@ -3275,8 +3317,8 @@ session_.UseAlternateDeliveryTimeout(); auto track_publisher = std::make_shared<MockTrackPublisher>(FullTrackName("foo", "bar")); - EXPECT_CALL(*track_publisher, GetTrackStatus()) - .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress)); + EXPECT_CALL(*track_publisher, forwarding_preference()) + .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); MoqtObjectListener* subscription = MoqtSessionPeer::AddSubscription(&session_, track_publisher, 1, 2, 0, 0); ASSERT_NE(subscription, nullptr); @@ -3284,7 +3326,7 @@ quic::QuicTimeDelta::FromSeconds(1)); webtransport::test::MockStream data_mock1; - EXPECT_CALL(*track_publisher, GetForwardingPreference()) + EXPECT_CALL(*track_publisher, forwarding_preference()) .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup)); EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream()) .WillRepeatedly(Return(true)); @@ -3312,7 +3354,10 @@ quiche::QuicheMemSlice(), false})) .WillOnce(Return(std::nullopt)); EXPECT_CALL(data_mock1, Writev(_, _)).WillOnce(Return(absl::OkStatus())); - subscription->OnNewObjectAvailable(Location(0, 0), 0); + ON_CALL(*track_publisher, largest_location) + .WillByDefault(Return(Location(0, 0))); + subscription->OnNewObjectAvailable(Location(0, 0), 0, + kDefaultPublisherPriority); webtransport::test::MockStream data_mock2; EXPECT_CALL(mock_session_, OpenOutgoingUnidirectionalStream()) @@ -3339,7 +3384,10 @@ quiche::QuicheMemSlice(), false})) .WillOnce(Return(std::nullopt)); EXPECT_CALL(data_mock2, Writev(_, _)).WillOnce(Return(absl::OkStatus())); - subscription->OnNewObjectAvailable(Location(1, 0), 0); + ON_CALL(*track_publisher, largest_location) + .WillByDefault(Return(Location(1, 0))); + subscription->OnNewObjectAvailable(Location(1, 0), 0, + kDefaultPublisherPriority); // Group 1 should start the timer on the Group 0 stream. auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>( @@ -3416,6 +3464,12 @@ Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError), _)); stream_input->OnSubscribeNamespaceMessage(MoqtSubscribeNamespace(7)); + MoqtTrackStatus track_status = DefaultSubscribe(); + track_status.request_id = 9; + EXPECT_CALL( + mock_stream_, + Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError), _)); + stream_input->OnTrackStatusMessage(track_status); // Block all outgoing SUBSCRIBE, ANNOUNCE, GOAWAY,etc. EXPECT_CALL(mock_stream_, Writev).Times(0); MockSubscribeRemoteTrackVisitor remote_track_visitor; @@ -3788,6 +3842,107 @@ EXPECT_TRUE(IsInvalidArgument(task->GetStatus())); } +TEST_F(MoqtSessionTest, IncomingTrackStatusThenSynchronousOk) { + webtransport::test::MockStream control_stream; + std::unique_ptr<MoqtControlParserVisitor> stream_input = + MoqtSessionPeer::CreateControlStream(&session_, &control_stream); + auto* track = CreateTrackPublisher(); + + MoqtTrackStatus track_status = DefaultSubscribe(); + EXPECT_CALL(*track, AddObjectListener) + .WillOnce(Invoke([&](MoqtObjectListener* listener) { + EXPECT_CALL(*track, expiration) + .WillRepeatedly( + Return(quic::QuicTimeDelta::FromMilliseconds(10000))); + EXPECT_CALL(*track, delivery_order) + .WillRepeatedly(Return(MoqtDeliveryOrder::kAscending)); + EXPECT_CALL(*track, largest_location) + .WillRepeatedly(Return(std::nullopt)); + MoqtTrackStatusOk expected_ok; + expected_ok.request_id = track_status.request_id; + expected_ok.track_alias = 0; + expected_ok.expires = quic::QuicTimeDelta::FromMilliseconds(10000); + expected_ok.group_order = MoqtDeliveryOrder::kAscending; + expected_ok.largest_location = std::nullopt; + EXPECT_CALL(control_stream, + Writev(SerializedControlMessage(expected_ok), _)); + EXPECT_CALL(*track, RemoveObjectListener); + listener->OnSubscribeAccepted(); + })); + stream_input->OnTrackStatusMessage(track_status); +} + +TEST_F(MoqtSessionTest, IncomingTrackStatusThenAsynchronousOk) { + webtransport::test::MockStream control_stream; + std::unique_ptr<MoqtControlParserVisitor> stream_input = + MoqtSessionPeer::CreateControlStream(&session_, &control_stream); + auto* track = CreateTrackPublisher(); + + MoqtTrackStatus track_status = DefaultSubscribe(); + MoqtObjectListener* listener = nullptr; + EXPECT_CALL(*track, AddObjectListener) + .WillOnce(testing::SaveArg<0>(&listener)); + stream_input->OnTrackStatusMessage(track_status); + ASSERT_NE(listener, nullptr); + EXPECT_CALL(*track, expiration) + .WillRepeatedly(Return(quic::QuicTimeDelta::FromMilliseconds(10000))); + EXPECT_CALL(*track, delivery_order) + .WillRepeatedly(Return(MoqtDeliveryOrder::kAscending)); + EXPECT_CALL(*track, largest_location).WillRepeatedly(Return(std::nullopt)); + MoqtTrackStatusOk expected_ok; + expected_ok.request_id = track_status.request_id; + expected_ok.track_alias = 0; + expected_ok.expires = quic::QuicTimeDelta::FromMilliseconds(10000); + expected_ok.group_order = MoqtDeliveryOrder::kAscending; + expected_ok.largest_location = std::nullopt; + EXPECT_CALL(control_stream, Writev(SerializedControlMessage(expected_ok), _)); + EXPECT_CALL(*track, RemoveObjectListener(listener)); + listener->OnSubscribeAccepted(); +} + +TEST_F(MoqtSessionTest, IncomingTrackStatusThenSynchronousError) { + webtransport::test::MockStream control_stream; + std::unique_ptr<MoqtControlParserVisitor> stream_input = + MoqtSessionPeer::CreateControlStream(&session_, &control_stream); + auto* track = CreateTrackPublisher(); + + MoqtTrackStatus track_status = DefaultSubscribe(); + bool executed_AddObjectListener = false; + EXPECT_CALL(*track, AddObjectListener) + .WillOnce(Invoke([&](MoqtObjectListener* listener) { + EXPECT_CALL( + control_stream, + Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError), + _)); + EXPECT_CALL(*track, RemoveObjectListener); + listener->OnSubscribeRejected(MoqtSubscribeErrorReason( + RequestErrorCode::kInternalError, "Test error")); + executed_AddObjectListener = true; + })); + stream_input->OnTrackStatusMessage(track_status); + EXPECT_TRUE(executed_AddObjectListener); +} + +TEST_F(MoqtSessionTest, IncomingTrackStatusThenAsynchronousError) { + webtransport::test::MockStream control_stream; + std::unique_ptr<MoqtControlParserVisitor> stream_input = + MoqtSessionPeer::CreateControlStream(&session_, &control_stream); + auto* track = CreateTrackPublisher(); + + MoqtTrackStatus track_status = DefaultSubscribe(); + MoqtObjectListener* listener; + EXPECT_CALL(*track, AddObjectListener) + .WillOnce(testing::SaveArg<0>(&listener)); + stream_input->OnTrackStatusMessage(track_status); + ASSERT_NE(listener, nullptr); + EXPECT_CALL( + control_stream, + Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError), _)); + EXPECT_CALL(*track, RemoveObjectListener(listener)); + listener->OnSubscribeRejected( + MoqtSubscribeErrorReason(RequestErrorCode::kInternalError, "Test error")); +} + // TODO: re-enable this test once this behavior is re-implemented. #if 0 TEST_F(MoqtSessionTest, SubscribeUpdateClosesSubscription) {
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc index f6b14b4..7656a9f 100644 --- a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc +++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
@@ -25,99 +25,6 @@ namespace { -struct TypeVisitor { - MoqtMessageType operator()(const MoqtClientSetup&) { - return MoqtMessageType::kClientSetup; - } - MoqtMessageType operator()(const MoqtServerSetup&) { - return MoqtMessageType::kServerSetup; - } - MoqtMessageType operator()(const MoqtSubscribe&) { - return MoqtMessageType::kSubscribe; - } - MoqtMessageType operator()(const MoqtSubscribeOk&) { - return MoqtMessageType::kSubscribeOk; - } - MoqtMessageType operator()(const MoqtSubscribeError&) { - return MoqtMessageType::kSubscribeError; - } - MoqtMessageType operator()(const MoqtUnsubscribe&) { - return MoqtMessageType::kUnsubscribe; - } - MoqtMessageType operator()(const MoqtSubscribeDone&) { - return MoqtMessageType::kSubscribeDone; - } - MoqtMessageType operator()(const MoqtSubscribeUpdate&) { - return MoqtMessageType::kSubscribeUpdate; - } - MoqtMessageType operator()(const MoqtAnnounce&) { - return MoqtMessageType::kAnnounce; - } - MoqtMessageType operator()(const MoqtAnnounceOk&) { - return MoqtMessageType::kAnnounceOk; - } - MoqtMessageType operator()(const MoqtAnnounceError&) { - return MoqtMessageType::kAnnounceError; - } - MoqtMessageType operator()(const MoqtAnnounceCancel&) { - return MoqtMessageType::kAnnounceCancel; - } - MoqtMessageType operator()(const MoqtTrackStatusRequest&) { - return MoqtMessageType::kTrackStatusRequest; - } - MoqtMessageType operator()(const MoqtUnannounce&) { - return MoqtMessageType::kUnannounce; - } - MoqtMessageType operator()(const MoqtTrackStatus&) { - return MoqtMessageType::kTrackStatus; - } - MoqtMessageType operator()(const MoqtGoAway&) { - return MoqtMessageType::kGoAway; - } - MoqtMessageType operator()(const MoqtSubscribeNamespace&) { - return MoqtMessageType::kSubscribeNamespace; - } - MoqtMessageType operator()(const MoqtSubscribeNamespaceOk&) { - return MoqtMessageType::kSubscribeNamespaceOk; - } - MoqtMessageType operator()(const MoqtSubscribeNamespaceError&) { - return MoqtMessageType::kSubscribeNamespaceError; - } - MoqtMessageType operator()(const MoqtUnsubscribeNamespace&) { - return MoqtMessageType::kUnsubscribeNamespace; - } - MoqtMessageType operator()(const MoqtMaxRequestId&) { - return MoqtMessageType::kMaxRequestId; - } - MoqtMessageType operator()(const MoqtFetch&) { - return MoqtMessageType::kFetch; - } - MoqtMessageType operator()(const MoqtFetchCancel&) { - return MoqtMessageType::kFetchCancel; - } - MoqtMessageType operator()(const MoqtFetchOk&) { - return MoqtMessageType::kFetchOk; - } - MoqtMessageType operator()(const MoqtFetchError&) { - return MoqtMessageType::kFetchError; - } - MoqtMessageType operator()(const MoqtRequestsBlocked&) { - return MoqtMessageType::kRequestsBlocked; - } - MoqtMessageType operator()(const MoqtPublish&) { - return MoqtMessageType::kPublish; - } - MoqtMessageType operator()(const MoqtPublishOk&) { - return MoqtMessageType::kPublishOk; - } - MoqtMessageType operator()(const MoqtPublishError&) { - return MoqtMessageType::kPublishError; - } - MoqtMessageType operator()(const MoqtObjectAck&) { - return MoqtMessageType::kObjectAck; - } -}; - struct FramingVisitor { quiche::QuicheBuffer operator()(const MoqtClientSetup& message) { return framer.SerializeClientSetup(message); @@ -152,18 +59,21 @@ quiche::QuicheBuffer operator()(const MoqtAnnounceError& message) { return framer.SerializeAnnounceError(message); } - quiche::QuicheBuffer operator()(const MoqtAnnounceCancel& message) { - return framer.SerializeAnnounceCancel(message); - } - quiche::QuicheBuffer operator()(const MoqtTrackStatusRequest& message) { - return framer.SerializeTrackStatusRequest(message); - } quiche::QuicheBuffer operator()(const MoqtUnannounce& message) { return framer.SerializeUnannounce(message); } + quiche::QuicheBuffer operator()(const MoqtAnnounceCancel& message) { + return framer.SerializeAnnounceCancel(message); + } quiche::QuicheBuffer operator()(const MoqtTrackStatus& message) { return framer.SerializeTrackStatus(message); } + quiche::QuicheBuffer operator()(const MoqtTrackStatusOk& message) { + return framer.SerializeTrackStatusOk(message); + } + quiche::QuicheBuffer operator()(const MoqtTrackStatusError& message) { + return framer.SerializeTrackStatusError(message); + } quiche::QuicheBuffer operator()(const MoqtGoAway& message) { return framer.SerializeGoAway(message); } @@ -211,6 +121,7 @@ } MoqtFramer& framer; + bool is_track_status; }; class GenericMessageParseVisitor : public MoqtControlParserVisitor { @@ -251,18 +162,21 @@ void OnAnnounceErrorMessage(const MoqtAnnounceError& message) { frames_.push_back(message); } - void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) { - frames_.push_back(message); - } - void OnTrackStatusRequestMessage(const MoqtTrackStatusRequest& message) { - frames_.push_back(message); - } void OnUnannounceMessage(const MoqtUnannounce& message) { frames_.push_back(message); } + void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) { + frames_.push_back(message); + } void OnTrackStatusMessage(const MoqtTrackStatus& message) { frames_.push_back(message); } + void OnTrackStatusOkMessage(const MoqtTrackStatusOk& message) { + frames_.push_back(message); + } + void OnTrackStatusErrorMessage(const MoqtTrackStatusError& message) { + frames_.push_back(message); + } void OnGoAwayMessage(const MoqtGoAway& message) { frames_.push_back(message); } @@ -324,10 +238,6 @@ return std::string(std::visit(FramingVisitor{framer}, frame).AsStringView()); } -MoqtMessageType MessageTypeForGenericMessage(const MoqtGenericFrame& frame) { - return std::visit(TypeVisitor(), frame); -} - std::vector<MoqtGenericFrame> ParseGenericMessage(absl::string_view body) { std::vector<MoqtGenericFrame> result; GenericMessageParseVisitor visitor(&result);
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h index 54a704c..b75a0c5 100644 --- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h +++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -25,19 +25,16 @@ // TODO: remove MoqtObject from TestMessageBase::MessageStructuredData and merge // those two types. -using MoqtGenericFrame = - std::variant<MoqtClientSetup, MoqtServerSetup, MoqtSubscribe, - MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe, - MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce, - MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel, - MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus, - MoqtGoAway, MoqtSubscribeNamespace, MoqtSubscribeNamespaceOk, - MoqtSubscribeNamespaceError, MoqtUnsubscribeNamespace, - MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk, - MoqtFetchError, MoqtRequestsBlocked, MoqtPublish, - MoqtPublishOk, MoqtPublishError, MoqtObjectAck>; - -MoqtMessageType MessageTypeForGenericMessage(const MoqtGenericFrame& frame); +using MoqtGenericFrame = std::variant< + MoqtClientSetup, MoqtServerSetup, MoqtSubscribe, MoqtSubscribeOk, + MoqtSubscribeError, MoqtUnsubscribe, MoqtSubscribeDone, MoqtSubscribeUpdate, + MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError, MoqtUnannounce, + MoqtAnnounceCancel, MoqtTrackStatus, MoqtTrackStatusOk, + MoqtTrackStatusError, MoqtGoAway, MoqtSubscribeNamespace, + MoqtSubscribeNamespaceOk, MoqtSubscribeNamespaceError, + MoqtUnsubscribeNamespace, MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, + MoqtFetchOk, MoqtFetchError, MoqtRequestsBlocked, MoqtPublish, + MoqtPublishOk, MoqtPublishError, MoqtObjectAck>; std::string SerializeGenericMessage(const MoqtGenericFrame& frame, bool use_webtrans = false);
diff --git a/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h b/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h index c29edb6..76ca1fa 100644 --- a/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h +++ b/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
@@ -75,19 +75,21 @@ void OnAnnounceErrorMessage(const MoqtAnnounceError& message) override { OnControlMessage(message); } - void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override { - OnControlMessage(message); - } - void OnTrackStatusRequestMessage( - const MoqtTrackStatusRequest& message) override { - OnControlMessage(message); - } void OnUnannounceMessage(const MoqtUnannounce& message) override { OnControlMessage(message); } + void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override { + OnControlMessage(message); + } void OnTrackStatusMessage(const MoqtTrackStatus& message) override { OnControlMessage(message); } + void OnTrackStatusOkMessage(const MoqtTrackStatusOk& message) override { + OnControlMessage(message); + } + void OnTrackStatusErrorMessage(const MoqtTrackStatusError& message) override { + OnControlMessage(message); + } void OnGoAwayMessage(const MoqtGoAway& message) override { OnControlMessage(message); }
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h index 55edb39..bfe3d95 100644 --- a/quiche/quic/moqt/test_tools/moqt_test_message.h +++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -61,17 +61,16 @@ public: virtual ~TestMessageBase() = default; - using MessageStructuredData = - std::variant<MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe, - MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe, - MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce, - MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel, - MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus, - MoqtGoAway, MoqtSubscribeNamespace, MoqtSubscribeNamespaceOk, - MoqtSubscribeNamespaceError, MoqtUnsubscribeNamespace, - MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk, - MoqtFetchError, MoqtRequestsBlocked, MoqtPublish, - MoqtPublishOk, MoqtPublishError, MoqtObjectAck>; + using MessageStructuredData = std::variant< + MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe, + MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe, MoqtSubscribeDone, + MoqtSubscribeUpdate, MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError, + MoqtUnannounce, MoqtAnnounceCancel, MoqtTrackStatus, MoqtTrackStatusOk, + MoqtTrackStatusError, MoqtGoAway, MoqtSubscribeNamespace, + MoqtSubscribeNamespaceOk, MoqtSubscribeNamespaceError, + MoqtUnsubscribeNamespace, MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, + MoqtFetchOk, MoqtFetchError, MoqtRequestsBlocked, MoqtPublish, + MoqtPublishOk, MoqtPublishError, MoqtObjectAck>; // The total actual size of the message. size_t total_message_size() const { return wire_image_size_; } @@ -116,6 +115,7 @@ memcpy(wire_image_, wire_image, wire_image_size); wire_image_size_ = wire_image_size; } + void SetByte(size_t offset, char value) { wire_image_[offset] = value; } // Expands all the varints in the message, alternating between making them 2, // 4, and 8 bytes long. Updates length fields accordingly. @@ -629,6 +629,20 @@ return TestMessageBase::MessageStructuredData(subscribe_); } + protected: + MoqtSubscribe subscribe_ = { + /*request_id=*/1, + FullTrackName("foo", "abcd"), + /*subscriber_priority=*/0x20, + /*group_order=*/MoqtDeliveryOrder::kDescending, + /*forward=*/true, + /*filter_type=*/MoqtFilterType::kAbsoluteStart, + /*start=*/Location(4, 1), + /*end_group=*/std::nullopt, + VersionSpecificParameters(quic::QuicTimeDelta::FromMilliseconds(10000), + AuthTokenType::kOutOfBand, "bar"), + }; + private: uint8_t raw_packet_[31] = { 0x03, @@ -664,19 +678,6 @@ 0x61, 0x72, // authorization_tag = "bar" }; - - MoqtSubscribe subscribe_ = { - /*request_id=*/1, - FullTrackName("foo", "abcd"), - /*subscriber_priority=*/0x20, - /*group_order=*/MoqtDeliveryOrder::kDescending, - /*forward=*/true, - /*filter_type=*/MoqtFilterType::kAbsoluteStart, - /*start=*/Location(4, 1), - /*end_group=*/std::nullopt, - VersionSpecificParameters(quic::QuicTimeDelta::FromMilliseconds(10000), - AuthTokenType::kOutOfBand, "bar"), - }; }; class QUICHE_NO_EXPORT SubscribeOkMessage : public TestMessageBase { @@ -730,16 +731,8 @@ SetWireImage(raw_packet_, sizeof(raw_packet_)); } - private: - uint8_t raw_packet_[17] = { - 0x04, 0x00, 0x0e, 0x01, 0x02, 0x03, // request_id, alias, expires - 0x02, 0x01, // group_order = 2, content exists - 0x0c, 0x14, // largest_location = (12, 20) - 0x02, // 2 parameters - 0x02, 0x67, 0x10, // delivery_timeout = 10000 - 0x04, 0x67, 0x10, // max_cache_duration = 10000 - }; - + protected: + // This is protected so that TrackStatusOk can edit the fields. MoqtSubscribeOk subscribe_ok_ = { /*request_id=*/1, /*track_alias=*/2, @@ -749,6 +742,16 @@ VersionSpecificParameters(quic::QuicTimeDelta::FromMilliseconds(10000), quic::QuicTimeDelta::FromMilliseconds(10000)), }; + + private: + uint8_t raw_packet_[17] = { + 0x04, 0x00, 0x0e, 0x01, 0x02, 0x03, // request_id, alias, expires + 0x02, 0x01, // group_order = 2, content exists + 0x0c, 0x14, // largest_location = (12, 20) + 0x02, // 2 parameters + 0x02, 0x67, 0x10, // delivery_timeout = 10000 + 0x04, 0x67, 0x10, // max_cache_duration = 10000 + }; }; class QUICHE_NO_EXPORT SubscribeErrorMessage : public TestMessageBase { @@ -780,6 +783,13 @@ return TestMessageBase::MessageStructuredData(subscribe_error_); } + protected: + MoqtSubscribeError subscribe_error_ = { + /*request_id=*/2, + /*error_code=*/RequestErrorCode::kInvalidRange, + /*reason_phrase=*/"bar", + }; + private: uint8_t raw_packet_[9] = { 0x05, 0x00, 0x06, @@ -787,12 +797,6 @@ 0x05, // error_code = 5 0x03, 0x62, 0x61, 0x72, // reason_phrase = "bar" }; - - MoqtSubscribeError subscribe_error_ = { - /*request_id=*/2, - /*error_code=*/RequestErrorCode::kInvalidRange, - /*reason_phrase=*/"bar", - }; }; class QUICHE_NO_EXPORT UnsubscribeMessage : public TestMessageBase { @@ -1053,6 +1057,37 @@ }; }; +class QUICHE_NO_EXPORT UnannounceMessage : public TestMessageBase { + public: + UnannounceMessage() : TestMessageBase() { + SetWireImage(raw_packet_, sizeof(raw_packet_)); + } + + bool EqualFieldValues(MessageStructuredData& values) const override { + auto cast = std::get<MoqtUnannounce>(values); + if (cast.track_namespace != unannounce_.track_namespace) { + QUIC_LOG(INFO) << "UNANNOUNCE track namespace mismatch"; + return false; + } + return true; + } + + void ExpandVarints() override { ExpandVarintsImpl("vv---"); } + + MessageStructuredData structured_data() const override { + return TestMessageBase::MessageStructuredData(unannounce_); + } + + private: + uint8_t raw_packet_[8] = { + 0x09, 0x00, 0x05, 0x01, 0x03, 0x66, 0x6f, 0x6f, // track_namespace + }; + + MoqtUnannounce unannounce_ = { + TrackNamespace("foo"), + }; +}; + class QUICHE_NO_EXPORT AnnounceCancelMessage : public TestMessageBase { public: AnnounceCancelMessage() : TestMessageBase() { @@ -1097,131 +1132,66 @@ }; }; -class QUICHE_NO_EXPORT TrackStatusRequestMessage : public TestMessageBase { +class QUICHE_NO_EXPORT TrackStatusMessage : public SubscribeMessage { public: - TrackStatusRequestMessage() : TestMessageBase() { - SetWireImage(raw_packet_, sizeof(raw_packet_)); + TrackStatusMessage() : SubscribeMessage() { + SetByte(0, static_cast<uint8_t>(MoqtMessageType::kTrackStatus)); } bool EqualFieldValues(MessageStructuredData& values) const override { - auto cast = std::get<MoqtTrackStatusRequest>(values); - if (cast.request_id != track_status_request_.request_id) { - QUIC_LOG(INFO) << "TRACK STATUS REQUEST request ID mismatch"; - return false; - } - if (cast.full_track_name != track_status_request_.full_track_name) { - QUIC_LOG(INFO) << "TRACK STATUS REQUEST track name mismatch"; - return false; - } - if (cast.parameters != track_status_request_.parameters) { - QUIC_LOG(INFO) << "TRACK STATUS REQUEST parameter mismatch"; - return false; - } - return true; + auto value = std::get<MoqtTrackStatus>(values); + auto* subscribe = reinterpret_cast<MoqtSubscribe*>(&value); + MessageStructuredData structured_data = + TestMessageBase::MessageStructuredData(*subscribe); + return SubscribeMessage::EqualFieldValues(structured_data); } - void ExpandVarints() override { ExpandVarintsImpl("vvv---v----vvv-----"); } - MessageStructuredData structured_data() const override { - return TestMessageBase::MessageStructuredData(track_status_request_); + return TestMessageBase::MessageStructuredData(MoqtTrackStatus(subscribe_)); } - - private: - uint8_t raw_packet_[22] = { - 0x0d, 0x00, 0x13, 0x02, // request_id = 2 - 0x01, 0x03, 0x66, 0x6f, 0x6f, // track_namespace = "foo" - 0x04, 0x61, 0x62, 0x63, 0x64, // track_name = "abcd" - 0x01, // 1 parameter - 0x03, 0x05, 0x03, 0x00, 0x62, 0x61, 0x72, // authorization_tag = "bar" - }; - - MoqtTrackStatusRequest track_status_request_ = { - /*request_id=*/2, - FullTrackName("foo", "abcd"), - VersionSpecificParameters(AuthTokenType::kOutOfBand, "bar"), - }; }; -class QUICHE_NO_EXPORT UnannounceMessage : public TestMessageBase { +class QUICHE_NO_EXPORT TrackStatusOkMessage : public SubscribeOkMessage { public: - UnannounceMessage() : TestMessageBase() { - SetWireImage(raw_packet_, sizeof(raw_packet_)); + TrackStatusOkMessage() : SubscribeOkMessage() { + SetByte(0, static_cast<uint8_t>(MoqtMessageType::kTrackStatusOk)); + // Track alias is zero. + SetByte(4, 0x00); + subscribe_ok_.track_alias = 0; } bool EqualFieldValues(MessageStructuredData& values) const override { - auto cast = std::get<MoqtUnannounce>(values); - if (cast.track_namespace != unannounce_.track_namespace) { - QUIC_LOG(INFO) << "UNANNOUNCE track namespace mismatch"; - return false; - } - return true; + auto value = std::get<MoqtTrackStatusOk>(values); + auto* subscribe = reinterpret_cast<MoqtSubscribeOk*>(&value); + MessageStructuredData structured_data = + TestMessageBase::MessageStructuredData(*subscribe); + return SubscribeOkMessage::EqualFieldValues(structured_data); } - void ExpandVarints() override { ExpandVarintsImpl("vv---"); } - MessageStructuredData structured_data() const override { - return TestMessageBase::MessageStructuredData(unannounce_); + return TestMessageBase::MessageStructuredData( + MoqtTrackStatusOk(subscribe_ok_)); } - - private: - uint8_t raw_packet_[8] = { - 0x09, 0x00, 0x05, 0x01, 0x03, 0x66, 0x6f, 0x6f, // track_namespace - }; - - MoqtUnannounce unannounce_ = { - TrackNamespace("foo"), - }; }; -class QUICHE_NO_EXPORT TrackStatusMessage : public TestMessageBase { +class QUICHE_NO_EXPORT TrackStatusErrorMessage : public SubscribeErrorMessage { public: - TrackStatusMessage() : TestMessageBase() { - SetWireImage(raw_packet_, sizeof(raw_packet_)); + TrackStatusErrorMessage() : SubscribeErrorMessage() { + SetByte(0, static_cast<uint8_t>(MoqtMessageType::kTrackStatusError)); } bool EqualFieldValues(MessageStructuredData& values) const override { - auto cast = std::get<MoqtTrackStatus>(values); - if (cast.request_id != track_status_.request_id) { - QUIC_LOG(INFO) << "TRACK STATUS request ID mismatch"; - return false; - } - if (cast.status_code != track_status_.status_code) { - QUIC_LOG(INFO) << "TRACK STATUS code mismatch"; - return false; - } - if (cast.largest_location != track_status_.largest_location) { - QUIC_LOG(INFO) << "TRACK STATUS largest location mismatch"; - return false; - } - if (cast.parameters != track_status_.parameters) { - QUIC_LOG(INFO) << "TRACK STATUS parameters mismatch"; - return false; - } - return true; + auto value = std::get<MoqtTrackStatusError>(values); + auto* subscribe = reinterpret_cast<MoqtSubscribeError*>(&value); + MessageStructuredData structured_data = + TestMessageBase::MessageStructuredData(*subscribe); + return SubscribeErrorMessage::EqualFieldValues(structured_data); } - void ExpandVarints() override { ExpandVarintsImpl("v-vvvv--v--"); } - MessageStructuredData structured_data() const override { - return TestMessageBase::MessageStructuredData(track_status_); + return TestMessageBase::MessageStructuredData( + MoqtTrackStatusError(subscribe_error_)); } - - private: - uint8_t raw_packet_[14] = { - 0x0e, 0x00, 0x0b, 0x02, // request_id = 2 - 0x00, 0x0c, 0x14, // status, last_group, last_object - 0x02, // 2 parameters - 0x02, 0x67, 0x10, // Delivery Timeout = 10000 - 0x04, 0x67, 0x10, // Max Cache Duration = 10000 - }; - - MoqtTrackStatus track_status_ = { - /*request_id=*/2, - /*status_code=*/MoqtTrackStatusCode::kInProgress, - /*largest_location=*/Location(12, 20), - VersionSpecificParameters(quic::QuicTimeDelta::FromMilliseconds(10000), - quic::QuicTimeDelta::FromMilliseconds(10000)), - }; }; class QUICHE_NO_EXPORT GoAwayMessage : public TestMessageBase { @@ -2067,14 +2037,16 @@ return std::make_unique<AnnounceOkMessage>(); case MoqtMessageType::kAnnounceError: return std::make_unique<AnnounceErrorMessage>(); - case MoqtMessageType::kAnnounceCancel: - return std::make_unique<AnnounceCancelMessage>(); - case MoqtMessageType::kTrackStatusRequest: - return std::make_unique<TrackStatusRequestMessage>(); case MoqtMessageType::kUnannounce: return std::make_unique<UnannounceMessage>(); + case MoqtMessageType::kAnnounceCancel: + return std::make_unique<AnnounceCancelMessage>(); case MoqtMessageType::kTrackStatus: return std::make_unique<TrackStatusMessage>(); + case MoqtMessageType::kTrackStatusOk: + return std::make_unique<TrackStatusOkMessage>(); + case MoqtMessageType::kTrackStatusError: + return std::make_unique<TrackStatusErrorMessage>(); case MoqtMessageType::kGoAway: return std::make_unique<GoAwayMessage>(); case MoqtMessageType::kSubscribeNamespace:
diff --git a/quiche/quic/moqt/tools/chat_server.cc b/quiche/quic/moqt/tools/chat_server.cc index acc818c..4c64466 100644 --- a/quiche/quic/moqt/tools/chat_server.cc +++ b/quiche/quic/moqt/tools/chat_server.cc
@@ -15,6 +15,7 @@ #include "absl/status/statusor.h" #include "absl/strings/string_view.h" #include "quiche/quic/core/crypto/proof_source.h" +#include "quiche/quic/core/quic_time.h" #include "quiche/quic/moqt/moqt_live_relay_queue.h" #include "quiche/quic/moqt/moqt_messages.h" #include "quiche/quic/moqt/moqt_priority.h" @@ -197,7 +198,8 @@ void ChatServer::AddUser(FullTrackName track_name) { // Add a local track. user_queues_[track_name] = std::make_shared<MoqtLiveRelayQueue>( - track_name, MoqtForwardingPreference::kSubgroup); + track_name, MoqtForwardingPreference::kSubgroup, + MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite()); publisher_.Add(user_queues_[track_name]); for (auto& session : sessions_) { session.AnnounceIfSubscribed(track_name.track_namespace());
diff --git a/quiche/quic/moqt/tools/moqt_mock_visitor.h b/quiche/quic/moqt/tools/moqt_mock_visitor.h index f786918..b3ff683 100644 --- a/quiche/quic/moqt/tools/moqt_mock_visitor.h +++ b/quiche/quic/moqt/tools/moqt_mock_visitor.h
@@ -58,7 +58,7 @@ public: explicit MockTrackPublisher(FullTrackName name) : track_name_(std::move(name)) { - ON_CALL(*this, GetDeliveryOrder()) + ON_CALL(*this, delivery_order()) .WillByDefault(testing::Return(MoqtDeliveryOrder::kAscending)); } const FullTrackName& GetTrackName() const override { return track_name_; } @@ -69,19 +69,20 @@ (override)); MOCK_METHOD(void, RemoveObjectListener, (MoqtObjectListener * listener), (override)); - MOCK_METHOD(absl::StatusOr<MoqtTrackStatusCode>, GetTrackStatus, (), + MOCK_METHOD(std::optional<Location>, largest_location, (), (const, override)); + MOCK_METHOD(std::optional<MoqtForwardingPreference>, forwarding_preference, + (), (const, override)); + MOCK_METHOD(std::optional<MoqtDeliveryOrder>, delivery_order, (), (const, override)); - MOCK_METHOD(Location, GetLargestLocation, (), (const, override)); - MOCK_METHOD(MoqtForwardingPreference, GetForwardingPreference, (), + MOCK_METHOD(std::optional<quic::QuicTimeDelta>, expiration, (), (const, override)); - MOCK_METHOD(MoqtPriority, GetPublisherPriority, (), (const, override)); - MOCK_METHOD(MoqtDeliveryOrder, GetDeliveryOrder, (), (const, override)); MOCK_METHOD(std::unique_ptr<MoqtFetchTask>, StandaloneFetch, - (Location, Location, MoqtDeliveryOrder), (override)); + (Location, Location, std::optional<MoqtDeliveryOrder>), + (override)); MOCK_METHOD(std::unique_ptr<MoqtFetchTask>, RelativeFetch, - (uint64_t, MoqtDeliveryOrder), (override)); + (uint64_t, std::optional<MoqtDeliveryOrder>), (override)); MOCK_METHOD(std::unique_ptr<MoqtFetchTask>, AbsoluteFetch, - (uint64_t, MoqtDeliveryOrder), (override)); + (uint64_t, std::optional<MoqtDeliveryOrder>), (override)); private: FullTrackName track_name_;