First-run workload experience

src/Cli/Microsoft.DotNet.Configurer/DotnetFirstRunConfiguration.cs

@@ -13,16 +13,20 @@ public class DotnetFirstRunConfiguration
 
         public bool NoLogo { get; }
 
+        public bool SkipWorkloadIntegrityCheck { get; }
+
         public DotnetFirstRunConfiguration(
             bool generateAspNetCertificate,
             bool telemetryOptout,
             bool addGlobalToolsToPath,
-            bool nologo)
+            bool nologo,
+            bool skipWorkloadIntegrityCheck)
         {
             GenerateAspNetCertificate = generateAspNetCertificate;
             TelemetryOptout = telemetryOptout;
             AddGlobalToolsToPath = addGlobalToolsToPath;
             NoLogo = nologo;
+            SkipWorkloadIntegrityCheck = skipWorkloadIntegrityCheck;
         }
     }
 }

src/Cli/dotnet/NugetPackageDownloader/NuGetPackageDownloader.cs

@@ -15,6 +15,7 @@
 
 namespace Microsoft.DotNet.Cli.NuGetPackageDownloader
 {
+    // TODO: Never name a class the same name as the namespace. Update either for easier type resolution.
     internal class NuGetPackageDownloader : INuGetPackageDownloader
     {
         private readonly SourceCacheContext _cacheSettings;

src/Cli/dotnet/Program.cs

@@ -7,11 +7,11 @@
 using Microsoft.DotNet.Configurer;
 using Microsoft.DotNet.ShellShim;
 using Microsoft.Extensions.EnvironmentAbstractions;
-using LocalizableStrings = Microsoft.DotNet.Cli.Utils.LocalizableStrings;
 using Microsoft.DotNet.CommandFactory;
 using NuGet.Frameworks;
 using CommandResult = System.CommandLine.Parsing.CommandResult;
 using System.CommandLine;
+using Microsoft.DotNet.Workloads.Workload;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -162,14 +162,13 @@ internal static int ProcessArgs(string[] args, TimeSpan startupTime, ITelemetry
 
                     var environmentProvider = new EnvironmentProvider();
 
-                    bool generateAspNetCertificate =
-                        environmentProvider.GetEnvironmentVariableAsBool("DOTNET_GENERATE_ASPNET_CERTIFICATE", defaultValue: true);
-                    bool telemetryOptout =
-                      environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.TELEMETRY_OPTOUT, defaultValue: CompileOptions.TelemetryOptOutDefault);
-                    bool addGlobalToolsToPath =
-                        environmentProvider.GetEnvironmentVariableAsBool("DOTNET_ADD_GLOBAL_TOOLS_TO_PATH", defaultValue: true);
-                    bool nologo =
-                        environmentProvider.GetEnvironmentVariableAsBool("DOTNET_NOLOGO", defaultValue: false);
+                    bool generateAspNetCertificate = environmentProvider.GetEnvironmentVariableAsBool("DOTNET_GENERATE_ASPNET_CERTIFICATE", defaultValue: true);
+                    bool telemetryOptout = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.TELEMETRY_OPTOUT, defaultValue: CompileOptions.TelemetryOptOutDefault);
+                    bool addGlobalToolsToPath = environmentProvider.GetEnvironmentVariableAsBool("DOTNET_ADD_GLOBAL_TOOLS_TO_PATH", defaultValue: true);
+                    bool nologo = environmentProvider.GetEnvironmentVariableAsBool("DOTNET_NOLOGO", defaultValue: false);
+                    bool skipWorkloadIntegrityCheck = environmentProvider.GetEnvironmentVariableAsBool("DOTNET_SKIP_WORKLOAD_INTEGRITY_CHECK",
+                        // Default the workload integrity check skip to true if the command is being ran in CI. Otherwise, false.
+                        defaultValue: new CIEnvironmentDetectorForTelemetry().IsCIEnvironment());
 
                     ReportDotnetHomeUsage(environmentProvider);
 
@@ -186,7 +185,8 @@ internal static int ProcessArgs(string[] args, TimeSpan startupTime, ITelemetry
                         generateAspNetCertificate: generateAspNetCertificate,
                         telemetryOptout: telemetryOptout,
                         addGlobalToolsToPath: addGlobalToolsToPath,
-                        nologo: nologo);
+                        nologo: nologo,
+                        skipWorkloadIntegrityCheck: skipWorkloadIntegrityCheck);
 
                     ConfigureDotNetForFirstTimeUse(
                         firstTimeUseNoticeSentinel,
@@ -291,7 +291,7 @@ private static void ReportDotnetHomeUsage(IEnvironmentProvider provider)
 
             Reporter.Verbose.WriteLine(
                 string.Format(
-                    LocalizableStrings.DotnetCliHomeUsed,
+                    Utils.LocalizableStrings.DotnetCliHomeUsed,
                     home,
                     CliFolderPathCalculator.DotnetHomeVariableName));
         }
@@ -305,16 +305,18 @@ private static void ConfigureDotNetForFirstTimeUse(
            IEnvironmentProvider environmentProvider,
            Dictionary<string, double> performanceMeasurements)
         {
+            var isFirstTimeUse = !firstTimeUseNoticeSentinel.Exists();
             var environmentPath = EnvironmentPathFactory.CreateEnvironmentPath(isDotnetBeingInvokedFromNativeInstaller, environmentProvider);
             var commandFactory = new DotNetCommandFactory(alwaysRunOutOfProc: true);
             var aspnetCertificateGenerator = new AspNetCoreCertificateGenerator();
+            var reporter = Reporter.Output;
             var dotnetConfigurer = new DotnetFirstTimeUseConfigurer(
                 firstTimeUseNoticeSentinel,
                 aspNetCertificateSentinel,
                 aspnetCertificateGenerator,
                 toolPathSentinel,
                 dotnetFirstRunConfiguration,
-                Reporter.Output,
+                reporter,
                 environmentPath,
                 performanceMeasurements);
 
@@ -324,6 +326,19 @@ private static void ConfigureDotNetForFirstTimeUse(
             {
                 DotDefaultPathCorrector.Correct();
             }
+
+            if (isFirstTimeUse && !dotnetFirstRunConfiguration.SkipWorkloadIntegrityCheck)
+            {
+                try
+                {
+                    WorkloadIntegrityChecker.RunFirstUseCheck(reporter);
+                }
+                catch (Exception)
+                {
+                    // If the workload check fails for any reason, we want to eat the failure and continue running the command.
+                    reporter.WriteLine(Workloads.Workload.LocalizableStrings.WorkloadIntegrityCheckError.Yellow());
+                }
+            }
         }
 
         private static void InitializeProcess()

src/Cli/dotnet/commands/dotnet-workload/LocalizableStrings.resx

@@ -153,4 +153,11 @@
   <data name="WorkloadInfoDescription" xml:space="preserve">
     <value>Display information about installed workloads.</value>
   </data>
-</root>
+  <data name="WorkloadIntegrityCheck" xml:space="preserve">
+    <value>Checking the state of installed workloads...</value>
+  </data>
+  <data name="WorkloadIntegrityCheckError" xml:space="preserve">
+    <value>An issue was encountered when verifying workloads. For more information, run "dotnet workload update".</value>
+    <comment>Do not translate "dotnet workload update" as it is a CLI command.</comment>
+  </data>
+</root>

src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandBase.cs

@@ -101,9 +101,9 @@ public WorkloadCommandBase(
 
             TempDirectoryPath = !string.IsNullOrWhiteSpace(tempDirPath)
                 ? tempDirPath
-                : !string.IsNullOrWhiteSpace(parseResult.GetValue(WorkloadInstallCommandParser.TempDirOption))
-                ? parseResult.GetValue(WorkloadInstallCommandParser.TempDirOption)
-                : PathUtilities.CreateTempSubdirectory();
+                : (!string.IsNullOrWhiteSpace(parseResult.GetValue(WorkloadInstallCommandParser.TempDirOption))
+                    ? parseResult.GetValue(WorkloadInstallCommandParser.TempDirOption)
+                    : PathUtilities.CreateTempSubdirectory());
 
             TempPackagesDirectory = new DirectoryPath(Path.Combine(TempDirectoryPath, "dotnet-sdk-advertising-temp"));
 
@@ -123,17 +123,18 @@ public WorkloadCommandBase(
         /// <param name="parseResult">The results of parsing the command line.</param>
         /// <returns><see langword="true"/> if signatures of packages and installers should be verified.</returns>
         /// <exception cref="GracefulException" />
-        private static bool ShouldVerifySignatures(ParseResult parseResult)
+        private static bool ShouldVerifySignatures(ParseResult parseResult) =>
+            ShouldVerifySignatures(parseResult.GetValue(WorkloadInstallCommandParser.SkipSignCheckOption));
+
+        public static bool ShouldVerifySignatures(bool skipSignCheck = false)
         {
             if (!SignCheck.IsDotNetSigned())
             {
                 // Can't enforce anything if we already allowed an unsigned dotnet to be installed.
                 return false;
             }
 
-            bool skipSignCheck = parseResult.GetValue(WorkloadInstallCommandParser.SkipSignCheckOption);
             bool policyEnabled = SignCheck.IsWorkloadSignVerificationPolicySet();
-
             if (skipSignCheck && policyEnabled)
             {
                 // Can't override the global policy by using the skip option.

src/Cli/dotnet/commands/dotnet-workload/WorkloadIntegrityChecker.cs

@@ -0,0 +1,53 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.NuGetPackageDownloader;
+using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Workloads.Workload.Install;
+using Microsoft.Extensions.EnvironmentAbstractions;
+using Microsoft.NET.Sdk.WorkloadManifestReader;
+using NuGet.Common;
+
+namespace Microsoft.DotNet.Workloads.Workload
+{
+    internal static class WorkloadIntegrityChecker
+    {
+        public static void RunFirstUseCheck(IReporter reporter)
+        {
+            var creationParameters = new WorkloadResolverFactory.CreationParameters()
+            {
+                CheckIfFeatureBandManifestExists = true,
+                UseInstalledSdkVersionForResolver = true
+            };
+
+            var creationResult = WorkloadResolverFactory.Create(creationParameters);
+            var sdkFeatureBand = new SdkFeatureBand(creationResult.SdkVersion);
+            var verifySignatures = WorkloadCommandBase.ShouldVerifySignatures();
+            var tempPackagesDirectory = new DirectoryPath(PathUtilities.CreateTempSubdirectory());
+            var packageDownloader = new NuGetPackageDownloader(
+                tempPackagesDirectory,
+                verboseLogger: new NullLogger(),
+                verifySignatures: verifySignatures);
+
+            var installer = WorkloadInstallerFactory.GetWorkloadInstaller(
+                reporter,
+                sdkFeatureBand,
+                creationResult.WorkloadResolver,
+                VerbosityOptions.normal,
+                creationResult.UserProfileDir,
+                verifySignatures,
+                packageDownloader,
+                creationResult.DotnetPath);
+            var repository = installer.GetWorkloadInstallationRecordRepository();
+            var installedWorkloads = repository.GetInstalledWorkloads(sdkFeatureBand);
+
+            if (installedWorkloads.Any())
+            {
+                reporter.WriteLine(LocalizableStrings.WorkloadIntegrityCheck);
+                CliTransaction.RunNew(context => installer.InstallWorkloads(installedWorkloads, sdkFeatureBand, context));
+                reporter.WriteLine("----------------");
+            }
+        }
+    }
+}

src/Cli/dotnet/commands/dotnet-workload/install/FileBasedInstaller.cs

@@ -83,7 +83,6 @@ IEnumerable<PackInfo> GetPacksInWorkloads(IEnumerable<WorkloadId> workloadIds)
             return packs;
         }
 
-
         public void InstallWorkloads(IEnumerable<WorkloadId> workloadIds, SdkFeatureBand sdkFeatureBand, ITransactionContext transactionContext, DirectoryPath? offlineCache = null)
         {
             var packInfos = GetPacksInWorkloads(workloadIds);
@@ -189,7 +188,7 @@ public void InstallWorkloads(IEnumerable<WorkloadId> workloadIds, SdkFeatureBand
 
         public void RepairWorkloads(IEnumerable<WorkloadId> workloadIds, SdkFeatureBand sdkFeatureBand, DirectoryPath? offlineCache = null)
         {
-            //  TODO: Actually re-extract the packs to fix any corrupted files. 
+            // TODO: Actually re-extract the packs to fix any corrupted files.
             CliTransaction.RunNew(context => InstallWorkloads(workloadIds, sdkFeatureBand, context, offlineCache));
         }
 

src/Cli/dotnet/commands/dotnet-workload/install/IInstaller.cs

@@ -33,8 +33,6 @@ internal interface IInstaller : IWorkloadManifestInstaller
         void ReplaceWorkloadResolver(IWorkloadResolver workloadResolver);
 
         void Shutdown();
-
-
     }
 
     // Interface to pass to workload manifest updater
@@ -63,6 +61,5 @@ public WorkloadDownload(string id, string nuGetPackageId, string nuGetPackageVer
             NuGetPackageId = nuGetPackageId;
             NuGetPackageVersion = nuGetPackageVersion;
         }
-
     }
 }

src/Cli/dotnet/commands/dotnet-workload/install/NetSdkMsiInstallerClient.cs

@@ -488,9 +488,7 @@ public void InstallWorkloads(IEnumerable<WorkloadId> workloadIds, SdkFeatureBand
                         RollBackMsiInstall(msiToInstall);
                     }
                 });
-
             }
-
         }
 
         void RollBackMsiInstall(WorkloadDownload msiToRollback, DirectoryPath? offlineCache = null)
@@ -1023,7 +1021,7 @@ public static NetSdkMsiInstallerClient Create(
             string tempDirPath = null,
             RestoreActionConfig restoreActionConfig = null)
         {
-            TimestampedFileLogger logger = new(Path.Combine(Path.GetTempPath(), $"Microsoft.NET.Workload_{Environment.ProcessId}_{DateTime.Now:yyyyMMdd_HHmmss}.log"));
+            TimestampedFileLogger logger = new(Path.Combine(Path.GetTempPath(), $"Microsoft.NET.Workload_{Environment.ProcessId}_{DateTime.Now:yyyyMMdd_HHmmss_fff}.log"));
             InstallClientElevationContext elevationContext = new(logger);
 
             if (nugetPackageDownloader == null)

src/Cli/dotnet/commands/dotnet-workload/install/WorkloadInstallerFactory.cs

@@ -14,15 +14,15 @@ internal class WorkloadInstallerFactory
         public static IInstaller GetWorkloadInstaller(
             IReporter reporter,
             SdkFeatureBand sdkFeatureBand,
-            IWorkloadResolver workloadResolver, 
+            IWorkloadResolver workloadResolver,
             VerbosityOptions verbosity,
             string userProfileDir,
             bool verifySignatures,
             INuGetPackageDownloader nugetPackageDownloader = null,
-            string dotnetDir = null, 
+            string dotnetDir = null,
             string tempDirPath = null,
             PackageSourceLocation packageSourceLocation = null,
-            RestoreActionConfig restoreActionConfig = null, 
+            RestoreActionConfig restoreActionConfig = null,
             bool elevationRequired = true)
         {
             dotnetDir = string.IsNullOrWhiteSpace(dotnetDir) ? Path.GetDirectoryName(Environment.ProcessPath) : dotnetDir;
@@ -61,13 +61,13 @@ public static IInstaller GetWorkloadInstaller(
 
         private static bool CanWriteToDotnetRoot(string dotnetDir = null)
         {
-            dotnetDir = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
+            dotnetDir ??= Path.GetDirectoryName(Environment.ProcessPath);
             try
             {
                 var testPath = Path.Combine(dotnetDir, "metadata", Path.GetRandomFileName());
                 if (Directory.Exists(Path.GetDirectoryName(testPath)))
                 {
-                    using (FileStream fs = File.Create(testPath, 1, FileOptions.DeleteOnClose)) { }
+                    using FileStream fs = File.Create(testPath, 1, FileOptions.DeleteOnClose);
                 }
                 else
                 {

src/Cli/dotnet/commands/dotnet-workload/install/WorkloadManifestUpdater.cs

@@ -69,7 +69,7 @@ private static WorkloadManifestUpdater GetInstance(string userProfileDir)
                                           reporter,
                                           verifySignatures: SignCheck.IsDotNetSigned());
             var installer = WorkloadInstallerFactory.GetWorkloadInstaller(reporter, new SdkFeatureBand(sdkVersion),
-                workloadResolver, Cli.VerbosityOptions.normal, userProfileDir, verifySignatures: false);
+                workloadResolver, VerbosityOptions.normal, userProfileDir, verifySignatures: false);
             var workloadRecordRepo = installer.GetWorkloadInstallationRecordRepository();
 
             return new WorkloadManifestUpdater(reporter, workloadResolver, nugetPackageDownloader, userProfileDir, tempPackagesDir.Value, workloadRecordRepo, installer);

src/Cli/dotnet/commands/dotnet-workload/install/WorkloadResolverFactory.cs

@@ -1,6 +1,5 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
-//
 
 using Microsoft.Deployment.DotNet.Releases;
 using Microsoft.DotNet.Cli.Utils;
@@ -32,7 +31,6 @@ public class CreationResult
             public ReleaseVersion SdkVersion { get; set; }
             public ReleaseVersion InstalledSdkVersion { get; set; }
             public IWorkloadResolver WorkloadResolver { get; set; }
-
         }
 
         public static CreationResult Create(CreationParameters parameters)

src/Cli/dotnet/commands/dotnet-workload/update/WorkloadUpdateCommand.cs

@@ -50,8 +50,6 @@ public WorkloadUpdateCommand(
                 _workloadInstaller.GetWorkloadInstallationRecordRepository(), _workloadInstaller, _packageSourceLocation, sdkFeatureBand: _sdkFeatureBand);
         }
 
-
-
         public override int Execute()
         {
             if (!string.IsNullOrWhiteSpace(_downloadToCacheOption))
@@ -67,7 +65,7 @@ public override int Execute()
             }
             else if (_printDownloadLinkOnly)
             {
-                var packageUrls = GetUpdatablePackageUrlsAsync(_includePreviews).GetAwaiter().GetResult();      
+                var packageUrls = GetUpdatablePackageUrlsAsync(_includePreviews).GetAwaiter().GetResult();
                 Reporter.WriteLine("==allPackageLinksJsonOutputStart==");
                 Reporter.WriteLine(JsonSerializer.Serialize(packageUrls, new JsonSerializerOptions() { WriteIndented = true }));
                 Reporter.WriteLine("==allPackageLinksJsonOutputEnd==");
@@ -164,7 +162,6 @@ private void UpdateWorkloadsWithInstallRecord(
                 {
                     //  Nothing to roll back at this level, InstallWorkloadManifest and InstallWorkloadPacks handle the transaction rollback
                 });
-
         }
 
         private async Task DownloadToOfflineCacheAsync(DirectoryPath offlineCache, bool includePreviews)