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