Merge pull request #217 from zhenlineo/1.5-remove-AggregateException

ali-ince · web-flow · commit 106cd983b67a · 2017-08-16T10:17:18.000+01:00
Avoiding throw AggregateException
diff --git a/Neo4j.Driver/Neo4j.Driver.IntegrationTests/DirectDriver/SessionIT.cs b/Neo4j.Driver/Neo4j.Driver.IntegrationTests/DirectDriver/SessionIT.cs
@@ -42,7 +42,7 @@ public void ServiceUnavailableErrorWhenFailedToConn()
                 exception = Record.Exception(() => session.Run("RETURN 1"));
             }
             exception.Should().BeOfType<ServiceUnavailableException>();
-            exception.Message.Should().Be("Connection with the server breaks due to AggregateException: One or more errors occurred.");
+            exception.Message.Should().Contain("Connection with the server breaks due to IOException");
             exception.GetBaseException().Should().BeOfType<SocketException>();
             exception.GetBaseException().Message.Should().Contain("No connection could be made because the target machine actively refused it");
         }
diff --git a/Neo4j.Driver/Neo4j.Driver.IntegrationTests/DirectDriver/TransactionIT.cs b/Neo4j.Driver/Neo4j.Driver.IntegrationTests/DirectDriver/TransactionIT.cs
@@ -46,11 +46,13 @@ public void ShouldRetry()
                 }));
                 timer.Stop();
 
-                var error = e as AggregateException;
+                e.Should().BeOfType<ServiceUnavailableException>();
+                var error = e.InnerException as AggregateException;
                 var innerErrors = error.Flatten().InnerExceptions;
                 foreach (var innerError in innerErrors)
                 {
                     Output.WriteLine(innerError.Message);
+                    innerError.Should().BeOfType<SessionExpiredException>();
                 }
                 innerErrors.Count.Should().BeGreaterOrEqualTo(5);
                 timer.Elapsed.TotalSeconds.Should().BeGreaterOrEqualTo(30);
diff --git a/Neo4j.Driver/Neo4j.Driver.IntegrationTests/Examples.cs b/Neo4j.Driver/Neo4j.Driver.IntegrationTests/Examples.cs
@@ -533,7 +533,7 @@ public bool AddItem()
                         );
                     }
                 }
-                catch (AggregateException)
+                catch (ServiceUnavailableException)
                 {
                     return false;
                 }
diff --git a/Neo4j.Driver/Neo4j.Driver.IntegrationTests/ExamplesAsync.cs b/Neo4j.Driver/Neo4j.Driver.IntegrationTests/ExamplesAsync.cs
@@ -614,7 +614,7 @@ public async Task<bool> AddItemAsync()
                         }
                     );
                 }
-                catch (AggregateException)
+                catch (ServiceUnavailableException)
                 {
                     return false;
                 }
diff --git a/Neo4j.Driver/Neo4j.Driver.Tests/RetryLogicTests.cs b/Neo4j.Driver/Neo4j.Driver.Tests/RetryLogicTests.cs
@@ -62,7 +62,8 @@ private void Retry(int index, IRetryLogic retryLogic)
             }));
             timer.Stop();
 
-            var error = e as AggregateException;
+            e.Should().BeOfType<ServiceUnavailableException>();
+            var error = e.InnerException as AggregateException;
             var innerErrors = error.Flatten().InnerExceptions;
 
             innerErrors.Count.Should().BeGreaterOrEqualTo(2);
diff --git a/Neo4j.Driver/Neo4j.Driver/Internal/Connector/SocketConnection.cs b/Neo4j.Driver/Neo4j.Driver/Internal/Connector/SocketConnection.cs
@@ -66,14 +66,22 @@ internal SocketConnection(ISocketClient socketClient, IAuthToken authToken,
 
         public void Init()
         {
-            var connected = Task.Run(() => _client.StartAsync(_connectionTimeout)).Wait(_connectionTimeout);
-            if (!connected)
+            try
             {
-                throw new IOException(
-                    $"Failed to connect to the server {Server.Address} within connection timeout {_connectionTimeout.TotalMilliseconds}ms");
+                var connected = Task.Run(() => _client.StartAsync(_connectionTimeout)).Wait(_connectionTimeout);
+                if (!connected)
+                {
+                    throw new IOException(
+                        $"Failed to connect to the server {Server.Address} within connection timeout {_connectionTimeout.TotalMilliseconds}ms");
+                }
+
+                Init(_authToken);
+            }
+            catch (AggregateException e)
+            {
+                // To remove the wrapper around the inner exception because of Task.Wait()
+                throw e.InnerException;
             }
-
-            Init(_authToken);
         }
 
         public async Task InitAsync()
diff --git a/Neo4j.Driver/Neo4j.Driver/Internal/Connector/TcpSocketClient.cs b/Neo4j.Driver/Neo4j.Driver/Internal/Connector/TcpSocketClient.cs
@@ -15,6 +15,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Net.Security;
 using System.Net.Sockets;
@@ -84,7 +85,7 @@ private async Task Connect(Uri uri, TimeSpan timeOut)
             using (CancellationTokenSource cancellationSource = new CancellationTokenSource(timeOut))
             {
                 var addresses = await uri.ResolveAsync(_ipv6Enabled).ConfigureAwait(false);
-                AggregateException innerErrors = null;
+                var innerErrors = new List<Exception>();
                 for (var i = 0; i < addresses.Length; i++)
                 {
                     try
@@ -101,13 +102,14 @@ private async Task Connect(Uri uri, TimeSpan timeOut)
                     catch (Exception e)
                     {
                         var error = new IOException($"Failed to connect to server '{uri}' via IP address '{addresses[i]}': {e.Message}", e);
-                        innerErrors = innerErrors == null ? new AggregateException(error) : new AggregateException(innerErrors, error);
+                        innerErrors.Add(error);
 
                         if (i == addresses.Length - 1)
                         {
                             // if all failed
                             throw new IOException(
-                                $"Failed to connect to server '{uri}' via IP addresses'{addresses.ToContentString()}' at port '{uri.Port}'.", innerErrors);
+                                $"Failed to connect to server '{uri}' via IP addresses'{addresses.ToContentString()}' at port '{uri.Port}'.", 
+                                new AggregateException(innerErrors));
                         }
                     }
                 }
diff --git a/Neo4j.Driver/Neo4j.Driver/Internal/RetryLogic.cs b/Neo4j.Driver/Neo4j.Driver/Internal/RetryLogic.cs
@@ -60,19 +60,21 @@ public ExponentialBackoffRetryLogic(TimeSpan maxRetryTimeout, ILogger logger = n
 
         public T Retry<T>(Func<T> runTxFunc)
         {
-            AggregateException exception = null;
+            var exceptions = new List<Exception>();
             var timer = new Stopwatch();
             timer.Start();
             var delayMs = _initialRetryDelayMs;
+            var counter = 0;
             do
             {
+                counter++;
                 try
                 {
                     return runTxFunc();
                 }
                 catch (Exception e) when (e.IsRetriableError())
                 {
-                    exception = exception == null ? new AggregateException(e) : new AggregateException(exception, e);
+                    exceptions.Add(e);
 
                     var delay = TimeSpan.FromMilliseconds(ComputeDelayWithJitter(delayMs));
                     _logger?.Info("Transaction failed and will be retried in " + delay + "ms.", e);
@@ -82,24 +84,28 @@ public T Retry<T>(Func<T> runTxFunc)
             } while (timer.Elapsed.TotalMilliseconds < _maxRetryTimeMs);
 
             timer.Stop();
-            throw exception;
+            throw new ServiceUnavailableException(
+                $"Failed after retried for {counter} times in {_maxRetryTimeMs} ms. " +
+                "Make sure that your database is online and retry again.", new AggregateException(exceptions));
         }
 
         public async Task<T> RetryAsync<T>(Func<Task<T>> runTxAsyncFunc)
         {
-            AggregateException exception = null;
+            var exceptions = new List<Exception>();
             var timer = new Stopwatch();
             timer.Start();
             var delayMs = _initialRetryDelayMs;
+            var counter = 0;
             do
             {
+                counter++;
                 try
                 {
                     return await runTxAsyncFunc().ConfigureAwait(false);
                 }
                 catch (Exception e) when (e.IsRetriableError())
                 {
-                    exception = exception == null ? new AggregateException(e) : new AggregateException(exception, e);
+                    exceptions.Add(e);
 
                     var delay = TimeSpan.FromMilliseconds(ComputeDelayWithJitter(delayMs));
                     _logger?.Info("Transaction failed and will be retried in " + delay + "ms.", e);
@@ -109,7 +115,10 @@ public async Task<T> RetryAsync<T>(Func<Task<T>> runTxAsyncFunc)
             } while (timer.Elapsed.TotalMilliseconds < _maxRetryTimeMs);
 
             timer.Stop();
-            throw exception;
+            throw new ServiceUnavailableException(
+                $"Failed after retried for {counter} times in {_maxRetryTimeMs} ms. " +
+                "Make sure that your database is online and retry again.", new AggregateException(exceptions));
+
         }
 
         private double ComputeDelayWithJitter(double delayMs)

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public void ServiceUnavailableErrorWhenFailedToConn()`
`42`	`42`	`exception = Record.Exception(() => session.Run("RETURN 1"));`
`43`	`43`	`}`
`44`	`44`	`exception.Should().BeOfType<ServiceUnavailableException>();`
`45`		`- exception.Message.Should().Be("Connection with the server breaks due to AggregateException: One or more errors occurred.");`
	`45`	`+ exception.Message.Should().Contain("Connection with the server breaks due to IOException");`
`46`	`46`	`exception.GetBaseException().Should().BeOfType<SocketException>();`
`47`	`47`	`exception.GetBaseException().Message.Should().Contain("No connection could be made because the target machine actively refused it");`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,11 +46,13 @@ public void ShouldRetry()`
`46`	`46`	`}));`
`47`	`47`	`timer.Stop();`
`48`	`48`
`49`		`- var error = e as AggregateException;`
	`49`	`+ e.Should().BeOfType<ServiceUnavailableException>();`
	`50`	`+ var error = e.InnerException as AggregateException;`
`50`	`51`	`var innerErrors = error.Flatten().InnerExceptions;`
`51`	`52`	`foreach (var innerError in innerErrors)`
`52`	`53`	`{`
`53`	`54`	`Output.WriteLine(innerError.Message);`
	`55`	`+ innerError.Should().BeOfType<SessionExpiredException>();`
`54`	`56`	`}`
`55`	`57`	`innerErrors.Count.Should().BeGreaterOrEqualTo(5);`
`56`	`58`	`timer.Elapsed.TotalSeconds.Should().BeGreaterOrEqualTo(30);`
Original file line number	Diff line number	Diff line change
`@@ -533,7 +533,7 @@ public bool AddItem()`
`533`	`533`	`);`
`534`	`534`	`}`
`535`	`535`	`}`
`536`		`- catch (AggregateException)`
	`536`	`+ catch (ServiceUnavailableException)`
`537`	`537`	`{`
`538`	`538`	`return false;`
`539`	`539`	`}`
Original file line number	Diff line number	Diff line change
`@@ -614,7 +614,7 @@ public async Task<bool> AddItemAsync()`
`614`	`614`	`}`
`615`	`615`	`);`
`616`	`616`	`}`
`617`		`- catch (AggregateException)`
	`617`	`+ catch (ServiceUnavailableException)`
`618`	`618`	`{`
`619`	`619`	`return false;`
`620`	`620`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@`
`15`	`15`	`// See the License for the specific language governing permissions and`
`16`	`16`	`// limitations under the License.`
`17`	`17`	`using System;`
	`18`	`+using System.Collections.Generic;`
`18`	`19`	`using System.IO;`
`19`	`20`	`using System.Net.Security;`
`20`	`21`	`using System.Net.Sockets;`
`@@ -84,7 +85,7 @@ private async Task Connect(Uri uri, TimeSpan timeOut)`
`84`	`85`	`using (CancellationTokenSource cancellationSource = new CancellationTokenSource(timeOut))`
`85`	`86`	`{`
`86`	`87`	`var addresses = await uri.ResolveAsync(_ipv6Enabled).ConfigureAwait(false);`
`87`		`- AggregateException innerErrors = null;`
	`88`	`+ var innerErrors = new List<Exception>();`
`88`	`89`	`for (var i = 0; i < addresses.Length; i++)`
`89`	`90`	`{`
`90`	`91`	`try`
`@@ -101,13 +102,14 @@ private async Task Connect(Uri uri, TimeSpan timeOut)`
`101`	`102`	`catch (Exception e)`
`102`	`103`	`{`
`103`	`104`	`var error = new IOException($"Failed to connect to server '{uri}' via IP address '{addresses[i]}': {e.Message}", e);`
`104`		`- innerErrors = innerErrors == null ? new AggregateException(error) : new AggregateException(innerErrors, error);`
	`105`	`+ innerErrors.Add(error);`
`105`	`106`
`106`	`107`	`if (i == addresses.Length - 1)`
`107`	`108`	`{`
`108`	`109`	`// if all failed`
`109`	`110`	`throw new IOException(`
`110`		`- $"Failed to connect to server '{uri}' via IP addresses'{addresses.ToContentString()}' at port '{uri.Port}'.", innerErrors);`
	`111`	`+ $"Failed to connect to server '{uri}' via IP addresses'{addresses.ToContentString()}' at port '{uri.Port}'.",`
	`112`	`+ new AggregateException(innerErrors));`
`111`	`113`	`}`
`112`	`114`	`}`
`113`	`115`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,19 +60,21 @@ public ExponentialBackoffRetryLogic(TimeSpan maxRetryTimeout, ILogger logger = n`
`60`	`60`
`61`	`61`	`public T Retry<T>(Func<T> runTxFunc)`
`62`	`62`	`{`
`63`		`- AggregateException exception = null;`
	`63`	`+ var exceptions = new List<Exception>();`
`64`	`64`	`var timer = new Stopwatch();`
`65`	`65`	`timer.Start();`
`66`	`66`	`var delayMs = _initialRetryDelayMs;`
	`67`	`+ var counter = 0;`
`67`	`68`	`do`
`68`	`69`	`{`
	`70`	`+ counter++;`
`69`	`71`	`try`
`70`	`72`	`{`
`71`	`73`	`return runTxFunc();`
`72`	`74`	`}`
`73`	`75`	`catch (Exception e) when (e.IsRetriableError())`
`74`	`76`	`{`
`75`		`- exception = exception == null ? new AggregateException(e) : new AggregateException(exception, e);`
	`77`	`+ exceptions.Add(e);`
`76`	`78`
`77`	`79`	`var delay = TimeSpan.FromMilliseconds(ComputeDelayWithJitter(delayMs));`
`78`	`80`	`_logger?.Info("Transaction failed and will be retried in " + delay + "ms.", e);`
`@@ -82,24 +84,28 @@ public T Retry<T>(Func<T> runTxFunc)`
`82`	`84`	`} while (timer.Elapsed.TotalMilliseconds < _maxRetryTimeMs);`
`83`	`85`
`84`	`86`	`timer.Stop();`
`85`		`- throw exception;`
	`87`	`+ throw new ServiceUnavailableException(`
	`88`	`+ $"Failed after retried for {counter} times in {_maxRetryTimeMs} ms. " +`
	`89`	`+ "Make sure that your database is online and retry again.", new AggregateException(exceptions));`
`86`	`90`	`}`
`87`	`91`
`88`	`92`	`public async Task<T> RetryAsync<T>(Func<Task<T>> runTxAsyncFunc)`
`89`	`93`	`{`
`90`		`- AggregateException exception = null;`
	`94`	`+ var exceptions = new List<Exception>();`
`91`	`95`	`var timer = new Stopwatch();`
`92`	`96`	`timer.Start();`
`93`	`97`	`var delayMs = _initialRetryDelayMs;`
	`98`	`+ var counter = 0;`
`94`	`99`	`do`
`95`	`100`	`{`
	`101`	`+ counter++;`
`96`	`102`	`try`
`97`	`103`	`{`
`98`	`104`	`return await runTxAsyncFunc().ConfigureAwait(false);`
`99`	`105`	`}`
`100`	`106`	`catch (Exception e) when (e.IsRetriableError())`
`101`	`107`	`{`
`102`		`- exception = exception == null ? new AggregateException(e) : new AggregateException(exception, e);`
	`108`	`+ exceptions.Add(e);`
`103`	`109`
`104`	`110`	`var delay = TimeSpan.FromMilliseconds(ComputeDelayWithJitter(delayMs));`
`105`	`111`	`_logger?.Info("Transaction failed and will be retried in " + delay + "ms.", e);`
`@@ -109,7 +115,10 @@ public async Task<T> RetryAsync<T>(Func<Task<T>> runTxAsyncFunc)`
`109`	`115`	`} while (timer.Elapsed.TotalMilliseconds < _maxRetryTimeMs);`
`110`	`116`
`111`	`117`	`timer.Stop();`
`112`		`- throw exception;`
	`118`	`+ throw new ServiceUnavailableException(`
	`119`	`+ $"Failed after retried for {counter} times in {_maxRetryTimeMs} ms. " +`
	`120`	`+ "Make sure that your database is online and retry again.", new AggregateException(exceptions));`
	`121`	`+`
`113`	`122`	`}`
`114`	`123`
`115`	`124`	`private double ComputeDelayWithJitter(double delayMs)`