예제 #1
0
        public string GetDownloadURLFor(InstallerPatch patch)
        {
            if (!string.IsNullOrEmpty(patch.DownloadURL))
            {
                return(patch.DownloadURL);
            }

            if (!string.IsNullOrEmpty(BaseDownloadURL))
            {
                return(BaseDownloadURL + PatchParameters.INSTALLER_PATCH_DIRECTORY + '/' + PatchParameters.INSTALLER_PATCH_FILENAME);
            }

            return(null);
        }
예제 #2
0
        public VersionInfo()
        {
            Name                = "NewProject";
            Version             = new VersionCode(1, 0);
            BaseDownloadURL     = "";
            MaintenanceCheckURL = "";

            IncrementalPatches = new List <IncrementalPatch>();
            InstallerPatch     = new InstallerPatch();

            IgnoredPaths      = new List <string>();
            CompressionFormat = CompressionFormat.LZMA;
            Files             = new List <VersionItem>();
        }
예제 #3
0
        private bool PatchUsingInstallerPatch()
        {
            if (comms.Cancel)
            {
                return(false);
            }

            comms.LogToFile(Localization.Get(StringId.ApplyingInstallerPatch));

            if (comms.VerifyFiles)
            {
                PatchStage = PatchStage.VerifyingFilesOnServer;

                InstallerPatch installerPatch = comms.VersionInfo.InstallerPatch;
                long           fileSize;
                if (!comms.DownloadManager.FileExistsAtUrl(comms.VersionInfo.GetDownloadURLFor(installerPatch), out fileSize))
                {
                    FailReason  = PatchFailReason.FileDoesNotExistOnServer;
                    FailDetails = Localization.Get(StringId.E_FileXDoesNotExistOnServer, PatchParameters.INSTALLER_PATCH_FILENAME);

                    return(false);
                }
                else if (fileSize > 0L && fileSize != installerPatch.PatchSize)
                {
                    FailReason  = PatchFailReason.FileIsNotValidOnServer;
                    FailDetails = Localization.Get(StringId.E_FileXIsNotValidOnServer, PatchParameters.INSTALLER_PATCH_FILENAME);

                    return(false);
                }
            }

            if (new InstallerPatchApplier(comms).Run() == PatchResult.Failed)
            {
                return(false);
            }

            return(true);
        }
예제 #4
0
        private PatchResult Patch()
        {
            PatchStage = PatchStage.CheckingUpdates;

            Stopwatch timer = Stopwatch.StartNew();

            comms.Log(Localization.Get(StringId.RetrievingVersionInfo));

            if (!FetchVersionInfo())
            {
                return(PatchResult.Failed);
            }

            if (comms.IsUnderMaintenance())
            {
                return(PatchResult.Failed);
            }

            if (!currentVersion.IsValid)
            {
                currentVersion = new VersionCode(0);
            }

            VersionCode rootVersion = currentVersion;

            if (comms.SelfPatching)
            {
                VersionCode patchedVersion = PatchUtils.GetVersion(comms.DecompressedFilesPath, comms.VersionInfo.Name);
                if (patchedVersion > currentVersion)
                {
                    currentVersion = patchedVersion;
                }
            }

            PatchStage = PatchStage.CheckingFileIntegrity;

            if (CheckLocalFilesUpToDate(true, false))
            {
                return(PatchResult.AlreadyUpToDate);
            }

            if (!PatchUtils.CheckWriteAccessToFolder(comms.RootPath))
            {
                FailReason  = PatchFailReason.RequiresAdminPriviledges;
                FailDetails = Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, comms.RootPath);

                return(PatchResult.Failed);
            }

            if (!PatchUtils.CheckWriteAccessToFolder(comms.CachePath))
            {
                FailReason  = PatchFailReason.RequiresAdminPriviledges;
                FailDetails = Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, comms.CachePath);

                return(PatchResult.Failed);
            }

            if (checkForMultipleRunningInstances)
            {
                string currentExecutablePath = PatchUtils.GetCurrentExecutablePath();
                if (PatchUtils.GetNumberOfRunningProcesses(currentExecutablePath) > 1)
                {
                    FailReason  = PatchFailReason.MultipleRunningInstances;
                    FailDetails = Localization.Get(StringId.E_AnotherInstanceOfXIsRunning, Path.GetFileName(currentExecutablePath));

                    return(PatchResult.Failed);
                }
            }

            if (comms.Cancel)
            {
                return(PatchResult.Failed);
            }

            // Add a date holder file to the cache to save the last access time reliably
            DateTime dateTimeNow = DateTime.UtcNow;

            File.WriteAllText(comms.CachePath + PatchParameters.CACHE_DATE_HOLDER_FILENAME, dateTimeNow.ToString("O"));

            // Check if there are any leftover files from other SimplePatchTool integrated apps in cache
            DirectoryInfo[] patcherCaches = new DirectoryInfo(comms.CachePath).Parent.GetDirectories();
            for (int i = 0; i < patcherCaches.Length; i++)
            {
                DirectoryInfo cacheDir = patcherCaches[i];
                if (cacheDir.Name.Equals(comms.VersionInfo.Name, StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                FileInfo dateHolder = new FileInfo(PatchUtils.GetPathWithTrailingSeparatorChar(cacheDir.FullName) + PatchParameters.CACHE_DATE_HOLDER_FILENAME);
                if (dateHolder.Exists && dateHolder.Length > 0L)
                {
                    DateTime lastAccessTime;
                    if (DateTime.TryParseExact(File.ReadAllText(dateHolder.FullName), "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out lastAccessTime))
                    {
                        if ((dateTimeNow - lastAccessTime).TotalDays <= PatchParameters.CACHE_DATE_EXPIRE_DAYS)
                        {
                            continue;
                        }
                    }
                }

                // This cache directory doesn't have a date holder file or is older than CACHE_DATE_EXPIRE_DAYS, delete it
                cacheDir.Delete(true);
            }

            bool canRepairPatch      = this.canRepairPatch;
            bool canIncrementalPatch = this.canIncrementalPatch;
            bool canInstallerPatch   = this.canInstallerPatch;

            List <PatchMethodHolder> preferredPatchMethods = new List <PatchMethodHolder>(3);
            List <VersionItem>       versionInfoFiles      = comms.VersionInfo.Files;

            if (canRepairPatch)
            {
                for (int i = 0; i < versionInfoFiles.Count; i++)
                {
                    VersionItem item = versionInfoFiles[i];
                    if (item.CompressedFileSize == 0L && string.IsNullOrEmpty(item.CompressedMd5Hash))
                    {
                        canRepairPatch = false;
                        break;
                    }
                }

                if (canRepairPatch)
                {
                    long repairPatchSize = 0L;
                    for (int i = 0; i < versionInfoFiles.Count; i++)
                    {
                        VersionItem item      = versionInfoFiles[i];
                        FileInfo    localFile = new FileInfo(comms.RootPath + item.Path);
                        if (localFile.Exists && localFile.MatchesSignature(item.FileSize, item.Md5Hash))
                        {
                            continue;
                        }

                        FileInfo downloadedFile = new FileInfo(comms.DownloadsPath + item.Path);
                        if (downloadedFile.Exists && downloadedFile.MatchesSignature(item.CompressedFileSize, item.CompressedMd5Hash))
                        {
                            continue;
                        }

                        if (comms.SelfPatching)
                        {
                            FileInfo decompressedFile = new FileInfo(comms.DecompressedFilesPath + item.Path);
                            if (decompressedFile.Exists && decompressedFile.MatchesSignature(item.FileSize, item.Md5Hash))
                            {
                                continue;
                            }
                        }

                        repairPatchSize += item.CompressedFileSize;
                    }

                    preferredPatchMethods.Add(new PatchMethodHolder(PatchMethod.RepairPatch, repairPatchSize));
                }
            }

            if (canIncrementalPatch)
            {
                // Find incremental patches to apply
                VersionCode             thisVersion        = rootVersion;
                List <IncrementalPatch> versionInfoPatches = comms.VersionInfo.IncrementalPatches;
                for (int i = 0; i < versionInfoPatches.Count; i++)
                {
                    if (thisVersion == comms.VersionInfo.Version)
                    {
                        break;
                    }

                    IncrementalPatch patch = versionInfoPatches[i];
                    if (thisVersion == patch.FromVersion)
                    {
                        thisVersion = patch.ToVersion;
                        incrementalPatches.Add(patch);
                    }
                }

                if (thisVersion != comms.VersionInfo.Version)
                {
                    incrementalPatches.Clear();
                }

                if (incrementalPatches.Count == 0)
                {
                    canIncrementalPatch = false;
                }
                else
                {
                    long incrementalPatchSize = 0L;
                    for (int i = 0; i < incrementalPatches.Count; i++)
                    {
                        IncrementalPatch incrementalPatch = incrementalPatches[i];
                        if (currentVersion > incrementalPatch.FromVersion)
                        {
                            continue;
                        }

                        FileInfo patchFile = new FileInfo(comms.GetDownloadPathForPatch(incrementalPatch.PatchVersion()));
                        if (patchFile.Exists && patchFile.MatchesSignature(incrementalPatch.PatchSize, incrementalPatch.PatchMd5Hash))
                        {
                            continue;
                        }

                        incrementalPatchSize += incrementalPatch.PatchSize;
                    }

                    preferredPatchMethods.Add(new PatchMethodHolder(PatchMethod.IncrementalPatch, incrementalPatchSize));
                }
            }

            if (canInstallerPatch)
            {
                InstallerPatch installerPatch = comms.VersionInfo.InstallerPatch;
                if (installerPatch.PatchSize == 0L && string.IsNullOrEmpty(installerPatch.PatchMd5Hash))
                {
                    canInstallerPatch = false;
                }
                else
                {
                    preferredPatchMethods.Add(new PatchMethodHolder(PatchMethod.InstallerPatch, installerPatch.PatchSize));
                }
            }

            preferredPatchMethods.Sort((p1, p2) => p1.size.CompareTo(p2.size));

            if (preferredPatchMethods.Count == 0)
            {
                FailReason  = PatchFailReason.NoSuitablePatchMethodFound;
                FailDetails = Localization.Get(StringId.E_NoSuitablePatchMethodFound);

                return(PatchResult.Failed);
            }

            // Check if there is enough free disk space
            long requiredFreeSpaceInCache = preferredPatchMethods[0].size, requiredFreeSpaceInRoot = 0L;

            for (int i = 0; i < versionInfoFiles.Count; i++)
            {
                VersionItem item      = versionInfoFiles[i];
                FileInfo    localFile = new FileInfo(comms.RootPath + item.Path);
                if (!localFile.Exists)
                {
                    requiredFreeSpaceInCache += item.FileSize;
                    requiredFreeSpaceInRoot  += item.FileSize;
                }
                else if (!localFile.MatchesSignature(item.FileSize, item.Md5Hash))
                {
                    requiredFreeSpaceInCache += item.FileSize;

                    long deltaSize = item.FileSize - localFile.Length;
                    if (deltaSize > 0L)
                    {
                        requiredFreeSpaceInRoot += deltaSize;
                    }
                }
            }

            requiredFreeSpaceInCache += requiredFreeSpaceInCache / 3;    // Require additional 33% free space (might be needed by compressed files and/or incremental patches)
            requiredFreeSpaceInCache += 1024 * 1024 * 1024L;             // Require additional 1 GB of free space, just in case

            string rootDrive = new DirectoryInfo(comms.RootPath).Root.FullName;
            string cacheDrive = new DirectoryInfo(comms.CachePath).Root.FullName;

            if (rootDrive.Equals(cacheDrive, StringComparison.OrdinalIgnoreCase))
            {
                if (!CheckFreeSpace(rootDrive, requiredFreeSpaceInCache + requiredFreeSpaceInRoot))
                {
                    return(PatchResult.Failed);
                }
            }
            else
            {
                if (!CheckFreeSpace(rootDrive, requiredFreeSpaceInRoot))
                {
                    return(PatchResult.Failed);
                }

                if (!CheckFreeSpace(cacheDrive, requiredFreeSpaceInCache))
                {
                    return(PatchResult.Failed);
                }
            }

            for (int i = 0; i < preferredPatchMethods.Count; i++)
            {
                comms.LogToFile(Localization.Get(StringId.PatchMethodXSizeY, preferredPatchMethods[i].method, preferredPatchMethods[i].size.ToMegabytes() + "MB"));
            }

            // Start patching
            for (int i = 0; i < preferredPatchMethods.Count; i++)
            {
                PatchMethod patchMethod = preferredPatchMethods[i].method;

                bool success;
                if (patchMethod == PatchMethod.RepairPatch)
                {
                    PatchMethod = PatchMethod.RepairPatch;
                    comms.ListenerCallPatchMethodChanged(PatchMethod);

                    success = PatchUsingRepairPatch();
                }
                else if (patchMethod == PatchMethod.IncrementalPatch)
                {
                    PatchMethod = PatchMethod.IncrementalPatch;
                    comms.ListenerCallPatchMethodChanged(PatchMethod);

                    success = PatchUsingIncrementalPatches();
                }
                else
                {
                    PatchMethod = PatchMethod.InstallerPatch;
                    comms.ListenerCallPatchMethodChanged(PatchMethod);

                    success = PatchUsingInstallerPatch();
                }

                if (comms.Cancel)
                {
                    return(PatchResult.Failed);
                }

                if (success)
                {
                    break;
                }
                else
                {
                    comms.LogToFile(string.Concat(comms.FailReason, ": ", comms.FailDetails));

                    if (i == preferredPatchMethods.Count - 1)
                    {
                        return(PatchResult.Failed);
                    }
                }
            }

            PatchStage = PatchStage.CheckingFileIntegrity;

            if (!CheckLocalFilesUpToDate(false, comms.SelfPatching))
            {
                comms.Log(Localization.Get(StringId.SomeFilesAreStillNotUpToDate));

                if (canRepairPatch)
                {
                    if (!PatchUsingRepairPatch())
                    {
                        return(PatchResult.Failed);
                    }
                }
                else
                {
                    FailReason  = PatchFailReason.FilesAreNotUpToDateAfterPatch;
                    FailDetails = Localization.Get(StringId.E_FilesAreNotUpToDateAfterPatch);

                    return(PatchResult.Failed);
                }
            }

            comms.UpdateVersion(comms.VersionInfo.Version);

            PatchStage = PatchStage.DeletingObsoleteFiles;
            comms.Log(Localization.Get(StringId.CalculatingObsoleteFiles));

            List <string> obsoleteFiles = FindFilesToDelete(comms.RootPath);

            if (!comms.SelfPatching)
            {
                if (obsoleteFiles.Count > 0)
                {
                    comms.Log(Localization.Get(StringId.DeletingXObsoleteFiles, obsoleteFiles.Count));
                    for (int i = 0; i < obsoleteFiles.Count; i++)
                    {
                        comms.Log(Localization.Get(StringId.DeletingX, obsoleteFiles[i]));
                        File.Delete(comms.RootPath + obsoleteFiles[i]);
                    }
                }
                else
                {
                    comms.Log(Localization.Get(StringId.NoObsoleteFiles));
                }

                PatchUtils.DeleteDirectory(comms.CachePath);
            }
            else
            {
                // Delete obsolete self patching files
                List <string> obsoleteSelfPatchingFiles = FindFilesToDelete(comms.DecompressedFilesPath);
                if (obsoleteSelfPatchingFiles.Count > 0)
                {
                    comms.Log(Localization.Get(StringId.DeletingXObsoleteFiles, obsoleteSelfPatchingFiles.Count));
                    for (int i = 0; i < obsoleteSelfPatchingFiles.Count; i++)
                    {
                        comms.Log(Localization.Get(StringId.DeletingX, obsoleteSelfPatchingFiles[i]));
                        File.Delete(comms.DecompressedFilesPath + obsoleteSelfPatchingFiles[i]);
                    }
                }
                else
                {
                    comms.Log(Localization.Get(StringId.NoObsoleteFiles));
                }

                // Self patcher executable, if exists, can't self patch itself, so patch it manually here
                // This assumes that self patcher and any related files are located at SELF_PATCHER_DIRECTORY
                string selfPatcherFiles = comms.DecompressedFilesPath + PatchParameters.SELF_PATCHER_DIRECTORY;
                if (Directory.Exists(selfPatcherFiles))
                {
                    PatchUtils.MoveDirectory(selfPatcherFiles, comms.RootPath + PatchParameters.SELF_PATCHER_DIRECTORY);
                }

                string        separator = PatchParameters.SELF_PATCH_OP_SEPARATOR;
                StringBuilder sb        = new StringBuilder(500);

                // Append current version to the beginning of the file
                sb.Append(rootVersion);

                // 1. Rename files
                if (incrementalPatchesInfo.Count > 0)
                {
                    sb.Append(separator).Append(PatchParameters.SELF_PATCH_MOVE_OP);
                    for (int i = 0; i < incrementalPatchesInfo.Count; i++)
                    {
                        IncrementalPatchInfo incrementalPatch = incrementalPatchesInfo[i];
                        for (int j = 0; j < incrementalPatch.RenamedFiles.Count; j++)
                        {
                            PatchRenamedItem renamedItem = incrementalPatch.RenamedFiles[j];
                            sb.Append(separator).Append(comms.RootPath + renamedItem.BeforePath).Append(separator).Append(comms.RootPath + renamedItem.AfterPath);
                        }
                    }
                }

                // 2. Update files
                sb.Append(separator).Append(PatchParameters.SELF_PATCH_MOVE_OP);

                DirectoryInfo   updatedFilesDir       = new DirectoryInfo(comms.DecompressedFilesPath);
                DirectoryInfo[] updatedSubDirectories = updatedFilesDir.GetDirectories();
                for (int i = 0; i < updatedSubDirectories.Length; i++)
                {
                    sb.Append(separator).Append(comms.DecompressedFilesPath).Append(updatedSubDirectories[i].Name).Append(Path.DirectorySeparatorChar).Append(separator).Append(comms.RootPath).Append(updatedSubDirectories[i].Name).Append(Path.DirectorySeparatorChar);
                }

                string     versionHolderFilename = comms.VersionInfo.Name + PatchParameters.VERSION_HOLDER_FILENAME_POSTFIX;
                FileInfo[] updatedFiles          = updatedFilesDir.GetFiles();
                for (int i = 0; i < updatedFiles.Length; i++)
                {
                    // Don't update the version holder file until everything else is updated properly
                    if (updatedFiles[i].Name != versionHolderFilename)
                    {
                        sb.Append(separator).Append(comms.DecompressedFilesPath).Append(updatedFiles[i].Name).Append(separator).Append(comms.RootPath).Append(updatedFiles[i].Name);
                    }
                }

                // Update the version holder now
                sb.Append(separator).Append(comms.DecompressedFilesPath).Append(versionHolderFilename).Append(separator).Append(comms.RootPath).Append(versionHolderFilename);

                // 3. Delete obsolete files
                if (obsoleteFiles.Count > 0)
                {
                    string selfPatcherDirectory = PatchParameters.SELF_PATCHER_DIRECTORY + Path.DirectorySeparatorChar;
                    sb.Append(separator).Append(PatchParameters.SELF_PATCH_DELETE_OP);

                    comms.Log(Localization.Get(StringId.DeletingXObsoleteFiles, obsoleteFiles.Count));
                    for (int i = 0; i < obsoleteFiles.Count; i++)
                    {
                        // Delete the obsolete files inside SELF_PATCHER_DIRECTORY manually
                        string absolutePath = comms.RootPath + obsoleteFiles[i];
                        if (obsoleteFiles[i].StartsWith(selfPatcherDirectory, StringComparison.OrdinalIgnoreCase))
                        {
                            comms.Log(Localization.Get(StringId.DeletingX, obsoleteFiles[i]));

                            if (File.Exists(absolutePath))
                            {
                                File.Delete(absolutePath);
                            }
                            else if (Directory.Exists(absolutePath))
                            {
                                PatchUtils.DeleteDirectory(absolutePath);
                            }
                        }
                        else
                        {
                            // '-->' indicates that the file will be deleted by the self patcher executable
                            comms.LogToFile(Localization.Get(StringId.DeletingX, "--> " + obsoleteFiles[i]));
                            sb.Append(separator).Append(absolutePath);
                        }
                    }
                }
                else
                {
                    comms.Log(Localization.Get(StringId.NoObsoleteFiles));
                }

                sb.Append(separator).Append(comms.CachePath);

                File.Delete(comms.CachePath + PatchParameters.SELF_PATCH_COMPLETED_INSTRUCTIONS_FILENAME);
                File.WriteAllText(comms.CachePath + PatchParameters.SELF_PATCH_INSTRUCTIONS_FILENAME, sb.Append(separator).ToString());
            }

            comms.Log(Localization.Get(StringId.PatchCompletedInXSeconds, timer.ElapsedSeconds()));
            return(PatchResult.Success);
        }
        protected override PatchResult Execute()
        {
            if (comms.Cancel)
            {
                return(PatchResult.Failed);
            }

            if (comms.IsUnderMaintenance())
            {
                return(PatchResult.Failed);
            }

            string rootPath            = comms.SelfPatching ? comms.DecompressedFilesPath : comms.RootPath;
            string patchDecompressPath = comms.GetDecompressPathForPatch(PatchParameters.INSTALLER_PATCH_DIRECTORY);
            string patchDownloadPath   = comms.CachePath + PatchParameters.INSTALLER_PATCH_FILENAME;

            InstallerPatch patchInfo = comms.VersionInfo.InstallerPatch;

            Stopwatch timer = Stopwatch.StartNew();

            comms.Stage = PatchStage.CalculatingFilesToUpdate;

            comms.Log(Localization.Get(StringId.CalculatingNewOrChangedFiles));
            List <VersionItem> filesToUpdate = comms.FindFilesToUpdate();

            if (filesToUpdate.Count == 0)
            {
                return(PatchResult.AlreadyUpToDate);
            }

            if (comms.Cancel)
            {
                return(PatchResult.Failed);
            }

            InitializeProgress(filesToUpdate.Count, patchInfo.PatchSize);

            PatchUtils.DeleteDirectory(patchDecompressPath);
            Directory.CreateDirectory(patchDecompressPath);

            FileInfo patchFile = new FileInfo(patchDownloadPath);

            if (!patchFile.Exists || !patchFile.MatchesSignature(patchInfo.PatchSize, patchInfo.PatchMd5Hash))
            {
                comms.Stage = PatchStage.DownloadingFiles;

                Stopwatch downloadTimer = Stopwatch.StartNew();
                comms.Log(Localization.Get(StringId.DownloadingPatchX, PatchParameters.INSTALLER_PATCH_FILENAME));

                patchFile = comms.DownloadManager.DownloadFileFromURLToPath(comms.VersionInfo.GetDownloadURLFor(patchInfo), patchDownloadPath, patchInfo.PatchSize);
                if (patchFile == null)
                {
                    comms.FailReason  = PatchFailReason.DownloadError;
                    comms.FailDetails = Localization.Get(StringId.E_XCouldNotBeDownloaded, PatchParameters.INSTALLER_PATCH_FILENAME);

                    return(PatchResult.Failed);
                }
                else if (!patchFile.MatchesSignature(patchInfo.PatchSize, patchInfo.PatchMd5Hash))
                {
                    comms.FailReason  = PatchFailReason.CorruptDownloadError;
                    comms.FailDetails = Localization.Get(StringId.E_DownloadedFileXIsCorrupt, PatchParameters.INSTALLER_PATCH_FILENAME);

                    return(PatchResult.Failed);
                }
                else
                {
                    comms.Log(Localization.Get(StringId.XDownloadedInYSeconds, PatchParameters.INSTALLER_PATCH_FILENAME, downloadTimer.ElapsedSeconds()));
                }
            }
            else
            {
                ReportProgress(0, patchInfo.PatchSize);
            }

            if (comms.Cancel)
            {
                return(PatchResult.Failed);
            }

            comms.Stage = PatchStage.ExtractingFilesFromArchive;
            comms.Log(Localization.Get(StringId.DecompressingPatchX, PatchParameters.INSTALLER_PATCH_FILENAME));

            ZipUtils.DecompressFolder(patchFile.FullName, patchDecompressPath, patchInfo.CompressionFormat);

            comms.Stage = PatchStage.UpdatingFiles;
            comms.Log(Localization.Get(StringId.UpdatingXFiles, filesToUpdate.Count));

            for (int i = 0; i < filesToUpdate.Count; i++)
            {
                if (comms.Cancel)
                {
                    return(PatchResult.Failed);
                }

                string fileRelativePath   = filesToUpdate[i].Path;
                string targetAbsolutePath = rootPath + fileRelativePath;

                comms.Log(Localization.Get(StringId.UpdatingXthFile, i + 1, filesToUpdate.Count, fileRelativePath));

                Directory.CreateDirectory(Path.GetDirectoryName(targetAbsolutePath));
                PatchUtils.CopyFile(patchDecompressPath + fileRelativePath, targetAbsolutePath);

                ReportProgress(1, 0L);
            }

            PatchUtils.DeleteDirectory(patchDecompressPath);
            File.Delete(patchDownloadPath);

            comms.Log(Localization.Get(StringId.PatchAppliedInXSeconds, timer.ElapsedSeconds()));
            return(PatchResult.Success);
        }