/// <summary>
/// Initializes a new <see cref="TopicController"/>
/// </summary>
/// <param name="subscriptionTrackingService">The subscription tracking service</param>
/// <param name="topics">The list of defined topics</param>
/// <param name="authorizationService">(Optional) Used to determine whether
/// a requestor is authorized to subscribe to a topic</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="subscriptionTrackingService"/>
/// is <c>null</c></exception>
public TopicController(ISubscriptionTrackingService subscriptionTrackingService, IEnumerable <TopicName> topics, IAuthorizationService authorizationService = null)
{
_subscriptionTrackingService = subscriptionTrackingService ?? throw new ArgumentNullException(nameof(subscriptionTrackingService));
_authorizationService = authorizationService;
_topics = (topics ?? Enumerable.Empty <TopicName>())
.Where(t => t != null)
.ToList();
}
public TopicController(ISubscriptionTrackingService subscriptionTrackingService, IEnumerable<TopicName> topics)
{
if (subscriptionTrackingService == null) throw new ArgumentNullException("subscriptionTrackingService");
_subscriptionTrackingService = subscriptionTrackingService;
_topics = (topics ?? Enumerable.Empty<TopicName>())
.Where(t => t != null)
.ToList();
}
/// <summary>
/// Initializes a new <see cref="MulticastSubscriptionTrackingService"/> decorating the
/// specified <paramref name="inner"/> <see cref="ISubscriptionTrackingService"/>
/// configured to broadcast and consume changes over the multicast group at the specified
/// <paramref name="groupAddress"/>.
/// </summary>
/// <param name="inner">The underlying subscription tracking service used to persist or
/// maintain subscription state</param>
/// <param name="groupAddress">The address of the multicast group to join</param>
/// <param name="port">The local port to bind to</param>
/// <param name="diagnosticService">(Optional) The service through which diagnostic events
/// are reported and processed</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="inner"/> or
/// <paramref name="groupAddress"/> is <c>null</c></exception>
/// <exception cref="ArgumentException">Thrown if <paramref name="groupAddress"/> does not
/// specify a compatible <see cref="AddressFamily"/></exception>
/// <exception cref="SocketException">Thrown if there is an error joining the multicast
/// group, i.e. due to an invalid multicast address.</exception>
/// <remarks>
/// The multicast group <paramref name="groupAddress"/> must be on the 224.0.0/4 subnet
/// </remarks>
public MulticastSubscriptionTrackingService(ISubscriptionTrackingService inner, IPAddress groupAddress, int port, IDiagnosticService diagnosticService = null)
{
_nodeId = NodeId.Generate();
_inner = inner ?? throw new ArgumentNullException(nameof(inner));
_groupAddress = groupAddress ?? throw new ArgumentNullException(nameof(groupAddress));
_port = port;
_diagnosticService = diagnosticService ?? DiagnosticService.DefaultInstance;
_broadcastClient = new UdpClient
{
ExclusiveAddressUse = false
};
_broadcastClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_broadcastClient.JoinMulticastGroup(groupAddress, IPAddress.Any);
_broadcastClient.Ttl = 2;
_broadcastClient.Client.Bind(new IPEndPoint(IPAddress.Any, 0));
var broadcastBinding = (IPEndPoint)_broadcastClient.Client.LocalEndPoint;
_diagnosticService.Emit(new MulticastEventBuilder(this, MulticastEventType.BroadcastSocketBound)
{
Node = _nodeId.ToString(),
Host = broadcastBinding.Address.ToString(),
Port = broadcastBinding.Port
}.Build());
_listenerClient = new UdpClient
{
ExclusiveAddressUse = false
};
_listenerClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_listenerClient.JoinMulticastGroup(groupAddress, IPAddress.Any);
_listenerClient.Client.Bind(new IPEndPoint(IPAddress.Any, _port));
var listenerBinding = (IPEndPoint)_listenerClient.Client.LocalEndPoint;
_diagnosticService.Emit(new MulticastEventBuilder(this, MulticastEventType.ListenerSocketBound)
{
Node = _nodeId.ToString(),
Host = listenerBinding.Address.ToString(),
Port = listenerBinding.Port
}.Build());
_cancellationTokenSource = new CancellationTokenSource();
_receiveResultQueue = new ActionBlock <UdpReceiveResult>(HandleReceiveResult,
new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = 2
});
_listenTask = Task.Run(async() => await Listen(_cancellationTokenSource.Token));
_diagnosticService.Emit(new MulticastEventBuilder(this, MulticastEventType.ListenerStarted)
{
Node = _nodeId.ToString(),
Host = listenerBinding.Address.ToString(),
Port = listenerBinding.Port
}.Build());
}
/// <summary>
/// Initializes a new <see cref="MulticastSubscriptionTrackingService"/> based on
/// the specified <paramref name="configuration"/> and wrapping the supplied
/// <paramref name="inner"/> subscription tracking service.
/// </summary>
/// <param name="configuration">The multicast configuration</param>
/// <param name="inner">The subscription tracking service that is being wrapped
/// by the multicast subscription tracking service</param>
/// <returns></returns>
public Task <ISubscriptionTrackingService> InitSubscriptionTrackingService(MulticastElement configuration,
ISubscriptionTrackingService inner)
{
if (configuration == null || !configuration.Enabled)
{
return(Task.FromResult(inner));
}
var multicastTrackingService = new MulticastSubscriptionTrackingService(
inner, configuration.Address, configuration.Port);
return(Task.FromResult <ISubscriptionTrackingService>(multicastTrackingService));
}
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));
}
public HttpTransportService(Uri baseUri, IEndpointCollection endpoints,
IMessageQueueingService messageQueueingService, IMessageJournal messageJournal,
ISubscriptionTrackingService subscriptionTrackingService,
bool bypassTransportLocalDestination = false,
IDiagnosticService diagnosticService = null)
: this(new HttpTransportServiceOptions(baseUri, messageQueueingService, subscriptionTrackingService)
{
DiagnosticService = diagnosticService,
Endpoints = endpoints,
MessageJournal = messageJournal,
BypassTransportLocalDestination = bypassTransportLocalDestination,
HttpClientFactory = new BasicHttpClientFactory()
})
{
}
public HttpTransportService(Uri baseUri, IEndpointCollection endpoints, IMessageQueueingService messageQueueingService, IMessageJournalingService messageJournalingService, ISubscriptionTrackingService subscriptionTrackingService)
{
if (baseUri == null) throw new ArgumentNullException("baseUri");
if (messageQueueingService == null) throw new ArgumentNullException("messageQueueingService");
if (subscriptionTrackingService == null) throw new ArgumentNullException("subscriptionTrackingService");
_baseUri = baseUri;
_endpoints = endpoints == null
? ReadOnlyEndpointCollection.Empty
: new ReadOnlyEndpointCollection(endpoints);
_messageQueueingService = messageQueueingService;
_messageJournalingService = messageJournalingService;
_subscriptionTrackingService = subscriptionTrackingService;
_outboundQueueName = "Outbound";
}
private HttpServer(IHttpServerConfiguration configuration)
{
_baseUri = configuration.BaseUri;
_metricsCollector = new HttpMetricsCollector();
_diagnosticService = configuration.DiagnosticService;
_diagnosticService.AddSink(_metricsCollector);
_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 = new Bus(configuration, _baseUri, TransportService, _messageQueueingService);
var authorizationService = configuration.AuthorizationService;
_resourceRouter = 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(_metricsCollector) }
};
_httpListener = InitHttpListener(_baseUri, configuration.AuthenticationSchemes);
var acceptBlockOptions = new ExecutionDataflowBlockOptions
{
CancellationToken = _cancellationTokenSource.Token
};
if (configuration.ConcurrencyLimit > 0)
{
acceptBlockOptions.MaxDegreeOfParallelism = configuration.ConcurrencyLimit;
}
_acceptBlock = new ActionBlock <HttpListenerContext>(async ctx => await Accept(ctx), acceptBlockOptions);
}
/// <summary>
/// Initializes a new <see cref="MulticastSubscriptionTrackingService"/> based on
/// the specified <paramref name="configuration"/> and wrapping the supplied
/// <paramref name="inner"/> subscription tracking service.
/// </summary>
/// <param name="configuration">The multicast configuration</param>
/// <param name="inner">The subscription tracking service that is being wrapped
/// by the multicast subscription tracking service</param>
/// <returns></returns>
public Task <ISubscriptionTrackingService> InitSubscriptionTrackingService(IConfiguration configuration,
ISubscriptionTrackingService inner)
{
var multicastSection = configuration?.GetSection("multicast");
var multicastEnabled = multicastSection?.GetValue <bool>("enabled") ?? false;
if (!multicastEnabled)
{
return(Task.FromResult(inner));
}
var ipAddress = multicastSection.GetValue("address", IPAddress.Parse(MulticastDefaults.Address));
var port = multicastSection.GetValue("port", MulticastDefaults.Port);
var multicastTrackingService = new MulticastSubscriptionTrackingService(inner, ipAddress, port);
return(Task.FromResult <ISubscriptionTrackingService>(multicastTrackingService));
}
private async Task Init(CancellationToken cancellationToken = default(CancellationToken))
{
_configuration = await IISConfigurationManager.LoadConfiguration();
_baseUri = _configuration.BaseUri;
_subscriptionTrackingService = _configuration.SubscriptionTrackingService;
_messageQueueingService = _configuration.MessageQueueingService;
_messageJournalingService = _configuration.MessageJournalingService;
var endpoints = _configuration.Endpoints;
_transportService = new HttpTransportService(_baseUri, endpoints, _messageQueueingService, _messageJournalingService, _subscriptionTrackingService);
_bus = new Bus(_configuration, _baseUri, _transportService, _messageQueueingService);
await _transportService.Init(cancellationToken);
await _bus.Init(cancellationToken);
_resourceRouter = new ResourceTypeDictionaryRouter
{
{"message", new MessageController(_bus.HandleMessage)},
{"topic", new TopicController(_subscriptionTrackingService, _configuration.Topics)}
};
}
/// <summary>
/// Initializes a new <see cref="HttpTransportService"/>
/// </summary>
/// <param name="options">The HTTP transport service configuration</param>
public HttpTransportService(HttpTransportServiceOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_baseUri = options.BaseUri.WithTrailingSlash();
_endpoints = options.Endpoints = options.Endpoints ?? EndpointCollection.Empty;
_messageQueueingService = options.MessageQueueingService;
_messageJournal = options.MessageJournal;
_subscriptionTrackingService = options.SubscriptionTrackingService;
_bypassTransportLocalDestination = options.BypassTransportLocalDestination;
_diagnosticService = options.DiagnosticService ?? DiagnosticService.DefaultInstance;
_httpClientFactory = options.HttpClientFactory ?? new BasicHttpClientFactory();
_outboundQueueName = "Outbound";
}
/// <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 HttpServer(IHttpServerConfiguration configuration)
{
_baseUri = configuration.BaseUri;
_subscriptionTrackingService = configuration.SubscriptionTrackingService;
_messageQueueingService = configuration.MessageQueueingService;
_messageJournalingService = configuration.MessageJournalingService;
var endpoints = configuration.Endpoints;
_transportService = new HttpTransportService(_baseUri, endpoints, _messageQueueingService, _messageJournalingService, _subscriptionTrackingService);
_bus = new Bus(configuration, _baseUri, _transportService, _messageQueueingService);
_resourceRouter = new ResourceTypeDictionaryRouter
{
{"message", new MessageController(_bus.HandleMessage)},
{"topic", new TopicController(_subscriptionTrackingService, configuration.Topics)}
};
_httpListener = InitHttpListener(_baseUri, configuration.AuthenticationSchemes);
}
/// <summary>
/// Initializes a new set of <see cref="HttpTransportServiceOptions"/>
/// </summary>
/// <param name="baseUri">The base URI of the application</param>
/// <param name="messageQueueingService">The message queueing service used
/// to queue outbound messages</param>
/// <param name="subscriptionTrackingService">The subscription tracking service</param>
public HttpTransportServiceOptions(Uri baseUri, IMessageQueueingService messageQueueingService, ISubscriptionTrackingService subscriptionTrackingService)
{
BaseUri = baseUri ?? throw new ArgumentNullException(nameof(baseUri));
MessageQueueingService = messageQueueingService ?? throw new ArgumentNullException(nameof(messageQueueingService));
SubscriptionTrackingService = subscriptionTrackingService ?? throw new ArgumentNullException(nameof(subscriptionTrackingService));
}
