public void AddRouteDataToRequest_DoesNotAddRequestProperty_WhenRouteDataNull()
{
var mockRouteData = new Mock <IHttpRouteData>(MockBehavior.Strict);
IDictionary <string, object> values = null;
mockRouteData.Setup(p => p.Values).Returns(values);
HttpRequestMessage request = new HttpRequestMessage();
WebScriptHostManager.AddRouteDataToRequest(mockRouteData.Object, request);
Assert.False(request.Properties.ContainsKey(ScriptConstants.AzureFunctionsHttpRouteDataKey));
}
// 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);
}
}
}
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());
}
}
private async Task RunTimeoutExceptionTest(TraceWriter trace, bool handleCancellation)
{
TimeSpan gracePeriod = TimeSpan.FromMilliseconds(5000);
_manager = await CreateAndStartWebScriptHostManager(trace);
string scenarioName = handleCancellation ? "useToken" : "ignoreToken";
var args = new Dictionary <string, object>
{
{ "input", scenarioName }
};
await Assert.ThrowsAsync <FunctionTimeoutException>(() => _manager.Instance.CallAsync("TimeoutToken", args));
}
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 Fixture()
{
string testRoot = Path.Combine(Path.GetTempPath(), "FunctionTests");
if (Directory.Exists(testRoot))
{
Directory.Delete(testRoot, recursive: true);
}
SecretsPath = Path.Combine(testRoot, "TestSecrets");
Directory.CreateDirectory(SecretsPath);
string logRoot = Path.Combine(testRoot, @"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);
HostManager = new WebScriptHostManager(config, secretManager);
Task task = Task.Run(() => { HostManager.RunAndBlock(); });
TestHelpers.Await(() =>
{
return(HostManager.IsRunning);
}).GetAwaiter().GetResult();
}
public async Task EmptyHost_StartsSuccessfully()
{
string functionTestDir = Path.Combine(_fixture.TestFunctionRoot, Guid.NewGuid().ToString());
Directory.CreateDirectory(functionTestDir);
// important for the repro that these directories no not exist
string logDir = Path.Combine(_fixture.TestLogsRoot, Guid.NewGuid().ToString());
string secretsDir = Path.Combine(_fixture.TestSecretsRoot, Guid.NewGuid().ToString());
JObject hostConfig = new JObject
{
{ "id", "123456" }
};
File.WriteAllText(Path.Combine(functionTestDir, ScriptConstants.HostMetadataFileName), hostConfig.ToString());
ScriptHostConfiguration config = new ScriptHostConfiguration
{
RootScriptPath = functionTestDir,
RootLogPath = logDir,
FileLoggingMode = FileLoggingMode.Always
};
ISecretManager secretManager = new SecretManager(secretsDir);
WebHostSettings webHostSettings = new WebHostSettings();
ScriptHostManager hostManager = new WebScriptHostManager(config, secretManager, webHostSettings);
Task runTask = Task.Run(() => hostManager.RunAndBlock());
await TestHelpers.Await(() => hostManager.IsRunning, timeout : 10000);
hostManager.Stop();
Assert.False(hostManager.IsRunning);
await Task.Delay(FileTraceWriter.LogFlushIntervalMs);
string hostLogFilePath = Directory.EnumerateFiles(Path.Combine(logDir, "Host")).Single();
string hostLogs = File.ReadAllText(hostLogFilePath);
Assert.Contains("Generating 0 job function(s)", hostLogs);
Assert.Contains("No job functions found.", hostLogs);
Assert.Contains("Job host started", hostLogs);
Assert.Contains("Job host stopped", hostLogs);
}
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);
_activeSecretManager = GetSecretManager(_settingsManager, settings.SecretsPath);
_activeReceiverManager = new WebHookReceiverManager(_activeSecretManager);
_activeHostManager = new WebScriptHostManager(_activeScriptHostConfig, _activeSecretManager, _settingsManager, settings);
(_standbySecretManager as IDisposable)?.Dispose();
_standbyHostManager?.Dispose();
_standbyReceiverManager?.Dispose();
_standbyScriptHostConfig = null;
_standbySecretManager = null;
_standbyHostManager = null;
_standbyReceiverManager = null;
_settingsManager.Reset();
}
}
else
{
if (_standbyHostManager == null)
{
_standbyScriptHostConfig = GetScriptHostConfiguration(settings.ScriptPath, settings.LogPath);
_standbySecretManager = GetSecretManager(_settingsManager, settings.SecretsPath);
_standbyReceiverManager = new WebHookReceiverManager(_standbySecretManager);
_standbyHostManager = new WebScriptHostManager(_standbyScriptHostConfig, _standbySecretManager, _settingsManager, settings);
}
}
}
public async Task MultipleHostRestarts()
{
string functionTestDir = Path.Combine(_fixture.TestFunctionRoot, Guid.NewGuid().ToString());
Directory.CreateDirectory(functionTestDir);
string logDir = Path.Combine(_fixture.TestLogsRoot, Guid.NewGuid().ToString());
string secretsDir = Path.Combine(_fixture.TestSecretsRoot, Guid.NewGuid().ToString());
ScriptHostConfiguration config = new ScriptHostConfiguration
{
RootLogPath = logDir,
RootScriptPath = functionTestDir,
FileLoggingMode = FileLoggingMode.Always,
RestartInterval = TimeSpan.FromMilliseconds(500)
};
SecretManager secretManager = new SecretManager(secretsDir);
WebHostSettings webHostSettings = new WebHostSettings();
var factoryMock = new Mock <IScriptHostFactory>();
int count = 0;
factoryMock.Setup(p => p.Create(config)).Callback(() =>
{
count++;
}).Throws(new Exception("Kaboom!"));
ScriptHostManager hostManager = new WebScriptHostManager(config, secretManager, webHostSettings, factoryMock.Object);
Task runTask = Task.Run(() => hostManager.RunAndBlock());
await TestHelpers.Await(() =>
{
return(count > 3);
});
hostManager.Stop();
Assert.False(hostManager.IsRunning);
// regression test: previously on multiple restarts we were recomposing
// the writer on each restart, resulting in a nested chain of writers
// increasing on each restart
Assert.Equal(typeof(SystemTraceWriter), config.TraceWriter.GetType());
}
public static void Reset()
{
_standbySecretManager?.Dispose();
_standbyHostManager?.Dispose();
_standbyReceiverManager?.Dispose();
_standbyScriptHostConfig = null;
_standbySecretManager = null;
_standbyHostManager = null;
_standbyReceiverManager = null;
_activeSecretManager?.Dispose();
_activeHostManager?.Dispose();
_activeReceiverManager?.Dispose();
_activeScriptHostConfig = null;
_activeSecretManager = null;
_activeHostManager = null;
_activeReceiverManager = null;
}
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)
{
_activeScriptHostConfig = CreateScriptHostConfiguration(settings);
_activeHostManager = new WebScriptHostManager(_activeScriptHostConfig, _secretManagerFactory, _eventManager, _settingsManager, settings);
_activeReceiverManager = new WebHookReceiverManager(_activeHostManager.SecretManager);
InitializeFileSystem();
if (_standbyHostManager != null)
{
// we're undergoing the one and only one
// standby mode specialization
_activeScriptHostConfig.TraceWriter.Info(Resources.HostSpecializationTrace);
}
_standbyHostManager?.Dispose();
_standbyReceiverManager?.Dispose();
_standbyScriptHostConfig = null;
_standbyHostManager = null;
_standbyReceiverManager = null;
_settingsManager.Reset();
}
}
else
{
if (_standbyHostManager == null)
{
_standbyScriptHostConfig = CreateScriptHostConfiguration(settings, true);
_standbyHostManager = new WebScriptHostManager(_standbyScriptHostConfig, _secretManagerFactory, _eventManager, _settingsManager, settings);
_standbyReceiverManager = new WebHookReceiverManager(_standbyHostManager.SecretManager);
InitializeFileSystem();
StandbyManager.Initialize(_standbyScriptHostConfig);
}
}
}
private async Task <WebScriptHostManager> CreateAndStartWebScriptHostManager(TraceWriter traceWriter)
{
var functions = new Collection <string> {
"TimeoutToken"
};
ScriptHostConfiguration config = new ScriptHostConfiguration()
{
RootScriptPath = $@"TestScripts\CSharp",
TraceWriter = traceWriter,
FileLoggingMode = FileLoggingMode.Always,
Functions = functions,
FunctionTimeout = TimeSpan.FromSeconds(3)
};
var manager = new WebScriptHostManager(config, new SecretManager(), new WebHostSettings());
Task task = Task.Run(() => { manager.RunAndBlock(); });
await TestHelpers.Await(() => manager.IsRunning);
return(manager);
}
public void AddRouteDataToRequest_AddsRequestProperty_WhenRouteDataNotNull()
{
var mockRouteData = new Mock <IHttpRouteData>(MockBehavior.Strict);
IDictionary <string, object> values = new Dictionary <string, object>
{
{ "p1", "abc" },
{ "p2", 123 },
{ "p3", null },
{ "p4", RouteParameter.Optional }
};
mockRouteData.Setup(p => p.Values).Returns(values);
HttpRequestMessage request = new HttpRequestMessage();
WebScriptHostManager.AddRouteDataToRequest(mockRouteData.Object, request);
var result = (IDictionary <string, object>)request.Properties[ScriptConstants.AzureFunctionsHttpRouteDataKey];
Assert.Equal(result["p1"], "abc");
Assert.Equal(result["p2"], 123);
Assert.Equal(result["p3"], null);
Assert.Equal(result["p4"], null);
}
/// <summary>
/// This method ensures that all services managed by this class are initialized
/// correctly taking into account specialization state transitions.
/// </summary>
internal void EnsureInitialized(WebHostSettings settings)
{
// Create a logger that we can use when the host isn't yet initialized.
ILogger logger = _loggerFactory.CreateLogger(LogCategories.Startup);
lock (_syncLock)
{
// Determine whether we should do normal or standby initialization
if (!WebScriptHostManager.InStandbyMode)
{
// We're not in standby mode. There are two cases to consider:
// 1) We _were_ in standby mode and now we're ready to specialize
// 2) We're doing non-specialization normal initialization
if (_activeHostManager == null &&
(_standbyHostManager == null || _settingsManager.ContainerReady))
{
_settingsManager.Reset();
_specializationTimer?.Dispose();
_specializationTimer = null;
_activeScriptHostConfig = CreateScriptHostConfiguration(settings);
_activeHostManager = new WebScriptHostManager(_activeScriptHostConfig, _secretManagerFactory, _eventManager, _settingsManager, settings,
_router, loggerProviderFactory: _loggerProviderFactory, loggerFactory: _loggerFactory);
//_activeReceiverManager = new WebHookReceiverManager(_activeHostManager.SecretManager);
InitializeFileSystem(settings, _settingsManager.FileSystemIsReadOnly);
if (_standbyHostManager != null)
{
// we're starting the one and only one
// standby mode specialization
logger.LogInformation(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
{
// We're in standby (placeholder) mode. Initialize the standby services.
if (_standbyHostManager == null)
{
var standbySettings = CreateStandbySettings(settings);
_standbyScriptHostConfig = CreateScriptHostConfiguration(standbySettings, true);
_standbyHostManager = new WebScriptHostManager(_standbyScriptHostConfig, _secretManagerFactory, _eventManager, _settingsManager, standbySettings,
_router, loggerProviderFactory: _loggerProviderFactory, loggerFactory: _loggerFactory);
// _standbyReceiverManager = new WebHookReceiverManager(_standbyHostManager.SecretManager);
InitializeFileSystem(settings, _settingsManager.FileSystemIsReadOnly);
StandbyManager.Initialize(_standbyScriptHostConfig, logger);
// start a background timer to identify when specialization happens
// specialization usually happens via an http request (e.g. scale controller
// ping) but this timer is started as well to handle cases where we
// might not receive a request
_specializationTimer = new Timer(OnSpecializationTimerTick, settings, 1000, 1000);
}
}
}
}
public Fixture()
{
EventGenerator = new TestSystemEventGenerator();
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.WriteAllText(Path.Combine(SecretsPath, ScriptConstants.HostMetadataFileName), string.Empty);
File.WriteAllText(Path.Combine(SecretsPath, "WebHookTrigger.json"), string.Empty);
File.WriteAllText(Path.Combine(SecretsPath, "QueueTriggerToBlob.json"), string.Empty);
File.WriteAllText(Path.Combine(SecretsPath, "Foo.json"), string.Empty);
File.WriteAllText(Path.Combine(SecretsPath, "Bar.json"), string.Empty);
File.WriteAllText(Path.Combine(SecretsPath, "Invalid.json"), string.Empty);
// 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,
FileLoggingMode = FileLoggingMode.Always
};
ISecretManager secretManager = new SecretManager(SecretsPath);
WebHostSettings webHostSettings = new WebHostSettings();
var hostConfig = config.HostConfig;
var testEventGenerator = new TestSystemEventGenerator();
hostConfig.AddService <IEventGenerator>(EventGenerator);
var mockHostManager = new WebScriptHostManager(config, secretManager, webHostSettings);
HostManager = mockHostManager;
Task task = Task.Run(() => { HostManager.RunAndBlock(); });
TestHelpers.Await(() =>
{
return(HostManager.IsRunning);
}).GetAwaiter().GetResult();
// verify startup system trace logs
string[] expectedPatterns = new string[]
{
"Info Reading host configuration file",
"Info Host lock lease acquired by instance ID '(.+)'",
"Info Function 'Excluded' is marked as excluded",
@"Info Generating ([0-9]+) job function\(s\)",
@"Info Starting Host \(HostId=function-tests-node, Version=(.+), ProcessId=[0-9]+, Debug=False\)",
"Info WebJobs.Indexing Found the following functions:",
"Info The next 5 occurrences of the schedule will be:",
"Info WebJobs.Host Job host started",
"Error The following 1 functions are in error:"
};
foreach (string pattern in expectedPatterns)
{
Assert.True(EventGenerator.Events.Any(p => Regex.IsMatch(p, pattern)), $"Expected trace event {pattern} not found.");
}
}
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();
}
}
}
public static async Task <HttpResponseMessage> WarmUp(HttpRequestMessage request, WebScriptHostManager scriptHostManager)
{
var queryParams = request.GetQueryParameterDictionary();
string value = null;
if (queryParams.TryGetValue("restart", out value) && string.Compare("1", value) == 0)
{
scriptHostManager.RestartHost();
await scriptHostManager.DelayUntilHostReady();
}
await StandbyManager.WarmUp(scriptHostManager.Instance);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
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);
}
}
}