Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
09/08/11 16:38:28 (13 years ago)
Author:
ascheibe
Message:

#1233 more renaming for more consistency

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/HiveClient.cs

    r6723 r6725  
    4545
    4646    #region Properties
    47     private ItemCollection<RefreshableHiveExperiment> hiveExperiments;
    48     public ItemCollection<RefreshableHiveExperiment> HiveExperiments {
    49       get { return hiveExperiments; }
     47    private ItemCollection<RefreshableJob> jobs;
     48    public ItemCollection<RefreshableJob> Jobs {
     49      get { return jobs; }
    5050      set {
    51         if (value != hiveExperiments) {
    52           hiveExperiments = value;
     51        if (value != jobs) {
     52          jobs = value;
    5353          OnHiveExperimentsChanged();
    5454        }
     
    8484        this.IsAllowedPrivileged = ServiceLocator.Instance.CallHiveService((s) => s.IsAllowedPrivileged());
    8585
    86         var oldExperiments = hiveExperiments ?? new ItemCollection<RefreshableHiveExperiment>();
    87         hiveExperiments = new HiveItemCollection<RefreshableHiveExperiment>();
     86        var oldExperiments = jobs ?? new ItemCollection<RefreshableJob>();
     87        jobs = new HiveItemCollection<RefreshableJob>();
    8888        var experimentsLoaded = ServiceLocator.Instance.CallHiveService<IEnumerable<Job>>(s => s.GetHiveExperiments());
    8989
     
    9292          if (hiveExperiment == null) {
    9393            // new
    94             hiveExperiments.Add(new RefreshableHiveExperiment(he) { IsAllowedPrivileged = this.isAllowedPrivileged });
     94            jobs.Add(new RefreshableJob(he) { IsAllowedPrivileged = this.isAllowedPrivileged });
    9595          } else {
    9696            // update
    97             hiveExperiment.HiveExperiment = he;
     97            hiveExperiment.Job = he;
    9898            hiveExperiment.IsAllowedPrivileged = this.isAllowedPrivileged;
    99             hiveExperiments.Add(hiveExperiment);
     99            jobs.Add(hiveExperiment);
    100100          }
    101101        }
     
    104104          if (experiment.Id == Guid.Empty) {
    105105            // experiment not uploaded... keep
    106             hiveExperiments.Add(experiment);
     106            jobs.Add(experiment);
    107107          } else {
    108108            experiment.RefreshAutomatically = false; // stop results polling
     
    111111      }
    112112      catch {
    113         hiveExperiments = null;
     113        jobs = null;
    114114        throw;
    115115      }
     
    138138    public static void Store(IHiveItem item, CancellationToken cancellationToken) {
    139139      if (item.Id == Guid.Empty) {
    140         if (item is RefreshableHiveExperiment) {
    141           HiveClient.Instance.UploadExperiment((RefreshableHiveExperiment)item, cancellationToken);
     140        if (item is RefreshableJob) {
     141          HiveClient.Instance.UploadExperiment((RefreshableJob)item, cancellationToken);
    142142        }
    143143        if (item is JobPermission) {
     
    178178      if (item is Job)
    179179        ServiceLocator.Instance.CallHiveService(s => s.DeleteHiveExperiment(item.Id));
    180       if (item is RefreshableHiveExperiment)
     180      if (item is RefreshableJob)
    181181        ServiceLocator.Instance.CallHiveService(s => s.DeleteHiveExperiment(item.Id));
    182182      if (item is JobPermission) {
     
    206206    #endregion
    207207
    208     public static void StartExperiment(Action<Exception> exceptionCallback, RefreshableHiveExperiment refreshableHiveExperiment, CancellationToken cancellationToken) {
     208    public static void StartExperiment(Action<Exception> exceptionCallback, RefreshableJob refreshableJob, CancellationToken cancellationToken) {
    209209      HiveClient.StoreAsync(
    210210        new Action<Exception>((Exception ex) => {
    211           refreshableHiveExperiment.ExecutionState = ExecutionState.Prepared;
     211          refreshableJob.ExecutionState = ExecutionState.Prepared;
    212212          exceptionCallback(ex);
    213         }), refreshableHiveExperiment, cancellationToken);
    214       refreshableHiveExperiment.ExecutionState = ExecutionState.Started;
    215     }
    216 
    217     public static void PauseExperiment(RefreshableHiveExperiment refreshableHiveExperiment) {
     213        }), refreshableJob, cancellationToken);
     214      refreshableJob.ExecutionState = ExecutionState.Started;
     215    }
     216
     217    public static void PauseExperiment(RefreshableJob refreshableHiveExperiment) {
    218218      ServiceLocator.Instance.CallHiveService(service => {
    219         foreach (HiveJob job in refreshableHiveExperiment.GetAllHiveJobs()) {
    220           if (job.Job.State != TaskState.Finished && job.Job.State != TaskState.Aborted && job.Job.State != TaskState.Failed)
    221             service.PauseJob(job.Job.Id);
     219        foreach (HiveTask job in refreshableHiveExperiment.GetAllHiveJobs()) {
     220          if (job.Task.State != TaskState.Finished && job.Task.State != TaskState.Aborted && job.Task.State != TaskState.Failed)
     221            service.PauseJob(job.Task.Id);
    222222        }
    223223      });
     
    225225    }
    226226
    227     public static void StopExperiment(RefreshableHiveExperiment refreshableHiveExperiment) {
     227    public static void StopExperiment(RefreshableJob refreshableJob) {
    228228      ServiceLocator.Instance.CallHiveService(service => {
    229         foreach (HiveJob job in refreshableHiveExperiment.GetAllHiveJobs()) {
    230           if (job.Job.State != TaskState.Finished && job.Job.State != TaskState.Aborted && job.Job.State != TaskState.Failed)
    231             service.StopJob(job.Job.Id);
     229        foreach (HiveTask job in refreshableJob.GetAllHiveJobs()) {
     230          if (job.Task.State != TaskState.Finished && job.Task.State != TaskState.Aborted && job.Task.State != TaskState.Failed)
     231            service.StopJob(job.Task.Id);
    232232        }
    233233      });
     
    239239    private static object jobCountLocker = new object();
    240240    private static object pluginLocker = new object();
    241     private void UploadExperiment(RefreshableHiveExperiment refreshableHiveExperiment, CancellationToken cancellationToken) {
     241    private void UploadExperiment(RefreshableJob refreshableJob, CancellationToken cancellationToken) {
    242242      try {
    243         refreshableHiveExperiment.Progress = new Progress("Connecting to server...");
    244         refreshableHiveExperiment.IsProgressing = true;
    245 
    246         IEnumerable<string> resourceNames = ToResourceNameList(refreshableHiveExperiment.HiveExperiment.ResourceNames);
     243        refreshableJob.Progress = new Progress("Connecting to server...");
     244        refreshableJob.IsProgressing = true;
     245
     246        IEnumerable<string> resourceNames = ToResourceNameList(refreshableJob.Job.ResourceNames);
    247247        var resourceIds = new List<Guid>();
    248248        foreach (var resourceName in resourceNames) {
     
    254254        }
    255255
    256         foreach (OptimizerHiveJob hiveJob in refreshableHiveExperiment.HiveJobs.OfType<OptimizerHiveJob>()) {
     256        foreach (OptimizerHiveTask hiveJob in refreshableJob.HiveJobs.OfType<OptimizerHiveTask>()) {
    257257          hiveJob.SetIndexInParentOptimizerList(null);
    258258        }
    259259
    260         // upload Job
    261         refreshableHiveExperiment.Progress.Status = "Uploading Job...";
    262         refreshableHiveExperiment.HiveExperiment.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddHiveExperiment(refreshableHiveExperiment.HiveExperiment));
    263         bool isPrivileged = refreshableHiveExperiment.HiveExperiment.IsPrivileged;
    264         refreshableHiveExperiment.HiveExperiment = ServiceLocator.Instance.CallHiveService((s) => s.GetHiveExperiment(refreshableHiveExperiment.HiveExperiment.Id)); // update owner and permissions
    265         refreshableHiveExperiment.HiveExperiment.IsPrivileged = isPrivileged;
    266         cancellationToken.ThrowIfCancellationRequested();
    267 
    268         int totalJobCount = refreshableHiveExperiment.GetAllHiveJobs().Count();
     260        // upload Task
     261        refreshableJob.Progress.Status = "Uploading Task...";
     262        refreshableJob.Job.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddHiveExperiment(refreshableJob.Job));
     263        bool isPrivileged = refreshableJob.Job.IsPrivileged;
     264        refreshableJob.Job = ServiceLocator.Instance.CallHiveService((s) => s.GetHiveExperiment(refreshableJob.Job.Id)); // update owner and permissions
     265        refreshableJob.Job.IsPrivileged = isPrivileged;
     266        cancellationToken.ThrowIfCancellationRequested();
     267
     268        int totalJobCount = refreshableJob.GetAllHiveJobs().Count();
    269269        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
    270270        cancellationToken.ThrowIfCancellationRequested();
    271271
    272272        // upload plugins
    273         refreshableHiveExperiment.Progress.Status = "Uploading plugins...";
     273        refreshableJob.Progress.Status = "Uploading plugins...";
    274274        this.OnlinePlugins = ServiceLocator.Instance.CallHiveService((s) => s.GetPlugins());
    275275        this.AlreadyUploadedPlugins = new List<Plugin>();
     
    278278        cancellationToken.ThrowIfCancellationRequested();
    279279
    280         if (refreshableHiveExperiment.RefreshAutomatically) refreshableHiveExperiment.StartResultPolling();
     280        if (refreshableJob.RefreshAutomatically) refreshableJob.StartResultPolling();
    281281
    282282        // upload jobs
    283         refreshableHiveExperiment.Progress.Status = "Uploading jobs...";
     283        refreshableJob.Progress.Status = "Uploading jobs...";
    284284
    285285        var tasks = new List<TS.Task>();
    286         foreach (HiveJob hiveJob in refreshableHiveExperiment.HiveJobs) {
     286        foreach (HiveTask hiveJob in refreshableJob.HiveJobs) {
    287287          tasks.Add(TS.Task.Factory.StartNew((hj) => {
    288             UploadJobWithChildren(refreshableHiveExperiment.Progress, (HiveJob)hj, null, resourceIds, jobCount, totalJobCount, configFilePlugin.Id, refreshableHiveExperiment.HiveExperiment.Id, refreshableHiveExperiment.Log, refreshableHiveExperiment.HiveExperiment.IsPrivileged, cancellationToken);
     288            UploadJobWithChildren(refreshableJob.Progress, (HiveTask)hj, null, resourceIds, jobCount, totalJobCount, configFilePlugin.Id, refreshableJob.Job.Id, refreshableJob.Log, refreshableJob.Job.IsPrivileged, cancellationToken);
    289289          }, hiveJob)
    290           .ContinueWith((x) => refreshableHiveExperiment.Log.LogException(x.Exception), TaskContinuationOptions.OnlyOnFaulted));
     290          .ContinueWith((x) => refreshableJob.Log.LogException(x.Exception), TaskContinuationOptions.OnlyOnFaulted));
    291291        }
    292292        try {
     
    296296          if (!ae.InnerExceptions.All(e => e is TaskCanceledException)) throw ae; // for some reason the WaitAll throws a AggregateException containg a TaskCanceledException. i don't know where it comes from, however the tasks all finish properly, so for now just ignore it
    297297        }
    298         refreshableHiveExperiment.HiveExperiment.Modified = false;
     298        refreshableJob.Job.Modified = false;
    299299      }
    300300      finally {
    301         refreshableHiveExperiment.IsProgressing = false;
     301        refreshableJob.IsProgressing = false;
    302302      }
    303303    }
     
    331331
    332332    /// <summary>
    333     /// Uploads the given job and all its child-jobs while setting the proper parentJobId values for the childs
     333    /// Uploads the given task and all its child-jobs while setting the proper parentJobId values for the childs
    334334    /// </summary>
    335     /// <param name="parentHiveJob">shall be null if its the root job</param>
    336     private void UploadJobWithChildren(IProgress progress, HiveJob hiveJob, HiveJob parentHiveJob, IEnumerable<Guid> groups, int[] jobCount, int totalJobCount, Guid configPluginId, Guid hiveExperimentId, ILog log, bool isPrivileged, CancellationToken cancellationToken) {
     335    /// <param name="parentHiveTask">shall be null if its the root task</param>
     336    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) {
    337337      jobUploadSemaphore.WaitOne();
    338338      bool semaphoreReleased = false;
     
    345345        List<IPluginDescription> plugins;
    346346
    347         if (hiveJob.ItemJob.ComputeInParallel && (hiveJob.ItemJob.Item is Optimization.Experiment || hiveJob.ItemJob.Item is Optimization.BatchRun)) {
    348           hiveJob.Job.IsParentJob = true;
    349           hiveJob.Job.FinishWhenChildJobsFinished = true;
    350           jobData = hiveJob.GetAsJobData(true, out plugins);
     347        if (hiveJob.ItemTask.ComputeInParallel && (hiveJob.ItemTask.Item is Optimization.Experiment || hiveJob.ItemTask.Item is Optimization.BatchRun)) {
     348          hiveJob.Task.IsParentTask = true;
     349          hiveJob.Task.FinishWhenChildJobsFinished = true;
     350          jobData = hiveJob.GetAsTaskData(true, out plugins);
    351351        } else {
    352           hiveJob.Job.IsParentJob = false;
    353           hiveJob.Job.FinishWhenChildJobsFinished = false;
    354           jobData = hiveJob.GetAsJobData(false, out plugins);
     352          hiveJob.Task.IsParentTask = false;
     353          hiveJob.Task.FinishWhenChildJobsFinished = false;
     354          jobData = hiveJob.GetAsTaskData(false, out plugins);
    355355        }
    356356        cancellationToken.ThrowIfCancellationRequested();
     
    359359          if (!cancellationToken.IsCancellationRequested) {
    360360            lock (pluginLocker) {
    361               ServiceLocator.Instance.CallHiveService((s) => hiveJob.Job.PluginsNeededIds = PluginUtil.GetPluginDependencies(s, this.onlinePlugins, this.alreadyUploadedPlugins, plugins));
     361              ServiceLocator.Instance.CallHiveService((s) => hiveJob.Task.PluginsNeededIds = PluginUtil.GetPluginDependencies(s, this.onlinePlugins, this.alreadyUploadedPlugins, plugins));
    362362            }
    363363          }
    364364        }, -1, "Failed to upload plugins");
    365365        cancellationToken.ThrowIfCancellationRequested();
    366         hiveJob.Job.PluginsNeededIds.Add(configPluginId);
    367         hiveJob.Job.JobId = hiveExperimentId;
    368         hiveJob.Job.IsPrivileged = isPrivileged;
    369 
    370         log.LogMessage(string.Format("Uploading job ({0} kb, {1} objects)", jobData.Data.Count() / 1024, hiveJob.ItemJob.GetObjectGraphObjects().Count()));
     366        hiveJob.Task.PluginsNeededIds.Add(configPluginId);
     367        hiveJob.Task.JobId = hiveExperimentId;
     368        hiveJob.Task.IsPrivileged = isPrivileged;
     369
     370        log.LogMessage(string.Format("Uploading task ({0} kb, {1} objects)", jobData.Data.Count() / 1024, hiveJob.ItemTask.GetObjectGraphObjects().Count()));
    371371        TryAndRepeat(() => {
    372372          if (!cancellationToken.IsCancellationRequested) {
    373373            if (parentHiveJob != null) {
    374               hiveJob.Job.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddChildJob(parentHiveJob.Job.Id, hiveJob.Job, jobData));
     374              hiveJob.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddChildJob(parentHiveJob.Task.Id, hiveJob.Task, jobData));
    375375            } else {
    376               hiveJob.Job.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddJob(hiveJob.Job, jobData, groups.ToList()));
     376              hiveJob.Task.Id = ServiceLocator.Instance.CallHiveService((s) => s.AddJob(hiveJob.Task, jobData, groups.ToList()));
    377377            }
    378378          }
    379         }, 50, "Failed to add job", log);
     379        }, 50, "Failed to add task", log);
    380380        cancellationToken.ThrowIfCancellationRequested();
    381381
    382382        lock (jobCountLocker) {
    383383          progress.ProgressValue = (double)jobCount[0] / totalJobCount;
    384           progress.Status = string.Format("Uploaded job ({0} of {1})", jobCount[0], totalJobCount);
     384          progress.Status = string.Format("Uploaded task ({0} of {1})", jobCount[0], totalJobCount);
    385385        }
    386386
    387387        var tasks = new List<TS.Task>();
    388         foreach (HiveJob child in hiveJob.ChildHiveJobs) {
     388        foreach (HiveTask child in hiveJob.ChildHiveTasks) {
    389389          tasks.Add(TS.Task.Factory.StartNew((tuple) => {
    390             var arguments = (Tuple<HiveJob, HiveJob>)tuple;
     390            var arguments = (Tuple<HiveTask, HiveTask>)tuple;
    391391            UploadJobWithChildren(progress, arguments.Item1, arguments.Item2, groups, jobCount, totalJobCount, configPluginId, hiveExperimentId, log, isPrivileged, cancellationToken);
    392           }, new Tuple<HiveJob, HiveJob>(child, hiveJob))
     392          }, new Tuple<HiveTask, HiveTask>(child, hiveJob))
    393393          .ContinueWith((x) => log.LogException(x.Exception), TaskContinuationOptions.OnlyOnFaulted));
    394394        }
     
    408408
    409409    #region Download Experiment
    410     public static void LoadExperiment(RefreshableHiveExperiment refreshableHiveExperiment) {
    411       var hiveExperiment = refreshableHiveExperiment.HiveExperiment;
    412       refreshableHiveExperiment.Progress = new Progress();
     410    public static void LoadExperiment(RefreshableJob refreshableJob) {
     411      var hiveExperiment = refreshableJob.Job;
     412      refreshableJob.Progress = new Progress();
    413413
    414414      try {
    415         refreshableHiveExperiment.IsProgressing = true;
     415        refreshableJob.IsProgressing = true;
    416416        int totalJobCount = 0;
    417417        IEnumerable<LightweightTask> allJobs;
    418418
    419         refreshableHiveExperiment.Progress.Status = "Connecting to Server...";
    420         // fetch all Task objects to create the full tree of tree of HiveJob objects
    421         refreshableHiveExperiment.Progress.Status = "Downloading list of jobs...";
     419        refreshableJob.Progress.Status = "Connecting to Server...";
     420        // fetch all Task objects to create the full tree of tree of HiveTask objects
     421        refreshableJob.Progress.Status = "Downloading list of jobs...";
    422422        allJobs = ServiceLocator.Instance.CallHiveService(s => s.GetLightweightExperimentJobs(hiveExperiment.Id));
    423423        totalJobCount = allJobs.Count();
    424424
    425         HiveJobDownloader downloader = new HiveJobDownloader(allJobs.Select(x => x.Id));
     425        TaskDownloader downloader = new TaskDownloader(allJobs.Select(x => x.Id));
    426426        downloader.StartAsync();
    427427
    428428        while (!downloader.IsFinished) {
    429           refreshableHiveExperiment.Progress.ProgressValue = downloader.FinishedCount / (double)totalJobCount;
    430           refreshableHiveExperiment.Progress.Status = string.Format("Downloading/deserializing jobs... ({0}/{1} finished)", downloader.FinishedCount, totalJobCount);
     429          refreshableJob.Progress.ProgressValue = downloader.FinishedCount / (double)totalJobCount;
     430          refreshableJob.Progress.Status = string.Format("Downloading/deserializing jobs... ({0}/{1} finished)", downloader.FinishedCount, totalJobCount);
    431431          Thread.Sleep(500);
    432432
     
    435435          }
    436436        }
    437         IDictionary<Guid, HiveJob> allHiveJobs = downloader.Results;
    438 
    439         refreshableHiveExperiment.HiveJobs = new ItemCollection<HiveJob>(allHiveJobs.Values.Where(x => !x.Job.ParentTaskId.HasValue));
    440 
    441         if (refreshableHiveExperiment.IsFinished()) {
    442           refreshableHiveExperiment.ExecutionState = Core.ExecutionState.Stopped;
     437        IDictionary<Guid, HiveTask> allHiveJobs = downloader.Results;
     438
     439        refreshableJob.HiveJobs = new ItemCollection<HiveTask>(allHiveJobs.Values.Where(x => !x.Task.ParentTaskId.HasValue));
     440
     441        if (refreshableJob.IsFinished()) {
     442          refreshableJob.ExecutionState = Core.ExecutionState.Stopped;
    443443        } else {
    444           refreshableHiveExperiment.ExecutionState = Core.ExecutionState.Started;
    445         }
    446 
    447         // build child-job tree
    448         foreach (HiveJob hiveJob in refreshableHiveExperiment.HiveJobs) {
     444          refreshableJob.ExecutionState = Core.ExecutionState.Started;
     445        }
     446
     447        // build child-task tree
     448        foreach (HiveTask hiveJob in refreshableJob.HiveJobs) {
    449449          BuildHiveJobTree(hiveJob, allJobs, allHiveJobs);
    450450        }
    451451
    452         refreshableHiveExperiment.OnLoaded();
     452        refreshableJob.OnLoaded();
    453453      }
    454454      finally {
    455         refreshableHiveExperiment.IsProgressing = false;
    456       }
    457     }
    458 
    459     private static void BuildHiveJobTree(HiveJob parentHiveJob, IEnumerable<LightweightTask> allJobs, IDictionary<Guid, HiveJob> allHiveJobs) {
     455        refreshableJob.IsProgressing = false;
     456      }
     457    }
     458
     459    private static void BuildHiveJobTree(HiveTask parentHiveJob, IEnumerable<LightweightTask> allJobs, IDictionary<Guid, HiveTask> allHiveJobs) {
    460460      IEnumerable<LightweightTask> childJobs = from job in allJobs
    461                                                where job.ParentTaskId.HasValue && job.ParentTaskId.Value == parentHiveJob.Job.Id
     461                                               where job.ParentTaskId.HasValue && job.ParentTaskId.Value == parentHiveJob.Task.Id
    462462                                               orderby job.DateCreated ascending
    463463                                               select job;
    464464      foreach (LightweightTask job in childJobs) {
    465         HiveJob childHiveJob = allHiveJobs[job.Id];
     465        HiveTask childHiveJob = allHiveJobs[job.Id];
    466466        parentHiveJob.AddChildHiveJob(childHiveJob);
    467467        BuildHiveJobTree(childHiveJob, allJobs, allHiveJobs);
     
    481481    }
    482482
    483     public static ItemJob LoadItemJob(Guid jobId) {
     483    public static ItemTask LoadItemJob(Guid jobId) {
    484484      TaskData jobData = ServiceLocator.Instance.CallHiveService(s => s.GetJobData(jobId));
    485485      try {
    486         return PersistenceUtil.Deserialize<ItemJob>(jobData.Data);
     486        return PersistenceUtil.Deserialize<ItemTask>(jobData.Data);
    487487      }
    488488      catch {
Note: See TracChangeset for help on using the changeset viewer.