Enable mesh init server

Author: ahmelsayed

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

@@ -270,24 +270,15 @@ private async Task ApplyContext(HostAssignmentContext assignmentContext)
             }
             else if (!string.IsNullOrEmpty(assignmentContext.AzureFilesConnectionString))
             {
-                ApplyAzureFilesContext(assignmentContext.AzureFilesConnectionString, assignmentContext.AzureFilesContentShare, "/home");
+                await MountCifs(assignmentContext.AzureFilesConnectionString, assignmentContext.AzureFilesContentShare, "/home");
             }
         }
 
-        private void ApplyAzureFilesContext(string connectionString, string contentShare, string targetPath)
-        {
-            var sa = CloudStorageAccount.Parse(connectionString);
-            var key = Convert.ToBase64String(sa.Credentials.ExportKey());
-
-            var mountCommand = $"mount -t cifs //{sa.FileEndpoint.Host}/{contentShare} {targetPath} -o vers=3.0,username={sa.Credentials.AccountName},password={key},dir_mode=0777,file_mode=0777,serverino";
-            RunBashCommand($"(mkdir -p {targetPath} || true) && ({mountCommand}) && (mkdir -p /home/site/wwwroot || true)", MetricEventNames.LinuxContainerSpecializationAzureFilesMount);
-        }
-
         private async Task ApplyBlobPackageContext(RunFromPackageContext pkgContext, string targetPath)
         {
             // download zip and extract
             var filePath = await Download(pkgContext);
-            UnpackPackage(filePath, targetPath, pkgContext);
+            await UnpackPackage(filePath, targetPath, pkgContext);
 
             string bundlePath = Path.Combine(targetPath, "worker-bundle");
             if (Directory.Exists(bundlePath))
@@ -368,7 +359,7 @@ private void AriaDownload(string directory, string fileName, Uri zipUri)
             _logger.LogInformation($"{fileInfo.Length} bytes downloaded");
         }
 
-        private void UnpackPackage(string filePath, string scriptPath, RunFromPackageContext pkgContext)
+        private async Task UnpackPackage(string filePath, string scriptPath, RunFromPackageContext pkgContext)
         {
             CodePackageType packageType;
             using (_metricsLogger.LatencyEvent(MetricEventNames.LinuxContainerSpecializationGetPackageType))
@@ -385,15 +376,15 @@ private void UnpackPackage(string filePath, string scriptPath, RunFromPackageCon
                 }
                 else
                 {
-                    MountFsImage(filePath, scriptPath);
+                    await MountFuse("squashfs", filePath, scriptPath);
                 }
             }
             else if (packageType == CodePackageType.Zip)
             {
                 // default to unzip for zip packages
                 if (_environment.IsMountEnabled())
                 {
-                    MountZipFile(filePath, scriptPath);
+                    await MountFuse("zip", filePath, scriptPath);
                 }
                 else
                 {
@@ -451,40 +442,35 @@ private void UnzipPackage(string filePath, string scriptPath)
         }
 
         private void UnsquashImage(string filePath, string scriptPath)
-            => RunBashCommand($"(mkdir -p '{scriptPath}' || true) && unsquashfs -f -d '{scriptPath}' '{filePath}'", MetricEventNames.LinuxContainerSpecializationUnsquash);
+            => RunBashCommand($"unsquashfs -f -d '{scriptPath}' '{filePath}'", MetricEventNames.LinuxContainerSpecializationUnsquash);
 
-        private void MountFsImage(string filePath, string scriptPath)
-            => RunFuseMount($"squashfuse_ll -o nonempty '{filePath}' '{scriptPath}'", scriptPath);
+        private async Task MountFuse(string type, string filePath, string scriptPath)
+            => await Mount(new[]
+            {
+                new KeyValuePair<string, string>("operation", type),
+                new KeyValuePair<string, string>("filePath", filePath),
+                new KeyValuePair<string, string>("targetPath", scriptPath),
+            });
 
-        private void MountZipFile(string filePath, string scriptPath)
-            => RunFuseMount($"fuse-zip -o nonempty -r '{filePath}' '{scriptPath}'", scriptPath);
+        private async Task MountCifs(string connectionString, string contentShare, string targetPath)
+        {
+            var sa = CloudStorageAccount.Parse(connectionString);
+            var key = Convert.ToBase64String(sa.Credentials.ExportKey());
+            await Mount(new[]
+           {
+                new KeyValuePair<string, string>("operation", "cifs"),
+                new KeyValuePair<string, string>("host", sa.FileEndpoint.Host),
+                new KeyValuePair<string, string>("accountName", sa.Credentials.AccountName),
+                new KeyValuePair<string, string>("accountKey", key),
+                new KeyValuePair<string, string>("contentShare", contentShare),
+                new KeyValuePair<string, string>("targetPath", targetPath),
+            });
+        }
 
-        private void RunFuseMount(string mountCommand, string targetPath)
+        private async Task Mount(IEnumerable<KeyValuePair<string, string>> formData)
         {
-            using (_metricsLogger.LatencyEvent(MetricEventNames.LinuxContainerSpecializationFuseMount))
-            {
-                var bashCommand = $"(mknod /dev/fuse c 10 229 || true) && (mkdir -p '{targetPath}' || true) && ({mountCommand})";
-                var process = new Process
-                {
-                    StartInfo = new ProcessStartInfo
-                    {
-                        FileName = "bash",
-                        Arguments = $"-c \"{bashCommand}\"",
-                        RedirectStandardOutput = true,
-                        RedirectStandardError = true,
-                        UseShellExecute = false,
-                        CreateNoWindow = true
-                    }
-                };
-                _logger.LogInformation($"Running: {process.StartInfo.FileName} {process.StartInfo.Arguments}");
-                process.Start();
-                var output = process.StandardOutput.ReadToEnd();
-                var error = process.StandardError.ReadToEnd();
-                process.WaitForExit();
-                _logger.LogInformation($"Output: {output}");
-                _logger.LogInformation($"error: {output}");
-                _logger.LogInformation($"exitCode: {process.ExitCode}");
-            }
+            var res = await _client.PostAsync(_environment.GetEnvironmentVariable(EnvironmentSettingNames.MeshInitURI), new FormUrlEncodedContent(formData));
+            _logger.LogInformation("Response {res} from init", res);
         }
 
         private (string, string, int) RunBashCommand(string command, string metricName)

src/WebJobs.Script/Environment/EnvironmentExtensions.cs

@@ -208,9 +208,11 @@ public static string GetKubernetesApiServerUrl(this IEnvironment environment)
         }
 
         public static bool IsMountEnabled(this IEnvironment environment)
-            => string.Equals(environment.GetEnvironmentVariable(MountEnabled), "1");
+            => string.Equals(environment.GetEnvironmentVariable(MountEnabled), "1") &&
+            !string.IsNullOrEmpty(environment.GetEnvironmentVariable(MeshInitURI));
 
         public static bool IsMountDisabled(this IEnvironment environment)
-            => string.Equals(environment.GetEnvironmentVariable(MountEnabled), "0");
+            => string.Equals(environment.GetEnvironmentVariable(MountEnabled), "0") ||
+            string.IsNullOrEmpty(environment.GetEnvironmentVariable(MeshInitURI));
     }
 }

src/WebJobs.Script/Environment/EnvironmentSettingNames.cs

@@ -77,5 +77,6 @@ public static class EnvironmentSettingNames
         public const string FunctionsLogPath = "FUNCTIONS_LOG_PATH";
         public const string FunctionsSecretsPath = "FUNCTIONS_SECRETS_PATH";
         public const string FunctionsTestDataPath = "FUNCTIONS_TEST_DATA_PATH";
+        public const string MeshInitURI = "MESH_INIT_URI";
     }
 }

test/WebJobs.Script.Tests.Integration/Management/InstanceManagerTests.cs

@@ -172,9 +172,9 @@ public async void StartAssignment_Succeeds_With_NonEmpty_ScmRunFromPackage_Blob(
                 p => Assert.StartsWith("Downloading zip contents from", p),
                 p => Assert.EndsWith(" bytes downloaded", p),
                 p => Assert.EndsWith(" bytes written", p),
-                p => Assert.StartsWith("Running: bash ", p),
+                p => Assert.StartsWith("Running: ", p),
                 p => Assert.StartsWith("Output:", p),
-                p => Assert.StartsWith("error:", p),
+                p => Assert.StartsWith("bash:", p),
                 p => Assert.StartsWith("exitCode:", p),
                 p => Assert.StartsWith("Triggering specialization", p));
         }