public override Task <DiagnosticResult> Examine(SharedState history)
{
if (!history.TryGetEnvironmentVariable("DOTNET_SDK_VERSION", out var sdkVersion))
{
sdkVersion = SdkVersion;
}
var workloadManager = new DotNetWorkloadManager(SdkRoot, sdkVersion, NuGetPackageSources);
//var installedWorkloads = workloadManager.GetInstalledWorkloads();
// This is a bit of a hack where we manually check the sdk-manifests/{SDK_VERSION}/* folders
// for installed workloads, and then go manually parse the manifest json
// as well as look for a .nuspec file from the extracted nupkg when it was installed
// the nuspec file contains the version we actually care about for now since the manifest json
// has a long number which is meaningless right now and will eventually be changed to a string
// when that happens we can use the actual resolver's method to get installed workload info
var installedPackageWorkloads = workloadManager.GetInstalledWorkloads();
var missingWorkloads = new List <Manifest.DotNetWorkload>();
foreach (var rp in RequiredWorkloads)
{
if (!NuGetVersion.TryParse(rp.Version, out var rpVersion))
{
rpVersion = new NuGetVersion(0, 0, 0);
}
// TODO: Eventually check actual workload resolver api for installed workloads and
// compare the manifest version once it has a string in it
if (!installedPackageWorkloads.Any(ip => ip.id.Equals(rp.Id, StringComparison.OrdinalIgnoreCase) && NuGetVersion.TryParse(ip.version, out var ipVersion) && ipVersion == rpVersion))
{
ReportStatus($"{rp.Id} ({rp.PackageId} : {rp.Version}) not installed.", Status.Error);
missingWorkloads.Add(rp);
}
public DotNetPacksCheckup(string sdkVersion, Manifest.NuGetPackage[] requiredPacks, params string[] nugetPackageSources) : base()
{
SdkVersion = sdkVersion;
RequiredPacks = requiredPacks;
NuGetPackageSources = nugetPackageSources;
dotnet = new DotNet();
SdkRoot = dotnet.DotNetSdkLocation.FullName;
workloadManager = new DotNetWorkloadManager(SdkRoot, SdkVersion, NuGetPackageSources);
}
public override async Task Implement(SharedState sharedState, CancellationToken cancellationToken)
{
await base.Implement(sharedState, cancellationToken);
ReportStatus($"Installing Pack: {Package.Id}...");
var workloadManager = new DotNetWorkloadManager(SdkRoot, SdkVersion, NuGetPackageSources);
if (await workloadManager.InstallWorkloadPack(SdkRoot, Package, cancellationToken))
{
ReportStatus($"Installed Pack: {Package.Id}.");
}
else
{
ReportStatus($"Failed to install Pack: {Package.Id}.");
}
}
public override Task <DiagnosticResult> Examine(SharedState history)
{
string sdkVersion;
if (!history.TryGetEnvironmentVariable("DOTNET_SDK_VERSION", out sdkVersion))
{
sdkVersion = SdkVersion;
}
var workloadManager = new DotNetWorkloadManager(SdkRoot, sdkVersion, NuGetPackageSources);
var sdkPacks = workloadManager.GetAllInstalledWorkloadPacks();
var missingPacks = new List <Manifest.DotNetSdkPack>();
foreach (var rp in GetAllRequiredPacks(history))
{
Util.Log($"Looking for pack: {rp.Id} ({rp.Version})");
if (!sdkPacks.Any(sp => sp.Id == rp.Id && sp.Version == rp.Version) &&
!workloadManager.TemplateExistsOnDisk(rp.Id, rp.Version, rp.PackKind, rp.TemplateShortName) &&
!workloadManager.PackExistsOnDisk(rp.Id, rp.Version))
{
ReportStatus($"{rp.Id} ({rp.Version}) not installed.", Status.Warning);
missingPacks.Add(rp);
}
else
{
ReportStatus($"{rp.Id} ({rp.Version}) installed.", Status.Ok);
}
}
if (!missingPacks.Any())
{
return(Task.FromResult(DiagnosticResult.Ok(this)));
}
var remedies = missingPacks
.Select(ms => new DotNetPackInstallSolution(SdkRoot, sdkVersion, ms, NuGetPackageSources));
return(Task.FromResult(new DiagnosticResult(
Status.Error,
this,
new Suggestion("Install Missing SDK Packs",
remedies.ToArray()))));
}
public override async Task Implement(SharedState sharedState, CancellationToken cancellationToken)
{
await base.Implement(sharedState, cancellationToken);
ReportStatus($"Installing Workload: {Workload.Id}...");
var workloadManager = new DotNetWorkloadManager(SdkRoot, SdkVersion, NuGetPackageSources);
if (NuGetVersion.TryParse(Workload.Version, out var version))
{
// Manually download and install the manifest to get an explicit version of it to install
// we have to run `dotnet workload install <id> --skip-manifest-update` to make this happen
if (await workloadManager.InstallWorkloadManifest(Workload.PackageId, Workload.Id, version, cancellationToken))
{
// This runs the `dotnet workload install <id> --skip-manifest-update`
await workloadManager.CliInstall(Workload.Id);
// Find any template packs that the workload comes with
// we want to try and `dotnet new --uninstall` them
// Since if one was previously installed with `dotnet new -i` it will be chosen over the optional workload
// version and the user could get a message about a newer template being available to install
var templatePacks = workloadManager.GetPacksInWorkload(Workload.Id)?.Where(p => p.Kind == Microsoft.NET.Sdk.WorkloadManifestReader.WorkloadPackKind.Template);
if (templatePacks?.Any() ?? false)
{
ReportStatus("Uninstalling previous template versions...");
foreach (var tp in templatePacks)
{
try { await workloadManager.UninstallTemplate(tp.Id); }
catch { }
}
}
}
// Install: dotnet workload install id --
ReportStatus($"Installed Workload: {Workload.Id}.");
}
else
{
var msg = $"Failed to install workload: {Workload.Id}.";
ReportStatus(msg);
throw new System.Exception(msg);
}
}
public override async Task Implement(SharedState sharedState, CancellationToken cancellationToken)
{
await base.Implement(sharedState, cancellationToken);
ReportStatus($"Installing Workload: {Workload.Id}...");
var workloadManager = new DotNetWorkloadManager(SdkRoot, SdkVersion, NuGetPackageSources);
if (NuGetVersion.TryParse(Workload.Version, out var version) &&
await workloadManager.InstallWorkloadManifest(Workload.PackageId, version, cancellationToken))
{
ReportStatus($"Installed Workload: {Workload.Id}.");
}
else
{
ReportStatus($"Failed to install workload: {Workload.Id}.");
}
}
public override async Task <DiagnosticResult> Examine(SharedState history)
{
if (!history.TryGetEnvironmentVariable("DOTNET_SDK_VERSION", out var sdkVersion))
{
sdkVersion = SdkVersion;
}
var force = history.TryGetEnvironmentVariable("DOTNET_FORCE", out var forceDotNet) &&
(forceDotNet?.Equals("true", StringComparison.OrdinalIgnoreCase) ?? false) &&
!wasForceRunAlready;
// Don't allow multiple force runs, just the first
if (force)
{
wasForceRunAlready = true;
}
var workloadManager = new DotNetWorkloadManager(SdkRoot, sdkVersion, NuGetPackageSources);
var installedPackageWorkloads = workloadManager.GetInstalledWorkloads();
var missingWorkloads = new List <Manifest.DotNetWorkload>();
foreach (var rp in RequiredWorkloads)
{
if (!NuGetVersion.TryParse(rp.Version, out var rpVersion))
{
rpVersion = new NuGetVersion(0, 0, 0);
}
// TODO: Eventually check actual workload resolver api for installed workloads and
// compare the manifest version once it has a string in it
if (!installedPackageWorkloads.Any(ip => ip.id.Equals(rp.Id, StringComparison.OrdinalIgnoreCase) && NuGetVersion.TryParse(ip.version, out var ipVersion) && ipVersion == rpVersion))
{
ReportStatus($"{rp.Id} ({rp.PackageId} : {rp.Version}) not installed.", Status.Error);
missingWorkloads.Add(rp);
}
public DotNetWorkloadInstallRemedy(string sdkRoot, string sdkVersion, DotNetWorkload[] packages, params string[] nugetPackageSources)
{
Packages = packages;
WorkloadManager = new DotNetWorkloadManager(sdkRoot, sdkVersion, nugetPackageSources);
}
public override Task <DiagnosticResult> Examine(SharedState history)
{
string sdkVersion;
if (!history.TryGetEnvironmentVariable("DOTNET_SDK_VERSION", out sdkVersion))
{
sdkVersion = SdkVersion;
}
var workloadManager = new DotNetWorkloadManager(SdkRoot, sdkVersion, NuGetPackageSources);
var installedWorkloads = workloadManager.GetInstalledWorkloads();
var installedPackageWorkloads = workloadManager.GetInstalledWorkloadNuGetPackages();
var missingWorkloads = new List <Manifest.DotNetWorkload>();
var requiredPacks = new List <WorkloadResolver.PackInfo>();
foreach (var rp in RequiredWorkloads)
{
NuGetVersion rpVersion;
if (!NuGetVersion.TryParse(rp.Version, out rpVersion))
{
rpVersion = new NuGetVersion(0, 0, 0);
}
if (!installedPackageWorkloads.Any(sp => sp.packageId.Equals(rp.PackageId, StringComparison.OrdinalIgnoreCase) && sp.packageVersion == rpVersion) ||
!installedWorkloads.Any(sp => sp.id.Equals(rp.Id, StringComparison.OrdinalIgnoreCase)))
{
ReportStatus($"{rp.Id} ({rp.PackageId} : {rp.Version}) not installed.", Status.Error);
missingWorkloads.Add(rp);
}
else
{
ReportStatus($"{rp.Id} ({rp.PackageId} : {rp.Version}) installed.", Status.Ok);
var workloadPacks = workloadManager.GetPacksInWorkload(rp.Id);
if (workloadPacks != null && workloadPacks.Any())
{
foreach (var wp in workloadPacks)
{
if (!(rp.IgnoredPackIds?.Any(ip => ip.Equals(wp.Id, StringComparison.OrdinalIgnoreCase)) ?? false))
{
requiredPacks.Add(wp);
}
}
}
}
}
if (requiredPacks.Any())
{
history.ContributeState(this, "required_packs", requiredPacks.ToArray());
}
if (!missingWorkloads.Any())
{
return(Task.FromResult(DiagnosticResult.Ok(this)));
}
var remedies = missingWorkloads
.Select(mw => new DotNetWorkloadInstallSolution(SdkRoot, sdkVersion, mw, NuGetPackageSources));
return(Task.FromResult(new DiagnosticResult(
Status.Error,
this,
new Suggestion("Install Missing SDK Workloads",
remedies.ToArray()))));
}
