コード例 #1
0
            // NB: Once we uninstall the old version of the app, we try to schedule
            // it to be deleted at next reboot. Unfortunately, depending on whether
            // the user has admin permissions, this can fail. So as a failsafe,
            // before we try to apply any update, we assume previous versions in the
            // directory are "dead" (i.e. already uninstalled, but not deleted), and
            // we blow them away. This is to make sure that we don't attempt to run
            // an uninstaller on an already-uninstalled version.
            async Task cleanDeadVersions(SemanticVersion currentVersion, SemanticVersion newVersion, bool forceUninstall = false)
            {
                if (newVersion == null)
                {
                    return;
                }

                var di = new DirectoryInfo(rootAppDirectory);

                if (!di.Exists)
                {
                    return;
                }

                this.Log().Info("cleanDeadVersions: checking for version {0}", newVersion);

                string currentVersionFolder = null;

                if (currentVersion != null)
                {
                    currentVersionFolder = getDirectoryForRelease(currentVersion).Name;
                    this.Log().Info("cleanDeadVersions: exclude current version folder {0}", currentVersionFolder);
                }

                string newVersionFolder = null;

                if (newVersion != null)
                {
                    newVersionFolder = getDirectoryForRelease(newVersion).Name;
                    this.Log().Info("cleanDeadVersions: exclude new version folder {0}", newVersionFolder);
                }

                // NB: If we try to access a directory that has already been
                // scheduled for deletion by MoveFileEx it throws what seems like
                // NT's only error code, ERROR_ACCESS_DENIED. Squelch errors that
                // come from here.
                var toCleanup = di.GetDirectories()
                                .Where(x => x.Name.ToLowerInvariant().Contains("app-"))
                                .Where(x => x.Name != newVersionFolder && x.Name != currentVersionFolder)
                                .Where(x => !isAppFolderDead(x.FullName));

                if (forceUninstall == false)
                {
                    await toCleanup.ForEachAsync(async x => {
                        var squirrelApps = SquirrelAwareExecutableDetector.GetAllSquirrelAwareApps(x.FullName);
                        var args         = String.Format("--squirrel-obsolete {0}", x.Name.Replace("app-", ""));

                        if (squirrelApps.Count > 0)
                        {
                            // For each app, run the install command in-order and wait
                            await squirrelApps.ForEachAsync(async exe => {
                                using (var cts = new CancellationTokenSource()) {
                                    cts.CancelAfter(10 * 1000);

                                    try {
                                        await Utility.InvokeProcessAsync(exe, args, cts.Token);
                                    } catch (Exception ex) {
                                        this.Log().ErrorException("Coudln't run Squirrel hook, continuing: " + exe, ex);
                                    }
                                }
                            }, 1 /* at a time */);
                        }
                    });
                }

                // Include dead folders in folders to :fire:
                toCleanup = di.GetDirectories()
                            .Where(x => x.Name.ToLowerInvariant().Contains("app-"))
                            .Where(x => x.Name != newVersionFolder && x.Name != currentVersionFolder);

                // Get the current process list in an attempt to not burn
                // directories which have running processes
                var runningProcesses = UnsafeUtility.EnumerateProcesses();

                // Finally, clean up the app-X.Y.Z directories
                await toCleanup.ForEachAsync(async x => {
                    try {
                        if (runningProcesses.All(p => p.Item1 == null || !p.Item1.StartsWith(x.FullName, StringComparison.OrdinalIgnoreCase)))
                        {
                            await Utility.DeleteDirectoryOrJustGiveUp(x.FullName);
                        }

                        if (Directory.Exists(x.FullName))
                        {
                            // NB: If we cannot clean up a directory, we need to make
                            // sure that anyone finding it later won't attempt to run
                            // Squirrel events on it. We'll mark it with a .dead file
                            markAppFolderAsDead(x.FullName);
                        }
                    } catch (UnauthorizedAccessException ex) {
                        this.Log().WarnException("Couldn't delete directory: " + x.FullName, ex);

                        // NB: Same deal as above
                        markAppFolderAsDead(x.FullName);
                    }
                });

                // Clean up the packages directory too
                var releasesFile = Utility.LocalReleaseFileForAppDir(rootAppDirectory);
                var entries      = ReleaseEntry.ParseReleaseFile(File.ReadAllText(releasesFile, Encoding.UTF8));
                var pkgDir       = Utility.PackageDirectoryForAppDir(rootAppDirectory);
                var releaseEntry = default(ReleaseEntry);

                foreach (var entry in entries)
                {
                    if (entry.Version == newVersion)
                    {
                        releaseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(pkgDir, entry.Filename));
                        continue;
                    }

                    File.Delete(Path.Combine(pkgDir, entry.Filename));
                }

                ReleaseEntry.WriteReleaseFile(new[] { releaseEntry }, releasesFile);
            }
コード例 #2
0
            public int KillAllProcessesBelongingToPackage()
            {
                var ourExe     = Assembly.GetEntryAssembly();
                var ourExePath = ourExe != null ? ourExe.Location : null;

                List <Tuple <string, int> > running = null;

                running = UnsafeUtility.EnumerateProcesses()
                          .Where(x =>
                {
                    // Processes we can't query will have an empty process name, we can't kill them
                    // anyways
                    if (String.IsNullOrWhiteSpace(x.Item1))
                    {
                        return(false);
                    }

                    // Files that aren't in our root app directory are untouched
                    if (!x.Item1.StartsWith(rootAppDirectory, StringComparison.OrdinalIgnoreCase))
                    {
                        return(false);
                    }

                    // Never kill our own EXE
                    if (ourExePath != null && x.Item1.Equals(ourExePath, StringComparison.OrdinalIgnoreCase))
                    {
                        return(false);
                    }

                    var name = Path.GetFileName(x.Item1).ToLowerInvariant();
                    if (name == "squirrel.exe" || name == "update.exe")
                    {
                        return(false);
                    }

                    return(true);
                }).ToList();

                running.Sort((Tuple <string, int> p1, Tuple <string, int> p2) =>
                {
                    if (p1.Item1 == default)
                    {
                        return(p2.Item1 == default ? -1 : 0);
                    }
                    if (p2.Item1 == default)
                    {
                        return(1);
                    }

                    var p1Parent = UnsafeUtility.GetParentProcessId(p1.Item2);
                    var p2Parent = UnsafeUtility.GetParentProcessId(p2.Item2);

                    if (p1Parent == -1 && p2Parent == -1)
                    {
                        return(0);
                    }

                    // no parent is higher.
                    if (p1Parent == -1)
                    {
                        return(1);
                    }
                    if (p2Parent == -1)
                    {
                        return(-1);
                    }

                    // direct relationships
                    if (p1.Item2 == p2Parent)
                    {
                        return(1);
                    }

                    if (p2.Item2 == p1Parent)
                    {
                        return(-1);
                    }

                    // don't care
                    return(0);
                });

                running.ForEach(x =>
                {
                    try
                    {
                        this.WarnIfThrows(() => Process.GetProcessById(x.Item2).Kill());
                    }
                    catch { }
                });

                return(running.Count);
            }