source: branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.4/ExperimentManager/JobDownloader.cs @ 6168

using System;
using System.Threading;
using System.Threading.Tasks;
using HeuristicLab.Hive;

namespace HeuristicLab.Clients.Hive {
  /// <summary>
  /// Downloads and deserializes jobs. It avoids too many jobs beeing downloaded or deserialized at the same time to avoid memory problems
  /// </summary>
  public class JobDownloader<T> where T : class, IJob {
    private bool abort = false;
    // use semaphore to ensure only few concurrenct connections and few SerializedJob objects in memory
    private Semaphore downloadSemaphore;
    private Semaphore deserializeSemaphore;
    
    public JobDownloader(int concurrentDownloads, int concurrentDeserializations) {
      downloadSemaphore = new Semaphore(concurrentDownloads, concurrentDownloads);
      deserializeSemaphore = new Semaphore(concurrentDeserializations, concurrentDeserializations);
      TaskScheduler.UnobservedTaskException += new EventHandler<UnobservedTaskExceptionEventArgs>(TaskScheduler_UnobservedTaskException);
    }

    public void DownloadJob(Guid jobId, Action<Guid, T, Exception> onFinishedAction) {
      Task<JobData>.Factory.StartNew((x) => DownloadJob(x), jobId)
                                     .ContinueWith((x) => DeserializeJob(x.Result))
                                     .ContinueWith((x) => OnJobFinished(jobId, x, onFinishedAction), TaskContinuationOptions.ExecuteSynchronously);
    }

    private void OnJobFinished(Guid jobId, Task<T> task, Action<Guid, T, Exception> onFinishedAction) {
      onFinishedAction(jobId, task.Result, task.Exception);
    }

    protected JobData DownloadJob(object jobId) {
      downloadSemaphore.WaitOne();
      deserializeSemaphore.WaitOne();
      JobData result;
      try {
        if (abort) return null;
        result = ServiceLocator.Instance.CallHiveService(s => s.GetJobData((Guid)jobId));
      }
      finally {
        downloadSemaphore.Release();
      }
      return result;
    }

    protected T DeserializeJob(JobData jobData) {
      try {
        Job job = ServiceLocator.Instance.CallHiveService(s => s.GetJob(jobData.JobId));
        if (abort || job == null || jobData == null) return null;
        var deserializedJob = PersistenceUtil.Deserialize<T>(jobData.Data);
        jobData.Data = null; // reduce memory consumption.
        return deserializedJob;
      }
      finally {
        deserializeSemaphore.Release();
      }
    }

    private void TaskScheduler_UnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e) {
      e.SetObserved(); // avoid crash of process because task crashes. first exception found is handled in Results property
    }
  }
}