private async Task PublishFunctionApp(Site functionApp, GitIgnoreParser ignoreParser, IDictionary <string, string> additionalAppSettings)
{
ColoredConsole.WriteLine("Getting site publishing info...");
var functionAppRoot = ScriptHostHelpers.GetFunctionAppRootDirectory(Environment.CurrentDirectory);
// For dedicated linux apps, we do not support run from package right now
if (functionApp.IsLinux && !functionApp.IsDynamic && RunFromPackageDeploy)
{
ColoredConsole.WriteLine("Assuming --nozip (do not run from package) for publishing to Linux dedicated plan.");
RunFromPackageDeploy = false;
}
var workerRuntime = _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(Constants.FunctionsWorkerRuntime, StringComparison.OrdinalIgnoreCase)).Value;
var workerRuntimeEnum = string.IsNullOrEmpty(workerRuntime) ? WorkerRuntime.None : WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntime);
if (workerRuntimeEnum == WorkerRuntime.python && !functionApp.IsLinux)
{
throw new CliException("Publishing Python functions is only supported for Linux FunctionApps");
}
Func <Task <Stream> > zipStreamFactory = () => ZipHelper.GetAppZipFile(workerRuntimeEnum, functionAppRoot, BuildNativeDeps, NoBuild, ignoreParser, AdditionalPackages, ignoreDotNetCheck: true);
// If Consumption Linux
if (functionApp.IsLinux && (functionApp.IsDynamic || functionApp.IsElasticPremium))
{
await PublishRunFromPackage(functionApp, await zipStreamFactory());
}
// If Windows default
else if (RunFromPackageDeploy)
{
await PublishRunFromPackageLocal(functionApp, zipStreamFactory);
}
// If Dedicated Linux or "--no-zip"
else
{
await PublishZipDeploy(functionApp, zipStreamFactory);
}
if (PublishLocalSettings)
{
await PublishLocalAppSettings(functionApp, additionalAppSettings);
}
else if (additionalAppSettings.Any())
{
await PublishAppSettings(functionApp, new Dictionary <string, string>(), additionalAppSettings);
}
// Syncing triggers is not required when using zipdeploy api
if ((functionApp.IsLinux && (functionApp.IsDynamic || functionApp.IsElasticPremium)) ||
RunFromPackageDeploy)
{
await Task.Delay(TimeSpan.FromSeconds(5));
await SyncTriggers(functionApp);
}
await AzureHelper.PrintFunctionsInfo(functionApp, AccessToken, showKeys : true);
}
public async override Task RunAsync()
{
if (Console.IsOutputRedirected || Console.IsInputRedirected)
{
if (string.IsNullOrEmpty(TemplateName) ||
string.IsNullOrEmpty(FunctionName))
{
ColoredConsole
.Error
.WriteLine(ErrorColor("Running with stdin\\stdout redirected. Command must specify --template, and --name explicitly."))
.WriteLine(ErrorColor("See 'func help function' for more details"));
return;
}
}
var templates = await _templatesManager.Templates;
templates = templates.Concat(_templatesManager.PythonTemplates);
var language = _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(Constants.FunctionsLanguageSetting, StringComparison.OrdinalIgnoreCase)).Value;
if (string.IsNullOrWhiteSpace(language))
{
ColoredConsole.Write("Select a language: ");
language = Language ?? SelectionMenuHelper.DisplaySelectionWizard(templates.Select(t => t.Metadata.Language).Distinct());
ColoredConsole.WriteLine(TitleColor(language));
language = InitAction.NormalizeLanguage(language);
_secretsManager.SetSecret(Constants.FunctionsLanguageSetting, language);
ColoredConsole
.WriteLine(WarningColor("Starting from 2.0.1-beta.26 it's required to set a language for your project in your settings"))
.WriteLine(WarningColor($"'{language}' has been set in your local.settings.json"));
}
if (language.Equals("csharp", StringComparison.OrdinalIgnoreCase))
{
language = "C#";
}
ColoredConsole.Write("Select a template: ");
var name = TemplateName ?? SelectionMenuHelper.DisplaySelectionWizard(templates.Where(t => t.Metadata.Language.Equals(language, StringComparison.OrdinalIgnoreCase)).Select(t => t.Metadata.Name).Distinct());
ColoredConsole.WriteLine(TitleColor(name));
var template = templates.FirstOrDefault(t => t.Metadata.Name.Equals(name, StringComparison.OrdinalIgnoreCase) && t.Metadata.Language.Equals(language, StringComparison.OrdinalIgnoreCase));
if (template == null)
{
ColoredConsole.Error.WriteLine(ErrorColor($"Can't find template \"{name}\" in \"{language}\""));
}
else
{
ColoredConsole.Write($"Function name: [{template.Metadata.DefaultFunctionName}] ");
var functionName = FunctionName ?? Console.ReadLine();
functionName = string.IsNullOrEmpty(functionName) ? template.Metadata.DefaultFunctionName : functionName;
await _templatesManager.Deploy(functionName, template);
}
}
private async Task <IDictionary <string, string> > GetConfigurationSettings(string scriptPath, Uri uri)
{
var settings = _secretsManager.GetSecrets();
settings.TryAdd(Constants.WebsiteHostname, uri.Authority);
// Add our connection strings
var connectionStrings = _secretsManager.GetConnectionStrings();
settings.AddRange(connectionStrings.ToDictionary(c => $"ConnectionStrings:{c.Name}", c => c.Value));
settings.TryAdd(EnvironmentSettingNames.AzureWebJobsScriptRoot, scriptPath);
var environment = Environment
.GetEnvironmentVariables()
.Cast <DictionaryEntry>()
.ToDictionary(k => k.Key.ToString(), v => v.Value.ToString());
await CheckNonOptionalSettings(settings.Union(environment), scriptPath, SkipAzureStorageCheck);
// when running locally in CLI we want the host to run in debug mode
// which optimizes host responsiveness
settings.TryAdd(Constants.AzureFunctionsEnvorinmentEnvironmentVariable, "Development");
settings.TryAdd(Constants.AspNetCoreEnvironmentEnvironmentVariable, "Development");
return(settings);
}
private void SetStorageServiceAndTaskHubClient(out AzureStorageOrchestrationService orchestrationService, out TaskHubClient taskHubClient, string connectionStringKey = null, string taskHubName = null)
{
_connectionStringKey = connectionStringKey ?? _connectionStringKey;
_taskHubName = taskHubName ?? _taskHubName;
var connectionString = Environment.GetEnvironmentVariable(_connectionStringKey); // Prioritize environment variables
connectionString = connectionString ?? _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(_connectionStringKey, StringComparison.OrdinalIgnoreCase)).Value;
if (!string.IsNullOrEmpty(connectionString))
{
var settings = new AzureStorageOrchestrationServiceSettings
{
TaskHubName = _taskHubName,
StorageConnectionString = connectionString,
};
orchestrationService = new AzureStorageOrchestrationService(settings);
taskHubClient = new TaskHubClient(orchestrationService);
}
else
{
throw new CliException("No storage connection string found.");
}
}
public override async Task RunAsync()
{
var functionAppRoot = string.IsNullOrEmpty(FolderName)
? Path.Combine(Environment.CurrentDirectory, FolderName)
: ScriptHostHelpers.GetFunctionAppRootDirectory(Environment.CurrentDirectory);
string outputPath;
if (string.IsNullOrEmpty(OutputPath))
{
outputPath = Path.Combine(Environment.CurrentDirectory, $"{Path.GetFileName(functionAppRoot)}.zip");
}
else
{
outputPath = Path.Combine(Environment.CurrentDirectory, OutputPath);
if (FileSystemHelpers.DirectoryExists(outputPath))
{
outputPath = Path.Combine(outputPath, $"{Path.GetFileName(functionAppRoot)}.zip");
}
}
if (!FileSystemHelpers.FileExists(Path.Combine(functionAppRoot, ScriptConstants.HostMetadataFileName)))
{
throw new CliException($"Can't find {Path.Combine(functionAppRoot, ScriptConstants.HostMetadataFileName)}");
}
var workerRuntime = _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(Constants.FunctionsWorkerRuntime, StringComparison.OrdinalIgnoreCase)).Value;
var workerRuntimeEnum = string.IsNullOrEmpty(workerRuntime) ? WorkerRuntime.None : WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntime);
var zipStream = await GetAppZipFile(workerRuntimeEnum, functionAppRoot);
await FileSystemHelpers.WriteToFile(outputPath, zipStream);
}
private async Task PublishAppSettings(Site functionApp)
{
var azureAppSettings = await _armManager.GetFunctionAppAppSettings(functionApp);
var localAppSettings = _secretsManager.GetSecrets();
var appSettings = MergeAppSettings(azureAppSettings, localAppSettings);
await _armManager.UpdateFunctionAppAppSettings(functionApp, appSettings);
}
private async Task PublishFunctionApp(Site functionApp, GitIgnoreParser ignoreParser, IDictionary <string, string> additionalAppSettings)
{
ColoredConsole.WriteLine("Getting site publishing info...");
var functionAppRoot = ScriptHostHelpers.GetFunctionAppRootDirectory(Environment.CurrentDirectory);
if (functionApp.IsLinux && !functionApp.IsDynamic && RunFromZipDeploy)
{
throw new CliException("--zip is not supported with dedicated linux apps.");
}
var workerRuntime = _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(Constants.FunctionsWorkerRuntime, StringComparison.OrdinalIgnoreCase)).Value;
var workerRuntimeEnum = string.IsNullOrEmpty(workerRuntime) ? WorkerRuntime.None : WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntime);
if (workerRuntimeEnum == WorkerRuntime.python && !functionApp.IsLinux)
{
throw new CliException("Publishing Python functions is only supported for Linux FunctionApps");
}
Func <Task <Stream> > zipStreamFactory = () => ZipHelper.GetAppZipFile(workerRuntimeEnum, functionAppRoot, BuildNativeDeps, ignoreParser, AdditionalPackages, ignoreDotNetCheck: true);
// if consumption Linux, or --zip, run from zip
if ((functionApp.IsLinux && functionApp.IsDynamic) || RunFromZipDeploy)
{
await PublishRunFromZip(functionApp, await zipStreamFactory());
}
else
{
await PublishZipDeploy(functionApp, zipStreamFactory);
}
if (PublishLocalSettings)
{
await PublishLocalAppSettings(functionApp, additionalAppSettings);
}
else if (additionalAppSettings.Any())
{
await PublishAppSettings(functionApp, new Dictionary <string, string>(), additionalAppSettings);
}
await Task.Delay(TimeSpan.FromSeconds(5));
await SyncTriggers(functionApp);
await AzureHelper.PrintFunctionsInfo(functionApp, AccessToken, showKeys : true);
}
private async Task InternalPublishFunctionApp(GitIgnoreParser ignoreParser)
{
ColoredConsole.WriteLine("Getting site publishing info...");
var functionApp = await _armManager.GetFunctionAppAsync(FunctionAppName);
var functionAppRoot = ScriptHostHelpers.GetFunctionAppRootDirectory(Environment.CurrentDirectory);
if (functionApp.IsLinux && !functionApp.IsDynamicLinux && RunFromZipDeploy)
{
ColoredConsole
.WriteLine(ErrorColor("--zip is not supported with dedicated linux apps."));
return;
}
var workerRuntime = _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(Constants.FunctionsWorkerRuntime, StringComparison.OrdinalIgnoreCase)).Value;
if (!string.IsNullOrWhiteSpace(workerRuntime))
{
var worker = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntime);
if (worker == WorkerRuntime.python)
{
if (!SkipWheelRestore)
{
await PythonHelpers.InstallPipWheel();
await PythonHelpers.DownloadWheels();
}
else
{
ColoredConsole.WriteLine("Skipping wheels download");
}
}
}
// if consumption linux, or --zip, run from zip
if (functionApp.IsDynamicLinux || RunFromZipDeploy)
{
await PublishRunFromZip(functionApp, functionAppRoot, ignoreParser);
}
else
{
await PublishZipDeploy(functionApp, functionAppRoot, ignoreParser);
}
}
private async Task InternalPublishFunctionApp(GitIgnoreParser ignoreParser)
{
ColoredConsole.WriteLine("Getting site publishing info...");
var functionApp = await _armManager.GetFunctionAppAsync(FunctionAppName);
var functionAppRoot = ScriptHostHelpers.GetFunctionAppRootDirectory(Environment.CurrentDirectory);
if (functionApp.IsLinux && !functionApp.IsDynamic && RunFromZipDeploy)
{
ColoredConsole
.WriteLine(ErrorColor("--zip is not supported with dedicated linux apps."));
return;
}
var workerRuntime = _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(Constants.FunctionsWorkerRuntime, StringComparison.OrdinalIgnoreCase)).Value;
var workerRuntimeEnum = string.IsNullOrEmpty(workerRuntime) ? WorkerRuntime.None : WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntime);
if (workerRuntimeEnum == WorkerRuntime.python && !functionApp.IsLinux)
{
throw new CliException("Publishing Python functions is only supported for Linux FunctionApps");
}
var zipStream = await ZipHelper.GetAppZipFile(workerRuntimeEnum, functionAppRoot, BuildNativeDeps, ignoreParser);
// if consumption Linux, or --zip, run from zip
if ((functionApp.IsLinux && functionApp.IsDynamic) || RunFromZipDeploy)
{
await PublishRunFromZip(functionApp, zipStream);
}
else
{
await PublishZipDeploy(functionApp, zipStream);
}
await SyncTriggers(functionApp);
if (PublishLocalSettings)
{
await PublishAppSettings(functionApp);
}
}
public static WorkerRuntime GetCurrentWorkerRuntimeLanguage(ISecretsManager secretsManager)
{
var setting = secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(Constants.FunctionsWorkerRuntime, StringComparison.OrdinalIgnoreCase)).Value;
try
{
return(NormalizeWorkerRuntime(setting));
}
catch
{
return(WorkerRuntime.None);
}
}
/// <summary>
/// This method reads the secrets from local.settings.json and sets them
/// AppSettings are set in environment variables, ConfigurationManager.AppSettings
/// ConnectionStrings are only set in ConfigurationManager.ConnectionStrings
///
/// It also sets up a FileSystemWatcher that kills the current running process
/// when local.settings.json is updated.
/// </summary>
private async Task ReadSecrets(string scriptPath)
{
var secrets = _secretsManager.GetSecrets();
UpdateEnvironmentVariables(secrets);
UpdateAppSettings(secrets);
UpdateConnectionStrings(_secretsManager.GetConnectionStrings());
await CheckNonOptionalSettings(secrets, scriptPath);
fsWatcher = new FileSystemWatcher(Path.GetDirectoryName(SecretsManager.AppSettingsFilePath), SecretsManager.AppSettingsFileName);
fsWatcher.Changed += (s, e) =>
{
Environment.Exit(ExitCodes.Success);
};
fsWatcher.EnableRaisingEvents = true;
}
private async Task <bool> PublishAppSettings(Site functionApp)
{
var azureAppSettings = await _armManager.GetFunctionAppAppSettings(functionApp);
var localAppSettings = _secretsManager.GetSecrets();
var appSettings = MergeAppSettings(azureAppSettings, localAppSettings);
var result = await _armManager.UpdateFunctionAppAppSettings(functionApp, appSettings);
if (!result.IsSuccessful)
{
ColoredConsole
.Error
.WriteLine(ErrorColor("Error updating app settings:"))
.WriteLine(ErrorColor(result.ErrorResult));
return(false);
}
return(true);
}
/// <summary>
/// This method reads the secrets from local.settings.json and sets them
/// AppSettings are set in environment variables, ConfigurationManager.AppSettings
/// ConnectionStrings are only set in ConfigurationManager.ConnectionStrings
///
/// It also sets up a FileSystemWatcher that kills the current running process
/// when local.settings.json is updated.
/// </summary>
private async Task ReadSecrets(string scriptPath, Uri uri)
{
var secrets = _secretsManager.GetSecrets();
var environment = Environment
.GetEnvironmentVariables()
.Cast <DictionaryEntry>()
.ToDictionary(k => k.Key.ToString(), v => v.Value.ToString());
UpdateEnvironmentVariables(secrets, uri);
UpdateAppSettings(secrets);
UpdateConnectionStrings(_secretsManager.GetConnectionStrings());
await CheckNonOptionalSettings(secrets.Union(environment), scriptPath);
fsWatcher = new FileSystemWatcher(Path.GetDirectoryName(SecretsManager.AppSettingsFilePath), SecretsManager.AppSettingsFileName);
fsWatcher.Changed += (s, e) =>
{
Environment.Exit(ExitCodes.Success);
};
fsWatcher.EnableRaisingEvents = true;
}
public override Task RunAsync()
{
ColoredConsole.WriteLine(TitleColor("App Settings:"));
foreach (var pair in _secretsManager.GetSecrets())
{
ColoredConsole
.WriteLine($" -> {TitleColor("Name")}: {pair.Key}")
.WriteLine($" {TitleColor("Value")}: {(ShowValues ? pair.Value : "*****")}")
.WriteLine();
}
ColoredConsole.WriteLine(TitleColor("Connection Strings:"));
foreach (var pair in _secretsManager.GetConnectionStrings())
{
ColoredConsole
.WriteLine($" -> {TitleColor("Name")}: {pair.Key}")
.WriteLine($" {TitleColor("Value")}: {(ShowValues ? pair.Value : "*****")}")
.WriteLine();
}
return(Task.CompletedTask);
}
public override async Task RunAsync()
{
(var resolvedImageName, var shouldBuild) = ResolveImageName();
TriggersPayload triggers = null;
if (DryRun)
{
if (shouldBuild)
{
// don't build on a --dry-run.
// read files from the local dir
triggers = await GetTriggersLocalFiles();
}
else
{
triggers = await DockerHelpers.GetTriggersFromDockerImage(resolvedImageName);
}
}
else
{
if (shouldBuild)
{
await DockerHelpers.DockerBuild(resolvedImageName, Environment.CurrentDirectory);
}
triggers = await DockerHelpers.GetTriggersFromDockerImage(resolvedImageName);
}
(var resources, var funcKeys) = await KubernetesHelper.GetFunctionsDeploymentResources(
Name,
resolvedImageName,
Namespace,
triggers,
_secretsManager.GetSecrets(),
PullSecret,
SecretsCollectionName,
ConfigMapName,
UseConfigMap,
PollingInterval,
CooldownPeriod,
ServiceType,
MinReplicaCount,
MaxReplicaCount,
KeysSecretCollectionName,
MountFuncKeysAsContainerVolume);
if (DryRun)
{
ColoredConsole.WriteLine(KubernetesHelper.SerializeResources(resources, OutputSerializationOptions.Yaml));
}
else
{
if (!await KubernetesHelper.NamespaceExists(Namespace))
{
await KubernetesHelper.CreateNamespace(Namespace);
}
if (shouldBuild)
{
await DockerHelpers.DockerPush(resolvedImageName);
}
foreach (var resource in resources)
{
await KubectlHelper.KubectlApply(resource, showOutput : true, ignoreError : IgnoreErrors, @namespace : Namespace);
}
//Print the function keys message to the console
await KubernetesHelper.PrintFunctionsInfo($"{Name}-http", Namespace, funcKeys, triggers);
}
}
private async Task <bool> PublishLocalAppSettings(Site functionApp, IDictionary <string, string> additionalAppSettings)
{
var localAppSettings = _secretsManager.GetSecrets();
return(await PublishAppSettings(functionApp, localAppSettings, additionalAppSettings));
}
public async override Task RunAsync()
{
if (Console.IsOutputRedirected || Console.IsInputRedirected)
{
if (string.IsNullOrEmpty(TemplateName) ||
string.IsNullOrEmpty(FunctionName))
{
ColoredConsole
.Error
.WriteLine(ErrorColor("Running with stdin\\stdout redirected. Command must specify --template, and --name explicitly."))
.WriteLine(ErrorColor("See 'func help function' for more details"));
return;
}
}
var templates = await _templatesManager.Templates;
var workerRuntime = _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(Constants.FunctionsWorkerRuntime, StringComparison.OrdinalIgnoreCase)).Value;
if (!string.IsNullOrWhiteSpace(workerRuntime) && !string.IsNullOrWhiteSpace(Language))
{
// validate
var worker = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntime);
var language = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(Language);
if (worker != language)
{
throw new CliException("Selected language doesn't match worker set in local.settings.json." +
$"Selected worker is: {worker} and selected language is: {language}");
}
}
else if (string.IsNullOrWhiteSpace(Language))
{
if (string.IsNullOrWhiteSpace(workerRuntime))
{
ColoredConsole.Write("Select a language: ");
Language = SelectionMenuHelper.DisplaySelectionWizard(templates.Select(t => t.Metadata.Language).Where(l => !l.Equals("python", StringComparison.OrdinalIgnoreCase)).Distinct());
var worker = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(Language);
_secretsManager.SetSecret(Constants.FunctionsWorkerRuntime, worker.ToString());
ColoredConsole
.WriteLine(WarningColor("Starting from 2.0.1-beta.26 it's required to set a language for your project in your settings"))
.WriteLine(WarningColor($"'{worker}' has been set in your local.settings.json"));
}
else
{
var worker = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntime);
var languages = WorkerRuntimeLanguageHelper.LanguagesForWorker(worker);
ColoredConsole.Write("Select a language: ");
var displayList = templates
.Select(t => t.Metadata.Language)
.Where(l => languages.Contains(l, StringComparer.OrdinalIgnoreCase))
.Distinct()
.ToArray();
if (displayList.Length == 1)
{
Language = displayList.First();
}
else
{
Language = SelectionMenuHelper.DisplaySelectionWizard(displayList);
}
}
}
else if (!string.IsNullOrWhiteSpace(Language))
{
var worker = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(Language);
_secretsManager.SetSecret(Constants.FunctionsWorkerRuntime, worker.ToString());
ColoredConsole
.WriteLine(WarningColor("Starting from 2.0.1-beta.26 it's required to set a language for your project in your settings"))
.WriteLine(WarningColor($"'{worker}' has been set in your local.settings.json"));
}
ColoredConsole.Write("Select a template: ");
var name = TemplateName ?? SelectionMenuHelper.DisplaySelectionWizard(templates.Where(t => t.Metadata.Language.Equals(Language, StringComparison.OrdinalIgnoreCase)).Select(t => t.Metadata.Name).Distinct());
ColoredConsole.WriteLine(TitleColor(name));
var template = templates.FirstOrDefault(t => t.Metadata.Name.Equals(name, StringComparison.OrdinalIgnoreCase) && t.Metadata.Language.Equals(Language, StringComparison.OrdinalIgnoreCase));
if (template == null)
{
ColoredConsole.Error.WriteLine(ErrorColor($"Can't find template \"{name}\" in \"{Language}\""));
}
else
{
ColoredConsole.Write($"Function name: [{template.Metadata.DefaultFunctionName}] ");
var functionName = FunctionName ?? Console.ReadLine();
functionName = string.IsNullOrEmpty(functionName) ? template.Metadata.DefaultFunctionName : functionName;
await _templatesManager.Deploy(functionName, template);
}
}
private async Task PublishFunctionApp(Site functionApp, GitIgnoreParser ignoreParser, IDictionary <string, string> additionalAppSettings)
{
ColoredConsole.WriteLine("Getting site publishing info...");
var functionAppRoot = ScriptHostHelpers.GetFunctionAppRootDirectory(Environment.CurrentDirectory);
// For dedicated linux apps, we do not support run from package right now
var isFunctionAppDedicated = !functionApp.IsDynamic && !functionApp.IsElasticPremium;
if (functionApp.IsLinux && isFunctionAppDedicated && RunFromPackageDeploy)
{
ColoredConsole.WriteLine("Assuming --nozip (do not run from package) for publishing to Linux dedicated plan.");
RunFromPackageDeploy = false;
}
var workerRuntime = _secretsManager.GetSecrets().FirstOrDefault(s => s.Key.Equals(Constants.FunctionsWorkerRuntime, StringComparison.OrdinalIgnoreCase)).Value;
var workerRuntimeEnum = string.IsNullOrEmpty(workerRuntime) ? WorkerRuntime.None : WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntime);
if (workerRuntimeEnum == WorkerRuntime.python && !functionApp.IsLinux)
{
throw new CliException("Publishing Python functions is only supported for Linux FunctionApps");
}
Func <Task <Stream> > zipStreamFactory = () => ZipHelper.GetAppZipFile(workerRuntimeEnum, functionAppRoot, BuildNativeDeps, NoBuild, ignoreParser, AdditionalPackages, ignoreDotNetCheck: true);
bool shouldSyncTriggers = true;
var fileNameNoExtension = string.Format("{0}-{1}", DateTimeOffset.UtcNow.ToString("yyyyMMddHHmmss"), Guid.NewGuid());
if (functionApp.IsLinux && functionApp.IsDynamic)
{
// Consumption Linux, try squashfs as a package format.
if (workerRuntimeEnum == WorkerRuntime.python && !NoBuild && BuildNativeDeps)
{
await PublishRunFromPackage(functionApp, await PythonHelpers.ZipToSquashfsStream(await zipStreamFactory()), $"{fileNameNoExtension}.squashfs");
}
else
{
await PublishRunFromPackage(functionApp, await zipStreamFactory(), $"{fileNameNoExtension}.zip");
}
}
else if (functionApp.IsLinux && functionApp.IsElasticPremium)
{
// Elastic Premium Linux
await PublishRunFromPackage(functionApp, await zipStreamFactory(), $"{fileNameNoExtension}.zip");
}
else if (RunFromPackageDeploy)
{
// Windows default
await PublishRunFromPackageLocal(functionApp, zipStreamFactory);
}
else
{
// ZipDeploy takes care of the SyncTriggers operation so we don't
// need to perform one
shouldSyncTriggers = false;
// Dedicated Linux or "--no-zip"
await PublishZipDeploy(functionApp, zipStreamFactory);
}
if (PublishLocalSettings)
{
await PublishLocalAppSettings(functionApp, additionalAppSettings);
}
else if (additionalAppSettings.Any())
{
await PublishAppSettings(functionApp, new Dictionary <string, string>(), additionalAppSettings);
}
if (shouldSyncTriggers)
{
await Task.Delay(TimeSpan.FromSeconds(5));
await SyncTriggers(functionApp);
}
// Linux Elastic Premium functions take longer to deploy. Right now, we cannot guarantee that functions info will be most up to date.
// So, we only show the info, if Function App is not Linux Elastic Premium
if (!(functionApp.IsLinux && functionApp.IsElasticPremium))
{
await AzureHelper.PrintFunctionsInfo(functionApp, AccessToken, ManagementURL, showKeys : true);
}
}