Move log upload thread to LogUploader class

BulkPrinting/BulkPrinting/BulkPrinting.csproj

       <DependentUpon>ExportForm.cs</DependentUpon>
     </Compile>
     <Compile Include="Globals.cs" />
+    <Compile Include="LogUploader.cs" />
     <Compile Include="Migrations.cs" />
     <Compile Include="ObservedForm.cs">
       <SubType>Form</SubType>

BulkPrinting/BulkPrinting/Globals.cs

         public static Printer MaxPrinter;
         public static List<int> OpenBatches;
         public static UserLimits UserCurrentUsage;
-        public static Thread LogUploadThread;
-        public static object LogUploadThreadLock = new object();
-        public static bool LogUploadThreadCancelled;
-        public static bool UploadNewLogs;
+        public static LogUploader LogUploader;
         public static Thread LogDownloadThread;
         public static object LogDownloadThreadLock = new object();
         public static bool LogDownloadThreadCancelled;

BulkPrinting/BulkPrinting/LogUploader.cs

+using System;
+using System.Collections.Generic;
+using System.Data.SQLite;
+using System.Threading;
+
+namespace BulkPrinting
+{
+    public class LogUploader
+    {
+        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()
+        {
+            var isCancelled = false;
+            while (!isCancelled)
+            {
+                var uploadFailed = false;
+                int lastSyncedLogId = Utility.GetLastSyncedLogID();
+
+                var result = _db.ExecuteScalar("SELECT MAX(Id) FROM Logs")?.ToString() ?? "0";
+                if (string.IsNullOrWhiteSpace(result))
+                {
+                    result = "0";
+                }
+                int lastRecordedLogId = int.Parse(result.ToString());
+
+                if (lastRecordedLogId > lastSyncedLogId)
+                {
+                    List<RemoteVendorEvent> eventList = new List<RemoteVendorEvent>();
+                    int counter = 0;
+                    using (var Command = _db.CreateCommand(
+                        "Select Id,UserId,VoucherId,EventDate,EventType From Logs WHERE Id > @id",
+                        new SQLiteParameter("@id", lastSyncedLogId)))
+                    {
+                        using (SQLiteDataReader read = Command.ExecuteReader())
+                        {
+                            while (read.Read())
+                            {
+                                counter += 1;
+                                var nextEvent = new RemoteVendorEvent();
+                                nextEvent.Id = read.GetInt32(0);
+                                nextEvent.UserId = read.GetInt32(1);
+                                if (read.IsDBNull(2) == true)
+                                {
+                                    nextEvent.VoucherId = null;
+                                }
+                                else
+                                {
+                                    nextEvent.VoucherId = read.GetInt32(2);
+                                }
+                                nextEvent.EventDate = read.GetDateTime(3);
+                                nextEvent.EventType = (VendorEvent.VendorEventType)Enum.Parse(typeof(VendorEvent.VendorEventType), read.GetValue(4).ToString());
+                                nextEvent.VendorId = Globals.SessionData.Credentials.Payload.Vendor.id;
+                                eventList.Add(nextEvent);
+
+                                if (counter == _uploadPageSize)
+                                {
+                                    var response = new RemoteVendorEventResponse();
+                                    if (Utility.RESTRequest(eventList, ref response, "/api/vendorevents/"))
+                                    {
+                                        counter = 0;
+                                        eventList.Clear();
+                                    }
+                                    else
+                                    {
+                                        uploadFailed = true;
+                                        break;
+                                    }
+                                }
+                            }
+                            if ((counter > 0) && ! uploadFailed)
+                            {
+                                var response = new RemoteVendorEventResponse();
+                                if (!Utility.RESTRequest(eventList, ref response, "/api/vendorevents/"))
+                                {
+                                    uploadFailed = true;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                lock (_lock)
+                {
+                    while (!_cancelled && !_uploadTriggered)
+                    {
+                        Monitor.Wait(_lock, uploadFailed ? _retryInterval : Timeout.Infinite);
+                        if (uploadFailed)
+                        {
+                            break;
+                        }
+                    }
+                    _uploadTriggered = false;
+                    isCancelled = _cancelled;
+                }
+            }
+        }
+
+        public void Start()
+        {
+            _thread.Start();
+        }
+
+        public void TriggerUpload()
+        {
+            lock (_lock)
+            {
+                _uploadTriggered = true;
+                Monitor.Pulse(_lock);
+            }
+        }
+    }
+}

BulkPrinting/BulkPrinting/Utility.cs

                     new SQLiteParameter("@value", SessionDataJson));
                 LogEvent(Globals.DB, VendorEvent.VendorEventType.Logout);
 
-                CancelLogUploadWorker();
+                if (Globals.LogUploader != null)
+                    Globals.LogUploader.Cancel();
+
                 CancelLogDownloadWorker();
 
-                if (Globals.LogUploadThread != null)
+                if (Globals.LogUploader != null)
                 {
-                    Globals.LogUploadThread.Join();
-                    Globals.LogUploadThread = null;
+                    Globals.LogUploader.Join();
+                    Globals.LogUploader = null;
                 }
+
                 if (Globals.LogDownloadThread != null)
                 {
                     Globals.LogDownloadThread.Join();
                     Globals.LogDownloadThread = null;
                 }
 
-                Globals.UploadNewLogs = false;
-                Globals.LogUploadThreadCancelled = false;
                 Globals.LogDownloadThreadCancelled = false;
 
                 Globals.DB.Close();
             }
         }
 
-        public static void CancelLogUploadWorker()
-        {
-            lock (Globals.LogUploadThreadLock)
-            {
-                Globals.LogUploadThreadCancelled = true;
-                Monitor.Pulse(Globals.LogUploadThreadLock);
-            }
-        }
-
-        public static void LogUploadWorker()
-        {
-            const int uploadPageSize = 1000;
-            var retryInterval = 30000;
-
-            var db = Globals.DB;
-            //using (var db = OpenDBConnection())
-            {
-                var cancelled = false;
-                while (! cancelled)
-                {
-                    var uploadFailed = false;
-                    int lastSyncedLogId = GetLastSyncedLogID();
-
-                    var result = db.ExecuteScalar("SELECT MAX(Id) FROM Logs")?.ToString() ?? "0";
-                    if (string.IsNullOrWhiteSpace(result))
-                    {
-                        result = "0";
-                    }
-                    int lastRecordedLogId = int.Parse(result.ToString());
-
-                    if (lastRecordedLogId > lastSyncedLogId)
-                    {
-                        List<RemoteVendorEvent> eventList = new List<RemoteVendorEvent>();
-                        int counter = 0;
-                        using (var Command = db.CreateCommand("Select Id,UserId,VoucherId,EventDate,EventType From Logs WHERE Id > @id",
-                            new SQLiteParameter("@id", lastSyncedLogId)))
-                        {
-                            using (SQLiteDataReader read = Command.ExecuteReader())
-                            {
-                                while (read.Read())
-                                {
-                                    counter += 1;
-                                    var nextEvent = new RemoteVendorEvent();
-                                    nextEvent.Id = read.GetInt32(0);
-                                    nextEvent.UserId = read.GetInt32(1);
-                                    if (read.IsDBNull(2) == true)
-                                    {
-                                        nextEvent.VoucherId = null;
-                                    }
-                                    else
-                                    {
-                                        nextEvent.VoucherId = read.GetInt32(2);
-                                    }
-                                    nextEvent.EventDate = read.GetDateTime(3);
-                                    nextEvent.EventType = (VendorEvent.VendorEventType)Enum.Parse(typeof(VendorEvent.VendorEventType), read.GetValue(4).ToString());
-                                    nextEvent.VendorId = Globals.SessionData.Credentials.Payload.Vendor.id;
-                                    eventList.Add(nextEvent);
-
-                                    if (counter == uploadPageSize)
-                                    {
-                                        var response = new RemoteVendorEventResponse();
-                                        if (RESTRequest(eventList, ref response, "/api/vendorevents/"))
-                                        {
-                                            counter = 0;
-                                            eventList.Clear();
-                                        }
-                                        else
-                                        {
-                                            uploadFailed = true;
-                                            break;
-                                        }
-                                    }
-                                }
-                                if (counter > 0)
-                                {
-                                    var response = new RemoteVendorEventResponse();
-                                    if (!RESTRequest(eventList, ref response, "/api/vendorevents/"))
-                                    {
-                                        uploadFailed = true;
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    lock (Globals.LogUploadThreadLock)
-                    {
-                        while (! Globals.LogUploadThreadCancelled && ! Globals.UploadNewLogs)
-                        {
-                            Monitor.Wait(Globals.LogUploadThreadLock, uploadFailed ? retryInterval : Timeout.Infinite);
-                            if (uploadFailed)
-                            {
-                                break;
-                            }
-                        }
-                        Globals.UploadNewLogs = false;
-                        cancelled = Globals.LogUploadThreadCancelled;
-                    }
-                }
-            }
-        }
-
         public static void TriggerLogUpload()
         {
-            if (Globals.LogUploadThread == null)
+            if (Globals.LogUploader == null)
             {
-                Globals.LogUploadThread = new Thread(() => LogUploadWorker());
-                Globals.LogUploadThread.Start();
+                Globals.LogUploader = new LogUploader(Globals.DB);
+                Globals.LogUploader.Start();
             }
             else
             {
-                lock (Globals.LogUploadThreadLock)
-                {
-                    Globals.UploadNewLogs = true;
-                    Monitor.Pulse(Globals.LogUploadThreadLock);
-                }
+                Globals.LogUploader.TriggerUpload();
             }
         }