public override int Execute()
{
try
{
_reporter.WriteLine();
var workloadIds = _workloadInstaller.GetWorkloadInstallationRecordRepository().GetInstalledWorkloads(new SdkFeatureBand(_sdkVersion));
_reporter.WriteLine(string.Format(LocalizableStrings.RepairingWorkloads, string.Join(" ", workloadIds)));
ReinstallWorkloadsBasedOnCurrentManifests(workloadIds, new SdkFeatureBand(_sdkVersion));
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
_workloadInstaller.GetPackInstaller().GarbageCollectInstalledWorkloadPacks();
}
_reporter.WriteLine();
_reporter.WriteLine(string.Format(LocalizableStrings.RepairSucceeded, string.Join(" ", workloadIds)));
_reporter.WriteLine();
}
catch (Exception e)
{
// Don't show entire stack trace
throw new GracefulException(string.Format(LocalizableStrings.WorkloadRepairFailed, e.Message), e);
}
finally
{
_workloadInstaller.Shutdown();
}
return(_workloadInstaller.ExitCode);
}
private void UpdateWorkloadsWithInstallRecord(
IEnumerable <WorkloadId> workloadIds,
SdkFeatureBand sdkFeatureBand,
IEnumerable <ManifestVersionUpdate> manifestsToUpdate,
DirectoryPath?offlineCache = null)
{
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
var installer = _workloadInstaller.GetPackInstaller();
IEnumerable <PackInfo> workloadPackToUpdate = new List <PackInfo>();
var transaction = new CliTransaction();
transaction.RollbackStarted = () =>
{
Reporter.WriteLine(LocalizableStrings.RollingBackInstall);
};
// Don't hide the original error if roll back fails, but do log the rollback failure
transaction.RollbackFailed = ex =>
{
Reporter.WriteLine(string.Format(LocalizableStrings.RollBackFailedMessage, ex.Message));
};
transaction.Run(
action: context =>
{
bool rollback = !string.IsNullOrWhiteSpace(_fromRollbackDefinition);
foreach (var manifestUpdate in manifestsToUpdate)
{
_workloadInstaller.InstallWorkloadManifest(manifestUpdate, context, offlineCache, rollback);
}
_workloadResolver.RefreshWorkloadManifests();
workloadPackToUpdate = GetUpdatablePacks(installer);
installer.InstallWorkloadPacks(workloadPackToUpdate, sdkFeatureBand, context, offlineCache);
},
rollback: () =>
{
// Nothing to roll back at this level, InstallWorkloadManifest and InstallWorkloadPacks handle the transaction rollback
});
}
else
{
var installer = _workloadInstaller.GetWorkloadInstaller();
foreach (var workloadId in workloadIds)
{
installer.InstallWorkload(workloadId);
}
}
}
public void InstallWorkloads(IEnumerable <WorkloadId> workloadIds, bool skipManifestUpdate = false, bool includePreviews = false, DirectoryPath?offlineCache = null)
{
_reporter.WriteLine();
var featureBand = new SdkFeatureBand(string.Join('.', _sdkVersion.Major, _sdkVersion.Minor, _sdkVersion.SdkFeatureBand));
IEnumerable <(ManifestId, ManifestVersion, ManifestVersion)> manifestsToUpdate = new List <(ManifestId, ManifestVersion, ManifestVersion)>();
if (!skipManifestUpdate)
{
// Update currently installed workloads
var installedWorkloads = _workloadInstaller.GetWorkloadInstallationRecordRepository().GetInstalledWorkloads(featureBand);
workloadIds = workloadIds.Concat(installedWorkloads).Distinct();
_workloadManifestUpdater.UpdateAdvertisingManifestsAsync(includePreviews, offlineCache).Wait();
manifestsToUpdate = _workloadManifestUpdater.CalculateManifestUpdates();
}
InstallWorkloadsWithInstallRecord(workloadIds, featureBand, manifestsToUpdate, offlineCache);
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
_workloadInstaller.GetPackInstaller().GarbageCollectInstalledWorkloadPacks();
}
_reporter.WriteLine();
_reporter.WriteLine(string.Format(LocalizableStrings.InstallationSucceeded, string.Join(" ", workloadIds)));
_reporter.WriteLine();
}
public void UpdateWorkloads(bool includePreviews = false, DirectoryPath?offlineCache = null)
{
_reporter.WriteLine();
var featureBand =
new SdkFeatureBand(string.Join('.', _sdkVersion.Major, _sdkVersion.Minor, _sdkVersion.SdkFeatureBand));
var workloadIds = GetUpdatableWorkloads();
_workloadManifestUpdater.UpdateAdvertisingManifestsAsync(includePreviews, offlineCache).Wait();
var manifestsToUpdate = string.IsNullOrWhiteSpace(_fromRollbackDefinition) ?
_workloadManifestUpdater.CalculateManifestUpdates().Select(m => (m.manifestId, m.existingVersion, m.newVersion)) :
_workloadManifestUpdater.CalculateManifestRollbacks(_fromRollbackDefinition);
UpdateWorkloadsWithInstallRecord(workloadIds, featureBand, manifestsToUpdate, offlineCache);
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
_workloadInstaller.GetPackInstaller().GarbageCollectInstalledWorkloadPacks();
}
_reporter.WriteLine();
_reporter.WriteLine(string.Format(LocalizableStrings.UpdateSucceeded, string.Join(" ", workloadIds)));
_reporter.WriteLine();
}
public void InstallWorkloads(IEnumerable <WorkloadId> workloadIds, bool skipManifestUpdate = false)
{
_reporter.WriteLine();
var featureBand = new SdkFeatureBand(string.Join('.', _sdkVersion.Major, _sdkVersion.Minor, _sdkVersion.SdkFeatureBand));
if (!skipManifestUpdate)
{
throw new NotImplementedException();
}
InstallWorkloadsWithInstallRecord(workloadIds, featureBand);
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
_workloadInstaller.GetPackInstaller().GarbageCollectInstalledWorkloadPacks();
}
_reporter.WriteLine();
_reporter.WriteLine(string.Format(LocalizableStrings.InstallationSucceeded, string.Join(" ", workloadIds)));
_reporter.WriteLine();
}
public override int Execute()
{
try
{
Reporter.WriteLine();
var featureBand = new SdkFeatureBand(_sdkVersion);
var installedWorkloads = _workloadInstaller.GetWorkloadInstallationRecordRepository().GetInstalledWorkloads(featureBand);
var unrecognizedWorkloads = _workloadIds.Where(workloadId => !installedWorkloads.Contains(workloadId));
if (unrecognizedWorkloads.Any())
{
throw new Exception(string.Format(LocalizableStrings.WorkloadNotInstalled, string.Join(" ", unrecognizedWorkloads)));
}
foreach (var workloadId in _workloadIds)
{
Reporter.WriteLine(string.Format(LocalizableStrings.RemovingWorkloadInstallationRecord, workloadId));
_workloadInstaller.GetWorkloadInstallationRecordRepository()
.DeleteWorkloadInstallationRecord(workloadId, featureBand);
}
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
var installer = _workloadInstaller.GetPackInstaller();
installer.GarbageCollectInstalledWorkloadPacks();
}
else
{
var installer = _workloadInstaller.GetWorkloadInstaller();
foreach (var workloadId in _workloadIds)
{
installer.UninstallWorkload(workloadId);
}
}
Reporter.WriteLine();
Reporter.WriteLine(string.Format(LocalizableStrings.UninstallSucceeded, string.Join(" ", _workloadIds)));
Reporter.WriteLine();
}
catch (Exception e)
{
_workloadInstaller.Shutdown();
// Don't show entire stack trace
throw new GracefulException(string.Format(LocalizableStrings.WorkloadUninstallFailed, e.Message), e, isUserError: false);
}
return(_workloadInstaller.ExitCode);
}
internal static void TryRunGarbageCollection(IInstaller workloadInstaller, IReporter reporter, VerbosityOptions verbosity, DirectoryPath?offlineCache = null)
{
try
{
if (workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
workloadInstaller.GetPackInstaller().GarbageCollectInstalledWorkloadPacks(offlineCache);
}
}
catch (Exception e)
{
// Garbage collection failed, warn user
reporter.WriteLine(string.Format(LocalizableStrings.GarbageCollectionFailed,
verbosity.VerbosityIsDetailedOrDiagnostic() ? e.StackTrace.ToString() : e.Message).Yellow());
}
}
public void UpdateWorkloads(bool includePreviews = false)
{
_reporter.WriteLine();
var featureBand = new SdkFeatureBand(string.Join('.', _sdkVersion.Major, _sdkVersion.Minor, _sdkVersion.SdkFeatureBand));
var workloadIds = _workloadInstaller.GetWorkloadInstallationRecordRepository().GetInstalledWorkloads(featureBand);
_workloadManifestUpdater.UpdateAdvertisingManifestsAsync(includePreviews).Wait();
var manifestsToUpdate = _workloadManifestUpdater.CalculateManifestUpdates();
UpdateWorkloadsWithInstallRecord(workloadIds, featureBand, manifestsToUpdate);
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
_workloadInstaller.GetPackInstaller().GarbageCollectInstalledWorkloadPacks();
}
_reporter.WriteLine();
_reporter.WriteLine(string.Format(LocalizableStrings.UpdateSucceeded, string.Join(" ", workloadIds)));
_reporter.WriteLine();
}
private void ReinstallWorkloadsBasedOnCurrentManifests(IEnumerable <WorkloadId> workloadIds, SdkFeatureBand sdkFeatureBand)
{
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
var installer = _workloadInstaller.GetPackInstaller();
var packsToInstall = workloadIds
.SelectMany(workloadId => _workloadResolver.GetPacksInWorkload(workloadId))
.Distinct()
.Select(packId => _workloadResolver.TryGetPackInfo(packId))
.Where(pack => pack != null);
foreach (var packId in packsToInstall)
{
CliTransaction.RunNew(context => installer.RepairWorkloadPack(packId, sdkFeatureBand, context));
}
}
else
{
throw new NotImplementedException();
}
}
private void InstallWorkloadsWithInstallRecord(
IEnumerable <WorkloadId> workloadIds,
SdkFeatureBand sdkFeatureBand,
IEnumerable <ManifestVersionUpdate> manifestsToUpdate,
DirectoryPath?offlineCache)
{
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
var installer = _workloadInstaller.GetPackInstaller();
IEnumerable <PackInfo> workloadPackToInstall = new List <PackInfo>();
IEnumerable <WorkloadId> newWorkloadInstallRecords = new List <WorkloadId>();
var transaction = new CliTransaction();
transaction.RollbackStarted = () =>
{
Reporter.WriteLine(LocalizableStrings.RollingBackInstall);
};
// Don't hide the original error if roll back fails, but do log the rollback failure
transaction.RollbackFailed = ex =>
{
Reporter.WriteLine(string.Format(LocalizableStrings.RollBackFailedMessage, ex.Message));
};
transaction.Run(
action: context =>
{
bool rollback = !string.IsNullOrWhiteSpace(_fromRollbackDefinition);
foreach (var manifestUpdate in manifestsToUpdate)
{
_workloadInstaller.InstallWorkloadManifest(manifestUpdate, context, offlineCache, rollback);
}
_workloadResolver.RefreshWorkloadManifests();
workloadPackToInstall = GetPacksToInstall(workloadIds);
installer.InstallWorkloadPacks(workloadPackToInstall, sdkFeatureBand, context, offlineCache);
var recordRepo = _workloadInstaller.GetWorkloadInstallationRecordRepository();
newWorkloadInstallRecords = workloadIds.Except(recordRepo.GetInstalledWorkloads(sdkFeatureBand));
foreach (var workloadId in newWorkloadInstallRecords)
{
recordRepo.WriteWorkloadInstallationRecord(workloadId, sdkFeatureBand);
}
},
rollback: () =>
{
// InstallWorkloadManifest and InstallWorkloadPacks already handle rolling back their actions, so here we only
// need to delete the installation records
foreach (var workloadId in newWorkloadInstallRecords)
{
_workloadInstaller.GetWorkloadInstallationRecordRepository()
.DeleteWorkloadInstallationRecord(workloadId, sdkFeatureBand);
}
});
}
else
{
var installer = _workloadInstaller.GetWorkloadInstaller();
foreach (var workloadId in workloadIds)
{
installer.InstallWorkload(workloadId);
}
}
}