public void ApplyConfiguration_Singleton() { JObject config = new JObject(); config["id"] = ID; JObject singleton = new JObject(); config["singleton"] = singleton; ScriptHostConfiguration scriptConfig = new ScriptHostConfiguration(); ScriptHost.ApplyConfiguration(config, scriptConfig); Assert.Equal(ID, scriptConfig.HostConfig.HostId); Assert.Equal(15, scriptConfig.HostConfig.Singleton.LockPeriod.TotalSeconds); Assert.Equal(1, scriptConfig.HostConfig.Singleton.ListenerLockPeriod.TotalMinutes); Assert.Equal(1, scriptConfig.HostConfig.Singleton.ListenerLockRecoveryPollingInterval.TotalMinutes); Assert.Equal(TimeSpan.MaxValue, scriptConfig.HostConfig.Singleton.LockAcquisitionTimeout); Assert.Equal(5, scriptConfig.HostConfig.Singleton.LockAcquisitionPollingInterval.TotalSeconds); singleton["lockPeriod"] = "00:00:17"; singleton["listenerLockPeriod"] = "00:00:22"; singleton["listenerLockRecoveryPollingInterval"] = "00:00:33"; singleton["lockAcquisitionTimeout"] = "00:05:00"; singleton["lockAcquisitionPollingInterval"] = "00:00:08"; ScriptHost.ApplyConfiguration(config, scriptConfig); Assert.Equal(17, scriptConfig.HostConfig.Singleton.LockPeriod.TotalSeconds); Assert.Equal(22, scriptConfig.HostConfig.Singleton.ListenerLockPeriod.TotalSeconds); Assert.Equal(33, scriptConfig.HostConfig.Singleton.ListenerLockRecoveryPollingInterval.TotalSeconds); Assert.Equal(5, scriptConfig.HostConfig.Singleton.LockAcquisitionTimeout.TotalMinutes); Assert.Equal(8, scriptConfig.HostConfig.Singleton.LockAcquisitionPollingInterval.TotalSeconds); }
public void ApplyConfiguration_Queues() { JObject config = new JObject(); config["id"] = ID; JObject queuesConfig = new JObject(); config["queues"] = queuesConfig; ScriptHostConfiguration scriptConfig = new ScriptHostConfiguration(); ScriptHost.ApplyConfiguration(config, scriptConfig); Assert.Equal(ID, scriptConfig.HostConfig.HostId); Assert.Equal(60 * 1000, scriptConfig.HostConfig.Queues.MaxPollingInterval.TotalMilliseconds); Assert.Equal(16, scriptConfig.HostConfig.Queues.BatchSize); Assert.Equal(5, scriptConfig.HostConfig.Queues.MaxDequeueCount); Assert.Equal(8, scriptConfig.HostConfig.Queues.NewBatchThreshold); queuesConfig["maxPollingInterval"] = 5000; queuesConfig["batchSize"] = 17; queuesConfig["maxDequeueCount"] = 3; queuesConfig["newBatchThreshold"] = 123; ScriptHost.ApplyConfiguration(config, scriptConfig); Assert.Equal(5000, scriptConfig.HostConfig.Queues.MaxPollingInterval.TotalMilliseconds); Assert.Equal(17, scriptConfig.HostConfig.Queues.BatchSize); Assert.Equal(3, scriptConfig.HostConfig.Queues.MaxDequeueCount); Assert.Equal(123, scriptConfig.HostConfig.Queues.NewBatchThreshold); }
protected EndToEndTestFixture(string rootPath) { string connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString); _queueClient = storageAccount.CreateCloudQueueClient(); _blobClient = storageAccount.CreateCloudBlobClient(); CreateTestStorageEntities(); TraceWriter = new TestTraceWriter(TraceLevel.Verbose); ScriptHostConfiguration config = new ScriptHostConfiguration() { RootScriptPath = rootPath, TraceWriter = TraceWriter, FileLoggingEnabled = true }; HostManager = new ScriptHostManager(config); Thread t = new Thread(_ => { HostManager.RunAndBlock(); }); t.Start(); TestHelpers.Await(() => HostManager.IsRunning).Wait(); }
protected ScriptHost(ScriptHostConfiguration scriptConfig) : base(scriptConfig.HostConfig) { ScriptConfig = scriptConfig; FunctionErrors = new Dictionary<string, Collection<string>>(StringComparer.OrdinalIgnoreCase); NodeFunctionInvoker.UnhandledException += OnUnhandledException; }
public static CSharpScriptHost Create(ScriptHostConfiguration scriptConfig) { JobHostConfiguration config = new JobHostConfiguration(); CSharpScriptHost scriptHost = new CSharpScriptHost(config, scriptConfig); scriptHost.Initialize(); return scriptHost; }
protected ScriptHost(ScriptHostConfiguration scriptConfig) : base(scriptConfig.HostConfig) { ScriptConfig = scriptConfig; if (scriptConfig.FileLoggingEnabled) { string hostLogFilePath = Path.Combine(scriptConfig.RootLogPath, "Host"); _traceWriter = new FileTraceWriter(hostLogFilePath, TraceLevel.Verbose); scriptConfig.HostConfig.Tracing.Tracers.Add(_traceWriter); } else { _traceWriter = NullTraceWriter.Instance; } if (scriptConfig.TraceWriter != null) { scriptConfig.HostConfig.Tracing.Tracers.Add(scriptConfig.TraceWriter); } else { scriptConfig.TraceWriter = NullTraceWriter.Instance; } if (scriptConfig.FileWatchingEnabled) { _fileWatcher = new FileSystemWatcher(scriptConfig.RootScriptPath) { IncludeSubdirectories = true, EnableRaisingEvents = true }; _fileWatcher.Changed += OnFileChanged; _fileWatcher.Created += OnFileChanged; _fileWatcher.Deleted += OnFileChanged; _fileWatcher.Renamed += OnFileChanged; } // 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 = (e) => { _traceWriter.Verbose(string.Format("File change of type '{0}' detected for '{1}'", e.ChangeType, e.FullPath)); _traceWriter.Verbose("Host configuration has changed. Signaling restart."); // signal host restart _restartEvent.Set(); }; _restart = _restart.Debounce(500); // take a snapshot so we can detect function additions/removals _directoryCountSnapshot = Directory.EnumerateDirectories(ScriptConfig.RootScriptPath).Count(); }
static void Main(string[] args) { ScriptHostConfiguration config = new ScriptHostConfiguration() { RootPath = args[0] }; ScriptHost host = ScriptHost.Create(config); host.RunAndBlock(); }
public void ApplyConfiguration_TopLevel() { JObject config = new JObject(); config["id"] = ID; ScriptHostConfiguration scriptConfig = new ScriptHostConfiguration(); ScriptHost.ApplyConfiguration(config, scriptConfig); Assert.Equal(ID, scriptConfig.HostConfig.HostId); }
public static void Main(string[] args) { ScriptHostConfiguration config = new ScriptHostConfiguration() { ApplicationRootPath = Directory.GetCurrentDirectory(), HostAssembly = Assembly.GetExecutingAssembly() }; ScriptHost host = CSharpScriptHost.Create(config); host.RunAndBlock(); }
protected virtual void OnInitializeConfig(ScriptHostConfiguration config) { var loggingConnectionString = config.HostConfig.DashboardConnectionString; if (string.IsNullOrEmpty(loggingConnectionString)) { // if no Dashboard connection string is provided, set this to null // to prevent host startup failure config.HostConfig.DashboardConnectionString = null; } }
static void Main(string[] args) { ScriptHostConfiguration config = new ScriptHostConfiguration() { ApplicationRootPath = Environment.CurrentDirectory, HostAssembly = Assembly.GetExecutingAssembly() }; ScriptHost host = NodeScriptHost.Create(config); host.RunAndBlock(); }
public ScriptHostManager(ScriptHostConfiguration config, IScriptEventManager eventManager = null, IScriptHostEnvironment environment = null) : this(config, ScriptSettingsManager.Instance, new ScriptHostFactory(), eventManager, environment) { if (config.FileWatchingEnabled) { // We only setup a subscription here as the actual ScriptHost will create the publisher // when initialized. _fileEventSubscription = EventManager.OfType <FileEvent>() .Where(f => string.Equals(f.Source, EventSources.ScriptFiles, StringComparison.Ordinal)) .Subscribe(e => OnScriptFileChanged(null, e.FileChangeArguments)); } }
public ScriptHostManager(ScriptHostConfiguration config, ScriptSettingsManager settingsManager, IScriptHostFactory scriptHostFactory, IScriptEventManager eventManager = null, IScriptHostEnvironment environment = null) { _environment = environment ?? this; _config = config; _settingsManager = settingsManager; _scriptHostFactory = scriptHostFactory; EventManager = eventManager ?? new ScriptEventManager(); }
public static Manifest Read(ScriptHostConfiguration config, IEnumerable<FunctionDescriptorProvider> descriptionProviders) { string manifestFilePath = Path.Combine(config.ApplicationRootPath, @"scripts\manifest.json"); Console.WriteLine(string.Format("Reading job manifest file '{0}'", manifestFilePath)); string json = File.ReadAllText(manifestFilePath); JObject manifest = JObject.Parse(json); return new Manifest { Functions = ReadFunctions(manifest, descriptionProviders), Configuration = (JObject)manifest["config"] }; }
protected EndToEndTestFixture(string rootPath) { CreateTestStorageEntities(); TraceWriter = new TestTraceWriter(TraceLevel.Verbose); ScriptHostConfiguration config = new ScriptHostConfiguration() { RootScriptPath = rootPath, TraceWriter = TraceWriter }; Host = ScriptHost.Create(config); Host.Start(); }
internal static bool ConsoleLoggingEnabled(ScriptHostConfiguration config, ScriptSettingsManager settingsManager) { // console logging defaults to false, except for self host bool enableConsole = config.IsSelfHost; string configValue = settingsManager.Configuration.GetSection(ScriptConstants.ConsoleLoggingMode).Value; if (!string.IsNullOrEmpty(configValue)) { // if it has been explicitly configured that value overrides default enableConsole = string.Compare(configValue, "always", StringComparison.OrdinalIgnoreCase) == 0 ? true : false; } return(enableConsole); }
public ScriptHostManager(ScriptHostConfiguration config, ScriptSettingsManager settingsManager, IScriptHostFactory scriptHostFactory, IScriptEventManager eventManager = null, IScriptHostEnvironment environment = null) { _environment = environment ?? this; _config = config; _settingsManager = settingsManager; _scriptHostFactory = scriptHostFactory; EventManager = eventManager ?? new ScriptEventManager(); _structuredLogWriter = new StructuredLogWriter(EventManager, config.RootLogPath); }
static void Main(string[] args) { string rootPath = Environment.CurrentDirectory; if (args.Length > 0) { rootPath = (string)args[0]; } ScriptHostConfiguration config = new ScriptHostConfiguration() { RootPath = rootPath }; ScriptHost host = ScriptHost.Create(config); host.RunAndBlock(); }
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(); } WebScriptHostManager scriptHostManager = new WebScriptHostManager(scriptHostConfig); builder.RegisterInstance<WebScriptHostManager>(scriptHostManager); 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); WebHookReceiverManager webHookReceiverManager = new WebHookReceiverManager(secretManager); builder.RegisterInstance<WebHookReceiverManager>(webHookReceiverManager); if (!settings.IsSelfHost) { HostingEnvironment.QueueBackgroundWorkItem((ct) => scriptHostManager.RunAndBlock(ct)); } else { Task.Run(() => scriptHostManager.RunAndBlock()); } }
public static ScriptHost Create(ScriptHostConfiguration scriptConfig = null) { if (scriptConfig == null) { scriptConfig = new ScriptHostConfiguration(); } if (!Path.IsPathRooted(scriptConfig.RootScriptPath)) { scriptConfig.RootScriptPath = Path.Combine(Environment.CurrentDirectory, scriptConfig.RootScriptPath); } ScriptHost scriptHost = new ScriptHost(scriptConfig); scriptHost.Initialize(); return(scriptHost); }
public ScriptHostManager(ScriptHostConfiguration config, ScriptSettingsManager settingsManager, IScriptHostFactory scriptHostFactory, IScriptEventManager eventManager = null, IScriptHostEnvironment environment = null, ILoggerProviderFactory loggerProviderFactory = null, HostPerformanceManager hostPerformanceManager = null) { if (config == null) { throw new ArgumentNullException(nameof(config)); } if (settingsManager == null) { throw new ArgumentNullException(nameof(settingsManager)); } scriptHostFactory = scriptHostFactory ?? new ScriptHostFactory(); _environment = environment ?? this; _config = config; _settingsManager = settingsManager; _scriptHostFactory = scriptHostFactory; _loggerProviderFactory = loggerProviderFactory; EventManager = eventManager ?? new ScriptEventManager(); _structuredLogWriter = new StructuredLogWriter(EventManager, config.RootLogPath); _performanceManager = hostPerformanceManager ?? new HostPerformanceManager(settingsManager, _config.HostHealthMonitor); if (config.FileWatchingEnabled && !settingsManager.FileSystemIsReadOnly) { // We only setup a subscription here as the actual ScriptHost will create the publisher // when initialized. _fileEventSubscription = EventManager.OfType <FileEvent>() .Where(f => string.Equals(f.Source, EventSources.ScriptFiles, StringComparison.Ordinal)) .Subscribe(e => OnScriptFileChanged(null, e.FileChangeArguments)); } if (ShouldMonitorHostHealth) { _healthCheckWindow = new SlidingWindow <bool>(_config.HostHealthMonitor.HealthCheckWindow); _hostHealthCheckTimer = new Timer(OnHostHealthCheckTimer, null, TimeSpan.Zero, _config.HostHealthMonitor.HealthCheckInterval); } }
/// <summary> /// Adds additional <see cref="ILoggerProvider"/>s to the <see cref="ILoggerFactory"/>. /// </summary> /// <param name="factory">The <see cref="ILoggerFactory"/>.</param> /// <param name="scriptConfig">The configuration.</param> public virtual void AddLoggerProviders(ILoggerFactory factory, ScriptHostConfiguration scriptConfig, ScriptSettingsManager settingsManager) { IMetricsLogger metricsLogger = scriptConfig.HostConfig.GetService <IMetricsLogger>(); // Automatically register App Insights if the key is present if (!string.IsNullOrEmpty(settingsManager?.ApplicationInsightsInstrumentationKey)) { metricsLogger?.LogEvent(MetricEventNames.ApplicationInsightsEnabled); ITelemetryClientFactory clientFactory = scriptConfig.HostConfig.GetService <ITelemetryClientFactory>() ?? new ScriptTelemetryClientFactory(settingsManager.ApplicationInsightsInstrumentationKey, scriptConfig.ApplicationInsightsSamplingSettings, scriptConfig.LogFilter.Filter); scriptConfig.HostConfig.LoggerFactory.AddApplicationInsights(clientFactory); } else { metricsLogger?.LogEvent(MetricEventNames.ApplicationInsightsDisabled); } }
private static Collection <ScriptBindingProvider> LoadBindingProviders(ScriptHostConfiguration config, JObject hostMetadata, TraceWriter traceWriter) { JobHostConfiguration hostConfig = config.HostConfig; // Register our built in extensions var bindingProviderTypes = new Collection <Type>() { // binding providers defined in this assembly typeof(WebJobsCoreScriptBindingProvider), typeof(ServiceBusScriptBindingProvider), // binding providers defined in known extension assemblies typeof(CoreExtensionsScriptBindingProvider), typeof(ApiHubScriptBindingProvider), typeof(DocumentDBScriptBindingProvider), typeof(MobileAppsScriptBindingProvider), typeof(NotificationHubScriptBindingProvider), typeof(SendGridScriptBindingProvider), typeof(TwilioScriptBindingProvider), typeof(BotFrameworkScriptBindingProvider) }; // Create the binding providers var bindingProviders = new Collection <ScriptBindingProvider>(); foreach (var bindingProviderType in bindingProviderTypes) { try { var provider = (ScriptBindingProvider)Activator.CreateInstance(bindingProviderType, new object[] { hostConfig, hostMetadata, traceWriter }); bindingProviders.Add(provider); } catch (Exception ex) { // If we're unable to load create a binding provider for any reason, log // the error and continue traceWriter.Error(string.Format("Unable to create binding provider '{0}'", bindingProviderType.FullName), ex); } } return(bindingProviders); }
public static void Main(string[] args) { if (args == null) { throw new ArgumentNullException("args"); } string rootPath = Environment.CurrentDirectory; if (args.Length > 0) { rootPath = (string)args[0]; } ScriptHostConfiguration config = new ScriptHostConfiguration() { RootScriptPath = rootPath }; ScriptHostManager scriptHostManager = new ScriptHostManager(config); scriptHostManager.RunAndBlock(); }
public static ScriptHost Create(ScriptHostConfiguration scriptConfig = null) { if (scriptConfig == null) { scriptConfig = new ScriptHostConfiguration() { RootPath = Environment.CurrentDirectory }; } if (!Path.IsPathRooted(scriptConfig.RootPath)) { scriptConfig.RootPath = Path.Combine(Environment.CurrentDirectory, scriptConfig.RootPath); } JobHostConfiguration config = new JobHostConfiguration(); ScriptHost scriptHost = new ScriptHost(config, scriptConfig); scriptHost.Initialize(); return scriptHost; }
internal static void Initialize(ContainerBuilder builder) { string logFilePath; string scriptRootPath; string secretsPath; string home = Environment.GetEnvironmentVariable("HOME"); bool isLocal = string.IsNullOrEmpty(home); if (isLocal) { // we're running locally scriptRootPath = Path.Combine(HostingEnvironment.ApplicationPhysicalPath, @"..\..\sample"); logFilePath = Path.Combine(Path.GetTempPath(), @"Functions"); secretsPath = HttpContext.Current.Server.MapPath("~/App_Data/Secrets"); } else { // we're running in Azure scriptRootPath = Path.Combine(home, @"site\wwwroot"); logFilePath = Path.Combine(home, @"LogFiles\Application\Functions"); secretsPath = Path.Combine(home, @"data\Functions\secrets"); } ScriptHostConfiguration scriptHostConfig = new ScriptHostConfiguration() { RootScriptPath = scriptRootPath, RootLogPath = logFilePath, FileLoggingEnabled = true }; WebScriptHostManager scriptHostManager = new WebScriptHostManager(scriptHostConfig); builder.RegisterInstance<WebScriptHostManager>(scriptHostManager); SecretManager secretManager = new SecretManager(secretsPath); builder.RegisterInstance<SecretManager>(secretManager); WebHookReceiverManager webHookRecieverManager = new WebHookReceiverManager(secretManager); builder.RegisterInstance<WebHookReceiverManager>(webHookRecieverManager); Task.Run(() => scriptHostManager.RunAndBlock(CancellationToken.None)); }
public ScriptHostManager(ScriptHostConfiguration config, ScriptSettingsManager settingsManager, IScriptHostFactory scriptHostFactory, IScriptEventManager eventManager = null, IScriptHostEnvironment environment = null, ILoggerFactoryBuilder loggerFactoryBuilder = null, HostPerformanceManager hostPerformanceManager = null) { if (config == null) { throw new ArgumentNullException(nameof(config)); } if (settingsManager == null) { throw new ArgumentNullException(nameof(settingsManager)); } scriptHostFactory = scriptHostFactory ?? new ScriptHostFactory(); _environment = environment ?? this; _config = config; _settingsManager = settingsManager; _scriptHostFactory = scriptHostFactory; _loggerFactoryBuilder = loggerFactoryBuilder; EventManager = eventManager ?? new ScriptEventManager(); _structuredLogWriter = new StructuredLogWriter(EventManager, config.RootLogPath); _performanceManager = hostPerformanceManager ?? new HostPerformanceManager(settingsManager); // TEMP : temporarily disabling this until the feature is improved bool periodicHealthCheckEnabled = false; if (periodicHealthCheckEnabled && config.HostHealthMonitorEnabled && settingsManager.IsAzureEnvironment) { _hostHealthCheckTimer = new Timer(OnHostHealthCheckTimer, null, TimeSpan.Zero, hostHealthCheckInterval); } }
public void RunAndBlock_DisposesOfHost_WhenExceptionIsThrown() { ScriptHostConfiguration config = new ScriptHostConfiguration() { RootScriptPath = Environment.CurrentDirectory, TraceWriter = NullTraceWriter.Instance }; var hostMock = new Mock<TestScriptHost>(config); var factoryMock = new Mock<IScriptHostFactory>(); factoryMock.Setup(f => f.Create(It.IsAny<ScriptHostConfiguration>())) .Returns(hostMock.Object); var target = new Mock<ScriptHostManager>(config, factoryMock.Object); target.Protected().Setup("OnHostStarted") .Throws(new Exception()); hostMock.Protected().Setup("Dispose", true) .Callback(() => target.Object.Stop()); Task.Run(() => target.Object.RunAndBlock()).Wait(5000); hostMock.Protected().Verify("Dispose", Times.Once(), true); }
internal static Collection<FunctionDescriptor> ReadFunctions(ScriptHostConfiguration config, IEnumerable<FunctionDescriptorProvider> descriptionProviders) { string scriptRootPath = config.RootPath; List<FunctionFolderInfo> functionFolderInfos = new List<FunctionFolderInfo>(); foreach (var scriptDir in Directory.EnumerateDirectories(scriptRootPath)) { FunctionFolderInfo functionInfo = new FunctionFolderInfo(); // read the function config string functionConfigPath = Path.Combine(scriptDir, "function.json"); if (!File.Exists(functionConfigPath)) { // not a function directory continue; } string json = File.ReadAllText(functionConfigPath); functionInfo.Configuration = JObject.Parse(json); // unless the name is explicitly set in the config, // default it to the function folder name string name = (string)functionInfo.Configuration["name"]; if (string.IsNullOrEmpty(name)) { functionInfo.Name = Path.GetFileNameWithoutExtension(scriptDir); } // determine the primary script string[] functionFiles = Directory.EnumerateFiles(scriptDir).Where(p => Path.GetFileName(p).ToLowerInvariant() != "function.json").ToArray(); if (functionFiles.Length == 0) { continue; } else if (functionFiles.Length == 1) { // if there is only a single file, that file is primary functionInfo.Source = functionFiles[0]; } else { // if there is a "run" file, that file is primary string functionPrimary = null; functionPrimary = functionFiles.FirstOrDefault(p => Path.GetFileNameWithoutExtension(p).ToLowerInvariant() == "run"); if (string.IsNullOrEmpty(functionPrimary)) { // for Node, any index.js file is primary functionPrimary = functionFiles.FirstOrDefault(p => Path.GetFileName(p).ToLowerInvariant() == "index.js"); if (string.IsNullOrEmpty(functionPrimary)) { // finally, if there is an explicit primary file indicated // in config, use it JToken token = functionInfo.Configuration["source"]; if (token != null) { string sourceFileName = (string)token; functionPrimary = Path.Combine(scriptDir, sourceFileName); } } } if (string.IsNullOrEmpty(functionPrimary)) { // TODO: should this be an error? continue; } functionInfo.Source = functionPrimary; } functionFolderInfos.Add(functionInfo); } var functions = ReadFunctions(functionFolderInfos, descriptionProviders); return functions; }
internal static void ApplyConfiguration(JObject config, ScriptHostConfiguration scriptConfig) { JobHostConfiguration hostConfig = scriptConfig.HostConfig; JArray functions = (JArray)config["functions"]; if (functions != null && functions.Count > 0) { scriptConfig.Functions = new Collection<string>(); foreach (var function in functions) { scriptConfig.Functions.Add((string)function); } } // We may already have a host id, but the one from the JSON takes precedence JToken hostId = (JToken)config["id"]; if (hostId != null) { hostConfig.HostId = (string)hostId; } else if (hostConfig.HostId == null) { throw new InvalidOperationException("An 'id' must be specified in the host configuration."); } JToken watchFiles = (JToken)config["watchFiles"]; if (watchFiles != null && watchFiles.Type == JTokenType.Boolean) { scriptConfig.FileWatchingEnabled = (bool)watchFiles; } // Apply Queues configuration JObject configSection = (JObject)config["queues"]; JToken value = null; if (configSection != null) { if (configSection.TryGetValue("maxPollingInterval", out value)) { hostConfig.Queues.MaxPollingInterval = TimeSpan.FromMilliseconds((int)value); } if (configSection.TryGetValue("batchSize", out value)) { hostConfig.Queues.BatchSize = (int)value; } if (configSection.TryGetValue("maxDequeueCount", out value)) { hostConfig.Queues.MaxDequeueCount = (int)value; } if (configSection.TryGetValue("newBatchThreshold", out value)) { hostConfig.Queues.NewBatchThreshold = (int)value; } } // Apply Singleton configuration configSection = (JObject)config["singleton"]; value = null; if (configSection != null) { if (configSection.TryGetValue("lockPeriod", out value)) { hostConfig.Singleton.LockPeriod = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("listenerLockPeriod", out value)) { hostConfig.Singleton.ListenerLockPeriod = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("listenerLockRecoveryPollingInterval", out value)) { hostConfig.Singleton.ListenerLockRecoveryPollingInterval = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("lockAcquisitionTimeout", out value)) { hostConfig.Singleton.LockAcquisitionTimeout = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("lockAcquisitionPollingInterval", out value)) { hostConfig.Singleton.LockAcquisitionPollingInterval = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } } // Apply ServiceBus configuration ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration(); configSection = (JObject)config["serviceBus"]; value = null; if (configSection != null) { if (configSection.TryGetValue("maxConcurrentCalls", out value)) { serviceBusConfig.MessageOptions.MaxConcurrentCalls = (int)value; } } hostConfig.UseServiceBus(serviceBusConfig); // Apply Tracing/Logging configuration configSection = (JObject)config["tracing"]; if (configSection != null) { if (configSection.TryGetValue("consoleLevel", out value)) { TraceLevel consoleLevel; if (Enum.TryParse<TraceLevel>((string)value, true, out consoleLevel)) { hostConfig.Tracing.ConsoleLevel = consoleLevel; } } if (configSection.TryGetValue("fileLoggingEnabled", out value)) { scriptConfig.FileLoggingEnabled = (bool)value; } } hostConfig.UseTimers(); hostConfig.UseCore(); }
internal static Collection <FunctionDescriptor> ReadFunctions(ScriptHostConfiguration config, IEnumerable <FunctionDescriptorProvider> descriptionProviders) { string scriptRootPath = config.RootScriptPath; List <FunctionMetadata> metadatas = new List <FunctionMetadata>(); foreach (var scriptDir in Directory.EnumerateDirectories(scriptRootPath)) { // read the function config string functionConfigPath = Path.Combine(scriptDir, "function.json"); if (!File.Exists(functionConfigPath)) { // not a function directory continue; } string json = File.ReadAllText(functionConfigPath); JObject jObject = JObject.Parse(json); FunctionMetadata metadata = null; // unless the name is explicitly set in the config, // default it to the function folder name string name = (string)jObject["name"]; if (string.IsNullOrEmpty(name)) { name = Path.GetFileNameWithoutExtension(scriptDir); } if (!TryParseFunctionMetadata(name, jObject, out metadata)) { // TODO: Handle error continue; } // determine the primary script string[] functionFiles = Directory.EnumerateFiles(scriptDir).Where(p => Path.GetFileName(p).ToLowerInvariant() != "function.json").ToArray(); if (functionFiles.Length == 0) { continue; } else if (functionFiles.Length == 1) { // if there is only a single file, that file is primary metadata.Source = functionFiles[0]; } else { // if there is a "run" file, that file is primary string functionPrimary = null; functionPrimary = functionFiles.FirstOrDefault(p => Path.GetFileNameWithoutExtension(p).ToLowerInvariant() == "run"); if (string.IsNullOrEmpty(functionPrimary)) { // for Node, any index.js file is primary functionPrimary = functionFiles.FirstOrDefault(p => Path.GetFileName(p).ToLowerInvariant() == "index.js"); if (string.IsNullOrEmpty(functionPrimary)) { // finally, if there is an explicit primary file indicated // in config, use it JToken token = jObject["source"]; if (token != null) { string sourceFileName = (string)token; functionPrimary = Path.Combine(scriptDir, sourceFileName); } } } if (string.IsNullOrEmpty(functionPrimary)) { // TODO: should this be an error? continue; } metadata.Source = functionPrimary; } metadatas.Add(metadata); } var functions = ReadFunctions(metadatas, descriptionProviders); return(functions); }
public ScriptHostManager(ScriptHostConfiguration config, ScriptSettingsManager settingsManager, IScriptHostFactory scriptHostFactory) { _config = config; _settingsManager = settingsManager; _scriptHostFactory = scriptHostFactory; }
protected virtual void OnInitializeConfig(ScriptHostConfiguration config) { }
public ScriptHostManager(ScriptHostConfiguration config) { _config = config; }
public ScriptHostManager(ScriptHostConfiguration config, IScriptHostFactory scriptHostFactory) { _config = config; _scriptHostFactory = scriptHostFactory; }
public ScriptHostManager(ScriptHostConfiguration config) : this(config, new ScriptHostFactory()) { }
protected ScriptHost(JobHostConfiguration config, ScriptHostConfiguration scriptConfig) : base(config) { _jobHostConfig = config; _scriptHostConfig = scriptConfig; }
public ScriptHost Create(ScriptSettingsManager settingsManager, ScriptHostConfiguration config) { return ScriptHost.Create(settingsManager, config); }
public virtual IEnumerable <ILoggerProvider> CreateLoggerProviders(string hostInstanceId, ScriptHostConfiguration scriptConfig, ScriptSettingsManager settingsManager, Func <bool> isFileLoggingEnabled, Func <bool> isPrimary) { IList <ILoggerProvider> providers = new List <ILoggerProvider>(); IMetricsLogger metricsLogger = scriptConfig.HostConfig.GetService <IMetricsLogger>(); // Automatically register App Insights if the key is present if (!string.IsNullOrEmpty(settingsManager?.ApplicationInsightsInstrumentationKey)) { metricsLogger?.LogEvent(MetricEventNames.ApplicationInsightsEnabled); ITelemetryClientFactory clientFactory = scriptConfig.HostConfig.GetService <ITelemetryClientFactory>() ?? new ScriptTelemetryClientFactory(settingsManager.ApplicationInsightsInstrumentationKey, scriptConfig.ApplicationInsightsSamplingSettings, scriptConfig.LogFilter.Filter); providers.Add(new ApplicationInsightsLoggerProvider(clientFactory)); } else { metricsLogger?.LogEvent(MetricEventNames.ApplicationInsightsDisabled); } providers.Add(new FunctionFileLoggerProvider(hostInstanceId, scriptConfig.RootLogPath, isFileLoggingEnabled, isPrimary)); providers.Add(new HostFileLoggerProvider(hostInstanceId, scriptConfig.RootLogPath, isFileLoggingEnabled)); if (settingsManager.Configuration.GetSection("host:logger:consoleLoggingMode").Value == "always") { providers.Add(new ConsoleLoggerProvider(scriptConfig.LogFilter.Filter, includeScopes: true)); } return(providers); }
public ScriptHostManager(ScriptHostConfiguration config) : this(config, ScriptSettingsManager.Instance, new ScriptHostFactory()) { }
public ScriptHost Create(ScriptSettingsManager settingsManager, ScriptHostConfiguration config) { return(ScriptHost.Create(settingsManager, config)); }
public static ScriptHost Create(ScriptHostConfiguration scriptConfig = null) { if (scriptConfig == null) { scriptConfig = new ScriptHostConfiguration(); } if (!Path.IsPathRooted(scriptConfig.RootScriptPath)) { scriptConfig.RootScriptPath = Path.Combine(Environment.CurrentDirectory, scriptConfig.RootScriptPath); } ScriptHost scriptHost = new ScriptHost(scriptConfig); try { scriptHost.Initialize(); } catch (Exception ex) { if (scriptHost.TraceWriter != null) { scriptHost.TraceWriter.Error("ScriptHost initialization failed", ex); } throw; } return scriptHost; }
protected ScriptHost(ScriptHostConfiguration scriptConfig) : base(scriptConfig.HostConfig) { ScriptConfig = scriptConfig; FunctionErrors = new Dictionary <string, Collection <string> >(StringComparer.OrdinalIgnoreCase); }
private Collection<FunctionDescriptor> ReadFunctions(ScriptHostConfiguration config, IEnumerable<FunctionDescriptorProvider> descriptorProviders) { string scriptRootPath = config.RootScriptPath; List<FunctionMetadata> metadatas = new List<FunctionMetadata>(); foreach (var scriptDir in Directory.EnumerateDirectories(scriptRootPath)) { string functionName = null; try { // read the function config string functionConfigPath = Path.Combine(scriptDir, ScriptConstants.FunctionConfigFileName); if (!File.Exists(functionConfigPath)) { // not a function directory continue; } functionName = Path.GetFileNameWithoutExtension(scriptDir); if (ScriptConfig.Functions != null && !ScriptConfig.Functions.Contains(functionName, StringComparer.OrdinalIgnoreCase)) { // a functions filter has been specified and the current function is // not in the filter list continue; } // TODO: we need to define a json schema document and do // schema validation string json = File.ReadAllText(functionConfigPath); JObject configMetadata = JObject.Parse(json); FunctionMetadata metadata = ParseFunctionMetadata(functionName, config.HostConfig.NameResolver, configMetadata); // determine the primary script string[] functionFiles = Directory.EnumerateFiles(scriptDir).Where(p => Path.GetFileName(p).ToLowerInvariant() != ScriptConstants.FunctionConfigFileName).ToArray(); if (functionFiles.Length == 0) { AddFunctionError(functionName, "No function script files present."); continue; } else if (functionFiles.Length == 1) { // if there is only a single file, that file is primary metadata.Source = functionFiles[0]; } else { // if there is a "run" file, that file is primary string functionPrimary = null; functionPrimary = functionFiles.FirstOrDefault(p => Path.GetFileNameWithoutExtension(p).ToLowerInvariant() == "run"); if (string.IsNullOrEmpty(functionPrimary)) { // for Node, any index.js file is primary functionPrimary = functionFiles.FirstOrDefault(p => Path.GetFileName(p).ToLowerInvariant() == "index.js"); if (string.IsNullOrEmpty(functionPrimary)) { // finally, if there is an explicit primary file indicated // in config, use it JToken token = configMetadata["source"]; if (token != null) { string sourceFileName = (string)token; functionPrimary = Path.Combine(scriptDir, sourceFileName); } } } if (string.IsNullOrEmpty(functionPrimary)) { AddFunctionError(functionName, "Unable to determine primary function script."); continue; } metadata.Source = functionPrimary; } metadata.ScriptType = ParseScriptType(metadata.Source); metadatas.Add(metadata); } catch (Exception ex) { // log any unhandled exceptions and continue AddFunctionError(functionName, ex.Message); } } return ReadFunctions(metadatas, descriptorProviders); }
internal static void ApplyConfiguration(JObject config, ScriptHostConfiguration scriptConfig) { JobHostConfiguration hostConfig = scriptConfig.HostConfig; JArray functions = (JArray)config["functions"]; if (functions != null && functions.Count > 0) { scriptConfig.Functions = new Collection <string>(); foreach (var function in functions) { scriptConfig.Functions.Add((string)function); } } // We may already have a host id, but the one from the JSON takes precedence JToken hostId = (JToken)config["id"]; if (hostId != null) { hostConfig.HostId = (string)hostId; } else if (hostConfig.HostId == null) { throw new InvalidOperationException("An 'id' must be specified in the host configuration."); } JToken watchFiles = (JToken)config["watchFiles"]; if (watchFiles != null && watchFiles.Type == JTokenType.Boolean) { scriptConfig.FileWatchingEnabled = (bool)watchFiles; } // Apply Queues configuration JObject configSection = (JObject)config["queues"]; JToken value = null; if (configSection != null) { if (configSection.TryGetValue("maxPollingInterval", out value)) { hostConfig.Queues.MaxPollingInterval = TimeSpan.FromMilliseconds((int)value); } if (configSection.TryGetValue("batchSize", out value)) { hostConfig.Queues.BatchSize = (int)value; } if (configSection.TryGetValue("maxDequeueCount", out value)) { hostConfig.Queues.MaxDequeueCount = (int)value; } if (configSection.TryGetValue("newBatchThreshold", out value)) { hostConfig.Queues.NewBatchThreshold = (int)value; } } // Apply Singleton configuration configSection = (JObject)config["singleton"]; value = null; if (configSection != null) { if (configSection.TryGetValue("lockPeriod", out value)) { hostConfig.Singleton.LockPeriod = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("listenerLockPeriod", out value)) { hostConfig.Singleton.ListenerLockPeriod = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("listenerLockRecoveryPollingInterval", out value)) { hostConfig.Singleton.ListenerLockRecoveryPollingInterval = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("lockAcquisitionTimeout", out value)) { hostConfig.Singleton.LockAcquisitionTimeout = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("lockAcquisitionPollingInterval", out value)) { hostConfig.Singleton.LockAcquisitionPollingInterval = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } } // Apply ServiceBus configuration ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration(); configSection = (JObject)config["serviceBus"]; value = null; if (configSection != null) { if (configSection.TryGetValue("maxConcurrentCalls", out value)) { serviceBusConfig.MessageOptions.MaxConcurrentCalls = (int)value; } } hostConfig.UseServiceBus(serviceBusConfig); // Apply Tracing/Logging configuration configSection = (JObject)config["tracing"]; if (configSection != null) { if (configSection.TryGetValue("consoleLevel", out value)) { TraceLevel consoleLevel; if (Enum.TryParse <TraceLevel>((string)value, true, out consoleLevel)) { hostConfig.Tracing.ConsoleLevel = consoleLevel; } } if (configSection.TryGetValue("fileLoggingEnabled", out value)) { scriptConfig.FileLoggingEnabled = (bool)value; } } hostConfig.UseTimers(); hostConfig.UseCore(); }
public FunctionTraceWriterFactory(string functionName, ScriptHostConfiguration scriptHostConfig) { _functionName = functionName; _scriptHostConfig = scriptHostConfig; }
public ScriptHost Create(IScriptHostEnvironment environment, ScriptSettingsManager settingsManager, ScriptHostConfiguration config) { return(ScriptHost.Create(environment, config, settingsManager)); }
private Collection <FunctionDescriptor> ReadFunctions(ScriptHostConfiguration config, IEnumerable <FunctionDescriptorProvider> descriptorProviders) { string scriptRootPath = config.RootScriptPath; List <FunctionMetadata> metadatas = new List <FunctionMetadata>(); foreach (var scriptDir in Directory.EnumerateDirectories(scriptRootPath)) { string functionName = null; try { // read the function config string functionConfigPath = Path.Combine(scriptDir, ScriptConstants.FunctionMetadataFileName); if (!File.Exists(functionConfigPath)) { // not a function directory continue; } functionName = Path.GetFileNameWithoutExtension(scriptDir); if (ScriptConfig.Functions != null && !ScriptConfig.Functions.Contains(functionName, StringComparer.OrdinalIgnoreCase)) { // a functions filter has been specified and the current function is // not in the filter list continue; } ValidateFunctionName(functionName); // TODO: we need to define a json schema document and do // schema validation and give more informative responses string json = File.ReadAllText(functionConfigPath); JObject functionConfig = JObject.Parse(json); FunctionMetadata metadata = ParseFunctionMetadata(functionName, functionConfig); if (metadata.IsExcluded) { TraceWriter.Info(string.Format("Function '{0}' is marked as excluded", functionName)); continue; } if (metadata.IsDisabled) { TraceWriter.Info(string.Format("Function '{0}' is disabled", functionName)); } // determine the primary script string[] functionFiles = Directory.EnumerateFiles(scriptDir).Where(p => Path.GetFileName(p).ToLowerInvariant() != ScriptConstants.FunctionMetadataFileName).ToArray(); if (functionFiles.Length == 0) { AddFunctionError(functionName, "No function script files present."); continue; } string scriptFile = DeterminePrimaryScriptFile(functionConfig, functionFiles); if (string.IsNullOrEmpty(scriptFile)) { AddFunctionError(functionName, "Unable to determine the primary function script. Try renaming your entry point script to 'run' (or 'index' in the case of Node), " + "or alternatively you can specify the name of the entry point script explicitly by adding a 'scriptFile' property to your function metadata."); continue; } metadata.ScriptFile = scriptFile; // determine the script type based on the primary script file extension metadata.ScriptType = ParseScriptType(metadata.ScriptFile); metadata.EntryPoint = (string)functionConfig["entryPoint"]; metadatas.Add(metadata); } catch (Exception ex) { // log any unhandled exceptions and continue AddFunctionError(functionName, ex.Message); } } return(ReadFunctions(metadatas, descriptorProviders)); }
internal static void ApplyConfiguration(JObject config, ScriptHostConfiguration scriptConfig) { JobHostConfiguration hostConfig = scriptConfig.HostConfig; JToken hostId = (JToken)config["id"]; if (hostId == null) { throw new InvalidOperationException("An 'id' must be specified in the host configuration."); } hostConfig.HostId = (string)hostId; JToken watchFiles = (JToken)config["watchFiles"]; if (watchFiles != null && watchFiles.Type == JTokenType.Boolean) { scriptConfig.FileWatchingEnabled = (bool)watchFiles; } // Apply Queues configuration JObject configSection = (JObject)config["queues"]; JToken value = null; if (configSection != null) { if (configSection.TryGetValue("maxPollingInterval", out value)) { hostConfig.Queues.MaxPollingInterval = TimeSpan.FromMilliseconds((int)value); } if (configSection.TryGetValue("batchSize", out value)) { hostConfig.Queues.BatchSize = (int)value; } if (configSection.TryGetValue("maxDequeueCount", out value)) { hostConfig.Queues.MaxDequeueCount = (int)value; } if (configSection.TryGetValue("newBatchThreshold", out value)) { hostConfig.Queues.NewBatchThreshold = (int)value; } } // Apply Singleton configuration configSection = (JObject)config["singleton"]; value = null; if (configSection != null) { if (configSection.TryGetValue("lockPeriod", out value)) { hostConfig.Singleton.LockPeriod = TimeSpan.Parse((string)value); } if (configSection.TryGetValue("listenerLockPeriod", out value)) { hostConfig.Singleton.ListenerLockPeriod = TimeSpan.Parse((string)value); } if (configSection.TryGetValue("listenerLockRecoveryPollingInterval", out value)) { hostConfig.Singleton.ListenerLockRecoveryPollingInterval = TimeSpan.Parse((string)value); } if (configSection.TryGetValue("lockAcquisitionTimeout", out value)) { hostConfig.Singleton.LockAcquisitionTimeout = TimeSpan.Parse((string)value); } if (configSection.TryGetValue("lockAcquisitionPollingInterval", out value)) { hostConfig.Singleton.LockAcquisitionPollingInterval = TimeSpan.Parse((string)value); } } // Apply ServiceBus configuration ServiceBusConfiguration sbConfig = new ServiceBusConfiguration(); configSection = (JObject)config["serviceBus"]; value = null; if (configSection != null) { if (configSection.TryGetValue("maxConcurrentCalls", out value)) { sbConfig.MessageOptions.MaxConcurrentCalls = (int)value; } } hostConfig.UseServiceBus(sbConfig); // Apply Tracing configuration configSection = (JObject)config["tracing"]; if (configSection != null && configSection.TryGetValue("consoleLevel", out value)) { TraceLevel consoleLevel; if (Enum.TryParse <TraceLevel>((string)value, true, out consoleLevel)) { hostConfig.Tracing.ConsoleLevel = consoleLevel; } } hostConfig.UseTimers(); hostConfig.UseCore(); }
private Collection <FunctionDescriptor> ReadFunctions(ScriptHostConfiguration config, IEnumerable <FunctionDescriptorProvider> descriptorProviders) { string scriptRootPath = config.RootScriptPath; List <FunctionMetadata> metadatas = new List <FunctionMetadata>(); foreach (var scriptDir in Directory.EnumerateDirectories(scriptRootPath)) { string functionName = null; try { // read the function config string functionConfigPath = Path.Combine(scriptDir, FunctionConfigFileName); if (!File.Exists(functionConfigPath)) { // not a function directory continue; } functionName = Path.GetFileNameWithoutExtension(scriptDir); if (ScriptConfig.Functions != null && !ScriptConfig.Functions.Contains(functionName, StringComparer.OrdinalIgnoreCase)) { // a functions filter has been specified and the current function is // not in the filter list continue; } // TODO: we need to define a json schema document and do // schema validation string json = File.ReadAllText(functionConfigPath); JObject configMetadata = JObject.Parse(json); FunctionMetadata metadata = ParseFunctionMetadata(functionName, config.HostConfig.NameResolver, configMetadata); // determine the primary script string[] functionFiles = Directory.EnumerateFiles(scriptDir).Where(p => Path.GetFileName(p).ToLowerInvariant() != FunctionConfigFileName).ToArray(); if (functionFiles.Length == 0) { AddFunctionError(functionName, "No function script files present."); continue; } else if (functionFiles.Length == 1) { // if there is only a single file, that file is primary metadata.Source = functionFiles[0]; } else { // if there is a "run" file, that file is primary string functionPrimary = null; functionPrimary = functionFiles.FirstOrDefault(p => Path.GetFileNameWithoutExtension(p).ToLowerInvariant() == "run"); if (string.IsNullOrEmpty(functionPrimary)) { // for Node, any index.js file is primary functionPrimary = functionFiles.FirstOrDefault(p => Path.GetFileName(p).ToLowerInvariant() == "index.js"); if (string.IsNullOrEmpty(functionPrimary)) { // finally, if there is an explicit primary file indicated // in config, use it JToken token = configMetadata["source"]; if (token != null) { string sourceFileName = (string)token; functionPrimary = Path.Combine(scriptDir, sourceFileName); } } } if (string.IsNullOrEmpty(functionPrimary)) { AddFunctionError(functionName, "Unable to determine primary function script."); continue; } metadata.Source = functionPrimary; } metadata.ScriptType = ParseScriptType(metadata.Source); metadatas.Add(metadata); } catch (Exception ex) { // log any unhandled exceptions and continue AddFunctionError(functionName, ex.Message); } } return(ReadFunctions(metadatas, descriptorProviders)); }
internal static void ApplyConfiguration(JObject config, ScriptHostConfiguration scriptConfig) { JobHostConfiguration hostConfig = scriptConfig.HostConfig; JToken hostId = (JToken)config["id"]; if (hostId == null) { throw new InvalidOperationException("An 'id' must be specified in the host configuration."); } hostConfig.HostId = (string)hostId; JToken watchFiles = (JToken)config["watchFiles"]; if (watchFiles != null && watchFiles.Type == JTokenType.Boolean) { scriptConfig.FileWatchingEnabled = (bool)watchFiles; } // Apply Queues configuration JObject configSection = (JObject)config["queues"]; JToken value = null; if (configSection != null) { if (configSection.TryGetValue("maxPollingInterval", out value)) { hostConfig.Queues.MaxPollingInterval = TimeSpan.FromMilliseconds((int)value); } if (configSection.TryGetValue("batchSize", out value)) { hostConfig.Queues.BatchSize = (int)value; } if (configSection.TryGetValue("maxDequeueCount", out value)) { hostConfig.Queues.MaxDequeueCount = (int)value; } if (configSection.TryGetValue("newBatchThreshold", out value)) { hostConfig.Queues.NewBatchThreshold = (int)value; } } // Apply Singleton configuration configSection = (JObject)config["singleton"]; value = null; if (configSection != null) { if (configSection.TryGetValue("lockPeriod", out value)) { hostConfig.Singleton.LockPeriod = TimeSpan.Parse((string)value); } if (configSection.TryGetValue("listenerLockPeriod", out value)) { hostConfig.Singleton.ListenerLockPeriod = TimeSpan.Parse((string)value); } if (configSection.TryGetValue("listenerLockRecoveryPollingInterval", out value)) { hostConfig.Singleton.ListenerLockRecoveryPollingInterval = TimeSpan.Parse((string)value); } if (configSection.TryGetValue("lockAcquisitionTimeout", out value)) { hostConfig.Singleton.LockAcquisitionTimeout = TimeSpan.Parse((string)value); } if (configSection.TryGetValue("lockAcquisitionPollingInterval", out value)) { hostConfig.Singleton.LockAcquisitionPollingInterval = TimeSpan.Parse((string)value); } } // Apply ServiceBus configuration ServiceBusConfiguration sbConfig = new ServiceBusConfiguration(); configSection = (JObject)config["serviceBus"]; value = null; if (configSection != null) { if (configSection.TryGetValue("maxConcurrentCalls", out value)) { sbConfig.MessageOptions.MaxConcurrentCalls = (int)value; } } hostConfig.UseServiceBus(sbConfig); // Apply Tracing configuration configSection = (JObject)config["tracing"]; if (configSection != null && configSection.TryGetValue("consoleLevel", out value)) { TraceLevel consoleLevel; if (Enum.TryParse<TraceLevel>((string)value, true, out consoleLevel)) { hostConfig.Tracing.ConsoleLevel = consoleLevel; } } hostConfig.UseTimers(); hostConfig.UseCore(); }
internal static string GetDefaultHostId(ScriptSettingsManager settingsManager, ScriptHostConfiguration scriptConfig) { // We're setting the default here on the newly created configuration // If the user has explicitly set the HostID via host.json, it will overwrite // what we set here string hostId = null; if (scriptConfig.IsSelfHost) { // When running locally, derive a stable host ID from machine name // and root path. We use a hash rather than the path itself to ensure // IDs differ (due to truncation) between folders that may share the same // root path prefix. // Note that such an ID won't work in distributed scenarios, so should // only be used for local/CLI scenarios. string sanitizedMachineName = Environment.MachineName .Where(char.IsLetterOrDigit) .Aggregate(new StringBuilder(), (b, c) => b.Append(c)).ToString(); hostId = $"{sanitizedMachineName}-{Math.Abs(GetStableHash(scriptConfig.RootScriptPath))}"; } else if (!string.IsNullOrEmpty(settingsManager?.AzureWebsiteUniqueSlotName)) { // If running on Azure Web App, derive the host ID from unique site slot name hostId = settingsManager.AzureWebsiteUniqueSlotName; } if (!string.IsNullOrEmpty(hostId)) { if (hostId.Length > ScriptConstants.MaximumHostIdLength) { // Truncate to the max host name length if needed hostId = hostId.Substring(0, ScriptConstants.MaximumHostIdLength); } } // Lowercase and trim any trailing '-' as they can cause problems with queue names return(hostId?.ToLowerInvariant().TrimEnd('-')); }
public static ScriptHost Create(ScriptSettingsManager settingsManager = null, ScriptHostConfiguration scriptConfig = null) { if (scriptConfig == null) { scriptConfig = new ScriptHostConfiguration(); } _settingsManager = settingsManager; if (settingsManager == null) { _settingsManager = ScriptSettingsManager.Instance; } if (!Path.IsPathRooted(scriptConfig.RootScriptPath)) { scriptConfig.RootScriptPath = Path.Combine(Environment.CurrentDirectory, scriptConfig.RootScriptPath); } ScriptHost scriptHost = new ScriptHost(scriptConfig); try { scriptHost.Initialize(); } catch (Exception ex) { if (scriptHost.TraceWriter != null) { scriptHost.TraceWriter.Error("ScriptHost initialization failed", ex); } throw; } return(scriptHost); }
public FunctionTraceWriterFactory(ScriptHostConfiguration scriptHostConfig) { _scriptHostConfig = scriptHostConfig; }
internal static void ApplyConfiguration(JObject config, ScriptHostConfiguration scriptConfig) { JobHostConfiguration hostConfig = scriptConfig.HostConfig; JArray functions = (JArray)config["functions"]; if (functions != null && functions.Count > 0) { scriptConfig.Functions = new Collection <string>(); foreach (var function in functions) { scriptConfig.Functions.Add((string)function); } } // We may already have a host id, but the one from the JSON takes precedence JToken hostId = (JToken)config["id"]; if (hostId != null) { hostConfig.HostId = (string)hostId; } else if (hostConfig.HostId == null) { throw new InvalidOperationException("An 'id' must be specified in the host configuration."); } JToken fileWatchingEnabled = (JToken)config["fileWatchingEnabled"]; if (fileWatchingEnabled != null && fileWatchingEnabled.Type == JTokenType.Boolean) { scriptConfig.FileWatchingEnabled = (bool)fileWatchingEnabled; } // Configure the set of watched directories, adding the standard built in // set to any the user may have specified if (scriptConfig.WatchDirectories == null) { scriptConfig.WatchDirectories = new HashSet <string>(StringComparer.OrdinalIgnoreCase); } scriptConfig.WatchDirectories.Add("node_modules"); JToken watchDirectories = config["watchDirectories"]; if (watchDirectories != null && watchDirectories.Type == JTokenType.Array) { foreach (JToken directory in watchDirectories.Where(p => p.Type == JTokenType.String)) { scriptConfig.WatchDirectories.Add((string)directory); } } // Apply Singleton configuration JObject configSection = (JObject)config["singleton"]; JToken value = null; if (configSection != null) { if (configSection.TryGetValue("lockPeriod", out value)) { hostConfig.Singleton.LockPeriod = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("listenerLockPeriod", out value)) { hostConfig.Singleton.ListenerLockPeriod = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("listenerLockRecoveryPollingInterval", out value)) { hostConfig.Singleton.ListenerLockRecoveryPollingInterval = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("lockAcquisitionTimeout", out value)) { hostConfig.Singleton.LockAcquisitionTimeout = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } if (configSection.TryGetValue("lockAcquisitionPollingInterval", out value)) { hostConfig.Singleton.LockAcquisitionPollingInterval = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); } } // Apply Tracing/Logging configuration configSection = (JObject)config["tracing"]; if (configSection != null) { if (configSection.TryGetValue("consoleLevel", out value)) { TraceLevel consoleLevel; if (Enum.TryParse <TraceLevel>((string)value, true, out consoleLevel)) { hostConfig.Tracing.ConsoleLevel = consoleLevel; } } if (configSection.TryGetValue("fileLoggingMode", out value)) { FileLoggingMode fileLoggingMode; if (Enum.TryParse <FileLoggingMode>((string)value, true, out fileLoggingMode)) { scriptConfig.FileLoggingMode = fileLoggingMode; } } } // apply http configuration configuration configSection = (JObject)config["http"]; string routePrefix = ScriptConstants.DefaultHttpRoutePrefix; if (configSection != null) { if (configSection.TryGetValue("routePrefix", out value)) { routePrefix = (string)value; } } scriptConfig.HttpRoutePrefix = routePrefix; if (config.TryGetValue("functionTimeout", out value)) { TimeSpan requestedTimeout = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture); // Only apply limits if this is Dynamic. if (IsDynamicSku() && (requestedTimeout < MinTimeout || requestedTimeout > MaxTimeout)) { string message = $"{nameof(scriptConfig.FunctionTimeout)} must be between {MinTimeout} and {MaxTimeout}."; throw new ArgumentException(message); } scriptConfig.FunctionTimeout = requestedTimeout; } else if (IsDynamicSku()) { // Apply a default if this is running on Dynamic. scriptConfig.FunctionTimeout = MaxTimeout; } }