public static void SetVersion(string rootPath, string projectName, VersionCode version) { Directory.CreateDirectory(rootPath); File.WriteAllText(GetPathWithTrailingSeparatorChar(rootPath) + projectName + PatchParameters.VERSION_HOLDER_FILENAME_POSTFIX, version); }
public void UpdateVersion(VersionCode version) { PatchUtils.SetVersion(SelfPatching ? DecompressedFilesPath : RootPath, VersionInfo.Name, version); }
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 bool FetchVersionInfo() { string versionInfoXML = comms.DownloadManager.DownloadTextFromURL(versionInfoURL); if (string.IsNullOrEmpty(versionInfoXML)) { FailReason = PatchFailReason.DownloadError; FailDetails = Localization.Get(StringId.E_VersionInfoCouldNotBeDownloaded); return(false); } if (VersionInfoVerifier != null && !VersionInfoVerifier(ref versionInfoXML)) { FailReason = PatchFailReason.CantVerifyVersionInfo; FailDetails = Localization.Get(StringId.E_VersionInfoCouldNotBeVerified); return(false); } try { comms.VersionInfo = PatchUtils.DeserializeXMLToVersionInfo(versionInfoXML); } catch (Exception e) { comms.LogToFile(e); FailReason = PatchFailReason.XmlDeserializeError; FailDetails = Localization.Get(StringId.E_VersionInfoInvalid); return(false); } if (comms.Cancel) { return(false); } if (!comms.VersionInfo.Version.IsValid) { FailReason = PatchFailReason.InvalidVersionCode; FailDetails = Localization.Get(StringId.E_VersionInfoInvalid); return(false); } incrementalPatches.Clear(); incrementalPatchesInfo.Clear(); filesInVersion.Clear(); comms.ListenerCallVersionInfoFetched(comms.VersionInfo); List <VersionItem> versionInfoFiles = comms.VersionInfo.Files; for (int i = 0; i < versionInfoFiles.Count; i++) { filesInVersion.Add(versionInfoFiles[i].Path); } currentVersion = PatchUtils.GetVersion(comms.RootPath, comms.VersionInfo.Name); comms.ListenerCallVersionFetched(currentVersion, comms.VersionInfo.Version); return(true); }
/// <exception cref = "DirectoryNotFoundException">Root path does not exist</exception> /// <exception cref = "UnauthorizedAccessException">A path needs admin priviledges to write</exception> /// <exception cref = "IOException">Output path is not empty</exception> /// <exception cref = "ArgumentException">An argument is empty</exception> /// <exception cref = "FormatException">Version is invalid</exception> public PatchCreator(string rootPath, string outputPath, string projectName, VersionCode version) { rootPath = rootPath.Trim(); outputPath = outputPath.Trim(); projectName = projectName.Trim(); if (string.IsNullOrEmpty(rootPath)) { throw new ArgumentException(Localization.Get(StringId.E_XCanNotBeEmpty, "'rootPath'")); } if (string.IsNullOrEmpty(outputPath)) { throw new ArgumentException(Localization.Get(StringId.E_XCanNotBeEmpty, "'outputPath'")); } if (string.IsNullOrEmpty(projectName)) { throw new ArgumentException(Localization.Get(StringId.E_XCanNotBeEmpty, "'projectName'")); } if (!version.IsValid) { throw new FormatException(Localization.Get(StringId.E_VersionCodeXIsInvalid, version)); } if (!Directory.Exists(rootPath)) { throw new DirectoryNotFoundException(Localization.Get(StringId.E_XDoesNotExist, rootPath)); } if (!PatchUtils.CheckWriteAccessToFolder(rootPath)) { throw new UnauthorizedAccessException(Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, rootPath)); } if (!PatchUtils.CheckWriteAccessToFolder(outputPath)) { throw new UnauthorizedAccessException(Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, outputPath)); } if (Directory.Exists(outputPath)) { if (Directory.GetFileSystemEntries(outputPath).Length > 0) { throw new IOException(Localization.Get(StringId.E_DirectoryXIsNotEmpty, outputPath)); } } Localization.Get(StringId.Done); // Force the localization system to be initialized with the current culture/language previousPatchFilesRoot = null; previousVersionInfo = null; dontCreatePatchFilesForUnchangedFiles = false; generateRepairPatch = true; generateInstallerPatch = true; previousVersionRoot = null; diffQuality = 0; this.previousVersion = null; this.version = version; this.rootPath = PatchUtils.GetPathWithTrailingSeparatorChar(rootPath); this.outputPath = PatchUtils.GetPathWithTrailingSeparatorChar(outputPath); this.projectName = projectName; repairPatchOutputPath = this.outputPath + PatchParameters.REPAIR_PATCH_DIRECTORY + Path.DirectorySeparatorChar; installerPatchOutputPath = this.outputPath + PatchParameters.INSTALLER_PATCH_DIRECTORY + Path.DirectorySeparatorChar; incrementalPatchOutputPath = this.outputPath + PatchParameters.INCREMENTAL_PATCH_DIRECTORY + Path.DirectorySeparatorChar; incrementalPatchTempPath = this.outputPath + "Temp" + Path.DirectorySeparatorChar; ignoredPaths = new HashSet <string>(); ignoredPathsRegex = new List <Regex>() { PatchUtils.WildcardToRegex("*" + PatchParameters.VERSION_HOLDER_FILENAME_POSTFIX), // Ignore any version holder files PatchUtils.WildcardToRegex("*" + PatchParameters.LOG_FILE_NAME) // Or log files }; compressionFormatRepairPatch = CompressionFormat.LZMA; compressionFormatInstallerPatch = CompressionFormat.LZMA; compressionFormatIncrementalPatch = CompressionFormat.LZMA; baseDownloadURL = ""; maintenanceCheckURL = ""; logs = new Queue <string>(); cancel = false; silentMode = false; IsRunning = false; Result = PatchResult.Failed; }
/// <exception cref = "DirectoryNotFoundException">Root path does not exist</exception> /// <exception cref = "UnauthorizedAccessException">A path needs admin priviledges to write</exception> /// <exception cref = "IOException">Output path is not empty</exception> /// <exception cref = "ArgumentException">An argument is empty</exception> /// <exception cref = "FormatException">Version is invalid</exception> public PatchCreator(string rootPath, string outputPath, string projectName, VersionCode version) { rootPath = rootPath.Trim(); outputPath = outputPath.Trim(); projectName = projectName.Trim(); if (string.IsNullOrEmpty(rootPath)) { throw new ArgumentException(Localization.Get(StringId.E_XCanNotBeEmpty, "'rootPath'")); } if (string.IsNullOrEmpty(outputPath)) { throw new ArgumentException(Localization.Get(StringId.E_XCanNotBeEmpty, "'outputPath'")); } if (string.IsNullOrEmpty(projectName)) { throw new ArgumentException(Localization.Get(StringId.E_XCanNotBeEmpty, "'projectName'")); } if (!version.IsValid) { throw new FormatException(Localization.Get(StringId.E_VersionCodeXIsInvalid, version)); } if (!Directory.Exists(rootPath)) { throw new DirectoryNotFoundException(Localization.Get(StringId.E_XDoesNotExist, rootPath)); } if (!PatchUtils.CheckWriteAccessToFolder(rootPath)) { throw new UnauthorizedAccessException(Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, rootPath)); } if (!PatchUtils.CheckWriteAccessToFolder(outputPath)) { throw new UnauthorizedAccessException(Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, outputPath)); } if (Directory.Exists(outputPath)) { if (Directory.GetFiles(outputPath).Length > 0 || Directory.GetDirectories(outputPath).Length > 0) { throw new IOException(Localization.Get(StringId.E_DirectoryXIsNotEmpty, outputPath)); } } previousVersionRoot = null; generateRepairPatch = false; this.previousVersion = null; this.version = version; this.rootPath = PatchUtils.GetPathWithTrailingSeparatorChar(rootPath); this.outputPath = PatchUtils.GetPathWithTrailingSeparatorChar(outputPath); this.projectName = projectName; repairPatchOutputPath = this.outputPath + PatchParameters.REPAIR_PATCH_DIRECTORY + Path.DirectorySeparatorChar; incrementalPatchOutputPath = this.outputPath + PatchParameters.INCREMENTAL_PATCH_DIRECTORY + Path.DirectorySeparatorChar; incrementalPatchTempPath = this.outputPath + "Temp" + Path.DirectorySeparatorChar; ignoredPaths = new HashSet <string>(); ignoredPathsRegex = new List <Regex>() { PatchUtils.WildcardToRegex("*" + PatchParameters.VERSION_HOLDER_FILENAME_POSTFIX) }; // Ignore any version holder files logs = new Queue <string>(); cancel = false; silentMode = false; IsRunning = false; Result = PatchResult.Failed; }