internal static int IncrementalPatchComparison(IncrementalPatch patch1, IncrementalPatch patch2)
{
int comparison = patch1.FromVersion.CompareTo(patch2.FromVersion);
if (comparison != 0)
{
return(comparison);
}
// If FromVersion's are the same, the patch with higher ToVersion should be put in front of the other
return(patch2.ToVersion.CompareTo(patch1.ToVersion));
}
public string GetInfoURLFor(IncrementalPatch patch)
{
if (!string.IsNullOrEmpty(patch.InfoURL))
{
return(patch.InfoURL);
}
if (!string.IsNullOrEmpty(BaseDownloadURL))
{
return(BaseDownloadURL + PatchParameters.INCREMENTAL_PATCH_DIRECTORY + '/' + patch.PatchVersion() + PatchParameters.PATCH_INFO_EXTENSION);
}
return(null);
}
public static string PatchVersion(this IncrementalPatch incrementalPatch)
{
return(incrementalPatch.FromVersion.ToString().Replace('.', '_') + "__" + incrementalPatch.ToVersion.ToString().Replace('.', '_'));
}
public static string PatchVersionBrief(this IncrementalPatch incrementalPatch)
{
return(incrementalPatch.FromVersion + "_" + incrementalPatch.ToVersion);
}
public bool UpdateDownloadLinks(Dictionary <string, string> downloadLinks)
{
// Replace all AltDirectorySeparatorChar's with DirectorySeparatorChar's in the dictionary keys
List <string> keys = new List <string>(downloadLinks.Keys);
for (int i = 0; i < keys.Count; i++)
{
string key = keys[i];
if (key.IndexOf(PatchUtils.AltDirectorySeparatorChar) >= 0)
{
downloadLinks[key.Replace(PatchUtils.AltDirectorySeparatorChar, Path.DirectorySeparatorChar)] = downloadLinks[key];
downloadLinks.Remove(key);
}
}
int updateCount = 0;
int totalCount = VersionInfo.Files.Count + VersionInfo.IncrementalPatches.Count;
for (int i = 0; i < VersionInfo.Files.Count; i++)
{
VersionItem item = VersionInfo.Files[i];
string downloadLink;
string relativePath = item.Path.Replace(PatchUtils.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
if (downloadLinks.TryGetValue(relativePath, out downloadLink) ||
downloadLinks.TryGetValue(relativePath + PatchParameters.REPAIR_PATCH_FILE_EXTENSION, out downloadLink) ||
downloadLinks.TryGetValue(PatchParameters.REPAIR_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath, out downloadLink) ||
downloadLinks.TryGetValue(PatchParameters.REPAIR_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath + PatchParameters.REPAIR_PATCH_FILE_EXTENSION, out downloadLink))
{
item.DownloadURL = downloadLink;
updateCount++;
}
}
for (int i = 0; i < VersionInfo.IncrementalPatches.Count; i++)
{
IncrementalPatch patch = VersionInfo.IncrementalPatches[i];
string downloadLink;
string relativePath = patch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_FILE_EXTENSION;
if (downloadLinks.TryGetValue(relativePath, out downloadLink) ||
downloadLinks.TryGetValue(PatchParameters.INCREMENTAL_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath, out downloadLink))
{
patch.DownloadURL = downloadLink;
updateCount++;
}
relativePath = patch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_INFO_EXTENSION;
if (downloadLinks.TryGetValue(relativePath, out downloadLink) ||
downloadLinks.TryGetValue(PatchParameters.INCREMENTAL_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath, out downloadLink))
{
patch.InfoURL = downloadLink;
updateCount++;
}
if (patch.Files > 0)
{
totalCount++;
}
}
if (VersionInfo.InstallerPatch.PatchSize > 0L || !string.IsNullOrEmpty(VersionInfo.InstallerPatch.PatchMd5Hash))
{
string downloadLink;
string relativePath = PatchParameters.INSTALLER_PATCH_FILENAME;
if (downloadLinks.TryGetValue(relativePath, out downloadLink) ||
downloadLinks.TryGetValue(PatchParameters.INSTALLER_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath, out downloadLink))
{
VersionInfo.InstallerPatch.DownloadURL = downloadLink;
updateCount++;
}
totalCount++;
}
if (Logger != null)
{
Logger(Localization.Get(StringId.XDownloadLinksAreUpdatedSuccessfully, updateCount, totalCount));
}
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 bool PatchUsingIncrementalPatches()
{
if (comms.Cancel)
{
return(false);
}
comms.LogToFile(Localization.Get(StringId.ApplyingIncrementalPatch));
if (incrementalPatches.Count == 0)
{
return(false);
}
if (comms.VerifyFiles)
{
PatchStage = PatchStage.VerifyingFilesOnServer;
for (int i = 0; i < incrementalPatches.Count; i++)
{
if (comms.Cancel)
{
return(false);
}
IncrementalPatch incrementalPatch = incrementalPatches[i];
long fileSize;
if (!comms.DownloadManager.FileExistsAtUrl(comms.VersionInfo.GetInfoURLFor(incrementalPatch), out fileSize))
{
FailReason = PatchFailReason.FileDoesNotExistOnServer;
FailDetails = Localization.Get(StringId.E_FileXDoesNotExistOnServer, incrementalPatch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_INFO_EXTENSION);
return(false);
}
if (incrementalPatch.Files > 0)
{
if (!comms.DownloadManager.FileExistsAtUrl(comms.VersionInfo.GetDownloadURLFor(incrementalPatch), out fileSize))
{
FailReason = PatchFailReason.FileDoesNotExistOnServer;
FailDetails = Localization.Get(StringId.E_FileXDoesNotExistOnServer, incrementalPatch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_FILE_EXTENSION);
return(false);
}
else if (fileSize > 0L && fileSize != incrementalPatch.PatchSize)
{
FailReason = PatchFailReason.FileIsNotValidOnServer;
FailDetails = Localization.Get(StringId.E_FileXIsNotValidOnServer, incrementalPatch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_FILE_EXTENSION);
return(false);
}
}
}
}
for (int i = 0; i < incrementalPatches.Count; i++)
{
if (comms.Cancel)
{
return(false);
}
IncrementalPatch incrementalPatch = incrementalPatches[i];
string patchInfoXML = comms.DownloadManager.DownloadTextFromURL(comms.VersionInfo.GetInfoURLFor(incrementalPatch));
if (patchInfoXML == null)
{
FailReason = PatchFailReason.DownloadError;
FailDetails = Localization.Get(StringId.E_CouldNotDownloadPatchInfoX, incrementalPatch.PatchVersionBrief());
return(false);
}
if (PatchInfoVerifier != null && !PatchInfoVerifier(ref patchInfoXML))
{
FailReason = PatchFailReason.CantVerifyPatchInfo;
FailDetails = Localization.Get(StringId.E_PatchInfoCouldNotBeVerified);
return(false);
}
IncrementalPatchInfo patchInfo;
try
{
patchInfo = PatchUtils.DeserializeXMLToIncrementalPatchInfo(patchInfoXML);
}
catch (Exception e)
{
comms.LogToFile(e);
FailReason = PatchFailReason.XmlDeserializeError;
FailDetails = Localization.Get(StringId.E_InvalidPatchInfoX, incrementalPatch.PatchVersionBrief());
return(false);
}
patchInfo.FromVersion = incrementalPatch.FromVersion;
patchInfo.ToVersion = incrementalPatch.ToVersion;
patchInfo.DownloadURL = comms.VersionInfo.GetDownloadURLFor(incrementalPatch);
patchInfo.CompressedFileSize = incrementalPatch.PatchSize;
patchInfo.CompressedMd5Hash = incrementalPatch.PatchMd5Hash;
patchInfo.CompressionFormat = incrementalPatch.CompressionFormat;
incrementalPatchesInfo.Add(patchInfo);
if (currentVersion > incrementalPatch.FromVersion)
{
continue;
}
if (new IncrementalPatchApplier(comms, patchInfo).Run() == PatchResult.Failed)
{
return(false);
}
}
return(true);
}