コード例 #1
0
        public override bool TryPrepareApplicationDirectory(out string error)
        {
            string upgradeApplicationDirectory = ProductUpgraderInfo.GetUpgradeApplicationDirectory();

            Exception deleteDirectoryException;

            if (this.FileSystem.DirectoryExists(upgradeApplicationDirectory) &&
                !this.FileSystem.TryDeleteDirectory(upgradeApplicationDirectory, out deleteDirectoryException))
            {
                error = $"Failed to delete {upgradeApplicationDirectory} - {deleteDirectoryException.Message}";

                this.TraceException(deleteDirectoryException, nameof(this.TryPrepareApplicationDirectory), $"Error deleting {upgradeApplicationDirectory}.");
                return(false);
            }

            if (!this.FileSystem.TryCreateOrUpdateDirectoryToAdminModifyPermissions(
                    this.Tracer,
                    upgradeApplicationDirectory,
                    out error))
            {
                return(false);
            }

            error = null;
            return(true);
        }
コード例 #2
0
 public override bool TryPrepareDownloadDirectory(out string error)
 {
     return(this.FileSystem.TryCreateOrUpdateDirectoryToAdminModifyPermissions(
                this.Tracer,
                ProductUpgraderInfo.GetAssetDownloadsPath(),
                out error));
 }
コード例 #3
0
        public override bool TryPrepareApplicationDirectory(out string error)
        {
            string rootDirectoryPath  = ProductUpgraderInfo.GetUpgradesDirectoryPath();
            string toolsDirectoryPath = Path.Combine(rootDirectoryPath, ProductUpgrader.ToolsDirectory);

            Exception deleteDirectoryException;

            if (this.FileSystem.DirectoryExists(toolsDirectoryPath) &&
                !this.FileSystem.TryDeleteDirectory(toolsDirectoryPath, out deleteDirectoryException))
            {
                error = $"Failed to delete {toolsDirectoryPath} - {deleteDirectoryException.Message}";

                this.TraceException(deleteDirectoryException, nameof(this.TryPrepareApplicationDirectory), $"Error deleting {toolsDirectoryPath}.");
                return(false);
            }

            if (!this.FileSystem.TryCreateOrUpdateDirectoryToAdminModifyPermissions(
                    this.Tracer,
                    toolsDirectoryPath,
                    out error))
            {
                return(false);
            }

            error = null;
            return(true);
        }
コード例 #4
0
        public override bool TryPrepareLogDirectory(out string error)
        {
            // Under normal circumstances
            // ProductUpgraderInfo.GetLogDirectoryPath will have
            // already been created by Scalar.Service.  If for some
            // reason it does not (e.g. the service failed to start),
            // we need to create
            // ProductUpgraderInfo.GetLogDirectoryPath() explicity to
            // ensure that it has the correct ACLs (so that both admin
            // and non-admin users can create log files).  If the logs
            // directory does not already exist, this call could fail
            // when running as a non-elevated user.
            string createDirectoryError;

            if (!this.FileSystem.TryCreateDirectoryWithAdminAndUserModifyPermissions(ProductUpgraderInfo.GetLogDirectoryPath(), out createDirectoryError))
            {
                error  = $"ERROR: Unable to create directory `{ProductUpgraderInfo.GetLogDirectoryPath()}`";
                error += $"\n{createDirectoryError}";
                error += $"\n\nTry running {ScalarConstants.UpgradeVerbMessages.ScalarUpgrade} from an elevated command prompt.";
                return(false);
            }

            error = null;
            return(true);
        }
コード例 #5
0
        internal NuGetUpgrader(
            string currentVersion,
            ITracer tracer,
            bool dryRun,
            bool noVerify,
            PhysicalFileSystem fileSystem,
            NuGetUpgraderConfig config,
            NuGetFeed nuGetFeed,
            ICredentialStore credentialStore)
            : base(
                currentVersion,
                tracer,
                dryRun,
                noVerify,
                fileSystem)
        {
            this.nuGetUpgraderConfig = config;

            this.nuGetFeed       = nuGetFeed;
            this.credentialStore = credentialStore;

            // Extract the folder inside ProductUpgraderInfo.GetAssetDownloadsPath to ensure the
            // correct ACLs are in place
            this.ExtractedInstallerPath = Path.Combine(
                ProductUpgraderInfo.GetAssetDownloadsPath(),
                ExtractedInstallerDirectoryName);
        }
コード例 #6
0
        private void TimerCallback(object unusedState)
        {
            string errorMessage = null;
            InstallerPreRunChecker prerunChecker = new InstallerPreRunChecker(this.tracer, string.Empty);
            IProductUpgrader       productUpgrader;
            bool deleteExistingDownloads = true;

            if (ProductUpgraderFactory.TryCreateUpgrader(out productUpgrader, this.tracer, out errorMessage))
            {
                if (prerunChecker.TryRunPreUpgradeChecks(out string _) && this.TryDownloadUpgrade(productUpgrader, out errorMessage))
                {
                    deleteExistingDownloads = false;
                }
            }

            if (errorMessage != null)
            {
                this.tracer.RelatedError(errorMessage);
            }

            if (deleteExistingDownloads)
            {
                ProductUpgraderInfo.DeleteAllInstallerDownloads();
            }
        }
コード例 #7
0
ファイル: UpgradeVerb.cs プロジェクト: py361/VFSForGit
        private bool TryInitializeUpgrader(out string error)
        {
            if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSUpgrade)
            {
                error = null;
                if (this.upgrader == null)
                {
                    JsonTracer jsonTracer  = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "UpgradeVerb");
                    string     logFilePath = GVFSEnlistment.GetNewGVFSLogFileName(
                        ProductUpgraderInfo.GetLogDirectoryPath(),
                        GVFSConstants.LogFileTypes.UpgradeVerb);
                    jsonTracer.AddLogFileEventListener(logFilePath, EventLevel.Informational, Keywords.Any);

                    this.tracer        = jsonTracer;
                    this.prerunChecker = new InstallerPreRunChecker(this.tracer, this.Confirmed ? GVFSConstants.UpgradeVerbMessages.GVFSUpgradeConfirm : GVFSConstants.UpgradeVerbMessages.GVFSUpgrade);

                    IProductUpgrader upgrader;
                    if (ProductUpgraderFactory.TryCreateUpgrader(out upgrader, this.tracer, out error))
                    {
                        this.upgrader = upgrader;
                    }
                    else
                    {
                        error = $"ERROR: {error}";
                    }
                }

                return(this.upgrader != null);
            }
            else
            {
                error = $"ERROR: {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} is not supported on this operating system.";
                return(false);
            }
        }
コード例 #8
0
        private void CreateAndConfigureUpgradeLogDirectory()
        {
            string            upgradeLogsPath     = ProductUpgraderInfo.GetLogDirectoryPath();
            DirectorySecurity upgradeLogsSecurity = this.GetUpgradeLogsDirectorySecurity(upgradeLogsPath);

            Directory.CreateDirectory(upgradeLogsPath, upgradeLogsSecurity);
            try
            {
                // Call SetAccessControl in case the directory already existed
                // (in which case the above CreateDirectory was a no-op)
                Directory.SetAccessControl(upgradeLogsPath, upgradeLogsSecurity);
            }
            catch (UnauthorizedAccessException e)
            {
                // UnauthorizedAccessException can occur when the upgrade logs directory was
                // created by a non-elevated user running 'gvfs upgrade'.  Only the owner
                // is allowed to modify the ACLs, and if the logs directory was created by
                // the user running 'gvfs upgrade' then the Adminstrators group is not the owner.

                EventMetadata metadata = new EventMetadata();
                metadata.Add("Exception", e.ToString());
                metadata.Add(
                    TracingConstants.MessageKey.InfoMessage,
                    $"{nameof(this.CreateAndConfigureUpgradeLogDirectory)}: UnauthorizedAccessException when setting log directory ACLs");
                this.tracer.RelatedEvent(EventLevel.Informational, "LogDirACL_UnauthorizedAccessException", metadata);

                // To avoid the ownership issues, rename the old log directory, create a new one, and migrate over
                // all of the contents of the old directory.
                this.MigrateUpgradeLogsToDirectoryWithFreshACLs();
            }
        }
コード例 #9
0
        /// <summary>
        /// Saves a copy of installer log from platform native installer in the
        /// upgrader diagnose logs directory. On the Mac, it is not possible to
        /// specify custom log file path as command line arg to the installer.
        /// </summary>
        private void SaveSystemInstallerLogs()
        {
            if (GVFSPlatform.Instance.SupportsSystemInstallLog)
            {
                string systemInstallerLog = GVFSPlatform.Instance.GetSystemInstallerLogPath();
                if (!string.IsNullOrEmpty(systemInstallerLog))
                {
                    string destinationPath = GVFSEnlistment.GetNewGVFSLogFileName(
                        ProductUpgraderInfo.GetLogDirectoryPath(),
                        GVFSConstants.LogFileTypes.UpgradeSystemInstaller,
                        this.UpgradeInstanceId);

                    try
                    {
                        using (Stream sourceStream = this.fileSystem.OpenFileStream(
                                   systemInstallerLog,
                                   FileMode.Open,
                                   FileAccess.Read,
                                   FileShare.ReadWrite,
                                   callFlushFileBuffers: false))
                            using (Stream destStream = this.fileSystem.OpenFileStream(
                                       destinationPath,
                                       FileMode.Create,
                                       FileAccess.Write,
                                       FileShare.None,
                                       callFlushFileBuffers: false))
                            {
                                // Copy the last 100K from the system wide installer log.
                                // System wide installer log (/var/log/install.log) holds
                                // all messages from installd, including the ones that
                                // it generated while installing VFSForGit. We don't
                                // need to capture the whole file, which can be lengthy.
                                // From my testing, the last 100K captured immediately
                                // after upgrade, is found to be lengthy enough to
                                // contain all of Git + GCM + Service + VFSForGit
                                // installer log messages.
                                long hundredKB      = 100 * 1024;
                                long copyFromOffset = sourceStream.Length > hundredKB ? sourceStream.Length - hundredKB : 0;

                                sourceStream.Seek(copyFromOffset, SeekOrigin.Begin);
                                sourceStream.CopyTo(destStream);
                            }
                    }
                    catch (Exception ex)
                    {
                        EventMetadata metadata = new EventMetadata();
                        metadata.Add("Exception", ex.ToString());
                        this.tracer.RelatedError(
                            metadata,
                            $"{nameof(this.SaveSystemInstallerLogs)} - Error saving native installer log file.");
                    }
                }
                else
                {
                    this.tracer.RelatedError($"{nameof(this.SaveSystemInstallerLogs)} - Error getting native installer log file path.");
                }
            }
        }
コード例 #10
0
ファイル: UpgradeVerb.cs プロジェクト: yunshan/VFSForGit
        private bool TryInitializeUpgrader(out string error)
        {
            if (this.DryRun && this.Confirmed)
            {
                error = $"{DryRunOption} and {ConfirmOption} arguments are not compatible.";
                return(false);
            }

            if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSUpgrade)
            {
                error = null;
                if (this.upgrader == null)
                {
                    this.productUpgraderPlatformStrategy = GVFSPlatform.Instance.CreateProductUpgraderPlatformInteractions(this.fileSystem, tracer: null);
                    if (!this.productUpgraderPlatformStrategy.TryPrepareLogDirectory(out error))
                    {
                        return(false);
                    }

                    JsonTracer jsonTracer  = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "UpgradeVerb");
                    string     logFilePath = GVFSEnlistment.GetNewGVFSLogFileName(
                        ProductUpgraderInfo.GetLogDirectoryPath(),
                        GVFSConstants.LogFileTypes.UpgradeVerb);
                    jsonTracer.AddLogFileEventListener(logFilePath, EventLevel.Informational, Keywords.Any);

                    this.tracer        = jsonTracer;
                    this.prerunChecker = new InstallerPreRunChecker(this.tracer, this.Confirmed ? GVFSPlatform.Instance.Constants.UpgradeConfirmCommandMessage : GVFSConstants.UpgradeVerbMessages.GVFSUpgrade);

                    string gitBinPath = GVFSPlatform.Instance.GitInstallation.GetInstalledGitBinPath();
                    if (string.IsNullOrEmpty(gitBinPath))
                    {
                        error = $"nameof(this.TryInitializeUpgrader): Unable to locate git installation. Ensure git is installed and try again.";
                        return(false);
                    }

                    ICredentialStore credentialStore = new GitProcess(gitBinPath, workingDirectoryRoot: null);

                    ProductUpgrader upgrader;
                    if (ProductUpgrader.TryCreateUpgrader(this.tracer, this.fileSystem, new LocalGVFSConfig(), credentialStore, this.DryRun, this.NoVerify, out upgrader, out error))
                    {
                        this.upgrader = upgrader;
                    }
                    else
                    {
                        error = $"ERROR: {error}";
                    }
                }

                return(this.upgrader != null);
            }
            else
            {
                error = $"ERROR: {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} is not supported on this operating system.";
                return(false);
            }
        }
コード例 #11
0
        private void MigrateUpgradeLogsToDirectoryWithFreshACLs()
        {
            string upgradeLogsPath     = ProductUpgraderInfo.GetLogDirectoryPath();
            string tempUpgradeLogsPath = Path.Combine(
                Path.GetDirectoryName(upgradeLogsPath),
                ProductUpgraderInfo.LogDirectory + "_" + Guid.NewGuid().ToString("N"));

            this.tracer.RelatedInfo($"{nameof(this.MigrateUpgradeLogsToDirectoryWithFreshACLs)}: Renaming '{upgradeLogsPath}' to '{tempUpgradeLogsPath}'");
            Directory.Move(upgradeLogsPath, tempUpgradeLogsPath);

            this.tracer.RelatedInfo($"{nameof(this.MigrateUpgradeLogsToDirectoryWithFreshACLs)}: Creating new '{upgradeLogsPath}' directory with appropriate ACLs");
            DirectorySecurity upgradeLogsSecurity = this.GetUpgradeLogsDirectorySecurity(upgradeLogsPath);

            Directory.CreateDirectory(upgradeLogsPath, upgradeLogsSecurity);

            try
            {
                DirectoryInfo tempDirectoryInfo = new DirectoryInfo(tempUpgradeLogsPath);

                this.tracer.RelatedInfo($"Moving directories from '{tempUpgradeLogsPath}' to '{upgradeLogsPath}'");
                foreach (DirectoryInfo logDirectoryInfo in tempDirectoryInfo.EnumerateDirectories(searchPattern: "*", searchOption: SearchOption.TopDirectoryOnly))
                {
                    Directory.Move(logDirectoryInfo.FullName, Path.Combine(upgradeLogsPath, logDirectoryInfo.Name));
                }

                this.tracer.RelatedInfo($"Moving files from '{tempUpgradeLogsPath}' to '{upgradeLogsPath}'");
                foreach (FileInfo logFileInfo in tempDirectoryInfo.EnumerateFiles(searchPattern: "*", searchOption: SearchOption.TopDirectoryOnly))
                {
                    File.Move(logFileInfo.FullName, Path.Combine(upgradeLogsPath, logFileInfo.Name));
                }

                FileSystemInfo[] remainingChildren = tempDirectoryInfo.GetFileSystemInfos();
                if (remainingChildren.Length > 0)
                {
                    this.tracer.RelatedWarning(
                        $"{nameof(this.MigrateUpgradeLogsToDirectoryWithFreshACLs)}: Skipping delete of old directory, {remainingChildren.Length} items still present on disk");
                }
                else
                {
                    PhysicalFileSystem fileSystem = new PhysicalFileSystem();
                    fileSystem.DeleteDirectory(tempUpgradeLogsPath, recursive: false);
                }
            }
            catch (Exception e)
            {
                EventMetadata metadata = new EventMetadata();
                metadata.Add("Exception", e.ToString());
                metadata.Add(nameof(tempUpgradeLogsPath), tempUpgradeLogsPath);
                metadata.Add(nameof(upgradeLogsPath), upgradeLogsPath);

                this.tracer.RelatedWarning(
                    metadata,
                    $"{nameof(this.MigrateUpgradeLogsToDirectoryWithFreshACLs)}: Caught exception migrating files from the old upgrade log directory");
            }
        }
コード例 #12
0
        public override void Execute()
        {
            this.ValidatePathParameter(this.EnlistmentRootPathParameter);

            this.Output.WriteLine("Most recent log files:");

            string errorMessage;
            string enlistmentRoot;

            if (!GVFSPlatform.Instance.TryGetGVFSEnlistmentRoot(this.EnlistmentRootPathParameter, out enlistmentRoot, out errorMessage))
            {
                this.ReportErrorAndExit(
                    "Error: '{0}' is not a valid GVFS enlistment",
                    this.EnlistmentRootPathParameter);
            }

            string gvfsLogsRoot = Path.Combine(
                enlistmentRoot,
                GVFSPlatform.Instance.Constants.DotGVFSRoot,
                GVFSConstants.DotGVFS.LogName);

            if (this.LogType == null)
            {
                this.DisplayMostRecent(gvfsLogsRoot, GVFSConstants.LogFileTypes.Clone);

                // By using MountPrefix ("mount") DisplayMostRecent will display either mount_verb, mount_upgrade, or mount_process, whichever is more recent
                this.DisplayMostRecent(gvfsLogsRoot, GVFSConstants.LogFileTypes.MountPrefix);
                this.DisplayMostRecent(gvfsLogsRoot, GVFSConstants.LogFileTypes.Prefetch);
                this.DisplayMostRecent(gvfsLogsRoot, GVFSConstants.LogFileTypes.Dehydrate);
                this.DisplayMostRecent(gvfsLogsRoot, GVFSConstants.LogFileTypes.Repair);
                this.DisplayMostRecent(gvfsLogsRoot, GVFSConstants.LogFileTypes.Sparse);

                string serviceLogsRoot = Path.Combine(
                    GVFSPlatform.Instance.GetDataRootForGVFSComponent(GVFSConstants.Service.ServiceName),
                    GVFSConstants.Service.LogDirectory);
                this.DisplayMostRecent(serviceLogsRoot, GVFSConstants.LogFileTypes.Service);

                this.DisplayMostRecent(ProductUpgraderInfo.GetLogDirectoryPath(), GVFSConstants.LogFileTypes.UpgradePrefix);
            }
            else
            {
                string logFile = FindNewestFileInFolder(gvfsLogsRoot, this.LogType);
                if (logFile == null)
                {
                    this.ReportErrorAndExit("No log file found");
                }
                else
                {
                    foreach (string line in File.ReadAllLines(logFile))
                    {
                        this.Output.WriteLine(line);
                    }
                }
            }
        }
コード例 #13
0
        /// <summary>
        /// Try to load a NuGetUpgrader from config settings.
        /// <isConfigured>Flag to indicate whether the system is configured to use a NuGetUpgrader.
        /// A NuGetUpgrader can be set as the Upgrader to use, but it might not be properly configured.
        /// </isConfigured>
        /// <Returns>True if able to load a properly configured NuGetUpgrader<Returns>
        /// </summary>
        public static bool TryCreate(
            ITracer tracer,
            PhysicalFileSystem fileSystem,
            bool dryRun,
            bool noVerify,
            out NuGetUpgrader nuGetUpgrader,
            out bool isConfigured,
            out string error)
        {
            NuGetUpgraderConfig upgraderConfig = new NuGetUpgraderConfig(tracer, new LocalGVFSConfig());

            nuGetUpgrader = null;
            isConfigured  = false;

            if (!upgraderConfig.TryLoad(out error))
            {
                nuGetUpgrader = null;
                return(false);
            }

            if (!(isConfigured = upgraderConfig.IsConfigured(out error)))
            {
                return(false);
            }

            // At this point, we have determined that the system is set up to use
            // the NuGetUpgrader

            if (!upgraderConfig.IsReady(out error))
            {
                return(false);
            }

            string gitBinPath = GVFSPlatform.Instance.GitInstallation.GetInstalledGitBinPath();

            if (string.IsNullOrEmpty(gitBinPath))
            {
                error = $"NuGetUpgrader: Unable to locate git installation. Ensure git is installed and try again.";
                return(false);
            }

            ICredentialStore credentialStore = new GitProcess(gitBinPath, workingDirectoryRoot: null, gvfsHooksRoot: null);

            nuGetUpgrader = new NuGetUpgrader(
                ProcessHelper.GetCurrentProcessVersion(),
                tracer,
                fileSystem,
                dryRun,
                noVerify,
                upgraderConfig,
                ProductUpgraderInfo.GetAssetDownloadsPath(),
                credentialStore);

            return(true);
        }
コード例 #14
0
ファイル: UpgradeVerb.cs プロジェクト: team172011/VFSForGit
        private bool TryInitializeUpgrader(out string error)
        {
            if (this.DryRun && this.Confirmed)
            {
                error = $"{DryRunOption} and {ConfirmOption} arguments are not compatible.";
                return(false);
            }

            if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSUpgrade)
            {
                error = null;
                if (this.upgrader == null)
                {
                    // Under normal circumstances ProductUpgraderInfo.GetLogDirectoryPath will have already been created by GVFS.Service.  If for some reason it
                    // does not (e.g. the service failed to start), we need to create ProductUpgraderInfo.GetLogDirectoryPath() explicity to ensure that
                    // it has the correct ACLs (so that both admin and non-admin users can create log files).
                    // If the logs directory does not already exist, this call could fail when running as a non-elevated user.
                    string createDirectoryError;
                    if (!this.fileSystem.TryCreateDirectoryWithAdminAndUserModifyPermissions(ProductUpgraderInfo.GetLogDirectoryPath(), out createDirectoryError))
                    {
                        error  = $"ERROR: Unable to create directory `{ProductUpgraderInfo.GetLogDirectoryPath()}`";
                        error += $"\n{createDirectoryError}";
                        error += $"\n\nTry running {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} from an elevated command prompt.";
                        return(false);
                    }

                    JsonTracer jsonTracer  = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "UpgradeVerb");
                    string     logFilePath = GVFSEnlistment.GetNewGVFSLogFileName(
                        ProductUpgraderInfo.GetLogDirectoryPath(),
                        GVFSConstants.LogFileTypes.UpgradeVerb);
                    jsonTracer.AddLogFileEventListener(logFilePath, EventLevel.Informational, Keywords.Any);

                    this.tracer        = jsonTracer;
                    this.prerunChecker = new InstallerPreRunChecker(this.tracer, this.Confirmed ? GVFSConstants.UpgradeVerbMessages.GVFSUpgradeConfirm : GVFSConstants.UpgradeVerbMessages.GVFSUpgrade);

                    ProductUpgrader upgrader;
                    if (ProductUpgrader.TryCreateUpgrader(this.tracer, this.fileSystem, this.DryRun, this.NoVerify, out upgrader, out error))
                    {
                        this.upgrader = upgrader;
                    }
                    else
                    {
                        error = $"ERROR: {error}";
                    }
                }

                return(this.upgrader != null);
            }
            else
            {
                error = $"ERROR: {GVFSConstants.UpgradeVerbMessages.GVFSUpgrade} is not supported on this operating system.";
                return(false);
            }
        }
コード例 #15
0
        public void SetUp()
        {
            this.upgradeDirectory = GVFSPlatform.Instance.GetDataRootForGVFSComponent(ProductUpgraderInfo.UpgradeDirectoryName);
            this.expectedNewVersionExistsFilePath = Path.Combine(this.upgradeDirectory, this.expectedNewVersionExistsFileName);
            this.mockFileSystem = new Mock <PhysicalFileSystem>();

            this.mockFileSystem.Setup(fileSystem => fileSystem.WriteAllText(this.expectedNewVersionExistsFilePath, It.IsAny <string>()));

            this.tracer = new MockTracer();

            this.productUpgraderInfo = new ProductUpgraderInfo(
                this.tracer,
                this.mockFileSystem.Object);
        }
コード例 #16
0
        private static void RemindUpgradeAvailable()
        {
            // The idea is to generate a random number between 0 and 100. To make
            // sure that the reminder is displayed only 10% of the times a git
            // command is run, check that the random number is between 0 and 10,
            // which will have a probability of 10/100 == 10%.
            int reminderFrequency = 10;
            int randomValue       = random.Next(0, 100);

            if (randomValue <= reminderFrequency && ProductUpgraderInfo.IsLocalUpgradeAvailable(tracer: null))
            {
                Console.WriteLine(Environment.NewLine + GVFSConstants.UpgradeVerbMessages.ReminderNotification);
            }
        }
コード例 #17
0
        public void SetUp()
        {
            this.upgradeDirectory = ProductUpgraderInfo.GetHighestAvailableVersionDirectory();
            this.expectedNewVersionExistsFilePath = Path.Combine(this.upgradeDirectory, this.expectedNewVersionExistsFileName);
            this.mockFileSystem = new Mock <PhysicalFileSystem>();

            this.mockFileSystem.Setup(fileSystem => fileSystem.WriteAllText(this.expectedNewVersionExistsFilePath, It.IsAny <string>()));

            this.tracer = new MockTracer();

            this.productUpgraderInfo = new ProductUpgraderInfo(
                this.tracer,
                this.mockFileSystem.Object);
        }
コード例 #18
0
        private void CreateAndConfigureProgramDataDirectories()
        {
            string serviceDataRootPath = ScalarPlatform.Instance.GetSecureDataRootForScalar();

            // Create Scalar.Service and Scalar.Upgrade related directories (if they don't already exist)
            // TODO #136: Determine if we still should be creating Scalar.Service here
            DirectoryEx.CreateDirectory(serviceDataRootPath);
            DirectoryEx.CreateDirectory(this.serviceDataLocation);
            DirectoryEx.CreateDirectory(ProductUpgraderInfo.GetUpgradeProtectedDataDirectory());

            // Special rules for the upgrader logs and registry, as non-elevated users need to be be able to write
            this.CreateAndConfigureUserWriteableDirectory(this.repoRegistryLocation);
            this.CreateAndConfigureUserWriteableDirectory(ProductUpgraderInfo.GetLogDirectoryPath());
            this.CreateAndConfigureUserWriteableDirectory(ScalarPlatform.Instance.GetLogsDirectoryForGVFSComponent(ScalarConstants.Service.UIName));
        }
コード例 #19
0
        private static void RemindUpgradeAvailable()
        {
            // The idea is to generate a random number between 0 and 100. To make
            // sure that the reminder is displayed only 10% of the times a git
            // command is run, check that the random number is between 0 and 10,
            // which will have a probability of 10/100 == 10%.
            int reminderFrequency = 10;
            int randomValue       = random.Next(0, 100);

            if ((IsUpgradeMessageDeterministic() || randomValue <= reminderFrequency) &&
                ProductUpgraderInfo.IsLocalUpgradeAvailable(tracer: null, highestAvailableVersionDirectory: GVFSHooksPlatform.GetUpgradeHighestAvailableVersionDirectory()))
            {
                Console.WriteLine(Environment.NewLine + GVFSHooksPlatform.GetUpgradeReminderNotification());
            }
        }
コード例 #20
0
        /// <summary>
        /// Try to load a NuGetUpgrader from config settings.
        /// <isConfigured>Flag to indicate whether the system is configured to use a NuGetUpgrader.
        /// A NuGetUpgrader can be set as the Upgrader to use, but it might not be properly configured.
        /// </isConfigured>
        /// <Returns>True if able to load a properly configured NuGetUpgrader<Returns>
        /// </summary>
        public static bool TryCreate(
            ITracer tracer,
            PhysicalFileSystem fileSystem,
            LocalScalarConfig scalarConfig,
            ICredentialStore credentialStore,
            bool dryRun,
            bool noVerify,
            out NuGetUpgrader nuGetUpgrader,
            out bool isConfigured,
            out string error)
        {
            NuGetUpgraderConfig upgraderConfig = new NuGetUpgraderConfig(tracer, scalarConfig);

            nuGetUpgrader = null;
            isConfigured  = false;

            if (!upgraderConfig.TryLoad(out error))
            {
                nuGetUpgrader = null;
                return(false);
            }

            if (!(isConfigured = upgraderConfig.IsConfigured(out error)))
            {
                return(false);
            }

            // At this point, we have determined that the system is set up to use
            // the NuGetUpgrader

            if (!upgraderConfig.IsReady(out error))
            {
                return(false);
            }

            nuGetUpgrader = new NuGetUpgrader(
                ProcessHelper.GetCurrentProcessVersion(),
                tracer,
                fileSystem,
                dryRun,
                noVerify,
                upgraderConfig,
                ProductUpgraderInfo.GetAssetDownloadsPath(),
                credentialStore);

            return(true);
        }
コード例 #21
0
        private void CreateAndConfigureProgramDataDirectories()
        {
            string serviceDataRootPath = Path.GetDirectoryName(this.serviceDataLocation);

            DirectorySecurity serviceDataRootSecurity = this.GetServiceDirectorySecurity(serviceDataRootPath);

            // Create GVFS.Service and GVFS.Upgrade related directories (if they don't already exist)
            Directory.CreateDirectory(serviceDataRootPath, serviceDataRootSecurity);
            Directory.CreateDirectory(this.serviceDataLocation, serviceDataRootSecurity);
            Directory.CreateDirectory(ProductUpgraderInfo.GetUpgradeProtectedDataDirectory(), serviceDataRootSecurity);

            // Ensure the ACLs are set correctly on any files or directories that were already created (e.g. after upgrading VFS4G)
            Directory.SetAccessControl(serviceDataRootPath, serviceDataRootSecurity);

            // Special rules for the upgrader logs, as non-elevated users need to be be able to write
            this.CreateAndConfigureUpgradeLogDirectory();
        }
コード例 #22
0
        private void CreateAndConfigureUpgradeLogDirectory()
        {
            string upgradeLogsPath = ProductUpgraderInfo.GetLogDirectoryPath();

            string error;

            if (!GVFSPlatform.Instance.FileSystem.TryCreateDirectoryWithAdminAndUserModifyPermissions(upgradeLogsPath, out error))
            {
                EventMetadata metadata = new EventMetadata();
                metadata.Add("Area", EtwArea);
                metadata.Add(nameof(upgradeLogsPath), upgradeLogsPath);
                metadata.Add(nameof(error), error);
                this.tracer.RelatedWarning(
                    metadata,
                    $"{nameof(this.CreateAndConfigureUpgradeLogDirectory)}: Failed to create upgrade logs directory",
                    Keywords.Telemetry);
            }
        }
コード例 #23
0
        public UpgradeOrchestrator()
        {
            string logFilePath = GVFSEnlistment.GetNewGVFSLogFileName(
                ProductUpgraderInfo.GetLogDirectoryPath(),
                GVFSConstants.LogFileTypes.UpgradeProcess);
            JsonTracer jsonTracer = new JsonTracer(GVFSConstants.GVFSEtwProviderName, "UpgradeProcess");

            jsonTracer.AddLogFileEventListener(
                logFilePath,
                DefaultEventLevel,
                Keywords.Any);

            this.tracer        = jsonTracer;
            this.preRunChecker = new InstallerPreRunChecker(this.tracer, GVFSConstants.UpgradeVerbMessages.GVFSUpgradeConfirm);
            this.output        = Console.Out;
            this.input         = Console.In;
            this.mount         = false;
            this.ExitCode      = ReturnCode.Success;
        }
コード例 #24
0
        public override bool TryPrepareDownloadDirectory(out string error)
        {
            string directory = ProductUpgraderInfo.GetAssetDownloadsPath();

            Exception deleteDirectoryException;

            if (this.FileSystem.DirectoryExists(directory) &&
                !this.FileSystem.TryDeleteDirectory(directory, out deleteDirectoryException))
            {
                error = $"Failed to delete {directory} - {deleteDirectoryException.Message}";

                this.TraceException(deleteDirectoryException, nameof(this.TryPrepareDownloadDirectory), $"Error deleting {directory}.");
                return(false);
            }

            this.FileSystem.CreateDirectory(directory);

            error = null;
            return(true);
        }
コード例 #25
0
        private bool TryDownloadUpgrade(IProductUpgrader productUpgrader, out string errorMessage)
        {
            using (ITracer activity = this.tracer.StartActivity("Checking for product upgrades.", EventLevel.Informational))
            {
                Version newerVersion  = null;
                string  detailedError = null;
                if (!productUpgrader.UpgradeAllowed(out errorMessage))
                {
                    return(false);
                }

                if (!productUpgrader.TryQueryNewestVersion(out newerVersion, out detailedError))
                {
                    errorMessage = "Could not fetch new version info. " + detailedError;
                    return(false);
                }

                if (newerVersion == null)
                {
                    // Already up-to-date
                    // Make sure there a no asset installers remaining in the Downloads directory. This can happen if user
                    // upgraded by manually downloading and running asset installers.
                    ProductUpgraderInfo.DeleteAllInstallerDownloads();
                    errorMessage = null;
                    return(true);
                }

                if (productUpgrader.TryDownloadNewestVersion(out detailedError))
                {
                    errorMessage = null;
                    return(true);
                }
                else
                {
                    errorMessage = "Could not download product upgrade. " + detailedError;
                    return(false);
                }
            }
        }
コード例 #26
0
        private bool TryRunUpgrade(out Version newVersion, out string consoleError)
        {
            Version newGVFSVersion = null;
            string  error          = null;

            if (!this.upgrader.UpgradeAllowed(out error))
            {
                ProductUpgraderInfo productUpgraderInfo = new ProductUpgraderInfo(
                    this.tracer,
                    this.fileSystem);
                productUpgraderInfo.DeleteAllInstallerDownloads();
                this.output.WriteLine(error);
                consoleError = null;
                newVersion   = null;
                return(true);
            }

            if (!this.LaunchInsideSpinner(
                    () =>
            {
                if (!this.preRunChecker.TryRunPreUpgradeChecks(out error))
                {
                    return(false);
                }

                if (!this.TryCheckIfUpgradeAvailable(out newGVFSVersion, out error))
                {
                    return(false);
                }

                this.LogInstalledVersionInfo();

                if (newGVFSVersion != null && !this.TryDownloadUpgrade(newGVFSVersion, out error))
                {
                    return(false);
                }

                return(true);
            },
                    "Downloading"))
            {
                newVersion   = null;
                consoleError = error;
                return(false);
            }

            if (newGVFSVersion == null)
            {
                newVersion   = null;
                consoleError = null;
                return(true);
            }

            if (!this.LaunchInsideSpinner(
                    () =>
            {
                if (!this.preRunChecker.TryUnmountAllGVFSRepos(out error))
                {
                    return(false);
                }

                this.mount = true;

                return(true);
            },
                    "Unmounting repositories"))
            {
                newVersion   = null;
                consoleError = error;
                return(false);
            }

            if (!this.LaunchInsideSpinner(
                    () =>
            {
                if (!this.preRunChecker.IsInstallationBlockedByRunningProcess(out error))
                {
                    return(false);
                }

                return(true);
            },
                    "Checking for blocking processes."))
            {
                newVersion   = null;
                consoleError = error;
                return(false);
            }

            if (!this.upgrader.TryRunInstaller(this.LaunchInsideSpinner, out consoleError))
            {
                newVersion = null;
                return(false);
            }

            newVersion   = newGVFSVersion;
            consoleError = null;
            return(true);
        }
コード例 #27
0
        protected override void Execute(GVFSEnlistment enlistment)
        {
            string diagnosticsRoot = Path.Combine(enlistment.DotGVFSRoot, "diagnostics");

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

            string archiveFolderPath = Path.Combine(diagnosticsRoot, "gvfs_" + DateTime.Now.ToString("yyyyMMdd_HHmmss"));

            Directory.CreateDirectory(archiveFolderPath);

            using (FileStream diagnosticLogFile = new FileStream(Path.Combine(archiveFolderPath, "diagnostics.log"), FileMode.CreateNew))
                using (this.diagnosticLogFileWriter = new StreamWriter(diagnosticLogFile))
                {
                    this.WriteMessage("Collecting diagnostic info into temp folder " + archiveFolderPath);

                    this.WriteMessage(string.Empty);
                    this.WriteMessage("gvfs version " + ProcessHelper.GetCurrentProcessVersion());

                    GitVersion gitVersion = null;
                    string     error      = null;
                    if (!string.IsNullOrEmpty(enlistment.GitBinPath) && GitProcess.TryGetVersion(enlistment.GitBinPath, out gitVersion, out error))
                    {
                        this.WriteMessage("git version " + gitVersion.ToString());
                    }
                    else
                    {
                        this.WriteMessage("Could not determine git version. " + error);
                    }

                    this.WriteMessage(enlistment.GitBinPath);
                    this.WriteMessage(string.Empty);
                    this.WriteMessage("Enlistment root: " + enlistment.EnlistmentRoot);
                    this.WriteMessage("Cache Server: " + CacheServerResolver.GetCacheServerFromConfig(enlistment));

                    string localCacheRoot;
                    string gitObjectsRoot;
                    this.GetLocalCachePaths(enlistment, out localCacheRoot, out gitObjectsRoot);
                    string actualLocalCacheRoot = !string.IsNullOrWhiteSpace(localCacheRoot) ? localCacheRoot : gitObjectsRoot;
                    this.WriteMessage("Local Cache: " + actualLocalCacheRoot);
                    this.WriteMessage(string.Empty);

                    this.PrintDiskSpaceInfo(actualLocalCacheRoot, this.EnlistmentRootPathParameter);

                    this.RecordVersionInformation();

                    this.ShowStatusWhileRunning(
                        () =>
                        this.RunAndRecordGVFSVerb <StatusVerb>(archiveFolderPath, "gvfs_status.txt") != ReturnCode.Success ||
                        this.RunAndRecordGVFSVerb <UnmountVerb>(archiveFolderPath, "gvfs_unmount.txt", verb => verb.SkipLock = true) == ReturnCode.Success,
                        "Unmounting",
                        suppressGvfsLogMessage: true);

                    this.ShowStatusWhileRunning(
                        () =>
                    {
                        // .gvfs
                        this.CopyAllFiles(enlistment.EnlistmentRoot, archiveFolderPath, GVFSPlatform.Instance.Constants.DotGVFSRoot, copySubFolders: false);

                        // driver
                        if (this.FlushKernelDriverLogs())
                        {
                            string kernelLogsFolderPath = GVFSPlatform.Instance.KernelDriver.LogsFolderPath;

                            // This copy sometimes fails because the OS has an exclusive lock on the etl files. The error is not actionable
                            // for the user so we don't write the error message to stdout, just to our own log file.
                            this.CopyAllFiles(Path.GetDirectoryName(kernelLogsFolderPath), archiveFolderPath, Path.GetFileName(kernelLogsFolderPath), copySubFolders: false, hideErrorsFromStdout: true);
                        }

                        // .git
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Root, copySubFolders: false);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Hooks.Root, copySubFolders: false);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Info.Root, copySubFolders: false);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Logs.Root, copySubFolders: true);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Refs.Root, copySubFolders: true);
                        this.CopyAllFiles(enlistment.WorkingDirectoryRoot, archiveFolderPath, GVFSConstants.DotGit.Objects.Info.Root, copySubFolders: false);
                        this.LogDirectoryEnumeration(enlistment.WorkingDirectoryRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGit.Objects.Root), GVFSConstants.DotGit.Objects.Pack.Root, "packs-local.txt");
                        this.LogLooseObjectCount(enlistment.WorkingDirectoryRoot, Path.Combine(archiveFolderPath, GVFSConstants.DotGit.Objects.Root), GVFSConstants.DotGit.Objects.Root, "objects-local.txt");

                        // databases
                        this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSPlatform.Instance.Constants.DotGVFSRoot), GVFSConstants.DotGVFS.Databases.Name, copySubFolders: false);

                        // local cache
                        this.CopyLocalCacheData(archiveFolderPath, localCacheRoot, gitObjectsRoot);

                        // corrupt objects
                        this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSPlatform.Instance.Constants.DotGVFSRoot), GVFSConstants.DotGVFS.CorruptObjectsName, copySubFolders: false);

                        // service
                        this.CopyAllFiles(
                            GVFSPlatform.Instance.GetDataRootForGVFS(),
                            archiveFolderPath,
                            this.ServiceName,
                            copySubFolders: true);

                        if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSUpgrade)
                        {
                            // upgrader
                            this.CopyAllFiles(
                                ProductUpgraderInfo.GetUpgradesDirectoryPath(),
                                archiveFolderPath,
                                DeprecatedUpgradeLogsDirectory,
                                copySubFolders: true,
                                targetFolderName: Path.Combine(ProductUpgraderInfo.UpgradeDirectoryName, DeprecatedUpgradeLogsDirectory));

                            this.CopyAllFiles(
                                ProductUpgraderInfo.GetUpgradesDirectoryPath(),
                                archiveFolderPath,
                                ProductUpgraderInfo.LogDirectory,
                                copySubFolders: true,
                                targetFolderName: Path.Combine(ProductUpgraderInfo.UpgradeDirectoryName, ProductUpgraderInfo.LogDirectory));

                            this.LogDirectoryEnumeration(
                                ProductUpgraderInfo.GetUpgradesDirectoryPath(),
                                Path.Combine(archiveFolderPath, ProductUpgraderInfo.UpgradeDirectoryName),
                                ProductUpgraderInfo.DownloadDirectory,
                                "downloaded-assets.txt");
                        }

                        if (GVFSPlatform.Instance.UnderConstruction.SupportsGVFSConfig)
                        {
                            this.CopyFile(GVFSPlatform.Instance.GetDataRootForGVFS(), archiveFolderPath, LocalGVFSConfig.FileName);
                        }

                        return(true);
                    },
                        "Copying logs");

                    this.ShowStatusWhileRunning(
                        () => this.RunAndRecordGVFSVerb <MountVerb>(archiveFolderPath, "gvfs_mount.txt") == ReturnCode.Success,
                        "Mounting",
                        suppressGvfsLogMessage: true);

                    this.CopyAllFiles(enlistment.DotGVFSRoot, Path.Combine(archiveFolderPath, GVFSPlatform.Instance.Constants.DotGVFSRoot), "logs", copySubFolders: false);
                }

            string zipFilePath = archiveFolderPath + ".zip";

            this.ShowStatusWhileRunning(
                () =>
            {
                ZipFile.CreateFromDirectory(archiveFolderPath, zipFilePath);
                this.fileSystem.DeleteDirectory(archiveFolderPath);

                return(true);
            },
                "Creating zip file",
                suppressGvfsLogMessage: true);

            this.Output.WriteLine();
            this.Output.WriteLine("Diagnostics complete. All of the gathered info, as well as all of the output above, is captured in");
            this.Output.WriteLine(zipFilePath);
        }
コード例 #28
0
        public override bool TryRunInstaller(InstallActionWrapper installActionWrapper, out string error)
        {
            string localError = null;
            int    installerExitCode;
            bool   installSuccessful = true;

            using (ITracer activity = this.tracer.StartActivity(nameof(this.TryRunInstaller), EventLevel.Informational))
            {
                InstallActionInfo currentInstallAction = null;
                try
                {
                    string platformKey = InstallManifest.WindowsPlatformKey;

                    if (!this.TryRecursivelyDeleteInstallerDirectory(out error))
                    {
                        return(false);
                    }

                    if (!this.noVerify)
                    {
                        if (!this.nuGetFeed.VerifyPackage(this.DownloadedPackagePath))
                        {
                            error = "Package signature validation failed. Check the upgrade logs for more details.";
                            activity.RelatedError(error);
                            this.fileSystem.DeleteFile(this.DownloadedPackagePath);
                            return(false);
                        }
                    }

                    this.UnzipPackage();
                    this.installManifest = InstallManifest.FromJsonFile(Path.Combine(this.ExtractedInstallerPath, ContentDirectoryName, InstallManifestFileName));
                    if (!this.installManifest.PlatformInstallManifests.TryGetValue(platformKey, out InstallManifestPlatform platformInstallManifest) ||
                        platformInstallManifest == null)
                    {
                        activity.RelatedError($"Extracted InstallManifest from JSON, but there was no entry for {platformKey}.");
                        error = $"No entry in the manifest for the current platform ({platformKey}). Please verify the upgrade package.";
                        return(false);
                    }

                    activity.RelatedInfo($"Extracted InstallManifest from JSON. InstallActions: {platformInstallManifest.InstallActions.Count}");

                    foreach (InstallActionInfo entry in platformInstallManifest.InstallActions)
                    {
                        currentInstallAction = entry;
                        string installerPath = Path.Combine(this.ExtractedInstallerPath, ContentDirectoryName, entry.InstallerRelativePath);

                        string args = entry.Args ?? string.Empty;

                        // Replace tokens on args
                        string processedArgs = NuGetUpgrader.ReplaceArgTokens(args, this.UpgradeInstanceId, ProductUpgraderInfo.GetLogDirectoryPath());

                        activity.RelatedInfo(
                            "Running install action: Name: {0}, Version: {1}, InstallerPath: {2} RawArgs: {3}, ProcessedArgs: {4}",
                            entry.Name,
                            entry.Version,
                            installerPath,
                            args,
                            processedArgs);

                        string progressMessage = string.IsNullOrWhiteSpace(entry.Version) ?
                                                 $"Running {entry.Name}" :
                                                 $"Running {entry.Name} (version {entry.Version})";

                        installActionWrapper(
                            () =>
                        {
                            if (!this.dryRun)
                            {
                                this.RunInstaller(installerPath, processedArgs, out installerExitCode, out localError);
                            }
                            else
                            {
                                // We add a sleep here to ensure
                                // the message for this install
                                // action is written to the
                                // console.  Even though the
                                // message is written with a delay
                                // of 0, the messages are not
                                // always written out.  If / when
                                // we can ensure that the message
                                // is written out to console, then
                                // we can remove this sleep.
                                Thread.Sleep(1500);
                                installerExitCode = 0;
                            }

                            installSuccessful = installerExitCode == 0;

                            return(installSuccessful);
                        },
                            progressMessage);

                        if (!installSuccessful)
                        {
                            break;
                        }
                    }
                }
                catch (Exception ex)
                {
                    localError        = ex.Message;
                    installSuccessful = false;
                }

                if (!installSuccessful)
                {
                    string installActionName = string.IsNullOrEmpty(currentInstallAction?.Name) ?
                                               "installer" :
                                               currentInstallAction.Name;

                    error = string.IsNullOrEmpty(localError) ?
                            $"The {installActionName} failed, but no error message was provided by the failing command." :
                            $"The {installActionName} failed with the following error: {localError}";

                    activity.RelatedError($"Could not complete all install actions. The following error was encountered: {error}");
                    return(false);
                }
                else
                {
                    activity.RelatedInfo($"Install actions completed successfully.");
                    error = null;
                    return(true);
                }
            }
        }
コード例 #29
0
ファイル: UpgradeVerb.cs プロジェクト: py361/VFSForGit
        private bool TryRunProductUpgrade()
        {
            string  errorOutputFormat   = Environment.NewLine + "ERROR: {0}";
            string  message             = null;
            string  cannotInstallReason = null;
            Version newestVersion       = null;

            bool isInstallable = this.TryCheckUpgradeInstallable(out cannotInstallReason);

            if (this.Confirmed && !isInstallable)
            {
                this.ReportInfoToConsole($"Cannot upgrade GVFS on this machine.");
                this.Output.WriteLine(errorOutputFormat, cannotInstallReason);
                this.tracer.RelatedError($"{nameof(this.TryRunProductUpgrade)}: Upgrade is not installable. {cannotInstallReason}");
                return(false);
            }

            if (!this.upgrader.UpgradeAllowed(out message))
            {
                ProductUpgraderInfo.DeleteAllInstallerDownloads();
                this.ReportInfoToConsole(message);
                return(true);
            }

            if (!this.TryRunUpgradeChecks(out newestVersion, out message))
            {
                this.Output.WriteLine(errorOutputFormat, message);
                this.tracer.RelatedError($"{nameof(this.TryRunProductUpgrade)}: Upgrade checks failed. {message}");
                return(false);
            }

            if (newestVersion == null)
            {
                // Make sure there a no asset installers remaining in the Downloads directory. This can happen if user
                // upgraded by manually downloading and running asset installers.
                ProductUpgraderInfo.DeleteAllInstallerDownloads();
                this.ReportInfoToConsole(message);
                return(true);
            }

            if (this.Confirmed)
            {
                this.ReportInfoToConsole(message);

                if (!isInstallable)
                {
                    this.tracer.RelatedError($"{nameof(this.TryRunProductUpgrade)}: {message}");
                    this.Output.WriteLine(errorOutputFormat, message);
                    return(false);
                }

                if (!this.TryRunInstaller(out message))
                {
                    this.tracer.RelatedError($"{nameof(this.TryRunProductUpgrade)}: Could not launch upgrade tool. {message}");
                    this.Output.WriteLine(errorOutputFormat, "Could not launch upgrade tool. " + message);
                    return(false);
                }
            }
            else
            {
                string advisoryMessage = string.Join(
                    Environment.NewLine,
                    GVFSConstants.UpgradeVerbMessages.UnmountRepoWarning,
                    GVFSConstants.UpgradeVerbMessages.UpgradeInstallAdvice);
                this.ReportInfoToConsole(message + Environment.NewLine + Environment.NewLine + advisoryMessage + Environment.NewLine);
            }

            return(true);
        }
コード例 #30
0
 public void TearDown()
 {
     this.mockFileSystem      = null;
     this.productUpgraderInfo = null;
     this.tracer = null;
 }