Fall back to relying on PATH when the dotnet executable is not found at the expected location (#5157)

AnatoliB · web-flow · commit 3d13bf10712e · 2019-10-26T14:10:04.000-07:00
Fall back to relying on PATH when the dotnet executable is not found at the expected location
diff --git a/src/WebJobs.Script/Workers/Http/Configuration/HttpWorkerOptionsSetup.cs b/src/WebJobs.Script/Workers/Http/Configuration/HttpWorkerOptionsSetup.cs
@@ -36,7 +36,7 @@ public void Configure(HttpWorkerOptions options)
                 {
                     throw new HostConfigurationException($"Missing WorkerDescription for HttpWorker");
                 }
-                httpWorkerDescription.ApplyDefaultsAndValidate(_scriptJobHostOptions.RootScriptPath);
+                httpWorkerDescription.ApplyDefaultsAndValidate(_scriptJobHostOptions.RootScriptPath, _logger);
                 options.Arguments = new WorkerProcessArguments()
                 {
                     ExecutablePath = options.Description.DefaultExecutablePath,
diff --git a/src/WebJobs.Script/Workers/Http/HttpWorkerDescription.cs b/src/WebJobs.Script/Workers/Http/HttpWorkerDescription.cs
@@ -5,12 +5,13 @@
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.IO;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.Azure.WebJobs.Script.Workers.Http
 {
     public class HttpWorkerDescription : WorkerDescription
     {
-        public override void ApplyDefaultsAndValidate(string workerDirectory)
+        public override void ApplyDefaultsAndValidate(string workerDirectory, ILogger logger)
         {
             if (workerDirectory == null)
             {
diff --git a/src/WebJobs.Script/Workers/ProcessManagement/WorkerDescription.cs b/src/WebJobs.Script/Workers/ProcessManagement/WorkerDescription.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
 using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.Azure.WebJobs.Script.Workers
 {
@@ -27,6 +28,6 @@ public abstract class WorkerDescription
         /// </summary>
         public List<string> Arguments { get; set; }
 
-        public abstract void ApplyDefaultsAndValidate(string workerDirectory);
+        public abstract void ApplyDefaultsAndValidate(string workerDirectory, ILogger logger);
     }
 }
diff --git a/src/WebJobs.Script/Workers/Rpc/Configuration/RpcWorkerConfigFactory.cs b/src/WebJobs.Script/Workers/Rpc/Configuration/RpcWorkerConfigFactory.cs
@@ -140,7 +140,7 @@ internal void AddProvider(string workerDir)
                     {
                         workerDescription.DefaultWorkerPath = GetHydratedWorkerPath(workerDescription);
                     }
-                    workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory());
+                    workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory(), _logger);
                     _workerDescripionDictionary[workerDescription.Language] = workerDescription;
                 }
                 catch (Exception ex)
diff --git a/src/WebJobs.Script/Workers/Rpc/RpcWorkerDescription.cs b/src/WebJobs.Script/Workers/Rpc/RpcWorkerDescription.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
+using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 
 namespace Microsoft.Azure.WebJobs.Script.Workers.Rpc
@@ -65,7 +66,10 @@ public List<string> Extensions
             }
         }
 
-        public override void ApplyDefaultsAndValidate(string workerDirectory)
+        // Can be replaced for testing purposes
+        internal Func<string, bool> FileExists { private get; set; } = File.Exists;
+
+        public override void ApplyDefaultsAndValidate(string workerDirectory, ILogger logger)
         {
             if (workerDirectory == null)
             {
@@ -94,7 +98,7 @@ public override void ApplyDefaultsAndValidate(string workerDirectory)
                 throw new FileNotFoundException($"Did not find {nameof(DefaultWorkerPath)} for language: {Language}");
             }
 
-            ResolveDotNetDefaultExecutablePath();
+            ResolveDotNetDefaultExecutablePath(logger);
         }
 
         public void ValidateWorkerPath(string workerPath, OSPlatform os, Architecture architecture, string version)
@@ -139,14 +143,29 @@ private void ValidateRuntimeVersion(string version)
             }
         }
 
-        private void ResolveDotNetDefaultExecutablePath()
+        private void ResolveDotNetDefaultExecutablePath(ILogger logger)
         {
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
                 && (DefaultExecutablePath.Equals(RpcWorkerConstants.DotNetExecutableName, StringComparison.OrdinalIgnoreCase)
                     || DefaultExecutablePath.Equals(RpcWorkerConstants.DotNetExecutableNameWithExtension, StringComparison.OrdinalIgnoreCase)))
             {
                 var programFilesFolder = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
-                DefaultExecutablePath = Path.Combine(programFilesFolder, RpcWorkerConstants.DotNetFolderName, DefaultExecutablePath);
+
+                var fullPath = Path.Combine(
+                                    programFilesFolder,
+                                    RpcWorkerConstants.DotNetFolderName,
+                                    RpcWorkerConstants.DotNetExecutableNameWithExtension);
+
+                if (FileExists(fullPath))
+                {
+                    DefaultExecutablePath = fullPath;
+                }
+                else
+                {
+                    logger.Log(
+                        LogLevel.Warning,
+                        $"File '{fullPath}' is not found, '{DefaultExecutablePath}' invocation will rely on the PATH environment variable.");
+                }
             }
         }
     }
diff --git a/test/WebJobs.Script.Tests/Workers/Rpc/RpcWorkerConfigTests.cs b/test/WebJobs.Script.Tests/Workers/Rpc/RpcWorkerConfigTests.cs
@@ -244,17 +244,21 @@ public void ReadWorkerProviderFromConfig_OverrideDefaultExePath()
         [MemberData(nameof(InvalidWorkerDescriptions))]
         public void InvalidWorkerDescription_Throws(WorkerDescription workerDescription)
         {
-            Assert.Throws<ValidationException>(() => workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory()));
+            var testLogger = new TestLogger(testLanguage);
+
+            Assert.Throws<ValidationException>(() => workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory(), testLogger));
         }
 
         [Theory]
         [MemberData(nameof(ValidWorkerDescriptions))]
         public void ValidateWorkerDescription_Succeeds(WorkerDescription workerDescription)
         {
+            var testLogger = new TestLogger(testLanguage);
+
             try
             {
                 RpcWorkerConfigTestUtilities.CreateTestWorkerFileInCurrentDir();
-                workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory());
+                workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory(), testLogger);
             }
             finally
             {
@@ -267,26 +271,88 @@ public void ValidateWorkerDescription_Succeeds(WorkerDescription workerDescripti
         [InlineData("DotNet")]
         [InlineData("dotnet.exe")]
         [InlineData("DOTNET.EXE")]
-        public void ValidateWorkerDescription_ResolvesDotNetDefaultWorkerExecutablePath(string defaultExecutablePath)
+        public void ValidateWorkerDescription_ResolvesDotNetDefaultWorkerExecutablePath_WhenExpectedFileExists(
+            string defaultExecutablePath)
         {
+            var testLogger = new TestLogger(testLanguage);
+
             var expectedExecutablePath =
                 RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-                    ? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "dotnet", defaultExecutablePath)
+                    ? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "dotnet", "dotnet.exe")
                     : defaultExecutablePath;
 
-            var workerDescription = new RpcWorkerDescription { Language = testLanguage, Extensions = new List<string>(), DefaultExecutablePath = defaultExecutablePath };
-            workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory());
+            var workerDescription = new RpcWorkerDescription
+            {
+                Language = testLanguage,
+                Extensions = new List<string>(),
+                DefaultExecutablePath = defaultExecutablePath,
+                FileExists = path =>
+                                {
+                                    Assert.Equal(expectedExecutablePath, path);
+                                    return true;
+                                }
+            };
+
+            workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory(), testLogger);
             Assert.Equal(expectedExecutablePath, workerDescription.DefaultExecutablePath);
         }
 
+        [Theory]
+        [InlineData("dotnet")]
+        [InlineData("DotNet")]
+        [InlineData("dotnet.exe")]
+        [InlineData("DOTNET.EXE")]
+        public void ValidateWorkerDescription_DoesNotModifyDefaultWorkerExecutablePathAndWarns_WhenExpectedFileDoesNotExist(
+            string defaultExecutablePath)
+        {
+            var testLogger = new TestLogger(testLanguage);
+
+            var expectedExecutablePath =
+                RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+                    ? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "dotnet", "dotnet.exe")
+                    : defaultExecutablePath;
+
+            var workerDescription = new RpcWorkerDescription
+            {
+                Language = testLanguage,
+                Extensions = new List<string>(),
+                DefaultExecutablePath = defaultExecutablePath,
+                FileExists = path =>
+                                {
+                                    Assert.Equal(expectedExecutablePath, path);
+                                    return false;
+                                }
+            };
+
+            workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory(), testLogger);
+            Assert.Equal(defaultExecutablePath, workerDescription.DefaultExecutablePath);
+            Assert.True(testLogger.GetLogMessages().Any(message => message.Level == LogLevel.Warning
+                                                                   && message.FormattedMessage.Contains(defaultExecutablePath)
+                                                                   && message.FormattedMessage.Contains(expectedExecutablePath)));
+        }
+
         [Theory]
         [InlineData(@"D:\CustomExecutableFolder\dotnet")]
         [InlineData(@"/CustomExecutableFolder/dotnet")]
         [InlineData("AnythingElse")]
-        public void ValidateWorkerDescription_DoesNotModifyDefaultWorkerExecutablePath_WhenDoesNotStrictlyMatchDotNet(string defaultExecutablePath)
+        public void ValidateWorkerDescription_DoesNotModifyDefaultWorkerExecutablePath_WhenDoesNotStrictlyMatchDotNet(
+            string defaultExecutablePath)
         {
-            var workerDescription = new RpcWorkerDescription { Language = testLanguage, Extensions = new List<string>(), DefaultExecutablePath = defaultExecutablePath };
-            workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory());
+            var testLogger = new TestLogger(testLanguage);
+
+            var workerDescription = new RpcWorkerDescription
+            {
+                Language = testLanguage,
+                Extensions = new List<string>(),
+                DefaultExecutablePath = defaultExecutablePath,
+                FileExists = path =>
+                                {
+                                    Assert.True(false, "FileExists should not be called");
+                                    return false;
+                                }
+            };
+
+            workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory(), testLogger);
             Assert.Equal(defaultExecutablePath, workerDescription.DefaultExecutablePath);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public void Configure(HttpWorkerOptions options)`
`36`	`36`	`{`
`37`	`37`	`throw new HostConfigurationException($"Missing WorkerDescription for HttpWorker");`
`38`	`38`	`}`
`39`		`- httpWorkerDescription.ApplyDefaultsAndValidate(_scriptJobHostOptions.RootScriptPath);`
	`39`	`+ httpWorkerDescription.ApplyDefaultsAndValidate(_scriptJobHostOptions.RootScriptPath, _logger);`
`40`	`40`	`options.Arguments = new WorkerProcessArguments()`
`41`	`41`	`{`
`42`	`42`	`ExecutablePath = options.Description.DefaultExecutablePath,`
Original file line number	Diff line number	Diff line change
`@@ -5,12 +5,13 @@`
`5`	`5`	`using System.Collections.Generic;`
`6`	`6`	`using System.ComponentModel.DataAnnotations;`
`7`	`7`	`using System.IO;`
	`8`	`+using Microsoft.Extensions.Logging;`
`8`	`9`
`9`	`10`	`namespace Microsoft.Azure.WebJobs.Script.Workers.Http`
`10`	`11`	`{`
`11`	`12`	`public class HttpWorkerDescription : WorkerDescription`
`12`	`13`	`{`
`13`		`- public override void ApplyDefaultsAndValidate(string workerDirectory)`
	`14`	`+ public override void ApplyDefaultsAndValidate(string workerDirectory, ILogger logger)`
`14`	`15`	`{`
`15`	`16`	`if (workerDirectory == null)`
`16`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// Licensed under the MIT License. See License.txt in the project root for license information.`
`3`	`3`
`4`	`4`	`using System.Collections.Generic;`
	`5`	`+using Microsoft.Extensions.Logging;`
`5`	`6`
`6`	`7`	`namespace Microsoft.Azure.WebJobs.Script.Workers`
`7`	`8`	`{`
`@@ -27,6 +28,6 @@ public abstract class WorkerDescription`
`27`	`28`	`/// </summary>`
`28`	`29`	`public List<string> Arguments { get; set; }`
`29`	`30`
`30`		`- public abstract void ApplyDefaultsAndValidate(string workerDirectory);`
	`31`	`+ public abstract void ApplyDefaultsAndValidate(string workerDirectory, ILogger logger);`
`31`	`32`	`}`
`32`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ internal void AddProvider(string workerDir)`
`140`	`140`	`{`
`141`	`141`	`workerDescription.DefaultWorkerPath = GetHydratedWorkerPath(workerDescription);`
`142`	`142`	`}`
`143`		`- workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory());`
	`143`	`+ workerDescription.ApplyDefaultsAndValidate(Directory.GetCurrentDirectory(), _logger);`
`144`	`144`	`_workerDescripionDictionary[workerDescription.Language] = workerDescription;`
`145`	`145`	`}`
`146`	`146`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`using System.IO;`
`8`	`8`	`using System.Linq;`
`9`	`9`	`using System.Runtime.InteropServices;`
	`10`	`+using Microsoft.Extensions.Logging;`
`10`	`11`	`using Newtonsoft.Json;`
`11`	`12`
`12`	`13`	`namespace Microsoft.Azure.WebJobs.Script.Workers.Rpc`
`@@ -65,7 +66,10 @@ public List<string> Extensions`
`65`	`66`	`}`
`66`	`67`	`}`
`67`	`68`
`68`		`- public override void ApplyDefaultsAndValidate(string workerDirectory)`
	`69`	`+ // Can be replaced for testing purposes`
	`70`	`+ internal Func<string, bool> FileExists { private get; set; } = File.Exists;`
	`71`	`+`
	`72`	`+ public override void ApplyDefaultsAndValidate(string workerDirectory, ILogger logger)`
`69`	`73`	`{`
`70`	`74`	`if (workerDirectory == null)`
`71`	`75`	`{`
`@@ -94,7 +98,7 @@ public override void ApplyDefaultsAndValidate(string workerDirectory)`
`94`	`98`	`throw new FileNotFoundException($"Did not find {nameof(DefaultWorkerPath)} for language: {Language}");`
`95`	`99`	`}`
`96`	`100`
`97`		`- ResolveDotNetDefaultExecutablePath();`
	`101`	`+ ResolveDotNetDefaultExecutablePath(logger);`
`98`	`102`	`}`
`99`	`103`
`100`	`104`	`public void ValidateWorkerPath(string workerPath, OSPlatform os, Architecture architecture, string version)`
`@@ -139,14 +143,29 @@ private void ValidateRuntimeVersion(string version)`
`139`	`143`	`}`
`140`	`144`	`}`
`141`	`145`
`142`		`- private void ResolveDotNetDefaultExecutablePath()`
	`146`	`+ private void ResolveDotNetDefaultExecutablePath(ILogger logger)`
`143`	`147`	`{`
`144`	`148`	`if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)`
`145`	`149`	`&& (DefaultExecutablePath.Equals(RpcWorkerConstants.DotNetExecutableName, StringComparison.OrdinalIgnoreCase)`
`146`	`150`	`\|\| DefaultExecutablePath.Equals(RpcWorkerConstants.DotNetExecutableNameWithExtension, StringComparison.OrdinalIgnoreCase)))`
`147`	`151`	`{`
`148`	`152`	`var programFilesFolder = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);`
`149`		`- DefaultExecutablePath = Path.Combine(programFilesFolder, RpcWorkerConstants.DotNetFolderName, DefaultExecutablePath);`
	`153`	`+`
	`154`	`+ var fullPath = Path.Combine(`
	`155`	`+ programFilesFolder,`
	`156`	`+ RpcWorkerConstants.DotNetFolderName,`
	`157`	`+ RpcWorkerConstants.DotNetExecutableNameWithExtension);`
	`158`	`+`
	`159`	`+ if (FileExists(fullPath))`
	`160`	`+ {`
	`161`	`+ DefaultExecutablePath = fullPath;`
	`162`	`+ }`
	`163`	`+ else`
	`164`	`+ {`
	`165`	`+ logger.Log(`
	`166`	`+ LogLevel.Warning,`
	`167`	`+ $"File '{fullPath}' is not found, '{DefaultExecutablePath}' invocation will rely on the PATH environment variable.");`
	`168`	`+ }`
`150`	`169`	`}`
`151`	`170`	`}`
`152`	`171`	`}`