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