public async void WorkerClient_Builds_On_Request()
{
//arrange
BuildResultDto actualResult = null; //hold actual result
var buildRequest = new BuildRequestDto
{
SessionId = arrangement.SessionId,
RunOnSuccess = false,
SourceCode = MockSourceCodeRepository.Get_Working_SimpleOutput_Code()
};
//act
arrangement.WorkerService.StartListening();
arrangement.WorkerService.WorkerConnected += (TcpClient workerClient, string sessionId) => {
arrangement.WorkerService.SendWorkerMessage(workerClient, MessageType.ServerBuildRequest, buildRequest);
};
arrangement.WorkerService.WorkerCompletedBuild += delegate(TcpClient workerClient, BuildResultDto message) {
arrangement.Worker?.Stop();
arrangement.WorkerService?.StopListening();
actualResult = message;
};
await arrangement.Worker.Start(arrangement.ServiceHostName, arrangement.ServicePort, arrangement.SessionId);
//assert
Assert.True(actualResult.IsSuccess);
}
public async void WorkerClient_Build_Fails_When_Ambiguous_EntryPoint()
{
//arrange
BuildResultDto actualResult = null; //hold actual result
var buildRequest = new BuildRequestDto
{
SessionId = arrangement.SessionId,
RunOnSuccess = true,
SourceCode = MockSourceCodeRepository.Get_AmbiguousMain_Code()
};
//act
arrangement.WorkerService.StartListening();
arrangement.WorkerService.WorkerConnected += (TcpClient workerClient, string sessionId) => {
arrangement.WorkerService.SendWorkerMessage(workerClient, MessageType.ServerBuildRequest, buildRequest);
};
arrangement.WorkerService.WorkerCompletedBuild += delegate(TcpClient workerClient, BuildResultDto message) {
arrangement.Worker?.Stop();
arrangement.WorkerService?.StopListening();
actualResult = message;
};
await arrangement.Worker.Start(arrangement.ServiceHostName, arrangement.ServicePort, arrangement.SessionId);
//assert
Assert.False(actualResult.IsSuccess);
//CS0017 = Program has more than one entry point defined. Compile with /main to specify the type that contains the entry point.
Assert.Equal("CS0017", actualResult.BuildErrors.First().Id);
}
public async void WorkerClient_Build_Fails_When_Bad_EntryPoint(string source, string expectedErrorCode)
{
//arrange
BuildResultDto actualResult = null; //hold actual result
var buildRequest = new BuildRequestDto
{
SessionId = arrangement.SessionId,
RunOnSuccess = true,
SourceCode = source
};
//act
arrangement.WorkerService.StartListening();
arrangement.WorkerService.WorkerConnected += (TcpClient workerClient, string sessionId) => {
arrangement.WorkerService.SendWorkerMessage(workerClient, MessageType.ServerBuildRequest, buildRequest);
};
arrangement.WorkerService.WorkerCompletedBuild += delegate(TcpClient workerClient, BuildResultDto message) {
arrangement.Worker?.Stop();
arrangement.WorkerService?.StopListening();
actualResult = message;
};
await arrangement.Worker.Start(arrangement.ServiceHostName, arrangement.ServicePort, arrangement.SessionId);
//assert
Assert.False(actualResult.IsSuccess);
Assert.Equal(expectedErrorCode, actualResult.BuildErrors.First().Id);
}
public async Task SendBuildResult(string sessionId, BuildResultDto result)
{
Logger.LogLine($"SignalRClientService.SendBuildResult: Dispatching BuildResultDto to client..");
try
{
await hubConnection.InvokeAsync(nameof(CodeHub.DispatchBuildResultToClient), sessionId, result);
}
catch (Exception ex)
{
Logger.LogLine($"SignalRClientService: {ex.Message}");
}
}
private void StartInternal(string host, int port, string sessionid)
{
Compiler compiler = new Compiler(netStandardLibPath);
TcpClient client = null;
NetworkStream networkStream = null;
try
{
using (client = new TcpClient())
{
client.Connect(host, port);
using (networkStream = client.GetStream())
{
Logger.LogLine("CLIENT: identifying with server...");
networkStream.WriteByte((byte)MessageType.WorkerIdentification);
Serializer.SerializeWithLengthPrefix(networkStream, new IdentificationDto
{
SessionId = sessionid
}, PrefixStyle.Fixed32);
Logger.LogLine("CLIENT: waiting for server...");
stopClient = false;
while (!stopClient)
{
if (!client.Connected)
{
stopClient = true;
break;
}
//check if server sent data
if (client.Available > 0)
{
byte msgHeader = (byte)networkStream.ReadByte();
MessageType msgType = (MessageType)msgHeader;
switch (msgType)
{
case MessageType.ServerBuildRequest:
//build shit
var buildrequest = Serializer.DeserializeWithLengthPrefix <BuildRequestDto>(networkStream, PrefixStyle.Fixed32);
Logger.LogLine("CLIENT: received BuildRequestDto");
EmitResult results = null;
byte[] assemblyBytes = null;
try
{
using (var assemblyStream = new MemoryStream())
{
results = compiler.Compile(buildrequest.SourceCode, buildrequest.SessionId, assemblyStream,
outputKind: OutputKind.ConsoleApplication).Result;
assemblyBytes = assemblyStream.ToArray();
}
}
catch (Exception ex)
{
Logger.LogLine($"CLIENT: Error! {ex.Message}");
throw;
}
Logger.LogLine("CLIENT: built source code");
BuildResultDto result = new BuildResultDto();
result.SessionId = buildrequest.SessionId;
result.BuildErrors = results.Diagnostics.Select(d =>
new BuildErrorDto
{
Id = d.Id,
Severity = d.Severity.ToString()?.ToLower(),
Description = d.GetMessage(),
StartPosition = LinePositionDto.FromLinePosition(d.Location.GetLineSpan().StartLinePosition),
EndPosition = LinePositionDto.FromLinePosition(d.Location.GetLineSpan().EndLinePosition),
}).ToList();
result.IsSuccess = results.Success;
networkStream.WriteByte((byte)MessageType.WorkerBuildResult);
Serializer.SerializeWithLengthPrefix(networkStream, result, PrefixStyle.Fixed32);
Logger.LogLine("CLIENT: sent build result");
if (buildrequest.RunOnSuccess && result.IsSuccess)
{
RunApplication(sessionid, client, assemblyBytes);
}
break;
default:
Logger.LogLine($"CLIENT: ERROR! Unknown server message header: {msgHeader}");
Logger.LogLine($"CLIENT: Shutting down due to unexpected server message.");
stopClient = true;
break;
}
}
}
}
}
}
finally
{
networkStream?.Close();
networkStream?.Dispose();
client?.Close();
client?.Dispose();
}
}
/// <summary>
/// Should only be used from the server side
/// </summary>
/// <returns></returns>
public async Task DispatchBuildResultToClient(string targetConnectionId, BuildResultDto result)
{
Logger.LogLine($"CodeHub: Sending BuildResult to {targetConnectionId} -- {result.IsSuccess}");
await Clients.Client(targetConnectionId).SendAsync("BuildComplete", result);
}
protected void Listener_WorkerCompletedBuild(TcpClient workerClient, BuildResultDto result)
{
clientService.SendBuildResult(result.SessionId, result);
}
