Update MOQTFetch* structures

Summary: In this commit, I'm updating the MOQTFetch, MOQTFetchOk, MOQTFetchError, and MOQTFetchCancel structures to be in line with the specification.

Reviewed By: sandarsh

Differential Revision: D88694518

fbshipit-source-id: 7efabc89b319ce414204052dff3a0aeb5dd8d44d

Author: Aman Sharma

moxygen/mlog/MLogTypes.cpp

@@ -147,51 +147,62 @@ folly::dynamic MOQTUnsubscribe::toDynamic() const {
   return obj;
 }
 
-folly::dynamic MOQTFetch::toDynamic() const {
+folly::dynamic MOQTStandaloneFetch::toDynamic() const {
   folly::dynamic obj = folly::dynamic::object;
-  obj["type"] = type;
-  obj["subscribeId"] = std::to_string(subscribeId);
-  obj["subscriberPriority"] = std::to_string(subscriberPriority);
-  obj["groupOrder"] = std::to_string(groupOrder);
-  obj["fetchType"] = std::to_string(fetchType);
-  auto trackNamespaceStr = parseTrackNamespace(trackNamespace);
-  obj["trackNamespace"] =
-      folly::dynamic::array(trackNamespaceStr.begin(), trackNamespaceStr.end());
-  if (trackName.hasValue()) {
-    obj["trackName"] = parseTrackName(trackName.value());
-  }
-  if (startGroup.hasValue()) {
-    obj["startGroup"] = std::to_string(startGroup.value());
-  }
-  if (startObject.hasValue()) {
-    obj["startObject"] = std::to_string(startObject.value());
-  }
-  if (endGroup.hasValue()) {
-    obj["endGroup"] = std::to_string(endGroup.value());
+  std::vector<std::string> trackNamespaceStr;
+  for (const auto& ns : trackNamespace) {
+    if (ns.type == MOQTByteStringType::STRING_VALUE) {
+      trackNamespaceStr.push_back(ns.value);
+    }
   }
-  if (endObject.hasValue()) {
-    obj["endObject"] = std::to_string(endObject.value());
+  obj["track_namespace"] =
+      folly::dynamic::array(trackNamespaceStr.begin(), trackNamespaceStr.end());
+  if (trackName.type == MOQTByteStringType::STRING_VALUE) {
+    obj["track_name"] = trackName.value;
   }
-  if (joiningSubscribeId.hasValue()) {
-    obj["joiningSubscribeId"] = std::to_string(joiningSubscribeId.value());
+  obj["start_location"] = startLocation.toDynamic();
+  obj["end_location"] = endLocation.toDynamic();
+  return obj;
+}
+
+folly::dynamic MOQTJoiningFetch::toDynamic() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["joining_request_id"] = joiningRequestId;
+  obj["joining_start"] = joiningStart;
+  return obj;
+}
+
+folly::dynamic MOQTFetch::toDynamic() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["type"] = type;
+  obj["request_id"] = requestId;
+  obj["subscriber_priority"] = subscriberPriority;
+  obj["group_order"] = groupOrder;
+  obj["fetch_type"] = fetchType;
+
+  if (standaloneFetch.hasValue()) {
+    obj["standalone_fetch"] = standaloneFetch->toDynamic();
   }
-  if (precedingGroupOffset.hasValue()) {
-    obj["precedingGroupOffset"] = std::to_string(precedingGroupOffset.value());
+
+  if (joiningFetch.hasValue()) {
+    obj["joining_fetch"] = joiningFetch->toDynamic();
   }
-  obj["numberOfParameters"] = std::to_string(numberOfParameters);
-  std::vector<folly::dynamic> paramObjects;
-  paramObjects.reserve(parameters.size());
-  for (auto& param : parameters) {
-    paramObjects.push_back(param.toDynamic());
+
+  if (!parameters.empty()) {
+    std::vector<folly::dynamic> paramObjects;
+    paramObjects.reserve(parameters.size());
+    for (auto& param : parameters) {
+      paramObjects.push_back(param.toDynamic());
+    }
+    obj["parameters"] = folly::dynamic::array(paramObjects);
   }
-  obj["parameters"] = folly::dynamic::array(paramObjects);
   return obj;
 }
 
 folly::dynamic MOQTFetchCancel::toDynamic() const {
   folly::dynamic obj = folly::dynamic::object;
   obj["type"] = type;
-  obj["subscribeId"] = std::to_string(subscribeId);
+  obj["request_id"] = requestId;
   return obj;
 }
 
@@ -326,31 +337,33 @@ folly::dynamic MOQTSubscribeError::toDynamic() const {
 folly::dynamic MOQTFetchOk::toDynamic() const {
   folly::dynamic obj = folly::dynamic::object;
   obj["type"] = type;
-  obj["subscribeId"] = std::to_string(subscribeId);
-  obj["groupOrder"] = std::to_string(groupOrder);
-  obj["endOfTrack"] = std::to_string(endOfTrack);
-  obj["largestGroupId"] = std::to_string(largestGroupId);
-  obj["largestObjectId"] = std::to_string(largestObjectId);
-  obj["numberOfParameters"] = std::to_string(numberOfParameters);
-  std::vector<folly::dynamic> paramObjects;
-  paramObjects.reserve(subscribeParameters.size());
-  for (auto& param : subscribeParameters) {
-    paramObjects.push_back(param.toDynamic());
+  obj["request_id"] = requestId;
+  obj["group_order"] = groupOrder;
+  obj["end_of_track"] = endOfTrack;
+  obj["end_location"] = endLocation.toDynamic();
+  obj["number_of_parameters"] = numberOfParameters;
+
+  if (numberOfParameters > 0) {
+    std::vector<folly::dynamic> paramObjects;
+    paramObjects.reserve(parameters.size());
+    for (auto& param : parameters) {
+      paramObjects.push_back(param.toDynamic());
+    }
+    obj["parameters"] = folly::dynamic::array(paramObjects);
   }
-  obj["subscribeParameters"] = folly::dynamic::array(paramObjects);
   return obj;
 }
 
 folly::dynamic MOQTFetchError::toDynamic() const {
   folly::dynamic obj = folly::dynamic::object;
   obj["type"] = type;
-  obj["subscribeId"] = std::to_string(subscribeId);
-  obj["errorCode"] = std::to_string(errorCode);
+  obj["request_id"] = requestId;
+  obj["error_code"] = errorCode;
   if (reason.hasValue()) {
     obj["reason"] = reason.value();
   }
   if (reasonBytes.hasValue()) {
-    obj["reasonBytes"] = reasonBytes.value();
+    obj["reason_bytes"] = reasonBytes.value();
   }
   return obj;
 }

moxygen/mlog/MLogTypes.h

@@ -180,25 +180,34 @@ class MOQTUnsubscribe : public MOQTBaseControlMessage {
   uint64_t subscribeId{0};
 };
 
+struct MOQTStandaloneFetch {
+  std::vector<MOQTByteString> trackNamespace;
+  MOQTByteString trackName;
+  MOQTLocation startLocation;
+  MOQTLocation endLocation;
+
+  folly::dynamic toDynamic() const;
+};
+
+struct MOQTJoiningFetch {
+  uint64_t joiningRequestId{0};
+  uint64_t joiningStart{0};
+
+  folly::dynamic toDynamic() const;
+};
+
 class MOQTFetch : public MOQTBaseControlMessage {
  public:
   MOQTFetch() {
     type = "fetch";
   }
   folly::dynamic toDynamic() const override;
-  uint64_t subscribeId{0};
+  uint64_t requestId{0};
   uint8_t subscriberPriority{};
   uint8_t groupOrder{};
-  uint64_t fetchType{};
-  std::vector<MOQTByteString> trackNamespace;
-  folly::Optional<MOQTByteString> trackName;
-  folly::Optional<uint64_t> startGroup;
-  folly::Optional<uint64_t> startObject;
-  folly::Optional<uint64_t> endGroup;
-  folly::Optional<uint64_t> endObject;
-  folly::Optional<uint64_t> joiningSubscribeId;
-  folly::Optional<uint64_t> precedingGroupOffset;
-  uint64_t numberOfParameters{};
+  std::string fetchType;
+  folly::Optional<MOQTStandaloneFetch> standaloneFetch;
+  folly::Optional<MOQTJoiningFetch> joiningFetch;
   std::vector<MOQTParameter> parameters;
 };
 
@@ -208,7 +217,7 @@ class MOQTFetchCancel : public MOQTBaseControlMessage {
     type = "fetch_cancel";
   }
   folly::dynamic toDynamic() const override;
-  uint64_t subscribeId{0};
+  uint64_t requestId{0};
 };
 
 class MOQTAnnounceOk : public MOQTBaseControlMessage {
@@ -318,13 +327,12 @@ class MOQTFetchOk : public MOQTBaseControlMessage {
     type = "fetch_ok";
   }
   folly::dynamic toDynamic() const override;
-  uint64_t subscribeId{0};
+  uint64_t requestId{0};
   uint8_t groupOrder{};
   uint8_t endOfTrack{};
-  uint64_t largestGroupId{};
-  uint64_t largestObjectId{};
+  MOQTLocation endLocation;
   uint64_t numberOfParameters{};
-  std::vector<MOQTParameter> subscribeParameters;
+  std::vector<MOQTParameter> parameters;
 };
 
 class MOQTFetchError : public MOQTBaseControlMessage {
@@ -333,7 +341,7 @@ class MOQTFetchError : public MOQTBaseControlMessage {
     type = "fetch_error";
   }
   folly::dynamic toDynamic() const override;
-  uint64_t subscribeId{0};
+  uint64_t requestId{0};
   uint64_t errorCode{};
   folly::Optional<std::string> reason;
   folly::Optional<std::string> reasonBytes;

moxygen/mlog/MLogger.cpp

@@ -281,33 +281,41 @@ void MLogger::logFetch(
     const MOQTByteStringType& type,
     ControlMessageType controlType) {
   auto baseMsg = std::make_unique<MOQTFetch>();
-  baseMsg->subscribeId = req.requestID.value;
+  baseMsg->requestId = req.requestID.value;
   baseMsg->subscriberPriority = req.priority;
   baseMsg->groupOrder = static_cast<uint8_t>(req.groupOrder);
 
   auto [standalone, joining] = fetchType(req);
   if (joining) {
-    baseMsg->fetchType = static_cast<uint64_t>(joining->fetchType);
-    baseMsg->joiningSubscribeId =
+    if (joining->fetchType == FetchType::RELATIVE_JOINING) {
+      baseMsg->fetchType = "relative_joining";
+    } else {
+      baseMsg->fetchType = "absolute_joining";
+    }
+    MOQTJoiningFetch joiningFetchMsg;
+    joiningFetchMsg.joiningRequestId =
         std::get<JoiningFetch>(req.args).joiningRequestID.value;
-    baseMsg->precedingGroupOffset =
+    joiningFetchMsg.joiningStart =
         std::get<JoiningFetch>(req.args).joiningStart;
+    baseMsg->joiningFetch = std::move(joiningFetchMsg);
   } else if (standalone) {
-    baseMsg->fetchType = static_cast<uint64_t>(FetchType::STANDALONE);
-    baseMsg->startGroup = std::get<StandaloneFetch>(req.args).start.group;
-    baseMsg->startObject = std::get<StandaloneFetch>(req.args).start.object;
-    baseMsg->endGroup = std::get<StandaloneFetch>(req.args).end.group;
-    baseMsg->endObject = std::get<StandaloneFetch>(req.args).end.object;
-  }
-
-  baseMsg->trackNamespace = convertTrackNamespaceToByteStringFormat(
-      req.fullTrackName.trackNamespace.trackNamespace, type);
-  if (req.fullTrackName.trackName != "") {
-    baseMsg->trackName =
+    baseMsg->fetchType = "standalone";
+    MOQTStandaloneFetch standaloneFetchMsg;
+    standaloneFetchMsg.trackNamespace = convertTrackNamespaceToByteStringFormat(
+        req.fullTrackName.trackNamespace.trackNamespace, type);
+    standaloneFetchMsg.trackName =
         convertTrackNameToByteStringFormat(req.fullTrackName.trackName);
+    standaloneFetchMsg.startLocation.group =
+        std::get<StandaloneFetch>(req.args).start.group;
+    standaloneFetchMsg.startLocation.object =
+        std::get<StandaloneFetch>(req.args).start.object;
+    standaloneFetchMsg.endLocation.group =
+        std::get<StandaloneFetch>(req.args).end.group;
+    standaloneFetchMsg.endLocation.object =
+        std::get<StandaloneFetch>(req.args).end.object;
+    baseMsg->standaloneFetch = std::move(standaloneFetchMsg);
   }
 
-  baseMsg->numberOfParameters = req.params.size();
   baseMsg->parameters = convertTrackParamsToMoQTParams(req.params);
 
   logControlMessage(
@@ -318,7 +326,7 @@ void MLogger::logFetchCancel(
     const FetchCancel& req,
     ControlMessageType controlType) {
   auto baseMsg = std::make_unique<MOQTFetchCancel>();
-  baseMsg->subscribeId = req.requestID.value;
+  baseMsg->requestId = req.requestID.value;
 
   logControlMessage(
       controlType, kFirstBidiStreamId, folly::none, std::move(baseMsg));
@@ -473,13 +481,13 @@ void MLogger::logSubscribeError(
 
 void MLogger::logFetchOk(const FetchOk& req, ControlMessageType controlType) {
   auto baseMsg = std::make_unique<MOQTFetchOk>();
-  baseMsg->subscribeId = req.requestID.value;
+  baseMsg->requestId = req.requestID.value;
   baseMsg->groupOrder = static_cast<uint8_t>(req.groupOrder);
   baseMsg->endOfTrack = req.endOfTrack;
-  baseMsg->largestGroupId = req.endLocation.group;
-  baseMsg->largestObjectId = req.endLocation.object;
+  baseMsg->endLocation.group = req.endLocation.group;
+  baseMsg->endLocation.object = req.endLocation.object;
   baseMsg->numberOfParameters = req.params.size();
-  baseMsg->subscribeParameters = convertTrackParamsToMoQTParams(req.params);
+  baseMsg->parameters = convertTrackParamsToMoQTParams(req.params);
 
   logControlMessage(
       controlType, kFirstBidiStreamId, folly::none, std::move(baseMsg));
@@ -489,7 +497,7 @@ void MLogger::logFetchError(
     const FetchError& req,
     ControlMessageType controlType) {
   auto baseMsg = std::make_unique<MOQTFetchError>();
-  baseMsg->subscribeId = req.requestID.value;
+  baseMsg->requestId = req.requestID.value;
   baseMsg->errorCode = static_cast<uint64_t>(req.errorCode);
 
   if (isHexstring(req.reasonPhrase)) {