public HttpWorkerChannelFactory(IEnvironment environment, ILoggerFactory loggerFactory, IOptions <HttpWorkerOptions> httpWorkerOptions, IScriptEventManager eventManager,
IOptionsMonitor <ScriptApplicationHostOptions> applicationHostOptions, IHttpWorkerProcessFactory httpWorkerProcessFactory, IHttpWorkerService httpWorkerService)
{
_eventManager = eventManager ?? throw new ArgumentNullException(nameof(eventManager));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_httpWorkerOptions = httpWorkerOptions.Value ?? throw new ArgumentNullException(nameof(httpWorkerOptions.Value));
_httpWorkerProcessFactory = httpWorkerProcessFactory ?? throw new ArgumentNullException(nameof(httpWorkerProcessFactory));
_httpWorkerService = httpWorkerService ?? throw new ArgumentNullException(nameof(httpWorkerService));
}
public FileMonitoringService(IOptions <ScriptJobHostOptions> scriptOptions, ILoggerFactory loggerFactory, IScriptEventManager eventManager, IScriptJobHostEnvironment scriptEnvironment)
{
_scriptOptions = scriptOptions.Value;
_eventManager = eventManager;
_scriptEnvironment = scriptEnvironment;
_hostLogPath = Path.Combine(_scriptOptions.RootLogPath, "Host");
_logger = loggerFactory.CreateLogger(LogCategories.Startup);
// If a file change should result in a restart, we debounce the event to
// ensure that only a single restart is triggered within a specific time window.
// This allows us to deal with a large set of file change events that might
// result from a bulk copy/unzip operation. In such cases, we only want to
// restart after ALL the operations are complete and there is a quiet period.
_restart = RestartAsync;
_restart = _restart.Debounce(500);
_shutdown = Shutdown;
_shutdown = _shutdown.Debounce(500);
}
protected SystemLoggerProvider(string hostInstanceId, IEventGenerator eventGenerator, IEnvironment environment, IDebugStateProvider debugStateProvider, IScriptEventManager eventManager)
{
_eventGenerator = eventGenerator;
_environment = environment;
_hostInstanceId = hostInstanceId;
_debugStateProvider = debugStateProvider;
_eventManager = eventManager;
}
public RpcInitializationService(IRpcServer rpcServer, IFunctionDispatcher functionDispatcher, IScriptEventManager eventManager)
{
_rpcServer = rpcServer;
_eventManager = eventManager;
_functionDispatcher = functionDispatcher;
}
public FunctionRpcService(IScriptEventManager scriptEventManager)
{
_eventManager = scriptEventManager;
Environment.SetEnvironmentVariable("GRPC_EXPERIMENTAL_DISABLE_FLOW_CONTROL", "1");
Environment.SetEnvironmentVariable("GRPC_CLIENT_CHANNEL_BACKUP_POLL_INTERVAL_MS Default", "0");
}
public ProxyMetadataManager(IOptions <ScriptJobHostOptions> scriptOptions, IEnvironment environment, IScriptEventManager eventManager, ILoggerFactory loggerFactory)
{
_scriptOptions = scriptOptions;
_environment = environment;
_logger = loggerFactory.CreateLogger(LogCategories.Startup);
_metadata = new Lazy <ProxyMetadataInfo>(LoadFunctionMetadata);
_fileChangeSubscription = eventManager.OfType <FileEvent>()
.Where(f => string.Equals(f.Source, EventSources.ScriptFiles, StringComparison.Ordinal) &&
string.Equals(Path.GetFileName(f.FileChangeArguments.Name), ScriptConstants.ProxyMetadataFileName, StringComparison.OrdinalIgnoreCase))
.Subscribe(e => HandleProxyFileChange());
}
public static void WarmUp(WebHostSettings settings, IScriptEventManager eventManager)
{
var traceWriter = new FileTraceWriter(Path.Combine(settings.LogPath, "Host"), TraceLevel.Info);
ScriptHost host = null;
try
{
traceWriter.Info("Warm up started");
string rootPath = settings.ScriptPath;
if (Directory.Exists(rootPath))
{
Directory.Delete(rootPath, true);
}
Directory.CreateDirectory(rootPath);
string content = ReadResourceString("Functions.host.json");
File.WriteAllText(Path.Combine(rootPath, "host.json"), content);
// read in the C# function
string functionPath = Path.Combine(rootPath, "Test-CSharp");
Directory.CreateDirectory(functionPath);
content = ReadResourceString("Functions.Test_CSharp.function.json");
File.WriteAllText(Path.Combine(functionPath, "function.json"), content);
content = ReadResourceString("Functions.Test_CSharp.run.csx");
File.WriteAllText(Path.Combine(functionPath, "run.csx"), content);
// read in the F# function
functionPath = Path.Combine(rootPath, "Test-FSharp");
Directory.CreateDirectory(functionPath);
content = ReadResourceString("Functions.Test_FSharp.function.json");
File.WriteAllText(Path.Combine(functionPath, "function.json"), content);
content = ReadResourceString("Functions.Test_FSharp.run.fsx");
File.WriteAllText(Path.Combine(functionPath, "run.fsx"), content);
traceWriter.Info("Warm up functions deployed");
ScriptHostConfiguration config = new ScriptHostConfiguration
{
RootScriptPath = rootPath,
FileLoggingMode = FileLoggingMode.Never,
RootLogPath = settings.LogPath,
TraceWriter = traceWriter,
FileWatchingEnabled = false
};
config.HostConfig.StorageConnectionString = null;
config.HostConfig.DashboardConnectionString = null;
host = ScriptHost.Create(new NullScriptHostEnvironment(), eventManager, config, ScriptSettingsManager.Instance);
traceWriter.Info(string.Format("Starting Host (Id={0})", host.ScriptConfig.HostConfig.HostId));
host.Start();
var arguments = new Dictionary <string, object>
{
{ "input", "{}" }
};
host.CallAsync("Test-CSharp", arguments).Wait();
host.CallAsync("Test-FSharp", arguments).Wait();
host.Stop();
traceWriter.Info("Warm up succeeded");
}
catch (Exception ex)
{
traceWriter.Error(string.Format("Warm up failed: {0}", ex));
}
finally
{
host?.Dispose();
traceWriter.Dispose();
}
}
public TestLanguageWorkerChannelFactory(IScriptEventManager eventManager, ILogger testLogger, string scriptRootPath)
{
_eventManager = eventManager;
_testLogger = testLogger;
_scriptRootPath = scriptRootPath;
}
protected SystemLoggerProvider(string hostInstanceId, IEventGenerator eventGenerator, IEnvironment environment, IDebugStateProvider debugStateProvider, IScriptEventManager eventManager, IOptionsMonitor <AppServiceOptions> appServiceOptions)
{
_eventGenerator = eventGenerator;
_environment = environment;
_hostInstanceId = hostInstanceId;
_debugStateProvider = debugStateProvider;
_eventManager = eventManager;
_appServiceOptions = appServiceOptions;
}
public MockScriptHostManager(ScriptHostConfiguration config, IScriptEventManager eventManager)
: base(config, eventManager)
{
}
public TestScriptEventManager()
{
_scriptEventManager = new ScriptEventManager();
}
public static IHostBuilder CreateHostBuilder(FunctionRpc.FunctionRpcBase service, IScriptEventManager scriptEventManager, int port) =>
new HostBuilder().ConfigureWebHost(webBuilder =>
{
webBuilder.UseKestrel(options =>
{
options.Listen(IPAddress.Parse(WorkerConstants.HostName), port, listenOptions =>
{
listenOptions.Protocols = HttpProtocols.Http2;
});
});
webBuilder.ConfigureServices(services =>
{
services.AddSingleton(scriptEventManager);
services.AddSingleton(service);
});
webBuilder.UseStartup <Startup>();
});
public FunctionRpcService(IScriptEventManager eventManager, ILoggerFactory loggerFactory)
{
_eventManager = eventManager;
_logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryFunctionRpcService);
}
public DebugStateProvider(IOptionsMonitor <ScriptApplicationHostOptions> scriptOptions, IScriptEventManager eventManager)
{
_event = eventManager.OfType <DebugNotification>()
.Subscribe(evt => LastDebugNotify = evt.NotificationTime);
_scriptOptions = scriptOptions;
InitializeLastDebugNotify();
// If these settings changes, we need to refresh our LastDebugNotify value
_scriptOptions.OnChange(_ => InitializeLastDebugNotify());
}
public WebJobsScriptHostService(IOptionsMonitor <ScriptApplicationHostOptions> applicationHostOptions, IScriptHostBuilder scriptHostBuilder, ILoggerFactory loggerFactory,
IScriptWebHostEnvironment scriptWebHostEnvironment, IEnvironment environment,
HostPerformanceManager hostPerformanceManager, IOptions <HostHealthMonitorOptions> healthMonitorOptions,
IMetricsLogger metricsLogger, IApplicationLifetime applicationLifetime, IConfiguration config, IScriptEventManager eventManager)
{
ArgumentNullException.ThrowIfNull(loggerFactory);
// This will no-op if already initialized.
InitializeApplicationInsightsRequestTracking();
_applicationLifetime = applicationLifetime;
RegisterApplicationLifetimeEvents();
_metricsLogger = metricsLogger;
_applicationHostOptions = applicationHostOptions ?? throw new ArgumentNullException(nameof(applicationHostOptions));
_scriptWebHostEnvironment = scriptWebHostEnvironment ?? throw new ArgumentNullException(nameof(scriptWebHostEnvironment));
_scriptHostBuilder = scriptHostBuilder ?? throw new ArgumentNullException(nameof(scriptHostBuilder));
_environment = environment ?? throw new ArgumentNullException(nameof(environment));
_performanceManager = hostPerformanceManager ?? throw new ArgumentNullException(nameof(hostPerformanceManager));
_healthMonitorOptions = healthMonitorOptions ?? throw new ArgumentNullException(nameof(healthMonitorOptions));
_logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryHostGeneral);
_config = config ?? throw new ArgumentNullException(nameof(config));
_eventManager = eventManager;
_hostStarted = _hostStartedSource.Task;
State = ScriptHostState.Default;
if (ShouldMonitorHostHealth)
{
_healthCheckWindow = new SlidingWindow <bool>(_healthMonitorOptions.Value.HealthCheckWindow);
_hostHealthCheckTimer = new Timer(OnHostHealthCheckTimer, null, TimeSpan.Zero, _healthMonitorOptions.Value.HealthCheckInterval);
}
}
public FunctionRpcService(IScriptEventManager eventManager)
{
_eventManager = eventManager;
}
public SystemLogger(string hostInstanceId, string categoryName, IEventGenerator eventGenerator, IEnvironment environment, IDebugStateProvider debugStateProvider, IScriptEventManager eventManager)
{
_environment = environment;
_eventGenerator = eventGenerator;
_categoryName = categoryName ?? string.Empty;
_logLevel = LogLevel.Debug;
_functionName = LogCategories.IsFunctionCategory(_categoryName) ? _categoryName.Split('.')[1] : string.Empty;
_isUserFunction = LogCategories.IsFunctionUserCategory(_categoryName);
_hostInstanceId = hostInstanceId;
_debugStateProvider = debugStateProvider;
_eventManager = eventManager;
}
public FunctionRpcService(IScriptEventManager eventManager, ILogger logger)
{
_eventManager = eventManager;
_logger = logger;
}
public WebHostSystemLoggerProvider(IEventGenerator eventGenerator, IEnvironment environment, IDebugStateProvider debugStateProvider, IScriptEventManager eventManager, IOptionsMonitor <AppServiceOptions> appServiceOptions)
: base(string.Empty, eventGenerator, environment, debugStateProvider, eventManager, appServiceOptions)
{
}
internal TestWorkerProcess(IScriptEventManager eventManager, IProcessRegistry processRegistry, ILogger workerProcessLogger, IWorkerConsoleLogSource consoleLogSource, IMetricsLogger metricsLogger, IServiceProvider serviceProvider, bool useStdErrStreamForErrorsOnly = false)
: base(eventManager, processRegistry, workerProcessLogger, consoleLogSource, metricsLogger, serviceProvider, useStdErrStreamForErrorsOnly)
{
}
public DebugStateProvider(IOptionsMonitor <ScriptApplicationHostOptions> scriptOptions, IScriptEventManager eventManager)
{
_debugModeEvent = eventManager.OfType <DebugNotification>()
.Subscribe(evt => LastDebugNotify = evt.NotificationTime);
_diagnosticModeEvent = eventManager.OfType <DiagnosticNotification>()
.Subscribe(evt => LastDiagnosticNotify = evt.NotificationTime);
_scriptOptions = scriptOptions;
_scriptOptions.OnChange(_ => InitializeLastNotificationTimes());
InitializeLastNotificationTimes();
}
public SystemLoggerProvider(IOptions <ScriptJobHostOptions> scriptOptions, IEventGenerator eventGenerator, IEnvironment environment, IDebugStateProvider debugStateProvider, IScriptEventManager eventManager)
: this(scriptOptions.Value.InstanceId, eventGenerator, environment, debugStateProvider, eventManager)
{
}
public WebHostSystemLoggerProvider(IEventGenerator eventGenerator, IEnvironment environment, IDebugStateProvider debugStateProvider, IScriptEventManager eventManager)
: base(string.Empty, eventGenerator, environment, debugStateProvider, eventManager)
{
}
// Specify the "builtin binding types". These are types that are directly accesible without needing an explicit load gesture.
// This is the set of bindings we shipped prior to binding extensibility.
// Map from BindingType to the Assembly Qualified Type name for its IExtensionConfigProvider object.
public ScriptHost(IOptions <JobHostOptions> options,
IOptions <HttpWorkerOptions> httpWorkerOptions,
IEnvironment environment,
IJobHostContextFactory jobHostContextFactory,
IConfiguration configuration,
IDistributedLockManager distributedLockManager,
IScriptEventManager eventManager,
ILoggerFactory loggerFactory,
IFunctionInvocationDispatcherFactory functionDispatcherFactory,
IFunctionMetadataManager functionMetadataManager,
IFileLoggingStatusManager fileLoggingStatusManager,
IMetricsLogger metricsLogger,
IOptions <ScriptJobHostOptions> scriptHostOptions,
ITypeLocator typeLocator,
IScriptHostManager scriptHostManager,
IDebugStateProvider debugManager,
IEnumerable <IScriptBindingProvider> bindingProviders,
IPrimaryHostStateProvider primaryHostStateProvider,
IJobHostMetadataProvider metadataProvider,
IHostIdProvider hostIdProvider,
IHttpRoutesManager httpRoutesManager,
IApplicationLifetime applicationLifetime,
IExtensionBundleManager extensionBundleManager,
ScriptSettingsManager settingsManager = null)
: base(options, jobHostContextFactory)
{
_environment = environment;
_typeLocator = typeLocator as ScriptTypeLocator
?? throw new ArgumentException(nameof(typeLocator), $"A {nameof(ScriptTypeLocator)} instance is required.");
_instanceId = Guid.NewGuid().ToString();
_hostOptions = options;
_configuration = configuration;
_storageConnectionString = configuration.GetWebJobsConnectionString(ConnectionStringNames.Storage);
_distributedLockManager = distributedLockManager;
_functionMetadataManager = functionMetadataManager;
_fileLoggingStatusManager = fileLoggingStatusManager;
_applicationLifetime = applicationLifetime;
_hostIdProvider = hostIdProvider;
_httpRoutesManager = httpRoutesManager;
_isHttpWorker = httpWorkerOptions.Value.Description != null;
ScriptOptions = scriptHostOptions.Value;
_scriptHostManager = scriptHostManager;
FunctionErrors = new Dictionary <string, ICollection <string> >(StringComparer.OrdinalIgnoreCase);
EventManager = eventManager;
_functionDispatcher = functionDispatcherFactory.GetFunctionDispatcher();
_settingsManager = settingsManager ?? ScriptSettingsManager.Instance;
ExtensionBundleManager = extensionBundleManager;
_metricsLogger = metricsLogger;
_hostLogPath = Path.Combine(ScriptOptions.RootLogPath, "Host");
_workerRuntime = _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName);
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger(LogCategories.Startup);
Logger = _logger;
_debugManager = debugManager;
_primaryHostStateProvider = primaryHostStateProvider;
_bindingProviders = new List <IScriptBindingProvider>(bindingProviders);
_metadataProvider = metadataProvider;
_eventSubscriptions.Add(EventManager.OfType <FunctionIndexingEvent>()
.Subscribe(evt =>
{
HandleHostError(evt.Exception);
}));
}
public WebHostResolver(ScriptSettingsManager settingsManager, ISecretManagerFactory secretManagerFactory, IScriptEventManager eventManager)
{
_settingsManager = settingsManager;
_secretManagerFactory = secretManagerFactory;
_eventManager = eventManager;
}
public FileMonitoringService(IOptions <ScriptJobHostOptions> scriptOptions, ILoggerFactory loggerFactory, IScriptEventManager eventManager, IApplicationLifetime applicationLifetime, IScriptHostManager scriptHostManager, IEnvironment environment)
{
_scriptOptions = scriptOptions.Value;
_eventManager = eventManager;
_applicationLifetime = applicationLifetime;
_scriptHostManager = scriptHostManager;
_hostLogPath = Path.Combine(_scriptOptions.RootLogPath, "Host");
_logger = loggerFactory.CreateLogger(LogCategories.Startup);
_environment = environment;
// Use this for newer logs as we can't change existing categories of log messages
_typedLogger = loggerFactory.CreateLogger <FileMonitoringService>();
// If a file change should result in a restart, we debounce the event to
// ensure that only a single restart is triggered within a specific time window.
// This allows us to deal with a large set of file change events that might
// result from a bulk copy/unzip operation. In such cases, we only want to
// restart after ALL the operations are complete and there is a quiet period.
_restart = RestartAsync;
_restart = _restart.Debounce(500);
_shutdown = Shutdown;
_shutdown = _shutdown.Debounce(milliseconds: 500);
_rootDirectorySnapshot = GetDirectorySnapshot();
}
public ScriptHost Create(IScriptHostEnvironment environment, IScriptEventManager eventManager, ScriptSettingsManager settingsManager, ScriptHostConfiguration config)
{
return(ScriptHost.Create(environment, eventManager, config, settingsManager));
}
