Example #1
0
        internal static Bus Build(BusBuilderConfiguration configuration)
        {
            var logger = configuration.Logger;
            logger.Debug("Constructing bus...");

            var container = new PoorMansIoC();

            RegisterPropertiesFromConfigurationObject(container, configuration);
            RegisterPropertiesFromConfigurationObject(container, configuration.LargeMessageStorageConfiguration);
            RegisterPropertiesFromConfigurationObject(container, configuration.Debugging);

            container.Register<Func<NamespaceManager>> (() =>
            {
                var ns = NamespaceManager.CreateFromConnectionString(container.Resolve<ConnectionStringSetting>());
                ns.Settings.OperationTimeout = configuration.DefaultTimeout;
                return ns;
            });
        
            container.Register<Func<MessagingFactory>>(() =>
            {
                var messagingFactory = MessagingFactory.CreateFromConnectionString(container.Resolve<ConnectionStringSetting>());
                messagingFactory.PrefetchCount = container.Resolve<ConcurrentHandlerLimitSetting>();
                return messagingFactory;
            });
   

            if (configuration.Debugging.RemoveAllExistingNamespaceElements)
            {
                var namespaceCleanser = container.Resolve<NamespaceCleanser>();
                namespaceCleanser.RemoveAllExistingNamespaceElements().Wait();
            }

            logger.Debug("Creating message receivers...");

            var messageReceiverManager = new MessageRecevierManager(
                container.Resolve<CommandMessageReceiverFactory>().CreateAll(),
                container.Resolve<MulticastEventMessageReceiverFactory>().CreateAll(),
                container.Resolve<CompetingEventMessageReceiverFactory>().CreateAll());

            logger.Debug("Message receivers are all created.");

            var bus = new Bus(container.Resolve<IZombusLogger>(),
                              container.Resolve<ICommandSender>(),
                              container.Resolve<IEventSender>(),
                              messageReceiverManager,
                              container.Resolve<DeadLetterQueues>(),
                              container.Resolve<IHeartbeat>());

            bus.Starting += delegate
                            {
                                container.Resolve<AzureQueueManager>().WarmUp();
                                container.Resolve<PropertyInjector>().Bus = bus;
                            };

            bus.Disposing += delegate { container.Dispose(); };

            logger.Info("Bus built. Job done!");

            return bus;
        }
Example #2
0
        private static async Task CleanNamespace(PoorMansIoC container, ILogger logger)
        {
            var removeAllExistingElements = container.Resolve<RemoveAllExistingNamespaceElementsSetting>();
            if (!removeAllExistingElements) return;

            logger.Debug("Removing all existing namespace elements. IMPORTANT: This should only be done in your regression test suites.");
            var cleanser = container.Resolve<INamespaceCleanser>();
            await cleanser.RemoveAllExistingNamespaceElements();
        }
Example #3
0
        private static void RegisterPropertiesFromConfigurationObject(PoorMansIoC container, object configuration)
        {
            foreach (var prop in configuration.GetType().GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance))
            {
                var value = prop.GetValue(configuration);
                if (value == null) continue;

                container.Register(value);
            }
        }
 internal ResponseMessagePumpFactory(ReplyQueueNameSetting replyQueueName,
                                     INimbusTransport transport,
                                     PoorMansIoC container,
                                     ResponseMessageDispatcher responseMessageDispatcher)
 {
     _replyQueueName = replyQueueName;
     _transport = transport;
     _responseMessageDispatcher = responseMessageDispatcher;
     _container = container;
 }
Example #5
0
 internal ResponseMessagePumpFactory(ReplyQueueNameSetting replyQueueName,
                                     INimbusTransport transport,
                                     PoorMansIoC container,
                                     ResponseMessageDispatcher responseMessageDispatcher)
 {
     _replyQueueName            = replyQueueName;
     _transport                 = transport;
     _responseMessageDispatcher = responseMessageDispatcher;
     _container                 = container;
 }
Example #6
0
        internal static Bus Build(BusBuilderConfiguration configuration)
        {
            var logger = configuration.Logger;
            logger.Debug("Constructing bus...");

            configuration.AssertConfigurationIsValid();

            var container = new PoorMansIoC();
            container.RegisterPropertiesFromConfigurationObject(configuration);

            logger.Debug("Creating message pumps...");
            var messagePumpsManager = new MessagePumpsManager(
                container.Resolve<ResponseMessagePumpFactory>().Create(),
                container.Resolve<RequestMessagePumpsFactory>().CreateAll(),
                container.Resolve<CommandMessagePumpsFactory>().CreateAll(),
                container.Resolve<MulticastRequestMessagePumpsFactory>().CreateAll(),
                container.Resolve<MulticastEventMessagePumpsFactory>().CreateAll(),
                container.Resolve<CompetingEventMessagePumpsFactory>().CreateAll());

            logger.Debug("Message pumps are all created.");

            var bus = container.ResolveWithOverrides<Bus>(messagePumpsManager);
            container.Resolve<PropertyInjector>().Bus = bus;

            bus.Starting += (s, e) =>
                            {
                                Task.Run(async () =>
                                               {
                                                   try
                                                   {
                                                       await container.Resolve<INimbusTransport>().TestConnection();
                                                       await CleanNamespace(container, logger);
                                                   }
                                                   catch (Exception ex)
                                                   {
                                                       logger.Error(ex, "Failed to establish connection to underlying transport: {Message}", ex.Message);
                                                       throw;
                                                   }
                                               }).Wait();
                            };

            bus.Disposing += (s, e) =>
                             {
                                 Task.Run(async () =>
                                                {
                                                    await CleanNamespace(container, logger);
                                                    container.Dispose();
                                                }).Wait();
                             };

            logger.Info("Bus built. Job done!");

            return bus;
        }
Example #7
0
 public override void Register <TLargeMessageBodyStore>(PoorMansIoC container)
 {
     container.Register(c =>
     {
         var uriFormatter          = new UriFormatter(AzureBlobStorageContainerUri, AzureBlobStorageContainerSharedAccessSignature);
         var blobStorageHttpClient = container.ResolveWithOverrides <IAzureBlobStorageHttpClient>(uriFormatter);
         var messageBodyStore      = container.ResolveWithOverrides <AzureBlobStorageHttpLargeMessageBodyStore>(blobStorageHttpClient);
         return(messageBodyStore);
     },
                        ComponentLifetime.SingleInstance,
                        typeof(ILargeMessageBodyStore));
 }
Example #8
0
        protected override void RegisterComponents(PoorMansIoC container)
        {
            container.RegisterType <WindowsServiceBusTransport>(ComponentLifetime.SingleInstance, typeof(INimbusTransport));

            container.RegisterType <BrokeredMessageFactory>(ComponentLifetime.SingleInstance, typeof(IBrokeredMessageFactory));
            container.RegisterType <NamespaceCleanser>(ComponentLifetime.SingleInstance);
            container.RegisterType <AzureQueueManager>(ComponentLifetime.SingleInstance, typeof(IQueueManager));
            container.RegisterType <DelayedDeliveryService>(ComponentLifetime.SingleInstance, typeof(IDelayedDeliveryService));
            container.RegisterType <WindowsServiceBusDeadLetterOffice>(ComponentLifetime.SingleInstance, typeof(IDeadLetterOffice));
            container.RegisterType <NamespaceCleanser>(ComponentLifetime.SingleInstance, typeof(INamespaceCleanser));
            container.RegisterType <SqlFilterExpressionGenerator>(ComponentLifetime.SingleInstance, typeof(ISqlFilterExpressionGenerator));

            container.Register(c =>
            {
                var namespaceManagerRoundRobin = new RoundRobin <NamespaceManager>(
                    c.Resolve <ServerConnectionCountSetting>(),
                    () =>
                {
                    var namespaceManager = NamespaceManager.CreateFromConnectionString(c.Resolve <ConnectionStringSetting>());
                    namespaceManager.Settings.OperationTimeout = c.Resolve <DefaultTimeoutSetting>();
                    return(namespaceManager);
                },
                    nsm => false,
                    nsm => { });

                return(namespaceManagerRoundRobin);
            },
                               ComponentLifetime.SingleInstance);

            container.Register <Func <NamespaceManager> >(c => c.Resolve <RoundRobin <NamespaceManager> >().GetNext, ComponentLifetime.InstancePerDependency);

            container.Register(c =>
            {
                var messagingFactoryRoundRobin = new RoundRobin <MessagingFactory>(
                    container.Resolve <ServerConnectionCountSetting>(),
                    () =>
                {
                    var messagingFactory           = MessagingFactory.CreateFromConnectionString(c.Resolve <ConnectionStringSetting>());
                    messagingFactory.PrefetchCount = c.Resolve <ConcurrentHandlerLimitSetting>();
                    return(messagingFactory);
                },
                    mf => mf.IsBorked(),
                    mf => mf.Dispose());

                return(messagingFactoryRoundRobin);
            },
                               ComponentLifetime.SingleInstance);

            container.Register <Func <MessagingFactory> >(c => c.Resolve <RoundRobin <MessagingFactory> >().GetNext, ComponentLifetime.InstancePerDependency);
        }
        protected override void RegisterComponents(PoorMansIoC container)
        {
            container.RegisterType<InProcessMessageStore>(ComponentLifetime.SingleInstance);

            container.RegisterType<InProcessQueueSender>(ComponentLifetime.InstancePerDependency);
            container.RegisterType<InProcessTopicSender>(ComponentLifetime.InstancePerDependency);
            container.RegisterType<InProcessQueueReceiver>(ComponentLifetime.InstancePerDependency);
            container.RegisterType<InProcessSubscriptionReceiver>(ComponentLifetime.InstancePerDependency);
            container.RegisterType<InProcessDelayedDeliveryService>(ComponentLifetime.SingleInstance, typeof (IDelayedDeliveryService));
            container.RegisterType<InProcessDeadLetterOffice>(ComponentLifetime.SingleInstance, typeof (IDeadLetterOffice));
            container.RegisterType<NamespaceCleanser>(ComponentLifetime.SingleInstance, typeof (INamespaceCleanser));
            container.RegisterType<UnsupportedLargeMessageBodyStore>(ComponentLifetime.SingleInstance, typeof (ILargeMessageBodyStore));
            container.RegisterType<InProcessTransport>(ComponentLifetime.SingleInstance, typeof (INimbusTransport));
        }
        protected override void RegisterComponents(PoorMansIoC container)
        {
            container.RegisterType<AzureServiceBusTransport>(ComponentLifetime.SingleInstance, typeof (INimbusTransport));

            container.RegisterType<BrokeredMessageFactory>(ComponentLifetime.SingleInstance, typeof (IBrokeredMessageFactory));
            container.RegisterType<NamespaceCleanser>(ComponentLifetime.SingleInstance);
            container.RegisterType<AzureQueueManager>(ComponentLifetime.SingleInstance, typeof (IQueueManager));
            container.RegisterType<DelayedDeliveryService>(ComponentLifetime.SingleInstance, typeof (IDelayedDeliveryService));
            container.RegisterType<AzureServiceBusDeadLetterOffice>(ComponentLifetime.SingleInstance, typeof (IDeadLetterOffice));
            container.RegisterType<NamespaceCleanser>(ComponentLifetime.SingleInstance, typeof (INamespaceCleanser));
            container.RegisterType<SqlFilterExpressionGenerator>(ComponentLifetime.SingleInstance, typeof(ISqlFilterExpressionGenerator));

            container.Register(c =>
                               {
                                   var namespaceManagerRoundRobin = new RoundRobin<NamespaceManager>(
                                       c.Resolve<ServerConnectionCountSetting>(),
                                       () =>
                                       {
                                           var namespaceManager = NamespaceManager.CreateFromConnectionString(c.Resolve<ConnectionStringSetting>());
                                           namespaceManager.Settings.OperationTimeout = c.Resolve<DefaultTimeoutSetting>();
                                           return namespaceManager;
                                       },
                                       nsm => false,
                                       nsm => { });

                                   return namespaceManagerRoundRobin;
                               },
                               ComponentLifetime.SingleInstance);

            container.Register<Func<NamespaceManager>>(c => c.Resolve<RoundRobin<NamespaceManager>>().GetNext, ComponentLifetime.InstancePerDependency);

            container.Register(c =>
                               {
                                   var messagingFactoryRoundRobin = new RoundRobin<MessagingFactory>(
                                       container.Resolve<ServerConnectionCountSetting>(),
                                       () =>
                                       {
                                           var messagingFactory = MessagingFactory.CreateFromConnectionString(c.Resolve<ConnectionStringSetting>());
                                           messagingFactory.PrefetchCount = c.Resolve<ConcurrentHandlerLimitSetting>();
                                           return messagingFactory;
                                       },
                                       mf => mf.IsBorked(),
                                       mf => mf.Dispose());

                                   return messagingFactoryRoundRobin;
                               },
                               ComponentLifetime.SingleInstance);

            container.Register<Func<MessagingFactory>>(c => c.Resolve<RoundRobin<MessagingFactory>>().GetNext, ComponentLifetime.InstancePerDependency);
        }
Example #11
0
        protected override void RegisterComponents(PoorMansIoC container)
        {
            container.RegisterType <InProcessMessageStore>(ComponentLifetime.SingleInstance);

            container.RegisterType <InProcessQueueSender>(ComponentLifetime.InstancePerDependency);
            container.RegisterType <InProcessTopicSender>(ComponentLifetime.InstancePerDependency);
            container.RegisterType <InProcessQueueReceiver>(ComponentLifetime.InstancePerDependency);
            container.RegisterType <InProcessSubscriptionReceiver>(ComponentLifetime.InstancePerDependency);
            container.RegisterType <InProcessDelayedDeliveryService>(ComponentLifetime.SingleInstance, typeof(IDelayedDeliveryService));
            container.RegisterType <InProcessDeadLetterOffice>(ComponentLifetime.SingleInstance, typeof(IDeadLetterOffice));
            container.RegisterType <NamespaceCleanser>(ComponentLifetime.SingleInstance, typeof(INamespaceCleanser));
            container.RegisterType <UnsupportedLargeMessageBodyStore>(ComponentLifetime.SingleInstance, typeof(ILargeMessageBodyStore));
            container.RegisterType <InProcessTransport>(ComponentLifetime.SingleInstance, typeof(INimbusTransport));
        }
 public CommandMessagePumpsFactory(IHandlerMapper handlerMapper,
                                   ILogger logger,
                                   IMessageDispatcherFactory messageDispatcherFactory,
                                   INimbusTransport transport,
                                   IRouter router,
                                   ITypeProvider typeProvider,
                                   PoorMansIoC container)
 {
     _handlerMapper            = handlerMapper;
     _logger                   = logger;
     _messageDispatcherFactory = messageDispatcherFactory;
     _transport                = transport;
     _router                   = router;
     _typeProvider             = typeProvider;
     _container                = container;
 }
 public CommandMessagePumpsFactory(IHandlerMapper handlerMapper,
                                   ILogger logger,
                                   IMessageDispatcherFactory messageDispatcherFactory,
                                   INimbusTransport transport,
                                   IRouter router,
                                   ITypeProvider typeProvider,
                                   PoorMansIoC container)
 {
     _handlerMapper = handlerMapper;
     _logger = logger;
     _messageDispatcherFactory = messageDispatcherFactory;
     _transport = transport;
     _router = router;
     _typeProvider = typeProvider;
     _container = container;
 }
Example #14
0
        protected override void RegisterComponents(PoorMansIoC container)
        {
            container.RegisterType <AzureServiceBusTransport>(ComponentLifetime.SingleInstance, typeof(INimbusTransport));
            container.RegisterType <AzureQueueManager>(ComponentLifetime.SingleInstance, typeof(IQueueManager));
            container.RegisterType <BrokeredMessageFactory>(ComponentLifetime.SingleInstance, typeof(IBrokeredMessageFactory));
            container.RegisterType <DelayedDeliveryService>(ComponentLifetime.SingleInstance, typeof(IDelayedDeliveryService));
            container.RegisterType <AzureServiceBusDeadLetterOffice>(ComponentLifetime.SingleInstance, typeof(IDeadLetterOffice));
            container.RegisterType <SqlFilterExpressionGenerator>(ComponentLifetime.SingleInstance, typeof(ISqlFilterExpressionGenerator));
            container.RegisterType <NamespaceCleanser>(ComponentLifetime.SingleInstance, typeof(INamespaceCleanser));
            container.RegisterType <ConnectionManager>(ComponentLifetime.SingleInstance, typeof(IConnectionManager));
            container.Register(c =>
            {
                var managerRoundRobin = new RoundRobin <ManagementClient>(
                    c.Resolve <ServerConnectionCountSetting>(),
                    () =>
                {
                    var client = new ManagementClient(c.Resolve <ConnectionStringSetting>());
                    return(client);
                },
                    nsm => false,
                    nsm => { });

                return(managerRoundRobin);
            },
                               ComponentLifetime.SingleInstance);

            container.Register <Func <ManagementClient> >(c => c.Resolve <RoundRobin <ManagementClient> >().GetNext, ComponentLifetime.InstancePerDependency);

            // container.Register(c =>
            //                    {
            //                        var messagingFactoryRoundRobin = new RoundRobin<MessagingFactory>(
            //                            container.Resolve<ServerConnectionCountSetting>(),
            //                            () =>
            //                            {
            //                                var messagingFactory = MessagingFactory.CreateFromConnectionString(c.Resolve<ConnectionStringSetting>());
            //                                messagingFactory.PrefetchCount = c.Resolve<ConcurrentHandlerLimitSetting>();
            //                                return messagingFactory;
            //                            },
            //                            mf => mf.IsBorked(),
            //                            mf => mf.Dispose());
            //
            //                        return messagingFactoryRoundRobin;
            //                    },
            //                    ComponentLifetime.SingleInstance);

            // container.Register<Func<MessagingFactory>>(c => c.Resolve<RoundRobin<MessagingFactory>>().GetNext, ComponentLifetime.InstancePerDependency);
        }
Example #15
0
        internal static Bus Build(BusBuilderConfiguration configuration)
        {
            var logger = configuration.Logger;
            logger.Debug("Constructing bus...");

            var container = new PoorMansIoC();

            foreach (var prop in configuration.GetType().GetProperties(BindingFlags.NonPublic | BindingFlags.Instance))
            {
                var value = prop.GetValue(configuration);
                if (value == null) continue;
                container.Register(value);
            }

            container.Register<Func<NamespaceManager>>(c => () => NamespaceManager.CreateFromConnectionString(c.Resolve<ConnectionStringSetting>()));
            container.Register<Func<MessagingFactory>>(c => () => MessagingFactory.CreateFromConnectionString(c.Resolve<ConnectionStringSetting>()));

            if (configuration.Debugging.RemoveAllExistingNamespaceElements)
            {
                RemoveAllExistingNamespaceElements(container.Resolve<Func<NamespaceManager>>(), logger);
            }

            logger.Debug("Creating message pumps and subscriptions.");
            var messagePumps = new List<IMessagePump>();
            messagePumps.Add(container.Resolve<ResponseMessagePumpFactory>().Create());
            messagePumps.AddRange(container.Resolve<CommandMessagePumpsFactory>().CreateAll());
            messagePumps.AddRange(container.Resolve<RequestMessagePumpsFactory>().CreateAll());
            messagePumps.AddRange(container.Resolve<MulticastRequestMessagePumpsFactory>().CreateAll());
            messagePumps.AddRange(container.Resolve<MulticastEventMessagePumpsFactory>().CreateAll());
            messagePumps.AddRange(container.Resolve<CompetingEventMessagePumpsFactory>().CreateAll());
            logger.Debug("Message pumps and subscriptions are all created.");

            var bus = new Bus(container.Resolve<ILogger>(),
                              container.Resolve<ICommandSender>(),
                              container.Resolve<IRequestSender>(),
                              container.Resolve<IMulticastRequestSender>(),
                              container.Resolve<IEventSender>(),
                              messagePumps,
                              container.Resolve<DeadLetterQueues>());

            bus.Disposing += (sender, args) => container.Dispose();

            logger.Debug("Bus built. Job done!");

            return bus;
        }
 public CompetingEventMessagePumpsFactory(ApplicationNameSetting applicationName,
                                          IHandlerMapper handlerMapper,
                                          ILogger logger,
                                          IMessageDispatcherFactory messageDispatcherFactory,
                                          INimbusTransport transport,
                                          IRouter router,
                                          ITypeProvider typeProvider,
                                          PoorMansIoC container)
 {
     _applicationName = applicationName;
     _handlerMapper = handlerMapper;
     _logger = logger;
     _messageDispatcherFactory = messageDispatcherFactory;
     _transport = transport;
     _router = router;
     _typeProvider = typeProvider;
     _container = container;
 }
 public MulticastRequestMessagePumpsFactory(ApplicationNameSetting applicationName,
                                            IHandlerMapper handlerMapper,
                                            ILogger logger,
                                            IMessageDispatcherFactory messageDispatcherFactory,
                                            INimbusTransport transport,
                                            IRouter router,
                                            ITypeProvider typeProvider,
                                            PoorMansIoC container)
 {
     _applicationName          = applicationName;
     _handlerMapper            = handlerMapper;
     _logger                   = logger;
     _messageDispatcherFactory = messageDispatcherFactory;
     _transport                = transport;
     _router                   = router;
     _typeProvider             = typeProvider;
     _container                = container;
 }
Example #18
0
        internal static Bus Build(BusBuilderConfiguration configuration)
        {
            var logger = configuration.Logger;
            logger.Debug("Constructing bus...");

            configuration.AssertConfigurationIsValid();

            var container = new PoorMansIoC();
            container.RegisterPropertiesFromConfigurationObject(configuration);

            logger.Debug("Creating message pumps...");
            var messagePumpsManager = new MessagePumpsManager(
                container.Resolve<ResponseMessagePumpFactory>().Create(),
                container.Resolve<RequestMessagePumpsFactory>().CreateAll(),
                container.Resolve<CommandMessagePumpsFactory>().CreateAll(),
                container.Resolve<MulticastRequestMessagePumpsFactory>().CreateAll(),
                container.Resolve<MulticastEventMessagePumpsFactory>().CreateAll(),
                container.Resolve<CompetingEventMessagePumpsFactory>().CreateAll());

            logger.Debug("Message pumps are all created.");

            var bus = container.ResolveWithOverrides<Bus>(messagePumpsManager);
            container.Resolve<PropertyInjector>().Bus = bus;

            bus.Starting += delegate
                            {
                                container.Resolve<INimbusTransport>().TestConnection().Wait();

                                var removeAllExistingElements = container.Resolve<RemoveAllExistingNamespaceElementsSetting>();
                                if (removeAllExistingElements)
                                {
                                    logger.Debug("Removing all existing namespace elements. IMPORTANT: This should only be done in your regression test suites.");
                                    var cleanser = container.Resolve<INamespaceCleanser>();
                                    cleanser.RemoveAllExistingNamespaceElements().Wait();
                                }
                            };
            bus.Disposing += delegate { container.Dispose(); };

            logger.Info("Bus built. Job done!");

            return bus;
        }
        public void RegisterWith(PoorMansIoC container)
        {
            container.Register(TypeProvider, typeof(ITypeProvider));
            container.Register(DependencyResolver, typeof(IDependencyResolver));
            container.Register(Logger, typeof(ILogger));
            container.Register(Serializer, typeof(ISerializer));
            container.Register(Compressor, typeof(ICompressor));
            container.Register(Router, typeof(IRouter));
            container.Register(DeliveryRetryStrategy, typeof(IDeliveryRetryStrategy));

            container.RegisterType<PathFactory>(ComponentLifetime.SingleInstance, typeof(IPathFactory));
            container.RegisterType<ReplyQueueNameSetting>(ComponentLifetime.SingleInstance);
            container.RegisterType<RequestResponseCorrelator>(ComponentLifetime.SingleInstance);
            container.RegisterType<CommandMessagePumpsFactory>(ComponentLifetime.SingleInstance);
            container.RegisterType<RequestMessagePumpsFactory>(ComponentLifetime.SingleInstance);
            container.RegisterType<ResponseMessagePumpFactory>(ComponentLifetime.SingleInstance);
            container.RegisterType<MulticastRequestMessagePumpsFactory>(ComponentLifetime.SingleInstance);
            container.RegisterType<MulticastEventMessagePumpsFactory>(ComponentLifetime.SingleInstance);
            container.RegisterType<CompetingEventMessagePumpsFactory>(ComponentLifetime.SingleInstance);
            container.RegisterType<SystemClock>(ComponentLifetime.SingleInstance, typeof(IClock));
            container.RegisterType<DispatchContextManager>(ComponentLifetime.SingleInstance, typeof(IDispatchContextManager));
            container.RegisterType<ResponseMessageDispatcher>(ComponentLifetime.SingleInstance);
            container.RegisterType<HandlerMapper>(ComponentLifetime.SingleInstance, typeof(IHandlerMapper));
            container.RegisterType<MessageDispatcherFactory>(ComponentLifetime.SingleInstance, typeof(IMessageDispatcherFactory));
            container.RegisterType<InboundInterceptorFactory>(ComponentLifetime.SingleInstance, typeof(IInboundInterceptorFactory));
            container.RegisterType<OutboundInterceptorFactory>(ComponentLifetime.SingleInstance, typeof(IOutboundInterceptorFactory));
            container.RegisterType<PropertyInjector>(ComponentLifetime.SingleInstance, typeof(IPropertyInjector), typeof(PropertyInjector));
            container.RegisterType<NimbusMessageFactory>(ComponentLifetime.SingleInstance, typeof(INimbusMessageFactory));
            container.RegisterType<BusCommandSender>(ComponentLifetime.SingleInstance, typeof(ICommandSender));
            container.RegisterType<BusRequestSender>(ComponentLifetime.SingleInstance, typeof(IRequestSender));
            container.RegisterType<BusMulticastRequestSender>(ComponentLifetime.SingleInstance, typeof(IMulticastRequestSender));
            container.RegisterType<BusEventSender>(ComponentLifetime.SingleInstance, typeof(IEventSender));
            container.RegisterType<KnownMessageTypeVerifier>(ComponentLifetime.SingleInstance, typeof(IKnownMessageTypeVerifier));
            container.RegisterType<Heartbeat>(ComponentLifetime.SingleInstance, typeof(IHeartbeat));
            container.RegisterType<Bus>(ComponentLifetime.SingleInstance);
            container.RegisterType<GlobalHandlerThrottle>(ComponentLifetime.SingleInstance, typeof(IGlobalHandlerThrottle));
            container.RegisterType<FilterConditionProvider>(ComponentLifetime.SingleInstance, typeof(IFilterConditionProvider));

            container.RegisterType<MessagePump>(ComponentLifetime.InstancePerDependency);
            container.RegisterType<DefaultRetry>(ComponentLifetime.InstancePerDependency, typeof(IRetry));
        }
 public MulticastRequestMessagePumpsFactory(ApplicationNameSetting applicationName,
                                            IFilterConditionProvider filterConditionProvider,
                                            IHandlerMapper handlerMapper,
                                            ILogger logger,
                                            IMessageDispatcherFactory messageDispatcherFactory,
                                            INimbusTransport transport,
                                            IPathFactory pathFactory,
                                            IRouter router,
                                            ITypeProvider typeProvider,
                                            PoorMansIoC container)
 {
     _applicationName = applicationName;
     _handlerMapper = handlerMapper;
     _logger = logger;
     _messageDispatcherFactory = messageDispatcherFactory;
     _transport = transport;
     _router = router;
     _typeProvider = typeProvider;
     _container = container;
     _pathFactory = pathFactory;
     _filterConditionProvider = filterConditionProvider;
 }
        protected override void RegisterComponents(PoorMansIoC container)
        {
            container.RegisterType<ConnectionMultiplexerFactory>(ComponentLifetime.SingleInstance);
            container.Register(c => new RoundRobin<ConnectionMultiplexer>(c.Resolve<ServerConnectionCountSetting>(),
                                                                          () => c.Resolve<ConnectionMultiplexerFactory>().Create(),
                                                                          multiplexer => false,
                                                                          multiplexer => multiplexer.Dispose()),
                               ComponentLifetime.SingleInstance);
            container.Register<Func<ConnectionMultiplexer>>(c => c.Resolve<RoundRobin<ConnectionMultiplexer>>().GetNext, ComponentLifetime.InstancePerDependency);
            container.Register<Func<IDatabase>>(c => () => c.Resolve<Func<ConnectionMultiplexer>>()().GetDatabase(), ComponentLifetime.InstancePerDependency);
            container.RegisterType<RedisMessageSender>(ComponentLifetime.InstancePerDependency);
            container.RegisterType<RedisMessageReceiver>(ComponentLifetime.InstancePerDependency);
            container.RegisterType<RedisTopicSender>(ComponentLifetime.InstancePerDependency);
            container.RegisterType<RedisSubscriptionReceiver>(ComponentLifetime.InstancePerDependency);

            container.RegisterType<RedisDelayedDeliveryService>(ComponentLifetime.SingleInstance, typeof (IDelayedDeliveryService));
            container.RegisterType<RedisDeadLetterOffice>(ComponentLifetime.SingleInstance, typeof (IDeadLetterOffice));
            container.RegisterType<NamespaceCleanser>(ComponentLifetime.SingleInstance, typeof (INamespaceCleanser));
            container.RegisterType<UnsupportedLargeMessageBodyStore>(ComponentLifetime.SingleInstance, typeof (ILargeMessageBodyStore));

            container.RegisterType<RedisTransport>(ComponentLifetime.SingleInstance, typeof (INimbusTransport));
        }
Example #22
0
 public CompetingEventMessagePumpsFactory(ApplicationNameSetting applicationName,
                                          IFilterConditionProvider filterConditionProvider,
                                          IHandlerMapper handlerMapper,
                                          ILogger logger,
                                          IMessageDispatcherFactory messageDispatcherFactory,
                                          INimbusTransport transport,
                                          IPathFactory pathFactory,
                                          IRouter router,
                                          ITypeProvider typeProvider,
                                          PoorMansIoC container)
 {
     _applicationName          = applicationName;
     _handlerMapper            = handlerMapper;
     _logger                   = logger;
     _messageDispatcherFactory = messageDispatcherFactory;
     _transport                = transport;
     _pathFactory              = pathFactory;
     _router                   = router;
     _typeProvider             = typeProvider;
     _container                = container;
     _filterConditionProvider  = filterConditionProvider;
 }
        protected override void RegisterComponents(PoorMansIoC container)
        {
            container.RegisterType <ConnectionMultiplexerFactory>(ComponentLifetime.SingleInstance);
            container.Register(c => new RoundRobin <ConnectionMultiplexer>(c.Resolve <ServerConnectionCountSetting>(),
                                                                           () => c.Resolve <ConnectionMultiplexerFactory>().Create(),
                                                                           multiplexer => false,
                                                                           multiplexer => multiplexer.Dispose()),
                               ComponentLifetime.SingleInstance);
            container.Register <Func <ConnectionMultiplexer> >(c => c.Resolve <RoundRobin <ConnectionMultiplexer> >().GetNext, ComponentLifetime.InstancePerDependency);
            container.Register <Func <IDatabase> >(c => () => c.Resolve <Func <ConnectionMultiplexer> >()().GetDatabase(), ComponentLifetime.InstancePerDependency);
            container.RegisterType <RedisMessageSender>(ComponentLifetime.InstancePerDependency);
            container.RegisterType <RedisMessageReceiver>(ComponentLifetime.InstancePerDependency);
            container.RegisterType <RedisTopicSender>(ComponentLifetime.InstancePerDependency);
            container.RegisterType <RedisSubscriptionReceiver>(ComponentLifetime.InstancePerDependency);

            container.RegisterType <RedisDelayedDeliveryService>(ComponentLifetime.SingleInstance, typeof(IDelayedDeliveryService));
            container.RegisterType <RedisDeadLetterOffice>(ComponentLifetime.SingleInstance, typeof(IDeadLetterOffice));
            container.RegisterType <NamespaceCleanser>(ComponentLifetime.SingleInstance, typeof(INamespaceCleanser));
            container.RegisterType <UnsupportedLargeMessageBodyStore>(ComponentLifetime.SingleInstance, typeof(ILargeMessageBodyStore));

            container.RegisterType <RedisTransport>(ComponentLifetime.SingleInstance, typeof(INimbusTransport));
        }
Example #24
0
 protected override void RegisterComponents(PoorMansIoC container)
 {
 }
Example #25
0
 public void RegisterWith(PoorMansIoC container)
 {
     //FIXME add a startup hook here somehow to remove namespace components as per before.
 }
Example #26
0
 public InProcessTransport(InProcessMessageStore messageStore, PoorMansIoC container)
 {
     _messageStore = messageStore;
     _container = container;
 }
Example #27
0
 public override void RegisterSupportingComponents(PoorMansIoC container)
 {
     container.RegisterType <AzureBlobStorageHttpClient>(ComponentLifetime.SingleInstance, typeof(IAzureBlobStorageHttpClient));
     container.RegisterType <AzureBlobStorageHttpLargeMessageBodyStore>(ComponentLifetime.SingleInstance);
 }
 public void RegisterWith(PoorMansIoC container)
 {
     RegisterComponents(container);
     //FIXME assert that a transport was actually registered
 }
Example #29
0
        internal static Bus Build(BusBuilderConfiguration configuration)
        {
            var logger = configuration.Logger;
            logger.Debug("Constructing bus...");

            var container = new PoorMansIoC();

            RegisterPropertiesFromConfigurationObject(container, configuration);
            RegisterPropertiesFromConfigurationObject(container, configuration.LargeMessageStorageConfiguration);
            RegisterPropertiesFromConfigurationObject(container, configuration.Debugging);

            var namespaceManagerRoundRobin = new RoundRobin<NamespaceManager>(
                container.Resolve<ServerConnectionCountSetting>(),
                () =>
                {
                    var namespaceManager = NamespaceManager.CreateFromConnectionString(container.Resolve<ConnectionStringSetting>());
                    namespaceManager.Settings.OperationTimeout = TimeSpan.FromSeconds(120);
                    return namespaceManager;
                },
                nsm => false,
                nsm => { });

            container.Register<Func<NamespaceManager>>(c => namespaceManagerRoundRobin.GetNext);

            var messagingFactoryRoundRobin = new RoundRobin<MessagingFactory>(
                container.Resolve<ServerConnectionCountSetting>(),
                () =>
                {
                    var messagingFactory = MessagingFactory.CreateFromConnectionString(container.Resolve<ConnectionStringSetting>());
                    messagingFactory.PrefetchCount = container.Resolve<ConcurrentHandlerLimitSetting>();
                    return messagingFactory;
                },
                mf => mf.IsBorked(),
                mf => { });

            container.Register<Func<MessagingFactory>>(c => messagingFactoryRoundRobin.GetNext);

            if (configuration.Debugging.RemoveAllExistingNamespaceElements)
            {
                var namespaceCleanser = container.Resolve<NamespaceCleanser>();
                namespaceCleanser.RemoveAllExistingNamespaceElements().Wait();
            }

            logger.Debug("Creating message pumps...");

            var messagePumps = new MessagePumpsManager(
                container.Resolve<ResponseMessagePumpFactory>().Create(),
                container.Resolve<RequestMessagePumpsFactory>().CreateAll(),
                container.Resolve<CommandMessagePumpsFactory>().CreateAll(),
                container.Resolve<MulticastRequestMessagePumpsFactory>().CreateAll(),
                container.Resolve<MulticastEventMessagePumpsFactory>().CreateAll(),
                container.Resolve<CompetingEventMessagePumpsFactory>().CreateAll(),
                container.Resolve<INimbusTaskFactory>());

            logger.Debug("Message pumps are all created.");

            var bus = new Bus(container.Resolve<ILogger>(),
                              container.Resolve<ICommandSender>(),
                              container.Resolve<IRequestSender>(),
                              container.Resolve<IMulticastRequestSender>(),
                              container.Resolve<IEventSender>(),
                              messagePumps,
                              container.Resolve<DeadLetterQueues>(),
                              container.Resolve<INimbusTaskFactory>(),
                              container.Resolve<IHeartbeat>());

            bus.Starting += delegate
                            {
                                container.Resolve<AzureQueueManager>().WarmUp();
                                container.Resolve<PropertyInjector>().Bus = bus;
                            };
            bus.Disposing += delegate { container.Dispose(); };

            logger.Info("Bus built. Job done!");

            return bus;
        }
Example #30
0
 public abstract void Register <TLargeMessageBodyStore>(PoorMansIoC container) where TLargeMessageBodyStore : ILargeMessageBodyStore;
Example #31
0
 public InProcessTransport(InProcessMessageStore messageStore, PoorMansIoC container)
 {
     _messageStore = messageStore;
     _container    = container;
 }
Example #32
0
 public RedisTransport(PoorMansIoC container, ConnectionMultiplexerFactory connectionMultiplexerFactory)
 {
     _container = container;
     _connectionMultiplexerFactory = connectionMultiplexerFactory;
 }
Example #33
0
 public void RegisterWith(PoorMansIoC container)
 {
     RegisterSupportingComponents(container);
     Register <ILargeMessageBodyStore>(container);
 }
 protected override void RegisterComponents(PoorMansIoC container)
 {
 }
Example #35
0
 public void RegisterWith(PoorMansIoC container)
 {
     //FIXME add a startup hook here somehow to remove namespace components as per before.
 }
 public void RegisterWith(PoorMansIoC container)
 {
     RegisterComponents(container);
     //FIXME assert that a transport was actually registered
 }
 public override void Register <TLargeMessageBodyStore>(PoorMansIoC container)
 {
     container.RegisterType <FileSystemLargeMessageBodyStore>(ComponentLifetime.SingleInstance, typeof(ILargeMessageBodyStore));
 }
Example #38
0
 public abstract void RegisterSupportingComponents(PoorMansIoC container);
 public override void RegisterSupportingComponents(PoorMansIoC container)
 {
 }
Example #40
0
 public RedisTransport(PoorMansIoC container, ConnectionMultiplexerFactory connectionMultiplexerFactory)
 {
     _container = container;
     _connectionMultiplexerFactory = connectionMultiplexerFactory;
 }
 protected abstract void RegisterComponents(PoorMansIoC container);
 protected abstract void RegisterComponents(PoorMansIoC container);