Support in sqlserver provider

with code updates from master

Author: alex-kulakov

Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/Connection.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2009-2020 Xtensive LLC.
+// Copyright (C) 2009-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Denis Krjuchkov
@@ -38,20 +38,35 @@ public override DbParameter CreateParameter()
     /// <inheritdoc/>
     public override void Open()
     {
-      if (!checkConnectionIsAlive)
+      if (!checkConnectionIsAlive) {
         base.Open();
-      else
-        OpenWithCheck(DefaultCheckConnectionQuery);
+      }
+      else {
+        var connectionHandlers = Extensions.Get<ConnectionHandlersExtension>();
+        if (connectionHandlers == null) {
+          OpenWithCheckFast(DefaultCheckConnectionQuery);
+        }
+        else {
+          OpenWithCheckAndNotification(DefaultCheckConnectionQuery, connectionHandlers);
+        }
+      }
     }
 
     /// <inheritdoc/>
     public override Task OpenAsync(CancellationToken cancellationToken)
     {
       cancellationToken.ThrowIfCancellationRequested();
-      if (!checkConnectionIsAlive)
+      if (!checkConnectionIsAlive) {
         return base.OpenAsync(cancellationToken);
-      else
-        return OpenWithCheckAsync(DefaultCheckConnectionQuery, cancellationToken);
+      }
+
+      var connectionHandlers = Extensions.Get<ConnectionHandlersExtension>();
+      if (connectionHandlers == null) {
+        return OpenWithCheckFastAsync(DefaultCheckConnectionQuery, cancellationToken);
+      }
+      else {
+        return OpenWithCheckAndNotificationAsync(DefaultCheckConnectionQuery, connectionHandlers, cancellationToken);
+      }
     }
 
     /// <inheritdoc/>
@@ -65,7 +80,13 @@ public override void OpenAndInitialize(string initializationScript)
       var script = string.IsNullOrEmpty(initializationScript.Trim())
         ? DefaultCheckConnectionQuery
         : initializationScript;
-      OpenWithCheck(script);
+      var connectionHandlers = Extensions.Get<ConnectionHandlersExtension>();
+      if (connectionHandlers == null) {
+        OpenWithCheckFast(script);
+      }
+      else {
+        OpenWithCheckAndNotification(script, connectionHandlers);
+      }
     }
 
     /// <inheritdoc/>
@@ -77,7 +98,10 @@ public override Task OpenAndInitializeAsync(string initializationScript, Cancell
       var script = string.IsNullOrEmpty(initializationScript.Trim())
         ? DefaultCheckConnectionQuery
         : initializationScript;
-      return OpenWithCheckAsync(script, cancellationToken);
+      var connectionHandlers = Extensions.Get<ConnectionHandlersExtension>();
+      return connectionHandlers == null
+        ? OpenWithCheckFastAsync(script, cancellationToken)
+        : OpenWithCheckAndNotificationAsync(script, connectionHandlers, cancellationToken);
     }
 
     /// <inheritdoc/>
@@ -131,16 +155,16 @@ protected override void ClearActiveTransaction()
       activeTransaction = null;
     }
 
-    private void OpenWithCheck(string checkQueryString)
+    private void OpenWithCheckFast(string checkQueryString)
     {
-      bool connectionChecked = false;
-      bool restoreTriggered = false;
+      var connectionChecked = false;
+      var restoreTriggered = false;
       while (!connectionChecked) {
         base.Open();
         try {
           using (var command = underlyingConnection.CreateCommand()) {
             command.CommandText = checkQueryString;
-            command.ExecuteNonQuery();
+            _ = command.ExecuteNonQuery();
           }
           connectionChecked = true;
         }
@@ -160,28 +184,118 @@ private void OpenWithCheck(string checkQueryString)
             restoreTriggered = true;
             continue;
           }
-          else
-            throw;
+
+          throw;
         }
       }
     }
 
-    private async Task OpenWithCheckAsync(string checkQueryString, CancellationToken cancellationToken)
+    private void OpenWithCheckAndNotification(string checkQueryString, ConnectionHandlersExtension connectionHandlers)
     {
-      bool connectionChecked = false;
-      bool restoreTriggered = false;
+      var connectionChecked = false;
+      var restoreTriggered = false;
+      var handlers = connectionHandlers.Handlers;
+      while (!connectionChecked) {
+        SqlHelper.NotifyConnectionOpening(handlers, UnderlyingConnection, (!connectionChecked && !restoreTriggered));
+        underlyingConnection.Open();
+        try {
+          SqlHelper.NotifyConnectionInitializing(handlers, UnderlyingConnection, checkQueryString, (!connectionChecked && !restoreTriggered));
+          using (var command = underlyingConnection.CreateCommand()) {
+            command.CommandText = checkQueryString;
+            _ = command.ExecuteNonQuery();
+          }
+          connectionChecked = true;
+          SqlHelper.NotifyConnectionOpened(handlers, UnderlyingConnection, (!connectionChecked && !restoreTriggered));
+        }
+        catch (Exception exception) {
+          SqlHelper.NotifyConnectionOpeningFailed(handlers, UnderlyingConnection, exception, (!connectionChecked && !restoreTriggered));
+          if (InternalHelpers.ShouldRetryOn(exception)) {
+            if (restoreTriggered) {
+              throw;
+            }
+
+            var newConnection = new SqlServerConnection(underlyingConnection.ConnectionString);
+            try {
+              underlyingConnection.Close();
+              underlyingConnection.Dispose();
+            }
+            catch { }
+
+            underlyingConnection = newConnection;
+            restoreTriggered = true;
+            continue;
+          }
+
+          throw;
+        }
+      }
+    }
+
+    private async Task OpenWithCheckFastAsync(string checkQueryString, CancellationToken cancellationToken)
+    {
+      var connectionChecked = false;
+      var restoreTriggered = false;
 
       while (!connectionChecked) {
         cancellationToken.ThrowIfCancellationRequested();
         await base.OpenAsync(cancellationToken).ConfigureAwait(false);
         try {
           using (var command = underlyingConnection.CreateCommand()) {
             command.CommandText = checkQueryString;
-            await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
+            _ = await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
+          }
+          connectionChecked = true;
+        }
+        catch (Exception exception) {
+          if (InternalHelpers.ShouldRetryOn(exception)) {
+            if (restoreTriggered) {
+              throw;
+            }
+            var newConnection = new SqlServerConnection(underlyingConnection.ConnectionString);
+            try {
+              underlyingConnection.Close();
+              underlyingConnection.Dispose();
+            }
+            catch { }
+
+            underlyingConnection = newConnection;
+            restoreTriggered = true;
+            continue;
+          }
+
+          throw;
+        }
+      }
+    }
+
+    private async Task OpenWithCheckAndNotificationAsync(string checkQueryString,
+      ConnectionHandlersExtension connectionHandlers, CancellationToken cancellationToken)
+    {
+      var connectionChecked = false;
+      var restoreTriggered = false;
+      var handlers = connectionHandlers.Handlers;
+
+      while (!connectionChecked) {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        SqlHelper.NotifyConnectionOpening(handlers, UnderlyingConnection, !connectionChecked && !restoreTriggered);
+
+        await underlyingConnection.OpenAsync(cancellationToken).ConfigureAwait(false);
+        try {
+          SqlHelper.NotifyConnectionInitializing(handlers,
+            UnderlyingConnection, checkQueryString, !connectionChecked && !restoreTriggered);
+
+          using (var command = underlyingConnection.CreateCommand()) {
+            command.CommandText = checkQueryString;
+            _ = await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
           }
           connectionChecked = true;
+          SqlHelper.NotifyConnectionOpened(handlers, UnderlyingConnection, !connectionChecked && !restoreTriggered);
         }
         catch (Exception exception) {
+          SqlHelper.NotifyConnectionOpeningFailed(handlers,
+            UnderlyingConnection, exception, (!connectionChecked && !restoreTriggered));
+
           if (InternalHelpers.ShouldRetryOn(exception)) {
             if (restoreTriggered) {
               throw;
@@ -197,8 +311,8 @@ private async Task OpenWithCheckAsync(string checkQueryString, CancellationToken
             restoreTriggered = true;
             continue;
           }
-          else
-            throw;
+
+          throw;
         }
       }
     }