Verteilte Architektur mit Masstransit, RabbitMQ und SignalR

Question

Ich entwickle verteilte Anwendung mit Hilfe von MassTransit und rabbitmq

Ich habe Möglichkeit zu bieten, Bericht auf einer Webseite ohne Seite Nachladen durch Klick auf eine Schaltfläche zu generieren, habe ich auch sollte einen Windows-Dienst für die Datenaufbereitung aufrufen (Der Dienst bearbeitet jede Anfrage für 30sek - 1min).

Mein erster Versuch an dieser Probe basiert: https://github.com/MassTransit/Sample-RequestResponse

[HttpPost] 
    public async Task<HttpStatusCodeResult> GenerateReport(string someJsonData) 
    {  
     var serviceAddress = new Uri(ConfigurationManager.AppSettings["BaseLineRecordService"]); 
     var client = this.Bus.CreateRequestClient<ICreateReportRequest, ICreateReportResponse>(serviceAddress, TimeSpan.FromHours(1)); 
     ICreateReportResponse response = await client.Request(new CreateReportRequest()); 
     reportHub.ShowRepordData(response); // Update data by SingleR 
     return new HttpStatusCodeResult(200); 
    } 

Aber wie ich sie verstehe es nicht eine bessere Lösung, weil ich Verbindung Vorbereitung während alle Daten halten werde.

Ich habe viele Artikel gelesen und ich habe drei Wege gefunden. Welcher Weg wird bevorzugt?

1) Wie auf diesem Artikel http://www.maldworth.com/2015/07/19/signalrchat-with-masstransit-v3/

2) Als erstes, aber mit dem Rest API anstelle den Verbraucher von IIS Seite

Aufruf

3) Idee aus diesem Artikel http://weblog.west-wind.com/posts/2013/Sep/04/SelfHosting-SignalR-in-a-Windows-Service

Answer 1

Ich mache dies mit Hubs von SignalR, und beobachten Sie Ereignisse auf dem Server mit regulären MassTransit-Verbraucher. Wenn Ereignisse beobachtet werden, trigger ich den Event-Handler, der den Hub an verbundene Clients sendet. Auf diese Weise werden die Ereignisse bis zum Browser geschoben, ohne einen asynchronen Anruf auf dem Server in einem Controller ausstehen zu lassen.

können Sie diese sehen in Fooidity der ähnlich etwas tut:

https://github.com/phatboyg/Fooidity/blob/develop/src/Fooidity.Management.Web/Hubs/ApplicationHubEventHandler.cs#L18

die GlobalHost Mit dem Hub zu lösen, dann auf der Nabe das Verfahren zu erhöhen. Der Ereigniskontext kann durch Verwendung von Gruppen unterschieden werden, die ein SignalR-Merkmal sind, das pro Knoten behandelt wird. Solange jeder Knoten das Ereignis beobachtet, können Clients mit jedem Hub verbunden und benachrichtigt werden. Dies funktioniert gut für den Lastenausgleich, ohne dass eine schwere Cluster-Backplane für SignalR verwendet werden muss - da RabbitMQ für die Ereignisverteilung superleicht ist.

Sie können es auch mit nicht dauerhaften Warteschlangen machen, was es noch schneller macht - da ein Serverreset/Verbindungsabbruch wahrscheinlicher ist als ein Brokerabsturz.

Authentifizierung innerhalb der ApplicationHub behandelt, wie es in der benachbarten Quelldatei angezeigt: https://github.com/phatboyg/Fooidity/blob/develop/src/Fooidity.Management.Web/Hubs/ApplicationHub.cs

Check it out, hoffentlich hilft es.