Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
09/12/11 18:04:25 (13 years ago)
Author:
ascheibe
Message:

#1233

  • fixed a bug in the Slave UI
  • finished renaming Webservice and Dao methods to be consistent with Job/Task naming
  • some cosmetic changes and project dependencies cleanups
Location:
branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Convert.cs

    r6725 r6743  
    2727using DT = HeuristicLab.Services.Hive.DataTransfer;
    2828
    29 
    3029namespace HeuristicLab.Services.Hive.DataTransfer {
    3130  public static class Convert {
    32     #region Job
     31    #region Task
    3332    public static DT.Task ToDto(DB.Task source) {
    3433      if (source == null) return null;
    … …  
    4746        FinishWhenChildJobsFinished = source.FinishWhenChildJobsFinished,
    4847        Command = Convert.ToDto(source.Command),
    49         LastJobDataUpdate = (source.JobData == null ? DateTime.MinValue : source.JobData.LastUpdate),
     48        LastTaskDataUpdate = (source.JobData == null ? DateTime.MinValue : source.JobData.LastUpdate),
    5049        JobId = source.JobId,
    5150        IsPrivileged = source.IsPrivileged
    … …  
    150149    #endregion
    151150
    152     #region HiveExperimentPermission
     151    #region JobPermission
    153152    public static DT.JobPermission ToDto(DB.JobPermission source) {
    154153      if (source == null) return null;
    … …  
    363362    }
    364363    #endregion
    365 
    366364
    367365    #region TaskData
    … …  
    433431    #endregion
    434432
    435 
    436433    #region Command
    437434    public static DT.Command? ToDto(DB.Command? source) {
    … …  
    462459        return null;
    463460    }
    464 
    465461    #endregion
    466462

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/Heartbeat.cs

    r6717 r6743  
    3535    public int FreeCores { get; set; }
    3636    [DataMember]
    37     public Dictionary<Guid, TimeSpan> JobProgress { get; set; } // TODO: define Type
     37    public Dictionary<Guid, TimeSpan> JobProgress { get; set; }
    3838    [DataMember]
    39     public bool AssignJob { get; set; } // if false, the server will not assign a new job
     39    public bool AssignJob { get; set; } // if false, the server will not assign a new task
    4040    [DataMember]
    4141    public float CpuUtilization { get; set; }

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/LightweightTask.cs

    r6721 r6743  
    4040    public Command? Command { get; set; }
    4141    [DataMember]
    42     public DateTime LastJobDataUpdate { get; set; }
     42    public DateTime LastTaskDataUpdate { get; set; }
    4343
    4444    public StateLog CurrentStateLog { get { return StateLog.LastOrDefault(); } }
    … …  
    5050    }
    5151
    52     public LightweightTask(Task job) {
    53       this.Id = job.Id;
    54       this.ExecutionTime = job.ExecutionTime;
    55       this.ParentTaskId = job.ParentTaskId;
    56       this.StateLog = new List<StateLog>(job.StateLog);
    57       this.State = job.State;
    58       this.Command = job.Command;
    59       this.LastJobDataUpdate = job.LastJobDataUpdate;
     52    public LightweightTask(Task task) {
     53      this.Id = task.Id;
     54      this.ExecutionTime = task.ExecutionTime;
     55      this.ParentTaskId = task.ParentTaskId;
     56      this.StateLog = new List<StateLog>(task.StateLog);
     57      this.State = task.State;
     58      this.Command = task.Command;
     59      this.LastTaskDataUpdate = task.LastTaskDataUpdate;
    6060    }
    6161  }

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/Permission.cs

    r6717 r6743  
    2828
    2929    /// <summary>
    30     /// User can only download and view experiments
     30    /// User can only download and view jobs
    3131    /// </summary>
    3232    Read,
    3333
    3434    /// <summary>
    35     /// User can pause, stop, restart, delete experiment. can also grant other
     35    /// User can pause, stop, restart, delete job. can also grant other
    3636    /// </summary>
    3737    Full

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/DataTransfer/TaskState.cs

    r6721 r6743  
    2626  public enum TaskState {
    2727    /// <summary>
    28     /// A task is offline as long as he is not yet submitted to the hive
     28    /// A task is offline as long as job is not yet submitted to the hive
    2929    /// </summary>
    3030    Offline,
    … …  
    6868  public static class TaskStateExtensions {
    6969    /// <summary>
    70     /// This job is not yet done
     70    /// This task is not yet done
    7171    /// </summary>
    7272    public static bool IsActive(this TaskState taskState) {
    … …  
    7575
    7676    /// <summary>
    77     /// This job is Waiting
     77    /// This task is Waiting
    7878    /// </summary>
    7979    public static bool IsWaiting(this TaskState taskState) {
    … …  
    8282
    8383    /// <summary>
    84     /// This job is Finished || Failed || Aborted
     84    /// This task is Finished || Failed || Aborted
    8585    /// </summary>
    8686    public static bool IsDone(this TaskState taskState) {

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HeuristicLab.Services.Hive-3.3.csproj

    r6723 r6743  
    7474    <Reference Include="HeuristicLab.Common-3.3">
    7575      <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Common-3.3.dll</HintPath>
    76     </Reference>
    77     <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    78       <SpecificVersion>False</SpecificVersion>
    79       <HintPath>C:\Program Files\HeuristicLab 3.3\HeuristicLab.Common.Resources-3.3.dll</HintPath>
    8076    </Reference>
    8177    <Reference Include="HeuristicLab.Core-3.3">

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HeuristicLabServicesHivePlugin.cs.frame

    r6717 r6743  
    2929  [Plugin("HeuristicLab.Services.Hive", "3.3.5.$WCREV$")]
    3030  [PluginFile("HeuristicLab.Services.Hive-3.3.dll", PluginFileType.Assembly)]
    31   [PluginDependency("HeuristicLab.Common", "3.3")]
    32   [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
     31  [PluginDependency("HeuristicLab.Common", "3.3")] 
    3332  [PluginDependency("HeuristicLab.Core", "3.3")]
    3433  [PluginDependency("HeuristicLab.Persistence", "3.3")] 

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HiveDao.cs

    r6725 r6743  
    3636    public HiveDao() { }
    3737
    38     #region Job Methods
    39     public DT.Task GetJob(Guid id) {
     38    #region Task Methods
     39    public DT.Task GetTask(Guid id) {
    4040      using (var db = CreateContext()) {
    4141        return DT.Convert.ToDto(db.Tasks.SingleOrDefault(x => x.TaskId == id));
    … …  
    4343    }
    4444
    45     public IEnumerable<DT.Task> GetJobs(Expression<Func<Task, bool>> predicate) {
     45    public IEnumerable<DT.Task> GetTasks(Expression<Func<Task, bool>> predicate) {
    4646      using (var db = CreateContext()) {
    4747        return db.Tasks.Where(predicate).Select(x => DT.Convert.ToDto(x)).ToArray();
    … …  
    4949    }
    5050
    51     public Guid AddJob(DT.Task dto) {
     51    public Guid AddTask(DT.Task dto) {
    5252      using (var db = CreateContext()) {
    5353        var entity = DT.Convert.ToEntity(dto);
    … …  
    6262    }
    6363
    64     public void UpdateJob(DT.Task dto) {
     64    public void UpdateTask(DT.Task dto) {
    6565      using (var db = CreateContext()) {
    6666        var entity = db.Tasks.FirstOrDefault(x => x.TaskId == dto.Id);
    … …  
    7676    }
    7777
    78     public void DeleteJob(Guid id) {
     78    public void DeleteTask(Guid id) {
    7979      using (var db = CreateContext()) {
    8080        var entity = db.Tasks.FirstOrDefault(x => x.TaskId == id);
    8181        if (entity != null) db.Tasks.DeleteOnSubmit(entity);
    82         db.SubmitChanges(); // JobData and child jobs are deleted by db-trigger
     82        db.SubmitChanges(); // taskData and child tasks are deleted by db-trigger
    8383      }
    8484    }
    8585
    8686    /// <summary>
    87     /// returns all parent jobs which are waiting for their child jobs to finish
     87    /// returns all parent tasks which are waiting for their child tasks to finish
    8888    /// </summary>
    89     /// <param name="resourceIds">list of resourceids which for which the jobs should be valid</param>
    90     /// <param name="count">maximum number of jobs to return</param>
    91     /// <param name="finished">if true, all parent jobs which have FinishWhenChildJobsFinished=true are returned, otherwise only FinishWhenChildJobsFinished=false are returned</param>
     89    /// <param name="resourceIds">list of resourceids which for which the task should be valid</param>
     90    /// <param name="count">maximum number of task to return</param>
     91    /// <param name="finished">if true, all parent task which have FinishWhenChildJobsFinished=true are returned, otherwise only FinishWhenChildJobsFinished=false are returned</param>
    9292    /// <returns></returns>
    93     public IEnumerable<DT.Task> GetParentJobs(IEnumerable<Guid> resourceIds, int count, bool finished) {
     93    public IEnumerable<DT.Task> GetParentTasks(IEnumerable<Guid> resourceIds, int count, bool finished) {
    9494      using (var db = CreateContext()) {
    9595        var query = from ar in db.AssignedResources
    … …  
    103103                               || child.State == TaskState.Aborted
    104104                               || child.State == TaskState.Failed).All(x => x)
    105                        && (from child in db.Tasks // avoid returning WaitForChildJobs jobs where no child-jobs exist (yet)
     105                       && (from child in db.Tasks // avoid returning WaitForChildTasks task where no child-task exist (yet)
    106106                           where child.ParentTaskId == ar.Task.TaskId
    107107                           select child).Count() > 0
    … …  
    112112    }
    113113
    114     public IEnumerable<DT.Task> GetWaitingJobs(DT.Slave slave, int count) {
     114    public IEnumerable<DT.Task> GetWaitingTasks(DT.Slave slave, int count) {
    115115      using (var db = CreateContext()) {
    116116        var resourceIds = GetParentResources(slave.Id).Select(r => r.Id);
    117         var waitingParentJobs = GetParentJobs(resourceIds, count, false);
     117        var waitingParentJobs = GetParentTasks(resourceIds, count, false);
    118118        if (count > 0 && waitingParentJobs.Count() >= count) return waitingParentJobs.Take(count).ToArray();
    119119
    … …  
    124124                       && ar.Task.CoresNeeded <= slave.FreeCores
    125125                       && ar.Task.MemoryNeeded <= slave.FreeMemory
    126                     orderby ar.Task.Priority descending, db.Random() // take random job to avoid the race condition that occurs when this method is called concurrently (the same job would be returned)
     126                    orderby ar.Task.Priority descending, db.Random() // take random task to avoid the race condition that occurs when this method is called concurrently (the same task would be returned)
    127127                    select DT.Convert.ToDto(ar.Task);
    128         var waitingJobs = (count == 0 ? query : query.Take(count)).ToArray();
    129         return waitingJobs.Union(waitingParentJobs).OrderByDescending(x => x.Priority);
    130       }
    131     }
    132 
    133     public DT.Task UpdateJobState(Guid jobId, TaskState jobState, Guid? slaveId, Guid? userId, string exception) {
    134       using (var db = CreateContext()) {
    135         var job = db.Tasks.SingleOrDefault(x => x.TaskId == jobId);
    136         job.State = jobState;
     128        var waitingTasks = (count == 0 ? query : query.Take(count)).ToArray();
     129        return waitingTasks.Union(waitingParentJobs).OrderByDescending(x => x.Priority);
     130      }
     131    }
     132
     133    public DT.Task UpdateTaskState(Guid taskId, TaskState taskState, Guid? slaveId, Guid? userId, string exception) {
     134      using (var db = CreateContext()) {
     135        var job = db.Tasks.SingleOrDefault(x => x.TaskId == taskId);
     136        job.State = taskState;
    137137        db.StateLogs.InsertOnSubmit(new StateLog {
    138           TaskId = jobId,
    139           State = jobState,
     138          TaskId = taskId,
     139          State = taskState,
    140140          SlaveId = slaveId,
    141141          UserId = userId,
    … …  
    144144        });
    145145        db.SubmitChanges();
    146         job = db.Tasks.SingleOrDefault(x => x.TaskId == jobId);
     146        job = db.Tasks.SingleOrDefault(x => x.TaskId == taskId);
    147147        return DT.Convert.ToDto(job);
    148148      }
    … …  
    151151
    152152    #region TaskData Methods
    153     public DT.TaskData GetJobData(Guid id) {
     153    public DT.TaskData GetTaskData(Guid id) {
    154154      using (var db = CreateContext(true)) {
    155155        return DT.Convert.ToDto(db.TaskDatas.SingleOrDefault(x => x.TaskId == id));
    … …  
    157157    }
    158158
    159     public IEnumerable<DT.TaskData> GetJobDatas(Expression<Func<TaskData, bool>> predicate) {
     159    public IEnumerable<DT.TaskData> GetTaskDatas(Expression<Func<TaskData, bool>> predicate) {
    160160      using (var db = CreateContext(true)) {
    161161        return db.TaskDatas.Where(predicate).Select(x => DT.Convert.ToDto(x)).ToArray();
    … …  
    163163    }
    164164
    165     public Guid AddJobData(DT.TaskData dto) {
     165    public Guid AddTaskData(DT.TaskData dto) {
    166166      using (var db = CreateContext(true)) {
    167167        var entity = DT.Convert.ToEntity(dto);
    … …  
    172172    }
    173173
    174     public void UpdateJobData(DT.TaskData dto) {
     174    public void UpdateTaskData(DT.TaskData dto) {
    175175      using (var db = CreateContext(true)) {
    176176        var entity = db.TaskDatas.FirstOrDefault(x => x.TaskId == dto.TaskId);
    … …  
    181181    }
    182182
    183     public void DeleteJobData(Guid id) {
     183    public void DeleteTaskData(Guid id) {
    184184      using (var db = CreateContext()) {
    185185        var entity = db.TaskDatas.FirstOrDefault(x => x.TaskId == id); // check if all the byte[] is loaded into memory here. otherwise work around to delete without loading it
    … …  
    231231
    232232    #region Job Methods
    233     public DT.Job GetHiveExperiment(Guid id) {
     233    public DT.Job GetJob(Guid id) {
    234234      using (var db = CreateContext()) {
    235235        return AddStatsToExperiment(db, DT.Convert.ToDto(db.Jobs.SingleOrDefault(x => x.JobId == id)));
    … …  
    248248    }
    249249
    250     public IEnumerable<DT.Job> GetHiveExperiments(Expression<Func<Job, bool>> predicate) {
     250    public IEnumerable<DT.Job> GetJobs(Expression<Func<Job, bool>> predicate) {
    251251      using (var db = CreateContext()) {
    252252        return db.Jobs.Where(predicate).Select(x => AddStatsToExperiment(db, DT.Convert.ToDto(x))).ToArray();
    … …  
    254254    }
    255255
    256     public Guid AddHiveExperiment(DT.Job dto) {
     256    public Guid AddJob(DT.Job dto) {
    257257      using (var db = CreateContext()) {
    258258        var entity = DT.Convert.ToEntity(dto);
    … …  
    263263    }
    264264
    265     public void UpdateHiveExperiment(DT.Job dto) {
     265    public void UpdateJob(DT.Job dto) {
    266266      using (var db = CreateContext()) {
    267267        var entity = db.Jobs.FirstOrDefault(x => x.JobId == dto.Id);
    … …  
    272272    }
    273273
    274     public void DeleteHiveExperiment(Guid id) {
     274    public void DeleteJob(Guid id) {
    275275      using (var db = CreateContext()) {
    276276        var entity = db.Jobs.FirstOrDefault(x => x.JobId == id);
    … …  
    282282
    283283    #region JobPermission Methods
    284     public DT.JobPermission GetHiveExperimentPermission(Guid hiveExperimentId, Guid grantedUserId) {
    285       using (var db = CreateContext()) {
    286         return DT.Convert.ToDto(db.JobPermissions.SingleOrDefault(x => x.JobId == hiveExperimentId && x.GrantedUserId == grantedUserId));
    287       }
    288     }
    289 
    290     public IEnumerable<DT.JobPermission> GetHiveExperimentPermissions(Expression<Func<JobPermission, bool>> predicate) {
     284    public DT.JobPermission GetJobPermission(Guid jobId, Guid grantedUserId) {
     285      using (var db = CreateContext()) {
     286        return DT.Convert.ToDto(db.JobPermissions.SingleOrDefault(x => x.JobId == jobId && x.GrantedUserId == grantedUserId));
     287      }
     288    }
     289
     290    public IEnumerable<DT.JobPermission> GetJobPermissions(Expression<Func<JobPermission, bool>> predicate) {
    291291      using (var db = CreateContext()) {
    292292        return db.JobPermissions.Where(predicate).Select(x => DT.Convert.ToDto(x)).ToArray();
    … …  
    294294    }
    295295
    296     public void AddHiveExperimentPermission(DT.JobPermission dto) {
     296    public void AddJobPermission(DT.JobPermission dto) {
    297297      using (var db = CreateContext()) {
    298298        var entity = DT.Convert.ToEntity(dto);
    … …  
    302302    }
    303303
    304     public void UpdateHiveExperimentPermission(DT.JobPermission dto) {
     304    public void UpdateJobPermission(DT.JobPermission dto) {
    305305      using (var db = CreateContext()) {
    306306        var entity = db.JobPermissions.FirstOrDefault(x => x.JobId == dto.JobId && x.GrantedUserId == dto.GrantedUserId);
    … …  
    311311    }
    312312
    313     public void DeleteHiveExperimentPermission(Guid hiveExperimentId, Guid grantedUserId) {
    314       using (var db = CreateContext()) {
    315         var entity = db.JobPermissions.FirstOrDefault(x => x.JobId == hiveExperimentId && x.GrantedUserId == grantedUserId);
     313    public void DeleteJobPermission(Guid jobId, Guid grantedUserId) {
     314      using (var db = CreateContext()) {
     315        var entity = db.JobPermissions.FirstOrDefault(x => x.JobId == jobId && x.GrantedUserId == grantedUserId);
    316316        if (entity != null) db.JobPermissions.DeleteOnSubmit(entity);
    317317        db.SubmitChanges();
    … …  
    322322    /// Sets the permissions for a experiment. makes sure that only one permission per user exists.
    323323    /// </summary>
    324     public void SetHiveExperimentPermission(Guid hiveExperimentId, Guid grantedByUserId, Guid grantedUserId, Permission permission) {
    325       using (var db = CreateContext()) {
    326         JobPermission hiveExperimentPermission = db.JobPermissions.SingleOrDefault(x => x.JobId == hiveExperimentId && x.GrantedUserId == grantedUserId);
    327         if (hiveExperimentPermission != null) {
     324    public void SetJobPermission(Guid jobId, Guid grantedByUserId, Guid grantedUserId, Permission permission) {
     325      using (var db = CreateContext()) {
     326        JobPermission jobPermission = db.JobPermissions.SingleOrDefault(x => x.JobId == jobId && x.GrantedUserId == grantedUserId);
     327        if (jobPermission != null) {
    328328          if (permission == Permission.NotAllowed) {
    329329            // not allowed, delete
    330             db.JobPermissions.DeleteOnSubmit(hiveExperimentPermission);
     330            db.JobPermissions.DeleteOnSubmit(jobPermission);
    331331          } else {
    332332            // update
    333             hiveExperimentPermission.Permission = permission;
    334             hiveExperimentPermission.GrantedByUserId = grantedByUserId; // update grantedByUserId, always the last "granter" is stored
     333            jobPermission.Permission = permission;
     334            jobPermission.GrantedByUserId = grantedByUserId; // update grantedByUserId, always the last "granter" is stored
    335335          }
    336336        } else {
    337337          // insert
    338338          if (permission != Permission.NotAllowed) {
    339             hiveExperimentPermission = new JobPermission() { JobId = hiveExperimentId, GrantedByUserId = grantedByUserId, GrantedUserId = grantedUserId, Permission = permission };
    340             db.JobPermissions.InsertOnSubmit(hiveExperimentPermission);
     339            jobPermission = new JobPermission() { JobId = jobId, GrantedByUserId = grantedByUserId, GrantedUserId = grantedUserId, Permission = permission };
     340            db.JobPermissions.InsertOnSubmit(jobPermission);
    341341          }
    342342        }
    … …  
    613613
    614614    #region Authorization Methods
     615    public Permission GetPermissionForTask(Guid taskId, Guid userId) {
     616      using (var db = CreateContext()) {
     617        return GetPermissionForJob(GetJobForTask(taskId), userId);
     618      }
     619    }
     620
    615621    public Permission GetPermissionForJob(Guid jobId, Guid userId) {
    616622      using (var db = CreateContext()) {
    617         return GetPermissionForExperiment(GetExperimentForJob(jobId), userId);
    618       }
    619     }
    620 
    621     public Permission GetPermissionForExperiment(Guid experimentId, Guid userId) {
    622       using (var db = CreateContext()) {
    623         Job hiveExperiment = db.Jobs.SingleOrDefault(x => x.JobId == experimentId);
    624         if (hiveExperiment == null) return Permission.NotAllowed;
    625         if (hiveExperiment.OwnerUserId == userId) return Permission.Full;
    626         JobPermission permission = db.JobPermissions.SingleOrDefault(p => p.JobId == experimentId && p.GrantedUserId == userId);
     623        Job job = db.Jobs.SingleOrDefault(x => x.JobId == jobId);
     624        if (job == null) return Permission.NotAllowed;
     625        if (job.OwnerUserId == userId) return Permission.Full;
     626        JobPermission permission = db.JobPermissions.SingleOrDefault(p => p.JobId == jobId && p.GrantedUserId == userId);
    627627        return permission != null ? permission.Permission : Permission.NotAllowed;
    628628      }
    629629    }
    630630
    631     public Guid GetExperimentForJob(Guid jobId) {
    632       using (var db = CreateContext()) {
    633         return db.Tasks.Single(j => j.TaskId == jobId).JobId;
     631    public Guid GetJobForTask(Guid taskId) {
     632      using (var db = CreateContext()) {
     633        return db.Tasks.Single(j => j.TaskId == taskId).JobId;
    634634      }
    635635    }
    … …  
    765765        }
    766766
    767         // execution times only of finished jobs - necessary to compute efficieny
     767        // execution times only of finished task - necessary to compute efficieny
    768768        var executionTimesFinishedJobs = from job in db.Tasks
    769769                                         where job.State == TaskState.Finished
    … …  
    778778        }
    779779
    780         // start to end times only of finished jobs - necessary to compute efficiency
     780        // start to end times only of finished task - necessary to compute efficiency
    781781        var startToEndTimesFinishedJobs = from job in db.Tasks
    782782                                          where job.State == TaskState.Finished
    … …  
    817817
    818818    #region Helpers
    819     private void CollectChildJobs(HiveDataContext db, Guid parentJobId, List<Task> collection) {
    820       var jobs = db.Tasks.Where(j => j.ParentTaskId == parentJobId);
    821       foreach (var job in jobs) {
    822         collection.Add(job);
    823         if (job.IsParentTask)
    824           CollectChildJobs(db, job.TaskId, collection);
     819    private void CollectChildTasks(HiveDataContext db, Guid parentTaskId, List<Task> collection) {
     820      var tasks = db.Tasks.Where(j => j.ParentTaskId == parentTaskId);
     821      foreach (var task in tasks) {
     822        collection.Add(task);
     823        if (task.IsParentTask)
     824          CollectChildTasks(db, task.TaskId, collection);
    825825      }
    826826    }

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/HiveService.cs

    r6725 r6743  
    6161
    6262    #region Job Methods
    63     public Guid AddJob(Task job, TaskData jobData, IEnumerable<Guid> resourceIds) {
    64       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    65       return trans.UseTransaction(() => {
    66         job.Id = dao.AddJob(job);
    67         jobData.TaskId = job.Id;
    68         jobData.LastUpdate = DateTime.Now;
     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;
    6969        foreach (Guid slaveGroupId in resourceIds) {
    70           dao.AssignJobToResource(job.Id, slaveGroupId);
    71         }
    72         dao.AddJobData(jobData);
    73         dao.UpdateJobState(job.Id, DA.TaskState.Waiting, null, userManager.CurrentUserId, null);
    74         return jobData.TaskId;
     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;
    7575      }, false, true);
    7676    }
    7777
    78     public Guid AddChildJob(Guid parentJobId, Task job, TaskData jobData) {
    79       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    80       return trans.UseTransaction(() => {
    81         job.ParentTaskId = parentJobId;
    82         return AddJob(job, jobData, dao.GetAssignedResources(parentJobId).Select(x => x.Id));
     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));
    8383      }, false, true);
    8484    }
    8585
    86     public Task GetJob(Guid jobId) {
    87       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     86    public Task GetTask(Guid taskId) {
     87      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     88      author.AuthorizeForTask(taskId, Permission.Read);
     89      return dao.GetTask(taskId);
     90    }
     91
     92    public IEnumerable<Task> GetTasks() {
     93      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     94      var tasks = dao.GetTasks(x => true);
     95      foreach (var task in tasks)
     96        author.AuthorizeForTask(task.Id, Permission.Read);
     97      return tasks;
     98    }
     99
     100    public IEnumerable<LightweightTask> GetLightweightTasks(IEnumerable<Guid> taskIds) {
     101      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     102      var tasks = dao.GetTasks(x => taskIds.Contains(x.TaskId)).Select(x => new LightweightTask(x)).ToArray();
     103      foreach (var task in tasks)
     104        author.AuthorizeForTask(task.Id, Permission.Read);
     105      return tasks;
     106    }
     107
     108    public IEnumerable<LightweightTask> GetLightweightChildTasks(Guid? parentTaskId, bool recursive, bool includeParent) {
     109      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     110      var tasks = GetChildTasks(parentTaskId, recursive, includeParent).Select(x => new LightweightTask(x)).ToArray();
     111      foreach (var task in tasks)
     112        author.AuthorizeForTask(task.Id, Permission.Read);
     113      return tasks;
     114    }
     115
     116    public IEnumerable<LightweightTask> GetLightweightJobTasks(Guid jobId) {
     117      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    88118      author.AuthorizeForJob(jobId, Permission.Read);
    89       return dao.GetJob(jobId);
    90     }
    91 
    92     public IEnumerable<Task> GetJobs() {
    93       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    94       var jobs = dao.GetJobs(x => true);
    95       foreach (var job in jobs)
    96         author.AuthorizeForJob(job.Id, Permission.Read);
    97       return jobs;
    98     }
    99 
    100     public IEnumerable<LightweightTask> GetLightweightJobs(IEnumerable<Guid> jobIds) {
    101       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    102       var jobs = dao.GetJobs(x => jobIds.Contains(x.TaskId)).Select(x => new LightweightTask(x)).ToArray();
    103       foreach (var job in jobs)
    104         author.AuthorizeForJob(job.Id, Permission.Read);
    105       return jobs;
    106     }
    107 
    108     public IEnumerable<LightweightTask> GetLightweightChildJobs(Guid? parentJobId, bool recursive, bool includeParent) {
    109       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    110       var jobs = GetChildJobs(parentJobId, recursive, includeParent).Select(x => new LightweightTask(x)).ToArray();
    111       foreach (var job in jobs)
    112         author.AuthorizeForJob(job.Id, Permission.Read);
    113       return jobs;
    114     }
    115 
    116     public IEnumerable<LightweightTask> GetLightweightExperimentJobs(Guid experimentId) {
    117       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    118       author.AuthorizeForExperiment(experimentId, Permission.Read);
    119       return dao.GetJobs(x => x.JobId == experimentId).Select(x => new LightweightTask(x)).ToArray();
    120     }
    121 
    122     public TaskData GetJobData(Guid jobId) {
    123       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
    124       author.AuthorizeForJob(jobId, Permission.Read);
    125       return dao.GetJobData(jobId);
    126     }
    127 
    128     public void UpdateJob(Task job) {
    129       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
    130       author.AuthorizeForJob(job.Id, Permission.Full);
    131       trans.UseTransaction(() => {
    132         dao.UpdateJob(job);
    133       });
    134     }
    135 
    136     public void UpdateJobData(Task job, TaskData jobData) {
    137       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
    138       author.AuthorizeForJob(job.Id, Permission.Full);
    139       author.AuthorizeForJob(jobData.TaskId, Permission.Full);
     119      return dao.GetTasks(x => x.JobId == jobId).Select(x => new LightweightTask(x)).ToArray();
     120    }
     121
     122    public TaskData GetTaskData(Guid taskId) {
     123      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     124      author.AuthorizeForTask(taskId, Permission.Read);
     125      return dao.GetTaskData(taskId);
     126    }
     127
     128    public void UpdateTask(Task taskDto) {
     129      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     130      author.AuthorizeForTask(taskDto.Id, Permission.Full);
     131      trans.UseTransaction(() => {
     132        dao.UpdateTask(taskDto);
     133      });
     134    }
     135
     136    public void UpdateTaskData(Task task, TaskData taskData) {
     137      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     138      author.AuthorizeForTask(task.Id, Permission.Full);
     139      author.AuthorizeForTask(taskData.TaskId, Permission.Full);
    140140      //trans.UseTransaction(() => { // cneumuel: try without transaction
    141       jobData.LastUpdate = DateTime.Now;
    142       dao.UpdateJob(job);
    143       dao.UpdateJobData(jobData);
     141      taskData.LastUpdate = DateTime.Now;
     142      dao.UpdateTask(task);
     143      dao.UpdateTaskData(taskData);
    144144      //}, false, true);
    145145    }
    146146
    147     public void DeleteJob(Guid jobId) {
    148       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
    149       author.AuthorizeForJob(jobId, Permission.Full);
    150       trans.UseTransaction(() => {
    151         dao.DeleteJob(jobId);
    152       });
    153     }
    154 
    155     public void DeleteChildJobs(Guid parentJobId) {
    156       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
    157       author.AuthorizeForJob(parentJobId, Permission.Full);
    158       trans.UseTransaction(() => {
    159         var jobs = GetChildJobs(parentJobId, true, false);
    160         foreach (var job in jobs) {
    161           dao.DeleteJob(job.Id);
    162           dao.DeleteJobData(job.Id);
     147    public void DeleteTask(Guid taskId) {
     148      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     149      author.AuthorizeForTask(taskId, Permission.Full);
     150      trans.UseTransaction(() => {
     151        dao.DeleteTask(taskId);
     152      });
     153    }
     154
     155    public void DeleteChildTasks(Guid parentTaskId) {
     156      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     157      author.AuthorizeForTask(parentTaskId, Permission.Full);
     158      trans.UseTransaction(() => {
     159        var tasks = GetChildTasks(parentTaskId, true, false);
     160        foreach (var task in tasks) {
     161          dao.DeleteTask(task.Id);
     162          dao.DeleteTaskData(task.Id);
    163163        };
    164164      });
    165165    }
    166166
    167     public Task UpdateJobState(Guid jobId, TaskState jobState, Guid? slaveId, Guid? userId, string exception) {
    168       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
    169       author.AuthorizeForJob(jobId, Permission.Full);
    170       return trans.UseTransaction(() => {
    171         Task job = dao.UpdateJobState(jobId, DataTransfer.Convert.ToEntity(jobState), slaveId, userId, exception);
    172 
    173         if (job.Command.HasValue && job.Command.Value == Command.Pause && job.State == TaskState.Paused) {
    174           job.Command = null;
    175         } else if (job.Command.HasValue && job.Command.Value == Command.Abort && job.State == TaskState.Aborted) {
    176           job.Command = null;
    177         } else if (job.Command.HasValue && job.Command.Value == Command.Stop && job.State == TaskState.Aborted) {
    178           job.Command = null;
    179         } else if (jobState == TaskState.Paused && !job.Command.HasValue) {
    180           // slave paused and uploaded the job (no user-command) -> set waiting.
    181           job = dao.UpdateJobState(jobId, DataTransfer.Convert.ToEntity(TaskState.Waiting), slaveId, userId, exception);
    182         }
    183 
    184         dao.UpdateJob(job);
    185         return job;
    186       });
    187     }
    188 
    189     public IEnumerable<Task> GetJobsByResourceId(Guid resourceId) {
    190       authen.AuthenticateForAnyRole(HiveRoles.Administrator);
    191       var jobs = trans.UseTransaction(() => dao.GetJobsByResourceId(resourceId));
    192       foreach (var job in jobs)
    193         author.AuthorizeForJob(job.Id, Permission.Read);
    194       return jobs;
     167    public Task UpdateTaskState(Guid taskId, TaskState taskState, Guid? slaveId, Guid? userId, string exception) {
     168      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     169      author.AuthorizeForTask(taskId, Permission.Full);
     170      return trans.UseTransaction(() => {
     171        Task task = dao.UpdateTaskState(taskId, DataTransfer.Convert.ToEntity(taskState), slaveId, userId, exception);
     172
     173        if (task.Command.HasValue && task.Command.Value == Command.Pause && task.State == TaskState.Paused) {
     174          task.Command = null;
     175        } else if (task.Command.HasValue && task.Command.Value == Command.Abort && task.State == TaskState.Aborted) {
     176          task.Command = null;
     177        } else if (task.Command.HasValue && task.Command.Value == Command.Stop && task.State == TaskState.Aborted) {
     178          task.Command = null;
     179        } else if (taskState == TaskState.Paused && !task.Command.HasValue) {
     180          // slave paused and uploaded the task (no user-command) -> set waiting.
     181          task = dao.UpdateTaskState(taskId, DataTransfer.Convert.ToEntity(TaskState.Waiting), slaveId, userId, exception);
     182        }
     183
     184        dao.UpdateTask(task);
     185        return task;
     186      });
     187    }
     188
     189    public IEnumerable<Task> GetTasksByResourceId(Guid resourceId) {
     190      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
     191      var tasks = trans.UseTransaction(() => dao.GetJobsByResourceId(resourceId));
     192      foreach (var task in tasks)
     193        author.AuthorizeForTask(task.Id, Permission.Read);
     194      return tasks;
    195195    }
    196196    #endregion
    197197
    198198    #region Task Control Methods
    199     public void StopJob(Guid jobId) {
    200       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
    201       author.AuthorizeForJob(jobId, Permission.Full);
    202       trans.UseTransaction(() => {
    203         var job = dao.GetJob(jobId);
    204         if (job.State == TaskState.Calculating || job.State == TaskState.Transferring) {
    205           job.Command = Command.Stop;
    206           dao.UpdateJob(job);
     199    public void StopTask(Guid taskId) {
     200      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     201      author.AuthorizeForTask(taskId, Permission.Full);
     202      trans.UseTransaction(() => {
     203        var task = dao.GetTask(taskId);
     204        if (task.State == TaskState.Calculating || task.State == TaskState.Transferring) {
     205          task.Command = Command.Stop;
     206          dao.UpdateTask(task);
    207207        } else {
    208           if (job.State != TaskState.Aborted && job.State != TaskState.Finished && job.State != TaskState.Failed) {
    209             job = UpdateJobState(jobId, TaskState.Aborted, null, null, string.Empty);
     208          if (task.State != TaskState.Aborted && task.State != TaskState.Finished && task.State != TaskState.Failed) {
     209            task = UpdateTaskState(taskId, TaskState.Aborted, null, null, string.Empty);
    210210          }
    211211        }
    … …  
    213213    }
    214214
    215     public void PauseJob(Guid jobId) {
    216       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
    217       author.AuthorizeForJob(jobId, Permission.Full);
    218       trans.UseTransaction(() => {
    219         var job = dao.GetJob(jobId);
     215    public void PauseTask(Guid taskId) {
     216      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     217      author.AuthorizeForTask(taskId, Permission.Full);
     218      trans.UseTransaction(() => {
     219        var job = dao.GetTask(taskId);
    220220        if (job.State == TaskState.Calculating || job.State == TaskState.Transferring) {
    221221          job.Command = Command.Pause;
    222           dao.UpdateJob(job);
     222          dao.UpdateTask(job);
    223223        } else {
    224           job = UpdateJobState(jobId, TaskState.Paused, null, null, string.Empty);
    225         }
    226       });
    227     }
    228 
    229     public void RestartJob(Guid jobId) {
    230       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
    231       author.AuthorizeForJob(jobId, Permission.Full);
    232       trans.UseTransaction(() => {
    233         Task job = dao.UpdateJobState(jobId, DA.TaskState.Waiting, null, userManager.CurrentUserId, string.Empty);
    234         job.Command = null;
    235         dao.UpdateJob(job);
     224          job = UpdateTaskState(taskId, TaskState.Paused, null, null, string.Empty);
     225        }
     226      });
     227    }
     228
     229    public void RestartTask(Guid taskId) {
     230      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client, HiveRoles.Slave);
     231      author.AuthorizeForTask(taskId, Permission.Full);
     232      trans.UseTransaction(() => {
     233        Task task = dao.UpdateTaskState(taskId, DA.TaskState.Waiting, null, userManager.CurrentUserId, string.Empty);
     234        task.Command = null;
     235        dao.UpdateTask(task);
    236236      });
    237237    }
    … …  
    239239
    240240    #region Job Methods
    241     public Job GetHiveExperiment(Guid id) {
    242       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    243       author.AuthorizeForExperiment(id, Permission.Read);
    244       var hiveExperiment = dao.GetHiveExperiments(x =>
     241    public Job GetJob(Guid id) {
     242      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     243      author.AuthorizeForJob(id, Permission.Read);
     244      var job = dao.GetJobs(x =>
    245245            x.JobId == id
    246246            && (x.OwnerUserId == userManager.CurrentUserId || x.JobPermissions.Count(hep => hep.Permission != DA.Permission.NotAllowed && hep.GrantedUserId == userManager.CurrentUserId) > 0)
    247247          ).FirstOrDefault();
    248       if (hiveExperiment != null) {
    249         hiveExperiment.Permission = DT.Convert.ToDto(dao.GetPermissionForExperiment(hiveExperiment.Id, userManager.CurrentUserId));
    250         hiveExperiment.OwnerUsername = userManager.GetUserById(hiveExperiment.OwnerUserId).UserName;
     248      if (job != null) {
     249        job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
     250        job.OwnerUsername = userManager.GetUserById(job.OwnerUserId).UserName;
    251251      }
    252       return hiveExperiment;
    253     }
    254 
    255     public IEnumerable<Job> GetHiveExperiments() {
    256       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    257       var hiveExperiments = dao.GetHiveExperiments(x => x.OwnerUserId == userManager.CurrentUserId || x.JobPermissions.Count(hep => hep.Permission != DA.Permission.NotAllowed && hep.GrantedUserId == userManager.CurrentUserId) > 0);
    258       foreach (var he in hiveExperiments) {
    259         author.AuthorizeForExperiment(he.Id, Permission.Read);
    260         he.Permission = DT.Convert.ToDto(dao.GetPermissionForExperiment(he.Id, userManager.CurrentUserId));
    261         he.OwnerUsername = userManager.GetUserById(he.OwnerUserId).UserName;
     252      return job;
     253    }
     254
     255    public IEnumerable<Job> GetJobs() {
     256      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     257      var jobs = dao.GetJobs(x => x.OwnerUserId == userManager.CurrentUserId || x.JobPermissions.Count(hep => hep.Permission != DA.Permission.NotAllowed && hep.GrantedUserId == userManager.CurrentUserId) > 0);
     258      foreach (var job in jobs) {
     259        author.AuthorizeForJob(job.Id, Permission.Read);
     260        job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
     261        job.OwnerUsername = userManager.GetUserById(job.OwnerUserId).UserName;
    262262      }
    263       return hiveExperiments;
    264     }
    265 
    266     public IEnumerable<Job> GetAllHiveExperiments() {
    267       authen.AuthenticateForAnyRole(HiveRoles.Administrator);
    268       var hiveExperiments = dao.GetHiveExperiments(x => true);
    269       foreach (var he in hiveExperiments) { // no authorization here, since this method is admin-only! (admin is allowed to read all jobs)
    270         he.Permission = DT.Convert.ToDto(dao.GetPermissionForExperiment(he.Id, userManager.CurrentUserId));
    271         he.OwnerUsername = userManager.GetUserById(he.OwnerUserId).UserName;
     263      return jobs;
     264    }
     265
     266    public IEnumerable<Job> GetAllJobs() {
     267      authen.AuthenticateForAnyRole(HiveRoles.Administrator);
     268      var jobs = dao.GetJobs(x => true);
     269      foreach (var job in jobs) { // no authorization here, since this method is admin-only! (admin is allowed to read all task)
     270        job.Permission = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
     271        job.OwnerUsername = userManager.GetUserById(job.OwnerUserId).UserName;
    272272      }
    273       return hiveExperiments;
    274     }
    275 
    276     public Guid AddHiveExperiment(Job hiveExperimentDto) {
    277       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    278       return trans.UseTransaction(() => {
    279         hiveExperimentDto.OwnerUserId = userManager.CurrentUserId;
    280         hiveExperimentDto.DateCreated = DateTime.Now;
    281         return dao.AddHiveExperiment(hiveExperimentDto);
    282       });
    283     }
    284 
    285     public void UpdateHiveExperiment(Job hiveExperimentDto) {
    286       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    287       author.AuthorizeForExperiment(hiveExperimentDto.Id, Permission.Full);
    288       trans.UseTransaction(() => {
    289         dao.UpdateHiveExperiment(hiveExperimentDto);
    290       });
    291     }
    292 
    293     public void DeleteHiveExperiment(Guid hiveExperimentId) {
    294       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    295       author.AuthorizeForExperiment(hiveExperimentId, Permission.Full);
    296       trans.UseTransaction(() => {
    297         dao.DeleteHiveExperiment(hiveExperimentId); // child jobs will be deleted by db-trigger
    298       });
    299     }
    300     #endregion
    301 
    302     #region HiveExperimentPermission Methods
    303     public void GrantPermission(Guid hiveExperimentId, Guid grantedUserId, Permission permission) {
    304       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    305       trans.UseTransaction(() => {
    306         Job he = dao.GetHiveExperiment(hiveExperimentId);
    307         if (he == null) throw new FaultException<FaultReason>(new FaultReason("Could not find hiveExperiment with id " + hiveExperimentId));
    308         Permission perm = DT.Convert.ToDto(dao.GetPermissionForExperiment(he.Id, userManager.CurrentUserId));
     273      return jobs;
     274    }
     275
     276    public Guid AddJob(Job jobDto) {
     277      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     278      return trans.UseTransaction(() => {
     279        jobDto.OwnerUserId = userManager.CurrentUserId;
     280        jobDto.DateCreated = DateTime.Now;
     281        return dao.AddJob(jobDto);
     282      });
     283    }
     284
     285    public void UpdateJob(Job jobDto) {
     286      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     287      author.AuthorizeForJob(jobDto.Id, Permission.Full);
     288      trans.UseTransaction(() => {
     289        dao.UpdateJob(jobDto);
     290      });
     291    }
     292
     293    public void DeleteJob(Guid jobId) {
     294      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     295      author.AuthorizeForJob(jobId, Permission.Full);
     296      trans.UseTransaction(() => {
     297        dao.DeleteJob(jobId); // child task will be deleted by db-trigger
     298      });
     299    }
     300    #endregion
     301
     302    #region JobPermission Methods
     303    public void GrantPermission(Guid jobId, Guid grantedUserId, Permission permission) {
     304      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     305      trans.UseTransaction(() => {
     306        Job job = dao.GetJob(jobId);
     307        if (job == null) throw new FaultException<FaultReason>(new FaultReason("Could not find task with id " + jobId));
     308        Permission perm = DT.Convert.ToDto(dao.GetPermissionForJob(job.Id, userManager.CurrentUserId));
    309309        if (perm != Permission.Full) throw new FaultException<FaultReason>(new FaultReason("Not allowed to grant permissions for this experiment"));
    310         dao.SetHiveExperimentPermission(hiveExperimentId, userManager.CurrentUserId, grantedUserId, DT.Convert.ToEntity(permission));
    311       });
    312     }
    313 
    314     public void RevokePermission(Guid hiveExperimentId, Guid grantedUserId) {
    315       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    316       trans.UseTransaction(() => {
    317         Job he = dao.GetHiveExperiment(hiveExperimentId);
    318         if (he == null) throw new FaultException<FaultReason>(new FaultReason("Could not find hiveExperiment with id " + hiveExperimentId));
    319         DA.Permission perm = dao.GetPermissionForExperiment(he.Id, userManager.CurrentUserId);
     310        dao.SetJobPermission(jobId, userManager.CurrentUserId, grantedUserId, DT.Convert.ToEntity(permission));
     311      });
     312    }
     313
     314    public void RevokePermission(Guid jobId, Guid grantedUserId) {
     315      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     316      trans.UseTransaction(() => {
     317        Job job = dao.GetJob(jobId);
     318        if (job == null) throw new FaultException<FaultReason>(new FaultReason("Could not find task with id " + jobId));
     319        DA.Permission perm = dao.GetPermissionForJob(job.Id, userManager.CurrentUserId);
    320320        if (perm != DA.Permission.Full) throw new FaultException<FaultReason>(new FaultReason("Not allowed to grant permissions for this experiment"));
    321         dao.SetHiveExperimentPermission(hiveExperimentId, userManager.CurrentUserId, grantedUserId, DA.Permission.NotAllowed);
    322       });
    323     }
    324     public IEnumerable<JobPermission> GetHiveExperimentPermissions(Guid hiveExperimentId) {
    325       authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
    326       return trans.UseTransaction(() => {
    327         DA.Permission currentUserPermission = dao.GetPermissionForExperiment(hiveExperimentId, userManager.CurrentUserId);
     321        dao.SetJobPermission(jobId, userManager.CurrentUserId, grantedUserId, DA.Permission.NotAllowed);
     322      });
     323    }
     324    public IEnumerable<JobPermission> GetJobPermissions(Guid jobId) {
     325      authen.AuthenticateForAnyRole(HiveRoles.Administrator, HiveRoles.Client);
     326      return trans.UseTransaction(() => {
     327        DA.Permission currentUserPermission = dao.GetPermissionForJob(jobId, userManager.CurrentUserId);
    328328        if (currentUserPermission != DA.Permission.Full) throw new FaultException<FaultReason>(new FaultReason("Not allowed to list permissions for this experiment"));
    329         return dao.GetHiveExperimentPermissions(x => x.JobId == hiveExperimentId);
     329        return dao.GetJobPermissions(x => x.JobId == jobId);
    330330      });
    331331    }
    … …  
    591591
    592592    #region Helper Methods
    593     private IEnumerable<Task> GetChildJobs(Guid? parentJobId, bool recursive, bool includeParent) {
    594       var jobs = new List<Task>(dao.GetJobs(x => parentJobId == null ? !x.ParentTaskId.HasValue : x.ParentTaskId.Value == parentJobId));
     593    private IEnumerable<Task> GetChildTasks(Guid? parentTaskId, bool recursive, bool includeParent) {
     594      var tasks = new List<Task>(dao.GetTasks(x => parentTaskId == null ? !x.ParentTaskId.HasValue : x.ParentTaskId.Value == parentTaskId));
    595595
    596596      if (recursive) {
    597597        var childs = new List<Task>();
    598         foreach (var job in jobs) {
    599           childs.AddRange(GetChildJobs(job.Id, recursive, false));
    600         }
    601         jobs.AddRange(childs);
     598        foreach (var task in tasks) {
     599          childs.AddRange(GetChildTasks(task.Id, recursive, false));
     600        }
     601        tasks.AddRange(childs);
    602602      }
    603603
    604       if (includeParent) jobs.Add(GetJob(parentJobId.Value));
    605       return jobs;
     604      if (includeParent) tasks.Add(GetTask(parentTaskId.Value));
     605      return tasks;
    606606    }
    607607    #endregion

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IAuthorizationManager.cs

    r6717 r6743  
    3030    void Authorize(Guid userId);
    3131
     32    void AuthorizeForTask(Guid taskId, Permission requiredPermission);
     33
    3234    void AuthorizeForJob(Guid jobId, Permission requiredPermission);
    33 
    34     void AuthorizeForExperiment(Guid experimentId, Permission requiredPermission);
    3535  }
    3636}

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IEventManager.cs

    r6698 r6743  
    2222namespace HeuristicLab.Services.Hive {
    2323  /// <summary>
    24   /// The only object in hive which holds a state. Must allow restarts without resetting all jobs
     24  /// The only object in hive which holds a state. Must allow restarts without resetting all task
    2525  /// </summary>
    2626  public interface IEventManager {

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Interfaces/IHiveDao.cs

    r6725 r6743  
    2929  public interface IHiveDao {
    3030    #region Task Methods
    31     DT.Task GetJob(Guid id);
    32     IEnumerable<DT.Task> GetJobs(Expression<Func<Task, bool>> predicate);
    33     Guid AddJob(DT.Task dto);
    34     void UpdateJob(DT.Task dto);
    35     void DeleteJob(Guid id);
    36     IEnumerable<DT.Task> GetWaitingJobs(DT.Slave slave, int count);
    37     IEnumerable<DT.Task> GetParentJobs(IEnumerable<Guid> resourceIds, int count, bool finished);
    38     DT.Task UpdateJobState(Guid jobId, TaskState jobState, Guid? slaveId, Guid? userId, string exception);
     31    DT.Task GetTask(Guid id);
     32    IEnumerable<DT.Task> GetTasks(Expression<Func<Task, bool>> predicate);
     33    Guid AddTask(DT.Task dto);
     34    void UpdateTask(DT.Task dto);
     35    void DeleteTask(Guid id);
     36    IEnumerable<DT.Task> GetWaitingTasks(DT.Slave slave, int count);
     37    IEnumerable<DT.Task> GetParentTasks(IEnumerable<Guid> resourceIds, int count, bool finished);
     38    DT.Task UpdateTaskState(Guid taskId, TaskState taskState, Guid? slaveId, Guid? userId, string exception);
    3939    #endregion
    4040
    4141    #region TaskData Methods
    42     DT.TaskData GetJobData(Guid id);
    43     IEnumerable<DT.TaskData> GetJobDatas(Expression<Func<TaskData, bool>> predicate);
    44     Guid AddJobData(DT.TaskData dto);
    45     void UpdateJobData(DT.TaskData dto);
    46     void DeleteJobData(Guid id);
     42    DT.TaskData GetTaskData(Guid id);
     43    IEnumerable<DT.TaskData> GetTaskDatas(Expression<Func<TaskData, bool>> predicate);
     44    Guid AddTaskData(DT.TaskData dto);
     45    void UpdateTaskData(DT.TaskData dto);
     46    void DeleteTaskData(Guid id);
    4747    #endregion
    4848
    … …  
    5555    #endregion
    5656
    57     #region HiveExperiment Methods
    58     DT.Job GetHiveExperiment(Guid id);
    59     IEnumerable<DT.Job> GetHiveExperiments(Expression<Func<Job, bool>> predicate);
    60     Guid AddHiveExperiment(DT.Job dto);
    61     void UpdateHiveExperiment(DT.Job dto);
    62     void DeleteHiveExperiment(Guid id);
     57    #region Job Methods
     58    DT.Job GetJob(Guid id);
     59    IEnumerable<DT.Job> GetJobs(Expression<Func<Job, bool>> predicate);
     60    Guid AddJob(DT.Job dto);
     61    void UpdateJob(DT.Job dto);
     62    void DeleteJob(Guid id);
    6363    #endregion
    6464
    65     #region HiveExperimentPermission Methods
    66     DT.JobPermission GetHiveExperimentPermission(Guid hiveExperimentId, Guid grantedUserId);
    67     IEnumerable<DT.JobPermission> GetHiveExperimentPermissions(Expression<Func<JobPermission, bool>> predicate);
    68     void AddHiveExperimentPermission(DT.JobPermission dto);
    69     void UpdateHiveExperimentPermission(DT.JobPermission dto);
    70     void DeleteHiveExperimentPermission(Guid hiveExperimentId, Guid grantedUserId);
    71     void SetHiveExperimentPermission(Guid hiveExperimentId, Guid grantedByUserId, Guid grantedUserId, Permission permission);
     65    #region JobPermission Methods
     66    DT.JobPermission GetJobPermission(Guid jobId, Guid grantedUserId);
     67    IEnumerable<DT.JobPermission> GetJobPermissions(Expression<Func<JobPermission, bool>> predicate);
     68    void AddJobPermission(DT.JobPermission dto);
     69    void UpdateJobPermission(DT.JobPermission dto);
     70    void DeleteJobPermission(Guid jobId, Guid grantedUserId);
     71    void SetJobPermission(Guid jobId, Guid grantedByUserId, Guid grantedUserId, Permission permission);
    7272    #endregion
    7373
    … …  
    8686    void UpdatePluginData(DT.PluginData dto);
    8787    void DeletePluginData(Guid id);
    88     #endregion
    89 
    90     #region Calendar Methods
    9188    #endregion
    9289
    … …  
    121118
    122119    #region Authorization Methods
     120    Permission GetPermissionForTask(Guid taskId, Guid userId);
    123121    Permission GetPermissionForJob(Guid jobId, Guid userId);
    124     Permission GetPermissionForExperiment(Guid experimentId, Guid userId);
    125     Guid GetExperimentForJob(Guid jobId);
     122    Guid GetJobForTask(Guid taskId);
    126123    #endregion
    127124

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/AuthorizationManager.cs

    r6717 r6743  
    3333    }
    3434
     35    public void AuthorizeForTask(Guid taskId, DT.Permission requiredPermission) {
     36      if (ServiceLocator.Instance.AuthenticationManager.IsInRole(HiveRoles.Slave)) return; // slave-users can access all tasks
     37
     38      Permission permission = ServiceLocator.Instance.HiveDao.GetPermissionForTask(taskId, ServiceLocator.Instance.UserManager.CurrentUserId);
     39      if (permission == Permission.NotAllowed || (permission != DT.Convert.ToEntity(requiredPermission) && DT.Convert.ToEntity(requiredPermission) == Permission.Full))
     40        throw new SecurityException("Current user is not authorized to access task");
     41    }
     42
    3543    public void AuthorizeForJob(Guid jobId, DT.Permission requiredPermission) {
    36       if (ServiceLocator.Instance.AuthenticationManager.IsInRole(HiveRoles.Slave)) return; // slave-users can access all jobs
    37 
    3844      Permission permission = ServiceLocator.Instance.HiveDao.GetPermissionForJob(jobId, ServiceLocator.Instance.UserManager.CurrentUserId);
    3945      if (permission == Permission.NotAllowed || (permission != DT.Convert.ToEntity(requiredPermission) && DT.Convert.ToEntity(requiredPermission) == Permission.Full))
    40         throw new SecurityException("Current user is not authorized to access job");
    41     }
    42 
    43     public void AuthorizeForExperiment(Guid experimentId, DT.Permission requiredPermission) {
    44       Permission permission = ServiceLocator.Instance.HiveDao.GetPermissionForExperiment(experimentId, ServiceLocator.Instance.UserManager.CurrentUserId);
    45       if (permission == Permission.NotAllowed || (permission != DT.Convert.ToEntity(requiredPermission) && DT.Convert.ToEntity(requiredPermission) == Permission.Full))
    46         throw new SecurityException("Current user is not authorized to access experiment");
     46        throw new SecurityException("Current user is not authorized to access task");
    4747    }
    4848  }

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/EventManager.cs

    r6721 r6743  
    2929namespace HeuristicLab.Services.Hive {
    3030  /// <summary>
    31   /// This class offers methods for cleaning up offline slaves and jobs
     31  /// This class offers methods for cleaning up offline slaves and task
    3232  /// </summary>
    3333  public class EventManager : IEventManager {
    … …  
    4545      log.Log("EventManager.Cleanup()");
    4646      SetTimeoutSlavesOffline();
    47       SetTimeoutJobsWaiting();
    48       FinishParentJobs();
     47      SetTimeoutTasksWaiting();
     48      FinishParentTasks();
    4949      UpdateStatistics();
    5050    }
    … …  
    7272
    7373    /// <summary>
    74     /// Searches for slaves which are timed out, puts them and their jobs offline
     74    /// Searches for slaves which are timed out, puts them and their task offline
    7575    /// </summary>
    7676    private void SetTimeoutSlavesOffline() {
    … …  
    7979        if (!slave.LastHeartbeat.HasValue || (DateTime.Now - slave.LastHeartbeat.Value) > HeuristicLab.Services.Hive.Properties.Settings.Default.SlaveHeartbeatTimeout) {
    8080          slave.SlaveState = DT.SlaveState.Offline;
    81           SetJobsWaiting(slave.Id);
     81          SetTasksWaiting(slave.Id);
    8282          dao.UpdateSlave(slave);
    8383        }
    … …  
    8686
    8787    /// <summary>
    88     /// Looks for parent jobs which have FinishWhenChildJobsFinished and set their state to finished
     88    /// Looks for parent tasks which have FinishWhenChildJobsFinished and set their state to finished
    8989    /// </summary>
    90     private void FinishParentJobs() {
    91       var parentJobsToFinish = dao.GetParentJobs(dao.GetResources(x => true).Select(x => x.Id), 0, true);
    92       foreach (var job in parentJobsToFinish) {
    93         dao.UpdateJobState(job.Id, TaskState.Finished, null, null, string.Empty);
     90    private void FinishParentTasks() {
     91      var parentTasksToFinish = dao.GetParentTasks(dao.GetResources(x => true).Select(x => x.Id), 0, true);
     92      foreach (var task in parentTasksToFinish) {
     93        dao.UpdateTaskState(task.Id, TaskState.Finished, null, null, string.Empty);
    9494      }
    9595    }
    9696
    97     private void SetJobsWaiting(Guid slaveId) {
    98       var jobs = dao.GetJobs(x => x.State == TaskState.Calculating).Where(x => x.StateLog.Last().SlaveId == slaveId);
    99       foreach (var j in jobs) {
    100         DT.Task job = dao.UpdateJobState(j.Id, TaskState.Waiting, slaveId, null, "Slave timed out.");
    101         job.Command = null;
    102         dao.UpdateJob(job);
     97    private void SetTasksWaiting(Guid slaveId) {
     98      var tasks = dao.GetTasks(x => x.State == TaskState.Calculating).Where(x => x.StateLog.Last().SlaveId == slaveId);
     99      foreach (var j in tasks) {
     100        DT.Task task = dao.UpdateTaskState(j.Id, TaskState.Waiting, slaveId, null, "Slave timed out.");
     101        task.Command = null;
     102        dao.UpdateTask(task);
    103103      }
    104104    }
    105105
    106106    /// <summary>
    107     /// Looks for jobs which have not sent heartbeats for some time and reschedules them for calculation
     107    /// Looks for task which have not sent heartbeats for some time and reschedules them for calculation
    108108    /// </summary>
    109     private void SetTimeoutJobsWaiting() {
    110       var jobs = dao.GetJobs(x => (x.State == TaskState.Calculating && (DateTime.Now - x.LastHeartbeat) > HeuristicLab.Services.Hive.Properties.Settings.Default.CalculatingJobHeartbeatTimeout)
     109    private void SetTimeoutTasksWaiting() {
     110      var tasks = dao.GetTasks(x => (x.State == TaskState.Calculating && (DateTime.Now - x.LastHeartbeat) > HeuristicLab.Services.Hive.Properties.Settings.Default.CalculatingJobHeartbeatTimeout)
    111111                               || (x.State == TaskState.Transferring && (DateTime.Now - x.LastHeartbeat) > HeuristicLab.Services.Hive.Properties.Settings.Default.TransferringJobHeartbeatTimeout));
    112       foreach (var j in jobs) {
    113         DT.Task job = dao.UpdateJobState(j.Id, TaskState.Waiting, null, null, "Slave timed out.");
    114         job.Command = null;
    115         dao.UpdateJob(job);
     112      foreach (var j in tasks) {
     113        DT.Task task = dao.UpdateTaskState(j.Id, TaskState.Waiting, null, null, "Slave timed out.");
     114        task.Command = null;
     115        dao.UpdateTask(task);
    116116      }
    117117    }

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/Manager/HeartbeatManager.cs

    r6725 r6743  
    5454        dao.UpdateSlave(slave);
    5555
    56         // update job data
    57         actions.AddRange(UpdateJobs(heartbeat, slave.IsAllowedToCalculate));
     56        // update task data
     57        actions.AddRange(UpdateTasks(heartbeat, slave.IsAllowedToCalculate));
    5858
    59         // assign new job
     59        // assign new task
    6060        if (heartbeat.AssignJob && slave.IsAllowedToCalculate && heartbeat.FreeCores > 0) {
    61           var availableJobs = dao.GetWaitingJobs(slave, 1);
     61          var availableJobs = dao.GetWaitingTasks(slave, 1);
    6262          if (availableJobs.Count() > 0) {
    6363            var job = availableJobs.First();
    … …  
    7171
    7272    // returns true if assignment was successful
    73     private bool AssignJob(Slave slave, Task job) {
    74       // load job again and check if it is still available (this is an attempt to reduce the race condition which causes multiple heartbeats to get the same job assigned)
    75       if (dao.GetJob(job.Id).State != TaskState.Waiting) return false;
     73    private bool AssignJob(Slave slave, Task task) {
     74      // load task again and check if it is still available (this is an attempt to reduce the race condition which causes multiple heartbeats to get the same task assigned)
     75      if (dao.GetTask(task.Id).State != TaskState.Waiting) return false;
    7676
    77       job = dao.UpdateJobState(job.Id, DataAccess.TaskState.Transferring, slave.Id, null, null);
     77      task = dao.UpdateTaskState(task.Id, DataAccess.TaskState.Transferring, slave.Id, null, null);
    7878
    79       // from now on the job has some time to send the next heartbeat (ApplicationConstants.TransferringJobHeartbeatTimeout)
    80       job.LastHeartbeat = DateTime.Now;
    81       dao.UpdateJob(job);
     79      // from now on the task has some time to send the next heartbeat (ApplicationConstants.TransferringJobHeartbeatTimeout)
     80      task.LastHeartbeat = DateTime.Now;
     81      dao.UpdateTask(task);
    8282      return true;
    8383    }
    8484
    8585    /// <summary>
    86     /// Update the progress of each job
    87     /// Checks if all the jobs sent by heartbeat are supposed to be calculated by this slave
     86    /// Update the progress of each task
     87    /// Checks if all the task sent by heartbeat are supposed to be calculated by this slave
    8888    /// </summary>
    89     private IEnumerable<MessageContainer> UpdateJobs(Heartbeat heartbeat, bool IsAllowedToCalculate) {
     89    private IEnumerable<MessageContainer> UpdateTasks(Heartbeat heartbeat, bool IsAllowedToCalculate) {
    9090      List<MessageContainer> actions = new List<MessageContainer>();
    9191
    … …  
    9898        // process the jobProgresses
    9999        foreach (var jobProgress in heartbeat.JobProgress) {
    100           Task curJob = dao.GetJob(jobProgress.Key);
     100          Task curJob = dao.GetTask(jobProgress.Key);
    101101          if (curJob == null) {
    102             // job does not exist in db
     102            // task does not exist in db
    103103            actions.Add(new MessageContainer(MessageContainer.MessageType.AbortTask, jobProgress.Key));
    104104            DA.LogFactory.GetLogger(this.GetType().Namespace).Log("Job does not exist in DB: " + jobProgress.Key);
    … …  
    108108              actions.Add(new MessageContainer(MessageContainer.MessageType.AbortTask, curJob.Id));
    109109              DA.LogFactory.GetLogger(this.GetType().Namespace).Log("The slave " + heartbeat.SlaveId + " is not supposed to calculate Job: " + curJob);
    110             } else if (!JobIsAllowedToBeCalculatedBySlave(heartbeat.SlaveId, curJob)) {
    111               // assigned resources ids of job do not match with slaveId (and parent resourceGroupIds); this might happen when slave is moved to different group
     110            } else if (!TaskIsAllowedToBeCalculatedBySlave(heartbeat.SlaveId, curJob)) {
     111              // assigned resources ids of task do not match with slaveId (and parent resourceGroupIds); this might happen when slave is moved to different group
    112112              actions.Add(new MessageContainer(MessageContainer.MessageType.PauseTask, curJob.Id));
    113113            } else {
    114               // save job execution time
     114              // save task execution time
    115115              curJob.ExecutionTime = jobProgress.Value;
    116116              curJob.LastHeartbeat = DateTime.Now;
    … …  
    127127                  break;
    128128              }
    129               dao.UpdateJob(curJob);
     129              dao.UpdateTask(curJob);
    130130            }
    131131          }
    … …  
    135135    }
    136136
    137     private bool JobIsAllowedToBeCalculatedBySlave(Guid slaveId, Task curJob) {
    138       var assignedResourceIds = dao.GetAssignedResources(curJob.Id).Select(x => x.Id);
     137    private bool TaskIsAllowedToBeCalculatedBySlave(Guid slaveId, Task curTask) {
     138      var assignedResourceIds = dao.GetAssignedResources(curTask.Id).Select(x => x.Id);
    139139      var slaveResourceIds = dao.GetParentResources(slaveId).Select(x => x.Id);
    140140      return assignedResourceIds.Any(x => slaveResourceIds.Contains(x));

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/MessageContainer.cs

    r6725 r6743  
    3737    public enum MessageType {
    3838      // *** commands from hive server ***
    39       CalculateTask, // slave should calculate a job. the job is already assigned to the slave
    40       StopTask,   // slave should stop the job and submit results
     39      CalculateTask, // slave should calculate a task. the task is already assigned to the slave
     40      StopTask,   // slave should stop the task and submit results
    4141      StopAll,   // stop all and submit results
    42       AbortTask,  // slave should shut the job down immediately without submitting results
    43       AbortAll,  // slave should abort all jobs immediately
    44       PauseTask,  // pause the job and submit the results   
    45       PauseAll,  // pause all jobs and submit results
     42      AbortTask,  // slave should shut the task down immediately without submitting results
     43      AbortAll,  // slave should abort all task immediately
     44      PauseTask,  // pause the task and submit the results   
     45      PauseAll,  // pause all task and submit results
    4646      Restart,   // restart operation after Sleep
    4747      Sleep,     // disconnect from server, but don't shutdown
    4848      ShutdownSlave,  // slave should shutdown immediately without submitting results
    49       SayHello,  // Slave should say hello, because he is unknown to the server
     49      SayHello,  // Slave should say hello, because job is unknown to the server
    5050    };
    5151

  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive/3.3/ServiceContracts/IHiveService.cs

    r6725 r6743  
    3333    #region Task Methods
    3434    [OperationContract]
    35     Guid AddJob(Task job, TaskData jobData, IEnumerable<Guid> resourceIds);
    36 
    37     [OperationContract]
    38     Guid AddChildJob(Guid parentJobId, Task job, TaskData jobData);
    39 
    40     [OperationContract]
    41     Task GetJob(Guid jobId);
    42 
    43     [OperationContract]
    44     IEnumerable<Task> GetJobs();
    45 
    46     [OperationContract]
    47     IEnumerable<LightweightTask> GetLightweightJobs(IEnumerable<Guid> jobIds);
    48 
    49     [OperationContract]
    50     IEnumerable<LightweightTask> GetLightweightChildJobs(Guid? parentJobId, bool recursive, bool includeParent);
    51 
    52     [OperationContract]
    53     IEnumerable<LightweightTask> GetLightweightExperimentJobs(Guid experimentId);
    54 
    55     [OperationContract]
    56     TaskData GetJobData(Guid jobId);
    57 
    58     [OperationContract]
    59     void UpdateJob(Task jobDto);
    60 
    61     [OperationContract]
    62     void UpdateJobData(Task jobDto, TaskData jobDataDto);
    63 
    64     [OperationContract]
    65     void DeleteJob(Guid jobId);
    66 
    67     [OperationContract]
    68     void DeleteChildJobs(Guid parentJobId);
    69 
    70     [OperationContract]
    71     Task UpdateJobState(Guid jobId, TaskState jobState, Guid? slaveId, Guid? userId, string exception);
    72     #endregion
    73 
    74     #region Job Control Methods
    75     [OperationContract]
    76     void StopJob(Guid jobId);
    77 
    78     [OperationContract]
    79     void PauseJob(Guid jobId);
    80 
    81     [OperationContract]
    82     void RestartJob(Guid jobId);
     35    Guid AddTask(Task task, TaskData taskData, IEnumerable<Guid> resourceIds);
     36
     37    [OperationContract]
     38    Guid AddChildTask(Guid parentTaskId, Task task, TaskData taskData);
     39
     40    [OperationContract]
     41    Task GetTask(Guid taskId);
     42
     43    [OperationContract]
     44    IEnumerable<Task> GetTasks();
     45
     46    [OperationContract]
     47    IEnumerable<LightweightTask> GetLightweightTasks(IEnumerable<Guid> taskIds);
     48
     49    [OperationContract]
     50    IEnumerable<LightweightTask> GetLightweightChildTasks(Guid? parentTaskId, bool recursive, bool includeParent);
     51
     52    [OperationContract]
     53    IEnumerable<LightweightTask> GetLightweightJobTasks(Guid jobId);
     54
     55    [OperationContract]
     56    TaskData GetTaskData(Guid taskId);
     57
     58    [OperationContract]
     59    void UpdateTask(Task taskDto);
     60
     61    [OperationContract]
     62    void UpdateTaskData(Task taskDto, TaskData taskDataDto);
     63
     64    [OperationContract]
     65    void DeleteTask(Guid taskId);
     66
     67    [OperationContract]
     68    void DeleteChildTasks(Guid parentTaskId);
     69
     70    [OperationContract]
     71    Task UpdateTaskState(Guid taskId, TaskState taskState, Guid? slaveId, Guid? userId, string exception);
     72    #endregion
     73
     74    #region Task Control Methods
     75    [OperationContract]
     76    void StopTask(Guid taskId);
     77
     78    [OperationContract]
     79    void PauseTask(Guid taskId);
     80
     81    [OperationContract]
     82    void RestartTask(Guid taskId);
    8383    #endregion
    8484
    8585    #region Job Methods
    8686    [OperationContract]
    87     Job GetHiveExperiment(Guid id);
     87    Job GetJob(Guid id);
    8888
    8989    /// <summary>
    90     /// Returns all experiments for the current user
     90    /// Returns all task for the current user
    9191    /// </summary>
    9292    [OperationContract]
    93     IEnumerable<Job> GetHiveExperiments();
     93    IEnumerable<Job> GetJobs();
    9494
    9595    /// <summary>
    96     /// Returns all experiments in the hive (only for admins)
     96    /// Returns all task in the hive (only for admins)
    9797    /// </summary>
    9898    /// <returns></returns>
    9999    [OperationContract]
    100     IEnumerable<Job> GetAllHiveExperiments();
    101 
    102     [OperationContract]
    103     Guid AddHiveExperiment(Job hiveExperimentDto);
    104 
    105     [OperationContract]
    106     void UpdateHiveExperiment(Job hiveExperimentDto);
    107 
    108     [OperationContract]
    109     void DeleteHiveExperiment(Guid hiveExperimentId);
    110     #endregion
    111 
    112     #region HiveExperimentPermission Methods
    113     [OperationContract]
    114     void GrantPermission(Guid hiveExperimentId, Guid grantedUserId, Permission permission);
     100    IEnumerable<Job> GetAllJobs();
     101
     102    [OperationContract]
     103    Guid AddJob(Job jobDto);
     104
     105    [OperationContract]
     106    void UpdateJob(Job jobDto);
     107
     108    [OperationContract]
     109    void DeleteJob(Guid JobId);
     110    #endregion
     111
     112    #region JobPermission Methods
     113    [OperationContract]
     114    void GrantPermission(Guid jobId, Guid grantedUserId, Permission permission);
    115115
    116116    [OperationContract]
    … …  
    118118
    119119    [OperationContract]
    120     IEnumerable<JobPermission> GetHiveExperimentPermissions(Guid hiveExperimentId);
    121 
    122     [OperationContract]
    123     bool IsAllowedPrivileged(); // current user may execute privileged jobs
     120    IEnumerable<JobPermission> GetJobPermissions(Guid jobId);
     121
     122    [OperationContract]
     123    bool IsAllowedPrivileged(); // current user may execute privileged task
    124124    #endregion
    125125
    … …  
    140140    [OperationContract]
    141141    Plugin GetPlugin(Guid pluginId);
     142
    142143    [OperationContract]
    143144    Plugin GetPluginByHash(byte[] hash);
     145
    144146    [OperationContract]
    145147    [FaultContract(typeof(PluginAlreadyExistsFault))]
    146148    Guid AddPlugin(Plugin plugin, List<PluginData> pluginData);
     149
    147150    [OperationContract]
    148151    IEnumerable<Plugin> GetPlugins();
     152
    149153    [OperationContract]
    150154    IEnumerable<PluginData> GetPluginDatas(List<Guid> pluginIds);
     155
    151156    [OperationContract]
    152157    void DeletePlugin(Guid pluginId);
    … …  
    194199
    195200    [OperationContract]
    196     IEnumerable<Task> GetJobsByResourceId(Guid resourceId);
     201    IEnumerable<Task> GetTasksByResourceId(Guid resourceId);
    197202
    198203    [OperationContract]
Note: See TracChangeset for help on using the changeset viewer.