private async Task WriteDockerfile(WorkerRuntime workerRuntime)
{
if (InitDocker)
{
if (workerRuntime == Helpers.WorkerRuntime.dotnet)
{
await WriteFiles("Dockerfile", await StaticResources.DockerfileDotNet);
}
else if (workerRuntime == Helpers.WorkerRuntime.node)
{
await WriteFiles("Dockerfile", await StaticResources.DockerfileNode);
}
else if (workerRuntime == Helpers.WorkerRuntime.python)
{
await WriteFiles("Dockerfile", await StaticResources.DockerfilePython);
}
else if (workerRuntime == Helpers.WorkerRuntime.None)
{
throw new CliException("Can't find WorkerRuntime None");
}
}
}
public static async Task <Stream> GetAppZipFile(WorkerRuntime workerRuntime, string functionAppRoot, bool buildNativeDeps, GitIgnoreParser ignoreParser = null, string additionalPackages = null, bool ignoreDotNetCheck = false)
{
var gitIgnorePath = Path.Combine(functionAppRoot, Constants.FuncIgnoreFile);
if (ignoreParser == null && FileSystemHelpers.FileExists(gitIgnorePath))
{
ignoreParser = new GitIgnoreParser(await FileSystemHelpers.ReadAllTextFromFileAsync(gitIgnorePath));
}
if (workerRuntime == WorkerRuntime.python)
{
return(await PythonHelpers.GetPythonDeploymentPackage(FileSystemHelpers.GetLocalFiles(functionAppRoot, ignoreParser), functionAppRoot, buildNativeDeps, additionalPackages));
}
else if (workerRuntime == WorkerRuntime.dotnet && !ignoreDotNetCheck)
{
throw new CliException("Pack command doesn't work for dotnet functions");
}
else
{
return(CreateZip(FileSystemHelpers.GetLocalFiles(functionAppRoot, ignoreParser), functionAppRoot));
}
}
private async Task PreRunConditions(WorkerRuntime workerRuntime)
{
if (workerRuntime == WorkerRuntime.python)
{
await PythonHelpers.VerifyPythonVersions(setWorkerExecutable : true);
// We need to update the PYTHONPATH to add worker's dependencies
var pythonPath = Environment.GetEnvironmentVariable("PYTHONPATH") ?? string.Empty;
var pythonWorkerDeps = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "workers", "python", "deps");
if (!pythonPath.Contains(pythonWorkerDeps))
{
Environment.SetEnvironmentVariable("PYTHONPATH", $"{pythonWorkerDeps}{Path.PathSeparator}{pythonPath}", EnvironmentVariableTarget.Process);
}
if (StaticSettings.IsDebug)
{
ColoredConsole.WriteLine($"PYTHONPATH for the process is: {Environment.GetEnvironmentVariable("PYTHONPATH")}");
}
}
else if (workerRuntime == WorkerRuntime.dotnet && !NoBuild)
{
if (DotnetHelpers.CanDotnetBuild())
{
var outputPath = Path.Combine("bin", "output");
await DotnetHelpers.BuildDotnetProject(outputPath, string.Empty);
Environment.CurrentDirectory = Path.Combine(Environment.CurrentDirectory, outputPath);
}
else if (StaticSettings.IsDebug)
{
ColoredConsole.WriteLine("Could not find a valid .csproj file. Skipping the build.");
}
}
if (!NetworkHelpers.IsPortAvailable(Port))
{
throw new CliException($"Port {Port} is unavailable. Close the process using that port, or specify another port using --port [-p].");
}
}
public static bool IsLinuxFxVersionRuntimeMatched(string linuxFxVersion, WorkerRuntime runtime)
{
if (string.IsNullOrEmpty(linuxFxVersion))
{
// Suppress the check since when LinuxFxVersion == "", runtime image will depends on FUNCTIONS_WORKER_RUNTIME setting
return(true);
}
// Test if linux fx version matches any legacy runtime image (e.g. DOCKER|mcr.microsoft.com/azure-functions/dotnet)
bool isStartingWithDocker = linuxFxVersion.StartsWith("docker|", StringComparison.OrdinalIgnoreCase);
bool isLegacyImageMatched = false;
if (Constants.WorkerRuntimeImages.TryGetValue(runtime, out IEnumerable <string> legacyImages))
{
isLegacyImageMatched = legacyImages
.Any(image => linuxFxVersion.Contains(image, StringComparison.OrdinalIgnoreCase));
}
// Test if linux fx version matches any official runtime image (e.g. DOTNET, DOTNET|2)
bool isOfficialImageMatched = linuxFxVersion.StartsWith(runtime.ToString(), StringComparison.OrdinalIgnoreCase);
return(isOfficialImageMatched || (isStartingWithDocker && isLegacyImageMatched));
}
public static IEnumerable <string> LanguagesForWorker(WorkerRuntime worker)
{
return(normalizeMap.Where(p => p.Value == worker).Select(p => p.Key));
}
private string ResolveWorkerRuntimeVersion(WorkerRuntime workerRuntime)
{
return(FunctionAppSupportedWorkerRuntime.GetDefaultLanguageVersion(workerRuntime));
}
private async Task <IWebHost> BuildWebHost(ScriptApplicationHostOptions hostOptions, WorkerRuntime workerRuntime, Uri baseAddress, X509Certificate2 certificate)
{
IDictionary <string, string> settings = await GetConfigurationSettings(hostOptions.ScriptPath, baseAddress);
settings.AddRange(LanguageWorkerHelper.GetWorkerConfiguration(workerRuntime, LanguageWorkerSetting));
UpdateEnvironmentVariables(settings);
var defaultBuilder = Microsoft.AspNetCore.WebHost.CreateDefaultBuilder(Array.Empty <string>());
if (UseHttps)
{
defaultBuilder
.UseKestrel(options =>
{
options.Listen(IPAddress.Loopback, baseAddress.Port, listenOptins =>
{
listenOptins.UseHttps(certificate);
});
});
}
return(defaultBuilder
.UseSetting(WebHostDefaults.ApplicationKey, typeof(Startup).Assembly.GetName().Name)
.UseUrls(baseAddress.ToString())
.ConfigureAppConfiguration(configBuilder =>
{
configBuilder.AddEnvironmentVariables();
})
.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.ClearProviders();
loggingBuilder.AddDefaultWebJobsFilters();
loggingBuilder.AddProvider(new ColoredConsoleLoggerProvider((cat, level) => level >= LogLevel.Information));
})
.ConfigureServices((context, services) => services.AddSingleton <IStartup>(new Startup(context, hostOptions, CorsOrigins)))
.Build());
}
private async Task <IDictionary <string, string> > ValidateFunctionAppPublish(Site functionApp, WorkerRuntime workerRuntime)
{
var result = new Dictionary <string, string>();
// Check version
if (!functionApp.IsLinux)
{
if (functionApp.AzureAppSettings.TryGetValue(Constants.FunctionsExtensionVersion, out string version))
{
// v2 can be either "~2", "beta", or an exact match like "2.0.11961-alpha"
if (!version.Equals("~2") &&
!version.StartsWith("2.0") &&
!version.Equals("beta", StringComparison.OrdinalIgnoreCase))
{
if (Force)
{
result.Add(Constants.FunctionsExtensionVersion, "~2");
}
else
{
throw new CliException("You're trying to publish to a non-v2 function app from v2 tooling.\n" +
"You can pass --force to force update the app to v2, or switch to v1 or v3 tooling for publishing");
}
}
}
}
if (functionApp.AzureAppSettings.TryGetValue(Constants.FunctionsWorkerRuntime, out string workerRuntimeStr))
{
var resolution = $"You can pass --force to update your Azure app with '{workerRuntime}' as a '{Constants.FunctionsWorkerRuntime}'";
try
{
var azureWorkerRuntime = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntimeStr);
if (azureWorkerRuntime != workerRuntime)
{
if (Force)
{
ColoredConsole.WriteLine(WarningColor($"Setting '{Constants.FunctionsWorkerRuntime}' to '{workerRuntime}' because --force was passed"));
result[Constants.FunctionsWorkerRuntime] = workerRuntime.ToString();
}
else
{
throw new CliException($"Your Azure Function App has '{Constants.FunctionsWorkerRuntime}' set to '{azureWorkerRuntime}' while your local project is set to '{workerRuntime}'.\n"
+ resolution);
}
}
}
catch (ArgumentException) when(Force)
{
result[Constants.FunctionsWorkerRuntime] = workerRuntime.ToString();
}
catch (ArgumentException) when(!Force)
{
throw new CliException($"Your app has an unknown {Constants.FunctionsWorkerRuntime} defined '{workerRuntimeStr}'. Only {WorkerRuntimeLanguageHelper.AvailableWorkersRuntimeString} are supported.\n" +
resolution);
}
}
if (!functionApp.AzureAppSettings.ContainsKey("AzureWebJobsStorage") && functionApp.IsDynamic)
{
throw new CliException($"'{FunctionAppName}' app is missing AzureWebJobsStorage app setting. That setting is required for publishing consumption linux apps.");
}
if (functionApp.IsLinux && !functionApp.IsDynamic && !string.IsNullOrEmpty(functionApp.LinuxFxVersion))
{
// If linuxFxVersion does not match any of our images
if (PublishHelper.IsLinuxFxVersionUsingCustomImage(functionApp.LinuxFxVersion))
{
ColoredConsole.WriteLine($"Your functionapp is using a custom image {functionApp.LinuxFxVersion}.\nAssuming that the image contains the correct framework.\n");
}
// If there the functionapp is our image but does not match the worker runtime image, we either fail or force update
else if (!PublishHelper.IsLinuxFxVersionRuntimeMatched(functionApp.LinuxFxVersion, workerRuntime))
{
if (Force)
{
var updatedSettings = new Dictionary <string, string>
{
[Constants.LinuxFxVersion] = $"DOCKER|{Constants.WorkerRuntimeImages.GetValueOrDefault(workerRuntime).FirstOrDefault()}"
};
var settingsResult = await AzureHelper.UpdateWebSettings(functionApp, updatedSettings, AccessToken, ManagementURL);
if (!settingsResult.IsSuccessful)
{
ColoredConsole.Error
.WriteLine(ErrorColor("Error updating linux image version:"))
.WriteLine(ErrorColor(settingsResult.ErrorResult));
}
}
else
{
throw new CliException($"Your Linux dedicated app has the container image version (LinuxFxVersion) set to {functionApp.LinuxFxVersion} which is not expected for the worker runtime {workerRuntime}. " +
$"To force publish use --force. This will update your app to the expected image for worker runtime {workerRuntime}\n");
}
}
}
return(result);
}
private IDictionary <string, string> ValidateFunctionAppPublish(Site functionApp, WorkerRuntime workerRuntime)
{
var result = new Dictionary <string, string>();
// Check version
if (!functionApp.IsLinux)
{
if (functionApp.AzureAppSettings.TryGetValue(Constants.FunctionsExtensionVersion, out string version))
{
// v2 can be either "~2", "beta", or an exact match like "2.0.11961-alpha"
if (!version.Equals("~2") &&
!version.StartsWith("2.0") &&
!version.Equals("beta", StringComparison.OrdinalIgnoreCase))
{
if (Force)
{
result.Add(Constants.FunctionsExtensionVersion, "~2");
}
else
{
throw new CliException("You're trying to publish to a v1 function app from v2 tooling.\n" +
"You can pass --force to force update the app to v2, or downgrade to v1 tooling for publishing");
}
}
}
}
if (functionApp.AzureAppSettings.TryGetValue(Constants.FunctionsWorkerRuntime, out string workerRuntimeStr))
{
var resolution = $"You can pass --force to update your Azure app with '{workerRuntime}' as a '{Constants.FunctionsWorkerRuntime}'";
try
{
var azureWorkerRuntime = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntimeStr);
if (azureWorkerRuntime != workerRuntime)
{
if (Force)
{
ColoredConsole.WriteLine(WarningColor($"Setting '{Constants.FunctionsWorkerRuntime}' to '{workerRuntime}' because --force was passed"));
result[Constants.FunctionsWorkerRuntime] = workerRuntime.ToString();
}
else
{
throw new CliException($"Your Azure Function App has '{Constants.FunctionsWorkerRuntime}' set to '{azureWorkerRuntime}' while your local project is set to '{workerRuntime}'.\n"
+ resolution);
}
}
}
catch (ArgumentException) when(Force)
{
result[Constants.FunctionsWorkerRuntime] = workerRuntime.ToString();
}
catch (ArgumentException) when(!Force)
{
throw new CliException($"Your app has an unknown {Constants.FunctionsWorkerRuntime} defined '{workerRuntimeStr}'. Only {WorkerRuntimeLanguageHelper.AvailableWorkersRuntimeString} are supported.\n" +
resolution);
}
}
if (!functionApp.AzureAppSettings.ContainsKey("AzureWebJobsStorage") && functionApp.IsDynamic)
{
throw new CliException($"'{FunctionAppName}' app is missing AzureWebJobsStorage app setting. That setting is required for publishing consumption linux apps.");
}
if (functionApp.IsLinux &&
functionApp.IsDynamic &&
functionApp.AzureAppSettings.ContainsKey("WEBSITE_CONTENTAZUREFILECONNECTIONSTRING"))
{
if (Force)
{
result.Add("WEBSITE_CONTENTSHARE", null);
result.Add("WEBSITE_CONTENTAZUREFILECONNECTIONSTRING", null);
}
else
{
throw new CliException("Your app is configured with Azure Files for editing from Azure Portal.\nTo force publish use --force. This will remove Azure Files from your app.");
}
}
return(result);
}
public void IsLinuxFxVersionRuntimeMatchedTest(string linuxFxVersion, WorkerRuntime runtime, bool expected)
{
Assert.Equal(expected, PublishHelper.IsLinuxFxVersionRuntimeMatched(linuxFxVersion, runtime));
}
