public void VerifyGetBundleDownloadPathReturnCorrectPath()
{
var downloadPath = ExtensionBundleHelper.GetBundleDownloadPath("BundleId");
var expectedPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".azure-functions-core-tools", "Functions", "ExtensionBundles", "BundleId");
Assert.Equal(expectedPath, downloadPath);
}
public async override Task RunAsync()
{
var extensionBundleManager = ExtensionBundleHelper.GetExtensionBundleManager();
if (extensionBundleManager.IsExtensionBundleConfigured())
{
var hostFilePath = Path.Combine(Environment.CurrentDirectory, ScriptConstants.HostMetadataFileName);
if (_showExtensionBundleWarning)
{
ColoredConsole.WriteLine(WarningColor($"No action performed. Extension bundle is configured in {hostFilePath}"));
}
return;
}
if (CommandChecker.CommandExists("dotnet"))
{
var extensionsProj = await ExtensionsHelper.EnsureExtensionsProjectExistsAsync(_secretsManager, Csx, ConfigPath);
var installExtensions = new Executable("dotnet", $"build \"{extensionsProj}\" -o \"{OutputPath}\"");
await installExtensions.RunAsync(output => ColoredConsole.WriteLine(output), error => ColoredConsole.WriteLine(ErrorColor(error)));
}
else
{
ColoredConsole.Error.WriteLine(ErrorColor(Constants.Errors.ExtensionsNeedDotnet));
}
}
private void SetBundlesEnvironmentVariables()
{
var bundleId = ExtensionBundleHelper.GetExtensionBundleOptions(_hostOptions).Id;
if (!string.IsNullOrEmpty(bundleId))
{
Environment.SetEnvironmentVariable("AzureFunctionsJobHost__extensionBundle__downloadPath", ExtensionBundleHelper.GetBundleDownloadPath(bundleId));
Environment.SetEnvironmentVariable("AzureFunctionsJobHost__extensionBundle__ensureLatest", "true");
}
}
private void SetBundlesEnvironmentVariables()
{
var bundleId = ExtensionBundleHelper.GetExtensionBundleOptions(_hostOptions).Id;
if (!string.IsNullOrEmpty(bundleId))
{
Environment.SetEnvironmentVariable("AzureFunctionsJobHost__extensionBundle__downloadPath", Path.Combine(Path.GetTempPath(), "Functions", ScriptConstants.ExtensionBundleDirectory, bundleId));
Environment.SetEnvironmentVariable("AzureFunctionsJobHost__extensionBundle__ensureLatest", "true");
}
}
private static async Task <IEnumerable <Template> > GetTemplates()
{
var extensionBundleManager = ExtensionBundleHelper.GetExtensionBundleManager();
string templatesJson;
if (extensionBundleManager.IsExtensionBundleConfigured())
{
var contentProvider = ExtensionBundleHelper.GetExtensionBundleContentProvider();
templatesJson = await contentProvider.GetTemplates();
}
else
{
templatesJson = await StaticResources.TemplatesJson;
}
return(JsonConvert.DeserializeObject <IEnumerable <Template> >(templatesJson));
}
public async override Task RunAsync()
{
var extensionBundleManager = ExtensionBundleHelper.GetExtensionBundleManager();
if (extensionBundleManager.IsExtensionBundleConfigured())
{
var hostFilePath = Path.Combine(Environment.CurrentDirectory, ScriptConstants.HostMetadataFileName);
if (_showNoActionWarning)
{
ColoredConsole.WriteLine(WarningColor($"No action performed. Extension bundle is configured in {hostFilePath}."));
}
return;
}
if (!string.IsNullOrEmpty(ConfigPath) && !FileSystemHelpers.DirectoryExists(ConfigPath))
{
throw new CliArgumentsException("Invalid config path, please verify directory exists");
}
if (!NeedsExtensionsInstall())
{
return;
}
if (CommandChecker.CommandExists("dotnet"))
{
var extensionsProj = await ExtensionsHelper.EnsureExtensionsProjectExistsAsync(_secretsManager, Csx, ConfigPath);
if (string.IsNullOrEmpty(Package) && string.IsNullOrEmpty(Version))
{
var project = ProjectHelpers.GetProject(extensionsProj);
foreach (var extensionPackage in ExtensionsHelper.GetExtensionPackages())
{
// Only add / update package referece if it does not exist or forced update is enabled
if (!ProjectHelpers.PackageReferenceExists(project, extensionPackage.Name) || Force)
{
await AddPackage(extensionsProj, extensionPackage.Name, extensionPackage.Version);
}
}
}
else if (!string.IsNullOrEmpty(Package) && !string.IsNullOrEmpty(Version))
{
await AddPackage(extensionsProj, Package, Version);
}
else
{
throw new CliArgumentsException("Must specify extension package name and version",
new CliArgument {
Name = nameof(Package), Description = "Extension package name"
},
new CliArgument {
Name = nameof(Version), Description = "Extension package version"
}
);
}
var syncAction = new SyncExtensionsAction(_secretsManager, false)
{
OutputPath = OutputPath,
ConfigPath = ConfigPath
};
await syncAction.RunAsync();
}
else
{
throw new CliException(Constants.Errors.ExtensionsNeedDotnet);
}
}
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;
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.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
.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));
}
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.Where(t => t.Metadata.Language.Equals(templateLanguage, StringComparison.OrdinalIgnoreCase)).Select(t => t.Metadata.Name).Distinct());
ColoredConsole.WriteLine(TitleColor(TemplateName));
var template = templates.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}");
}
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.");
}
