T throwMongoTimeoutException() {
- throw new MongoOperationTimeoutException("The operation exceeded the timeout limit.");
+ throw new MongoOperationTimeoutException(DEFAULT_TIMEOUT_MESSAGE);
}
public static MongoOperationTimeoutException createMongoTimeoutException(final Throwable cause) {
- return createMongoTimeoutException("Operation exceeded the timeout limit: " + cause.getMessage(), cause);
+ return createMongoTimeoutException(DEFAULT_TIMEOUT_MESSAGE, cause);
}
public static MongoOperationTimeoutException createMongoTimeoutException(final String message, @Nullable final Throwable cause) {
@@ -113,10 +114,6 @@ public TimeoutContext(final TimeoutSettings timeoutSettings) {
this(false, timeoutSettings, startTimeout(timeoutSettings.getTimeoutMS()));
}
- private TimeoutContext(final TimeoutSettings timeoutSettings, @Nullable final Timeout timeout) {
- this(false, timeoutSettings, timeout);
- }
-
private TimeoutContext(final boolean isMaintenanceContext,
final TimeoutSettings timeoutSettings,
@Nullable final Timeout timeout) {
@@ -181,6 +178,7 @@ public Timeout timeoutIncludingRoundTrip() {
* @param alternativeTimeoutMS the alternative timeout.
* @return timeout to use.
*/
+ @VisibleForTesting(otherwise = PRIVATE)
public long timeoutOrAlternative(final long alternativeTimeoutMS) {
if (timeout == null) {
return alternativeTimeoutMS;
@@ -188,7 +186,7 @@ public long timeoutOrAlternative(final long alternativeTimeoutMS) {
return timeout.call(MILLISECONDS,
() -> 0L,
(ms) -> ms,
- () -> throwMongoTimeoutException("The operation exceeded the timeout limit."));
+ () -> throwMongoTimeoutException());
}
}
@@ -232,7 +230,7 @@ public int getConnectTimeoutMs() {
return Math.toIntExact(Timeout.nullAsInfinite(timeout).call(MILLISECONDS,
() -> connectTimeoutMS,
(ms) -> connectTimeoutMS == 0 ? ms : Math.min(ms, connectTimeoutMS),
- () -> throwMongoTimeoutException("The operation exceeded the timeout limit.")));
+ () -> throwMongoTimeoutException()));
}
/**
@@ -253,13 +251,11 @@ public TimeoutContext withMaxTimeAsMaxAwaitTimeOverride() {
* The override will be provided as the remaining value in
* {@link #runMaxTimeMS}, where 0 is ignored. This is useful for setting timeout
* in {@link CommandMessage} as an extra element before we send it to the server.
- *
*
- * NOTE: Suitable for static user-defined values only (i.e MaxAwaitTimeMS),
+ * Suitable for static user-defined values only (i.e. {@code MaxAwaitTimeMS}),
* not for running timeouts that adjust dynamically (CSOT).
- *
+ *
* If remaining CSOT timeout is less than this static timeout, then CSOT timeout will be used.
- *
*/
public TimeoutContext withMaxTimeOverride(final long maxTimeMS) {
return new TimeoutContext(
@@ -389,11 +385,6 @@ public TimeoutContext withAdditionalReadTimeout(final int additionalReadTimeout)
return new TimeoutContext(timeoutSettings.withReadTimeoutMS(newReadTimeout > 0 ? newReadTimeout : Long.MAX_VALUE));
}
- // Creates a copy of the timeout context that can be reset without resetting the original.
- public TimeoutContext copyTimeoutContext() {
- return new TimeoutContext(getTimeoutSettings(), getTimeout());
- }
-
@Override
public String toString() {
return "TimeoutContext{"
@@ -488,10 +479,10 @@ private void runMinTimeout(final LongConsumer onRemaining, final long fixedMs) {
timeout.run(MILLISECONDS, () -> {
onRemaining.accept(fixedMs);
},
- (renamingMs) -> {
- onRemaining.accept(Math.min(renamingMs, fixedMs));
+ (remainingMs) -> {
+ onRemaining.accept(Math.min(remainingMs, fixedMs));
}, () -> {
- throwMongoTimeoutException("The operation exceeded the timeout limit.");
+ throwMongoTimeoutException();
});
} else {
onRemaining.accept(fixedMs);
diff --git a/driver-core/src/main/com/mongodb/internal/async/AsyncRunnable.java b/driver-core/src/main/com/mongodb/internal/async/AsyncRunnable.java
index deeef6239c4..37b55afe6af 100644
--- a/driver-core/src/main/com/mongodb/internal/async/AsyncRunnable.java
+++ b/driver-core/src/main/com/mongodb/internal/async/AsyncRunnable.java
@@ -17,9 +17,10 @@
package com.mongodb.internal.async;
import com.mongodb.internal.async.function.AsyncCallbackLoop;
-import com.mongodb.internal.async.function.LoopState;
-import com.mongodb.internal.async.function.RetryState;
+import com.mongodb.internal.async.function.LoopControl;
+import com.mongodb.internal.async.function.RetryControl;
import com.mongodb.internal.async.function.RetryingAsyncCallbackSupplier;
+import com.mongodb.internal.thread.AsyncClientExecutor;
import java.util.function.BooleanSupplier;
import java.util.function.Predicate;
@@ -111,9 +112,11 @@
*
Is every c.complete followed by a return, to end execution?
* Have all sync method calls been converted to async, where needed?
*
- *
- * This class is not part of the public API and may be removed or changed
- * at any time
+ *
+ * If, when writing a lambda expression, you need to have an effectively {@code final} variable
+ * whose value may be mutated, use {@link MutableValue}.
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
*/
@FunctionalInterface
public interface AsyncRunnable extends AsyncSupplier, AsyncConsumer {
@@ -231,9 +234,9 @@ default AsyncSupplier thenSupply(final AsyncSupplier supplier) {
default AsyncRunnable thenRunRetryingWhile(final AsyncRunnable runnable, final Predicate shouldRetry) {
return thenRun(callback -> {
new RetryingAsyncCallbackSupplier(
- new RetryState(),
- (previouslyChosenFailure, lastAttemptFailure) -> lastAttemptFailure,
- (rs, lastAttemptFailure) -> shouldRetry.test(lastAttemptFailure),
+ // `AsyncClientExecutor` is not needed, given the contract of `SimpleRetryPolicy`, `RetryingAsyncCallbackSupplier`
+ AsyncClientExecutor.NO_OP,
+ new RetryControl<>(new SimpleRetryPolicy(shouldRetry)),
// `finish` is required here instead of `unsafeFinish`
// because only `finish` meets the contract of
// `AsyncCallbackSupplier.get`, which we implement here
@@ -253,10 +256,10 @@ default AsyncRunnable thenRunRetryingWhile(final AsyncRunnable runnable, final P
*/
default AsyncRunnable thenRunWhileLoop(final BooleanSupplier whileCheck, final AsyncRunnable loopBodyRunnable) {
return thenRun(finalCallback -> {
- LoopState loopState = new LoopState();
- new AsyncCallbackLoop(loopState, iterationCallback -> {
+ LoopControl loopControl = new LoopControl();
+ new AsyncCallbackLoop(loopControl, iterationCallback -> {
- if (loopState.breakAndCompleteIf(() -> !whileCheck.getAsBoolean(), iterationCallback)) {
+ if (loopControl.breakAndCompleteIf(() -> !whileCheck.getAsBoolean(), iterationCallback)) {
return;
}
loopBodyRunnable.finish((result, t) -> {
@@ -282,15 +285,15 @@ default AsyncRunnable thenRunWhileLoop(final BooleanSupplier whileCheck, final A
*/
default AsyncRunnable thenRunDoWhileLoop(final AsyncRunnable loopBodyRunnable, final BooleanSupplier whileCheck) {
return thenRun(finalCallback -> {
- LoopState loopState = new LoopState();
- new AsyncCallbackLoop(loopState, iterationCallback -> {
+ LoopControl loopControl = new LoopControl();
+ new AsyncCallbackLoop(loopControl, iterationCallback -> {
loopBodyRunnable.finish((result, t) -> {
if (t != null) {
iterationCallback.completeExceptionally(t);
return;
}
- if (loopState.breakAndCompleteIf(() -> !whileCheck.getAsBoolean(), iterationCallback)) {
+ if (loopControl.breakAndCompleteIf(() -> !whileCheck.getAsBoolean(), iterationCallback)) {
return;
}
iterationCallback.complete(iterationCallback);
diff --git a/driver-core/src/main/com/mongodb/internal/async/SimpleRetryPolicy.java b/driver-core/src/main/com/mongodb/internal/async/SimpleRetryPolicy.java
new file mode 100644
index 00000000000..3854c77a891
--- /dev/null
+++ b/driver-core/src/main/com/mongodb/internal/async/SimpleRetryPolicy.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.internal.async;
+
+import com.mongodb.internal.async.function.RetryContext;
+import com.mongodb.internal.async.function.RetryPolicy;
+import com.mongodb.internal.async.function.RetryPolicy.Decision.RetryAttemptInfo;
+
+import java.time.Duration;
+import java.util.function.Predicate;
+
+/**
+ * {@link RetryAttemptInfo#getBackoff()} is always {@link Duration#isZero() zero}.
+ */
+final class SimpleRetryPolicy implements RetryPolicy {
+ private final Predicate shouldRetry;
+
+ SimpleRetryPolicy(final Predicate shouldRetry) {
+ this.shouldRetry = shouldRetry;
+ }
+
+ @Override
+ public Decision onAttemptFailure(final RetryContext retryContext, final Throwable attemptFailedResult) {
+ return new Decision(attemptFailedResult, shouldRetry.test(attemptFailedResult) ? new RetryAttemptInfo(Duration.ZERO) : null);
+ }
+}
diff --git a/driver-core/src/main/com/mongodb/internal/async/SingleResultCallback.java b/driver-core/src/main/com/mongodb/internal/async/SingleResultCallback.java
index 11da1c97f75..cefab04f312 100644
--- a/driver-core/src/main/com/mongodb/internal/async/SingleResultCallback.java
+++ b/driver-core/src/main/com/mongodb/internal/async/SingleResultCallback.java
@@ -37,7 +37,7 @@ public interface SingleResultCallback {
* @param result the result, which may be null. Always null if e is not null.
* @param t the throwable, or null if the operation completed normally
* @throws RuntimeException Never.
- * @throws Error Never, on the best effort basis.
+ * @throws Error Never, on the best-effort basis.
*/
void onResult(@Nullable T result, @Nullable Throwable t);
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackFunction.java b/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackFunction.java
index cf2fedbc1ef..3efe1fa97bf 100644
--- a/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackFunction.java
+++ b/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackFunction.java
@@ -35,8 +35,8 @@
* "normal" and "abrupt completion"
* are used as they defined by the Java Language Specification, while the terms "successful" and "failed completion" are used to refer to a
* situation when the function produces either a successful or a failed result respectively.
- *
- * This class is not part of the public API and may be removed or changed at any time
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
*
* @param
The type of the first parameter to the function.
* @param The type of successful result. A failed result is of the {@link Throwable} type
@@ -51,7 +51,7 @@ public interface AsyncCallbackFunction {
* @param callback A consumer of a result, {@link SingleResultCallback#onResult(Object, Throwable) completed} after
* (in the happens-before order) the asynchronous function completes.
* @throws RuntimeException Never. Exceptions must be relayed to the {@code callback}.
- * @throws Error Never, on the best effort basis. Errors should be relayed to the {@code callback}.
+ * @throws Error Never, on the best-effort basis. Errors should be relayed to the {@code callback}.
*/
void apply(P a, SingleResultCallback callback);
}
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackLoop.java b/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackLoop.java
index a1021d15483..46936a10ecb 100644
--- a/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackLoop.java
+++ b/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackLoop.java
@@ -29,26 +29,26 @@
* This class emulates the {@code while(true)}
* statement.
*
- * The original function may additionally observe or control looping via {@link LoopState}.
- * Looping continues until either of the following happens:
+ * The original function may additionally observe or control the loop via {@link LoopControl}.
+ * The loop continues until either of the following happens:
*
* - the original function fails as specified by {@link AsyncCallbackFunction};
- * - the original function calls {@link LoopState#breakAndCompleteIf(Supplier, SingleResultCallback)}.
+ * - the original function calls {@link LoopControl#breakAndCompleteIf(Supplier, SingleResultCallback)}.
*
- *
- * This class is not part of the public API and may be removed or changed at any time
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
*/
@NotThreadSafe
public final class AsyncCallbackLoop implements AsyncCallbackRunnable {
- private final LoopState state;
+ private final LoopControl control;
private final AsyncCallbackRunnable body;
/**
- * @param state The {@link LoopState} to be deemed as initial for the purpose of the new {@link AsyncCallbackLoop}.
+ * @param control The {@link LoopControl} to control the new {@link AsyncCallbackLoop}.
* @param body The body of the loop.
*/
- public AsyncCallbackLoop(final LoopState state, final AsyncCallbackRunnable body) {
- this.state = state;
+ public AsyncCallbackLoop(final LoopControl control, final AsyncCallbackRunnable body) {
+ this.control = control;
this.body = body;
}
@@ -77,7 +77,7 @@ public void onResult(@Nullable final Void result, @Nullable final Throwable t) {
} else {
boolean continueLooping;
try {
- continueLooping = state.advance();
+ continueLooping = control.advance();
} catch (Throwable e) {
wrapped.onResult(null, e);
return;
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackRunnable.java b/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackRunnable.java
index 02fdbdf9699..68bc2d7cc51 100644
--- a/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackRunnable.java
+++ b/driver-core/src/main/com/mongodb/internal/async/function/AsyncCallbackRunnable.java
@@ -20,8 +20,8 @@
/**
* An {@linkplain AsyncCallbackFunction asynchronous callback-based function} of no parameters and no successful result.
* This class is a callback-based counterpart of {@link Runnable}.
- *
- *
This class is not part of the public API and may be removed or changed at any time
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
*
* @see AsyncCallbackFunction
*/
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/LoopControl.java b/driver-core/src/main/com/mongodb/internal/async/function/LoopControl.java
new file mode 100644
index 00000000000..5b89ce55434
--- /dev/null
+++ b/driver-core/src/main/com/mongodb/internal/async/function/LoopControl.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.internal.async.function;
+
+import com.mongodb.annotations.NotThreadSafe;
+import com.mongodb.internal.async.MutableValue;
+import com.mongodb.internal.async.SingleResultCallback;
+
+import java.util.function.Supplier;
+
+import static com.mongodb.assertions.Assertions.assertFalse;
+
+/**
+ * A stateful controller of a loop that can be used to control it, for example,
+ * to {@linkplain #breakAndCompleteIf(Supplier, SingleResultCallback) break} it.
+ * {@linkplain MutableValue} may be used by the loop to preserve state between iterations.
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
+ *
+ * @see AsyncCallbackLoop
+ */
+@NotThreadSafe
+public final class LoopControl {
+ private int iteration;
+ private boolean lastIteration;
+
+ public LoopControl() {
+ iteration = 0;
+ }
+
+ /**
+ * Advances this {@link LoopControl} such that it represents the state of the immediate next iteration, if any.
+ * Must not be called before the {@linkplain #isFirstIteration() first iteration}, must be called before each subsequent iteration.
+ *
+ * @return {@code true} if another iteration must be executed;
+ * otherwise the loop was {@link #isLastIteration() broken} and {@code false} is returned.
+ */
+ boolean advance() {
+ if (lastIteration) {
+ return false;
+ } else {
+ iteration++;
+ return true;
+ }
+ }
+
+ /**
+ * Returns {@code true} iff the current iteration is the first one.
+ *
+ * @see #iteration()
+ */
+ boolean isFirstIteration() {
+ return iteration == 0;
+ }
+
+ /**
+ * Returns {@code true} iff {@link #breakAndCompleteIf(Supplier, SingleResultCallback)} / {@link #markAsLastIteration()} was called.
+ */
+ boolean isLastIteration() {
+ return lastIteration;
+ }
+
+ /**
+ * A 0-based iteration number.
+ */
+ int iteration() {
+ return iteration;
+ }
+
+ /**
+ * This method emulates executing the {@code break} statement
+ * in callback-based code. If {@code true} is returned, the caller must complete the current attempt.
+ *
+ * Must not be called after breaking the loop.
+ *
+ * @param predicate {@code true} iff the loop needs to be broken.
+ *
+ * -
+ * If the {@code predicate} completes abruptly, this method completes the {@code callback} with the same exception but does not break the loop;
+ * -
+ * if the {@code predicate} is {@code true}, then this method breaks the retry loop;
+ * -
+ * if the {@code predicate} is {@code false}, then this method does nothing.
+ *
+ * @return {@code true} iff the {@code callback} was completed, which happens iff any of the following is true:
+ *
+ * - the {@code predicate} completed abruptly;
+ * - this method broke the loop.
+ *
+ *
+ * @see #isLastIteration()
+ */
+ public boolean breakAndCompleteIf(final Supplier predicate, final SingleResultCallback callback) {
+ assertFalse(lastIteration);
+ try {
+ lastIteration = predicate.get();
+ } catch (Throwable predicateException) {
+ callback.onResult(null, predicateException);
+ return true;
+ }
+ if (lastIteration) {
+ callback.onResult(null, null);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * This method is similar to {@link #breakAndCompleteIf(Supplier, SingleResultCallback)}.
+ * The difference is that it allows the current iteration to continue, yet no more iterations will happen.
+ *
+ * @see #isLastIteration()
+ */
+ void markAsLastIteration() {
+ assertFalse(lastIteration);
+ lastIteration = true;
+ }
+
+ @Override
+ public String toString() {
+ return "LoopControl{"
+ + "iteration=" + iteration
+ + ", lastIteration=" + lastIteration
+ + '}';
+ }
+}
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/LoopState.java b/driver-core/src/main/com/mongodb/internal/async/function/LoopState.java
deleted file mode 100644
index f3b19fecde7..00000000000
--- a/driver-core/src/main/com/mongodb/internal/async/function/LoopState.java
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- * Copyright 2008-present MongoDB, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.mongodb.internal.async.function;
-
-import com.mongodb.annotations.Immutable;
-import com.mongodb.annotations.NotThreadSafe;
-import com.mongodb.internal.async.SingleResultCallback;
-import com.mongodb.lang.Nullable;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import java.util.function.Supplier;
-
-import static com.mongodb.assertions.Assertions.assertFalse;
-import static com.mongodb.assertions.Assertions.assertNotNull;
-
-/**
- * Represents both the state associated with a loop and a handle that can be used to affect looping, e.g.,
- * to {@linkplain #breakAndCompleteIf(Supplier, SingleResultCallback) break} it.
- * {@linkplain #attachment(AttachmentKey) Attachments} may be used by the associated loop
- * to preserve a state between iterations.
- *
- * This class is not part of the public API and may be removed or changed at any time
- *
- * @see AsyncCallbackLoop
- */
-@NotThreadSafe
-public final class LoopState {
- private int iteration;
- private boolean lastIteration;
- @Nullable
- private Map, AttachmentValueContainer> attachments;
-
- public LoopState() {
- iteration = 0;
- }
-
- /**
- * Advances this {@link LoopState} such that it represents the state of a new iteration.
- * Must not be called before the {@linkplain #isFirstIteration() first iteration}, must be called before each subsequent iteration.
- *
- * @return {@code true} if the next iteration must be executed; {@code false} iff the loop was {@link #isLastIteration() broken}.
- */
- boolean advance() {
- if (lastIteration) {
- return false;
- } else {
- iteration++;
- removeAutoRemovableAttachments();
- return true;
- }
- }
-
- /**
- * Returns {@code true} iff the current iteration is the first one.
- *
- * @see #iteration()
- */
- public boolean isFirstIteration() {
- return iteration == 0;
- }
-
- /**
- * Returns {@code true} iff {@link #breakAndCompleteIf(Supplier, SingleResultCallback)} / {@link #markAsLastIteration()} was called.
- */
- boolean isLastIteration() {
- return lastIteration;
- }
-
- /**
- * A 0-based iteration number.
- */
- public int iteration() {
- return iteration;
- }
-
- /**
- * This method emulates executing the
- * {@code break} statement. Must not be called more than once per {@link LoopState}.
- *
- * @param predicate {@code true} iff the associated loop needs to be broken.
- * @return {@code true} iff the {@code callback} was completed, which happens iff any of the following is true:
- *
- * - the {@code predicate} completed abruptly, in which case the exception thrown is relayed to the {@code callback};
- * - this method broke the associated loop.
- *
- * If {@code true} is returned, the caller must complete the ongoing attempt.
- * @see #isLastIteration()
- */
- public boolean breakAndCompleteIf(final Supplier predicate, final SingleResultCallback callback) {
- assertFalse(lastIteration);
- try {
- lastIteration = predicate.get();
- } catch (Throwable t) {
- callback.onResult(null, t);
- return true;
- }
- if (lastIteration) {
- callback.onResult(null, null);
- return true;
- } else {
- return false;
- }
- }
-
- /**
- * This method is similar to {@link #breakAndCompleteIf(Supplier, SingleResultCallback)}.
- * The difference is that it allows the current iteration to continue, yet no more iterations will happen.
- *
- * @see #isLastIteration()
- */
- void markAsLastIteration() {
- assertFalse(lastIteration);
- lastIteration = true;
- }
-
- /**
- * The associated loop may use this method to preserve a state between iterations.
- *
- * @param autoRemove Specifies whether the attachment must be automatically removed before (in the happens-before order) the next
- * {@linkplain #iteration() iteration} as if this removal were the very first action of the iteration.
- * Note that there is no guarantee that the attachment is removed after the {@linkplain #isLastIteration() last iteration}.
- * @return {@code this}.
- * @see #attachment(AttachmentKey)
- */
- public LoopState attach(final AttachmentKey key, final V value, final boolean autoRemove) {
- attachments().put(assertNotNull(key), new AttachmentValueContainer(assertNotNull(value), autoRemove));
- return this;
- }
-
- /**
- * @see #attach(AttachmentKey, Object, boolean)
- */
- public Optional attachment(final AttachmentKey key) {
- AttachmentValueContainer valueContainer = attachments().get(assertNotNull(key));
- @SuppressWarnings("unchecked") V value = valueContainer == null ? null : (V) valueContainer.value();
- return Optional.ofNullable(value);
- }
-
- private Map, AttachmentValueContainer> attachments() {
- if (attachments == null) {
- attachments = new HashMap<>();
- }
- return attachments;
- }
-
- private void removeAutoRemovableAttachments() {
- if (attachments == null) {
- return;
- }
- attachments.entrySet().removeIf(entry -> entry.getValue().autoRemove());
- }
-
- @Override
- public String toString() {
- return "LoopState{"
- + "iteration=" + iteration
- + ", attachments=" + attachments
- + '}';
- }
-
- /**
- * A value-based
- * identifier of an attachment.
- *
- * @param The type of the corresponding attachment value.
- */
- @Immutable
- // the type parameter V is of the essence even though it is not used in the interface itself
- @SuppressWarnings("unused")
- public interface AttachmentKey {
- }
-
- private static final class AttachmentValueContainer {
- @Nullable
- private final Object value;
- private final boolean autoRemove;
-
- AttachmentValueContainer(@Nullable final Object value, final boolean autoRemove) {
- this.value = value;
- this.autoRemove = autoRemove;
- }
-
- @Nullable
- Object value() {
- return value;
- }
-
- boolean autoRemove() {
- return autoRemove;
- }
-
- @Override
- public String toString() {
- return "AttachmentValueContainer{"
- + "value=" + value
- + ", autoRemove=" + autoRemove
- + '}';
- }
- }
-}
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/RetryContext.java b/driver-core/src/main/com/mongodb/internal/async/function/RetryContext.java
new file mode 100644
index 00000000000..419224d4f80
--- /dev/null
+++ b/driver-core/src/main/com/mongodb/internal/async/function/RetryContext.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.internal.async.function;
+
+import com.mongodb.annotations.NotThreadSafe;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+
+/**
+ * The part of {@link RetryControl} accessible to the methods of the {@link RetryPolicy} interface.
+ * It prevents, for example, the method {@link RetryPolicy#onAttemptFailure(RetryContext, Throwable)} from calling
+ * {@link RetryControl#breakAndThrowIfRetryAnd(Supplier)}, as that is forbidden.
+ * A non-overriding method of a {@link RetryPolicy} implementation is free to access the full {@link RetryControl}
+ * as opposed to {@link RetryContext}.
+ */
+@NotThreadSafe
+public interface RetryContext {
+ /**
+ * Returns {@code true} iff the current attempt is the first one, i.e., no retry attempts have been made.
+ *
+ * @see #attempt()
+ */
+ boolean isFirstAttempt();
+
+ /**
+ * A 0-based attempt number.
+ *
+ * @see #isFirstAttempt()
+ */
+ int attempt();
+
+ /**
+ * Returns the exception that is currently deemed to be the prospective failed result of the retryable activity.
+ * Note that it is not necessary the failed result of the most recent failed attempt.
+ * Returns an {@linkplain Optional#isEmpty() empty} {@link Optional} iff called during the {@linkplain #isFirstAttempt() first attempt}.
+ *
+ * @see RetryPolicy.Decision#getProspectiveFailedResult()
+ */
+ Optional getProspectiveFailedResult();
+}
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/RetryControl.java b/driver-core/src/main/com/mongodb/internal/async/function/RetryControl.java
new file mode 100644
index 00000000000..c7b99e20308
--- /dev/null
+++ b/driver-core/src/main/com/mongodb/internal/async/function/RetryControl.java
@@ -0,0 +1,261 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.internal.async.function;
+
+import com.mongodb.annotations.NotThreadSafe;
+import com.mongodb.assertions.Assertions;
+import com.mongodb.internal.async.AsyncSupplier;
+import com.mongodb.internal.async.MutableValue;
+import com.mongodb.internal.async.SingleResultCallback;
+import com.mongodb.internal.async.function.RetryPolicy.Decision;
+import com.mongodb.internal.async.function.RetryPolicy.Decision.RetryAttemptInfo;
+import com.mongodb.lang.Nullable;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+
+import static com.mongodb.assertions.Assertions.assertFalse;
+import static com.mongodb.assertions.Assertions.assertNotNull;
+import static com.mongodb.assertions.Assertions.assertTrue;
+import static com.mongodb.internal.async.AsyncRunnable.beginAsync;
+
+/**
+ * A stateful controller of a retryable activity that can be used to control it, for example,
+ * to {@linkplain #breakAndThrowIfRetryAnd(Supplier) break} it.
+ * Either {@linkplain MutableValue} or an implementation of {@link RetryPolicy} may be used by the retryable activity
+ * to preserve state between attempts.
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
+ *
+ * @see RetryingSyncSupplier
+ * @see RetryingAsyncCallbackSupplier
+ */
+@NotThreadSafe
+public final class RetryControl
implements RetryContext {
+ private final LoopControl loopControl;
+ private boolean disabled;
+ @Nullable
+ private Decision mostRecentDecision;
+ private final P policy;
+
+ public RetryControl(final P policy) {
+ loopControl = new LoopControl();
+ this.policy = policy;
+ disabled = false;
+ mostRecentDecision = null;
+ }
+
+ @Override
+ public boolean isFirstAttempt() {
+ return loopControl.isFirstIteration();
+ }
+
+ @Override
+ public int attempt() {
+ return loopControl.iteration();
+ }
+
+ public P getPolicy() {
+ return policy;
+ }
+
+ /**
+ * Advances this {@link RetryControl} such that it represents the state of the immediate next attempt, if any.
+ * Must not be called before the {@linkplain #isFirstAttempt() first attempt}, must be called before each subsequent attempt.
+ *
+ * @param attemptFailedResult The failed result of the most recent attempt.
+ * @return {@link RetryAttemptInfo} iff another attempt must be executed.
+ * @throws RuntimeException If another attempt must not be executed.
+ * The exception thrown represents the failed result of the retryable activity.
+ * @throws Error See above for {@link RuntimeException}.
+ */
+ RetryAttemptInfo advanceOrThrow(final Throwable attemptFailedResult) throws RuntimeException, Error {
+ assertNotNull(attemptFailedResult);
+ try {
+ if (disabled) {
+ throw attemptFailedResult;
+ }
+ Throwable prospectiveFailedResult = getProspectiveFailedResult().orElse(null);
+ if (attemptFailedResult instanceof Error) {
+ onAttemptFatalFailure(policy, prospectiveFailedResult, (Error) attemptFailedResult);
+ throw attemptFailedResult;
+ }
+ // this `RetryControl` must not be mutated before calling `onAttemptFatalFailure`/`onAttemptFailure`
+ Decision decision = onAttemptFailure(policy, this, prospectiveFailedResult, attemptFailedResult);
+ mostRecentDecision = decision;
+ if (loopControl.isLastIteration() || !decision.getImmediateNextAttemptInfo().isPresent()) {
+ throw decision.getProspectiveFailedResult();
+ } else {
+ assertTrue(loopControl.advance());
+ return decision.getImmediateNextAttemptInfo().orElseThrow(Assertions::fail);
+ }
+ } catch (RuntimeException | Error uncheckedFailedResult) {
+ throw uncheckedFailedResult;
+ } catch (Throwable checkedFailedResult) {
+ throw new RuntimeException(checkedFailedResult);
+ }
+ }
+
+ private static
void onAttemptFatalFailure(
+ final P policy,
+ @Nullable final Throwable prospectiveFailedResult,
+ final Error attemptFailedResult) throws RuntimeException, Error {
+ doAndHandleException(
+ () -> {
+ policy.onAttemptFatalFailure();
+ return null;
+ },
+ prospectiveFailedResult,
+ attemptFailedResult);
+ }
+
+ private static
Decision onAttemptFailure(
+ final P policy,
+ final RetryContext retryContext,
+ @Nullable final Throwable prospectiveFailedResult,
+ final Throwable attemptFailedResult) throws RuntimeException, Error {
+ return assertNotNull(doAndHandleException(
+ () -> policy.onAttemptFailure(retryContext, attemptFailedResult),
+ prospectiveFailedResult,
+ attemptFailedResult));
+ }
+
+ @Nullable
+ private static T doAndHandleException(
+ final Supplier action,
+ @Nullable final Throwable prospectiveFailedResult,
+ final Throwable attemptFailedResult) throws RuntimeException, Error {
+ T result;
+ try {
+ result = action.get();
+ } catch (Throwable actionException) {
+ if (prospectiveFailedResult != null && prospectiveFailedResult != actionException) {
+ actionException.addSuppressed(prospectiveFailedResult);
+ }
+ if (attemptFailedResult != actionException) {
+ actionException.addSuppressed(attemptFailedResult);
+ }
+ throw actionException;
+ }
+ return result;
+ }
+
+ @Override
+ public Optional getProspectiveFailedResult() {
+ assertTrue(isFirstAttempt() ^ mostRecentDecision != null);
+ return mostRecentDecision == null
+ ? Optional.empty()
+ : Optional.of(mostRecentDecision.getProspectiveFailedResult());
+ }
+
+ /**
+ * This method is similar to the semantics of the
+ * {@code break} statement,
+ * with the difference that breaking results in throwing an exception.
+ * That thrown exception must be used by the caller to complete the current attempt.
+ * Does nothing and completes normally if called during the {@linkplain #isFirstAttempt() first attempt}.
+ *
+ * This method is useful when the retryable activity detects that a retry attempt should not happen
+ * despite having been started.
+ *
+ * Must not be called after breaking the retry loop.
+ *
+ * @param predicate {@code true} iff the retry loop needs to be broken.
+ * The {@code predicate} is not called during the {@linkplain #isFirstAttempt() first attempt}.
+ *
+ * -
+ * If the {@code predicate} completes abruptly, this method completes abruptly with the same exception, but does not break the retry loop;
+ * -
+ * if the {@code predicate} is {@code true}, then this method breaks the retry loop and completes abruptly by throwing {@link #getProspectiveFailedResult()};
+ * -
+ * if the {@code predicate} is {@code false}, then this method does nothing.
+ *
+ * @throws RuntimeException Iff any of the following is true:
+ *
+ * - the {@code predicate} completed abruptly;
+ * - this method broke the retry loop.
+ *
+ */
+ public void breakAndThrowIfRetryAnd(final Supplier predicate) throws RuntimeException, Error {
+ assertFalse(loopControl.isLastIteration());
+ if (isFirstAttempt()) {
+ return;
+ }
+ Throwable prospectiveFailedResult = getProspectiveFailedResult().orElseThrow(Assertions::fail);
+ try {
+ if (predicate.get()) {
+ loopControl.markAsLastIteration();
+ }
+ } catch (Throwable predicateException) {
+ if (prospectiveFailedResult != predicateException) {
+ predicateException.addSuppressed(prospectiveFailedResult);
+ }
+ throw predicateException;
+ }
+ if (loopControl.isLastIteration()) {
+ try {
+ throw prospectiveFailedResult;
+ } catch (RuntimeException | Error unchecked) {
+ throw unchecked;
+ } catch (Throwable checked) {
+ throw new RuntimeException(checked);
+ }
+ }
+ }
+
+ /**
+ * This method allows to execute {@code action} within the encompassing retryable activity, as if it were not retryable.
+ * If {@code action} throws an exception, then this method throws that same exception, and, if the current attempt fails,
+ * the {@link RetryPolicy#onAttemptFailure(RetryContext, Throwable)} is not called, and the failed result of the attempt
+ * becomes the failed result of the retryable activity disregarding {@link #getProspectiveFailedResult()}.
+ *
+ * @see #doWhileDisabledAsync(AsyncSupplier, SingleResultCallback)
+ */
+ public R doWhileDisabled(final Supplier action) {
+ boolean originalDisabled = disabled;
+ disabled = true;
+ R result = action.get();
+ // `disabled` must be reverted to its original value only if `action` completes normally
+ disabled = originalDisabled;
+ return result;
+ }
+
+ /**
+ * This method is similar to {@link #doWhileDisabled(Supplier)},
+ * but instead of throwing an exception, it completes the {@code callback} with it.
+ * This method is intended to be used in callback-based code.
+ */
+ public void doWhileDisabledAsync(final AsyncSupplier action, final SingleResultCallback callback) {
+ boolean originalDisabled = disabled;
+ disabled = true;
+ beginAsync().thenSupply(c -> {
+ action.finish(c);
+ }).thenRunAndFinish(() -> {
+ // `disabled` must be reverted to its original value only if `action` completes normally
+ disabled = originalDisabled;
+ }, callback);
+ }
+
+ @Override
+ public String toString() {
+ return "RetryControl{"
+ + "loopControl=" + loopControl
+ + ", disabled=" + disabled
+ + ", mostRecentDecision=" + mostRecentDecision
+ + ", policy=" + policy
+ + '}';
+ }
+}
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/RetryPolicy.java b/driver-core/src/main/com/mongodb/internal/async/function/RetryPolicy.java
new file mode 100644
index 00000000000..3f6320bf0ac
--- /dev/null
+++ b/driver-core/src/main/com/mongodb/internal/async/function/RetryPolicy.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.internal.async.function;
+
+import com.mongodb.annotations.NotThreadSafe;
+import com.mongodb.lang.Nullable;
+
+import java.time.Duration;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+import static com.mongodb.assertions.Assertions.assertFalse;
+import static com.mongodb.assertions.Assertions.assertNotNull;
+
+/**
+ * Customizes retrying and may allow for control beyond what {@link RetryControl} itself provides, depending on the implementation.
+ *
+ * An implementation may be stateful.
+ * An implementation must be thread-safe iff a {@link RetryPolicy} instance is shared by multiple concurrent executions of a retryable activity.
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
+ */
+@NotThreadSafe
+public interface RetryPolicy {
+ /**
+ * This method is called exactly once per failed attempt,
+ * even if that is the last attempt due to {@linkplain RetryControl#breakAndThrowIfRetryAnd(Supplier) breaking} the retry loop,
+ * provided that retrying is not {@linkplain RetryControl#doWhileDisabled(Supplier) disabled},
+ * and the failed result of the attempt is not {@linkplain #onAttemptFatalFailure() fatal}.
+ *
+ * If this method completes abruptly, then another attempt is not executed,
+ * and the exception thrown by the method is used as the failed result of the retryable activity.
+ *
+ * This method may have side effects, and may mutate {@link RetryContext#getProspectiveFailedResult()}, {@code attemptFailedResult}.
+ *
+ * @param attemptFailedResult The failed result of the most recent attempt.
+ * @see #onAttemptFatalFailure()
+ */
+ Decision onAttemptFailure(RetryContext retryContext, Throwable attemptFailedResult);
+
+ /**
+ * This method is similar to {@link #onAttemptFailure(RetryContext, Throwable)}, with the following difference:
+ * it is called only if the failed result of the most recent attempt is an {@link Error}.
+ * The method intentionally accepts neither {@link RetryContext}, nor information about the {@link Error},
+ * to discourage the implementation from doing much.
+ *
+ * If this method is invoked, then another attempt is not executed regardless of whether the method completes normally or abruptly.
+ * However, if the method completes abruptly, then the exception thrown by the method is used as the failed result of the retryable activity.
+ */
+ default void onAttemptFatalFailure() {
+ }
+
+ final class Decision {
+ private final Throwable prospectiveFailedResult;
+ @Nullable
+ private final RetryAttemptInfo immediateNextAttemptInfo;
+
+ /**
+ * @param immediateNextAttemptInfo See {@link #getImmediateNextAttemptInfo()}.
+ */
+ public Decision(final Throwable prospectiveFailedResult, @Nullable final RetryAttemptInfo immediateNextAttemptInfo) {
+ assertNotNull(prospectiveFailedResult);
+ this.prospectiveFailedResult = prospectiveFailedResult;
+ this.immediateNextAttemptInfo = immediateNextAttemptInfo;
+ }
+
+ /**
+ * @see RetryControl#getProspectiveFailedResult()
+ */
+ public Throwable getProspectiveFailedResult() {
+ return prospectiveFailedResult;
+ }
+
+ /**
+ * Returns {@link Optional#isEmpty()} to signal that another attempt must not be executed.
+ * If {@link RetryAttemptInfo} is {@linkplain Optional#isPresent() present},
+ * another attempt is still not executed if the retry loop was {@linkplain RetryControl#breakAndThrowIfRetryAnd(Supplier) broken}.
+ */
+ public Optional getImmediateNextAttemptInfo() {
+ return Optional.ofNullable(immediateNextAttemptInfo);
+ }
+
+ @Override
+ public String toString() {
+ return "Decision{"
+ + "prospectiveFailedResult=" + prospectiveFailedResult
+ + ", immediateNextAttemptInfo=" + immediateNextAttemptInfo
+ + '}';
+ }
+
+ /**
+ * The information needed to start a retry attempt.
+ */
+ public static final class RetryAttemptInfo {
+ private final Duration backoff;
+
+ public RetryAttemptInfo(final Duration backoff) {
+ assertFalse(backoff.isNegative());
+ this.backoff = backoff;
+ }
+
+ /**
+ * A non-{@linkplain Duration#isNegative() negative} backoff.
+ */
+ public Duration getBackoff() {
+ return backoff;
+ }
+
+ @Override
+ public String toString() {
+ return "RetryAttemptInfo{"
+ + "backoff=" + backoff
+ + '}';
+ }
+ }
+ }
+}
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/RetryState.java b/driver-core/src/main/com/mongodb/internal/async/function/RetryState.java
deleted file mode 100644
index b209035d7a2..00000000000
--- a/driver-core/src/main/com/mongodb/internal/async/function/RetryState.java
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
- * Copyright 2008-present MongoDB, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.mongodb.internal.async.function;
-
-import com.mongodb.MongoOperationTimeoutException;
-import com.mongodb.annotations.NotThreadSafe;
-import com.mongodb.internal.async.SingleResultCallback;
-import com.mongodb.internal.async.function.LoopState.AttachmentKey;
-import com.mongodb.lang.NonNull;
-import com.mongodb.lang.Nullable;
-
-import java.util.Optional;
-import java.util.function.BiPredicate;
-import java.util.function.BinaryOperator;
-import java.util.function.Supplier;
-
-import static com.mongodb.assertions.Assertions.assertFalse;
-import static com.mongodb.assertions.Assertions.assertNotNull;
-import static com.mongodb.assertions.Assertions.assertTrue;
-import static com.mongodb.internal.TimeoutContext.createMongoTimeoutException;
-
-/**
- * Represents both the state associated with a retryable activity and a handle that can be used to affect retrying, e.g.,
- * to {@linkplain #breakAndThrowIfRetryAnd(Supplier) break} it.
- * {@linkplain #attachment(AttachmentKey) Attachments} may be used by the associated retryable activity either
- * to preserve a state between attempts.
- *
- * This class is not part of the public API and may be removed or changed at any time
- *
- * @see RetryingSyncSupplier
- * @see RetryingAsyncCallbackSupplier
- */
-@NotThreadSafe
-public final class RetryState {
- public static final int MAX_RETRIES = 1;
- private static final int INFINITE_RETRIES = Integer.MAX_VALUE;
-
- private final LoopState loopState;
- private final int attempts;
- @Nullable
- private Throwable previouslyChosenException;
-
- /**
- * Creates a {@link RetryState} that does not explicitly limit the number of attempts.
- * Retrying still may be stopped because, for example,
- * the failed result from the most recent attempt is {@link MongoOperationTimeoutException}.
- */
- public RetryState() {
- this(INFINITE_RETRIES);
- }
-
- /**
- * @param retries A non-negative number of allowed retry attempts.
- * {@value #INFINITE_RETRIES} is interpreted as {@linkplain #RetryState() absence of explicit limit}.
- */
- public RetryState(final int retries) {
- assertTrue(retries >= 0);
- loopState = new LoopState();
- attempts = retries == INFINITE_RETRIES ? INFINITE_RETRIES : retries + 1;
- }
-
- /**
- * Advances this {@link RetryState} such that it represents the state of a new attempt.
- * If there is at least one more attempt left, it is consumed by this method.
- * Must not be called before the {@linkplain #isFirstAttempt() first attempt}, must be called before each subsequent attempt.
- *
- * This method is intended to be used by code that generally does not handle {@link Error}s explicitly,
- * which is usually synchronous code.
- *
- * @param attemptException The exception produced by the most recent attempt.
- * It is passed to the {@code retryPredicate} and to the {@code onAttemptFailureOperator}.
- * @param onAttemptFailureOperator The action that is called once per failed attempt before (in the happens-before order) the
- * {@code retryPredicate}, regardless of whether the {@code retryPredicate} is called.
- * This action is allowed to have side effects.
- *
- * It also has to choose which exception to preserve as a prospective failed result of the associated retryable activity.
- * The {@code onAttemptFailureOperator} may mutate its arguments, choose from the arguments, or return a different exception,
- * but it must return a {@code @}{@link NonNull} value.
- * The choice is between
- *
- * - the previously chosen exception or {@code null} if none has been chosen
- * (the first argument of the {@code onAttemptFailureOperator})
- * - and the exception from the most recent attempt (the second argument of the {@code onAttemptFailureOperator}).
- *
- * The result of the {@code onAttemptFailureOperator} does not affect the exception passed to the {@code retryPredicate}.
- * @param retryPredicate {@code true} iff another attempt needs to be made. The {@code retryPredicate} is called not more than once
- * per attempt and only if all the following is true:
- *
- * - {@code onAttemptFailureOperator} completed normally;
- * - the most recent attempt is not known to be the {@linkplain #isLastAttempt(Throwable) last} one.
- *
- * The {@code retryPredicate} accepts this {@link RetryState} and the exception from the most recent attempt,
- * and may mutate the exception. The {@linkplain RetryState} advances to represent the state of a new attempt
- * after (in the happens-before order) testing the {@code retryPredicate}, and only if the predicate completes normally.
- * @throws RuntimeException Iff any of the following is true:
- *
- * - the {@code onAttemptFailureOperator} completed abruptly;
- * - the most recent attempt is known to be the {@linkplain #isLastAttempt(Throwable) last} one;
- * - the {@code retryPredicate} completed abruptly;
- * - the {@code retryPredicate} is {@code false}.
- *
- * The exception thrown represents the failed result of the associated retryable activity,
- * i.e., the caller must not make any more attempts.
- * @see #advanceOrThrow(Throwable, BinaryOperator, BiPredicate)
- */
- void advanceOrThrow(final RuntimeException attemptException, final BinaryOperator onAttemptFailureOperator,
- final BiPredicate retryPredicate) throws RuntimeException {
- try {
- doAdvanceOrThrow(attemptException, onAttemptFailureOperator, retryPredicate, true);
- } catch (RuntimeException | Error unchecked) {
- throw unchecked;
- } catch (Throwable checked) {
- throw new AssertionError(checked);
- }
- }
-
- /**
- * This method is intended to be used by code that generally handles all {@link Throwable} types explicitly,
- * which is usually asynchronous code.
- *
- * @see #advanceOrThrow(RuntimeException, BinaryOperator, BiPredicate)
- */
- void advanceOrThrow(final Throwable attemptException, final BinaryOperator onAttemptFailureOperator,
- final BiPredicate retryPredicate) throws Throwable {
- doAdvanceOrThrow(attemptException, onAttemptFailureOperator, retryPredicate, false);
- }
-
- /**
- * @param onlyRuntimeExceptions {@code true} iff the method must expect {@link #previouslyChosenException} and {@code attemptException} to be
- * {@link RuntimeException}s and must not explicitly handle other {@link Throwable} types, of which only {@link Error} is possible
- * as {@link RetryState} does not have any source of {@link Exception}s.
- * @param onAttemptFailureOperator See {@link #advanceOrThrow(RuntimeException, BinaryOperator, BiPredicate)}.
- */
- private void doAdvanceOrThrow(final Throwable attemptException,
- final BinaryOperator onAttemptFailureOperator,
- final BiPredicate retryPredicate,
- final boolean onlyRuntimeExceptions) throws Throwable {
- assertTrue(attempt() < attempts);
- assertNotNull(attemptException);
- if (onlyRuntimeExceptions) {
- assertTrue(isRuntime(attemptException));
- }
- assertTrue(!isFirstAttempt() || previouslyChosenException == null);
- Throwable newlyChosenException = callOnAttemptFailureOperator(previouslyChosenException, attemptException, onlyRuntimeExceptions, onAttemptFailureOperator);
- if (isLastAttempt(attemptException)) {
- previouslyChosenException = newlyChosenException;
- if (attemptException instanceof MongoOperationTimeoutException) {
- previouslyChosenException = createMongoTimeoutException("Retry attempt exceeded the timeout limit.", previouslyChosenException);
- }
- throw previouslyChosenException;
- } else {
- // note that we must not update the state, e.g, `previouslyChosenException`, `loopState`, before calling `retryPredicate`
- boolean retry = shouldRetry(this, attemptException, newlyChosenException, onlyRuntimeExceptions, retryPredicate);
- previouslyChosenException = newlyChosenException;
- if (retry) {
- assertTrue(loopState.advance());
- } else {
- throw previouslyChosenException;
- }
- }
- }
-
- /**
- * @param onlyRuntimeExceptions See {@link #doAdvanceOrThrow(Throwable, BinaryOperator, BiPredicate, boolean)}.
- * @param onAttemptFailureOperator See {@link #advanceOrThrow(RuntimeException, BinaryOperator, BiPredicate)}.
- */
- private static Throwable callOnAttemptFailureOperator(
- @Nullable final Throwable previouslyChosenException,
- final Throwable attemptException,
- final boolean onlyRuntimeExceptions,
- final BinaryOperator onAttemptFailureOperator) {
- if (onlyRuntimeExceptions && previouslyChosenException != null) {
- assertTrue(isRuntime(previouslyChosenException));
- }
- Throwable result;
- try {
- result = assertNotNull(onAttemptFailureOperator.apply(previouslyChosenException, attemptException));
- if (onlyRuntimeExceptions) {
- assertTrue(isRuntime(result));
- }
- } catch (Throwable onAttemptFailureOperatorException) {
- if (onlyRuntimeExceptions && !isRuntime(onAttemptFailureOperatorException)) {
- throw onAttemptFailureOperatorException;
- }
- if (previouslyChosenException != null) {
- onAttemptFailureOperatorException.addSuppressed(previouslyChosenException);
- }
- onAttemptFailureOperatorException.addSuppressed(attemptException);
- throw onAttemptFailureOperatorException;
- }
- return result;
- }
-
- /**
- * @param readOnlyRetryState Must not be mutated by this method.
- * @param onlyRuntimeExceptions See {@link #doAdvanceOrThrow(Throwable, BinaryOperator, BiPredicate, boolean)}.
- */
- private boolean shouldRetry(final RetryState readOnlyRetryState, final Throwable attemptException, final Throwable newlyChosenException,
- final boolean onlyRuntimeExceptions, final BiPredicate retryPredicate) {
- try {
- return retryPredicate.test(readOnlyRetryState, attemptException);
- } catch (Throwable retryPredicateException) {
- if (onlyRuntimeExceptions && !isRuntime(retryPredicateException)) {
- throw retryPredicateException;
- }
- retryPredicateException.addSuppressed(newlyChosenException);
- throw retryPredicateException;
- }
- }
-
- private static boolean isRuntime(@Nullable final Throwable exception) {
- return exception instanceof RuntimeException;
- }
-
- /**
- * This method is similar to the semantics of the
- * {@code break} statement, with the difference
- * that breaking results in throwing an exception because the retry loop has more than one iteration only if the first iteration fails.
- * Does nothing and completes normally if called during the {@linkplain #isFirstAttempt() first attempt}.
- * This method is useful when the associated retryable activity detects that a retry attempt should not happen
- * despite having been started. Must not be called more than once per {@link RetryState}.
- *
- * If the {@code predicate} completes abruptly, this method also completes abruptly with the same exception but does not break retrying;
- * if the {@code predicate} is {@code true}, then the method breaks retrying and completes abruptly by throwing the exception that is
- * currently deemed to be a prospective failed result of the associated retryable activity. The thrown exception must also be used
- * by the caller to complete the ongoing attempt.
- *
- * If this method is called from
- * {@linkplain RetryingSyncSupplier#RetryingSyncSupplier(RetryState, BinaryOperator, BiPredicate, Supplier)
- * retry predicate / failed result transformer}, the behavior is unspecified.
- *
- * @param predicate {@code true} iff retrying needs to be broken.
- * The {@code predicate} is not called during the {@linkplain #isFirstAttempt() first attempt}.
- * @throws RuntimeException Iff any of the following is true:
- *
- * - the {@code predicate} completed abruptly;
- * - this method broke retrying.
- *
- * The exception thrown represents the failed result of the associated retryable activity.
- * @see #breakAndCompleteIfRetryAnd(Supplier, SingleResultCallback)
- */
- public void breakAndThrowIfRetryAnd(final Supplier predicate) throws RuntimeException {
- assertFalse(loopState.isLastIteration());
- if (!isFirstAttempt()) {
- assertNotNull(previouslyChosenException);
- assertTrue(previouslyChosenException instanceof RuntimeException);
- RuntimeException localException = (RuntimeException) previouslyChosenException;
- try {
- if (predicate.get()) {
- loopState.markAsLastIteration();
- }
- } catch (Exception predicateException) {
- predicateException.addSuppressed(localException);
- throw predicateException;
- }
- if (loopState.isLastIteration()) {
- throw localException;
- }
- }
- }
-
- /**
- * This method is intended to be used by callback-based code. It is similar to {@link #breakAndThrowIfRetryAnd(Supplier)},
- * but instead of throwing an exception, it relays it to the {@code callback}.
- *
- * If this method is called from
- * {@linkplain RetryingAsyncCallbackSupplier#RetryingAsyncCallbackSupplier(RetryState, BinaryOperator, BiPredicate, AsyncCallbackSupplier)
- * retry predicate / failed result transformer}, the behavior is unspecified.
- *
- * @return {@code true} iff the {@code callback} was completed, which happens in the same situations in which
- * {@link #breakAndThrowIfRetryAnd(Supplier)} throws an exception. If {@code true} is returned, the caller must complete
- * the ongoing attempt.
- * @see #breakAndThrowIfRetryAnd(Supplier)
- */
- public boolean breakAndCompleteIfRetryAnd(final Supplier predicate, final SingleResultCallback callback) {
- try {
- breakAndThrowIfRetryAnd(predicate);
- return false;
- } catch (Throwable t) {
- callback.onResult(null, t);
- return true;
- }
- }
-
- /**
- * This method is similar to
- * {@link RetryState#breakAndThrowIfRetryAnd(Supplier)} / {@link RetryState#breakAndCompleteIfRetryAnd(Supplier, SingleResultCallback)}.
- * The difference is that it allows the current attempt to continue, yet no more attempts will happen. Also, unlike the aforementioned
- * methods, this method has effect even if called during the {@linkplain #isFirstAttempt() first attempt}.
- */
- public void markAsLastAttempt() {
- loopState.markAsLastIteration();
- }
-
- /**
- * Returns {@code true} iff the current attempt is the first one, i.e., no retry attempts have been made.
- *
- * @see #attempt()
- */
- public boolean isFirstAttempt() {
- return loopState.isFirstIteration();
- }
-
- /**
- * Returns {@code true} iff the current attempt is known to be the last one, i.e., it is known that no more attempts will be made.
- * An attempt is known to be the last one iff any of the following applies:
- *
- * - {@link #breakAndThrowIfRetryAnd(Supplier)} / {@link #breakAndCompleteIfRetryAnd(Supplier, SingleResultCallback)} / {@link #markAsLastAttempt()} was called.
- * - {@code attemptException} is a {@link MongoOperationTimeoutException}.
- * - The number of attempts is limited, and the current attempt is the last one.
- *
- *
- * @see #attempt()
- */
- private boolean isLastAttempt(final Throwable attemptException) {
- boolean operationTimeout = attemptException instanceof MongoOperationTimeoutException;
- boolean attemptLimit = attempt() == attempts - 1;
- return loopState.isLastIteration() || operationTimeout || attemptLimit;
- }
-
- /**
- * A 0-based attempt number.
- *
- * @see #isFirstAttempt()
- */
- public int attempt() {
- return loopState.iteration();
- }
-
- /**
- * Returns the exception that is currently deemed to be a prospective failed result of the associated retryable activity.
- * Note that this exception is not necessary the one from the most recent failed attempt.
- * Returns an {@linkplain Optional#isEmpty() empty} {@link Optional} iff called during the {@linkplain #isFirstAttempt() first attempt}.
- *
- * In synchronous code the returned exception is of the type {@link RuntimeException}.
- */
- public Optional exception() {
- assertTrue(previouslyChosenException == null || !isFirstAttempt());
- return Optional.ofNullable(previouslyChosenException);
- }
-
- /**
- * @see LoopState#attach(AttachmentKey, Object, boolean)
- */
- public RetryState attach(final AttachmentKey key, final V value, final boolean autoRemove) {
- loopState.attach(key, value, autoRemove);
- return this;
- }
-
- /**
- * @see LoopState#attachment(AttachmentKey)
- */
- public Optional attachment(final AttachmentKey key) {
- return loopState.attachment(key);
- }
-
- @Override
- public String toString() {
- return "RetryState{"
- + "loopState=" + loopState
- + ", attempts=" + (attempts == INFINITE_RETRIES ? "infinite" : attempts)
- + ", exception=" + previouslyChosenException
- + '}';
- }
-}
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/RetryingAsyncCallbackSupplier.java b/driver-core/src/main/com/mongodb/internal/async/function/RetryingAsyncCallbackSupplier.java
index 8d12e82e19e..f0f991fac7e 100644
--- a/driver-core/src/main/com/mongodb/internal/async/function/RetryingAsyncCallbackSupplier.java
+++ b/driver-core/src/main/com/mongodb/internal/async/function/RetryingAsyncCallbackSupplier.java
@@ -16,108 +16,71 @@
package com.mongodb.internal.async.function;
import com.mongodb.annotations.NotThreadSafe;
+import com.mongodb.internal.async.MutableValue;
import com.mongodb.internal.async.SingleResultCallback;
-import com.mongodb.lang.NonNull;
-import com.mongodb.lang.Nullable;
+import com.mongodb.internal.async.function.RetryPolicy.Decision.RetryAttemptInfo;
+import com.mongodb.internal.thread.AsyncClientExecutor;
+import com.mongodb.internal.thread.ThreadUtil;
-import java.util.function.BiPredicate;
-import java.util.function.BinaryOperator;
-import java.util.function.Supplier;
+import java.time.Duration;
+
+import static com.mongodb.assertions.Assertions.fail;
+import static com.mongodb.internal.async.AsyncRunnable.beginAsync;
+import static com.mongodb.internal.thread.ThreadUtil.sleepAsync;
/**
* A decorator that implements automatic retrying of failed executions of an {@link AsyncCallbackSupplier}.
* {@link RetryingAsyncCallbackSupplier} may execute the original retryable asynchronous function multiple times sequentially,
* while guaranteeing that the callback passed to {@link #get(SingleResultCallback)} is completed at most once.
*
- * The original function may additionally observe or control retrying via {@link RetryState}.
- * For example, the {@link RetryState#breakAndCompleteIfRetryAnd(Supplier, SingleResultCallback)} method may be used to
- * break retrying if the original function decides so.
- *
- *
This class is not part of the public API and may be removed or changed at any time
+ * The original function may additionally observe or control the retry loop via {@link RetryControl}.
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
*
* @see RetryingSyncSupplier
*/
@NotThreadSafe
public final class RetryingAsyncCallbackSupplier implements AsyncCallbackSupplier {
- private final RetryState state;
- private final BiPredicate retryPredicate;
- private final BinaryOperator onAttemptFailureOperator;
+ private final AsyncClientExecutor clientExecutor;
+ private final RetryControl control;
private final AsyncCallbackSupplier asyncFunction;
/**
- * @param state The {@link RetryState} to be deemed as initial for the purpose of the new {@link RetryingAsyncCallbackSupplier}.
- * @param onAttemptFailureOperator The action that is called once per failed attempt before (in the happens-before order) the
- * {@code retryPredicate}, regardless of whether the {@code retryPredicate} is called.
- * This action is allowed to have side effects.
- *
- * It also has to choose which exception to preserve as a prospective failed result of this {@link RetryingAsyncCallbackSupplier}.
- * The {@code onAttemptFailureOperator} may mutate its arguments, choose from the arguments, or return a different exception,
- * but it must return a {@code @}{@link NonNull} value.
- * The choice is between
- *
- * - the previously chosen failed result or {@code null} if none has been chosen
- * (the first argument of the {@code onAttemptFailureOperator})
- * - and the failed result from the most recent attempt (the second argument of the {@code onAttemptFailureOperator}).
- *
- * The result of the {@code onAttemptFailureOperator} does not affect the exception passed to the {@code retryPredicate}.
- *
- * If {@code onAttemptFailureOperator} completes abruptly, then the {@code asyncFunction} cannot be retried and the exception thrown by
- * the {@code onAttemptFailureOperator} is used as a failed result of this {@link RetryingAsyncCallbackSupplier}.
- * @param retryPredicate {@code true} iff another attempt needs to be made. If it completes abruptly,
- * then the {@code asyncFunction} cannot be retried and the exception thrown by the {@code retryPredicate}
- * is used as a failed result of this {@link RetryingAsyncCallbackSupplier}. The {@code retryPredicate} is called not more than once
- * per attempt and only if all the following is true:
- *
- * - {@code onAttemptFailureOperator} completed normally;
- * - the most recent attempt is not known to be the last one.
- *
- * The {@code retryPredicate} accepts this {@link RetryState} and the exception from the most recent attempt,
- * and may mutate the exception. The {@linkplain RetryState} advances to represent the state of a new attempt
- * after (in the happens-before order) testing the {@code retryPredicate}, and only if the predicate completes normally.
+ * @param clientExecutor For {@linkplain ThreadUtil#sleepAsync(Duration, AsyncClientExecutor, SingleResultCallback) delaying} attempts
+ * according to {@link RetryAttemptInfo#getBackoff()}.
+ * @param control The {@link RetryControl} to control the new {@link RetryingAsyncCallbackSupplier}.
* @param asyncFunction The retryable {@link AsyncCallbackSupplier} to be decorated.
*/
public RetryingAsyncCallbackSupplier(
- final RetryState state,
- final BinaryOperator onAttemptFailureOperator,
- final BiPredicate retryPredicate,
+ final AsyncClientExecutor clientExecutor,
+ final RetryControl control,
final AsyncCallbackSupplier asyncFunction) {
- this.state = state;
- this.retryPredicate = retryPredicate;
- this.onAttemptFailureOperator = onAttemptFailureOperator;
+ this.clientExecutor = clientExecutor;
+ this.control = control;
this.asyncFunction = asyncFunction;
}
@Override
public void get(final SingleResultCallback callback) {
- /* `asyncFunction` and `callback` are the only externally provided pieces of code for which we do not need to care about
- * them throwing exceptions. If they do, that violates their contract and there is nothing we should do about it. */
- asyncFunction.get(new RetryingCallback(callback));
- }
-
- /**
- * This callback is allowed to be completed more than once.
- */
- @NotThreadSafe
- private class RetryingCallback implements SingleResultCallback {
- private final SingleResultCallback wrapped;
-
- RetryingCallback(final SingleResultCallback callback) {
- wrapped = callback;
- }
-
- @Override
- public void onResult(@Nullable final R result, @Nullable final Throwable t) {
- if (t != null) {
- try {
- state.advanceOrThrow(t, onAttemptFailureOperator, retryPredicate);
- } catch (Throwable failedResult) {
- wrapped.onResult(null, failedResult);
- return;
+ MutableValue> asyncFunctionSuccessfulResult = new MutableValue<>();
+ beginAsync().thenRunWhileLoop(() -> asyncFunctionSuccessfulResult.getNullable() == null, iterationCallback -> {
+ beginAsync().thenSupply(asyncFunctionCallback -> {
+ asyncFunction.get(asyncFunctionCallback);
+ }).thenConsume((attemptSuccessfulResult, onAttemptSuccessCallback) -> {
+ // `attemptSuccessfulResult` may be `null`, so we have to wrap it in `MutableValue` for the while check to notice it
+ asyncFunctionSuccessfulResult.set(new MutableValue<>(attemptSuccessfulResult));
+ onAttemptSuccessCallback.complete(onAttemptSuccessCallback);
+ }).onErrorIf(e -> true, (attemptFailedResult, onAttemptFailureCallback) -> {
+ if (attemptFailedResult instanceof Error) {
+ control.advanceOrThrow(attemptFailedResult);
+ fail("Must not be reached");
+ } else {
+ RetryAttemptInfo retryAttemptInfo = control.advanceOrThrow(attemptFailedResult);
+ sleepAsync(retryAttemptInfo.getBackoff(), clientExecutor, onAttemptFailureCallback);
}
- asyncFunction.get(this);
- } else {
- wrapped.onResult(result, null);
- }
- }
+ }).finish(iterationCallback);
+ }).thenSupply(c -> {
+ c.complete(asyncFunctionSuccessfulResult.get().getNullable());
+ }).finish(callback);
}
}
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/RetryingSyncSupplier.java b/driver-core/src/main/com/mongodb/internal/async/function/RetryingSyncSupplier.java
index ad3e4b2b807..fe768a48ae9 100644
--- a/driver-core/src/main/com/mongodb/internal/async/function/RetryingSyncSupplier.java
+++ b/driver-core/src/main/com/mongodb/internal/async/function/RetryingSyncSupplier.java
@@ -16,60 +16,50 @@
package com.mongodb.internal.async.function;
import com.mongodb.annotations.NotThreadSafe;
+import com.mongodb.internal.async.function.RetryPolicy.Decision.RetryAttemptInfo;
+import com.mongodb.internal.thread.AsyncClientExecutor;
+import com.mongodb.lang.Nullable;
-import java.util.function.BiPredicate;
-import java.util.function.BinaryOperator;
import java.util.function.Supplier;
+import static com.mongodb.assertions.Assertions.fail;
+import static com.mongodb.internal.thread.ThreadUtil.sleep;
+
/**
* A decorator that implements automatic retrying of failed executions of a {@link Supplier}.
* {@link RetryingSyncSupplier} may execute the original retryable function multiple times sequentially.
*
- * The original function may additionally observe or control retrying via {@link RetryState}.
- * For example, the {@link RetryState#breakAndThrowIfRetryAnd(Supplier)} method may be used to
- * break retrying if the original function decides so.
- *
- *
This class is not part of the public API and may be removed or changed at any time
+ * The original function may additionally observe or control the retry loop via {@link RetryControl}.
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
*
* @see RetryingAsyncCallbackSupplier
*/
@NotThreadSafe
public final class RetryingSyncSupplier implements Supplier {
- private final RetryState state;
- private final BiPredicate retryPredicate;
- private final BinaryOperator onAttemptFailureOperator;
+ private final RetryControl control;
private final Supplier syncFunction;
/**
- * See {@link RetryingAsyncCallbackSupplier#RetryingAsyncCallbackSupplier(RetryState, BinaryOperator, BiPredicate, AsyncCallbackSupplier)}
- * for the documentation of the parameters.
- *
- * @param onAttemptFailureOperator Even though the {@code onAttemptFailureOperator} accepts {@link Throwable},
- * only {@link RuntimeException}s are passed to it.
- * @param retryPredicate Even though the {@code retryPredicate} accepts {@link Throwable},
- * only {@link RuntimeException}s are passed to it.
+ * See {@link RetryingAsyncCallbackSupplier#RetryingAsyncCallbackSupplier(AsyncClientExecutor, RetryControl, AsyncCallbackSupplier)}.
*/
- public RetryingSyncSupplier(
- final RetryState state,
- final BinaryOperator onAttemptFailureOperator,
- final BiPredicate retryPredicate,
- final Supplier syncFunction) {
- this.state = state;
- this.retryPredicate = retryPredicate;
- this.onAttemptFailureOperator = onAttemptFailureOperator;
+ public RetryingSyncSupplier(final RetryControl control, final Supplier syncFunction) {
+ this.control = control;
this.syncFunction = syncFunction;
}
@Override
+ @Nullable
public R get() {
while (true) {
try {
return syncFunction.get();
- } catch (RuntimeException attemptException) {
- state.advanceOrThrow(attemptException, onAttemptFailureOperator, retryPredicate);
- } catch (Exception attemptException) {
- // wrap potential sneaky / Kotlin exceptions
- state.advanceOrThrow(new RuntimeException(attemptException), onAttemptFailureOperator, retryPredicate);
+ } catch (Error attemptFailedResult) {
+ control.advanceOrThrow(attemptFailedResult);
+ fail("Must not be reached");
+ } catch (Throwable attemptFailedResult) {
+ RetryAttemptInfo retryAttemptInfo = control.advanceOrThrow(attemptFailedResult);
+ sleep(retryAttemptInfo.getBackoff());
}
}
}
diff --git a/driver-core/src/main/com/mongodb/internal/async/function/package-info.java b/driver-core/src/main/com/mongodb/internal/async/function/package-info.java
index 2a89dc73a54..1b289f3d5bf 100644
--- a/driver-core/src/main/com/mongodb/internal/async/function/package-info.java
+++ b/driver-core/src/main/com/mongodb/internal/async/function/package-info.java
@@ -17,7 +17,6 @@
/**
* This package contains internal functionality that may change at any time.
*/
-
@Internal
@NonNullApi
package com.mongodb.internal.async.function;
diff --git a/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBson.java b/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBson.java
index 278f7e273be..43a06911785 100644
--- a/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBson.java
+++ b/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBson.java
@@ -32,10 +32,10 @@
/**
* A {@link Bson} that allows constructing new instances via {@link #newAppended(String, Object)} instead of mutating {@code this}.
* See {@link #AbstractConstructibleBson(Bson, Document)} for the note on mutability.
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
*
- *
This class is not part of the public API and may be removed or changed at any time
- *
- * @param A type introduced by the concrete class that extends this abstract class.
+ * @param Self. The type introduced by a subclass of {@link AbstractConstructibleBson}.
* @see AbstractConstructibleBsonElement
*/
public abstract class AbstractConstructibleBson> implements Bson, ToMap {
diff --git a/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBsonElement.java b/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBsonElement.java
index b6ef3391430..43c209bf821 100644
--- a/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBsonElement.java
+++ b/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBsonElement.java
@@ -35,10 +35,10 @@
* A {@link Bson} that contains exactly one name/value pair
* and allows constructing new instances via {@link #newWithAppendedValue(String, Object)} instead of mutating {@code this}.
* The value must itself be a {@code Bson}.
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
*
- *
This class is not part of the public API and may be removed or changed at any time
- *
- * @param A type introduced by the concrete class that extends this abstract class.
+ * @param Self. The type introduced by a subclass of {@link AbstractConstructibleBsonElement}.
* @see AbstractConstructibleBson
*/
public abstract class AbstractConstructibleBsonElement> implements Bson, ToMap {
diff --git a/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStream.java b/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStream.java
index c60981c115e..f9939ae66d3 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStream.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStream.java
@@ -19,8 +19,10 @@
import com.mongodb.MongoSocketException;
import com.mongodb.MongoSocketOpenException;
import com.mongodb.ServerAddress;
+import com.mongodb.annotations.ThreadSafe;
import com.mongodb.connection.AsyncCompletionHandler;
import com.mongodb.connection.SocketSettings;
+import com.mongodb.internal.VisibleForTesting;
import com.mongodb.lang.Nullable;
import com.mongodb.spi.dns.InetAddressResolver;
@@ -38,6 +40,7 @@
import java.util.concurrent.atomic.AtomicReference;
import static com.mongodb.assertions.Assertions.isTrue;
+import static com.mongodb.internal.VisibleForTesting.AccessModifier.PRIVATE;
import static com.mongodb.internal.connection.ServerAddressHelper.getSocketAddresses;
/**
@@ -47,24 +50,24 @@ public final class AsynchronousSocketChannelStream extends AsynchronousChannelSt
private final ServerAddress serverAddress;
private final InetAddressResolver inetAddressResolver;
private final SocketSettings settings;
- @Nullable
- private final AsynchronousChannelGroup group;
+ private final AsynchronousSocketChannelOpener channelOpener;
+ @VisibleForTesting(otherwise = PRIVATE)
AsynchronousSocketChannelStream(
final ServerAddress serverAddress, final InetAddressResolver inetAddressResolver,
final SocketSettings settings, final PowerOfTwoBufferPool bufferProvider) {
- this(serverAddress, inetAddressResolver, settings, bufferProvider, null);
+ this(serverAddress, inetAddressResolver, settings, bufferProvider, AsynchronousSocketChannel::open);
}
- public AsynchronousSocketChannelStream(
+ AsynchronousSocketChannelStream(
final ServerAddress serverAddress, final InetAddressResolver inetAddressResolver,
final SocketSettings settings, final PowerOfTwoBufferPool bufferProvider,
- @Nullable final AsynchronousChannelGroup group) {
+ final AsynchronousSocketChannelOpener channelOpener) {
super(serverAddress, settings, bufferProvider);
this.serverAddress = serverAddress;
this.inetAddressResolver = inetAddressResolver;
this.settings = settings;
- this.group = group;
+ this.channelOpener = channelOpener;
}
@Override
@@ -89,10 +92,7 @@ private void initializeSocketChannel(final AsyncCompletionHandler handler,
SocketAddress socketAddress = socketAddressQueue.poll();
try {
- AsynchronousSocketChannel attemptConnectionChannel;
- attemptConnectionChannel = group == null
- ? AsynchronousSocketChannel.open()
- : AsynchronousSocketChannel.open(group);
+ AsynchronousSocketChannel attemptConnectionChannel = channelOpener.open();
attemptConnectionChannel.setOption(StandardSocketOptions.TCP_NODELAY, true);
attemptConnectionChannel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
if (settings.getReceiveBufferSize() > 0) {
@@ -207,4 +207,15 @@ public void close() throws IOException {
channel.close();
}
}
+
+ /**
+ * An implementation must be thread-safe.
+ */
+ @ThreadSafe
+ interface AsynchronousSocketChannelOpener {
+ /**
+ * See {@link AsynchronousSocketChannel#open(AsynchronousChannelGroup)}.
+ */
+ AsynchronousSocketChannel open() throws IOException;
+ }
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStreamFactory.java b/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStreamFactory.java
index 1ea15abe59d..7dfbe2097cc 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStreamFactory.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStreamFactory.java
@@ -19,13 +19,15 @@
import com.mongodb.ServerAddress;
import com.mongodb.connection.SocketSettings;
import com.mongodb.connection.SslSettings;
-import com.mongodb.lang.Nullable;
+import com.mongodb.internal.VisibleForTesting;
+import com.mongodb.internal.connection.AsynchronousSocketChannelStream.AsynchronousSocketChannelOpener;
import com.mongodb.spi.dns.InetAddressResolver;
-import java.nio.channels.AsynchronousChannelGroup;
+import java.nio.channels.AsynchronousSocketChannel;
import static com.mongodb.assertions.Assertions.assertFalse;
import static com.mongodb.assertions.Assertions.notNull;
+import static com.mongodb.internal.VisibleForTesting.AccessModifier.PRIVATE;
/**
* Factory to create a Stream that's an AsynchronousSocketChannelStream. Throws an exception if SSL is enabled.
@@ -34,34 +36,28 @@ public class AsynchronousSocketChannelStreamFactory implements StreamFactory {
private final PowerOfTwoBufferPool bufferProvider = PowerOfTwoBufferPool.DEFAULT;
private final SocketSettings settings;
private final InetAddressResolver inetAddressResolver;
- @Nullable
- private final AsynchronousChannelGroup group;
+ private final AsynchronousSocketChannelOpener channelOpener;
- /**
- * Create a new factory with the default {@code BufferProvider} and {@code AsynchronousChannelGroup}.
- *
- * @param settings the settings for the connection to a MongoDB server
- * @param sslSettings the settings for connecting via SSL
- */
+ @VisibleForTesting(otherwise = PRIVATE)
public AsynchronousSocketChannelStreamFactory(
final InetAddressResolver inetAddressResolver, final SocketSettings settings,
final SslSettings sslSettings) {
- this(inetAddressResolver, settings, sslSettings, null);
+ this(inetAddressResolver, settings, sslSettings, AsynchronousSocketChannel::open);
}
AsynchronousSocketChannelStreamFactory(
final InetAddressResolver inetAddressResolver, final SocketSettings settings,
- final SslSettings sslSettings, @Nullable final AsynchronousChannelGroup group) {
+ final SslSettings sslSettings, final AsynchronousSocketChannelOpener channelOpener) {
assertFalse(sslSettings.isEnabled());
this.inetAddressResolver = inetAddressResolver;
this.settings = notNull("settings", settings);
- this.group = group;
+ this.channelOpener = channelOpener;
}
@Override
public Stream create(final ServerAddress serverAddress) {
return new AsynchronousSocketChannelStream(
- serverAddress, inetAddressResolver, settings, bufferProvider, group);
+ serverAddress, inetAddressResolver, settings, bufferProvider, channelOpener);
}
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStreamFactoryFactory.java b/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStreamFactoryFactory.java
index 8c5a8f654c5..e63492e5dbe 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStreamFactoryFactory.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/AsynchronousSocketChannelStreamFactoryFactory.java
@@ -16,12 +16,25 @@
package com.mongodb.internal.connection;
+import com.mongodb.MongoClientException;
+import com.mongodb.connection.AsyncTransportSettings;
import com.mongodb.connection.SocketSettings;
import com.mongodb.connection.SslSettings;
+import com.mongodb.internal.VisibleForTesting;
+import com.mongodb.internal.thread.DaemonThreadFactory;
+import com.mongodb.internal.thread.MongoThreadPoolExecutor;
import com.mongodb.lang.Nullable;
import com.mongodb.spi.dns.InetAddressResolver;
+import java.io.IOException;
import java.nio.channels.AsynchronousChannelGroup;
+import java.nio.channels.AsynchronousSocketChannel;
+import java.time.Duration;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.SynchronousQueue;
+
+import static com.mongodb.internal.VisibleForTesting.AccessModifier.PRIVATE;
/**
* A {@code StreamFactoryFactory} implementation for AsynchronousSocketChannel-based streams.
@@ -30,30 +43,59 @@
*/
public final class AsynchronousSocketChannelStreamFactoryFactory implements StreamFactoryFactory {
private final InetAddressResolver inetAddressResolver;
- @Nullable
private final AsynchronousChannelGroup group;
+ private final ExecutorService ownedExecutorService;
- public AsynchronousSocketChannelStreamFactoryFactory(final InetAddressResolver inetAddressResolver) {
+ @VisibleForTesting(otherwise = PRIVATE)
+ AsynchronousSocketChannelStreamFactoryFactory(final InetAddressResolver inetAddressResolver) {
this(inetAddressResolver, null);
}
+ /**
+ * @param applicationSuppliedOwnedExecutorService Owned {@link ExecutorService} from {@link AsyncTransportSettings#getExecutorService()}.
+ */
AsynchronousSocketChannelStreamFactoryFactory(
final InetAddressResolver inetAddressResolver,
- @Nullable final AsynchronousChannelGroup group) {
+ @Nullable final ExecutorService applicationSuppliedOwnedExecutorService) {
this.inetAddressResolver = inetAddressResolver;
- this.group = group;
+ try {
+ if (applicationSuppliedOwnedExecutorService == null) {
+ // We try to create a group similarly to how
+ // the system-wide default `AsynchronousChannelGroup` is created.
+ // This means:
+ // - creating the executor similarly to `Executors.newCachedThreadPool`;
+ // - creating the group via `withCachedThreadPool`;
+ // - requesting the implementation specific default by passing negative `initialSize`.
+ ownedExecutorService = new MongoThreadPoolExecutor(
+ 0, Integer.MAX_VALUE, Duration.ofSeconds(60), new SynchronousQueue<>(), new DaemonThreadFactory("IOExecutor"));
+ group = AsynchronousChannelGroup.withCachedThreadPool(ownedExecutorService, -1);
+ } else {
+ ownedExecutorService = applicationSuppliedOwnedExecutorService;
+ group = AsynchronousChannelGroup.withThreadPool(ownedExecutorService);
+ }
+ } catch (IOException e) {
+ throw new MongoClientException("Unable to create an asynchronous channel group", e);
+ }
}
@Override
public StreamFactory create(final SocketSettings socketSettings, final SslSettings sslSettings) {
return new AsynchronousSocketChannelStreamFactory(
- inetAddressResolver, socketSettings, sslSettings, group);
+ inetAddressResolver, socketSettings, sslSettings, () -> AsynchronousSocketChannel.open(group));
+ }
+
+ /**
+ * @return The {@link ExecutorService} used by the {@link StreamFactory} created via {@link #create(SocketSettings, SslSettings)}.
+ * It may be provided by an application via {@link AsyncTransportSettings#getExecutorService()}.
+ */
+ @Override
+ public Executor getExecutor() {
+ return ownedExecutorService;
}
@Override
public void close() {
- if (group != null) {
- group.shutdown();
- }
+ // termination of the `group` results in the orderly shutdown of the `ownedExecutorService`
+ group.shutdown();
}
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/BackpressureErrorLabeler.java b/driver-core/src/main/com/mongodb/internal/connection/BackpressureErrorLabeler.java
new file mode 100644
index 00000000000..ec14c941896
--- /dev/null
+++ b/driver-core/src/main/com/mongodb/internal/connection/BackpressureErrorLabeler.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.internal.connection;
+
+import com.mongodb.MongoException;
+import com.mongodb.MongoSocketException;
+import com.mongodb.MongoSocksProxyException;
+
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLProtocolException;
+import java.net.UnknownHostException;
+import java.security.cert.CertPathBuilderException;
+import java.security.cert.CertPathValidatorException;
+import java.security.cert.CertificateException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * Attaches {@link MongoException#SYSTEM_OVERLOADED_ERROR_LABEL} and
+ * {@link MongoException#RETRYABLE_ERROR_LABEL} to network errors encountered during connection
+ * establishment or the hello message, per the CMAP specification.
+ *
+ * This is topology-agnostic: it must be invoked from the connection-establishment path so that
+ * both default SDAM and load-balanced modes are covered.
+ */
+final class BackpressureErrorLabeler {
+
+ /**
+ * BouncyCastle TLS fatal-alert exception type names.
+ */
+ private static final Set BOUNCY_CASTLE_TLS_FATAL_TYPE_NAMES = Collections.unmodifiableSet(
+ new HashSet<>(Arrays.asList(
+ "org.bouncycastle.tls.TlsFatalAlert",
+ "org.bouncycastle.tls.TlsFatalAlertReceived",
+ "org.bouncycastle.tls.crypto.TlsCryptoException")));
+
+ /**
+ * RFC 5246 / RFC 8446 alert descriptions that surface in BouncyCastle TLS exception messages.
+ * See AlertDescription.java.
+ * See (TLS) Protocol Version 1.2 - Alert Protocol.
+ */
+ private static final Set BOUNCY_CASTLE_TLS_ALERT_DESCRIPTIONS = Collections.unmodifiableSet(
+ new HashSet<>(Arrays.asList(
+ "close_notify", "unexpected_message", "bad_record_mac", "decryption_failed",
+ "record_overflow", "decompression_failure", "handshake_failure", "no_certificate",
+ "bad_certificate", "unsupported_certificate", "certificate_revoked", "certificate_expired",
+ "certificate_unknown", "illegal_parameter", "unknown_ca", "access_denied",
+ "decode_error", "decrypt_error", "export_restriction", "protocol_version",
+ "insufficient_security", "internal_error", "no_renegotiation", "unsupported_extension",
+ "certificate_unobtainable", "unrecognized_name", "bad_certificate_status_response",
+ "bad_certificate_hash_value", "unknown_psk_identity", "no_application_protocol",
+ "inappropriate_fallback", "missing_extension", "certificate_required")));
+
+ private BackpressureErrorLabeler() {
+ }
+
+ static void applyLabelsIfEligible(final Throwable t) {
+ if (!(t instanceof MongoSocketException)) {
+ return;
+ }
+ MongoSocketException socketException = (MongoSocketException) t;
+ if (isSocksFailureNotEligibleForLabeling(socketException)) {
+ return;
+ }
+ if (isDnsLookupFailure(socketException)) {
+ return;
+ }
+ if (isTlsConfigurationError(socketException)) {
+ return;
+ }
+ socketException.addLabel(MongoException.SYSTEM_OVERLOADED_ERROR_LABEL);
+ socketException.addLabel(MongoException.RETRYABLE_ERROR_LABEL);
+ }
+
+ private static boolean isSocksFailureNotEligibleForLabeling(final MongoSocketException t) {
+ if (!(t instanceof MongoSocksProxyException)) {
+ return false;
+ }
+ Integer replyCode = ((MongoSocksProxyException) t).getProxyReplyCode();
+ if (replyCode == null) {
+ return true;
+ }
+ return replyCode != SocksSocket.ServerReply.NET_UNREACHABLE.getReplyNumber()
+ && replyCode != SocksSocket.ServerReply.HOST_UNREACHABLE.getReplyNumber()
+ && replyCode != SocksSocket.ServerReply.CONN_REFUSED.getReplyNumber();
+ }
+
+ private static boolean isDnsLookupFailure(final MongoSocketException t) {
+ Throwable cause = t.getCause();
+ while (cause != null) {
+ if (cause instanceof UnknownHostException) {
+ return true;
+ }
+ cause = cause.getCause();
+ }
+ return false;
+ }
+
+ private static boolean isTlsConfigurationError(final MongoSocketException t) {
+ Throwable cause = t.getCause();
+ while (cause != null) {
+ if (cause instanceof CertificateException
+ || cause instanceof CertPathBuilderException
+ || cause instanceof CertPathValidatorException
+ || cause instanceof SSLPeerUnverifiedException
+ || cause instanceof SSLProtocolException) {
+ return true;
+ }
+ if (cause instanceof SSLHandshakeException) {
+ String message = cause.getMessage();
+ if (message != null) {
+ String lowerMessage = message.toLowerCase(Locale.ROOT);
+ if (lowerMessage.contains("verify")
+ || lowerMessage.contains("protocol")
+ || lowerMessage.contains("cipher")
+ || lowerMessage.contains("received fatal alert")) {
+ return true;
+ }
+ }
+ }
+ if (isBouncyCastleTlsError(cause)) {
+ return true;
+ }
+
+ cause = cause.getCause();
+ }
+ return false;
+ }
+
+ private static boolean isBouncyCastleTlsError(final Throwable cause) {
+ if (!isBouncyCastleTlsFatalType(cause.getClass())) {
+ return false;
+ }
+ String message = cause.getMessage();
+ if (message == null) {
+ return false;
+ }
+ String description = message.toLowerCase(Locale.ROOT);
+ for (String alertName : BOUNCY_CASTLE_TLS_ALERT_DESCRIPTIONS) {
+ if (description.contains(alertName)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Walks the class hierarchy comparing fully qualified names so a subclass of a known BC type
+ * still matches.
+ */
+ private static boolean isBouncyCastleTlsFatalType(final Class exceptionClass) {
+ Class cls = exceptionClass;
+ while (cls != null) {
+ if (BOUNCY_CASTLE_TLS_FATAL_TYPE_NAMES.contains(cls.getName())) {
+ return true;
+ }
+ cls = cls.getSuperclass();
+ }
+ return false;
+ }
+}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/BaseCluster.java b/driver-core/src/main/com/mongodb/internal/connection/BaseCluster.java
index 4146d06c22e..2f0fcaa6379 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/BaseCluster.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/BaseCluster.java
@@ -113,9 +113,9 @@ abstract class BaseCluster implements Cluster {
private volatile ClusterDescription description;
BaseCluster(final ClusterId clusterId,
- final ClusterSettings settings,
- final ClusterableServerFactory serverFactory,
- final ClientMetadata clientMetadata) {
+ final ClusterSettings settings,
+ final ClusterableServerFactory serverFactory,
+ final ClientMetadata clientMetadata) {
this.clusterId = notNull("clusterId", clusterId);
this.settings = notNull("settings", settings);
this.serverFactory = notNull("serverFactory", serverFactory);
@@ -159,7 +159,7 @@ public ServerTuple selectServer(final ServerSelector serverSelector, final Opera
if (serverTuple != null) {
ServerAddress serverAddress = serverTuple.getServerDescription().getAddress();
logServerSelectionSucceeded(operationContext, clusterId, serverAddress, serverSelector, currentDescription);
- serverDeprioritization.updateCandidate(serverAddress);
+ serverDeprioritization.updateCandidate(serverAddress, currentDescription.getType());
return serverTuple;
}
computedServerSelectionTimeout.onExpired(() ->
@@ -302,7 +302,7 @@ private boolean handleServerSelectionRequest(
if (serverTuple != null) {
ServerAddress serverAddress = serverTuple.getServerDescription().getAddress();
logServerSelectionSucceeded(operationContext, clusterId, serverAddress, request.originalSelector, description);
- serverDeprioritization.updateCandidate(serverAddress);
+ serverDeprioritization.updateCandidate(serverAddress, description.getType());
request.onResult(serverTuple, null);
return true;
}
@@ -361,8 +361,7 @@ private static ServerSelector getCompleteServerSelector(
final ClusterSettings settings) {
List selectors = Stream.of(
getRaceConditionPreFilteringSelector(serversSnapshot),
- serverSelector,
- serverDeprioritization.getServerSelector(),
+ serverDeprioritization.apply(serverSelector),
settings.getServerSelector(), // may be null
new LatencyMinimizingServerSelector(settings.getLocalThreshold(MILLISECONDS), MILLISECONDS),
AtMostTwoRandomServerSelector.instance(),
diff --git a/driver-core/src/main/com/mongodb/internal/connection/ClusterClockAdvancingSessionContext.java b/driver-core/src/main/com/mongodb/internal/connection/ClusterClockAdvancingSessionContext.java
index 0b297e4b4e3..8a8240d4c71 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/ClusterClockAdvancingSessionContext.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/ClusterClockAdvancingSessionContext.java
@@ -17,6 +17,7 @@
package com.mongodb.internal.connection;
import com.mongodb.ReadConcern;
+import com.mongodb.internal.session.BaseClientSessionImpl.OverloadRetryPolicyState;
import com.mongodb.internal.session.SessionContext;
import com.mongodb.lang.Nullable;
import org.bson.BsonDocument;
@@ -136,4 +137,9 @@ public void markSessionDirty() {
public boolean isSessionMarkedDirty() {
return wrapped.isSessionMarkedDirty();
}
+
+ @Override
+ public OverloadRetryPolicyState getOverloadRetryPolicyState() {
+ return wrapped.getOverloadRetryPolicyState();
+ }
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/CommandMessage.java b/driver-core/src/main/com/mongodb/internal/connection/CommandMessage.java
index 348349fd18c..78cc03ea76b 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/CommandMessage.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/CommandMessage.java
@@ -344,12 +344,12 @@ private List getExtraElements(final OperationContext operationConte
extraElements.add(new BsonElement("lsid", sessionContext.getSessionId()));
}
}
- boolean firstMessageInTransaction = sessionContext.notifyMessageSent();
+ boolean startTransaction = sessionContext.notifyMessageSent();
assertFalse(sessionContext.hasActiveTransaction() && sessionContext.isSnapshot());
if (sessionContext.hasActiveTransaction()) {
extraElements.add(new BsonElement("txnNumber", new BsonInt64(sessionContext.getTransactionNumber())));
- if (firstMessageInTransaction) {
+ if (startTransaction) {
extraElements.add(new BsonElement("startTransaction", BsonBoolean.TRUE));
addReadConcernDocument(extraElements, sessionContext);
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/DefaultClusterFactory.java b/driver-core/src/main/com/mongodb/internal/connection/DefaultClusterFactory.java
index ac853cb002e..668af7119c3 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/DefaultClusterFactory.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/DefaultClusterFactory.java
@@ -35,6 +35,7 @@
import com.mongodb.internal.VisibleForTesting;
import com.mongodb.internal.diagnostics.logging.Logger;
import com.mongodb.internal.diagnostics.logging.Loggers;
+import com.mongodb.internal.thread.AsyncClientExecutor;
import com.mongodb.lang.Nullable;
import com.mongodb.spi.dns.DnsClient;
@@ -65,6 +66,7 @@ public Cluster createCluster(final ClusterSettings originalClusterSettings, fina
final StreamFactory streamFactory,
final TimeoutSettings heartbeatTimeoutSettings,
final StreamFactory heartbeatStreamFactory,
+ final AsyncClientExecutor clientExecutor,
@Nullable final MongoCredential credential,
final LoggerSettings loggerSettings,
@Nullable final CommandListener commandListener,
@@ -103,9 +105,9 @@ public Cluster createCluster(final ClusterSettings originalClusterSettings, fina
DnsSrvRecordMonitorFactory dnsSrvRecordMonitorFactory = new DefaultDnsSrvRecordMonitorFactory(clusterId, serverSettings, dnsClient);
InternalOperationContextFactory clusterOperationContextFactory =
- new InternalOperationContextFactory(clusterTimeoutSettings, serverApi);
+ new InternalOperationContextFactory(clusterTimeoutSettings, serverApi, clientExecutor);
InternalOperationContextFactory heartBeatOperationContextFactory =
- new InternalOperationContextFactory(heartbeatTimeoutSettings, serverApi);
+ new InternalOperationContextFactory(heartbeatTimeoutSettings, serverApi, clientExecutor);
ClientMetadata clientMetadata = new ClientMetadata(
applicationName,
diff --git a/driver-core/src/main/com/mongodb/internal/connection/DefaultConnectionPool.java b/driver-core/src/main/com/mongodb/internal/connection/DefaultConnectionPool.java
index 2339cf18b86..a0a8bbe6e2d 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/DefaultConnectionPool.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/DefaultConnectionPool.java
@@ -894,7 +894,7 @@ public boolean shouldPrune(final UsageTrackingInternalConnection usageTrackingCo
/**
* Package-access methods are thread-safe,
- * and only they should be called outside of the {@link OpenConcurrencyLimiter}'s code.
+ * and only they should be called outside the {@link OpenConcurrencyLimiter}'s code.
*/
@ThreadSafe
private final class OpenConcurrencyLimiter {
@@ -1334,7 +1334,6 @@ private boolean initUnlessClosed() {
* {@linkplain Task#failAsClosed() fail} asynchronously.
*/
@Override
- @SuppressWarnings("try")
public void close() {
withLock(lock, () -> {
if (state != State.CLOSED) {
diff --git a/driver-core/src/main/com/mongodb/internal/connection/DefaultSdamServerDescriptionManager.java b/driver-core/src/main/com/mongodb/internal/connection/DefaultSdamServerDescriptionManager.java
index af4acd8c031..371e709d807 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/DefaultSdamServerDescriptionManager.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/DefaultSdamServerDescriptionManager.java
@@ -137,6 +137,9 @@ private void handleException(final SdamIssue sdamIssue, final boolean beforeHand
serverMonitor.connect();
} else if (sdamIssue.relatedToNetworkNotTimeout()
|| (beforeHandshake && (sdamIssue.relatedToNetworkTimeout() || sdamIssue.relatedToAuth()))) {
+ if (sdamIssue.hasSystemOverloadedLabel()) {
+ return;
+ }
updateDescription(sdamIssue.serverDescription());
connectionPool.invalidate(sdamIssue.exception().orElse(null));
serverMonitor.cancelCurrentCheck();
diff --git a/driver-core/src/main/com/mongodb/internal/connection/InternalOperationContextFactory.java b/driver-core/src/main/com/mongodb/internal/connection/InternalOperationContextFactory.java
index 4653c90050b..851ca5a38ca 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/InternalOperationContextFactory.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/InternalOperationContextFactory.java
@@ -18,6 +18,7 @@
import com.mongodb.ServerApi;
import com.mongodb.internal.TimeoutContext;
import com.mongodb.internal.TimeoutSettings;
+import com.mongodb.internal.thread.AsyncClientExecutor;
import com.mongodb.lang.Nullable;
import static com.mongodb.internal.connection.OperationContext.simpleOperationContext;
@@ -27,17 +28,22 @@ public final class InternalOperationContextFactory {
private final TimeoutSettings timeoutSettings;
@Nullable
private final ServerApi serverApi;
+ private final AsyncClientExecutor clientExecutor;
- public InternalOperationContextFactory(final TimeoutSettings timeoutSettings, @Nullable final ServerApi serverApi) {
+ public InternalOperationContextFactory(
+ final TimeoutSettings timeoutSettings,
+ @Nullable final ServerApi serverApi,
+ final AsyncClientExecutor clientExecutor) {
this.timeoutSettings = timeoutSettings;
this.serverApi = serverApi;
+ this.clientExecutor = clientExecutor;
}
/**
* @return a simple operation context without timeoutMS
*/
OperationContext create() {
- return simpleOperationContext(timeoutSettings.connectionOnly(), serverApi);
+ return simpleOperationContext(timeoutSettings.connectionOnly(), serverApi, clientExecutor);
}
/**
diff --git a/driver-core/src/main/com/mongodb/internal/connection/InternalStreamConnection.java b/driver-core/src/main/com/mongodb/internal/connection/InternalStreamConnection.java
index 27de4840633..24c685fcbca 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/InternalStreamConnection.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/InternalStreamConnection.java
@@ -231,9 +231,11 @@ public void open(final OperationContext originalOperationContext) {
isTrue("Open already called", stream == null);
stream = streamFactory.create(serverId.getAddress());
OperationContext operationContext = originalOperationContext;
+ boolean beforeHandshake = true;
try {
stream.open(operationContext);
InternalConnectionInitializationDescription initializationDescription = connectionInitializer.startHandshake(this, operationContext);
+ beforeHandshake = false;
operationContext = operationContext.withOverride(TimeoutContext::withNewlyStartedMaintenanceTimeout);
initAfterHandshakeStart(initializationDescription);
@@ -242,6 +244,9 @@ public void open(final OperationContext originalOperationContext) {
initAfterHandshakeFinish(initializationDescription);
} catch (Throwable t) {
close();
+ if (beforeHandshake) {
+ BackpressureErrorLabeler.applyLabelsIfEligible(t);
+ }
if (t instanceof MongoException) {
throw (MongoException) t;
} else {
@@ -264,6 +269,7 @@ public void completed(@Nullable final Void aVoid) {
(initialResult, initialException) -> {
if (initialException != null) {
close();
+ BackpressureErrorLabeler.applyLabelsIfEligible(initialException);
callback.onResult(null, initialException);
} else {
assertNotNull(initialResult);
@@ -279,11 +285,13 @@ public void completed(@Nullable final Void aVoid) {
@Override
public void failed(final Throwable t) {
close();
+ BackpressureErrorLabeler.applyLabelsIfEligible(t);
callback.onResult(null, t);
}
});
} catch (Throwable t) {
close();
+ BackpressureErrorLabeler.applyLabelsIfEligible(t);
callback.onResult(null, t);
}
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/InternalStreamConnectionInitializer.java b/driver-core/src/main/com/mongodb/internal/connection/InternalStreamConnectionInitializer.java
index 574a85669d0..36f6688cb0e 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/InternalStreamConnectionInitializer.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/InternalStreamConnectionInitializer.java
@@ -172,7 +172,8 @@ private InternalConnectionInitializationDescription createInitializationDescript
private BsonDocument createHelloCommand(final Authenticator authenticator, final InternalConnection connection) {
BsonDocument helloCommandDocument = new BsonDocument(getHandshakeCommandName(), new BsonInt32(1))
- .append("helloOk", BsonBoolean.TRUE);
+ .append("helloOk", BsonBoolean.TRUE)
+ .append("backpressure", BsonBoolean.TRUE);
if (clientMetadataDocument != null) {
helloCommandDocument.append("client", clientMetadataDocument);
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/NoOpSessionContext.java b/driver-core/src/main/com/mongodb/internal/connection/NoOpSessionContext.java
index 2b5f7d8ef6c..4e658756f95 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/NoOpSessionContext.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/NoOpSessionContext.java
@@ -17,6 +17,7 @@
package com.mongodb.internal.connection;
import com.mongodb.ReadConcern;
+import com.mongodb.internal.session.BaseClientSessionImpl.OverloadRetryPolicyState;
import com.mongodb.internal.session.SessionContext;
import com.mongodb.lang.Nullable;
import org.bson.BsonDocument;
@@ -133,4 +134,9 @@ public void markSessionDirty() {
public boolean isSessionMarkedDirty() {
return false;
}
+
+ @Override
+ public OverloadRetryPolicyState getOverloadRetryPolicyState() {
+ return OverloadRetryPolicyState.NO_OP;
+ }
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/OidcAuthenticator.java b/driver-core/src/main/com/mongodb/internal/connection/OidcAuthenticator.java
index 3793d5b7a5b..5920bbc8756 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/OidcAuthenticator.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/OidcAuthenticator.java
@@ -135,7 +135,7 @@ private Duration getCallbackTimeout(final TimeoutContext timeoutContext) {
() ->
// we can get here if server selection timeout was set to infinite.
ChronoUnit.FOREVER.getDuration(),
- (renamingMs) -> Duration.ofMillis(renamingMs),
+ (remainingMs) -> Duration.ofMillis(remainingMs),
() -> throwMongoTimeoutException());
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/OperationContext.java b/driver-core/src/main/com/mongodb/internal/connection/OperationContext.java
index f23d5e5226b..cb8d0830dd1 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/OperationContext.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/OperationContext.java
@@ -17,6 +17,7 @@
import com.mongodb.Function;
import com.mongodb.MongoConnectionPoolClearedException;
+import com.mongodb.MongoException;
import com.mongodb.ReadConcern;
import com.mongodb.RequestContext;
import com.mongodb.ServerAddress;
@@ -30,7 +31,9 @@
import com.mongodb.internal.VisibleForTesting;
import com.mongodb.internal.observability.micrometer.Span;
import com.mongodb.internal.observability.micrometer.TracingManager;
+import com.mongodb.internal.operation.OperationHelper;
import com.mongodb.internal.session.SessionContext;
+import com.mongodb.internal.thread.AsyncClientExecutor;
import com.mongodb.lang.Nullable;
import com.mongodb.selector.ServerSelector;
@@ -40,6 +43,9 @@
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
+import static com.mongodb.MongoException.SYSTEM_OVERLOADED_ERROR_LABEL;
+import static com.mongodb.assertions.Assertions.assertFalse;
+import static com.mongodb.internal.VisibleForTesting.AccessModifier.PRIVATE;
import static java.util.stream.Collectors.toList;
/**
@@ -57,19 +63,37 @@ public class OperationContext {
private final ServerApi serverApi;
@Nullable
private final String operationName;
+ private final AsyncClientExecutor clientExecutor;
@Nullable
private Span tracingSpan;
+ @VisibleForTesting(otherwise = PRIVATE)
public OperationContext(final RequestContext requestContext, final SessionContext sessionContext, final TimeoutContext timeoutContext,
@Nullable final ServerApi serverApi) {
- this(requestContext, sessionContext, timeoutContext, TracingManager.NO_OP, serverApi, null);
+ this(requestContext, sessionContext, timeoutContext, AsyncClientExecutor.NO_OP, TracingManager.NO_OP, serverApi, null);
}
public OperationContext(final RequestContext requestContext, final SessionContext sessionContext, final TimeoutContext timeoutContext,
+ final AsyncClientExecutor clientExecutor,
final TracingManager tracingManager,
@Nullable final ServerApi serverApi,
@Nullable final String operationName) {
this(NEXT_ID.incrementAndGet(), requestContext, sessionContext, timeoutContext, new ServerDeprioritization(),
+ clientExecutor,
+ tracingManager,
+ serverApi,
+ operationName,
+ null);
+ }
+
+ public OperationContext(final RequestContext requestContext, final SessionContext sessionContext, final TimeoutContext timeoutContext,
+ final AsyncClientExecutor clientExecutor,
+ final TracingManager tracingManager,
+ @Nullable final ServerApi serverApi,
+ @Nullable final String operationName,
+ final ServerDeprioritization serverDeprioritization) {
+ this(NEXT_ID.incrementAndGet(), requestContext, sessionContext, timeoutContext, serverDeprioritization,
+ clientExecutor,
tracingManager,
serverApi,
operationName,
@@ -77,40 +101,45 @@ public OperationContext(final RequestContext requestContext, final SessionContex
}
public static OperationContext simpleOperationContext(
- final TimeoutSettings timeoutSettings, @Nullable final ServerApi serverApi) {
+ final TimeoutSettings timeoutSettings, @Nullable final ServerApi serverApi, final AsyncClientExecutor clientExecutor) {
return new OperationContext(
IgnorableRequestContext.INSTANCE,
NoOpSessionContext.INSTANCE,
new TimeoutContext(timeoutSettings),
+ clientExecutor,
TracingManager.NO_OP,
serverApi,
- null
- );
+ null);
}
- public static OperationContext simpleOperationContext(final TimeoutContext timeoutContext) {
- return new OperationContext(
- IgnorableRequestContext.INSTANCE,
- NoOpSessionContext.INSTANCE,
- timeoutContext,
- TracingManager.NO_OP,
- null,
- null);
+ @VisibleForTesting(otherwise = PRIVATE)
+ static OperationContext simpleOperationContext(final TimeoutSettings timeoutSettings) {
+ return simpleOperationContext(timeoutSettings, null, AsyncClientExecutor.NO_OP);
}
public OperationContext withSessionContext(final SessionContext sessionContext) {
- return new OperationContext(id, requestContext, sessionContext, timeoutContext, serverDeprioritization, tracingManager, serverApi,
- operationName, tracingSpan);
+ return new OperationContext(id, requestContext, sessionContext, timeoutContext, serverDeprioritization, clientExecutor,
+ tracingManager, serverApi, operationName, tracingSpan);
}
public OperationContext withTimeoutContext(final TimeoutContext timeoutContext) {
- return new OperationContext(id, requestContext, sessionContext, timeoutContext, serverDeprioritization, tracingManager, serverApi,
- operationName, tracingSpan);
+ return new OperationContext(id, requestContext, sessionContext, timeoutContext, serverDeprioritization, clientExecutor,
+ tracingManager, serverApi, operationName, tracingSpan);
}
public OperationContext withOperationName(final String operationName) {
- return new OperationContext(id, requestContext, sessionContext, timeoutContext, serverDeprioritization, tracingManager, serverApi,
- operationName, tracingSpan);
+ return new OperationContext(id, requestContext, sessionContext, timeoutContext, serverDeprioritization, clientExecutor,
+ tracingManager, serverApi, operationName, tracingSpan);
+ }
+
+ /**
+ * TODO-JAVA-6058: This method enables overriding the ServerDeprioritization state.
+ * It is a temporary solution to handle cases where deprioritization state persists across operations.
+ */
+ public OperationContext withNewServerDeprioritization() {
+ return new OperationContext(id, requestContext, sessionContext, timeoutContext,
+ new ServerDeprioritization(serverDeprioritization.enableOverloadRetargeting), clientExecutor,
+ tracingManager, serverApi, operationName, tracingSpan);
}
public long getId() {
@@ -143,6 +172,10 @@ public String getOperationName() {
return operationName;
}
+ public AsyncClientExecutor getClientExecutor() {
+ return clientExecutor;
+ }
+
@Nullable
public Span getTracingSpan() {
return tracingSpan;
@@ -152,12 +185,12 @@ public void setTracingSpan(final Span tracingSpan) {
this.tracingSpan = tracingSpan;
}
- @VisibleForTesting(otherwise = VisibleForTesting.AccessModifier.PRIVATE)
- public OperationContext(final long id,
+ private OperationContext(final long id,
final RequestContext requestContext,
final SessionContext sessionContext,
final TimeoutContext timeoutContext,
final ServerDeprioritization serverDeprioritization,
+ final AsyncClientExecutor clientExecutor,
final TracingManager tracingManager,
@Nullable final ServerApi serverApi,
@Nullable final String operationName,
@@ -168,32 +201,13 @@ public OperationContext(final long id,
this.requestContext = requestContext;
this.sessionContext = sessionContext;
this.timeoutContext = timeoutContext;
+ this.clientExecutor = clientExecutor;
this.tracingManager = tracingManager;
this.serverApi = serverApi;
this.operationName = operationName;
this.tracingSpan = tracingSpan;
}
- @VisibleForTesting(otherwise = VisibleForTesting.AccessModifier.PRIVATE)
- public OperationContext(final long id,
- final RequestContext requestContext,
- final SessionContext sessionContext,
- final TimeoutContext timeoutContext,
- final TracingManager tracingManager,
- @Nullable final ServerApi serverApi,
- @Nullable final String operationName) {
- this.id = id;
- this.serverDeprioritization = new ServerDeprioritization();
- this.requestContext = requestContext;
- this.sessionContext = sessionContext;
- this.timeoutContext = timeoutContext;
- this.tracingManager = tracingManager;
- this.serverApi = serverApi;
- this.operationName = operationName;
- this.tracingSpan = null;
- }
-
-
/**
* @return The same {@link ServerDeprioritization} if called on the same {@link OperationContext}.
*/
@@ -217,7 +231,8 @@ public OperationContext withConnectionEstablishmentSessionContext() {
}
public OperationContext withMinRoundTripTime(final ServerDescription serverDescription) {
- return withTimeoutContext(timeoutContext.withMinRoundTripTime(TimeUnit.NANOSECONDS.toMillis(serverDescription.getMinRoundTripTimeNanos())));
+ return withTimeoutContext(
+ timeoutContext.withMinRoundTripTime(TimeUnit.NANOSECONDS.toMillis(serverDescription.getMinRoundTripTimeNanos())));
}
public OperationContext withOverride(final TimeoutContextOverride timeoutContextOverrideFunction) {
@@ -227,34 +242,55 @@ public OperationContext withOverride(final TimeoutContextOverride timeoutContext
public static final class ServerDeprioritization {
@Nullable
private ServerAddress candidate;
+ @Nullable
+ private ClusterType clusterType;
private final Set deprioritized;
- private final DeprioritizingSelector selector;
+ private final boolean enableOverloadRetargeting;
- private ServerDeprioritization() {
- candidate = null;
- deprioritized = new HashSet<>();
- selector = new DeprioritizingSelector();
+ public ServerDeprioritization() {
+ this(false);
+ }
+
+ public ServerDeprioritization(final boolean enableOverloadRetargeting) {
+ this.enableOverloadRetargeting = enableOverloadRetargeting;
+ this.candidate = null;
+ this.deprioritized = new HashSet<>();
+ this.clusterType = null;
}
/**
- * The returned {@link ServerSelector} tries to {@linkplain ServerSelector#select(ClusterDescription) select}
- * only the {@link ServerDescription}s that do not have deprioritized {@link ServerAddress}es.
- * If no such {@link ServerDescription} can be selected, then it selects {@link ClusterDescription#getServerDescriptions()}.
+ * The returned {@link ServerSelector} wraps the provided selector and attempts
+ * {@linkplain ServerSelector#select(ClusterDescription) server selection} in two passes:
+ *
+ * - First pass: selects using the wrapped selector with only non-deprioritized {@link ServerDescription}s.
+ * - Second pass: if the first pass selects no {@link ServerDescription}s,
+ * selects using the wrapped selector again with all {@link ServerDescription}s, including deprioritized ones.
+ *
*/
- ServerSelector getServerSelector() {
- return selector;
+ ServerSelector apply(final ServerSelector wrappedSelector) {
+ return new DeprioritizingSelector(wrappedSelector);
}
- void updateCandidate(final ServerAddress serverAddress) {
- candidate = serverAddress;
+ void updateCandidate(final ServerAddress serverAddress, final ClusterType clusterType) {
+ this.candidate = serverAddress;
+ this.clusterType = clusterType;
}
- public void onAttemptFailure(final Throwable failure) {
- if (candidate == null || failure instanceof MongoConnectionPoolClearedException) {
+ public void onAttemptFailure(final Throwable attemptFailedResult) {
+ assertFalse(attemptFailedResult instanceof OperationHelper.ResourceSupplierInternalException);
+ if (candidate == null || attemptFailedResult instanceof MongoConnectionPoolClearedException) {
candidate = null;
return;
}
- deprioritized.add(candidate);
+
+ // As per spec: sharded clusters deprioritize on any error,
+ // other topologies deprioritize on overload only when retargeting is enabled.
+ boolean isSystemOverloadedError = attemptFailedResult instanceof MongoException
+ && ((MongoException) attemptFailedResult).hasErrorLabel(SYSTEM_OVERLOADED_ERROR_LABEL);
+
+ if (clusterType == ClusterType.SHARDED || (isSystemOverloadedError && enableOverloadRetargeting)) {
+ deprioritized.add(candidate);
+ }
}
/**
@@ -263,28 +299,46 @@ public void onAttemptFailure(final Throwable failure) {
* which indeed may be used concurrently. {@link DeprioritizingSelector} does not need to be thread-safe.
*/
private final class DeprioritizingSelector implements ServerSelector {
- private DeprioritizingSelector() {
+ private final ServerSelector wrappedSelector;
+
+ private DeprioritizingSelector(final ServerSelector wrappedSelector) {
+ this.wrappedSelector = wrappedSelector;
}
@Override
public List select(final ClusterDescription clusterDescription) {
List serverDescriptions = clusterDescription.getServerDescriptions();
- if (!isEnabled(clusterDescription.getType())) {
- return serverDescriptions;
+
+ // TODO-JAVA-5908: Evaluate whether using the early-return optimization has a meaningful performance impact on server selection.
+ if (serverDescriptions.size() == 1 || deprioritized.isEmpty()) {
+ return wrappedSelector.select(clusterDescription);
}
+
+ // TODO-JAVA-5908: Evaluate whether using a loop instead of Stream has a meaningful performance impact on server selection.
List nonDeprioritizedServerDescriptions = serverDescriptions
.stream()
.filter(serverDescription -> !deprioritized.contains(serverDescription.getAddress()))
.collect(toList());
- return nonDeprioritizedServerDescriptions.isEmpty() ? serverDescriptions : nonDeprioritizedServerDescriptions;
- }
- private boolean isEnabled(final ClusterType clusterType) {
- return clusterType == ClusterType.SHARDED;
+ // TODO-JAVA-5908: Evaluate whether using the early-return optimization has a meaningful performance impact on server selection.
+ if (nonDeprioritizedServerDescriptions.isEmpty()) {
+ return wrappedSelector.select(clusterDescription);
+ }
+
+ List selected = wrappedSelector.select(
+ new ClusterDescription(
+ clusterDescription.getConnectionMode(),
+ clusterDescription.getType(),
+ clusterDescription.getSrvResolutionException(),
+ nonDeprioritizedServerDescriptions,
+ clusterDescription.getClusterSettings(),
+ clusterDescription.getServerSettings()));
+ return selected.isEmpty() ? wrappedSelector.select(clusterDescription) : selected;
}
}
}
- public interface TimeoutContextOverride extends Function {}
+ public interface TimeoutContextOverride extends Function {
+ }
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/OverloadStateSuspendedSessionContext.java b/driver-core/src/main/com/mongodb/internal/connection/OverloadStateSuspendedSessionContext.java
new file mode 100644
index 00000000000..58a1ab814b4
--- /dev/null
+++ b/driver-core/src/main/com/mongodb/internal/connection/OverloadStateSuspendedSessionContext.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.internal.connection;
+
+import com.mongodb.ReadConcern;
+import com.mongodb.internal.session.BaseClientSessionImpl;
+import com.mongodb.internal.session.SessionContext;
+import com.mongodb.lang.Nullable;
+import org.bson.BsonDocument;
+import org.bson.BsonTimestamp;
+
+/**
+ * A {@link SessionContext} decorator that suspends session-scoped overload retry policy state by returning
+ * {@link BaseClientSessionImpl.OverloadRetryPolicyState#NO_OP} from {@link #getOverloadRetryPolicyState()}.
+ * Every other method delegates to the wrapped context.
+ *
+ * This class is not part of the public API and may be removed or changed at any time.
+ */
+public final class OverloadStateSuspendedSessionContext implements SessionContext {
+
+ private final SessionContext wrapped;
+
+ public OverloadStateSuspendedSessionContext(final SessionContext wrapped) {
+ this.wrapped = wrapped;
+ }
+
+ @Override
+ public boolean hasSession() {
+ return wrapped.hasSession();
+ }
+
+ @Override
+ public boolean isImplicitSession() {
+ return wrapped.isImplicitSession();
+ }
+
+ @Override
+ public BsonDocument getSessionId() {
+ return wrapped.getSessionId();
+ }
+
+ @Override
+ public boolean isCausallyConsistent() {
+ return wrapped.isCausallyConsistent();
+ }
+
+ @Override
+ public long getTransactionNumber() {
+ return wrapped.getTransactionNumber();
+ }
+
+ @Override
+ public long advanceTransactionNumber() {
+ return wrapped.advanceTransactionNumber();
+ }
+
+ @Override
+ public boolean notifyMessageSent() {
+ return wrapped.notifyMessageSent();
+ }
+
+ @Override
+ @Nullable
+ public BsonTimestamp getOperationTime() {
+ return wrapped.getOperationTime();
+ }
+
+ @Override
+ public void advanceOperationTime(@Nullable final BsonTimestamp operationTime) {
+ wrapped.advanceOperationTime(operationTime);
+ }
+
+ @Override
+ @Nullable
+ public BsonDocument getClusterTime() {
+ return wrapped.getClusterTime();
+ }
+
+ @Override
+ public void advanceClusterTime(@Nullable final BsonDocument clusterTime) {
+ wrapped.advanceClusterTime(clusterTime);
+ }
+
+ @Override
+ public boolean isSnapshot() {
+ return wrapped.isSnapshot();
+ }
+
+ @Override
+ public void setSnapshotTimestamp(@Nullable final BsonTimestamp snapshotTimestamp) {
+ wrapped.setSnapshotTimestamp(snapshotTimestamp);
+ }
+
+ @Override
+ @Nullable
+ public BsonTimestamp getSnapshotTimestamp() {
+ return wrapped.getSnapshotTimestamp();
+ }
+
+ @Override
+ public boolean hasActiveTransaction() {
+ return wrapped.hasActiveTransaction();
+ }
+
+ @Override
+ public ReadConcern getReadConcern() {
+ return wrapped.getReadConcern();
+ }
+
+ @Override
+ public void setRecoveryToken(final BsonDocument recoveryToken) {
+ wrapped.setRecoveryToken(recoveryToken);
+ }
+
+ @Override
+ public void clearTransactionContext() {
+ wrapped.clearTransactionContext();
+ }
+
+ @Override
+ public void markSessionDirty() {
+ wrapped.markSessionDirty();
+ }
+
+ @Override
+ public boolean isSessionMarkedDirty() {
+ return wrapped.isSessionMarkedDirty();
+ }
+
+ @Override
+ public BaseClientSessionImpl.OverloadRetryPolicyState getOverloadRetryPolicyState() {
+ return BaseClientSessionImpl.OverloadRetryPolicyState.NO_OP;
+ }
+}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/SdamServerDescriptionManager.java b/driver-core/src/main/com/mongodb/internal/connection/SdamServerDescriptionManager.java
index 7f014d7ede6..4b989193c0d 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/SdamServerDescriptionManager.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/SdamServerDescriptionManager.java
@@ -17,6 +17,7 @@
package com.mongodb.internal.connection;
import com.mongodb.MongoCommandException;
+import com.mongodb.MongoException;
import com.mongodb.MongoNodeIsRecoveringException;
import com.mongodb.MongoNotPrimaryException;
import com.mongodb.MongoSecurityException;
@@ -162,6 +163,11 @@ boolean relatedToWriteConcern() {
return exception instanceof MongoWriteConcernWithResponseException;
}
+ boolean hasSystemOverloadedLabel() {
+ return exception instanceof MongoException
+ && ((MongoException) exception).hasErrorLabel(MongoException.SYSTEM_OVERLOADED_ERROR_LABEL);
+ }
+
private static boolean stale(@Nullable final Throwable t, final ServerDescription currentServerDescription) {
return TopologyVersionHelper.topologyVersion(t)
.map(candidateTopologyVersion -> TopologyVersionHelper.newerOrEqual(
diff --git a/driver-core/src/main/com/mongodb/internal/connection/SocketStream.java b/driver-core/src/main/com/mongodb/internal/connection/SocketStream.java
index a1c3ed0d914..764f41034f2 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/SocketStream.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/SocketStream.java
@@ -16,14 +16,18 @@
package com.mongodb.internal.connection;
+import com.mongodb.MongoException;
+import com.mongodb.MongoInterruptedException;
import com.mongodb.MongoSocketException;
import com.mongodb.MongoSocketOpenException;
import com.mongodb.MongoSocketReadException;
+import com.mongodb.MongoSocksProxyException;
import com.mongodb.ServerAddress;
import com.mongodb.connection.AsyncCompletionHandler;
import com.mongodb.connection.ProxySettings;
import com.mongodb.connection.SocketSettings;
import com.mongodb.connection.SslSettings;
+import com.mongodb.lang.Nullable;
import com.mongodb.spi.dns.InetAddressResolver;
import org.bson.ByteBuf;
@@ -38,6 +42,7 @@
import java.net.SocketTimeoutException;
import java.util.Iterator;
import java.util.List;
+import java.util.Optional;
import static com.mongodb.assertions.Assertions.assertTrue;
import static com.mongodb.assertions.Assertions.notNull;
@@ -79,13 +84,26 @@ public void open(final OperationContext operationContext) {
socket = initializeSocket(operationContext);
outputStream = socket.getOutputStream();
inputStream = socket.getInputStream();
+ } catch (MongoSocksProxyException e) {
+ close();
+ throw translateOr(e.getCause(), e);
} catch (IOException e) {
close();
- throw translateInterruptedException(e, "Interrupted while connecting")
- .orElseThrow(() -> new MongoSocketOpenException("Exception opening socket", getAddress(), e));
+ throw translateOr(e, new MongoSocketOpenException("Exception opening socket", getAddress(), e));
}
}
+ /**
+ * If {@code interruptCandidate} represents a thread interruption, returns the corresponding
+ * {@link MongoInterruptedException}; otherwise returns {@code fallback}.
+ */
+ private static MongoException translateOr(@Nullable final Throwable interruptCandidate,
+ final MongoException fallback) {
+ Optional translated =
+ translateInterruptedException(interruptCandidate, "Interrupted while connecting");
+ return translated.isPresent() ? translated.get() : fallback;
+ }
+
protected Socket initializeSocket(final OperationContext operationContext) throws IOException {
ProxySettings proxySettings = settings.getProxySettings();
if (proxySettings.isProxyEnabled()) {
@@ -119,15 +137,28 @@ private SSLSocket initializeSslSocketOverSocksProxy(final OperationContext opera
final int serverPort = address.getPort();
SocksSocket socksProxy = new SocksSocket(settings.getProxySettings());
- configureSocket(socksProxy, operationContext, settings);
- InetSocketAddress inetSocketAddress = toSocketAddress(serverHost, serverPort);
- socksProxy.connect(inetSocketAddress, operationContext.getTimeoutContext().getConnectTimeoutMs());
-
- SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket(socksProxy, serverHost, serverPort, true);
- //Even though Socks proxy connection is already established, TLS handshake has not been performed yet.
- //So it is possible to set SSL parameters before handshake is done.
- configureSslSocket(sslSocket, sslSettings, inetSocketAddress);
- return sslSocket;
+ // Track the outermost socket layer to close on failure. Initially this is socksProxy;
+ // once we wrap it into an SSLSocket, that becomes the outermost layer and closing it
+ // tears down the underlying socksProxy as well.
+ Socket toClose = socksProxy;
+ try {
+ configureSocket(socksProxy, operationContext, settings);
+ InetSocketAddress inetSocketAddress = toSocketAddress(serverHost, serverPort);
+ socksProxy.connect(inetSocketAddress, operationContext.getTimeoutContext().getConnectTimeoutMs());
+ SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket(socksProxy, serverHost, serverPort, true);
+ toClose = sslSocket;
+ //Even though Socks proxy connection is already established, TLS handshake has not been performed yet.
+ //So it is possible to set SSL parameters before handshake is done.
+ configureSslSocket(sslSocket, sslSettings, inetSocketAddress);
+ return sslSocket;
+ } catch (IOException | RuntimeException e) {
+ try {
+ toClose.close();
+ } catch (IOException closeException) {
+ e.addSuppressed(closeException);
+ }
+ throw e;
+ }
}
@@ -141,17 +172,27 @@ private static InetSocketAddress toSocketAddress(final String serverHost, final
private Socket initializeSocketOverSocksProxy(final OperationContext operationContext) throws IOException {
Socket createdSocket = socketFactory.createSocket();
- configureSocket(createdSocket, operationContext, settings);
- /*
- Wrap the configured socket with SocksSocket to add extra functionality.
- Reason for separate steps: We can't directly extend Java 11 methods within 'SocksSocket'
- to configure itself.
- */
- SocksSocket socksProxy = new SocksSocket(createdSocket, settings.getProxySettings());
-
- socksProxy.connect(toSocketAddress(address.getHost(), address.getPort()),
- operationContext.getTimeoutContext().getConnectTimeoutMs());
- return socksProxy;
+ try {
+ configureSocket(createdSocket, operationContext, settings);
+ /*
+ Wrap the configured socket with SocksSocket to add extra functionality.
+ Reason for separate steps: We can't directly extend Java 11 methods within 'SocksSocket'
+ to configure itself.
+ */
+ SocksSocket socksProxy = new SocksSocket(createdSocket, settings.getProxySettings());
+ socksProxy.connect(toSocketAddress(address.getHost(), address.getPort()),
+ operationContext.getTimeoutContext().getConnectTimeoutMs());
+ return socksProxy;
+ } catch (IOException | RuntimeException e) {
+ // SocksSocket.connect() closes itself on failure, but createdSocket may not yet
+ // be owned by a SocksSocket (e.g. configureSocket threw). Close defensively;
+ try {
+ createdSocket.close();
+ } catch (IOException closeException) {
+ e.addSuppressed(closeException);
+ }
+ throw e;
+ }
}
@Override
diff --git a/driver-core/src/main/com/mongodb/internal/connection/SocksSocket.java b/driver-core/src/main/com/mongodb/internal/connection/SocksSocket.java
index 2619a3c2c10..9a1a42511e1 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/SocksSocket.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/SocksSocket.java
@@ -15,6 +15,8 @@
*/
package com.mongodb.internal.connection;
+import com.mongodb.MongoSocksProxyException;
+import com.mongodb.ServerAddress;
import com.mongodb.connection.ProxySettings;
import com.mongodb.internal.time.Timeout;
import com.mongodb.lang.Nullable;
@@ -81,7 +83,7 @@ public SocksSocket(@Nullable final Socket socket, final ProxySettings proxySetti
}
@Override
- public void connect(final SocketAddress endpoint, final int connectTimeoutMs) throws IOException {
+ public void connect(final SocketAddress endpoint, final int connectTimeoutMs) {
// `Socket` requires `IllegalArgumentException`
isTrueArgument("connectTimeoutMs", connectTimeoutMs >= 0);
try {
@@ -97,22 +99,53 @@ public void connect(final SocketAddress endpoint, final int connectTimeoutMs) th
(ms) -> socketConnect(proxyAddress, Math.toIntExact(ms)),
() -> throwSocketConnectionTimeout());
- SocksAuthenticationMethod authenticationMethod = performNegotiation(timeout);
- authenticate(authenticationMethod, timeout);
- sendConnect(timeout);
- } catch (SocketException socketException) {
- /*
- * The 'close()' call here has two purposes:
- *
- * 1. Enforces self-closing under RFC 1928 if METHOD is X'FF'.
- * 2. Handles all other errors during connection, distinct from external closures.
- */
+ SocksAuthenticationMethod authenticationMethod;
+ try {
+ authenticationMethod = performNegotiation(timeout);
+ } catch (IOException e) {
+ throw new MongoSocksProxyException("Negotiation failed: " + e.getMessage(),
+ targetServerAddress(), e);
+ }
+
+ try {
+ authenticate(authenticationMethod, timeout);
+ } catch (IOException e) {
+ throw new MongoSocksProxyException("Authentication failed: " + e.getMessage(),
+ targetServerAddress(), e);
+ }
+
+ try {
+ sendConnect(timeout);
+ } catch (IOException e) {
+ throw new MongoSocksProxyException("CONNECT relay failed: " + e.getMessage(),
+ targetServerAddress(), e);
+ }
+ } catch (MongoSocksProxyException e) {
+ // Reached for any SOCKS5 protocol failure (negotiation / authentication / CONNECT-relay,
+ // including RFC 1928 X'FF' "no acceptable method" self-close). The proxy TCP socket is
+ // already connected at this point. MongoSocksProxyException is a RuntimeException and is
+ // not caught below, so close the socket here to avoid leaking the FD.
try {
close();
} catch (Exception closeException) {
- socketException.addSuppressed(closeException);
+ e.addSuppressed(closeException);
}
- throw socketException;
+ throw e;
+ } catch (IOException ioException) {
+ // Reached only when the initial proxy TCP connect fails
+ // before any SOCKS5 handshake byte goes on the wire. Inner-phase IOExceptions are
+ // converted to MongoSocksProxyException by the per-phase wrappers and caught above.
+ // Close the partially-initialised proxy socket so we don't leak a FD.
+ try {
+ close();
+ } catch (Exception closeException) {
+ ioException.addSuppressed(closeException);
+ }
+ throw new MongoSocksProxyException(
+ "Exception connecting to SOCKS5 proxy ("
+ + proxySettings.getHost() + ":" + proxySettings.getPort() + "): "
+ + ioException.getMessage(),
+ targetServerAddress(), ioException);
}
}
@@ -223,7 +256,9 @@ private void checkServerReply(final Timeout timeout) throws IOException {
}
return;
}
- throw new ConnectException(reply.getMessage());
+ throw new MongoSocksProxyException(
+ "CONNECT reply: " + reply.message + " (code " + reply.replyNumber + ")",
+ targetServerAddress(), reply.replyNumber);
}
private void authenticate(final SocksAuthenticationMethod authenticationMethod, final Timeout timeout) throws IOException {
@@ -249,7 +284,9 @@ private void authenticate(final SocksAuthenticationMethod authenticationMethod,
byte authStatus = authResult[1];
if (authStatus != AUTHENTICATION_SUCCEEDED_STATUS) {
- throw new ConnectException("Authentication failed. Proxy server returned status: " + authStatus);
+ throw new MongoSocksProxyException(
+ "Authentication failed. Proxy server returned status: " + authStatus,
+ targetServerAddress());
}
}
}
@@ -273,13 +310,16 @@ private SocksAuthenticationMethod performNegotiation(final Timeout timeout) thro
byte[] handshakeReply = readSocksReply(2, timeout);
if (handshakeReply[0] != SOCKS_VERSION) {
- throw new ConnectException("Remote server doesn't support socks version 5"
- + " Received version: " + handshakeReply[0]);
+ throw new MongoSocksProxyException("Remote server doesn't support socks version 5"
+ + " Received version: " + handshakeReply[0],
+ targetServerAddress());
}
byte authMethodNumber = handshakeReply[1];
if (authMethodNumber == (byte) 0xFF) {
- throw new ConnectException("None of the authentication methods listed are acceptable. Attempted methods: "
- + Arrays.toString(authenticationMethods));
+ throw new MongoSocksProxyException(
+ "None of the authentication methods listed are acceptable. Attempted methods: "
+ + Arrays.toString(authenticationMethods),
+ targetServerAddress());
}
if (authMethodNumber == SocksAuthenticationMethod.NO_AUTH.getMethodNumber()) {
return SocksAuthenticationMethod.NO_AUTH;
@@ -287,7 +327,12 @@ private SocksAuthenticationMethod performNegotiation(final Timeout timeout) thro
return SocksAuthenticationMethod.USERNAME_PASSWORD;
}
- throw new ConnectException("Proxy returned unsupported authentication method: " + authMethodNumber);
+ throw new MongoSocksProxyException("Proxy returned unsupported authentication method: " + authMethodNumber,
+ targetServerAddress());
+ }
+
+ private ServerAddress targetServerAddress() {
+ return new ServerAddress(remoteAddress.getHostString(), remoteAddress.getPort());
}
private SocksAuthenticationMethod[] getSocksAuthenticationMethods() {
@@ -435,6 +480,10 @@ static ServerReply of(final byte byteStatus) throws ConnectException {
public String getMessage() {
return message;
}
+
+ public int getReplyNumber() {
+ return replyNumber;
+ }
}
@Override
diff --git a/driver-core/src/main/com/mongodb/internal/connection/StreamFactoryFactory.java b/driver-core/src/main/com/mongodb/internal/connection/StreamFactoryFactory.java
index 6cbe620fd43..589a20bb8e1 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/StreamFactoryFactory.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/StreamFactoryFactory.java
@@ -18,6 +18,10 @@
import com.mongodb.connection.SocketSettings;
import com.mongodb.connection.SslSettings;
+import com.mongodb.connection.TransportSettings;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
/**
* A factory of {@code StreamFactory} instances.
@@ -29,10 +33,18 @@ public interface StreamFactoryFactory extends AutoCloseable {
*
* @param socketSettings the socket settings
* @param sslSettings the SSL settings
- * @return a stream factory that will apply the given settins
+ * @return a stream factory that will apply the given settings
*/
StreamFactory create(SocketSettings socketSettings, SslSettings sslSettings);
+ /**
+ * The {@link Executor} that the {@link StreamFactoryFactory} uses for I/O.
+ * It is usually {@link ExecutorService#shutdown() shut down} by {@link #close()},
+ * but the behavior may be different if an application provides an executor via {@link TransportSettings}.
+ * See the documentation of the corresponding API for information about the lifecycle of an application-provided executor.
+ */
+ Executor getExecutor();
+
@Override
void close();
}
diff --git a/driver-core/src/main/com/mongodb/internal/connection/StreamFactoryHelper.java b/driver-core/src/main/com/mongodb/internal/connection/StreamFactoryHelper.java
index 7aeb65720b0..b8b14e317ef 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/StreamFactoryHelper.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/StreamFactoryHelper.java
@@ -27,10 +27,11 @@
import com.mongodb.lang.Nullable;
import com.mongodb.spi.dns.InetAddressResolver;
-import java.io.IOException;
-import java.nio.channels.AsynchronousChannelGroup;
+import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
+import static com.mongodb.assertions.Assertions.fail;
+
/**
* This class is not part of the public API and may be removed or changed at any time
*/
@@ -47,6 +48,11 @@ public StreamFactory create(final SocketSettings socketSettings, final SslSettin
return new SocketStreamFactory(inetAddressResolver, socketSettings, sslSettings);
}
+ @Override
+ public Executor getExecutor() {
+ throw fail();
+ }
+
@Override
public void close() {
//NOP
@@ -71,15 +77,7 @@ public static StreamFactoryFactory getAsyncStreamFactoryFactory(final MongoClien
if (settings.getSslSettings().isEnabled()) {
return new TlsChannelStreamFactoryFactory(inetAddressResolver, executorService);
}
- AsynchronousChannelGroup group = null;
- if (executorService != null) {
- try {
- group = AsynchronousChannelGroup.withThreadPool(executorService);
- } catch (IOException e) {
- throw new MongoClientException("Unable to create an asynchronous channel group", e);
- }
- }
- return new AsynchronousSocketChannelStreamFactoryFactory(inetAddressResolver, group);
+ return new AsynchronousSocketChannelStreamFactoryFactory(inetAddressResolver, executorService);
} else if (transportSettings instanceof NettyTransportSettings) {
return getNettyStreamFactoryFactory(inetAddressResolver, (NettyTransportSettings) transportSettings);
} else {
diff --git a/driver-core/src/main/com/mongodb/internal/connection/Time.java b/driver-core/src/main/com/mongodb/internal/connection/Time.java
index e3940adf1de..9b7f935e631 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/Time.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/Time.java
@@ -20,7 +20,11 @@
* To enable unit testing of classes that rely on System.nanoTime
*
* This class is not part of the public API and may be removed or changed at any time
+ *
+ * @deprecated Use {@link com.mongodb.internal.time.SystemNanoTime} in production code,
+ * and {@code Mockito.mockStatic} in test code to tamper with it.
*/
+@Deprecated
public final class Time {
static final long CONSTANT_TIME = 42;
diff --git a/driver-core/src/main/com/mongodb/internal/connection/TlsChannelStreamFactoryFactory.java b/driver-core/src/main/com/mongodb/internal/connection/TlsChannelStreamFactoryFactory.java
index b0fae1d044d..4296cb01392 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/TlsChannelStreamFactoryFactory.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/TlsChannelStreamFactoryFactory.java
@@ -20,6 +20,7 @@
import com.mongodb.MongoSocketOpenException;
import com.mongodb.ServerAddress;
import com.mongodb.connection.AsyncCompletionHandler;
+import com.mongodb.connection.AsyncTransportSettings;
import com.mongodb.connection.SocketSettings;
import com.mongodb.connection.SslSettings;
import com.mongodb.internal.connection.tlschannel.BufferAllocator;
@@ -47,6 +48,7 @@
import java.security.NoSuchAlgorithmException;
import java.util.Iterator;
import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
@@ -93,10 +95,22 @@ public StreamFactory create(final SocketSettings socketSettings, final SslSettin
selectorMonitor);
}
+ /**
+ * @return The {@link Executor} used by the {@link StreamFactory} created via {@link #create(SocketSettings, SslSettings)}.
+ * It may be backed by the {@link ExecutorService} provided by an application via {@link AsyncTransportSettings#getExecutorService()}.
+ */
+ @Override
+ public Executor getExecutor() {
+ return group;
+ }
+
@Override
public void close() {
- selectorMonitor.close();
- group.shutdown();
+ try {
+ selectorMonitor.close();
+ } finally {
+ group.shutdown();
+ }
}
/**
diff --git a/driver-core/src/main/com/mongodb/internal/connection/netty/NettyStreamFactoryFactory.java b/driver-core/src/main/com/mongodb/internal/connection/netty/NettyStreamFactoryFactory.java
index 7fe54defaa2..a939092f952 100644
--- a/driver-core/src/main/com/mongodb/internal/connection/netty/NettyStreamFactoryFactory.java
+++ b/driver-core/src/main/com/mongodb/internal/connection/netty/NettyStreamFactoryFactory.java
@@ -36,6 +36,7 @@
import java.security.Security;
import java.util.Objects;
+import java.util.concurrent.Executor;
import static com.mongodb.assertions.Assertions.isTrueArgument;
import static com.mongodb.assertions.Assertions.notNull;
@@ -151,7 +152,7 @@ public Builder eventLoopGroup(final EventLoopGroup eventLoopGroup) {
/**
* Sets a {@linkplain SslContextBuilder#forClient() client-side} {@link SslContext io.netty.handler.ssl.SslContext},
* which overrides the standard {@link SslSettings#getContext()}.
- * By default it is {@code null} and {@link SslSettings#getContext()} is at play.
+ * By default, it is {@code null} and {@link SslSettings#getContext()} is at play.
*
* This option may be used as a convenient way to utilize
* OpenSSL as an alternative to the TLS/SSL protocol implementation in a JDK.
@@ -203,13 +204,22 @@ public StreamFactory create(final SocketSettings socketSettings, final SslSettin
sslContext);
}
+ /**
+ * @return The {@link EventLoopGroup} used by the {@link StreamFactory} created via {@link #create(SocketSettings, SslSettings)}.
+ * It may be provided by an application via {@link NettyTransportSettings#getEventLoopGroup()}.
+ */
+ @Override
+ public Executor getExecutor() {
+ return eventLoopGroup;
+ }
+
@Override
public void close() {
- if (ownsEventLoopGroup) {
- // ignore the returned Future. This is in line with MongoClient behavior to not block waiting for connections to be returned
- // to the pool
- eventLoopGroup.shutdownGracefully();
- }
+ if (ownsEventLoopGroup) {
+ // ignore the returned Future. This is in line with MongoClient behavior to not block waiting for connections to be returned
+ // to the pool
+ eventLoopGroup.shutdownGracefully();
+ }
}
@Override
diff --git a/driver-core/src/main/com/mongodb/internal/diagnostics/logging/Logger.java b/driver-core/src/main/com/mongodb/internal/diagnostics/logging/Logger.java
index e9907bb3953..4c1eda53e11 100644
--- a/driver-core/src/main/com/mongodb/internal/diagnostics/logging/Logger.java
+++ b/driver-core/src/main/com/mongodb/internal/diagnostics/logging/Logger.java
@@ -17,8 +17,7 @@
package com.mongodb.internal.diagnostics.logging;
/**
- * This class is not part of the public API. It may be removed or changed at any time.
- *
+ * This class is not part of the public API and may be removed or changed at any time.
*/
public interface Logger {
/**
diff --git a/driver-core/src/main/com/mongodb/internal/event/CommandListenerMulticaster.java b/driver-core/src/main/com/mongodb/internal/event/CommandListenerMulticaster.java
index e18318f8cde..8f9a9f51e24 100644
--- a/driver-core/src/main/com/mongodb/internal/event/CommandListenerMulticaster.java
+++ b/driver-core/src/main/com/mongodb/internal/event/CommandListenerMulticaster.java
@@ -16,6 +16,7 @@
package com.mongodb.internal.event;
+import com.mongodb.annotations.ThreadSafe;
import com.mongodb.event.CommandFailedEvent;
import com.mongodb.event.CommandListener;
import com.mongodb.event.CommandStartedEvent;
@@ -29,7 +30,11 @@
import static com.mongodb.assertions.Assertions.isTrue;
import static java.lang.String.format;
-
+/**
+ * This {@link CommandListener} is {@linkplain ThreadSafe thread-safe},
+ * provided that the recipient listeners passed to {@link #CommandListenerMulticaster(List)} are.
+ */
+@ThreadSafe
final class CommandListenerMulticaster implements CommandListener {
private static final Logger LOGGER = Loggers.getLogger("protocol.event");
diff --git a/driver-core/src/main/com/mongodb/internal/operation/AbortTransactionOperation.java b/driver-core/src/main/com/mongodb/internal/operation/AbortTransactionOperation.java
index 21981fa968a..94aab881505 100644
--- a/driver-core/src/main/com/mongodb/internal/operation/AbortTransactionOperation.java
+++ b/driver-core/src/main/com/mongodb/internal/operation/AbortTransactionOperation.java
@@ -21,10 +21,11 @@
import com.mongodb.WriteConcern;
import com.mongodb.internal.MongoNamespaceHelper;
import com.mongodb.internal.TimeoutContext;
+import com.mongodb.internal.connection.OperationContext;
+import com.mongodb.internal.operation.CommandOperationHelper.CommandCreator;
import com.mongodb.lang.Nullable;
import org.bson.BsonDocument;
-import static com.mongodb.internal.operation.CommandOperationHelper.CommandCreator;
import static com.mongodb.internal.operation.DocumentHelper.putIfNotNull;
/**
@@ -36,8 +37,8 @@ public class AbortTransactionOperation extends TransactionOperation {
private static final String COMMAND_NAME = "abortTransaction";
private BsonDocument recoveryToken;
- public AbortTransactionOperation(final WriteConcern writeConcern) {
- super(writeConcern);
+ public AbortTransactionOperation(final WriteConcern writeConcern, @Nullable final Integer maxAdaptiveRetriesSetting) {
+ super(writeConcern, maxAdaptiveRetriesSetting);
}
public AbortTransactionOperation recoveryToken(@Nullable final BsonDocument recoveryToken) {
@@ -68,7 +69,7 @@ CommandCreator getCommandCreator() {
}
@Override
- protected Function getRetryCommandModifier(final TimeoutContext timeoutContext) {
+ protected Function getRetryCommandModifier(final OperationContext operationContext) {
return cmd -> cmd;
}
}
diff --git a/driver-core/src/main/com/mongodb/internal/operation/AbstractCommandReadOperation.java b/driver-core/src/main/com/mongodb/internal/operation/AbstractCommandReadOperation.java
new file mode 100644
index 00000000000..9ed68b79332
--- /dev/null
+++ b/driver-core/src/main/com/mongodb/internal/operation/AbstractCommandReadOperation.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.internal.operation;
+
+import com.mongodb.MongoNamespace;
+import com.mongodb.internal.async.SingleResultCallback;
+import com.mongodb.internal.binding.AsyncReadBinding;
+import com.mongodb.internal.binding.ReadBinding;
+import com.mongodb.internal.connection.OperationContext;
+import org.bson.BsonDocument;
+import org.bson.codecs.Decoder;
+
+import static com.mongodb.internal.MongoNamespaceHelper.COMMAND_COLLECTION_NAME;
+import static com.mongodb.assertions.Assertions.notNull;
+import static com.mongodb.internal.operation.AsyncOperationHelper.CommandReadTransformerAsync;
+import static com.mongodb.internal.operation.AsyncOperationHelper.executeRetryableReadAsync;
+import static com.mongodb.internal.operation.CommandOperationHelper.CommandCreator;
+import static com.mongodb.internal.operation.SyncOperationHelper.CommandReadTransformer;
+import static com.mongodb.internal.operation.SyncOperationHelper.executeRetryableRead;
+
+/**
+ * An operation that executes an arbitrary command that reads from the server.
+ *
+ * This class is not part of the public API and may be removed or changed at any time
+ */
+public abstract class AbstractCommandReadOperation implements ReadOperationSimple {
+ private final String commandName;
+ private final String databaseName;
+ private final CommandCreator commandCreator;
+ private final Decoder decoder;
+
+ AbstractCommandReadOperation(final String databaseName, final BsonDocument command, final Decoder decoder) {
+ this(databaseName, command.getFirstKey(), (operationContext, serverDescription, connectionDescription) -> command, decoder);
+ }
+
+ AbstractCommandReadOperation(final String databaseName, final String commandName, final CommandCreator commandCreator,
+ final Decoder decoder) {
+ this.commandName = notNull("commandName", commandName);
+ this.databaseName = notNull("databaseName", databaseName);
+ this.commandCreator = notNull("commandCreator", commandCreator);
+ this.decoder = notNull("decoder", decoder);
+ }
+
+ @Override
+ public String getCommandName() {
+ return commandName;
+ }
+
+ @Override
+ public MongoNamespace getNamespace() {
+ return new MongoNamespace(databaseName, COMMAND_COLLECTION_NAME);
+ }
+
+ String getDatabaseName() {
+ return databaseName;
+ }
+
+ CommandCreator getCommandCreator() {
+ return commandCreator;
+ }
+
+ Decoder getDecoder() {
+ return decoder;
+ }
+
+ @Override
+ public T execute(final ReadBinding binding, final OperationContext operationContext) {
+ return executeRetryableRead(binding, operationContext, databaseName, commandCreator, decoder,
+ transformer(), false, null);
+ }
+
+ @Override
+ public void executeAsync(final AsyncReadBinding binding, final OperationContext operationContext,
+ final SingleResultCallback callback) {
+ executeRetryableReadAsync(binding, operationContext, databaseName, commandCreator, decoder,
+ asyncTransformer(), false, null, callback);
+ }
+
+ static CommandReadTransformer transformer() {
+ return (result, source, connection, operationContext) -> result;
+ }
+
+ static CommandReadTransformerAsync asyncTransformer() {
+ return (result, source, connection, operationContext) -> result;
+ }
+}
diff --git a/driver-core/src/main/com/mongodb/internal/operation/AbstractWriteSearchIndexOperation.java b/driver-core/src/main/com/mongodb/internal/operation/AbstractWriteSearchIndexOperation.java
index a409da75f6e..375280c90c7 100644
--- a/driver-core/src/main/com/mongodb/internal/operation/AbstractWriteSearchIndexOperation.java
+++ b/driver-core/src/main/com/mongodb/internal/operation/AbstractWriteSearchIndexOperation.java
@@ -20,15 +20,23 @@
import com.mongodb.MongoCommandException;
import com.mongodb.MongoNamespace;
import com.mongodb.internal.async.SingleResultCallback;
+import com.mongodb.internal.async.function.AsyncCallbackSupplier;
+import com.mongodb.internal.async.function.RetryControl;
import com.mongodb.internal.binding.AsyncWriteBinding;
import com.mongodb.internal.binding.WriteBinding;
import com.mongodb.internal.connection.OperationContext;
import com.mongodb.lang.Nullable;
import org.bson.BsonDocument;
+import java.util.function.Supplier;
+
+import static com.mongodb.internal.operation.AsyncOperationHelper.decorateWithRetriesAsync;
import static com.mongodb.internal.operation.AsyncOperationHelper.executeCommandAsync;
import static com.mongodb.internal.operation.AsyncOperationHelper.withAsyncSourceAndConnection;
import static com.mongodb.internal.operation.AsyncOperationHelper.writeConcernErrorTransformerAsync;
+import static com.mongodb.internal.operation.CommandOperationHelper.createSpecRetryControl;
+import static com.mongodb.internal.operation.SpecRetryPolicy.IndividualPolicies.overloadForWrite;
+import static com.mongodb.internal.operation.SyncOperationHelper.decorateWithRetries;
import static com.mongodb.internal.operation.SyncOperationHelper.executeCommand;
import static com.mongodb.internal.operation.SyncOperationHelper.withConnection;
import static com.mongodb.internal.operation.SyncOperationHelper.writeConcernErrorTransformer;
@@ -40,39 +48,64 @@
*/
abstract class AbstractWriteSearchIndexOperation implements WriteOperation {
private final MongoNamespace namespace;
+ private final boolean retryWrites;
+ @Nullable
+ private final Integer maxAdaptiveRetriesSetting;
AbstractWriteSearchIndexOperation(final MongoNamespace namespace) {
+ this(namespace, false, null);
+ }
+
+ AbstractWriteSearchIndexOperation(final MongoNamespace namespace, final boolean retryWrites,
+ @Nullable final Integer maxAdaptiveRetriesSetting) {
this.namespace = namespace;
+ this.retryWrites = retryWrites;
+ this.maxAdaptiveRetriesSetting = maxAdaptiveRetriesSetting;
}
@Override
public Void execute(final WriteBinding binding, final OperationContext operationContext) {
- return withConnection(binding, operationContext, (connection, operationContextWithMinRtt) -> {
- try {
- executeCommand(binding, operationContextWithMinRtt, namespace.getDatabaseName(), buildCommand(),
- connection,
- writeConcernErrorTransformer(operationContextWithMinRtt.getTimeoutContext()));
- } catch (MongoCommandException mongoCommandException) {
- swallowOrThrow(mongoCommandException);
- }
- return null;
+ RetryControl retryControl = createSpecRetryControl(
+ overloadForWrite(retryWrites, maxAdaptiveRetriesSetting),
+ operationContext);
+ Supplier retryingCommandExecutor = decorateWithRetries(retryControl, operationContext, () -> {
+ retryControl.getPolicy().onCommand(this::getCommandName);
+ return withConnection(binding, operationContext, (connection, operationContextWithMinRtt) -> {
+ try {
+ executeCommand(binding, operationContextWithMinRtt, namespace.getDatabaseName(), buildCommand(),
+ connection,
+ writeConcernErrorTransformer(operationContextWithMinRtt.getTimeoutContext()));
+ } catch (MongoCommandException mongoCommandException) {
+ swallowOrThrow(mongoCommandException);
+ }
+ return null;
+ });
});
+ return retryingCommandExecutor.get();
}
@Override
public void executeAsync(final AsyncWriteBinding binding, final OperationContext operationContext, final SingleResultCallback callback) {
- withAsyncSourceAndConnection(binding::getWriteConnectionSource, false, operationContext, callback,
- (connectionSource, connection, operationContextWithMinRtt, cb) ->
- executeCommandAsync(binding, operationContextWithMinRtt, namespace.getDatabaseName(), buildCommand(), connection,
- writeConcernErrorTransformerAsync(operationContextWithMinRtt.getTimeoutContext()), (result, commandExecutionError) -> {
- try {
- swallowOrThrow(commandExecutionError);
- cb.onResult(result, null);
- } catch (Throwable mongoCommandException) {
- cb.onResult(null, mongoCommandException);
+ RetryControl retryControl = createSpecRetryControl(
+ overloadForWrite(retryWrites, maxAdaptiveRetriesSetting),
+ operationContext);
+ AsyncCallbackSupplier retryingCommandExecutor = decorateWithRetriesAsync(retryControl, operationContext, supplierCallback -> {
+ retryControl.getPolicy().onCommand(this::getCommandName);
+ withAsyncSourceAndConnection(binding::getWriteConnectionSource, false, operationContext, supplierCallback,
+ (connectionSource, connection, operationContextWithMinRtt, cb) ->
+ executeCommandAsync(binding, operationContextWithMinRtt, namespace.getDatabaseName(), buildCommand(),
+ connection, writeConcernErrorTransformerAsync(operationContextWithMinRtt.getTimeoutContext()),
+ (result, commandExecutionError) -> {
+ try {
+ swallowOrThrow(commandExecutionError);
+ cb.onResult(result, null);
+ } catch (Throwable mongoCommandException) {
+ cb.onResult(null, mongoCommandException);
+ }
}
- }
- ));
+ ));
+ });
+ retryingCommandExecutor.get(callback);
}
/**
@@ -101,4 +134,5 @@ void swallowOrThrow(@Nullable final E mongoExecutionExcept
public MongoNamespace getNamespace() {
return namespace;
}
+
}
diff --git a/driver-core/src/main/com/mongodb/internal/operation/AggregateOperation.java b/driver-core/src/main/com/mongodb/internal/operation/AggregateOperation.java
index 1f2a6ba518f..07ce3ce62bb 100644
--- a/driver-core/src/main/com/mongodb/internal/operation/AggregateOperation.java
+++ b/driver-core/src/main/com/mongodb/internal/operation/AggregateOperation.java
@@ -45,13 +45,14 @@
public class AggregateOperation implements ReadOperationExplainable {
private final AggregateOperationImpl wrapped;
- public AggregateOperation(final MongoNamespace namespace, final List pipeline, final Decoder decoder) {
- this(namespace, pipeline, decoder, AggregationLevel.COLLECTION);
+ public AggregateOperation(final MongoNamespace namespace, final List pipeline, final Decoder decoder,
+ @Nullable final Integer maxAdaptiveRetriesSetting) {
+ this(namespace, pipeline, decoder, AggregationLevel.COLLECTION, maxAdaptiveRetriesSetting);
}
public AggregateOperation(final MongoNamespace namespace, final List pipeline, final Decoder decoder,
- final AggregationLevel aggregationLevel) {
- this.wrapped = new AggregateOperationImpl<>(namespace, pipeline, decoder, aggregationLevel);
+ final AggregationLevel aggregationLevel, @Nullable final Integer maxAdaptiveRetriesSetting) {
+ this.wrapped = new AggregateOperationImpl<>(namespace, pipeline, decoder, aggregationLevel, maxAdaptiveRetriesSetting);
}
public List getPipeline() {
@@ -156,7 +157,7 @@ public ReadOperationSimple asExplainableOperation(@Nullable final Explain
return createExplainableOperation(verbosity, resultDecoder);
}
- CommandReadOperation createExplainableOperation(@Nullable final ExplainVerbosity verbosity, final Decoder resultDecoder) {
+ ExplainCommandOperation createExplainableOperation(@Nullable final ExplainVerbosity verbosity, final Decoder resultDecoder) {
return new ExplainCommandOperation<>(getNamespace().getDatabaseName(), getCommandName(),
(operationContext, serverDescription, connectionDescription) -> {
BsonDocument command = wrapped.getCommand(operationContext, UNKNOWN_WIRE_VERSION);
diff --git a/driver-core/src/main/com/mongodb/internal/operation/AggregateOperationImpl.java b/driver-core/src/main/com/mongodb/internal/operation/AggregateOperationImpl.java
index 940073d4238..0442571f41c 100644
--- a/driver-core/src/main/com/mongodb/internal/operation/AggregateOperationImpl.java
+++ b/driver-core/src/main/com/mongodb/internal/operation/AggregateOperationImpl.java
@@ -65,6 +65,8 @@ class AggregateOperationImpl implements ReadOperationCursor {
private final PipelineCreator pipelineCreator;
private boolean retryReads;
+ @Nullable
+ private final Integer maxAdaptiveRetriesSetting;
private Boolean allowDiskUse;
private Integer batchSize;
private Collation collation;
@@ -75,21 +77,24 @@ class AggregateOperationImpl implements ReadOperationCursor {
private CursorType cursorType;
AggregateOperationImpl(final MongoNamespace namespace,
- final List pipeline, final Decoder decoder, final AggregationLevel aggregationLevel) {
+ final List pipeline, final Decoder decoder, final AggregationLevel aggregationLevel,
+ @Nullable final Integer maxAdaptiveRetriesSetting) {
this(namespace, pipeline, decoder,
defaultAggregateTarget(notNull("aggregationLevel", aggregationLevel),
notNull("namespace", namespace).getCollectionName()),
- defaultPipelineCreator(pipeline));
+ defaultPipelineCreator(pipeline), maxAdaptiveRetriesSetting);
}
AggregateOperationImpl(final MongoNamespace namespace,
final List pipeline, final Decoder decoder, final AggregateTarget aggregateTarget,
- final PipelineCreator pipelineCreator) {
+ final PipelineCreator pipelineCreator,
+ @Nullable final Integer maxAdaptiveRetriesSetting) {
this.namespace = notNull("namespace", namespace);
this.pipeline = notNull("pipeline", pipeline);
this.decoder = notNull("decoder", decoder);
this.aggregateTarget = notNull("aggregateTarget", aggregateTarget);
this.pipelineCreator = notNull("pipelineCreator", pipelineCreator);
+ this.maxAdaptiveRetriesSetting = maxAdaptiveRetriesSetting;
}
List getPipeline() {
@@ -196,7 +201,7 @@ public MongoNamespace getNamespace() {
public BatchCursor execute(final ReadBinding binding, final OperationContext operationContext) {
return executeRetryableRead(binding, applyTimeoutModeToOperationContext(timeoutMode, operationContext), namespace.getDatabaseName(),
getCommandCreator(), CommandResultDocumentCodec.create(decoder, FIELD_NAMES_WITH_RESULT),
- transformer(), retryReads);
+ transformer(), retryReads, maxAdaptiveRetriesSetting);
}
@Override
@@ -204,7 +209,7 @@ public void executeAsync(final AsyncReadBinding binding, final OperationContext
SingleResultCallback> errHandlingCallback = errorHandlingCallback(callback, LOGGER);
executeRetryableReadAsync(binding, applyTimeoutModeToOperationContext(timeoutMode, operationContext), namespace.getDatabaseName(),
getCommandCreator(), CommandResultDocumentCodec.create(decoder, FIELD_NAMES_WITH_RESULT),
- asyncTransformer(), retryReads,
+ asyncTransformer(), retryReads, maxAdaptiveRetriesSetting,
errHandlingCallback);
}
@@ -245,7 +250,8 @@ private CommandReadTransformer> transformer(
return (result, source, connection, operationContext) ->
new CommandBatchCursor<>(getTimeoutMode(), getMaxTimeForCursor(operationContext.getTimeoutContext()), operationContext, new CommandCursor<>(
result, batchSize != null ? batchSize : 0,
- decoder, comment, source, connection
+ decoder, comment, source, connection,
+ retryReads, maxAdaptiveRetriesSetting
));
}
@@ -253,7 +259,8 @@ private CommandReadTransformerAsync> asyncTran
return (result, source, connection, operationContext) ->
new AsyncCommandBatchCursor<>(getTimeoutMode(), getMaxTimeForCursor(operationContext.getTimeoutContext()),
operationContext, new AsyncCommandCursor<>(
- result, batchSize != null ? batchSize : 0, decoder, comment, source, connection
+ result, batchSize != null ? batchSize : 0, decoder, comment, source, connection,
+ retryReads, maxAdaptiveRetriesSetting
));
}
diff --git a/driver-core/src/main/com/mongodb/internal/operation/AggregateToCollectionOperation.java b/driver-core/src/main/com/mongodb/internal/operation/AggregateToCollectionOperation.java
index 146a6680d37..763c9d1a78f 100644
--- a/driver-core/src/main/com/mongodb/internal/operation/AggregateToCollectionOperation.java
+++ b/driver-core/src/main/com/mongodb/internal/operation/AggregateToCollectionOperation.java
@@ -43,6 +43,7 @@
import static com.mongodb.internal.operation.AsyncOperationHelper.CommandReadTransformerAsync;
import static com.mongodb.internal.operation.AsyncOperationHelper.executeRetryableReadAsync;
import static com.mongodb.internal.operation.ServerVersionHelper.FIVE_DOT_ZERO_WIRE_VERSION;
+import static com.mongodb.internal.operation.SpecRetryPolicy.IndividualPolicies.overloadForWrite;
import static com.mongodb.internal.operation.SyncOperationHelper.CommandReadTransformer;
import static com.mongodb.internal.operation.SyncOperationHelper.executeRetryableRead;
import static com.mongodb.internal.operation.WriteConcernHelper.appendWriteConcernToCommand;
@@ -64,6 +65,9 @@ public class AggregateToCollectionOperation implements ReadOperationSimple
private final WriteConcern writeConcern;
private final ReadConcern readConcern;
private final AggregationLevel aggregationLevel;
+ private final boolean retryWrites;
+ @Nullable
+ private final Integer maxAdaptiveRetriesSetting;
private Boolean allowDiskUse;
private Boolean bypassDocumentValidation;
@@ -79,11 +83,19 @@ public AggregateToCollectionOperation(final MongoNamespace namespace, final List
public AggregateToCollectionOperation(final MongoNamespace namespace, final List pipeline,
@Nullable final ReadConcern readConcern, @Nullable final WriteConcern writeConcern, final AggregationLevel aggregationLevel) {
+ this(namespace, pipeline, readConcern, writeConcern, aggregationLevel, false, null);
+ }
+
+ public AggregateToCollectionOperation(final MongoNamespace namespace, final List pipeline,
+ @Nullable final ReadConcern readConcern, @Nullable final WriteConcern writeConcern, final AggregationLevel aggregationLevel,
+ final boolean retryWrites, @Nullable final Integer maxAdaptiveRetriesSetting) {
this.namespace = notNull("namespace", namespace);
this.pipeline = notNull("pipeline", pipeline);
this.writeConcern = writeConcern;
this.readConcern = readConcern;
this.aggregationLevel = notNull("aggregationLevel", aggregationLevel);
+ this.retryWrites = retryWrites;
+ this.maxAdaptiveRetriesSetting = maxAdaptiveRetriesSetting;
isTrueArgument("pipeline is not empty", !pipeline.isEmpty());
}
@@ -178,7 +190,7 @@ public Void execute(final ReadBinding binding, final OperationContext operationC
getCommandCreator(),
new BsonDocumentCodec(),
transformer(),
- false);
+ overloadForWrite(retryWrites, maxAdaptiveRetriesSetting));
}
@Override
@@ -193,7 +205,7 @@ public void executeAsync(final AsyncReadBinding binding, final OperationContext
getCommandCreator(),
new BsonDocumentCodec(),
asyncTransformer(),
- false,
+ overloadForWrite(retryWrites, maxAdaptiveRetriesSetting),
callback);
}
@@ -249,4 +261,5 @@ private static CommandReadTransformerAsync asyncTransformer(
return null;
};
}
+
}
diff --git a/driver-core/src/main/com/mongodb/internal/operation/AsyncChangeStreamBatchCursor.java b/driver-core/src/main/com/mongodb/internal/operation/AsyncChangeStreamBatchCursor.java
index ce7127e0dc3..7c32dc41404 100644
--- a/driver-core/src/main/com/mongodb/internal/operation/AsyncChangeStreamBatchCursor.java
+++ b/driver-core/src/main/com/mongodb/internal/operation/AsyncChangeStreamBatchCursor.java
@@ -73,7 +73,9 @@ final class AsyncChangeStreamBatchCursor implements AsyncAggregateResponseBat
this.wrapped = new AtomicReference<>(assertNotNull(wrapped));
this.binding = binding;
binding.retain();
- this.initialOperationContext = operationContext.withOverride(TimeoutContext::withMaxTimeAsMaxAwaitTimeOverride);
+ this.initialOperationContext = operationContext
+ .withOverride(TimeoutContext::withMaxTimeAsMaxAwaitTimeOverride)
+ .withNewServerDeprioritization();
this.resumeToken = resumeToken;
this.maxWireVersion = maxWireVersion;
isClosed = new AtomicBoolean();
diff --git a/driver-core/src/main/com/mongodb/internal/operation/AsyncCommandCursor.java b/driver-core/src/main/com/mongodb/internal/operation/AsyncCommandCursor.java
index 6af8b9ec678..6a4ef41a43e 100644
--- a/driver-core/src/main/com/mongodb/internal/operation/AsyncCommandCursor.java
+++ b/driver-core/src/main/com/mongodb/internal/operation/AsyncCommandCursor.java
@@ -30,6 +30,7 @@
import com.mongodb.connection.ServerType;
import com.mongodb.internal.async.SingleResultCallback;
import com.mongodb.internal.async.function.AsyncCallbackSupplier;
+import com.mongodb.internal.async.function.RetryControl;
import com.mongodb.internal.binding.AsyncConnectionSource;
import com.mongodb.internal.connection.AsyncConnection;
import com.mongodb.internal.connection.Connection;
@@ -51,6 +52,9 @@
import static com.mongodb.assertions.Assertions.doesNotThrow;
import static com.mongodb.internal.async.AsyncRunnable.beginAsync;
import static com.mongodb.internal.async.SingleResultCallback.THEN_DO_NOTHING;
+import static com.mongodb.internal.operation.AsyncOperationHelper.decorateWithRetriesAsync;
+import static com.mongodb.internal.operation.CommandOperationHelper.createSpecRetryControl;
+import static com.mongodb.internal.operation.SpecRetryPolicy.IndividualPolicies.overloadForRead;
import static com.mongodb.internal.operation.CommandBatchCursorHelper.FIRST_BATCH;
import static com.mongodb.internal.operation.CommandBatchCursorHelper.MESSAGE_IF_CLOSED_AS_CURSOR;
import static com.mongodb.internal.operation.CommandBatchCursorHelper.NEXT_BATCH;
@@ -71,6 +75,9 @@ class AsyncCommandCursor implements AsyncCursor {
private final boolean firstBatchEmpty;
private final ResourceManager resourceManager;
private final AtomicBoolean processedInitial = new AtomicBoolean();
+ private final boolean retryReads;
+ @Nullable
+ private final Integer maxAdaptiveRetriesSetting;
private int batchSize;
private volatile CommandCursorResult commandCursorResult;
@@ -80,7 +87,9 @@ class AsyncCommandCursor implements AsyncCursor {
final Decoder decoder,
@Nullable final BsonValue comment,
final AsyncConnectionSource connectionSource,
- final AsyncConnection connection) {
+ final AsyncConnection connection,
+ final boolean retryReads,
+ @Nullable final Integer maxAdaptiveRetriesSetting) {
ConnectionDescription connectionDescription = connection.getDescription();
this.commandCursorResult = toCommandCursorResult(connectionDescription.getServerAddress(), FIRST_BATCH, commandCursorDocument);
this.namespace = commandCursorResult.getNamespace();
@@ -92,6 +101,8 @@ class AsyncCommandCursor implements AsyncCursor {
AsyncConnection connectionToPin = connectionSource.getServerDescription().getType() == ServerType.LOAD_BALANCER
? connection : null;
resourceManager = new ResourceManager(namespace, connectionSource, connectionToPin, commandCursorResult.getServerCursor());
+ this.retryReads = retryReads;
+ this.maxAdaptiveRetriesSetting = maxAdaptiveRetriesSetting;
}
@Override
@@ -181,16 +192,24 @@ private void getMoreLoop(final ServerCursor localServerCursor,
}
private void getMore(final ServerCursor cursor, final OperationContext operationContext, final SingleResultCallback> callback) {
- resourceManager.executeWithConnection(operationContext, (connection, wrappedCallback) ->
- executeGetMoreCommand(assertNotNull(connection), cursor, operationContext, wrappedCallback), callback);
+ RetryControl retryControl = createSpecRetryControl(
+ overloadForRead(retryReads, maxAdaptiveRetriesSetting), operationContext);
+ AsyncCallbackSupplier> retryingCommandExecutor = decorateWithRetriesAsync(retryControl, operationContext, attemptCallback ->
+ resourceManager.executeWithConnection(operationContext, (connection, wrappedCallback) ->
+ executeGetMoreCommand(assertNotNull(connection), cursor, operationContext, retryControl, wrappedCallback),
+ attemptCallback));
+ retryingCommandExecutor.get(callback);
}
private void executeGetMoreCommand(final AsyncConnection connection,
final ServerCursor serverCursor,
final OperationContext operationContext,
+ final RetryControl retryControl,
final SingleResultCallback> callback) {
+ BsonDocument command = getMoreCommandDocument(serverCursor.getId(), connection.getDescription(), namespace, batchSize, comment);
+ retryControl.getPolicy().onCommand(command::getFirstKey);
connection.commandAsync(namespace.getDatabaseName(),
- getMoreCommandDocument(serverCursor.getId(), connection.getDescription(), namespace, batchSize, comment),
+ command,
NoOpFieldNameValidator.INSTANCE, ReadPreference.primary(),
CommandResultDocumentCodec.create(decoder, NEXT_BATCH),
operationContext,
diff --git a/driver-core/src/main/com/mongodb/internal/operation/AsyncOperationHelper.java b/driver-core/src/main/com/mongodb/internal/operation/AsyncOperationHelper.java
index 91e52ca1baf..15c5e235f6f 100644
--- a/driver-core/src/main/com/mongodb/internal/operation/AsyncOperationHelper.java
+++ b/driver-core/src/main/com/mongodb/internal/operation/AsyncOperationHelper.java
@@ -21,14 +21,16 @@
import com.mongodb.ReadPreference;
import com.mongodb.assertions.Assertions;
import com.mongodb.client.cursor.TimeoutMode;
+import com.mongodb.connection.ConnectionDescription;
import com.mongodb.connection.ServerDescription;
import com.mongodb.internal.TimeoutContext;
import com.mongodb.internal.async.AsyncBatchCursor;
+import com.mongodb.internal.async.MutableValue;
import com.mongodb.internal.async.SingleResultCallback;
import com.mongodb.internal.async.function.AsyncCallbackFunction;
import com.mongodb.internal.async.function.AsyncCallbackSupplier;
import com.mongodb.internal.async.function.AsyncCallbackTriFunction;
-import com.mongodb.internal.async.function.RetryState;
+import com.mongodb.internal.async.function.RetryControl;
import com.mongodb.internal.async.function.RetryingAsyncCallbackSupplier;
import com.mongodb.internal.binding.AsyncConnectionSource;
import com.mongodb.internal.binding.AsyncReadBinding;
@@ -36,7 +38,7 @@
import com.mongodb.internal.binding.ReferenceCounted;
import com.mongodb.internal.connection.AsyncConnection;
import com.mongodb.internal.connection.OperationContext;
-import com.mongodb.internal.operation.retry.AttachmentKeys;
+import com.mongodb.internal.session.SessionContext;
import com.mongodb.internal.validator.NoOpFieldNameValidator;
import com.mongodb.lang.Nullable;
import org.bson.BsonDocument;
@@ -48,16 +50,15 @@
import java.util.Collections;
import java.util.List;
+import static com.mongodb.assertions.Assertions.assertFalse;
import static com.mongodb.assertions.Assertions.assertNotNull;
+import static com.mongodb.internal.async.AsyncRunnable.beginAsync;
import static com.mongodb.internal.async.ErrorHandlingResultCallback.errorHandlingCallback;
import static com.mongodb.internal.operation.CommandOperationHelper.CommandCreator;
-import static com.mongodb.internal.operation.CommandOperationHelper.addRetryableWriteErrorLabel;
-import static com.mongodb.internal.operation.CommandOperationHelper.initialRetryState;
-import static com.mongodb.internal.operation.CommandOperationHelper.isRetryableWriteCommand;
-import static com.mongodb.internal.operation.CommandOperationHelper.logRetryCommand;
-import static com.mongodb.internal.operation.CommandOperationHelper.onRetryableReadAttemptFailure;
-import static com.mongodb.internal.operation.CommandOperationHelper.onRetryableWriteAttemptFailure;
+import static com.mongodb.internal.operation.CommandOperationHelper.createSpecRetryControl;
import static com.mongodb.internal.operation.CommandOperationHelper.transformWriteException;
+import static com.mongodb.internal.operation.CommandOperationHelper.isWriteRetryRequirementsMet;
+import static com.mongodb.internal.operation.OperationHelper.isServerWriteRetryRequirementsMet;
import static com.mongodb.internal.operation.WriteConcernHelper.throwOnWriteConcernError;
final class AsyncOperationHelper {
@@ -110,8 +111,7 @@ static void withAsyncSourceAndConnection(
final boolean wrapConnectionSourceException,
final OperationContext operationContext,
final SingleResultCallback callback,
- final AsyncCallbackTriFunction asyncFunction)
- throws OperationHelper.ResourceSupplierInternalException {
+ final AsyncCallbackTriFunction asyncFunction) {
SingleResultCallback errorHandlingCallback = errorHandlingCallback(callback, OperationHelper.LOGGER);
OperationContext serverSelectionOperationContext =
@@ -140,8 +140,7 @@ static void withAsyncSuppliedResource(final Asyn
final boolean wrapSourceConnectionException,
final OperationContext operationContext,
final SingleResultCallback callback,
- final AsyncCallbackFunction function)
- throws OperationHelper.ResourceSupplierInternalException {
+ final AsyncCallbackFunction function) {
SingleResultCallback errorHandlingCallback = errorHandlingCallback(callback, OperationHelper.LOGGER);
resourceSupplier.apply(operationContext, (resource, supplierException) -> {
if (supplierException != null) {
@@ -176,10 +175,11 @@ static void executeRetryableReadAsync(
final CommandCreator commandCreator,
final Decoder decoder,
final CommandReadTransformerAsync transformer,
- final boolean retryReads,
+ final boolean retryReadsSetting,
+ @Nullable final Integer maxAdaptiveRetriesSetting,
final SingleResultCallback callback) {
executeRetryableReadAsync(binding, operationContext, binding::getReadConnectionSource, database, commandCreator,
- decoder, transformer, retryReads, callback);
+ decoder, transformer, retryReadsSetting, maxAdaptiveRetriesSetting, callback);
}
static void executeRetryableReadAsync(
@@ -190,19 +190,46 @@ static void executeRetryableReadAsync(
final CommandCreator commandCreator,
final Decoder decoder,
final CommandReadTransformerAsync transformer,
- final boolean retryReads,
+ final boolean retryReadsSetting,
+ @Nullable final Integer maxAdaptiveRetriesSetting,
final SingleResultCallback callback) {
- RetryState retryState = initialRetryState(retryReads, operationContext.getTimeoutContext());
+ executeRetryableReadAsync(binding, operationContext, sourceAsyncFunction, database, commandCreator, decoder, transformer,
+ new SpecRetryPolicy.IndividualPolicies(retryReadsSetting)
+ .includeRead(operationContext)
+ .includeOverload(maxAdaptiveRetriesSetting),
+ callback);
+ }
+
+ static void executeRetryableReadAsync(
+ final AsyncReadBinding binding,
+ final OperationContext operationContext,
+ final String database,
+ final CommandCreator commandCreator,
+ final Decoder decoder,
+ final CommandReadTransformerAsync transformer,
+ final SpecRetryPolicy.IndividualPolicies policies,
+ final SingleResultCallback callback) {
+ executeRetryableReadAsync(binding, operationContext, binding::getReadConnectionSource, database, commandCreator,
+ decoder, transformer, policies, callback);
+ }
+
+ static void executeRetryableReadAsync(
+ final AsyncReadBinding binding,
+ final OperationContext operationContext,
+ final AsyncCallbackFunction sourceAsyncFunction,
+ final String database,
+ final CommandCreator commandCreator,
+ final Decoder decoder,
+ final CommandReadTransformerAsync transformer,
+ final SpecRetryPolicy.IndividualPolicies policies,
+ final SingleResultCallback callback) {
+ RetryControl retryControl = createSpecRetryControl(policies, operationContext);
binding.retain();
- AsyncCallbackSupplier asyncRead = decorateReadWithRetriesAsync(retryState, operationContext,
+ AsyncCallbackSupplier asyncRead = decorateWithRetriesAsync(retryControl, operationContext,
(AsyncCallbackSupplier) funcCallback ->
withAsyncSourceAndConnection(sourceAsyncFunction, false, operationContext, funcCallback,
(source, connection, operationContextWithMinRtt, releasingCallback) -> {
- if (retryState.breakAndCompleteIfRetryAnd(
- () -> !OperationHelper.canRetryRead(operationContextWithMinRtt), releasingCallback)) {
- return;
- }
- createReadCommandAndExecuteAsync(retryState, operationContextWithMinRtt, source, database,
+ createReadCommandAndExecuteAsync(retryControl, operationContextWithMinRtt, source, database,
commandCreator, decoder, transformer, connection, releasingCallback);
})
).whenComplete(binding::release);
@@ -242,12 +269,13 @@ static void executeCommandAsync(final AsyncWriteBinding binding,
final CommandWriteTransformerAsync transformer,
final SingleResultCallback callback) {
Assertions.notNull("binding", binding);
- SingleResultCallback addingRetryableLabelCallback = addingRetryableLabelCallback(callback,
- connection.getDescription().getMaxWireVersion());
connection.commandAsync(database, command, NoOpFieldNameValidator.INSTANCE, ReadPreference.primary(), new BsonDocumentCodec(),
- operationContext, transformingWriteCallback(transformer, connection, addingRetryableLabelCallback));
+ operationContext, transformingWriteCallback(transformer, connection, callback));
}
+ /**
+ * @param effectiveRetryWritesSetting See {@link SpecRetryPolicy}.
+ */
static void executeRetryableWriteAsync(
final AsyncWriteBinding binding,
final OperationContext operationContext,
@@ -258,57 +286,54 @@ static void executeRetryableWriteAsync(
final CommandCreator commandCreator,
final CommandWriteTransformerAsync transformer,
final Function retryCommandModifier,
+ final boolean effectiveRetryWritesSetting,
+ @Nullable final Integer maxAdaptiveRetriesSetting,
final SingleResultCallback callback) {
-
- RetryState retryState = initialRetryState(true, operationContext.getTimeoutContext());
- binding.retain();
-
- AsyncCallbackSupplier asyncWrite = decorateWriteWithRetriesAsync(retryState, operationContext,
- (AsyncCallbackSupplier) funcCallback -> {
- boolean firstAttempt = retryState.isFirstAttempt();
- if (!firstAttempt && operationContext.getSessionContext().hasActiveTransaction()) {
- operationContext.getSessionContext().clearTransactionContext();
- }
- withAsyncSourceAndConnection(binding::getWriteConnectionSource, true, operationContext, funcCallback,
- (source, connection, operationContextWithMinRtt, releasingCallback) -> {
- int maxWireVersion = connection.getDescription().getMaxWireVersion();
- SingleResultCallback addingRetryableLabelCallback = firstAttempt
- ? releasingCallback
- : addingRetryableLabelCallback(releasingCallback, maxWireVersion);
- if (retryState.breakAndCompleteIfRetryAnd(() ->
- !OperationHelper.canRetryWrite(connection.getDescription()), addingRetryableLabelCallback)) {
- return;
- }
- BsonDocument command;
- try {
- command = retryState.attachment(AttachmentKeys.command())
- .map(previousAttemptCommand -> {
- Assertions.assertFalse(firstAttempt);
- return retryCommandModifier.apply(previousAttemptCommand);
- }).orElseGet(() -> commandCreator.create(
- operationContextWithMinRtt,
- source.getServerDescription(),
- connection.getDescription()));
- // attach `maxWireVersion`, `retryableWriteCommandFlag` ASAP because they are used to check whether we should retry
- retryState.attach(AttachmentKeys.maxWireVersion(), maxWireVersion, true)
- .attach(AttachmentKeys.retryableWriteCommandFlag(), isRetryableWriteCommand(command), true)
- .attach(AttachmentKeys.commandDescriptionSupplier(), command::getFirstKey, false)
- .attach(AttachmentKeys.command(), command, false);
- } catch (Throwable t) {
- addingRetryableLabelCallback.onResult(null, t);
- return;
- }
- connection.commandAsync(database, command, fieldNameValidator, readPreference, commandResultDecoder,
- operationContextWithMinRtt,
- transformingWriteCallback(transformer, connection, addingRetryableLabelCallback));
- });
- }).whenComplete(binding::release);
-
- asyncWrite.get(exceptionTransformingCallback(errorHandlingCallback(callback, OperationHelper.LOGGER)));
+ beginAsync().thenSupply(c -> {
+ binding.retain();
+ MutableValue command = new MutableValue<>();
+ RetryControl retryControl = createSpecRetryControl(
+ new SpecRetryPolicy.IndividualPolicies(effectiveRetryWritesSetting).includeWrite().includeOverload(maxAdaptiveRetriesSetting),
+ operationContext);
+ AsyncCallbackSupplier retryingWrite = decorateWithRetriesAsync(retryControl, operationContext, supplierCallback -> {
+ beginAsync().thenSupply(withSourceAndConnectionCallback -> {
+ boolean firstAttempt = retryControl.isFirstAttempt();
+ SessionContext sessionContext = operationContext.getSessionContext();
+ if (!firstAttempt && sessionContext.hasActiveTransaction()) {
+ sessionContext.clearTransactionContext();
+ }
+ withAsyncSourceAndConnection(binding::getWriteConnectionSource, true, operationContext, withSourceAndConnectionCallback,
+ (source, connection, operationContextWithMinRtt, functionCallback) -> {
+ beginAsync().thenSupply(executeCommandCallback -> {
+ ConnectionDescription connectionDescription = connection.getDescription();
+ retryControl.breakAndThrowIfRetryAnd(() -> !isServerWriteRetryRequirementsMet(connectionDescription));
+ if (command.getNullable() == null) {
+ command.set(commandCreator.create(operationContextWithMinRtt, source.getServerDescription(), connectionDescription));
+ } else {
+ assertFalse(firstAttempt);
+ command.set(retryCommandModifier.apply(command.get()));
+ }
+ retryControl.getPolicy()
+ .onCommand(() -> command.get().getFirstKey())
+ .onWriteRetryRequirements(isWriteRetryRequirementsMet(command.get()), connectionDescription);
+ connection.commandAsync(database, command.get(), fieldNameValidator, readPreference,
+ commandResultDecoder, operationContextWithMinRtt, executeCommandCallback);
+ }).thenApply((result, transformResultCallback) -> {
+ transformResultCallback.complete(transformer.apply(assertNotNull(result), connection));
+ }).finish(functionCallback);
+ });
+ }).finish(supplierCallback);
+ });
+ beginAsync().thenSupply(retryingWriteCallback -> {
+ retryingWrite.get(retryingWriteCallback);
+ }).onErrorIf(e -> e instanceof MongoException, (e, onErrorCallback) -> {
+ throw transformWriteException((MongoException) e);
+ }).finish(c);
+ }).thenAlwaysRunAndFinish(binding::release, callback);
}
static void createReadCommandAndExecuteAsync(
- final RetryState retryState,
+ final RetryControl retryControl,
final OperationContext operationContext,
final AsyncConnectionSource source,
final String database,
@@ -320,7 +345,7 @@ static void createReadCommandAndExecuteAsync(
BsonDocument command;
try {
command = commandCreator.create(operationContext, source.getServerDescription(), connection.getDescription());
- retryState.attach(AttachmentKeys.commandDescriptionSupplier(), command::getFirstKey, false);
+ retryControl.getPolicy().onCommand(command::getFirstKey);
} catch (IllegalArgumentException e) {
callback.onResult(null, e);
return;
@@ -329,22 +354,18 @@ static void createReadCommandAndExecuteAsync(
operationContext, transformingReadCallback(transformer, source, connection, operationContext, callback));
}
- static AsyncCallbackSupplier decorateReadWithRetriesAsync(final RetryState retryState, final OperationContext operationContext,
- final AsyncCallbackSupplier asyncReadFunction) {
- return new RetryingAsyncCallbackSupplier<>(retryState, onRetryableReadAttemptFailure(operationContext),
- CommandOperationHelper::loggingShouldAttemptToRetryRead, callback -> {
- logRetryCommand(retryState, operationContext);
- asyncReadFunction.get(callback);
- });
- }
-
- static AsyncCallbackSupplier decorateWriteWithRetriesAsync(final RetryState retryState, final OperationContext operationContext,
- final AsyncCallbackSupplier asyncWriteFunction) {
- return new RetryingAsyncCallbackSupplier<>(retryState, onRetryableWriteAttemptFailure(operationContext),
- CommandOperationHelper::loggingShouldAttemptToRetryWriteAndAddRetryableLabel, callback -> {
- logRetryCommand(retryState, operationContext);
- asyncWriteFunction.get(callback);
- });
+ static AsyncCallbackSupplier decorateWithRetriesAsync(
+ final RetryControl retryControl,
+ final OperationContext operationContext,
+ final AsyncCallbackSupplier supplier) {
+ return (callback) -> {
+ beginAsync().thenSupply(c -> {
+ new RetryingAsyncCallbackSupplier(operationContext.getClientExecutor(), retryControl, supplierCallback -> {
+ retryControl.getPolicy().onAttemptStart(retryControl, operationContext);
+ supplier.get(supplierCallback);
+ }).get(c);
+ }).thenAlwaysRunAndFinish(() -> retryControl.getPolicy().onLastAttemptCompletion(), callback);
+ };
}
static CommandWriteTransformerAsync writeConcernErrorTransformerAsync(final TimeoutContext timeoutContext) {
@@ -369,9 +390,11 @@ static AsyncBatchCursor cursorDocumentToAsyncBatchCursor(final TimeoutMod
@Nullable final BsonValue comment,
final AsyncConnectionSource source,
final AsyncConnection connection,
- final OperationContext operationContext) {
+ final OperationContext operationContext,
+ final boolean retryReads,
+ @Nullable final Integer maxAdaptiveRetriesSetting) {
return new AsyncCommandBatchCursor<>(timeoutMode, 0, operationContext, new AsyncCommandCursor<>(
- cursorDocument, batchSize, decoder, comment, source, connection
+ cursorDocument, batchSize, decoder, comment, source, connection, retryReads, maxAdaptiveRetriesSetting
));
}
@@ -379,20 +402,6 @@ static SingleResultCallback releasingCallback(final SingleResultCallback<
return new ReferenceCountedReleasingWrappedCallback<>(wrapped, Collections.singletonList(connection));
}
- static SingleResultCallback exceptionTransformingCallback(final SingleResultCallback callback) {
- return (result, t) -> {
- if (t != null) {
- if (t instanceof MongoException) {
- callback.onResult(null, transformWriteException((MongoException) t));
- } else {
- callback.onResult(null, t);
- }
- } else {
- callback.onResult(result, null);
- }
- };
- }
-
private static SingleResultCallback