SERVER-28814 Stop returning Status from metadata functions

Every caller was already using uassertStatusOK. Moving that into the
functions simplifies both the implementation and the callers. Also eliminated
functions without any callers.

5 files changed, 45 insertions, 128 deletions

diff --git a/src/mongo/rpc/legacy_reply.cpp b/src/mongo/rpc/legacy_reply.cpp
index a300a8dafc7..7728a444532 100644
--- a/src/mongo/rpc/legacy_reply.cpp
+++ b/src/mongo/rpc/legacy_reply.cpp
@@ -75,8 +75,7 @@ LegacyReply::LegacyReply(const Message* message) : _message(std::move(message))
                           << causedBy(status),
             status.isOK());
 
-    std::tie(_commandReply, _metadata) =
-        uassertStatusOK(rpc::upconvertReplyMetadata(BSONObj(qr.data())));
+    std::tie(_commandReply, _metadata) = rpc::upconvertReplyMetadata(BSONObj(qr.data()));
 
     return;
 }
diff --git a/src/mongo/rpc/legacy_request.cpp b/src/mongo/rpc/legacy_request.cpp
index 9a6ff145166..dd003c91fa7 100644
--- a/src/mongo/rpc/legacy_request.cpp
+++ b/src/mongo/rpc/legacy_request.cpp
@@ -41,9 +41,8 @@ LegacyRequest::LegacyRequest(const Message* message)
     : _message(std::move(message)), _dbMessage(*message), _queryMessage(_dbMessage) {
     _database = nsToDatabaseSubstring(_queryMessage.ns);
 
-    std::tie(_upconvertedCommandArgs, _upconvertedMetadata) =
-        uassertStatusOK(rpc::upconvertRequestMetadata(std::move(_queryMessage.query),
-                                                      std::move(_queryMessage.queryOptions)));
+    std::tie(_upconvertedCommandArgs, _upconvertedMetadata) = rpc::upconvertRequestMetadata(
+        std::move(_queryMessage.query), std::move(_queryMessage.queryOptions));
 }
 
 LegacyRequest::~LegacyRequest() = default;
diff --git a/src/mongo/rpc/legacy_request_builder.cpp b/src/mongo/rpc/legacy_request_builder.cpp
index 49034f94eb6..87fc766a608 100644
--- a/src/mongo/rpc/legacy_request_builder.cpp
+++ b/src/mongo/rpc/legacy_request_builder.cpp
@@ -76,8 +76,8 @@ LegacyRequestBuilder& LegacyRequestBuilder::setMetadata(BSONObj metadata) {
     BSONObj legacyCommandArgs;
     int queryOptions;
 
-    std::tie(legacyCommandArgs, queryOptions) = uassertStatusOK(
-        rpc::downconvertRequestMetadata(std::move(_commandArgs), std::move(metadata)));
+    std::tie(legacyCommandArgs, queryOptions) =
+        rpc::downconvertRequestMetadata(std::move(_commandArgs), std::move(metadata));
 
     _builder.appendNum(queryOptions);  // queryOptions
     _builder.appendStr(_ns);
diff --git a/src/mongo/rpc/metadata.cpp b/src/mongo/rpc/metadata.cpp
index 07cdfef9fca..5dc5f65d169 100644
--- a/src/mongo/rpc/metadata.cpp
+++ b/src/mongo/rpc/metadata.cpp
@@ -75,7 +75,7 @@ BSONObj makeEmptyMetadata() {
     return BSONObj();
 }
 
-Status readRequestMetadata(OperationContext* opCtx, const BSONObj& metadataObj) {
+void readRequestMetadata(OperationContext* opCtx, const BSONObj& metadataObj) {
     BSONElement ssmElem;
     BSONElement auditElem;
     BSONElement configSvrElem;
@@ -100,82 +100,47 @@ Status readRequestMetadata(OperationContext* opCtx, const BSONObj& metadataObj)
         }
     }
 
-    auto swServerSelectionMetadata = ServerSelectionMetadata::readFromMetadata(ssmElem);
-    if (!swServerSelectionMetadata.isOK()) {
-        return swServerSelectionMetadata.getStatus();
-    }
-    ServerSelectionMetadata::get(opCtx) = std::move(swServerSelectionMetadata.getValue());
+    ServerSelectionMetadata::get(opCtx) =
+        uassertStatusOK(ServerSelectionMetadata::readFromMetadata(ssmElem));
 
-    auto swAuditMetadata = AuditMetadata::readFromMetadata(auditElem);
-    if (!swAuditMetadata.isOK()) {
-        return swAuditMetadata.getStatus();
-    }
-    AuditMetadata::get(opCtx) = std::move(swAuditMetadata.getValue());
+    AuditMetadata::get(opCtx) = uassertStatusOK(AuditMetadata::readFromMetadata(auditElem));
 
-    const auto statusClientMetadata =
-        ClientMetadataIsMasterState::readFromMetadata(opCtx, clientElem);
-    if (!statusClientMetadata.isOK()) {
-        return statusClientMetadata;
-    }
+    uassertStatusOK(ClientMetadataIsMasterState::readFromMetadata(opCtx, clientElem));
 
-    auto configServerMetadata = ConfigServerMetadata::readFromMetadata(configSvrElem);
-    if (!configServerMetadata.isOK()) {
-        return configServerMetadata.getStatus();
-    }
-    ConfigServerMetadata::get(opCtx) = std::move(configServerMetadata.getValue());
+    ConfigServerMetadata::get(opCtx) =
+        uassertStatusOK(ConfigServerMetadata::readFromMetadata(configSvrElem));
 
-    auto trackingMetadata = TrackingMetadata::readFromMetadata(trackingElem);
-    if (!trackingMetadata.isOK()) {
-        return trackingMetadata.getStatus();
-    }
-    TrackingMetadata::get(opCtx) = std::move(trackingMetadata.getValue());
+    TrackingMetadata::get(opCtx) =
+        uassertStatusOK(TrackingMetadata::readFromMetadata(trackingElem));
 
     auto logicalClock = LogicalClock::get(opCtx);
     if (logicalClock) {
-        auto logicalTimeMetadata = rpc::LogicalTimeMetadata::readFromMetadata(logicalTimeElem);
-        if (!logicalTimeMetadata.isOK()) {
-            return logicalTimeMetadata.getStatus();
-        }
+        auto logicalTimeMetadata =
+            uassertStatusOK(rpc::LogicalTimeMetadata::readFromMetadata(logicalTimeElem));
 
-        auto& signedTime = logicalTimeMetadata.getValue().getSignedTime();
+        auto& signedTime = logicalTimeMetadata.getSignedTime();
         // LogicalTimeMetadata is default constructed if no logical time metadata was sent, so a
         // default constructed SignedLogicalTime should be ignored.
-        if (signedTime.getTime() == LogicalTime::kUninitialized) {
-            return Status::OK();
-        }
-
-        auto logicalTimeValidator = LogicalTimeValidator::get(opCtx);
-        if (isAuthorizedToAdvanceClock(opCtx)) {
-            if (logicalTimeValidator) {
-                logicalTimeValidator->updateCacheTrustedSource(signedTime);
-            }
-        } else if (!logicalTimeValidator) {
-            return Status(ErrorCodes::CannotVerifyAndSignLogicalTime,
+        if (signedTime.getTime() != LogicalTime::kUninitialized) {
+            auto logicalTimeValidator = LogicalTimeValidator::get(opCtx);
+            if (isAuthorizedToAdvanceClock(opCtx)) {
+                if (logicalTimeValidator) {
+                    logicalTimeValidator->updateCacheTrustedSource(signedTime);
+                }
+            } else if (!logicalTimeValidator) {
+                uasserted(ErrorCodes::CannotVerifyAndSignLogicalTime,
                           "Cannot accept logicalTime: " + signedTime.getTime().toString() +
                               ". May not be a part of a sharded cluster");
-        } else {
-            auto advanceClockStatus = logicalTimeValidator->validate(signedTime);
-
-            if (!advanceClockStatus.isOK()) {
-                return advanceClockStatus;
+            } else {
+                uassertStatusOK(logicalTimeValidator->validate(signedTime));
             }
-        }
-
-        logicalClock->advanceClusterTime(signedTime.getTime());
-    }
 
-    return Status::OK();
-}
-
-Status writeRequestMetadata(OperationContext* opCtx, BSONObjBuilder* metadataBob) {
-    auto ssStatus = ServerSelectionMetadata::get(opCtx).writeToMetadata(metadataBob);
-    if (!ssStatus.isOK()) {
-        return ssStatus;
+            uassertStatusOK(logicalClock->advanceClusterTime(signedTime.getTime()));
+        }
     }
-    return Status::OK();
 }
 
-StatusWith<CommandAndMetadata> upconvertRequestMetadata(BSONObj legacyCmdObj, int queryFlags) {
+CommandAndMetadata upconvertRequestMetadata(BSONObj legacyCmdObj, int queryFlags) {
     // We can reuse the same metadata BOB for every upconvert call, but we need to keep
     // making new command BOBs as each metadata bob will need to remove fields. We can not use
     // mutablebson here because the ServerSelectionMetadata upconvert routine performs
@@ -186,73 +151,39 @@ StatusWith<CommandAndMetadata> upconvertRequestMetadata(BSONObj legacyCmdObj, in
     // Ordering is important here - ServerSelectionMetadata must be upconverted
     // first, then AuditMetadata.
     BSONObjBuilder ssmCommandBob;
-    auto upconvertStatus =
-        ServerSelectionMetadata::upconvert(legacyCmdObj, queryFlags, &ssmCommandBob, &metadataBob);
-    if (!upconvertStatus.isOK()) {
-        return upconvertStatus;
-    }
-
+    uassertStatusOK(
+        ServerSelectionMetadata::upconvert(legacyCmdObj, queryFlags, &ssmCommandBob, &metadataBob));
 
     BSONObjBuilder auditCommandBob;
-    upconvertStatus =
-        AuditMetadata::upconvert(ssmCommandBob.done(), queryFlags, &auditCommandBob, &metadataBob);
-
-    if (!upconvertStatus.isOK()) {
-        return upconvertStatus;
-    }
-
+    uassertStatusOK(
+        AuditMetadata::upconvert(ssmCommandBob.done(), queryFlags, &auditCommandBob, &metadataBob));
 
     return std::make_tuple(auditCommandBob.obj(), metadataBob.obj());
 }
 
-StatusWith<LegacyCommandAndFlags> downconvertRequestMetadata(BSONObj cmdObj, BSONObj metadata) {
+LegacyCommandAndFlags downconvertRequestMetadata(BSONObj cmdObj, BSONObj metadata) {
     int legacyQueryFlags = 0;
     BSONObjBuilder auditCommandBob;
     // Ordering is important here - AuditingMetadata must be downconverted first,
     // then ServerSelectionMetadata.
-    auto downconvertStatus =
-        AuditMetadata::downconvert(cmdObj, metadata, &auditCommandBob, &legacyQueryFlags);
-
-    if (!downconvertStatus.isOK()) {
-        return downconvertStatus;
-    }
+    uassertStatusOK(
+        AuditMetadata::downconvert(cmdObj, metadata, &auditCommandBob, &legacyQueryFlags));
 
 
     BSONObjBuilder ssmCommandBob;
-    downconvertStatus = ServerSelectionMetadata::downconvert(
-        auditCommandBob.done(), metadata, &ssmCommandBob, &legacyQueryFlags);
-    if (!downconvertStatus.isOK()) {
-        return downconvertStatus;
-    }
-
+    uassertStatusOK(ServerSelectionMetadata::downconvert(
+        auditCommandBob.done(), metadata, &ssmCommandBob, &legacyQueryFlags));
 
     return std::make_tuple(ssmCommandBob.obj(), std::move(legacyQueryFlags));
 }
 
-StatusWith<CommandReplyWithMetadata> upconvertReplyMetadata(const BSONObj& legacyReply) {
+CommandReplyWithMetadata upconvertReplyMetadata(const BSONObj& legacyReply) {
     BSONObjBuilder commandReplyBob;
     BSONObjBuilder metadataBob;
 
-    auto upconvertStatus = ShardingMetadata::upconvert(legacyReply, &commandReplyBob, &metadataBob);
-    if (!upconvertStatus.isOK()) {
-        return upconvertStatus;
-    }
-
+    uassertStatusOK(ShardingMetadata::upconvert(legacyReply, &commandReplyBob, &metadataBob));
     return std::make_tuple(commandReplyBob.obj(), metadataBob.obj());
 }
 
-StatusWith<BSONObj> downconvertReplyMetadata(const BSONObj& commandReply,
-                                             const BSONObj& replyMetadata) {
-    BSONObjBuilder legacyCommandReplyBob;
-
-    auto downconvertStatus =
-        ShardingMetadata::downconvert(commandReply, replyMetadata, &legacyCommandReplyBob);
-    if (!downconvertStatus.isOK()) {
-        return downconvertStatus;
-    }
-
-    return legacyCommandReplyBob.obj();
-}
-
 }  // namespace rpc
 }  // namespace mongo
diff --git a/src/mongo/rpc/metadata.h b/src/mongo/rpc/metadata.h
index 42c10bb3d24..8d3482be458 100644
--- a/src/mongo/rpc/metadata.h
+++ b/src/mongo/rpc/metadata.h
@@ -53,12 +53,7 @@ BSONObj makeEmptyMetadata();
 /**
  * Reads metadata from a metadata object and sets it on this OperationContext.
  */
-Status readRequestMetadata(OperationContext* opCtx, const BSONObj& metadataObj);
-
-/**
- * Writes metadata from an OperationContext to a metadata object.
- */
-Status writeRequestMetadata(OperationContext* opCtx, BSONObjBuilder* metadataBob);
+void readRequestMetadata(OperationContext* opCtx, const BSONObj& metadataObj);
 
 /**
  * A command object and a corresponding metadata object.
@@ -75,13 +70,13 @@ using LegacyCommandAndFlags = std::tuple<BSONObj, int>;
  * Given a legacy command object and a query flags bitfield, attempts to parse and remove
  * the metadata from the command object and construct a corresponding metadata object.
  */
-StatusWith<CommandAndMetadata> upconvertRequestMetadata(BSONObj legacyCmdObj, int queryFlags);
+CommandAndMetadata upconvertRequestMetadata(BSONObj legacyCmdObj, int queryFlags);
 
 /**
  * Given a command object and a metadata object, attempts to construct a legacy command
  * object and query flags bitfield augmented with the given metadata.
  */
-StatusWith<LegacyCommandAndFlags> downconvertRequestMetadata(BSONObj cmdObj, BSONObj metadata);
+LegacyCommandAndFlags downconvertRequestMetadata(BSONObj cmdObj, BSONObj metadata);
 
 /**
  * A command reply and associated metadata object.
@@ -92,14 +87,7 @@ using CommandReplyWithMetadata = std::tuple<BSONObj, BSONObj>;
  * Given a legacy command reply, attempts to strip the metadata from the reply and construct
  * a metadata object.
  */
-StatusWith<CommandReplyWithMetadata> upconvertReplyMetadata(const BSONObj& legacyReply);
-
-/**
- * Given a command reply object and an associated metadata object,
- * attempts to construct a legacy command object.
- */
-StatusWith<BSONObj> downconvertReplyMetadata(const BSONObj& commandReply,
-                                             const BSONObj& replyMetadata);
+CommandReplyWithMetadata upconvertReplyMetadata(const BSONObj& legacyReply);
 
 /**
  * A function type for writing request metadata. The function takes a pointer to an optional