public async Task PullCount(int count)
{
TestHorseMq server = new TestHorseMq();
await server.Initialize();
int port = server.Start();
HorseQueue queue = server.Server.FindQueue("pull-a");
for (int i = 0; i < 25; i++)
{
await queue.Push("Hello, World");
}
HorseClient client = new HorseClient();
await client.ConnectAsync("hmq://localhost:" + port);
HorseResult joined = await client.Queues.Subscribe("pull-a", true);
Assert.Equal(HorseResultCode.Ok, joined.Code);
PullRequest request = new PullRequest
{
Queue = "pull-a",
Count = count
};
PullContainer container = await client.Queues.Pull(request);
Assert.Equal(count, container.ReceivedCount);
Assert.Equal(PullProcess.Completed, container.Status);
}
/// <summary>
/// Sends the message to binding receivers
/// </summary>
public override async Task <bool> Send(MqClient sender, HorseMessage message)
{
try
{
HorseQueue queue = await GetQueue(message);
if (queue == null)
{
return(false);
}
string messageId = Interaction == BindingInteraction.None
? Router.Server.MessageIdGenerator.Create()
: message.MessageId;
HorseMessage msg = message.Clone(true, true, messageId);
msg.Type = MessageType.QueueMessage;
msg.SetTarget(Target);
msg.WaitResponse = Interaction == BindingInteraction.Response;
QueueMessage queueMessage = new QueueMessage(msg);
queueMessage.Source = sender;
PushResult result = await queue.Push(queueMessage, sender);
return(result == PushResult.Success);
}
catch (Exception e)
{
Router.Server.SendError("BINDING_SEND", e, $"Type:AutoQueue, Binding:{Name}");
return(false);
}
}
public async Task PullOrder(bool?fifo)
{
TestHorseMq server = new TestHorseMq();
await server.Initialize();
int port = server.Start();
HorseQueue queue = server.Server.FindQueue("pull-a");
await queue.Push("First Message");
await queue.Push("Second Message");
HorseClient client = new HorseClient();
await client.ConnectAsync("hmq://localhost:" + port);
HorseResult joined = await client.Queues.Subscribe("pull-a", true);
Assert.Equal(HorseResultCode.Ok, joined.Code);
PullRequest request = new PullRequest
{
Queue = "pull-a",
Count = 1,
Order = !fifo.HasValue || fifo.Value ? MessageOrder.FIFO : MessageOrder.LIFO
};
PullContainer container = await client.Queues.Pull(request);
Assert.Equal(PullProcess.Completed, container.Status);
HorseMessage msg = container.ReceivedMessages.FirstOrDefault();
Assert.NotNull(msg);
string content = msg.GetStringContent();
if (fifo.HasValue && !fifo.Value)
{
Assert.Equal("Second Message", content);
}
else
{
Assert.Equal("First Message", content);
}
}
public async Task ClearMessages(bool priorityMessages, bool messages)
{
TestHorseMq server = new TestHorseMq();
await server.Initialize();
int port = server.Start();
HorseQueue queue = server.Server.FindQueue("push-a");
await queue.Push("Hello, World");
await queue.Push("Hello, World", true);
await Task.Delay(500);
HorseClient client = new HorseClient();
await client.ConnectAsync("hmq://localhost:" + port);
var result = await client.Queues.ClearMessages("push-a", priorityMessages, messages);
Assert.Equal(HorseResultCode.Ok, result.Code);
if (priorityMessages)
{
Assert.Empty(queue.PriorityMessages);
}
else
{
Assert.NotEmpty(queue.PriorityMessages);
}
if (messages)
{
Assert.Empty(queue.Messages);
}
else
{
Assert.NotEmpty(queue.Messages);
}
}
/// <summary>
/// Handles pushing a message into a queue
/// </summary>
private async Task HandlePush(MqClient client, HorseMessage message, HorseQueue queue, bool answerSender)
{
//check authority
foreach (IClientAuthorization authorization in _server.Authorizations)
{
bool grant = await authorization.CanMessageToQueue(client, queue, message);
if (!grant)
{
if (answerSender && !string.IsNullOrEmpty(message.MessageId))
{
await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized));
}
return;
}
}
//prepare the message
QueueMessage queueMessage = new QueueMessage(message);
queueMessage.Source = client;
//push the message
PushResult result = await queue.Push(queueMessage, client);
if (result == PushResult.StatusNotSupported)
{
if (answerSender)
{
await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized));
}
}
else if (result == PushResult.LimitExceeded)
{
if (answerSender)
{
await client.SendAsync(message.CreateResponse(HorseResultCode.LimitExceeded));
}
}
}
public async Task PullClearAfter(int count, bool priorityMessages, bool messages)
{
TestHorseMq server = new TestHorseMq();
await server.Initialize();
int port = server.Start();
HorseQueue queue = server.Server.FindQueue("pull-a");
for (int i = 0; i < 5; i++)
{
await queue.Push("Hello, World");
await queue.Push("Hello, World");
}
HorseClient client = new HorseClient();
await client.ConnectAsync("hmq://localhost:" + port);
HorseResult joined = await client.Queues.Subscribe("pull-a", true);
Assert.Equal(HorseResultCode.Ok, joined.Code);
ClearDecision clearDecision = ClearDecision.None;
if (priorityMessages && messages)
{
clearDecision = ClearDecision.AllMessages;
}
else if (priorityMessages)
{
clearDecision = ClearDecision.PriorityMessages;
}
else if (messages)
{
clearDecision = ClearDecision.Messages;
}
PullRequest request = new PullRequest
{
Queue = "pull-a",
Count = count,
ClearAfter = clearDecision
};
PullContainer container = await client.Queues.Pull(request);
Assert.Equal(count, container.ReceivedCount);
Assert.Equal(PullProcess.Completed, container.Status);
if (priorityMessages)
{
Assert.Empty(queue.PriorityMessages);
}
if (messages)
{
Assert.Empty(queue.Messages);
}
}
public async Task ReloadAfterRestart()
{
await Task.Delay(500);
ConfigurationFactory.Destroy();
RedeliveryService service = new RedeliveryService("data/reload-test.tdb.delivery");
await service.Load();
await service.Clear();
await service.Set("id", 4);
await service.Close();
if (System.IO.File.Exists("data/config.json"))
{
System.IO.File.Delete("data/config.json");
}
if (System.IO.File.Exists("data/reload-test.tdb"))
{
System.IO.File.Delete("data/reload-test.tdb");
}
if (System.IO.File.Exists("data/reload-test.tdb.delivery"))
{
System.IO.File.Delete("data/reload-test.tdb.delivery");
}
HorseServer server = new HorseServer();
PersistentDeliveryHandler handler = null;
Func <DeliveryHandlerBuilder, Task <IMessageDeliveryHandler> > fac = async builder =>
{
DatabaseOptions options = new DatabaseOptions
{
Filename = "data/reload-test.tdb",
InstantFlush = true,
CreateBackupOnShrink = false,
ShrinkInterval = TimeSpan.FromSeconds(60)
};
handler = (PersistentDeliveryHandler)await builder.CreatePersistentDeliveryHandler(o =>
{
return(new PersistentDeliveryHandler(builder.Queue,
options,
DeleteWhen.AfterSend,
ProducerAckDecision.None,
true));
});
return(handler);
};
HorseMq mq = server.UseHorseMq(cfg => cfg
.AddPersistentQueues(q => q.KeepLastBackup())
.UseDeliveryHandler(fac));
HorseQueue queue = await mq.CreateQueue("reload-test",
o => o.Status = QueueStatus.Push);
HorseMessage msg = new HorseMessage(MessageType.QueueMessage, "reload-test");
msg.SetMessageId("id");
msg.SetStringContent("Hello, World!");
await queue.Push(msg);
QueueMessage queueMsg = queue.Messages.FirstOrDefault();
await handler.BeginSend(queue, queueMsg);
await handler.RedeliveryService.Close();
ConfigurationFactory.Destroy();
mq = server.UseHorseMq(cfg => cfg
.AddPersistentQueues(q => q.KeepLastBackup())
.UseDeliveryHandler(fac));
await mq.LoadPersistentQueues();
HorseQueue queue2 = mq.FindQueue("reload-test");
Assert.NotNull(queue2);
Assert.NotEmpty(queue2.Messages);
QueueMessage loadedMsg = queue2.Messages.FirstOrDefault();
Assert.NotNull(loadedMsg);
Assert.Equal(1, loadedMsg.DeliveryCount);
}
