public void ShouldSyncTriggers_ReturnsExpectedResult(bool isPrimary, ScriptHostState hostState, bool expected)
{
_mockPrimaryHostStateProviderMock.Setup(p => p.IsPrimary).Returns(isPrimary);
_mockScriptHostManager.Setup(p => p.State).Returns(hostState);
Assert.Equal(expected, _syncService.ShouldSyncTriggers);
}
public async Task SetState_Succeeds(string desiredState, ScriptHostState currentState, HttpStatusCode statusCode)
{
_mockScriptHostManager.SetupGet(p => p.State).Returns(currentState);
var result = await _hostController.SetState(desiredState);
var resultStatus = HttpStatusCode.InternalServerError;
if (result is StatusCodeResult)
{
resultStatus = (HttpStatusCode)((StatusCodeResult)result).StatusCode;
}
else if (result is ObjectResult)
{
resultStatus = (HttpStatusCode)((ObjectResult)result).StatusCode;
}
else
{
Assert.True(false);
}
Assert.Equal(statusCode, resultStatus);
bool fileExists = File.Exists(_appOfflineFilePath);
if (string.Compare("offline", desiredState) == 0 && currentState != ScriptHostState.Offline)
{
// verify file was created
Assert.True(fileExists);
}
else
{
// verify file does not exist
Assert.False(fileExists);
}
}
public static void HostStateChanged(this ILogger logger, ScriptHostState previousHostState, ScriptHostState newHostState)
{
var newState = newHostState.ToString();
var previousState = previousHostState.ToString();
_hostStateChanged(logger, previousState, newState, null);
}
public async Task <IActionResult> Resume([FromServices] IScriptHostManager scriptHostManager)
{
try
{
await _resumeSemaphore.WaitAsync();
ScriptHostState currentState = scriptHostManager.State;
_logger.LogDebug($"Received request to resume a draining host - host status: {currentState.ToString()}");
if (currentState != ScriptHostState.Running ||
!Utility.TryGetHostService(scriptHostManager, out IDrainModeManager drainModeManager))
{
_logger.LogDebug("The host is not in a state where we can resume.");
return(StatusCode(StatusCodes.Status409Conflict));
}
_logger.LogDebug($"Drain mode enabled: {drainModeManager.IsDrainModeEnabled}");
if (drainModeManager.IsDrainModeEnabled)
{
_logger.LogDebug("Starting a new host");
await scriptHostManager.RestartHostAsync();
}
var status = new ResumeStatus {
State = scriptHostManager.State
};
return(Ok(status));
}
finally
{
_resumeSemaphore.Release();
}
}
private async Task AwaitHostStateAsync(ScriptHostState state)
{
await TestHelpers.Await(async() =>
{
var response = await GetHostStatusAsync();
var hostStatus = response.Content.ReadAsAsync <HostStatus>();
return(string.Compare(hostStatus.Result.State, state.ToString(), StringComparison.OrdinalIgnoreCase) == 0);
});
}
public async Task ResumeHost_HostNotRunning_ReturnsExpected(ScriptHostState hostStatus, bool drainModeEnabled, int expectedCode)
{
var scriptHostManagerMock = new Mock <IScriptHostManager>(MockBehavior.Strict);
var drainModeManager = new Mock <IDrainModeManager>(MockBehavior.Strict);
var serviceProviderMock = scriptHostManagerMock.As <IServiceProvider>();
serviceProviderMock.Setup(x => x.GetService(typeof(IDrainModeManager))).Returns(drainModeManager.Object);
scriptHostManagerMock.SetupGet(p => p.State).Returns(hostStatus);
drainModeManager.Setup(x => x.IsDrainModeEnabled).Returns(drainModeEnabled);
var result = (StatusCodeResult)await _hostController.Resume(scriptHostManagerMock.Object);
Assert.Equal(expectedCode, result.StatusCode);
scriptHostManagerMock.Verify(p => p.RestartHostAsync(It.IsAny <CancellationToken>()), Times.Never());
}
