Merge remote-tracking branch 'origin/release' into dev

build.cmd

@@ -19,12 +19,12 @@ IF EXIST packages\KoreBuild goto run
 .nuget\NuGet.exe install KoreBuild -ExcludeVersion -o packages -nocache -pre
 .nuget\NuGet.exe install Sake -version 0.2 -o packages -ExcludeVersion
 
-IF "%SKIP_DOTNET_INSTALL%"=="1" goto run
+IF "%SKIP_KRE_INSTALL%"=="1" goto run
-CALL packages\KoreBuild\build\dotnetsdk upgrade -x64
+CALL packages\KoreBuild\build\kvm upgrade -x64
-CALL packages\KoreBuild\build\dotnetsdk install default -runtime CoreCLR -x64
+CALL packages\KoreBuild\build\kvm install default -runtime CoreCLR -x64
-CALL packages\KoreBuild\build\dotnetsdk install default -x86
+CALL packages\KoreBuild\build\kvm install default -x86
-CALL packages\KoreBuild\build\dotnetsdk install default -runtime CoreCLR -x86
+CALL packages\KoreBuild\build\kvm install default -runtime CoreCLR -x86
 
 :run
-CALL packages\KoreBuild\build\dotnetsdk use default -runtime CLR -x86
+CALL packages\KoreBuild\build\kvm use default -runtime CLR -x86
 packages\Sake\tools\Sake.exe -I packages\KoreBuild\build -f makefile.shade %*

build.sh

@@ -28,11 +28,11 @@ if test ! -d packages/KoreBuild; then
 fi
 
 if ! type k > /dev/null 2>&1; then
-    source packages/KoreBuild/build/dotnetsdk.sh
+    source packages/KoreBuild/build/kvm.sh
 fi
 
 if ! type k > /dev/null 2>&1; then
-    dotnetsdk upgrade
+    kvm upgrade
 fi
 
 mono packages/Sake/tools/Sake.exe -I packages/KoreBuild/build -f makefile.shade "$@"

src/MusicStore/CopyAspNetLoader.cmd

@@ -1,8 +1,8 @@
 REM copy the AspNet.Loader.dll to bin folder
 md wwwroot\bin
 
-SET ASPNETLOADER_PACKAGE_BASEPATH=%USERPROFILE%\.dotnet\packages\Microsoft.AspNet.Loader.IIS.Interop
+SET ASPNETLOADER_PACKAGE_BASEPATH=%USERPROFILE%\.k\packages\Microsoft.AspNet.Loader.IIS.Interop
 REM figure out the path of AspNet.Loader.dll
 FOR /F %%j IN ('dir /b /o:-d %ASPNETLOADER_PACKAGE_BASEPATH%\*') do (SET AspNetLoaderPath=%ASPNETLOADER_PACKAGE_BASEPATH%\%%j\tools\AspNet.Loader.dll)
 echo Found AspNetLoader.dll at %AspNetLoaderPath%. Copying to bin\
-copy %AspNetLoaderPath% wwwroot\bin\
+copy %AspNetLoaderPath% wwwroot\bin\

src/MusicStore/wwwroot/web.config

@@ -10,7 +10,7 @@
     <!-- This will turn on detailed errors when deployed to remote servers -->
     <!-- This setting is not recommended for production -->
     <add key="ASPNET_DETAILED_ERRORS" value="true" />
-    <add key="dotnet-app-base" value="../" />
+    <add key="kre-app-base" value="../" />
   </appSettings>
 
 </configuration>

test/E2ETests/Common/DeploymentUtility.cs

@@ -15,13 +15,13 @@ namespace E2ETests
 {
     internal class DeploymentUtility
     {
-        private static string GetIISExpressPath(DotnetArchitecture architecture)
+        private static string GetIISExpressPath(RuntimeArchitecture architecture)
         {
             // Get path to program files
             var iisExpressPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "IIS Express", "iisexpress.exe");
 
             // Get path to 64 bit of IIS Express
-            if (architecture == DotnetArchitecture.amd64)
+            if (architecture == RuntimeArchitecture.amd64)
             {
                 iisExpressPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "IIS Express", "iisexpress.exe");
 
@@ -67,9 +67,9 @@ namespace E2ETests
         {
             startParameters.ApplicationPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, APP_RELATIVE_PATH));
 
-            //To avoid the DOTNET_DEFAULT_LIB of the test process flowing into Helios, set it to empty
+            //To avoid the KRE_DEFAULT_LIB of the test process flowing into Helios, set it to empty
-            var backupDotnetDefaultLibPath = Environment.GetEnvironmentVariable("DOTNET_DEFAULT_LIB");
+            var backupRuntimeDefaultLibPath = Environment.GetEnvironmentVariable("KRE_DEFAULT_LIB");
-            Environment.SetEnvironmentVariable("DOTNET_DEFAULT_LIB", string.Empty);
+            Environment.SetEnvironmentVariable("KRE_DEFAULT_LIB", string.Empty);
 
             if (!string.IsNullOrWhiteSpace(startParameters.EnvironmentName))
             {
@@ -88,16 +88,16 @@ namespace E2ETests
 
             Process hostProcess = null;
 
-            if (startParameters.DotnetFlavor == DotnetFlavor.Mono)
+            if (startParameters.RuntimeFlavor == RuntimeFlavor.Mono)
             {
                 hostProcess = StartMonoHost(startParameters, logger);
             }
             else
             {
-                //Tweak the %PATH% to the point to the right DOTNETFLAVOR
+                //Tweak the %PATH% to the point to the right RUNTIMEFLAVOR
-                startParameters.Dotnet = SwitchPathToDotnetFlavor(startParameters.DotnetFlavor, startParameters.DotnetArchitecture, logger);
+                startParameters.Runtime = SwitchPathToRuntimeFlavor(startParameters.RuntimeFlavor, startParameters.RuntimeArchitecture, logger);
 
-                //Reason to do pack here instead of in a common place is use the right Dotnet to do the packing. Previous line switches to use the right Dotnet.
+                //Reason to do pack here instead of in a common place is use the right runtime to do the packing. Previous line switches to use the right runtime.
                 if (startParameters.BundleApplicationBeforeStart)
                 {
                     if (startParameters.ServerType == ServerType.IISNativeModule ||
@@ -162,8 +162,8 @@ namespace E2ETests
                 }
             }
 
-            //Restore the DOTNET_DEFAULT_LIB after starting the host process
+            //Restore the KRE_DEFAULT_LIB after starting the host process
-            Environment.SetEnvironmentVariable("DOTNET_DEFAULT_LIB", backupDotnetDefaultLibPath);
+            Environment.SetEnvironmentVariable("KRE_DEFAULT_LIB", backupRuntimeDefaultLibPath);
             Environment.SetEnvironmentVariable("ASPNET_ENV", string.Empty);
             return hostProcess;
         }
@@ -171,33 +171,33 @@ namespace E2ETests
         private static Process StartMonoHost(StartParameters startParameters, ILogger logger)
         {
             var path = Environment.GetEnvironmentVariable("PATH");
-            var dotnetBin = path.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).
+            var runtimeBin = path.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).
-                Where(c => c.Contains("dotnet-mono")).FirstOrDefault();
+                Where(c => c.Contains("kre-mono")).FirstOrDefault();
 
-            if (string.IsNullOrWhiteSpace(dotnetBin))
+            if (string.IsNullOrWhiteSpace(runtimeBin))
             {
-                throw new Exception("Dotnet not detected on the machine.");
+                throw new Exception("Runtime not detected on the machine.");
             }
 
             if (startParameters.BundleApplicationBeforeStart)
             {
-                // We use full path to Dotnet to pack.
+                // We use full path to runtime to pack.
-                startParameters.Dotnet = new DirectoryInfo(dotnetBin).Parent.FullName;
+                startParameters.Runtime = new DirectoryInfo(runtimeBin).Parent.FullName;
                 KpmBundle(startParameters, logger);
             }
 
             //Mono now supports --appbase 
-            Environment.SetEnvironmentVariable("DOTNET_APPBASE", startParameters.ApplicationPath);
+            Environment.SetEnvironmentVariable("KRE_APPBASE", startParameters.ApplicationPath);
             logger.WriteInformation("Setting the --appbase to", startParameters.ApplicationPath);
 
-            var dotnet = "dotnet";
+            var bootstrapper = "klr";
 
             var commandName = startParameters.ServerType == ServerType.Kestrel ? "kestrel" : string.Empty;
-            logger.WriteInformation(string.Format("Executing command: {0} {1} {2}", dotnet, startParameters.ApplicationPath, commandName));
+            logger.WriteInformation(string.Format("Executing command: {0} {1} {2}", bootstrapper, startParameters.ApplicationPath, commandName));
 
             var startInfo = new ProcessStartInfo
             {
-                FileName = dotnet,
+                FileName = bootstrapper,
                 Arguments = string.Format("{0} {1}", startParameters.ApplicationPath, commandName),
                 UseShellExecute = false,
                 CreateNoWindow = true,
@@ -241,7 +241,7 @@ namespace E2ETests
                             string.Format("/port:5001 /path:{0}", webroot) :
                             string.Format("/site:{0} /config:{1}", startParameters.SiteName, startParameters.ApplicationHostConfigLocation);
 
-            var iisExpressPath = GetIISExpressPath(startParameters.DotnetArchitecture);
+            var iisExpressPath = GetIISExpressPath(startParameters.RuntimeArchitecture);
 
             logger.WriteInformation("Executing command : {0} {1}", iisExpressPath, parameters);
 
@@ -262,11 +262,11 @@ namespace E2ETests
         private static Process StartSelfHost(StartParameters startParameters, string identityDbName, ILogger logger)
         {
             var commandName = startParameters.ServerType == ServerType.WebListener ? "web" : "kestrel";
-            logger.WriteInformation("Executing dotnet.exe --appbase {0} \"Microsoft.Framework.ApplicationHost\" {1}", startParameters.ApplicationPath, commandName);
+            logger.WriteInformation("Executing klr.exe --appbase {0} \"Microsoft.Framework.ApplicationHost\" {1}", startParameters.ApplicationPath, commandName);
 
             var startInfo = new ProcessStartInfo
             {
-                FileName = "dotnet.exe",
+                FileName = "klr.exe",
                 Arguments = string.Format("--appbase {0} \"Microsoft.Framework.ApplicationHost\" {1}", startParameters.ApplicationPath, commandName),
                 UseShellExecute = true,
                 CreateNoWindow = true
@@ -290,38 +290,38 @@ namespace E2ETests
             return hostProcess;
         }
 
-        private static string SwitchPathToDotnetFlavor(DotnetFlavor dotnetFlavor, DotnetArchitecture dotnetArchitecture, ILogger logger)
+        private static string SwitchPathToRuntimeFlavor(RuntimeFlavor runtimeFlavor, RuntimeArchitecture runtimeArchitecture, ILogger logger)
         {
             var pathValue = Environment.GetEnvironmentVariable("PATH");
             logger.WriteInformation(string.Empty);
             logger.WriteInformation("Current %PATH% value : {0}", pathValue);
 
             var replaceStr = new StringBuilder().
-                Append("dotnet").
+                Append("kre").
-                Append((dotnetFlavor == DotnetFlavor.CoreClr) ? "-coreclr" : "-clr").
+                Append((runtimeFlavor == RuntimeFlavor.CoreClr) ? "-coreclr" : "-clr").
                 Append("-win").
-                Append((dotnetArchitecture == DotnetArchitecture.x86) ? "-x86" : "-x64").
+                Append((runtimeArchitecture == RuntimeArchitecture.x86) ? "-x86" : "-x64").
                 ToString();
 
-            pathValue = Regex.Replace(pathValue, "dotnet-(clr|coreclr)-win-(x86|x64)", replaceStr, RegexOptions.IgnoreCase);
+            pathValue = Regex.Replace(pathValue, "kre-(clr|coreclr)-win-(x86|x64)", replaceStr, RegexOptions.IgnoreCase);
 
-            var startIndex = pathValue.IndexOf(replaceStr); // First instance of this Dotnet name.
+            var startIndex = pathValue.IndexOf(replaceStr); // First instance of this runtime name.
-            var dotnetName = pathValue.Substring(startIndex, pathValue.IndexOf(';', startIndex) - startIndex);
+            var runtimeName = pathValue.Substring(startIndex, pathValue.IndexOf(';', startIndex) - startIndex);
-            dotnetName = dotnetName.Substring(0, dotnetName.IndexOf('\\')); // Trim the \bin from the path.
+            runtimeName = runtimeName.Substring(0, runtimeName.IndexOf('\\')); // Trim the \bin from the path.
 
-            // Tweak the %PATH% to the point to the right DOTNETFLAVOR.
+            // Tweak the %PATH% to the point to the right RUNTIMEFLAVOR.
             Environment.SetEnvironmentVariable("PATH", pathValue);
 
             logger.WriteInformation(string.Empty);
-            logger.WriteInformation("Changing to use DOTNET : {0}", dotnetName);
+            logger.WriteInformation("Changing to use runtime : {0}", runtimeName);
-            return dotnetName;
+            return runtimeName;
         }
 
         private static void KpmBundle(StartParameters startParameters, ILogger logger, string bundleRoot = null)
         {
             startParameters.BundledApplicationRootPath = Path.Combine(bundleRoot ?? Path.GetTempPath(), Guid.NewGuid().ToString());
 
-            var parameters = string.Format("bundle {0} -o {1} --runtime {2}", startParameters.ApplicationPath, startParameters.BundledApplicationRootPath, startParameters.Dotnet);
+            var parameters = string.Format("bundle {0} -o {1} --runtime {2}", startParameters.ApplicationPath, startParameters.BundledApplicationRootPath, startParameters.Runtime);
             logger.WriteInformation("Executing command kpm {0}", parameters);
 
             var startInfo = new ProcessStartInfo

test/E2ETests/Common/DotnetArchitecture.cs

@@ -1,6 +1,6 @@
 namespace E2ETests
 {
-    public enum DotnetArchitecture
+    public enum RuntimeArchitecture
     {
         amd64,
         x86

test/E2ETests/Common/DotnetFlavor.cs

@@ -1,6 +1,6 @@
 namespace E2ETests
 {
-    public enum DotnetFlavor
+    public enum RuntimeFlavor
     {
         DesktopClr,
         CoreClr,

test/E2ETests/Common/IISApplication.cs

@@ -57,9 +57,9 @@ namespace E2ETests
                 // Not assigning a runtime version will choose v4.0 default.
                 applicationPool.ManagedRuntimeVersion = NATIVE_MODULE_MANAGED_RUNTIME_VERSION;
             }
-            applicationPool.Enable32BitAppOnWin64 = (_startParameters.DotnetArchitecture == DotnetArchitecture.x86);
+            applicationPool.Enable32BitAppOnWin64 = (_startParameters.RuntimeArchitecture == RuntimeArchitecture.x86);
             _logger.WriteInformation("Created {0} application pool '{1}' with runtime version '{2}'.",
-                _startParameters.DotnetArchitecture, applicationPool.Name,
+                _startParameters.RuntimeArchitecture, applicationPool.Name,
                 applicationPool.ManagedRuntimeVersion ?? "default");
             return applicationPool;
         }

test/E2ETests/Common/StartParameters.cs

@@ -7,9 +7,9 @@
     {
         public ServerType ServerType { get; set; }
 
-        public DotnetFlavor DotnetFlavor { get; set; }
+        public RuntimeFlavor RuntimeFlavor { get; set; }
 
-        public DotnetArchitecture DotnetArchitecture { get; set; }
+        public RuntimeArchitecture RuntimeArchitecture { get; set; }
 
         public string EnvironmentName { get; set; }
 
@@ -25,7 +25,7 @@
 
         public string BundledApplicationRootPath { get; set; }
 
-        public string Dotnet { get; set; }
+        public string Runtime { get; set; }
 
         public IISApplication IISApplication { get; set; }
     }

test/E2ETests/NtlmAuthentationTest.cs

@@ -12,21 +12,21 @@ namespace E2ETests
     {
         [ConditionalTheory]
         [OSSkipCondition(OperatingSystems.Unix | OperatingSystems.MacOSX)]
-        [InlineData(ServerType.IISExpress, DotnetFlavor.CoreClr, DotnetArchitecture.x86, "http://localhost:5001/")]
+        [InlineData(ServerType.IISExpress, RuntimeFlavor.CoreClr, RuntimeArchitecture.x86, "http://localhost:5001/")]
-        [InlineData(ServerType.IISExpress, DotnetFlavor.DesktopClr, DotnetArchitecture.amd64, "http://localhost:5001/")]
+        [InlineData(ServerType.IISExpress, RuntimeFlavor.DesktopClr, RuntimeArchitecture.amd64, "http://localhost:5001/")]
-        [InlineData(ServerType.WebListener, DotnetFlavor.CoreClr, DotnetArchitecture.amd64, "http://localhost:5002/")]
+        [InlineData(ServerType.WebListener, RuntimeFlavor.CoreClr, RuntimeArchitecture.amd64, "http://localhost:5002/")]
-        public void NtlmAuthenticationTest(ServerType serverType, DotnetFlavor dotnetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void NtlmAuthenticationTest(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
             using (_logger.BeginScope("NtlmAuthenticationTest"))
             {
-                _logger.WriteInformation("Variation Details : HostType = {0}, DotnetFlavor = {1}, Architecture = {2}, applicationBaseUrl = {3}",
+                _logger.WriteInformation("Variation Details : HostType = {0}, RuntimeFlavor = {1}, Architecture = {2}, applicationBaseUrl = {3}",
-                    serverType, dotnetFlavor, architecture, applicationBaseUrl);
+                    serverType, runtimeFlavor, architecture, applicationBaseUrl);
 
                 _startParameters = new StartParameters
                 {
                     ServerType = serverType,
-                    DotnetFlavor = dotnetFlavor,
+                    RuntimeFlavor = runtimeFlavor,
-                    DotnetArchitecture = architecture,
+                    RuntimeArchitecture = architecture,
                     EnvironmentName = "NtlmAuthentication", //Will pick the Start class named 'StartupNtlmAuthentication'
                     ApplicationHostConfigTemplateContent = (serverType == ServerType.IISExpress) ? File.ReadAllText("NtlmAuthentation.config") : null,
                     SiteName = "MusicStoreNtlmAuthentication" //This is configured in the NtlmAuthentication.config

test/E2ETests/PublishAndRunTests.cs

@@ -12,42 +12,42 @@ namespace E2ETests
     {
         [ConditionalTheory]
         [FrameworkSkipCondition(RuntimeFrameworks.Mono)]
-        [InlineData(ServerType.IISExpress, DotnetFlavor.DesktopClr, DotnetArchitecture.x86, "http://localhost:5001/")]
+        [InlineData(ServerType.IISExpress, RuntimeFlavor.DesktopClr, RuntimeArchitecture.x86, "http://localhost:5001/")]
-        public void Publish_And_Run_Tests_On_X86(ServerType serverType, DotnetFlavor dotnetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void Publish_And_Run_Tests_On_X86(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
-            Publish_And_Run_Tests(serverType, dotnetFlavor, architecture, applicationBaseUrl);
+            Publish_And_Run_Tests(serverType, runtimeFlavor, architecture, applicationBaseUrl);
         }
 
         [ConditionalTheory]
         [FrameworkSkipCondition(RuntimeFrameworks.DotNet)]
-        [InlineData(ServerType.Kestrel, DotnetFlavor.Mono, DotnetArchitecture.x86, "http://localhost:5004/")]
+        [InlineData(ServerType.Kestrel, RuntimeFlavor.Mono, RuntimeArchitecture.x86, "http://localhost:5004/")]
-        public void Publish_And_Run_Tests_On_Mono(ServerType serverType, DotnetFlavor dotnetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void Publish_And_Run_Tests_On_Mono(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
-            Publish_And_Run_Tests(serverType, dotnetFlavor, architecture, applicationBaseUrl);
+            Publish_And_Run_Tests(serverType, runtimeFlavor, architecture, applicationBaseUrl);
         }
 
         [ConditionalTheory]
         [FrameworkSkipCondition(RuntimeFrameworks.Mono)]
-        [InlineData(ServerType.WebListener, DotnetFlavor.DesktopClr, DotnetArchitecture.amd64, "http://localhost:5002/")]
+        [InlineData(ServerType.WebListener, RuntimeFlavor.DesktopClr, RuntimeArchitecture.amd64, "http://localhost:5002/")]
         //https://github.com/aspnet/KRuntime/issues/642
-        //[InlineData(ServerType.Helios, DotnetFlavor.CoreClr, DotnetArchitecture.amd64, "http://localhost:5001/")]
+        //[InlineData(ServerType.Helios, RuntimeFlavor.CoreClr, RuntimeArchitecture.amd64, "http://localhost:5001/")]
-        public void Publish_And_Run_Tests_On_AMD64(ServerType serverType, DotnetFlavor dotnetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void Publish_And_Run_Tests_On_AMD64(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
-            Publish_And_Run_Tests(serverType, dotnetFlavor, architecture, applicationBaseUrl);
+            Publish_And_Run_Tests(serverType, runtimeFlavor, architecture, applicationBaseUrl);
         }
 
-        private void Publish_And_Run_Tests(ServerType serverType, DotnetFlavor dotnetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        private void Publish_And_Run_Tests(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
             using (_logger.BeginScope("Publish_And_Run_Tests"))
             {
-                _logger.WriteInformation("Variation Details : HostType = {0}, DotnetFlavor = {1}, Architecture = {2}, applicationBaseUrl = {3}",
+                _logger.WriteInformation("Variation Details : HostType = {0}, RuntimeFlavor = {1}, Architecture = {2}, applicationBaseUrl = {3}",
-                    serverType, dotnetFlavor, architecture, applicationBaseUrl);
+                    serverType, runtimeFlavor, architecture, applicationBaseUrl);
 
                 _startParameters = new StartParameters
                 {
                     ServerType = serverType,
-                    DotnetFlavor = dotnetFlavor,
+                    RuntimeFlavor = runtimeFlavor,
-                    DotnetArchitecture = architecture,
+                    RuntimeArchitecture = architecture,
                     BundleApplicationBeforeStart = true
                 };
 

test/E2ETests/SmokeTests.cs

@@ -27,32 +27,32 @@ namespace E2ETests
 
         [ConditionalTheory]
         [FrameworkSkipCondition(RuntimeFrameworks.Mono)]
-        [InlineData(ServerType.IISExpress, DotnetFlavor.DesktopClr, DotnetArchitecture.x86, "http://localhost:5001/")]
+        [InlineData(ServerType.IISExpress, RuntimeFlavor.DesktopClr, RuntimeArchitecture.x86, "http://localhost:5001/")]
-        [InlineData(ServerType.WebListener, DotnetFlavor.DesktopClr, DotnetArchitecture.x86, "http://localhost:5002/")]
+        [InlineData(ServerType.WebListener, RuntimeFlavor.DesktopClr, RuntimeArchitecture.x86, "http://localhost:5002/")]
-        [InlineData(ServerType.Kestrel, DotnetFlavor.DesktopClr, DotnetArchitecture.x86, "http://localhost:5004/")]
+        [InlineData(ServerType.Kestrel, RuntimeFlavor.DesktopClr, RuntimeArchitecture.x86, "http://localhost:5004/")]
-        [InlineData(ServerType.IISExpress, DotnetFlavor.CoreClr, DotnetArchitecture.x86, "http://localhost:5001/")]
+        [InlineData(ServerType.IISExpress, RuntimeFlavor.CoreClr, RuntimeArchitecture.x86, "http://localhost:5001/")]
-        [InlineData(ServerType.WebListener, DotnetFlavor.CoreClr, DotnetArchitecture.x86, "http://localhost:5002/")]
+        [InlineData(ServerType.WebListener, RuntimeFlavor.CoreClr, RuntimeArchitecture.x86, "http://localhost:5002/")]
-        [InlineData(ServerType.Kestrel, DotnetFlavor.CoreClr, DotnetArchitecture.x86, "http://localhost:5004/")]
+        [InlineData(ServerType.Kestrel, RuntimeFlavor.CoreClr, RuntimeArchitecture.x86, "http://localhost:5004/")]
-        public void SmokeTestSuite_OnX86(ServerType serverType, DotnetFlavor dotnetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void SmokeTestSuite_OnX86(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
-            SmokeTestSuite(serverType, dotnetFlavor, architecture, applicationBaseUrl);
+            SmokeTestSuite(serverType, runtimeFlavor, architecture, applicationBaseUrl);
         }
 
         [ConditionalTheory]
         [FrameworkSkipCondition(RuntimeFrameworks.Mono)]
         [SkipOn32BitOS]
-        [InlineData(ServerType.WebListener, DotnetFlavor.DesktopClr, DotnetArchitecture.amd64, "http://localhost:5002/")]
+        [InlineData(ServerType.WebListener, RuntimeFlavor.DesktopClr, RuntimeArchitecture.amd64, "http://localhost:5002/")]
-        [InlineData(ServerType.IISExpress, DotnetFlavor.CoreClr, DotnetArchitecture.amd64, "http://localhost:5001/")]
+        [InlineData(ServerType.IISExpress, RuntimeFlavor.CoreClr, RuntimeArchitecture.amd64, "http://localhost:5001/")]
-        [InlineData(ServerType.Kestrel, DotnetFlavor.CoreClr, DotnetArchitecture.amd64, "http://localhost:5004/")]
+        [InlineData(ServerType.Kestrel, RuntimeFlavor.CoreClr, RuntimeArchitecture.amd64, "http://localhost:5004/")]
-        public void SmokeTestSuite_OnAMD64(ServerType serverType, DotnetFlavor donetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void SmokeTestSuite_OnAMD64(ServerType serverType, RuntimeFlavor donetFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
             SmokeTestSuite(serverType, donetFlavor, architecture, applicationBaseUrl);
         }
 
         [ConditionalTheory]
         [FrameworkSkipCondition(RuntimeFrameworks.DotNet)]
-        [InlineData(ServerType.Kestrel, DotnetFlavor.Mono, DotnetArchitecture.x86, "http://localhost:5004/")]
+        [InlineData(ServerType.Kestrel, RuntimeFlavor.Mono, RuntimeArchitecture.x86, "http://localhost:5004/")]
-        public void SmokeTestSuite_OnMono(ServerType serverType, DotnetFlavor donetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void SmokeTestSuite_OnMono(ServerType serverType, RuntimeFlavor donetFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
             SmokeTestSuite(serverType, donetFlavor, architecture, applicationBaseUrl);
         }
@@ -61,8 +61,8 @@ namespace E2ETests
         [SkipIfNativeModuleNotInstalled]
         [FrameworkSkipCondition(RuntimeFrameworks.Mono)]
         [OSSkipCondition(OperatingSystems.Win7And2008R2 | OperatingSystems.MacOSX | OperatingSystems.Unix)]
-        [InlineData(ServerType.IISNativeModule, DotnetFlavor.CoreClr, DotnetArchitecture.x86, "http://localhost:5005/")]
+        [InlineData(ServerType.IISNativeModule, RuntimeFlavor.CoreClr, RuntimeArchitecture.x86, "http://localhost:5005/")]
-        public void SmokeTestSuite_On_NativeModule_X86(ServerType serverType, DotnetFlavor donetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void SmokeTestSuite_On_NativeModule_X86(ServerType serverType, RuntimeFlavor donetFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
             SmokeTestSuite(serverType, donetFlavor, architecture, applicationBaseUrl);
         }
@@ -72,8 +72,8 @@ namespace E2ETests
         [FrameworkSkipCondition(RuntimeFrameworks.Mono)]
         [OSSkipCondition(OperatingSystems.Win7And2008R2 | OperatingSystems.MacOSX | OperatingSystems.Unix)]
         [SkipOn32BitOS]
-        [InlineData(ServerType.IISNativeModule, DotnetFlavor.CoreClr, DotnetArchitecture.amd64, "http://localhost:5005/")]
+        [InlineData(ServerType.IISNativeModule, RuntimeFlavor.CoreClr, RuntimeArchitecture.amd64, "http://localhost:5005/")]
-        public void SmokeTestSuite_On_NativeModule_AMD64(ServerType serverType, DotnetFlavor donetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void SmokeTestSuite_On_NativeModule_AMD64(ServerType serverType, RuntimeFlavor donetFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
             SmokeTestSuite(serverType, donetFlavor, architecture, applicationBaseUrl);
         }
@@ -81,13 +81,13 @@ namespace E2ETests
         // [ConditionalTheory]
         [FrameworkSkipCondition(RuntimeFrameworks.Mono)]
         [OSSkipCondition(OperatingSystems.MacOSX | OperatingSystems.Unix)]
-        [InlineData(ServerType.IIS, DotnetFlavor.CoreClr, DotnetArchitecture.x86, "http://localhost:5005/")]
+        [InlineData(ServerType.IIS, RuntimeFlavor.CoreClr, RuntimeArchitecture.x86, "http://localhost:5005/")]
-        public void SmokeTestSuite_On_IIS_X86(ServerType serverType, DotnetFlavor donetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        public void SmokeTestSuite_On_IIS_X86(ServerType serverType, RuntimeFlavor donetFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
             SmokeTestSuite(serverType, donetFlavor, architecture, applicationBaseUrl);
         }
 
-        private void SmokeTestSuite(ServerType serverType, DotnetFlavor donetFlavor, DotnetArchitecture architecture, string applicationBaseUrl)
+        private void SmokeTestSuite(ServerType serverType, RuntimeFlavor donetFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
         {
             using (_logger.BeginScope("SmokeTestSuite"))
             {
@@ -97,8 +97,8 @@ namespace E2ETests
                 _startParameters = new StartParameters
                 {
                     ServerType = serverType,
-                    DotnetFlavor = donetFlavor,
+                    RuntimeFlavor = donetFlavor,
-                    DotnetArchitecture = architecture,
+                    RuntimeArchitecture = architecture,
                     EnvironmentName = "SocialTesting"
                 };