Update logic to set the function app root for both programming models

Author: Francisco-Gamino

src/FunctionLoader.cs

@@ -72,10 +72,9 @@ internal static void ClearLoadedFunctions()
         /// Setup the well known paths about the FunctionApp.
         /// This method is called only once during the code start.
         /// </summary>
-        internal static void SetupWellKnownPaths(FunctionLoadRequest request, string managedDependenciesPath)
+        internal static void SetupWellKnownPaths(string functionAppRootPath, string managedDependenciesPath)
         {
-            // Resolve the FunctionApp root path
-            FunctionAppRootPath = Path.GetFullPath(Path.Join(request.Metadata.Directory, ".."));
+            FunctionAppRootPath = functionAppRootPath;
 
             // Resolve module paths
             var appLevelModulesPath = Path.Join(FunctionAppRootPath, "Modules");

src/RequestProcessor.cs

@@ -32,6 +32,7 @@ internal class RequestProcessor
         private readonly PowerShellManagerPool _powershellPool;
         private DependencyManager _dependencyManager;
         private string _pwshVersion;
+        private string _functionAppRootPath;
 
         // Holds the exception if an issue is encountered while processing the function app dependencies.
         private Exception _initTerminatingError;
@@ -135,18 +136,6 @@ internal StreamingMessage ProcessWorkerInitRequest(StreamingMessage request)
 
                 response.WorkerInitResponse.WorkerMetadata = GetWorkerMetadata(_pwshVersion);
 
-                // Previously, the dependency management would happen just prior to the dependency download in the
-                // first function load request. Now that we have the FunctionAppDirectory in the WorkerInitRequest,
-                // we can do the setup of these variables in the function load request. We need these variables initialized
-                // for the FunctionMetadataRequest, should it be sent.
-                _dependencyManager = new DependencyManager(request.WorkerInitRequest.FunctionAppDirectory, logger: rpcLogger);
-
-                // The profile is invoke during this stage.
-                // TODO: Initialize the first PowerShell instance, but delay the invocation of the profile.
-                //       The first PowerShell instance will be used to import the PowerShell SDK to generate the function metadata
-                // Issue: We do not know if Managed Dependencies is enabled until the first function load.
-                _powershellPool.Initialize(_firstPwshInstance);
-
                 rpcLogger.Log(isUserOnlyLog: false, LogLevel.Trace, string.Format(PowerShellWorkerStrings.WorkerInitCompleted, stopwatch.ElapsedMilliseconds));
             }
             catch (Exception e)
@@ -231,16 +220,39 @@ internal StreamingMessage ProcessFunctionLoadRequest(StreamingMessage request)
             {
                 try
                 {
+                    _isFunctionAppInitialized = true;
+
                     var rpcLogger = new RpcLogger(_msgStream);
                     rpcLogger.SetContext(request.RequestId, null);
 
-                    _isFunctionAppInitialized = true;
+                    // _functionAppRootPath is set in ProcessFunctionMetadataRequest for the v2 progamming model.
+                    if (_functionAppRootPath == null)
+                    {
+                        // If _functionAppRootPath is null, this means that this is an app for the v1 programming model.
+                        _functionAppRootPath = request.FunctionLoadRequest.Metadata.Directory;
+                    }
 
+                    if (string.IsNullOrWhiteSpace(_functionAppRootPath))
+                    {
+                        throw new ArgumentException("Failed to resolve the function app root", nameof(_functionAppRootPath));
+                    }
+
+                    _dependencyManager = new DependencyManager(_functionAppRootPath, logger: rpcLogger);
                     var managedDependenciesPath = _dependencyManager.Initialize(request, rpcLogger);
 
-                    SetupAppRootPathAndModulePath(request.FunctionLoadRequest, managedDependenciesPath);
+                    SetupAppRootPathAndModulePath(_functionAppRootPath, managedDependenciesPath);
+
+                    // The profile is invoke when the instance is initialized.
+                    // TODO: Initialize the first PowerShell instance but delay the invocation of the profile until the first function load.
+                    //       The first PowerShell instance will be used to import the AzureFunctions.PowerShell.SDK to generate the function metadata
+                    // Issue: We do not know if Managed Dependencies is enabled until the first function load.
+                    _powershellPool.Initialize(_firstPwshInstance);
+
                     // Start the download asynchronously if needed.
                     _dependencyManager.StartDependencyInstallationIfNeeded(request, _firstPwshInstance, rpcLogger);
+
+                    rpcLogger.Log(isUserOnlyLog: false, LogLevel.Trace, string.Format(PowerShellWorkerStrings.FirstFunctionLoadCompleted, stopwatch.ElapsedMilliseconds));
+
                 }
                 catch (Exception e)
                 {
@@ -387,8 +399,8 @@ private StreamingMessage ProcessFunctionMetadataRequest(StreamingMessage request
             var rpcLogger = new RpcLogger(_msgStream);
             rpcLogger.SetContext(request.RequestId, null);
 
-            //response.FunctionMetadataResponse.FunctionMetadataResults.AddRange(WorkerIndexingHelper.IndexFunctions(request.FunctionsMetadataRequest.FunctionAppDirectory));
-            response.FunctionMetadataResponse.FunctionMetadataResults.AddRange(WorkerIndexingHelper.IndexFunctions(request.FunctionsMetadataRequest.FunctionAppDirectory, rpcLogger));
+            _functionAppRootPath = request.FunctionsMetadataRequest.FunctionAppDirectory;
+            response.FunctionMetadataResponse.FunctionMetadataResults.AddRange(WorkerIndexingHelper.IndexFunctions(_functionAppRootPath, rpcLogger));
 
             return response;
         }
@@ -559,9 +571,9 @@ private static void BindOutputFromResult(InvocationResponse response, AzFunction
             }
         }
 
-        private void SetupAppRootPathAndModulePath(FunctionLoadRequest functionLoadRequest, string managedDependenciesPath)
+        private void SetupAppRootPathAndModulePath(string functionAppRootPath, string managedDependenciesPath)
         {
-            FunctionLoader.SetupWellKnownPaths(functionLoadRequest, managedDependenciesPath);
+            FunctionLoader.SetupWellKnownPaths(functionAppRootPath, managedDependenciesPath);
 
             if (FunctionLoader.FunctionAppRootPath == null)
             {

src/WorkerIndexing/WorkerIndexingHelper.cs

@@ -26,9 +26,13 @@ internal class WorkerIndexingHelper
         const string AzureFunctionsPowerShellSDKModuleName = "AzureFunctions.PowerShell.SDK";
         private static readonly ErrorRecordFormatter _errorRecordFormatter = new ErrorRecordFormatter();
 
-        //internal static IEnumerable<RpcFunctionMetadata> IndexFunctions(string baseDir)
-        internal static IEnumerable<RpcFunctionMetadata> IndexFunctions(string baseDir, ILogger logger)
+        internal static IEnumerable<RpcFunctionMetadata> IndexFunctions(string functionAppRootPath, ILogger logger)
         {
+            if (string.IsNullOrWhiteSpace(functionAppRootPath))
+            {
+                throw new ArgumentException("Empty function app root path", nameof(functionAppRootPath));
+            }
+
             List<RpcFunctionMetadata> indexedFunctions = new List<RpcFunctionMetadata>();
 
             // This is not the correct way to deal with getting a runspace for the cmdlet. 
@@ -66,7 +70,7 @@ internal static IEnumerable<RpcFunctionMetadata> IndexFunctions(string baseDir,
 
             try
             {
-                _powershell.AddCommand(GetFunctionsMetadataCmdletName).AddArgument(baseDir);
+                _powershell.AddCommand(GetFunctionsMetadataCmdletName).AddArgument(functionAppRootPath);
                 results = _powershell.Invoke();
                 cmdletExecutionHadErrors = _powershell.HadErrors;
             }