Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango

1 files changed, 583 insertions, 85 deletions

diff --git a/Software/Visual_Studio/PPC/Tango.PPC.Common/MachineUpdate/MachineUpdateManager.cs b/Software/Visual_Studio/PPC/Tango.PPC.Common/MachineUpdate/MachineUpdateManager.cs
index 5296a9f34..d0424254b 100644
--- a/Software/Visual_Studio/PPC/Tango.PPC.Common/MachineUpdate/MachineUpdateManager.cs
+++ b/Software/Visual_Studio/PPC/Tango.PPC.Common/MachineUpdate/MachineUpdateManager.cs
@@ -10,6 +10,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Tango.BL;
+using Tango.BL.Entities;
 using Tango.Core;
 using Tango.Core.DB;
 using Tango.Core.ExtensionMethods;
@@ -22,12 +23,14 @@ using Tango.PMR.Synchronization;
 using Tango.PPC.Common.Application;
 using Tango.PPC.Common.Connection;
 using Tango.PPC.Common.Navigation;
+using Tango.PPC.Common.Publish;
 using Tango.PPC.Common.UpdatePackages;
 using Tango.PPC.Common.Web;
 using Tango.Settings;
 using Tango.SharedUI.Helpers;
 using Tango.SQLExaminer;
 using Tango.Transport.Web;
+using System.Data.Entity;
 
 namespace Tango.PPC.Common.MachineUpdate
 {
@@ -40,6 +43,8 @@ namespace Tango.PPC.Common.MachineUpdate
         private List<LogItemBase> _logs;
         private System.Timers.Timer _checkForUpdateTimer;
         private bool _isUpdating;
+        private PPCSettings _settings;
+        private DateTime _updateStartDate;
 
         #region Events
 
@@ -76,7 +81,7 @@ namespace Tango.PPC.Common.MachineUpdate
         /// <summary>
         /// Gets or sets a value indicating whether to automatically check for new application updates.
         /// </summary>
-        public bool AutoCheckForUpdates
+        public bool EnableAutoCheckForUpdates
         {
             get { return _autoCheckForUpdates; }
             set { _autoCheckForUpdates = value; RaisePropertyChangedAuto(); }
@@ -96,7 +101,7 @@ namespace Tango.PPC.Common.MachineUpdate
             _machineProvider = machineProvider;
             _app_manager = applicationManager;
             _packageRunner = packageRunner;
-            _packageRunner.PackageStateChanged += _packageRunner_PackageStateChanged;
+            _packageRunner.PackageProgress += _packageRunner_PackageProgress;
 
             _logs = new List<LogItemBase>();
             LogManager.NewLog += LogManager_NewLog;
@@ -104,20 +109,25 @@ namespace Tango.PPC.Common.MachineUpdate
             _checkForUpdateTimer = new System.Timers.Timer(TimeSpan.FromMinutes(1).TotalMilliseconds);
             _checkForUpdateTimer.Elapsed += _checkForUpdateTimer_Elapsed;
             _checkForUpdateTimer.Start();
+
+            _settings = SettingsManager.Default.GetOrCreate<PPCSettings>();
         }
 
         #endregion
 
         #region Event Handlers
 
-        private void _packageRunner_PackageStateChanged(object sender, PackageStateChangedEventArgs e)
+        private void _packageRunner_PackageProgress(object sender, PackageProgressEventArgs e)
         {
-            UpdateProgress(e.PackageType == PackageType.Pre ? "Preparing" : "Finalizing", e.PackageName);
+            UpdateProgress(e.PackageName, e.Message, e.IsIntermediate, e.Progress, e.Total);
         }
 
         private void LogManager_NewLog(object sender, LogItemBase e)
         {
-            _logs.Add(e);
+            if (_isUpdating)
+            {
+                _logs.Add(e);
+            }
         }
 
         #endregion
@@ -133,40 +143,85 @@ namespace Tango.PPC.Common.MachineUpdate
             });
         }
 
-        private async void OnFailed(Exception ex, TaskCompletionSource<MachineUpdateResult> completionSource, DownloadUpdateResponse response, bool performDatabaseRollback, String dbBackupFile, Tango.Core.DataSource localDataSource)
+        private async void OnFailed(Exception ex, TaskCompletionSource<MachineUpdateResult> completionSource, DownloadUpdateResponse response, bool performDatabaseRollback, String dbBackupFile, String backupsFolder, String tempDbName, Tango.Core.DataSource localDataSource, String tempUpdatePackageFolder = null, PublishInfo tupPublishInfo = null)
         {
             LogManager.Log(ex, "An error occurred in machine update.");
 
-            if (performDatabaseRollback)
+            await Task.Factory.StartNew(() =>
             {
-                LogManager.Log("Rolling back database changes...");
 
-                using (DbManager db = DbManager.FromDataSource(localDataSource))
+                if (performDatabaseRollback)
+                {
+                    LogManager.Log("Rolling back database changes...");
+
+                    using (DbManager db = DbManager.FromDataSource(localDataSource))
+                    {
+                        try
+                        {
+                            UpdateProgress("Rollback", "Rolling back database changes...");
+                            db.Restore(localDataSource.Catalog, dbBackupFile);
+                            LogManager.Log("Database restored successfully.");
+                        }
+                        catch (Exception e)
+                        {
+                            LogManager.Log(e, "Could not rollback the database.");
+                        }
+                        finally
+                        {
+                            try
+                            {
+                                File.Delete(dbBackupFile);
+                            }
+                            catch { }
+                        }
+                    }
+                }
+
+                if (tempDbName != null)
                 {
                     try
                     {
-                        UpdateProgress("Rollback", "Rolling back database changes...");
-                        await Task.Factory.StartNew(() => db.Restore(localDataSource.Catalog, dbBackupFile));
-                        LogManager.Log("Database restored successfully.");
+                        LogManager.Log($"Removing temporary database '{tempDbName}'...");
+                        using (DbManager dbManager = DbManager.FromDataSource(localDataSource))
+                        {
+                            dbManager.SetOffline(tempDbName);
+                            dbManager.SetOnline(tempDbName);
+                            dbManager.Delete(tempDbName);
+                        }
                     }
-                    catch (Exception e)
+                    catch (Exception exx)
                     {
-                        LogManager.Log(e, "Could not rollback the database.");
-                        throw ex;
+                        LogManager.Log(exx, "Error removing temporary database.");
                     }
-                    finally
+                }
+
+                try
+                {
+                    Directory.Delete(backupsFolder, true);
+                }
+                catch (Exception ee)
+                {
+                    LogManager.Log(ee, $"Error deleting backups folder '{backupsFolder}'.");
+                }
+
+                if (tempUpdatePackageFolder != null)
+                {
+                    try
                     {
-                        try
-                        {
-                            File.Delete(dbBackupFile);
-                        }
-                        catch { }
+                        Directory.Delete(tempUpdatePackageFolder, true);
+                    }
+                    catch (Exception eee)
+                    {
+                        LogManager.Log(eee, "Error removing temporary package folder.");
                     }
                 }
-            }
+
+            });
 
             completionSource.SetException(ex);
 
+            String logs = GetLogsStringAndClear();
+
             if (response != null)
             {
                 try
@@ -176,25 +231,108 @@ namespace Tango.PPC.Common.MachineUpdate
                         Token = response.NotifyCompletedToken,
                         Status = BL.Enumerations.TangoUpdateStatuses.UpdateFailed,
                         FailedReason = ex.FlattenMessage(),
-                        FailedLog = GetLogsStringAndClear(),
+                        FailedLog = logs,
                     });
                 }
                 catch (Exception xx)
                 {
                     LogManager.Log(xx, "Error notifying update failed.");
                 }
+
+                try
+                {
+                    using (ObservablesContext db = ObservablesContext.CreateDefault())
+                    {
+                        TangoUpdate update = new TangoUpdate();
+                        update.ApplicationVersion = response.Version;
+                        update.FirmwareVersion = response.FirmwareVersion;
+                        update.MachineGuid = _machineProvider.Machine.Guid;
+                        update.UpdateStatus = BL.Enumerations.TangoUpdateStatuses.UpdateFailed;
+                        update.StartDate = _updateStartDate;
+                        update.EndDate = DateTime.UtcNow;
+                        update.FailedReason = ex.FlattenMessage();
+                        update.FailedLog = logs;
+                        await db.SaveChangesAsync();
+                    }
+                }
+                catch (Exception xxx)
+                {
+                    LogManager.Log(xxx, "Error saving tango update information to database.");
+                }
+            }
+
+
+            if (tupPublishInfo != null)
+            {
+                try
+                {
+                    using (ObservablesContext db = ObservablesContext.CreateDefault())
+                    {
+                        TangoUpdate update = new TangoUpdate();
+                        update.ApplicationVersion = tupPublishInfo.ApplicationVersion;
+                        update.FirmwareVersion = tupPublishInfo.GetFirmwareVersion();
+                        update.MachineGuid = _machineProvider.Machine.Guid;
+                        update.UpdateStatus = BL.Enumerations.TangoUpdateStatuses.OfflineUpdateFailed;
+                        update.StartDate = _updateStartDate;
+                        update.EndDate = DateTime.UtcNow;
+                        update.FailedReason = ex.FlattenMessage();
+                        update.FailedLog = logs;
+                        await db.SaveChangesAsync();
+                    }
+                }
+                catch (Exception xxx)
+                {
+                    LogManager.Log(xxx, "Error saving tango offline update information to database.");
+                }
             }
 
             _isUpdating = false;
         }
 
-        private async void OnCompleted(MachineUpdateResult result, TaskCompletionSource<MachineUpdateResult> completionSource, DownloadUpdateResponse response, String dbBackupFile)
+        private async void OnCompleted(MachineUpdateResult result, TaskCompletionSource<MachineUpdateResult> completionSource, DownloadUpdateResponse response, String tempDbName, String backupsFolder, Core.DataSource localDataSource, PublishInfo tupPublishInfo = null)
         {
-            try
+            await Task.Factory.StartNew(() =>
             {
-                File.Delete(dbBackupFile);
-            }
-            catch { }
+                if (tempDbName != null)
+                {
+                    try
+                    {
+                        LogManager.Log($"Removing temporary database '{tempDbName}'...");
+                        using (DbManager dbManager = DbManager.FromDataSource(localDataSource))
+                        {
+                            dbManager.SetOffline(tempDbName);
+                            dbManager.SetOnline(tempDbName);
+                            dbManager.Delete(tempDbName);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        LogManager.Log(ex, "Error removing temporary database.");
+                    }
+                }
+
+                try
+                {
+                    Directory.Delete(backupsFolder, true);
+                }
+                catch (Exception ex)
+                {
+                    LogManager.Log(ex, $"Error deleting backups folder '{backupsFolder}'.");
+                }
+
+                if (!result.RequiresBinariesUpdate)
+                {
+                    try
+                    {
+                        Directory.Delete(result.UpdatePackagePath, true);
+                    }
+                    catch (Exception ex)
+                    {
+                        LogManager.Log(ex, "Error removing temporary package folder.");
+                    }
+                }
+
+            });
 
             completionSource.SetResult(result);
 
@@ -212,26 +350,47 @@ namespace Tango.PPC.Common.MachineUpdate
                 {
                     LogManager.Log(ex, "Error notifying update completed.");
                 }
+
+                try
+                {
+                    using (ObservablesContext db = ObservablesContext.CreateDefault())
+                    {
+                        TangoUpdate update = new TangoUpdate();
+                        update.ApplicationVersion = response.Version;
+                        update.FirmwareVersion = response.FirmwareVersion;
+                        update.MachineGuid = (await db.Machines.FirstAsync()).Guid;
+                        update.UpdateStatus = BL.Enumerations.TangoUpdateStatuses.UpdateCompleted;
+                        update.StartDate = _updateStartDate;
+                        update.EndDate = DateTime.UtcNow;
+                        await db.SaveChangesAsync();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    LogManager.Log(ex, "Error saving tango update information to database.");
+                }
             }
 
-            _isUpdating = false;
-        }
 
-        private void OnCompleted(UpdateDBResponse response)
-        {
-            if (response != null)
+            if (tupPublishInfo != null)
             {
                 try
                 {
-                    var r = _client.NotifyUpdateCompleted(new MachineUpdateCompletedRequest()
+                    using (ObservablesContext db = ObservablesContext.CreateDefault())
                     {
-                        Token = response.NotifyCompletedToken,
-                        Status = BL.Enumerations.TangoUpdateStatuses.DatabaseCompleted,
-                    }).Result;
+                        TangoUpdate update = new TangoUpdate();
+                        update.ApplicationVersion = tupPublishInfo.ApplicationVersion;
+                        update.FirmwareVersion = tupPublishInfo.GetFirmwareVersion();
+                        update.MachineGuid = _machineProvider.Machine.Guid;
+                        update.UpdateStatus = BL.Enumerations.TangoUpdateStatuses.OfflineUpdateCompleted;
+                        update.StartDate = _updateStartDate;
+                        update.EndDate = DateTime.UtcNow;
+                        await db.SaveChangesAsync();
+                    }
                 }
-                catch (Exception ex)
+                catch (Exception xxx)
                 {
-                    LogManager.Log(ex, "Error notifying database completed.");
+                    LogManager.Log(xxx, "Error saving tango offline update information to database.");
                 }
             }
 
@@ -270,6 +429,8 @@ namespace Tango.PPC.Common.MachineUpdate
                 }
             }
 
+            String logs = GetLogsStringAndClear();
+
             if (response != null)
             {
                 try
@@ -279,13 +440,78 @@ namespace Tango.PPC.Common.MachineUpdate
                         Token = response.NotifyCompletedToken,
                         Status = BL.Enumerations.TangoUpdateStatuses.DatabaseFailed,
                         FailedReason = ex.FlattenMessage(),
-                        FailedLog = GetLogsStringAndClear(),
+                        FailedLog = logs,
                     }).Result;
                 }
                 catch (Exception xx)
                 {
                     LogManager.Log(xx, "Error notifying database failed.");
                 }
+
+                try
+                {
+                    using (ObservablesContext db = ObservablesContext.CreateDefault())
+                    {
+                        TangoUpdate update = new TangoUpdate();
+                        update.ApplicationVersion = _app_manager.Version.ToString();
+                        update.FirmwareVersion = _app_manager.FirmwareVersion.ToString();
+                        update.MachineGuid = _machineProvider.Machine.Guid;
+                        update.UpdateStatus = BL.Enumerations.TangoUpdateStatuses.DatabaseFailed;
+                        update.StartDate = _updateStartDate;
+                        update.EndDate = DateTime.UtcNow;
+                        update.FailedReason = ex.FlattenMessage();
+                        update.FailedLog = logs;
+                        db.SaveChanges();
+                    }
+                }
+                catch (Exception exx)
+                {
+                    LogManager.Log(exx, "Error saving database update information to database.");
+                }
+            }
+
+            _isUpdating = false;
+        }
+
+        private void OnCompleted(UpdateDBResponse response, bool completedWithNoDifferences = false)
+        {
+            if (response != null)
+            {
+                try
+                {
+                    var r = _client.NotifyUpdateCompleted(new MachineUpdateCompletedRequest()
+                    {
+                        Token = response.NotifyCompletedToken,
+                        Status = BL.Enumerations.TangoUpdateStatuses.DatabaseCompleted,
+                        ReportsAboutDbCheckNoDifferences = completedWithNoDifferences,
+                    }).Result;
+                }
+                catch (Exception ex)
+                {
+                    LogManager.Log(ex, "Error notifying database completed.");
+                }
+
+                if (!completedWithNoDifferences)
+                {
+                    try
+                    {
+                        using (ObservablesContext db = ObservablesContext.CreateDefault())
+                        {
+                            TangoUpdate update = new TangoUpdate();
+                            update.ApplicationVersion = _app_manager.Version.ToString();
+                            update.FirmwareVersion = _app_manager.FirmwareVersion.ToString();
+                            update.MachineGuid = _machineProvider.Machine.Guid;
+                            update.UpdateStatus = BL.Enumerations.TangoUpdateStatuses.DatabaseCompleted;
+                            update.StartDate = _updateStartDate;
+                            update.EndDate = DateTime.UtcNow;
+                            db.SaveChanges();
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        LogManager.Log(ex, "Error saving database update information to database.");
+                    }
+                }
             }
 
             _isUpdating = false;
@@ -315,8 +541,9 @@ namespace Tango.PPC.Common.MachineUpdate
         /// or
         /// </exception>
         /// <exception cref="System.InvalidProgramException">Database tango does not exists.</exception>
-        public async Task<MachineUpdateResult> Update(String serialNumber, bool setupFirmware, bool setupFPGA)
+        public async Task<MachineUpdateResult> Update(bool setupFirmware, bool setupFPGA)
         {
+            _updateStartDate = DateTime.UtcNow;
             _logs.Clear();
 
             TaskCompletionSource<MachineUpdateResult> result = new TaskCompletionSource<MachineUpdateResult>();
@@ -325,12 +552,19 @@ namespace Tango.PPC.Common.MachineUpdate
             bool performDatabaseRollback = false;
             String dbBackupFile = null;
             DownloadUpdateResponse update_response = null;
+            String backupsFolder = "C:\\Backups";
+
+            //Create temporary folders for packages.
+            var _newPackageTempFolder = TemporaryManager.CreateFolder();
+            _newPackageTempFolder.Persist = true;
+
+            String serialNumber = _machineProvider.Machine.SerialNumber;
 
             try
             {
                 _isUpdating = true;
 
-                var machineServiceAddress = SettingsManager.Default.GetOrCreate<PPCSettings>().GetMachineServiceAddress();
+                var machineServiceAddress = _settings.GetMachineServiceAddress();
 
                 LogManager.Log($"Starting machine update for serial number {serialNumber}...");
 
@@ -371,10 +605,6 @@ namespace Tango.PPC.Common.MachineUpdate
 
                 LogManager.Log($"Machine update response received: {Environment.NewLine}{update_response.ToJsonString()}");
 
-                //Create temporary folders for packages.
-                var _newPackageTempFolder = TemporaryManager.CreateFolder();
-                _newPackageTempFolder.Persist = true;
-
                 LogManager.Log($"Temporary package folder created: {_newPackageTempFolder}.");
 
                 //Download software package.
@@ -413,8 +643,12 @@ namespace Tango.PPC.Common.MachineUpdate
                 UpdateProgress("Downloading software package", "Extracting package...");
 
                 LogManager.Log("Extracting downloaded zip file...");
-                //Extract software package.
-                ZipFile.ExtractToDirectory(tempFile, _newPackageTempFolder);
+
+                await Task.Factory.StartNew(() =>
+                {
+                    //Extract software package.
+                    ZipFile.ExtractToDirectory(tempFile, _newPackageTempFolder);
+                });
 
                 LogManager.Log("Copying latest updater utility to application path...");
                 //Copy new updater utility to app path.
@@ -464,8 +698,8 @@ namespace Tango.PPC.Common.MachineUpdate
                 //Create Database Backup
                 try
                 {
-                    Directory.CreateDirectory("C:\\Backups");
-                    dbBackupFile = $"C:\\Backups\\{Path.GetRandomFileName()}.bak";
+                    Directory.CreateDirectory(backupsFolder);
+                    dbBackupFile = $"{backupsFolder}\\{Path.GetRandomFileName()}.bak";
                     LogManager.Log($"Creating database backup to '{dbBackupFile}'...");
                     await Task.Factory.StartNew(() => db.Backup(localDataSource.Catalog, dbBackupFile));
                     performDatabaseRollback = true;
@@ -548,7 +782,7 @@ namespace Tango.PPC.Common.MachineUpdate
                     handler.Failed += (_, ex) =>
                     {
                         stream.Dispose();
-                        OnFailed(ex, result, update_response, performDatabaseRollback, dbBackupFile, localDataSource);
+                        OnFailed(ex, result, update_response, performDatabaseRollback, dbBackupFile, backupsFolder, null, localDataSource, _newPackageTempFolder);
                     };
                     handler.Completed += (_, __) =>
                     {
@@ -557,12 +791,12 @@ namespace Tango.PPC.Common.MachineUpdate
                         OnCompleted(new MachineUpdateResult()
                         {
                             UpdatePackagePath = _newPackageTempFolder,
-                        }, result, update_response, dbBackupFile);
+                        }, result, update_response, null, backupsFolder, localDataSource);
                     };
                     handler.Canceled += (_, __) =>
                     {
                         stream.Dispose();
-                        OnFailed(new Exception("The operation has been canceled."), result, update_response, performDatabaseRollback, dbBackupFile, localDataSource);
+                        OnFailed(new Exception("The operation has been canceled."), result, update_response, performDatabaseRollback, dbBackupFile, backupsFolder, null, localDataSource, _newPackageTempFolder);
                     };
                     handler.Progress += (_, e) =>
                     {
@@ -574,12 +808,12 @@ namespace Tango.PPC.Common.MachineUpdate
                     OnCompleted(new MachineUpdateResult()
                     {
                         UpdatePackagePath = _newPackageTempFolder,
-                    }, result, update_response, dbBackupFile);
+                    }, result, update_response, null, backupsFolder, localDataSource);
                 }
             }
             catch (Exception ex)
             {
-                OnFailed(ex, result, update_response, performDatabaseRollback, dbBackupFile, localDataSource);
+                OnFailed(ex, result, update_response, performDatabaseRollback, dbBackupFile, backupsFolder, null, localDataSource, _newPackageTempFolder);
             }
 
             return await result.Task;
@@ -597,7 +831,7 @@ namespace Tango.PPC.Common.MachineUpdate
             {
                 _isUpdating = true;
 
-                var machineServiceAddress = SettingsManager.Default.GetOrCreate<PPCSettings>().GetMachineServiceAddress();
+                var machineServiceAddress = _settings.GetMachineServiceAddress();
 
                 LogManager.Log($"Connecting to machine service on {machineServiceAddress}...");
 
@@ -611,6 +845,8 @@ namespace Tango.PPC.Common.MachineUpdate
 
                 try
                 {
+                    request.MachineLastUpdated = _machineProvider.Machine.LastUpdated;
+
                     using (ObservablesContext db = ObservablesContext.CreateDefault())
                     {
                         request.Rmls = db.Rmls.ToList().Select(x => new UpdatedEntity(x)).ToList();
@@ -643,6 +879,7 @@ namespace Tango.PPC.Common.MachineUpdate
         /// <returns></returns>
         public Task UpdateDB(DbCompareResult dbCompareResult, String serialNumber)
         {
+            _updateStartDate = DateTime.UtcNow;
             _logs.Clear();
 
             return Task.Factory.StartNew(() =>
@@ -770,7 +1007,7 @@ namespace Tango.PPC.Common.MachineUpdate
         {
             return Task.Factory.StartNew<DbCompareResult>(() =>
             {
-                var machineServiceAddress = SettingsManager.Default.GetOrCreate<PPCSettings>().GetMachineServiceAddress();
+                var machineServiceAddress = _settings.GetMachineServiceAddress();
 
                 LogManager.Log($"Checking if database update is required for serial number {serialNumber}...");
 
@@ -789,6 +1026,8 @@ namespace Tango.PPC.Common.MachineUpdate
 
                 UpdateDBRequest request = new UpdateDBRequest();
                 request.SerialNumber = serialNumber;
+                request.ApplicationVersion = _app_manager.Version.ToString();
+                request.FirmwareVersion = _app_manager.FirmwareVersion.ToString();
 
                 UpdateDBResponse update_response = null;
 
@@ -856,12 +1095,18 @@ namespace Tango.PPC.Common.MachineUpdate
                     }
                     catch (Exception ex)
                     {
+                        OnFailed(ex, update_response, false, null, null);
                         throw LogManager.Log(ex, "Update manager error while trying to compare the database.");
                     }
                 }
 
                 LogManager.Log("Comparison completed successfully.");
 
+                if (!has_differences)
+                {
+                    OnCompleted(update_response, true);
+                }
+
                 return new DbCompareResult()
                 {
                     RequiresUpdate = has_differences,
@@ -875,31 +1120,286 @@ namespace Tango.PPC.Common.MachineUpdate
         /// </summary>
         /// <param name="fileName">Name of the file.</param>
         /// <returns></returns>
-        public Task<MachineUpdateResult> UpdateFromTUP(string fileName)
+        public async Task<MachineUpdateResult> UpdateFromTUP(string fileName, bool setupFirmware, bool setupFPGA)
         {
-            return Task.Factory.StartNew<MachineUpdateResult>(() =>
+            _updateStartDate = DateTime.UtcNow;
+            _logs.Clear();
+
+            TaskCompletionSource<MachineUpdateResult> result = new TaskCompletionSource<MachineUpdateResult>();
+
+            var localDataSource = SettingsManager.Default.GetOrCreate<CoreSettings>().DataSource;
+            bool performDatabaseRollback = false;
+            String dbBackupFile = null;
+            String tempDbName = "Tango_TUP";
+            String tempDbFileName = tempDbName + ".bak";
+            String backupsFolder = "C:\\Backups";
+            bool replaceBinaries = false;
+            PublishInfo publishInfo = null;
+
+            String serialNumber = _machineProvider.Machine.SerialNumber;
+
+            //Create temporary folders for packages.
+            var _newPackageTempFolder = TemporaryManager.CreateFolder();
+            _newPackageTempFolder.Persist = true;
+
+            try
             {
-                LogManager.Log($"Starting machine update from update package '{fileName}'...");
+                _isUpdating = true;
+
+                LogManager.Log($"Starting machine update for serial number {serialNumber}...");
+
+                //Connecting to machine...
+                LogManager.Log("Verifying machine connection and state...");
 
-                //Create temporary folders for packages.
-                var _newPackageTempFolder = TemporaryManager.CreateFolder();
-                _newPackageTempFolder.Persist = true;
+                UpdateProgress("Verifying machine state", "Initializing...");
 
-                LogManager.Log("Extracting downloaded zip file...");
-                //Extract software package.
-                ZipFile.ExtractToDirectory(fileName, _newPackageTempFolder);
+                await Task.Delay(1000);
+
+                IMachineOperator op = _machineProvider.MachineOperator;
+
+                if (setupFirmware)
+                {
+                    LogManager.Log("Machine is configured to update firmware...");
+
+                    if (op.State != Transport.TransportComponentState.Connected)
+                    {
+                        throw LogManager.Log(new InvalidOperationException("Could not perform an update while the machine is not connected."));
+                    }
+                    if (op.Status != MachineStatuses.ReadyToDye)
+                    {
+                        throw LogManager.Log(new InvalidOperationException($"Could not perform an update while the machine is in {op.Status} status."));
+                    }
+                }
+
+                UpdateProgress("Exploring package", "Extracting...");
+                LogManager.Log("Extracting package...");
+
+                LogManager.Log($"Temporary package folder created: {_newPackageTempFolder}.");
+
+                await Task.Factory.StartNew(() =>
+                {
+                    //Extract software package.
+                    ZipFile.ExtractToDirectory(fileName, _newPackageTempFolder);
+                });
+
+                //Extracting publish info
+                UpdateProgress("Exploring package", "Verifying...");
+                publishInfo = PublishInfo.FromJson(File.ReadAllText(Path.Combine(_newPackageTempFolder, "version.json")));
+
+                if (!publishInfo.IsMachineTupPackage)
+                {
+                    throw new InvalidOperationException("The specified tup file is invalid. Updating a machine from a tup file requires a custom generated package.");
+                }
+
+                if (publishInfo.MachineSerialNumber != serialNumber)
+                {
+                    throw new InvalidOperationException("The specified tup file is invalid. The package was generated for a different machine.");
+                }
+
+                if (publishInfo.MachineDeploymentSlot != _settings.DeploymentSlot)
+                {
+                    throw new InvalidOperationException("The specified tup file is invalid. The package was generated on a different environment.");
+                }
+
+                replaceBinaries = _app_manager.Version.ToString() != publishInfo.ApplicationVersion;
 
                 LogManager.Log("Copying latest updater utility to application path...");
+
                 //Copy new updater utility to app path.
                 File.Copy(Path.Combine(_newPackageTempFolder, "Tango.PPC.Updater.exe"), Path.Combine(PathHelper.GetStartupPath(), "Tango.PPC.Updater.exe"), true);
 
-                LogManager.Log("Update operation completed!");
+                //Run pre-update packages.
+                try
+                {
+                    UpdateProgress("Preparing", "Running update packages...");
+                    LogManager.Log("Running pre-update packages...");
+                    var packagesFolder = Path.Combine(_newPackageTempFolder, "Packages");
 
-                return new MachineUpdateResult()
+                    Version updateVersion = new Version(1, 0, 0, 0);
+                    try
+                    {
+                        updateVersion = Version.Parse(publishInfo.ApplicationVersion);
+                    }
+                    catch (Exception ex)
+                    {
+                        LogManager.Log(ex, "Error parsing new version string for package runner.");
+                    }
+
+                    await _packageRunner.Run(PackageType.Pre, updateVersion, packagesFolder);
+                }
+                catch (Exception ex)
                 {
-                    UpdatePackagePath = _newPackageTempFolder,
+                    LogManager.Log(ex, "Error running pre-update packages...");
+                }
+
+                //Synchronize database
+                UpdateProgress("Updating Database", "Initializing...");
+
+                UpdateProgress("Updating Database", "Connecting to local database...");
+                LogManager.Log("Initializing database manager...");
+                DbManager db = DbManager.FromDataSource(localDataSource);
+
+                LogManager.Log("Checking Tango database exists on the local machine...");
+                if (!db.Exists(localDataSource.Catalog))
+                {
+                    throw new InvalidProgramException("Database tango does not exists.");
+                }
+
+                UpdateProgress("Updating Database", "Creating database backup...");
+
+                //Create Database Backup
+                try
+                {
+                    Directory.CreateDirectory(backupsFolder);
+                    dbBackupFile = $"{backupsFolder}\\{Path.GetRandomFileName()}.bak";
+                    LogManager.Log($"Creating database backup to '{dbBackupFile}'...");
+                    await Task.Factory.StartNew(() => db.Backup(localDataSource.Catalog, dbBackupFile));
+                    performDatabaseRollback = true;
+                    LogManager.Log("Database backup created successfully.");
+                }
+                catch (Exception ex)
+                {
+                    throw LogManager.Log(ex, "Update manager error while trying to create a database backup.");
+                }
+
+                LogManager.Log("Extracting database file from package...");
+                File.Copy(Path.Combine(_newPackageTempFolder, tempDbFileName), Path.Combine(backupsFolder, tempDbFileName));
+
+                LogManager.Log("Restoring package database as a new database...");
+                db.RestoreAsNew(tempDbName, Path.Combine(backupsFolder, tempDbFileName), backupsFolder);
+
+                Core.DataSource tempDbDataSource = new Core.DataSource();
+                tempDbDataSource.Address = localDataSource.Address;
+                tempDbDataSource.IntegratedSecurity = localDataSource.IntegratedSecurity;
+                tempDbDataSource.Type = localDataSource.Type;
+                tempDbDataSource.Catalog = tempDbName;
+
+                LogManager.Log("Disposing database manager.");
+                db.Dispose();
+
+                LogManager.Log($"Initializing {nameof(ExaminerSequenceConfigurationRunner)}...");
+
+                UpdateProgress("Updating Database", "Initializing update sequence...");
+
+                ExaminerSequenceConfigurationRunner runner = new ExaminerSequenceConfigurationRunner(
+                    Path.Combine(_newPackageTempFolder, "Update Scripts", "config.xml"),
+                    Path.Combine(_newPackageTempFolder, "Update Scripts"),
+                        tempDbDataSource,
+                        localDataSource,
+                        serialNumber);
+
+                runner.Log += (x, msg) =>
+                {
+                    LogManager.Log(msg);
+                    ProgressLog?.Invoke(this, msg);
                 };
-            });
+
+                runner.ScriptExecuting += (x, item) =>
+                {
+                    LogManager.Log($"Executing script {item.ToString()}...");
+                    UpdateProgress("Updating Database", item.Name + "...");
+                };
+
+                LogManager.Log("Starting synchronization process...");
+
+                try
+                {
+                    await runner.Run();
+                    LogManager.Log("Synchronization completed successfully!");
+                    UpdateProgress("Updating Database", "Database synchronization completed successfully.");
+                }
+                catch (Exception ex)
+                {
+                    throw LogManager.Log(ex, "Update manager error while trying to synchronize database.");
+                }
+
+                LogManager.Log("Getting setup firmware/fpga directly from db..");
+
+                using (var dbManager = DbManager.FromDataSource(localDataSource))
+                {
+                    try
+                    {
+                        String firmware = dbManager.GetValue($"SELECT TOP 1 * FROM MACHINES WHERE SERIAL_NUMBER = '{serialNumber}'", "SETUP_FIRMWARE");
+                        String fpga = dbManager.GetValue($"SELECT TOP 1 * FROM MACHINES WHERE SERIAL_NUMBER = '{serialNumber}'", "SETUP_FPGA");
+
+                        setupFirmware = bool.Parse(firmware);
+                        setupFPGA = bool.Parse(fpga);
+                    }
+                    catch (Exception ex)
+                    {
+                        LogManager.Log(ex, "Error getting new values of SETUP_FIRMWARE and SETUP_FPGA.");
+                    }
+                }
+
+                //Updating firmware
+                if (setupFirmware)
+                {
+                    UpdateProgress("Updating Firmware", "Connecting to firmware device...");
+                    LogManager.Log("");
+                    LogManager.Log("-------------------------------------------------------------------------");
+                    LogManager.Log("Updating Firmware...");
+
+                    UpdateProgress("Updating Firmware", "Loading firmware package...");
+                    var tfpPath = Path.Combine(_newPackageTempFolder, "firmware_package.tfp");
+                    var stream = new FileStream(tfpPath, FileMode.Open);
+
+                    if (!_machineProvider.Machine.IsDemo)
+                    {
+                        if (setupFPGA)
+                        {
+                            op.FirmwareUpgradeMode = FirmwareUpgradeModes.DFU | FirmwareUpgradeModes.TFP_PACKAGE;
+                        }
+                        else
+                        {
+                            op.FirmwareUpgradeMode = FirmwareUpgradeModes.DFU;
+                        }
+                    }
+                    else
+                    {
+                        op.FirmwareUpgradeMode = FirmwareUpgradeModes.TFP_PACKAGE;
+                    }
+
+                    var handler = await op.UpgradeFirmware(stream);
+                    handler.Failed += (_, ex) =>
+                    {
+                        stream.Dispose();
+                        OnFailed(ex, result, null, performDatabaseRollback, dbBackupFile, backupsFolder, tempDbName, localDataSource, _newPackageTempFolder, publishInfo);
+                    };
+                    handler.Completed += (_, __) =>
+                    {
+                        UpdateProgress("Updating Firmware", "Firmware update completed successfully.");
+                        stream.Dispose();
+                        OnCompleted(new MachineUpdateResult()
+                        {
+                            UpdatePackagePath = _newPackageTempFolder,
+                            RequiresBinariesUpdate = replaceBinaries,
+                        }, result, null, tempDbName, backupsFolder, localDataSource, publishInfo);
+                    };
+                    handler.Canceled += (_, __) =>
+                    {
+                        stream.Dispose();
+                        OnFailed(new Exception("The operation has been canceled."), result, null, performDatabaseRollback, dbBackupFile, backupsFolder, tempDbName, localDataSource, _newPackageTempFolder, publishInfo);
+                    };
+                    handler.Progress += (_, e) =>
+                    {
+                        UpdateProgress("Updating Firmware", e.Message, false, e.Current, e.Total);
+                    };
+                }
+                else
+                {
+                    OnCompleted(new MachineUpdateResult()
+                    {
+                        UpdatePackagePath = _newPackageTempFolder,
+                        RequiresBinariesUpdate = replaceBinaries,
+                    }, result, null, tempDbName, backupsFolder, localDataSource, publishInfo);
+                }
+            }
+            catch (Exception ex)
+            {
+                OnFailed(ex, result, null, performDatabaseRollback, dbBackupFile, backupsFolder, tempDbName, localDataSource, _newPackageTempFolder, publishInfo);
+            }
+
+            return await result.Task;
         }
 
         /// <summary>
@@ -907,25 +1407,23 @@ namespace Tango.PPC.Common.MachineUpdate
         /// </summary>
         /// <param name="filePath">The file path.</param>
         /// <returns></returns>
-        public Task<UpdatePackageFile> GetUpdatePackageFileInfo(string filePath)
+        public Task<PublishInfo> GetUpdatePackageFileInfo(string filePath)
         {
-            return Task.Factory.StartNew<UpdatePackageFile>(() =>
+            return Task.Factory.StartNew<PublishInfo>(() =>
             {
-                UpdatePackageFile file = new UpdatePackageFile();
-                var tempFolder = TemporaryManager.CreateFolder();
-
                 using (Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(filePath))
                 {
-                    var appEntry = zip.Entries.SingleOrDefault(x => x.FileName == "Tango.PPC.UI.exe");
-                    appEntry.Extract(tempFolder);
-                }
-
-                FileVersionInfo info = FileVersionInfo.GetVersionInfo(Path.Combine(tempFolder, "Tango.PPC.UI.exe"));
-                file.Version = Version.Parse(info.ProductVersion);
+                    var appEntry = zip.Entries.SingleOrDefault(x => x.FileName == "version.json");
+                    var reader = appEntry.OpenReader();
 
-                tempFolder.Delete();
+                    using (StreamReader stReader = new StreamReader(reader))
+                    {
+                        String json = stReader.ReadToEnd();
+                        reader.Dispose();
 
-                return file;
+                        return PublishInfo.FromJson(json);
+                    }
+                }
             });
         }
 
@@ -948,7 +1446,7 @@ namespace Tango.PPC.Common.MachineUpdate
             String packagesFolder = Path.Combine(AssemblyHelper.GetCurrentAssemblyFolder(), "packages");
 
             Version previousVersion = null;
-            String str = SettingsManager.Default.GetOrCreate<PPCSettings>().PreviousApplicationVersion;
+            String str = _settings.PreviousApplicationVersion;
 
             if (Version.TryParse(str, out previousVersion))
             {
@@ -989,7 +1487,7 @@ namespace Tango.PPC.Common.MachineUpdate
 
         private async void _checkForUpdateTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
         {
-            if (AutoCheckForUpdates && !_isUpdating)
+            if (EnableAutoCheckForUpdates && _settings.AutoCheckForUpdates && !_isUpdating)
             {
                 _checkForUpdateTimer.Stop();