public void Update(CancellationToken cancellationToken)
{
Assert.MethodCalledOnlyOnce(ref _updateHasBeenCalled, "Update");
Assert.ApplicationIsInstalled(_context.App);
DebugLogger.Log("Updating with diff strategy.");
var latestVersionId = _context.App.GetLatestVersionId();
var currentLocalVersionId = _context.App.GetInstalledVersionId();
DebugLogger.LogVariable(latestVersionId, "latestVersionId");
DebugLogger.LogVariable(currentLocalVersionId, "currentLocalVersionId");
var commandFactory = new AppUpdaterCommandFactory();
var geolocateCommand = commandFactory.CreateGeolocateCommand();
geolocateCommand.Prepare(_context.StatusMonitor);
geolocateCommand.Execute(cancellationToken);
var checkDiskSpaceCommand = commandFactory.CreateCheckDiskSpaceCommandForDiff(latestVersionId, _context);
checkDiskSpaceCommand.Prepare(_context.StatusMonitor);
checkDiskSpaceCommand.Execute(cancellationToken);
var validateLicense = commandFactory.CreateValidateLicenseCommand(_context);
validateLicense.Prepare(_context.StatusMonitor);
validateLicense.Execute(cancellationToken);
var diffCommandsList = new List <DiffCommands>();
for (int i = currentLocalVersionId + 1; i <= latestVersionId; i++)
{
DiffCommands diffCommands;
diffCommands.Download = commandFactory.CreateDownloadDiffPackageCommand(i, validateLicense.KeySecret,
geolocateCommand.CountryCode, _context);
diffCommands.Download.Prepare(_context.StatusMonitor);
diffCommands.Install = commandFactory.CreateInstallDiffCommand(i, _context);
diffCommands.Install.Prepare(_context.StatusMonitor);
diffCommandsList.Add(diffCommands);
}
foreach (var diffCommands in diffCommandsList)
{
diffCommands.Download.Execute(cancellationToken);
diffCommands.Install.Execute(cancellationToken);
}
_context.App.DownloadDirectory.Clear();
}
public void Update(CancellationToken cancellationToken)
{
Assert.MethodCalledOnlyOnce(ref _updateHasBeenCalled, "Update");
Assert.ApplicationIsInstalled(_context.App);
DebugLogger.Log("Updating with diff strategy.");
var latestVersionId = _context.App.GetLatestVersionId(true, cancellationToken);
var currentLocalVersionId = _context.App.GetInstalledVersionId();
DebugLogger.LogVariable(latestVersionId, "latestVersionId");
DebugLogger.LogVariable(currentLocalVersionId, "currentLocalVersionId");
var commandFactory = new AppUpdaterCommandFactory();
var geolocateCommand = commandFactory.CreateGeolocateCommand();
geolocateCommand.Prepare(_status, cancellationToken);
geolocateCommand.Execute(cancellationToken);
var checkDiskSpaceCommand = commandFactory.CreateCheckDiskSpaceCommandForDiff(latestVersionId, _context, cancellationToken);
checkDiskSpaceCommand.Prepare(_status, cancellationToken);
checkDiskSpaceCommand.Execute(cancellationToken);
var validateLicense = commandFactory.CreateValidateLicenseCommand(_context);
validateLicense.Prepare(_status, cancellationToken);
validateLicense.Execute(cancellationToken);
var diffCommandsList = new List <DiffCommands>();
for (int i = currentLocalVersionId + 1; i <= latestVersionId; i++)
{
DiffCommands diffCommands;
var resource = _context.App.RemoteData.GetDiffPackageResource(i, validateLicense.KeySecret, geolocateCommand.CountryCode, cancellationToken);
diffCommands.Download = new DiffCommands.Context <IDownloadPackageCommand> {
Command = commandFactory.CreateDownloadDiffPackageCommand(i, validateLicense.KeySecret,
geolocateCommand.CountryCode, _context, cancellationToken),
VersionId = i,
Size = resource.Size,
};
diffCommands.Download.Command.Prepare(_status, cancellationToken);
diffCommands.Install = commandFactory.CreateInstallDiffCommand(i, _context);
diffCommands.Install.Prepare(_status, cancellationToken);
diffCommandsList.Add(diffCommands);
}
foreach (var diffCommands in diffCommandsList)
{
var optionalParams = new PatcherStatistics.OptionalParams
{
Size = diffCommands.Download.Size,
VersionId = diffCommands.Download.VersionId
};
try
{
PatcherStatistics.DispatchSendEvent(PatcherStatistics.Event.PatchDownloadStarted, optionalParams);
diffCommands.Download.Command.Execute(cancellationToken);
PatcherStatistics.DispatchSendEvent(PatcherStatistics.Event.PatchDownloadSucceeded, optionalParams);
}
catch (OperationCanceledException)
{
PatcherStatistics.DispatchSendEvent(PatcherStatistics.Event.PatchDownloadCanceled, optionalParams);
throw;
}
catch (Exception)
{
PatcherStatistics.DispatchSendEvent(PatcherStatistics.Event.PatchDownloadFailed, optionalParams);
throw;
}
diffCommands.Install.Execute(cancellationToken);
}
_context.App.DownloadDirectory.Clear();
}
public void Update(CancellationToken cancellationToken)
{
_logger.LogDebug("Executing content repair strategy.");
var installedVersionId = _context.App.GetInstalledVersionId();
string metaDestination = _context.App.DownloadDirectory.GetDiffPackageMetaPath(installedVersionId);
var commandFactory = new AppUpdaterCommandFactory();
var validateLicense = commandFactory.CreateValidateLicenseCommand(_context);
validateLicense.Prepare(_status, cancellationToken);
validateLicense.Execute(cancellationToken);
var geolocateCommand = commandFactory.CreateGeolocateCommand();
geolocateCommand.Prepare(_status, cancellationToken);
geolocateCommand.Execute(cancellationToken);
var resource = _context.App.RemoteData.GetContentPackageResource(
installedVersionId,
validateLicense.KeySecret,
geolocateCommand.CountryCode,
cancellationToken);
if (!resource.HasMetaUrls())
{
throw new ArgumentException("Cannot execute content repair strategy without meta files.");
}
_logger.LogDebug("Downloading the meta file.");
var downloader = new HttpDownloader(metaDestination, resource.GetMetaUrls());
downloader.Download(cancellationToken);
ICheckVersionIntegrityCommand checkVersionIntegrityCommand
= commandFactory.CreateCheckVersionIntegrityCommand(installedVersionId, _context, true, true, cancellationToken);
checkVersionIntegrityCommand.Prepare(_status, cancellationToken);
checkVersionIntegrityCommand.Execute(cancellationToken);
var meta = Pack1Meta.ParseFromFile(metaDestination);
FileIntegrity[] filesIntegrity = checkVersionIntegrityCommand.Results.Files;
var contentSummary = _context.App.RemoteMetaData.GetContentSummary(installedVersionId, cancellationToken);
foreach (var invalidVersionIdFile in filesIntegrity.Where(x =>
x.Status == FileIntegrityStatus.InvalidVersion).ToArray())
{
var fileName = invalidVersionIdFile.FileName;
var file = contentSummary.Files.First(x => x.Path == fileName);
var localPath = _context.App.LocalDirectory.Path.PathCombine(file.Path);
string actualFileHash = HashCalculator.ComputeFileHash(localPath);
if (actualFileHash != file.Hash)
{
FileOperations.Delete(localPath, cancellationToken);
_context.App.LocalMetaData.RegisterEntry(fileName, installedVersionId);
invalidVersionIdFile.Status = FileIntegrityStatus.MissingData;
}
else
{
_context.App.LocalMetaData.RegisterEntry(fileName, installedVersionId);
invalidVersionIdFile.Status = FileIntegrityStatus.Ok;
}
}
Pack1Meta.FileEntry[] brokenFiles = filesIntegrity
// Filter only files with invalid size, hash or missing entirely
.Where(f => f.Status == FileIntegrityStatus.InvalidHash ||
f.Status == FileIntegrityStatus.InvalidSize ||
f.Status == FileIntegrityStatus.MissingData)
// Map to file entires from meta
.Select(integrity => meta.Files.SingleOrDefault(file => file.Name == integrity.FileName))
// Filter only regular files
.Where(file => file.Type == Pack1Meta.RegularFileType)
.ToArray();
if (brokenFiles.Length == 0)
{
_logger.LogDebug("Nothing to repair.");
return;
}
_logger.LogDebug(string.Format("Broken files count: {0}", brokenFiles.Length));
IRepairFilesCommand repairCommand = commandFactory.CreateRepairFilesCommand(
installedVersionId,
_context,
resource,
brokenFiles,
meta);
repairCommand.Prepare(_status, cancellationToken);
repairCommand.Execute(cancellationToken);
}