private async Task InitFunctionAppProject()
{
WorkerRuntime workerRuntime;
string language = string.Empty;
if (Csx)
{
workerRuntime = Helpers.WorkerRuntime.dotnet;
}
else
{
(workerRuntime, language) = ResolveWorkerRuntimeAndLanguage(WorkerRuntime, Language);
}
if (workerRuntime == Helpers.WorkerRuntime.dotnet && !Csx)
{
await DotnetHelpers.DeployDotnetProject(Utilities.SanitizeLiteral(Path.GetFileName(Environment.CurrentDirectory), allowed: "-"), Force);
}
else
{
bool managedDependenciesOption = ResolveManagedDependencies(workerRuntime, ManagedDependencies);
await InitLanguageSpecificArtifacts(workerRuntime, language, managedDependenciesOption);
await WriteFiles();
await WriteHostJson(workerRuntime, managedDependenciesOption, ExtensionBundle);
await WriteLocalSettingsJson(workerRuntime);
}
await WriteExtensionsJson();
if (InitSourceControl)
{
await SetupSourceControl();
}
if (InitDocker)
{
await WriteDockerfile(workerRuntime);
}
}
private async Task InitFunctionAppProject()
{
if (Csx)
{
ResolvedWorkerRuntime = Helpers.WorkerRuntime.dotnet;
}
else
{
(ResolvedWorkerRuntime, ResolvedLanguage) = ResolveWorkerRuntimeAndLanguage(WorkerRuntime, Language);
}
TelemetryHelpers.AddCommandEventToDictionary(TelemetryCommandEvents, "WorkerRuntime", ResolvedWorkerRuntime.ToString());
if (ResolvedWorkerRuntime == Helpers.WorkerRuntime.dotnet && !Csx)
{
await DotnetHelpers.DeployDotnetProject(Utilities.SanitizeLiteral(Path.GetFileName(Environment.CurrentDirectory), allowed: "-"), Force);
}
else
{
bool managedDependenciesOption = ResolveManagedDependencies(ResolvedWorkerRuntime, ManagedDependencies);
await InitLanguageSpecificArtifacts(ResolvedWorkerRuntime, ResolvedLanguage, managedDependenciesOption);
await WriteFiles();
await WriteHostJson(ResolvedWorkerRuntime, managedDependenciesOption, ExtensionBundle);
await WriteLocalSettingsJson(ResolvedWorkerRuntime);
}
await WriteExtensionsJson();
if (InitSourceControl)
{
await SetupSourceControl();
}
if (InitDocker)
{
await WriteDockerfile(ResolvedWorkerRuntime, Csx);
}
}
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 = WorkerRuntimeLanguageHelper.GetCurrentWorkerRuntimeLanguage(_secretsManager);
if (workerRuntime != WorkerRuntime.None && !string.IsNullOrWhiteSpace(Language))
{
// validate
var language = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(Language);
if (workerRuntime != language)
{
throw new CliException("Selected language doesn't match worker set in local.settings.json." +
$"Selected worker is: {workerRuntime} and selected language is: {language}");
}
}
else if (string.IsNullOrWhiteSpace(Language))
{
if (workerRuntime == WorkerRuntime.None)
{
ColoredConsole.Write("Select a language: ");
Language = SelectionMenuHelper.DisplaySelectionWizard(templates.Select(t => t.Metadata.Language).Where(l => !l.Equals("python", StringComparison.OrdinalIgnoreCase)).Distinct());
workerRuntime = WorkerRuntimeLanguageHelper.SetWorkerRuntime(_secretsManager, Language);
}
else if (workerRuntime != WorkerRuntime.dotnet)
{
var languages = WorkerRuntimeLanguageHelper.LanguagesForWorker(workerRuntime);
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))
{
workerRuntime = WorkerRuntimeLanguageHelper.SetWorkerRuntime(_secretsManager, Language);
}
if (workerRuntime == WorkerRuntime.dotnet)
{
ColoredConsole.Write("Select a template: ");
var templateName = TemplateName ?? SelectionMenuHelper.DisplaySelectionWizard(DotnetHelpers.GetTemplates());
ColoredConsole.Write("Function name: ");
var functionName = FunctionName ?? Console.ReadLine();
ColoredConsole.WriteLine(functionName);
var namespaceStr = Path.GetFileName(Environment.CurrentDirectory);
await DotnetHelpers.DeployDotnetFunction(templateName, functionName, namespaceStr);
}
else
{
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);
}
}
}
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 workerRuntime = GlobalCoreToolsSettings.CurrentWorkerRuntimeOrNone;
if (!FileSystemHelpers.FileExists(Path.Combine(Environment.CurrentDirectory, "local.settings.json")))
{
// we're assuming "func init" has not been run
await _initAction.RunAsync();
workerRuntime = _initAction.ResolvedWorkerRuntime;
Language = _initAction.ResolvedLanguage;
}
var templates = await _templatesManager.Templates;
if (workerRuntime != WorkerRuntime.None && !string.IsNullOrWhiteSpace(Language))
{
// validate
var workerRuntimeSelected = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(Language);
if (workerRuntime != workerRuntimeSelected)
{
throw new CliException("Selected language doesn't match worker set in local.settings.json." +
$"Selected worker is: {workerRuntime} and selected language is: {workerRuntimeSelected}");
}
}
else if (string.IsNullOrWhiteSpace(Language))
{
if (workerRuntime == WorkerRuntime.None)
{
SelectionMenuHelper.DisplaySelectionWizardPrompt("language");
Language = SelectionMenuHelper.DisplaySelectionWizard(_templates.Value.Select(t => t.Metadata.Language).Where(l => !l.Equals("python", StringComparison.OrdinalIgnoreCase)).Distinct());
workerRuntime = WorkerRuntimeLanguageHelper.SetWorkerRuntime(_secretsManager, Language);
}
else if (workerRuntime != WorkerRuntime.dotnet || Csx)
{
var languages = WorkerRuntimeLanguageHelper.LanguagesForWorker(workerRuntime);
var displayList = _templates.Value
.Select(t => t.Metadata.Language)
.Where(l => languages.Contains(l, StringComparer.OrdinalIgnoreCase))
.Distinct()
.ToArray();
if (displayList.Length == 1)
{
Language = displayList.First();
}
else if (!InferAndUpdateLanguage(workerRuntime))
{
SelectionMenuHelper.DisplaySelectionWizardPrompt("language");
Language = SelectionMenuHelper.DisplaySelectionWizard(displayList);
}
}
}
else if (!string.IsNullOrWhiteSpace(Language))
{
workerRuntime = WorkerRuntimeLanguageHelper.SetWorkerRuntime(_secretsManager, Language);
}
if (workerRuntime == WorkerRuntime.dotnet && !Csx)
{
SelectionMenuHelper.DisplaySelectionWizardPrompt("template");
TemplateName = TemplateName ?? SelectionMenuHelper.DisplaySelectionWizard(DotnetHelpers.GetTemplates());
ColoredConsole.Write("Function name: ");
FunctionName = FunctionName ?? Console.ReadLine();
ColoredConsole.WriteLine(FunctionName);
var namespaceStr = Path.GetFileName(Environment.CurrentDirectory);
await DotnetHelpers.DeployDotnetFunction(TemplateName.Replace(" ", string.Empty), Utilities.SanitizeClassName(FunctionName), Utilities.SanitizeNameSpace(namespaceStr), AuthorizationLevel);
}
else
{
SelectionMenuHelper.DisplaySelectionWizardPrompt("template");
string templateLanguage;
try
{
templateLanguage = WorkerRuntimeLanguageHelper.NormalizeLanguage(Language);
}
catch (Exception)
{
// Ideally this should never happen.
templateLanguage = WorkerRuntimeLanguageHelper.GetDefaultTemplateLanguageFromWorker(workerRuntime);
}
TelemetryHelpers.AddCommandEventToDictionary(TelemetryCommandEvents, "language", templateLanguage);
TemplateName = TemplateName ?? SelectionMenuHelper.DisplaySelectionWizard(_templates.Value.Where(t => t.Metadata.Language.Equals(templateLanguage, StringComparison.OrdinalIgnoreCase)).Select(t => t.Metadata.Name).Distinct());
ColoredConsole.WriteLine(TitleColor(TemplateName));
var template = _templates.Value.FirstOrDefault(t => Utilities.EqualsIgnoreCaseAndSpace(t.Metadata.Name, TemplateName) && t.Metadata.Language.Equals(templateLanguage, StringComparison.OrdinalIgnoreCase));
if (template == null)
{
TelemetryHelpers.AddCommandEventToDictionary(TelemetryCommandEvents, "template", "N/A");
throw new CliException($"Can't find template \"{TemplateName}\" in \"{Language}\"");
}
else
{
TelemetryHelpers.AddCommandEventToDictionary(TelemetryCommandEvents, "template", TemplateName);
var extensionBundleManager = ExtensionBundleHelper.GetExtensionBundleManager();
if (template.Metadata.Extensions != null && !extensionBundleManager.IsExtensionBundleConfigured() && !CommandChecker.CommandExists("dotnet"))
{
throw new CliException($"The {template.Metadata.Name} template has extensions. {Constants.Errors.ExtensionsNeedDotnet}");
}
if (AuthorizationLevel.HasValue)
{
ConfigureAuthorizationLevel(template);
}
ColoredConsole.Write($"Function name: [{template.Metadata.DefaultFunctionName}] ");
FunctionName = FunctionName ?? Console.ReadLine();
FunctionName = string.IsNullOrEmpty(FunctionName) ? template.Metadata.DefaultFunctionName : FunctionName;
await _templatesManager.Deploy(FunctionName, template);
PerformPostDeployTasks(FunctionName, Language);
}
}
ColoredConsole.WriteLine($"The function \"{FunctionName}\" was created successfully from the \"{TemplateName}\" template.");
}