Switch --runtime value to linux-x64

src/Amazon.Lambda.Tools/LambdaConstants.cs

@@ -33,8 +33,8 @@ public static class LambdaConstants
         // https://github.com/dotnet/corefx/blob/release/1.0.0/pkg/Microsoft.NETCore.Platforms/runtime.json
         internal const string RUNTIME_HIERARCHY = "netcore.runtime.hierarchy.json";
 
-        // The closest match to Amazon Linux
-        internal const string RUNTIME_HIERARCHY_STARTING_POINT = "rhel.7.2-x64";
+        // The runtime identifier used for older Lambda runtimes running on Amazon Linux 1.
+        internal const string LEGACY_RUNTIME_HIERARCHY_STARTING_POINT = "rhel.7.2-x64";
 
 
         public const string AWS_LAMBDA_MANAGED_POLICY_PREFIX = "AWSLambda";

src/Amazon.Lambda.Tools/LambdaDotNetCLIWrapper.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using Amazon.Common.DotNetCli.Tools;
+using System.Linq;
 
 namespace Amazon.Lambda.Tools
 {
@@ -81,7 +82,9 @@ public int Store(LambdaToolsDefaults defaults, string projectLocation, string ou
             }
 
             arguments.Append($" --manifest \"{fullPackageManifest}\"");
-            arguments.Append($" --runtime {LambdaConstants.RUNTIME_HIERARCHY_STARTING_POINT}");
+
+
+            arguments.Append($" --runtime {LambdaUtilities.DetermineRuntimeParameter(targetFramework)}");
 
             if(!enableOptimization)
             {
@@ -207,25 +210,48 @@ public int Publish(LambdaToolsDefaults defaults, string projectLocation, string
             {
                 arguments.Append(" /p:GenerateRuntimeConfigurationFiles=true");
 
-                // If you set the runtime to RUNTIME_HIERARCHY_STARTING_POINT it will trim out the Windows and Mac OS specific dependencies but Razor view precompilation
-                // will not run. So only do this packaging optimization if there are no Razor views.
-                if (Directory.GetFiles(fullProjectLocation, "*.cshtml", SearchOption.AllDirectories).Length == 0)
+                // Define an action to set the runtime and self-contained switches.
+                var applyRuntimeSwitchAction = (Action)(() =>
                 {
-                    arguments.Append($" -r {LambdaConstants.RUNTIME_HIERARCHY_STARTING_POINT}");
+                    if (msbuildParameters == null ||
+                        msbuildParameters.IndexOf("--runtime", StringComparison.InvariantCultureIgnoreCase) == -1)
+                    {
+                        arguments.Append($" --runtime {LambdaUtilities.DetermineRuntimeParameter(targetFramework)}");
+                    }
 
                     if (msbuildParameters == null ||
                         msbuildParameters.IndexOf("--self-contained", StringComparison.InvariantCultureIgnoreCase) == -1)
                     {
                         arguments.Append(" --self-contained false ");
                     }
 
-                    if (string.IsNullOrEmpty(msbuildParameters) ||
-                        !msbuildParameters.Contains("PreserveCompilationContext"))
+                });
+
+                // This is here to not change existing behavior for the 2.0 and 2.1 runtimes. For those runtimes if
+                // cshtml files are being used we need to support that cshtml being compiled at runtime. In order to do that we
+                // need to not turn PreserveCompilationContext which provides reference assemblies to the runtime
+                // compilation and not set a runtime.
+                //
+                // If there are no cshtml then disable PreserveCompilationContext to reduce package size and continue
+                // to use the same runtime identifier that we used when those runtimes were launched.
+                if (new string[] { "netcoreapp2.0", "netcoreapp2.1" }.Contains(targetFramework))
+                {
+                    if(Directory.GetFiles(fullProjectLocation, "*.cshtml", SearchOption.AllDirectories).Length == 0)
                     {
-                        _logger?.WriteLine("... Disabling compilation context to reduce package size. If compilation context is needed pass in the \"/p:PreserveCompilationContext=false\" switch.");
-                        arguments.Append(" /p:PreserveCompilationContext=false");
+                        applyRuntimeSwitchAction();
+
+                        if (string.IsNullOrEmpty(msbuildParameters) ||
+                            !msbuildParameters.Contains("PreserveCompilationContext"))
+                        {
+                            _logger?.WriteLine("... Disabling compilation context to reduce package size. If compilation context is needed pass in the \"/p:PreserveCompilationContext=false\" switch.");
+                            arguments.Append(" /p:PreserveCompilationContext=false");
+                        }
                     }
                 }
+                else
+                {
+                    applyRuntimeSwitchAction();
+                }
 
                 // If we have a manifest of packages already deploy in target deployment environment then write it to disk and add the 
                 // command line switch

src/Amazon.Lambda.Tools/LambdaPackager.cs

@@ -427,7 +427,7 @@ private static IList<string> CalculateRuntimeHierarchy()
 
                 // Use a queue to do a breadth first search through the list of runtimes.
                 var queue = new Queue<string>();
-                queue.Enqueue(LambdaConstants.RUNTIME_HIERARCHY_STARTING_POINT);
+                queue.Enqueue(LambdaConstants.LEGACY_RUNTIME_HIERARCHY_STARTING_POINT);
 
                 while(queue.Count > 0)
                 {

src/Amazon.Lambda.Tools/LambdaUtilities.cs

@@ -673,6 +673,27 @@ public static ConvertManifestContentToSdkManifestResult ConvertManifestContentTo
             var updatedContent = updatedDoc.ToString();
 
             return new ConvertManifestContentToSdkManifestResult(true, updatedContent);
-        }                
+        }
+
+        /// <summary>
+        /// Determines what runtime identifier (RID) to use when running a dotnet CLI command. For the
+        /// older .NET Lambda runtimes that are not running on Amazon Linux 2 keep using the existing rhel.7.2-x64
+        /// RID. For all other runtimes that are running on Amazon Linux 2 use the newer linux-x64 RID which did
+        /// not exist when this tool was first created.
+        /// </summary>
+        /// <param name="targetFramework"></param>
+        /// <returns></returns>
+        public static string DetermineRuntimeParameter(string targetFramework)
+        {
+            switch (targetFramework)
+            {
+                case "netcoreapp1.0":
+                case "netcoreapp2.0":
+                case "netcoreapp2.1":
+                    return LambdaConstants.LEGACY_RUNTIME_HIERARCHY_STARTING_POINT;
+                default:
+                    return "linux-x64";
+            }
+        }
     }
 }

test/Amazon.Common.DotNetCli.Tools.Test/UtilitesTests.cs

@@ -11,7 +11,7 @@ namespace Amazon.Common.DotNetCli.Tools.Test
     public class UtilitesTests
     {
         [Theory]
-        [InlineData("../../../../../testapps/TestFunction", "netcoreapp1.0")]
+        [InlineData("../../../../../testapps/TestFunction", "netcoreapp2.1")]
         [InlineData("../../../../../testapps/ServerlessWithYamlFunction", "netcoreapp2.1")]
         [InlineData("../../../../../testapps/TestBeanstalkWebApp", "netcoreapp2.1")]
         public void CheckFramework(string projectPath, string expectedFramework)

test/Amazon.Lambda.Tools.Test/UtilitiesTests.cs

@@ -32,5 +32,20 @@ public void TestGettingLayerDescriptionForNonDotnetLayer(string fullLayer, strin
             var value = LambdaUtilities.DetermineListDisplayLayerDescription(fullLayer, maxLength);
             Assert.Equal(displayLayer, value);
         }
+
+        [Theory]
+        [InlineData("netcoreapp1.0", "rhel.7.2-x64")]
+        [InlineData("netcoreapp1.1", "linux-x64")]
+        [InlineData("netcoreapp2.0", "rhel.7.2-x64")]
+        [InlineData("netcoreapp2.1", "rhel.7.2-x64")]
+        [InlineData("netcoreapp2.2", "linux-x64")]
+        [InlineData("netcoreapp3.0", "linux-x64")]
+        [InlineData("netcoreapp3.1", "linux-x64")]
+        [InlineData("netcoreapp6.0", "linux-x64")]
+        public void TestDetermineRuntimeParameter(string targetFramework, string expectedValue)
+        {
+            var runtime = LambdaUtilities.DetermineRuntimeParameter(targetFramework);
+            Assert.Equal(expectedValue, runtime);
+        }
     }
 }