public async Task ShutdownRequest_WriteRead_RoundtripsProperly()
{
// Arrange
var memoryStream = new MemoryStream();
var request = ServerRequest.CreateShutdown();
// Act
await request.WriteAsync(memoryStream, CancellationToken.None);
// Assert
memoryStream.Position = 0;
var read = await ServerRequest.ReadAsync(memoryStream, CancellationToken.None);
var argument1 = request.Arguments[0];
Assert.Equal(RequestArgument.ArgumentId.Shutdown, argument1.Id);
Assert.Equal(0, argument1.ArgumentIndex);
Assert.Equal("", argument1.Value);
var argument2 = request.Arguments[1];
Assert.Equal(RequestArgument.ArgumentId.CommandLineArgument, argument2.Id);
Assert.Equal(1, argument2.ArgumentIndex);
Assert.Equal("shutdown", argument2.Value);
}
protected async override Task <int> ExecuteCoreAsync()
{
if (!IsServerRunning())
{
// server isn't running right now
Out.Write("Server is not running.");
return(0);
}
try
{
using (var client = await Client.ConnectAsync(Pipe.Value(), timeout: TimeSpan.FromSeconds(5), cancellationToken: Cancelled))
{
if (client == null)
{
throw new InvalidOperationException("Couldn't connect to the server.");
}
var request = ServerRequest.CreateShutdown();
await request.WriteAsync(client.Stream, Cancelled).ConfigureAwait(false);
var response = ((ShutdownServerResponse)await ServerResponse.ReadAsync(client.Stream, Cancelled));
if (Wait.HasValue())
{
try
{
var process = Process.GetProcessById(response.ServerProcessId);
process.WaitForExit();
}
catch (Exception ex)
{
// There is an inherent race here with the server process. If it has already shutdown
// by the time we try to access it then the operation has succeeded.
Error.Write(ex);
}
Out.Write("Server pid:{0} shut down completed.", response.ServerProcessId);
}
}
}
catch (Exception ex) when(IsServerRunning())
{
// Ignore an exception that occurred while the server was shutting down.
Error.Write(ex);
}
return(0);
}
public void CreateShutdown_CreatesCorrectShutdownRequest()
{
// Arrange & Act
var request = ServerRequest.CreateShutdown();
// Assert
Assert.Equal(2, request.Arguments.Count);
var argument1 = request.Arguments[0];
Assert.Equal(RequestArgument.ArgumentId.Shutdown, argument1.Id);
Assert.Equal(0, argument1.ArgumentIndex);
Assert.Equal("", argument1.Value);
var argument2 = request.Arguments[1];
Assert.Equal(RequestArgument.ArgumentId.CommandLineArgument, argument2.Id);
Assert.Equal(1, argument2.ArgumentIndex);
Assert.Equal("shutdown", argument2.Value);
}
public async Task AcceptConnection_ShutdownRequest_ReturnsShutdownResponse()
{
// Arrange
var stream = new TestableStream();
await ServerRequest.CreateShutdown().WriteAsync(stream.ReadStream, CancellationToken.None);
stream.ReadStream.Position = 0;
var connection = CreateConnection(stream);
var connectionHost = CreateConnectionHost();
var compilerHost = CreateCompilerHost();
var dispatcher = new DefaultRequestDispatcher(connectionHost, compilerHost, CancellationToken.None);
// Act
var connectionResult = await dispatcher.AcceptConnection(
Task.FromResult <Connection>(connection), accept : true, cancellationToken : CancellationToken.None);
// Assert
Assert.Equal(ConnectionResult.Reason.ClientShutdownRequest, connectionResult.CloseReason);
stream.WriteStream.Position = 0;
var response = await ServerResponse.ReadAsync(stream.WriteStream).ConfigureAwait(false);
Assert.Equal(ServerResponse.ResponseType.Shutdown, response.Type);
}
internal static async Task <int> SendShutdown(string pipeName)
{
var response = await Send(pipeName, ServerRequest.CreateShutdown());
return(((ShutdownServerResponse)response).ServerProcessId);
}
