source: branches/1888_OaaS/HeuristicLab.Services.Hive/3.3/ConnectionProvider.cs @ 16371

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Services.Hive.Interfaces;
using System.Configuration;
using System.Data.Common;
using System.ServiceModel;
using System.Transactions;

namespace HeuristicLab.Services.Hive {
  public class ConnectionProvider : IConnectionProvider {
    public System.Data.Common.DbConnection GetOpenConnection(string connectionStringName) {
      ConnectionStringSettings connSettings = ConfigurationManager.ConnectionStrings[connectionStringName];
      DbProviderFactory dbProvFact = DbProviderFactories.GetFactory(connSettings.ProviderName);
      return ConnectionUtilsStorage.Current.GetOpenConnection(dbProvFact, connSettings.ConnectionString);
    }


    public void ReleaseConnection(DbConnection connection) {
      ConnectionUtilsStorage.Current.ReleaseConnection(connection);
    }
  }

  /// <summary>
  /// Based on the connection management developed by jheinzelreiter,
  /// this class stores transactions + connections, closing connections
  /// after a transaction has been closed.
  /// A non-transacted connection might be closed by the user by calling
  /// ReleaseConnection(connection).
  /// </summary>
  class ConnectionUtilsStorage : IExtension<OperationContext> {
    private readonly IDictionary<Transaction, IDictionary<string, DbConnection>>
      transactedConnections = new Dictionary<Transaction, IDictionary<string, DbConnection>>();

    /// <summary>
    /// Returns an opened DbConnection. If a transaction is present, for
    /// each unique connection string the same connection is returned.
    /// </summary>
    /// <param name="providerFactory">DbProviderFactory, which should be used to create 
    /// connection</param>
    /// <param name="connectionString">connection string of the connection</param>
    /// <returns>A <see cref="DbConnection"/> instance</returns>
    public DbConnection GetOpenConnection(DbProviderFactory providerFactory, string connectionString) {
      DbConnection connection = null;
      Transaction currentTransaction = Transaction.Current;
      if (currentTransaction == null) {
        // no transaction context -> return "ordinary" connection
        connection = CreateOpenConnection(providerFactory, connectionString);
      }
      else {
        // transaction present
        IDictionary<string, DbConnection> connections = null;
        lock (transactedConnections) {
          // check if current transaction already has at least one connection assigned
          if (!transactedConnections.TryGetValue(currentTransaction, out connections)) {
            connections = new Dictionary<string, DbConnection>();
            transactedConnections[currentTransaction] = connections;
          }

          if (!connections.TryGetValue(connectionString, out connection)) {
            // no connection for this connection string in the current transaction
            connection = CreateOpenConnection(providerFactory, connectionString);

            connections[connectionString] = connection;
            currentTransaction.TransactionCompleted +=
              new TransactionCompletedEventHandler(OnTransactionCompleted);
          }
        }
      }
      return connection;
    }

    /// <summary>
    /// Creates a new, opened DbConnection
    /// </summary>
    /// <param name="connectionString">connection string of the connection</param>
    /// <param name="providerFactory">DbProviderFactory, which should be used to create 
    /// connection</param>
    /// <returns>A <see cref="DbConnection"/> instance </returns>
    private DbConnection CreateOpenConnection(DbProviderFactory providerFactory,
                                                     string connectionString) {
      DbConnection connection = providerFactory.CreateConnection();
      connection.ConnectionString = connectionString;
      connection.Open();
      return connection;
    }

    /// <summary>
    /// Releases a connection. 
    /// (Remark: The connection is closed only when not used in a transaction)
    /// </summary>
    /// <param name="connection">connection to release</param>
    public void ReleaseConnection(DbConnection connection) {
      if (connection == null)
        return;

      Transaction currentTransaction = Transaction.Current;
      // close connection if no transaction is active
      if (currentTransaction == null)
        connection.Close();
    }

    /// <summary>
    /// Determines, if custom connection handling code should close a connection.
    /// (Remark: Used for DataReader.CommandBehavior)
    /// </summary>
    /// <returns></returns>
    public bool ShouldCloseConnection() {
      return Transaction.Current == null;
    }

    /// <summary>
    /// Eventhandler for TransactionScope.TransactionCompleted.
    /// Closes connections and removes transaction from observed connections.
    /// </summary>
    /// <param name="sender">sender</param>
    /// <param name="e">TransactionEventArgs</param>
    private void OnTransactionCompleted(object sender, TransactionEventArgs e) {
      lock (transactedConnections) {
        IDictionary<string, DbConnection> connections = null;
        if (transactedConnections.TryGetValue(e.Transaction, out connections)) {
          foreach (DbConnection conn in connections.Values)
            conn.Close();
          transactedConnections.Remove(e.Transaction);
        }
      }
    }
    private static object monitor = new object();
    private static ConnectionUtilsStorage _context = new ConnectionUtilsStorage();

    public static ConnectionUtilsStorage Current {
      get {
        ConnectionUtilsStorage context;
        if (OperationContext.Current != null) {
          context = OperationContext.Current.Extensions.Find<ConnectionUtilsStorage>();
          if (context == null) {
            lock (monitor) {
              context = OperationContext.Current.Extensions.Find<ConnectionUtilsStorage>();
              if (context == null) {
                context = new ConnectionUtilsStorage();
                OperationContext.Current.Extensions.Add(context);
              }
            }
          }
        }
        else {
          context = _context;
        }
        return context;
      }
    }

    public void Attach(OperationContext owner) {
    }

    public void Detach(OperationContext owner) {
    }
  }
}