Refactor RpcInitializationService and add unit tests (#3861)

Author: pragnagopa

src/WebJobs.Script/Description/Rpc/ScriptInvocationResult.cs

@@ -5,7 +5,7 @@
 
 namespace Microsoft.Azure.WebJobs.Script.Description
 {
-    public class ScriptInvocationResult
+    internal class ScriptInvocationResult
     {
         public object Return { get; set; }
 

src/WebJobs.Script/Rpc/FunctionRegistration/FunctionDispatcher.cs

@@ -16,7 +16,7 @@
 
 namespace Microsoft.Azure.WebJobs.Script.Rpc
 {
-    public class FunctionDispatcher : IFunctionDispatcher
+    internal class FunctionDispatcher : IFunctionDispatcher
     {
         private IScriptEventManager _eventManager;
         private IMetricsLogger _metricsLogger;

src/WebJobs.Script/Rpc/ILanguageWorkerChannelManager.cs

@@ -10,7 +10,7 @@ namespace Microsoft.Azure.WebJobs.Script.Rpc
 {
     public interface ILanguageWorkerChannelManager
     {
-        Task InitializeAsync();
+        Task InitializeChannelAsync(string language);
 
         ILanguageWorkerChannel GetChannel(string language);
 

src/WebJobs.Script/Rpc/LanguageWorkerChannel.cs

@@ -24,7 +24,7 @@
 
 namespace Microsoft.Azure.WebJobs.Script.Rpc
 {
-    public class LanguageWorkerChannel : ILanguageWorkerChannel
+    internal class LanguageWorkerChannel : ILanguageWorkerChannel
     {
         private readonly TimeSpan processStartTimeout = TimeSpan.FromSeconds(40);
         private readonly TimeSpan workerInitTimeout = TimeSpan.FromSeconds(30);

src/WebJobs.Script/Rpc/LanguageWorkerChannelManager.cs

@@ -16,11 +16,6 @@ namespace Microsoft.Azure.WebJobs.Script.Rpc
 {
     public class LanguageWorkerChannelManager : ILanguageWorkerChannelManager
     {
-        private readonly IEnumerable<string> _languages = new List<string>()
-        {
-            LanguageWorkerConstants.JavaLanguageWorkerName
-        };
-
         private readonly IEnumerable<WorkerConfig> _workerConfigs = null;
         private readonly ILogger _logger = null;
         private readonly TimeSpan processStartTimeout = TimeSpan.FromSeconds(40);
@@ -83,40 +78,18 @@ public ILanguageWorkerChannel CreateLanguageWorkerChannel(string workerId, strin
                          attemptCount);
         }
 
-        public Task InitializeAsync()
-        {
-            _workerRuntime = _environment.GetEnvironmentVariable(LanguageWorkerConstants.FunctionWorkerRuntimeSettingName);
-            if (SystemEnvironment.Instance.IsLinuxAppServiceEnvironment())
-            {
-                return Task.CompletedTask;
-            }
-            if (SystemEnvironment.Instance.IsLinuxContainerEnvironment())
-            {
-                return Task.CompletedTask;
-            }
-            if (string.IsNullOrEmpty(_workerRuntime))
-            {
-                return Task.WhenAll(_languages.Select(language => InitializeChannelAsync(language)));
-            }
-            if (_languages.Contains(_workerRuntime))
-            {
-                return InitializeChannelAsync(_workerRuntime);
-            }
-            return Task.CompletedTask;
-        }
-
-        internal async Task InitializeChannelAsync(string language)
+        public async Task InitializeChannelAsync(string runtime)
         {
-            _logger?.LogDebug("Initializing language worker channel for {runtime}:", language);
-            await InitializeLanguageWorkerChannel(language, _applicationHostOptions.CurrentValue.ScriptPath);
+            _logger?.LogDebug("Initializing language worker channel for runtime:{runtime}", runtime);
+            await InitializeLanguageWorkerChannel(runtime, _applicationHostOptions.CurrentValue.ScriptPath);
         }
 
         private async Task InitializeLanguageWorkerChannel(string language, string scriptRootPath)
         {
             try
             {
                 string workerId = Guid.NewGuid().ToString();
-                _logger.LogInformation($"Creating language worker channel for runtime", language);
+                _logger.LogInformation("Creating language worker channel for runtime:{runtime}", language);
                 ILanguageWorkerChannel languageWorkerChannel = CreateLanguageWorkerChannel(workerId, scriptRootPath, language, null, null, 0);
                 languageWorkerChannel.StartWorkerProcess();
                 IObservable<RpcChannelReadyEvent> rpcChannelReadyEvent = _eventManager.OfType<RpcChannelReadyEvent>()

src/WebJobs.Script/Rpc/LanguageWorkerChannelUtilities.cs

@@ -9,7 +9,7 @@
 
 namespace Microsoft.Azure.WebJobs.Script.Rpc
 {
-    public static class LanguageWorkerChannelUtilities
+    internal static class LanguageWorkerChannelUtilities
     {
         private static int maxNumberOfErrorMessages = 3;
 

src/WebJobs.Script/Rpc/ProcessManagement/IWorkerProcessFactory.cs

@@ -5,7 +5,7 @@
 
 namespace Microsoft.Azure.WebJobs.Script.Rpc
 {
-    public interface IWorkerProcessFactory
+    internal interface IWorkerProcessFactory
     {
         // TODO: create an abstraction like Executable in the cli which wraps the process
         Process CreateWorkerProcess(WorkerContext context);

src/WebJobs.Script/Rpc/ProcessManagement/WorkerContext.cs

@@ -7,7 +7,7 @@
 namespace Microsoft.Azure.WebJobs.Script.Rpc
 {
     // Arguments to start a worker process
-    public class WorkerContext
+    internal class WorkerContext
     {
         public Uri ServerUri { get; set; }
 

src/WebJobs.Script/Rpc/RpcInitializationService.cs

@@ -16,16 +16,22 @@ namespace Microsoft.Azure.WebJobs.Script.Rpc
     public class RpcInitializationService : IHostedService
     {
         private readonly IOptionsMonitor<ScriptApplicationHostOptions> _applicationHostOptions;
-
+        private readonly IEnvironment _environment;
         private readonly ILanguageWorkerChannelManager _languageWorkerChannelManager;
         private readonly IRpcServer _rpcServer;
         private readonly ILogger _logger;
 
-        public RpcInitializationService(IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions, IRpcServer rpcServer, ILanguageWorkerChannelManager languageWorkerChannelManager, ILoggerFactory loggerFactory)
+        private List<string> _languages = new List<string>()
+        {
+            LanguageWorkerConstants.JavaLanguageWorkerName
+        };
+
+        public RpcInitializationService(IOptionsMonitor<ScriptApplicationHostOptions> applicationHostOptions, IEnvironment environment, IRpcServer rpcServer, ILanguageWorkerChannelManager languageWorkerChannelManager, ILoggerFactory loggerFactory)
         {
             _applicationHostOptions = applicationHostOptions ?? throw new ArgumentNullException(nameof(applicationHostOptions));
             _logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryRpcInitializationService);
             _rpcServer = rpcServer;
+            _environment = environment;
             _languageWorkerChannelManager = languageWorkerChannelManager ?? throw new ArgumentNullException(nameof(languageWorkerChannelManager));
         }
 
@@ -35,19 +41,19 @@ public async Task StartAsync(CancellationToken cancellationToken)
             {
                 return;
             }
-            _logger.LogInformation("Initializing Rpc Channels Manager");
+            _logger.LogInformation("Starting Rpc Initialization Service.");
             await InitializeRpcServerAsync();
-            await _languageWorkerChannelManager.InitializeAsync();
+            await InitializeChannelsAsync();
         }
 
         public async Task StopAsync(CancellationToken cancellationToken)
         {
             _logger.LogInformation("Shuttingdown Rpc Channels Manager");
-            await _rpcServer.KillAsync();
             await _languageWorkerChannelManager.ShutdownChannelsAsync();
+            await _rpcServer.KillAsync();
         }
 
-        private async Task InitializeRpcServerAsync()
+        internal async Task InitializeRpcServerAsync()
         {
             try
             {
@@ -59,5 +65,31 @@ private async Task InitializeRpcServerAsync()
                 var hostInitEx = new HostInitializationException($"Failed to start Rpc Server. Check if your app is hitting connection limits.", grpcInitEx);
             }
         }
+
+        internal Task InitializeChannelsAsync()
+        {
+            string workerRuntime = _environment.GetEnvironmentVariable(LanguageWorkerConstants.FunctionWorkerRuntimeSettingName);
+            if (_environment.IsLinuxAppServiceEnvironment())
+            {
+                return Task.CompletedTask;
+            }
+            if (_environment.IsLinuxContainerEnvironment())
+            {
+                return Task.CompletedTask;
+            }
+            if (string.IsNullOrEmpty(workerRuntime) && _environment.IsPlaceholderModeEnabled())
+            {
+                // Only warm up language workers in placeholder mode in worker runtime is not set
+                return Task.WhenAll(_languages.Select(runtime => _languageWorkerChannelManager.InitializeChannelAsync(runtime)));
+            }
+            if (_languages.Contains(workerRuntime))
+            {
+                return _languageWorkerChannelManager.InitializeChannelAsync(workerRuntime);
+            }
+            return Task.CompletedTask;
+        }
+
+        // To help with unit tests
+        internal void AddSupportedRuntime(string language) => _languages.Add(language);
     }
 }

test/WebJobs.Script.Tests.Shared/TestHelpers.cs

@@ -13,6 +13,7 @@
 using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Script.Abstractions;
 using Microsoft.Azure.WebJobs.Script.Rpc;
+using Microsoft.Azure.WebJobs.Script.WebHost;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Options;
 using Microsoft.WindowsAzure.Storage.Blob;
@@ -260,6 +261,15 @@ public static IList<WorkerConfig> GetTestWorkerConfigs()
             };
         }
 
+        public static string CreateOfflineFile(string rootPath)
+        {
+            // create a test offline file
+            var offlineFilePath = Path.Combine(Path.GetTempPath(), ScriptConstants.AppOfflineFileName);
+            string content = FileUtility.ReadResourceString($"{ScriptConstants.ResourcePath}.{ScriptConstants.AppOfflineFileName}", typeof(HttpException).Assembly);
+            File.WriteAllText(offlineFilePath, content);
+            return offlineFilePath;
+        }
+
         public static WorkerDescription GetTestWorkerDescription(string language, string extension)
         {
             return new WorkerDescription()