Initial block for .NET in-proc indexing in the OOP host. (#10573)

Author: fabiocav

release_notes.md

@@ -16,4 +16,5 @@
 - Update PowerShell 7.4 worker to [4.0.4026](https://github.com/Azure/azure-functions-powershell-worker/releases/tag/v4.0.4026)
 - Added support for identity-based connections to Diagnostic Events (#10438)
 - Updating Microsoft.Azure.WebJobs.Logging.ApplicationInsights to 3.0.42-12121
-- Updated retry logic in Worker HTTP proxy to allow for longer worker HTTP listener initialization times (#10566).
+- Updated retry logic in Worker HTTP proxy to allow for longer worker HTTP listener initialization times (#10566).
+- Introduced proper handling in environments where .NET in-proc is not supported.

src/WebJobs.Script/Config/FunctionsHostingConfigOptions.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Azure.WebJobs.Script.Workers.Http;
 using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
 
 namespace Microsoft.Azure.WebJobs.Script.Config
@@ -212,6 +213,14 @@ internal bool WorkerRuntimeStrictValidationEnabled
             }
         }
 
+        internal bool IsDotNetInProcDisabled
+        {
+            get
+            {
+                return GetFeatureAsBooleanOrDefault(ScriptConstants.HostingConfigDotNetInProcDisabled, false);
+            }
+        }
+
         /// <summary>
         /// Gets feature by name.
         /// </summary>

src/WebJobs.Script/Environment/EnvironmentExtensions.cs

@@ -115,6 +115,12 @@ public static bool AzureFilesAppSettingsExist(this IEnvironment environment)
                    !string.IsNullOrEmpty(environment.GetEnvironmentVariable(AzureFilesContentShare));
         }
 
+        public static bool IsDotNetInProcSupported(this IEnvironment environment)
+        {
+            return !IsFlexConsumptionSku(environment)
+                   && !string.Equals(environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionsDisableInProc), "1", StringComparison.OrdinalIgnoreCase);
+        }
+
         public static string GetAzureWebsiteHomePath(this IEnvironment environment)
         {
             return environment.GetEnvironmentVariable(AzureWebsiteHomePath);

src/WebJobs.Script/Environment/EnvironmentSettingNames.cs

@@ -83,6 +83,7 @@ public static class EnvironmentSettingNames
         public const string FunctionsWebsiteTimeZone = "WEBSITE_TIME_ZONE";
         public const string FunctionsTargetGroup = "FUNCTIONS_TARGET_GROUP";
         public const string WebsiteArmResourceId = "WEBSITE_ARM_RESOURCE_ID";
+        public const string FunctionsDisableInProc = "FUNCTIONS_DISABLE_INPROC";
 
         //Function in Kubernetes
         public const string PodNamespace = "POD_NAMESPACE";

src/WebJobs.Script/Extensions/FunctionMetadataExtensions.cs

@@ -124,6 +124,14 @@ public static bool IsDirect(this FunctionMetadata metadata)
             return result;
         }
 
+        public static bool IsDotNetInProc(this FunctionMetadata metadata)
+        {
+            return metadata.IsDirect()
+                   || (string.Equals(metadata.Language, DotNetScriptTypes.CSharp, StringComparison.OrdinalIgnoreCase)
+                       || string.Equals(metadata.Language, DotNetScriptTypes.DotNetAssembly, StringComparison.OrdinalIgnoreCase)
+                       || string.Equals(metadata.Language, DotNetScriptTypes.RawDotNetAssembly, StringComparison.OrdinalIgnoreCase));
+        }
+
         public static bool IsDisabled(this FunctionMetadata metadata)
         {
             Utility.TryReadAsBool(metadata.Properties, IsDisabledKey, out bool result);

src/WebJobs.Script/Host/ScriptHost.cs

@@ -737,7 +737,7 @@ private void VerifyPrecompileStatus(IEnumerable<FunctionDescriptor> functions)
                         scriptFile);
 
                     // Adding a function error will cause this function to get ignored
-                    Utility.AddFunctionError(this.FunctionErrors, metadata.Name, msg);
+                    Utility.AddFunctionError(FunctionErrors, metadata.Name, msg);
 
                     _logger.ConfigurationError(msg);
                 }
@@ -823,15 +823,34 @@ internal async Task<Collection<FunctionDescriptor>> GetFunctionDescriptorsAsync(
 
                 Utility.VerifyFunctionsMatchSpecifiedLanguage(functions, workerRuntime, _environment.IsPlaceholderModeEnabled(), _isHttpWorker, cancellationToken, throwOnMismatch: throwOnWorkerRuntimeAndPayloadMetadataMismatch);
 
+                var inProcIndexingSupported = _environment.IsPlaceholderModeEnabled()
+                                              || (_environment.IsDotNetInProcSupported()
+                                                  && !_hostingConfigOptions.Value.IsDotNetInProcDisabled);
+
                 foreach (FunctionMetadata metadata in functions)
                 {
                     try
                     {
-                        bool created = false;
+                        // If this is metadata represents a function that requires direct type indexing (in-proc), and that is not supported,
+                        // throw an exception with detailed information.
+                        // This is temporary and will be removed in a future release, along with all other logic to support the in-proc model.
+                        if (metadata.IsDotNetInProc())
+                        {
+                            if (!inProcIndexingSupported)
+                            {
+                                throw new HostInitializationException(".NET In-process function detected. This model is not supported by the host in the current environment." +
+                                                                      " See https://aka.ms/azure-functions-retirements/in-process-model for more information.");
+                            }
+
+                            // If this is metadata represents a function that supports direct type indexing,
+                            // set that type in the function metadata
+                            TrySetDirectType(metadata);
+                        }
+
                         FunctionDescriptor descriptor = null;
                         foreach (var provider in descriptorProviders)
                         {
-                            (created, descriptor) = await provider.TryCreate(metadata);
+                            (bool created, descriptor) = await provider.TryCreate(metadata);
                             if (created)
                             {
                                 break;
@@ -843,12 +862,8 @@ internal async Task<Collection<FunctionDescriptor>> GetFunctionDescriptorsAsync(
                             ValidateFunction(descriptor, httpFunctions, _environment);
                             functionDescriptors.Add(descriptor);
                         }
-
-                        // If this is metadata represents a function that supports direct type indexing,
-                        // set that type int he function metadata
-                        TrySetDirectType(metadata);
                     }
-                    catch (Exception ex)
+                    catch (Exception ex) when (ex is not HostInitializationException)
                     {
                         // log any unhandled exceptions and continue
                         Utility.AddFunctionError(FunctionErrors, metadata.Name, Utility.FlattenException(ex, includeSource: false));

src/WebJobs.Script/ScriptConstants.cs

@@ -144,6 +144,7 @@ public static class ScriptConstants
         public const string HostingConfigSwtAuthenticationEnabled = "SwtAuthenticationEnabled";
         public const string HostingConfigSwtIssuerEnabled = "SwtIssuerEnabled";
         public const string HostingConfigInternalAuthApisAllowList = "InternalAuthApisAllowList";
+        public const string HostingConfigDotNetInProcDisabled = "DotNetInProcDisabled";
 
         public const string SiteAzureFunctionsUriFormat = "https://{0}.azurewebsites.net/azurefunctions";
         public const string ScmSiteUriFormat = "https://{0}.scm.azurewebsites.net";

test/WebJobs.Script.Tests/Configuration/FunctionsHostingConfigOptionsTest.cs

@@ -142,7 +142,12 @@ public void Property_Validation()
                 (nameof(FunctionsHostingConfigOptions.WorkerRuntimeStrictValidationEnabled), "WORKER_RUNTIME_STRICT_VALIDATION_ENABLED=1", true),
 
                 (nameof(FunctionsHostingConfigOptions.InternalAuthApisAllowList), "InternalAuthApisAllowList=|", "|"),
-                (nameof(FunctionsHostingConfigOptions.InternalAuthApisAllowList), "InternalAuthApisAllowList=/admin/host/foo|/admin/host/bar", "/admin/host/foo|/admin/host/bar")
+                (nameof(FunctionsHostingConfigOptions.InternalAuthApisAllowList), "InternalAuthApisAllowList=/admin/host/foo|/admin/host/bar", "/admin/host/foo|/admin/host/bar"),
+
+                (nameof(FunctionsHostingConfigOptions.IsDotNetInProcDisabled), "DotNetInProcDisabled=False", false),
+                (nameof(FunctionsHostingConfigOptions.IsDotNetInProcDisabled), "DotNetInProcDisabled=True", true),
+                (nameof(FunctionsHostingConfigOptions.IsDotNetInProcDisabled), "DotNetInProcDisabled=1", true),
+                (nameof(FunctionsHostingConfigOptions.IsDotNetInProcDisabled), "DotNetInProcDisabled=0", false),
             };
 
             // use reflection to ensure that we have a test that uses every value exposed on FunctionsHostingConfigOptions