Index: branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/HiveClientWeb.cs
===================================================================
--- branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/HiveClientWeb.cs	(revision 13696)
+++ branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/HiveClientWeb.cs	(revision 13712)
@@ -36,4 +36,5 @@
 using HeuristicLab.Clients.Common.Properties;
 using Microsoft.AspNet.Hosting;
+using HeuristicLab.Clients.Hive.WebJobManager.Services.Imports;
 
 namespace HeuristicLab.Clients.Hive.WebJobManager
@@ -320,5 +321,8 @@
                 }
 
-
+                foreach (OptimizerHiveTask hiveJob in refreshableJob.HiveTasks.OfType<OptimizerHiveTask>())
+                {
+                    hiveJob.SetIndexInParentOptimizerList(null);
+                }
 
                 // upload Job
@@ -486,5 +490,5 @@
             var hiveExperiment = refreshableJob.Job;
             refreshableJob.IsProgressing = true;
-            TaskDownloader downloader = null;
+            TaskDownloaderWeb downloader = null;
 
             try
@@ -499,5 +503,5 @@
 
                 refreshableJob.Progress.Status = "Downloading tasks...";
-                downloader = new TaskDownloader(allTasks.Select(x => x.Id));
+                downloader = new TaskDownloaderWeb(allTasks.Select(x => x.Id));
                 downloader.StartAsync();
 
Index: branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/HiveServiceLocatorWebManagerService.cs
===================================================================
--- branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/HiveServiceLocatorWebManagerService.cs	(revision 13696)
+++ branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/HiveServiceLocatorWebManagerService.cs	(revision 13712)
@@ -149,4 +149,15 @@
             binding.AllowCookies = false;
 
+            binding.ReaderQuotas.MaxDepth = 32;
+            binding.ReaderQuotas.MaxStringContentLength = 200000000;
+            binding.ReaderQuotas.MaxArrayLength = 200000000;
+            binding.ReaderQuotas.MaxBytesPerRead = 4096;
+            binding.ReaderQuotas.MaxNameTableCharCount = 16384;
+
+            binding.ReliableSession.Ordered = true;
+            binding.ReliableSession.InactivityTimeout = TimeSpan.Parse("00:10:00");
+            binding.ReliableSession.Enabled = false;
+
+
             binding.Security.Mode = SecurityMode.Message;
             binding.Security.Message.ClientCredentialType = MessageCredentialType.UserName;
Index: branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/Imports/ConcurrentTaskDownloaderWeb.cs
===================================================================
--- branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/Imports/ConcurrentTaskDownloaderWeb.cs	(revision 13712)
+++ branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/Imports/ConcurrentTaskDownloaderWeb.cs	(revision 13712)
@@ -0,0 +1,122 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Threading;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Hive;
+
+namespace HeuristicLab.Clients.Hive.WebJobManager.Services.Imports
+{
+  /// <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 ConcurrentTaskDownloaderWeb<T> : IDisposable where T : class, ITask {
+    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 ConcurrentTaskDownloaderWeb(int concurrentDownloads, int concurrentDeserializations) {
+      downloadSemaphore = new Semaphore(concurrentDownloads, concurrentDownloads);
+      deserializeSemaphore = new Semaphore(concurrentDeserializations, concurrentDeserializations);
+    }
+
+    public void DownloadTaskData(Task t, Action<Task, T> onFinishedAction) {
+      Task<Tuple<Task, T>> task = Task<Tuple<Task, TaskData>>.Factory.StartNew(DownloadTaskData, t)
+                                     .ContinueWith((y) => DeserializeTask(y.Result));
+
+      task.ContinueWith((x) => OnTaskFinished(x, onFinishedAction), TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion);
+      task.ContinueWith((x) => OnTaskFailed(x), TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnFaulted);
+    }
+
+    public void DownloadTaskDataAndTask(Guid taskId, Action<Task, T> onFinishedAction) {
+      Task<Tuple<Task, T>> task = Task<Task>.Factory.StartNew(DownloadTask, taskId)
+                                     .ContinueWith((x) => DownloadTaskData(x.Result))
+                                     .ContinueWith((y) => DeserializeTask(y.Result));
+
+      task.ContinueWith((x) => OnTaskFinished(x, onFinishedAction), TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion);
+      task.ContinueWith((x) => OnTaskFailed(x), TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnFaulted);
+    }
+
+    private void OnTaskFinished(Task<Tuple<Task, T>> task, Action<Task, T> onFinishedAction) {
+      onFinishedAction(task.Result.Item1, task.Result.Item2);
+    }
+    private void OnTaskFailed(Task<Tuple<Task, T>> task) {
+      task.Exception.Flatten().Handle((e) => { return true; });
+      OnExceptionOccured(task.Exception.Flatten());
+    }
+
+    private Task DownloadTask(object taskId) {
+      Task t = null;
+      HiveClientWeb.TryAndRepeat(() => {
+        t = HiveServiceLocatorWebManagerService.Instance.CallHiveService(s => s.GetTask((Guid)taskId));
+      }, Settings.Default.MaxRepeatServiceCalls, "Failed to download task.");
+      return t;
+    }
+
+    protected Tuple<Task, TaskData> DownloadTaskData(object taskId) {
+      return DownloadTaskData((Task)taskId);
+    }
+
+    protected Tuple<Task, TaskData> DownloadTaskData(Task task) {
+      downloadSemaphore.WaitOne();
+      TaskData result = null;
+      try {
+        if (abort) return null;
+        HiveClientWeb.TryAndRepeat(() => {
+          result = HiveServiceLocatorWebManagerService.Instance.CallHiveService(s => s.GetTaskData(task.Id));
+        }, Settings.Default.MaxRepeatServiceCalls, "Failed to download task data.");
+      }
+      finally {
+        downloadSemaphore.Release();
+      }
+      return new Tuple<Task, TaskData>(task, result);
+    }
+
+    protected Tuple<Task, T> DeserializeTask(Tuple<Task, TaskData> taskData) {
+      deserializeSemaphore.WaitOne();
+      try {
+        if (abort || taskData.Item2 == null || taskData.Item1 == null) return null;
+        var deserializedJob = PersistenceUtil.Deserialize<T>(taskData.Item2.Data);
+        taskData.Item2.Data = null; // reduce memory consumption.
+        return new Tuple<Task, T>(taskData.Item1, deserializedJob);
+      }
+      finally {
+        deserializeSemaphore.Release();
+      }
+    }
+
+    public event EventHandler<EventArgs<Exception>> ExceptionOccured;
+    private void OnExceptionOccured(Exception exception) {
+      var handler = ExceptionOccured;
+      if (handler != null) handler(this, new EventArgs<Exception>(exception));
+    }
+
+    #region IDisposable Members
+    public void Dispose() {
+      deserializeSemaphore.Dispose();
+      downloadSemaphore.Dispose();
+    }
+    #endregion
+  }
+}
Index: branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/Imports/TaskDownloaderWeb.cs
===================================================================
--- branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/Imports/TaskDownloaderWeb.cs	(revision 13712)
+++ branches/WebJobManager/HeuristicLab.Clients.Hive.WebJobManager/Services/Imports/TaskDownloaderWeb.cs	(revision 13712)
@@ -0,0 +1,123 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Clients.Hive.WebJobManager.Services.Imports {
+  public class TaskDownloaderWeb : IDisposable {
+    private IEnumerable<Guid> taskIds;
+    private ConcurrentTaskDownloaderWeb<ItemTask> taskDownloader;
+    private IDictionary<Guid, HiveTask> results;
+    private bool exceptionOccured = false;
+    private Exception currentException;
+    private ReaderWriterLockSlim resultsLock = new ReaderWriterLockSlim();
+
+    public bool IsFinished {
+      get {
+        try {
+          resultsLock.EnterReadLock();
+          return results.Count == taskIds.Count();
+        }
+        finally { resultsLock.ExitReadLock(); }
+      }
+    }
+
+    public bool IsFaulted {
+      get {
+        return exceptionOccured;
+      }
+    }
+
+    public Exception Exception {
+      get {
+        return currentException;
+      }
+    }
+
+    public int FinishedCount {
+      get {
+        try {
+          resultsLock.EnterReadLock();
+          return results.Count;
+        }
+        finally { resultsLock.ExitReadLock(); }
+      }
+    }
+
+    public IDictionary<Guid, HiveTask> Results {
+      get {
+        try {
+          resultsLock.EnterReadLock();
+          return results;
+        }
+        finally { resultsLock.ExitReadLock(); }
+      }
+    }
+
+    public TaskDownloaderWeb(IEnumerable<Guid> jobIds) {
+      taskIds = jobIds;
+      taskDownloader = new ConcurrentTaskDownloaderWeb<ItemTask>(Settings.Default.MaxParallelDownloads, Settings.Default.MaxParallelDownloads);
+      taskDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(taskDownloader_ExceptionOccured);
+      results = new Dictionary<Guid, HiveTask>();
+    }
+
+    public void StartAsync() {
+      foreach (Guid taskId in taskIds) {
+        taskDownloader.DownloadTaskDataAndTask(taskId,
+          (localTask, itemTask) => {
+            if (localTask != null && itemTask != null) {
+              HiveTask hiveTask = itemTask.CreateHiveTask();
+              hiveTask.Task = localTask;
+              try {
+                resultsLock.EnterWriteLock();
+                results.Add(localTask.Id, hiveTask);
+              }
+              finally { resultsLock.ExitWriteLock(); }
+            }
+          });
+      }
+    }
+
+    private void taskDownloader_ExceptionOccured(object sender, EventArgs<Exception> e) {
+      OnExceptionOccured(e.Value);
+    }
+
+    public event EventHandler<EventArgs<Exception>> ExceptionOccured;
+    private void OnExceptionOccured(Exception exception) {
+      exceptionOccured = true;
+      currentException = exception;
+      var handler = ExceptionOccured;
+      if (handler != null) handler(this, new EventArgs<Exception>(exception));
+    }
+
+    #region IDisposable Members
+    public void Dispose() {
+      taskDownloader.ExceptionOccured -= new EventHandler<EventArgs<Exception>>(taskDownloader_ExceptionOccured);
+      resultsLock.Dispose();
+      taskDownloader.Dispose();
+    }
+    #endregion
+  }
+}
