public static FunctionMetadata GetFunctionMetadata(string functionName)
{
var functionErrors = new Dictionary <string, Collection <string> >();
var scriptHostOptions = new ScriptJobHostOptions
{
RootScriptPath = Environment.CurrentDirectory
};
var loggerFactory = new LoggerFactory();
var languageWorkerOptions = new LanguageWorkerOptions {
};
loggerFactory.AddProvider(new ColoredConsoleLoggerProvider((cat, level) => level >= LogLevel.Information));
var metadataManager = new FunctionMetadataManager(new OptionsWrapper <ScriptJobHostOptions>(scriptHostOptions), new OptionsWrapper <LanguageWorkerOptions>(languageWorkerOptions), loggerFactory);
var function = metadataManager.Functions.FirstOrDefault(f => f.Name.Equals(functionName, StringComparison.OrdinalIgnoreCase));
if (function == null)
{
var error = metadataManager.Errors
.FirstOrDefault(f => f.Key.Equals(functionName, StringComparison.OrdinalIgnoreCase))
.Value
.Aggregate(string.Empty, (a, b) => string.Join(Environment.NewLine, a, b));
throw new FunctionNotFoundException($"Unable to get metadata for function {functionName}. Error: {error}");
}
else
{
return(function);
}
}
public WebHostLanguageWorkerChannelManagerTests()
{
_eventManager = new ScriptEventManager();
_rpcServer = new TestRpcServer();
_loggerProvider = new TestLoggerProvider();
_loggerFactory = new LoggerFactory();
_testEnvironment = new TestEnvironment();
_loggerFactory.AddProvider(_loggerProvider);
_languageWorkerProcess = new Mock <ILanguageWorkerProcess>();
_languageWorkerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var applicationHostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = @"c:\testing\FUNCTIONS-TEST\test$#"
};
_optionsMonitor = TestHelpers.CreateOptionsMonitor(applicationHostOptions);
_languageWorkerProcessFactory = new Mock <ILanguageWorkerProcessFactory>();
_languageWorkerProcessFactory.Setup(m => m.CreateLanguageWorkerProcess(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(_languageWorkerProcess.Object);
_languageWorkerChannelFactory = new TestLanguageWorkerChannelFactory(_eventManager, null, _scriptRootPath);
_languageWorkerChannelManager = new WebHostLanguageWorkerChannelManager(_eventManager, _testEnvironment, _loggerFactory, _languageWorkerChannelFactory, _optionsMonitor);
}
private static IFunctionDispatcher GetTestFunctionDispatcherWithMockLanguageWorkerChannelManager(string maxProcessCountValue = null, bool addWebhostChannel = false)
{
var eventManager = new ScriptEventManager();
var scriptJobHostEnvironment = new Mock <IScriptJobHostEnvironment>();
var metricsLogger = new Mock <IMetricsLogger>();
var testEnv = new TestEnvironment();
if (!string.IsNullOrEmpty(maxProcessCountValue))
{
testEnv.SetEnvironmentVariable(LanguageWorkerConstants.FunctionsWorkerProcessCountSettingName, maxProcessCountValue);
}
var loggerFactory = MockNullLoggerFactory.CreateLoggerFactory();
var testLogger = new TestLogger("FunctionDispatcherTests");
var options = new ScriptJobHostOptions
{
RootLogPath = Path.GetTempPath()
};
IOptions <ScriptJobHostOptions> scriptOptions = new OptionsManager <ScriptJobHostOptions>(new TestOptionsFactory <ScriptJobHostOptions>(options));
var workerConfigOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var languageWorkerChannelManager = new Mock <ILanguageWorkerChannelManager>();
var mockFunctionDispatcherLoadBalancer = new Mock <IFunctionDispatcherLoadBalancer>();
return(new FunctionDispatcher(scriptOptions, metricsLogger.Object, testEnv, scriptJobHostEnvironment.Object, eventManager, loggerFactory, new OptionsWrapper <LanguageWorkerOptions>(workerConfigOptions), languageWorkerChannelManager.Object, null, mockFunctionDispatcherLoadBalancer.Object));
}
public void LanguageWorkerOptions_Expected_ListOfConfigs(string workerRuntime)
{
var testEnvironment = new TestEnvironment();
var configurationBuilder = new ConfigurationBuilder()
.Add(new ScriptEnvironmentVariablesConfigurationSource());
var configuration = configurationBuilder.Build();
if (!string.IsNullOrEmpty(workerRuntime))
{
testEnvironment.SetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName, workerRuntime);
}
LanguageWorkerOptionsSetup setup = new LanguageWorkerOptionsSetup(configuration, NullLoggerFactory.Instance, testEnvironment, new TestMetricsLogger());
LanguageWorkerOptions options = new LanguageWorkerOptions();
setup.Configure(options);
if (string.IsNullOrEmpty(workerRuntime))
{
Assert.Equal(4, options.WorkerConfigs.Count);
}
else if (workerRuntime.Equals(RpcWorkerConstants.DotNetLanguageWorkerName, StringComparison.OrdinalIgnoreCase))
{
Assert.Empty(options.WorkerConfigs);
}
else
{
Assert.Equal(1, options.WorkerConfigs.Count);
}
}
public FunctionMetadataProviderTests()
{
_testMetricsLogger = new TestMetricsLogger();
_scriptApplicationHostOptions = new ScriptApplicationHostOptions();
_languageWorkerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
}
public object GetService(System.Type serviceType)
{
var workerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
return(new FunctionMetadataProvider(_optionsMonitor, new OptionsWrapper <LanguageWorkerOptions>(workerOptions), NullLogger <FunctionMetadataProvider> .Instance));
}
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 <ScriptApplicationHostOptions>();
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 workerOptions = new LanguageWorkerOptions();
FileUtility.Instance = fileSystem;
_fileSystem = fileSystem;
var languageWorkerOptions = new OptionsWrapper <LanguageWorkerOptions>(CreateLanguageWorkerConfigSettings());
var metadataProvider = new FunctionMetadataProvider(optionsMonitor, languageWorkerOptions, NullLogger <FunctionMetadataProvider> .Instance, new TestMetricsLogger());
var functionsSyncManager = new FunctionsSyncManager(configurationMock.Object, hostIdProviderMock.Object, optionsMonitor, loggerFactory.CreateLogger <FunctionsSyncManager>(), httpClient, secretManagerProviderMock.Object, mockWebHostEnvironment.Object, _mockEnvironment.Object, hostNameProvider, metadataProvider);
_webFunctionsManager = new WebFunctionsManager(optionsMonitor, new OptionsWrapper <LanguageWorkerOptions>(CreateLanguageWorkerConfigSettings()), loggerFactory, httpClient, secretManagerProviderMock.Object, functionsSyncManager, hostNameProvider, metadataProvider);
}
private static RpcFunctionInvocationDispatcher GetTestFunctionDispatcher(string maxProcessCountValue = null, bool addWebhostChannel = false, Mock <IWebHostRpcWorkerChannelManager> mockwebHostLanguageWorkerChannelManager = null, bool throwOnProcessStartUp = false)
{
var eventManager = new ScriptEventManager();
var metricsLogger = new Mock <IMetricsLogger>();
var mockApplicationLifetime = new Mock <IApplicationLifetime>();
var testEnv = new TestEnvironment();
if (!string.IsNullOrEmpty(maxProcessCountValue))
{
testEnv.SetEnvironmentVariable(RpcWorkerConstants.FunctionsWorkerProcessCountSettingName, maxProcessCountValue);
}
var loggerFactory = MockNullLoggerFactory.CreateLoggerFactory();
var options = new ScriptJobHostOptions
{
RootLogPath = Path.GetTempPath()
};
IOptions <ScriptJobHostOptions> scriptOptions = new OptionsManager <ScriptJobHostOptions>(new TestOptionsFactory <ScriptJobHostOptions>(options));
var workerConfigOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
IRpcWorkerChannelFactory testLanguageWorkerChannelFactory = new TestRpcWorkerChannelFactory(eventManager, _testLogger, scriptOptions.Value.RootScriptPath, throwOnProcessStartUp);
IWebHostRpcWorkerChannelManager testWebHostLanguageWorkerChannelManager = new TestRpcWorkerChannelManager(eventManager, _testLogger, scriptOptions.Value.RootScriptPath, testLanguageWorkerChannelFactory);
IJobHostRpcWorkerChannelManager jobHostLanguageWorkerChannelManager = new JobHostRpcWorkerChannelManager(loggerFactory);
if (addWebhostChannel)
{
testWebHostLanguageWorkerChannelManager.InitializeChannelAsync("java");
}
if (mockwebHostLanguageWorkerChannelManager != null)
{
testWebHostLanguageWorkerChannelManager = mockwebHostLanguageWorkerChannelManager.Object;
}
var mockFunctionDispatcherLoadBalancer = new Mock <IRpcFunctionInvocationDispatcherLoadBalancer>();
_javaTestChannel = new TestRpcWorkerChannel(Guid.NewGuid().ToString(), "java", eventManager, _testLogger, false);
var optionsMonitor = TestHelpers.CreateOptionsMonitor(workerConfigOptions);
return(new RpcFunctionInvocationDispatcher(scriptOptions,
metricsLogger.Object,
testEnv,
mockApplicationLifetime.Object,
eventManager,
loggerFactory,
testLanguageWorkerChannelFactory,
optionsMonitor,
testWebHostLanguageWorkerChannelManager,
jobHostLanguageWorkerChannelManager,
new OptionsWrapper <ManagedDependencyOptions>(new ManagedDependencyOptions()),
mockFunctionDispatcherLoadBalancer.Object));
}
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", "WarmupFunction");
_testHome = Path.Combine(Path.GetTempPath(), @"WarmupFunction");
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 HostFunctionMetadataProvider(optionsMonitor, NullLogger <HostFunctionMetadataProvider> .Instance, new TestMetricsLogger());
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));
services.SkipDependencyValidation();
});
// TODO: https://github.com/Azure/azure-functions-host/issues/4876
_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);
}
private static IServiceCollection AddFunctionMetadataProvider(this IServiceCollection services, ScriptApplicationHostOptions options)
{
var factory = new TestOptionsFactory <ScriptApplicationHostOptions>(options);
var source = new TestChangeTokenSource();
var changeTokens = new[] { source };
var optionsMonitor = new OptionsMonitor <ScriptApplicationHostOptions>(factory, changeTokens, factory);
var workerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var metadataProvider = new FunctionMetadataProvider(optionsMonitor, new OptionsWrapper <LanguageWorkerOptions>(workerOptions), NullLogger <FunctionMetadataProvider> .Instance);
return(services.AddSingleton <IFunctionMetadataProvider>(metadataProvider));
}
private FunctionMetadataManager GetMetadataManager(IOptionsMonitor <ScriptApplicationHostOptions> optionsMonitor, IScriptHostManager manager, ILoggerFactory factory)
{
var workerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var managerServiceProvider = manager as IServiceProvider;
var metadataProvider = new FunctionMetadataProvider(optionsMonitor, NullLogger <FunctionMetadataProvider> .Instance, new TestMetricsLogger());
var metadataManager = new FunctionMetadataManager(managerServiceProvider.GetService <IOptions <ScriptJobHostOptions> >(), metadataProvider,
managerServiceProvider.GetService <IOptions <HttpWorkerOptions> >(), manager, factory, new OptionsWrapper <LanguageWorkerOptions>(workerOptions));
return(metadataManager);
}
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 LanguageWorkerChannelManagerTests()
{
_eventManager = new ScriptEventManager();
_rpcServer = new TestRpcServer();
_loggerProvider = new TestLoggerProvider();
_loggerFactory = new LoggerFactory();
_testEnvironment = new TestEnvironment();
_loggerFactory.AddProvider(_loggerProvider);
_languageWorkerOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
var applicationHostOptions = new ScriptApplicationHostOptions
{
IsSelfHost = true,
ScriptPath = @"c:\testing\FUNCTIONS-TEST\test$#"
};
_optionsMonitor = TestHelpers.CreateOptionsMonitor(applicationHostOptions);
}
private static IFunctionDispatcher GetTestFunctionDispatcher()
{
var eventManager = new Mock <IScriptEventManager>();
var metricsLogger = new Mock <IMetricsLogger>();
var languageWorkerChannelManager = new Mock <ILanguageWorkerChannelManager>();
var loggerFactory = MockNullLoggerFactory.CreateLoggerFactory();
var options = new ScriptJobHostOptions
{
RootLogPath = Path.GetTempPath()
};
IOptions <ScriptJobHostOptions> scriptOptions = new OptionsManager <ScriptJobHostOptions>(new TestOptionsFactory <ScriptJobHostOptions>(options));
var workerConfigOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs()
};
return(new FunctionDispatcher(scriptOptions, metricsLogger.Object, eventManager.Object, loggerFactory, new OptionsWrapper <LanguageWorkerOptions>(workerConfigOptions), languageWorkerChannelManager.Object));
}
public async Task GetExtensionsStartupTypes_WorkerIndexing_BypassesSelectiveLoading()
{
var storageExtensionReference = new ExtensionReference {
Name = "Storage", TypeName = typeof(AzureStorageWebJobsStartup).AssemblyQualifiedName
};
storageExtensionReference.Bindings.Add("blob");
var sendGridExtensionReference = new ExtensionReference {
Name = "SendGrid", TypeName = typeof(AzureStorageWebJobsStartup).AssemblyQualifiedName
};
sendGridExtensionReference.Bindings.Add("sendGrid");
var references = new[] { storageExtensionReference, sendGridExtensionReference };
TestMetricsLogger testMetricsLogger = new TestMetricsLogger();
var extensions = new JObject
{
{ "extensions", JArray.FromObject(references) }
};
using (var directory = new TempDirectory())
{
var binPath = Path.Combine(directory.Path, "bin");
Directory.CreateDirectory(binPath);
void CopyToBin(string path)
{
File.Copy(path, Path.Combine(binPath, Path.GetFileName(path)));
}
CopyToBin(typeof(AzureStorageWebJobsStartup).Assembly.Location);
File.WriteAllText(Path.Combine(binPath, "extensions.json"), extensions.ToString());
TestLoggerProvider testLoggerProvider = new TestLoggerProvider();
LoggerFactory factory = new LoggerFactory();
factory.AddProvider(testLoggerProvider);
var testLogger = factory.CreateLogger <ScriptStartupTypeLocator>();
var mockFunctionMetadataManager = GetTestFunctionMetadataManager();
var mockExtensionBundleManager = new Mock <IExtensionBundleManager>();
mockExtensionBundleManager.Setup(e => e.IsExtensionBundleConfigured()).Returns(true);
mockExtensionBundleManager.Setup(e => e.GetExtensionBundleBinPathAsync()).Returns(Task.FromResult(binPath));
// mock worker config and environment variables to make host choose worker indexing
RpcWorkerConfig workerConfig = new RpcWorkerConfig()
{
Description = TestHelpers.GetTestWorkerDescription("python", "none", true)
};
var tempOptions = new LanguageWorkerOptions();
tempOptions.WorkerConfigs = new List <RpcWorkerConfig>();
tempOptions.WorkerConfigs.Add(workerConfig);
var languageWorkerOptions = new OptionsWrapper <LanguageWorkerOptions>(tempOptions);
Environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
Environment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, "python");
var discoverer = new ScriptStartupTypeLocator(directory.Path, testLogger, mockExtensionBundleManager.Object, mockFunctionMetadataManager, testMetricsLogger, languageWorkerOptions);
// Act
var types = await discoverer.GetExtensionsStartupTypesAsync();
Environment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, null);
Environment.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, null);
//Assert that filtering did not take place because of worker indexing
Assert.True(types.Count() == 2);
Assert.Equal(typeof(AzureStorageWebJobsStartup).FullName, types.ElementAt(0).FullName);
Assert.Equal(typeof(AzureStorageWebJobsStartup).FullName, types.ElementAt(1).FullName);
}
}
private static RpcFunctionInvocationDispatcher GetTestFunctionDispatcher(int maxProcessCountValue = 1, bool addWebhostChannel = false,
Mock <IWebHostRpcWorkerChannelManager> mockwebHostLanguageWorkerChannelManager = null, bool throwOnProcessStartUp = false, TimeSpan?startupIntervals = null, string runtime = null, bool workerIndexing = false, bool placeholder = false)
{
var eventManager = new ScriptEventManager();
var metricsLogger = new Mock <IMetricsLogger>();
var mockApplicationLifetime = new Mock <IApplicationLifetime>();
var testEnv = new TestEnvironment();
TimeSpan intervals = startupIntervals ?? TimeSpan.FromMilliseconds(100);
testEnv.SetEnvironmentVariable(RpcWorkerConstants.FunctionsWorkerProcessCountSettingName, maxProcessCountValue.ToString());
if (runtime != null)
{
testEnv.SetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime, runtime);
}
if (workerIndexing)
{
testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableWorkerIndexing);
}
if (placeholder)
{
testEnv.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1");
}
var options = new ScriptJobHostOptions
{
RootLogPath = Path.GetTempPath()
};
IOptions <ScriptJobHostOptions> scriptOptions = new OptionsManager <ScriptJobHostOptions>(new TestOptionsFactory <ScriptJobHostOptions>(options));
var workerConfigOptions = new LanguageWorkerOptions
{
WorkerConfigs = TestHelpers.GetTestWorkerConfigs(processCountValue: maxProcessCountValue, processStartupInterval: intervals,
processRestartInterval: intervals, processShutdownTimeout: TimeSpan.FromSeconds(1), workerIndexing: workerIndexing)
};
IRpcWorkerChannelFactory testLanguageWorkerChannelFactory = new TestRpcWorkerChannelFactory(eventManager, _testLogger, scriptOptions.Value.RootScriptPath, throwOnProcessStartUp);
IWebHostRpcWorkerChannelManager testWebHostLanguageWorkerChannelManager = new TestRpcWorkerChannelManager(eventManager, _testLogger, scriptOptions.Value.RootScriptPath, testLanguageWorkerChannelFactory);
IJobHostRpcWorkerChannelManager jobHostLanguageWorkerChannelManager = new JobHostRpcWorkerChannelManager(_testLoggerFactory);
if (addWebhostChannel)
{
testWebHostLanguageWorkerChannelManager.InitializeChannelAsync("java");
}
if (mockwebHostLanguageWorkerChannelManager != null)
{
testWebHostLanguageWorkerChannelManager = mockwebHostLanguageWorkerChannelManager.Object;
}
var mockFunctionDispatcherLoadBalancer = new Mock <IRpcFunctionInvocationDispatcherLoadBalancer>();
_javaTestChannel = new TestRpcWorkerChannel(Guid.NewGuid().ToString(), "java", eventManager, _testLogger, false);
var optionsMonitor = TestHelpers.CreateOptionsMonitor(workerConfigOptions);
return(new RpcFunctionInvocationDispatcher(scriptOptions,
metricsLogger.Object,
testEnv,
mockApplicationLifetime.Object,
eventManager,
_testLoggerFactory,
testLanguageWorkerChannelFactory,
optionsMonitor,
testWebHostLanguageWorkerChannelManager,
jobHostLanguageWorkerChannelManager,
new OptionsWrapper <ManagedDependencyOptions>(new ManagedDependencyOptions()),
mockFunctionDispatcherLoadBalancer.Object,
Options.Create(new WorkerConcurrencyOptions())));
}
