init

Common/DTS.Common.Utilities/TextLogger.WriteCycleHandle.cs

@@ -0,0 +1,225 @@
+/*
+ * TextLogger.WriteCycleHandle.cs
+ * 
+ * Copyright © 2010
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace DTS.Common.Utilities.Logging
+{   // *** see TextLogger.cs ***
+    public partial class TextLogger
+    {
+        /// <summary>
+        /// "Handle" containing the state information for a log message write session.
+        /// </summary>
+        protected class WriteCycleHandle
+        {
+            /// <summary>
+            /// The filename of the log file receiving the messages being supplied to this
+            /// write session.
+            /// </summary>
+            public string FullLogFileName { get; set; }
+
+            /// <summary>
+            /// The <see cref="System.Threading.AutoResetEvent"/> whose "set" kicks off
+            /// a write cycle.
+            /// </summary>
+            public AutoResetEvent CycleTrigger { get; set; }
+
+            /// <summary>
+            /// The <see cref="System.Threading.AutoResetEvent"/> that is signaled when
+            /// a write cycle completes.
+            /// </summary>
+            public AutoResetEvent CycleCompletionTrigger { get; set; }
+
+            /// <summary>
+            /// The <see cref="Logging.TextLogger.WriteCycleExceptionHandler"/> to be
+            /// invoked when the write cycle encounters an exception.
+            /// </summary>
+            public WriteCycleExceptionHandler OnWriteCycleException { get; set; }
+
+            /// <summary>
+            /// <see cref="bool"/> flag that controls whether or not the write cycle should
+            /// auto-terminate whenever it encounters an exception.
+            /// </summary>
+            public bool TerminateCycleOnException { get; set; }
+
+            private static readonly object MyLock = new object();
+            /// <summary>
+            /// Get/set the <see cref="bool"/> flag that will terminate the associated write cycle when set to 'true'.
+            /// </summary>
+            public bool TerminateWriteCycle
+            {
+                get
+                {
+                    try
+                    {
+                        lock (MyLock)
+                        {
+                            if (!_IsTerminateWriteCycleInitialized)
+                                throw new ApplicationException("TerminateWriteCycle value has not been initialized");
+                            else return _TerminateWriteCycle;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new ApplicationException("encountered problem getting value for property " + GetType().FullName + ".TerminateWriteCycle", ex);
+                    }
+                }
+                set
+                {
+                    try
+                    {
+                        lock (MyLock)
+                        {   //
+                            // Set the termination flag and then kick off a cycle so it goes into
+                            // effect asap.
+                            //
+                            _IsTerminateWriteCycleInitialized = true;
+                            _TerminateWriteCycle = value;
+                            if (_TerminateWriteCycle)
+                                CycleTrigger.Set();
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new ApplicationException("encountered problem setting value for property " + GetType().FullName + ".TerminateWriteCycle", ex);
+                    }
+                }
+            }
+            private bool _TerminateWriteCycle;
+            private bool _IsTerminateWriteCycleInitialized = false;
+
+            /// <summary>
+            /// The actually queue of log message <see cref="string"/>s to be written to the active log file.
+            /// </summary>
+            public Queue<string> WriteQueue
+            {
+                get
+                {
+                    try
+                    {
+                        if (!_IsWriteQueueInitialized)
+                            throw new ApplicationException("WriteQueue has not been initialized");
+                        else return _WriteQueue;
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new ApplicationException("encountered problem getting value for property " + GetType().FullName + ".WriteQueue", ex);
+                    }
+                }
+                set
+                {
+                    try
+                    {
+                        _IsWriteQueueInitialized = true;
+                        _WriteQueue = value;
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new ApplicationException("encountered problem setting value for property " + GetType().FullName + ".WriteQueue", ex);
+                    }
+                }
+            }
+            private Queue<string> _WriteQueue = null;
+            private bool _IsWriteQueueInitialized = false;
+
+            /// <summary>
+            /// Callback to be invoked when the write cycle has closed it's associated log file's
+            /// write handle for the last time.
+            /// </summary>
+            public WriteCycleCallback OnWriteCycleTermination
+            {
+                get
+                {
+                    try
+                    {
+                        lock (MyLock)
+                        {
+                            return _OnWriteCycleTermination;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new ApplicationException("encountered problem getting value for property " + GetType().FullName + ".OnWriteCycleTermination", ex);
+                    }
+                }
+                set
+                {
+                    try
+                    {
+                        lock (MyLock)
+                        {   //
+                            // Set the cycle termination callback.  If we're undergoing termination and there's 
+                            // nothing left in the write queue, then go ahead and immediately call the termination
+                            // callback.  Null the reference after the call so we don't accidentally somehow end up
+                            // calling it twice.
+                            //
+                            _OnWriteCycleTermination = value;
+                            if (_IsTerminateWriteCycleInitialized && _TerminateWriteCycle &&
+                                _IsWriteQueueInitialized && _WriteQueue.Count <= 0)
+                            {
+                                _OnWriteCycleTermination(_WriteQueue);
+                                _OnWriteCycleTermination = null;
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new ApplicationException("encountered problem setting value for property " + GetType().FullName + ".OnWriteCycleTermination", ex);
+                    }
+                }
+            }
+            private WriteCycleCallback _OnWriteCycleTermination = null;
+
+            /// <summary>
+            /// Initialize an instance of the <see cref="Logging.TextLogger.WriteCycleHandle"/> class.
+            /// </summary>
+            /// 
+            /// <param name="fullLogFileName">
+            /// The filename of the log file receiving the messages being supplied to this
+            /// write session.
+            /// </param>
+            /// 
+            /// <param name="writeQueue">
+            /// The actually queue of log message <see cref="string"/>s to be written to the active log file.
+            /// </param>
+            /// 
+            /// <param name="onWriteCycleTermination">
+            /// Callback to be invoked when the write cycle has closed it's associated log file's
+            /// write handle for the last time.
+            /// </param>
+            /// 
+            /// <param name="onWriteCycleException">
+            /// Callback to be invoked when the write cycle has closed it's associated log file's
+            /// write handle for the last time.
+            /// </param>
+            /// 
+            /// <param name="terminateCycleOnException">
+            /// <see cref="bool"/> flag that controls whether or not the write cycle should
+            /// auto-terminate whenever it encounters an exception.
+            /// </param>
+            /// 
+            public WriteCycleHandle(string fullLogFileName,
+                                     Queue<string> writeQueue,
+                                     WriteCycleCallback onWriteCycleTermination,
+                                     WriteCycleExceptionHandler onWriteCycleException,
+                                     bool terminateCycleOnException)
+            {
+                TerminateWriteCycle = false;
+                FullLogFileName = fullLogFileName;
+                WriteQueue = writeQueue;
+                CycleTrigger = new AutoResetEvent(false);
+                CycleCompletionTrigger = new AutoResetEvent(false);
+                OnWriteCycleTermination = onWriteCycleTermination;
+                OnWriteCycleException = onWriteCycleException;
+                TerminateCycleOnException = terminateCycleOnException;
+            }
+        }
+    }
+}