Add InstanceController for instance management calls

Author: ahmelsayed

src/WebJobs.Script.WebHost/Controllers/FunctionsController.cs

@@ -3,6 +3,8 @@
 
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.IO.Abstractions;
+using System.IO.Compression;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
@@ -12,17 +14,19 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Management.Models;
+using Microsoft.Azure.WebJobs.Script.WebHost.Extensions;
 using Microsoft.Azure.WebJobs.Script.WebHost.Filters;
 using Microsoft.Azure.WebJobs.Script.WebHost.Management;
 using Microsoft.Azure.WebJobs.Script.WebHost.Models;
 using Microsoft.Azure.WebJobs.Script.WebHost.Security.Authorization.Policies;
 using Microsoft.Extensions.Logging;
+using Microsoft.Net.Http.Headers;
 
 namespace Microsoft.Azure.WebJobs.Script.WebHost.Controllers
 {
     /// <summary>
     /// Controller responsible for administrative and management operations on functions
-    /// example retriving a list of functions, invoking a function, creating a function, etc
+    /// example retrieving a list of functions, invoking a function, creating a function, etc
     /// </summary>
     public class FunctionsController : Controller
     {
@@ -162,5 +166,35 @@ public async Task<IActionResult> Delete(string name)
                 return StatusCode(StatusCodes.Status500InternalServerError, error);
             }
         }
+
+        [HttpGet]
+        [Route("admin/functions/download")]
+        [Authorize(Policy = PolicyNames.AdminAuthLevel)]
+        public IActionResult Download()
+        {
+            var path = _scriptHostManager.Instance.ScriptConfig.RootScriptPath;
+            var dirInfo = FileUtility.DirectoryInfoFromDirectoryName(path);
+            return new FileCallbackResult(new MediaTypeHeaderValue("application/octet-stream"), async (outputStream, _) =>
+            {
+                using (var zipArchive = new ZipArchive(outputStream, ZipArchiveMode.Create))
+                {
+                    foreach (FileSystemInfoBase fileSysInfo in dirInfo.GetFileSystemInfos())
+                    {
+                        if (fileSysInfo is DirectoryInfoBase directoryInfo)
+                        {
+                            await zipArchive.AddDirectory(directoryInfo, fileSysInfo.Name);
+                        }
+                        else
+                        {
+                            // Add it at the root of the zip
+                            await zipArchive.AddFile(fileSysInfo.FullName, string.Empty);
+                        }
+                    }
+                }
+            })
+            {
+                FileDownloadName = (System.Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME") ?? "functions") + ".zip"
+            };
+        }
     }
 }

src/WebJobs.Script.WebHost/Controllers/HostController.cs

@@ -141,6 +141,15 @@ public async Task<IActionResult> SyncTriggers()
                 : StatusCode(StatusCodes.Status500InternalServerError, new { status = error });
         }
 
+        [HttpPost]
+        [Route("admin/host/restart")]
+        [Authorize(Policy = PolicyNames.AdminAuthLevel)]
+        public IActionResult Restart()
+        {
+            _scriptHostManager.RestartHost();
+            return Ok(_webHostSettings);
+        }
+
         [HttpGet]
         [HttpPost]
         [Authorize(AuthenticationSchemes = AuthLevelAuthenticationDefaults.AuthenticationScheme)]

src/WebJobs.Script.WebHost/Controllers/InstanceController.cs

@@ -0,0 +1,63 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Azure.WebJobs.Script.Config;
+using Microsoft.Azure.WebJobs.Script.WebHost.Management;
+using Microsoft.Azure.WebJobs.Script.WebHost.Models;
+using Microsoft.Azure.WebJobs.Script.WebHost.Security.Authorization.Policies;
+
+namespace Microsoft.Azure.WebJobs.Script.WebHost.Controllers
+{
+    /// <summary>
+    /// Controller responsible for instance operations that are orthogonal to the script host.
+    /// An instance is an unassigned generic container running with the runtime in standby mode.
+    /// These APIs are used by the AppService Controller to validate standby instance status and info.
+    /// </summary>
+    public class InstanceController : Controller
+    {
+        private readonly WebScriptHostManager _scriptHostManager;
+        private readonly ScriptSettingsManager _settingsManager;
+        private readonly IInstanceManager _instanceManager;
+
+        public InstanceController(WebScriptHostManager scriptHostManager, ScriptSettingsManager settingsManager, IInstanceManager instanceManager)
+        {
+            _scriptHostManager = scriptHostManager;
+            _settingsManager = settingsManager;
+            _instanceManager = instanceManager;
+        }
+
+        [HttpPost]
+        [Route("admin/instance/assign")]
+        [Authorize(Policy = PolicyNames.AdminAuthLevel)]
+        public IActionResult Assign([FromBody] EncryptedHostAssignmentContext encryptedAssignmentContext)
+        {
+            var containerKey = _settingsManager.GetSetting(EnvironmentSettingNames.ContainerEncryptionKey);
+            var assignmentContext = encryptedAssignmentContext.Decrypt(containerKey);
+            return _instanceManager.StartAssignment(assignmentContext)
+                ? Accepted()
+                : StatusCode(StatusCodes.Status409Conflict, "Instance already assigned");
+        }
+
+        [HttpGet]
+        [Route("admin/instance/status")]
+        [Authorize(Policy = PolicyNames.AdminAuthLevel)]
+        public async Task<IActionResult> GetInstanceStatus([FromQuery] int timeout = int.MaxValue)
+        {
+            return await _scriptHostManager.DelayUntilHostReady(timeoutSeconds: timeout)
+                ? Ok()
+                : StatusCode(StatusCodes.Status503ServiceUnavailable);
+        }
+
+        [HttpGet]
+        [Route("admin/instance/info")]
+        [Authorize(Policy = PolicyNames.AdminAuthLevel)]
+        public IActionResult GetInstanceInfo()
+        {
+            return Ok(_instanceManager.GetInstanceInfo());
+        }
+    }
+}

src/WebJobs.Script.WebHost/Extensions/ZipArchiveExtensions.cs

@@ -0,0 +1,77 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
+using System.IO.Compression;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.WebJobs.Script.WebHost.Extensions
+{
+    public static class ZipArchiveExtensions
+    {
+        public static async Task AddDirectory(this ZipArchive zipArchive, DirectoryInfoBase directory, string directoryNameInArchive)
+        {
+            await InternalAddDirectory(zipArchive, directory, directoryNameInArchive);
+        }
+
+        private static async Task InternalAddDirectory(ZipArchive zipArchive, DirectoryInfoBase directory, string directoryNameInArchive, IList<ZipArchiveEntry> files = null)
+        {
+            bool any = false;
+            foreach (var info in directory.GetFileSystemInfos())
+            {
+                any = true;
+                if (info is DirectoryInfoBase subDirectoryInfo)
+                {
+                    string childName = ForwardSlashCombine(directoryNameInArchive, subDirectoryInfo.Name);
+                    await InternalAddDirectory(zipArchive, subDirectoryInfo, childName, files);
+                }
+                else
+                {
+                    var entry = await zipArchive.AddFile((FileInfoBase)info, directoryNameInArchive);
+                    files?.Add(entry);
+                }
+            }
+
+            if (!any)
+            {
+                // If the directory did not have any files or folders, add a entry for it
+                zipArchive.CreateEntry(EnsureTrailingSlash(directoryNameInArchive));
+            }
+        }
+
+        private static string ForwardSlashCombine(string part1, string part2)
+        {
+            return Path.Combine(part1, part2).Replace('\\', '/');
+        }
+
+        public static Task<ZipArchiveEntry> AddFile(this ZipArchive zipArchive, string filePath, string directoryNameInArchive = "")
+        {
+            var fileInfo = FileUtility.FileInfoFromFileName(filePath);
+            return zipArchive.AddFile(fileInfo, directoryNameInArchive);
+        }
+
+        public static async Task<ZipArchiveEntry> AddFile(this ZipArchive zipArchive, FileInfoBase file, string directoryNameInArchive)
+        {
+            using (var fileStream = file.OpenRead())
+            {
+                string fileName = ForwardSlashCombine(directoryNameInArchive, file.Name);
+                ZipArchiveEntry entry = zipArchive.CreateEntry(fileName, CompressionLevel.Fastest);
+                entry.LastWriteTime = file.LastWriteTime;
+
+                using (var zipStream = entry.Open())
+                {
+                    await fileStream.CopyToAsync(zipStream);
+                }
+                return entry;
+            }
+        }
+
+        private static string EnsureTrailingSlash(string input)
+        {
+            return input.EndsWith("/", StringComparison.Ordinal) ? input : input + "/";
+        }
+    }
+}

src/WebJobs.Script.WebHost/Helpers/SimpleWebTokenHelper.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Security.Cryptography;
@@ -13,15 +12,15 @@ namespace Microsoft.Azure.WebJobs.Script.WebHost.Helpers
     public static class SimpleWebTokenHelper
     {
         /// <summary>
-        /// A SWT or a Simple Web Token is a token that's made of key=value pairs seperated
+        /// A SWT or a Simple Web Token is a token that's made of key=value pairs separated
         /// by &. We only specify expiration in ticks from now (exp={ticks})
         /// The SWT is then returned as an encrypted string
         /// </summary>
         /// <param name="validUntil">Datetime for when the token should expire</param>
         /// <returns>a SWT signed by this app</returns>
         public static string CreateToken(DateTime validUntil) => Encrypt($"exp={validUntil.Ticks}");
 
-        private static string Encrypt(string value)
+        internal static string Encrypt(string value)
         {
             using (var aes = new AesManaged { Key = GetWebSiteAuthEncryptionKey() })
             {
@@ -46,6 +45,38 @@ private static string Encrypt(string value)
             }
         }
 
+        internal static string Decrypt(byte[] encryptionKey, string value)
+        {
+            var parts = value.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
+            if (parts.Length != 2 && parts.Length != 3)
+            {
+                throw new InvalidOperationException("Malformed token.");
+            }
+
+            var iv = Convert.FromBase64String(parts[0]);
+            var data = Convert.FromBase64String(parts[1]);
+            var base64KeyHash = parts.Length == 3 ? parts[2] : null;
+
+            if (!string.IsNullOrEmpty(base64KeyHash) && !string.Equals(GetSHA256Base64String(encryptionKey), base64KeyHash))
+            {
+                throw new InvalidOperationException(string.Format("Key with hash {0} does not exist.", base64KeyHash));
+            }
+
+            using (var aes = new AesManaged { Key = encryptionKey })
+            {
+                using (var ms = new MemoryStream())
+                {
+                    using (var cs = new CryptoStream(ms, aes.CreateDecryptor(aes.Key, iv), CryptoStreamMode.Write))
+                    using (var binaryWriter = new BinaryWriter(cs))
+                    {
+                        binaryWriter.Write(data, 0, data.Length);
+                    }
+
+                    return Encoding.UTF8.GetString(ms.ToArray());
+                }
+            }
+        }
+
         private static string GetSHA256Base64String(byte[] key)
         {
             using (var sha256 = new SHA256Managed())

src/WebJobs.Script.WebHost/Management/IInstanceManager.cs

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using Microsoft.Azure.WebJobs.Script.WebHost.Models;
+
+namespace Microsoft.Azure.WebJobs.Script.WebHost.Management
+{
+    public interface IInstanceManager
+    {
+        IDictionary<string, string> GetInstanceInfo();
+
+        bool StartAssignment(HostAssignmentContext assignmentContext);
+    }
+}