Hydrate worker path with version/os/arch (#4985)

maiqbal11 · pragnagopa · commit ebc3adfba046 · 2019-10-04T09:24:14.000-07:00
diff --git a/src/WebJobs.Script.Grpc/Abstractions/WorkerDescription.cs b/src/WebJobs.Script.Grpc/Abstractions/WorkerDescription.cs
@@ -15,12 +15,36 @@ public class WorkerDescription
         [JsonProperty(PropertyName = "language")]
         public string Language { get; set; }
 
+        /// <summary>
+        /// Gets or sets the default runtime version.
+        /// </summary>
+        [JsonProperty(PropertyName = "defaultRuntimeVersion")]
+        public string DefaultRuntimeVersion { get; set; }
+
         /// <summary>
         /// Gets or sets the supported file extension type. Functions are registered with workers based on extension.
         /// </summary>
         [JsonProperty(PropertyName = "extensions")]
         public List<string> Extensions { get; set; }
 
+        /// <summary>
+        /// Gets or sets the supported architectures for this runtime.
+        /// </summary>
+        [JsonProperty(PropertyName = "supportedArchitectures")]
+        public List<string> SupportedArchitectures { get; set; }
+
+        /// <summary>
+        /// Gets or sets the supported operating systems for this runtime.
+        /// </summary>
+        [JsonProperty(PropertyName = "supportedOperatingSystems")]
+        public List<string> SupportedOperatingSystems { get; set; }
+
+        /// <summary>
+        /// Gets or sets the supported versions for this runtime.
+        /// </summary>
+        [JsonProperty(PropertyName = "supportedRuntimeVersions")]
+        public List<string> SupportedRuntimeVersions { get; set; }
+
         /// <summary>
         /// Gets or sets the default executable path.
         /// </summary>
diff --git a/src/WebJobs.Script.Grpc/Abstractions/WorkerDescriptionExtensions.cs b/src/WebJobs.Script.Grpc/Abstractions/WorkerDescriptionExtensions.cs
@@ -1,12 +1,19 @@
 ﻿// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
+using System;
 using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.Azure.WebJobs.Script.Abstractions
 {
     public static class WorkerDescriptionExtensions
     {
+        public const string OSPlaceholder = "{os}";
+        public const string ArchitecturePlaceholder = "{architecture}";
+        public const string RuntimeVersionPlaceholder = "%FUNCTIONS_WORKER_RUNTIME_VERSION%";
+
         public static void Validate(this WorkerDescription workerDescription)
         {
             if (string.IsNullOrEmpty(workerDescription.Language))
@@ -22,5 +29,51 @@ public static void Validate(this WorkerDescription workerDescription)
                 throw new ValidationException($"WorkerDescription {nameof(workerDescription.DefaultExecutablePath)} cannot be empty");
             }
         }
+
+        public static void ValidateWorkerPath(this WorkerDescription description, string workerPath, OSPlatform os, Architecture architecture, string version)
+        {
+            string language = description.Language;
+            if (workerPath.Contains(OSPlaceholder))
+            {
+                ValidateOSPlatform(description, os);
+            }
+
+            if (workerPath.Contains(ArchitecturePlaceholder))
+            {
+                ValidateArchitecture(description, architecture);
+            }
+
+            if (workerPath.Contains(RuntimeVersionPlaceholder) && !string.IsNullOrEmpty(version))
+            {
+                ValidateRuntimeVersion(description, version);
+            }
+        }
+
+        private static void ValidateOSPlatform(this WorkerDescription description, OSPlatform os)
+        {
+            string language = description.Language;
+            if (!description.SupportedOperatingSystems.Any(s => s.Equals(os.ToString(), StringComparison.OrdinalIgnoreCase)))
+            {
+                throw new PlatformNotSupportedException($"OS {os.ToString()} is not supported for language {language}");
+            }
+        }
+
+        private static void ValidateArchitecture(this WorkerDescription description, Architecture architecture)
+        {
+            string language = description.Language;
+            if (!description.SupportedArchitectures.Any(s => s.Equals(architecture.ToString(), StringComparison.OrdinalIgnoreCase)))
+            {
+                throw new PlatformNotSupportedException($"Architecture {architecture.ToString()} is not supported for language {language}");
+            }
+        }
+
+        private static void ValidateRuntimeVersion(this WorkerDescription description, string version)
+        {
+            string language = description.Language;
+            if (!description.SupportedRuntimeVersions.Any(s => s.Equals(version, StringComparison.OrdinalIgnoreCase)))
+            {
+                throw new NotSupportedException($"Version {version} is not supported for language {language}");
+            }
+        }
     }
 }
diff --git a/src/WebJobs.Script/Rpc/Configuration/LanguageWorkerOptionsSetup.cs b/src/WebJobs.Script/Rpc/Configuration/LanguageWorkerOptionsSetup.cs
@@ -1,6 +1,7 @@
 ﻿// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
+using System.Collections;
 using System.Collections.Generic;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
@@ -12,16 +13,19 @@ internal class LanguageWorkerOptionsSetup : IConfigureOptions<LanguageWorkerOpti
     {
         private IConfiguration _configuration;
         private ILogger _logger;
+        private IEnvironment _environment;
 
-        public LanguageWorkerOptionsSetup(IConfiguration configuration, ILoggerFactory loggerFactory)
+        public LanguageWorkerOptionsSetup(IConfiguration configuration, ILoggerFactory loggerFactory, IEnvironment environment)
         {
             _configuration = configuration;
             _logger = loggerFactory.CreateLogger("Host.LanguageWorkerConfig");
+            _environment = environment;
         }
 
         public void Configure(LanguageWorkerOptions options)
         {
-            var configFactory = new WorkerConfigFactory(_configuration, _logger);
+            ISystemRuntimeInformation systemRuntimeInfo = new SystemRuntimeInformation();
+            var configFactory = new WorkerConfigFactory(_configuration, _logger, systemRuntimeInfo, _environment);
             options.WorkerConfigs = configFactory.GetConfigs();
         }
     }
diff --git a/src/WebJobs.Script/Rpc/Configuration/WorkerConfigFactory.cs b/src/WebJobs.Script/Rpc/Configuration/WorkerConfigFactory.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
 using Microsoft.Azure.WebJobs.Script.Abstractions;
 using Microsoft.Azure.WebJobs.Script.Config;
@@ -19,12 +20,16 @@ internal class WorkerConfigFactory
     {
         private readonly IConfiguration _config;
         private readonly ILogger _logger;
+        private readonly ISystemRuntimeInformation _systemRuntimeInformation;
+        private readonly IEnvironment _environment;
         private Dictionary<string, IWorkerProvider> _workerProviderDictionary = new Dictionary<string, IWorkerProvider>();
 
-        public WorkerConfigFactory(IConfiguration config, ILogger logger)
+        public WorkerConfigFactory(IConfiguration config, ILogger logger, ISystemRuntimeInformation systemRuntimeInfo, IEnvironment environment)
         {
             _config = config ?? throw new ArgumentNullException(nameof(config));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _systemRuntimeInformation = systemRuntimeInfo ?? throw new ArgumentNullException(nameof(systemRuntimeInfo));
+            _environment = environment ?? throw new ArgumentNullException(nameof(environment));
             WorkersDirPath = Path.Combine(Path.GetDirectoryName(new Uri(typeof(WorkerConfigFactory).Assembly.CodeBase).LocalPath), LanguageWorkerConstants.DefaultWorkersDirectoryName);
             var workersDirectorySection = _config.GetSection($"{LanguageWorkerConstants.LanguageWorkersSectionName}:{LanguageWorkerConstants.WorkersDirectorySectionName}");
             if (!string.IsNullOrEmpty(workersDirectorySection.Value))
@@ -47,10 +52,17 @@ public IList<WorkerConfig> GetConfigs()
                 var description = provider.GetDescription();
                 _logger.LogDebug($"Worker path for language worker {description.Language}: {description.WorkerDirectory}");
 
+                string workerPath = description.GetWorkerPath();
+
+                if (IsHydrationNeeded(workerPath))
+                {
+                    workerPath = GetHydratedWorkerPath(description);
+                }
+
                 var arguments = new WorkerProcessArguments()
                 {
                     ExecutablePath = description.DefaultExecutablePath,
-                    WorkerPath = description.GetWorkerPath()
+                    WorkerPath = workerPath
                 };
 
                 if (description.Language.Equals(LanguageWorkerConstants.JavaLanguageWorkerName))
@@ -133,6 +145,12 @@ internal void AddProvider(string workerDir)
                 AddArgumentsFromAppSettings(workerDescription, languageSection);
 
                 string workerPath = workerDescription.GetWorkerPath();
+
+                if (IsHydrationNeeded(workerPath))
+                {
+                    workerPath = GetHydratedWorkerPath(workerDescription);
+                }
+
                 if (string.IsNullOrEmpty(workerPath) || File.Exists(workerPath))
                 {
                     _logger.LogDebug($"Will load worker provider for language: {workerDescription.Language}");
@@ -220,5 +238,41 @@ internal string GetExecutablePathForJava(string defaultExecutablePath)
                 return Path.GetFullPath(Path.Combine(javaHome, "bin", defaultExecutablePath));
             }
         }
+
+        internal bool IsHydrationNeeded(string workerPath)
+        {
+            if (string.IsNullOrEmpty(workerPath))
+            {
+                return false;
+            }
+
+            return workerPath.Contains(LanguageWorkerConstants.OSPlaceholder) ||
+                    workerPath.Contains(LanguageWorkerConstants.ArchitecturePlaceholder) ||
+                    workerPath.Contains(LanguageWorkerConstants.RuntimeVersionPlaceholder);
+        }
+
+        internal string GetHydratedWorkerPath(WorkerDescription description)
+        {
+            string workerPath = description.GetWorkerPath();
+            if (string.IsNullOrEmpty(workerPath))
+            {
+                return null;
+            }
+
+            OSPlatform os = _systemRuntimeInformation.GetOSPlatform();
+
+            Architecture architecture = _systemRuntimeInformation.GetOSArchitecture();
+            string version = _environment.GetEnvironmentVariable(LanguageWorkerConstants.FunctionWorkerRuntimeVersionSettingName);
+            if (string.IsNullOrEmpty(version))
+            {
+                version = description.DefaultRuntimeVersion;
+            }
+
+            description.ValidateWorkerPath(workerPath, os, architecture, version);
+
+            return workerPath.Replace(LanguageWorkerConstants.OSPlaceholder, os.ToString())
+                             .Replace(LanguageWorkerConstants.ArchitecturePlaceholder, architecture.ToString())
+                             .Replace(LanguageWorkerConstants.RuntimeVersionPlaceholder, version);
+        }
     }
 }
diff --git a/src/WebJobs.Script/Rpc/LanguageWorkerConstants.cs b/src/WebJobs.Script/Rpc/LanguageWorkerConstants.cs
@@ -9,6 +9,7 @@ public static class LanguageWorkerConstants
     {
         public const int ProcessStartTimeoutSeconds = 60;
         public const string FunctionWorkerRuntimeSettingName = "FUNCTIONS_WORKER_RUNTIME";
+        public const string FunctionWorkerRuntimeVersionSettingName = "FUNCTIONS_WORKER_RUNTIME_VERSION";
         public const string FunctionsWorkerProcessCountSettingName = "FUNCTIONS_WORKER_PROCESS_COUNT";
         public const string DotNetLanguageWorkerName = "dotnet";
         public const string NodeLanguageWorkerName = "node";
@@ -29,6 +30,9 @@ public static class LanguageWorkerConstants
         public const string WorkerDescriptionDefaultWorkerPath = "defaultWorkerPath";
         public const string WorkerDescription = "description";
         public const string WorkerDescriptionArguments = "arguments";
+        public const string OSPlaceholder = "{os}";
+        public const string ArchitecturePlaceholder = "{architecture}";
+        public const string RuntimeVersionPlaceholder = "%FUNCTIONS_WORKER_RUNTIME_VERSION%";
 
         // Profiles
         public const string WorkerDescriptionProfiles = "profiles";
diff --git a/src/WebJobs.Script/Rpc/RuntimeInformation/ISystemRuntimeInformation.cs b/src/WebJobs.Script/Rpc/RuntimeInformation/ISystemRuntimeInformation.cs
@@ -0,0 +1,14 @@
+﻿// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Azure.WebJobs.Script.Rpc
+{
+    public interface ISystemRuntimeInformation
+    {
+        Architecture GetOSArchitecture();
+
+        OSPlatform GetOSPlatform();
+    }
+}
diff --git a/src/WebJobs.Script/Rpc/RuntimeInformation/SystemRuntimeInformation.cs b/src/WebJobs.Script/Rpc/RuntimeInformation/SystemRuntimeInformation.cs
@@ -0,0 +1,34 @@
+﻿// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Azure.WebJobs.Script.Rpc
+{
+    public class SystemRuntimeInformation : ISystemRuntimeInformation
+    {
+        public Architecture GetOSArchitecture()
+        {
+            return RuntimeInformation.OSArchitecture;
+        }
+
+        public OSPlatform GetOSPlatform()
+        {
+            OSPlatform os;
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                os = OSPlatform.Windows;
+            }
+            else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+            {
+                os = OSPlatform.OSX;
+            }
+            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                os = OSPlatform.Linux;
+            }
+
+            return os;
+        }
+    }
+}
diff --git a/test/WebJobs.Script.Tests/Rpc/GenericWorkerProviderTests.cs b/test/WebJobs.Script.Tests/Rpc/GenericWorkerProviderTests.cs
@@ -8,6 +8,7 @@
 using System.Linq;
 using Microsoft.Azure.WebJobs.Script.Abstractions;
 using Microsoft.Azure.WebJobs.Script.Config;
+using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Rpc;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
@@ -253,7 +254,9 @@ private IEnumerable<IWorkerProvider> TestReadWorkerProviderFromConfig(IEnumerabl
 
                 var scriptHostOptions = new ScriptJobHostOptions();
                 var scriptSettingsManager = new ScriptSettingsManager(config);
-                var configFactory = new WorkerConfigFactory(config, testLogger);
+                var testSysRuntimeInfo = new TestSystemRuntimeInformation();
+                var environment = new TestEnvironment();
+                var configFactory = new WorkerConfigFactory(config, testLogger, testSysRuntimeInfo, environment);
                 if (appSvcEnv)
                 {
                     var testEnvVariables = new Dictionary<string, string>
diff --git a/test/WebJobs.Script.Tests/Rpc/WorkerConfigFactoryTests.cs b/test/WebJobs.Script.Tests/Rpc/WorkerConfigFactoryTests.cs
diff --git a/test/WebJobs.Script.Tests/RuntimeInformation/TestSystemRuntimeInformation.cs b/test/WebJobs.Script.Tests/RuntimeInformation/TestSystemRuntimeInformation.cs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`// Copyright (c) .NET Foundation. All rights reserved.`
`2`	`2`	`// Licensed under the MIT License. See License.txt in the project root for license information.`
`3`	`3`
	`4`	`+using System.Collections;`
`4`	`5`	`using System.Collections.Generic;`
`5`	`6`	`using Microsoft.Extensions.Configuration;`
`6`	`7`	`using Microsoft.Extensions.Logging;`
`@@ -12,16 +13,19 @@ internal class LanguageWorkerOptionsSetup : IConfigureOptions<LanguageWorkerOpti`
`12`	`13`	`{`
`13`	`14`	`private IConfiguration _configuration;`
`14`	`15`	`private ILogger _logger;`
	`16`	`+ private IEnvironment _environment;`
`15`	`17`
`16`		`- public LanguageWorkerOptionsSetup(IConfiguration configuration, ILoggerFactory loggerFactory)`
	`18`	`+ public LanguageWorkerOptionsSetup(IConfiguration configuration, ILoggerFactory loggerFactory, IEnvironment environment)`
`17`	`19`	`{`
`18`	`20`	`_configuration = configuration;`
`19`	`21`	`_logger = loggerFactory.CreateLogger("Host.LanguageWorkerConfig");`
	`22`	`+ _environment = environment;`
`20`	`23`	`}`
`21`	`24`
`22`	`25`	`public void Configure(LanguageWorkerOptions options)`
`23`	`26`	`{`
`24`		`- var configFactory = new WorkerConfigFactory(_configuration, _logger);`
	`27`	`+ ISystemRuntimeInformation systemRuntimeInfo = new SystemRuntimeInformation();`
	`28`	`+ var configFactory = new WorkerConfigFactory(_configuration, _logger, systemRuntimeInfo, _environment);`
`25`	`29`	`options.WorkerConfigs = configFactory.GetConfigs();`
`26`	`30`	`}`
`27`	`31`	`}`