Ejemplo n.º 1
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();
        }
Ejemplo n.º 2
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;
        }
Ejemplo n.º 3
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;
        }
Ejemplo n.º 4
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<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.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);
        }
Ejemplo n.º 6
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;
        }
Ejemplo n.º 7
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;
        }
Ejemplo n.º 8
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;
        }