static async Task MainAsync(string[] args)
{
int numberOfProcesses = Int32.Parse(args[0]);
// Initialise processes
CancellationTokenSource cancellation = new CancellationTokenSource();
for (int i = 0; i < numberOfProcesses; i++)
{
var proc = new Process($"process{i}", cancellation.Token);
processes.Add(proc);
proc.Initialise();
}
// Subscribe to Build Messages
IQueueBuilder queueBuilder = new RabbitBuilder();
IReceiver receiver = queueBuilder.ConfigureTransport(_queueServer, _queueVhost, _queueUsername, _queuePassword)
.IReceiveFrom(QueueNames.Build())
.IReceiveForever()
.Build();
receiver.Receive <RunBuild>((m) => {
RunBuild(m);
});
Console.ReadLine();
Console.WriteLine("Cancelling processes ...");
cancellation.Cancel();
Console.WriteLine("Processes cancelled.");
}
public async Task TestSendReceive()
{
IQueueBuilder builder;
builder = new RabbitBuilder();
var sender = builder.ConfigureTransport(_hostName, _vHost, _userName, _password)
.ISendTo(_queueName).Build();
builder = new RabbitBuilder();
var receiver = builder.ConfigureTransport(_hostName, _vHost, _userName, _password)
.IReceiveFrom(_queueName).IReceiveForever().Build();
String message = "Test Message";
sender.Send <String>(message);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(2000);
Func <string> subscriptionFunction = () =>
{
String result = null;
receiver.Receive <String>((s) => { result = s; });
while (string.IsNullOrEmpty(result))
{
Task.Delay(100);
}
return(result);
};
var res = await Task <string> .Run(subscriptionFunction, cancellationTokenSource.Token);
Assert.AreEqual(message, res);
}
public void IQueueBuilder_returns_IDirectionSelector()
{
IQueueBuilder sut = new RabbitBuilder();
var res = sut.ConfigureTransport(_hostName, _vHost, _userName, _password);
Assert.IsInstanceOf <IDirectionSelector>(res);
}
private ISender ConfigureSender(string queue)
{
IQueueBuilder queueBuilder = new RabbitBuilder();
ISender sender = queueBuilder.ConfigureTransport(_host, _vHost, _username, _password)
.ISendTo(queue)
.Build();
return(sender);
}
private IReceiver ConfigureReceiver(string queue)
{
IQueueBuilder queueBuilder = new RabbitBuilder();
IReceiver receiver = queueBuilder.ConfigureTransport(_host, _vHost, _username, _password)
.IReceiveFrom(queue)
.IReceiveForever()
.Build();
return(receiver);
}
public void IReceiveFrom_returns_IReceiveTypeSelector()
{
IQueueBuilder sut = new RabbitBuilder();
var res =
sut.ConfigureTransport(_hostName, _vHost, _userName, _password)
.IReceiveFrom(_queueName);
Assert.IsInstanceOf <IReceiveTypeSelector>(res);
}
public void ISenderBuilder_returns_ISenderBuilder()
{
IQueueBuilder sut = new RabbitBuilder();
var res =
sut.ConfigureTransport(_hostName, _vHost, _userName, _password)
.ISendTo(_queueName);
Assert.IsInstanceOf <ISenderBuilder>(res);
}
public void IReceiveTypeSelector_returns_ITemporaryReceiverBuilder()
{
IQueueBuilder sut = new RabbitBuilder();
var res =
sut.ConfigureTransport(_hostName, _vHost, _userName, _password)
.IReceiveFrom(_queueName)
.IReceiveUntilNoMoreMessages(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(1), () => { });
Assert.IsInstanceOf <ITemporaryReceiverBuilder>(res);
}
public void IPermanentReceiverBuilder_returns_RabbitPermanentReceiver()
{
IQueueBuilder sut = new RabbitBuilder();
var res =
sut.ConfigureTransport(_hostName, _vHost, _userName, _password)
.IReceiveFrom(_queueName)
.IReceiveForever()
.Build();
Assert.IsInstanceOf <RabbitPermanentReceiver>(res);
}
public void Initialise()
{
Task.Run(async() =>
{
while (true)
{
RunBuild currentBuild = null;
currentBuild = await GetCurrentBuild();
IQueueBuilder queueBuilder = new RabbitBuilder();
using (ISender statusMessageSender = queueBuilder.ConfigureTransport(_queueServer, _queueVhost, _queueUsername, _queuePassword)
.ISendTo(QueueNames.Status(currentBuild.Build))
.Build())
{
try
{
Action <(string status, string warning, string error)> notify = ((string status, string warning, string error)state) =>
{
if (!string.IsNullOrEmpty(state.status))
{
Console.WriteLine($"INFO: {state.status}");
}
if (!string.IsNullOrEmpty(state.warning))
{
Console.WriteLine($"WARNING: {state.warning}");
}
if (!string.IsNullOrEmpty(state.error))
{
Console.WriteLine($"ERROR: {state.error}");
}
statusMessageSender.Send(StatusReport(state));
};
await RunProcess(currentBuild, notify);
}
catch (Exception ex)
{
statusMessageSender.Send(StatusReport((null, null, SerialiseError(ex))));
// TODO : Log the exception
// Rethrowing the exception from this point would kill the thread which we don't want to do
}
finally
{
RemoveBuild(currentBuild);
}
}
}
}, _cancellationToken);
}
public void DeleteQueue(int jobId)
{
string queueName = $"{jobId}";
IQueueBuilder queueBuilder = new RabbitBuilder();
using (ISender sender = queueBuilder
.ConfigureTransport(_settings.Value.Server, _settings.Value.Vhost, _settings.Value.Username, _settings.Value.Password)
.ISendTo(queueName)
.Build())
{
sender.DeleteQueue();
}
}
public Task StartAsync(CancellationToken cancellationToken)
{
IQueueBuilder queueBuilder = new RabbitBuilder();
_receiver = queueBuilder.ConfigureTransport(_settings.Value.Server, _settings.Value.Vhost, _settings.Value.Username, _settings.Value.Password)
.IReceiveFrom(RESPONSE_QUEUE_NAME)
.IReceiveForever()
.Build();
_logger.LogDebug("Received Created");
_receiver.Receive <TestResult>(ReceiveMessage);
return(Task.CompletedTask);
}
public void EnqueueTests(Job job)
{
string queueName = $"{job.JobId}";
IQueueBuilder queueBuilder = new RabbitBuilder();
using (ISender sender = queueBuilder
.ConfigureTransport(_settings.Value.Server, _settings.Value.Vhost, _settings.Value.Username, _settings.Value.Password)
.ISendTo(queueName)
.Build())
{
foreach (TestRequest request in job.TestRequests)
{
EnqueueTest(sender, request);
}
}
}
public static void RunBuild(RunBuild build)
{
IQueueBuilder queueBuilder = new RabbitBuilder();
List <Task> tasks = new List <Task>();
using (ISender statusMessageSender = queueBuilder.ConfigureTransport(_queueServer, _queueVhost, _queueUsername, _queuePassword)
.ISendTo(QueueNames.Status(build.Build))
.Build())
{
SendStatusMessage(statusMessageSender, $"Starting build {build.Build}");
}
foreach (var proc in processes)
{
tasks.Add(proc.RunBuild(build));
}
// Wait for at least one task to complete this build before moving onto the next build
Task.WaitAny(tasks.ToArray());
// Don't send anymore messages to the status queue after this point as it might have been removed already
// and we don't want to re-create it
}
static void Main(string[] args)
{
Console.WriteLine("Running tester in container");
string requestQueueName = System.Environment.GetEnvironmentVariable("TESTER_REQUEST_QUEUE");
Console.WriteLine($"requestQueueName: {requestQueueName}");
string responseQueueName = System.Environment.GetEnvironmentVariable("TESTER_RESPONSE_QUEUE");
Console.WriteLine($"responseQueueName: {responseQueueName}");
string instanceName = System.Environment.GetEnvironmentVariable("TESTER_INSTANCE");
Console.WriteLine($"instanceName: {instanceName}");
string queueServer = System.Environment.GetEnvironmentVariable("TESTER_SERVER");
Console.WriteLine($"queueServer: {queueServer}");
string queueVhost = System.Environment.GetEnvironmentVariable("TESTER_VHOST");
Console.WriteLine($"queueVhost: {queueVhost}");
string queueUsername = System.Environment.GetEnvironmentVariable("TESTER_USERNAME");
Console.WriteLine($"queueUsername: {queueUsername}");
string queuePassword = System.Environment.GetEnvironmentVariable("TESTER_PASSWORD");
Console.WriteLine($"queuePassword: {queuePassword}");
string directoryToSearch = ConfigurationManager.AppSettings["directoryToSearch"];
Console.WriteLine($"directoryToSearch: {directoryToSearch}");
string listTests = System.Environment.GetEnvironmentVariable("TESTER_LISTTESTS");
Console.WriteLine($"listTests: {listTests}");
if (!string.IsNullOrEmpty(listTests))
{
ListTests(directoryToSearch);
return;
}
log4net.GlobalContext.Properties["LogName"] = $"{instanceName}.log";
XmlConfigurator.Configure();
IQueueBuilder queueBuilder = new RabbitBuilder();
receiver =
queueBuilder.ConfigureTransport(queueServer, queueVhost, queueUsername, queuePassword)
.IReceiveFrom(requestQueueName)
.IReceiveUntilNoMoreMessages(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(20), ShutDown)
.Build();
queueBuilder = new RabbitBuilder();
sender = queueBuilder.ConfigureTransport(queueServer, queueVhost, queueUsername, queuePassword)
.ISendTo(responseQueueName)
.Build();
var files = Directory.GetFiles(directoryToSearch, "*.dll", SearchOption.AllDirectories).ToList();
TestExecutor executor = new TestExecutor(files);
receiver.Receive <RunTest>((m) =>
{
try
{
Console.WriteLine($"Running {m.FullName} ...");
var responseXML = executor.Execute(m);
var responseNode = responseXML.SelectSingleNode("//test-case");
var testResult = responseNode.Attributes["result"].Value;
Console.WriteLine($"{m.FullName} : {testResult.ToUpper()}");
sender.Send(new TestResult {
TestRequestId = m.TestRequestId, Build = m.Build, FullName = m.FullName
});
} catch (Exception e)
{
sender.Send(new StatusMessage {
Application = "TestRunner", Process = instanceName, Error = e.Message
});
}
});
Console.WriteLine("Listening ...");
}
