Refactor and clean up based on the dependency management changes (Azure#194)

daxian-dbw · web-flow · commit 61aabba69a7c · 2019-04-26T20:08:30.000-07:00
diff --git a/src/DependencyManagement/DependencyManager.cs b/src/DependencyManagement/DependencyManager.cs
@@ -3,25 +3,25 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
-using Microsoft.Azure.WebJobs.Script.Grpc.Messages;
 using System;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Azure.Functions.PowerShellWorker.PowerShell;
 using Microsoft.Azure.Functions.PowerShellWorker.Utility;
-using LogLevel = Microsoft.Azure.WebJobs.Script.Grpc.Messages.RpcLog.Types.Level;
 using Microsoft.Azure.Functions.PowerShellWorker.Messaging;
+using Microsoft.Azure.WebJobs.Script.Grpc.Messages;
+using LogLevel = Microsoft.Azure.WebJobs.Script.Grpc.Messages.RpcLog.Types.Level;
 
 namespace Microsoft.Azure.Functions.PowerShellWorker.DependencyManagement
 {
     using System.Management.Automation;
     using System.Management.Automation.Language;
     using System.Management.Automation.Runspaces;
-    using System.Threading.Tasks;
 
     internal class DependencyManager
     {
@@ -122,18 +122,9 @@ private void ProcessDependencies(RpcLogger rpcLogger)
             try
             {
                 _dependencyError = null;
-                var initialSessionState = InitialSessionState.CreateDefault();
-                initialSessionState.ThreadOptions = PSThreadOptions.UseCurrentThread;
-                initialSessionState.EnvironmentVariables.Add(new SessionStateVariableEntry("PSModulePath", FunctionLoader.FunctionModulePath, null));
-                // Setting the execution policy on macOS and Linux throws an exception so only update it on Windows
-                if (Platform.IsWindows)
-                {
-                    initialSessionState.ExecutionPolicy = Microsoft.PowerShell.ExecutionPolicy.Unrestricted;
-                }
-
-                using (PowerShell powerShellInstance = PowerShell.Create(initialSessionState))
+                using (PowerShell pwsh = PowerShell.Create(Utils.SingletonISS.Value))
                 {
-                    InstallFunctionAppDependencies(powerShellInstance, rpcLogger);
+                    InstallFunctionAppDependencies(pwsh, rpcLogger);
                 }
             }
             catch (Exception e)
@@ -152,6 +143,11 @@ private void ProcessDependencies(RpcLogger rpcLogger)
         /// </summary>
         internal void Initialize(FunctionLoadRequest request)
         {
+            if (!request.ManagedDependencyEnabled)
+            {
+                return;
+            }
+
             try
             {
                 // Resolve the FunctionApp root path.
diff --git a/src/PowerShell/PowerShellManager.cs b/src/PowerShell/PowerShellManager.cs
@@ -52,21 +52,8 @@ internal PowerShellManager(ILogger logger)
                 throw new InvalidOperationException(PowerShellWorkerStrings.FunctionAppRootNotResolved);
             }
 
-            var initialSessionState = InitialSessionState.CreateDefault();
-            initialSessionState.ThreadOptions = PSThreadOptions.UseCurrentThread;
-            initialSessionState.EnvironmentVariables.Add(
-                new SessionStateVariableEntry("PSModulePath", FunctionLoader.FunctionModulePath, null));
-
-            // Setting the execution policy on macOS and Linux throws an exception so only update it on Windows
-            if(Platform.IsWindows)
-            {
-                // This sets the execution policy on Windows to Unrestricted which is required to run the user's function scripts on
-                // Windows client versions. This is needed if a user is testing their function locally with the func CLI
-                initialSessionState.ExecutionPolicy = Microsoft.PowerShell.ExecutionPolicy.Unrestricted;
-            }
-
             _logger = logger;
-            _pwsh = PowerShell.Create(initialSessionState);
+            _pwsh = PowerShell.Create(Utils.SingletonISS.Value);
 
             // Setup Stream event listeners
             var streamHandler = new StreamHandler(logger);
diff --git a/src/RequestProcessor.cs b/src/RequestProcessor.cs
@@ -25,8 +25,7 @@ internal class RequestProcessor
         private readonly PowerShellManagerPool _powershellPool;
         private readonly DependencyManager _dependencyManager;
 
-        // Holds the exception if an issue is encountered while installing the function app dependencies
-        // or while initializing PowerShell.
+        // Holds the exception if an issue is encountered while processing the function app dependencies.
         private Exception _initTerminatingError;
 
         // Indicate whether the FunctionApp has been initialized.
@@ -167,7 +166,11 @@ internal StreamingMessage ProcessFunctionLoadRequest(StreamingMessage request)
                 try
                 {
                     _isFunctionAppInitialized = true;
-                    InitializeForFunctionApp(request);
+                    _dependencyManager.Initialize(functionLoadRequest);
+
+                    // Setup the FunctionApp root path and module path.
+                    FunctionLoader.SetupWellKnownPaths(functionLoadRequest);
+                    _dependencyManager.ProcessDependencyDownload(_msgStream, request);
                 }
                 catch (Exception e)
                 {
@@ -200,15 +203,12 @@ internal StreamingMessage ProcessFunctionLoadRequest(StreamingMessage request)
         /// </summary>
         internal StreamingMessage ProcessInvocationRequest(StreamingMessage request)
         {
-            AzFunctionInfo functionInfo = null;
-            PowerShellManager psManager = null;
+            Exception error = null;
 
             try
             {
-                if (_dependencyManager.DependencyDownloadTask != null
-                    && (_dependencyManager.DependencyDownloadTask.Status != TaskStatus.Canceled
-                    || _dependencyManager.DependencyDownloadTask.Status != TaskStatus.Faulted
-                    || _dependencyManager.DependencyDownloadTask.Status != TaskStatus.RanToCompletion))
+                if (_dependencyManager.DependencyDownloadTask != null &&
+                    !_dependencyManager.DependencyDownloadTask.IsCompleted)
                 {
                     var rpcLogger = new RpcLogger(_msgStream);
                     rpcLogger.SetContext(request.RequestId, request.InvocationRequest?.InvocationId);
@@ -218,43 +218,42 @@ internal StreamingMessage ProcessInvocationRequest(StreamingMessage request)
 
                 if (_dependencyManager.DependencyError != null)
                 {
-                    StreamingMessage response = NewStreamingMessageTemplate(request.RequestId,
-                        StreamingMessage.ContentOneofCase.InvocationResponse,
-                        out StatusResult status);
-                    status.Status = StatusResult.Types.Status.Failure;
-                    status.Exception = _dependencyManager.DependencyError.ToRpcException();
-                    response.InvocationResponse.InvocationId = request.InvocationRequest.InvocationId;
-                    return response;
-                }
-
-                functionInfo = _functionLoader.GetFunctionInfo(request.InvocationRequest.FunctionId);
-                psManager = _powershellPool.CheckoutIdleWorker(request, functionInfo);
-
-                if (_powershellPool.UpperBound == 1)
-                {
-                    // When the concurrency upper bound is 1, we can handle only one invocation at a time anyways,
-                    // so it's better to just do it on the current thread to reduce the required synchronization.
-                    ProcessInvocationRequestImpl(request, functionInfo, psManager);
+                    error = _dependencyManager.DependencyError;
                 }
                 else
                 {
-                    // When the concurrency upper bound is more than 1, we have to handle the invocation in a worker
-                    // thread, so multiple invocations can make progress at the same time, even though by time-sharing.
-                    Task.Run(() => ProcessInvocationRequestImpl(request, functionInfo, psManager));
+                    AzFunctionInfo functionInfo = _functionLoader.GetFunctionInfo(request.InvocationRequest.FunctionId);
+                    PowerShellManager psManager = _powershellPool.CheckoutIdleWorker(request, functionInfo);
+
+                    if (_powershellPool.UpperBound == 1)
+                    {
+                        // When the concurrency upper bound is 1, we can handle only one invocation at a time anyways,
+                        // so it's better to just do it on the current thread to reduce the required synchronization.
+                        ProcessInvocationRequestImpl(request, functionInfo, psManager);
+                    }
+                    else
+                    {
+                        // When the concurrency upper bound is more than 1, we have to handle the invocation in a worker
+                        // thread, so multiple invocations can make progress at the same time, even though by time-sharing.
+                        Task.Run(() => ProcessInvocationRequestImpl(request, functionInfo, psManager));
+                    }
                 }
             }
             catch (Exception e)
             {
-                _powershellPool.ReclaimUsedWorker(psManager);
+                error = e;
+            }
 
+            if (error != null)
+            {
                 StreamingMessage response = NewStreamingMessageTemplate(
                     request.RequestId,
                     StreamingMessage.ContentOneofCase.InvocationResponse,
                     out StatusResult status);
 
                 response.InvocationResponse.InvocationId = request.InvocationRequest.InvocationId;
                 status.Status = StatusResult.Types.Status.Failure;
-                status.Exception = e.ToRpcException();
+                status.Exception = error.ToRpcException();
 
                 return response;
             }
@@ -314,22 +313,6 @@ internal StreamingMessage ProcessFunctionEnvironmentReloadRequest(StreamingMessa
 
         #region Helper_Methods
 
-        /// <summary>
-        /// Initialize the worker based on the FunctionApp that the worker will deal with.
-        /// </summary>
-        private void InitializeForFunctionApp(StreamingMessage request)
-        {
-            var functionLoadRequest = request.FunctionLoadRequest;
-            if (functionLoadRequest.ManagedDependencyEnabled)
-            {
-                _dependencyManager.Initialize(functionLoadRequest);
-            }
-
-            // Setup the FunctionApp root path and module path.
-            FunctionLoader.SetupWellKnownPaths(functionLoadRequest);
-            _dependencyManager.ProcessDependencyDownload(_msgStream, request);
-        }
-
         /// <summary>
         /// Create an object of 'StreamingMessage' as a template, for further update.
         /// </summary>
diff --git a/src/Utility/Utils.cs b/src/Utility/Utils.cs
