source: branches/3.3-Hive/sources/HeuristicLab.Hive/HeuristicLab.Hive.Server.LINQDataAccess/3.3/ContextFactory.cs @ 4424

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 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.Data.Linq;
using System.Threading;
using System.Transactions;
using HeuristicLab.Hive.Contracts;
using HeuristicLab.Hive.Server.DataAccess;
using HeuristicLab.Hive.Server.LINQDataAccess.Properties;
using HeuristicLab.Tracing;


namespace HeuristicLab.Hive.Server.LINQDataAccess {
  /// <summary>
  /// This class handles creates one Context for each Thread which asks for one.
  /// If one Thread calls GetContext several times, it always gets the same Context object.
  /// A context object is removed from the cache when it is disposed. 
  /// 
  /// Every context has a DB-Transaction over its livetime. After using the context object
  /// it has to be disposed in order to finish the corresponding transaction.
  /// </summary>
  class ContextFactory : IContextFactory {
    private static object locker = new object();
    private static IDictionary<int, HiveDataContext> contexts = new Dictionary<int, HiveDataContext>();
    private static IDictionary<int, TransactionScope> transactions = new Dictionary<int, TransactionScope>();

    private static IContextFactory instance = null;
    public static IContextFactory Instance {
      get {
        if (instance == null)
          instance = new ContextFactory();
        return instance;
      }
    }

    #region IContextManager Members

    public IDisposable GetContext() {
      return GetContext(true);
    }

    public IDisposable GetContext(bool withTransaction) {
      lock (locker) {
        int threadId = Thread.CurrentThread.ManagedThreadId;

        if (contexts.ContainsKey(threadId)) {
          Logger.Error("ERROR: Context for this Thread already defined. Will dispose it and then create a new one.");
          RemoveContext();
          RemoveAndCompleteTransaction();
        }

        DisposableHiveDataContext context = CreateContext();
        context.OnDisposing += new EventHandler(context_OnDisposing);
        contexts.Add(threadId, context);

        if (withTransaction) {
          TransactionScope transaction = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = ApplicationConstants.ISOLATION_LEVEL_SCOPE });
          transactions.Add(threadId, transaction);
        }
        return context;
      }
    }

    private static DisposableHiveDataContext CreateContext() {
      return new DisposableHiveDataContext(Settings.Default.HeuristicLab_Hive_LinqConnectionString);
    }

    void context_OnDisposing(object sender, EventArgs e) {
      lock (locker) {
        RemoveContext();
        RemoveAndCompleteTransaction();
      }
    }

    public void RollbackTransaction() {
      int threadId = Thread.CurrentThread.ManagedThreadId;

      TransactionScope transaction = transactions[threadId];
      transaction.Dispose();
    }

    public void RemoveContext() {
      lock (locker) {
        int threadId = Thread.CurrentThread.ManagedThreadId;

        contexts.Remove(threadId);
        // context gets disposed implicitly, when it is used as IDisposable
      }
    }

    public void RemoveAndCompleteTransaction() {
      lock (locker) {
        int threadId = Thread.CurrentThread.ManagedThreadId;

        // context does not always have an associated transaction
        if (transactions.ContainsKey(threadId)) {
          try {
            transactions[threadId].Complete();
            transactions[threadId].Dispose();
          }
          catch (Exception) { }
          finally {
            transactions.Remove(threadId);
          }
        }
      }
    }

    public DataContext CurrentContext {
      get {
        lock (locker) {
          int threadId = Thread.CurrentThread.ManagedThreadId;
          if (contexts.ContainsKey(threadId)) {
            return contexts[threadId];
          } else {
            return null;
          }
        }
      }
    }

    #endregion
  }

  /// <summary>
  /// Offers an event when it gets disposed
  /// </summary>
  class DisposableHiveDataContext : HiveDataContext {

    public DisposableHiveDataContext(string connection) : base(connection) { }

    protected override void Dispose(bool disposing) {
      base.Dispose(disposing);
      if (OnDisposing != null)
        OnDisposing(this, new EventArgs());
    }

    public event EventHandler OnDisposing;
  }
}