Support for connection hanlders on high level

Author: alex-kulakov

Orm/Xtensive.Orm/Orm/Configuration/DomainTypeRegistry.cs

@@ -25,7 +25,11 @@ public class DomainTypeRegistry : TypeRegistry
     private readonly static Type iModuleType = typeof(IModule);
     private readonly static Type iUpgradeHandlerType = typeof(IUpgradeHandler);
     private readonly static Type keyGeneratorType = typeof(KeyGenerator);
-    private static readonly Type ifulltextCatalogNameBuilder = typeof(IFullTextCatalogNameBuilder);
+    private readonly static Type ifulltextCatalogNameBuilder = typeof(IFullTextCatalogNameBuilder);
+    private readonly static Type iConnectionHandlerType = typeof(IConnectionHandler);
+
+    private Type[] connectionHandlers;
+
 
     /// <summary>
     /// Gets all the registered persistent types.
@@ -68,6 +72,27 @@ public class DomainTypeRegistry : TypeRegistry
     /// </summary>
     public IEnumerable<Type> FullTextCatalogResolvers => this.Where(IsFullTextCatalogNameBuilder);
 
+    /// <summary>
+    /// Gets all the registered <see cref="IConnectionHandler"/> implementations.
+    /// </summary>
+    public IEnumerable<Type> ConnectionHandlers
+    {
+      get {
+        // a lot of access to this property. better to have items cached;
+        if (IsLocked) {
+          if(connectionHandlers == null) {
+            var container = new List<Type>(10);// not so many handlers expected
+            foreach (var type in this.Where(IsConnectionHandler))
+              container.Add(type);
+            connectionHandlers = container.Count == 0 ? Array.Empty<Type>() : container.ToArray();
+          }
+          return connectionHandlers;
+        }
+        // if instacne is not locked then there is a chance of new handlers appeared
+        return this.Where(IsConnectionHandler);
+      }
+    }
+
     #region IsXxx method group
 
     /// <summary>
@@ -85,7 +110,8 @@ public static bool IsInterestingType(Type type) =>
       IsUpgradeHandler(type) ||
       IsKeyGenerator(type) ||
       IsCompilerContainer(type) ||
-      IsFullTextCatalogNameBuilder(type);
+      IsFullTextCatalogNameBuilder(type) ||
+      IsConnectionHandler(type);
 
     /// <summary>
     /// Determines whether a <paramref name="type"/>
@@ -201,6 +227,21 @@ public static bool IsFullTextCatalogNameBuilder(Type type)
       return ifulltextCatalogNameBuilder.IsAssignableFrom(type) && ifulltextCatalogNameBuilder != type;
     }
 
+    /// <summary>
+    /// Determines whether the <paramref name="type"/> is
+    /// a connection handler.
+    /// </summary>
+    /// <param name="type">The type to check.</param>
+    /// <returns>Check result.</returns>
+    public static bool IsConnectionHandler(Type type)
+    {
+      if (type.IsAbstract) {
+        return false;
+      }
+
+      return iConnectionHandlerType.IsAssignableFrom(type) && iConnectionHandlerType != type;
+    }
+
     #endregion
 
     #region ICloneable members

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

@@ -14,7 +14,7 @@
 
 namespace Xtensive.Orm.Providers
 {
-  partial class StorageDriver
+  public partial class StorageDriver
   {
     private sealed class InitializationSqlExtension
     {
@@ -50,6 +50,10 @@ public SqlConnection CreateConnection(Session session)
       catch (Exception exception) {
         throw ExceptionBuilder.BuildException(exception);
       }
+      if (handlerFactoriesCache != null) {
+        connection.Extensions.Set(
+          new ConnectionHandlersExtension(CreateHandlersForConnection(configuration.Types.ConnectionHandlers)));
+      }
 
       var sessionConfiguration = GetConfiguration(session);
       connection.CommandTimeout = sessionConfiguration.DefaultCommandTimeout;
@@ -76,7 +80,7 @@ public void OpenConnection(Session session, SqlConnection connection)
       var script = extension?.Script;
       try {
         if (!string.IsNullOrEmpty(script)) {
-          connection.OpenAndInitialize(extension.Script);
+          connection.OpenAndInitialize(script);
         }
         else {
           connection.Open();
@@ -100,8 +104,9 @@ public async Task OpenConnectionAsync(Session session, SqlConnection connection,
       var extension = connection.Extensions.Get<InitializationSqlExtension>();
 
       try {
-        if (!string.IsNullOrEmpty(extension?.Script)) {
-          await connection.OpenAndInitializeAsync(extension.Script, cancellationToken).ConfigureAwait(false);
+        var script = extension?.Script;
+        if (!string.IsNullOrEmpty(script)) {
+          await connection.OpenAndInitializeAsync(script, cancellationToken).ConfigureAwait(false);
         }
         else {
           await connection.OpenAsync(cancellationToken).ConfigureAwait(false);

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

@@ -18,6 +18,10 @@
 using Xtensive.Sql.Info;
 using Xtensive.Sql.Model;
 using Xtensive.Tuples;
+using System.Collections.Concurrent;
+using Xtensive.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
 
 namespace Xtensive.Orm.Providers
 {
@@ -26,13 +30,17 @@ namespace Xtensive.Orm.Providers
   /// </summary>
   public sealed partial class StorageDriver
   {
+    private static readonly MethodInfo FactoryCreatorMethod = typeof(StorageDriver).GetMethod(nameof(NewFactory), BindingFlags.Static | BindingFlags.NonPublic);
+
     private readonly DomainConfiguration configuration;
     private readonly SqlDriver underlyingDriver;
     private readonly SqlTranslator translator;
     private readonly TypeMappingRegistry allMappings;
     private readonly bool isLoggingEnabled;
     private readonly bool hasSavepoints;
 
+    private readonly ConcurrentDictionary<Type, Func<IConnectionHandler>> handlerFactoriesCache;
+
     public ProviderInfo ProviderInfo { get; private set; }
 
     public StorageExceptionBuilder ExceptionBuilder { get; private set; }
@@ -97,7 +105,7 @@ public DbDataReaderAccessor GetDataReaderAccessor(TupleDescriptor descriptor)
     public StorageDriver CreateNew(Domain domain)
     {
       ArgumentValidator.EnsureArgumentNotNull(domain, "domain");
-      return new StorageDriver(underlyingDriver, ProviderInfo, domain.Configuration, GetModelProvider(domain));
+      return new StorageDriver(underlyingDriver, ProviderInfo, domain.Configuration, GetModelProvider(domain), handlerFactoriesCache);
     }
 
     private static DomainModel GetNullModel()
@@ -151,14 +159,51 @@ private void FixExtractionResultSqlServerFamily(SqlExtractionResult result)
       }
     }
 
+    private IReadOnlyCollection<IConnectionHandler> CreateHandlersForConnection(IEnumerable<Type> connectionHandlerTypes)
+    {
+      if (handlerFactoriesCache == null)
+        return Array.Empty<IConnectionHandler>();
+      var instances = new List<IConnectionHandler>(handlerFactoriesCache.Count);
+      foreach (var type in connectionHandlerTypes) {
+        if (handlerFactoriesCache.TryGetValue(type, out var factory))
+          instances.Add(factory());
+      }
+      return instances.ToArray();
+    }
+
+    // used on driver creation so it is very first time handlers are created.
+    // great place to create and cache factories for faster initialization on session opening later
+    private static IReadOnlyCollection<IConnectionHandler> CreateConnectionHandlers(IEnumerable<Type> connectionHandlerTypes,
+      out ConcurrentDictionary<Type, Func<IConnectionHandler>> factories)
+    {
+      var instances = new List<IConnectionHandler>();
+      factories = new ConcurrentDictionary<Type, Func<IConnectionHandler>>();
+      foreach (var item in connectionHandlerTypes) {
+        var handlerFactory = (Func<IConnectionHandler>) FactoryCreatorMethod.MakeGenericMethod(item).Invoke(null, null);
+        instances.Add(handlerFactory());
+        factories[item] = handlerFactory;
+      }
+      if (factories.Count == 0)
+        factories = null;
+      return instances.ToArray();
+    }
+
+    private static Func<IConnectionHandler> NewFactory<T>() where T : IConnectionHandler
+    {
+      return FastExpression.Lambda<Func<IConnectionHandler>>(
+        Expression.Convert(Expression.New(typeof(T)), typeof(IConnectionHandler)))
+        .Compile();
+    }
+
     // Constructors
 
     public static StorageDriver Create(SqlDriverFactory driverFactory, DomainConfiguration configuration)
     {
       ArgumentValidator.EnsureArgumentNotNull(driverFactory, nameof(driverFactory));
       ArgumentValidator.EnsureArgumentNotNull(configuration, nameof(configuration));
 
-      var driverConfiguration = new SqlDriverConfiguration {
+      var handlers = CreateConnectionHandlers(configuration.Types.ConnectionHandlers, out var factories);
+      var driverConfiguration = new SqlDriverConfiguration(handlers) {
         ForcedServerVersion = configuration.ForcedServerVersion,
         ConnectionInitializationSql = configuration.ConnectionInitializationSql,
         EnsureConnectionIsAlive = configuration.EnsureConnectionIsAlive,
@@ -167,7 +212,7 @@ public static StorageDriver Create(SqlDriverFactory driverFactory, DomainConfigu
       var driver = driverFactory.GetDriver(configuration.ConnectionInfo, driverConfiguration);
       var providerInfo = ProviderInfoBuilder.Build(configuration.ConnectionInfo.Provider, driver);
 
-      return new StorageDriver(driver, providerInfo, configuration, GetNullModel);
+      return new StorageDriver(driver, providerInfo, configuration, GetNullModel, factories);
     }
 
     public static async Task<StorageDriver> CreateAsync(
@@ -176,7 +221,8 @@ public static async Task<StorageDriver> CreateAsync(
       ArgumentValidator.EnsureArgumentNotNull(driverFactory, nameof(driverFactory));
       ArgumentValidator.EnsureArgumentNotNull(configuration, nameof(configuration));
 
-      var driverConfiguration = new SqlDriverConfiguration {
+      var handlers = CreateConnectionHandlers(configuration.Types.ConnectionHandlers, out var factories);
+      var driverConfiguration = new SqlDriverConfiguration(handlers) {
         ForcedServerVersion = configuration.ForcedServerVersion,
         ConnectionInitializationSql = configuration.ConnectionInitializationSql,
         EnsureConnectionIsAlive = configuration.EnsureConnectionIsAlive,
@@ -186,11 +232,14 @@ public static async Task<StorageDriver> CreateAsync(
         .ConfigureAwait(false);
       var providerInfo = ProviderInfoBuilder.Build(configuration.ConnectionInfo.Provider, driver);
 
-      return new StorageDriver(driver, providerInfo, configuration, GetNullModel);
+      return new StorageDriver(driver, providerInfo, configuration, GetNullModel, factories);
     }
 
-    private StorageDriver(
-      SqlDriver driver, ProviderInfo providerInfo, DomainConfiguration configuration, Func<DomainModel> modelProvider)
+    private StorageDriver(SqlDriver driver,
+      ProviderInfo providerInfo,
+      DomainConfiguration configuration,
+      Func<DomainModel> modelProvider,
+      ConcurrentDictionary<Type,Func<IConnectionHandler>> factoryCache)
     {
       underlyingDriver = driver;
       ProviderInfo = providerInfo;
@@ -201,6 +250,7 @@ private StorageDriver(
       hasSavepoints = underlyingDriver.ServerInfo.ServerFeatures.Supports(ServerFeatures.Savepoints);
       isLoggingEnabled = SqlLog.IsLogged(LogLevel.Info); // Just to cache this value
       ServerInfo = underlyingDriver.ServerInfo;
+      handlerFactoriesCache = factoryCache;
     }
   }
 }

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 handlers 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;
+    }
+  }
+}