Removing NuGetConfig from the first run experience and replacing the sentinel with the FirstUseNoticeSentinel when needed.

livarcocc · livarcocc · commit a357fd7bcaf6 · 2017-06-20T10:59:23.000-07:00
diff --git a/packaging/rpm/scripts/after_install_host.sh b/packaging/rpm/scripts/after_install_host.sh
@@ -19,4 +19,4 @@ The data collected is anonymous and will be published in an aggregated form for
 
 The .NET Core Tools telemetry feature is enabled by default. You can opt-out of the telemetry feature by setting an environment variable DOTNET_CLI_TELEMETRY_OPTOUT (for example, 'export' on macOS/Linux, 'set' on Windows) to true (for example, 'true', 1). You can read more about .NET Core tools telemetry at https://aka.ms/dotnet-cli-telemetry."
 
-su - $SUDO_USER -c "dotnet new > /dev/null 2>&1 || true"
+dotnet new > /dev/null 2>&1 || true
diff --git a/src/Microsoft.DotNet.Configurer/CliFallbackFolderPathCalculator.cs b/src/Microsoft.DotNet.Configurer/CliFallbackFolderPathCalculator.cs
@@ -16,6 +16,17 @@ public class CliFallbackFolderPathCalculator
             Environment.GetEnvironmentVariable("DOTNET_CLI_TEST_FALLBACKFOLDER") ??
             Path.Combine(new DirectoryInfo(AppContext.BaseDirectory).Parent.FullName, "NuGetFallbackFolder");
 
+        public string DotnetUserProfileFolderPath
+        {
+            get
+            {
+                string profileDir = Environment.GetEnvironmentVariable(
+                    RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERPROFILE" : "HOME");
+
+                return Path.Combine(profileDir, ".dotnet");
+            }
+        }
+
         public string NuGetUserSettingsDirectory =>
             NuGetEnvironment.GetFolderPath(NuGetFolderPath.UserSettingsDirectory);
     }
diff --git a/src/Microsoft.DotNet.Configurer/DotnetFirstTimeUseConfigurer.cs b/src/Microsoft.DotNet.Configurer/DotnetFirstTimeUseConfigurer.cs
@@ -41,13 +41,15 @@ public void Configure()
 
             if (ShouldPrimeNugetCache())
             {
+                if (_nugetCacheSentinel.UnauthorizedAccess)
+                {
+                    PrintUnauthorizedAccessMessage();
+                }
+
                 PrintNugetCachePrimeMessage();
+
                 _nugetCachePrimer.PrimeCache();
             }
-            else if (_nugetCacheSentinel.UnauthorizedAccess)
-            {
-                PrintUnauthorizedAccessMessage();
-            }
         }
 
         private bool ShouldPrintFirstTimeUseNotice()
diff --git a/src/Microsoft.DotNet.Configurer/FirstTimeUseNoticeSentinel.cs b/src/Microsoft.DotNet.Configurer/FirstTimeUseNoticeSentinel.cs
@@ -14,19 +14,19 @@ public class FirstTimeUseNoticeSentinel : IFirstTimeUseNoticeSentinel
 
         private readonly IFile _file;
 
-        private string _nugetCachePath;
+        private string _dotnetUserProfileFolderPath;
 
-        private string SentinelPath => Path.Combine(_nugetCachePath, SENTINEL);
+        private string SentinelPath => Path.Combine(_dotnetUserProfileFolderPath, SENTINEL);
 
         public FirstTimeUseNoticeSentinel(CliFallbackFolderPathCalculator cliFallbackFolderPathCalculator) :
-            this(cliFallbackFolderPathCalculator.CliFallbackFolderPath, FileSystemWrapper.Default.File)
+            this(cliFallbackFolderPathCalculator.DotnetUserProfileFolderPath, FileSystemWrapper.Default.File)
         {
         }
 
-        internal FirstTimeUseNoticeSentinel(string nugetCachePath, IFile file)
+        internal FirstTimeUseNoticeSentinel(string dotnetUserProfileFolderPath, IFile file)
         {
             _file = file;
-            _nugetCachePath = nugetCachePath;
+            _dotnetUserProfileFolderPath = dotnetUserProfileFolderPath;
         }
 
         public bool Exists()
diff --git a/src/Microsoft.DotNet.Configurer/INuGetConfig.cs b/src/Microsoft.DotNet.Configurer/INuGetConfig.cs
diff --git a/src/Microsoft.DotNet.Configurer/LocalizableStrings.resx b/src/Microsoft.DotNet.Configurer/LocalizableStrings.resx
@@ -143,7 +143,7 @@ Here are some options to fix this error:
 ---------------------
 1. Re-run this command with elevated access.
 2. Disabled the first run experience by setting the environment variable DOTNET_SKIP_FIRST_TIME_EXPERIENCE to true.
-3. Copy the .NET Core SDK to a non-protected location and use it from there.";
+3. Copy the .NET Core SDK to a non-protected location and use it from there.
     </value>
   </data>
 </root>
diff --git a/src/Microsoft.DotNet.Configurer/NuGetCachePrimer.cs b/src/Microsoft.DotNet.Configurer/NuGetCachePrimer.cs
@@ -17,18 +17,14 @@ public class NuGetCachePrimer : INuGetCachePrimer
 
         private readonly INuGetCacheSentinel _nuGetCacheSentinel;
 
-        private readonly INuGetConfig _nuGetConfig;
-
         private readonly CliFallbackFolderPathCalculator _cliFallbackFolderPathCalculator;
 
         public NuGetCachePrimer(
             INuGetPackagesArchiver nugetPackagesArchiver,
             INuGetCacheSentinel nuGetCacheSentinel,
-            INuGetConfig nuGetConfig,
             CliFallbackFolderPathCalculator cliFallbackFolderPathCalculator)
             : this(nugetPackagesArchiver,
                 nuGetCacheSentinel,
-                nuGetConfig,
                 cliFallbackFolderPathCalculator,
                 FileSystemWrapper.Default.File)
         {
@@ -37,16 +33,13 @@ public NuGetCachePrimer(
         internal NuGetCachePrimer(
             INuGetPackagesArchiver nugetPackagesArchiver,
             INuGetCacheSentinel nuGetCacheSentinel,
-            INuGetConfig nuGetConfig,
             CliFallbackFolderPathCalculator cliFallbackFolderPathCalculator,
             IFile file)
         {
             _nugetPackagesArchiver = nugetPackagesArchiver;
 
             _nuGetCacheSentinel = nuGetCacheSentinel;
 
-            _nuGetConfig = nuGetConfig;
-
             _cliFallbackFolderPathCalculator = cliFallbackFolderPathCalculator;
 
             _file = file;
@@ -63,8 +56,6 @@ public void PrimeCache()
 
             _nugetPackagesArchiver.ExtractArchive(nuGetFallbackFolder);
 
-            _nuGetConfig.AddCliFallbackFolder(nuGetFallbackFolder);
-
             _nuGetCacheSentinel.CreateIfNotExists();
         }
 
diff --git a/src/Microsoft.DotNet.Configurer/NuGetConfig.cs b/src/Microsoft.DotNet.Configurer/NuGetConfig.cs
diff --git a/src/dotnet/Program.cs b/src/dotnet/Program.cs
@@ -128,7 +128,7 @@ internal static int ProcessArgs(string[] args, ITelemetry telemetryClient = null
 
                 if (telemetryClient == null)
                 {
-                    telemetryClient = new Telemetry(nugetCacheSentinel);
+                    telemetryClient = new Telemetry(firstTimeUseNoticeSentinel);
                 }
             }
 
@@ -177,18 +177,16 @@ private static void ConfigureDotNetForFirstTimeUse(
                 var nugetPackagesArchiver = new NuGetPackagesArchiver();
                 var environmentProvider = new EnvironmentProvider();
                 var commandFactory = new DotNetCommandFactory(alwaysRunOutOfProc: true);
-                var nugetConfig = new NuGetConfig(cliFallbackFolderPathCalculator);
                 var nugetCachePrimer = new NuGetCachePrimer(
                     nugetPackagesArchiver,
                     nugetCacheSentinel,
-                    nugetConfig,
                     cliFallbackFolderPathCalculator);
                 var dotnetConfigurer = new DotnetFirstTimeUseConfigurer(
                     nugetCachePrimer,
                     nugetCacheSentinel,
                     firstTimeUseNoticeSentinel,
                     environmentProvider,
-                    Reporter.Output
+                    Reporter.Output,
                     cliFallbackFolderPathCalculator.CliFallbackFolderPath);
 
                 dotnetConfigurer.Configure();
diff --git a/src/dotnet/Telemetry.cs b/src/dotnet/Telemetry.cs
@@ -35,9 +35,9 @@ public class Telemetry : ITelemetry
 
         public Telemetry () : this(null) { }
 
-        public Telemetry(INuGetCacheSentinel sentinel) : this(sentinel, null) { }
+        public Telemetry(IFirstTimeUseNoticeSentinel sentinel) : this(sentinel, null) { }
 
-        public Telemetry(INuGetCacheSentinel sentinel, string sessionId)
+        public Telemetry(IFirstTimeUseNoticeSentinel sentinel, string sessionId)
         {
             Enabled = !Env.GetEnvironmentVariableAsBool(TelemetryOptout) && PermissionExists(sentinel);
 
@@ -53,7 +53,7 @@ public Telemetry(INuGetCacheSentinel sentinel, string sessionId)
             _trackEventTask = Task.Factory.StartNew(() => InitializeTelemetry());
         }
 
-        private bool PermissionExists(INuGetCacheSentinel sentinel)
+        private bool PermissionExists(IFirstTimeUseNoticeSentinel sentinel)
         {
             if (sentinel == null)
             {
diff --git a/src/dotnet/commands/dotnet-msbuild/MSBuildLogger.cs b/src/dotnet/commands/dotnet-msbuild/MSBuildLogger.cs
@@ -11,7 +11,8 @@ namespace Microsoft.DotNet.Tools.MSBuild
 {
     public sealed class MSBuildLogger : Logger
     {
-        private readonly INuGetCacheSentinel _sentinel = new NuGetCacheSentinel(new CliFallbackFolderPathCalculator());
+        private readonly IFirstTimeUseNoticeSentinel _sentinel =
+            new FirstTimeUseNoticeSentinel(new CliFallbackFolderPathCalculator());
         private readonly ITelemetry _telemetry;
 
         public MSBuildLogger()
diff --git a/src/dotnet/commands/dotnet-new/NewCommandShim.cs b/src/dotnet/commands/dotnet-new/NewCommandShim.cs
@@ -28,8 +28,10 @@ internal class NewCommandShim
 
         public static int Run(string[] args)
         {
-            var sessionId = Environment.GetEnvironmentVariable(MSBuildForwardingApp.TelemetrySessionIdEnvironmentVariableName);
-            var telemetry = new Telemetry(new NuGetCacheSentinel(new CliFallbackFolderPathCalculator()), sessionId);
+            var sessionId =
+                Environment.GetEnvironmentVariable(MSBuildForwardingApp.TelemetrySessionIdEnvironmentVariableName);
+            var telemetry =
+                new Telemetry(new FirstTimeUseNoticeSentinel(new CliFallbackFolderPathCalculator()), sessionId);
             var logger = new TelemetryLogger(null);
 
             if (telemetry.Enabled)
diff --git a/test/Microsoft.DotNet.Configurer.UnitTests/GivenANuGetCachePrimer.cs b/test/Microsoft.DotNet.Configurer.UnitTests/GivenANuGetCachePrimer.cs
@@ -26,7 +26,6 @@ public class GivenANuGetCachePrimer
 
         private Mock<INuGetPackagesArchiver> _nugetPackagesArchiverMock;
         private Mock<INuGetCacheSentinel> _nugetCacheSentinel;
-        private Mock<INuGetConfig> _nugetConfigMock;
         private CliFallbackFolderPathCalculator _cliFallbackFolderPathCalculator;
 
         public GivenANuGetCachePrimer()
@@ -41,14 +40,11 @@ public GivenANuGetCachePrimer()
 
             _nugetCacheSentinel = new Mock<INuGetCacheSentinel>();
 
-            _nugetConfigMock = new Mock<INuGetConfig>();
-
             _cliFallbackFolderPathCalculator = new CliFallbackFolderPathCalculator();
 
             var nugetCachePrimer = new NuGetCachePrimer(
                 _nugetPackagesArchiverMock.Object,
                 _nugetCacheSentinel.Object,
-                _nugetConfigMock.Object,
                 _cliFallbackFolderPathCalculator,
                 _fileSystemMock.File);
 
@@ -67,7 +63,6 @@ public void It_does_not_prime_the_NuGet_cache_if_the_archive_is_not_found_so_tha
             var nugetCachePrimer = new NuGetCachePrimer(
                 nugetPackagesArchiverMock.Object,
                 _nugetCacheSentinel.Object,
-                _nugetConfigMock.Object,
                 _cliFallbackFolderPathCalculator,
                 fileSystemMock.File);
 
@@ -76,14 +71,6 @@ public void It_does_not_prime_the_NuGet_cache_if_the_archive_is_not_found_so_tha
             nugetPackagesArchiverMock.Verify(n => n.ExtractArchive(It.IsAny<string>()), Times.Never);
         }
 
-        [Fact]
-        public void It_adds_the_fallback_folder_to_NuGet_Config()
-        {
-            _nugetConfigMock.Verify(n =>
-                n.AddCliFallbackFolder(_cliFallbackFolderPathCalculator.CliFallbackFolderPath),
-                Times.Exactly(1));
-        }
-
         [Fact]
         public void It_extracts_the_archive_to_the_fallback_folder()
         {
@@ -108,7 +95,6 @@ public void It_does_not_create_a_sentinel_when_extracting_the_archive_fails()
             var nugetCachePrimer = new NuGetCachePrimer(
                 nugetPackagesArchiveMock.Object,
                 nugetCacheSentinel.Object,
-                _nugetConfigMock.Object,
                 _cliFallbackFolderPathCalculator,
                 _fileSystemMock.File);
 
diff --git a/test/Microsoft.DotNet.Configurer.UnitTests/GivenANuGetConfig.cs b/test/Microsoft.DotNet.Configurer.UnitTests/GivenANuGetConfig.cs
diff --git a/test/dotnet-msbuild.Tests/GivenDotnetMSBuildBuildsProjects.cs b/test/dotnet-msbuild.Tests/GivenDotnetMSBuildBuildsProjects.cs
@@ -109,7 +109,7 @@ public void WhenRestoreSourcesStartsWithUnixPathThenHttpsSourceIsParsedCorrectly
 
             result.Should().Fail();
 
-            result.StdOut.Should().ContainVisuallySameFragment(@"source(s): /usr/local/bin, nuget.org");
+            result.StdOut.Should().ContainVisuallySameFragment("NU1101");
         }
 
         [Fact]
@@ -186,7 +186,7 @@ private string[] GetArgsForMSBuild(Func<bool> sentinelExists, out Telemetry tele
         }
     }
 
-    public sealed class MockNuGetCacheSentinel : INuGetCacheSentinel
+    public sealed class MockNuGetCacheSentinel : IFirstTimeUseNoticeSentinel
     {
         private readonly Func<bool> _exists;
 

Original file line number	Diff line number	Diff line change
`@@ -19,4 +19,4 @@ The data collected is anonymous and will be published in an aggregated form for`
`19`	`19`
`20`	`20`	`The .NET Core Tools telemetry feature is enabled by default. You can opt-out of the telemetry feature by setting an environment variable DOTNET_CLI_TELEMETRY_OPTOUT (for example, 'export' on macOS/Linux, 'set' on Windows) to true (for example, 'true', 1). You can read more about .NET Core tools telemetry at https://aka.ms/dotnet-cli-telemetry."`
`21`	`21`
`22`		`-su - $SUDO_USER -c "dotnet new > /dev/null 2>&1 \|\| true"`
	`22`	`+dotnet new > /dev/null 2>&1 \|\| true`
Original file line number	Diff line number	Diff line change
`@@ -41,13 +41,15 @@ public void Configure()`
`41`	`41`
`42`	`42`	`if (ShouldPrimeNugetCache())`
`43`	`43`	`{`
	`44`	`+ if (_nugetCacheSentinel.UnauthorizedAccess)`
	`45`	`+ {`
	`46`	`+ PrintUnauthorizedAccessMessage();`
	`47`	`+ }`
	`48`	`+`
`44`	`49`	`PrintNugetCachePrimeMessage();`
	`50`	`+`
`45`	`51`	`_nugetCachePrimer.PrimeCache();`
`46`	`52`	`}`
`47`		`- else if (_nugetCacheSentinel.UnauthorizedAccess)`
`48`		`- {`
`49`		`- PrintUnauthorizedAccessMessage();`
`50`		`- }`
`51`	`53`	`}`
`52`	`54`
`53`	`55`	`private bool ShouldPrintFirstTimeUseNotice()`
Original file line number	Diff line number	Diff line change
`@@ -14,19 +14,19 @@ public class FirstTimeUseNoticeSentinel : IFirstTimeUseNoticeSentinel`
`14`	`14`
`15`	`15`	`private readonly IFile _file;`
`16`	`16`
`17`		`- private string _nugetCachePath;`
	`17`	`+ private string _dotnetUserProfileFolderPath;`
`18`	`18`
`19`		`- private string SentinelPath => Path.Combine(_nugetCachePath, SENTINEL);`
	`19`	`+ private string SentinelPath => Path.Combine(_dotnetUserProfileFolderPath, SENTINEL);`
`20`	`20`
`21`	`21`	`public FirstTimeUseNoticeSentinel(CliFallbackFolderPathCalculator cliFallbackFolderPathCalculator) :`
`22`		`- this(cliFallbackFolderPathCalculator.CliFallbackFolderPath, FileSystemWrapper.Default.File)`
	`22`	`+ this(cliFallbackFolderPathCalculator.DotnetUserProfileFolderPath, FileSystemWrapper.Default.File)`
`23`	`23`	`{`
`24`	`24`	`}`
`25`	`25`
`26`		`- internal FirstTimeUseNoticeSentinel(string nugetCachePath, IFile file)`
	`26`	`+ internal FirstTimeUseNoticeSentinel(string dotnetUserProfileFolderPath, IFile file)`
`27`	`27`	`{`
`28`	`28`	`_file = file;`
`29`		`- _nugetCachePath = nugetCachePath;`
	`29`	`+ _dotnetUserProfileFolderPath = dotnetUserProfileFolderPath;`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`public bool Exists()`
Original file line number	Diff line number	Diff line change
`@@ -35,9 +35,9 @@ public class Telemetry : ITelemetry`
`35`	`35`
`36`	`36`	`public Telemetry () : this(null) { }`
`37`	`37`
`38`		`- public Telemetry(INuGetCacheSentinel sentinel) : this(sentinel, null) { }`
	`38`	`+ public Telemetry(IFirstTimeUseNoticeSentinel sentinel) : this(sentinel, null) { }`
`39`	`39`
`40`		`- public Telemetry(INuGetCacheSentinel sentinel, string sessionId)`
	`40`	`+ public Telemetry(IFirstTimeUseNoticeSentinel sentinel, string sessionId)`
`41`	`41`	`{`
`42`	`42`	`Enabled = !Env.GetEnvironmentVariableAsBool(TelemetryOptout) && PermissionExists(sentinel);`
`43`	`43`
`@@ -53,7 +53,7 @@ public Telemetry(INuGetCacheSentinel sentinel, string sessionId)`
`53`	`53`	`_trackEventTask = Task.Factory.StartNew(() => InitializeTelemetry());`
`54`	`54`	`}`
`55`	`55`
`56`		`- private bool PermissionExists(INuGetCacheSentinel sentinel)`
	`56`	`+ private bool PermissionExists(IFirstTimeUseNoticeSentinel sentinel)`
`57`	`57`	`{`
`58`	`58`	`if (sentinel == null)`
`59`	`59`	`{`