Update upstream source from tag 'upstream/6.0.0'master

Update to upstream version '6.0.0'
with Debian dir 5604a80ec1c96ca76f25f40d78e6ef855abec322

1 files changed, 44 insertions, 56 deletions

diff --git a/src/mongo/db/repl/initial_syncer.cpp b/src/mongo/db/repl/initial_syncer.cpp
index d8a2f5104d7..02fb4af0be5 100644
--- a/src/mongo/db/repl/initial_syncer.cpp
+++ b/src/mongo/db/repl/initial_syncer.cpp
@@ -548,7 +548,6 @@ void InitialSyncer::_setUp_inlock(OperationContext* opCtx, std::uint32_t initial
     _stats.initialSyncStart = _exec->now();
     _stats.maxFailedInitialSyncAttempts = initialSyncMaxAttempts;
     _stats.failedInitialSyncAttempts = 0;
-    _stats.exec = std::weak_ptr<executor::TaskExecutor>(_exec);
 
     _allowedOutageDuration = Seconds(initialSyncTransientErrorRetryPeriodSeconds.load());
 }
@@ -1394,63 +1393,53 @@ void InitialSyncer::_lastOplogEntryFetcherCallbackForStopTimestamp(
     std::shared_ptr<OnCompletionGuard> onCompletionGuard) {
     OpTimeAndWallTime resultOpTimeAndWallTime = {OpTime(), Date_t()};
     {
-        {
-            stdx::lock_guard<Latch> lock(_mutex);
-            auto status = _checkForShutdownAndConvertStatus_inlock(
-                result.getStatus(), "error fetching last oplog entry for stop timestamp");
-            if (_shouldRetryError(lock, status)) {
-                auto scheduleStatus =
-                    (*_attemptExec)
-                        ->scheduleWork(
-                            [this, onCompletionGuard](executor::TaskExecutor::CallbackArgs args) {
-                                // It is not valid to schedule the retry from within this callback,
-                                // hence we schedule a lambda to schedule the retry.
-                                stdx::lock_guard<Latch> lock(_mutex);
-                                // Since the stopTimestamp is retrieved after we have done all the
-                                // work of retrieving collection data, we handle retries within this
-                                // class by retrying for
-                                // 'initialSyncTransientErrorRetryPeriodSeconds' (default 24 hours).
-                                // This is the same retry strategy used when retrieving collection
-                                // data, and avoids retrieving all the data and then throwing it
-                                // away due to a transient network outage.
-                                auto status = _scheduleLastOplogEntryFetcher_inlock(
-                                    [=](const StatusWith<mongo::Fetcher::QueryResponse>& status,
-                                        mongo::Fetcher::NextAction*,
-                                        mongo::BSONObjBuilder*) {
-                                        _lastOplogEntryFetcherCallbackForStopTimestamp(
-                                            status, onCompletionGuard);
-                                    },
-                                    kInitialSyncerHandlesRetries);
-                                if (!status.isOK()) {
-                                    onCompletionGuard->setResultAndCancelRemainingWork_inlock(
-                                        lock, status);
-                                }
-                            });
-                if (scheduleStatus.isOK())
-                    return;
-                // If scheduling failed, we're shutting down and cannot retry.
-                // So just continue with the original failed status.
-            }
-            if (!status.isOK()) {
-                onCompletionGuard->setResultAndCancelRemainingWork_inlock(lock, status);
-                return;
-            }
-
-            auto&& optimeStatus = parseOpTimeAndWallTime(result);
-            if (!optimeStatus.isOK()) {
-                onCompletionGuard->setResultAndCancelRemainingWork_inlock(lock,
-                                                                          optimeStatus.getStatus());
+        stdx::lock_guard<Latch> lock(_mutex);
+        auto status = _checkForShutdownAndConvertStatus_inlock(
+            result.getStatus(), "error fetching last oplog entry for stop timestamp");
+        if (_shouldRetryError(lock, status)) {
+            auto scheduleStatus =
+                (*_attemptExec)
+                    ->scheduleWork([this,
+                                    onCompletionGuard](executor::TaskExecutor::CallbackArgs args) {
+                        // It is not valid to schedule the retry from within this callback,
+                        // hence we schedule a lambda to schedule the retry.
+                        stdx::lock_guard<Latch> lock(_mutex);
+                        // Since the stopTimestamp is retrieved after we have done all the work of
+                        // retrieving collection data, we handle retries within this class by
+                        // retrying for 'initialSyncTransientErrorRetryPeriodSeconds' (default 24
+                        // hours).  This is the same retry strategy used when retrieving collection
+                        // data, and avoids retrieving all the data and then throwing it away due to
+                        // a transient network outage.
+                        auto status = _scheduleLastOplogEntryFetcher_inlock(
+                            [=](const StatusWith<mongo::Fetcher::QueryResponse>& status,
+                                mongo::Fetcher::NextAction*,
+                                mongo::BSONObjBuilder*) {
+                                _lastOplogEntryFetcherCallbackForStopTimestamp(status,
+                                                                               onCompletionGuard);
+                            },
+                            kInitialSyncerHandlesRetries);
+                        if (!status.isOK()) {
+                            onCompletionGuard->setResultAndCancelRemainingWork_inlock(lock, status);
+                        }
+                    });
+            if (scheduleStatus.isOK())
                 return;
-            }
-            resultOpTimeAndWallTime = optimeStatus.getValue();
+            // If scheduling failed, we're shutting down and cannot retry.
+            // So just continue with the original failed status.
+        }
+        if (!status.isOK()) {
+            onCompletionGuard->setResultAndCancelRemainingWork_inlock(lock, status);
+            return;
         }
 
-        // Release the _mutex to write to disk.
-        auto opCtx = makeOpCtx();
-        _replicationProcess->getConsistencyMarkers()->setMinValid(
-            opCtx.get(), resultOpTimeAndWallTime.opTime, true);
+        auto&& optimeStatus = parseOpTimeAndWallTime(result);
+        if (!optimeStatus.isOK()) {
+            onCompletionGuard->setResultAndCancelRemainingWork_inlock(lock,
+                                                                      optimeStatus.getStatus());
+            return;
+        }
+        resultOpTimeAndWallTime = optimeStatus.getValue();
 
-        stdx::lock_guard<Latch> lock(_mutex);
         _initialSyncState->stopTimestamp = resultOpTimeAndWallTime.opTime.getTimestamp();
 
         // If the beginFetchingTimestamp is different from the stopTimestamp, it indicates that
@@ -2197,10 +2186,9 @@ void InitialSyncer::Stats::append(BSONObjBuilder* builder) const {
     builder->appendNumber("maxFailedInitialSyncAttempts",
                           static_cast<long long>(maxFailedInitialSyncAttempts));
 
-    auto e = exec.lock();
     if (initialSyncStart != Date_t()) {
         builder->appendDate("initialSyncStart", initialSyncStart);
-        auto elapsedDurationEnd = e ? e->now() : Date_t::now();
+        auto elapsedDurationEnd = Date_t::now();
         if (initialSyncEnd != Date_t()) {
             builder->appendDate("initialSyncEnd", initialSyncEnd);
             elapsedDurationEnd = initialSyncEnd;