public void GivenWorkloadInstallItCanRollBackPackInstallation()
{
var mockWorkloadIds = new WorkloadId[] { new WorkloadId("xamarin-android"), new WorkloadId("xamarin-android-build") };
var testDirectory = _testAssetsManager.CreateTestDirectory().Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var installer = new MockPackWorkloadInstaller(failingWorkload: "xamarin-android-build");
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), new string[] { dotnetRoot });
var parseResult = Parser.GetWorkloadsInstance.Parse(new string[] { "dotnet", "workload", "install", "xamarin-android", "xamarin-android-build", "--skip-manifest-update" });
var installManager = new WorkloadInstallCommand(parseResult, reporter: _reporter, workloadResolver: workloadResolver, workloadInstaller: installer, version: "6.0.100");
try
{
installManager.InstallWorkloads(mockWorkloadIds, true);
// Install should have failed
true.Should().BeFalse();
}
catch (Exception e)
{
e.Message.Should().Be("Failing workload: xamarin-android-build");
var expectedPacks = mockWorkloadIds
.SelectMany(workloadId => workloadResolver.GetPacksInWorkload(workloadId.ToString()))
.Distinct()
.Select(packId => workloadResolver.TryGetPackInfo(packId));
installer.RolledBackPacks.ShouldBeEquivalentTo(expectedPacks);
installer.WorkloadInstallRecord.Should().BeEmpty();
}
}
public void GivenWorkloadsAreOutOfDateUpdatesAreAdvertised()
{
_reporter.Clear();
var testDirectory = _testAssetsManager.CreateTestDirectory().Path;
var expectedWorkloads = new List <WorkloadId>()
{
new WorkloadId("mock-workload-1"), new WorkloadId("mock-workload-2"), new WorkloadId("mock-workload-3")
};
var workloadInstaller = new MockWorkloadRecordRepo(expectedWorkloads);
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), new string[] { testDirectory });
// Lay out fake advertising manifests with pack version update for pack A (in workloads 1 and 3)
var userHome = Path.Combine(testDirectory, "userHome");
var manifestPath = Path.Combine(userHome, ".dotnet", "sdk-advertising", "6.0.100", "SampleManifest", "WorkloadManifest.json");
Directory.CreateDirectory(Path.GetDirectoryName(manifestPath));
File.Copy(Path.Combine(_testAssetsManager.GetAndValidateTestProjectDirectory("SampleManifest"), "MockListSampleUpdated.json"), manifestPath);
var command = new WorkloadListCommand(_parseResult, _reporter, workloadInstaller, "6.0.100", workloadResolver: workloadResolver, userHome: userHome);
command.Execute();
// Workloads 1 and 3 should have updates
_reporter.Lines.Should().Contain(string.Format(LocalizableStrings.WorkloadUpdatesAvailable, "mock-workload-1 mock-workload-3"));
}
public WorkloadUninstallCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
INuGetPackageDownloader nugetPackageDownloader = null,
string dotnetDir = null,
string version = null)
: base(parseResult)
{
_reporter = reporter ?? Reporter.Output;
_workloadIds = parseResult.ValueForArgument <IEnumerable <string> >(WorkloadUninstallCommandParser.WorkloadIdArgument)
.Select(workloadId => new WorkloadId(workloadId)).ToList().AsReadOnly();
_sdkVersion = string.IsNullOrEmpty(parseResult.ValueForOption <string>(WorkloadUninstallCommandParser.VersionOption)) ?
new ReleaseVersion(version ?? Product.Version) :
new ReleaseVersion(parseResult.ValueForOption <string>(WorkloadUninstallCommandParser.VersionOption));
var dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
var verbosity = parseResult.ValueForOption <VerbosityOptions>(WorkloadUninstallCommandParser.VerbosityOption);
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, _sdkVersion.ToString());
workloadResolver = workloadResolver ?? WorkloadResolver.Create(workloadManifestProvider, dotnetPath, _sdkVersion.ToString());
nugetPackageDownloader = nugetPackageDownloader ?? new NuGetPackageDownloader(new DirectoryPath(Path.GetTempPath()), filePermissionSetter: null, new NullLogger());
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
_workloadInstaller = WorkloadInstallerFactory.GetWorkloadInstaller(_reporter, sdkFeatureBand, workloadResolver, verbosity, nugetPackageDownloader, dotnetPath);
}
protected override void ExecuteCore()
{
if (MissingWorkloadPacks.Any())
{
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(NetCoreRoot, NETCoreSdkVersion);
var workloadResolver = WorkloadResolver.Create(workloadManifestProvider, NetCoreRoot, NETCoreSdkVersion);
var suggestedWorkloads = workloadResolver.GetWorkloadSuggestionForMissingPacks(MissingWorkloadPacks.Select(item => item.ItemSpec).ToList());
if (GenerateErrorsForMissingWorkloads)
{
var suggestedInstallCommand = "dotnet workload install " + string.Join(" ", suggestedWorkloads.Select(w => w.Id));
var errorMessage = string.Format(CultureInfo.CurrentCulture,
Strings.WorkloadNotInstalled, string.Join(" ", suggestedWorkloads.Select(w => w.Id)), suggestedInstallCommand);
Log.LogError(errorMessage);
}
SuggestedWorkloads = suggestedWorkloads.Select(suggestedWorkload =>
{
var taskItem = new TaskItem(suggestedWorkload.Id);
taskItem.SetMetadata("VisualStudioComponentId", ToSafeId(suggestedWorkload.Id));
return(taskItem);
}).ToArray();
}
}
public WorkloadUpdateCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
IInstaller workloadInstaller = null,
INuGetPackageDownloader nugetPackageDownloader = null,
IWorkloadManifestUpdater workloadManifestUpdater = null,
string dotnetDir = null,
string userHome = null,
string version = null)
: base(parseResult)
{
_printDownloadLinkOnly =
parseResult.ValueForOption <bool>(WorkloadInstallCommandParser.PrintDownloadLinkOnlyOption);
_fromCacheOption = parseResult.ValueForOption <string>(WorkloadInstallCommandParser.FromCacheOption);
_reporter = reporter ?? Reporter.Output;
_includePreviews = parseResult.ValueForOption <bool>(WorkloadUpdateCommandParser.IncludePreviewsOption);
_verbosity = parseResult.ValueForOption <VerbosityOptions>(WorkloadUpdateCommandParser.VerbosityOption);
_sdkVersion = new ReleaseVersion(version ??
(string.IsNullOrWhiteSpace(parseResult.ValueForOption <string>(WorkloadUpdateCommandParser.SdkVersionOption)) ?
Product.Version : parseResult.ValueForOption <string>(WorkloadUpdateCommandParser.SdkVersionOption)));
var dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
_workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, _sdkVersion.ToString());
_workloadResolver = workloadResolver ?? WorkloadResolver.Create(_workloadManifestProvider, dotnetPath, _sdkVersion.ToString());
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
_workloadInstaller = workloadInstaller ?? WorkloadInstallerFactory.GetWorkloadInstaller(_reporter, sdkFeatureBand, _workloadResolver, _verbosity, nugetPackageDownloader, dotnetDir);
userHome = userHome ?? CliFolderPathCalculator.DotnetHomePath;
var tempPackagesDir = new DirectoryPath(Path.Combine(userHome, ".dotnet", "sdk-advertising-temp"));
_nugetPackageDownloader = nugetPackageDownloader ?? new NuGetPackageDownloader(tempPackagesDir, filePermissionSetter: null, new NullLogger());
_workloadManifestUpdater = workloadManifestUpdater ?? new WorkloadManifestUpdater(_reporter, _workloadManifestProvider, _nugetPackageDownloader, userHome);
}
public void ItShouldGetWorkloadDescription()
{
WorkloadResolver workloadResolver = SetUp();
var result = workloadResolver.GetWorkloadInfo(new WorkloadId("xamarin-android"));
result.Description.Should().Be("Create, build and run Android apps");
}
public void GetExtendedWorkloads_SampleDeduplicatedClosureExpected()
{
var manifestPath = Path.Combine(_testAssetsManager.GetAndValidateTestProjectDirectory("SampleManifest"), "Sample.json");
var workloadResolver = WorkloadResolver.CreateForTests(new FakeManifestProvider(manifestPath), fakeRootPath);
var resultWorkloads = workloadResolver.GetExtendedWorkloads(new List <WorkloadId>()
{
new WorkloadId("xamarin-android-build-x86"),
new WorkloadId("xamarin-empty-mock"),
new WorkloadId("xamarin-android"),
}).ToList();
List <WorkloadResolver.WorkloadInfo> expected = new()
{
new(new WorkloadId("xamarin-android-build-x86"), null),
new(new WorkloadId("xamarin-android-build"), "Build and run Android apps"),
new(new WorkloadId("xamarin-empty-mock"), "Empty mock workload for testing"),
new(new WorkloadId("xamarin-android"), "Create, build and run Android apps"),
new(new WorkloadId("xamarin-android-build-armv7a"), null),
};
resultWorkloads.Should().Equal(expected,
(w1, w2) => w1.Id.Equals(w2.Id) && string.Equals(w1.Description, w2.Description),
"WorkloadResolver should return expected workload infos based on manifest");
}
public async static Task BackgroundUpdateAdvertisingManifestsAsync()
{
try
{
var reporter = new NullReporter();
var dotnetPath = Path.GetDirectoryName(Environment.ProcessPath);
var sdkVersion = Product.Version;
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, sdkVersion);
var workloadResolver = WorkloadResolver.Create(workloadManifestProvider, dotnetPath, sdkVersion);
var tempPackagesDir = new DirectoryPath(Path.Combine(Path.GetTempPath(), "dotnet-sdk-advertising-temp"));
var nugetPackageDownloader = new NuGetPackageDownloader(tempPackagesDir,
filePermissionSetter: null,
new FirstPartyNuGetPackageSigningVerifier(tempPackagesDir, new NullLogger()),
new NullLogger(),
reporter);
var userHome = CliFolderPathCalculator.DotnetHomePath;
var manifestUpdater = new WorkloadManifestUpdater(reporter, workloadManifestProvider, workloadResolver, nugetPackageDownloader, userHome, tempPackagesDir.Value);
await manifestUpdater.BackgroundUpdateAdvertisingManifestsWhenRequiredAsync();
}
catch (Exception)
{
// Never surface messages on background updates
}
}
public WorkloadRepairCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
IInstaller workloadInstaller = null,
INuGetPackageDownloader nugetPackageDownloader = null,
string dotnetDir = null,
string tempDirPath = null,
string version = null,
string userProfileDir = null)
: base(parseResult, reporter: reporter, nugetPackageDownloader: nugetPackageDownloader)
{
_dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
userProfileDir ??= CliFolderPathCalculator.DotnetUserProfileFolderPath;
_sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(WorkloadRepairCommandParser.VersionOption), version, _dotnetPath, userProfileDir);
var configOption = parseResult.GetValueForOption(WorkloadRepairCommandParser.ConfigOption);
var sourceOption = parseResult.GetValueForOption(WorkloadRepairCommandParser.SourceOption);
_packageSourceLocation = string.IsNullOrEmpty(configOption) && (sourceOption == null || !sourceOption.Any()) ? null :
new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), sourceFeedOverrides: sourceOption);
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(_dotnetPath, _sdkVersion.ToString(), userProfileDir);
_workloadResolver = workloadResolver ?? WorkloadResolver.Create(workloadManifestProvider, _dotnetPath, _sdkVersion.ToString(), userProfileDir);
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
_workloadInstaller = workloadInstaller ??
WorkloadInstallerFactory.GetWorkloadInstaller(Reporter, sdkFeatureBand,
_workloadResolver, Verbosity, userProfileDir, VerifySignatures, PackageDownloader, dotnetDir, TempDirectoryPath,
_packageSourceLocation, _parseResult.ToRestoreActionConfig());
}
public WorkloadUninstallCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
INuGetPackageDownloader nugetPackageDownloader = null,
string dotnetDir = null,
string version = null,
string userProfileDir = null)
: base(parseResult, reporter: reporter, nugetPackageDownloader: nugetPackageDownloader)
{
_workloadIds = parseResult.GetValueForArgument(WorkloadUninstallCommandParser.WorkloadIdArgument)
.Select(workloadId => new WorkloadId(workloadId)).ToList().AsReadOnly();
var dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
userProfileDir = userProfileDir ?? CliFolderPathCalculator.DotnetUserProfileFolderPath;
_sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(WorkloadUninstallCommandParser.VersionOption), version, dotnetPath, userProfileDir);
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(dotnetPath, _sdkVersion.ToString(), userProfileDir);
workloadResolver ??= WorkloadResolver.Create(workloadManifestProvider, dotnetPath, _sdkVersion.ToString(), userProfileDir);
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
_workloadInstaller = WorkloadInstallerFactory.GetWorkloadInstaller(Reporter, sdkFeatureBand, workloadResolver, Verbosity, userProfileDir, VerifySignatures, PackageDownloader, dotnetPath);
}
void TestMultiplePackRoots(bool defaultExists, bool additionalExists)
{
var testDirectory = _testAssetsManager.CreateTestDirectory(identifier: defaultExists.ToString() + "_" + additionalExists.ToString()).Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
Directory.CreateDirectory(dotnetRoot);
var additionalRoot = Path.Combine(testDirectory, "additionalPackRoot");
Directory.CreateDirectory(additionalRoot);
var defaultPackPath = Path.Combine(dotnetRoot, "packs", "Xamarin.Android.Sdk", "8.4.7");
var additionalPackPath = Path.Combine(additionalRoot, "packs", "Xamarin.Android.Sdk", "8.4.7");
if (defaultExists)
{
Directory.CreateDirectory(defaultPackPath);
}
if (additionalExists)
{
Directory.CreateDirectory(additionalPackPath);
}
var manifestProvider = new FakeManifestProvider(Path.Combine("Manifests", "Sample.json"));
var resolver = WorkloadResolver.CreateForTests(manifestProvider, new[] { additionalRoot, dotnetRoot });
var pack = resolver.TryGetPackInfo("Xamarin.Android.Sdk");
pack.Should().NotBeNull();
string expectedPath = additionalExists ? additionalPackPath : defaultPackPath;
pack.Path.Should().Be(expectedPath);
}
private async Task DownloadToOfflineCacheAsync(DirectoryPath offlineCache, bool includePreviews)
{
var manifestPackagePaths = await _workloadManifestUpdater.DownloadManifestPackagesAsync(includePreviews, offlineCache);
var tempManifestDir = Path.Combine(offlineCache.Value, "temp-manifests");
try
{
await _workloadManifestUpdater.ExtractManifestPackagesToTempDirAsync(manifestPackagePaths, new DirectoryPath(tempManifestDir));
var overlayManifestProvider = new TempDirectoryWorkloadManifestProvider(tempManifestDir, _sdkVersion.ToString());
_workloadResolver = WorkloadResolver.Create(overlayManifestProvider, _dotnetPath, _sdkVersion.ToString(), _userProfileDir);
if (_workloadInstaller.GetInstallationUnit().Equals(InstallationUnit.Packs))
{
var installer = _workloadInstaller.GetPackInstaller();
var packsToUpdate = GetUpdatablePacks(installer);
foreach (var pack in packsToUpdate)
{
installer.DownloadToOfflineCache(pack, new DirectoryPath(_downloadToCacheOption), _includePreviews);
}
}
else
{
throw new NotImplementedException();
}
}
finally
{
if (!string.IsNullOrWhiteSpace(tempManifestDir) && Directory.Exists(tempManifestDir))
{
Directory.Delete(tempManifestDir, true);
}
}
}
public WorkloadInstallCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
IInstaller workloadInstaller = null,
INuGetPackageDownloader nugetPackageDownloader = null,
IWorkloadManifestUpdater workloadManifestUpdater = null,
string dotnetDir = null,
string userHome = null,
string tempDirPath = null,
string version = null,
IReadOnlyCollection <string> workloadIds = null)
: base(parseResult)
{
_reporter = reporter ?? Reporter.Output;
_skipManifestUpdate = parseResult.ValueForOption <bool>(WorkloadInstallCommandParser.SkipManifestUpdateOption);
_includePreviews = parseResult.ValueForOption <bool>(WorkloadInstallCommandParser.IncludePreviewOption);
_printDownloadLinkOnly = parseResult.ValueForOption <bool>(WorkloadInstallCommandParser.PrintDownloadLinkOnlyOption);
_fromCacheOption = parseResult.ValueForOption <string>(WorkloadInstallCommandParser.FromCacheOption);
_downloadToCacheOption = parseResult.ValueForOption <string>(WorkloadInstallCommandParser.DownloadToCacheOption);
_workloadIds = workloadIds ?? parseResult.ValueForArgument <IEnumerable <string> >(WorkloadInstallCommandParser.WorkloadIdArgument).ToList().AsReadOnly();
_verbosity = parseResult.ValueForOption <VerbosityOptions>(WorkloadInstallCommandParser.VerbosityOption);
_dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
_sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.ValueForOption <string>(WorkloadInstallCommandParser.VersionOption), version, _dotnetPath);
_sdkFeatureBand = new SdkFeatureBand(string.Join('.', _sdkVersion.Major, _sdkVersion.Minor, _sdkVersion.SdkFeatureBand));
_tempDirPath = tempDirPath ?? (string.IsNullOrWhiteSpace(parseResult.ValueForOption <string>(WorkloadInstallCommandParser.TempDirOption)) ?
Path.GetTempPath() :
parseResult.ValueForOption <string>(WorkloadInstallCommandParser.TempDirOption));
var configOption = parseResult.ValueForOption <string>(WorkloadInstallCommandParser.ConfigOption);
var sourceOption = parseResult.ValueForOption <string[]>(WorkloadInstallCommandParser.SourceOption);
_packageSourceLocation = string.IsNullOrEmpty(configOption) && (sourceOption == null || !sourceOption.Any()) ? null :
new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), sourceFeedOverrides: sourceOption);
var sdkWorkloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(_dotnetPath, _sdkVersion.ToString());
_workloadResolver = workloadResolver ?? WorkloadResolver.Create(sdkWorkloadManifestProvider, _dotnetPath, _sdkVersion.ToString());
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
var tempPackagesDir = new DirectoryPath(Path.Combine(_tempDirPath, "dotnet-sdk-advertising-temp"));
var restoreActionConfig = _parseResult.ToRestoreActionConfig();
_nugetPackageDownloader = nugetPackageDownloader ??
new NuGetPackageDownloader(tempPackagesDir,
filePermissionSetter: null,
new FirstPartyNuGetPackageSigningVerifier(tempPackagesDir, _verbosity.VerbosityIsDetailedOrDiagnostic() ? new NuGetConsoleLogger() : new NullLogger()),
_verbosity.VerbosityIsDetailedOrDiagnostic() ? new NuGetConsoleLogger() : new NullLogger(), restoreActionConfig: restoreActionConfig);
_workloadInstaller = workloadInstaller ??
WorkloadInstallerFactory.GetWorkloadInstaller(_reporter, sdkFeatureBand,
_workloadResolver, _verbosity, _nugetPackageDownloader, _dotnetPath, _tempDirPath,
_packageSourceLocation, restoreActionConfig, elevationRequired: !_printDownloadLinkOnly && string.IsNullOrWhiteSpace(_downloadToCacheOption));
_userHome = userHome ?? CliFolderPathCalculator.DotnetHomePath;
_workloadManifestUpdater = workloadManifestUpdater ?? new WorkloadManifestUpdater(_reporter, _workloadResolver, _nugetPackageDownloader, _userHome, _tempDirPath,
_workloadInstaller.GetWorkloadInstallationRecordRepository(), _packageSourceLocation);
ValidateWorkloadIdsInput();
}
public void GetExtendedWorkloads_EmptyInputYieldsEmptyOutput()
{
var manifestPath = Path.Combine(_testAssetsManager.GetAndValidateTestProjectDirectory("SampleManifest"), "Sample.json");
var workloadResolver = WorkloadResolver.CreateForTests(new FakeManifestProvider(manifestPath), fakeRootPath);
var resultWorkloads = workloadResolver.GetExtendedWorkloads(Enumerable.Empty <WorkloadId>()).ToList();
resultWorkloads.Should().BeEmpty();
}
private WorkloadResolver SetUp()
{
var workloadResolver =
WorkloadResolver.CreateForTests(new FakeManifestProvider(new[] { ManifestPath }),
new[] { "fakepath" });
workloadResolver.ReplaceFilesystemChecksForTest(fileExists: (_) => true, directoryExists: (_) => true);
return(workloadResolver);
}
public DotNetWorkloadManager(string sdkRoot, string sdkVersion, params string[] nugetPackageSources)
{
SdkRoot = sdkRoot;
SdkVersion = sdkVersion;
NuGetPackageSources = nugetPackageSources;
manifestProvider = new SdkDirectoryWorkloadManifestProvider(SdkRoot, SdkVersion);
workloadResolver = WorkloadResolver.Create(manifestProvider, SdkRoot, SdkVersion);
}
private static WorkloadResolver SetUp()
{
var workloadResolver =
WorkloadResolver.CreateForTests(new FakeManifestProvider(new[] { Path.Combine("Manifests", "Sample.json") }),
"fakepath", ManifestTests.TEST_RUNTIME_IDENTIFIER_CHAIN);
workloadResolver.ReplaceFilesystemChecksForTest(fileExists: (_) => true, directoryExists: (_) => true);
return(workloadResolver);
}
public void GivenWorkloadUpdateAcrossFeatureBandsItUpdatesPacks(bool userLocal)
{
var testDirectory = _testAssetsManager.CreateTestDirectory(identifier: userLocal ? "userlocal" : "default").Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var userProfileDir = Path.Combine(testDirectory, "user-profile");
var manifestPath = Path.Combine(_testAssetsManager.GetAndValidateTestProjectDirectory("SampleManifest"), "BasicSample.json");
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { manifestPath }), dotnetRoot, userLocal, userProfileDir);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var manifestUpdater = new MockWorkloadManifestUpdater();
var sdkFeatureVersion = "6.0.100";
var installingWorkload = "simple-workload";
string installRoot = userLocal ? userProfileDir : dotnetRoot;
if (userLocal)
{
WorkloadFileBasedInstall.SetUserLocal(dotnetRoot, sdkFeatureVersion);
}
var workloadPacks = new List <PackInfo>()
{
CreatePackInfo("mock-pack-1", "1.0.0", WorkloadPackKind.Framework, Path.Combine(installRoot, "packs", "mock-pack-1", "1.0.0"), "mock-pack-1"),
CreatePackInfo("mock-pack-2", "2.0.0", WorkloadPackKind.Framework, Path.Combine(installRoot, "packs", "mock-pack-2", "2.0.0"), "mock-pack-2")
};
// Lay out workload installs for a previous feature band
var oldFeatureBand = "5.0.100";
var packRecordDir = Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1");
foreach (var pack in workloadPacks)
{
Directory.CreateDirectory(Path.Combine(packRecordDir, pack.Id, pack.Version));
File.Create(Path.Combine(packRecordDir, pack.Id, pack.Version, oldFeatureBand));
}
Directory.CreateDirectory(Path.Combine(installRoot, "metadata", "workloads", oldFeatureBand, "InstalledWorkloads"));
Directory.CreateDirectory(Path.Combine(installRoot, "metadata", "workloads", sdkFeatureVersion, "InstalledWorkloads"));
File.Create(Path.Combine(installRoot, "metadata", "workloads", oldFeatureBand, "InstalledWorkloads", installingWorkload));
File.Create(Path.Combine(installRoot, "metadata", "workloads", sdkFeatureVersion, "InstalledWorkloads", installingWorkload));
// Update workload (without installing any workloads to this feature band)
var updateParseResult = Parser.Instance.Parse(new string[] { "dotnet", "workload", "update", "--from-previous-sdk" });
var updateCommand = new WorkloadUpdateCommand(updateParseResult, reporter: _reporter, workloadResolver: workloadResolver, nugetPackageDownloader: nugetDownloader,
workloadManifestUpdater: manifestUpdater, userProfileDir: userProfileDir, version: sdkFeatureVersion, dotnetDir: dotnetRoot, tempDirPath: testDirectory);
updateCommand.Execute();
foreach (var pack in workloadPacks)
{
Directory.Exists(pack.Path).Should().BeTrue(because: $"Pack should be installed {testDirectory}");
File.Exists(Path.Combine(packRecordDir, pack.Id, pack.Version, oldFeatureBand))
.Should().BeTrue(because: "Pack install record should still be present for old feature band");
}
File.Exists(Path.Combine(installRoot, "metadata", "workloads", oldFeatureBand, "InstalledWorkloads", installingWorkload))
.Should().BeTrue(because: "Workload install record should still be present for old feature band");
File.Exists(Path.Combine(installRoot, "metadata", "workloads", sdkFeatureVersion, "InstalledWorkloads", installingWorkload))
.Should().BeTrue(because: "Workload install record should be present for current feature band");
}
private static WorkloadResolver SetUp()
{
var workloadResolver =
new WorkloadResolver(new FakeManifestProvider(new[] { Path.Combine("Manifests", "Sample.json") }),
"fakepath");
workloadResolver.ReplaceFilesystemChecksForTest(fileExists: (_) => true, directoryExists: (_) => true);
return(workloadResolver);
}
private (string, NetSdkManagedInstaller, INuGetPackageDownloader) GetTestInstaller([CallerMemberName] string testName = "", bool failingInstaller = false, string identifier = "", bool manifestDownload = false)
{
var testDirectory = _testAssetsManager.CreateTestDirectory(testName, identifier: identifier).Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
INuGetPackageDownloader nugetInstaller = failingInstaller ? new FailingNuGetPackageDownloader(testDirectory) : new MockNuGetPackageDownloader(dotnetRoot, manifestDownload);
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), new string[] { dotnetRoot });
var sdkFeatureBand = new SdkFeatureBand("6.0.100");
return(dotnetRoot, new NetSdkManagedInstaller(_reporter, sdkFeatureBand, workloadResolver, nugetInstaller, dotnetRoot), nugetInstaller);
}
private void UninstallWorkload(string uninstallingWorkload, string testDirectory, string sdkFeatureVersion)
{
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), new string[] { dotnetRoot });
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var uninstallParseResult = Parser.GetWorkloadsInstance.Parse(new string[] { "dotnet", "workload", "uninstall", uninstallingWorkload });
var uninstallCommand = new WorkloadUninstallCommand(uninstallParseResult, reporter: _reporter, workloadResolver, nugetDownloader, dotnetDir: dotnetRoot, version: sdkFeatureVersion);
uninstallCommand.Execute();
}
public void TestGetManifestFeatureBands()
{
var manifestProvider = CreateManifestProvider();
var workloadResolver = WorkloadResolver.CreateForTests(manifestProvider, TestContext.Current.ToolsetUnderTest.DotNetRoot);
foreach (var manifestInfo in workloadResolver.GetInstalledManifests())
{
Log.WriteLine(manifestInfo.Id + ": " + manifestInfo.ManifestFeatureBand);
}
}
private async Task UseTempManifestsToResolvePacksAsync(DirectoryPath tempPath, bool includePreview)
{
var manifestPackagePaths = await _workloadManifestUpdater.DownloadManifestPackagesAsync(includePreview, tempPath);
await _workloadManifestUpdater.ExtractManifestPackagesToTempDirAsync(manifestPackagePaths, tempPath);
var overlayManifestProvider = new TempDirectoryWorkloadManifestProvider(tempPath.Value, _sdkVersion.ToString());
_workloadResolver = WorkloadResolver.Create(overlayManifestProvider, _dotnetPath, _sdkVersion.ToString(), _userProfileDir);
}
public WorkloadUpdateCommand(
ParseResult parseResult,
IReporter reporter = null,
IWorkloadResolver workloadResolver = null,
IInstaller workloadInstaller = null,
INuGetPackageDownloader nugetPackageDownloader = null,
IWorkloadManifestUpdater workloadManifestUpdater = null,
string dotnetDir = null,
string userProfileDir = null,
string tempDirPath = null,
string version = null)
: base(parseResult)
{
_printDownloadLinkOnly =
parseResult.GetValueForOption(WorkloadUpdateCommandParser.PrintDownloadLinkOnlyOption);
_fromCacheOption = parseResult.GetValueForOption(WorkloadUpdateCommandParser.FromCacheOption);
_reporter = reporter ?? Reporter.Output;
_includePreviews = parseResult.GetValueForOption(WorkloadUpdateCommandParser.IncludePreviewsOption);
_fromPreviousSdk = parseResult.GetValueForOption(WorkloadUpdateCommandParser.FromPreviousSdkOption);
_adManifestOnlyOption = parseResult.GetValueForOption(WorkloadUpdateCommandParser.AdManifestOnlyOption);
_downloadToCacheOption = parseResult.GetValueForOption(WorkloadUpdateCommandParser.DownloadToCacheOption);
_verbosity = parseResult.GetValueForOption(WorkloadUpdateCommandParser.VerbosityOption);
_dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
_userProfileDir = userProfileDir ?? CliFolderPathCalculator.DotnetUserProfileFolderPath;
_sdkVersion = WorkloadOptionsExtensions.GetValidatedSdkVersion(parseResult.GetValueForOption(WorkloadUpdateCommandParser.VersionOption), version, _dotnetPath, _userProfileDir);
_tempDirPath = tempDirPath ?? (string.IsNullOrWhiteSpace(parseResult.GetValueForOption(WorkloadUpdateCommandParser.TempDirOption)) ?
Path.GetTempPath() :
parseResult.GetValueForOption(WorkloadUpdateCommandParser.TempDirOption));
_printRollbackDefinitionOnly = parseResult.GetValueForOption(WorkloadUpdateCommandParser.PrintRollbackOption);
_fromRollbackDefinition = parseResult.GetValueForOption(WorkloadUpdateCommandParser.FromRollbackFileOption);
var configOption = parseResult.GetValueForOption(WorkloadUpdateCommandParser.ConfigOption);
var sourceOption = parseResult.GetValueForOption <string[]>(WorkloadUpdateCommandParser.SourceOption);
_packageSourceLocation = string.IsNullOrEmpty(configOption) && (sourceOption == null || !sourceOption.Any()) ? null :
new PackageSourceLocation(string.IsNullOrEmpty(configOption) ? null : new FilePath(configOption), sourceFeedOverrides: sourceOption);
var workloadManifestProvider = new SdkDirectoryWorkloadManifestProvider(_dotnetPath, _sdkVersion.ToString(), _userProfileDir);
_workloadResolver = workloadResolver ?? WorkloadResolver.Create(workloadManifestProvider, _dotnetPath, _sdkVersion.ToString(), _userProfileDir);
var sdkFeatureBand = new SdkFeatureBand(_sdkVersion);
var restoreActionConfig = _parseResult.ToRestoreActionConfig();
_workloadInstaller = workloadInstaller ?? WorkloadInstallerFactory.GetWorkloadInstaller(_reporter,
sdkFeatureBand, _workloadResolver, _verbosity, _userProfileDir, nugetPackageDownloader,
dotnetDir, _tempDirPath, packageSourceLocation: _packageSourceLocation, restoreActionConfig,
elevationRequired: !_printDownloadLinkOnly && string.IsNullOrWhiteSpace(_downloadToCacheOption));
var tempPackagesDir = new DirectoryPath(Path.Combine(_tempDirPath, "dotnet-sdk-advertising-temp"));
_nugetPackageDownloader = nugetPackageDownloader ?? new NuGetPackageDownloader(tempPackagesDir,
filePermissionSetter: null, new FirstPartyNuGetPackageSigningVerifier(tempPackagesDir, _verbosity.VerbosityIsDetailedOrDiagnostic() ? new NuGetConsoleLogger() : new NullLogger()),
_verbosity.VerbosityIsDetailedOrDiagnostic() ? new NuGetConsoleLogger() : new NullLogger(), restoreActionConfig: restoreActionConfig);
_workloadManifestUpdater = workloadManifestUpdater ?? new WorkloadManifestUpdater(_reporter, _workloadResolver, _nugetPackageDownloader, _userProfileDir, _tempDirPath,
_workloadInstaller.GetWorkloadInstallationRecordRepository(), _packageSourceLocation);
}
public void UnresolvedAliasedPackPath()
{
var manifestProvider = new FakeManifestProvider(ManifestPath);
var resolver = WorkloadResolver.CreateForTests(manifestProvider, fakeRootPath, currentRuntimeIdentifiers: new[] { "fake-platform" });
resolver.ReplaceFilesystemChecksForTest(_ => true, _ => true);
var buildToolsPack = resolver.GetInstalledWorkloadPacksOfKind(WorkloadPackKind.Sdk).FirstOrDefault(pack => pack.Id == "Xamarin.Android.BuildTools");
buildToolsPack.Should().BeNull();
}
public void GivenWorkloadSDKsDirectoryNotExistOnDiskItShouldReturnEmpty()
{
var workloadResolver =
new WorkloadResolver(new FakeManifestProvider(new[] { Path.Combine("Manifests", "Sample.json") }),
"fakepath");
workloadResolver.ReplaceFilesystemChecksForTest(fileExists: (_) => true, directoryExists: (_) => false);
var result = workloadResolver.GetInstalledWorkloadPacksOfKind(WorkloadPackKind.Sdk);
result.Should().HaveCount(0);
}
public WorkloadListCommand(
ParseResult result,
IReporter reporter = null,
IWorkloadInstallationRecordRepository workloadRecordRepo = null,
string currentSdkVersion = null,
string dotnetDir = null,
string userProfileDir = null,
string tempDirPath = null,
INuGetPackageDownloader nugetPackageDownloader = null,
IWorkloadManifestUpdater workloadManifestUpdater = null,
IWorkloadResolver workloadResolver = null
) : base(result)
{
_reporter = reporter ?? Reporter.Output;
_machineReadableOption = result.GetValueForOption(WorkloadListCommandParser.MachineReadableOption);
_verbosity = result.GetValueForOption(WorkloadListCommandParser.VerbosityOption);
_dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
ReleaseVersion currentSdkReleaseVersion = new(currentSdkVersion ?? Product.Version);
_currentSdkFeatureBand = new SdkFeatureBand(currentSdkReleaseVersion);
_includePreviews = result.GetValueForOption(WorkloadListCommandParser.IncludePreviewsOption);
_tempDirPath = tempDirPath ??
(string.IsNullOrWhiteSpace(
result.GetValueForOption(WorkloadListCommandParser.TempDirOption))
? Path.GetTempPath()
: result.GetValueForOption(WorkloadListCommandParser.TempDirOption));
_targetSdkVersion = result.GetValueForOption(WorkloadListCommandParser.VersionOption);
_userProfileDir = userProfileDir ?? CliFolderPathCalculator.DotnetUserProfileFolderPath;
var workloadManifestProvider =
new SdkDirectoryWorkloadManifestProvider(_dotnetPath,
string.IsNullOrWhiteSpace(_targetSdkVersion)
? currentSdkReleaseVersion.ToString()
: _targetSdkVersion,
_userProfileDir);
DirectoryPath tempPackagesDir =
new(Path.Combine(_userProfileDir, "sdk-advertising-temp"));
NullLogger nullLogger = new NullLogger();
_nugetPackageDownloader = nugetPackageDownloader ??
new NuGetPackageDownloader(tempPackagesDir, null,
new FirstPartyNuGetPackageSigningVerifier(tempPackagesDir, nullLogger),
verboseLogger: nullLogger,
restoreActionConfig: _parseResult.ToRestoreActionConfig());
workloadResolver ??= WorkloadResolver.Create(workloadManifestProvider, _dotnetPath, currentSdkReleaseVersion.ToString(), _userProfileDir);
_workloadRecordRepo = workloadRecordRepo ??
WorkloadInstallerFactory.GetWorkloadInstaller(reporter, _currentSdkFeatureBand, workloadResolver, _verbosity, _userProfileDir,
elevationRequired: false).GetWorkloadInstallationRecordRepository();
_workloadManifestUpdater = workloadManifestUpdater ?? new WorkloadManifestUpdater(_reporter,
workloadResolver, _nugetPackageDownloader, _userProfileDir, _tempDirPath, _workloadRecordRepo);
}
public void GivenWorkloadSDKsDirectoryNotExistOnDiskItShouldReturnEmpty()
{
var workloadResolver =
WorkloadResolver.CreateForTests(new FakeManifestProvider(new[] { ManifestPath }),
new[] { "fakepath" });
workloadResolver.ReplaceFilesystemChecksForTest(fileExists: (_) => true, directoryExists: (_) => false);
var result = workloadResolver.GetInstalledWorkloadPacksOfKind(WorkloadPackKind.Sdk);
result.Should().HaveCount(0);
}
public void GivenTemplateNupkgDoesNotExistOnDiskItShouldReturnEmpty()
{
var workloadResolver =
WorkloadResolver.CreateForTests(new FakeManifestProvider(new[] { Path.Combine("Manifests", "Sample.json") }),
"fakepath", ManifestTests.TEST_RUNTIME_IDENTIFIER_CHAIN);
workloadResolver.ReplaceFilesystemChecksForTest(fileExists: (_) => false, directoryExists: (_) => true);
var result = workloadResolver.GetInstalledWorkloadPacksOfKind(WorkloadPackKind.Template);
result.Should().HaveCount(0);
}
private void InitializeWorkloadResolver(SdkResolverContext context)
{
var dotnetRootPath = GetDotNetRoot(context);
var sdkDirectory = GetSdkDirectory(context);
// The SDK version is the name of the SDK directory (ie dotnet\sdk\5.0.100)
var sdkVersion = Path.GetFileName(sdkDirectory);
_workloadManifestProvider ??= new SdkDirectoryWorkloadManifestProvider(dotnetRootPath, sdkVersion);
_workloadResolver ??= WorkloadResolver.Create(_workloadManifestProvider, dotnetRootPath, sdkVersion);
}
