/// <summary>
/// Creates new router on the server
/// </summary>
public Router(HorseMq server, string name, RouteMethod method)
{
Server = server;
IsEnabled = true;
Name = name;
Method = method;
}
private static void Main(string[] args)
{
HorseMq mq = HorseMqBuilder.Create()
.AddClientHandler <ClientHandler>()
.AddQueueEventHandler <QueueEventHandler>()
.UseJustAllowDeliveryHandler()
.Build();
var sampleMessageRouter = mq.AddRouter("SAMPLE-MESSAGE-ROUTER", RouteMethod.Distribute);
var sampleMessageQueueBinding = new QueueBinding("sample-message-queue-binding", "SAMPLE-MESSAGE-QUEUE", 1, BindingInteraction.Response);
var sampleMessageDirectBinding = new DirectBinding("sample-message-direct-binding", "@type:SAMPLE-MESSAGE-CONSUMER", 2, BindingInteraction.Response, RouteMethod.RoundRobin);
sampleMessageRouter.AddBinding(sampleMessageQueueBinding);
sampleMessageRouter.AddBinding(sampleMessageDirectBinding);
var giveMeGuidRequestRouter = mq.AddRouter("GIVE-ME-REQUEST-ROUTER", RouteMethod.Distribute);
var giveMeGuidRequestHandler = new DirectBinding("sample-message-direct-binding", "@name:GIVE-ME-GUID-REQUEST-HANDLER-CONSUMER", 2, BindingInteraction.Response);
giveMeGuidRequestRouter.AddBinding(giveMeGuidRequestHandler);
HorseServer server = new HorseServer();
server.UseHorseMq(mq);
server.Run(15500);
}
/// <summary>
/// Name is definition of the event.
/// Target is the queue name of the event.
/// Content Type is the Queue Id of the event.
/// </summary>
protected EventManager(HorseMq server, string name, string target)
{
_server = server;
Name = name;
Target = target;
_cleanup = new Timer(s => CheckCleanup(), null, 60000, 60000);
}
/// <summary>
/// Loads all persistent queue messages from databases
/// </summary>
public static Task LoadPersistentQueues(this HorseMq server)
{
if (ConfigurationFactory.Builder == null)
{
throw new InvalidOperationException("Before loading queues initialize persistent queues with AddPersistentQueues method");
}
return(ConfigurationFactory.Manager.LoadQueues(server));
}
/// <summary>
/// Creates new persistent queue
/// </summary>
/// <param name="mq">Horse MQ</param>
/// <param name="queue">Queue Name</param>
/// <param name="deleteWhen">Decision, when messages will be removed from disk</param>
/// <param name="producerAckDecision">Decision, when ack will be sent to producer</param>
/// <returns></returns>
public static Task <HorseQueue> CreatePersistentQueue(this HorseMq mq,
string queue,
DeleteWhen deleteWhen,
ProducerAckDecision producerAckDecision)
{
QueueOptions options = QueueOptions.CloneFrom(mq.Options);
return(CreatePersistentQueue(mq, queue, deleteWhen, producerAckDecision, options));
}
internal HorseQueue(HorseMq server, string name, QueueOptions options)
{
Server = server;
Name = name;
Options = options;
Status = options.Status;
_clients = new SafeList <QueueClient>(256);
OnConsumerSubscribed = new SubscriptionEventManager(Server, EventNames.Subscribe, this);
OnConsumerUnsubscribed = new SubscriptionEventManager(Server, EventNames.Unsubscribe, this);
OnMessageProduced = new MessageEventManager(Server, EventNames.MessageProduced, this);
}
public HmqNetworkHandler(HorseMq server)
{
_server = server;
_serverHandler = new ServerMessageHandler(server);
_queueMessageHandler = new QueueMessageHandler(server);
_routerMessageHandler = new RouterMessageHandler(server);
_pullRequestHandler = new PullRequestMessageHandler(server);
_clientHandler = new DirectMessageHandler(server);
_responseHandler = new ResponseMessageHandler(server);
_instanceHandler = new NodeMessageHandler(server);
_eventHandler = new EventMessageHandler(server);
}
/// <summary>
/// Creates new persistent queue
/// </summary>
/// <param name="mq">Horse MQ Server</param>
/// <param name="queueName">Queue name</param>
/// <param name="options">Queue Options</param>
/// <param name="factory">Delivery handler instance creator factory</param>
/// <returns></returns>
public static async Task <HorseQueue> CreatePersistentQueue(this HorseMq mq,
string queueName,
QueueOptions options,
Func <DatabaseOptions, IPersistentDeliveryHandler> factory)
{
HorseQueue queue = await CreateQueue(mq, queueName, options, factory);
IPersistentDeliveryHandler deliveryHandler = (IPersistentDeliveryHandler)queue.DeliveryHandler;
ConfigurationFactory.Manager.Add(queue, deliveryHandler.DbFilename);
ConfigurationFactory.Manager.Save();
return(queue);
}
/// <summary>
/// Creates and returns persistent queue
/// </summary>
internal static async Task <HorseQueue> CreateQueue(HorseMq mq,
string queueName,
QueueOptions options,
Func <DatabaseOptions, IPersistentDeliveryHandler> factory)
{
return(await mq.CreateQueue(queueName, options, async builder =>
{
DatabaseOptions databaseOptions = ConfigurationFactory.Builder.CreateOptions(builder.Queue);
IPersistentDeliveryHandler handler = factory(databaseOptions);
await handler.Initialize();
return handler;
}));
}
/// <summary>
/// Creates new persistent queue
/// </summary>
/// <param name="mq">Horse MQ Server</param>
/// <param name="queueName">Queue name</param>
/// <param name="deleteWhen">Decision, when messages will be removed from disk</param>
/// <param name="producerAckDecision">Decision, when ack will be sent to producer</param>
/// <param name="options">Queue Options</param>
/// <returns></returns>
public static async Task <HorseQueue> CreatePersistentQueue(this HorseMq mq,
string queueName,
DeleteWhen deleteWhen,
ProducerAckDecision producerAckDecision,
QueueOptions options)
{
HorseQueue queue = await CreateQueue(mq, queueName, deleteWhen, producerAckDecision, options);
IPersistentDeliveryHandler deliveryHandler = (IPersistentDeliveryHandler)queue.DeliveryHandler;
ConfigurationFactory.Manager.Add(queue, deliveryHandler.DbFilename);
ConfigurationFactory.Manager.Save();
return(queue);
}
/// <summary>
/// Creates and returns persistent queue
/// </summary>
internal static async Task <HorseQueue> CreateQueue(HorseMq mq,
string queueName,
DeleteWhen deleteWhen,
ProducerAckDecision producerAckDecision,
QueueOptions options)
{
return(await mq.CreateQueue(queueName, options, async builder =>
{
DatabaseOptions databaseOptions = ConfigurationFactory.Builder.CreateOptions(builder.Queue);
PersistentDeliveryHandler handler = new PersistentDeliveryHandler(builder.Queue, databaseOptions, deleteWhen, producerAckDecision);
await handler.Initialize();
return handler;
}));
}
/// <summary>
/// Adds persistent queues with customized configuration
/// </summary>
public static HorseMq AddPersistentQueues(this HorseMq server,
Action <DataConfigurationBuilder> cfg)
{
DataConfigurationBuilder builder = new DataConfigurationBuilder();
cfg(builder);
if (builder.GenerateQueueFilename == null)
{
builder.GenerateQueueFilename = DefaultQueueDbPath;
}
ConfigurationFactory.Initialize(builder);
return(server);
}
static void Main(string[] args)
{
HorseMq mq = HorseMqBuilder.Create()
.AddOptions(o => o.Status = QueueStatus.Push)
.AddClientHandler <ClientHandler>()
.AddQueueEventHandler <QueueEventHandler>()
.AddPersistentQueues()
.UsePersistentDeliveryHandler(DeleteWhen.AfterAcknowledgeReceived, ProducerAckDecision.AfterSaved)
.Build();
mq.LoadPersistentQueues();
HorseServer server = new HorseServer();
server.UseHorseMq(mq);
server.Run(26222);
}
/// <summary>
/// Loads messages of queues in configuration
/// </summary>
public async Task LoadQueues(HorseMq server)
{
foreach (QueueConfiguration queueConfiguration in Config.Queues)
{
HorseQueue queue = server.FindQueue(queueConfiguration.Name);
if (queue == null)
{
if (server.DeliveryHandlerFactory != null)
{
queue = await server.CreateQueue(queueConfiguration.Name,
queueConfiguration.Configuration.ToOptions(),
async builder =>
{
builder.DeliveryHandlerHeader = queueConfiguration.DeliveryHandler;
IMessageDeliveryHandler handler = await server.DeliveryHandlerFactory(builder);
builder.OnAfterCompleted(b => { }); //don't trigger created events, it's already created and reloading
return(handler);
});
}
else
{
queue = await Extensions.CreateQueue(server,
queueConfiguration.Name,
(DeleteWhen)queueConfiguration.DeleteWhen,
(ProducerAckDecision)queueConfiguration.ProducerAck,
queueConfiguration.Configuration.ToOptions());
}
//queue creation not permitted, skip
if (queue == null)
{
continue;
}
}
else
{
if (queue.DeliveryHandler is IPersistentDeliveryHandler deliveryHandler)
{
await deliveryHandler.Initialize();
}
}
queueConfiguration.Queue = queue;
}
}
/// <summary>
/// Creates new MQ Client
/// </summary>
public MqClient(HorseMq server, IConnectionInfo info) : base(server.Server, info)
{
HorseMq = server;
IsConnected = true;
}
public EventMessageHandler(HorseMq server)
{
_server = server;
}
public QueueMessageHandler(HorseMq server)
{
_server = server;
}
public PullRequestMessageHandler(HorseMq server)
{
_server = server;
}
/// <summary>
/// Creates new client event manager
/// </summary>
public ClientEventManager(string eventName, HorseMq server)
: base(server, eventName, null)
{
}
public HmqWebSocketClient(WsServerSocket socket, HorseMq server, IConnectionInfo info, IUniqueIdGenerator generator, bool useUniqueMessageId = true)
: base(server, info, generator, useUniqueMessageId)
{
Socket = socket;
}
/// <summary>
/// Adds persistent queues with default configuration
/// </summary>
public static HorseMq AddPersistentQueues(this HorseMq server)
{
return(AddPersistentQueues(server, c => { }));
}
public async Task InPersistentHandler()
{
ConfigurationFactory.Destroy();
PersistentDeliveryHandler handler = null;
HorseServer server = new HorseServer();
HorseMq mq = server.UseHorseMq(cfg => cfg
.AddPersistentQueues(q => q.KeepLastBackup())
.UseDeliveryHandler(async builder =>
{
DatabaseOptions options = new DatabaseOptions
{
Filename = "redelivery-test.tdb",
InstantFlush = true,
CreateBackupOnShrink = false,
ShrinkInterval = TimeSpan.FromSeconds(60)
};
handler = new PersistentDeliveryHandler(builder.Queue,
options,
DeleteWhen.AfterSend,
ProducerAckDecision.None,
true);
await handler.Initialize();
return(handler);
}));
HorseQueue queue = await mq.CreateQueue("test");
HorseMessage message = new HorseMessage(MessageType.QueueMessage, "test");
message.SetMessageId("id");
message.SetStringContent("Hello, World!");
QueueMessage queueMessage = new QueueMessage(message);
await handler.BeginSend(queue, queueMessage);
List <KeyValuePair <string, int> > deliveries = handler.RedeliveryService.GetDeliveries();
Assert.Single(deliveries);
Assert.Equal("id", deliveries[0].Key);
Assert.Equal(1, deliveries[0].Value);
string header = message.FindHeader(HorseHeaders.DELIVERY);
Assert.Null(header);
await handler.BeginSend(queue, queueMessage);
deliveries = handler.RedeliveryService.GetDeliveries();
Assert.Single(deliveries);
Assert.Equal("id", deliveries[0].Key);
Assert.Equal(2, deliveries[0].Value);
header = message.FindHeader(HorseHeaders.DELIVERY);
Assert.NotNull(header);
Assert.Equal(2, Convert.ToInt32(header));
queueMessage.MarkAsSent();
await handler.EndSend(queue, queueMessage);
deliveries = handler.RedeliveryService.GetDeliveries();
Assert.Empty(deliveries);
}
public HmqWebSocketClient(WsServerSocket socket, HorseMq server, IConnectionInfo info) : base(server, info)
{
Socket = socket;
}
/// <summary>
/// Creates new MQ Client
/// </summary>
public MqClient(HorseMq server, IConnectionInfo info, IUniqueIdGenerator generator, bool useUniqueMessageId = true)
: base(server.Server, info, generator, useUniqueMessageId)
{
HorseMq = server;
IsConnected = true;
}
/// <summary>
/// Creates new message event manager
/// </summary>
public MessageEventManager(HorseMq server, string eventName, HorseQueue queue)
: base(server, eventName, queue.Name)
{
}
/// <summary>
/// Creates new client event manager
/// </summary>
public SubscriptionEventManager(HorseMq server, string eventName, HorseQueue queue)
: base(server, eventName, queue.Name)
{
}
public ServerMessageHandler(HorseMq server)
{
_server = server;
}
internal RouterMessageHandler(HorseMq server)
{
_server = server;
}
public DirectMessageHandler(HorseMq server)
{
_server = server;
}
public static void UseTmqOverWebSockets(this TwinoServer server, HorseMq mq)
{
throw new NotImplementedException();
}
