Changeset 2602

Timestamp:

3/30/2012 11:16:14 AM (15 months ago)

Author:

lowjoel

Message:

Make the LogSink? a base class (LogSinkBase?) and implement a normal LogSink? (API compatible with the old LogSink?) and a new LazyLogSink? class which will load a log from disk as required.
As a result of this change, Task will have two WriteXml? functions: The default will continue to generate the same code; the new overload will place references to logs if the logs are larger than a certain threshold. This is to optimize the task list for size when loading/unloading.

Location:

branches/eraser6/XmlTaskLists

Files:

• Eraser.Manager/Task.cs (modified) (6 diffs)
• Eraser.Util/Logger.cs (modified) (3 diffs)
• Eraser/LogForm.cs (modified) (1 diff)

branches/eraser6/XmlTaskLists/Eraser.Manager/Task.cs

@@ -50 +50 @@
             Targets = (ErasureTargetCollection)info.GetValue("Targets", typeof(ErasureTargetCollection));
             Targets.Owner = this;
-            Log = (List<LogSink>)info.GetValue("Log", typeof(List<LogSink>));
+            Log = (List<LogSinkBase>)info.GetValue("Log", typeof(List<LogSinkBase>));
             Canceled = false;
 
@@ -98 +98 @@
                         break;
 
-                    case "ArrayOfArrayOfLogEntry":
+                    case "Logs":
                         ReadLog(reader);
                         break;
@@ -143 +143 @@
         private void ReadLog(XmlReader reader)
         {
-            XmlSerializer logSerializer = new XmlSerializer(Log.GetType());
-            Log = (List<LogSink>)logSerializer.Deserialize(reader);
-        }
-
-        public void WriteXml(XmlWriter writer)
+            //We can either have a ArrayOfLogEntry or LogRef element as children.
+            Log = new List<LogSinkBase>();
+            while (reader.Read() && reader.NodeType != XmlNodeType.EndElement)
+            {
+                if (reader.Name == "LogRef")
+                {
+                    Log.Add(new LazyLogSink(reader.ReadString()));
+                }
+                else if (reader.Name == "ArrayOfLogEntry")
+                {
+                    XmlSerializer logSerializer = new XmlSerializer(typeof(LogSink));
+                    Log.Add((LogSink)logSerializer.Deserialize(reader));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Writes the common part of the Task XML Element.
+        /// </summary>
+        /// <param name="writer">The XML Writer instance to write to.</param>
+        private void WriteXmlCommon(XmlWriter writer)
         {
             writer.WriteAttributeString("name", Name);
@@ -168 +184 @@
             XmlSerializer targetsSerializer = new XmlSerializer(Targets.GetType());
             targetsSerializer.Serialize(writer, Targets);
-
-            XmlSerializer logSerializer = new XmlSerializer(Log.GetType());
-            logSerializer.Serialize(writer, Log);
+        }
+
+        public void WriteXml(XmlWriter writer)
+        {
+            WriteXmlCommon(writer);
+
+            writer.WriteStartElement("Logs");
+            foreach (LogSinkBase log in Log)
+            {
+                XmlSerializer logSerializer = new XmlSerializer(log.GetType());
+                logSerializer.Serialize(writer, log);
+            }
+            writer.WriteEndElement();
+        }
+
+        /// <summary>
+        /// Writes an XML element with the Log entries linked instead of embedded
+        /// in the task list.
+        /// </summary>
+        /// <param name="writer">The XML Writer instance to write to.</param>
+        /// <param name="logPaths">The path to a folder to store logs in.</param>
+        public void WriteSeparatedXml(XmlWriter writer, string logPaths)
+        {
+            WriteXmlCommon(writer);
+
+            writer.WriteStartElement("Logs");
+            foreach (LogSinkBase log in Log)
+            {
+                //If we have a file-backed log, retain that.
+                if (log is LazyLogSink)
+                {
+                    writer.WriteElementString("LogRef", ((LazyLogSink)log).SavePath);
+                }
+                
+                //Otherwise, decide if we want to store the log inline (if small) or
+                //link to the log file.
+                else if (log.Count < 5)
+                {
+                    //Small log, keep it inline.
+                    XmlSerializer logSerializer = new XmlSerializer(log.GetType());
+                    logSerializer.Serialize(writer, log);
+                }
+                else
+                {
+                    string savePath;
+                    do
+                    {
+                        savePath = Path.Combine(logPaths, Guid.NewGuid().ToString() + ".log");
+                    }
+                    while (File.Exists(savePath));
+
+                    log.Save(savePath);
+                    writer.WriteElementString("LogRef", savePath);
+                }
+            }
+            writer.WriteEndElement();
         }
         #endregion
@@ -183 +252 @@
             Schedule = Schedule.RunNow;
             Canceled = false;
-            Log = new List<LogSink>();
+            Log = new List<LogSinkBase>();
         }
 
@@ -282 +351 @@
         /// The log entries which this task has accumulated.
         /// </summary>
-        public List<LogSink> Log { get; private set; }
+        public List<LogSinkBase> Log { get; private set; }
 
         /// <summary>

branches/eraser6/XmlTaskLists/Eraser.Util/Logger.cs

@@ -601 +601 @@
     /// <remarks>Instance functions of this class are thread-safe.</remarks>
     [Serializable]
-    public class LogSink : ISerializable, ILogTarget, IList<LogEntry>
-    {
-        public LogSink()
+    public abstract class LogSinkBase : ISerializable, ILogTarget, IList<LogEntry>
+    {
+        public LogSinkBase()
         {
         }
@@ -609 +609 @@
         #region ISerializable Members
 
-        public LogSink(SerializationInfo info, StreamingContext context)
-        {
-            List = (List<LogEntry>)info.GetValue("List", typeof(List<LogEntry>));
+        public LogSinkBase(SerializationInfo info, StreamingContext context)
+        {
         }
 
         [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
-        public void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            info.AddValue("List", List);
-        }
-
-        #endregion
+        public abstract void GetObjectData(SerializationInfo info, StreamingContext context);
+
+        #endregion 
 
         #region ILoggerTarget Members
@@ -791 +787 @@
 
         /// <summary>
+        /// Saves the log to the given path in an XML format which can be read
+        /// by <see cref="LazyLogSink"/>.
+        /// </summary>
+        /// <param name="path">The path to save the log contents to.</param>
+        public void Save(string path)
+        {
+            using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
+                Save(stream);
+        }
+
+        public void Save(Stream stream)
+        {
+            IList<LogEntry> list = List;
+            lock (list)
+            {
+                XmlRootAttribute root = new XmlRootAttribute("Log");
+                XmlSerializer serializer = new XmlSerializer(list.GetType(), root);
+
+                serializer.Serialize(stream, list);
+            }
+        }
+
+        /// <summary>
         /// The backing store of this session.
         /// </summary>
-        private List<LogEntry> List = new List<LogEntry>();
+        protected abstract IList<LogEntry> List
+        {
+            get;
+        }
+    }
+
+    [Serializable]
+    public class LogSink : LogSinkBase
+    {
+        public LogSink()
+        {
+            list = new List<LogEntry>();
+        }
+
+        #region ISerializable Members
+
+        public LogSink(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+            list = (List<LogEntry>)info.GetValue("List", typeof(List<LogEntry>));
+        }
+
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            info.AddValue("List", List);
+        }
+
+        #endregion 
+
+        protected override IList<LogEntry> List
+        {
+            get { return list; }
+        }
+        private List<LogEntry> list;
+    }
+
+    [Serializable]
+    public class LazyLogSink : LogSinkBase
+    {
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="path">The path to the log file.</param>
+        public LazyLogSink(string path)
+        {
+            SavePath = path;
+        }
+
+        #region ISerializable Members
+
+        public LazyLogSink(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+            SavePath = (string)info.GetValue("SavePath", typeof(string));
+        }
+
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            info.AddValue("SavePath", SavePath);
+        }
+
+        #endregion
+
+        private void LoadList()
+        {
+            lock (Synchronise)
+            {
+                XmlRootAttribute root = new XmlRootAttribute("Log");
+                XmlSerializer serializer = new XmlSerializer(typeof(List<LogEntry>), root);
+
+                using (FileStream stream = new FileStream(SavePath, FileMode.Open))
+                    list = (List<LogEntry>)serializer.Deserialize(stream);
+            }
+        }
+
+        /// <summary>
+        /// The path the log was saved to.
+        /// </summary>
+        public string SavePath
+        {
+            get;
+            private set;
+        }
+
+        protected override IList<LogEntry> List
+        {
+            get
+            {
+                if (list == null)
+                    LoadList();
+                return list;
+            }
+        }
+
+        private List<LogEntry> list;
+
+        /// <summary>
+        /// Private object to makw sure LoadList is not called on multiple threads.
+        /// </summary>
+        private object Synchronise = new object();
     }
 }

branches/eraser6/XmlTaskLists/Eraser/LogForm.cs

@@ -321 +321 @@
 
             Application.UseWaitCursor = true;
-            LogSink sink = Task.Log[filterSessionCombobox.SelectedIndex];
+            LogSinkBase sink = Task.Log[filterSessionCombobox.SelectedIndex];
             EntryCache.Clear();
             SelectedEntries.Clear();