source: branches/HiveStatistics/sources/HeuristicLab.Services.Hive.DataAccess/3.3/Manager/PersistenceManager.cs @ 12477

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 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.Data.Linq;
using System.Transactions;
using HeuristicLab.Services.Hive.DataAccess.Daos;
using HeuristicLab.Services.Hive.DataAccess.Daos.HiveStatistics;
using HeuristicLab.Services.Hive.DataAccess.Interfaces;

namespace HeuristicLab.Services.Hive.DataAccess.Manager {
  public class PersistenceManager : IPersistenceManager {
    private readonly DataContext dataContext;
    public DataContext DataContext {
      get { return dataContext; }
    }

    #region Hive daos
    public AssignedResourceDao AssignedResourceDao {
      get { return new AssignedResourceDao(dataContext); }
    }

    public DowntimeDao DowntimeDao {
      get { return new DowntimeDao(dataContext); }
    }

    public JobDao JobDao {
      get { return new JobDao(dataContext); }
    }

    public JobPermissionDao JobPermissionDao {
      get { return new JobPermissionDao(dataContext); }
    }

    public LifecycleDao LifecycleDao {
      get { return new LifecycleDao(dataContext); }
    }

    public PluginDao PluginDao {
      get { return new PluginDao(dataContext); }
    }

    public PluginDataDao PluginDataDao {
      get { return new PluginDataDao(dataContext); }
    }

    public RequiredPluginDao RequiredPluginDao {
      get { return new RequiredPluginDao(dataContext); }
    }

    public ResourceDao ResourceDao {
      get { return new ResourceDao(dataContext); }
    }

    public ResourcePermissionDao ResourcePermissionDao {
      get { return new ResourcePermissionDao(dataContext); }
    }

    public SlaveDao SlaveDao {
      get { return new SlaveDao(dataContext); }
    }

    public SlaveGroupDao SlaveGroupDao {
      get { return new SlaveGroupDao(dataContext); }
    }

    public StateLogDao StateLogDao {
      get { return new StateLogDao(dataContext); }
    }

    public TaskDao TaskDao {
      get { return new TaskDao(dataContext); }
    }

    public TaskDataDao TaskDataDao {
      get { return new TaskDataDao(dataContext); }
    }

    public UserPriorityDao UserPriorityDao {
      get { return new UserPriorityDao(dataContext); }
    }
    #endregion

    #region HiveStatistics daos
    public DimClientDao DimClientDao {
      get { return new DimClientDao(dataContext); }
    }

    public DimJobDao DimJobDao {
      get { return new DimJobDao(dataContext); }
    }

    public DimTimeDao DimTimeDao {
      get { return new DimTimeDao(dataContext); }
    }

    public DimUserDao DimUserDao {
      get { return new DimUserDao(dataContext); }
    }

    public FactClientInfoDao FactClientInfoDao {
      get { return new FactClientInfoDao(dataContext); }
    }

    public FactTaskDao FactTaskDao {
      get { return new FactTaskDao(dataContext); }
    }
    #endregion

    public PersistenceManager(bool longRunning = false) {
      var context = new HiveDataContext(Settings.Default.HeuristicLab_Hive_LinqConnectionString);
      if (longRunning) context.CommandTimeout = (int)Settings.Default.LongRunningDatabaseCommandTimeout.TotalSeconds;
      dataContext = context;
    }

    #region Transaction management
    public void UseTransaction(Action call, bool repeatableRead = false, bool longRunning = false) {
      UseTransaction<object>(() => {
        call();
        return null;
      });
    }

    public T UseTransaction<T>(Func<T> call, bool repeatableRead = false, bool longRunning = false) {
      int n = 10;
      while (n > 0) {
        TransactionScope transaction = CreateTransaction(repeatableRead, longRunning);
        try {
          T result = call();
          transaction.Complete();
          return result;
        }
        catch (System.Data.SqlClient.SqlException e) {
          n--; // probably deadlock situation, let it roll back and repeat the transaction n times
          LogFactory.GetLogger(typeof(TransactionManager).Namespace).Log(string.Format("Exception occured, repeating transaction {0} more times. Details: {1}", n, e.ToString()));
          if (n <= 0) throw;
        }
        finally {
          transaction.Dispose();
        }
      }
      throw new Exception("Transaction couldn't be completed.");
    }

    private static TransactionScope CreateTransaction(bool repeatableRead, bool longRunning) {
      var options = new TransactionOptions {
        IsolationLevel = repeatableRead ? IsolationLevel.RepeatableRead : IsolationLevel.ReadUncommitted
      };
      if (longRunning) {
        options.Timeout = Settings.Default.LongRunningDatabaseCommandTimeout;
      }
      return new TransactionScope(TransactionScopeOption.Required, options);
    }
    #endregion

    public void SubmitChanges() {
      if (dataContext != null) {
        dataContext.SubmitChanges();
      }
    }

    public void Dispose() {
      if (dataContext != null) {
        dataContext.Dispose();
      }
    }
  }
}