Merge pull request #1074 from Azure/dev

Update master with 2.0.12309

Author: ahmelsayed

README.md

@@ -60,17 +60,18 @@ brew install azure-functions-core-tools
 #### Ubuntu/Debian
 
 1. Set up package feed
-##### Ubuntu 18.04
+
+##### Ubuntu 18.10
 
 ```bash
-wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb
+wget -q https://packages.microsoft.com/config/ubuntu/18.10/packages-microsoft-prod.deb
 sudo dpkg -i packages-microsoft-prod.deb
 ```
 
-##### Ubuntu 17.10
+##### Ubuntu 18.04
 
 ```bash
-wget -q https://packages.microsoft.com/config/ubuntu/17.10/packages-microsoft-prod.deb
+wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb
 sudo dpkg -i packages-microsoft-prod.deb
 ```
 

build/Settings.cs

@@ -42,9 +42,9 @@ private static string config(string @default = null, [CallerMemberName] string k
 
         public const string DistLibUrl = "https://github.com/vsajip/distlib/archive/15dba58a827f56195b0fa0afe80a8925a92e8bf5.zip";
 
-        public const string PythonWorkerUrl = "https://raw.githubusercontent.com/Azure/azure-functions-python-worker/1.0.0b3/python/worker.py";
+        public const string PythonWorkerUrl = "https://raw.githubusercontent.com/Azure/azure-functions-python-worker/1.0.0b4/python/worker.py";
 
-        public const string PythonWorkerConfigUrl = "https://raw.githubusercontent.com/Azure/azure-functions-python-worker/1.0.0b3/python/worker.config.json";
+        public const string PythonWorkerConfigUrl = "https://raw.githubusercontent.com/Azure/azure-functions-python-worker/1.0.0b4/python/worker.config.json";
 
         public static readonly string OutputDir = Path.Combine(Path.GetFullPath(".."), "artifacts");
 

src/Azure.Functions.Cli/Actions/DeployActions/Platforms/Models/FunctionJson.cs

@@ -15,5 +15,6 @@ public class FunctionJson
     {
         public bool disabled { get; set; }
         public List<Binding> bindings { get; set; }
+        public string scriptFile { get; set; }
     }
 }

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

@@ -3,11 +3,13 @@
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using Azure.Functions.Cli.Actions.DeployActions.Platforms.Models;
 using Azure.Functions.Cli.Common;
 using Azure.Functions.Cli.Helpers;
 using Azure.Functions.Cli.Interfaces;
 using Colors.Net;
 using Fclp;
+using Newtonsoft.Json;
 using static Azure.Functions.Cli.Common.OutputTheme;
 
 namespace Azure.Functions.Cli.Actions.LocalActions
@@ -76,11 +78,11 @@ public async override Task RunAsync()
             if (workerRuntime != WorkerRuntime.None && !string.IsNullOrWhiteSpace(Language))
             {
                 // validate
-                var language = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(Language);
-                if (workerRuntime != language)
+                var workerRuntimeSelected = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(Language);
+                if (workerRuntime != workerRuntimeSelected)
                 {
                     throw new CliException("Selected language doesn't match worker set in local.settings.json." +
-                        $"Selected worker is: {workerRuntime} and selected language is: {language}");
+                        $"Selected worker is: {workerRuntime} and selected language is: {workerRuntimeSelected}");
                 }
             }
             else if (string.IsNullOrWhiteSpace(Language))
@@ -103,7 +105,7 @@ public async override Task RunAsync()
                     {
                         Language = displayList.First();
                     }
-                    else
+                    else if (!InferAndUpdateLanguage(workerRuntime))
                     {
                         ColoredConsole.Write("Select a language: ");
                         Language = SelectionMenuHelper.DisplaySelectionWizard(displayList);
@@ -128,7 +130,16 @@ public async override Task RunAsync()
             else
             {
                 ColoredConsole.Write("Select a template: ");
-                var templateLanguage = WorkerRuntimeLanguageHelper.GetTemplateLanguageFromWorker(workerRuntime);
+                string templateLanguage;
+                try
+                {
+                    templateLanguage = WorkerRuntimeLanguageHelper.NormalizeLanguage(Language);
+                }
+                catch (Exception)
+                {
+                    // Ideally this should never happen.
+                    templateLanguage = WorkerRuntimeLanguageHelper.GetDefaultTemplateLanguageFromWorker(workerRuntime);
+                }
                 TemplateName = TemplateName ?? SelectionMenuHelper.DisplaySelectionWizard(templates.Where(t => t.Metadata.Language.Equals(templateLanguage, StringComparison.OrdinalIgnoreCase)).Select(t => t.Metadata.Name).Distinct());
                 ColoredConsole.WriteLine(TitleColor(TemplateName));
 
@@ -145,9 +156,34 @@ public async override Task RunAsync()
                     FunctionName = FunctionName ?? Console.ReadLine();
                     FunctionName = string.IsNullOrEmpty(FunctionName) ? template.Metadata.DefaultFunctionName : FunctionName;
                     await _templatesManager.Deploy(FunctionName, template);
+                    PerformPostDeployTasks(FunctionName, Language);
                 }
             }
             ColoredConsole.WriteLine($"The function \"{FunctionName}\" was created successfully from the \"{TemplateName}\" template.");
         }
+
+        private bool InferAndUpdateLanguage(WorkerRuntime workerRuntime)
+        {
+            // If there is a tsconfig.json present, we assume that the language is typescript
+            if (workerRuntime == WorkerRuntime.node)
+            {
+                Language = FileSystemHelpers.FileExists(Path.Combine(Environment.CurrentDirectory, "tsconfig.json")) ? Constants.Languages.TypeScript : Constants.Languages.JavaScript;
+                return true;
+            }
+            return false;
+        }
+
+        private void PerformPostDeployTasks(string functionName, string language)
+        {
+            if (language == Constants.Languages.TypeScript)
+            {
+                // Update typescript function.json
+                var funcJsonFile = Path.Combine(Environment.CurrentDirectory, functionName, Constants.FunctionJsonFileName);
+                var jsonStr = FileSystemHelpers.ReadAllTextFromFile(funcJsonFile);
+                var funcObj = JsonConvert.DeserializeObject<FunctionJson>(jsonStr);
+                funcObj.scriptFile = $"../dist/{functionName}/index.js";
+                FileSystemHelpers.WriteAllTextToFile(funcJsonFile, JsonConvert.SerializeObject(funcObj, Formatting.Indented));
+            }
+        }
     }
 }

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

@@ -32,6 +32,8 @@ internal class InitAction : BaseAction
 
         public bool Csx { get; set; }
 
+        public string Language { get; set; }
+
         internal readonly Dictionary<Lazy<string>, Task<string>> fileToContentMap = new Dictionary<Lazy<string>, Task<string>>
         {
             { new Lazy<string>(() => ".gitignore"), StaticResources.GitIgnore },
@@ -74,6 +76,12 @@ public override ICommandLineParserResult ParseArgs(string[] args)
                 .WithDescription("use csx dotnet functions")
                 .Callback(f => Csx = f);
 
+            Parser
+                .Setup<string>("language")
+                .SetDefault(null)
+                .WithDescription("Initialize a language specific project. Currently supported when --worker-runtime set to node. Options are - \"typescript\" and \"javascript\"")
+                .Callback(l => Language = l);
+
             if (args.Any() && !args.First().StartsWith("-"))
             {
                 FolderName = args.First();
@@ -109,10 +117,12 @@ public override async Task RunAsync()
                 var workerRuntimeString = SelectionMenuHelper.DisplaySelectionWizard(workerRuntimeToDisplayString.Values);
                 workerRuntime = workerRuntimeToDisplayString.FirstOrDefault(wr => wr.Value.Equals(workerRuntimeString)).Key;
                 ColoredConsole.WriteLine(TitleColor(workerRuntime.ToString()));
+                LanguageSelectionIfRelevant(workerRuntime);
             }
             else
             {
                 workerRuntime = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(WorkerRuntime);
+                Language = Language ?? WorkerRuntimeLanguageHelper.NormalizeLanguage(WorkerRuntime);
             }
 
             if (workerRuntime == Helpers.WorkerRuntime.dotnet && !Csx)
@@ -131,6 +141,20 @@ public override async Task RunAsync()
             await WriteDockerfile(workerRuntime);
         }
 
+        private void LanguageSelectionIfRelevant(WorkerRuntime workerRuntime)
+        {
+            if (workerRuntime == Helpers.WorkerRuntime.node)
+            {
+                if (WorkerRuntimeLanguageHelper.WorkerToSupportedLanguages.TryGetValue(workerRuntime, out IEnumerable<string> languages) 
+                    && languages.Count() != 0)
+                {
+                    ColoredConsole.Write("Select a Language: ");
+                    Language = SelectionMenuHelper.DisplaySelectionWizard(languages);
+                    ColoredConsole.WriteLine(TitleColor(Language));
+                }
+            }
+        }
+
         private async Task InitLanguageSpecificArtifacts(WorkerRuntime workerRuntime)
         {
             if (workerRuntime == Helpers.WorkerRuntime.python)
@@ -141,6 +165,12 @@ private async Task InitLanguageSpecificArtifacts(WorkerRuntime workerRuntime)
             {
                 await WriteFiles("profile.ps1", await StaticResources.PowerShellProfilePs1);
             }
+            if (Language == Constants.Languages.TypeScript)
+            {
+                await WriteFiles(".funcignore", await StaticResources.FuncIgnore);
+                await WriteFiles("package.json", await StaticResources.PackageJson);
+                await WriteFiles("tsconfig.json", await StaticResources.TsConfig);
+            }
         }
 
         private async Task WriteLocalSettingsJson(WorkerRuntime workerRuntime)

src/Azure.Functions.Cli/Azure.Functions.Cli.csproj

@@ -63,6 +63,15 @@
     <EmbeddedResource Include="StaticResources\templates.json">
       <LogicalName>$(AssemblyName).templates.json</LogicalName>
     </EmbeddedResource>
+    <EmbeddedResource Include="StaticResources\package.json">
+      <LogicalName>$(AssemblyName).package.json</LogicalName>
+    </EmbeddedResource>
+    <EmbeddedResource Include="StaticResources\tsconfig.json">
+      <LogicalName>$(AssemblyName).tsconfig.json</LogicalName>
+    </EmbeddedResource>
+    <EmbeddedResource Include="StaticResources\funcignore">
+      <LogicalName>$(AssemblyName).funcignore</LogicalName>
+    </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
     <Content Include="..\..\tools\python\packapp\__main__.py">
@@ -81,7 +90,7 @@
     <PackageReference Include="Microsoft.Azure.Functions.JavaWorker" Version="1.3.0-SNAPSHOT" />
     <PackageReference Include="Microsoft.Azure.Functions.NodeJsWorker" Version="1.0.1" />
     <PackageReference Include="Microsoft.Azure.Functions.PowerShellWorker" Version="0.1.63-preview" />
-    <PackageReference Include="Microsoft.Azure.WebJobs.Script.WebHost" Version="2.0.12303" />
+    <PackageReference Include="Microsoft.Azure.WebJobs.Script.WebHost" Version="2.0.12309" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
   </ItemGroup>
 </Project>

src/Azure.Functions.Cli/Common/Constants.cs

@@ -48,6 +48,16 @@ public static class Errors
             public const string ExtensionsNeedDotnet = "Extensions command requires dotnet on your path. Please make sure to install dotnet (.NET Core SDK) for your system from https://www.microsoft.com/net/download";
         }
 
+        public static class Languages
+        {
+            public const string JavaScript = "javascript";
+            public const string TypeScript = "typescript";
+            public const string Python = "python";
+            public const string CSharp = "c#";
+            public const string Powershell = "powershell";
+            public const string Java = "java";
+        }
+
         public static class ArmConstants
         {
             public const string AADAuthorityBase = "https://login.microsoftonline.com";
@@ -59,7 +69,7 @@ public static class ArmConstants
 
         public static class DockerImages
         {
-            public const string LinuxPythonImageAmd64 = "mcr.microsoft.com/azure-functions/python:2.0.12285";
+            public const string LinuxPythonImageAmd64 = "mcr.microsoft.com/azure-functions/python:2.0.12309";
         }
 
         public static class StaticResourcesNames

src/Azure.Functions.Cli/Helpers/PythonHelpers.cs

@@ -13,7 +13,7 @@ namespace Azure.Functions.Cli.Helpers
 {
     public static class PythonHelpers
     {
-        private static readonly string[] _workerPackages = new[] { "azure-functions==1.0.0b3", "azure-functions-worker==1.0.0b3" };
+        private static readonly string[] _workerPackages = new[] { "azure-functions==1.0.0b3", "azure-functions-worker==1.0.0b4" };
         private static bool InVirtualEnvironment => !string.IsNullOrEmpty(VirtualEnvironmentPath);
         public static string VirtualEnvironmentPath => Environment.GetEnvironmentVariable("VIRTUAL_ENV");
 

src/Azure.Functions.Cli/Helpers/WorkerRuntimeLanguageHelper.cs

@@ -23,7 +23,7 @@ public static class WorkerRuntimeLanguageHelper
         private static readonly IDictionary<WorkerRuntime, IEnumerable<string>> availableWorkersRuntime = new Dictionary<WorkerRuntime, IEnumerable<string>>
         {
             { WorkerRuntime.dotnet, new [] { "c#", "csharp", "f#", "fsharp" } },
-            { WorkerRuntime.node, new [] { "js", "javascript" } },
+            { WorkerRuntime.node, new [] { "js", "javascript", "typescript", "ts" } },
             { WorkerRuntime.python, new []  { "py" } },
             { WorkerRuntime.java, new string[] { } },
             { WorkerRuntime.powershell, new [] { "pwsh" } }
@@ -34,12 +34,33 @@ public static class WorkerRuntimeLanguageHelper
             .SelectMany(i => i)
             .ToDictionary(k => k.key, v => v.value, StringComparer.OrdinalIgnoreCase);
 
-        private static readonly IDictionary<WorkerRuntime, string> workerToLanguageMap = new Dictionary<WorkerRuntime, string>
+        private static readonly IDictionary<WorkerRuntime, string> workerToDefaultLanguageMap = new Dictionary<WorkerRuntime, string>
         {
-            { WorkerRuntime.dotnet, "c#" },
-            { WorkerRuntime.node, "javascript" },
-            { WorkerRuntime.python, "python" },
-            { WorkerRuntime.powershell, "powershell" }
+            { WorkerRuntime.dotnet, Constants.Languages.CSharp },
+            { WorkerRuntime.node, Constants.Languages.JavaScript },
+            { WorkerRuntime.python, Constants.Languages.Python },
+            { WorkerRuntime.powershell, Constants.Languages.Powershell }
+        };
+
+        private static readonly IDictionary<string, IEnumerable<string>> languageToAlias = new Dictionary<string, IEnumerable<string>>
+        {
+            // By default node should map to javascript
+            { Constants.Languages.JavaScript, new [] { "js", "node" } },
+            { Constants.Languages.TypeScript, new [] { "ts" } },
+            { Constants.Languages.Python, new [] { "py" } },
+            { Constants.Languages.Powershell, new [] { "pwsh" } },
+            { Constants.Languages.CSharp, new [] { "csharp", "dotnet" } },
+            { Constants.Languages.Java, new string[] { } }
+        };
+
+        public static readonly IDictionary<string, string> WorkerRuntimeStringToLanguage = languageToAlias
+            .Select(p => p.Value.Select(v => new { key = v, value = p.Key }).Append(new { key = p.Key.ToString(), value = p.Key }))
+            .SelectMany(i => i)
+            .ToDictionary(k => k.key, v => v.value, StringComparer.OrdinalIgnoreCase);
+
+        public static readonly IDictionary<WorkerRuntime, IEnumerable<string>> WorkerToSupportedLanguages = new Dictionary<WorkerRuntime, IEnumerable<string>>
+        {
+            { WorkerRuntime.node, new [] { Constants.Languages.JavaScript, Constants.Languages.TypeScript } }
         };
 
         public static string AvailableWorkersRuntimeString =>
@@ -86,6 +107,22 @@ public static WorkerRuntime NormalizeWorkerRuntime(string workerRuntime)
             }
         }
 
+        public static string NormalizeLanguage(string languageString)
+        {
+            if (string.IsNullOrWhiteSpace(languageString))
+            {
+                throw new ArgumentNullException(nameof(languageString), "language can't be empty");
+            }
+            else if (normalizeMap.ContainsKey(languageString))
+            {
+                return WorkerRuntimeStringToLanguage[languageString];
+            }
+            else
+            {
+                throw new ArgumentException($"Language '{languageString}' is not available. Available language strings are {WorkerRuntimeStringToLanguage.Keys}");
+            }
+        }
+
         public static IEnumerable<string> LanguagesForWorker(WorkerRuntime worker)
         {
             return normalizeMap.Where(p => p.Value == worker).Select(p => p.Key);
@@ -116,13 +153,13 @@ internal static WorkerRuntime SetWorkerRuntime(ISecretsManager secretsManager, s
             return worker;
         }
 
-        public static string GetTemplateLanguageFromWorker(WorkerRuntime worker)
+        public static string GetDefaultTemplateLanguageFromWorker(WorkerRuntime worker)
         {
-            if (!workerToLanguageMap.ContainsKey(worker))
+            if (!workerToDefaultLanguageMap.ContainsKey(worker))
             {
                 throw new ArgumentException($"Worker runtime '{worker}' is not a valid worker for a template.");
             }
-            return workerToLanguageMap[worker];
+            return workerToDefaultLanguageMap[worker];
         }
     }
 }

src/Azure.Functions.Cli/StaticResources/StaticResources.cs

@@ -50,5 +50,11 @@ private static async Task<string> GetValue(string name)
         public static Task<string> PowerShellProfilePs1 => GetValue("profile.ps1");
 
         public static Task<string> TemplatesJson => GetValue("templates.json");
+
+        public static Task<string> FuncIgnore => GetValue("funcignore");
+
+        public static Task<string> PackageJson => GetValue("package.json");
+
+        public static Task<string> TsConfig => GetValue("tsconfig.json");
     }
 }