CSHARP-2229: Added RetryabilityHelper

rstam · rstam · commit d250d9f4d429 · 2018-04-09T13:42:08.000-04:00
diff --git a/src/MongoDB.Driver.Core/Core/Operations/ChangeStreamCursor.cs b/src/MongoDB.Driver.Core/Core/Operations/ChangeStreamCursor.cs
@@ -88,7 +88,7 @@ public void Dispose()
             }
             catch (Exception ex)
             {
-                if (CanResumeAfter(ex))
+                if (RetryabilityHelper.IsResumableChangeStreamException(ex))
                 {
                     _cursor = _changeStreamOperation.Resume(_binding, _resumeToken, cancellationToken);
                     hasMore = _cursor.MoveNext(cancellationToken);
@@ -113,7 +113,7 @@ public void Dispose()
             }
             catch (Exception ex)
             {
-                if (CanResumeAfter(ex))
+                if (RetryabilityHelper.IsResumableChangeStreamException(ex))
                 {
                     _cursor = await _changeStreamOperation.ResumeAsync(_binding, _resumeToken, cancellationToken).ConfigureAwait(false);
                     hasMore = await _cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false);
@@ -129,36 +129,6 @@ public void Dispose()
         }
 
         // private methods
-        private bool CanResumeAfter(Exception exception)
-        {
-            var commandException = exception as MongoCommandException;
-            if (commandException != null)
-            {
-                var code = (ServerErrorCode)commandException.Code;
-                switch (code)
-                {
-                    case ServerErrorCode.HostNotFound:
-                    case ServerErrorCode.HostUnreachable:
-                    case ServerErrorCode.InterruptedAtShutdown:
-                    case ServerErrorCode.InterruptedDueToReplStateChange:
-                    case ServerErrorCode.NetworkTimeout:
-                    case ServerErrorCode.NotMaster:
-                    case ServerErrorCode.NotMasterNoSlaveOk:
-                    case ServerErrorCode.NotMasterOrSecondary:
-                    case ServerErrorCode.PrimarySteppedDown:
-                    case ServerErrorCode.ShutdownInProgress:
-                    case ServerErrorCode.SocketException:
-                    case ServerErrorCode.WriteConcernFailed:
-                        return true;
-
-                    default:
-                        return false;
-                }
-            }
-
-            return exception is MongoConnectionException || exception is MongoCursorNotFoundException || exception is MongoNotPrimaryException;
-        }
-
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times")]
         private TDocument DeserializeDocument(RawBsonDocument rawDocument)
         {
diff --git a/src/MongoDB.Driver.Core/Core/Operations/RetryabilityHelper.cs b/src/MongoDB.Driver.Core/Core/Operations/RetryabilityHelper.cs
@@ -0,0 +1,98 @@
+﻿/* Copyright 2018-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.
+*/
+
+using System;
+using System.Collections.Generic;
+
+namespace MongoDB.Driver.Core.Operations
+{
+    internal static class RetryabilityHelper
+    {
+        // private static fields
+        private static readonly HashSet<Type> __resumableChangeStreamExceptions;
+        private static readonly HashSet<ServerErrorCode> __resumableChangeStreamErrorCodes;
+        private static readonly HashSet<Type> __retryableWriteExceptions;
+        private static readonly HashSet<ServerErrorCode> __retryableWriteErrorCodes;
+
+        // static constructor
+        static RetryabilityHelper()
+        {
+            var resumableAndRetryableExceptions = new HashSet<Type>()
+            {
+                typeof(MongoConnectionException),
+                typeof(MongoNotPrimaryException)
+            };
+
+            __resumableChangeStreamExceptions = new HashSet<Type>(resumableAndRetryableExceptions)
+            {
+                typeof(MongoCursorNotFoundException)
+            };
+
+            __retryableWriteExceptions = new HashSet<Type>(resumableAndRetryableExceptions)
+            {
+                typeof(MongoNodeIsRecoveringException)
+            };
+
+            var resumableAndRetryableErrorCodes = new HashSet<ServerErrorCode>
+            {
+                ServerErrorCode.HostNotFound,
+                ServerErrorCode.HostUnreachable,
+                ServerErrorCode.InterruptedAtShutdown,
+                ServerErrorCode.InterruptedDueToReplStateChange,
+                ServerErrorCode.NetworkTimeout,
+                ServerErrorCode.NotMaster,
+                ServerErrorCode.NotMasterNoSlaveOk,
+                ServerErrorCode.NotMasterOrSecondary,
+                ServerErrorCode.PrimarySteppedDown,
+                ServerErrorCode.ShutdownInProgress,
+                ServerErrorCode.SocketException
+            };
+
+            __resumableChangeStreamErrorCodes = new HashSet<ServerErrorCode>(resumableAndRetryableErrorCodes)
+            {
+            };
+
+            __retryableWriteErrorCodes = new HashSet<ServerErrorCode>(resumableAndRetryableErrorCodes)
+            {
+                ServerErrorCode.WriteConcernFailed
+            };
+        }
+
+        // public static methods
+        public static bool IsResumableChangeStreamException(Exception exception)
+        {
+            return IsMatch(exception, __resumableChangeStreamExceptions, __resumableChangeStreamErrorCodes);
+        }
+
+        public static bool IsRetryableWriteException(Exception exception)
+        {
+            return IsMatch(exception, __retryableWriteExceptions, __retryableWriteErrorCodes);
+        }
+
+        // private static methods
+        private static bool IsMatch(Exception exception, HashSet<Type> matchingExceptions, HashSet<ServerErrorCode> matchingErrorCodes)
+        {
+            var commandException = exception as MongoCommandException;
+            if (commandException != null)
+            {
+                return matchingErrorCodes.Contains((ServerErrorCode)commandException.Code);
+            }
+            else
+            {
+                return matchingExceptions.Contains(exception.GetType());
+            }
+        }
+    }
+}
diff --git a/src/MongoDB.Driver.Core/Core/Operations/RetryableWriteOperationExecutor.cs b/src/MongoDB.Driver.Core/Core/Operations/RetryableWriteOperationExecutor.cs
@@ -46,7 +46,7 @@ public static TResult Execute<TResult>(IRetryableWriteOperation<TResult> operati
             {
                 return operation.ExecuteAttempt(context, 1, transactionNumber, cancellationToken);
             }
-            catch (Exception ex) when (IsRetryableException(ex))
+            catch (Exception ex) when (RetryabilityHelper.IsRetryableWriteException(ex))
             {
                 originalException = ex;
             }
@@ -97,7 +97,7 @@ public static async Task<TResult> ExecuteAsync<TResult>(IRetryableWriteOperation
             {
                 return await operation.ExecuteAttemptAsync(context, 1, transactionNumber, cancellationToken).ConfigureAwait(false);
             }
-            catch (Exception ex) when (IsRetryableException(ex))
+            catch (Exception ex) when (RetryabilityHelper.IsRetryableWriteException(ex))
             {
                 originalException = ex;
             }
@@ -135,39 +135,6 @@ private static bool AreRetryableWritesSupported(ConnectionDescription connection
                 connectionDescription.IsMasterResult.ServerType != ServerType.Standalone;
         }
 
-        private static bool IsRetryableException(Exception ex)
-        {
-            var commandException = ex as MongoCommandException;
-            if (commandException != null)
-            {
-                var code = (ServerErrorCode)commandException.Code;
-                switch (code)
-                {
-                    case ServerErrorCode.HostNotFound:
-                    case ServerErrorCode.HostUnreachable:
-                    case ServerErrorCode.InterruptedAtShutdown:
-                    case ServerErrorCode.InterruptedDueToReplStateChange:
-                    case ServerErrorCode.NetworkTimeout:
-                    case ServerErrorCode.NotMaster:
-                    case ServerErrorCode.NotMasterNoSlaveOk:
-                    case ServerErrorCode.NotMasterOrSecondary:
-                    case ServerErrorCode.PrimarySteppedDown:
-                    case ServerErrorCode.ShutdownInProgress:
-                    case ServerErrorCode.SocketException:
-                    case ServerErrorCode.WriteConcernFailed:
-                        return true;
-
-                    default:
-                        return false;
-                }
-            }
-
-            return
-                ex is MongoConnectionException ||
-                ex is MongoNotPrimaryException ||
-                ex is MongoNodeIsRecoveringException;
-        }
-
         private static bool ShouldThrowOriginalException(Exception retryException)
         {
             return retryException is MongoException && !(retryException is MongoConnectionException);
diff --git a/src/MongoDB.Driver.Core/MongoDB.Driver.Core.csproj b/src/MongoDB.Driver.Core/MongoDB.Driver.Core.csproj
@@ -127,6 +127,7 @@
     <Compile Include="Core\Clusters\IClusterClock.cs" />
     <Compile Include="Core\Operations\DelayedEvaluationWriteConcernSerializer.cs" />
     <Compile Include="Core\Operations\RetryableDeleteCommandOperation.cs" />
+    <Compile Include="Core\Operations\RetryabilityHelper.cs" />
     <Compile Include="Core\Operations\RetryableInsertCommandOperation.cs" />
     <Compile Include="Core\Operations\IOperationClock.cs" />
     <Compile Include="Core\Operations\IRetryableOperation.cs" />
diff --git a/tests/MongoDB.Bson.TestHelpers/Reflector.cs b/tests/MongoDB.Bson.TestHelpers/Reflector.cs
@@ -13,7 +13,6 @@
 * limitations under the License.
 */
 
-using System;
 using System.Linq;
 using System.Reflection;
 
@@ -43,14 +42,5 @@ public static object Invoke<T1>(object obj, string name, T1 arg1)
                 .Single();
             return methodInfo.Invoke(obj, new object[] { arg1 });
         }
-
-        public static object InvokeStatic<T1>(Type type, string name, T1 arg1)
-        {
-            var parameterTypes = new[] { typeof(T1) };
-            var methodInfo = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Static)
-                .Where(m => m.Name == name && m.GetParameters().Select(p => p.ParameterType).SequenceEqual(parameterTypes))
-                .Single();
-            return methodInfo.Invoke(null, new object[] { arg1 });
-        }
     }
 }
diff --git a/tests/MongoDB.Driver.Core.Tests/Core/Operations/ChangeStreamCursorTests.cs b/tests/MongoDB.Driver.Core.Tests/Core/Operations/ChangeStreamCursorTests.cs
@@ -13,23 +13,26 @@
 * limitations under the License.
 */
 
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Reflection;
-using System.Threading;
-using System.Threading.Tasks;
 using FluentAssertions;
 using MongoDB.Bson;
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Serializers;
-using MongoDB.Bson.TestHelpers;
 using MongoDB.Bson.TestHelpers.XunitExtensions;
 using MongoDB.Driver.Core.Bindings;
+using MongoDB.Driver.Core.Clusters;
+using MongoDB.Driver.Core.Connections;
+using MongoDB.Driver.Core.Servers;
 using MongoDB.Driver.Core.TestHelpers;
 using MongoDB.Driver.Core.WireProtocol.Messages.Encoders;
 using Moq;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace MongoDB.Driver.Core.Operations
@@ -369,43 +372,6 @@ void ProcessBatch_should_throw_when_resume_token_is_missing(
             exception.Message.Should().Be("Cannot provide resume functionality when the resume token is missing.");
         }
 
-        [Theory]
-        [InlineData(1, false)]
-        [InlineData(ServerErrorCode.HostNotFound, true)]
-        [InlineData(ServerErrorCode.HostUnreachable, true)]
-        [InlineData(ServerErrorCode.InterruptedAtShutdown, true)]
-        [InlineData(ServerErrorCode.InterruptedDueToReplStateChange, true)]
-        [InlineData(ServerErrorCode.NetworkTimeout, true)]
-        [InlineData(ServerErrorCode.NotMaster, true)]
-        [InlineData(ServerErrorCode.NotMasterNoSlaveOk, true)]
-        [InlineData(ServerErrorCode.NotMasterOrSecondary, true)]
-        [InlineData(ServerErrorCode.PrimarySteppedDown, true)]
-        [InlineData(ServerErrorCode.ShutdownInProgress, true)]
-        [InlineData(ServerErrorCode.SocketException, true)]
-        [InlineData(ServerErrorCode.WriteConcernFailed, true)]
-        public void CanResumeAfter_should_return_expected_result_for_MongoCommandExceptions(int code, bool expectedResult)
-        {
-            var subject = CreateSubject();
-            var exception = CoreExceptionHelper.CreateMongoCommandException(code);
-            var result = subject.CanResumeAfter(exception);
-
-            result.Should().Be(expectedResult);
-        }
-
-        [Theory]
-        [InlineData(typeof(IOException), false)]
-        [InlineData(typeof(MongoConnectionException), true)]
-        [InlineData(typeof(MongoCursorNotFoundException), true)]
-        [InlineData(typeof(MongoNotPrimaryException), true)]
-        public void CanResumeAfter_should_return_expected_result_for_other_exceptions(Type exceptionType, bool expectedResult)
-        {
-            var subject = CreateSubject();
-            var exception = CoreExceptionHelper.CreateException(exceptionType);
-            var result = subject.CanResumeAfter(exception);
-
-            result.Should().Be(expectedResult);
-        }
-
         // private methods
         private ChangeStreamOperation<BsonDocument> CreateChangeStreamOperation()
         {
@@ -448,14 +414,46 @@ private RawBsonDocument ToRawDocument(BsonDocument document)
 
     internal static class ChangeStreamCursorReflector
     {
-        public static IReadBinding _binding(this ChangeStreamCursor<BsonDocument> cursor) => (IReadBinding)Reflector.GetFieldValue(cursor, nameof(_binding));
-        public static ChangeStreamOperation<BsonDocument> _changeStreamOperation(this ChangeStreamCursor<BsonDocument> cursor) => (ChangeStreamOperation<BsonDocument>)Reflector.GetFieldValue(cursor, nameof(_changeStreamOperation));
-        public static IEnumerable<BsonDocument> _current(this ChangeStreamCursor<BsonDocument> cursor) => (IEnumerable<BsonDocument>)Reflector.GetFieldValue(cursor, nameof(_current));
-        public static IAsyncCursor<RawBsonDocument> _cursor(this ChangeStreamCursor<BsonDocument> cursor) => (IAsyncCursor<RawBsonDocument>)Reflector.GetFieldValue(cursor, nameof(_cursor));
-        public static bool _disposed(this ChangeStreamCursor<BsonDocument> cursor) => (bool)Reflector.GetFieldValue(cursor, nameof(_disposed));
-        public static IBsonSerializer<BsonDocument> _documentSerializer(this ChangeStreamCursor<BsonDocument> cursor) => (IBsonSerializer<BsonDocument>)Reflector.GetFieldValue(cursor, nameof(_documentSerializer));
-        public static BsonDocument _resumeToken(this ChangeStreamCursor<BsonDocument> cursor) => (BsonDocument)Reflector.GetFieldValue(cursor, nameof(_resumeToken));
-
-        public static bool CanResumeAfter(this ChangeStreamCursor<BsonDocument> cursor, Exception exception) => (bool)Reflector.Invoke(cursor, nameof(CanResumeAfter), exception);
+        public static IReadBinding _binding(this ChangeStreamCursor<BsonDocument> cursor)
+        {
+            var fieldInfo = typeof(ChangeStreamCursor<BsonDocument>).GetField("_binding", BindingFlags.NonPublic | BindingFlags.Instance);
+            return (IReadBinding)fieldInfo.GetValue(cursor);
+        }
+
+        public static ChangeStreamOperation<BsonDocument> _changeStreamOperation(this ChangeStreamCursor<BsonDocument> cursor)
+        {
+            var fieldInfo = typeof(ChangeStreamCursor<BsonDocument>).GetField("_changeStreamOperation", BindingFlags.NonPublic | BindingFlags.Instance);
+            return (ChangeStreamOperation<BsonDocument>)fieldInfo.GetValue(cursor);
+        }
+
+        public static IEnumerable<BsonDocument> _current(this ChangeStreamCursor<BsonDocument> cursor)
+        {
+            var fieldInfo = typeof(ChangeStreamCursor<BsonDocument>).GetField("_current", BindingFlags.NonPublic | BindingFlags.Instance);
+            return (IEnumerable<BsonDocument>)fieldInfo.GetValue(cursor);
+        }
+
+        public static IAsyncCursor<RawBsonDocument> _cursor(this ChangeStreamCursor<BsonDocument> cursor)
+        {
+            var fieldInfo = typeof(ChangeStreamCursor<BsonDocument>).GetField("_cursor", BindingFlags.NonPublic | BindingFlags.Instance);
+            return (IAsyncCursor<RawBsonDocument>)fieldInfo.GetValue(cursor);
+        }
+
+        public static bool _disposed(this ChangeStreamCursor<BsonDocument> cursor)
+        {
+            var fieldInfo = typeof(ChangeStreamCursor<BsonDocument>).GetField("_disposed", BindingFlags.NonPublic | BindingFlags.Instance);
+            return (bool)fieldInfo.GetValue(cursor);
+        }
+
+        public static IBsonSerializer<BsonDocument> _documentSerializer(this ChangeStreamCursor<BsonDocument> cursor)
+        {
+            var fieldInfo = typeof(ChangeStreamCursor<BsonDocument>).GetField("_documentSerializer", BindingFlags.NonPublic | BindingFlags.Instance);
+            return (IBsonSerializer<BsonDocument>)fieldInfo.GetValue(cursor);
+        }
+
+        public static BsonDocument _resumeToken(this ChangeStreamCursor<BsonDocument> cursor)
+        {
+            var fieldInfo = typeof(ChangeStreamCursor<BsonDocument>).GetField("_resumeToken", BindingFlags.NonPublic | BindingFlags.Instance);
+            return (BsonDocument)fieldInfo.GetValue(cursor);
+        }
     }
 }
diff --git a/tests/MongoDB.Driver.Core.Tests/Core/Operations/RetryabilityHelperTests.cs b/tests/MongoDB.Driver.Core.Tests/Core/Operations/RetryabilityHelperTests.cs
diff --git a/tests/MongoDB.Driver.Core.Tests/MongoDB.Driver.Core.Tests.csproj b/tests/MongoDB.Driver.Core.Tests/MongoDB.Driver.Core.Tests.csproj
