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;
}
