MREGE

1 files changed, 266 insertions, 111 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 b7573ec60..dacd1b69a 100644
--- a/Software/Visual_Studio/PPC/Tango.PPC.Common/MachineUpdate/MachineUpdateManager.cs
+++ b/Software/Visual_Studio/PPC/Tango.PPC.Common/MachineUpdate/MachineUpdateManager.cs
@@ -84,6 +84,154 @@ namespace Tango.PPC.Common.MachineUpdate
             });
         }
 
+        private async void OnFailed(Exception ex, TaskCompletionSource<MachineUpdateResult> completionSource, DownloadUpdateResponse response, bool performDatabaseRollback, String dbBackupFile, Tango.Core.DataSource localDataSource)
+        {
+            LogManager.Log(ex, "An error occurred in machine update.");
+
+            if (performDatabaseRollback)
+            {
+                LogManager.Log("Rolling back database changes...");
+
+                using (DbManager db = DbManager.FromDataSource(localDataSource))
+                {
+                    try
+                    {
+                        UpdateProgress("Rollback", "Rolling back database changes...");
+                        await Task.Factory.StartNew(() => db.Restore(localDataSource.Catalog, dbBackupFile));
+                        LogManager.Log("Database restored successfully.");
+                    }
+                    catch (Exception e)
+                    {
+                        LogManager.Log(e, "Could not rollback the database.");
+                        throw ex;
+                    }
+                    finally
+                    {
+                        try
+                        {
+                            File.Delete(dbBackupFile);
+                        }
+                        catch { }
+                    }
+                }
+            }
+
+            completionSource.SetException(ex);
+
+            if (response != null)
+            {
+                try
+                {
+                    var result = await _client.NotifyUpdateCompleted(new MachineUpdateCompletedRequest()
+                    {
+                        Token = response.NotifyCompletedToken,
+                        Status = BL.Enumerations.TangoUpdateStatuses.UpdateFailed,
+                        FailedReason = ex.FlattenMessage(),
+                    });
+                }
+                catch (Exception xx)
+                {
+                    LogManager.Log(xx, "Error notifying update failed.");
+                }
+            }
+        }
+
+        private async void OnCompleted(MachineUpdateResult result, TaskCompletionSource<MachineUpdateResult> completionSource, DownloadUpdateResponse response, String dbBackupFile)
+        {
+            try
+            {
+                File.Delete(dbBackupFile);
+            }
+            catch { }
+
+            completionSource.SetResult(result);
+
+            if (response != null)
+            {
+                try
+                {
+                    var r = await _client.NotifyUpdateCompleted(new MachineUpdateCompletedRequest()
+                    {
+                        Token = response.NotifyCompletedToken,
+                        Status = BL.Enumerations.TangoUpdateStatuses.UpdateCompleted,
+                    });
+                }
+                catch (Exception ex)
+                {
+                    LogManager.Log(ex, "Error notifying update completed.");
+                }
+            }
+        }
+
+        private void OnCompleted(UpdateDBResponse response)
+        {
+            if (response != null)
+            {
+                try
+                {
+                    var r = _client.NotifyUpdateCompleted(new MachineUpdateCompletedRequest()
+                    {
+                        Token = response.NotifyCompletedToken,
+                        Status = BL.Enumerations.TangoUpdateStatuses.DatabaseCompleted,
+                    }).Result;
+                }
+                catch (Exception ex)
+                {
+                    LogManager.Log(ex, "Error notifying database completed.");
+                }
+            }
+        }
+
+        private void OnFailed(Exception ex, UpdateDBResponse response, bool performDatabaseRollback, String dbBackupFile, Tango.Core.DataSource localDataSource)
+        {
+            LogManager.Log(ex, "An error occurred in database update.");
+
+            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.");
+                        throw ex;
+                    }
+                    finally
+                    {
+                        try
+                        {
+                            File.Delete(dbBackupFile);
+                        }
+                        catch { }
+                    }
+                }
+            }
+
+            if (response != null)
+            {
+                try
+                {
+                    var r = _client.NotifyUpdateCompleted(new MachineUpdateCompletedRequest()
+                    {
+                        Token = response.NotifyCompletedToken,
+                        Status = BL.Enumerations.TangoUpdateStatuses.DatabaseFailed,
+                        FailedReason = ex.FlattenMessage(),
+                    }).Result;
+                }
+                catch (Exception xx)
+                {
+                    LogManager.Log(xx, "Error notifying database failed.");
+                }
+            }
+        }
+
         #endregion
 
         #region Public Methods
@@ -108,6 +256,7 @@ namespace Tango.PPC.Common.MachineUpdate
             var localDataSource = SettingsManager.Default.GetOrCreate<CoreSettings>().DataSource;
             bool performDatabaseRollback = false;
             String dbBackupFile = null;
+            DownloadUpdateResponse update_response = null;
 
             try
             {
@@ -148,8 +297,6 @@ namespace Tango.PPC.Common.MachineUpdate
                 DownloadUpdateRequest request = new DownloadUpdateRequest();
                 request.SerialNumber = serialNumber;
 
-                DownloadUpdateResponse update_response = null;
-
                 update_response = await _client.MachineUpdate(request);
 
                 LogManager.Log($"Machine update response received: {Environment.NewLine}{update_response.ToJsonString()}");
@@ -212,25 +359,24 @@ namespace Tango.PPC.Common.MachineUpdate
                     throw new InvalidProgramException("Database tango does not exists.");
                 }
 
-                if (setupFirmware)
-                {
-                    LogManager.Log("Setup firmware is active so a database rollback procedure should be configured.");
-                    UpdateProgress("Updating Database", "Creating database backup...");
+                UpdateProgress("Updating Database", "Creating database backup...");
 
-                    try
-                    {
-                        Directory.CreateDirectory("C:\\Backups");
-                        dbBackupFile = $"C:\\Backups\\{Path.GetRandomFileName()}.bak";
-                        LogManager.Log($"Creating database backup to '{dbBackupFile}'...");
-                        await Task.Factory.StartNew(() => db.Backup(localDataSource.Catalog, dbBackupFile));
-                        LogManager.Log("Database backup created successfully.");
-                    }
-                    catch (Exception ex)
-                    {
-                        throw LogManager.Log(ex, "Setup manager error while trying to create a database backup.");
-                    }
+                //Create Database Backup
+                try
+                {
+                    Directory.CreateDirectory("C:\\Backups");
+                    dbBackupFile = $"C:\\Backups\\{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("Disposing database manager.");
                 db.Dispose();
 
@@ -267,14 +413,12 @@ namespace Tango.PPC.Common.MachineUpdate
                 }
                 catch (Exception ex)
                 {
-                    throw LogManager.Log(ex, "Setup manager error while trying to synchronize database.");
+                    throw LogManager.Log(ex, "Update manager error while trying to synchronize database.");
                 }
 
                 //Updating firmware
                 if (setupFirmware)
                 {
-                    performDatabaseRollback = true;
-
                     UpdateProgress("Updating Firmware", "Connecting to firmware device...");
                     LogManager.Log("");
                     LogManager.Log("-------------------------------------------------------------------------");
@@ -284,34 +428,41 @@ namespace Tango.PPC.Common.MachineUpdate
                     var tfpPath = Path.Combine(_newPackageTempFolder, "firmware_package.tfp");
                     var stream = new FileStream(tfpPath, FileMode.Open);
 
-                    if (setupFPGA)
+                    if (!_machineProvider.Machine.IsDemo)
                     {
-                        op.FirmwareUpgradeMode = FirmwareUpgradeModes.DFU | FirmwareUpgradeModes.TFP_PACKAGE;
+                        if (setupFPGA)
+                        {
+                            op.FirmwareUpgradeMode = FirmwareUpgradeModes.DFU | FirmwareUpgradeModes.TFP_PACKAGE;
+                        }
+                        else
+                        {
+                            op.FirmwareUpgradeMode = FirmwareUpgradeModes.DFU;
+                        }
                     }
                     else
                     {
-                        op.FirmwareUpgradeMode = FirmwareUpgradeModes.DFU;
+                        op.FirmwareUpgradeMode = FirmwareUpgradeModes.TFP_PACKAGE;
                     }
 
                     var handler = await op.UpgradeFirmware(stream);
                     handler.Failed += (_, ex) =>
                     {
                         stream.Dispose();
-                        throw ex;
+                        OnFailed(ex, result, update_response, performDatabaseRollback, dbBackupFile, localDataSource);
                     };
                     handler.Completed += (_, __) =>
                     {
                         UpdateProgress("Updating Firmware", "Firmware update completed successfully.");
                         stream.Dispose();
-                        result.SetResult(new MachineUpdateResult()
+                        OnCompleted(new MachineUpdateResult()
                         {
                             UpdatePackagePath = _newPackageTempFolder,
-                        });
+                        }, result, update_response, dbBackupFile);
                     };
                     handler.Canceled += (_, __) =>
                     {
                         stream.Dispose();
-                        throw new Exception("The operation has been canceled.");
+                        OnFailed(new Exception("The operation has been canceled."), result, update_response, performDatabaseRollback, dbBackupFile, localDataSource);
                     };
                     handler.Progress += (_, e) =>
                     {
@@ -320,53 +471,15 @@ namespace Tango.PPC.Common.MachineUpdate
                 }
                 else
                 {
-                    result.SetResult(new MachineUpdateResult()
+                    OnCompleted(new MachineUpdateResult()
                     {
                         UpdatePackagePath = _newPackageTempFolder,
-                    });
+                    }, result, update_response, dbBackupFile);
                 }
             }
             catch (Exception ex)
             {
-                LogManager.Log(ex, "An error occurred in machine update.");
-
-                if (performDatabaseRollback)
-                {
-                    LogManager.Log("Rolling back database changes...");
-
-                    using (DbManager db = DbManager.FromDataSource(localDataSource))
-                    {
-                        try
-                        {
-                            UpdateProgress("Rollback", "Rolling back database changes...");
-                            await Task.Factory.StartNew(() => db.Restore(localDataSource.Catalog, dbBackupFile));
-                            LogManager.Log("Database restored successfully.");
-                        }
-                        catch (Exception e)
-                        {
-                            LogManager.Log(e, "Could not rollback the database.");
-                            throw ex;
-                        }
-                        finally
-                        {
-                            try
-                            {
-                                File.Delete(dbBackupFile);
-                            }
-                            catch { }
-                        }
-                    }
-                }
-
-                result.SetException(ex);
-            }
-            finally
-            {
-                try
-                {
-                    File.Delete(dbBackupFile);
-                }
-                catch { }
+                OnFailed(ex, result, update_response, performDatabaseRollback, dbBackupFile, localDataSource);
             }
 
             return await result.Task;
@@ -414,73 +527,115 @@ namespace Tango.PPC.Common.MachineUpdate
         {
             return Task.Factory.StartNew(() =>
             {
-                LogManager.Log("Starting database update...");
+                UpdateDBResponse update_response = null;
+                var localDataSource = SettingsManager.Default.GetOrCreate<CoreSettings>().DataSource;
+                bool performDatabaseRollback = false;
+                String dbBackupFile = null;
 
-                UpdateProgress("Updating Database", "Initializing...");
+                try
+                {
+                    LogManager.Log("Starting database update...");
 
-                LogManager.Log("Looking for update scripts configuration on application path...");
+                    UpdateProgress("Updating Database", "Initializing...");
 
-                String config_file = Path.Combine(PathHelper.GetStartupPath(), "Update Scripts", "config.xml");
+                    LogManager.Log("Looking for update scripts configuration on application path...");
 
-                if (!File.Exists(config_file))
-                {
-                    throw LogManager.Log(new FileNotFoundException($"Could not locate '{config_file}' file on application folder."));
-                }
+                    String config_file = Path.Combine(PathHelper.GetStartupPath(), "Update Scripts", "config.xml");
 
-                UpdateDBResponse update_response = dbCompareResult.UpdateDBResponse;
+                    if (!File.Exists(config_file))
+                    {
+                        throw LogManager.Log(new FileNotFoundException($"Could not locate '{config_file}' file on application folder."));
+                    }
 
-                var localDataSource = SettingsManager.Default.GetOrCreate<CoreSettings>().DataSource;
+                    update_response = dbCompareResult.UpdateDBResponse;
 
-                LogManager.Log($"Updating database '{update_response.DataSource.ToString()}' => '{localDataSource.ToString()}'...");
+                    LogManager.Log($"Updating database '{update_response.DataSource.ToString()}' => '{localDataSource.ToString()}'...");
 
-                UpdateProgress("Updating Database", "Initializing update sequence...");
+                    UpdateProgress("Updating Database", "Initializing update sequence...");
 
-                ExaminerSequenceConfiguration config_sequence = ExaminerSequenceConfiguration.FromFile(config_file);
-
-                foreach (var item in config_sequence.Items.Where(x => x.Type == ExaminerSequenceItemType.Data || update_response.PerformSchemaUpdate).OrderBy(x => x.Index))
-                {
-                    LogManager.Log($"Executing update script '{item.FileName}...'");
+                    ExaminerSequenceConfiguration config_sequence = ExaminerSequenceConfiguration.FromFile(config_file);
 
-                    ExaminerConfigurationBuilder builder = new ExaminerConfigurationBuilder(Path.Combine(Path.GetDirectoryName(config_file), item.FileName));
-                    builder.SetSource(update_response.DataSource);
-                    builder.SetTarget(localDataSource);
+                    UpdateProgress("Updating Database", "Connecting to local database...");
+                    LogManager.Log("Initializing database manager...");
+                    DbManager db = DbManager.FromDataSource(localDataSource);
 
-                    if (item.RequiresSerialNumber)
+                    LogManager.Log("Checking Tango database exists on the local machine...");
+                    if (!db.Exists(localDataSource.Catalog))
                     {
-                        builder.SetMachineSerialNumber(serialNumber);
+                        throw new InvalidProgramException("Database tango does not exists.");
                     }
 
-                    builder.Synchronize();
-
-                    var config = builder.Build();
+                    UpdateProgress("Updating Database", "Creating database backup...");
 
-                    ExaminerProcess process = new ExaminerProcess(config, item.Type == ExaminerSequenceItemType.Data ? ExaminerProcessType.Data : ExaminerProcessType.Schema);
-                    process.Progress += (x, msg) =>
+                    //Create Database Backup
+                    try
                     {
-                        LogManager.Log(msg);
-                    };
+                        Directory.CreateDirectory("C:\\Backups");
+                        dbBackupFile = $"C:\\Backups\\{Path.GetRandomFileName()}.bak";
+                        LogManager.Log($"Creating database backup to '{dbBackupFile}'...");
+                        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.");
+                    }
 
-                    try
+                    LogManager.Log("Disposing database manager.");
+                    db.Dispose();
+
+                    foreach (var item in config_sequence.Items.Where(x => x.Type == ExaminerSequenceItemType.Data || update_response.PerformSchemaUpdate).OrderBy(x => x.Index))
                     {
-                        UpdateProgress("Updating Database", item.Name + "...");
+                        LogManager.Log($"Executing update script '{item.FileName}...'");
 
-                        var result = process.Execute().Result;
+                        ExaminerConfigurationBuilder builder = new ExaminerConfigurationBuilder(Path.Combine(Path.GetDirectoryName(config_file), item.FileName));
+                        builder.SetSource(update_response.DataSource);
+                        builder.SetTarget(localDataSource);
 
-                        if (result.ExitCode != ExaminerProcessExitCode.Success)
+                        if (item.RequiresSerialNumber)
                         {
-                            throw LogManager.Log(new InvalidDataException($"{item.FileName} script has terminated with exit code '{result.ExitCode}'."));
+                            builder.SetMachineSerialNumber(serialNumber);
                         }
 
-                        LogManager.Log("Script executed successfully.");
-                    }
-                    catch (Exception ex)
-                    {
-                        throw LogManager.Log(ex, "Setup manager error while trying to update the database.");
+                        builder.Synchronize();
+
+                        var config = builder.Build();
+
+                        ExaminerProcess process = new ExaminerProcess(config, item.Type == ExaminerSequenceItemType.Data ? ExaminerProcessType.Data : ExaminerProcessType.Schema);
+                        process.Progress += (x, msg) =>
+                        {
+                            LogManager.Log(msg);
+                        };
+
+                        try
+                        {
+                            UpdateProgress("Updating Database", item.Name + "...");
+
+                            var result = process.Execute().Result;
+
+                            if (result.ExitCode != ExaminerProcessExitCode.Success)
+                            {
+                                throw LogManager.Log(new InvalidDataException($"{item.FileName} script has terminated with exit code '{result.ExitCode}'."));
+                            }
+
+                            LogManager.Log("Script executed successfully.");
+                        }
+                        catch (Exception ex)
+                        {
+                            throw LogManager.Log(ex, "Upudate manager error while trying to update the database.");
+                        }
                     }
-                }
 
-                UpdateProgress("Updating Database", "Database synchronization completed successfully.");
-                LogManager.Log("Update completed successfully.");
+                    UpdateProgress("Updating Database", "Database synchronization completed successfully.");
+                    LogManager.Log("Update completed successfully.");
+                    OnCompleted(update_response);
+                }
+                catch (Exception ex)
+                {
+                    OnFailed(ex, update_response, performDatabaseRollback, dbBackupFile, localDataSource);
+                    throw ex;
+                }
             });
         }