private static async Task <Bus> InitBus(IIISConfiguration cfg, HttpTransportService ts, IMessageQueueingService mqs)
{
var bus = new Bus(cfg, cfg.BaseUri, ts, mqs);
await ts.Init();
await bus.Init();
return(bus);
}
/// <summary>
/// Initializes a new <see cref="T:Platibus.IIS.PlatibusHttpModule" /> with the specified configuration
/// and any configuration hooks present in the app domain assemblies
/// </summary>
public PlatibusHttpModule(IIISConfiguration configuration)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
var managedBus = BusManager.SingletonInstance.GetManagedBus(_configuration);
_bus = managedBus.Bus;
_transportService = managedBus.TransportService;
}
/// <inheritdoc />
/// <summary>
/// Inititializes a new <see cref="T:Platibus.IIS.PlatibusHttpHandler" /> with the specified
/// <paramref name="bus" /> and <paramref name="configuration" />
/// </summary>
/// <param name="configuration">The bus configuration</param>
/// <param name="bus">The initialized bus instance</param>
/// <param name="transportService"></param>
/// <remarks>
/// Used internally by <see cref="T:Platibus.IIS.PlatibusHttpModule" />. This method bypasses the
/// configuration cache and singleton diagnostic service and metrics collector.
/// </remarks>
internal PlatibusHttpHandler(IIISConfiguration configuration, IBus bus, HttpTransportService transportService)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
Bus = bus ?? throw new ArgumentNullException(nameof(bus));
if (transportService == null)
{
throw new ArgumentNullException(nameof(transportService));
}
BaseUri = configuration.BaseUri;
_resourceRouter = InitResourceRouter(configuration, transportService);
}
static void Main(string[] args)
{
Console.WriteLine("Client application...");
// Read command line parameters.
int startupDelay = int.Parse(args[0]);
string dataFormat = args[1];
int dataWarehousePortNumber = int.Parse(args[2]);
Thread.Sleep(startupDelay);
Task t = Task.Run(async() =>
{
ITransportService transportService =
new HttpTransportService(dataFormat, dataWarehousePortNumber);
var userInteractor = new UserInteractor(transportService);
string input = String.Empty;
do
{
Console.WriteLine(
"\nChoose an option:" +
"\n1. Retreive the list of Employees from the DataWarehouse" +
"\n2. Retreive data for the specified Employee" +
"\n3. Update an Employee using its ID" +
"\n4. Exit");
try
{
input = Console.ReadLine();
switch (input)
{
case "1":
await userInteractor.RetreiveEmployees();
break;
case "2":
await userInteractor.RetreiveEmployee();
break;
case "3":
await userInteractor.UpdateEmployee();
break;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
} while (input != "4");
});
t.Wait();
Console.ReadLine();
}
public async Task StartAsync(string configSectionName, Func <OwinConfiguration, Task> configure = null)
{
var serverPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, configSectionName);
var serverDirectory = new DirectoryInfo(serverPath);
serverDirectory.Refresh();
if (serverDirectory.Exists)
{
serverDirectory.Delete(true);
}
var configuration = new OwinConfiguration();
var configurationManager = new OwinConfigurationManager();
await configurationManager.Initialize(configuration, configSectionName);
#pragma warning disable 612
await configurationManager.FindAndProcessConfigurationHooks(configuration);
#pragma warning restore 612
if (configure != null)
{
await configure(configuration);
}
var baseUri = configuration.BaseUri;
_subscriptionTrackingService = configuration.SubscriptionTrackingService;
_messageQueueingService = configuration.MessageQueueingService;
var transportServiceOptions = new HttpTransportServiceOptions(baseUri, _messageQueueingService, _subscriptionTrackingService)
{
DiagnosticService = configuration.DiagnosticService,
Endpoints = configuration.Endpoints,
MessageJournal = configuration.MessageJournal,
BypassTransportLocalDestination = configuration.BypassTransportLocalDestination
};
_transportService = new HttpTransportService(transportServiceOptions);
var bus = new Bus(configuration, baseUri, _transportService, _messageQueueingService);
_transportService.MessageReceived += (sender, args) => bus.HandleMessage(args.Message, args.Principal);
await _transportService.Init();
await bus.Init();
Bus = bus;
_middleware = new PlatibusMiddleware(configuration, bus, _transportService);
_webapp = WebApp.Start(baseUri.ToString(), app => app.UsePlatibusMiddleware(_middleware));
}
private static void Main(string[] args)
{
Console.WriteLine("Server application...");
Thread.Sleep(1000);
Task t = Task.Run(async() =>
{
// === Read settings ===
// Emplyees file name.
string employeesFileName = args[0];
// Server port.
string serverPortSetting = args[1];
int serverPort = int.Parse(serverPortSetting);
// Data format.
string dataFormat = args[2];
// Read Employees data from the XML file.
string employeesDataText =
File.ReadAllText("D:\\DistributionCollections\\" + employeesFileName);
Employee[] employees =
await UtilityXml.DeserializeXmlAsync <Employee[]>(employeesDataText, rootElementName: "Employees");
// Add Employees to the repository.
employees.ToList().ForEach(e =>
{
EmployeeRepository.Instance.Add(e);
});
// PUT all employees data to the DataWarehouse.
foreach (Employee employee in employees)
{
await SendEmployee(employee, dataFormat, serverPort);
}
// Run the HTTP Transport Service.
var httpTransportService = new HttpTransportService(serverPort, dataFormat);
httpTransportService.Start();
Thread.Sleep(60000);
httpTransportService.Stop();
});
t.Wait();
Console.ReadLine();
}
private static async Task <IAppBuilder> UsePlatibusMiddlewareAsync(this IAppBuilder app,
IOwinConfiguration configuration)
{
var baseUri = configuration.BaseUri;
var subscriptionTrackingService = configuration.SubscriptionTrackingService;
var messageQueueingService = configuration.MessageQueueingService;
var transportServiceOptions = new HttpTransportServiceOptions(baseUri, messageQueueingService, subscriptionTrackingService)
{
DiagnosticService = configuration.DiagnosticService,
Endpoints = configuration.Endpoints,
MessageJournal = configuration.MessageJournal,
BypassTransportLocalDestination = configuration.BypassTransportLocalDestination
};
var transportService = new HttpTransportService(transportServiceOptions);
var bus = new Bus(configuration, baseUri, transportService, messageQueueingService);
await transportService.Init();
await bus.Init();
var middleware = new PlatibusMiddleware(configuration, bus, transportService);
var appProperties = new AppProperties(app.Properties);
appProperties = appProperties.Set("platibus.Bus", bus);
appProperties.OnAppDisposing.Register(() =>
{
middleware.Dispose();
transportService.Dispose();
bus.Dispose();
(messageQueueingService as IDisposable)?.Dispose();
(subscriptionTrackingService as IDisposable)?.Dispose();
});
return(app.Use(middleware.Invoke));
}
public async Task TransportExceptionThrownIfConnectionRefused()
{
var endpoint = new UriBuilder
{
Scheme = "http",
Host = "localhost",
Port = 53062,
Path = "/platibus.test/"
}.Uri;
var transportServiceOptions = new HttpTransportServiceOptions(endpoint, new InMemoryMessageQueueingService(), new InMemorySubscriptionTrackingService());
var transportService = new HttpTransportService(transportServiceOptions);
var message = new Message(new MessageHeaders
{
{ HeaderName.ContentType, "text/plain" },
{ HeaderName.MessageId, Guid.NewGuid().ToString() },
{ HeaderName.Destination, endpoint.ToString() },
{ HeaderName.Synchronous, "true" }
}, "Hello, world!");
await Assert.ThrowsAsync <ConnectionRefusedException>(() => transportService.SendMessage(message));
}
/// <summary>
/// Initializes a new <see cref="ManagedBus"/> with the specified <paramref name="configuration"/>
/// </summary>
/// <param name="configuration">The configuration used to initialize the bus instance
/// and its related components</param>
public ManagedBus(IIISConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
var baseUri = configuration.BaseUri;
_subscriptionTrackingService = configuration.SubscriptionTrackingService;
_messageQueueingService = configuration.MessageQueueingService;
_messageJournal = configuration.MessageJournal;
var transportServiceOptions = new HttpTransportServiceOptions(baseUri, _messageQueueingService, _subscriptionTrackingService)
{
DiagnosticService = configuration.DiagnosticService,
Endpoints = configuration.Endpoints,
MessageJournal = configuration.MessageJournal,
BypassTransportLocalDestination = configuration.BypassTransportLocalDestination
};
TransportService = new HttpTransportService(transportServiceOptions);
Bus = InitBus(configuration, TransportService, _messageQueueingService).GetResultFromCompletionSource();
}
private static IHttpResourceRouter InitResourceRouter(IIISConfiguration configuration, HttpTransportService transportService)
{
var authorizationService = configuration.AuthorizationService;
var subscriptionTrackingService = configuration.SubscriptionTrackingService;
return(new ResourceTypeDictionaryRouter(configuration.BaseUri)
{
{ "message", new MessageController(transportService.ReceiveMessage, authorizationService) },
{ "topic", new TopicController(subscriptionTrackingService, configuration.Topics, authorizationService) },
{ "journal", new JournalController(configuration.MessageJournal, configuration.AuthorizationService) },
{ "metrics", new MetricsController(SingletonMetricsCollector) }
});
}
/// <summary>
/// Adds Platibus services to the specified service collection
/// </summary>
/// <param name="services">The service collection to which the Platibus services will
/// be added</param>
public static void AddPlatibus(this IServiceCollection services)
{
services.AddSingleton <AspNetCoreLoggingSink>();
services.AddSingleton(serviceProvider => serviceProvider.GetService <IAspNetCoreConfiguration>().DiagnosticService);
services.AddSingleton(serviceProvider => serviceProvider.GetService <IAspNetCoreConfiguration>().MessageQueueingService);
services.AddSingleton(serviceProvider => serviceProvider.GetService <IAspNetCoreConfiguration>().SubscriptionTrackingService);
services.AddSingleton(serviceProvider => serviceProvider.GetService <IAspNetCoreConfiguration>().MessageJournal);
services.AddSingleton(serviceProvider => serviceProvider.GetService <IAspNetCoreConfiguration>().AuthorizationService);
services.AddSingleton(serviceProvider =>
{
var diagnosticsService = serviceProvider.GetService <IDiagnosticService>();
var metricsCollector = new HttpMetricsCollector();
diagnosticsService.AddSink(metricsCollector);
return(metricsCollector);
});
services.AddSingleton <ITransportService>(serviceProvider =>
{
var configuration = serviceProvider.GetService <IAspNetCoreConfiguration>();
var diagnosticsService = serviceProvider.GetService <IDiagnosticService>();
var messageQueueingService = serviceProvider.GetService <IMessageQueueingService>();
var subscriptionTrackingService = serviceProvider.GetService <ISubscriptionTrackingService>();
var messageJournal = serviceProvider.GetService <IMessageJournal>();
var transportServiceOptions = new HttpTransportServiceOptions(configuration.BaseUri, messageQueueingService, subscriptionTrackingService)
{
DiagnosticService = diagnosticsService,
Endpoints = configuration.Endpoints,
MessageJournal = messageJournal,
HttpClientFactory = configuration.HttpClientFactory,
BypassTransportLocalDestination = configuration.BypassTransportLocalDestination
};
var transportService = new HttpTransportService(transportServiceOptions);
transportService.Init().WaitOnCompletionSource();
return(transportService);
});
services.AddSingleton <IHttpResourceRouter>(serviceProvider =>
{
var configuration = serviceProvider.GetService <IAspNetCoreConfiguration>();
var transportService = serviceProvider.GetService <ITransportService>();
var subscriptionTrackingService = serviceProvider.GetService <ISubscriptionTrackingService>();
var messageJournal = serviceProvider.GetService <IMessageJournal>();
var metricsCollector = serviceProvider.GetService <HttpMetricsCollector>();
var authorizationService = serviceProvider.GetService <IAuthorizationService>();
return(new ResourceTypeDictionaryRouter(configuration.BaseUri)
{
{ "message", new MessageController(transportService.ReceiveMessage, authorizationService) },
{ "topic", new TopicController(subscriptionTrackingService, configuration.Topics, authorizationService) },
{ "journal", new JournalController(messageJournal, authorizationService) },
{ "metrics", new MetricsController(metricsCollector) }
});
});
services.AddSingleton <IBus>(serviceProvider =>
{
var configuration = serviceProvider.GetService <IAspNetCoreConfiguration>();
var transportService = serviceProvider.GetService <ITransportService>();
var messageQueueingService = serviceProvider.GetService <IMessageQueueingService>();
var bus = new Bus(configuration, configuration.BaseUri, transportService, messageQueueingService);
bus.Init().WaitOnCompletionSource();
return(bus);
});
}
public PlatibusMiddleware(IOwinConfiguration configuration, IBus bus, HttpTransportService transportService)
{
Configuration = configuration ?? throw new ArgumentNullException(nameof(bus));
Bus = bus ?? throw new ArgumentNullException(nameof(bus));
_resourceRouter = InitResourceRouter(Configuration, transportService);
}
