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 ..."); }