public override IEnumerable <Checkup> Contribute(Manifest.Manifest manifest, SharedState sharedState)
{
var sdks = manifest?.Check?.DotNet?.Sdks;
if (sdks?.Any() ?? false)
{
foreach (var sdk in sdks)
{
var workloads = sdk?.Workloads?.ToArray() ?? Array.Empty <DotNetWorkload>();
var packs = sdk?.Packs?.ToArray() ?? Array.Empty <DotNetSdkPack>();
var pkgSrcs = sdk?.PackageSources?.ToArray() ?? Array.Empty <string>();
string sdkVersion;
if (!sharedState.TryGetEnvironmentVariable("DOTNET_SDK_VERSION", out sdkVersion))
{
sdkVersion = sdk.Version;
}
if (sdk.Workloads?.Any() ?? false)
{
yield return(new DotNetWorkloadsCheckup(sharedState, sdkVersion, workloads, pkgSrcs));
}
// Always generate a packs check even if no packs, since the workloads may dynamically
// discover packs required and register them with the SharedState
yield return(new DotNetPacksCheckup(sharedState, sdkVersion, packs, pkgSrcs));
}
}
}
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 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 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);
string sdkRoot = default;
if (sharedState != null && sharedState.TryGetEnvironmentVariable("DOTNET_ROOT", out var envSdkRoot))
{
if (Directory.Exists(envSdkRoot))
{
sdkRoot = envSdkRoot;
}
}
if (string.IsNullOrEmpty(sdkRoot))
{
sdkRoot = Util.IsWindows
? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "dotnet")
: Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".dotnet");
}
var scriptUrl = Util.IsWindows ? installScriptPwsh : installScriptBash;
var scriptPath = Path.Combine(Path.GetTempPath(), Util.IsWindows ? "dotnet-install.ps1" : "dotnet-install.sh");
Util.Log($"Downloading dotnet-install script: {scriptUrl}");
var http = new HttpClient();
var data = await http.GetStringAsync(scriptUrl);
File.WriteAllText(scriptPath, data);
var exe = Util.IsWindows ? "powershell" : "sh";
var args = Util.IsWindows
? $"{scriptPath} -InstallDir {sdkRoot} -Version {Version}"
: $"{scriptPath} --install-dir {sdkRoot} --version {Version}";
Util.Log($"Executing dotnet-install script...");
Util.Log($"\t{exe} {args}");
// Launch the process
var p = new ShellProcessRunner(new ShellProcessRunnerOptions(exe, args));
p.WaitForExit();
}
public override Task <DiagnosticResult> Examine(SharedState history)
{
var dotnet = new DotNetSdk(history);
var sdkRoot = dotnet.DotNetSdkLocation.FullName;
if (history.TryGetEnvironmentVariable("DOTNET_SDK_VERSION", out var sdkVersion))
{
// HACK / WORKAROUND
// Workload manifest specs changed between p4/p5 and with that came manifest folder name changes
// The problem is we can be left with duplicate workload manifests but in different
// folder names and the resolver can't handle that.
// This will identify a block list of old workload folders and delete them if the dotnet version
// is -preview.5 or newer of the sdk and a different block list if -preview.4 or older
if (NuGetVersion.TryParse(sdkVersion, out var parsedSdkVersion))
{
DeleteBlockedWorkloads(
sdkRoot,
$"{parsedSdkVersion.Major}.{parsedSdkVersion.Minor}.{parsedSdkVersion.Patch}",
parsedSdkVersion >= new NuGetVersion("6.0.100-preview.5")
? new[] {
"Microsoft.NET.Workload.Android",
"Microsoft.NET.Workload.BlazorWebAssembly",
"Microsoft.NET.Workload.iOS",
"Microsoft.NET.Workload.MacCatalyst",
"Microsoft.NET.Workload.macOS",
"Microsoft.NET.Workload.tvOS"
}
: new[] {
"Microsoft.NET.Sdk.Android",
"Microsoft.NET.Sdk.iOS",
"Microsoft.NET.Sdk.MacCatalyst",
"Microsoft.NET.Sdk.macOS",
"Microsoft.NET.Sdk.tvOS",
"Microsoft.NET.Workload.Mono.ToolChain"
});
}
}
return(Task.FromResult(DiagnosticResult.Ok(this)));
}
public override IEnumerable <Checkup> Contribute(Manifest.Manifest manifest, SharedState sharedState)
{
var sdks = manifest?.Check?.DotNet?.Sdks;
if (sdks?.Any() ?? false)
{
foreach (var sdk in sdks)
{
var workloads = sdk?.Workloads?.ToArray() ?? Array.Empty <DotNetWorkload>();
var pkgSrcs = sdk?.PackageSources?.ToArray() ?? Array.Empty <string>();
string sdkVersion;
if (!sharedState.TryGetEnvironmentVariable("DOTNET_SDK_VERSION", out sdkVersion))
{
sdkVersion = sdk.Version;
}
if (sdk.Workloads?.Any() ?? false)
{
yield return(new DotNetWorkloadsCheckup(sharedState, sdkVersion, workloads, pkgSrcs));
}
}
}
}
public DotNetSdk(SharedState sharedState)
{
KnownDotnetLocations = Util.Platform switch
{
Platform.Windows => new string[]
{
Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86),
"dotnet",
DotNetExeName),
Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles),
"dotnet",
DotNetExeName),
},
Platform.OSX => new string[]
{
"/usr/local/share/dotnet/dotnet",
},
Platform.Linux => new string[]
{
// /home/user/share/dotnet/dotnet
Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
"share",
"dotnet",
DotNetExeName)
},
_ => new string[] { }
};
string sdkRoot = null;
if (sharedState != null && sharedState.TryGetEnvironmentVariable("DOTNET_ROOT", out var envSdkRoot))
{
if (Directory.Exists(envSdkRoot))
{
sdkRoot = envSdkRoot;
}
}
if (string.IsNullOrEmpty(sdkRoot) || !Directory.Exists(sdkRoot))
{
sdkRoot = Microsoft.DotNet.NativeWrapper.EnvironmentProvider.GetDotnetExeDirectory();
}
if (string.IsNullOrEmpty(sdkRoot) || !Directory.Exists(sdkRoot))
{
var l = FindDotNetLocations();
if (l != default)
{
sdkRoot = l.sdkDir.FullName;
}
}
sharedState.SetEnvironmentVariable("DOTNET_ROOT", sdkRoot);
// First try and use the actual resolver logic
DotNetSdkLocation = new DirectoryInfo(sdkRoot);
DotNetExeLocation = new FileInfo(Path.Combine(DotNetSdkLocation.FullName, DotNetExeName));
}
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()))));
}