Move log download thread to LogDownloader class.

BulkPrinting/BulkPrinting/BulkPrinting.csproj

       <DependentUpon>ExportForm.cs</DependentUpon>
     </Compile>
     <Compile Include="Globals.cs" />
+    <Compile Include="LogDownloader.cs" />
     <Compile Include="LogUploader.cs" />
     <Compile Include="Migrations.cs" />
     <Compile Include="ObservedForm.cs">
     <Compile Include="ProgressDialog.Designer.cs">
       <DependentUpon>ProgressDialog.cs</DependentUpon>
     </Compile>
+    <Compile Include="ThreadHelper.cs" />
     <Compile Include="Utility.cs" />
     <Compile Include="Models.cs" />
     <Compile Include="OrderForm.cs">

BulkPrinting/BulkPrinting/Globals.cs

         public static List<int> OpenBatches;
         public static UserLimits UserCurrentUsage;
         public static LogUploader LogUploader;
-        public static Thread LogDownloadThread;
-        public static object LogDownloadThreadLock = new object();
-        public static bool LogDownloadThreadCancelled;
+        public static LogDownloader LogDownloader;
     }
 }

BulkPrinting/BulkPrinting/LogDownloader.cs

+using System;
+using System.Threading;
+
+namespace BulkPrinting
+{
+    public class LogDownloader : ThreadHelper
+    {
+        private const int _vendorEventPageSize = 5000;
+        private const int _retryInterval = 30000;
+
+        private DBHelper _db;
+
+        public LogDownloader(DBHelper db)
+        {
+            _db = db;
+        }
+
+        protected override void Run()
+        {
+            bool isCancelled = false;
+            int maxRemoteId = Utility.GetSavedParameterAsInt(_db, "SyncBackwardsFromLogId");
+            while (!isCancelled && (maxRemoteId > 0))
+            {
+                var EventPage = new Page<VendorEvent>();
+                if (Utility.RESTRequest(ref EventPage, String.Format(
+                    "/api/vendorevents/?maxRemoteId={0}&pageSize={1}", maxRemoteId, _vendorEventPageSize)))
+                {
+                    lock (_db.WriteLock)
+                    {
+                        using (var trans = _db.BeginTransaction())
+                        {
+                            using (var insertCommand = _db.CreateCommand(
+                                "INSERT INTO Logs (Id,  UserId,  VoucherId,  EventDate,  EventType,  Retry) " +
+                                          "VALUES (@id, @userid, @voucherid, @eventdate, @eventtype, @retry)",
+                                trans))
+                            using (var updateCommand = _db.CreateCommand(
+                                "UPDATE Parameters SET Value=@Value WHERE Key='SyncBackwardsFromLogId'", trans))
+                            {
+                                foreach (VendorEvent Event in EventPage.Items)
+                                {
+                                    if (!Event.RemoteId.HasValue)
+                                    {
+                                        throw new Exception("Downloaded event with no remote ID");
+                                    }
+                                    else if (Event.RemoteId.Value > maxRemoteId)
+                                    {
+                                        throw new Exception("Downloaded event remote ID was not in descending order");
+                                    }
+
+                                    insertCommand.Parameters.Clear();
+                                    insertCommand.Parameters.AddWithValue("@id", Event.RemoteId);
+                                    insertCommand.Parameters.AddWithValue("@userid", Event.UserId);
+                                    insertCommand.Parameters.AddWithValue("@voucherid", Event.VoucherId);
+                                    insertCommand.Parameters.AddWithValue("@eventdate", Event.EventDate.UtcDateTime);
+                                    insertCommand.Parameters.AddWithValue("@eventtype", Event.EventType);
+                                    insertCommand.Parameters.AddWithValue("@retry", Event.Retry);
+                                    insertCommand.ExecuteNonQuery();
+
+                                    maxRemoteId = Event.RemoteId.Value - 1;
+                                }
+
+                                updateCommand.Parameters.Clear();
+                                updateCommand.Parameters.AddWithValue("@Value", maxRemoteId.ToString());
+                                updateCommand.ExecuteNonQuery();
+                            }
+
+                            trans.Commit();
+                        }
+                    }
+
+                    lock (_lock)
+                    {
+                        isCancelled = _cancelled;
+                    }
+                }
+                else
+                {
+                    lock (_lock)
+                    {
+                        if (!_cancelled)
+                        {
+                            Monitor.Wait(_lock, _retryInterval);
+                        }
+                        isCancelled = _cancelled;
+                    }
+                }
+            }
+        }
+    }
+}

BulkPrinting/BulkPrinting/LogUploader.cs

 
 namespace BulkPrinting
 {
-    public class LogUploader
+    public class LogUploader : ThreadHelper
     {
         private const int _uploadPageSize = 5000;
         private const int _retryInterval = 30000;
 
-        private Thread _thread;
-        private object _lock = new object();
         private DBHelper _db;
-        private bool _cancelled;
         private bool _uploadTriggered;
 
         public LogUploader(DBHelper db)
         {
             _db = db;
-            _thread = new Thread(Run);
         }
 
-        public void Cancel()
-        {
-            lock (_lock)
-            {
-                _cancelled = true;
-                Monitor.Pulse(_lock);
-            }
-        }
-
-        public void Join()
-        {
-            _thread.Join();
-        }
-
-        private void Run()
+        protected override void Run()
         {
             var isCancelled = false;
             while (!isCancelled)
             }
         }
 
-        public void Start()
-        {
-            _thread.Start();
-        }
-
         public void TriggerUpload()
         {
             lock (_lock)

BulkPrinting/BulkPrinting/ThreadHelper.cs

+using System.Threading;
+
+namespace BulkPrinting
+{
+    public abstract class ThreadHelper
+    {
+        protected Thread _thread;
+        protected object _lock = new object();
+        protected bool _cancelled;
+
+        public ThreadHelper()
+        {
+            _thread = new Thread(Run);
+        }
+
+        public void Abort()
+        {
+            _thread.Abort();
+        }
+
+        public void Cancel()
+        {
+            lock (_lock)
+            {
+                _cancelled = true;
+                Monitor.Pulse(_lock);
+            }
+        }
+
+        public void Join()
+        {
+            _thread.Join();
+        }
+
+        protected abstract void Run();
+
+        public void Start()
+        {
+            _thread.Start();
+        }
+    }
+}

BulkPrinting/BulkPrinting/Utility.cs

                 if (Globals.LogUploader != null)
                     Globals.LogUploader.Cancel();
 
-                CancelLogDownloadWorker();
+                if (Globals.LogDownloader != null)
+                    Globals.LogDownloader.Cancel();
 
                 if (Globals.LogUploader != null)
                 {
                     Globals.LogUploader = null;
                 }
 
-                if (Globals.LogDownloadThread != null)
+                if (Globals.LogDownloader != null)
                 {
-                    Globals.LogDownloadThread.Join();
-                    Globals.LogDownloadThread = null;
+                    Globals.LogDownloader.Join();
+                    Globals.LogDownloader = null;
                 }
 
-                Globals.LogDownloadThreadCancelled = false;
-
                 Globals.DB.Close();
                 Globals.DB.Dispose();
                 Globals.DB = null;
             }
         }
 
-        public static void CancelLogDownloadWorker()
-        {
-            lock (Globals.LogDownloadThreadLock)
-            {
-                Globals.LogDownloadThreadCancelled = true;
-                Monitor.Pulse(Globals.LogDownloadThreadLock);
-            }
-        }
-
-        public static void LogDownloadWorker()
-        {
-            const int vendorEventPageSize = 1000;
-            const int retryInterval = 30000;
-
-            var db = Globals.DB;
-            //using (var db = OpenDBConnection())
-            {
-                bool cancelled = false;
-                int maxRemoteId = GetSavedParameterAsInt(db, "SyncBackwardsFromLogId");
-                while (!cancelled && (maxRemoteId > 0))
-                {
-                    var EventPage = new Page<VendorEvent>();
-                    if (RESTRequest(ref EventPage, String.Format("/api/vendorevents/?maxRemoteId={0}&pageSize={1}", maxRemoteId, vendorEventPageSize)))
-                    {
-                        lock (db.WriteLock)
-                        {
-                            using (var trans = db.BeginTransaction())
-                            {
-                                using (var insertCommand = db.CreateCommand(
-                                    "INSERT INTO Logs (Id,  UserId,  VoucherId,  EventDate,  EventType,  Retry) " +
-                                              "VALUES (@id, @userid, @voucherid, @eventdate, @eventtype, @retry)",
-                                    trans))
-                                using (var updateCommand = db.CreateCommand(
-                                    "UPDATE Parameters SET Value=@Value WHERE Key='SyncBackwardsFromLogId'", trans))
-                                {
-                                    foreach (VendorEvent Event in EventPage.Items)
-                                    {
-                                        if (!Event.RemoteId.HasValue)
-                                        {
-                                            throw new Exception("Downloaded event with no remote ID");
-                                        }
-                                        else if (Event.RemoteId.Value > maxRemoteId)
-                                        {
-                                            throw new Exception("Downloaded event remote ID was not in descending order");
-                                        }
-
-                                        insertCommand.Parameters.Clear();
-                                        insertCommand.Parameters.AddWithValue("@id", Event.RemoteId);
-                                        insertCommand.Parameters.AddWithValue("@userid", Event.UserId);
-                                        insertCommand.Parameters.AddWithValue("@voucherid", Event.VoucherId);
-                                        insertCommand.Parameters.AddWithValue("@eventdate", Event.EventDate.UtcDateTime);
-                                        insertCommand.Parameters.AddWithValue("@eventtype", Event.EventType);
-                                        insertCommand.Parameters.AddWithValue("@retry", Event.Retry);
-                                        insertCommand.ExecuteNonQuery();
-
-                                        maxRemoteId = Event.RemoteId.Value - 1;
-                                    }
-
-                                    updateCommand.Parameters.Clear();
-                                    updateCommand.Parameters.AddWithValue("@Value", maxRemoteId.ToString());
-                                    updateCommand.ExecuteNonQuery();
-                                }
-
-                                trans.Commit();
-                            }
-                        }
-
-                        lock (Globals.LogDownloadThreadLock)
-                        {
-                            cancelled = Globals.LogDownloadThreadCancelled;
-                        }
-                    }
-                    else
-                    {
-                        lock (Globals.LogDownloadThreadLock)
-                        {
-                            if (!Globals.LogDownloadThreadCancelled)
-                            {
-                                Monitor.Wait(Globals.LogDownloadThreadLock, retryInterval);
-                            }
-                            cancelled = Globals.LogDownloadThreadCancelled;
-                        }
-                    }
-                }
-            }
-        }
-
         public static void TriggerLogDownload()
         {
-            if (Globals.LogDownloadThread == null)
+            if (Globals.LogDownloader == null)
             {
-                Globals.LogDownloadThread = new Thread(() => LogDownloadWorker());
-                Globals.LogDownloadThread.Start();
+                Globals.LogDownloader = new LogDownloader(Globals.DB);
+                Globals.LogDownloader.Start();
             }
         }