Skip to content

Commit 9f550b0

Browse files
papafepapafe
committed
CSHARP-6089: Rename retryAfterMS to baseBackoffMS per updated spec
1 parent f60f1ed commit 9f550b0

8 files changed

Lines changed: 49 additions & 49 deletions

File tree

‎src/MongoDB.Driver/Core/Operations/RetryabilityHelper.cs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -134,15 +134,15 @@ public static int GetRetryDelayMs(IRandom random, int attempt, double backoffBas
134134
/// </summary>
135135
/// <param name="attempt">The retry attempt number.</param>
136136
/// <param name="random">The random number generator.</param>
137-
/// <param name="retryAfterMs">
138-
/// A server-supplied backoff base (from the overload error's <c>retryAfterMS</c> field) that overrides
137+
/// <param name="baseBackoffMs">
138+
/// A server-supplied backoff base (from the overload error's <c>baseBackoffMS</c> field) that overrides
139139
/// the driver's default initial backoff, or <see langword="null"/> to use the default.
140140
/// </param>
141-
public static TimeSpan GetOperationRetryBackoffDelay(int attempt, IRandom random, int? retryAfterMs = null)
141+
public static TimeSpan GetOperationRetryBackoffDelay(int attempt, IRandom random, int? baseBackoffMs = null)
142142
{
143143
// Limit a server-supplied override to MaxBackoff so the backoff still resolves to min(MaxBackoff, ...) rather than tripping GetRetryDelayMs's guard.
144144
var initialBackoff = Math.Min(
145-
retryAfterMs ?? OperationRetryBackpressureConstants.InitialBackoff,
145+
baseBackoffMs ?? OperationRetryBackpressureConstants.InitialBackoff,
146146
OperationRetryBackpressureConstants.MaxBackoff);
147147
return TimeSpan.FromMilliseconds(
148148
GetRetryDelayMs(
@@ -154,14 +154,14 @@ public static TimeSpan GetOperationRetryBackoffDelay(int attempt, IRandom random
154154
}
155155

156156
/// <summary>
157-
/// Reads a server-supplied backoff override (the <c>retryAfterMS</c> field) from a retryable overload error,
157+
/// Reads a server-supplied backoff override (the <c>baseBackoffMS</c> field) from a retryable overload error,
158158
/// or <see langword="null"/> when absent. Only <see cref="MongoCommandException"/> results are inspected; a
159159
/// missing, non-numeric, or non-positive value is treated as absent.
160160
/// </summary>
161-
public static int? GetRetryAfterMs(Exception exception)
161+
public static int? GetBaseBackoffMs(Exception exception)
162162
{
163163
if (exception is MongoCommandException { Result: { } result } &&
164-
result.TryGetValue("retryAfterMS", out var value) &&
164+
result.TryGetValue("baseBackoffMS", out var value) &&
165165
value.IsNumeric)
166166
{
167167
var ms = value.ToInt64();

‎src/MongoDB.Driver/Core/Operations/RetryableReadOperationExecutor.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -165,8 +165,8 @@ private static bool ShouldRetry(
165165
currentTransaction.ResetState();
166166
}
167167

168-
var retryAfterMs = RetryabilityHelper.GetRetryAfterMs(exception);
169-
backoff = RetryabilityHelper.GetOperationRetryBackoffDelay(attempt, random, retryAfterMs);
168+
var baseBackoffMs = RetryabilityHelper.GetBaseBackoffMs(exception);
169+
backoff = RetryabilityHelper.GetOperationRetryBackoffDelay(attempt, random, baseBackoffMs);
170170

171171
return attempt <= context.MaxAdaptiveRetries;
172172
}

‎src/MongoDB.Driver/Core/Operations/RetryableWriteOperationExecutor.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -232,8 +232,8 @@ private static bool ShouldRetry(
232232
currentTransaction.ResetState();
233233
}
234234

235-
var retryAfterMs = RetryabilityHelper.GetRetryAfterMs(exception);
236-
backoff = RetryabilityHelper.GetOperationRetryBackoffDelay(attempt, random, retryAfterMs);
235+
var baseBackoffMs = RetryabilityHelper.GetBaseBackoffMs(exception);
236+
backoff = RetryabilityHelper.GetOperationRetryBackoffDelay(attempt, random, baseBackoffMs);
237237

238238
return attempt <= context.MaxAdaptiveRetries;
239239
}

‎tests/MongoDB.Driver.Tests/Core/Operations/RetryabilityHelperTests.cs‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -290,30 +290,30 @@ public void IsRetryableWriteException_should_return_expected_result([Values(fals
290290
}
291291

292292
[Fact]
293-
public void GetRetryAfterMs_should_return_null_for_non_command_exception()
293+
public void GetBaseBackoffMs_should_return_null_for_non_command_exception()
294294
{
295295
var exception = CoreExceptionHelper.CreateException(typeof(MongoConnectionException));
296296

297-
var retryAfterMs = RetryabilityHelper.GetRetryAfterMs(exception);
297+
var baseBackoffMs = RetryabilityHelper.GetBaseBackoffMs(exception);
298298

299-
retryAfterMs.Should().Be(null);
299+
baseBackoffMs.Should().Be(null);
300300
}
301301

302302
[Theory]
303303
[InlineData("{ ok : 0, code : 2 }", null)]
304-
[InlineData("{ ok : 0, code : 2, retryAfterMS : 0 }", null)]
305-
[InlineData("{ ok : 0, code : 2, retryAfterMS : -5 }", null)]
306-
[InlineData("{ ok : 0, code : 2, retryAfterMS : 'not-a-number' }", null)]
307-
[InlineData("{ ok : 0, code : 2, retryAfterMS : 50 }", 50)]
308-
[InlineData("{ ok : 0, code : 2, retryAfterMS : NumberLong(9999999999) }", int.MaxValue)]
309-
public void GetRetryAfterMs_should_return_expected_result(string resultJson, int? expectedValue)
304+
[InlineData("{ ok : 0, code : 2, baseBackoffMS : 0 }", null)]
305+
[InlineData("{ ok : 0, code : 2, baseBackoffMS : -5 }", null)]
306+
[InlineData("{ ok : 0, code : 2, baseBackoffMS : 'not-a-number' }", null)]
307+
[InlineData("{ ok : 0, code : 2, baseBackoffMS : 50 }", 50)]
308+
[InlineData("{ ok : 0, code : 2, baseBackoffMS : NumberLong(9999999999) }", int.MaxValue)]
309+
public void GetBaseBackoffMs_should_return_expected_result(string resultJson, int? expectedValue)
310310
{
311311
var result = BsonDocument.Parse(resultJson);
312312
var exception = CoreExceptionHelper.CreateMongoCommandExceptionWithLabels(result);
313313

314-
var retryAfterMs = RetryabilityHelper.GetRetryAfterMs(exception);
314+
var baseBackoffMs = RetryabilityHelper.GetBaseBackoffMs(exception);
315315

316-
retryAfterMs.Should().Be(expectedValue);
316+
baseBackoffMs.Should().Be(expectedValue);
317317
}
318318

319319
[Theory]
@@ -323,22 +323,22 @@ public void GetRetryAfterMs_should_return_expected_result(string resultJson, int
323323
[InlineData(2, 50, 0, 100)]
324324
[InlineData(1, 10000, 0, 10000)]
325325
[InlineData(2, 20000, 0, 10000)]
326-
public void GetOperationRetryBackoffDelay_should_apply_retryAfterMs_override(int attempt, int? retryAfterMs, int expectedRangeMin, int expectedRangeMax)
326+
public void GetOperationRetryBackoffDelay_should_apply_baseBackoffMs_override(int attempt, int? baseBackoffMs, int expectedRangeMin, int expectedRangeMax)
327327
{
328-
var result = RetryabilityHelper.GetOperationRetryBackoffDelay(attempt, DefaultRandom.Instance, retryAfterMs);
328+
var result = RetryabilityHelper.GetOperationRetryBackoffDelay(attempt, DefaultRandom.Instance, baseBackoffMs);
329329

330330
result.TotalMilliseconds.Should().BeInRange(expectedRangeMin, expectedRangeMax);
331331
}
332332

333333
[Theory]
334334
[InlineData(1, 10000, 10000)]
335335
[InlineData(2, 20000, 10000)]
336-
public void GetOperationRetryBackoffDelay_should_limit_override_to_MaxBackoff(int attempt, int retryAfterMs, int expectedMs)
336+
public void GetOperationRetryBackoffDelay_should_limit_override_to_MaxBackoff(int attempt, int baseBackoffMs, int expectedMs)
337337
{
338338
var randomMock = new Mock<IRandom>();
339339
randomMock.Setup(r => r.NextDouble()).Returns(1.0);
340340

341-
var result = RetryabilityHelper.GetOperationRetryBackoffDelay(attempt, randomMock.Object, retryAfterMs);
341+
var result = RetryabilityHelper.GetOperationRetryBackoffDelay(attempt, randomMock.Object, baseBackoffMs);
342342

343343
result.TotalMilliseconds.Should().Be(expectedMs);
344344
}

‎tests/MongoDB.Driver.Tests/Core/Operations/RetryableReadOperationExecutorTests.cs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -141,14 +141,14 @@ public void ShouldRetry_with_system_overloaded_exception_should_not_retry_when_r
141141
[InlineData(2, 50, 0, 100)]
142142
[InlineData(1, 10000, 0, 10000)]
143143
[InlineData(2, 20000, 0, 10000)]
144-
public void ShouldRetry_with_retryAfterMs_should_use_it_as_backoff_base(
144+
public void ShouldRetry_with_baseBackoffMs_should_use_it_as_backoff_base(
145145
int attempt,
146-
int retryAfterMs,
146+
int baseBackoffMs,
147147
int expectedRangeMinMs,
148148
int expectedRangeMaxMs)
149149
{
150150
var context = CreateContext(retryRequested: true, isInTransaction: false);
151-
var result = BsonDocument.Parse($"{{ ok : 0, code : 2, retryAfterMS : {retryAfterMs} }}");
151+
var result = BsonDocument.Parse($"{{ ok : 0, code : 2, baseBackoffMS : {baseBackoffMs} }}");
152152
var exception = CoreExceptionHelper.CreateMongoCommandExceptionWithLabels(result, "SystemOverloadedError", "RetryableError");
153153
var operationContext = new OperationContext(null, CancellationToken.None);
154154
var randomMock = new Mock<IRandom>();

‎tests/MongoDB.Driver.Tests/Core/Operations/RetryableWriteOperationExecutorTests.cs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -95,14 +95,14 @@ public void IsOperationAcknowledged_should_return_expected_result(bool? isAcknow
9595
[InlineData(2, 50, 0, 100)]
9696
[InlineData(1, 10000, 0, 10000)]
9797
[InlineData(2, 20000, 0, 10000)]
98-
public void ShouldRetry_with_retryAfterMs_should_use_it_as_backoff_base(
98+
public void ShouldRetry_with_baseBackoffMs_should_use_it_as_backoff_base(
9999
int attempt,
100-
int retryAfterMs,
100+
int baseBackoffMs,
101101
int expectedRangeMinMs,
102102
int expectedRangeMaxMs)
103103
{
104104
var context = CreateContext(retryRequested: true, areRetryableWritesSupported: true, hasSessionId: true, isInTransaction: false);
105-
var result = BsonDocument.Parse($"{{ ok : 0, code : 2, retryAfterMS : {retryAfterMs} }}");
105+
var result = BsonDocument.Parse($"{{ ok : 0, code : 2, baseBackoffMS : {baseBackoffMs} }}");
106106
var exception = CoreExceptionHelper.CreateMongoCommandExceptionWithLabels(result, "SystemOverloadedError", "RetryableError");
107107
var operationContext = new OperationContext(null, CancellationToken.None);
108108
var randomMock = new Mock<IRandom>();

‎tests/MongoDB.Driver.Tests/Core/WireProtocol/CommandWriteProtocolTests.cs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -487,7 +487,7 @@ ICoreSession CreateTransactionSession()
487487

488488
[Theory]
489489
[ParameterAttributeData]
490-
public async Task Execute_should_preserve_server_supplied_retryAfterMS_in_the_command_exception(
490+
public async Task Execute_should_preserve_server_supplied_baseBackoffMS_in_the_command_exception(
491491
[Values(false, true)] bool async)
492492
{
493493
var connection = new MockConnection();
@@ -498,7 +498,7 @@ public async Task Execute_should_preserve_server_supplied_retryAfterMS_in_the_co
498498
{ "code", 462 },
499499
{ "errmsg", "overloaded" },
500500
{ "errorLabels", new BsonArray { "SystemOverloadedError", "RetryableError" } },
501-
{ "retryAfterMS", 50 }
501+
{ "baseBackoffMS", 50 }
502502
};
503503
connection.EnqueueCommandResponseMessage(
504504
MessageHelper.BuildCommandResponse(CreateRawBsonDocument(errorResponse)));
@@ -521,8 +521,8 @@ public async Task Execute_should_preserve_server_supplied_retryAfterMS_in_the_co
521521
: Record.Exception(() => subject.Execute(OperationContext.NoTimeout, connection));
522522

523523
var commandException = exception.Should().BeOfType<MongoCommandException>().Subject;
524-
commandException.Result["retryAfterMS"].ToInt32().Should().Be(50);
525-
RetryabilityHelper.GetRetryAfterMs(commandException).Should().Be(50);
524+
commandException.Result["baseBackoffMS"].ToInt32().Should().Be(50);
525+
RetryabilityHelper.GetBaseBackoffMs(commandException).Should().Be(50);
526526
}
527527

528528
// private methods

‎tests/MongoDB.Driver.Tests/Specifications/client-backpressure/prose-tests/ClientBackpressureProseTests.cs‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -86,10 +86,10 @@ await AssertBackoffBehavior(
8686
[Theory]
8787
[InlineData(false)]
8888
[InlineData(true)]
89-
// https://github.com/mongodb/specifications/pull/1953 (Test 5: overload errors with retryAfterMS override base backoff)
90-
public async Task ReadExecute_should_use_retryAfterMs_as_backoff_base(bool async)
89+
// https://github.com/mongodb/specifications/pull/1953 (Test 5: overload errors with baseBackoffMS override base backoff)
90+
public async Task ReadExecute_should_use_baseBackoffMs_as_backoff_base(bool async)
9191
{
92-
await AssertRetryAfterMsOverridesBackoff(
92+
await AssertBaseBackoffMsOverridesBackoff(
9393
async,
9494
random => CreateRetryableReadContext(random),
9595
exception =>
@@ -110,10 +110,10 @@ await AssertRetryAfterMsOverridesBackoff(
110110
[Theory]
111111
[InlineData(false)]
112112
[InlineData(true)]
113-
// https://github.com/mongodb/specifications/pull/1953 (Test 5: overload errors with retryAfterMS override base backoff)
114-
public async Task WriteExecute_should_use_retryAfterMs_as_backoff_base(bool async)
113+
// https://github.com/mongodb/specifications/pull/1953 (Test 5: overload errors with baseBackoffMS override base backoff)
114+
public async Task WriteExecute_should_use_baseBackoffMs_as_backoff_base(bool async)
115115
{
116-
await AssertRetryAfterMsOverridesBackoff(
116+
await AssertBaseBackoffMsOverridesBackoff(
117117
async,
118118
random => CreateRetryableWriteContext(random),
119119
exception =>
@@ -176,7 +176,7 @@ private async Task AssertBackoffBehavior<TContext>(
176176
$"backoff difference should be approximately 300ms, got {difference}ms (noBackoff: {noBackoffTime}ms, withBackoff: {withBackoffTime}ms)");
177177
}
178178

179-
private async Task AssertRetryAfterMsOverridesBackoff<TOperation, TContext>(
179+
private async Task AssertBaseBackoffMsOverridesBackoff<TOperation, TContext>(
180180
bool async,
181181
Func<IRandom, TContext> createContext,
182182
Func<Exception, TOperation> createOperation,
@@ -188,18 +188,18 @@ private async Task AssertRetryAfterMsOverridesBackoff<TOperation, TContext>(
188188
var fullJitterRandom = new Mock<IRandom>();
189189
fullJitterRandom.Setup(r => r.NextDouble()).Returns(1.0);
190190

191-
// Exponential backoff run: overload error without retryAfterMS -> 100ms + 200ms = 300ms with jitter = 1.
191+
// Exponential backoff run: overload error without baseBackoffMS -> 100ms + 200ms = 300ms with jitter = 1.
192192
var exponentialException = CoreExceptionHelper.CreateMongoCommandExceptionWithLabels(462, "SystemOverloadedError", "RetryableError");
193193
var exponentialMs = await MeasureBackoff(async, executeSync, executeAsync, operationContext, createOperation(exponentialException), createContext(fullJitterRandom.Object));
194194

195-
// retryAfterMS override run: overload error with retryAfterMS = 50 -> 50ms + 100ms = 150ms with jitter = 1.
196-
var overrideResult = BsonDocument.Parse("{ ok : 0, code : 462, retryAfterMS : 50 }");
195+
// baseBackoffMS override run: overload error with baseBackoffMS = 50 -> 50ms + 100ms = 150ms with jitter = 1.
196+
var overrideResult = BsonDocument.Parse("{ ok : 0, code : 462, baseBackoffMS : 50 }");
197197
var overrideException = CoreExceptionHelper.CreateMongoCommandExceptionWithLabels(overrideResult, "SystemOverloadedError", "RetryableError");
198-
var withRetryAfterMs = await MeasureBackoff(async, executeSync, executeAsync, operationContext, createOperation(overrideException), createContext(fullJitterRandom.Object));
198+
var withBaseBackoffMs = await MeasureBackoff(async, executeSync, executeAsync, operationContext, createOperation(overrideException), createContext(fullJitterRandom.Object));
199199

200200
// Per the spec: assertTrue(abs(exponential_backoff_time - (with_retry_after_ms_time + 0.2s)) < 0.2s)
201-
Math.Abs(exponentialMs - (withRetryAfterMs + 200)).Should().BeLessThan(200,
202-
$"retryAfterMS should shorten the backoff base (exponential: {exponentialMs}ms, withRetryAfterMS: {withRetryAfterMs}ms)");
201+
Math.Abs(exponentialMs - (withBaseBackoffMs + 200)).Should().BeLessThan(200,
202+
$"baseBackoffMS should shorten the backoff base (exponential: {exponentialMs}ms, withBaseBackoffMS: {withBaseBackoffMs}ms)");
203203
}
204204

205205
private static async Task<long> MeasureBackoff<TOperation, TContext>(

0 commit comments

Comments
 (0)