Changeset 6743 for branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveClient.cs

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

File:

• branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveClient.cs (modified) (20 diffs)

branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveClient.cs

@@ -86 +86 @@
         var oldExperiments = jobs ?? new ItemCollection<RefreshableJob>();
         jobs = new HiveItemCollection<RefreshableJob>();
-        var experimentsLoaded = ServiceLocator.Instance.CallHiveService<IEnumerable<Job>>(s => s.GetHiveExperiments());
+        var experimentsLoaded = ServiceLocator.Instance.CallHiveService<IEnumerable<Job>>(s => s.GetJobs());
 
         foreach (var he in experimentsLoaded) {
-          var hiveExperiment = oldExperiments.SingleOrDefault(x => x.Id == he.Id);
-          if (hiveExperiment == null) {
+          var job = oldExperiments.SingleOrDefault(x => x.Id == he.Id);
+          if (job == null) {
             // new
             jobs.Add(new RefreshableJob(he) { IsAllowedPrivileged = this.isAllowedPrivileged });
           } else {
             // update
-            hiveExperiment.Job = he;
-            hiveExperiment.IsAllowedPrivileged = this.isAllowedPrivileged;
-            jobs.Add(hiveExperiment);
+            job.Job = he;
+            job.IsAllowedPrivileged = this.isAllowedPrivileged;
+            jobs.Add(job);
           }
         }
@@ -139 +139 @@
       if (item.Id == Guid.Empty) {
         if (item is RefreshableJob) {
-          HiveClient.Instance.UploadExperiment((RefreshableJob)item, cancellationToken);
+          HiveClient.Instance.UploadJob((RefreshableJob)item, cancellationToken);
         }
         if (item is JobPermission) {
@@ -151 +151 @@
       } else {
         if (item is Job)
-          ServiceLocator.Instance.CallHiveService(s => s.UpdateHiveExperiment((Job)item));
+          ServiceLocator.Instance.CallHiveService(s => s.UpdateJob((Job)item));
       }
     }
@@ -177 +177 @@
 
       if (item is Job)
-        ServiceLocator.Instance.CallHiveService(s => s.DeleteHiveExperiment(item.Id));
+        ServiceLocator.Instance.CallHiveService(s => s.DeleteJob(item.Id));
       if (item is RefreshableJob)
-        ServiceLocator.Instance.CallHiveService(s => s.DeleteHiveExperiment(item.Id));
+        ServiceLocator.Instance.CallHiveService(s => s.DeleteJob(item.Id));
       if (item is JobPermission) {
         var hep = (JobPermission)item;
@@ -206 +206 @@
     #endregion
 
-    public static void StartExperiment(Action<Exception> exceptionCallback, RefreshableJob refreshableJob, CancellationToken cancellationToken) {
+    public static void StartJob(Action<Exception> exceptionCallback, RefreshableJob refreshableJob, CancellationToken cancellationToken) {
       HiveClient.StoreAsync(
         new Action<Exception>((Exception ex) => {
@@ -215 +215 @@
     }
 
-    public static void PauseExperiment(RefreshableJob refreshableHiveExperiment) {
+    public static void PauseJob(RefreshableJob refreshableJob) {
       ServiceLocator.Instance.CallHiveService(service => {
-        foreach (HiveTask job in refreshableHiveExperiment.GetAllHiveJobs()) {
-          if (job.Task.State != TaskState.Finished && job.Task.State != TaskState.Aborted && job.Task.State != TaskState.Failed)
-            service.PauseJob(job.Task.Id);
+        foreach (HiveTask task in refreshableJob.GetAllHiveTasks()) {
+          if (task.Task.State != TaskState.Finished && task.Task.State != TaskState.Aborted && task.Task.State != TaskState.Failed)
+            service.PauseTask(task.Task.Id);
         }
       });
-      refreshableHiveExperiment.ExecutionState = ExecutionState.Paused;
-    }
-
-    public static void StopExperiment(RefreshableJob refreshableJob) {
+      refreshableJob.ExecutionState = ExecutionState.Paused;
+    }
+
+    public static void StopJob(RefreshableJob refreshableJob) {
       ServiceLocator.Instance.CallHiveService(service => {
-        foreach (HiveTask job in refreshableJob.GetAllHiveJobs()) {
-          if (job.Task.State != TaskState.Finished && job.Task.State != TaskState.Aborted && job.Task.State != TaskState.Failed)
-            service.StopJob(job.Task.Id);
+        foreach (HiveTask task in refreshableJob.GetAllHiveTasks()) {
+          if (task.Task.State != TaskState.Finished && task.Task.State != TaskState.Aborted && task.Task.State != TaskState.Failed)
+            service.StopTask(task.Task.Id);
         }
       });
@@ -235 +235 @@
     }
 
-    #region Upload Experiment
+    #region Upload Job
     private Semaphore jobUploadSemaphore = new Semaphore(4, 4); // todo: take magic number into config
     private static object jobCountLocker = new object();
     private static object pluginLocker = new object();
-    private void UploadExperiment(RefreshableJob refreshableJob, CancellationToken cancellationToken) {
+    private void UploadJob(RefreshableJob refreshableJob, CancellationToken cancellationToken) {
       try {
         refreshableJob.Progress = new Progress("Connecting to server...");
@@ -254 +254 @@
         }
 
-        foreach (OptimizerHiveTask hiveJob in refreshableJob.HiveJobs.OfType<OptimizerHiveTask>()) {
+        foreach (OptimizerHiveTask hiveJob in refreshableJob.HiveTasks.OfType<OptimizerHiveTask>()) {
           hiveJob.SetIndexInParentOptimizerList(null);
         }
@@ -260 +260 @@
         // upload Task
         refreshableJob.Progress.Status = "Uploading Task...";
-        refreshableJob.Job.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddHiveExperiment(refreshableJob.Job));
+        refreshableJob.Job.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddJob(refreshableJob.Job));
         bool isPrivileged = refreshableJob.Job.IsPrivileged;
-        refreshableJob.Job = ServiceLocator.Instance.CallHiveService((s) => s.GetHiveExperiment(refreshableJob.Job.Id)); // update owner and permissions
+        refreshableJob.Job = ServiceLocator.Instance.CallHiveService((s) => s.GetJob(refreshableJob.Job.Id)); // update owner and permissions
         refreshableJob.Job.IsPrivileged = isPrivileged;
         cancellationToken.ThrowIfCancellationRequested();
 
-        int totalJobCount = refreshableJob.GetAllHiveJobs().Count();
+        int totalJobCount = refreshableJob.GetAllHiveTasks().Count();
         int[] jobCount = new int[1]; // use a reference type (int-array) instead of value type (int) in order to pass the value via a delegate to task-parallel-library
         cancellationToken.ThrowIfCancellationRequested();
@@ -284 +284 @@
 
         var tasks = new List<TS.Task>();
-        foreach (HiveTask hiveJob in refreshableJob.HiveJobs) {
+        foreach (HiveTask hiveJob in refreshableJob.HiveTasks) {
           tasks.Add(TS.Task.Factory.StartNew((hj) => {
-            UploadJobWithChildren(refreshableJob.Progress, (HiveTask)hj, null, resourceIds, jobCount, totalJobCount, configFilePlugin.Id, refreshableJob.Job.Id, refreshableJob.Log, refreshableJob.Job.IsPrivileged, cancellationToken);
+            UploadTaskWithChildren(refreshableJob.Progress, (HiveTask)hj, null, resourceIds, jobCount, totalJobCount, configFilePlugin.Id, refreshableJob.Job.Id, refreshableJob.Log, refreshableJob.Job.IsPrivileged, cancellationToken);
           }, hiveJob)
           .ContinueWith((x) => refreshableJob.Log.LogException(x.Exception), TaskContinuationOptions.OnlyOnFaulted));
@@ -334 +334 @@
     /// </summary>
     /// <param name="parentHiveTask">shall be null if its the root task</param>
-    private void UploadJobWithChildren(IProgress progress, HiveTask hiveJob, HiveTask parentHiveJob, IEnumerable<Guid> groups, int[] jobCount, int totalJobCount, Guid configPluginId, Guid hiveExperimentId, ILog log, bool isPrivileged, CancellationToken cancellationToken) {
+    private void UploadTaskWithChildren(IProgress progress, HiveTask hiveTask, HiveTask parentHiveJob, IEnumerable<Guid> groups, int[] taskCount, int totalJobCount, Guid configPluginId, Guid jobId, ILog log, bool isPrivileged, CancellationToken cancellationToken) {
       jobUploadSemaphore.WaitOne();
       bool semaphoreReleased = false;
@@ -340 +340 @@
         cancellationToken.ThrowIfCancellationRequested();
         lock (jobCountLocker) {
-          jobCount[0]++;
+          taskCount[0]++;
         }
         TaskData jobData;
         List<IPluginDescription> plugins;
 
-        if (hiveJob.ItemTask.ComputeInParallel && (hiveJob.ItemTask.Item is Optimization.Experiment || hiveJob.ItemTask.Item is Optimization.BatchRun)) {
-          hiveJob.Task.IsParentTask = true;
-          hiveJob.Task.FinishWhenChildJobsFinished = true;
-          jobData = hiveJob.GetAsTaskData(true, out plugins);
+        if (hiveTask.ItemTask.ComputeInParallel && (hiveTask.ItemTask.Item is Optimization.Experiment || hiveTask.ItemTask.Item is Optimization.BatchRun)) {
+          hiveTask.Task.IsParentTask = true;
+          hiveTask.Task.FinishWhenChildJobsFinished = true;
+          jobData = hiveTask.GetAsTaskData(true, out plugins);
         } else {
-          hiveJob.Task.IsParentTask = false;
-          hiveJob.Task.FinishWhenChildJobsFinished = false;
-          jobData = hiveJob.GetAsTaskData(false, out plugins);
+          hiveTask.Task.IsParentTask = false;
+          hiveTask.Task.FinishWhenChildJobsFinished = false;
+          jobData = hiveTask.GetAsTaskData(false, out plugins);
         }
         cancellationToken.ThrowIfCancellationRequested();
@@ -359 +359 @@
           if (!cancellationToken.IsCancellationRequested) {
             lock (pluginLocker) {
-              ServiceLocator.Instance.CallHiveService((s) => hiveJob.Task.PluginsNeededIds = PluginUtil.GetPluginDependencies(s, this.onlinePlugins, this.alreadyUploadedPlugins, plugins));
+              ServiceLocator.Instance.CallHiveService((s) => hiveTask.Task.PluginsNeededIds = PluginUtil.GetPluginDependencies(s, this.onlinePlugins, this.alreadyUploadedPlugins, plugins));
             }
           }
         }, -1, "Failed to upload plugins");
         cancellationToken.ThrowIfCancellationRequested();
-        hiveJob.Task.PluginsNeededIds.Add(configPluginId);
-        hiveJob.Task.JobId = hiveExperimentId;
-        hiveJob.Task.IsPrivileged = isPrivileged;
-
-        log.LogMessage(string.Format("Uploading task ({0} kb, {1} objects)", jobData.Data.Count() / 1024, hiveJob.ItemTask.GetObjectGraphObjects().Count()));
+        hiveTask.Task.PluginsNeededIds.Add(configPluginId);
+        hiveTask.Task.JobId = jobId;
+        hiveTask.Task.IsPrivileged = isPrivileged;
+
+        log.LogMessage(string.Format("Uploading task ({0} kb, {1} objects)", jobData.Data.Count() / 1024, hiveTask.ItemTask.GetObjectGraphObjects().Count()));
         TryAndRepeat(() => {
           if (!cancellationToken.IsCancellationRequested) {
             if (parentHiveJob != null) {
-              hiveJob.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddChildJob(parentHiveJob.Task.Id, hiveJob.Task, jobData));
+              hiveTask.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddChildTask(parentHiveJob.Task.Id, hiveTask.Task, jobData));
             } else {
-              hiveJob.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddJob(hiveJob.Task, jobData, groups.ToList()));
+              hiveTask.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddTask(hiveTask.Task, jobData, groups.ToList()));
             }
           }
@@ -381 +381 @@
 
         lock (jobCountLocker) {
-          progress.ProgressValue = (double)jobCount[0] / totalJobCount;
-          progress.Status = string.Format("Uploaded task ({0} of {1})", jobCount[0], totalJobCount);
+          progress.ProgressValue = (double)taskCount[0] / totalJobCount;
+          progress.Status = string.Format("Uploaded task ({0} of {1})", taskCount[0], totalJobCount);
         }
 
         var tasks = new List<TS.Task>();
-        foreach (HiveTask child in hiveJob.ChildHiveTasks) {
+        foreach (HiveTask child in hiveTask.ChildHiveTasks) {
           tasks.Add(TS.Task.Factory.StartNew((tuple) => {
             var arguments = (Tuple<HiveTask, HiveTask>)tuple;
-            UploadJobWithChildren(progress, arguments.Item1, arguments.Item2, groups, jobCount, totalJobCount, configPluginId, hiveExperimentId, log, isPrivileged, cancellationToken);
-          }, new Tuple<HiveTask, HiveTask>(child, hiveJob))
+            UploadTaskWithChildren(progress, arguments.Item1, arguments.Item2, groups, taskCount, totalJobCount, configPluginId, jobId, log, isPrivileged, cancellationToken);
+          }, new Tuple<HiveTask, HiveTask>(child, hiveTask))
           .ContinueWith((x) => log.LogException(x.Exception), TaskContinuationOptions.OnlyOnFaulted));
         }
@@ -408 +408 @@
 
     #region Download Experiment
-    public static void LoadExperiment(RefreshableJob refreshableJob) {
+    public static void LoadJob(RefreshableJob refreshableJob) {
       var hiveExperiment = refreshableJob.Job;
       refreshableJob.Progress = new Progress();
@@ -415 +415 @@
         refreshableJob.IsProgressing = true;
         int totalJobCount = 0;
-        IEnumerable<LightweightTask> allJobs;
+        IEnumerable<LightweightTask> allTasks;
 
         refreshableJob.Progress.Status = "Connecting to Server...";
         // fetch all Task objects to create the full tree of tree of HiveTask objects
         refreshableJob.Progress.Status = "Downloading list of jobs...";
-        allJobs = ServiceLocator.Instance.CallHiveService(s => s.GetLightweightExperimentJobs(hiveExperiment.Id));
-        totalJobCount = allJobs.Count();
-
-        TaskDownloader downloader = new TaskDownloader(allJobs.Select(x => x.Id));
+        allTasks = ServiceLocator.Instance.CallHiveService(s => s.GetLightweightJobTasks(hiveExperiment.Id));
+        totalJobCount = allTasks.Count();
+
+        TaskDownloader downloader = new TaskDownloader(allTasks.Select(x => x.Id));
         downloader.StartAsync();
 
@@ -435 +435 @@
           }
         }
-        IDictionary<Guid, HiveTask> allHiveJobs = downloader.Results;
-
-        refreshableJob.HiveJobs = new ItemCollection<HiveTask>(allHiveJobs.Values.Where(x => !x.Task.ParentTaskId.HasValue));
+        IDictionary<Guid, HiveTask> allHiveTasks = downloader.Results;
+
+        refreshableJob.HiveTasks = new ItemCollection<HiveTask>(allHiveTasks.Values.Where(x => !x.Task.ParentTaskId.HasValue));
 
         if (refreshableJob.IsFinished()) {
@@ -446 +446 @@
 
         // build child-task tree
-        foreach (HiveTask hiveJob in refreshableJob.HiveJobs) {
-          BuildHiveJobTree(hiveJob, allJobs, allHiveJobs);
+        foreach (HiveTask hiveTask in refreshableJob.HiveTasks) {
+          BuildHiveJobTree(hiveTask, allTasks, allHiveTasks);
         }
 
@@ -482 +482 @@
 
     public static ItemTask LoadItemJob(Guid jobId) {
-      TaskData jobData = ServiceLocator.Instance.CallHiveService(s => s.GetJobData(jobId));
+      TaskData jobData = ServiceLocator.Instance.CallHiveService(s => s.GetTaskData(jobId));
       try {
         return PersistenceUtil.Deserialize<ItemTask>(jobData.Data);
@@ -506 +506 @@
     }
 
-    public static HiveItemCollection<JobPermission> GetHiveExperimentPermissions(Guid hiveExperimentId) {
+    public static HiveItemCollection<JobPermission> GetJobPermissions(Guid jobId) {
       return ServiceLocator.Instance.CallHiveService((service) => {
-        IEnumerable<JobPermission> heps = service.GetHiveExperimentPermissions(hiveExperimentId);
-        foreach (var hep in heps) {
+        IEnumerable<JobPermission> jps = service.GetJobPermissions(jobId);
+        foreach (var hep in jps) {
           hep.GrantedUserName = service.GetUsernameByUserId(hep.GrantedUserId);
         }
-        return new HiveItemCollection<JobPermission>(heps);
+        return new HiveItemCollection<JobPermission>(jps);
       });
     }