public override Task <Diagonosis> Examine(PatientHistory history)
{
var files = new List <string>();
var contributingCheckupIds = new[] { "dotnet", "visualstudio" };
foreach (var checkupId in contributingCheckupIds)
{
if (history.TryGetNotes <string[]>(checkupId, "sentinel_files", out var dotnetSentinelFiles) && (dotnetSentinelFiles?.Any() ?? false))
{
files.AddRange(dotnetSentinelFiles);
}
}
var missingFiles = new List <string>();
foreach (var file in files.Distinct())
{
// Check if exists
if (!File.Exists(file))
{
missingFiles.Add(file);
}
}
if (missingFiles.Any())
{
return(Task.FromResult(
new Diagonosis(Status.Error, this, new Prescription("Create EnableWorkloadResolver.sentinel files.",
missingFiles.Select(f => new CreateFileRemedy(f)).ToArray()))));
}
return(Task.FromResult(Diagonosis.Ok(this)));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var vsinfo = await GetMacInfo();
var ok = false;
foreach (var vs in vsinfo)
{
if (vs.Version.IsCompatible(MinimumVersion, ExactVersion))
{
ok = true;
ReportStatus($"Visual Studio for Mac ({vs.Version})", Status.Ok);
}
else
{
ReportStatus($"Visual Studio for Mac ({vs.Version})", null);
}
}
if (ok)
{
return(Diagonosis.Ok(this));
}
return(new Diagonosis(Status.Error, this));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var vsinfo = await GetWindowsInfo();
var sentinelFiles = new List <string>();
foreach (var vi in vsinfo)
{
if (vi.Version.IsCompatible(MinimumVersion, ExactVersion))
{
ReportStatus($"{vi.Version} - {vi.Path}", Status.Ok);
var sentinel = Path.Combine(vi.Path, "MSBuild\\Current\\Bin\\SdkResolvers\\Microsoft.DotNet.MSBuildSdkResolver\\EnableWorkloadResolver.sentinel");
sentinelFiles.Add(sentinel);
}
else
{
ReportStatus($"{vi.Version}", null);
}
}
if (sentinelFiles.Any())
{
history.AddNotes(this, "sentinel_files", sentinelFiles.ToArray());
}
if (vsinfo.Any(vs => vs.Version.IsCompatible(MinimumVersion, ExactVersion)))
{
return(Diagonosis.Ok(this));
}
return(new Diagonosis(Status.Error, this));
}
public override Task <Diagonosis> Examine(PatientHistory history)
{
var jdks = FindJdks();
var ok = false;
foreach (var jdk in jdks)
{
if ((jdk.JavaC.FullName.Contains("microsoft") || jdk.JavaC.FullName.Contains("openjdk")) &&
jdk.Version.IsCompatible(MinimumVersion, ExactVersion))
{
ok = true;
ReportStatus($"{jdk.Version} ({jdk.Directory})", Status.Ok);
Util.SetDoctorEnvironmentVariable("JAVA_HOME", jdk.Directory.FullName);
}
else
{
ReportStatus($"{jdk.Version} ({jdk.Directory})", null);
}
}
if (ok)
{
return(Task.FromResult(Diagonosis.Ok(this)));
}
return(Task.FromResult(new Diagonosis(Status.Error, this)));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var installedWorkloads = workloadManager.GetInstalledWorkloads();
var missingWorkloads = new List <Manifest.DotNetWorkload>();
var requiredPacks = new List <WorkloadResolver.PackInfo>();
foreach (var rp in RequiredWorkloads)
{
if (!installedWorkloads.Any(sp => sp == rp.Id))
{
ReportStatus($"{rp.Id} not installed.", Status.Error);
missingWorkloads.Add(rp);
}
else
{
ReportStatus($"{rp.Id} 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.AddNotes(this, "required_packs", requiredPacks.ToArray());
}
if (!missingWorkloads.Any())
{
return(Diagonosis.Ok(this));
}
return(new Diagonosis(
Status.Error,
this,
new Prescription("Install Missing SDK Workloads",
new DotNetWorkloadInstallRemedy(SdkRoot, SdkVersion, missingWorkloads.ToArray(), NuGetPackageSources))));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var info = await GetInfo();
if (NuGetVersion.TryParse(info.Version?.ToString(), out var semVer))
{
if (semVer.IsCompatible(MinimumVersion, ExactVersion))
{
ReportStatus($"XCode.app ({info.Version} {info.Build})", Status.Ok);
return(Diagonosis.Ok(this));
}
}
ReportStatus($"XCode.app ({info.Version}) not installed.", Status.Error);
return(new Diagonosis(Status.Error, this, new Prescription($"Download XCode {MinimumVersion.ThisOrExact(ExactVersion)}")));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var sdkPacks = workloadManager.GetAllInstalledWorkloadPacks();
var missingPacks = new List <NuGetPackage>();
var requiredPacks = new List <NuGetPackage>();
requiredPacks.AddRange(RequiredPacks);
if (history.TryGetNotes <WorkloadResolver.PackInfo[]>("dotnetworkloads", "required_packs", out var p) && p.Any())
{
requiredPacks.AddRange(p.Select(pi => new NuGetPackage {
Id = pi.Id, Version = pi.Version
}));
}
var uniqueRequiredPacks = requiredPacks
.GroupBy(p => p.Id + p.Version.ToString())
.Select(g => g.First());
foreach (var rp in uniqueRequiredPacks)
{
if (!sdkPacks.Any(sp => sp.Id == rp.Id && sp.Version == 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(Diagonosis.Ok(this));
}
return(new Diagonosis(
Status.Error,
this,
new Prescription("Install Missing SDK Packs",
new DotNetPackInstallRemedy(SdkRoot, SdkVersion, missingPacks.ToArray(), NuGetPackageSources))));;
}
public override Task <Diagonosis> Examine(PatientHistory history)
{
var android = new AndroidSdk.AndroidSdkManager(
Util.GetDoctorEnvironmentVariable("ANDROID_SDK_ROOT") ?? Util.GetDoctorEnvironmentVariable("ANDROID_HOME"));
var packages = android.SdkManager.List().InstalledPackages;
var missingPackages = new List <Manifest.AndroidPackage>();
foreach (var rp in RequiredPackages)
{
if (!packages.Any(p => p.Path.Equals(rp.Path, StringComparison.OrdinalIgnoreCase) &&
NuGetVersion.Parse(p.Version) >= NuGetVersion.Parse(rp.Version)))
{
ReportStatus($"{rp.Path} ({rp.Version}) missing.", Status.Error);
missingPackages.Add(rp);
}
else
{
ReportStatus($"{rp.Path} ({rp.Version})", Status.Ok);
}
}
if (!missingPackages.Any())
{
return(Task.FromResult(Diagonosis.Ok(this)));
}
var remedies = Util.IsMac ? new AndroidPackagesRemedy[] { new AndroidPackagesRemedy(android, missingPackages.ToArray()) } : null;
return(Task.FromResult(new Diagonosis(
Status.Error,
this,
new Prescription("Install missing Android SDK items",
"Your Android SDK is missing some required packages. You can use the Android SDK Manager to install them. For more information see: https://aka.ms/dotnet-androidsdk-help",
remedies))));
}
public override Task <Diagonosis> Examine(PatientHistory history)
{
var android = new AndroidSdk.AndroidSdkManager(
Util.GetDoctorEnvironmentVariable("ANDROID_SDK_ROOT") ?? Util.GetDoctorEnvironmentVariable("ANDROID_HOME"));
try
{
var v = android.SdkManager.RequiresLicenseAcceptance();
if (!v)
{
ReportStatus($"All licenses accepted.", Status.Ok);
return(Task.FromResult(Diagonosis.Ok(this)));
}
}
catch { }
ReportStatus("One or more Licenses are not accepted.", Status.Error);
var ext = Util.IsWindows ? ".bat" : string.Empty;
var sdkMgrPath = android.SdkManager.FindToolPath(android.Home)?.FullName;
if (string.IsNullOrEmpty(sdkMgrPath))
{
sdkMgrPath = $"sdkmanager{ext}";
}
return(Task.FromResult(new Diagonosis(Status.Error, this, new Prescription("Android SDK has licenses which need to be accepted.",
$"To read and accept Android SDK licenses, run the following command in a terminal:{Environment.NewLine} {sdkMgrPath} --licenses"))));
//,new ActionRemedy((r, ct) =>
//{
// android.SdkManager.AcceptLicenses();
// return Task.CompletedTask;
//}))));
}
public override async Task <int> ExecuteAsync(CommandContext context, DoctorSettings settings)
{
Console.Title = ToolName;
AnsiConsole.MarkupLine($"[underline bold green]{Icon.Ambulance} {ToolName} {Icon.Recommend}[/]");
AnsiConsole.Render(new Rule());
AnsiConsole.MarkupLine("This tool will attempt to evaluate your .NET MAUI development environment.");
AnsiConsole.MarkupLine("If problems are detected, this tool may offer the option to try and fix them for you, or suggest a way to fix them yourself.");
AnsiConsole.WriteLine();
AnsiConsole.MarkupLine("Thanks for choosing .NET MAUI!");
AnsiConsole.WriteLine();
if (!settings.NonInteractive)
{
AnsiConsole.Markup("Press any key to start...");
Console.ReadKey();
AnsiConsole.WriteLine();
}
AnsiConsole.Render(new Rule());
var clinic = new Clinic();
var cts = new System.Threading.CancellationTokenSource();
var checkupStatus = new Dictionary <string, Doctoring.Status>();
var patientHistory = new PatientHistory();
var diagnoses = new List <Diagonosis>();
var consoleStatus = AnsiConsole.Status();
AnsiConsole.Markup($"[bold blue]{Icon.Thinking} Synchronizing configuration...[/]");
var chart = await Manifest.Chart.FromFileOrUrl(settings.Manifest);
var toolVersion = chart?.Doctor?.ToolVersion;
var fileVersion = NuGetVersion.Parse(FileVersionInfo.GetVersionInfo(this.GetType().Assembly.Location).FileVersion);
if (string.IsNullOrEmpty(toolVersion) || !NuGetVersion.TryParse(toolVersion, out var toolVer) || fileVersion < toolVer)
{
Console.WriteLine();
AnsiConsole.MarkupLine($"[bold red]{Icon.Error} Updating to version {toolVersion} or newer is required:[/]");
AnsiConsole.MarkupLine($"[red]Update with the following:[/]");
var installCmdVer = string.IsNullOrEmpty(toolVersion) ? "" : $" --version {toolVersion}";
AnsiConsole.Markup($" dotnet tool install --global {ToolPackageId}{installCmdVer}");
return(-1);
}
AnsiConsole.MarkupLine(" ok");
AnsiConsole.Markup($"[bold blue]{Icon.Thinking} Scheduling appointments...[/]");
if (chart.Doctor.OpenJdk != null)
{
clinic.OfferService(new OpenJdkCheckup(chart.Doctor.OpenJdk.MinimumVersion, chart.Doctor.OpenJdk.ExactVersion));
}
if (chart.Doctor.Android != null)
{
clinic.OfferService(new AndroidSdkManagerCheckup());
clinic.OfferService(new AndroidSdkPackagesCheckup(chart.Doctor.Android.Packages.ToArray()));
clinic.OfferService(new AndroidSdkLicensesCheckup());
}
if (chart.Doctor.XCode != null)
{
clinic.OfferService(new XCodeCheckup(chart.Doctor.XCode.MinimumVersion, chart.Doctor.XCode.ExactVersion));
}
if (chart.Doctor.VSMac != null && !string.IsNullOrEmpty(chart.Doctor.VSMac.MinimumVersion))
{
clinic.OfferService(new VisualStudioMacCheckup(chart.Doctor.VSMac.MinimumVersion, chart.Doctor.VSMac.ExactVersion));
}
if (chart.Doctor.VSWin != null && !string.IsNullOrEmpty(chart.Doctor.VSWin.MinimumVersion))
{
clinic.OfferService(new VisualStudioWindowsCheckup(chart.Doctor.VSWin.MinimumVersion, chart.Doctor.VSWin.ExactVersion));
}
if (chart.Doctor.DotNet?.Sdks?.Any() ?? false)
{
clinic.OfferService(new DotNetCheckup(chart.Doctor.DotNet.Sdks.ToArray()));
foreach (var sdk in chart.Doctor.DotNet.Sdks)
{
clinic.OfferService(new DotNetWorkloadsCheckup(sdk.Version, sdk.Workloads.ToArray(), sdk.PackageSources.ToArray()));
// Always run the packs checkup even if manifest is empty, since the workloads may resolve some required packs dynamically that aren't from the manifest
clinic.OfferService(new DotNetPacksCheckup(sdk.Version, sdk.Packs?.ToArray() ?? Array.Empty <Manifest.NuGetPackage>(), sdk.PackageSources.ToArray()));
}
}
var checkups = clinic.ScheduleCheckups();
AnsiConsole.MarkupLine(" ok");
foreach (var checkup in checkups)
{
var skipCheckup = false;
// Make sure our dependencies succeeded first
if (checkup.Dependencies?.Any() ?? false)
{
foreach (var dep in checkup.Dependencies)
{
if (!checkupStatus.TryGetValue(dep.CheckupId, out var depStatus) || depStatus != Doctoring.Status.Ok)
{
skipCheckup = dep.IsRequired;
break;
}
}
}
if (skipCheckup)
{
checkupStatus.Add(checkup.Id, Doctoring.Status.Error);
AnsiConsole.WriteLine();
AnsiConsole.MarkupLine($"[bold red]{Icon.Error} Skipped: " + checkup.Title + "[/]");
continue;
}
checkup.OnStatusUpdated += (s, e) =>
{
var msg = "";
if (e.Status == Doctoring.Status.Error)
{
msg = $"[red]{Icon.Error} {e.Message}[/]";
}
else if (e.Status == Doctoring.Status.Warning)
{
msg = $"[red]{Icon.Error} {e.Message}[/]";
}
else if (e.Status == Doctoring.Status.Ok)
{
msg = $"[green]{Icon.Success} {e.Message}[/]";
}
else
{
msg = $"{Icon.ListItem} {e.Message}";
}
AnsiConsole.MarkupLine(" " + msg);
};
AnsiConsole.WriteLine();
AnsiConsole.MarkupLine($"[bold]{Icon.Checking} " + checkup.Title + " Checkup[/]...");
Console.Title = checkup.Title;
Diagonosis diagnosis = null;
try
{
diagnosis = await checkup.Examine(patientHistory);
}
catch (Exception ex)
{
diagnosis = new Diagonosis(Doctoring.Status.Error, checkup, ex.Message);
}
diagnoses.Add(diagnosis);
// Cache the status for dependencies
checkupStatus.Add(checkup.Id, diagnosis.Status);
if (diagnosis.Status == Doctoring.Status.Ok)
{
continue;
}
var statusEmoji = diagnosis.Status == Doctoring.Status.Error ? Icon.Error : Icon.Warning;
var statusColor = diagnosis.Status == Doctoring.Status.Error ? "red" : "orange3";
var msg = !string.IsNullOrEmpty(diagnosis.Message) ? " - " + diagnosis.Message : string.Empty;
//AnsiConsole.MarkupLine($"[{statusColor}]{statusEmoji} {checkup.Title}{msg}[/]");
if (diagnosis.HasPrescription)
{
AnsiConsole.MarkupLine($" [bold blue]{Icon.Recommend} Recommendation:[/] {diagnosis.Prescription.Name}");
if (!string.IsNullOrEmpty(diagnosis.Prescription.Description))
{
AnsiConsole.MarkupLine(" " + diagnosis.Prescription.Description);
}
// See if we should fix
// needs to have a remedy available to even bother asking/trying
var doFix = diagnosis.Prescription.HasRemedy &&
(
// --fix + --non-interactive == auto fix, no prompt
(settings.NonInteractive && settings.Fix)
// interactive (default) + prompt/confirm they want to fix
|| (!settings.NonInteractive && AnsiConsole.Confirm($" [bold]{Icon.Bell} Attempt to fix?[/]"))
);
if (doFix)
{
var isAdmin = Util.IsAdmin();
foreach (var remedy in diagnosis.Prescription.Remedies)
{
if (!remedy.HasPrivilegesToRun(isAdmin, Util.Platform))
{
AnsiConsole.Markup("Fix requires running with adminstrator privileges. Try opening a terminal as administrator and running maui-doctor again.");
continue;
}
try
{
remedy.OnStatusUpdated += (s, e) =>
{
AnsiConsole.MarkupLine(" " + e.Message);
};
AnsiConsole.MarkupLine($"{Icon.Thinking} Attempting to fix: " + checkup.Title);
await remedy.Cure(cts.Token);
AnsiConsole.MarkupLine(" Fix applied. Run doctor again to verify.");
}
catch (Exception ex)
{
AnsiConsole.MarkupLine(" Fix failed - " + ex.Message);
}
}
}
}
}
AnsiConsole.Render(new Rule());
AnsiConsole.WriteLine();
if (diagnoses.Any(d => d.Status == Doctoring.Status.Error))
{
AnsiConsole.MarkupLine($"[bold red]{Icon.Bell} There were one or more problems detected.[/]");
AnsiConsole.MarkupLine($"[bold red]Please review the errors and correct them and run maui-doctor again.[/]");
}
else
{
AnsiConsole.MarkupLine($"[bold blue]{Icon.Success} Congratulations, everything looks great![/]");
}
Console.Title = ToolName;
return(0);
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var dn = new DotNet();
var missingDiagnosis = new Diagonosis(Status.Error, this, new Prescription(".NET SDK not installed"));
if (!dn.Exists)
{
return(missingDiagnosis);
}
var sdks = await dn.GetSdks();
var missingSdks = new List <Manifest.DotNetSdk>();
var sentinelFiles = new List <string>();
if (RequiredSdks?.Any() ?? false)
{
foreach (var rs in RequiredSdks)
{
if (!sdks.Any(s => s.Version.Equals(NuGetVersion.Parse(rs.Version))))
{
missingSdks.Add(rs);
}
}
}
DotNetSdkInfo bestSdk = null;
foreach (var sdk in sdks)
{
var requiredSdk = RequiredSdks.FirstOrDefault(rs => sdk.Version == NuGetVersion.Parse(rs.Version));
if (requiredSdk != null)
{
if (bestSdk == null || sdk.Version > bestSdk.Version)
{
bestSdk = sdk;
}
if (requiredSdk.EnableWorkloadResolver)
{
var sentinelPath = Path.Combine(sdk.Directory.FullName, "EnableWorkloadResolver.sentinel");
sentinelFiles.Add(sentinelPath);
}
ReportStatus($"{sdk.Version} - {sdk.Directory}", Status.Ok);
}
else
{
ReportStatus($"{sdk.Version} - {sdk.Directory}", null);
}
}
// Find newest compatible sdk
if (bestSdk != null)
{
Util.SetDoctorEnvironmentVariable("DOTNET_SDK", bestSdk.Directory.FullName);
}
// Add sentinel files that should be considered
if (sentinelFiles.Any())
{
history.AddNotes(this, "sentinel_files", sentinelFiles.ToArray());
}
if (missingSdks.Any())
{
var str = SdkListToString();
return(new Diagonosis(Status.Error, this, $".NET SDK {str} not installed.",
new Prescription($"Download .NET SDK {str}",
new BootsRemedy(missingSdks.Select(ms => (ms.Urls.For(Util.Platform)?.ToString(), ".NET SDK " + ms.Version)).ToArray())
{
AdminRequirements = new [] { (Platform.Windows, true) }
public override Task <Diagonosis> Examine(PatientHistory history)
{
try
{
var homes = AndroidSdk.AndroidSdkManager.FindHome();
foreach (var home in homes)
{
try
{
var sdk = new AndroidSdk.SdkManager(home);
var v = sdk.GetVersion();
if (v != default)
{
if (SelectedHome == default)
{
SelectedHome = home;
SdkManagerPath = sdk.FindToolPath(SelectedHome);
if (SdkManagerPath != null)
{
Util.SetDoctorEnvironmentVariable("ANDROID_SDK_ROOT", SdkManagerPath.FullName);
Util.SetDoctorEnvironmentVariable("ANDROID_HOME", SdkManagerPath.FullName);
}
ReportStatus($"{home.FullName} ({v}) installed.", Status.Ok);
}
else
{
ReportStatus($"{home.FullName} ({v}) also installed.", Status.Ok);
}
}
else
{
ReportStatus($"{home.FullName} invalid.", Status.Warning);
}
}
catch
{
ReportStatus($"{home.FullName} invalid.", Status.Warning);
}
}
if (SelectedHome != default)
{
return(Task.FromResult(Diagonosis.Ok(this)));
}
} catch { }
return(Task.FromResult(
new Diagonosis(
Status.Error,
this,
"Failed to find Android SDK.",
new Prescription("Please Install the Android SDK Manager. For more information see: https://aka.ms/dotnet-androidsdk-help")))); //,
//new ActionRemedy((r, ct) =>
//{
// if (SelectedHome != null)
// {
// if (SelectedHome.Exists)
// {
// try { SelectedHome.Delete(true); }
// catch (UnauthorizedAccessException)
// {
// throw new Exception("Fix requires running with adminstrator privileges. Try opening a terminal as administrator and running maui-doctor again.");
// }
// catch (Exception ex)
// {
// throw new Exception("Failed to delete existing Android SDK: " + ex.Message);
// }
// try { SelectedHome.Create(); }
// catch { }
// }
// }
// else
// {
// SelectedHome = new DirectoryInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "Android", "android-sdk"));
// try { SelectedHome.Create(); }
// catch { }
// }
// var sdk = new AndroidSdk.AndroidSdkManager(SelectedHome);
// sdk.Acquire();
// return Task.CompletedTask;
//}))));
}