Core Tools OOP Host

build.ps1

@@ -23,11 +23,11 @@ if ($env:IntegrationBuildNumber)
         throw $errorMessage
     }
 
-    $buildCommand = { dotnet run --integrationTests }
+    $buildCommand = { dotnet run --integrationTests --skipArtifactGeneration}
 }
 else
 {
-    $buildCommand = { dotnet run --ci }
+    $buildCommand = { dotnet run --ci --skipArtifactGeneration}
 }
 
 Write-Host "Running $buildCommand"

build/BuildSteps.cs

@@ -102,7 +102,7 @@ public static void DotnetPack()
             Shell.Run("dotnet", $"pack {Settings.SrcProjectPath} " +
                                 $"/p:BuildNumber=\"{Settings.BuildNumber}\" " +
                                 $"/p:NoWorkers=\"true\" " +
-                                $"/p:TargetFramework=net6.0 " +  // without TargetFramework, the generated nuspec has incorrect path for the copy files operation.
+                                $"/p:TargetFramework=net8.0 " +  // without TargetFramework, the generated nuspec has incorrect path for the copy files operation.
                                 $"/p:CommitHash=\"{Settings.CommitId}\" " +
                                 (string.IsNullOrEmpty(Settings.IntegrationBuildNumber) ? string.Empty : $"/p:IntegrationBuildNumber=\"{Settings.IntegrationBuildNumber}\" ") +
                                 $"-o {outputPath} -c Release --no-build");
@@ -116,8 +116,7 @@ public static void DotnetPublishForZips()
                 var outputPath = Path.Combine(Settings.OutputDir, runtime);
                 var rid = GetRuntimeId(runtime);
 
-                ExecuteDotnetPublish(outputPath, rid, "net6.0", skipLaunchingNet8ChildProcess: isMinVersion);
-
+                ExecuteDotnetPublish(outputPath, rid, "net8.0", skipLaunchingNet8ChildProcess: isMinVersion);
                 if (isMinVersion)
                 {
                     RemoveLanguageWorkers(outputPath);
@@ -342,7 +341,7 @@ public static void Test()
 
             Environment.SetEnvironmentVariable("DURABLE_FUNCTION_PATH", Settings.DurableFolder);
 
-            Shell.Run("dotnet", $"test {Settings.TestProjectFile} -f net6.0 --logger trx");
+            Shell.Run("dotnet", $"test {Settings.TestProjectFile} -f net8.0 --logger trx");
         }
 
         public static void CopyBinariesToSign()
@@ -643,10 +642,10 @@ public static void DotnetPublishForNupkg()
             Shell.Run("dotnet", $"publish {Settings.ProjectFile} " +
                                 $"/p:BuildNumber=\"{Settings.BuildNumber}\" " +
                                 $"/p:NoWorkers=\"true\" " +
-                                $"/p:TargetFramework=net6.0 " +
+                                $"/p:TargetFramework=net8.0 " +
                                 $"/p:CommitHash=\"{Settings.CommitId}\" " +
                                 (string.IsNullOrEmpty(Settings.IntegrationBuildNumber) ? string.Empty : $"/p:IntegrationBuildNumber=\"{Settings.IntegrationBuildNumber}\" ") +
-                                $"-c Release -f net6.0");
+                                $"-c Release -f net8.0");
         }
 
         public static void GenerateSBOMManifestForNupkg()

build/Program.cs

@@ -29,11 +29,11 @@ static void Main(string[] args)
                 .Then(TestPreSignedArtifacts, skip: !args.Contains("--ci"))
                 .Then(CopyBinariesToSign, skip: !args.Contains("--ci"))
                 .Then(Test)
-                .Then(Zip)
+                .Then(Zip, skip: args.Contains("--skipArtifactGeneration"))
                 .Then(DotnetPublishForNupkg)
                 .Then(DotnetPack)
                 .Then(CreateIntegrationTestsBuildManifest, skip: !args.Contains("--integrationTests"))
-                .Then(UploadToStorage, skip: !args.Contains("--ci"))
+                .Then(UploadToStorage, skip: !args.Contains("--ci") || args.Contains("--skipArtifactGeneration"))
                 .Run();
         }
     }

build/Settings.cs

@@ -341,6 +341,16 @@ public class SignInfo
                 "Microsoft.OData.Edm.dll",
                 "Microsoft.Spatial.dll",
                 "Mono.Posix.NETStandard.dll",
+                "OpenTelemetry.Api.dll",
+                "OpenTelemetry.Api.ProviderBuilderExtensions.dll",
+                "OpenTelemetry.dll",
+                "OpenTelemetry.Exporter.Console.dll",
+                "OpenTelemetry.Exporter.OpenTelemetryProtocol.dll",
+                "OpenTelemetry.Extensions.Hosting.dll",
+                "OpenTelemetry.Instrumentation.AspNetCore.dll",
+                "OpenTelemetry.Instrumentation.Http.dll",
+                "OpenTelemetry.PersistentStorage.Abstractions.dll",
+                "OpenTelemetry.PersistentStorage.FileSystem.dll",
                 Path.Combine("tools", "python", "packapp", "distlib")
             };
         }

code-mirror.yml

@@ -8,6 +8,7 @@ trigger:
     - release_4.0
     - release_3.0
     - release_4.0_hotfix
+    - feature/*
 
 resources:
   repositories:

eng/ci/official-build.yml

@@ -15,6 +15,7 @@ trigger:
     include:
     - v4.x
     - release_4.0
+    - feature/*
 
 resources:
   repositories:

eng/ci/public-build.yml

@@ -13,13 +13,15 @@ pr:
     include:
     - v4.x
     - release_4.0
+    - feature/*
 
 trigger:
   batch: true
   branches:
     include:
     - v4.x
     - release_4.0
+    - feature/*
 
 resources:
   repositories:

pipelineUtilities.psm1

@@ -124,7 +124,7 @@ function Install-DotnetVersion($Version,$Channel) {
     if ($IsWindows) {
         & .\$installScript -InstallDir "$env:ProgramFiles/dotnet" -Channel $Channel -Version $Version
         # Installing .NET into x86 directory since the E2E App runs the tests on x86 and looks for the specified framework there
-        & .\$installScript -InstallDir "$env:ProgramFiles (x86)/dotnet" -Channel $Channel -Version $Version
+        & .\$installScript -InstallDir "$env:ProgramFiles (x86)/dotnet" -Channel $Channel -Version $Version -Architecture x86
     } else {
         bash ./$installScript --install-dir /usr/share/dotnet -c $Channel -v $Version
     }

src/Azure.Functions.Cli/Actions/HostActions/StartHostAction.cs

@@ -7,7 +7,6 @@
 using System.Net;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography.X509Certificates;
-using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Azure.Functions.Cli.Common;
 using Azure.Functions.Cli.Diagnostics;
@@ -40,10 +39,6 @@ internal class StartHostAction : BaseAction
     {
         private const int DefaultPort = 7071;
         private const int DefaultTimeout = 20;
-        private const string Net6FrameworkDescriptionPrefix = ".NET 6.0";
-        private const string WindowsExecutableName = "func.exe";
-        private const string LinuxExecutableName = "func";
-        private const string InProc8DirectoryName = "in-proc8";
         private readonly ISecretsManager _secretsManager;
         private readonly IProcessManager _processManager;
         private IConfigurationRoot _hostJsonConfig;
@@ -81,6 +76,8 @@ internal class StartHostAction : BaseAction
 
         public string JsonOutputFile { get; set; }
 
+        public string? HostRuntime { get; set; }
+
         public StartHostAction(ISecretsManager secretsManager, IProcessManager processManager)
         {
             _secretsManager = secretsManager;
@@ -176,6 +173,11 @@ public override ICommandLineParserResult ParseArgs(string[] args)
                .WithDescription("If provided, a path to the file that will be used to write the output when using --enable-json-output.")
                .Callback(jsonOutputFile => JsonOutputFile = jsonOutputFile);
 
+            Parser
+               .Setup<string>("runtime")
+               .WithDescription($"If provided, determines which version of the host to start. Allowed values are '{DotnetConstants.InProc6HostRuntime}', '{DotnetConstants.InProc8HostRuntime}', and 'default' (which runs the out-of-process host).")
+               .Callback(startHostFromRuntime => HostRuntime = startHostFromRuntime);
+
             var parserResult = base.ParseArgs(args);
             bool verboseLoggingArgExists = parserResult.UnMatchedOptions.Any(o => o.LongName.Equals("verbose", StringComparison.OrdinalIgnoreCase));
             // Input args do not contain --verbose flag
@@ -418,15 +420,34 @@ private async Task<JObject> GetLocalSettingsJsonAsJObjectAsync()
         public override async Task RunAsync()
         {
             await PreRunConditions();
+            var isVerbose = VerboseLogging.HasValue && VerboseLogging.Value;
 
-            var isCurrentProcessNet6Build = RuntimeInformation.FrameworkDescription.Contains(Net6FrameworkDescriptionPrefix);
-            if (isCurrentProcessNet6Build && ShouldLaunchInProcNet8AsChildProcess() && await IsInProcNet8Enabled())
+            // If --runtime param is set, handle runtime param logic; otherwise we infer the host to launch on startup
+            if (HostRuntime is not null)
+            {
+                // Check if we should start child process from user specified host runtime and return
+                var shouldStartChildProcess = await ShouldStartChildProcessFromHostRuntime(isVerbose);
+
+                if (shouldStartChildProcess)
+                {
+                    var isNet8InProcSpecified = string.Equals(HostRuntime, DotnetConstants.InProc8HostRuntime, StringComparison.OrdinalIgnoreCase);
+                    await StartHostAsChildProcessAsync(isNet8InProcSpecified);
+                    return;
+                }
+            }
+            else
             {
-                await StartInProc8AsChildProcessAsync();
-                return;
+                // Infer host runtime and check if we should launch child process
+                var shouldNet8InProcBeLaunched = await ShouldNet8InProcBeLaunched();
+                var shouldStartChildProcess = ShouldLaunchChildProcessAfterInferringHostRuntimeAsync(shouldNet8InProcBeLaunched, isVerbose);
+
+                if (shouldStartChildProcess)
+                {
+                    await StartHostAsChildProcessAsync(shouldNet8InProcBeLaunched);
+                    return;
+                }
             }
 
-            var isVerbose = VerboseLogging.HasValue && VerboseLogging.Value;
             if (isVerbose || EnvironmentHelper.GetEnvironmentVariableAsBool(Constants.DisplayLogo))
             {
                 Utilities.PrintLogo();
@@ -480,31 +501,128 @@ public override async Task RunAsync()
             await runTask;
         }
 
+        private async Task<bool> ShouldStartChildProcessFromHostRuntime(bool isVerbose)
+        {
+            if (string.Equals(HostRuntime, "default", StringComparison.OrdinalIgnoreCase))
+            {
+                if (isVerbose)
+                {
+                    PrintVerboseForHostSelection(isVerbose, "out-of-process");
+                }
+                return false;
+            }
+            else if (string.Equals(HostRuntime, DotnetConstants.InProc8HostRuntime, StringComparison.OrdinalIgnoreCase))
+            {
+                if (await ShouldNet8InProcBeLaunched())
+                {
+                    if (isVerbose)
+                    {
+                        PrintVerboseForHostSelection(isVerbose, DotnetConstants.InProc8HostRuntime);
+                    }
+                    return true;
+                }
+                else
+                {
+                    throw new CliException($"Invalid config for running {DotnetConstants.InProc8HostRuntime} host.");
+                }
+            }
+            else if (string.Equals(HostRuntime, DotnetConstants.InProc6HostRuntime, StringComparison.OrdinalIgnoreCase))
+            {
+                if (isVerbose)
+                {
+                    PrintVerboseForHostSelection(isVerbose, DotnetConstants.InProc6HostRuntime);
+                }
+                return true;
+            }
+            else
+            {
+                throw new CliException($"Invalid host runtime '{HostRuntime}'. Valid values are 'default', '{DotnetConstants.InProc8HostRuntime}', '{DotnetConstants.InProc6HostRuntime}'.");
+            }
+        }
+
+        private void PrintVerboseForHostSelection(bool isVerbose, string hostRuntime)
+        {
+            if (isVerbose)
+            {
+                ColoredConsole.WriteLine(VerboseColor($"Selected {hostRuntime} host"));
+            }
+        }
+
+        private async Task<bool> ShouldNet8InProcBeLaunched()
+        {
+            // Start .NET 8 child process if InProc8 is enabled
+            if (ShouldLaunchInProcNet8AsChildProcess() && await IsInProcNet8Enabled())
+            {
+                return true;
+            }
+            return false;
+        }
+
+        private bool ShouldLaunchChildProcessAfterInferringHostRuntimeAsync(bool shouldLaunchNet8, bool isVerbose)
+        {
+            // We should try to infer if we run inproc6 host, inproc8 host, or OOP host (default)
+            var isOutOfProc = GlobalCoreToolsSettings.CurrentWorkerRuntime == WorkerRuntime.dotnet ? false : true;
+
+            // Check if the app is in-proc
+            if (!isOutOfProc)
+            {
+                if (isVerbose)
+                {
+                    // Start .NET 8 child process if InProc8 is enabled and if TFM of function app is .NET 8
+                    if (shouldLaunchNet8)
+                    {
+                        ColoredConsole.WriteLine(VerboseColor($"Selected {DotnetConstants.InProc8HostRuntime} host"));
+                    }
+                    // Otherwise start .NET 6 child process since we are running an inproc app
+                    else
+                    {
+                        ColoredConsole.WriteLine(VerboseColor($"Selected {DotnetConstants.InProc6HostRuntime} host"));
+                    }
+                }
+                return true;
+            }
+            // If the above conditions fail, the default should be OOP host
+            if (isVerbose)
+            {
+                ColoredConsole.WriteLine(VerboseColor("Selected out-of-process host"));
+            }
+            return false;
+
+        }
+
         private static string GetInProcNet8ExecutablePath()
         {
             var funcExecutableDirectory = Path.GetDirectoryName(typeof(StartHostAction).Assembly.Location)!;
-            var executableName = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? WindowsExecutableName : LinuxExecutableName;
+            var executableName = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? DotnetConstants.WindowsExecutableName : DotnetConstants.LinuxExecutableName;
+
+            return Path.Combine(funcExecutableDirectory, DotnetConstants.InProc8DirectoryName, executableName);
+        }
+
+        private static string GetInProcNet6ExecutablePath()
+        {
+            var funcExecutableDirectory = Path.GetDirectoryName(typeof(StartHostAction).Assembly.Location)!;
+            var executableName = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? DotnetConstants.WindowsExecutableName : DotnetConstants.LinuxExecutableName;
 
-            return Path.Combine(funcExecutableDirectory, InProc8DirectoryName, executableName);
+            return Path.Combine(funcExecutableDirectory, DotnetConstants.InProc6DirectoryName, executableName);
         }
 
-        private Task StartInProc8AsChildProcessAsync()
+        private async Task StartHostAsChildProcessAsync(bool shouldStartNet8ChildProcess)
         {
             if (VerboseLogging == true)
             {
-                ColoredConsole.WriteLine(VerboseColor($"Starting child process for in-process model host."));
+                ColoredConsole.WriteLine(VerboseColor($"Starting child process for {(shouldStartNet8ChildProcess ? DotnetConstants.InProc8HostRuntime : DotnetConstants.InProc6HostRuntime)} model host."));
             }
 
             var commandLineArguments = string.Join(" ", Environment.GetCommandLineArgs().Skip(1));
             var tcs = new TaskCompletionSource();
 
-            var inProc8FuncExecutablePath = GetInProcNet8ExecutablePath();
+            var funcExecutablePath = shouldStartNet8ChildProcess ? GetInProcNet8ExecutablePath() : GetInProcNet6ExecutablePath();
 
-            EnsureNet8FuncExecutablePresent(inProc8FuncExecutablePath);
+            EnsureFuncExecutablePresent(funcExecutablePath, shouldStartNet8ChildProcess);
 
-            var inprocNet8ChildProcessInfo = new ProcessStartInfo
+            var childProcessInfo = new ProcessStartInfo
             {
-                FileName = inProc8FuncExecutablePath,
+                FileName = funcExecutablePath,
                 Arguments = $"{commandLineArguments} --no-build",
                 WorkingDirectory = Environment.CurrentDirectory,
                 UseShellExecute = false,
@@ -515,7 +633,7 @@ private Task StartInProc8AsChildProcessAsync()
 
             try
             {
-                var childProcess = Process.Start(inprocNet8ChildProcessInfo);
+                var childProcess = Process.Start(childProcessInfo);
                 if (VerboseLogging == true)
                 {
                     ColoredConsole.WriteLine(VerboseColor($"Started child process with ID: {childProcess.Id}"));
@@ -546,23 +664,21 @@ private Task StartInProc8AsChildProcessAsync()
             }
             catch (Exception ex)
             {
-                throw new CliException($"Failed to start the in-process model host. {ex.Message}");
+                throw new CliException($"Failed to start the {(shouldStartNet8ChildProcess ? DotnetConstants.InProc8HostRuntime : DotnetConstants.InProc6HostRuntime)} model host. {ex.Message}");
             }
-
-            return tcs.Task;
         }
 
-        private void EnsureNet8FuncExecutablePresent(string inProc8FuncExecutablePath)
+        private void EnsureFuncExecutablePresent(string funcExecutablePath, bool isInProcNet8)
         {
-            bool net8ExeExist = File.Exists(inProc8FuncExecutablePath);
+            bool funcExeExist = File.Exists(funcExecutablePath);
             if (VerboseLogging == true)
             {
-                ColoredConsole.WriteLine(VerboseColor($"{inProc8FuncExecutablePath} {(net8ExeExist ? "present" : "not present")} "));
+                ColoredConsole.WriteLine(VerboseColor($"{funcExecutablePath} {(funcExeExist ? "present" : "not present")} "));
             }
 
-            if (!net8ExeExist)
+            if (!funcExeExist)
             {
-                throw new CliException($"Failed to locate the in-process model host at {inProc8FuncExecutablePath}");
+                throw new CliException($"Failed to locate the {(isInProcNet8 ? DotnetConstants.InProc8HostRuntime : DotnetConstants.InProc6HostRuntime)} model host at {funcExecutablePath}");
             }
         }
 

src/Azure.Functions.Cli/Actions/LocalActions/CreateFunctionAction.cs

@@ -13,7 +13,6 @@
 using Azure.Functions.Cli.Interfaces;
 using Colors.Net;
 using Fclp;
-using ImTools;
 using Microsoft.Azure.AppService.Proxy.Common.Context;
 using Microsoft.Azure.WebJobs.Extensions.Http;
 using Microsoft.Azure.WebJobs.Script;