private static WebHostSettings GetDefaultSettings(ScriptSettingsManager settingsManager) { WebHostSettings settings = new WebHostSettings(); string home = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebsiteHomePath); bool isLocal = string.IsNullOrEmpty(home); if (isLocal) { settings.ScriptPath = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebJobsScriptRoot); settings.LogPath = Path.Combine(Path.GetTempPath(), @"Functions"); settings.SecretsPath = HttpContext.Current.Server.MapPath("~/App_Data/Secrets"); } else { // we're running in Azure settings.ScriptPath = Path.Combine(home, @"site\wwwroot"); settings.LogPath = Path.Combine(home, @"LogFiles\Application\Functions"); settings.SecretsPath = Path.Combine(home, @"data\Functions\secrets"); } if (string.IsNullOrEmpty(settings.ScriptPath)) { throw new InvalidOperationException("Unable to determine function script root directory."); } return settings; }
private void EnsureInitialized(WebHostSettings settings) { // standby mode can only change from true to false // When standby mode changes, we reset all instances var standbyMode = WebScriptHostManager.InStandbyMode; if (!standbyMode) { if (_activeHostManager == null) { _activeScriptHostConfig = CreateScriptHostConfiguration(settings); _activeHostManager = new WebScriptHostManager(_activeScriptHostConfig, _secretManagerFactory, _eventManager, _settingsManager, settings); _activeReceiverManager = new WebHookReceiverManager(_activeHostManager.SecretManager); _standbyHostManager?.Dispose(); _standbyReceiverManager?.Dispose(); _standbyScriptHostConfig = null; _standbyHostManager = null; _standbyReceiverManager = null; _settingsManager.Reset(); } } else { if (_standbyHostManager == null) { _standbyScriptHostConfig = CreateScriptHostConfiguration(settings); _standbyHostManager = new WebScriptHostManager(_standbyScriptHostConfig, _secretManagerFactory, _eventManager, _settingsManager, settings); _standbyReceiverManager = new WebHookReceiverManager(_standbyHostManager.SecretManager); } } }
internal static WebHostSettings CreateDefault(ScriptSettingsManager settingsManager) { WebHostSettings settings = new WebHostSettings { IsSelfHost = !settingsManager.IsAzureEnvironment }; if (settingsManager.IsAzureEnvironment) { string home = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebsiteHomePath); settings.ScriptPath = Path.Combine(home, @"site\wwwroot"); settings.LogPath = Path.Combine(home, @"LogFiles\Application\Functions"); settings.SecretsPath = Path.Combine(home, @"data\Functions\secrets"); } else { settings.ScriptPath = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebJobsScriptRoot); settings.LogPath = Path.Combine(Path.GetTempPath(), @"Functions"); settings.SecretsPath = System.Web.HttpContext.Current.Server.MapPath("~/App_Data/Secrets"); } if (string.IsNullOrEmpty(settings.ScriptPath)) { throw new InvalidOperationException("Unable to determine function script root directory."); } return(settings); }
internal static WebHostSettings CreateDefault(ScriptSettingsManager settingsManager) { WebHostSettings settings = new WebHostSettings { IsSelfHost = !settingsManager.IsAppServiceEnvironment && !settingsManager.IsLinuxContainerEnvironment }; if (settingsManager.IsAppServiceEnvironment) { // Running in App Service string home = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebsiteHomePath); settings.ScriptPath = Path.Combine(home, "site", "wwwroot"); settings.LogPath = Path.Combine(home, "LogFiles", "Application", "Functions"); settings.SecretsPath = Path.Combine(home, "data", "Functions", "secrets"); settings.TestDataPath = Path.Combine(home, "data", "Functions", "sampledata"); } else { // Local hosting or Linux container scenarios settings.ScriptPath = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebJobsScriptRoot); settings.LogPath = Path.Combine(Path.GetTempPath(), @"Functions"); settings.TestDataPath = Path.Combine(Path.GetTempPath(), @"FunctionsData"); // TODO: Revisit. We'll likely have to take an instance of an IHostingEnvironment here settings.SecretsPath = Path.Combine(AppContext.BaseDirectory, "Secrets"); } if (string.IsNullOrEmpty(settings.ScriptPath)) { throw new InvalidOperationException("Unable to determine function script root directory."); } return(settings); }
public void GetHttpFunctionOrNull_DecodesUriProperly() { WebHostSettings webHostSettings = new WebHostSettings(); WebScriptHostManager manager = new WebScriptHostManager(new ScriptHostConfiguration(), new SecretManager(), webHostSettings); // Initialize the FunctionMetadata metadata = new FunctionMetadata(); metadata.Bindings.Add(new HttpTriggerBindingMetadata { Type = "HttpTrigger" }); TestInvoker invoker = new TestInvoker(); Collection <ParameterDescriptor> parameters = new Collection <ParameterDescriptor>(); Collection <FunctionDescriptor> functions = new Collection <FunctionDescriptor>() { new FunctionDescriptor("Foo Bar", invoker, metadata, parameters), new FunctionDescriptor("éà 中國", invoker, metadata, parameters) }; manager.InitializeHttpFunctions(functions); Uri uri = new Uri("http://local/api/Foo Bar"); var result = manager.GetHttpFunctionOrNull(uri); Assert.Same(functions[0], result); uri = new Uri("http://local/api/éà 中國"); result = manager.GetHttpFunctionOrNull(uri); Assert.Same(functions[1], result); }
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, IScriptEventManager eventManager, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings, IWebJobsRouter router, ILoggerFactory loggerFactory, IScriptHostFactory scriptHostFactory = null, ISecretsRepositoryFactory secretsRepositoryFactory = null, HostPerformanceManager hostPerformanceManager = null, ILoggerProviderFactory loggerProviderFactory = null, int hostTimeoutSeconds = 30, int hostPollingIntervalMilliseconds = 500) : base(config, settingsManager, scriptHostFactory, eventManager, environment: null, hostPerformanceManager: hostPerformanceManager, loggerProviderFactory: loggerProviderFactory) { _config = config; _metricsLogger = new WebHostMetricsLogger(); _exceptionHandler = new WebScriptHostExceptionHandler(this); _webHostSettings = webHostSettings; _settingsManager = settingsManager; _hostTimeoutSeconds = hostTimeoutSeconds; _hostRunningPollIntervalMilliseconds = hostPollingIntervalMilliseconds; _router = router; config.IsSelfHost = webHostSettings.IsSelfHost; secretsRepositoryFactory = secretsRepositoryFactory ?? new DefaultSecretsRepositoryFactory(); var secretsRepository = secretsRepositoryFactory.Create(settingsManager, webHostSettings, config); _secretManager = secretManagerFactory.Create(settingsManager, loggerFactory.CreateLogger(ScriptConstants.LogCategoryHostGeneral), secretsRepository); _bindingWebHookProvider = new WebJobsSdkExtensionHookProvider(_secretManager); }
private static WebHostSettings GetDefaultSettings(ScriptSettingsManager settingsManager) { WebHostSettings settings = new WebHostSettings(); string home = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebsiteHomePath); bool isLocal = string.IsNullOrEmpty(home); if (isLocal) { settings.ScriptPath = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebJobsScriptRoot); settings.LogPath = Path.Combine(Path.GetTempPath(), @"Functions"); settings.SecretsPath = HttpContext.Current.Server.MapPath("~/App_Data/Secrets"); } else { // we're running in Azure settings.ScriptPath = Path.Combine(home, @"site\wwwroot"); settings.LogPath = Path.Combine(home, @"LogFiles\Application\Functions"); settings.SecretsPath = Path.Combine(home, @"data\Functions\secrets"); } if (string.IsNullOrEmpty(settings.ScriptPath)) { throw new InvalidOperationException("Unable to determine function script root directory."); } return(settings); }
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings, IScriptHostFactory scriptHostFactory = null, ISecretsRepositoryFactory secretsRepositoryFactory = null) : base(config, settingsManager, scriptHostFactory) { _config = config; _metricsLogger = new WebHostMetricsLogger(); _exceptionHandler = new WebScriptHostExceptionHandler(this); _webHostSettings = webHostSettings; var systemEventGenerator = config.HostConfig.GetService <IEventGenerator>() ?? new EventGenerator(); var systemTraceWriter = new SystemTraceWriter(systemEventGenerator, settingsManager, TraceLevel.Verbose); if (config.TraceWriter != null) { config.TraceWriter = new CompositeTraceWriter(new TraceWriter[] { config.TraceWriter, systemTraceWriter }); } else { config.TraceWriter = systemTraceWriter; } config.IsSelfHost = webHostSettings.IsSelfHost; _performanceManager = new HostPerformanceManager(settingsManager, config.TraceWriter); _swaggerDocumentManager = new SwaggerDocumentManager(config); var secretsRepository = secretsRepositoryFactory.Create(settingsManager, webHostSettings, config); _secretManager = secretManagerFactory.Create(settingsManager, config.TraceWriter, secretsRepository); }
private static ScriptHostConfiguration CreateScriptHostConfiguration(WebHostSettings settings) { InitializeFileSystem(settings.ScriptPath); var scriptHostConfig = new ScriptHostConfiguration() { RootScriptPath = settings.ScriptPath, RootLogPath = settings.LogPath, FileLoggingMode = FileLoggingMode.DebugOnly, TraceWriter = settings.TraceWriter }; // If running on Azure Web App, derive the host ID from the default subdomain string hostId = _settingsManager.AzureWebsiteDefaultSubdomain; if (!String.IsNullOrEmpty(hostId)) { // Truncate to the max host name length if needed const int MaximumHostIdLength = 32; if (hostId.Length > MaximumHostIdLength) { hostId = hostId.Substring(0, MaximumHostIdLength); } // Trim any trailing - as they can cause problems with queue names hostId = hostId.TrimEnd('-'); scriptHostConfig.HostConfig.HostId = hostId.ToLowerInvariant(); } return(scriptHostConfig); }
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, IScriptEventManager eventManager, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings) : this(config, secretManagerFactory, eventManager, settingsManager, webHostSettings, new ScriptHostFactory()) { }
public static IServiceProvider AddWebJobsScriptHost(this IServiceCollection services, IConfiguration configuration) { services.AddWebJobsScriptHostRouting(); services.AddMvc() .AddXmlDataContractSerializerFormatters(); services.TryAddEnumerable(ServiceDescriptor.Singleton <IHostedService, WebJobsScriptHostService>()); // TODO: This is a direct port from the current model. // Some of those services (or the way we register them) may need to change var builder = new ContainerBuilder(); // ScriptSettingsManager should be replaced. We're setting this here as a temporary step until // broader configuaration changes are made: ScriptSettingsManager.Instance.SetConfigurationFactory(() => configuration); builder.RegisterInstance(ScriptSettingsManager.Instance); builder.RegisterType <DefaultSecretManagerFactory>().As <ISecretManagerFactory>().SingleInstance(); builder.RegisterType <ScriptEventManager>().As <IScriptEventManager>().SingleInstance(); builder.RegisterType <EventGenerator>().As <IEventGenerator>().SingleInstance(); builder.Register(c => WebHostSettings.CreateDefault(c.Resolve <ScriptSettingsManager>())); // Pass a specially-constructed LoggerFactory to the WebHostResolver. This LoggerFactory is only used // when there is no host available. // Only use this LoggerFactory for this constructor; use the registered ILoggerFactory below everywhere else. builder.RegisterType <WebHostResolver>().SingleInstance() .WithParameter(new ResolvedParameter( (pi, ctx) => pi.ParameterType == typeof(ILoggerFactory), (pi, ctx) => CreateLoggerFactory(string.Empty, ctx.Resolve <ScriptSettingsManager>(), ctx.Resolve <IEventGenerator>(), ctx.Resolve <WebHostSettings>()))); // Register the LoggerProviderFactory, which defines the ILoggerProviders for the host. builder.RegisterType <WebHostLoggerProviderFactory>().As <ILoggerProviderFactory>().SingleInstance(); // Temporary - This should be replaced with a simple type registration. builder.Register <IExtensionsManager>(c => { var hostInstance = c.Resolve <WebScriptHostManager>().Instance; return(new ExtensionsManager(hostInstance.ScriptConfig.RootScriptPath, hostInstance.Logger, hostInstance.ScriptConfig.NugetFallBackPath)); }); // The services below need to be scoped to a pseudo-tenant (warm/specialized environment) builder.Register <WebScriptHostManager>(c => c.Resolve <WebHostResolver>().GetWebScriptHostManager()).ExternallyOwned(); builder.Register <ISecretManager>(c => c.Resolve <WebHostResolver>().GetSecretManager()).ExternallyOwned(); builder.RegisterType <WebFunctionsManager>().As <IWebFunctionsManager>().SingleInstance(); builder.RegisterType <VirtualFileSystem>(); builder.RegisterType <VirtualFileSystemMiddleware>(); // Populate the container builder with registered services. // Doing this here will cause any services registered in the service collection to // override the registrations above builder.Populate(services); builder.Register(ct => ct.Resolve <WebHostResolver>().GetLoggerFactory(ct.Resolve <WebHostSettings>())).As <ILoggerFactory>().ExternallyOwned(); var applicationContainer = builder.Build(); return(new AutofacServiceProvider(applicationContainer)); }
public static void Register(HttpConfiguration config, ScriptSettingsManager settingsManager = null, WebHostSettings settings = null, Action <ContainerBuilder, WebHostSettings> dependencyCallback = null) { if (config == null) { throw new ArgumentNullException("config"); } settingsManager = settingsManager ?? ScriptSettingsManager.Instance; settings = settings ?? WebHostSettings.CreateDefault(settingsManager); var builder = new ContainerBuilder(); builder.RegisterApiControllers(typeof(FunctionsController).Assembly); AutofacBootstrap.Initialize(settingsManager, builder, settings); // Invoke registration callback dependencyCallback?.Invoke(builder, settings); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); config.Formatters.Add(new PlaintextMediaTypeFormatter()); config.Services.Replace(typeof(IExceptionHandler), new ExceptionProcessingHandler(config)); AddMessageHandlers(config); // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "Home", routeTemplate: string.Empty, defaults: new { controller = "Home" }); config.Routes.MapHttpRoute( name: "Functions", routeTemplate: "{*uri}", defaults: new { controller = "Functions" }); // Initialize WebHook Receivers config.InitializeReceiveGenericJsonWebHooks(); config.InitializeReceiveAzureAlertWebHooks(); config.InitializeReceiveKuduWebHooks(); config.InitializeReceivePusherWebHooks(); config.InitializeReceiveStripeWebHooks(); config.InitializeReceiveTrelloWebHooks(); config.InitializeReceiveDynamicsCrmWebHooks(); config.InitializeReceiveMailChimpWebHooks(); config.InitializeReceiveSlackWebHooks(); config.InitializeReceiveBitbucketWebHooks(); config.InitializeReceiveDropboxWebHooks(); config.InitializeReceiveWordPressWebHooks(); config.InitializeReceiveGitHubWebHooks(); config.InitializeReceiveSalesforceWebHooks(); }
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, IScriptEventManager eventManager, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings, IScriptHostFactory scriptHostFactory) : this(config, secretManagerFactory, eventManager, settingsManager, webHostSettings, scriptHostFactory, new DefaultSecretsRepositoryFactory()) { }
public WebHostResolver(ScriptSettingsManager settingsManager, ISecretManagerFactory secretManagerFactory, IScriptEventManager eventManager, WebHostSettings settings, IWebJobsRouter router, ILoggerFactoryBuilder loggerFactoryBuilder) { _settingsManager = settingsManager; _secretManagerFactory = secretManagerFactory; _eventManager = eventManager; _router = router; _loggerFactoryBuilder = loggerFactoryBuilder; _settings = settings; }
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, IScriptEventManager eventManager, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings, IWebJobsRouter router, ILoggerFactory loggerFactory) : this(config, secretManagerFactory, eventManager, settingsManager, webHostSettings, router, loggerFactory, new ScriptHostFactory()) { }
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, IScriptEventManager eventManager, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings, IWebJobsRouter router, IScriptHostFactory scriptHostFactory, ILoggerFactoryBuilder loggerFactoryBuilder) : this(config, secretManagerFactory, eventManager, settingsManager, webHostSettings, router, scriptHostFactory, new DefaultSecretsRepositoryFactory(), loggerFactoryBuilder) { }
public static void Initialize(HttpConfiguration config, ScriptSettingsManager settingsManager = null, WebHostSettings settings = null, Action<ContainerBuilder, WebHostSettings> dependencyCallback = null) { Register(config, settingsManager, settings, dependencyCallback); var scriptHostManager = config.DependencyResolver.GetService<WebScriptHostManager>(); if (scriptHostManager != null && !scriptHostManager.Initialized) { scriptHostManager.Initialize(); } }
public static void Register(HttpConfiguration config, ScriptSettingsManager settingsManager = null, WebHostSettings settings = null, Action<ContainerBuilder, WebHostSettings> dependencyCallback = null) { if (config == null) { throw new ArgumentNullException("config"); } settingsManager = settingsManager ?? ScriptSettingsManager.Instance; settings = settings ?? GetDefaultSettings(settingsManager); var builder = new ContainerBuilder(); builder.RegisterApiControllers(typeof(FunctionsController).Assembly); AutofacBootstrap.Initialize(settingsManager, builder, settings); // Invoke registration callback dependencyCallback?.Invoke(builder, settings); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); config.Formatters.Add(new PlaintextMediaTypeFormatter()); config.MessageHandlers.Add(new WebScriptHostHandler(config)); // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "Home", routeTemplate: string.Empty, defaults: new { controller = "Home" }); config.Routes.MapHttpRoute( name: "Functions", routeTemplate: "{*uri}", defaults: new { controller = "Functions" }); // Initialize WebHook Receivers config.InitializeReceiveGenericJsonWebHooks(); config.InitializeReceiveAzureAlertWebHooks(); config.InitializeReceiveKuduWebHooks(); config.InitializeReceivePusherWebHooks(); config.InitializeReceiveStripeWebHooks(); config.InitializeReceiveTrelloWebHooks(); config.InitializeReceiveDynamicsCrmWebHooks(); config.InitializeReceiveMailChimpWebHooks(); config.InitializeReceiveSlackWebHooks(); config.InitializeReceiveBitbucketWebHooks(); config.InitializeReceiveDropboxWebHooks(); config.InitializeReceiveWordPressWebHooks(); config.InitializeReceiveGitHubWebHooks(); config.InitializeReceiveSalesforceWebHooks(); }
private static void VerifyAndEnableShadowCopy(WebHostSettings webHostSettings) { if (!FeatureFlags.IsEnabled(ScriptConstants.FeatureFlagDisableShadowCopy)) { string currentShadowCopyDirectories = AppDomain.CurrentDomain.SetupInformation.ShadowCopyDirectories; string shadowCopyPath = GetShadowCopyPath(currentShadowCopyDirectories, webHostSettings.ScriptPath); #pragma warning disable CS0618 AppDomain.CurrentDomain.SetShadowCopyPath(shadowCopyPath); #pragma warning restore CS0618 } }
public static void Initialize(HttpConfiguration config, ScriptSettingsManager settingsManager = null, WebHostSettings settings = null, Action <ContainerBuilder, WebHostSettings> dependencyCallback = null) { Register(config, settingsManager, settings, dependencyCallback); var scriptHostManager = config.DependencyResolver.GetService <WebScriptHostManager>(); if (scriptHostManager != null && !scriptHostManager.Initialized) { scriptHostManager.Initialize(); } }
// TODO: FACAVAL (WEBHOOKS) //public WebHookReceiverManager GetWebHookReceiverManager(WebHostSettings settings) //{ // if (_activeReceiverManager != null) // { // return _activeReceiverManager; // } // lock (_syncLock) // { // EnsureInitialized(settings); // return _activeReceiverManager ?? _standbyReceiverManager; // } //} internal void EnsureInitialized(WebHostSettings settings) { if (!WebScriptHostManager.InStandbyMode) { // standby mode can only change from true to false // when standby mode changes, we reset all instances if (_activeHostManager == null) { _settingsManager.Reset(); _activeScriptHostConfig = CreateScriptHostConfiguration(settings); _activeHostManager = new WebScriptHostManager(_activeScriptHostConfig, _secretManagerFactory, _eventManager, _settingsManager, settings, _router, _loggerFactoryBuilder); //_activeReceiverManager = new WebHookReceiverManager(_activeHostManager.SecretManager); InitializeFileSystem(); if (_standbyHostManager != null) { // we're starting the one and only one // standby mode specialization _activeScriptHostConfig.TraceWriter.Info(Resources.HostSpecializationTrace); // After specialization, we need to ensure that custom timezone // settings configured by the user (WEBSITE_TIME_ZONE) are honored. // DateTime caches timezone information, so we need to clear the cache. TimeZoneInfo.ClearCachedData(); } if (_standbyHostManager != null) { _standbyHostManager.Stop(); _standbyHostManager.Dispose(); } //_standbyReceiverManager?.Dispose(); _standbyScriptHostConfig = null; _standbyHostManager = null; //_standbyReceiverManager = null; } } else { if (_standbyHostManager == null) { var standbySettings = CreateStandbySettings(settings); _standbyScriptHostConfig = CreateScriptHostConfiguration(standbySettings, true); _standbyHostManager = new WebScriptHostManager(_standbyScriptHostConfig, _secretManagerFactory, _eventManager, _settingsManager, standbySettings, _router, _loggerFactoryBuilder); // _standbyReceiverManager = new WebHookReceiverManager(_standbyHostManager.SecretManager); InitializeFileSystem(); StandbyManager.Initialize(_standbyScriptHostConfig); } } }
protected void Application_Start() { var settingsManager = ScriptSettingsManager.Instance; var webHostSettings = WebHostSettings.CreateDefault(settingsManager); VerifyAndEnableShadowCopy(webHostSettings); using (var metricsLogger = new WebHostMetricsLogger()) using (metricsLogger.LatencyEvent(MetricEventNames.ApplicationStartLatency)) { GlobalConfiguration.Configure(c => WebApiConfig.Initialize(c, settingsManager, webHostSettings)); } }
internal static void Initialize(ContainerBuilder builder, WebHostSettings settings) { // register the resolver so that it is disposed when the container // is disposed var webHostResolver = new WebHostResolver(); builder.RegisterInstance(webHostResolver); // these services are externally owned by the WebHostResolver, and will be disposed // when the resolver is disposed builder.Register <SecretManager>(ct => webHostResolver.GetSecretManager(settings)).ExternallyOwned(); builder.Register <WebScriptHostManager>(ct => webHostResolver.GetWebScriptHostManager(settings)).ExternallyOwned(); builder.Register <WebHookReceiverManager>(ct => webHostResolver.GetWebHookReceiverManager(settings)).ExternallyOwned(); }
public ScriptHostConfiguration GetScriptHostConfiguration(WebHostSettings settings) { if (_activeScriptHostConfig != null) { return _activeScriptHostConfig; } lock (_syncLock) { EnsureInitialized(settings); return _activeScriptHostConfig ?? _standbyScriptHostConfig; } }
public WebScriptHostManager GetWebScriptHostManager(WebHostSettings settings) { if (_activeHostManager != null) { return _activeHostManager; } lock (_syncLock) { EnsureInitialized(settings); return _activeHostManager ?? _standbyHostManager; } }
public WebHookReceiverManager GetWebHookReceiverManager(WebHostSettings settings) { if (_activeReceiverManager != null) { return _activeReceiverManager; } lock (_syncLock) { EnsureInitialized(settings); return _activeReceiverManager ?? _standbyReceiverManager; } }
internal static void Initialize(ContainerBuilder builder, WebHostSettings settings) { ScriptHostConfiguration scriptHostConfig = new ScriptHostConfiguration() { RootScriptPath = settings.ScriptPath, RootLogPath = settings.LogPath, FileLoggingEnabled = true }; // If running on Azure Web App, derive the host ID from the site name string hostId = Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME"); if (!String.IsNullOrEmpty(hostId)) { // Truncate to the max host name length if needed const int MaximumHostIdLength = 32; if (hostId.Length > MaximumHostIdLength) { hostId = hostId.Substring(0, MaximumHostIdLength); } // Trim any trailing - as they can cause problems with queue names hostId = hostId.TrimEnd('-'); scriptHostConfig.HostConfig.HostId = hostId.ToLowerInvariant(); } SecretManager secretManager = new SecretManager(settings.SecretsPath); // Make sure that host secrets get created on startup if they don't exist secretManager.GetHostSecrets(); builder.RegisterInstance <SecretManager>(secretManager); WebScriptHostManager scriptHostManager = new WebScriptHostManager(scriptHostConfig, secretManager); builder.RegisterInstance <WebScriptHostManager>(scriptHostManager); WebHookReceiverManager webHookReceiverManager = new WebHookReceiverManager(secretManager); builder.RegisterInstance <WebHookReceiverManager>(webHookReceiverManager); if (!settings.IsSelfHost) { HostingEnvironment.QueueBackgroundWorkItem((ct) => scriptHostManager.RunAndBlock(ct)); } else { Task.Run(() => scriptHostManager.RunAndBlock()); } }
internal static void Initialize(ScriptSettingsManager settingsManager, ContainerBuilder builder, WebHostSettings settings) { builder.RegisterInstance(settingsManager); builder.RegisterType<WebHostResolver>().SingleInstance(); // these services are externally owned by the WebHostResolver, and will be disposed // when the resolver is disposed builder.RegisterType<DefaultSecretManagerFactory>().As<ISecretManagerFactory>().SingleInstance(); builder.Register<TraceWriter>(ct => ct.ResolveOptional<WebScriptHostManager>()?.Instance?.TraceWriter ?? NullTraceWriter.Instance).ExternallyOwned(); builder.Register<ISecretManager>(ct => ct.Resolve<WebHostResolver>().GetSecretManager(settings)).ExternallyOwned(); builder.Register<WebScriptHostManager>(ct => ct.Resolve<WebHostResolver>().GetWebScriptHostManager(settings)).ExternallyOwned(); builder.Register<WebHookReceiverManager>(ct => ct.Resolve<WebHostResolver>().GetWebHookReceiverManager(settings)).ExternallyOwned(); }
protected override void RegisterDependencies(ContainerBuilder builder, WebHostSettings settings) { TestFunctionKeys = new Dictionary<string, string> { { "key1", "1234" }, { "key2", "1234" } }; SecretManagerMock = BuildSecretManager(); builder.RegisterInstance<ISecretManager>(SecretManagerMock.Object); base.RegisterDependencies(builder, settings); }
public ISecretManager GetSecretManager(WebHostSettings settings) { if (_activeSecretManager != null) { return(_activeSecretManager); } lock (_syncLock) { EnsureInitialized(settings); return(_activeSecretManager ?? _standbySecretManager); } }
public WebHookReceiverManager GetWebHookReceiverManager(WebHostSettings settings) { if (_activeReceiverManager != null) { return(_activeReceiverManager); } lock (_syncLock) { EnsureInitialized(settings); return(_activeReceiverManager ?? _standbyReceiverManager); } }
public ScriptHostConfiguration GetScriptHostConfiguration(WebHostSettings settings) { if (_activeScriptHostConfig != null) { return(_activeScriptHostConfig); } lock (_syncLock) { EnsureInitialized(settings); return(_activeScriptHostConfig ?? _standbyScriptHostConfig); } }
public WebScriptHostManager GetWebScriptHostManager(WebHostSettings settings) { if (_activeHostManager != null) { return(_activeHostManager); } lock (_syncLock) { EnsureInitialized(settings); return(_activeHostManager ?? _standbyHostManager); } }
private static ScriptHostConfiguration CreateScriptHostConfiguration(WebHostSettings settings) { InitializeFileSystem(settings.ScriptPath); var scriptHostConfig = new ScriptHostConfiguration() { RootScriptPath = settings.ScriptPath, RootLogPath = settings.LogPath, FileLoggingMode = FileLoggingMode.DebugOnly, TraceWriter = settings.TraceWriter }; return(scriptHostConfig); }
public AdminControllerTests() { _settingsManager = ScriptSettingsManager.Instance; testFunctions = new Collection<FunctionDescriptor>(); var config = new ScriptHostConfiguration(); hostMock = new Mock<ScriptHost>(MockBehavior.Strict, new object[] { config }); hostMock.Setup(p => p.Functions).Returns(testFunctions); WebHostSettings settings = new WebHostSettings(); managerMock = new Mock<WebScriptHostManager>(MockBehavior.Strict, new object[] { config, new TestSecretManagerFactory(), _settingsManager, settings }); managerMock.SetupGet(p => p.Instance).Returns(hostMock.Object); testController = new AdminController(managerMock.Object); }
public ISecretsRepository Create(ScriptSettingsManager settingsManager, WebHostSettings webHostSettings, ScriptHostConfiguration config, ILogger logger) { string secretStorageType = settingsManager.GetSetting(EnvironmentSettingNames.AzureWebJobsSecretStorageType); string storageString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage); if (secretStorageType != null && secretStorageType.Equals("Blob", StringComparison.OrdinalIgnoreCase) && storageString != null) { string siteSlotName = settingsManager.AzureWebsiteUniqueSlotName ?? config.HostConfig.HostId; return(new BlobStorageSecretsMigrationRepository(Path.Combine(webHostSettings.SecretsPath, "Sentinels"), storageString, siteSlotName, logger)); } else { return(new FileSystemSecretsRepository(webHostSettings.SecretsPath)); } }
public Fixture() { TestFunctionRoot = Path.Combine(TestHelpers.FunctionsTestDirectory, "Functions"); TestLogsRoot = Path.Combine(TestHelpers.FunctionsTestDirectory, "Logs"); TestSecretsRoot = Path.Combine(TestHelpers.FunctionsTestDirectory, "Secrets"); string testRoot = Path.Combine(TestFunctionRoot, Guid.NewGuid().ToString()); SecretsPath = Path.Combine(TestSecretsRoot, Guid.NewGuid().ToString()); Directory.CreateDirectory(SecretsPath); string logRoot = Path.Combine(TestLogsRoot, Guid.NewGuid().ToString(), @"Functions"); Directory.CreateDirectory(logRoot); FunctionsLogDir = Path.Combine(logRoot, @"Function"); Directory.CreateDirectory(FunctionsLogDir); // Add some secret files (both old and valid) File.Create(Path.Combine(SecretsPath, ScriptConstants.HostMetadataFileName)); File.Create(Path.Combine(SecretsPath, "WebHookTrigger.json")); File.Create(Path.Combine(SecretsPath, "QueueTriggerToBlob.json")); File.Create(Path.Combine(SecretsPath, "Foo.json")); File.Create(Path.Combine(SecretsPath, "Bar.json")); File.Create(Path.Combine(SecretsPath, "Invalid.json")); // Add some old file directories CreateTestFunctionLogs(FunctionsLogDir, "Foo"); CreateTestFunctionLogs(FunctionsLogDir, "Bar"); CreateTestFunctionLogs(FunctionsLogDir, "Baz"); CreateTestFunctionLogs(FunctionsLogDir, "Invalid"); ScriptHostConfiguration config = new ScriptHostConfiguration { RootScriptPath = @"TestScripts\Node", RootLogPath = logRoot, FileLoggingEnabled = true }; SecretManager secretManager = new SecretManager(SecretsPath); WebHostSettings webHostSettings = new WebHostSettings(); HostManager = new WebScriptHostManager(config, secretManager, webHostSettings); Task task = Task.Run(() => { HostManager.RunAndBlock(); }); TestHelpers.Await(() => { return(HostManager.IsRunning); }).GetAwaiter().GetResult(); }
public WebHostResolver(ScriptSettingsManager settingsManager, ISecretManagerFactory secretManagerFactory, IScriptEventManager eventManager, WebHostSettings settings, IWebJobsRouter router, ILoggerProviderFactory loggerProviderFactory, ILoggerFactory loggerFactory) { _settingsManager = settingsManager; _secretManagerFactory = secretManagerFactory; _eventManager = eventManager; _router = router; _settings = settings; // _loggerProviderFactory is used for creating the LoggerFactory for each ScriptHost _loggerProviderFactory = loggerProviderFactory; // _loggerFactory is used when there is no host available. _loggerFactory = loggerFactory; }
internal static ScriptHostConfiguration CreateScriptHostConfiguration(WebHostSettings settings) { InitializeFileSystem(settings.ScriptPath); var scriptHostConfig = new ScriptHostConfiguration() { RootScriptPath = settings.ScriptPath, RootLogPath = settings.LogPath, FileLoggingMode = FileLoggingMode.DebugOnly, TraceWriter = settings.TraceWriter, IsSelfHost = settings.IsSelfHost }; scriptHostConfig.HostConfig.HostId = Utility.GetDefaultHostId(_settingsManager, scriptHostConfig); return(scriptHostConfig); }
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings, IScriptHostFactory scriptHostFactory = null) : base(config, settingsManager, scriptHostFactory) { _config = config; _metricsLogger = new WebHostMetricsLogger(); _exceptionHandler = new WebScriptHostExceptionHandler(this); _webHostSettings = webHostSettings; var systemEventGenerator = config.HostConfig.GetService<IEventGenerator>() ?? new EventGenerator(); var systemTraceWriter = new SystemTraceWriter(systemEventGenerator, settingsManager, TraceLevel.Verbose); if (config.TraceWriter != null) { config.TraceWriter = new CompositeTraceWriter(new TraceWriter[] { config.TraceWriter, systemTraceWriter }); } else { config.TraceWriter = systemTraceWriter; } _secretManager = secretManagerFactory.Create(settingsManager, config.TraceWriter, webHostSettings.SecretsPath); }
public ControllerScenarioTestFixture() { _config = new HttpConfiguration(); _settingsManager = ScriptSettingsManager.Instance; HostSettings = new WebHostSettings { IsSelfHost = true, ScriptPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\sample"), LogPath = Path.Combine(Path.GetTempPath(), @"Functions"), SecretsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\src\WebJobs.Script.WebHost\App_Data\Secrets") }; WebApiConfig.Register(_config, _settingsManager, HostSettings, RegisterDependencies); HttpServer = new HttpServer(_config); this.HttpClient = new HttpClient(HttpServer); this.HttpClient.BaseAddress = new Uri("https://localhost/"); WaitForHost(); }
private void EnsureInitialized(WebHostSettings settings) { // standby mode can only change from true to false // When standby mode changes, we reset all instances var standbyMode = WebScriptHostManager.InStandbyMode; if (!standbyMode) { if (_activeHostManager == null) { if (_standbyHostManager != null) { // reintialize app settings if we were in standby ReinitializeAppSettings(); } _activeScriptHostConfig = GetScriptHostConfiguration(settings.ScriptPath, settings.LogPath); _activeHostManager = new WebScriptHostManager(_activeScriptHostConfig, _secretManagerFactory, _settingsManager, settings); _activeReceiverManager = new WebHookReceiverManager(_activeHostManager.SecretManager); _standbyHostManager?.Dispose(); _standbyReceiverManager?.Dispose(); _standbyScriptHostConfig = null; _standbyHostManager = null; _standbyReceiverManager = null; _settingsManager.Reset(); } } else { if (_standbyHostManager == null) { _standbyScriptHostConfig = GetScriptHostConfiguration(settings.ScriptPath, settings.LogPath); _standbyHostManager = new WebScriptHostManager(_standbyScriptHostConfig, _secretManagerFactory, _settingsManager, settings); _standbyReceiverManager = new WebHookReceiverManager(_standbyHostManager.SecretManager); } } }
public ISecretManager GetSecretManager(WebHostSettings settings) { return GetWebScriptHostManager(settings).SecretManager; }
public WebScriptHostManager(ScriptHostConfiguration config, ISecretManagerFactory secretManagerFactory, ScriptSettingsManager settingsManager, WebHostSettings webHostSettings) : this(config, secretManagerFactory, settingsManager, webHostSettings, new ScriptHostFactory()) { }
public static void WarmUp(WebHostSettings settings) { 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(ScriptSettingsManager.Instance, config); 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(); } }
internal async Task GeneratedMethods_WithOutParams_DoNotCauseDeadlocks(string fixture) { var traceWriter = new TestTraceWriter(TraceLevel.Verbose); ScriptHostConfiguration config = new ScriptHostConfiguration() { RootScriptPath = @"TestScripts\FunctionGeneration", TraceWriter = traceWriter }; string secretsPath = Path.Combine(Path.GetTempPath(), @"FunctionTests\Secrets"); WebHostSettings webHostSettings = new WebHostSettings(); var secretManager = new SecretManager(SettingsManager, secretsPath, NullTraceWriter.Instance); using (var manager = new WebScriptHostManager(config, new TestSecretManagerFactory(secretManager), SettingsManager, webHostSettings)) { Thread runLoopThread = new Thread(_ => { manager.RunAndBlock(CancellationToken.None); }); runLoopThread.IsBackground = true; runLoopThread.Start(); await TestHelpers.Await(() => { return manager.State == ScriptHostState.Running; }); var request = new HttpRequestMessage(HttpMethod.Get, String.Format("http://localhost/api/httptrigger-{0}", fixture)); FunctionDescriptor function = manager.GetHttpFunctionOrNull(request); SynchronizationContext currentContext = SynchronizationContext.Current; var resetEvent = new ManualResetEventSlim(); try { var requestThread = new Thread(() => { var context = new SingleThreadSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(context); manager.HandleRequestAsync(function, request, CancellationToken.None) .ContinueWith(task => resetEvent.Set()); Thread.Sleep(500); context.Run(); }); requestThread.IsBackground = true; requestThread.Start(); bool threadSignaled = resetEvent.Wait(TimeSpan.FromSeconds(10)); requestThread.Abort(); Assert.True(threadSignaled, "Thread execution did not complete"); } finally { SynchronizationContext.SetSynchronizationContext(currentContext); manager.Stop(); } } }
protected virtual void RegisterDependencies(ContainerBuilder builder, WebHostSettings settings) { }