protected override void UpdateRestartNeeded(string executableName = "")
{
Data.Log(Context.LocalizedMessages.UpdateRestartNeeded);
Context.Logger.Info($"===> [{UpdateProcessName}] process INCOMPLETE: restart is needed! <===");
string filePath;
if (!string.IsNullOrWhiteSpace(executableName))
{
filePath = PathsManager.Combine(Context.Settings.RootPath, executableName);
}
else
{
filePath = PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName);
}
try
{
ApplicationStarter.StartApplication(
Path.Combine(Context.Settings.RootPath, Data.LauncherExecutableName), "");
Data.Dispatcher.Invoke(Application.Quit);
}
catch (Exception ex)
{
Context.Logger.Error(null, $"Unable to start the Launcher at {filePath}.");
UpdateFailed(ex);
}
}
private FileIntegrity GetRelaxedFileIntegrity(BuildDefinitionEntry entry)
{
foreach (var existingFile in _context.ExistingFiles)
{
var existingFilePath = FilesManager.SanitizePath(PathsManager.Combine(_context.Settings.RootPath, existingFile.RelativePath));
var entryFilePath = FilesManager.SanitizePath(PathsManager.Combine(_context.Settings.GetGamePath(), entry.RelativePath));
if (existingFilePath == entryFilePath)
{
var integrity = FileIntegrity.None;
if (existingFile.Size != entry.Size)
{
integrity |= FileIntegrity.InvalidSize;
}
if (integrity == FileIntegrity.None)
{
return(FileIntegrity.Valid);
}
return(integrity);
}
}
return(FileIntegrity.NotExisting);
}
private void StartGame()
{
var filePath = PathsManager.Combine(Context.Settings.GetGamePath(), Data.GameExecutableName);
ApplicationStarter.StartApplication(filePath, $"{Context.Settings.LaunchArgumentParameter}={Context.Settings.LaunchArgumentValue}");
Application.Quit();
}
private void EnsureDefinition(UpdaterDefinitionEntry entry)
{
var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath);
File.SetAttributes(filePath, entry.Attributes);
File.SetLastWriteTimeUtc(filePath, entry.LastWriting);
}
private void BuildPatchDefinition(PatchDefinition definition)
{
definition.Hash = Hashing.GetFileHash(PathsManager.Combine(_context.Settings.GetPatchesFolderPath(), _context.PatchName));
definition.From = _context.VersionFrom;
definition.To = _context.VersionTo;
File.WriteAllText(_context.Settings.GetPatchIndexPath(_context.VersionFrom, _context.VersionTo), _context.Serializer.Serialize(definition));
}
private void HandleChangedAttributesFile(PatchDefinitionEntry entry)
{
var path = PathsManager.Combine(_context.Settings.GetGameFolderPath(_context.VersionTo), entry.RelativePath);
var info = FilesManager.GetFileInfo(path);
entry.Attributes = info.Attributes;
entry.LastWriting = info.LastWriting;
}
private void CompressPatch()
{
Compressor.Compress(
_context.Settings.GetPatchesTempFolderPath(),
PathsManager.Combine(_context.Settings.GetPatchesFolderPath(), _context.PatchName),
null,
_context.CompressionLevel
);
}
private void HandleAddedFile(PatchDefinition definition, PatchDefinitionEntry entry)
{
var sourcePath = PathsManager.Combine(_context.Settings.GetUncompressedPatchArchivePath(definition.From, definition.To), entry.RelativePath);
var destinationPath = PathsManager.Combine(_context.Settings.GetGamePath(), entry.RelativePath);
FilesManager.Delete(destinationPath);
FilesManager.Move(sourcePath, destinationPath);
EnsureDefinition(destinationPath, entry);
}
protected override void UpdateRestartNeeded()
{
Data.Log(Context.LocalizedMessages.UpdateRestartNeeded);
Context.Logger.Info($"===> [{UpdateProcessName}] process INCOMPLETE: restart is needed! <===");
EnsureExecutePrivileges(PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName));
ApplicationStarter.StartApplication(Path.Combine(Context.Settings.RootPath, Data.LauncherExecutableName), "");
Data.Dispatcher.Invoke(Application.Quit);
}
private bool HandleInvalidLastWriting(BuildDefinitionEntry entry)
{
var filePath = PathsManager.Combine(_context.Settings.GetGamePath(), entry.RelativePath);
var hash = Hashing.GetFileHash(filePath);
if (entry.Hash != hash)
{
FilesManager.Delete(filePath);
return(false);
}
return(true);
}
private void StartGame()
{
if (_alreadyTriggeredGameStart)
{
return;
}
_alreadyTriggeredGameStart = true;
var filePath = PathsManager.Combine(Context.Settings.GetGamePath(), Data.GameExecutableName);
ApplicationStarter.StartApplication(filePath, $"{Context.Settings.LaunchArgumentParameter}={Context.Settings.LaunchArgumentValue}");
Application.Quit();
}
private void HandleDeletedFile(UpdaterDefinitionEntry entry)
{
var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath);
if (FilesManager.IsFileLocked(filePath))
{
var newFilePath = FilesManager.GetTemporaryDeletingFileName(filePath);
FilesManager.Rename(filePath, newFilePath);
}
else
{
FilesManager.Delete(filePath);
}
}
protected override void UpdateRestartNeeded(string executableName = "")
{
Data.Dispatcher.Invoke(() => { Data.Log(Context.LocalizedMessages.UpdateRestartNeeded); });
Context.Logger.Info($"===> [{UpdateProcessName}] process INCOMPLETE: restart is needed! <===");
EnsureExecutePrivileges(PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName));
string filePath;
if (!string.IsNullOrWhiteSpace(executableName))
{
filePath = PathsManager.Combine(Context.Settings.RootPath, executableName);
}
else
{
filePath = PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName);
}
Data.Dispatcher.Invoke(
() =>
{
Data.Dialog.ShowDialog(
"Pending update!",
Context.LocalizedMessages.UpdateRestartNeeded,
() => Data.Dialog.CloseDialog(),
() =>
{
try
{
ApplicationStarter.StartApplication(
Path.Combine(Context.Settings.RootPath,
Data.LauncherExecutableName),
"");
Data.Dispatcher.Invoke(Application.Quit);
}
catch (Exception ex)
{
Context.Logger.Error(null, $"Unable to start the Launcher at {filePath}.");
UpdateFailed(ex);
}
}
);
RestartNeeded?.Invoke();
}
);
_isPreviousUpdateCompleted = false;
}
private void HandleAddedFile(UpdaterDefinitionEntry entry)
{
var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath);
var difference = FileValidityDifference.None;
var alreadyExisting = FilesManager.Exists(filePath);
if (alreadyExisting && IsValid(entry, out difference))
{
return;
}
if (difference.HasFlag(FileValidityDifference.Size))
{
if (FilesManager.IsFileLocked(filePath))
{
var newFilePath = FilesManager.GetTemporaryDeletingFileName(filePath);
FilesManager.Rename(filePath, newFilePath);
}
else
{
FilesManager.Delete(filePath);
}
Downloader.Download(_context.Settings.GetRemoteUpdaterFileUrl(entry.RelativePath),
PathsManager.GetDirectoryPath(filePath));
EnsureDefinition(entry);
_context.SetDirtyFlag(entry.RelativePath);
}
else
{
if (!alreadyExisting)
{
Downloader.Download(_context.Settings.GetRemoteUpdaterFileUrl(entry.RelativePath),
PathsManager.GetDirectoryPath(filePath));
}
if (FilesManager.IsFileLocked(filePath))
{
var newFilePath = FilesManager.GetTemporaryDeletingFileName(filePath);
FilesManager.Rename(filePath, newFilePath);
FilesManager.Copy(newFilePath, filePath);
}
EnsureDefinition(entry);
}
}
private void HandleUpdatedFile(PatchDefinitionEntry entry)
{
var fromFile = PathsManager.Combine(_context.Settings.GetGameFolderPath(_context.VersionFrom), entry.RelativePath);
var toFile = PathsManager.Combine(_context.Settings.GetGameFolderPath(_context.VersionTo), entry.RelativePath);
var patchFile = PathsManager.Combine(_context.Settings.GetPatchesTempFolderPath(), entry.RelativePath + ".patch");
var signatureFile = PathsManager.Combine(_context.Settings.GetPatchesTempFolderPath(), entry.RelativePath + ".signature");
DirectoriesManager.Create(PathsManager.GetDirectoryPath(patchFile));
DeltaFileBuilder.Build(fromFile, toFile, patchFile, signatureFile);
var path = PathsManager.Combine(_context.Settings.GetGameFolderPath(_context.VersionTo), entry.RelativePath);
var info = FilesManager.GetFileInfo(path);
entry.Attributes = info.Attributes;
entry.LastWriting = info.LastWriting;
}
protected override void UpdateCompleted()
{
Data.Log(Context.LocalizedMessages.UpdateProcessCompleted);
Context.Logger.Info($"===> [{UpdateProcessName}] process COMPLETED! <===");
Data.Dispatcher.Invoke(() =>
{
Data.ProgressBar.Progress = 1;
Data.ProgressPercentage.text = "100%";
});
EnsureExecutePrivileges(PathsManager.Combine(Context.Settings.GetGamePath(), Data.GameExecutableName));
EnsureExecutePrivileges(PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName));
Data.Dispatcher.Invoke(() =>
{
Invoke(nameof(StartGame), 1.5f);
});
}
private void HandleChangedAttributesFile(UpdaterDefinitionEntry entry)
{
var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath);
if (!FilesManager.Exists(filePath))
{
Downloader.Download(_context.Settings.GetRemoteUpdaterFileUrl(entry.RelativePath),
PathsManager.GetDirectoryPath(filePath));
}
else
{
if (FilesManager.IsFileLocked(filePath))
{
var newFilePath = FilesManager.GetTemporaryDeletingFileName(filePath);
FilesManager.Rename(filePath, newFilePath);
FilesManager.Copy(newFilePath, filePath);
}
}
EnsureDefinition(entry);
}
private void HandleUpdatedFile(PatchDefinition definition, PatchDefinitionEntry entry)
{
var filePath = PathsManager.Combine(_context.Settings.GetGamePath(), entry.RelativePath);
var fileBackupPath = filePath + ".bak";
var patchPath = PathsManager.Combine(_context.Settings.GetUncompressedPatchArchivePath(definition.From, definition.To), entry.RelativePath + ".patch");
try
{
FilesManager.Rename(filePath, fileBackupPath);
DeltaFileApplier.Apply(fileBackupPath, patchPath, filePath);
EnsureDefinition(filePath, entry);
}
catch
{
}
finally
{
FilesManager.Delete(fileBackupPath);
}
}
private bool IsValid(UpdaterDefinitionEntry entry, out FileValidityDifference difference)
{
var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath);
var info = FilesManager.GetFileInfo(filePath);
difference = FileValidityDifference.None;
if (info.Size != entry.Size)
{
difference |= FileValidityDifference.Size;
}
if (!AreLastWritingsEqual(info.LastWriting, entry.LastWriting))
{
difference |= FileValidityDifference.LastWriting;
}
if (info.Attributes != entry.Attributes)
{
difference |= FileValidityDifference.Attributes;
}
return(difference == FileValidityDifference.None);
}
private void BuildDefinition()
{
var files = FilesManager.GetFilesInfo(_context.Settings.GetApplicationFolderPath());
var definitions = new BuildDefinition();
definitions.Entries = new BuildDefinitionEntry[files.Length + 1];
for (var i = 0; i < files.Length; i++)
{
var file = files[i];
definitions.Entries[i] = new BuildDefinitionEntry()
{
Attributes = file.Attributes,
Hash = Hashing.GetFileHash(PathsManager.Combine(_context.Settings.GetApplicationFolderPath(), file.RelativePath)),
LastWriting = file.LastWriting,
RelativePath = file.RelativePath,
Size = file.Size
};
_context.ReportProgress(string.Format(_context.LocalizedMessages.BuildDefinitionProcessed, PathsManager.GetFilename(file.RelativePath)));
}
var versionFile = FilesManager.GetFileInfo(_context.Settings.GetVersionFilePath(_context.BuildVersion));
definitions.Entries[files.Length] = new BuildDefinitionEntry()
{
Attributes = versionFile.Attributes,
Hash = Hashing.GetFileHash(_context.Settings.GetVersionFilePath(_context.BuildVersion)),
LastWriting = versionFile.LastWriting,
RelativePath = versionFile.RelativePath,
Size = versionFile.Size
};
_context.ReportProgress(string.Format(_context.LocalizedMessages.BuildDefinitionProcessed, PathsManager.GetFilename(versionFile.RelativePath)));
File.WriteAllText(_context.Settings.GetBuildDefinitionPath(_context.BuildVersion), _context.Serializer.Serialize(definitions));
}
public virtual string GetPatchIndexPath(IVersion from, IVersion to) => PathsManager.Combine(RootPath, PatchesFolderName, string.Format(PatchDefinitionFileName, from, to));
public virtual string GetBuildDefinitionPath(IVersion version) => PathsManager.Combine(RootPath, BuildsFolderName, string.Format(BuildDefinitionFileName, version.ToString()));
public virtual string GetPatchesIndexPath() => PathsManager.Combine(RootPath, PatchesFolderName, PatchesIndexFileName);
public virtual string GetLogsDirectoryPath() => PathsManager.Combine(RootPath, LogsFolderName);
public virtual string GetGameFolderPath(IVersion version) => PathsManager.Combine(RootPath, BuildsFolderName, version.ToString(), GameFolderName);
public virtual string GetLogsFilePath() => PathsManager.Combine(RootPath, LogsFolderName, LogsFileName);
public virtual string GetDebugReportFilePath() => PathsManager.Combine(RootPath, "debug_report.txt");
public virtual string GetUpdaterDeployPath(string fileName) => PathsManager.Combine(RootPath, fileName + ".zip");
public virtual string GetUpdaterIndexPath() => PathsManager.Combine(RootPath, UpdaterFolderName, UpdaterIndexFileName);
public virtual string GetVersionFilePath(IVersion version) => PathsManager.Combine(GetGameFolderPath(version), VersionFileName);
