Exemple #1
0
        private void Disconnect()
        {
            _bufferReady.Set();

            lock (this) {
                if (!Connected)
                {
                    return;
                }
                Connected = false;
            }

            Logger.Message("disposing of pipes: [{0}]-[{1}]".format(_clientId, _sessionId));
            try {
                if (_serverPipe != null)
                {
                    _serverPipe.Close();
                }
                _serverPipe = null;

                if (!_isAsychronous && _responsePipe != null)
                {
                    _responsePipe.Close();
                }
                _responsePipe = null;
            } catch (Exception e) {
                Logger.Error(e);
            }

            // clean up anything that can be cleaned up.
            FilesystemExtensions.RemoveTemporaryFiles();
        }
Exemple #2
0
        protected virtual int Startup(IEnumerable <string> args)
        {
            var task = Task.Factory.StartNew(() => {
                Main(args);
            }, CancellationTokenSource.Token);

            try {
                Console.CancelKeyPress += (x, y) => {
                    if (!CancellationTokenSource.IsCancellationRequested)
                    {
                        Console.WriteLine("Operation Canceled...");
                        CancellationTokenSource.Cancel();
                        if (y.SpecialKey == ConsoleSpecialKey.ControlBreak)
                        {
                            // can't cancel so we just block on the task.
                            return;
                            // task.Wait();
                        }
                    }
                    y.Cancel = true;
                };
                task.Wait(CancellationTokenSource.Token);
            } catch (Exception e) {
                HandleException(e.Unwrap());
                return(1);
            }
            FilesystemExtensions.RemoveTemporaryFiles();
            return(0);
        }
        /// <summary>
        /// Extract zipped package and return the unzipped folder
        /// </summary>
        /// <param name="zippedPackagePath"></param>
        /// <returns></returns>
        private string ExtractZipPackage(string zippedPackagePath)
        {
            if (zippedPackagePath != null && zippedPackagePath.FileExists())
            {
                // extracted folder
                string extractedFolder = FilesystemExtensions.GenerateTemporaryFileOrDirectoryNameInTempDirectory();

                try
                {
                    //unzip the file
                    ZipFile.ExtractToDirectory(zippedPackagePath, extractedFolder);

                    // extraction fails
                    if (!Directory.Exists(extractedFolder))
                    {
                        Verbose(string.Format(CultureInfo.CurrentCulture, Resources.Messages.FailToExtract, zippedPackagePath, extractedFolder));
                        return(string.Empty);
                    }

                    // the zipped folder
                    var zippedDirectory = Directory.EnumerateDirectories(extractedFolder).FirstOrDefault();

                    if (!string.IsNullOrWhiteSpace(zippedDirectory) && Directory.Exists(zippedDirectory))
                    {
                        return(zippedDirectory);
                    }
                }
                catch (Exception ex)
                {
                    Verbose(string.Format(CultureInfo.CurrentCulture, Resources.Messages.FailToInstallZipFolder, zippedPackagePath, ex.Message));
                    Debug(ex.StackTrace);

                    // remove the extracted folder
                    extractedFolder.TryHardToDelete();
                }
            }

            return(string.Empty);
        }
        internal string DownLoadFileFromLinks(IEnumerable <Link> links)
        {
            string file = null;

            foreach (var link in links)
            {
                file = RetryDownload(
                    // the download function takes in a uri link and download it
                    (uri) => {
                    var tmpFile = FilesystemExtensions.GenerateTemporaryFileOrDirectoryNameInTempDirectory();
                    return(ProviderServices.DownloadFile(uri, tmpFile, -1, true, this));
                },
                    link.HRef);

                // got a valid file!
                if (file != null && file.FileExists())
                {
                    // if file is zip, unpack it and return the unpacked folder
                    if (link.MediaType == Iso19770_2.MediaType.ZipPackage)
                    {
                        try
                        {
                            // let's extract the zipped file
                            return(ExtractZipPackage(file));
                        }
                        finally
                        {
                            // delete the zipped file
                            file.TryHardToDelete();
                        }
                    }

                    return(file);
                }
            }

            return(file);
        }
Exemple #5
0
        internal string DownLoadFileFromLinks(IEnumerable <Link> links)
        {
            string file = null;

            foreach (var link in links)
            {
                file = RetryDownload(
                    // the download function takes in a uri link and download it
                    (uri) => {
                    var tmpFile = FilesystemExtensions.GenerateTemporaryFileOrDirectoryNameInTempDirectory();
                    return(ProviderServices.DownloadFile(uri, tmpFile, -1, true, this));
                },
                    link.HRef);

                // got a valid file!
                if (file != null && file.FileExists())
                {
                    return(file);
                }
            }

            return(file);
        }
Exemple #6
0
        private Swidtag DownloadSwidtag(IEnumerable <Uri> locations, BootstrapRequest request)
        {
            foreach (var location in locations.WhereNotNull())
            {
                try {
                    var filename = FilesystemExtensions.GenerateTemporaryFileOrDirectoryNameInTempDirectory();
                    DownloadSwidtagToFile(filename, location);

                    if (_timedOut)
                    {
                        // try one more time...
                        DownloadSwidtagToFile(filename, location);
                    }

                    if (filename.FileExists())
                    {
                        try
                        {
                            var document = XDocument.Load(filename);
                            if (Swidtag.IsSwidtag(document.Root))
                            {
                                Location = location;
                                return(new Swidtag(document));
                            }
                        }
                        finally
                        {
                            System.IO.File.Delete(filename);
                        }
                    }
                } catch (Exception e) {
                    e.Dump(request);
                }
            }
            return(null);
        }
Exemple #7
0
        private bool InstallNugetPackage(Package provider, Link link, string fastPath, BootstrapRequest request)
        {
            // download the nuget package
            string downloadedNupkg = request.DownloadAndValidateFile(provider._swidtag);

            if (downloadedNupkg != null)
            {
                // extracted folder
                string extractedFolder = String.Concat(FilesystemExtensions.GenerateTemporaryFileOrDirectoryNameInTempDirectory());

                try
                {
                    //unzip the file
                    ZipFile.ExtractToDirectory(downloadedNupkg, extractedFolder);

                    if (Directory.Exists(extractedFolder))
                    {
                        string versionFolder = Path.Combine(request.DestinationPath(request), provider.Name, provider.Version);
                        // tool folder is where we find things like nuget.exe
                        string toolFolder = Path.Combine(extractedFolder, "tools");
                        string libFolder  = Path.Combine(extractedFolder, "lib");

                        // create the directory version folder if not exist
                        if (!Directory.Exists(versionFolder))
                        {
                            Directory.CreateDirectory(versionFolder);
                        }

                        // copy the tools directory
                        if (Directory.Exists(toolFolder))
                        {
                            string destinationToolFolder = Path.Combine(versionFolder, "tools");

                            if (!Directory.Exists(destinationToolFolder))
                            {
                                Directory.CreateDirectory(destinationToolFolder);
                            }

                            foreach (string child in Directory.EnumerateFiles(toolFolder))
                            {
                                try
                                {
                                    // try copy and overwrite
                                    File.Copy(child, Path.Combine(destinationToolFolder, Path.GetFileName(child)), true);
                                }
                                catch (Exception e)
                                {
                                    request.Debug(e.StackTrace);
                                    if (!(e is UnauthorizedAccessException || e is IOException))
                                    {
                                        // something wrong, delete the version folder
                                        versionFolder.TryHardToDelete();
                                        return(false);
                                    }

                                    // otherwise this means the file is just being used. so just moves on to copy other files
                                }
                            }
                        }

                        // copy files from lib
                        if (Directory.Exists(libFolder))
                        {
                            // check that the lib folder has at most 1 dll
                            if (Directory.EnumerateFiles(libFolder).Count(file => String.Equals(Path.GetExtension(file), ".dll", StringComparison.OrdinalIgnoreCase)) > 1)
                            {
                                request.Warning(String.Format(CultureInfo.CurrentCulture, Resources.Messages.MoreThanOneDllExists, provider.Name));
                                return(false);
                            }

                            foreach (string child in Directory.EnumerateFiles(libFolder))
                            {
                                try
                                {
                                    File.Copy(child, Path.Combine(versionFolder, Path.GetFileName(child)), true);
                                }
                                catch (Exception e)
                                {
                                    request.Debug(e.StackTrace);
                                    if (!(e is UnauthorizedAccessException || e is IOException))
                                    {
                                        // something wrong, delete the version folder
                                        versionFolder.TryHardToDelete();
                                        return(false);
                                    }

                                    // otherwise this means the file is just being used. so just moves on to copy other files
                                }
                            }
                        }

                        // target file name is the assembly provider
                        string targetFile = Path.Combine(versionFolder, Path.GetFileName(link.Attributes[Iso19770_2.Discovery.TargetFilename]));

                        if (File.Exists(targetFile))
                        {
                            request.Verbose(Resources.Messages.InstalledPackage, provider.Name, targetFile);
                            request.YieldFromSwidtag(provider, fastPath);
                            return(true);
                        }
                    }
                }
                finally
                {
                    downloadedNupkg.TryHardToDelete();
                    extractedFolder.TryHardToDelete();
                }
            }

            return(false);
        }
        public override bool ProcessRecordAsync()
        {
            if (Stopping)
            {
                return(false);
            }

            var packageProvider = SelectProviders(ProviderName).ReEnumerable();

            if (ProviderName.IsNullOrEmpty())
            {
                Error(Constants.Errors.ProviderNameNotSpecified, packageProvider.Select(p => p.ProviderName).JoinWithComma());
                return(false);
            }

            switch (packageProvider.Count())
            {
            case 0:
                Error(Constants.Errors.UnknownProvider, ProviderName);
                return(false);

            case 1:
                break;

            default:
                Error(Constants.Errors.MatchesMultipleProviders, packageProvider.Select(p => p.ProviderName).JoinWithComma());
                return(false);
            }


            var provider = packageProvider.First();

            using (var sources = provider.ResolvePackageSources(this).CancelWhen(CancellationEvent.Token)) {
                // first, check if there is a source by this name already.
                var existingSources = sources.Where(each => each.IsRegistered && each.Name.Equals(Name, StringComparison.OrdinalIgnoreCase)).ToArray();

                if (existingSources.Any())
                {
                    // if there is, and the user has said -Force, then let's remove it.
                    foreach (var existingSource in existingSources)
                    {
                        if (Force)
                        {
                            if (ShouldProcess(FormatMessageString(Constants.Messages.TargetPackageSource, existingSource.Name, existingSource.Location, existingSource.ProviderName), Constants.Messages.ActionReplacePackageSource).Result)
                            {
                                var removedSources = provider.RemovePackageSource(existingSource.Name, this).CancelWhen(CancellationEvent.Token);
                                foreach (var removedSource in removedSources)
                                {
                                    Verbose(Constants.Messages.OverwritingPackageSource, removedSource.Name);
                                }
                            }
                        }
                        else
                        {
                            Error(Constants.Errors.PackageSourceExists, existingSource.Name);
                            return(false);
                        }
                    }
                }
            }

            string providerNameForProcessMessage = ProviderName.JoinWithComma();

            if (ShouldProcess(FormatMessageString(Constants.Messages.TargetPackageSource, Name, Location, providerNameForProcessMessage), FormatMessageString(Constants.Messages.ActionRegisterPackageSource)).Result)
            {
                //Need to resolve the path created via psdrive.
                //e.g., New-PSDrive -Name x -PSProvider FileSystem -Root \\foobar\myfolder. Here we are resolving x:\
                try
                {
                    if (FilesystemExtensions.LooksLikeAFilename(Location))
                    {
                        ProviderInfo providerInfo  = null;
                        var          resolvedPaths = GetResolvedProviderPathFromPSPath(Location, out providerInfo);

                        // Ensure the path is a single path from the file system provider
                        if ((providerInfo != null) && (resolvedPaths.Count == 1) && String.Equals(providerInfo.Name, "FileSystem", StringComparison.OrdinalIgnoreCase))
                        {
                            Location = resolvedPaths[0];
                        }
                    }
                } catch (Exception) {
                    //allow to continue handling the cases other than file system
                }

                using (var added = provider.AddPackageSource(Name, Location, Trusted, this).CancelWhen(CancellationEvent.Token)) {
                    foreach (var addedSource in added)
                    {
                        WriteObject(addedSource);
                    }
                }
                return(true);
            }

            return(false);
        }
        public string DownloadFile(Uri remoteLocation, string localFilename, int timeoutMilliseconds, bool showProgress, Request request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            if (remoteLocation == null)
            {
                throw new ArgumentNullException("remoteLocation");
            }

            request.Debug("Calling 'WebDownloader::DownloadFile' '{0}','{1}','{2}','{3}'", remoteLocation, localFilename, timeoutMilliseconds, showProgress);

            if (remoteLocation.Scheme.ToLowerInvariant() != "http" && remoteLocation.Scheme.ToLowerInvariant() != "https" && remoteLocation.Scheme.ToLowerInvariant() != "ftp")
            {
                request.Error(ErrorCategory.InvalidResult, remoteLocation.ToString(), Constants.Messages.SchemeNotSupported, remoteLocation.Scheme);
                return(null);
            }

            if (localFilename == null)
            {
                localFilename = FilesystemExtensions.GenerateTemporaryFileOrDirectoryNameInTempDirectory();
            }

            localFilename = Path.GetFullPath(localFilename);

            // did the caller pass us a directory name?
            if (Directory.Exists(localFilename))
            {
                localFilename = Path.Combine(localFilename, "downloadedFile.tmp");
            }

            // make sure that the parent folder is created first.
            var folder = Path.GetDirectoryName(localFilename);

            if (!Directory.Exists(folder))
            {
                Directory.CreateDirectory(folder);
            }

            // clobber an existing file if it's already there.
            // todo: in the future, we could check the md5 of the file and if the remote server supports it
            // todo: we could skip the download.
            if (File.Exists(localFilename))
            {
                localFilename.TryHardToDelete();
            }

            // setup the progress tracker if the caller wanted one.
            int pid = 0;

            if (showProgress)
            {
                pid = request.StartProgress(0, "Downloading '{0}'", remoteLocation);
            }

#if CORECLR
            var task = Download(remoteLocation, localFilename, showProgress, request, pid);

            task.Wait(timeoutMilliseconds);

            if (!task.IsCompleted)
            {
                request.Warning(Constants.Status.TimedOut);
                request.Debug("Timed out downloading '{0}'", remoteLocation.AbsoluteUri);
            }
#else
            var webClient = new WebClient();

            // Mozilla/5.0 is the general token that says the browser is Mozilla compatible, and is common to almost every browser today.
            webClient.Headers.Add("User-Agent", "Mozilla/5.0 PackageManagement");

            if (request.WebProxy != null)
            {
                // if user supplies webproxy, use that
                webClient.Proxy = request.WebProxy;
            }
            else
            {
                // get ie settings
                webClient.Proxy = WebRequest.GetSystemWebProxy();

                // set credentials to be user credentials
                webClient.Proxy.Credentials = CredentialCache.DefaultNetworkCredentials;
            }

            var done = new ManualResetEvent(false);

            webClient.DownloadFileCompleted += (sender, args) => {
                if (args.Cancelled || args.Error != null)
                {
                    localFilename = null;
                }
                done.Set();
            };

            var lastPercent = 0;

            if (showProgress)
            {
                webClient.DownloadProgressChanged += (sender, args) => {
                    // Progress(requestObject, 2, (int)percent, "Downloading {0} of {1} bytes", args.BytesReceived, args.TotalBytesToReceive);
                    var percent = (int)((args.BytesReceived * 100) / args.TotalBytesToReceive);
                    if (percent > lastPercent)
                    {
                        lastPercent = percent;
                        request.Progress(pid, (int)((args.BytesReceived * 100) / args.TotalBytesToReceive), "To {0}", localFilename);
                    }
                };
            }

            // start the download
            webClient.DownloadFileAsync(remoteLocation, localFilename);

            // wait for the completion
            if (timeoutMilliseconds > 0)
            {
                if (!done.WaitOne(timeoutMilliseconds))
                {
                    webClient.CancelAsync();
                    request.Warning(Constants.Status.TimedOut);
                    request.Debug("Timed out downloading '{0}'", remoteLocation.AbsoluteUri);
                    return(null);
                }
            }
            else
            {
                // wait until it completes or fails on it's own
                done.WaitOne();
            }
#endif

            // if we don't have the file by this point, we've failed.
            if (localFilename == null || !File.Exists(localFilename))
            {
                request.CompleteProgress(pid, false);
                request.Warning(Constants.Messages.UnableToDownload, remoteLocation.ToString(), localFilename);
                return(null);
            }

            if (showProgress)
            {
                request.CompleteProgress(pid, true);
            }

            return(localFilename);
        }
Exemple #10
0
        public static void Start()
        {
            try {
                MessageText     = "It will be just a moment while we \r\nremove old versions of the\r\nCoApp Package Manager.";
                StatusText      = "Status: Shutting down CoApp Service";
                OverallProgress = 5;
                OnPropertyChanged();


                var tsk = Task.Factory.StartNew(FilesystemExtensions.RemoveTemporaryFiles);

                // try to gracefully kill coapp.service
                try {
                    var psi = new ProcessStartInfo {
                        FileName    = "sc.exe",
                        Arguments   = @"stop  ""CoApp Package Installer Service""",
                        WindowStyle = ProcessWindowStyle.Hidden
                    };
                    var p = Process.Start(psi);
                    p.WaitForExit();
                } catch {
                    // it's ok.
                }

                // try to gracefully kill coapp.service ( new )
                try {
                    var psi = new ProcessStartInfo {
                        FileName    = "sc.exe",
                        Arguments   = @"stop  ""CoApp""",
                        WindowStyle = ProcessWindowStyle.Hidden
                    };
                    var p = Process.Start(psi);
                    p.WaitForExit();
                }
                catch {
                    // it's ok.
                }

                // let's just kill the processes if they exist
                var serviceProcs = Process.GetProcessesByName("CoApp.Service");
                if (serviceProcs.Any())
                {
                    foreach (var proc in serviceProcs)
                    {
                        try {
                            proc.Kill();
                        } catch {
                            // it's ok.
                        }
                    }
                }

                StatusText      = "Status: Removing Service";
                OverallProgress = 10;
                OnPropertyChanged();
                // remove service if it exists
                try {
                    var psi = new ProcessStartInfo {
                        FileName    = "sc.exe",
                        Arguments   = @"delete  ""CoApp Package Installer Service""",
                        WindowStyle = ProcessWindowStyle.Hidden
                    };
                    var p = Process.Start(psi);
                    p.WaitForExit();
                } catch {
                    // it's ok.
                }

                try {
                    var psi = new ProcessStartInfo {
                        FileName    = "sc.exe",
                        Arguments   = @"delete  ""CoApp""",
                        WindowStyle = ProcessWindowStyle.Hidden
                    };
                    var p = Process.Start(psi);
                    p.WaitForExit();
                }
                catch {
                    // it's ok.
                }

                MsiSetInternalUI(2, IntPtr.Zero);
                MsiSetExternalUI((context, messageType, message) => 1, 0x400, IntPtr.Zero);

                StatusText      = "Status: Finding installed packages.";
                OverallProgress = 15;
                OnPropertyChanged();

                var installedMSIs = GetInstalledCoAppMSIs().ToArray();
                StatusText      = string.Format("Status: Found {0} installed packages.", installedMSIs.Length);
                OverallProgress = 20;
                OnPropertyChanged();



                // Remove CoApp toolkit MSIs
                var toolkits = installedMSIs.Where(each => (each.ProductName.Equals("CoApp.Toolkit", StringComparison.InvariantCultureIgnoreCase) || each.ProductName.Equals("CoApp", StringComparison.InvariantCultureIgnoreCase)) && each.Manufacturer.Equals("OUTERCURVE FOUNDATION", StringComparison.CurrentCultureIgnoreCase)).ToArray();

                if (toolkits.Any())
                {
                    StatusText      = "Status: Removing CoApp Toolkit.";
                    OverallProgress = 25;
                    OnPropertyChanged();

                    foreach (var pkg in toolkits)
                    {
                        OverallProgress++;
                        OnPropertyChanged();

                        MsiInstallProduct(pkg.Path, @"REMOVE=ALL ALLUSERS=1 COAPP=1 COAPP_INSTALLED=1 REBOOT=REALLYSUPPRESS");
                    }
                }

                if (installedMSIs.Any())
                {
                    installedMSIs = GetInstalledCoAppMSIs().ToArray();

                    if (AllPackages && installedMSIs.Any())
                    {
                        var eachProgress = 45 / installedMSIs.Count();
                        StatusText      = "Status: Removing other packages.";
                        OverallProgress = 30;
                        OnPropertyChanged();

                        foreach (var pkg in installedMSIs)
                        {
                            OverallProgress += eachProgress;
                            OnPropertyChanged();

                            MsiInstallProduct(pkg.Path, @"REMOVE=ALL ALLUSERS=1 COAPP=1 COAPP_INSTALLED=1 REBOOT=REALLYSUPPRESS");
                        }
                    }
                }
                //
                // installedMSIs = GetInstalledCoAppMSIs().ToArray();
                // if (!installedMSIs.Any()) {
                StatusText      = "Status: Removing CoApp Folder.";
                OverallProgress = 75;
                OnPropertyChanged();

                // get rid of c:\windows\coapp.exe
                var coappexe = Path.Combine(Environment.GetEnvironmentVariable("SystemRoot"), "coapp.exe");
                if (File.Exists(coappexe))
                {
                    coappexe.TryHardToDelete();
                }

                // try to get rid of c:\apps
                var apps = String.Format("{0}\\apps", Environment.GetEnvironmentVariable("SystemDrive"));
                if (Symlink.IsSymlink(apps))
                {
                    Symlink.DeleteSymlink(apps);
                }
                else if (Directory.Exists(apps))
                {
                    FilesystemExtensions.TryHardToDelete(String.Format("{0}\\apps", Environment.GetEnvironmentVariable("SystemDrive")));
                }
                // no more packages installed-- remove the c:\apps directory
                var rootFolder = CoAppRootFolder.Value;

                FilesystemExtensions.TryHardToDelete(Path.Combine(rootFolder, ".cache"));
                FilesystemExtensions.TryHardToDelete(Path.Combine(rootFolder, "ReferenceAssemblies"));
                FilesystemExtensions.TryHardToDelete(Path.Combine(rootFolder, "x86"));
                FilesystemExtensions.TryHardToDelete(Path.Combine(rootFolder, "x64"));
                FilesystemExtensions.TryHardToDelete(Path.Combine(rootFolder, "bin"));
                FilesystemExtensions.TryHardToDelete(Path.Combine(rootFolder, "powershell"));
                FilesystemExtensions.TryHardToDelete(Path.Combine(rootFolder, "lib"));
                FilesystemExtensions.TryHardToDelete(Path.Combine(rootFolder, "include"));
                // FilesystemExtensions.TryHardToDelete(Path.Combine(rootFolder, "etc"));

                StatusText      = "Status: Removing Dead Links.";
                OverallProgress = 80;
                OnPropertyChanged();

                FilesystemExtensions.RemoveDeadLnks(rootFolder);

                StatusText      = "Status: Removing Empty Folders.";
                OverallProgress = 81;
                OnPropertyChanged();


                FilesystemExtensions.RemoveEssentiallyEmptyFolders(rootFolder);

                // }

                // clean out the CoApp registry keys
                try {
                    StatusText      = "Status: Removing CoApp Registry Settings.";
                    OverallProgress = 83;
                    OnPropertyChanged();

                    var registryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64).CreateSubKey(@"Software");
                    if (registryKey != null)
                    {
                        registryKey.DeleteSubKeyTree("CoApp");
                    }
                } catch {
                }

                StatusText      = "Status: Cleaning up Temp Folder.";
                OverallProgress = 85;
                OnPropertyChanged();

                foreach (var f in Directory.EnumerateFiles(FilesystemExtensions.TempPath, "*.msi"))
                {
                    FilesystemExtensions.TryHardToDelete(f);
                }
                OverallProgress = 88;
                OnPropertyChanged();

                foreach (var f in Directory.EnumerateFiles(FilesystemExtensions.TempPath, "*.tmp"))
                {
                    FilesystemExtensions.TryHardToDelete(f);
                }

                OverallProgress = 91;
                OnPropertyChanged();

                foreach (var f in Directory.EnumerateFiles(FilesystemExtensions.TempPath, "*.exe"))
                {
                    FilesystemExtensions.TryHardToDelete(f);
                }
                OverallProgress = 93;
                OnPropertyChanged();

                foreach (var f in Directory.EnumerateFiles(FilesystemExtensions.TempPath, "*.dll"))
                {
                    FilesystemExtensions.TryHardToDelete(f);
                }

                OverallProgress = 95;
                OnPropertyChanged();


                MsiSetExternalUI(null, 0x400, IntPtr.Zero);
                FilesystemExtensions.RemoveTemporaryFiles();

                StatusText      = "Status: Complete";
                OverallProgress = 100;
                OnPropertyChanged();
            } catch {
                // meh.
            }

            Environment.Exit(0);
        }