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 void Constructor_ReturnsCorrectRequestQueueName() { var name = fixture.CreateAnonymous <string>(); var names = new QueueNames(name, fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <string>()); Assert.Equal(name, names.Request); }
public void Can_remove_empty_temp_queues() { //Clean up sqsQueueManager.RemoveEmptyTemporaryQueues(DateTime.UtcNow.AddDays(5).ToUnixTime()); var nonEmptyTempQueue = sqsQueueManager.CreateQueue(QueueNames.GetTempQueueName()); sqsQueueManager.SqsClient.SendMessage(new SendMessageRequest(nonEmptyTempQueue.QueueUrl, "Just some text")); sqsQueueManager.SqsClient.SendMessage(new SendMessageRequest(nonEmptyTempQueue.QueueUrl, "Just some more text")); var emptyTempQueue1 = sqsQueueManager.CreateQueue(QueueNames.GetTempQueueName()); var emptyTempQueue2 = sqsQueueManager.CreateQueue(QueueNames.GetTempQueueName()); var emptyTempQueueNotCached = sqsQueueManager.CreateQueue(QueueNames.GetTempQueueName()); if (!SqsTestAssert.IsFakeClient) { // List queue doesn't return newly created queues for a bit, so if this a "real", we skip this part sqsQueueManager.QueueNameMap.TryRemove(emptyTempQueueNotCached.QueueName, out _); } var countOfQueuesRemoved = sqsQueueManager.RemoveEmptyTemporaryQueues(DateTime.UtcNow.AddDays(5).ToUnixTime()); try { SqsTestAssert.FakeEqualRealGreater(3, 2, countOfQueuesRemoved); } finally { // Cleanup sqsQueueManager.DeleteQueue(nonEmptyTempQueue.QueueName); sqsQueueManager.DeleteQueue(emptyTempQueue1.QueueName); sqsQueueManager.DeleteQueue(emptyTempQueue2.QueueName); sqsQueueManager.DeleteQueue(emptyTempQueueNotCached.QueueName); } }
public string GetTempQueueName() { // NOTE: Purposely not creating DLQ queues for all these temps if they get used, they'll get // created on the fly as needed if messages actually fail var queueDefinition = sqsQueueManager.GetOrCreate(QueueNames.GetTempQueueName()); return(queueDefinition.QueueName); }
public async Task Consume(ConsumeContext <IFulfillOrder> context) { _logger.LogInformation($"Fulfilled order {context.Message.OrderId}"); var builder = new RoutingSlipBuilder(NewId.NextGuid()); var order = await _orderService.GetOrderAsync(context.Message.OrderId); builder.AddActivity("SubmitOrder", QueueNames.GetActivityUri(nameof(SubmitOrderActivity))); builder.AddActivity("ReserveProducts", QueueNames.GetActivityUri(nameof(ReserveProductsActivity)), new { order.OrderItems }); builder.AddActivity("Payment", QueueNames.GetActivityUri(nameof(PaymentActivity))); builder.AddActivity("Delivery", QueueNames.GetActivityUri(nameof(DeliveryActivity))); builder.AddVariable("CorrelationId", context.Message.CorrelationId); builder.AddVariable("OrderId", context.Message.OrderId); await builder.AddSubscription(context.SourceAddress, RoutingSlipEvents.Faulted | RoutingSlipEvents.Supplemental, RoutingSlipEventContents.None, x => x.Send <IOrderFulfillFaultedEvent>(new { context.Message.OrderId })); await builder.AddSubscription(context.SourceAddress, RoutingSlipEvents.Completed | RoutingSlipEvents.Supplemental, RoutingSlipEventContents.None, x => x.Send <IOrderFulfillCompletedEvent>(new { context.Message.OrderId })); var routingSlip = builder.Build(); await context.Execute(routingSlip).ConfigureAwait(false); }
public void Constructor_ReturnsCorrectPoisonQueueName() { var name = fixture.CreateAnonymous <string>(); var names = new QueueNames(fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <string>(), name); Assert.Equal(name, names.Poison); }
protected internal void StartQueues(Dictionary <Type, IMessageHandlerFactory> handlerMap) { // Create queues for each registered type this.handlerMap = handlerMap; queueMap = new Dictionary <string, Type>(); var mqSuffixes = new [] { ".inq", ".outq", ".priorityq", ".dlq" }; foreach (var type in this.handlerMap.Keys) { foreach (var mqSuffix in mqSuffixes) { var queueName = QueueNames.ResolveQueueNameFn(type.Name, mqSuffix); if (!queueMap.ContainsKey(queueName)) { queueMap.Add(queueName, type); } #if !NETSTANDARD2_0 var mqDesc = new QueueDescription(queueName); if (!namespaceManager.QueueExists(queueName)) { namespaceManager.CreateQueue(mqDesc); } #endif } var mqNames = new QueueNames(type); AddQueueHandler(mqNames.In); AddQueueHandler(mqNames.Priority); } }
public static void RegisterQueues(this IModel channel, QueueNames queueNames) { channel.RegisterQueue(queueNames.In); channel.RegisterQueue(queueNames.Priority); channel.RegisterTopic(queueNames.Out); channel.RegisterDlq(queueNames.Dlq); }
static void Main(string[] args) { QueueNames.SetQueuePrefix("site1."); typeof(Program).Namespace.Print(); using (var mqServer = CreateMqServer()) using (var mqClient = mqServer.CreateMessageQueueClient()) { var replyToMq = mqClient.GetTempQueueName(); mqClient.Publish(new Message <HelloRabbit>(new HelloRabbit { Name = "World" }) { ReplyTo = replyToMq }); IMessage <HelloRabbitResponse> responseMsg = mqClient.Get <HelloRabbitResponse>(replyToMq); mqClient.Ack(responseMsg); responseMsg.GetBody().PrintDump(); Console.ReadKey(); } }
public void Does_resolve_QueueNames_using_QueuePrefix() { QueueNames.SetQueuePrefix("site1."); Assert.That(new QueueNames(typeof(TestPrefix)).In, Is.EqualTo("site1.mq:TestPrefix.inq")); Assert.That(QueueNames <TestPrefix> .In, Is.EqualTo("site1.mq:TestPrefix.inq")); QueueNames.SetQueuePrefix(""); }
private SqsQueueDefinition CreateQueue(SqsQueueName queueName, int?visibilityTimeoutSeconds = null, int?receiveWaitTimeSeconds = null, bool?disasbleBuffering = null, SqsRedrivePolicy redrivePolicy = null) { SqsQueueDefinition queueDefinition = null; var request = new CreateQueueRequest { QueueName = queueName.AwsQueueName, Attributes = new Dictionary <string, string> { { QueueAttributeName.ReceiveMessageWaitTimeSeconds, TimeSpan.FromSeconds(receiveWaitTimeSeconds ?? DefaultReceiveWaitTime) .TotalSeconds .ToString(CultureInfo.InvariantCulture) }, { QueueAttributeName.VisibilityTimeout, TimeSpan.FromSeconds(visibilityTimeoutSeconds ?? DefaultVisibilityTimeout) .TotalSeconds .ToString(CultureInfo.InvariantCulture) }, { QueueAttributeName.MessageRetentionPeriod, (QueueNames.IsTempQueue(queueName.QueueName) ? SqsQueueDefinition.DefaultTempQueueRetentionSeconds : SqsQueueDefinition.DefaultPermanentQueueRetentionSeconds).ToString(CultureInfo.InvariantCulture) } } }; if (redrivePolicy != null) { var json = redrivePolicy.ToJson(); request.Attributes.Add(QueueAttributeName.RedrivePolicy, json); } try { var createResponse = SqsClient.CreateQueue(request); // Note - must go fetch the attributes from the server after creation, as the request attributes do not include // anything assigned by the server (i.e. the ARN, etc.). queueDefinition = GetQueueDefinition(queueName, createResponse.QueueUrl); queueDefinition.DisableBuffering = disasbleBuffering ?? DisableBuffering; queueNameMap[queueDefinition.QueueName] = queueDefinition; } catch (QueueNameExistsException) { // Queue exists with different attributes, instead of creating, alter those attributes to match what was requested queueDefinition = UpdateQueue(queueName, request.ToSetAttributesRequest(null), disasbleBuffering); } return(queueDefinition); }
public void Init() { if (workers == null) { var workerBuilder = new List <MessageHandlerWorker>(); foreach (var entry in handlerMap) { var msgType = entry.Key; var handlerFactory = entry.Value; var queueNames = new QueueNames(msgType); var noOfThreads = handlerThreadCountMap[msgType]; if (PriortyQueuesWhitelist == null || PriortyQueuesWhitelist.Any(x => x == msgType.Name)) { noOfThreads.Times(i => workerBuilder.Add(new MessageHandlerWorker( clientsManager, handlerFactory.CreateMessageHandler(), queueNames.Priority, WorkerErrorHandler))); } noOfThreads.Times(i => workerBuilder.Add(new MessageHandlerWorker( clientsManager, handlerFactory.CreateMessageHandler(), queueNames.In, WorkerErrorHandler))); } workers = workerBuilder.ToArray(); queueWorkerIndexMap = new Dictionary <string, int[]>(); for (var i = 0; i < workers.Length; i++) { var worker = workers[i]; int[] workerIds; if (!queueWorkerIndexMap.TryGetValue(worker.QueueName, out workerIds)) { queueWorkerIndexMap[worker.QueueName] = new[] { i }; } else { workerIds = new List <int>(workerIds) { i }.ToArray(); queueWorkerIndexMap[worker.QueueName] = workerIds; } } } }
public Queue(LfMergeSettings settings, QueueNames name) { if (name == QueueNames.None) { throw new ArgumentException("Can't create a queue of type QueueNames.None", "name"); } Settings = settings; Name = name; }
public PublishService(ICommandPublisher commandPublisher, IOptions <QueueNames> options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } _commandPublisher = commandPublisher ?? throw new ArgumentNullException(nameof(commandPublisher)); _queueNames = options.Value; }
public void Can_determine_TempQueue_with_Custom_QueuePrefix() { QueueNames.SetQueuePrefix("site1."); var tmpName = QueueNames.GetTempQueueName(); Assert.That(QueueNames.IsTempQueue(tmpName), Is.True); QueueNames.SetQueuePrefix(""); }
public void SetQueueNames(params string[] queueNames) { if (queueNames == null) { throw new ArgumentNullException(nameof(queueNames)); } QueueNames.Clear(); QueueNames.AddRange(queueNames); }
public void Can_determine_TempQueue_with_Custom_QueueNameFm() { QueueNames.ResolveQueueNameFn = (typeName, suffix) => "SITE.{0}{1}".Fmt(typeName, suffix.ToUpper()); var tmpName = QueueNames.GetTempQueueName(); Assert.That(QueueNames.IsTempQueue(tmpName), Is.True); QueueNames.ResolveQueueNameFn = QueueNames.ResolveQueueName; }
public string GetTempQueueName() { var anonMq = Channel.QueueDeclare( queue: QueueNames.GetTempQueueName(), durable: false, exclusive: true, autoDelete: true, arguments: null); return(anonMq.QueueName); }
private async Task TakeProductCommand(BehaviorContext <OrderState, OrderAcceptedEvent> context) { var uri = QueueNames.GetMessageUri(nameof(TakeProductMessage)); var sendEndpoint = await context.GetSendEndpoint(uri); await sendEndpoint.Send <TakeProductMessage>(new { CorrelationId = context.Data.CorrelationId, OrderId = context.Data.OrderId }); }
public void NextAction(QueueNames queueName, ActionNames[] expectedActionNames) { var actions = new List<ActionNames>(); for (var sut = Queue.GetQueue(queueName).CurrentAction; sut != null; sut = sut.NextAction) { actions.Add(sut.Name); } Assert.That(actions, Is.EquivalentTo(expectedActionNames)); }
public TriggerProcessor(ICommandPublisher commandPublisher, IOptions <QueueNames> options, IIdentityClient identityClient) { if (options == null) { throw new ArgumentNullException(nameof(options)); } _commandPublisher = commandPublisher ?? throw new ArgumentNullException(nameof(commandPublisher)); _identityClient = identityClient ?? throw new ArgumentNullException(nameof(identityClient)); _queueNames = options.Value; }
public async Task Execute(BehaviorContext <OrderTransactionState, OrderTransactionSubmittedEvent> context, Behavior <OrderTransactionState, OrderTransactionSubmittedEvent> next) { var sendEndpoint = await context.GetSendEndpoint(QueueNames.GetMessageUri(nameof(FullfillOrderMessage))); logger.LogInformation($"Order Transaction activity for sendEndpoint {sendEndpoint} will be called"); await sendEndpoint.Send <FullfillOrderMessage>(new { OrderId = context.Data.OrderId, Credit = context.Data.Credit, CustomerId = context.Data.CustomerId }); }
public async Task Execute(BehaviorContext <OrderState, IOrderSubmittedEvent> context, Behavior <OrderState, IOrderSubmittedEvent> next) { var sendEndpoint = await context.GetSendEndpoint(QueueNames.GetMessageUri(nameof(IFulfillOrder))); _logger.LogInformation($"Order Transaction activity for sendEndpoint {sendEndpoint} will be called"); await sendEndpoint.Send <IFulfillOrder>(new { CorrelationId = context.Data.CorrelationId, OrderId = context.Data.OrderId, }); }
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 async Task <CompensationResult> Compensate(CompensateContext <TakeProductLog> context) { logger.LogInformation($"Compensate Take Product Courier called for order {context.Log.OrderId}"); var uri = QueueNames.GetMessageUri(nameof(ReturnProductTransactionMessage)); var sendEndpoint = await context.GetSendEndpoint(uri); await sendEndpoint.Send <ReturnProductTransactionMessage>(new { ProductBaskets = context.Log.Baskets }); return(context.Compensated()); }
public static ActionNames GetActionForQueue(QueueNames queue) { switch (queue) { case QueueNames.Edit: return ActionNames.Edit; case QueueNames.None: break; case QueueNames.Synchronize: return ActionNames.Synchronize; } return ActionNames.None; }
private async Task WithdrawCustomerCreditCommand(BehaviorContext <OrderState, OrderSubmittedEvent> context) { var uri = QueueNames.GetMessageUri(nameof(WithdrawCustomerCreditMessage)); var sendEndpoint = await context.GetSendEndpoint(uri); await sendEndpoint.Send <WithdrawCustomerCreditMessage>(new { CorrelationId = context.Data.CorrelationId, Credit = context.Data.Credit, CustomerId = context.Data.CustomerId, OrderId = context.Data.OrderId }); }
public async Task Execute(BehaviorContext <OrderState, IOrderSubmitted> context, Behavior <OrderState, IOrderSubmitted> next) { var uri = QueueNames.GetMessageUri(nameof(IAssetCanBeProtectedEvent)); var sendEndpoint = await context.GetSendEndpoint(uri); await sendEndpoint.Send <IAssetCanBeProtectedEvent>(new { OrderId = context.Data.OrderId }); await next.Execute(context).ConfigureAwait(false); }
public async Task TestInitialize() { _messages = new MessageRepository(ConnectonString); // make sure we're starting with empty queues foreach (var queueName in QueueNames.Enumerate()) { var removedTimeRanges1 = await _messages.RemoveTimeRangesAsync(queueName, null, null); Assert.AreEqual(0, await _messages.GetTimeRangeCountAsync(queueName)); Assert.AreEqual(0, await _messages.GetPendingMessageCountAsync(queueName)); } }
public void NextAction(QueueNames queueName, ActionNames[] expectedActionNames) { var actions = new List <ActionNames>(); for (var sut = Action.GetAction(Queue.GetQueue(queueName).CurrentActionName); sut != null; sut = sut.NextAction) { actions.Add(sut.Name); } Assert.That(actions, Is.EquivalentTo(expectedActionNames)); }
public static void RegisterQueue(this IModel channel, string queueName) { var args = new Dictionary <string, object> { { "x-dead-letter-exchange", QueueNames.ExchangeDlq }, { "x-dead-letter-routing-key", queueName.Replace(".inq", ".dlq").Replace(".priorityq", ".dlq") }, }; if (!QueueNames.IsTempQueue(queueName)) //Already declared in GetTempQueueName() { channel.QueueDeclare(queueName, durable: true, exclusive: false, autoDelete: false, arguments: args); } channel.QueueBind(queueName, QueueNames.Exchange, routingKey: queueName); }
public async Task Execute(BehaviorContext <OrderState, IAssetCanBeProtectedEvent> context, Behavior <OrderState, IAssetCanBeProtectedEvent> next) { var uri = QueueNames.GetMessageUri(nameof(ITryBlockBalanceCommand)); var sendEndpoint = await context.GetSendEndpoint(uri); await sendEndpoint.Send <ITryBlockBalanceCommand>(new { OrderId = context.Data.OrderId, Amount = 100m }); await next.Execute(context).ConfigureAwait(false); }
public void GetActionFromQueue(QueueNames queue, ActionNames expectedAction) { Assert.That(Options.GetActionForQueue(queue), Is.EqualTo(expectedAction)); }
public void GetQueueFromAction(ActionNames action, QueueNames expectedQueue) { Assert.That(Options.GetQueueForAction(action), Is.EqualTo(expectedQueue)); }
public QueueDouble(LfMergeSettingsIni settings, QueueNames name) : base(settings, name) { }
public void CurrentAction_Works(QueueNames queueName, Type expectedType) { var sut = Queue.GetQueue(queueName); Assert.That(sut.CurrentAction, Is.TypeOf(expectedType)); }
public string GetQueueDirectory(QueueNames queue) { return QueueDirectories[(int)queue]; }
public void Constructor_ReturnsCorrectPoisonQueueName() { var name = fixture.CreateAnonymous<string>(); var names = new QueueNames(fixture.CreateAnonymous<string>(), fixture.CreateAnonymous<string>(), name); Assert.Equal(name, names.Poison); }
public void Constructor_ReturnsCorrectRequestQueueName() { var name = fixture.CreateAnonymous<string>(); var names = new QueueNames(name, fixture.CreateAnonymous<string>(), fixture.CreateAnonymous<string>()); Assert.Equal(name, names.Request); }