public KeysControllerTests()
{
_settingsManager = ScriptSettingsManager.Instance;
_testFunctions = new Collection <FunctionDescriptor>();
_testFunctionErrors = new Dictionary <string, Collection <string> >();
string rootScriptPath = @"c:\test\functions";
var environment = new NullScriptHostEnvironment();
var eventManager = new Mock <IScriptEventManager>();
var mockRouter = new Mock <IWebJobsRouter>();
var settings = new ScriptApplicationHostOptions()
{
ScriptPath = rootScriptPath,
SecretsPath = _secretsDirectory.Path
};
_secretsManagerMock = new Mock <ISecretManager>(MockBehavior.Strict);
var fileSystem = new Mock <IFileSystem>();
var fileBase = new Mock <FileBase>();
var dirBase = new Mock <DirectoryBase>();
fileSystem.SetupGet(f => f.File).Returns(fileBase.Object);
fileBase.Setup(f => f.ReadAllText(Path.Combine(rootScriptPath, "TestFunction1", ScriptConstants.FunctionMetadataFileName))).Returns("{}");
fileBase.Setup(f => f.ReadAllText(Path.Combine(rootScriptPath, "TestFunction2", ScriptConstants.FunctionMetadataFileName))).Returns("{}");
fileBase.Setup(f => f.ReadAllText(Path.Combine(rootScriptPath, "DNE", ScriptConstants.FunctionMetadataFileName))).Throws(new DirectoryNotFoundException());
_functionsSyncManagerMock = new Mock <IFunctionsSyncManager>(MockBehavior.Strict);
_functionsSyncManagerMock.Setup(p => p.TrySyncTriggersAsync(false)).ReturnsAsync(new SyncTriggersResult {
Success = true
});
_testController = new KeysController(new OptionsWrapper <ScriptApplicationHostOptions>(settings), new TestSecretManagerProvider(_secretsManagerMock.Object), new LoggerFactory(), fileSystem.Object, _functionsSyncManagerMock.Object);
var keys = new Dictionary <string, string>
{
{ "key1", "secret1" }
};
_secretsManagerMock.Setup(p => p.GetFunctionSecretsAsync("TestFunction1", false)).ReturnsAsync(keys);
keys = new Dictionary <string, string>
{
{ "key1", "secret1" }
};
_secretsManagerMock.Setup(p => p.GetFunctionSecretsAsync("TestFunction2", false)).ReturnsAsync(keys);
_secretsManagerMock.Setup(p => p.GetFunctionSecretsAsync("DNE", false)).ReturnsAsync((IDictionary <string, string>)null);
SetHttpContext();
}
public static ExtensionBundleOptions GetExtensionBundleOptions(ScriptApplicationHostOptions hostOptions = null)
{
hostOptions = hostOptions ?? SelfHostWebHostSettingsFactory.Create(Environment.CurrentDirectory);
IConfigurationBuilder builder = new ConfigurationBuilder();
builder.Add(new HostJsonFileConfigurationSource(hostOptions, SystemEnvironment.Instance, loggerFactory: NullLoggerFactory.Instance));
var configuration = builder.Build();
var configurationHelper = new ExtensionBundleConfigurationHelper(configuration, SystemEnvironment.Instance);
var options = new ExtensionBundleOptions();
configurationHelper.Configure(options);
return(options);
}
public TestFixture()
{
// copy test files to temp directory, since accessing the metadata APIs will result
// in file creations (for test data files)
var scriptSource = Path.Combine(Environment.CurrentDirectory, @"..\..\..\TestScripts\Proxies");
_testHome = Path.Combine(Path.GetTempPath(), @"ProxyTests");
var scriptRoot = Path.Combine(_testHome, @"site\wwwroot");
FileUtility.CopyDirectory(scriptSource, scriptRoot);
HostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = scriptRoot,
LogPath = Path.Combine(_testHome, @"LogFiles\Application\Functions"),
SecretsPath = Path.Combine(_testHome, @"data\Functions\Secrets"),
TestDataPath = Path.Combine(_testHome, @"data\Functions\SampleData")
};
FileUtility.EnsureDirectoryExists(HostOptions.TestDataPath);
var optionsMonitor = TestHelpers.CreateOptionsMonitor(HostOptions);
var workerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var provider = new FunctionMetadataProvider(optionsMonitor, new OptionsWrapper <LanguageWorkerOptions>(workerOptions), NullLogger <FunctionMetadataProvider> .Instance);
var builder = AspNetCore.WebHost.CreateDefaultBuilder()
.UseStartup <Startup>()
.ConfigureServices(services =>
{
services.Replace(new ServiceDescriptor(typeof(IOptions <ScriptApplicationHostOptions>), new OptionsWrapper <ScriptApplicationHostOptions>(HostOptions)));
services.Replace(new ServiceDescriptor(typeof(ISecretManagerProvider), new TestSecretManagerProvider(new TestSecretManager())));
services.Replace(new ServiceDescriptor(typeof(IOptionsMonitor <ScriptApplicationHostOptions>), optionsMonitor));
services.Replace(new ServiceDescriptor(typeof(IFunctionMetadataProvider), provider));
});
_testServer = new TestServer(builder);
HostOptions.RootServiceProvider = _testServer.Host.Services;
var scriptConfig = _testServer.Host.Services.GetService <IOptions <ScriptJobHostOptions> >().Value;
HttpClient = _testServer.CreateClient();
HttpClient.BaseAddress = new Uri("https://localhost/");
TestHelpers.WaitForWebHost(HttpClient);
}
public TestFunctionHost(string appRoot,
Action <IWebJobsBuilder> configureJobHost,
Action <IConfigurationBuilder> configureAppConfiguration = null)
{
_appRoot = appRoot;
_hostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = _appRoot,
LogPath = Path.Combine(Path.GetTempPath(), @"Functions"),
SecretsPath = Environment.CurrentDirectory, // not used
HasParentScope = true
};
var factory = new TestOptionsFactory <ScriptApplicationHostOptions>(_hostOptions);
var optionsMonitor = new OptionsMonitor <ScriptApplicationHostOptions>(factory, Array.Empty <IOptionsChangeTokenSource <ScriptApplicationHostOptions> >(), factory);
var builder = new WebHostBuilder()
.ConfigureServices(services =>
{
services.Replace(new ServiceDescriptor(typeof(ISecretManagerProvider), new TestSecretManagerProvider(new TestSecretManager())));
services.Replace(ServiceDescriptor.Singleton <IServiceProviderFactory <IServiceCollection> >(new WebHostServiceProviderFactory()));
services.Replace(new ServiceDescriptor(typeof(IOptions <ScriptApplicationHostOptions>), new OptionsWrapper <ScriptApplicationHostOptions>(_hostOptions)));
services.Replace(new ServiceDescriptor(typeof(IOptionsMonitor <ScriptApplicationHostOptions>), optionsMonitor));
services.AddSingleton <IConfigureBuilder <IConfigurationBuilder> >(_ => new DelegatedConfigureBuilder <IConfigurationBuilder>(configureAppConfiguration));
})
.AddScriptHostBuilder(webJobsBuilder =>
{
var loggingBuilder = new LoggingBuilder(webJobsBuilder.Services);
loggingBuilder.AddProvider(_loggerProvider);
loggingBuilder.AddFilter <TestLoggerProvider>(_ => true);
webJobsBuilder.AddAzureStorage();
configureJobHost?.Invoke(webJobsBuilder);
})
.UseStartup <Startup>();
_testServer = new TestServer(builder);
HttpClient = new HttpClient(new UpdateContentLengthHandler(_testServer.CreateHandler()));
HttpClient.BaseAddress = new Uri("https://localhost/");
var manager = _testServer.Host.Services.GetService <IScriptHostManager>();
_hostService = manager as WebJobsScriptHostService;
StartAsync().GetAwaiter().GetResult();
}
public static IHostBuilder ConfigureDefaultTestWebScriptHost(this IHostBuilder builder, Action <IWebJobsBuilder> configureWebJobs,
Action <ScriptApplicationHostOptions> configure = null, bool runStartupHostedServices = false, Action <IServiceCollection> configureRootServices = null)
{
var webHostOptions = new ScriptApplicationHostOptions()
{
IsSelfHost = true,
ScriptPath = TestHelpers.FunctionsTestDirectory,
LogPath = TestHelpers.GetHostLogFileDirectory().FullName
};
TestMetricsLogger metricsLogger = new TestMetricsLogger();
configure?.Invoke(webHostOptions);
// Register root services
var services = new ServiceCollection();
AddMockedSingleton <IDebugStateProvider>(services);
AddMockedSingleton <IScriptHostManager>(services);
AddMockedSingleton <IEnvironment>(services);
AddMockedSingleton <IScriptWebHostEnvironment>(services);
AddMockedSingleton <IEventGenerator>(services);
AddMockedSingleton <IFunctionInvocationDispatcherFactory>(services);
AddMockedSingleton <IHttpWorkerService>(services);
AddMockedSingleton <IApplicationLifetime>(services);
AddMockedSingleton <IDependencyValidator>(services);
services.AddSingleton <HostNameProvider>();
services.AddSingleton <IMetricsLogger>(metricsLogger);
services.AddWebJobsScriptHostRouting();
services.AddLogging();
services.AddFunctionMetadataManager(webHostOptions, metricsLogger);
configureRootServices?.Invoke(services);
var rootProvider = new WebHostServiceProvider(services);
builder
.AddWebScriptHost(rootProvider, rootProvider, webHostOptions, configureWebJobs)
.ConfigureAppConfiguration(c =>
{
c.AddTestSettings();
});
if (!runStartupHostedServices)
{
builder.ConfigureServices(s => s.RemoveAll <IHostedService>());
}
webHostOptions.RootServiceProvider = rootProvider;
return(builder);
}
private void InitializeTestHost(string testDirName)
{
var httpConfig = new HttpConfiguration();
var uniqueTestRootPath = Path.Combine(_testRootPath, testDirName, Guid.NewGuid().ToString());
_loggerProvider = new TestLoggerProvider();
_webHostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
LogPath = Path.Combine(uniqueTestRootPath, "Logs"),
SecretsPath = Path.Combine(uniqueTestRootPath, "Secrets"),
ScriptPath = Path.Combine(uniqueTestRootPath, "WWWRoot")
};
if (_settingsManager.IsAppServiceEnvironment)
{
// if the test is mocking App Service environment, we need
// to also set the HOME variable
Environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteHomePath, uniqueTestRootPath);
}
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(_loggerProvider);
var webHostBuilder = Program.CreateWebHostBuilder()
.ConfigureServices(c =>
{
c.AddSingleton(_webHostOptions)
.AddSingleton <ILoggerProvider>(_loggerProvider)
.AddSingleton <ILoggerFactory>(loggerFactory);
});
_httpServer = new TestServer(webHostBuilder);
_httpClient = _httpServer.CreateClient();
_httpClient.BaseAddress = new Uri("https://localhost/");
TestHelpers.WaitForWebHost(_httpClient);
var traces = _loggerProvider.GetAllLogMessages().ToArray();
Assert.NotNull(traces.Single(p => p.FormattedMessage.StartsWith("Starting Host (HostId=placeholder-host")));
Assert.NotNull(traces.Single(p => p.FormattedMessage.StartsWith("Host is in standby mode")));
var hostConfig = _webHostOptions.ToScriptHostConfiguration(true);
// TODO: DI (FACAVAL) Review
// _expectedHostId = hostConfig.HostConfig.HostId;
}
public FunctionsSyncManagerTests()
{
_testRootScriptPath = Path.GetTempPath();
_testHostConfigFilePath = Path.Combine(_testRootScriptPath, ScriptConstants.HostMetadataFileName);
FileUtility.DeleteFileSafe(_testHostConfigFilePath);
_hostOptions = new ScriptApplicationHostOptions
{
ScriptPath = @"x:\root",
IsSelfHost = false,
LogPath = @"x:\tmp\log",
SecretsPath = @"x:\secrets",
TestDataPath = @"x:\test"
};
_vars = new Dictionary <string, string>
{
{ EnvironmentSettingNames.WebSiteAuthEncryptionKey, TestHelpers.GenerateKeyHexString() },
{ EnvironmentSettingNames.AzureWebsiteHostName, "appName.azurewebsites.net" }
};
ResetMockFileSystem();
_loggerProvider = new TestLoggerProvider();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(_loggerProvider);
_contentBuilder = new StringBuilder();
_mockHttpHandler = new MockHttpHandler(_contentBuilder);
var httpClient = CreateHttpClient(_mockHttpHandler);
var factory = new TestOptionsFactory <ScriptApplicationHostOptions>(_hostOptions);
var tokenSource = new TestChangeTokenSource();
var changeTokens = new[] { tokenSource };
var optionsMonitor = new OptionsMonitor <ScriptApplicationHostOptions>(factory, changeTokens, factory);
var secretManagerProviderMock = new Mock <ISecretManagerProvider>(MockBehavior.Strict);
var secretManagerMock = new Mock <ISecretManager>(MockBehavior.Strict);
secretManagerProviderMock.SetupGet(p => p.Current).Returns(secretManagerMock.Object);
var configuration = ScriptSettingsManager.BuildDefaultConfiguration();
var hostIdProviderMock = new Mock <IHostIdProvider>(MockBehavior.Strict);
hostIdProviderMock.Setup(p => p.GetHostIdAsync(CancellationToken.None)).ReturnsAsync("testhostid123");
_functionsSyncManager = new FunctionsSyncManager(configuration, hostIdProviderMock.Object, optionsMonitor, new OptionsWrapper <LanguageWorkerOptions>(CreateLanguageWorkerConfigSettings()), loggerFactory, httpClient, secretManagerProviderMock.Object);
_expectedSyncTriggersPayload = "[{\"authLevel\":\"anonymous\",\"type\":\"httpTrigger\",\"direction\":\"in\",\"name\":\"req\",\"functionName\":\"function1\"}," +
"{\"name\":\"myQueueItem\",\"type\":\"orchestrationTrigger\",\"direction\":\"in\",\"queueName\":\"myqueue-items\",\"connection\":\"DurableStorage\",\"functionName\":\"function2\",\"taskHubName\":\"TestHubValue\"}," +
"{\"name\":\"myQueueItem\",\"type\":\"activityTrigger\",\"direction\":\"in\",\"queueName\":\"myqueue-items\",\"connection\":\"DurableStorage\",\"functionName\":\"function3\",\"taskHubName\":\"TestHubValue\"}]";
}
public RpcInitializationServiceTests()
{
_mockLanguageWorkerChannelManager = new Mock <ILanguageWorkerChannelManager>();
_loggerFactory = new LoggerFactory();
var applicationHostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = Path.GetTempPath()
};
_optionsMonitor = TestHelpers.CreateOptionsMonitor(applicationHostOptions);
_mockLanguageWorkerChannelManager.Setup(m => m.InitializeChannelAsync(It.IsAny <string>()))
.Returns(Task.CompletedTask);
}
public WebFunctionsManagerTests()
{
_testRootScriptPath = Path.GetTempPath();
_testHostConfigFilePath = Path.Combine(_testRootScriptPath, ScriptConstants.HostMetadataFileName);
FileUtility.DeleteFileSafe(_testHostConfigFilePath);
_hostOptions = new ScriptApplicationHostOptions
{
ScriptPath = @"x:\root",
IsSelfHost = false,
LogPath = @"x:\tmp\log",
SecretsPath = @"x:\secrets",
TestDataPath = @"x:\test"
};
}
public DebugStateProviderTests()
{
_options = new ScriptApplicationHostOptions
{
LogPath = Path.Combine(Directory.GetCurrentDirectory(), "DebugPath1")
};
var factory = new TestOptionsFactory <ScriptApplicationHostOptions>(_options);
_tokenSource = new TestChangeTokenSource <ScriptApplicationHostOptions>();
var changeTokens = new[] { _tokenSource };
var optionsMonitor = new OptionsMonitor <ScriptApplicationHostOptions>(factory, changeTokens, factory);
_provider = new DebugStateProvider(optionsMonitor, new ScriptEventManager());
}
public void Configure(ScriptJobHostOptions options)
{
// Add the standard built in watched directories set to any the user may have specified
options.WatchDirectories.Add("node_modules");
// Add the default files we need to watch
options.WatchFiles.Add(ScriptConstants.HostMetadataFileName);
options.WatchFiles.Add(ScriptConstants.FunctionMetadataFileName);
options.WatchFiles.Add(ScriptConstants.ProxyMetadataFileName);
// Set default logging mode
options.FileLoggingMode = FileLoggingMode.DebugOnly;
// Bind to all configuration properties
IConfigurationSection jobHostSection = _configuration.GetSection(ConfigurationSectionNames.JobHost);
if (jobHostSection != null)
{
jobHostSection.Bind(options);
var fileLoggingMode = jobHostSection.GetSection(ConfigurationSectionNames.Logging)
?.GetValue <FileLoggingMode?>("fileLoggingMode");
if (fileLoggingMode != null)
{
options.FileLoggingMode = fileLoggingMode.Value;
}
Utility.ValidateRetryOptions(options.Retry);
}
// FunctionTimeout
ConfigureFunctionTimeout(options);
// If we have a read only file system, override any configuration and
// disable file watching
if (_applicationHostOptions.Value.IsFileSystemReadOnly)
{
options.FileWatchingEnabled = false;
}
// Set the root script path to the value the runtime was initialized with:
ScriptApplicationHostOptions webHostOptions = _applicationHostOptions.Value;
options.RootScriptPath = webHostOptions.ScriptPath;
options.RootLogPath = webHostOptions.LogPath;
options.IsSelfHost = webHostOptions.IsSelfHost;
options.TestDataPath = webHostOptions.TestDataPath;
options.IsFileSystemReadOnly = webHostOptions.IsFileSystemReadOnly;
}
public void GetDefaultHostId_AzureHost_ReturnsExpectedResult(string siteName, string expected)
{
var options = new ScriptApplicationHostOptions
{
ScriptPath = @"c:\testscripts"
};
var environment = new TestEnvironment();
environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteInstanceId, "123123");
environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteName, siteName);
string hostId = ScriptHostIdProvider.GetDefaultHostId(environment, options);
Assert.Equal(expected, hostId);
}
public WebFunctionsManagerTests()
{
_testRootScriptPath = Path.GetTempPath();
_testHostConfigFilePath = Path.Combine(_testRootScriptPath, ScriptConstants.HostMetadataFileName);
FileUtility.DeleteFileSafe(_testHostConfigFilePath);
_hostOptions = new ScriptApplicationHostOptions
{
ScriptPath = @"x:\root",
IsSelfHost = false,
LogPath = @"x:\tmp\log",
SecretsPath = @"x:\secrets",
TestDataPath = @"x:\test"
};
string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample");
var fileSystem = CreateFileSystem(_hostOptions);
var loggerFactory = MockNullLoggerFactory.CreateLoggerFactory();
var contentBuilder = new StringBuilder();
var httpClient = CreateHttpClient(contentBuilder);
var factory = new TestOptionsFactory<ScriptApplicationHostOptions>(_hostOptions);
var tokenSource = new TestChangeTokenSource();
var changeTokens = new[] { tokenSource };
var optionsMonitor = new OptionsMonitor<ScriptApplicationHostOptions>(factory, changeTokens, factory);
var secretManagerProviderMock = new Mock<ISecretManagerProvider>(MockBehavior.Strict);
var secretManagerMock = new Mock<ISecretManager>(MockBehavior.Strict);
secretManagerProviderMock.SetupGet(p => p.Current).Returns(secretManagerMock.Object);
var hostSecretsInfo = new HostSecretsInfo();
secretManagerMock.Setup(p => p.GetHostSecretsAsync()).ReturnsAsync(hostSecretsInfo);
Dictionary<string, string> functionSecrets = new Dictionary<string, string>();
secretManagerMock.Setup(p => p.GetFunctionSecretsAsync("httptrigger", false)).ReturnsAsync(functionSecrets);
var configurationMock = new Mock<IConfiguration>(MockBehavior.Strict);
var hostIdProviderMock = new Mock<IHostIdProvider>(MockBehavior.Strict);
var mockWebHostEnvironment = new Mock<IScriptWebHostEnvironment>(MockBehavior.Strict);
mockWebHostEnvironment.SetupGet(p => p.InStandbyMode).Returns(false);
_mockEnvironment = new Mock<IEnvironment>(MockBehavior.Strict);
_mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteContainerReady)).Returns("1");
_mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.CoreToolsEnvironment)).Returns((string)null);
_mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteHostName)).Returns(TestHostName);
var hostNameProvider = new HostNameProvider(_mockEnvironment.Object, loggerFactory.CreateLogger<HostNameProvider>());
var functionsSyncManager = new FunctionsSyncManager(configurationMock.Object, hostIdProviderMock.Object, optionsMonitor, new OptionsWrapper<LanguageWorkerOptions>(CreateLanguageWorkerConfigSettings()), loggerFactory.CreateLogger<FunctionsSyncManager>(), httpClient, secretManagerProviderMock.Object, mockWebHostEnvironment.Object, _mockEnvironment.Object, hostNameProvider);
_webFunctionsManager = new WebFunctionsManager(optionsMonitor, new OptionsWrapper<LanguageWorkerOptions>(CreateLanguageWorkerConfigSettings()), loggerFactory, httpClient, secretManagerProviderMock.Object, functionsSyncManager, hostNameProvider);
FileUtility.Instance = fileSystem;
}
private void ValidateAndBuildHostJsonConfigurationIfFileExists(ScriptApplicationHostOptions hostOptions)
{
bool IsPreCompiledApp = IsPreCompiledFunctionApp();
var hostJsonPath = Path.Combine(Environment.CurrentDirectory, Constants.HostJsonFileName);
if (IsPreCompiledApp && !File.Exists(hostJsonPath))
{
throw new CliException($"Host.json file in missing. Please make sure host.json file is present at {Environment.CurrentDirectory}");
}
//BuildHostJsonConfigutation only if host.json file exists.
_hostJsonConfig = Utilities.BuildHostJsonConfigutation(hostOptions);
if (IsPreCompiledApp && Utilities.JobHostConfigSectionExists(_hostJsonConfig, ConfigurationSectionNames.ExtensionBundle))
{
throw new CliException($"Extension bundle configuration should not be present for the function app with pre-compiled functions. Please remove extension bundle configuration from host.json: {Path.Combine(Environment.CurrentDirectory, "host.json")}");
}
}
private async Task <IWebHost> BuildWebHost(ScriptApplicationHostOptions hostOptions, Uri listenAddress, Uri baseAddress, X509Certificate2 certificate)
{
IDictionary <string, string> settings = await GetConfigurationSettings(hostOptions.ScriptPath, baseAddress);
settings.AddRange(LanguageWorkerHelper.GetWorkerConfiguration(LanguageWorkerSetting));
UpdateEnvironmentVariables(settings);
LoggingFilterHelper loggingFilterHelper = new LoggingFilterHelper(_hostJsonConfig, VerboseLogging);
var defaultBuilder = Microsoft.AspNetCore.WebHost.CreateDefaultBuilder(Array.Empty <string>());
if (UseHttps)
{
defaultBuilder
.UseKestrel(options =>
{
options.Listen(IPAddress.Any, listenAddress.Port, listenOptins =>
{
listenOptins.UseHttps(certificate);
});
});
}
return(defaultBuilder
.UseSetting(WebHostDefaults.ApplicationKey, typeof(Startup).Assembly.GetName().Name)
.UseUrls(listenAddress.ToString())
.ConfigureAppConfiguration(configBuilder =>
{
configBuilder.AddEnvironmentVariables();
})
.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.ClearProviders();
loggingBuilder.Services.AddSingleton <ILoggerProvider>(p =>
{
//Cache LoggerFilterOptions to be used by the logger to filter logs based on content
var filterOptions = p.GetService <IOptions <LoggerFilterOptions> >().Value;
// Set min level to SystemLogDefaultLogLevel.
filterOptions.MinLevel = loggingFilterHelper.SystemLogDefaultLogLevel;
return new ColoredConsoleLoggerProvider(loggingFilterHelper, filterOptions);
});
// This is needed to filter system logs only for known categories
loggingBuilder.AddDefaultWebJobsFilters <ColoredConsoleLoggerProvider>(LogLevel.Trace);
})
.ConfigureServices((context, services) => services.AddSingleton <IStartup>(new Startup(context, hostOptions, CorsOrigins, CorsCredentials, EnableAuth, loggingFilterHelper)))
.Build());
}
private void ConfiguredOptions(ScriptApplicationHostOptions options, bool inStandbyMode, IEnvironment environment = null, bool blobExists = false)
{
var builder = new ConfigurationBuilder();
var configuration = builder.Build();
var standbyOptions = new TestOptionsMonitor <StandbyOptions>(new StandbyOptions {
InStandbyMode = inStandbyMode
});
var mockServiceProvider = new Mock <IServiceProvider>();
var mockEnvironment = environment ?? new TestEnvironment();
var setup = new TestScriptApplicationHostOptionsSetup(configuration, standbyOptions, mockServiceProvider.Object, mockEnvironment)
{
BlobExistsReturnValue = blobExists
};
setup.Configure(options);
}
public InstanceManager(IOptions <ScriptApplicationHostOptions> webHostSettings, ILoggerFactory loggerFactory, HttpClient client, IScriptWebHostEnvironment webHostEnvironment)
{
if (webHostSettings == null)
{
throw new ArgumentNullException(nameof(webHostSettings));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_client = client ?? throw new ArgumentNullException(nameof(client));
_webHostEnvironment = webHostEnvironment ?? throw new ArgumentNullException(nameof(webHostEnvironment));
_webHostSettings = webHostSettings.Value;
_logger = loggerFactory.CreateLogger(LogCategories.Startup);
}
public async Task GetHostIdAsync_WithConfigurationHostId_ReturnsConfigurationHostId()
{
var options = new ScriptApplicationHostOptions();
var environment = new TestEnvironment();
var config = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>
{
{ ConfigurationPath.Combine(ConfigurationSectionNames.JobHost, "id"), "test-host-id" }
})
.Build();
var provider = new ScriptHostIdProvider(config, environment, new TestOptionsMonitor <ScriptApplicationHostOptions>(options));
string hostId = await provider.GetHostIdAsync(CancellationToken.None);
Assert.Equal("test-host-id", hostId);
}
private ScriptApplicationHostOptions CreateConfiguredOptions(bool inStandbyMode, IEnvironment environment = null)
{
var builder = new ConfigurationBuilder();
var configuration = builder.Build();
var standbyOptions = new TestOptionsMonitor <StandbyOptions>(new StandbyOptions {
InStandbyMode = inStandbyMode
});
var mockCache = new Mock <IOptionsMonitorCache <ScriptApplicationHostOptions> >();
var mockServiceProvider = new Mock <IServiceProvider>();
var mockEnvironment = environment ?? new TestEnvironment();
var setup = new ScriptApplicationHostOptionsSetup(configuration, standbyOptions, mockCache.Object, mockServiceProvider.Object, mockEnvironment);
var options = new ScriptApplicationHostOptions();
setup.Configure(options);
return(options);
}
private Task <ScriptApplicationHostOptions> GetWebHostSettings()
{
var home = _settingsManager.GetSetting(EnvironmentSettingNames.AzureWebsiteHomePath);
var settings = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = Path.Combine(home, @"site\wwwroot"),
LogPath = Path.Combine(home, @"LogFiles\Application\Functions"),
SecretsPath = Path.Combine(home, @"data\Functions\secrets")
};
Directory.CreateDirectory(settings.ScriptPath);
Directory.CreateDirectory(settings.LogPath);
Directory.CreateDirectory(settings.SecretsPath);
return(Task.Delay(200)
.ContinueWith(t => settings));
}
public void ReadFunctionMetadata_Succeeds()
{
string functionsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample\node");
var scriptApplicationHostOptions = new ScriptApplicationHostOptions()
{
ScriptPath = functionsPath
};
var optionsMonitor = TestHelpers.CreateOptionsMonitor(scriptApplicationHostOptions);
var workerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var metadataProvider = new FunctionMetadataProvider(optionsMonitor, new OptionsWrapper <LanguageWorkerOptions>(workerOptions), NullLogger <FunctionMetadataProvider> .Instance);
Assert.Equal(17, metadataProvider.GetFunctionMetadata(false).Length);
}
public void Configure_InStandbyMode_ReturnsExpectedConfiguration()
{
var settings = new Dictionary <string, string>
{
{ EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1" }
};
ScriptApplicationHostOptionsSetup setup = CreateSetupWithConfiguration(new TestEnvironment(settings));
var options = new ScriptApplicationHostOptions();
setup.Configure(options);
Assert.EndsWith(@"functions\standby\logs", options.LogPath);
Assert.EndsWith(@"functions\standby\wwwroot", options.ScriptPath);
Assert.EndsWith(@"functions\standby\secrets", options.SecretsPath);
Assert.False(options.IsSelfHost);
}
public RpcInitializationServiceTests()
{
_mockLanguageWorkerChannelManager = new Mock <IWebHostLanguageWorkerChannelManager>();
_loggerFactory = new LoggerFactory();
_logger = _loggerFactory.CreateLogger <RpcInitializationService>();
var applicationHostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = Path.GetTempPath()
};
_optionsMonitor = TestHelpers.CreateOptionsMonitor(applicationHostOptions);
ILanguageWorkerChannel testLanguageWorkerChannel = new TestLanguageWorkerChannel(Guid.NewGuid().ToString(), LanguageWorkerConstants.NodeLanguageWorkerName);
_mockLanguageWorkerChannelManager.Setup(m => m.InitializeChannelAsync(It.IsAny <string>()))
.Returns(Task.FromResult <ILanguageWorkerChannel>(testLanguageWorkerChannel));
}
public void Configure(ScriptJobHostOptions options)
{
// Add the standard built in watched directories set to any the user may have specified
options.WatchDirectories.Add("node_modules");
// Set default logging mode
options.FileLoggingMode = FileLoggingMode.DebugOnly;
// Bind to all configuration properties
IConfigurationSection jobHostSection = _configuration.GetSection(ConfigurationSectionNames.JobHost);
if (jobHostSection != null)
{
jobHostSection.Bind(options);
var fileLoggingMode = jobHostSection.GetSection(ConfigurationSectionNames.Logging)
?.GetValue <FileLoggingMode?>("fileLoggingMode");
if (fileLoggingMode != null)
{
options.FileLoggingMode = fileLoggingMode.Value;
}
}
// FunctionTimeout
ConfigureFunctionTimeout(jobHostSection, options);
// Worker configuration
ConfigureLanguageWorkers(jobHostSection, options);
// If we have a read only file system, override any configuration and
// disable file watching
if (_environment.FileSystemIsReadOnly())
{
options.FileWatchingEnabled = false;
}
// Set the root script path to the value the runtime was initialized with:
ScriptApplicationHostOptions webHostOptions = _applicationHostOptions.Value;
options.RootScriptPath = webHostOptions.ScriptPath;
options.RootLogPath = webHostOptions.LogPath;
options.IsSelfHost = webHostOptions.IsSelfHost;
options.TestDataPath = webHostOptions.TestDataPath;
}
public virtual async Task InitializeAsync()
{
_config = new HttpConfiguration();
_settingsManager = ScriptSettingsManager.Instance;
HostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\..\sample"),
LogPath = Path.Combine(Path.GetTempPath(), @"Functions"),
SecretsPath = Path.Combine(Path.GetTempPath(), @"FunctionsTests\Secrets"),
HasParentScope = true
};
var factory = new TestOptionsFactory <ScriptApplicationHostOptions>(HostOptions);
var optionsMonitor = new OptionsMonitor <ScriptApplicationHostOptions>(factory, Array.Empty <IOptionsChangeTokenSource <ScriptApplicationHostOptions> >(), factory);
var webHostBuilder = new WebHostBuilder()
.ConfigureServices(services =>
{
services.Replace(ServiceDescriptor.Singleton <IServiceProviderFactory <IServiceCollection> >(new WebHostServiceProviderFactory()));
services.AddSingleton <IOptions <ScriptApplicationHostOptions> >(new OptionsWrapper <ScriptApplicationHostOptions>(HostOptions));
services.Replace(new ServiceDescriptor(typeof(IOptionsMonitor <ScriptApplicationHostOptions>), optionsMonitor));
})
.ConfigureAppConfiguration((builderContext, config) =>
{
config.Add(new WebScriptHostConfigurationSource
{
IsAppServiceEnvironment = SystemEnvironment.Instance.IsAppServiceEnvironment(),
IsLinuxContainerEnvironment = SystemEnvironment.Instance.IsLinuxContainerEnvironment()
});
})
.UseStartup <Startup>()
.ConfigureAppConfiguration(c => c.AddEnvironmentVariables());
ConfigureWebHostBuilder(webHostBuilder);
HttpServer = new TestServer(webHostBuilder);
HttpClient = HttpServer.CreateClient();
HttpClient.BaseAddress = new Uri("https://localhost/");
var manager = HttpServer.Host.Services.GetService <IScriptHostManager>();
await manager.DelayUntilHostReady();
}
public override async Task RunAsync()
{
await PreRunConditions();
var isVerbose = VerboseLogging.HasValue && VerboseLogging.Value;
if (isVerbose || EnvironmentHelper.GetEnvironmentVariableAsBool(Constants.DisplayLogo))
{
Utilities.PrintLogo();
}
// Suppress AspNetCoreSupressStatusMessages
EnvironmentHelper.SetEnvironmentVariableAsBoolIfNotExists(Constants.AspNetCoreSupressStatusMessages);
Utilities.PrintVersion();
ScriptApplicationHostOptions hostOptions = SelfHostWebHostSettingsFactory.Create(Environment.CurrentDirectory);
ValidateAndBuildHostJsonConfigurationIfFileExists(hostOptions);
(var listenUri, var baseUri, var certificate) = await Setup();
IWebHost host = await BuildWebHost(hostOptions, listenUri, baseUri, certificate);
var runTask = host.RunAsync();
var hostService = host.Services.GetRequiredService <WebJobsScriptHostService>();
await hostService.DelayUntilHostReady();
var scriptHost = hostService.Services.GetRequiredService <IScriptJobHost>();
var httpOptions = hostService.Services.GetRequiredService <IOptions <HttpOptions> >();
if (scriptHost != null && scriptHost.Functions.Any())
{
DisplayFunctionsInfoUtilities.DisplayFunctionsInfo(scriptHost.Functions, httpOptions.Value, baseUri);
}
if (VerboseLogging == null || !VerboseLogging.Value)
{
ColoredConsole.WriteLine(AdditionalInfoColor("For detailed output, run func with --verbose flag."));
}
await runTask;
}
public async Task HostInitialization_OnInitializationException_MaintainsErrorInformation()
{
var options = new ScriptApplicationHostOptions
{
ScriptPath = @"c:\tests",
LogPath = @"c:\tests\logs",
};
var monitor = new ScriptApplicationHostOptionsMonitor(options);
var services = new ServiceCollection()
.AddLogging()
.BuildServiceProvider();
var host = new Mock <IHost>();
host.Setup(h => h.Services)
.Returns(services);
host.SetupSequence(h => h.StartAsync(It.IsAny <CancellationToken>()))
.Throws(new HostInitializationException("boom"))
.Returns(Task.CompletedTask);
var hostBuilder = new Mock <IScriptHostBuilder>();
hostBuilder.Setup(b => b.BuildHost(It.IsAny <bool>(), It.IsAny <bool>()))
.Returns(host.Object);
var mockRootServiceProvider = new Mock <IServiceProvider>();
var mockRootScopeFactory = new Mock <IServiceScopeFactory>();
var mockScriptWebHostEnvironment = new Mock <IScriptWebHostEnvironment>();
var mockEnvironment = new Mock <IEnvironment>();
var healthMonitorOptions = new OptionsWrapper <HostHealthMonitorOptions>(new HostHealthMonitorOptions());
var hostPerformanceManager = new HostPerformanceManager(mockEnvironment.Object, healthMonitorOptions);
var hostService = new WebJobsScriptHostService(
monitor, hostBuilder.Object, NullLoggerFactory.Instance, mockRootServiceProvider.Object, mockRootScopeFactory.Object,
mockScriptWebHostEnvironment.Object, mockEnvironment.Object, hostPerformanceManager, healthMonitorOptions);
await hostService.StartAsync(CancellationToken.None);
Assert.Equal(ScriptHostState.Error, hostService.State);
Assert.IsType <HostInitializationException>(hostService.LastError);
}
public void GetDefaultHostId_AzureHost_ReturnsExpectedResult(string siteName, string azureWebsiteInstanceId, string expected, bool expectedTruncation)
{
var options = new ScriptApplicationHostOptions
{
ScriptPath = @"c:\testscripts"
};
var environment = new TestEnvironment();
environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteInstanceId, azureWebsiteInstanceId);
environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteName, siteName);
environment.SetEnvironmentVariable(EnvironmentSettingNames.ContainerName, "testContainer");
environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteHostName, "testsite.azurewebsites.net");
var result = ScriptHostIdProvider.GetDefaultHostId(environment, options);
Assert.Equal(expected, result.HostId);
Assert.Equal(expectedTruncation, result.IsTruncated);
Assert.False(result.IsLocal);
}
public static async Task Main(string[] args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
string rootPath = Environment.CurrentDirectory;
if (args.Length > 0)
{
rootPath = (string)args[0];
}
var options = new ScriptApplicationHostOptions
{
ScriptPath = rootPath,
LogPath = Path.Combine(Path.GetTempPath(), "functionshost"),
IsSelfHost = true
};
var host = new HostBuilder()
.SetAzureFunctionsEnvironment()
.ConfigureLogging(b =>
{
b.SetMinimumLevel(LogLevel.Information);
b.AddConsole();
})
.AddScriptHost(options, webJobsBuilder =>
{
webJobsBuilder.AddAzureStorageCoreServices();
})
.UseConsoleLifetime()
.Build();
Console.WriteLine("Starting host");
using (host)
{
await host.RunAsync();
}
}
public GrpcWorkerChannelTests()
{
_logger = new TestLogger("FunctionDispatcherTests");
_testFunctionRpcService = new TestFunctionRpcService(_eventManager, _workerId, _logger, _expectedLogMsg);
_testWorkerConfig = TestHelpers.GetTestWorkerConfigs().FirstOrDefault();
_mockrpcWorkerProcess.Setup(m => m.StartProcessAsync()).Returns(Task.CompletedTask);
_testEnvironment = new TestEnvironment();
ILogger <MemoryMappedFileAccessor> mmapAccessorLogger = NullLogger <MemoryMappedFileAccessor> .Instance;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
_mapAccessor = new MemoryMappedFileAccessorWindows(mmapAccessorLogger);
}
else
{
_mapAccessor = new MemoryMappedFileAccessorUnix(mmapAccessorLogger, _testEnvironment);
}
_sharedMemoryManager = new SharedMemoryManager(_loggerFactory, _mapAccessor);
var hostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = _scriptRootPath,
LogPath = Environment.CurrentDirectory, // not tested
SecretsPath = Environment.CurrentDirectory, // not tested
HasParentScope = true
};
_hostOptionsMonitor = TestHelpers.CreateOptionsMonitor(hostOptions);
_workerChannel = new GrpcWorkerChannel(
_workerId,
_eventManager,
_testWorkerConfig,
_mockrpcWorkerProcess.Object,
_logger,
_metricsLogger,
0,
_testEnvironment,
_hostOptionsMonitor,
_sharedMemoryManager);
}