public void Should_include_NServiceBus_by_default()
        {
            var found = AllAssemblies
                        .Matching("foo.bar").ToArray();

            Assert.True(found.Any(a => a.GetName().Name.StartsWith("NServiceBus.")));
        }
        public static Configure SetupEndpoint(IContainer container, string endpointName = ENDPOINT_NAME)
        {
            Configure.Transactions.Enable();

            var config = Configure.With(
                AllAssemblies.Matching("Subscriber.dll")
                .And("Messages.dll")
                .And("NServiceBus.NHibernate.dll"))
                         .DefineEndpointName(endpointName)
                         .DefiningMessagesAs(t => t.Namespace != null &&
                                             !t.Namespace.Contains("NServiceBus") &&
                                             t.Namespace.Contains("Messages.") &&
                                             t.Name.EndsWith("Message"))
                         .DefiningEventsAs(
                t =>
                t.Namespace != null && !t.Namespace.Contains("NServiceBus") &&
                t.Namespace.Contains(".Messages.") && t.Name.EndsWith("Event"))
                         .DefiningCommandsAs(t => t.Namespace != null &&
                                             !t.Namespace.Contains("NServiceBus") &&
                                             t.Namespace.Contains("Messages.") &&
                                             t.Name.EndsWith("Command"))
                         .StructureMapBuilder(container)
                         .UseNHibernateSagaPersister()
                         .UseNHibernateTimeoutPersister()
                         .UseNHibernateSubscriptionPersister()
                         .UseTransport <Msmq>()
                         .UnicastBus();

            return(config);
        }
Beispiel #3
0
 private static void ConfigureAssembliesToScan(BusConfiguration busConfiguration)
 {
     busConfiguration.AssembliesToScan(
         AllAssemblies.Matching("NServiceBus")
         .And("Messages")
         .And("Ui"));
 }
        public void Should_include_fsharp_by_expression()
        {
            var found = AllAssemblies
                        .Matching("TestAssembly.").ToArray();

            Assert.True(found.Any(a => a.GetName().Name == "TestAssembly"));
        }
Beispiel #5
0
 public void Init()
 {
     Configure.Transactions.Enable();
     Configure.With(AllAssemblies.Matching("AscEsbTrainingMessages"))
     .DefaultBuilder()
     //this overrides the NServiceBus default convention of IEvent
     .DefiningEventsAs(t => t.Namespace != null && t.Namespace.StartsWith("AscEsbTrainingMessages"));
 }
Beispiel #6
0
    public ScanningPublicApi()
    {
        IEnumerable <Assembly> myListOfAssemblies = null;

        Assembly assembly2 = null;
        Assembly assembly1 = null;

        IEnumerable <Type> myTypes = null;


        #region ScanningDefault

        var configuration = new BusConfiguration();

        #endregion

        #region ScanningListOfAssemblies

        configuration.AssembliesToScan(myListOfAssemblies);

        #endregion

        #region ScanningParamArrayOfAssemblies

        configuration.AssembliesToScan(assembly1, assembly2);

        #endregion

        #region ScanningCustomDirectory

        configuration.ScanAssembliesInDirectory(@"c:\my-custom-dir");

        #endregion

        #region ScanningListOfTypes

        configuration.TypesToScan(myTypes);

        #endregion

        #region ScanningExcludeByName

        configuration.AssembliesToScan(AllAssemblies.Except("MyAssembly.dll").And("MyAssembly.dll"));

        #endregion

        #region ScanningIncludeByPattern

        configuration.AssembliesToScan(AllAssemblies.Matching("MyCompany.").And("SomethingElse"));

        #endregion

        #region ScanningMixingIncludeAndExclude

        configuration.AssembliesToScan(AllAssemblies.Matching("MyCompany.").Except("BadAssembly.dll"));

        #endregion
    }
        public void Should_include_fsharp_using_And()
        {
            var found = AllAssemblies
                        .Matching("foo.bar")
                        .And("TestAssembly.")
                        .ToArray();

            Assert.True(found.Any(a => a.GetName().Name == "TestAssembly"));
        }
Beispiel #8
0
    static IBus StartInstance2()
    {
        var busConfiguration = new BusConfiguration();

        busConfiguration.EndpointName("Samples.MultiHosting.Instance2");
        busConfiguration.AssembliesToScan(AllAssemblies.Matching("Instance2.").And("Shared"));
        busConfiguration.EnableInstallers();
        busConfiguration.UsePersistence <InMemoryPersistence>();

        return(Bus.Create(busConfiguration).Start());
    }
        void ScanningMixingIncludeAndExclude(BusConfiguration busConfiguration)
        {
            #region ScanningMixingIncludeAndExclude

            var excludesBuilder = AllAssemblies
                                  .Matching("NServiceBus")
                                  .And("MyCompany.")
                                  .Except("BadAssembly.dll");
            busConfiguration.AssembliesToScan(excludesBuilder);

            #endregion
        }
        void ScanningIncludeByPattern(BusConfiguration busConfiguration)
        {
            #region ScanningIncludeByPattern

            var includesBuilder = AllAssemblies
                                  .Matching("NServiceBus")
                                  .And("MyCompany.")
                                  .And("SomethingElse");
            busConfiguration.AssembliesToScan(includesBuilder);

            #endregion
        }
Beispiel #11
0
        void ScanningMixingIncludeAndExclude()
        {
            #region ScanningMixingIncludeAndExclude

            var excludesBuilder = AllAssemblies
                                  .Matching("NServiceBus")
                                  .And("MyCompany.")
                                  .Except("BadAssembly.dll");
            Configure.With(excludesBuilder);

            #endregion
        }
Beispiel #12
0
    static IBus StartInstance2()
    {
        BusConfiguration busConfig = new BusConfiguration();

        busConfig.EndpointName("Samples.MultiHosting-2");
        busConfig.AssembliesToScan(AllAssemblies.Matching("Instance2."));
        busConfig.UseSerialization <XmlSerializer>();
        busConfig.EnableInstallers();
        busConfig.UsePersistence <InMemoryPersistence>();

        return(Bus.Create(busConfig).Start());
    }
Beispiel #13
0
        void ScanningIncludeByPattern()
        {
            #region ScanningIncludeByPattern

            var includesBuilder = AllAssemblies
                                  .Matching("NServiceBus")
                                  .And("MyCompany.")
                                  .And("SomethingElse");
            Configure.With(includesBuilder);

            #endregion
        }
        void ScanningUpgrade(BusConfiguration busConfiguration)
        {
            #region 5to6ScanningUpgrade

            IExcludesBuilder excludesBuilder =
                AllAssemblies.Matching("NServiceBus")
                .And("MyCompany.")
                .Except("BadAssembly1.dll")
                .And("BadAssembly2.dll");
            busConfiguration.AssembliesToScan(excludesBuilder);

            #endregion
        }
Beispiel #15
0
    static IBus StartInstance1()
    {
        #region multi-hosting-assembly-scan

        var busConfiguration = new BusConfiguration();

        busConfiguration.EndpointName("Samples.MultiHosting.Instance1");
        // only include Instance1.dll and dependent assemblies
        busConfiguration.AssembliesToScan(AllAssemblies.Matching("Instance1.").And("Shared"));
        busConfiguration.EnableInstallers();
        busConfiguration.UsePersistence <InMemoryPersistence>();

        return(Bus.Create(busConfiguration).Start());

        #endregion
    }
Beispiel #16
0
    static IBus StartInstance1()
    {
        #region multi-hosting-assembly-scan

        BusConfiguration busConfiguration = new BusConfiguration();

        busConfiguration.EndpointName("Samples.MultiHosting.Instance1");
        busConfiguration.AssembliesToScan(AllAssemblies.Matching("Instance1.").And("Shared"));
        busConfiguration.UseSerialization <JsonSerializer>();
        busConfiguration.EnableInstallers();
        busConfiguration.UsePersistence <InMemoryPersistence>();

        return(Bus.Create(busConfiguration).Start());

        #endregion
    }
Beispiel #17
0
        public ScanningPublicApiV4()
        {
            IEnumerable <Assembly> myListOfAssemblies = null;

            Assembly assembly2 = null;
            Assembly assembly1 = null;

            IEnumerable <Type> myTypes = null;

            #region ScanningDefaultV4
            Configure.With();
            #endregion


            #region ScanningListOfAssembliesV4
            Configure.With(myListOfAssemblies);
            #endregion

            #region ScanningParamArrayOfAssembliesV4
            Configure.With(assembly1, assembly2);
            #endregion


            #region ScanningCustomDirectoryV4
            Configure.With(@"c:\my-custom-dir");
            #endregion


            #region ScanningListOfTypesV4
            Configure.With(myTypes);
            #endregion

            #region ScanningExcludeByNameV4
            Configure.With(AllAssemblies.Except("MyAssembly.dll").And("MyAssembly.dll"));
            #endregion

            #region ScanningIncludeByPatternV4
            Configure.With(AllAssemblies.Matching("MyCompany.").And("SomethingElse"));
            #endregion


            #region ScanningMixingIncludeAndExcludeV4
            Configure.With(AllAssemblies.Matching("MyCompany.").Except("BadAssembly.dll"));
            #endregion
        }
Beispiel #18
0
        public static Configure SetupEndpoint()
        {
            Configure.Endpoint.AsSendOnly();
            Configure.Transactions.Disable();

            Configure.Features.Disable <NServiceBus.Features.AutoSubscribe>();
            Configure.Features.Disable <NServiceBus.Features.SecondLevelRetries>();
            Configure.Features.Disable <NServiceBus.Features.TimeoutManager>();
            Configure.Features.Disable <NServiceBus.Features.Gateway>();
            Configure.Features.Disable <NServiceBus.Features.Sagas>();

            Configure.Serialization.Xml();

            return(Configure.With(AllAssemblies.Matching("Messages.dll"))
                   .DefineEndpointName(ENDPOINT_NAME)
                   .DefiningCommandsAs(t => t.Namespace != null &&
                                       t.Namespace.Contains("Messages.") &&
                                       !t.Namespace.StartsWith("NServiceBus"))
                   .StructureMapBuilder(ObjectFactory.Container)
                   .UseTransport <Msmq>()
                   .UnicastBus());
        }
        private void PublisherFormShown(object sender, EventArgs e)
        {
            try
            {
                buttonPublishMessage.Enabled = false;
                Refresh();
                Thread.Sleep(1000);
                labelStatus.ForeColor = Color.Olive;
                labelStatus.Text      = "Preparing publisher...";
                Refresh();

                Thread.Sleep(1000);

                // Sets up the Bus to receive messages from publisher endpoints. See config file section
                Configure.Transactions.Enable();
                Bus = Configure
                      .With(AllAssemblies.Matching("AscEsbTrainingMessages"))
                      .DefiningEventsAs(t => t.Namespace != null && t.Namespace.StartsWith("AscEsbTrainingMessages"))
                      .Log4Net()
                      .DefaultBuilder()
                      //.IsTransactional(true)
                      .DisableTimeoutManager()   // Stops default creation of RavenDB database.
                      .UseTransport <Msmq>()
                      .MsmqSubscriptionStorage()
                      .UnicastBus()
                      .CreateBus()
                      .Start(() => Configure.Instance.ForInstallationOn <NServiceBus.Installation.Environments.Windows>().Install());


                labelStatus.ForeColor        = Color.Green;
                labelStatus.Text             = "Ready to publish messages.";
                buttonPublishMessage.Enabled = true;
            }
            catch (Exception ex)
            {
                // Show contents of exception on the GUI
                labelStatus.Text = String.Format(ex.ToString());
            }
        }
        public void Customize(BusConfiguration config)
        {
            log4net.Config.XmlConfigurator.Configure();
            NServiceBus.Logging.LogManager.Use <Log4NetFactory>();


            var conventions = config.Conventions();

            conventions
            .DefiningEventsAs(t => t.Namespace != null && t.Namespace.StartsWith("Demo") && t.Namespace.EndsWith("Events"))
            .DefiningCommandsAs(t => t.Namespace != null && t.Namespace.StartsWith("Demo") && t.Namespace.EndsWith("Commands"))
            .DefiningMessagesAs(t => t.Namespace != null && t.Namespace.StartsWith("Demo") && (t.Namespace.EndsWith("Messages") || t.Namespace.EndsWith("Queries")));

            config.LicensePath(@"C:\License.xml");

            config.EndpointName("DemoMessages");
            config.EndpointVersion("0.0.0");
            config.AssembliesToScan(AllAssemblies.Matching("DemoMessages").And("Domain"));

            config.UsePersistence <InMemoryPersistence>();
            config.UseContainer <StructureMapBuilder>(c => c.ExistingContainer(_container));
            config.UseSerialization <NServiceBus.JsonSerializer>();
        }
Beispiel #21
0
        public override ServiceStackHost Init()
        {
            LogManager.LogFactory = new Log4NetFactory(true);
            NServiceBus.Logging.LogManager.Use <NServiceBus.Log4Net.Log4NetFactory>();

            var serverEvents = new MemoryServerEvents
            {
                IdleTimeout = TimeSpan.FromSeconds(30),
                NotifyChannelOfSubscriptions = false
            };

            var store      = ConfigureStore();
            var elastic    = ConfigureElastic();
            var eventstore = ConfigureEventStore();

            _container = new Container(x =>
            {
                x.For <IManager>().Use <Manager>();
                x.For <ICacheClient>().Use(new MemoryCacheClient());
                x.For <IServerEvents>().Use(serverEvents);
                x.For <ISubscriptionManager>().Use <MemorySubscriptionManager>();
                x.For <IDocumentStore>().Use(store).Singleton();
                x.For <IElasticClient>().Use(elastic).Singleton();
                x.For <IEventStoreConnection>().Use(eventstore).Singleton();
                x.For <IQueryProcessor>().Use <QueryProcessor>();
                x.For <IPersistCheckpoints>().Use <RavenCheckpointPersister>();

                x.Scan(y =>
                {
                    AllAssemblies.Matching("Application").ToList().ForEach(a => y.Assembly(a));

                    y.WithDefaultConventions();
                    y.ConnectImplementationsToTypesClosing(typeof(IQueryHandler <,>));
                    y.ConnectImplementationsToTypesClosing(typeof(IPagingQueryHandler <,>));
                });
            });

            var config = new BusConfiguration();

            //var conventions = config.Conventions();
            //conventions
            //    .DefiningEventsAs(t => t.Namespace != null && t.Namespace.StartsWith("Demo") && t.Namespace.EndsWith("Events"))
            //    .DefiningCommandsAs(t => t.Namespace != null && t.Namespace.StartsWith("Demo") && t.Namespace.EndsWith("Commands"))
            //    .DefiningMessagesAs(t => t.Namespace != null && t.Namespace.StartsWith("Demo") && (t.Namespace.EndsWith("Messages") || t.Namespace.EndsWith("Queries")));

            config.LicensePath(@"C:\License.xml");

            var endpoint = ConfigurationManager.AppSettings["endpoint"];

            if (string.IsNullOrEmpty(endpoint))
            {
                endpoint = "application.servicestack";
            }

            config.EndpointName(endpoint);
            //config.AssembliesToScan(AllAssemblies.Matching("Presentation").And("Application").And("Domain").And("Library"));

            config.UsePersistence <InMemoryPersistence>();
            config.UseContainer <StructureMapBuilder>(c => c.ExistingContainer(_container));
            config.UseSerialization <NServiceBus.JsonSerializer>();
            config.EnableInstallers();

            config.EnableFeature <Aggregates.EventStore>();
            config.EnableFeature <Aggregates.DurableConsumer>();

            var bus = Bus.Create(config).Start();

            _container.Configure(x => x.For <IBus>().Use(bus).Singleton());

            return(base.Init());
        }
Beispiel #22
0
        public override ServiceStackHost Init()
        {
            ServicePointManager.UseNagleAlgorithm      = false;
            ServicePointManager.DefaultConnectionLimit = 1000;

            var conf = NLog.Config.ConfigurationItemFactory.Default;

            conf.LayoutRenderers.RegisterDefinition("logsdir", typeof(LogsDir));
            conf.LayoutRenderers.RegisterDefinition("Domain", typeof(Library.Logging.Domain));
            NLog.LogManager.Configuration = new NLog.Config.XmlLoggingConfiguration($"{AppDomain.CurrentDomain.BaseDirectory}/logging.config");

            LogManager.LogFactory = new global::ServiceStack.Logging.NLogger.NLogFactory();
            AppDomain.CurrentDomain.UnhandledException   += UnhandledExceptionTrapper;
            AppDomain.CurrentDomain.FirstChanceException += ExceptionTrapper;
            NServiceBus.Logging.LogManager.Use <NServiceBus.NLogFactory>();


            IRedisClientsManager redisClient = null;
            ICacheClient         cacheClient;
            IServerEvents        serverEvents;
            var connectionString = ConfigurationManager.ConnectionStrings["Redis"];

            if (connectionString == null)
            {
                cacheClient  = new MemoryCacheClient();
                serverEvents = new MemoryServerEvents
                {
                    IdleTimeout = TimeSpan.FromSeconds(30),
                    NotifyChannelOfSubscriptions = false
                };
            }
            else
            {
                redisClient  = new BasicRedisClientManager(connectionString.ConnectionString);
                cacheClient  = new RedisClientManagerCacheClient(redisClient);
                serverEvents = new RedisServerEvents(redisClient)
                {
                    Timeout = TimeSpan.FromSeconds(30),
                    NotifyChannelOfSubscriptions = false,
                };
            }

            IDbConnectionFactory sql = null;
            var connectionStringSQL  = ConfigurationManager.ConnectionStrings["SQL"];

            if (connectionStringSQL != null)
            {
                sql = new OrmLiteConnectionFactory(connectionStringSQL.ConnectionString, SqlServer2012Dialect.Provider)
                {
                    ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current)
                };
            }



            _container = new Container(x =>
            {
                if (redisClient != null)
                {
                    x.For <IRedisClientsManager>().Use(redisClient);
                }
                if (sql != null)
                {
                    x.For <IDbConnectionFactory>().Use(sql);
                    x.For <ISubscriptionStorage>().Use <MSSQLStorage>();
                }
                else
                {
                    x.For <ISubscriptionStorage>().Use <MemoryStorage>();
                }

                x.For <IManager>().Use <Manager>();
                x.For <IFuture>().Use <Future>().Singleton();
                x.For <ICacheClient>().Use(cacheClient);
                x.For <IServerEvents>().Use(serverEvents);
                x.For <ISubscriptionManager>().Use <SubscriptionManager>().Singleton();

                x.Scan(y =>
                {
                    AllAssemblies.Matching("Presentation.ServiceStack").ToList().ForEach(a => y.Assembly(a));

                    y.WithDefaultConventions();
                    y.AddAllTypesOf <ISetup>();
                });
            });

            // Do this before bus starts
            InitiateSetup();
            SetupApplication();

            var config = new BusConfiguration();

            Logger.Info("Initializing Service Bus");
            config.LicensePath(ConfigurationManager.AppSettings["license"]);

            var endpoint = ConfigurationManager.AppSettings["endpoint"];

            if (string.IsNullOrEmpty(endpoint))
            {
                endpoint = "application.servicestack";
            }

            config.EndpointName(endpoint);

            config.EnableInstallers();
            config.UsePersistence <InMemoryPersistence>();
            config.UseContainer <StructureMapBuilder>(c => c.ExistingContainer(_container));

            config.DisableFeature <Sagas>();
            config.DisableFeature <SecondLevelRetries>();
            // Important to not subscribe to messages as we receive them from the event store
            config.DisableFeature <AutoSubscribe>();

            config.UseTransport <RabbitMQTransport>()
            .CallbackReceiverMaxConcurrency(36)
            .UseDirectRoutingTopology()
            .ConnectionStringName("RabbitMq");

            config.Transactions().DisableDistributedTransactions();
            //config.DisableDurableMessages();

            config.UseSerialization <NewtonsoftSerializer>();

            config.EnableFeature <Aggregates.Feature>();



            if (Logger.IsDebugEnabled)
            {
                config.Pipeline.Register <LogIncomingRegistration>();
            }

            var bus = Bus.Create(config).Start();

            _container.Configure(x => x.For <IBus>().Use(bus).Singleton());

            return(base.Init());
        }
Beispiel #23
0
        private static void Main(string[] args)
        {
            ServicePointManager.UseNagleAlgorithm = false;
            var conf = NLog.Config.ConfigurationItemFactory.Default;

            conf.LayoutRenderers.RegisterDefinition("logsdir", typeof(LogsDir));
            conf.LayoutRenderers.RegisterDefinition("Domain", typeof(Library.Logging.Domain));
            NLog.LogManager.Configuration = new NLog.Config.XmlLoggingConfiguration($"{AppDomain.CurrentDomain.BaseDirectory}/logging.config");

            AppDomain.CurrentDomain.UnhandledException   += UnhandledExceptionTrapper;
            AppDomain.CurrentDomain.FirstChanceException += ExceptionTrapper;

            NServiceBus.Logging.LogManager.Use <NLogFactory>();
            //EventStore.Common.Log.LogManager.SetLogFactory((name) => new EmbeddedLogger(name));

            var embedded = args.FirstOrDefault(x => x.StartsWith("--embedded"));

            try
            {
                _embedded = Boolean.Parse(embedded.Substring(embedded.IndexOf('=') + 1));
            }
            catch { }

            var client = ConfigureStore();

            var riak = ConfigureRiak();

            ConfigureMetrics();

            _container = new Container(x =>
            {
                x.For <IManager>().Use <Manager>();
                x.For <IEventStoreConnection>().Use(client).Singleton();
                x.For <IEventMutator>().Use <EventMutator>();
                x.For <IFuture>().Use <Future>().Singleton();
                x.For <Infrastructure.IUnitOfWork>().Use <UnitOfWork>();
                x.For <ICommandUnitOfWork>().Add(b => (ICommandUnitOfWork)b.GetInstance <Infrastructure.IUnitOfWork>());
                x.For <IEventUnitOfWork>().Add(b => (IEventUnitOfWork)b.GetInstance <Infrastructure.IUnitOfWork>());
                x.For <IRiakClient>().Use(riak).Singleton();

                x.Scan(y =>
                {
                    AllAssemblies.Matching("Domain").ToList().ForEach(a => y.Assembly(a));

                    y.WithDefaultConventions();
                });
            });
            // Do this before bus starts
            InitiateSetup();
            SetupApplication();

            var bus = InitBus();

            _container.Configure(x => x.For <IBus>().Use(bus).Singleton());

            Console.WriteLine("Press CTRL+C to exit...");
            Console.CancelKeyPress += (sender, eArgs) =>
            {
                _quitEvent.Set();
                eArgs.Cancel = true;
            };
            _quitEvent.WaitOne();
        }
Beispiel #24
0
        private static void Main(string[] args)
        {
            ServicePointManager.UseNagleAlgorithm = false;

            var conf = NLog.Config.ConfigurationItemFactory.Default;

            conf.LayoutRenderers.RegisterDefinition("logsdir", typeof(LogsDir));
            conf.LayoutRenderers.RegisterDefinition("Domain", typeof(Library.Logging.Domain));
            NLog.LogManager.Configuration = new NLog.Config.XmlLoggingConfiguration($"{AppDomain.CurrentDomain.BaseDirectory}/logging.config");

            AppDomain.CurrentDomain.UnhandledException   += UnhandledExceptionTrapper;
            AppDomain.CurrentDomain.FirstChanceException += ExceptionTrapper;

            NServiceBus.Logging.LogManager.Use <NLogFactory>();

            var buckets = args.FirstOrDefault(x => x.StartsWith("--buckets"));
            var handled = args.FirstOrDefault(x => x.StartsWith("--handled"));

            _buckets        = 1;
            _bucketsHandled = 1;
            try
            {
                _buckets        = Int32.Parse(buckets.Substring(buckets.IndexOf('=') + 1), System.Globalization.NumberStyles.Integer);
                _bucketsHandled = Int32.Parse(handled.Substring(handled.IndexOf('=') + 1), System.Globalization.NumberStyles.Integer);
            }
            catch { }

            var client  = ConfigureStore();
            var elastic = ConfigureElastic();

            ConfigureMetrics();

            _container = new Container(x =>
            {
                x.For <IManager>().Use <Manager>();
                x.For <IEventStoreConnection>().Use(client).Singleton();
                x.For <IFuture>().Use <Future>().Singleton();
                x.For <IPersistCheckpoints>().Use <Checkpoints.ElasticCheckpoints>();
                x.For <IManageCompetes>().Use <Checkpoints.ElasticCompetes>();
                x.For <IUnitOfWork>().Use <UnitOfWork>();
                x.For <IEventUnitOfWork>().Add(b => (IEventUnitOfWork)b.GetInstance <IUnitOfWork>());
                x.For <IElasticClient>().Use(elastic).Singleton();

                x.Scan(y =>
                {
                    AllAssemblies.Matching("Application.Elastic").ToList().ForEach(a => y.Assembly(a));

                    y.WithDefaultConventions();
                    y.AddAllTypesOf <ISetup>();
                });
            });
            // Do this before bus starts
            InitiateSetup();
            SetupApplication();

            var bus = InitBus();

            _container.Configure(x => x.For <IBus>().Use(bus).Singleton());


            Console.WriteLine("Press CTRL+C to exit...");
            Console.CancelKeyPress += (sender, eArgs) =>
            {
                _quitEvent.Set();
                eArgs.Cancel = true;
            };
            _quitEvent.WaitOne();
        }