Example #1
0
        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));
        }
Example #2
0
        private RabbitMQHost(IRabbitMQHostConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException(nameof(configuration));
            }

            var diagnosticService = configuration.DiagnosticService;
            var baseUri           = configuration.BaseUri.WithoutTrailingSlash();

            _connectionManager = new ConnectionManager();
            var encoding = configuration.Encoding ?? Encoding.UTF8;

            var defaultQueueOptions = new QueueOptions
            {
                AutoAcknowledge  = configuration.AutoAcknowledge,
                MaxAttempts      = configuration.MaxAttempts,
                ConcurrencyLimit = configuration.ConcurrencyLimit,
                RetryDelay       = configuration.RetryDelay,
                IsDurable        = configuration.IsDurable
            };

            var securityTokenService = configuration.SecurityTokenService ?? new JwtSecurityTokenService();

            _messageJournal = configuration.MessageJournal;

            var queueingOptions = new RabbitMQMessageQueueingOptions(baseUri)
            {
                ConnectionManager    = _connectionManager,
                DefaultQueueOptions  = defaultQueueOptions,
                DiagnosticService    = diagnosticService,
                Encoding             = encoding,
                SecurityTokenService = securityTokenService
            };

            _messageQueueingService = new RabbitMQMessageQueueingService(queueingOptions);

            var transportServiceOptions = new RabbitMQTransportServiceOptions(baseUri, _connectionManager)
            {
                DiagnosticService    = configuration.DiagnosticService,
                MessageJournal       = configuration.MessageJournal,
                SecurityTokenService = configuration.SecurityTokenService,
                Encoding             = configuration.Encoding,
                DefaultQueueOptions  = defaultQueueOptions,
                Topics = configuration.Topics
            };

            _transportService = new RabbitMQTransportService(transportServiceOptions);

            Bus = new Bus(configuration, configuration.BaseUri, _transportService, _messageQueueingService);
        }
Example #3
0
        private Mock <IMessageQueueingService> GivenMockQueueingService()
        {
            var mockQueueingService = new Mock <IMessageQueueingService>();

            mockQueueingService.Setup(x => x.CreateQueue(
                                          It.IsAny <QueueName>(),
                                          It.IsAny <IQueueListener>(),
                                          It.IsAny <QueueOptions>(),
                                          It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult(true));

            MessageQueueingService = mockQueueingService.Object;
            return(mockQueueingService);
        }
Example #4
0
 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()
 })
 {
 }
Example #5
0
        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";
        }
Example #6
0
        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);
        }
Example #7
0
 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)}
     };
 }
Example #8
0
        /// <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";
        }
Example #9
0
        /// <summary>
        /// Initializes a new <see cref="Bus"/> with the specified configuration and services
        /// provided by the host
        /// </summary>
        /// <param name="configuration">The core bus configuration</param>
        /// <param name="baseUri">The base URI provided by the host</param>
        /// <param name="transportService">The transport service provided by the host</param>
        /// <param name="messageQueueingService">The message queueing service provided by the host</param>
        /// <exception cref="ArgumentNullException">Thrown if any of the parameters are <c>null</c></exception>
        public Bus(IPlatibusConfiguration configuration, Uri baseUri, ITransportService transportService, IMessageQueueingService messageQueueingService)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException(nameof(configuration));
            }

            // Validate the provided configuration and throw exceptions for missing or invalid
            // configurations
            configuration.Validate();

            _baseUri                = baseUri ?? throw new ArgumentNullException(nameof(baseUri));
            _transportService       = transportService ?? throw new ArgumentNullException(nameof(transportService));
            _messageQueueingService = messageQueueingService ?? throw new ArgumentNullException(nameof(messageQueueingService));
            _defaultContentType     = string.IsNullOrWhiteSpace(configuration.DefaultContentType)
                ? "application/json"
                : configuration.DefaultContentType;

            _defaultSendOptions = configuration.DefaultSendOptions ?? new SendOptions();

            _messageMarshaller = new MessageMarshaller(
                configuration.MessageNamingService,
                configuration.SerializationService,
                configuration.DefaultContentType);

            _endpoints     = configuration.Endpoints ?? EndpointCollection.Empty;
            _topics        = configuration.Topics.ToList();
            _sendRules     = configuration.SendRules.ToList();
            _handlingRules = configuration.HandlingRules.ToList();
            _subscriptions = configuration.Subscriptions.ToList();

            _diagnosticService = configuration.DiagnosticService;
            _messageHandler    = new MessageHandler(_messageMarshaller, _diagnosticService);

            _transportService.MessageReceived += OnMessageReceived;

            _replyHub = new MemoryCacheReplyHub(_messageMarshaller, _diagnosticService, TimeSpan.FromMinutes(5));
        }
Example #10
0
        /// <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();
        }
Example #11
0
        /// <summary>
        /// Initializes a new <see cref="Bus"/> with the specified configuration and services
        /// provided by the host
        /// </summary>
        /// <param name="configuration">The core bus configuration</param>
        /// <param name="baseUri">The base URI provided by the host</param>
        /// <param name="transportService">The transport service provided by the host</param>
        /// <param name="messageQueueingService">The message queueing service provided by the host</param>
        /// <exception cref="ArgumentNullException">Thrown if any of the parameters are <c>null</c></exception>
        public Bus(IPlatibusConfiguration configuration, Uri baseUri, ITransportService transportService, IMessageQueueingService messageQueueingService)
        {
            if (configuration == null) throw new ArgumentNullException("configuration");
            if (baseUri == null) throw new ArgumentNullException("baseUri");
            if (transportService == null) throw new ArgumentNullException("transportService");
            if (messageQueueingService == null) throw new ArgumentNullException("messageQueueingService");

            _baseUri = baseUri;
            _transportService = transportService;
            _messageQueueingService = messageQueueingService;

            // TODO: Throw configuration exception if message queueing service, message naming
            // service, or serialization service are null

            _messageJournalingService = configuration.MessageJournalingService;
            _messageNamingService = configuration.MessageNamingService;
            _serializationService = configuration.SerializationService;

            _endpoints = new ReadOnlyEndpointCollection(configuration.Endpoints);
            _topics = configuration.Topics.ToList();
            _sendRules = configuration.SendRules.ToList();
            _handlingRules = configuration.HandlingRules.ToList();
            _subscriptions = configuration.Subscriptions.ToList();
        }
Example #12
0
 public IISConfiguration()
 {
     SubscriptionTrackingService = new InMemorySubscriptionTrackingService();
     MessageQueueingService = new InMemoryMessageQueueingService();
 }
Example #13
0
 public SendMessageCommand(IMessageQueueingService messageQueueingService,
                           ISerializationService serializationService)
 {
     _messsageQueuingService = messageQueueingService;
     _serializationService   = serializationService;
 }
Example #14
0
        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);
        }
Example #15
0
 /// <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));
 }
Example #16
0
        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);
        }