sweetlandj / platibus Goto Github PK

Implement ISubscriptionTrackingService backed by ADO.NET provider to support storing subscription information in a database.

For getting the status of the queue, memory usage, and statistics something like 'GET /queues/myqueue' or similar would be helpful.

Implement IMessageQueueingService with MongoDB backend.

SQLite message queueing service.

Implement IMessageQueueingService backed by an ADO.NET provider to allow messages to be queued in a database.

Currently handler queues are named by taking the MD5 hash of the handler type name. This is done to ensure that the queue names:

• Are short enough to not run afoul of path length restrictions in Windows
• Are unique (enough)
• Are consistent across restarts

We need to continue to meet the above goals while addressing the following:

• Queue names should be descriptive
• Queue names should be intuitive
• Queue names should be discoverable/navigable

Possible solutions:

• Change the default to use the Type.Name (not Type.FullName) truncated at a certain number of characters with a small(er) hash of the full name to ensure uniqueness
• Introduce a [Queue] attribute for the HandleMessage method(s) that indicates the queue name, max concurrency, max retries, etc. for queues used for handling rules targeting those methods

I think it'd be super nice to have some UI add-on for ASP.NET (maybe a middleware) that can show real-time or history message traffic from Platibus. I think this would help a lot with dev, debugging, and the overall understanding of messaging in the application and between other application.

Would you prefer to have something like this added to this repo or another repo?

Implement ISubscriptionTrackingService with MongoDB backend

Introduce a container abstraction that can be used to register Platibus components such as:

• IMessageQueueingService
• ISubscriptionTrackingService
• ITransportService
• IMessageJournalingService
• SendRule (collection)
• Subscription (collection)
• HandlingRule (collection)
• IConfigurationHook (collection)

This would enable external dependencies to be injected i.e. into an IConfigurationHook implementation and message handlers without relying on assembly scanning and service locators.

Calls to IBus.Send(object, EndpointName, SendOptions, CancellationToken) fail with EndpointNotFoundException when using the LoopbackHost despite the inability to configure endpoints in the LoopbackConfiguration.

Expected Result

Messages should be "looped back" to the originating bus instance and handled there according to the handling rules that have been registered.

Actual Result

EndpointNotFoundException is thrown from the call to IBus.Send.

Implement a transport service that uses RabbitMQ queues to communicate messages and subscription requests between applications. Each application could have a queue each for inbound messages, and one queue per topic, using fanout exchanges to publish messages to the topic queues. Subscription requests would just set up consumers listening to the remote topic queues. Direct message delivery would occur by simply publishing messages to the receiving applications inbound queue.

TODO: come up with a URI scheme / base URI syntax for queue naming. Possible examples:

• Inbound queue: urn:{host}[;{port}]/platibus/messages
• Topic queue: urn:{host}[;{port}]/platibus/topic/{topic}

Determine whether it is possible to create an ITransportService based on SignalR. The goal would be to see whether we could support async messaging from a Javascript client (i.e. browser) and a Pluribus server. It would also be interesting to see if SignalR could be used for server-to-server communications as well.

Bummer I can't submit a PR to the wiki because of how it works on GitHub, but I pushed my own fork with the addition here.

https://github.com/tdbrian/PlatibusWiki/blob/master/1.-Installation.md#platibusaspnetcore

Platibus.AspNetCore

AspNetCore support is provided in the Platibus.AspNetCore package. This package allows for configuration through ConfigurePlatibus on the IServiceCollection and middleware setup through UsePlatibusMiddleware on the IApplicationBuilder. This library provides a .Net Core logging sink as well.

To install, search for and install the package Platibus.AspNetCore in the NuGet package manager or run the following PowerShell command from the NuGet Package Manager Console:

PM> Install-Package Platibus.AspNetCore

Investigate using an IHttpHandlerFactory that will create and cache PlatibusHttpHandler instances dynamically based on the baseUri attributes specified in PlatibusConfigSections in web.config.

• Support relative paths in baseUri (e.g. "~/platibus")
• Match HttpContext.Request.Path to relative paths in config sections and construct a baseUri dynamically
• Catch and return PlatibusHandler instances based on the appropriate configuration sections

This will enable support for multiple instances of Platibus in a single IIS-hosed web app, and will eliminate the need to ensure that the host, ports, and paths for the site, PlatibusConfigurationSection, and configuration all match.

The HTTP transport currently supports NTLM authentication by using the default network credentials when making requests to the server. This needs to be more configurable to allow the client to specify whether credentials should be sent; whether NTLM or basic auth should be used; and to override credentials if necessary.

Subscriptions fail when a trailing slash is not included in the base URI. The HTTP transport service should implement better logic for concatenating URI path segments so that the trailing slash is not required.

Create StartTransaction extension method for IMessageContext that will create and return a new TransactionScope and register a delegate on the Transaction.Current.TransactionCompleted event that will call IMessageContext.Acknowledge() if the transaction status is TransactionStatus.Committed.

Example usage:

using (var scope = messageContext.StartTransaction())
{
   // Do work
    scope.Complete();
}

Intro documentation and quick-start guide for Github landing page

Implement abstractions (IMessageJournalingService) and implementation (FilesystemMessageJournalingService) for journaling inbound and outbound messages. Add journaling service configuration to IPluribusConfiguration, PluribusConfiguration, and PluribusConfigurationSection. Wire up journaling service based on configuration in Bootstrapper.

Events to capture:

• Message sent
• Message received
• Message processed
• Message processing failed (max retries exceeded)

Provide an IMessageJournal implementation that reads and writes message journal entries in ElasticSearch

If a message is sent with the UseDurableTransport=false send option then that should be conveyed to the receiver. The receiver, at its discretion, can honor that flag and immediately process the message in the handling thread (Bus.OnMessageReceived) rather than queueing and returning immediately. In this case, the HTTP response code would be 200 OK or a specific 4XX/5XX error code rather than 201 Accepted.

Determine whether it is feasible to implement IMessageQueuingService based on RabbitMQ given the current contracts. Determine what if any changes need to be made to the interface to support RabbitMQ.

Do a Redis implementation of the IMessageQueueingService

Implement a REST API that will enable remote Platibus instances to request configuration from a primary instance or configuration server. In addition, provide an IPlatibusConfiguration implementation that will make this call and retrieve configuration from the remote server, as well as a ConfigurationSection that can be used to declaratively specify the base URIs of the primary instance / configuration server. Finally, provide an ISubscriptionTrackingService that will POST or DELETE subscription info to the primary instance / configuration server as it is updated.

We should create an IConfigurationProvider abstraction with multiple implementation such as:

• AppConfigConfigurationProvider -- reads from app.config or web.config
• SqlConfigurationProvider -- Reads and configuration from database
• HttpConfigurationProvider -- REST API for reading config as a JSON document
• (etc.)

In the future we might want to consider an IBus shim implementation that will "phone home" and update its configuration (creating a new bus instance) and then swap out the old instance for the new instance when configuration changes in a way that is transparent to any consumers o the IBus interface.

Add a discrete timestamp column to the PB_MessageJournal table to enable roll-off of older messages by date.

Provide an IDiagnosticEventSink that writes directly to ElasticSearch

Provide a means to prevent journaling of sent messages; received messages; and/or published messages depending on the needs of the application.