Example #1
0
        void bw_DoWorkPreExecute(object sender, DoWorkEventArgs e)
        {
            // simply update the progress bar to show the 3rd step is entirely complete
            bw.ReportProgress(0, new object[] { GetRelativeProgess(3, 0), 0, string.Empty, ProgressStatus.None, null });

            List <UninstallFileInfo> rollbackCOM = new List <UninstallFileInfo>();
            Exception except = null;

            for (int i = 0; i < UpdtDetails.UpdateFiles.Count; i++)
            {
                bool unregister = (UpdtDetails.UpdateFiles[i].RegisterCOMDll &
                                   (COMRegistration.UnRegister | COMRegistration.PreviouslyRegistered)) != 0;

                // skip non-executing files, skip execute "after" updates
                if ((!UpdtDetails.UpdateFiles[i].Execute || !UpdtDetails.UpdateFiles[i].ExBeforeUpdate) && !unregister)
                {
                    continue;
                }

                // form the absolute path of the file to execute or unregister
                string fullFile = FixUpdateDetailsPaths(UpdtDetails.UpdateFiles[i].RelativePath);

                if (string.IsNullOrEmpty(fullFile))
                {
                    continue;
                }

                if (!unregister)
                {
                    try
                    {
                        // we only support starting non-elevated on Vista+
                        // And the user must be an admin (otherwise starting as the same elevation as wyUpdate is ample)
                        if (UpdtDetails.UpdateFiles[i].ElevationType == ElevationType.NotElevated &&
                            IsAdmin &&
                            VistaTools.AtLeastVista())
                        {
                            int exitCode = (int)LimitedProcess.Start(fullFile,
                                                                     string.IsNullOrEmpty(UpdtDetails.UpdateFiles[i].CommandLineArgs)
                                                     ? null
                                                     : ParseText(UpdtDetails.UpdateFiles[i].CommandLineArgs), false,
                                                                     UpdtDetails.UpdateFiles[i].WaitForExecution,
                                                                     UpdtDetails.UpdateFiles[i].ProcessWindowStyle);

                            // if we're rolling back on non-zero return codes, the return code is non-zero, and it's not in the exception list
                            if (UpdtDetails.UpdateFiles[i].RollbackOnNonZeroRet && exitCode != 0 && (UpdtDetails.UpdateFiles[i].RetExceptions == null ||
                                                                                                     !UpdtDetails.UpdateFiles[i].RetExceptions.Contains(exitCode)))
                            {
                                except = new Exception("\"" + fullFile + "\" returned " + exitCode + ".");
                                break;
                            }
                        }
                        else // Same as wyUpdate or elevated
                        {
                            ProcessStartInfo psi = new ProcessStartInfo
                            {
                                FileName    = fullFile,
                                WindowStyle = UpdtDetails.UpdateFiles[i].ProcessWindowStyle
                            };

                            // command line arguments
                            if (!string.IsNullOrEmpty(UpdtDetails.UpdateFiles[i].CommandLineArgs))
                            {
                                psi.Arguments = ParseText(UpdtDetails.UpdateFiles[i].CommandLineArgs);
                            }

                            // only elevate if the current process isn't already elevated
                            if (!IsAdmin && UpdtDetails.UpdateFiles[i].ElevationType == ElevationType.Elevated)
                            {
                                psi.Verb                    = "runas";
                                psi.ErrorDialog             = true;
                                psi.ErrorDialogParentHandle = MainWindowHandle;
                            }

                            //start the process
                            Process p = Process.Start(psi);

                            if (UpdtDetails.UpdateFiles[i].WaitForExecution && p != null)
                            {
                                p.WaitForExit();

                                // if we're rolling back on non-zero return codes, the return code is non-zero, and it's not in the exception list
                                if (UpdtDetails.UpdateFiles[i].RollbackOnNonZeroRet && p.ExitCode != 0 && (UpdtDetails.UpdateFiles[i].RetExceptions == null ||
                                                                                                           !UpdtDetails.UpdateFiles[i].RetExceptions.Contains(p.ExitCode)))
                                {
                                    except = new Exception("\"" + psi.FileName + "\" returned " + p.ExitCode + ".");
                                    break;
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        // failure when executing the file
                        except = new Exception("Failed to execute the file \"" + fullFile + "\": " + ex.Message, ex);
                        break;
                    }
                }
                else // unregistering DLL
                {
                    try
                    {
                        RegisterDllServer(fullFile, true);

                        // add to the rollback list
                        rollbackCOM.Add(new UninstallFileInfo {
                            Path = fullFile, RegisterCOMDll = COMRegistration.Register
                        });
                    }
                    catch (Exception ex)
                    {
                        except = ex;
                        break;
                    }
                }
            }

            // save rollback info
            RollbackUpdate.WriteRollbackCOM(Path.Combine(TempDirectory, "backup\\unreggedComList.bak"), rollbackCOM);

            if (IsCancelled() || except != null)
            {
                // rollback unregged COM
                bw.ReportProgress(1, false);
                RollbackUpdate.RollbackUnregedCOM(TempDirectory);

                // rollback stopped services
                RollbackUpdate.RollbackStoppedServices(TempDirectory);

                bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Failure, except });
            }
            else
            {
                // registry modification completed sucessfully
                bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Success, null });
            }
        }
        void bw_DoWorkOptimizeExecute(object sender, DoWorkEventArgs e)
        {
            // simply update the progress bar to show the 6th step is entirely complete
            bw.ReportProgress(0, new object[] { GetRelativeProgess(6, 0), 0, string.Empty, ProgressStatus.None, null });

            List <UninstallFileInfo> rollbackCOM     = new List <UninstallFileInfo>();
            List <string>            startedServices = new List <string>();
            Exception except = null;

            //optimize everything but "temp" files
            for (int i = 0; i < UpdtDetails.UpdateFiles.Count; i++)
            {
                if (UpdtDetails.UpdateFiles[i].IsNETAssembly || (UpdtDetails.UpdateFiles[i].RegisterCOMDll & COMRegistration.Register) == COMRegistration.Register)
                {
                    if (IsCancelled())
                    {
                        break;
                    }

                    //if not a temp file
                    if (UpdtDetails.UpdateFiles[i].RelativePath.Length >= 4 &&
                        UpdtDetails.UpdateFiles[i].RelativePath.Substring(0, 4) != "temp")
                    {
                        //optimize (ngen) the file
                        string filename = FixUpdateDetailsPaths(UpdtDetails.UpdateFiles[i].RelativePath);

                        if (UpdtDetails.UpdateFiles[i].IsNETAssembly)
                        {
                            //TODO: add proper rolling back of newly NGENed files
                            if (!string.IsNullOrEmpty(filename))
                            {
                                NGenInstall(filename, UpdtDetails.UpdateFiles[i]); //optimize the file
                            }
                        }
                        else
                        {
                            try
                            {
                                RegisterDllServer(filename, false);

                                // add to the rollback list
                                rollbackCOM.Add(new UninstallFileInfo {
                                    Path = filename, RegisterCOMDll = COMRegistration.UnRegister
                                });
                            }
                            catch (Exception ex)
                            {
                                except = ex;
                                break;
                            }
                        }
                    }
                }
            }

            RollbackUpdate.WriteRollbackCOM(Path.Combine(TempDirectory, "backup\\reggedComList.bak"), rollbackCOM);

            bw.ReportProgress(0, new object[] { GetRelativeProgess(6, 50), 50, string.Empty, ProgressStatus.None, null });

            if (!IsCancelled() && except == null)
            {
                // execute files
                for (int i = 0; i < UpdtDetails.UpdateFiles.Count; i++)
                {
                    // skip non-executing files, skip execute "before" updates
                    if (!UpdtDetails.UpdateFiles[i].Execute || UpdtDetails.UpdateFiles[i].ExBeforeUpdate)
                    {
                        continue;
                    }

                    // form the absolute path of the file to execute
                    string fileToExec = FixUpdateDetailsPaths(UpdtDetails.UpdateFiles[i].RelativePath);

                    if (string.IsNullOrEmpty(fileToExec))
                    {
                        continue;
                    }

                    try
                    {
                        // we only support starting non-elevated on Vista+
                        // And the user must be an admin (otherwise starting as the same elevation as wyUpdate is ample)
                        if (UpdtDetails.UpdateFiles[i].ElevationType == ElevationType.NotElevated &&
                            IsAdmin &&
                            VistaTools.AtLeastVista())
                        {
                            int exitCode = (int)LimitedProcess.Start(fileToExec,
                                                                     string.IsNullOrEmpty(UpdtDetails.UpdateFiles[i].CommandLineArgs)
                                                     ? null
                                                     : ParseText(UpdtDetails.UpdateFiles[i].CommandLineArgs), false,
                                                                     UpdtDetails.UpdateFiles[i].WaitForExecution,
                                                                     UpdtDetails.UpdateFiles[i].ProcessWindowStyle);

                            // if we're rolling back on non-zero return codes, the return code is non-zero, and it's not in the exception list
                            if (UpdtDetails.UpdateFiles[i].RollbackOnNonZeroRet && exitCode != 0 && (UpdtDetails.UpdateFiles[i].RetExceptions == null ||
                                                                                                     !UpdtDetails.UpdateFiles[i].RetExceptions.Contains(exitCode)))
                            {
                                except = new Exception("\"" + fileToExec + "\" returned " + exitCode + ".");
                                break;
                            }
                        }
                        else
                        {
                            ProcessStartInfo psi = new ProcessStartInfo
                            {
                                FileName    = fileToExec,
                                WindowStyle = UpdtDetails.UpdateFiles[i].ProcessWindowStyle
                            };

                            // command line arguments
                            if (!string.IsNullOrEmpty(UpdtDetails.UpdateFiles[i].CommandLineArgs))
                            {
                                psi.Arguments = ParseText(UpdtDetails.UpdateFiles[i].CommandLineArgs);
                            }

                            // only elevate if the current process isn't already elevated
                            if (!IsAdmin && UpdtDetails.UpdateFiles[i].ElevationType == ElevationType.Elevated)
                            {
                                psi.Verb                    = "runas";
                                psi.ErrorDialog             = true;
                                psi.ErrorDialogParentHandle = MainWindowHandle;
                            }

                            // start the process
                            Process p = Process.Start(psi);

                            if (UpdtDetails.UpdateFiles[i].WaitForExecution && p != null)
                            {
                                p.WaitForExit();

                                // if we're rolling back on non-zero return codes, the return code is non-zero, and it's not in the exception list
                                if (UpdtDetails.UpdateFiles[i].RollbackOnNonZeroRet && p.ExitCode != 0 && (UpdtDetails.UpdateFiles[i].RetExceptions == null ||
                                                                                                           !UpdtDetails.UpdateFiles[i].RetExceptions.Contains(p.ExitCode)))
                                {
                                    except = new Exception("\"" + psi.FileName + "\" returned " + p.ExitCode + ".");
                                    break;
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        // failure when executing the file
                        except = new Exception("Failed to execute the file \"" + fileToExec + "\": " + ex.Message, ex);
                        break;
                    }
                }
            }

            if (!IsCancelled() && except == null)
            {
                try
                {
                    // try to start services
                    foreach (StartService service in UpdtDetails.ServicesToStart)
                    {
                        // skip the start service if it will be started as part of the auto-update process
                        if (SkipStartService != null && string.Compare(SkipStartService, service.Name, StringComparison.OrdinalIgnoreCase) == 0)
                        {
                            continue;
                        }

                        using (ServiceController srvc = new ServiceController(service.Name))
                        {
                            ServiceControllerStatus status = srvc.Status;

                            if (status != ServiceControllerStatus.Running)
                            {
                                if (service.Arguments != null)
                                {
                                    // parse the arguments for variables
                                    for (int i = 0; i < service.Arguments.Length; i++)
                                    {
                                        service.Arguments[i] = ParseText(service.Arguments[i]);
                                    }

                                    // start the service with the arguments
                                    srvc.Start(service.Arguments);
                                }
                                else // no arguments
                                {
                                    srvc.Start();
                                }

                                // report that we're waiting for the service to start so the user knows what's going on
                                bw.ReportProgress(0, new object[] { GetRelativeProgess(6, 50), 50, "Waiting for service to start: " + srvc.DisplayName, ProgressStatus.None, null });

                                //TODO: periodically check if the user has cancelled -- for services that fail to start
                                //srvc.WaitForStatus(ServiceControllerStatus.Running, TimeSpan.FromSeconds(5));
                                srvc.WaitForStatus(ServiceControllerStatus.Running);

                                startedServices.Add(service.Name);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    except = ex;
                }

                // save rollback info
                RollbackUpdate.WriteRollbackServices(Path.Combine(TempDirectory, "backup\\startedServices.bak"), startedServices);
            }

            if (IsCancelled() || except != null)
            {
                // tell the main window we're rolling back registry
                bw.ReportProgress(1, true);

                // rollback started services
                RollbackUpdate.RollbackStartedServices(TempDirectory);

                // rollback newly regged COM dlls
                RollbackUpdate.RollbackRegedCOM(TempDirectory);

                // rollback the registry
                RollbackUpdate.RollbackRegistry(TempDirectory);

                //rollback files
                bw.ReportProgress(1, false);
                RollbackUpdate.RollbackFiles(TempDirectory, ProgramDirectory);

                // rollback unregged COM
                RollbackUpdate.RollbackUnregedCOM(TempDirectory);

                // rollback stopped services
                RollbackUpdate.RollbackStoppedServices(TempDirectory);

                bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Failure, except });
            }
            else
            {
                bw.ReportProgress(0, new object[] { -1, -1, string.Empty, ProgressStatus.Success, null });
            }
        }