source: branches/HiveProjectManagement/HeuristicLab.Services.Hive.DataAccess/3.3/Manager/PersistenceManager.cs @ 15546

Last change on this file since 15546 was 15546, checked in by jzenisek, 3 years ago

#2839 worked on ProjectResource assignment: (cascading) assigning & unassigning

File size: 9.0 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Data.Linq;
24using System.Linq;
25using System.Transactions;
26using HeuristicLab.Services.Hive.DataAccess.Daos;
27using HeuristicLab.Services.Hive.DataAccess.Daos.HiveStatistics;
28using HeuristicLab.Services.Hive.DataAccess.Data;
29using HeuristicLab.Services.Hive.DataAccess.Interfaces;
30
31namespace HeuristicLab.Services.Hive.DataAccess.Manager {
32  public class PersistenceManager : IPersistenceManager {
33    private readonly DataContext dataContext;
34    public DataContext DataContext {
35      get { return dataContext; }
36    }
37
38    #region Hive daos
39
40    private AssignedTaskResourceDao assignedTaskResourceDao;
41    public AssignedTaskResourceDao AssignedTaskResourceDao {
42      get { return assignedTaskResourceDao ?? (assignedTaskResourceDao = new AssignedTaskResourceDao(dataContext)); }
43    }
44
45    private AssignedProjectResourceDao assignedProjectResourceDao;
46    public AssignedProjectResourceDao AssignedProjectResourceDao {
47      get { return assignedProjectResourceDao ?? (assignedProjectResourceDao = new AssignedProjectResourceDao(dataContext)); }
48    }
49
50    private DowntimeDao downtimeDao;
51    public DowntimeDao DowntimeDao {
52      get { return downtimeDao ?? (downtimeDao = new DowntimeDao(dataContext)); }
53    }
54
55    private JobDao jobDao;
56    public JobDao JobDao {
57      get { return jobDao ?? (jobDao = new JobDao(dataContext)); }
58    }
59
60    private JobPermissionDao jobPermissionDao;
61    public JobPermissionDao JobPermissionDao {
62      get { return jobPermissionDao ?? (jobPermissionDao = new JobPermissionDao(dataContext)); }
63    }
64
65    private LifecycleDao lifecycleDao;
66    public LifecycleDao LifecycleDao {
67      get { return lifecycleDao ?? (lifecycleDao = new LifecycleDao(dataContext)); }
68    }
69
70    private PluginDao pluginDao;
71    public PluginDao PluginDao {
72      get { return pluginDao ?? (pluginDao = new PluginDao(dataContext)); }
73    }
74
75    private PluginDataDao pluginDataDao;
76    public PluginDataDao PluginDataDao {
77      get { return pluginDataDao ?? (pluginDataDao = new PluginDataDao(dataContext)); }
78    }
79
80    private ProjectDao projectDao;
81    public ProjectDao ProjectDao {
82      get { return projectDao ?? (projectDao = new ProjectDao(dataContext)); }
83    }
84
85    private ProjectPermissionDao projectPermissionDao;
86    public ProjectPermissionDao ProjectPermissionDao {
87      get { return projectPermissionDao ?? (projectPermissionDao = new ProjectPermissionDao(dataContext)); }
88    }
89
90    private RequiredPluginDao requiredPluginDao;
91    public RequiredPluginDao RequiredPluginDao {
92      get { return requiredPluginDao ?? (requiredPluginDao = new RequiredPluginDao(dataContext)); }
93    }
94
95    private ResourceDao resourceDao;
96    public ResourceDao ResourceDao {
97      get { return resourceDao ?? (resourceDao = new ResourceDao(dataContext)); }
98    }
99
100    private SlaveDao slaveDao;
101    public SlaveDao SlaveDao {
102      get { return slaveDao ?? (slaveDao = new SlaveDao(dataContext)); }
103    }
104
105    private SlaveGroupDao slaveGroupDao;
106    public SlaveGroupDao SlaveGroupDao {
107      get { return slaveGroupDao ?? (slaveGroupDao = new SlaveGroupDao(dataContext)); }
108    }
109
110    private StateLogDao stateLogDao;
111    public StateLogDao StateLogDao {
112      get { return stateLogDao ?? (stateLogDao = new StateLogDao(dataContext)); }
113    }
114
115    private TaskDao taskDao;
116    public TaskDao TaskDao {
117      get { return taskDao ?? (taskDao = new TaskDao(dataContext)); }
118    }
119
120    private TaskDataDao taskDataDao;
121    public TaskDataDao TaskDataDao {
122      get { return taskDataDao ?? (taskDataDao = new TaskDataDao(dataContext)); }
123    }
124
125    private UserPriorityDao userPriorityDao;
126    public UserPriorityDao UserPriorityDao {
127      get { return userPriorityDao ?? (userPriorityDao = new UserPriorityDao(dataContext)); }
128    }
129    #endregion
130
131    #region HiveStatistics daos
132
133    private DimClientDao dimClientDao;
134    public DimClientDao DimClientDao {
135      get { return dimClientDao ?? (dimClientDao = new DimClientDao(dataContext)); }
136    }
137
138    private DimJobDao dimJobDao;
139    public DimJobDao DimJobDao {
140      get { return dimJobDao ?? (dimJobDao = new DimJobDao(dataContext)); }
141    }
142
143    private DimTimeDao dimTimeDao;
144    public DimTimeDao DimTimeDao {
145      get { return dimTimeDao ?? (dimTimeDao = new DimTimeDao(dataContext)); }
146    }
147
148    private DimUserDao dimUserDao;
149    public DimUserDao DimUserDao {
150      get { return dimUserDao ?? (dimUserDao = new DimUserDao(dataContext)); }
151    }
152
153    private FactClientInfoDao factClientInfoDao;
154    public FactClientInfoDao FactClientInfoDao {
155      get { return factClientInfoDao ?? (factClientInfoDao = new FactClientInfoDao(dataContext)); }
156    }
157
158    private FactTaskDao factTaskDao;
159    public FactTaskDao FactTaskDao {
160      get { return factTaskDao ?? (factTaskDao = new FactTaskDao(dataContext)); }
161    }
162    #endregion
163
164    public PersistenceManager(bool longRunning = false) {
165      var context = new HiveDataContext(Settings.Default.HeuristicLab_Hive_LinqConnectionString);
166      if (longRunning) context.CommandTimeout = (int)Settings.Default.LongRunningDatabaseCommandTimeout.TotalSeconds;
167      dataContext = context;
168    }
169
170    public PersistenceManager(DataContext dataContext) {
171      this.dataContext = dataContext;
172    }
173
174    #region Transaction management
175    public void UseTransaction(Action call, bool repeatableRead = false, bool longRunning = false) {
176      UseTransaction<object>(() => {
177        call();
178        return null;
179      });
180    }
181
182    public T UseTransaction<T>(Func<T> call, bool repeatableRead = false, bool longRunning = false) {
183      int n = 10;
184      while (n > 0) {
185        TransactionScope transaction = CreateTransaction(repeatableRead, longRunning);
186        try {
187          T result = call();
188          transaction.Complete();
189          return result;
190        }
191        catch (System.Data.SqlClient.SqlException e) {
192          n--; // probably deadlock situation, let it roll back and repeat the transaction n times
193          LogFactory.GetLogger(typeof(TransactionManager).Namespace).Log(string.Format("Exception occured, repeating transaction {0} more times. Details: {1}", n, e.ToString()));
194          if (n <= 0) throw;
195        }
196        finally {
197          transaction.Dispose();
198        }
199      }
200      throw new Exception("Transaction couldn't be completed.");
201    }
202
203    private static TransactionScope CreateTransaction(bool repeatableRead, bool longRunning) {
204      var options = new TransactionOptions {
205        IsolationLevel = repeatableRead ? IsolationLevel.RepeatableRead : IsolationLevel.ReadUncommitted
206      };
207      if (longRunning) {
208        options.Timeout = Settings.Default.LongRunningDatabaseCommandTimeout;
209      }
210      return new TransactionScope(TransactionScopeOption.Required, options);
211    }
212    #endregion
213
214    public TableInformation GetTableInformation(string table) {
215      string query = string.Format("sp_spaceused '{0}'", table);
216      var result = dataContext.ExecuteQuery<SqlServerTableInformation>(query).FirstOrDefault();
217      if (result == null) return null;
218      return new TableInformation {
219        Name = result.Name,
220        Rows = int.Parse(result.Rows.Remove(result.Rows.IndexOf(' '))),
221        Reserved = int.Parse(result.Reserved.Remove(result.Reserved.IndexOf(' '))),
222        Data = int.Parse(result.Data.Remove(result.Data.IndexOf(' '))),
223        IndexSize = int.Parse(result.Index_Size.Remove(result.Index_Size.IndexOf(' '))),
224        Unused = int.Parse(result.Unused.Remove(result.Unused.IndexOf(' ')))
225      };
226    }
227
228    public void SubmitChanges() {
229      if (dataContext != null) {
230        dataContext.SubmitChanges();
231      }
232    }
233
234    public void Dispose() {
235      if (dataContext != null) {
236        dataContext.Dispose();
237      }
238    }
239
240    private class SqlServerTableInformation {
241      public string Name { get; set; }
242      public string Rows { get; set; }
243      public string Reserved { get; set; }
244      public string Data { get; set; }
245      public string Index_Size { get; set; } // naming of sp_spaceused...
246      public string Unused { get; set; }
247    }
248  }
249}
Note: See TracBrowser for help on using the repository browser.