source: branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Experiment/3.3/HiveExperiment.cs @ 4333

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Optimization;
using System.Drawing;
using HeuristicLab.Collections;
using System.Collections.Generic;
using HeuristicLab.Hive.Contracts.BusinessObjects;
using System.IO;
using HeuristicLab.Persistence.Default.Xml;
using HeuristicLab.PluginInfrastructure;
using System.Reflection;
using HeuristicLab.Hive.Contracts.Interfaces;
using HeuristicLab.Hive.Contracts;
using System.Threading;
using HeuristicLab.Tracing;
using HeuristicLab.Hive.JobBase;
using System.Diagnostics;
using System.Collections;
using System.ServiceModel;
using HeuristicLab.Hive.Contracts.ResponseObjects;
using HeuristicLab.Hive.Experiment.Properties;

namespace HeuristicLab.Hive.Experiment {
  /// <summary>
  /// An experiment which contains multiple batch runs of algorithms.
  /// </summary>
  [Item(itemName, itemDescription)]
  [Creatable("Testing & Analysis")]
  [StorableClass]
  public class HiveExperiment : NamedItem, IExecutable {
    private const string itemName = "Hive Experiment";
    private const string itemDescription = "A runner for a single experiment, which's algorithms are executed in the Hive.";
    private const int resultPollingIntervalMs = 5000;
    private const int snapshotPollingIntervalMs = 1000;
    private const int maxSnapshotRetries = 20;
    private object locker = new object();

    private System.Timers.Timer timer;
    private bool pausePending, stopPending;
    private bool sendingJobsFinished = false;

    // ensure that only 2 threads can fetch jobresults simultaniously
    private Semaphore fetchJobSemaphore = new Semaphore(2, 2);

    private static object pendingOptimizerMappingsLocker = new object();

    private bool stopResultsPollingPending = false;

    private Thread resultPollingThread;

    private bool isPollingResults;
    public bool IsPollingResults {
      get { return isPollingResults; }
      private set {
        if (isPollingResults != value) {
          isPollingResults = value;
          OnIsPollingResultsChanged();
        }
      }
    }

    public IEnumerable<string> ResourceGroups {
      get {
        if (!string.IsNullOrEmpty(resourceIds)) {
          return resourceIds.Split(';');
        } else {
          return new List<string>();
        }
      }
    }

    #region Storable Properties
    [Storable]
    private DateTime lastUpdateTime;

    /// <summary>
    /// Mapping from JobId to an optimizer.
    /// Stores all pending optimizers. If an optimizer is finished it is removed from this collection
    /// </summary>
    [Storable]
    private IDictionary<Guid, IOptimizer> pendingOptimizersByJobId = new Dictionary<Guid, IOptimizer>();

    /// <summary>
    /// Stores a mapping from the child-optimizer to the parent optimizer.
    /// Needed to replace a finished optimizer in the optimizer-tree.
    /// Only pending optmizers are stored.
    /// </summary>
    [Storable]
    private IDictionary<IOptimizer, IOptimizer> parentOptimizersByPendingOptimizer = new Dictionary<IOptimizer, IOptimizer>();

    [Storable]
    private JobItemList jobItems;
    public JobItemList JobItems {
      get { return jobItems; }
    }

    [Storable]
    private string resourceIds;
    public string ResourceIds {
      get { return resourceIds; }
      set {
        if (resourceIds != value) {
          resourceIds = value;
          OnResourceIdsChanged();
        }
      }
    }

    [Storable]
    private HeuristicLab.Optimization.Experiment experiment;
    public HeuristicLab.Optimization.Experiment Experiment {
      get { return experiment; }
      set {
        if (experiment != value) {
          experiment = value;
          OnExperimentChanged();
        }
      }
    }

    [Storable]
    private ILog log;
    public ILog Log {
      get { return log; }
    }

    [Storable]
    private Core.ExecutionState executionState;
    public ExecutionState ExecutionState {
      get { return executionState; }
      private set {
        if (executionState != value) {
          executionState = value;
          OnExecutionStateChanged();
        }
      }
    }

    [Storable]
    private TimeSpan executionTime;
    public TimeSpan ExecutionTime {
      get { return executionTime; }
      private set {
        if (executionTime != value) {
          executionTime = value;
          OnExecutionTimeChanged();
        }
      }
    }
    #endregion

    [StorableConstructor]
    public HiveExperiment(bool deserializing)
      : base(deserializing) {
    }

    public HiveExperiment()
      : base(itemName, itemDescription) {
      this.ResourceIds = HeuristicLab.Hive.Experiment.Properties.Settings.Default.ResourceIds;
      this.log = new Log();
      pausePending = stopPending = false;
      jobItems = new JobItemList();
      isPollingResults = false;
      RegisterJobItemListEvents();
      InitTimer();
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      LogMessage("I am beeing cloned");
      HiveExperiment clone = (HiveExperiment)base.Clone(cloner);
      clone.resourceIds = this.resourceIds;
      clone.experiment = (HeuristicLab.Optimization.Experiment)cloner.Clone(experiment);
      clone.executionState = this.executionState;
      clone.executionTime = this.executionTime;
      clone.pendingOptimizersByJobId = new Dictionary<Guid, IOptimizer>();

      lock (pendingOptimizerMappingsLocker) {
        foreach (var pair in this.pendingOptimizersByJobId)
          clone.pendingOptimizersByJobId[pair.Key] = (IOptimizer)cloner.Clone(pair.Value);

        foreach (var pair in this.parentOptimizersByPendingOptimizer)
          clone.parentOptimizersByPendingOptimizer[(IOptimizer)cloner.Clone(pair.Key)] = (IOptimizer)cloner.Clone(pair.Value);
      }
      clone.log = (ILog)cloner.Clone(log);
      clone.stopPending = this.stopPending;
      clone.pausePending = this.pausePending;
      clone.jobItems.AddRange((JobItemList)cloner.Clone(jobItems));
      clone.lastUpdateTime = this.lastUpdateTime;
      clone.isPollingResults = this.isPollingResults;
      return clone;
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      InitTimer();
      this.IsPollingResults = false;
      this.stopResultsPollingPending = false;
      RegisterJobItemListEvents();
      LogMessage("I was deserialized.");
    }

    #region Execution Time Timer
    private void InitTimer() {
      timer = new System.Timers.Timer(100);
      timer.AutoReset = true;
      timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
    }

    private void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) {
      DateTime now = DateTime.Now;
      ExecutionTime += now - lastUpdateTime;
      lastUpdateTime = now;
    }
    #endregion

    #region IExecutable Methods
    public void Pause() {
      throw new NotSupportedException();
    }

    public void Prepare() {
      if (experiment != null) {
        StopResultPolling();
        lock (pendingOptimizerMappingsLocker) {
          pendingOptimizersByJobId.Clear();
          parentOptimizersByPendingOptimizer.Clear();
        }
        lock (jobItems) {
          jobItems.Clear();
        }
        experiment.Prepare();
        this.ExecutionState = Core.ExecutionState.Prepared;
        OnPrepared();
      }
    }

    public void Start() {
      sendingJobsFinished = false;
      OnStarted();
      ExecutionTime = new TimeSpan();
      lastUpdateTime = DateTime.Now;
      this.ExecutionState = Core.ExecutionState.Started;
      StartResultPolling();

      Thread t = new Thread(() => {
        IClientFacade clientFacade = CreateStreamedClientFacade();

        try {
          pendingOptimizersByJobId = new Dictionary<Guid, IOptimizer>();

          LogMessage("Extracting jobs from Experiment");
          parentOptimizersByPendingOptimizer = GetOptimizers(true);
          LogMessage("Extraction of jobs from Experiment finished");

          IEnumerable<string> groups = ResourceGroups;
          lock (pendingOptimizerMappingsLocker) {
            foreach (IOptimizer optimizer in parentOptimizersByPendingOptimizer.Keys) {
              SerializedJob serializedJob = CreateSerializedJob(optimizer);
              ResponseObject<JobDto> response = clientFacade.AddJobWithGroupStrings(serializedJob, groups);
              pendingOptimizersByJobId.Add(response.Obj.Id, optimizer);

              JobItem jobItem = new JobItem() {
                JobDto = response.Obj,
                LatestSnapshot = null,
                Optimizer = optimizer
              };
              lock (jobItems) {
                jobItems.Add(jobItem);
              }
              LogMessage(jobItem.JobDto.Id, "Job sent to Hive");
            }
          }
        }
        catch (Exception e) {
          LogMessage("Error: Starting HiveExperiment failed: " + e.Message);
          this.ExecutionState = Core.ExecutionState.Stopped;
          OnStopped();
        }
        finally {
          ServiceLocator.DisposeClientFacade(clientFacade);
        }

        sendingJobsFinished = true;
      });
      t.Start();
    }

    public void Stop() {
      this.ExecutionState = Core.ExecutionState.Stopped;
      foreach (JobItem jobItem in jobItems) {
        AbortJob(jobItem.JobDto.Id);
      }
      OnStopped();
    }
    #endregion

    #region Optimizier Management
    /// <summary>
    /// Returns all optimizers in the current Experiment
    /// </summary>
    /// <param name="flatout">if false only top level optimizers are returned, if true the optimizer-tree is flatted</param>
    /// <returns></returns>
    private IDictionary<IOptimizer, IOptimizer> GetOptimizers(bool flatout) {
      if (!flatout) {
        var optimizers = new Dictionary<IOptimizer, IOptimizer>();
        foreach (IOptimizer opt in experiment.Optimizers) {
          optimizers.Add(experiment, opt);
        }
        return optimizers;
      } else {
        return FlatOptimizerTree(null, experiment, "");
      }
    }

    /// <summary>
    /// Recursively iterates all IOptimizers in the optimizer-tree and returns them.
    /// 
    /// [chn] this could be implemented more cleanly if Experiment and BatchRun would implement an interface like:
    /// interface IParallelizable {
    ///   IEnumerable&lt;IOptimizer&gt; GetOptimizers();
    /// }
    /// </summary>
    /// <returns>a dictionary mapping from the parent optimizer to the child optimizer</returns>
    private IDictionary<IOptimizer, IOptimizer> FlatOptimizerTree(IOptimizer parent, IOptimizer optimizer, string prepend) {
      IDictionary<IOptimizer, IOptimizer> optimizers = new Dictionary<IOptimizer, IOptimizer>();
      if (optimizer is HeuristicLab.Optimization.Experiment) {
        HeuristicLab.Optimization.Experiment experiment = optimizer as HeuristicLab.Optimization.Experiment;
        if (this.experiment != experiment) {
          prepend += experiment.Name + "/"; // don't prepend for top-level optimizers
        }
        foreach (IOptimizer opt in experiment.Optimizers) {
          AddRange(optimizers, FlatOptimizerTree(experiment, opt, prepend));
        }
      } else if (optimizer is BatchRun) {
        BatchRun batchRun = optimizer as BatchRun;
        prepend += batchRun.Name + "/";
        for (int i = 0; i < batchRun.Repetitions; i++) {
          IOptimizer opt = (IOptimizer)batchRun.Algorithm.Clone();
          opt.Name += " [" + i + "]";
          IDictionary<IOptimizer, IOptimizer> batchOptimizers = FlatOptimizerTree(batchRun, opt, prepend);
          AddRange(optimizers, batchOptimizers);
        }
      } else if (optimizer is EngineAlgorithm) {
        optimizer.Name = prepend + optimizer.Name;
        optimizers.Add(optimizer, parent);
        LogMessage("Optimizer extracted: " + optimizer.Name);
      } else {
        Logger.Warn("Optimizer of type " + optimizers.GetType().ToString() + " unknown");
        optimizer.Name = prepend + optimizer.Name;
        optimizers.Add(optimizer, parent);
        LogMessage("Optimizer extracted: " + optimizer.Name);
      }
      return optimizers;
    }

    private void ReplaceOptimizer(IOptimizer parentOptimizer, IOptimizer originalOptimizer, IOptimizer newOptimizer) {
      lock (locker) {
        if (parentOptimizer is HeuristicLab.Optimization.Experiment) {
          HeuristicLab.Optimization.Experiment exp = (HeuristicLab.Optimization.Experiment)parentOptimizer;
          int originalOptimizerIndex = exp.Optimizers.IndexOf(originalOptimizer);
          exp.Optimizers[originalOptimizerIndex] = newOptimizer;
        } else if (parentOptimizer is BatchRun) {
          BatchRun batchRun = (BatchRun)parentOptimizer;
          if (newOptimizer is IAlgorithm) {
            batchRun.Runs.Add(new Run(newOptimizer.Name, (IAlgorithm)newOptimizer));
          } else {
            throw new NotSupportedException("Only IAlgorithm types supported");
          }
        } else {
          throw new NotSupportedException("Invalid parentOptimizer");
        }
      }
    }

    private bool NoMorePendingOptimizers() {
      lock (pendingOptimizerMappingsLocker) {
        return pendingOptimizersByJobId.Count == 0;
      }
    }

    /// <summary>
    /// Removes optimizers from
    ///  - parentOptimizersByPendingOptimizer
    ///  - pendingOptimizersByJobId
    /// </summary>
    /// <param name="jobId"></param>
    private void DisposeOptimizerMappings(Guid jobId) {
      LogMessage(jobId, "Disposing Optimizer Mappings");
      lock (pendingOptimizerMappingsLocker) {
        parentOptimizersByPendingOptimizer.Remove(pendingOptimizersByJobId[jobId]);
        pendingOptimizersByJobId.Remove(jobId);
      }
    }

    #endregion

    #region Job Management
    /// <summary>
    /// Updates all JobItems with the results
    /// </summary>
    /// <param name="jobResultList"></param>
    private void UpdateJobItems(JobResultList jobResultList) {
      // use a Dict to avoid quadratic runtime complexity
      IDictionary<Guid, JobResult> jobResultDict = jobResultList.ToDictionary(job => job.JobId);
      lock (jobItems) {
        foreach (JobItem jobItem in JobItems) {
          if (jobResultDict.ContainsKey(jobItem.JobDto.Id)) {
            jobItem.JobResult = jobResultDict[jobItem.JobDto.Id];
          }
        }
      }
    }

    private void JobItem_JobStateChanged(object sender, EventArgs e) {
      JobItem jobItem = (JobItem)sender;

      Thread t = new Thread(() => {
        try {
          if (jobItem.State == JobState.Finished) {
            FetchAndUpdateJob(jobItem.JobDto.Id);
            DisposeOptimizerMappings(jobItem.JobDto.Id);
          } else if (jobItem.State == JobState.Failed) {
            DisposeOptimizerMappings(jobItem.JobDto.Id);
          }

          if (NoMorePendingOptimizers()) {
            StopResultPolling();
            this.ExecutionState = Core.ExecutionState.Stopped;
            OnStopped();
          }
        }
        catch (Exception ex) {
          Logger.Error("JobItem_JobStateChanged failed badly: " + ex.Message);
          LogMessage("JobItem_JobStateChanged failed badly: " + ex.Message);
        }
      });
      t.Start();
    }

    /// <summary>
    /// Fetches the finished job from the server and updates the jobItem
    /// </summary>
    private void FetchAndUpdateJob(Guid jobId) {
      bool tryagain = false;
      LogMessage(jobId, "FetchAndUpdateJob started");
      if (fetchJobSemaphore.WaitOne(new TimeSpan(0, 2, 0))) {
        IClientFacade clientFacade = null;
        try {
          clientFacade = CreateStreamedClientFacade();
          IOptimizer originalOptimizer;
          originalOptimizer = pendingOptimizersByJobId[jobId];

          ResponseObject<SerializedJob> jobResponse = clientFacade.GetLastSerializedResult(jobId, false, false);
          IJob restoredObject = XmlParser.Deserialize<IJob>(new MemoryStream(jobResponse.Obj.SerializedJobData));
          IOptimizer restoredOptimizer = ((OptimizerJob)restoredObject).Optimizer;
          ReplaceOptimizer(parentOptimizersByPendingOptimizer[originalOptimizer], originalOptimizer, restoredOptimizer);
          LogMessage(jobId, "FetchAndUpdateJob ended");
        }
        catch (Exception e) {
          LogMessage(jobId, "FetchAndUpdateJob failed: " + e.Message + ". Will try again!");
          tryagain = true;
        }
        finally {
          ServiceLocator.DisposeClientFacade(clientFacade);
          fetchJobSemaphore.Release();
        }
      } else {
        LogMessage(jobId, "FetchAndUpdateJob timed out. Will try again!");
        tryagain = true;
      }

      if (tryagain) {
        FetchAndUpdateJob(jobId);
      }
    }

    private void UpdateJobItem(JobDto jobDto) {
      JobItem jobItem = jobItems.Single(x => x.JobDto.Id == jobDto.Id);
      jobItem.JobDto = jobDto;
    }

    public void AbortJob(Guid jobId) {
      IClientFacade clientFacade = CreateClientFacade();
      Response response = clientFacade.AbortJob(jobId);
      LogMessage(jobId, "Aborting Job: " + response.StatusMessage);
    }

    private SerializedJob CreateSerializedJob(IOptimizer optimizer) {
      IJob job = new OptimizerJob() {
        Optimizer = optimizer
      };

      // serialize job
      MemoryStream memStream = new MemoryStream();
      XmlGenerator.Serialize(job, memStream);
      byte[] jobByteArray = memStream.ToArray();
      memStream.Dispose();

      // find out which which plugins are needed for the given object
      List<HivePluginInfoDto> pluginsNeeded = (
        from p in GetDeclaringPlugins(job.GetType())
        select new HivePluginInfoDto() {
          Name = p.Name,
          Version = p.Version
        }).ToList();

      JobDto jobDto = new JobDto() {
        CoresNeeded = 1, // [chn] how to determine real cores needed?
        PluginsNeeded = pluginsNeeded,
        State = JobState.Offline,
        MemoryNeeded = 0
      };

      SerializedJob serializedJob = new SerializedJob() {
        JobInfo = jobDto,
        SerializedJobData = jobByteArray
      };

      return serializedJob;
    }

    private JobItem GetJobItemById(Guid jobId) {
      return jobItems.Single(x => x.JobDto.Id == jobId);
    }
    #endregion

    #region Result Polling
    public void StartResultPolling() {
      this.stopResultsPollingPending = false;
      this.IsPollingResults = true;
      resultPollingThread = CreateResultPollingThread();
      if (resultPollingThread.ThreadState != System.Threading.ThreadState.Running)
        resultPollingThread.Start();
    }

    public void StopResultPolling() {
      this.stopResultsPollingPending = true;
      if (resultPollingThread != null && resultPollingThread.ThreadState == System.Threading.ThreadState.WaitSleepJoin) {
        resultPollingThread.Interrupt();
      }
      this.stopResultsPollingPending = false;
    }

    private Thread CreateResultPollingThread() {
      return new Thread(() => {
        try {
          do {
            IClientFacade clientFacade = CreateStreamedClientFacade();
            IEnumerable<Guid> jobIdsToQuery = from job in JobItems
                                              where job.State != JobState.Finished &&
                                              job.State != JobState.Failed
                                              select job.JobDto.Id;
            if (jobIdsToQuery.Count() > 0) {
              LogMessage("Polling results for " + jobIdsToQuery.Count() + " jobs");
              try {
                ResponseObject<JobResultList> response = clientFacade.GetJobResults(jobIdsToQuery);
                if (response.StatusMessage == ResponseStatus.Ok) {
                  JobResultList jobItemList = response.Obj;
                  UpdateJobItems(jobItemList);

                  LogMessage("Polling successfully finished");
                } else {
                  throw new Exception(response.StatusMessage.ToString());
                }
              }
              catch (Exception e) {
                LogMessage("Polling results failed: " + e.Message);
              }
              finally {
                ServiceLocator.DisposeClientFacade(clientFacade);
              }
              Thread.Sleep(resultPollingIntervalMs);
            } else {
              if (sendingJobsFinished) {
                // all the jobs have been sent to hive, but non are to query any more (all finished or failed)
                this.stopResultsPollingPending = true;
              }
            }
          } while (!this.stopResultsPollingPending);
        }
        catch (ThreadInterruptedException exception) {
          // thread has been interuppted
        }
        catch (Exception e) {
          LogMessage("Result Polling Thread failed badly: " + e.Message);
          Logger.Error("Result Polling Thread failed badly: " + e.Message);
        }
        finally {
          this.IsPollingResults = false;
        }
      });
    }

    #endregion

    #region Snapshots

    private void UpdateSnapshot(ResponseObject<SerializedJob> response) {
      JobItem jobItem = jobItems.Single(x => x.JobDto.Id == response.Obj.JobInfo.Id);
      jobItem.LatestSnapshot = response;
    }

    public void RequestSnapshot(Guid jobId) {
      Thread t = new Thread(() => {
        IClientFacade clientFacade = null;
        try {
          clientFacade = CreateStreamedClientFacade();

          ResponseObject<SerializedJob> response;
          int retryCount = 0;

          Response snapShotResponse = clientFacade.RequestSnapshot(jobId);
          if (snapShotResponse.StatusMessage == ResponseStatus.RequestSnapshot_JobIsNotBeeingCalculated) {
            // job already finished
            Logger.Debug("HiveExperiment: Abort - GetLastResult(false)");
            response = clientFacade.GetLastSerializedResult(jobId, false, false);
            Logger.Debug("HiveExperiment: Abort - Server: " + response.StatusMessage);
          } else {
            // server sent snapshot request to client
            // poll until snapshot is ready
            do {
              Thread.Sleep(snapshotPollingIntervalMs);
              Logger.Debug("HiveExperiment: Abort - GetLastResult(true)");
              response = clientFacade.GetLastSerializedResult(jobId, false, true);
              Logger.Debug("HiveExperiment: Abort - Server: " + response.StatusMessage);
              retryCount++;
              // loop while
              // 1. problem with communication with server
              // 2. job result not yet ready
            } while (
              (retryCount < maxSnapshotRetries) && (
              response.StatusMessage == ResponseStatus.GetLastSerializedResult_JobResultNotYetThere)
              );
          }
          if (response.StatusMessage == ResponseStatus.Ok) {
            LogMessage(jobId, "Snapshot polling successfull for job " + jobId);
            UpdateSnapshot(response);
          } else {
            LogMessage(jobId, "Error: Polling of Snapshot failed for job " + jobId + ": " + response.StatusMessage);
          }
        }
        catch (Exception e) {
          LogMessage("RequestSnapshot Thread failed badly: " + e.Message);
          Logger.Error("RequestSnapshot Thread failed badly: " + e.Message);
        }
        finally {
          ServiceLocator.DisposeClientFacade(clientFacade);
        }
      });
      t.Start();
    }

    void JobItem_SnapshotRequestedStateChanged(object sender, EventArgs e) {
      JobItem jobItem = (JobItem)sender;
      if (jobItem.SnapshotRequestedState == SnapshotRequestedState.Requested) {
        RequestSnapshot(jobItem.JobDto.Id);
      }
    }

    #endregion

    #region Required Plugin Search
    /// <summary>
    /// Returns a list of plugins in which the type itself and all members 
    /// of the type are declared. Objectgraph is searched recursively.
    /// </summary>
    private IEnumerable<IPluginDescription> GetDeclaringPlugins(Type type) {
      HashSet<Type> types = new HashSet<Type>();
      FindTypes(type, types, "HeuristicLab.");
      return GetDeclaringPlugins(types);
    }

    /// <summary>
    /// Returns the plugins (including dependencies) in which the given types are declared
    /// </summary>
    private IEnumerable<IPluginDescription> GetDeclaringPlugins(IEnumerable<Type> types) {
      HashSet<IPluginDescription> plugins = new HashSet<IPluginDescription>();
      foreach (Type t in types) {
        FindDeclaringPlugins(ApplicationManager.Manager.GetDeclaringPlugin(t), plugins);
      }
      return plugins;
    }

    /// <summary>
    /// Finds the dependencies of the given plugin and adds it to the plugins hashset.
    /// Also searches the dependencies recursively.
    /// </summary>
    private void FindDeclaringPlugins(IPluginDescription plugin, HashSet<IPluginDescription> plugins) {
      if (!plugins.Contains(plugin)) {
        plugins.Add(plugin);
        foreach (IPluginDescription dependency in plugin.Dependencies) {
          FindDeclaringPlugins(dependency, plugins);
        }
      }
    }

    /// <summary>
    /// Recursively finds all types used in type which are in a namespace which starts with namespaceStart
    /// Be aware that search is not performed on attributes
    /// </summary>
    /// <param name="type">the type to be searched</param>
    /// <param name="types">found types will be stored there, needed in order to avoid duplicates</param>
    /// <param name="namespaceStart">only types from namespaces which start with this will be searched and added</param>
    private void FindTypes(Type type, HashSet<Type> types, string namespaceStart) {
      if (!types.Contains(type) && type.Namespace.StartsWith(namespaceStart)) {
        types.Add(type);

        // constructors
        foreach (ConstructorInfo info in type.GetConstructors()) {
          foreach (ParameterInfo paramInfo in info.GetParameters()) {
            FindTypes(paramInfo.ParameterType, types, namespaceStart);
          }
        }

        // interfaces
        foreach (Type t in type.GetInterfaces()) {
          FindTypes(t, types, namespaceStart);
        }

        // events
        foreach (EventInfo info in type.GetEvents()) {
          FindTypes(info.EventHandlerType, types, namespaceStart);
          FindTypes(info.DeclaringType, types, namespaceStart);
        }

        // properties
        foreach (PropertyInfo info in type.GetProperties()) {
          FindTypes(info.PropertyType, types, namespaceStart);
        }

        // fields
        foreach (FieldInfo info in type.GetFields()) {
          FindTypes(info.FieldType, types, namespaceStart);
        }

        // methods
        foreach (MethodInfo info in type.GetMethods()) {
          foreach (ParameterInfo paramInfo in info.GetParameters()) {
            FindTypes(paramInfo.ParameterType, types, namespaceStart);
          }
          FindTypes(info.ReturnType, types, namespaceStart);
        }
      }
    }
    #endregion

    #region Eventhandler

    public event EventHandler ExecutionTimeChanged;
    private void OnExecutionTimeChanged() {
      EventHandler handler = ExecutionTimeChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler ExecutionStateChanged;
    private void OnExecutionStateChanged() {
      LogMessage("ExecutionState changed to " + executionState.ToString());
      EventHandler handler = ExecutionStateChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;

    public event EventHandler Started;
    private void OnStarted() {
      LogMessage("Started");
      timer.Start();
      EventHandler handler = Started;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler Stopped;
    private void OnStopped() {
      timer.Stop();
      LogMessage("Stopped");
      EventHandler handler = Stopped;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler Paused;
    private void OnPaused() {
      timer.Stop();
      LogMessage("Paused");
      EventHandler handler = Paused;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler Prepared;
    protected virtual void OnPrepared() {
      LogMessage("Prepared");
      EventHandler handler = Prepared;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler ResourceIdsChanged;
    protected virtual void OnResourceIdsChanged() {
      EventHandler handler = ResourceIdsChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler ExperimentChanged;
    protected virtual void OnExperimentChanged() {
      LogMessage("Experiment changed");
      EventHandler handler = ExperimentChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler ServerUrlChanged;
    protected virtual void OnServerUrlChanged() {
      EventHandler handler = ServerUrlChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public event EventHandler IsResultsPollingChanged;
    private void OnIsPollingResultsChanged() {
      if (this.IsPollingResults) {
        LogMessage("Results Polling Started");
        timer.Start();
      } else {
        LogMessage("Results Polling Stopped");
        timer.Stop();
      }
      EventHandler handler = IsResultsPollingChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    private void RegisterJobItemListEvents() {
      jobItems.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<JobItem>>(jobItems_CollectionReset);
      jobItems.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<JobItem>>(jobItems_ItemsAdded);
      jobItems.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<JobItem>>(jobItems_ItemsRemoved);
      jobItems.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<JobItem>>(jobItems_ItemsReplaced);
      foreach (JobItem jobItem in jobItems) {
        RegisterJobItemEvents(jobItem);
      }
    }

    private void DeregisterJobItemListEvents() {
      jobItems.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<JobItem>>(jobItems_CollectionReset);
      jobItems.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<JobItem>>(jobItems_ItemsAdded);
      jobItems.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<JobItem>>(jobItems_ItemsRemoved);
      jobItems.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<JobItem>>(jobItems_ItemsReplaced);
      foreach (JobItem jobItem in jobItems) {
        DeregisterJobItemEvents(jobItem);
      }
    }

    void jobItems_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<JobItem>> e) {
      UpdateJobItemEvents(e);
    }

    private void UpdateJobItemEvents(CollectionItemsChangedEventArgs<IndexedItem<JobItem>> e) {
      if (e.OldItems != null) {
        foreach (var item in e.OldItems) {
          DeregisterJobItemEvents(item.Value);
        }
      }
      if (e.Items != null) {
        foreach (var item in e.Items) {
          RegisterJobItemEvents(item.Value);
        }
      }
    }

    private void RegisterJobItemEvents(JobItem jobItem) {
      jobItem.SnapshotRequestedStateChanged += new EventHandler(JobItem_SnapshotRequestedStateChanged);
      jobItem.JobStateChanged += new EventHandler(JobItem_JobStateChanged);
    }

    private void DeregisterJobItemEvents(JobItem jobItem) {
      jobItem.SnapshotRequestedStateChanged -= new EventHandler(JobItem_SnapshotRequestedStateChanged);
      jobItem.JobStateChanged -= new EventHandler(JobItem_JobStateChanged);
    }

    void jobItems_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<JobItem>> e) {
      UpdateJobItemEvents(e);
    }

    void jobItems_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<JobItem>> e) {
      UpdateJobItemEvents(e);
    }

    void jobItems_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<JobItem>> e) {
      foreach (var item in e.OldItems) {
        item.Value.JobStateChanged -= new EventHandler(JobItem_JobStateChanged);
        item.Value.SnapshotRequestedStateChanged -= new EventHandler(JobItem_SnapshotRequestedStateChanged);
      }
    }
    #endregion

    #region Helper Functions
    private IClientFacade CreateClientFacade() {
      IClientFacade clientFacade = null;
      do {
        try {
          //clientFacade = ServiceLocator.CreateClientFacade(string.Format("http://{0}:{1}/{2}", Settings.Default.HiveServerIp, Settings.Default.HiveServerPort, WcfSettings.ClientServiceName));
          clientFacade = ServiceLocator.CreateClientFacade(Settings.Default.HiveServerIp);

        }
        catch (EndpointNotFoundException exception) {
          LogMessage("Could not connect to Server: " + exception.Message + ". Will try again in " + (resultPollingIntervalMs / 1000) + " sec.");
          Thread.Sleep(resultPollingIntervalMs);
        }
      } while (clientFacade == null && this.ExecutionState != Core.ExecutionState.Stopped);
      return clientFacade;
    }

    private IClientFacade CreateStreamedClientFacade() {
      IClientFacade clientFacade = null;
      do {
        try {
          //clientFacade = ServiceLocator.CreateStreamedClientFacade(string.Format("http://{0}:{1}/{2}", Settings.Default.HiveServerIp, Settings.Default.HiveServerPort, WcfSettings.ClientStreamedServiceName));
          clientFacade = ServiceLocator.CreateStreamedClientFacade(Settings.Default.HiveServerIp);
        }
        catch (EndpointNotFoundException exception) {
          LogMessage("Could not connect to Server: " + exception.Message + ". Will try again in " + (resultPollingIntervalMs / 1000) + " sec.");
          Thread.Sleep(resultPollingIntervalMs);
        }
      } while (clientFacade == null && this.ExecutionState != Core.ExecutionState.Stopped);
      return clientFacade;
    }

    private void AddRange(IDictionary<IOptimizer, IOptimizer> optimizers, IDictionary<IOptimizer, IOptimizer> childs) {
      foreach (KeyValuePair<IOptimizer, IOptimizer> kvp in childs) {
        optimizers.Add(kvp);
      }
    }

    #endregion

    #region Logging
    private void LogMessage(string message) {
      // HeuristicLab.Log is not Thread-Safe, so lock on every call
      lock (locker) {
        log.LogMessage(message);
      }
    }

    private void LogMessage(Guid jobId, string message) {
      GetJobItemById(jobId).LogMessage(message);
      LogMessage(message + " (jobId: " + jobId + ")");
    }

    #endregion
  }
}