private bool RenameItems(List <PatchRenamedItem> items) { string rootPath = comms.SelfPatching ? comms.DecompressedFilesPath : comms.RootPath; for (int i = 0; i < items.Count; i++) { if (comms.Cancel) { return(false); } string fromAbsolutePath = rootPath + items[i].BeforePath; string toAbsolutePath = rootPath + items[i].AfterPath; if (File.Exists(fromAbsolutePath)) { PatchUtils.MoveFile(fromAbsolutePath, toAbsolutePath); } else if (Directory.Exists(fromAbsolutePath)) { PatchUtils.MoveDirectory(fromAbsolutePath, toAbsolutePath); } } return(true); }
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); }
private PatchResult GeneratePatchInternal() { if (!Directory.Exists(versionsPath)) { Log(Localization.Get(StringId.E_XDoesNotExist, versionsPath)); return(PatchResult.Failed); } if (!File.Exists(projectInfoPath)) { Log(Localization.Get(StringId.E_XDoesNotExist, projectInfoPath)); return(PatchResult.Failed); } string[] versions = Directory.GetDirectories(versionsPath); if (versions.Length == 0) { Log(Localization.Get(StringId.E_DirectoryXIsEmpty, versionsPath)); return(PatchResult.Failed); } string validationResult = ValidateProject(); if (!string.IsNullOrEmpty(validationResult)) { Log(validationResult); return(PatchResult.Failed); } Stopwatch timer = Stopwatch.StartNew(); // Here's how it works: // Move previous incremental patch files to Temp\IncrementalFormer // Generate repair patch and installer patch files on Temp\Output // Foreach incremental patch to generate: // Generate incremental patch files on Temp\Incremental // Move the incremental patch files from there to Temp\IncrementalFormer // Replace the contents of outputPath with Temp\Output: // Delete outputPath directory // Move Temp\Output to outputPath // Move Temp\IncrementalFormer to outputPath // Delete Temp string tempRoot = projectRoot + "Temp" + Path.DirectorySeparatorChar; string tempOutput = tempRoot + "Output" + Path.DirectorySeparatorChar; string tempIncrementalOutput = tempRoot + "Incremental" + Path.DirectorySeparatorChar; string tempPrevIncrementalPatches = tempRoot + "IncrementalFormer" + Path.DirectorySeparatorChar; PatchUtils.DeleteDirectory(tempOutput); PatchUtils.DeleteDirectory(tempIncrementalOutput); // Preserve the previous incremental patches string versionInfoPath = outputPath + PatchParameters.VERSION_INFO_FILENAME; string incrementalPatchesPath = outputPath + PatchParameters.INCREMENTAL_PATCH_DIRECTORY; if (Directory.Exists(incrementalPatchesPath)) { PatchUtils.MoveDirectory(incrementalPatchesPath, tempPrevIncrementalPatches); } List <IncrementalPatch> incrementalPatches = new List <IncrementalPatch>(); if (File.Exists(versionInfoPath)) { VersionInfo oldVersionInfo = PatchUtils.GetVersionInfoFromPath(versionInfoPath); if (oldVersionInfo != null) { incrementalPatches.AddRange(oldVersionInfo.IncrementalPatches); } } Array.Sort(versions, new VersionComparer()); string latestVersion = versions[versions.Length - 1]; ProjectInfo projectInfo = PatchUtils.GetProjectInfoFromPath(projectInfoPath); if (projectInfo.IsSelfPatchingApp && Directory.Exists(selfPatcherPath) && Directory.GetFileSystemEntries(selfPatcherPath).Length > 0) { PatchUtils.CopyDirectory(selfPatcherPath, Path.Combine(latestVersion, PatchParameters.SELF_PATCHER_DIRECTORY)); } patchCreator = new PatchCreator(latestVersion, tempOutput, projectInfo.Name, Path.GetFileName(latestVersion)).SetListener(this). SetCompressionFormat(projectInfo.CompressionFormatRepairPatch, projectInfo.CompressionFormatInstallerPatch, projectInfo.CompressionFormatIncrementalPatch). CreateRepairPatch(projectInfo.CreateRepairPatch).CreateInstallerPatch(projectInfo.CreateInstallerPatch).CreateIncrementalPatch(false). AddIgnoredPaths(projectInfo.IgnoredPaths).SilentMode(silentMode).SetBaseDownloadURL(projectInfo.BaseDownloadURL).SetMaintenanceCheckURL(projectInfo.MaintenanceCheckURL); // Generate repair patch and installer patch files if (cancel || !ExecuteCurrentPatch()) { return(PatchResult.Failed); } if (projectInfo.CreateIncrementalPatch && versions.Length > 1) { string incrementalPatchesGenerated = tempIncrementalOutput + PatchParameters.INCREMENTAL_PATCH_DIRECTORY; string versionInfoGenerated = tempIncrementalOutput + PatchParameters.VERSION_INFO_FILENAME; patchCreator = new PatchCreator(latestVersion, tempIncrementalOutput, projectInfo.Name, Path.GetFileName(latestVersion)).SetListener(this). SetCompressionFormat(projectInfo.CompressionFormatRepairPatch, projectInfo.CompressionFormatInstallerPatch, projectInfo.CompressionFormatIncrementalPatch). AddIgnoredPaths(projectInfo.IgnoredPaths).SilentMode(silentMode).CreateRepairPatch(false).CreateInstallerPatch(false); for (int i = versions.Length - 2; i >= 0; i--) { Log(Localization.Get(StringId.CreatingIncrementalPatchX, Path.GetFileName(versions[i]) + "->" + Path.GetFileName(latestVersion))); // Generate incremental patch files patchCreator.CreateIncrementalPatch(true, versions[i], projectInfo.BinaryDiffQuality); if (cancel || !ExecuteCurrentPatch()) { return(PatchResult.Failed); } List <IncrementalPatch> newIncrementalPatches = PatchUtils.GetVersionInfoFromPath(versionInfoGenerated).IncrementalPatches; for (int j = incrementalPatches.Count - 1; j >= 0; j--) { // Don't allow duplicate IncrementalPatch entries for (int k = newIncrementalPatches.Count - 1; k >= 0; k--) { if (incrementalPatches[j].FromVersion == newIncrementalPatches[k].FromVersion && incrementalPatches[j].ToVersion == newIncrementalPatches[k].ToVersion) { incrementalPatches.RemoveAt(j); break; } } } incrementalPatches.AddRange(newIncrementalPatches); // Move incremental patch files to Temp PatchUtils.MoveDirectory(incrementalPatchesGenerated, tempPrevIncrementalPatches); PatchUtils.DeleteDirectory(tempIncrementalOutput); if (!projectInfo.CreateAllIncrementalPatches) { break; } } } PatchUtils.DeleteDirectory(outputPath); PatchUtils.MoveDirectory(tempOutput, outputPath); if (Directory.Exists(tempPrevIncrementalPatches)) { PatchUtils.MoveDirectory(tempPrevIncrementalPatches, incrementalPatchesPath); } VersionInfo versionInfo = PatchUtils.GetVersionInfoFromPath(versionInfoPath); incrementalPatches.Sort(PatchUtils.IncrementalPatchComparison); versionInfo.IncrementalPatches = incrementalPatches; PatchUtils.SerializeVersionInfoToXML(versionInfo, versionInfoPath); PatchUtils.DeleteDirectory(tempRoot); Log(Localization.Get(StringId.AllPatchesCreatedInXSeconds, timer.ElapsedSeconds())); return(PatchResult.Success); }