Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Services.Hive/3.3/HiveService.cs @ 9219

Last change on this file since 9219 was 9219, checked in by ascheibe, 11 years ago

#2005 merged Hive Job Unloading branch back into trunk
File size: 30.0 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2012 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.Collections.Generic;
24using System.Linq;
25using System.ServiceModel;
26using HeuristicLab.Services.Hive.DataTransfer;
27using HeuristicLab.Services.Hive.ServiceContracts;
28using DA = HeuristicLab.Services.Hive.DataAccess;
29using DT = HeuristicLab.Services.Hive.DataTransfer;
30
31
32namespace HeuristicLab.Services.Hive {
33
34  /// <summary>
35  /// Implementation of the Hive service (interface <see cref="IHiveService"/>).
36  /// We need 'IgnoreExtensionDataObject' Attribute for the slave to work.
37  /// </summary>
38  [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, IgnoreExtensionDataObject = true)]
39  public class HiveService : IHiveService {
40    private IHiveDao dao {
41      get { return ServiceLocator.Instance.HiveDao; }
42    }
43    private Access.IRoleVerifier authen {
44      get { return ServiceLocator.Instance.RoleVerifier; }
45    }
46    private IAuthorizationManager author {
47      get { return ServiceLocator.Instance.AuthorizationManager; }
48    }
49    private DataAccess.ITransactionManager trans {
50      get { return ServiceLocator.Instance.TransactionManager; }
51    }
52    private IEventManager eventManager {
53      get { return ServiceLocator.Instance.EventManager; }
54    }
55    private Access.IUserManager userManager {
56      get { return ServiceLocator.Instance.UserManager; }
57    }
58    private HeartbeatManager heartbeatManager {
59      get { return ServiceLocator.Instance.HeartbeatManager; }
60    }
61
62    #region Task Methods
63    public Guid AddTask(Task task, TaskData taskData, IEnumerable<Guid> resourceIds) {
64      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
65      return trans.UseTransaction(() => {
66        task.Id = dao.AddTask(task);
67        taskData.TaskId = task.Id;
68        taskData.LastUpdate = DateTime.Now;
69        foreach (Guid slaveGroupId in resourceIds) {
70          dao.AssignJobToResource(task.Id, slaveGroupId);
71        }
72        dao.AddTaskData(taskData);
73        dao.UpdateTaskState(task.Id, DA.TaskState.Waiting, null, userManager.CurrentUserId, null);
74        return taskData.TaskId;
75      }, false, true);
76    }
77
78    public Guid AddChildTask(Guid parentTaskId, Task task, TaskData taskData) {
79      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
80      return trans.UseTransaction(() => {
81        task.ParentTaskId = parentTaskId;
82        return AddTask(task, taskData, dao.GetAssignedResources(parentTaskId).Select(x => x.Id));
83      }, false, true);
84    }
85
86    public Task GetTask(Guid taskId) {
87      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
88      author.AuthorizeForTask(taskId, Permission.Read);
89
90      return trans.UseTransaction(() => {
91        return dao.GetTask(taskId);
92      }, false, false);
93    }
94
95    public IEnumerable<Task> GetTasks() {
96      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
97      var tasks = dao.GetTasks(x => true);
98      foreach (var task in tasks)
99        author.AuthorizeForTask(task.Id, Permission.Read);
100      return tasks;
101    }
102
103    public IEnumerable<LightweightTask> GetLightweightTasks(IEnumerable<Guid> taskIds) {
104      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
105
106      return trans.UseTransaction(() => {
107        var tasks = dao.GetTasks(x => taskIds.Contains(x.TaskId)).Select(x => new LightweightTask(x)).ToArray();
108        foreach (var task in tasks)
109          author.AuthorizeForTask(task.Id, Permission.Read);
110        return tasks;
111      }, false, false);
112    }
113
114    public IEnumerable<LightweightTask> GetLightweightChildTasks(Guid? parentTaskId, bool recursive, bool includeParent) {
115      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
116
117      return trans.UseTransaction(() => {
118        var tasks = GetChildTasks(parentTaskId, recursive, includeParent).Select(x => new LightweightTask(x)).ToArray();
119        foreach (var task in tasks)
120          author.AuthorizeForTask(task.Id, Permission.Read);
121        return tasks;
122      }, false, false);
123    }
124
125    public IEnumerable<LightweightTask> GetLightweightJobTasks(Guid jobId) {
126      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
127      author.AuthorizeForJob(jobId, Permission.Read);
128
129      return trans.UseTransaction(() => {
130        return dao.GetLightweightTasks(task => task.JobId == jobId).ToArray();
131      }, false, true);
132    }
133
134    public IEnumerable<LightweightTask> GetLightweightJobTasksWithoutStateLog(Guid jobId) {
135      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
136      author.AuthorizeForJob(jobId, Permission.Read);
137
138      return trans.UseTransaction(() => {
139        return dao.GetLightweightTasksWithoutStateLog(task => task.JobId == jobId).ToArray();
140      }, false, false);
141    }
142
143    public TaskData GetTaskData(Guid taskId) {
144      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
145      author.AuthorizeForTask(taskId, Permission.Read);
146      return dao.GetTaskData(taskId);
147    }
148
149    public void UpdateTask(Task taskDto) {
150      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
151      author.AuthorizeForTask(taskDto.Id, Permission.Full);
152      trans.UseTransaction(() => {
153        dao.UpdateTaskAndPlugins(taskDto);
154      });
155    }
156
157    public void UpdateTaskData(Task task, TaskData taskData) {
158      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
159      author.AuthorizeForTask(task.Id, Permission.Full);
160      author.AuthorizeForTask(taskData.TaskId, Permission.Full);
161      //trans.UseTransaction(() => { // cneumuel: try without transaction
162      taskData.LastUpdate = DateTime.Now;
163      dao.UpdateTaskAndPlugins(task);
164      dao.UpdateTaskData(taskData);
165      //}, false, true);
166    }
167
168    public void DeleteTask(Guid taskId) {
169      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
170      author.AuthorizeForTask(taskId, Permission.Full);
171      trans.UseTransaction(() => {
172        dao.DeleteTask(taskId);
173      });
174    }
175
176    public void DeleteChildTasks(Guid parentTaskId) {
177      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
178      author.AuthorizeForTask(parentTaskId, Permission.Full);
179      trans.UseTransaction(() => {
180        var tasks = GetChildTasks(parentTaskId, true, false);
181        foreach (var task in tasks) {
182          dao.DeleteTask(task.Id);
183          dao.DeleteTaskData(task.Id);
184        };
185      });
186    }
187
188    public Task UpdateTaskState(Guid taskId, TaskState taskState, Guid? slaveId, Guid? userId, string exception) {
189      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
190      author.AuthorizeForTask(taskId, Permission.Full);
191      return trans.UseTransaction(() => {
192        Task task = dao.UpdateTaskState(taskId, DataTransfer.Convert.ToEntity(taskState), slaveId, userId, exception);
193
194        if (task.Command.HasValue && task.Command.Value == Command.Pause && task.State == TaskState.Paused) {
195          task.Command = null;
196        } else if (task.Command.HasValue && task.Command.Value == Command.Abort && task.State == TaskState.Aborted) {
197          task.Command = null;
198        } else if (task.Command.HasValue && task.Command.Value == Command.Stop && task.State == TaskState.Aborted) {
199          task.Command = null;
200        } else if (taskState == TaskState.Paused && !task.Command.HasValue) {
201          // slave paused and uploaded the task (no user-command) -> set waiting.
202          task = dao.UpdateTaskState(taskId, DataTransfer.Convert.ToEntity(TaskState.Waiting), slaveId, userId, exception);
203        }
204
205        dao.UpdateTaskAndPlugins(task);
206        return task;
207      });
208    }
209
210    public IEnumerable<Task> GetTasksByResourceId(Guid resourceId) {
211      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
212      var tasks = trans.UseTransaction(() => dao.GetJobsByResourceId(resourceId));
213      foreach (var task in tasks)
214        author.AuthorizeForTask(task.Id, Permission.Read);
215      return tasks;
216    }
217    #endregion
218
219    #region Task Control Methods
220    public void StopTask(Guid taskId) {
221      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
222      author.AuthorizeForTask(taskId, Permission.Full);
223      trans.UseTransaction(() => {
224        var task = dao.GetTask(taskId);
225        if (task.State == TaskState.Calculating || task.State == TaskState.Transferring) {
226          task.Command = Command.Stop;
227          dao.UpdateTask(task);
228        } else {
229          if (task.State != TaskState.Aborted && task.State != TaskState.Finished && task.State != TaskState.Failed) {
230            task = UpdateTaskState(taskId, TaskState.Aborted, null, null, string.Empty);
231          }
232        }
233      });
234    }
235
236    public void PauseTask(Guid taskId) {
237      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
238      author.AuthorizeForTask(taskId, Permission.Full);
239      trans.UseTransaction(() => {
240        var job = dao.GetTask(taskId);
241        if (job.State == TaskState.Calculating || job.State == TaskState.Transferring) {
242          job.Command = Command.Pause;
243          dao.UpdateTask(job);
244        } else {
245          job = UpdateTaskState(taskId, TaskState.Paused, null, null, string.Empty);
246        }
247      });
248    }
249
250    public void RestartTask(Guid taskId) {
251      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
252      author.AuthorizeForTask(taskId, Permission.Full);
253      trans.UseTransaction(() => {
254        Task task = dao.UpdateTaskState(taskId, DA.TaskState.Waiting, null, userManager.CurrentUserId, string.Empty);
255        task.Command = null;
256        dao.UpdateTask(task);
257      });
258    }
259    #endregion
260
261    #region Job Methods
262    public Job GetJob(Guid id) {
263      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
264      author.AuthorizeForJob(id, Permission.Read);
265      var job = dao.GetJobs(x =>
266            x.JobId == id
267            && (x.OwnerUserId == userManager.CurrentUserId || x.JobPermissions.Count(hep => hep.Permission != DA.Permission.NotAllowed && hep.GrantedUserId == userManager.CurrentUserId) > 0)
268          ).FirstOrDefault();
269      if (job != null) {
270        job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
271        job.OwnerUsername = userManager.GetUserById(job.OwnerUserId).UserName;
272      }
273      return job;
274    }
275
276    public IEnumerable<Job> GetJobs() {
277      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
278      var jobs = dao.GetJobs(x => x.OwnerUserId == userManager.CurrentUserId || x.JobPermissions.Count(hep => hep.Permission != DA.Permission.NotAllowed && hep.GrantedUserId == userManager.CurrentUserId) > 0);
279      foreach (var job in jobs) {
280        author.AuthorizeForJob(job.Id, Permission.Read);
281        job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
282        job.OwnerUsername = userManager.GetUserById(job.OwnerUserId).UserName;
283      }
284      return jobs;
285    }
286
287    public IEnumerable<Job> GetAllJobs() {
288      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
289      var jobs = dao.GetJobs(x => true);
290      foreach (var job in jobs) { // no authorization here, since this method is admin-only! (admin is allowed to read all task)
291        job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
292        job.OwnerUsername = userManager.GetUserById(job.OwnerUserId).UserName;
293      }
294      return jobs;
295    }
296
297    public Guid AddJob(Job jobDto) {
298      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
299      return trans.UseTransaction(() => {
300        jobDto.OwnerUserId = userManager.CurrentUserId;
301        jobDto.DateCreated = DateTime.Now;
302        return dao.AddJob(jobDto);
303      });
304    }
305
306    public void UpdateJob(Job jobDto) {
307      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
308      author.AuthorizeForJob(jobDto.Id, Permission.Full);
309      trans.UseTransaction(() => {
310        dao.UpdateJob(jobDto);
311      });
312    }
313
314    public void DeleteJob(Guid jobId) {
315      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
316      author.AuthorizeForJob(jobId, Permission.Full);
317      trans.UseTransaction(() => {
318        dao.DeleteJob(jobId); // child task will be deleted by db-trigger
319      });
320    }
321    #endregion
322
323    #region JobPermission Methods
324    public void GrantPermission(Guid jobId, Guid grantedUserId, Permission permission) {
325      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
326      trans.UseTransaction(() => {
327        Job job = dao.GetJob(jobId);
328        if (job == null) throw new FaultException<FaultReason>(new FaultReason("Could not find task with id " + jobId));
329        Permission perm = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
330        if (perm != Permission.Full) throw new FaultException<FaultReason>(new FaultReason("Not allowed to grant permissions for this experiment"));
331        dao.SetJobPermission(jobId, userManager.CurrentUserId, grantedUserId, DT.Convert.ToEntity(permission));
332      });
333    }
334
335    public void RevokePermission(Guid jobId, Guid grantedUserId) {
336      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
337      trans.UseTransaction(() => {
338        Job job = dao.GetJob(jobId);
339        if (job == null) throw new FaultException<FaultReason>(new FaultReason("Could not find task with id " + jobId));
340        DA.Permission perm = dao.GetPermissionForJob(job.Id, userManager.CurrentUserId);
341        if (perm != DA.Permission.Full) throw new FaultException<FaultReason>(new FaultReason("Not allowed to grant permissions for this experiment"));
342        dao.SetJobPermission(jobId, userManager.CurrentUserId, grantedUserId, DA.Permission.NotAllowed);
343      });
344    }
345
346    public IEnumerable<JobPermission> GetJobPermissions(Guid jobId) {
347      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
348      return trans.UseTransaction(() => {
349        DA.Permission currentUserPermission = dao.GetPermissionForJob(jobId, userManager.CurrentUserId);
350        if (currentUserPermission != DA.Permission.Full) throw new FaultException<FaultReason>(new FaultReason("Not allowed to list permissions for this experiment"));
351        return dao.GetJobPermissions(x => x.JobId == jobId);
352      });
353    }
354
355    public bool IsAllowedPrivileged() {
356      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
357      return authen.IsInRole(HiveRoles.IsAllowedPrivileged);
358    }
359    #endregion
360
361    #region Login Methods
362    public void Hello(Slave slaveInfo) {
363      authen.AuthenticateForAnyRole(HiveRoles.Slave);
364      if (userManager.CurrentUser.UserName != "hiveslave")
365        slaveInfo.OwnerUserId = userManager.CurrentUserId;
366
367      trans.UseTransaction(() => {
368        var slave = dao.GetSlave(slaveInfo.Id);
369
370        if (slave == null) {
371          dao.AddSlave(slaveInfo);
372        } else {
373          slave.Name = slaveInfo.Name;
374          slave.Description = slaveInfo.Description;
375          slave.OwnerUserId = slaveInfo.OwnerUserId;
376
377          slave.Cores = slaveInfo.Cores;
378          slave.CpuArchitecture = slaveInfo.CpuArchitecture;
379          slave.CpuSpeed = slaveInfo.CpuSpeed;
380          slave.FreeCores = slaveInfo.FreeCores;
381          slave.FreeMemory = slaveInfo.FreeMemory;
382          slave.Memory = slaveInfo.Memory;
383          slave.OperatingSystem = slaveInfo.OperatingSystem;
384
385          slave.LastHeartbeat = DateTime.Now;
386          slave.SlaveState = SlaveState.Idle;
387
388          // don't update those properties: dbSlave.IsAllowedToCalculate, dbSlave.ParentResourceId
389
390          dao.UpdateSlave(slave);
391        }
392      });
393    }
394
395    public void GoodBye(Guid slaveId) {
396      authen.AuthenticateForAnyRole(HiveRoles.Slave);
397      trans.UseTransaction(() => {
398        var slave = dao.GetSlave(slaveId);
399        if (slave != null) {
400          slave.SlaveState = SlaveState.Offline;
401          dao.UpdateSlave(slave);
402        }
403      });
404    }
405    #endregion
406
407    #region Heartbeat Methods
408    public List<MessageContainer> Heartbeat(Heartbeat heartbeat) {
409      authen.AuthenticateForAnyRole(HiveRoles.Slave);
410
411      List<MessageContainer> result = trans.UseTransaction(() => heartbeatManager.ProcessHeartbeat(heartbeat));
412
413      if (HeuristicLab.Services.Hive.Properties.Settings.Default.TriggerEventManagerInHeartbeat) {
414        TriggerEventManager(false);
415      }
416
417      return result;
418    }
419    #endregion
420
421    #region Plugin Methods
422    public Guid AddPlugin(Plugin plugin, List<PluginData> pluginDatas) {
423      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
424      return trans.UseTransaction(() => {
425        plugin.UserId = userManager.CurrentUserId;
426        plugin.DateCreated = DateTime.Now;
427
428        var existing = dao.GetPlugins(x => x.Hash != null).Where(x => x.Hash.SequenceEqual(plugin.Hash));
429        if (existing.Count() > 0) {
430          // a plugin already exists.
431          throw new FaultException<PluginAlreadyExistsFault>(new PluginAlreadyExistsFault(existing.Single().Id));
432        }
433
434        Guid pluginId = dao.AddPlugin(plugin);
435        foreach (PluginData pluginData in pluginDatas) {
436          pluginData.PluginId = pluginId;
437          dao.AddPluginData(pluginData);
438        }
439        return pluginId;
440      });
441    }
442
443    public Plugin GetPlugin(Guid pluginId) {
444      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
445      return dao.GetPlugin(pluginId);
446    }
447
448    public Plugin GetPluginByHash(byte[] hash) {
449      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
450      return dao.GetPlugins(x => x.Hash == hash).FirstOrDefault();
451    }
452
453    // note: this is a possible security problem, since a client is able to download all plugins, which may contain proprietary code (which can be disassembled)
454    //       change so that only with GetPluginByHash it is possible to download plugins
455    public IEnumerable<Plugin> GetPlugins() {
456      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
457      return dao.GetPlugins(x => x.Hash != null);
458    }
459
460    public IEnumerable<PluginData> GetPluginDatas(List<Guid> pluginIds) {
461      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
462      var pluginDatas = new List<PluginData>();
463      return trans.UseTransaction(() => {
464        foreach (Guid guid in pluginIds) {
465          pluginDatas.AddRange(dao.GetPluginDatas(x => x.PluginId == guid).ToList());
466        }
467        return pluginDatas;
468      });
469    }
470
471    public void DeletePlugin(Guid pluginId) {
472      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
473      dao.DeletePlugin(pluginId);
474    }
475    #endregion
476
477    #region ResourcePermission Methods
478    public void GrantResourcePermissions(Guid resourceId, Guid[] grantedUserIds) {
479      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
480      trans.UseTransaction(() => {
481        Resource resource = dao.GetResource(resourceId);
482        if (resource == null) throw new FaultException<FaultReason>(new FaultReason("Could not find resource with id " + resourceId));
483        if (resource.OwnerUserId != userManager.CurrentUserId && !authen.IsInRole(HiveRoles.Administrator)) throw new FaultException<FaultReason>(new FaultReason("Not allowed to grant permission for this resource"));
484        foreach (Guid id in grantedUserIds)
485          dao.AddResourcePermission(new ResourcePermission { ResourceId = resourceId, GrantedByUserId = userManager.CurrentUserId, GrantedUserId = id });
486      });
487    }
488
489    public void RevokeResourcePermissions(Guid resourceId, Guid[] grantedUserIds) {
490      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
491      trans.UseTransaction(() => {
492        Resource resource = dao.GetResource(resourceId);
493        if (resource == null) throw new FaultException<FaultReason>(new FaultReason("Could not find resource with id " + resourceId));
494        if (resource.OwnerUserId != userManager.CurrentUserId && !authen.IsInRole(HiveRoles.Administrator)) throw new FaultException<FaultReason>(new FaultReason("Not allowed to revoke permission for this resource"));
495        foreach (Guid id in grantedUserIds)
496          dao.DeleteResourcePermission(resourceId, id);
497      });
498    }
499
500    public IEnumerable<ResourcePermission> GetResourcePermissions(Guid resourceId) {
501      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
502      return trans.UseTransaction(() => {
503        Resource resource = dao.GetResource(resourceId);
504        if (resource == null) throw new FaultException<FaultReason>(new FaultReason("Could not find resource with id " + resourceId));
505        return dao.GetResourcePermissions(x => x.ResourceId == resourceId);
506      });
507    }
508    #endregion
509
510    #region Resource Methods
511    public IEnumerable<Resource> GetChildResources(Guid resourceId) {
512      return dao.GetChildResources(resourceId);
513    }
514    #endregion
515
516    #region Slave Methods
517    public int GetNewHeartbeatInterval(Guid slaveId) {
518      authen.AuthenticateForAnyRole(HiveRoles.Slave);
519      Slave s = dao.GetSlave(slaveId);
520      if (s != null) {
521        return s.HbInterval;
522      } else {
523        return -1;
524      }
525    }
526
527    public Guid AddSlave(Slave slave) {
528      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
529      return trans.UseTransaction(() => dao.AddSlave(slave));
530    }
531
532    public Guid AddSlaveGroup(SlaveGroup slaveGroup) {
533      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
534      return trans.UseTransaction(() => dao.AddSlaveGroup(slaveGroup));
535    }
536
537    public Slave GetSlave(Guid slaveId) {
538      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
539      return dao.GetSlave(slaveId);
540    }
541
542    public SlaveGroup GetSlaveGroup(Guid slaveGroupId) {
543      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
544      return dao.GetSlaveGroup(slaveGroupId);
545    }
546
547    public IEnumerable<Slave> GetSlaves() {
548      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
549      return dao.GetSlaves(x => true).Where(x => x.OwnerUserId == null
550                                         || x.OwnerUserId == userManager.CurrentUserId
551                                         || userManager.VerifyUser(userManager.CurrentUserId, GetResourcePermissions(x.Id).Select(y => y.GrantedUserId).ToList())
552                                         || authen.IsInRole(HiveRoles.Administrator)).ToArray();
553    }
554
555    public IEnumerable<SlaveGroup> GetSlaveGroups() {
556      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
557      return dao.GetSlaveGroups(x => true).Where(x => x.OwnerUserId == null
558                                              || x.OwnerUserId == userManager.CurrentUserId
559                                              || userManager.VerifyUser(userManager.CurrentUserId, GetResourcePermissions(x.Id).Select(y => y.GrantedUserId).ToList())
560                                              || authen.IsInRole(HiveRoles.Administrator)).ToArray();
561    }
562
563    public void UpdateSlave(Slave slave) {
564      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
565      trans.UseTransaction(() => {
566        dao.UpdateSlave(slave);
567      });
568    }
569
570    public void UpdateSlaveGroup(SlaveGroup slaveGroup) {
571      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
572      trans.UseTransaction(() => {
573        dao.UpdateSlaveGroup(slaveGroup);
574      });
575    }
576
577    public void DeleteSlave(Guid slaveId) {
578      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
579      author.AuthorizeForResourceAdministration(slaveId);
580      trans.UseTransaction(() => {
581        dao.DeleteSlave(slaveId);
582      });
583    }
584
585    public void DeleteSlaveGroup(Guid slaveGroupId) {
586      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
587      author.AuthorizeForResourceAdministration(slaveGroupId);
588      trans.UseTransaction(() => {
589        dao.DeleteSlaveGroup(slaveGroupId);
590      });
591    }
592
593    public void AddResourceToGroup(Guid slaveGroupId, Guid resourceId) {
594      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
595      trans.UseTransaction(() => {
596        var resource = dao.GetResource(resourceId);
597        resource.ParentResourceId = slaveGroupId;
598        dao.UpdateResource(resource);
599      });
600    }
601
602    public void RemoveResourceFromGroup(Guid slaveGroupId, Guid resourceId) {
603      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
604      trans.UseTransaction(() => {
605        var resource = dao.GetResource(resourceId);
606        resource.ParentResourceId = null;
607        dao.UpdateResource(resource);
608      });
609    }
610
611    public Guid GetResourceId(string resourceName) {
612      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
613      return trans.UseTransaction(() => {
614        var resource = dao.GetResources(x => x.Name == resourceName).FirstOrDefault();
615        if (resource != null) {
616          return resource.Id;
617        } else {
618          return Guid.Empty;
619        }
620      });
621    }
622
623    public void TriggerEventManager(bool force) {
624      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Slave);
625      // use a serializable transaction here to ensure not two threads execute this simultaniously (mutex-lock would not work since IIS may use multiple AppDomains)
626      bool cleanup = false;
627      trans.UseTransaction(() => {
628        DateTime lastCleanup = dao.GetLastCleanup();
629        if (force || DateTime.Now - lastCleanup > HeuristicLab.Services.Hive.Properties.Settings.Default.CleanupInterval) {
630          dao.SetLastCleanup(DateTime.Now);
631          cleanup = true;
632        }
633      }, true);
634
635      if (cleanup) {
636        eventManager.Cleanup();
637      }
638    }
639    #endregion
640
641    #region Downtime Methods
642    public Guid AddDowntime(Downtime downtime) {
643      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
644      author.AuthorizeForResourceAdministration(downtime.ResourceId);
645      return trans.UseTransaction(() => dao.AddDowntime(downtime));
646    }
647
648    public void DeleteDowntime(Guid downtimeId) {
649      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
650      // TODO: pass resource id
651      // author.AuthorizeForResource(resourceId);
652      trans.UseTransaction(() => {
653        dao.DeleteDowntime(downtimeId);
654      });
655    }
656
657    public void UpdateDowntime(Downtime downtime) {
658      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
659      author.AuthorizeForResourceAdministration(downtime.ResourceId);
660      trans.UseTransaction(() => {
661        dao.UpdateDowntime(downtime);
662      });
663    }
664
665    public IEnumerable<Downtime> GetDowntimesForResource(Guid resourceId) {
666      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
667      return trans.UseTransaction(() => dao.GetDowntimes(x => x.ResourceId == resourceId));
668    }
669    #endregion
670
671    #region User Methods
672    public string GetUsernameByUserId(Guid userId) {
673      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
674      var user = ServiceLocator.Instance.UserManager.GetUserById(userId);
675      if (user != null)
676        return user.UserName;
677      else
678        return null;
679    }
680
681    public Guid GetUserIdByUsername(string username) {
682      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
683      var user = ServiceLocator.Instance.UserManager.GetUserByName(username);
684      return user != null ? (Guid)user.ProviderUserKey : Guid.Empty;
685    }
686    #endregion
687
688    #region UserPriority Methods
689    public IEnumerable<UserPriority> GetUserPriorities() {
690      return trans.UseTransaction(() => dao.GetUserPriorities(x => true));
691    }
692    #endregion
693
694    #region Helper Methods
695    private IEnumerable<Task> GetChildTasks(Guid? parentTaskId, bool recursive, bool includeParent) {
696      var tasks = new List<Task>(dao.GetTasks(x => parentTaskId == null ? !x.ParentTaskId.HasValue : x.ParentTaskId.Value == parentTaskId));
697
698      if (recursive) {
699        var childs = new List<Task>();
700        foreach (var task in tasks) {
701          childs.AddRange(GetChildTasks(task.Id, recursive, false));
702        }
703        tasks.AddRange(childs);
704      }
705
706      if (includeParent) tasks.Add(GetTask(parentTaskId.Value));
707      return tasks;
708    }
709    #endregion
710
711    #region Statistics Methods
712    public IEnumerable<Statistics> GetStatistics() {
713      return dao.GetStatistics(x => true);
714    }
715    public IEnumerable<Statistics> GetStatisticsForTimePeriod(DateTime from, DateTime to) {
716      return dao.GetStatistics(x => x.Timestamp >= from && x.Timestamp <= to);
717    }
718    #endregion
719  }
720}
Note: See TracBrowser for help on using the repository browser.