Support for connection that storage driver opens

Author: alex-kulakov

Orm/Xtensive.Orm/Orm/Providers/StorageDriver.Operations.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
@@ -14,7 +14,7 @@
 
 namespace Xtensive.Orm.Providers
 {
-  partial class StorageDriver
+  public partial class StorageDriver
   {
     private sealed class InitializationSqlExtension
     {
@@ -50,6 +50,11 @@ public SqlConnection CreateConnection(Session session)
         throw ExceptionBuilder.BuildException(exception);
       }
 
+      if (handlerFactoriesCache != null) {
+        connection.AssignConnectionHandlers(
+          CreateConnectionHandlersFast(configuration.Types.ConnectionHandlers));
+      }
+
       var sessionConfiguration = GetConfiguration(session);
       connection.CommandTimeout = sessionConfiguration.DefaultCommandTimeout;
       var connectionInfo = GetConnectionInfo(session) ?? sessionConfiguration.ConnectionInfo;
@@ -69,14 +74,14 @@ public void OpenConnection(Session session, SqlConnection connection)
       if (isLoggingEnabled)
         SqlLog.Info(Strings.LogSessionXOpeningConnectionY, session.ToStringSafely(), connection.ConnectionInfo);
 
-      var extension = connection.Extensions.Get<InitializationSqlExtension>();
+      var script = connection.Extensions.Get<InitializationSqlExtension>()?.Script;
 
       try {
-        if (extension == null || string.IsNullOrEmpty(extension.Script)) {
-          connection.Open();
+        if (!string.IsNullOrEmpty(script)) {
+          connection.OpenAndInitialize(script);
         }
         else {
-          connection.OpenAndInitialize(extension.Script);
+          connection.Open();
         }
       }
       catch (Exception exception) {
@@ -94,13 +99,15 @@ public async Task OpenConnectionAsync(Session session, SqlConnection connection,
       if (isLoggingEnabled)
         SqlLog.Info(Strings.LogSessionXOpeningConnectionY, session.ToStringSafely(), connection.ConnectionInfo);
 
-      var extension = connection.Extensions.Get<InitializationSqlExtension>();
+      var script = connection.Extensions.Get<InitializationSqlExtension>()?.Script;
 
       try {
-        if (!string.IsNullOrEmpty(extension?.Script))
-          await connection.OpenAndInitializeAsync(extension.Script, cancellationToken).ConfigureAwait(false);
-        else
+        if (!string.IsNullOrEmpty(script)) {
+          await connection.OpenAndInitializeAsync(script, cancellationToken).ConfigureAwait(false);
+        }
+        else {
           await connection.OpenAsync(cancellationToken).ConfigureAwait(false);
+        }
       }
       catch (OperationCanceledException) {
         throw;

Orm/Xtensive.Orm/Orm/Providers/StorageDriver.cs

@@ -211,7 +211,7 @@ public static StorageDriver Create(SqlDriverFactory driverFactory, DomainConfigu
       ArgumentValidator.EnsureArgumentNotNull(configuration, "configuration");
 
       var handlers = CreateConnectionHandlers(configuration.Types.ConnectionHandlers, out var factories);
-      var driverConfiguration = new SqlDriverConfiguration {
+      var driverConfiguration = new SqlDriverConfiguration(handlers) {
         ForcedServerVersion = configuration.ForcedServerVersion,
         ConnectionInitializationSql = configuration.ConnectionInitializationSql,
         EnsureConnectionIsAlive = configuration.EnsureConnectionIsAlive,

Orm/Xtensive.Orm/Sql/ConnectionHandlersExtension.cs

@@ -0,0 +1,25 @@
+// Copyright (C) 2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using System.Collections.Generic;
+using Xtensive.Orm;
+
+namespace Xtensive.Sql
+{
+  /// <summary>
+  /// Wrapper to pass <see cref="IConnectionHandler"/>s to connection.
+  /// </summary>
+  public sealed class ConnectionHandlersExtension
+  {
+    /// <summary>
+    /// Collection of <see cref="IConnectionHandler"/> instances.
+    /// </summary>
+    public IReadOnlyCollection<IConnectionHandler> Handlers { get; }
+
+    internal ConnectionHandlersExtension(IReadOnlyCollection<IConnectionHandler> handlers)
+    {
+      Handlers = handlers;
+    }
+  }
+}

Orm/Xtensive.Orm/Sql/SqlConnection.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2003-2010 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.
 
@@ -166,7 +166,22 @@ public virtual IBinaryLargeObject CreateBinaryLargeObject() =>
     public virtual void Open()
     {
       EnsureIsNotDisposed();
-      UnderlyingConnection.Open();
+      var connectionHandlers = Extensions.Get<ConnectionHandlersExtension>();
+      if (connectionHandlers == null) {
+        UnderlyingConnection.Open();
+      }
+      else {
+        var handlers = connectionHandlers.Handlers;
+        SqlHelper.NotifyConnectionOpening(handlers, UnderlyingConnection);
+        try {
+          UnderlyingConnection.Open();
+          SqlHelper.NotifyConnectionOpened(handlers, UnderlyingConnection);
+        }
+        catch (Exception ex) {
+          SqlHelper.NotifyConnectionOpeningFailed(handlers, UnderlyingConnection, ex);
+          throw;
+        }
+      }
     }
 
     /// <summary>
@@ -176,14 +191,37 @@ public virtual void Open()
     public virtual void OpenAndInitialize(string initializationScript)
     {
       UnderlyingConnection.Open();
-      if (string.IsNullOrEmpty(initializationScript)) {
-        return;
-      }
+      var connectionHandlers = Extensions.Get<ConnectionHandlersExtension>();
+      if (connectionHandlers == null) {
+        UnderlyingConnection.Open();
+        if (string.IsNullOrEmpty(initializationScript)) {
+          return;
+        }
 
-      using (var command = UnderlyingConnection.CreateCommand()) {
+        using var command = UnderlyingConnection.CreateCommand();
         command.CommandText = initializationScript;
         _ = command.ExecuteNonQuery();
       }
+      else {
+        var handlers = connectionHandlers.Handlers;
+        SqlHelper.NotifyConnectionOpening(handlers, UnderlyingConnection);
+        try {
+          UnderlyingConnection.Open();
+          if (string.IsNullOrEmpty(initializationScript)) {
+            SqlHelper.NotifyConnectionOpened(handlers, UnderlyingConnection);
+            return;
+          }
+
+          SqlHelper.NotifyConnectionInitializing(handlers, UnderlyingConnection, initializationScript);
+          using var command = UnderlyingConnection.CreateCommand();
+          command.CommandText = initializationScript;
+          _ = command.ExecuteNonQuery();
+        }
+        catch (Exception ex) {
+          SqlHelper.NotifyConnectionOpeningFailed(handlers, UnderlyingConnection, ex);
+          throw;
+        }
+      }
     }
 
     /// <summary>

Orm/Xtensive.Orm/Sql/SqlDriverConfiguration.cs

@@ -1,9 +1,14 @@
-// Copyright (C) 2003-2012 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2012-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
 // Created:    2012.12.27
 
+using System;
+using System.Collections.Generic;
+using Xtensive.Core;
+using Xtensive.Orm;
+
 namespace Xtensive.Sql
 {
   /// <summary>
@@ -26,13 +31,23 @@ public sealed class SqlDriverConfiguration
     /// </summary>
     public bool EnsureConnectionIsAlive { get; set; }
 
+    /// <summary>
+    /// Gets connection handlers that should be notified about connection events.
+    /// </summary>
+    public IReadOnlyCollection<IConnectionHandler> ConnectionHandlers { get; private set; }
+
     /// <summary>
     /// Clones this instance.
     /// </summary>
     /// <returns>Clone of this instance.</returns>
     public SqlDriverConfiguration Clone()
     {
-      return new SqlDriverConfiguration {
+      // no deep cloning
+      var handlers = (ConnectionHandlers.Count == 0)
+        ? Array.Empty<IConnectionHandler>()
+        : ConnectionHandlers.ToArray(ConnectionHandlers.Count);
+
+      return new SqlDriverConfiguration(handlers) {
         ForcedServerVersion = ForcedServerVersion,
         ConnectionInitializationSql = ConnectionInitializationSql,
         EnsureConnectionIsAlive = EnsureConnectionIsAlive
@@ -44,6 +59,15 @@ public SqlDriverConfiguration Clone()
     /// </summary>
     public SqlDriverConfiguration()
     {
+      ConnectionHandlers = Array.Empty<IConnectionHandler>();
+    }
+
+    /// <summary>
+    /// Creates new instance of this type.
+    /// </summary>
+    public SqlDriverConfiguration(IReadOnlyCollection<IConnectionHandler> connectionHandlers)
+    {
+      ConnectionHandlers = connectionHandlers;
     }
   }
 }

Orm/Xtensive.Orm/Sql/SqlExtensions.cs

@@ -1,10 +1,11 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// 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
 // Created:    2009.07.30
 
 using System;
+using System.Collections.Generic;
 using Xtensive.Core;
 using Xtensive.Orm;
 using Xtensive.Sql.Dml;
@@ -49,5 +50,16 @@ public static string GetSchema(this UrlInfo url, string defaultValue)
       var result = resource.Substring(position + 1).TryCutSuffix(SchemaSeparatorString);
       return string.IsNullOrEmpty(result) ? defaultValue : result;
     }
+
+    /// <summary>
+    /// Adds handlers to connection so they will take effect on connection operations.
+    /// </summary>
+    /// <param name="connection">The connection to assign handlers.</param>
+    /// <param name="connectionHandlers">The handlers.</param>
+    public static void AssignConnectionHandlers(this SqlConnection connection,
+      IReadOnlyCollection<IConnectionHandler> connectionHandlers)
+    {
+      connection.Extensions.Set(new ConnectionHandlersExtension(connectionHandlers));
+    }
   }
 }

Orm/Xtensive.Orm/Sql/SqlHelper.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
+// Copyright (C) 2009-2021 Xtensive LLC.
 // All rights reserved.
 // For conditions of distribution and use, see license.
 // Created by: Denis Krjuchkov
@@ -433,5 +433,75 @@ public static NotSupportedException NotSupported(ServerFeatures feature)
     {
       return NotSupported(feature.ToString());
     }
+
+    #region Notifications
+
+    /// <summary>
+    /// Notifies all the <paramref name="connectionHandlers"/> that
+    /// <paramref name="connection"/> is about to be opened.
+    /// </summary>
+    /// <param name="connectionHandlers">The handlers that should be notified.</param>
+    /// <param name="connection">The connection that is opening.</param>
+    /// <param name="reconnect"><see langword="true"/> if event happened on attemp to restore connection, otherwise <see langword="false"/>.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void NotifyConnectionOpening(
+      IEnumerable<IConnectionHandler> connectionHandlers, DbConnection connection, bool reconnect = false)
+    {
+      foreach (var handler in connectionHandlers) {
+        handler.ConnectionOpening(new ConnectionEventData(connection, reconnect));
+      }
+    }
+
+    /// <summary>
+    /// Notifies all the <paramref name="connectionHandlers"/> that
+    /// opened connection is about to be initialized with <paramref name="initializationScript"/>.
+    /// </summary>
+    /// <param name="connectionHandlers">The handlers that should be notified.</param>
+    /// <param name="connection">Opened but not initialized connection</param>
+    /// <param name="initializationScript">The script that will run to initialize connection</param>
+    /// <param name="reconnect"><see langword="true"/> if event happened on attemp to restore connection, otherwise <see langword="false"/>.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void NotifyConnectionInitializing(
+      IEnumerable<IConnectionHandler> connectionHandlers, DbConnection connection, string initializationScript, bool reconnect = false)
+    {
+      foreach (var handler in connectionHandlers) {
+        handler.ConnectionInitialization(new ConnectionInitEventData(initializationScript, connection, reconnect));
+      }
+    }
+
+    /// <summary>
+    /// Notifies all the <paramref name="connectionHandlers"/> about
+    /// successful connection opening.
+    /// </summary>
+    /// <param name="connectionHandlers">The handlers that should be notified.</param>
+    /// <param name="connection">The connection that is completely opened and initialized.</param>
+    /// <param name="reconnect"><see langword="true"/> if event happened on attemp to restore connection, otherwise <see langword="false"/>.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void NotifyConnectionOpened(
+      IEnumerable<IConnectionHandler> connectionHandlers, DbConnection connection, bool reconnect = false)
+    {
+      foreach (var handler in connectionHandlers) {
+        handler.ConnectionOpened(new ConnectionEventData(connection, reconnect));
+      }
+    }
+
+    /// <summary>
+    /// Notifies all the <paramref name="connectionHandlers"/> about
+    /// connection opening failure.
+    /// </summary>
+    /// <param name="connectionHandlers">The handlers that should be notified.</param>
+    /// <param name="connection">Connection that failed to be opened or properly initialized.</param>
+    /// <param name="exception">The exception which appeared.</param>
+    /// <param name="reconnect"><see langword="true"/> if event happened on attemp to restore connection, otherwise <see langword="false"/>.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void NotifyConnectionOpeningFailed(
+      IEnumerable<IConnectionHandler> connectionHandlers, DbConnection connection, Exception exception, bool reconnect = false)
+    {
+      foreach (var handler in connectionHandlers) {
+        handler.ConnectionOpeningFailed(new ConnectionErrorEventData(exception, connection, reconnect));
+      }
+    }
+
+    #endregion
   }
 }