Add FetchAvailability result

cmd/examples/server.cpp

@@ -770,10 +770,10 @@ class MyServer : public quicr::Server
      *
      * @returns true if the range of groups and objects exist in the cache, otherwise returns false.
      */
-    bool FetchReceived([[maybe_unused]] quicr::ConnectionHandle connection_handle,
-                       [[maybe_unused]] uint64_t subscribe_id,
-                       const quicr::FullTrackName& track_full_name,
-                       const quicr::FetchAttributes& attrs) override
+    std::optional<FetchAvailability> FetchReceived([[maybe_unused]] quicr::ConnectionHandle connection_handle,
+                                                   [[maybe_unused]] uint64_t subscribe_id,
+                                                   const quicr::FullTrackName& track_full_name,
+                                                   const quicr::FetchAttributes& attrs) override
     {
         SPDLOG_INFO("Received Fetch for conn_id: {} subscribe_id: {} start_group: {} end_group: {}",
                     connection_handle,
@@ -786,7 +786,7 @@ class MyServer : public quicr::Server
         auto cache_entry_it = qserver_vars::cache.find(th.track_fullname_hash);
         if (cache_entry_it == qserver_vars::cache.end()) {
             SPDLOG_WARN("No cache entry for the hash {}", th.track_fullname_hash);
-            return false;
+            return std::nullopt;
         }
 
         auto& [_, cache_entry] = *cache_entry_it;
@@ -795,13 +795,21 @@ class MyServer : public quicr::Server
 
         if (groups.empty()) {
             SPDLOG_WARN("No groups found for requested range");
-            return false;
+            return std::nullopt;
         }
 
-        return std::any_of(groups.begin(), groups.end(), [&](const auto& group) {
+        const bool available = std::any_of(groups.begin(), groups.end(), [&](const auto& group) {
             return !group->empty() && group->begin()->headers.object_id <= attrs.start_object &&
                    std::prev(group->end())->headers.object_id >= (attrs.end_object - 1);
         });
+        if (!available) {
+            SPDLOG_WARN("No objects found for requested range");
+            return std::nullopt;
+        }
+        const auto last_cached = std::prev(groups.back()->end())->headers;
+        return FetchAvailability{ .end_of_track = false,
+                                  .largest_group = last_cached.group_id,
+                                  .largest_object = last_cached.object_id };
     }
 
     /**

include/quicr/server.h

@@ -46,6 +46,14 @@ namespace quicr {
             std::optional<Bytes> reason_phrase;
         };
 
+        // Availability of the track.
+        struct FetchAvailability
+        {
+            bool end_of_track;
+            messages::GroupId largest_group;
+            messages::ObjectId largest_object;
+        };
+
         /**
          * @brief MoQ Server constructor to create the MOQ server mode instance
          *
@@ -282,12 +290,12 @@ namespace quicr {
          * @param track_full_name   Track full name
          * @param attributes        Fetch attributes received.
          *
-         * @returns true if user defined conditions of Fetch are satisfied, false otherwise.
+         * @returns Availability for FETCH_OK, if possible. If the fetch cannot be served, return std::nullopt.
          */
-        virtual bool FetchReceived(ConnectionHandle connection_handle,
-                                   uint64_t subscribe_id,
-                                   const FullTrackName& track_full_name,
-                                   const FetchAttributes& attributes);
+        virtual std::optional<FetchAvailability> FetchReceived(ConnectionHandle connection_handle,
+                                                               uint64_t subscribe_id,
+                                                               const FullTrackName& track_full_name,
+                                                               const FetchAttributes& attributes);
 
         /**
          * @brief Event to run on sending FetchOk.

src/server.cpp

@@ -74,9 +74,12 @@ namespace quicr {
     {
     }
 
-    bool Server::FetchReceived(ConnectionHandle, uint64_t, const FullTrackName&, const FetchAttributes&)
+    std::optional<Server::FetchAvailability> Server::FetchReceived(ConnectionHandle,
+                                                                   uint64_t,
+                                                                   const FullTrackName&,
+                                                                   const FetchAttributes&)
     {
-        return false;
+        return std::nullopt;
     }
 
     void Server::OnFetchOk(ConnectionHandle, uint64_t, const FullTrackName&, const FetchAttributes&) {}
@@ -548,7 +551,8 @@ namespace quicr {
                     .end_object = msg.end_object,
                 };
 
-                if (!FetchReceived(conn_ctx.connection_handle, msg.subscribe_id, tfn, attrs)) {
+                const auto available = FetchReceived(conn_ctx.connection_handle, msg.subscribe_id, tfn, attrs);
+                if (!available) {
                     SendFetchError(
                       conn_ctx, msg.subscribe_id, messages::FetchErrorCode::kTrackDoesNotExist, "Track does not exist");
 
@@ -562,7 +566,12 @@ namespace quicr {
                     conn_ctx.current_subscribe_id = msg.subscribe_id + 1;
                 }
 
-                SendFetchOk(conn_ctx, msg.subscribe_id, msg.group_order, false, 0, 0);
+                SendFetchOk(conn_ctx,
+                            msg.subscribe_id,
+                            msg.group_order,
+                            available->end_of_track,
+                            available->largest_group,
+                            available->largest_object);
                 OnFetchOk(conn_ctx.connection_handle, msg.subscribe_id, tfn, attrs);
 
                 return true;