changing dotnet helper back

Author: aishwaryabh

src/Cli/func/Helpers/DotnetHelpers.cs

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 using System.Reflection;
@@ -15,6 +15,8 @@ public static class DotnetHelpers
     {
         private const string WebJobsTemplateBasePackId = "Microsoft.Azure.WebJobs";
         private const string IsolatedTemplateBasePackId = "Microsoft.Azure.Functions.Worker";
+        private const string TemplatesLockFileName = "func_dotnet_templates.lock";
+        private static readonly Lazy<Task<HashSet<string>>> _installedTemplatesList = new(GetInstalledTemplatePackageIds);
 
         public static void EnsureDotnet()
         {
@@ -67,7 +69,7 @@ public static async Task<string> DetermineTargetFramework(string projectDirector
 
         public static async Task DeployDotnetProject(string name, bool force, WorkerRuntime workerRuntime, string targetFramework = "")
         {
-            await TemplateOperation(
+            await TemplateOperationAsync(
                 async () =>
                 {
                     var frameworkString = string.IsNullOrEmpty(targetFramework)
@@ -89,7 +91,7 @@ await TemplateOperation(
         public static async Task DeployDotnetFunction(string templateName, string functionName, string namespaceStr, string language, WorkerRuntime workerRuntime, AuthorizationLevel? httpAuthorizationLevel = null)
         {
             ColoredConsole.WriteLine($"{Environment.NewLine}Creating dotnet function...");
-            await TemplateOperation(
+            await TemplateOperationAsync(
                 async () =>
                 {
                     // In .NET 6.0, the 'dotnet new' command requires the short name.
@@ -275,87 +277,128 @@ public static string GetCsprojOrFsproj()
             }
         }
 
-        private static Task TemplateOperation(Func<Task> action, WorkerRuntime workerRuntime)
+        private static async Task TemplateOperationAsync(Func<Task> action, WorkerRuntime workerRuntime)
         {
             EnsureDotnet();
 
             if (workerRuntime == WorkerRuntime.DotnetIsolated)
             {
-                return IsolatedTemplateOperation(action);
+                await EnsureIsolatedTemplatesInstalled();
             }
             else
             {
-                return WebJobsTemplateOperation(action);
+                await EnsureWebJobsTemplatesInstalled();
             }
+
+            await action();
         }
 
-        private static async Task IsolatedTemplateOperation(Func<Task> action)
+        private static async Task EnsureIsolatedTemplatesInstalled()
         {
-            try
+            if (AreDotnetTemplatePackagesInstalled(await _installedTemplatesList.Value, WebJobsTemplateBasePackId))
             {
                 await UninstallWebJobsTemplates();
-                await InstallIsolatedTemplates();
-                await action();
             }
-            finally
+
+            if (AreDotnetTemplatePackagesInstalled(await _installedTemplatesList.Value, IsolatedTemplateBasePackId))
             {
-                await UninstallIsolatedTemplates();
+                return;
             }
+
+            await FileLockHelper.WithFileLockAsync(TemplatesLockFileName, InstallIsolatedTemplates);
         }
 
-        private static async Task WebJobsTemplateOperation(Func<Task> action)
+        private static async Task EnsureWebJobsTemplatesInstalled()
         {
-            try
+            if (AreDotnetTemplatePackagesInstalled(await _installedTemplatesList.Value, IsolatedTemplateBasePackId))
             {
                 await UninstallIsolatedTemplates();
-                await InstallWebJobsTemplates();
-                await action();
             }
-            finally
+
+            if (AreDotnetTemplatePackagesInstalled(await _installedTemplatesList.Value, WebJobsTemplateBasePackId))
             {
-                await UninstallWebJobsTemplates();
+                return;
             }
+
+            await FileLockHelper.WithFileLockAsync(TemplatesLockFileName, InstallWebJobsTemplates);
         }
 
-        private static async Task UninstallIsolatedTemplates()
+        internal static bool AreDotnetTemplatePackagesInstalled(HashSet<string> templates, string packageIdPrefix)
         {
-            string projTemplates = $"{IsolatedTemplateBasePackId}.ProjectTemplates";
-            string itemTemplates = $"{IsolatedTemplateBasePackId}.ItemTemplates";
-
-            var exe = new Executable("dotnet", $"new -u \"{projTemplates}\"");
-            await exe.RunAsync();
+            var hasProjectTemplates = templates.Contains($"{packageIdPrefix}.ProjectTemplates", StringComparer.OrdinalIgnoreCase);
+            var hasItemTemplates = templates.Contains($"{packageIdPrefix}.ItemTemplates", StringComparer.OrdinalIgnoreCase);
 
-            exe = new Executable("dotnet", $"new -u \"{itemTemplates}\"");
-            await exe.RunAsync();
+            return hasProjectTemplates && hasItemTemplates;
         }
 
-        private static async Task UninstallWebJobsTemplates()
+        private static async Task<HashSet<string>> GetInstalledTemplatePackageIds()
         {
-            string projTemplates = $"{WebJobsTemplateBasePackId}.ProjectTemplates";
-            string itemTemplates = $"{WebJobsTemplateBasePackId}.ItemTemplates";
+            var exe = new Executable("dotnet", "new uninstall", shareConsole: false);
+            var output = new StringBuilder();
+            var exitCode = await exe.RunAsync(o => output.AppendLine(o), e => output.AppendLine(e));
+
+            if (exitCode != 0)
+            {
+                throw new CliException("Failed to get list of installed template packages");
+            }
+
+            var lines = output.ToString()
+                .Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries);
+
+            var packageIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            const string uninstallPrefix = "dotnet new uninstall ";
+
+            foreach (var line in lines)
+            {
+                var trimmed = line.Trim();
 
-            var exe = new Executable("dotnet", $"new -u \"{projTemplates}\"");
-            await exe.RunAsync();
+                if (trimmed.StartsWith(uninstallPrefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    var packageId = trimmed.Substring(uninstallPrefix.Length).Trim();
+                    if (!string.IsNullOrWhiteSpace(packageId))
+                    {
+                        packageIds.Add(packageId);
+                    }
+                }
+            }
 
-            exe = new Executable("dotnet", $"new -u \"{itemTemplates}\"");
-            await exe.RunAsync();
+            return packageIds;
         }
 
+        private static Task UninstallIsolatedTemplates() => DotnetTemplatesAction("uninstall", nugetPackageList: [$"{IsolatedTemplateBasePackId}.ProjectTemplates", $"{IsolatedTemplateBasePackId}.ItemTemplates"]);
+
+        private static Task UninstallWebJobsTemplates() => DotnetTemplatesAction("uninstall", nugetPackageList: [$"{WebJobsTemplateBasePackId}.ProjectTemplates", $"{WebJobsTemplateBasePackId}.ItemTemplates"]);
+
         private static Task InstallWebJobsTemplates() => DotnetTemplatesAction("install", "templates");
 
         private static Task InstallIsolatedTemplates() => DotnetTemplatesAction("install", Path.Combine("templates", $"net-isolated"));
 
-        private static async Task DotnetTemplatesAction(string action, string templateDirectory)
+        private static async Task DotnetTemplatesAction(string action, string templateDirectory = null, string[] nugetPackageList = null)
         {
-            var templatesLocation = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), templateDirectory);
-            if (!FileSystemHelpers.DirectoryExists(templatesLocation))
+            string[] list;
+
+            if (!string.IsNullOrEmpty(templateDirectory))
+            {
+                var templatesLocation = Path.Combine(
+                    Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
+                    templateDirectory);
+
+                if (!FileSystemHelpers.DirectoryExists(templatesLocation))
+                {
+                    throw new CliException($"Can't find templates location. Looked under '{templatesLocation}'");
+                }
+
+                list = Directory.GetFiles(templatesLocation, "*.nupkg", SearchOption.TopDirectoryOnly);
+            }
+            else
             {
-                throw new CliException($"Can't find templates location. Looked under '{templatesLocation}'");
+                list = nugetPackageList ?? Array.Empty<string>();
             }
 
-            foreach (var nupkg in Directory.GetFiles(templatesLocation, "*.nupkg", SearchOption.TopDirectoryOnly))
+            foreach (var nupkg in list)
             {
-                var exe = new Executable("dotnet", $"new --{action} \"{nupkg}\"");
+                var exe = new Executable("dotnet", $"new {action} \"{nupkg}\"");
                 await exe.RunAsync();
             }
         }