Changeset 16325

Timestamp:

11/23/18 15:37:24 (5 years ago)

Author:

pfleck

Message:

#2965

• Added CancelationTokens for the Save and Serialize methods.
• Fixed a potential temp-file-leak when replacing the old file with the new one after serialization.

Location:

branches/2965_CancelablePersistence

Files:

• HeuristicLab.Common/3.3/Content/ContentManager.cs (modified) (5 diffs)
• HeuristicLab.Core/3.3/PersistenceContentManager.cs (modified) (2 diffs)
• HeuristicLab.Optimizer/3.3/FileManager.cs (modified) (6 diffs)
• HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs (modified) (15 diffs)

branches/2965_CancelablePersistence/HeuristicLab.Common/3.3/Content/ContentManager.cs

@@ -21 +21 @@
 
 using System;
+using System.Threading;
 
 namespace HeuristicLab.Common {
@@ -43 +44 @@
       if (instance == null) throw new InvalidOperationException("ContentManager is not initialized.");
       var func = new Func<string, IStorableContent>(instance.LoadContent);
-      func.BeginInvoke(filename, delegate(IAsyncResult result) {
+      func.BeginInvoke(filename, delegate (IAsyncResult result) {
         Exception error = null;
         IStorableContent content = null;
@@ -49 +50 @@
           content = func.EndInvoke(result);
           content.Filename = filename;
-        }
-        catch (Exception ex) {
+        } catch (Exception ex) {
           error = ex;
         }
@@ -58 +58 @@
     protected abstract IStorableContent LoadContent(string filename);
 
-    public static void Save(IStorableContent content, string filename, bool compressed) {
+    public static void Save(IStorableContent content, string filename, bool compressed, CancellationToken cancellationToken = default(CancellationToken)) {
       if (instance == null) throw new InvalidOperationException("ContentManager is not initialized.");
-      instance.SaveContent(content, filename, compressed);
+      instance.SaveContent(content, filename, compressed, cancellationToken);
       content.Filename = filename;
     }
-    public static void SaveAsync(IStorableContent content, string filename, bool compressed, Action<IStorableContent, Exception> savingCompletedCallback) {
+    public static void SaveAsync(IStorableContent content, string filename, bool compressed, Action<IStorableContent, Exception> savingCompletedCallback, CancellationToken cancellationToken = default(CancellationToken)) {
       if (instance == null) throw new InvalidOperationException("ContentManager is not initialized.");
-      var action = new Action<IStorableContent, string, bool>(instance.SaveContent);
-      action.BeginInvoke(content, filename, compressed, delegate(IAsyncResult result) {
+      var action = new Action<IStorableContent, string, bool, CancellationToken>(instance.SaveContent);
+      action.BeginInvoke(content, filename, compressed, cancellationToken, delegate (IAsyncResult result) {
         Exception error = null;
         try {
           action.EndInvoke(result);
           content.Filename = filename;
-        }
-        catch (Exception ex) {
+        } catch (Exception ex) {
           error = ex;
         }
@@ -79 +78 @@
 
     }
-    protected abstract void SaveContent(IStorableContent content, string filename, bool compressed);
+    protected abstract void SaveContent(IStorableContent content, string filename, bool compressed, CancellationToken cancellationToken);
   }
 }

branches/2965_CancelablePersistence/HeuristicLab.Core/3.3/PersistenceContentManager.cs

@@ -21 +21 @@
 
 using System.IO.Compression;
+using System.Threading;
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.Xml;
@@ -32 +33 @@
     }
 
-    protected override void SaveContent(IStorableContent content, string filename, bool compressed) {
-      XmlGenerator.Serialize(content, filename, compressed ? CompressionLevel.Optimal : CompressionLevel.NoCompression);
+    protected override void SaveContent(IStorableContent content, string filename, bool compressed, CancellationToken cancellationToken) {
+      XmlGenerator.Serialize(content, filename, compressed ? CompressionLevel.Optimal : CompressionLevel.NoCompression, cancellationToken);
     }
   }

branches/2965_CancelablePersistence/HeuristicLab.Optimizer/3.3/FileManager.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
 using System.Windows.Forms;
 using HeuristicLab.Common;
@@ -78 +79 @@
         if (view == null)
           ErrorHandling.ShowErrorDialog("There is no view for the loaded item. It cannot be displayed.", new InvalidOperationException("No View Available"));
-      }
-      catch (Exception ex) {
+      } catch (Exception ex) {
         ErrorHandling.ShowErrorDialog((Control)MainFormManager.MainForm, "Cannot open file.", ex);
-      }
-      finally {
+      } finally {
         ((MainForm.WindowsForms.MainForm)MainFormManager.MainForm).ResetAppStartingCursor();
       }
@@ -100 +99 @@
         else {
           MainFormManager.GetMainForm<HeuristicLab.MainForm.WindowsForms.MainForm>().SetAppStartingCursor();
+          var cancellationTokenSource = new CancellationTokenSource();
           SetSaveOperationProgressInContentViews(content, true);
-          ContentManager.SaveAsync(content, content.Filename, true, SavingCompleted);
+          ContentManager.SaveAsync(content, content.Filename, true, SavingCompleted, cancellationTokenSource.Token);
         }
       }
@@ -132 +132 @@
         if (saveFileDialog.ShowDialog() == DialogResult.OK) {
           MainFormManager.GetMainForm<HeuristicLab.MainForm.WindowsForms.MainForm>().SetAppStartingCursor();
-          SetSaveOperationProgressInContentViews(content, true, saveFileDialog.FileName);
-          if (saveFileDialog.FilterIndex == 1) {
-            ContentManager.SaveAsync(content, saveFileDialog.FileName, false, SavingCompleted);
-          } else {
-            ContentManager.SaveAsync(content, saveFileDialog.FileName, true, SavingCompleted);
-          }
+          bool compressed = saveFileDialog.FilterIndex != 1;
+          var cancellationTokenSource = new CancellationTokenSource();
+          SetSaveOperationProgressInContentViews(content, compressed, saveFileDialog.FileName);
+
+          ContentManager.SaveAsync(content, saveFileDialog.FileName, compressed, SavingCompleted, cancellationTokenSource.Token);
         }
       }
@@ -145 +144 @@
         if (error != null) throw error;
         MainFormManager.GetMainForm<HeuristicLab.MainForm.WindowsForms.MainForm>().UpdateTitle();
-      }
-      catch (Exception ex) {
+      } catch (Exception ex) {
         ErrorHandling.ShowErrorDialog((Control)MainFormManager.MainForm, "Cannot save file.", ex);
-      }
-      finally {
+      } finally {
         SetSaveOperationProgressInContentViews(content, false);
         MainFormManager.GetMainForm<HeuristicLab.MainForm.WindowsForms.MainForm>().ResetAppStartingCursor();
@@ -167 +164 @@
       #endregion
     }
+
+    /* For later merge with #2845
+    private static void AddProgressInContentViews(IStorableContent content, CancellationTokenSource cancellationTokenSource, string fileName = null) {
+      string message = string.Format("Saving to file \"{0}\"...", Path.GetFileName(fileName ?? content.Filename));
+      Progress.Show(content, message, ProgressMode.Indeterminate, cancelRequestHandler: () => cancellationTokenSource.Cancel());
+    }*/
   }
 }

branches/2965_CancelablePersistence/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs

@@ -26 +26 @@
 using System.Linq;
 using System.Text;
+using System.Threading;
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Core.Tokens;
@@ -61 +62 @@
     }
 
-    protected enum NodeType { Start, End, Inline } ;
+    protected enum NodeType { Start, End, Inline };
 
     protected static void AddXmlTagContent(StringBuilder sb, string name, Dictionary<string, string> attributes) {
@@ -256 +257 @@
           {"typeName", lastTypeToken.TypeName },
           {"serializer", lastTypeToken.Serializer }});
-      }
-      finally {
+      } finally {
         lastTypeToken = null;
       }
@@ -284 +284 @@
     /// <param name="o">The object.</param>
     /// <param name="filename">The filename.</param>
-    public static void Serialize(object o, string filename) {
-      Serialize(o, filename, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), false, CompressionLevel.Optimal);
+    public static void Serialize(object o, string filename, CancellationToken cancellationToken = default(CancellationToken)) {
+      Serialize(o, filename, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), false, CompressionLevel.Optimal, cancellationToken);
     }
 
@@ -296 +296 @@
     /// <param name="filename">The filename.</param>
     /// <param name="compression">ZIP file compression level</param>
-    public static void Serialize(object o, string filename, CompressionLevel compression) {
-      Serialize(o, filename, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), false, compression);
+    public static void Serialize(object o, string filename, CompressionLevel compression, CancellationToken cancellationToken = default(CancellationToken)) {
+      Serialize(o, filename, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), false, compression, cancellationToken);
     }
 
@@ -307 +307 @@
     /// <param name="filename">The filename.</param>
     /// <param name="config">The configuration.</param>
-    public static void Serialize(object obj, string filename, Configuration config) {
-      Serialize(obj, filename, config, false, CompressionLevel.Optimal);
-    }
-
-    private static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies
-   , CompressionLevel compression) {
+    public static void Serialize(object obj, string filename, Configuration config, CancellationToken cancellationToken = default(CancellationToken)) {
+      Serialize(obj, filename, config, false, CompressionLevel.Optimal, cancellationToken);
+    }
+
+    private static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies, CompressionLevel compression, CancellationToken cancellationToken = default(CancellationToken)) {
       Serializer serializer = new Serializer(obj, config);
-      Serialize(stream, includeAssemblies, compression, serializer);
-    }
-
-    private static void Serialize(Stream stream, bool includeAssemblies, CompressionLevel compression, Serializer serializer) {
+      Serialize(stream, includeAssemblies, compression, serializer, cancellationToken);
+    }
+
+    private static void Serialize(Stream stream, bool includeAssemblies, CompressionLevel compression, Serializer serializer, CancellationToken cancellationToken = default(CancellationToken)) {
       try {
+        cancellationToken.ThrowIfCancellationRequested();
         DateTime start = DateTime.Now;
         serializer.InterleaveTypeInformation = false;
@@ -326 +326 @@
           using (StreamWriter writer = new StreamWriter(entry.Open())) {
             foreach (ISerializationToken token in serializer) {
+              cancellationToken.ThrowIfCancellationRequested();
               string line = generator.Format(token);
               writer.Write(line);
@@ -338 +339 @@
           if (includeAssemblies) {
             foreach (string name in serializer.RequiredFiles) {
+              cancellationToken.ThrowIfCancellationRequested();
               Uri uri = new Uri(name);
               if (!uri.IsFile) {
@@ -348 +350 @@
                   byte[] buffer = new byte[1024 * 1024];
                   while (true) {
+                    cancellationToken.ThrowIfCancellationRequested();
                     int bytesRead = reader.Read(buffer, 0, 1024 * 1024);
                     if (bytesRead == 0)
@@ -360 +363 @@
         Logger.Info(String.Format("serialization took {0} seconds with compression level {1}",
           (DateTime.Now - start).TotalSeconds, compression));
-      }
-      catch (Exception) {
+      } catch (Exception) {
         Logger.Warn("Exception caught, no data has been serialized.");
         throw;
@@ -375 +377 @@
     /// <param name="includeAssemblies">if set to <c>true</c> include needed assemblies.</param>
     /// <param name="compression">The ZIP compression level.</param>
-    public static void Serialize(object obj, string filename, Configuration config, bool includeAssemblies, CompressionLevel compression) {
+    public static void Serialize(object obj, string filename, Configuration config, bool includeAssemblies, CompressionLevel compression, CancellationToken cancellationToken = default(CancellationToken)) {
+      string tempfile = null;
       try {
-        string tempfile = Path.GetTempFileName();
+        tempfile = Path.GetTempFileName();
 
         using (FileStream stream = File.Create(tempfile)) {
-          Serialize(obj, stream, config, includeAssemblies, compression);
-        }
-
+          Serialize(obj, stream, config, includeAssemblies, compression, cancellationToken);
+        }
+        // copy only if needed
         File.Copy(tempfile, filename, true);
-        File.Delete(tempfile);
-      }
-      catch (Exception) {
+      } catch (Exception) {
         Logger.Warn("Exception caught, no data has been written.");
         throw;
+      } finally {
+        if (tempfile != null && File.Exists(tempfile))
+          File.Delete(tempfile);
       }
     }
@@ -399 +403 @@
     /// <param name="stream">The stream.</param>
     /// <param name="compressionType">Type of compression, default is GZip.</param>
-    public static void Serialize(object obj, Stream stream, CompressionType compressionType = CompressionType.GZip) {
-      Serialize(obj, stream, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), compressionType);
+    public static void Serialize(object obj, Stream stream, CompressionType compressionType = CompressionType.GZip, CancellationToken cancellationToken = default(CancellationToken)) {
+      Serialize(obj, stream, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), compressionType, cancellationToken);
     }
 
@@ -411 +415 @@
     /// <param name="config">The configuration.</param>
     /// <param name="compressionType">Type of compression, default is GZip.</param>
-    public static void Serialize(object obj, Stream stream, Configuration config, CompressionType compressionType = CompressionType.GZip) {
-      Serialize(obj, stream, config, false, compressionType);
+    public static void Serialize(object obj, Stream stream, Configuration config, CompressionType compressionType = CompressionType.GZip, CancellationToken cancellationToken = default(CancellationToken)) {
+      Serialize(obj, stream, config, false, compressionType, cancellationToken);
     }
 
@@ -423 +427 @@
     /// <param name="includeAssemblies">if set to <c>true</c> include need assemblies.</param>
     /// <param name="compressionType">Type of compression, default is GZip.</param>
-    public static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies,
-                                 CompressionType compressionType = CompressionType.GZip) {
+    public static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies, CompressionType compressionType = CompressionType.GZip, CancellationToken cancellationToken = default(CancellationToken)) {
       try {
         Serializer serializer = new Serializer(obj, config);
         if (compressionType == CompressionType.Zip) {
-          Serialize(obj, stream, config, includeAssemblies, CompressionLevel.Optimal);
+          Serialize(obj, stream, config, includeAssemblies, CompressionLevel.Optimal, cancellationToken);
         } else {
-          Serialize(stream, serializer);
-        }
-      }
-      catch (PersistenceException) {
+          Serialize(stream, serializer, cancellationToken);
+        }
+      } catch (PersistenceException) {
         throw;
-      }
-      catch (Exception e) {
+      } catch (Exception e) {
         throw new PersistenceException("Unexpected exception during Serialization.", e);
       }
@@ -451 +452 @@
     /// <param name="compressionType">Type of compression, default is GZip.</param>
     public static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies, out IEnumerable<Type> types,
-                                 CompressionType compressionType = CompressionType.GZip) {
+                                 CompressionType compressionType = CompressionType.GZip, CancellationToken cancellationToken = default(CancellationToken)) {
       try {
         Serializer serializer = new Serializer(obj, config);
         if (compressionType == CompressionType.Zip) {
-          Serialize(stream, includeAssemblies, CompressionLevel.Optimal, serializer);
+          Serialize(stream, includeAssemblies, CompressionLevel.Optimal, serializer, cancellationToken);
         } else {
-          Serialize(stream, serializer);
+          Serialize(stream, serializer, cancellationToken);
         }
         types = serializer.SerializedTypes;
-      }
-      catch (PersistenceException) {
+      } catch (PersistenceException) {
         throw;
-      }
-      catch (Exception e) {
+      } catch (Exception e) {
         throw new PersistenceException("Unexpected exception during Serialization.", e);
       }
     }
 
-    private static void Serialize(Stream stream, Serializer serializer) {
+    private static void Serialize(Stream stream, Serializer serializer, CancellationToken cancellationToken = default(CancellationToken)) {
+      cancellationToken.ThrowIfCancellationRequested();
       using (StreamWriter writer = new StreamWriter(new GZipStream(stream, CompressionMode.Compress))) {
         serializer.InterleaveTypeInformation = true;
         XmlGenerator generator = new XmlGenerator();
         foreach (ISerializationToken token in serializer) {
+          cancellationToken.ThrowIfCancellationRequested();
           string line = generator.Format(token);
           writer.Write(line);