Example #1
0
 public Usage()
 {
     #region DefiningEventsAs
     Configure configure = Configure.With();
     configure.DefiningEventsAs(t => t.Namespace != null && t.Namespace.StartsWith("Domain") && t.Name.EndsWith("Event"));
     #endregion
 }
    public IEndpointConfiguration Bootstrap(EndpointDefinition endpointDefinition)
    {
        if (endpointDefinition.MachineName != null)
        {
            RuntimeEnvironment.MachineNameAction = () => endpointDefinition.MachineName;
        }

        configure = Configure.With();
        configure.DefaultBuilder();

        configure.DefineEndpointName(endpointDefinition.Name);
        Address.InitializeLocalAddress(endpointDefinition.Name);

        configure.DefiningMessagesAs(t => t.Namespace != null && t.Namespace.EndsWith(".Messages") && t != typeof(TestEvent));
        configure.DefiningEventsAs(t => t == typeof(TestEvent));

        configure.UseInMemoryTimeoutPersister();
        configure.InMemorySubscriptionStorage();

        customConfiguration = new CustomConfiguration();
        configure.CustomConfigurationSource(customConfiguration);

        Feature.Enable <MessageDrivenSubscriptions>();

        configure.Configurer.ConfigureComponent <MessageStore>(DependencyLifecycle.SingleInstance);

        return(this);
    }
Example #3
0
 Usage(Configure configure)
 {
     #region DefiningEventsAs
     configure.DefiningEventsAs(t => 
     t.Namespace != null &&
     t.Namespace.StartsWith("Domain") && 
     t.Name.EndsWith("Event"));
     #endregion
 }
 public static void ApplyCustomConventions(this Configure configure)
 {
     configure.FileShareDataBus(@"..\..\..\DataBusShare\");
     configure.DefiningCommandsAs(t => t.Namespace != null && t.Namespace.EndsWith("Commands"));
     configure.DefiningEventsAs(t => t.Namespace != null && t.Namespace.EndsWith("Events"));
     configure.DefiningMessagesAs(t => t.Namespace == "Messages");
     configure.DefiningEncryptedPropertiesAs(p => p.Name.StartsWith("Encrypted"));
     configure.DefiningDataBusPropertiesAs(p => p.Name.EndsWith("DataBus"));
     configure.DefiningExpressMessagesAs(t => t.Name.EndsWith("Express"));
     configure.DefiningTimeToBeReceivedAs(t => t.Name.EndsWith("Expires") ? TimeSpan.FromSeconds(30) : TimeSpan.MaxValue);
 }
        public void Simple()
        {
            #region CustomConfigOverrides

            Configure configure = Configure.With(AllAssemblies.Except("NotThis.dll"))
                                  .DefaultBuilder();
            configure.DefineEndpointName("MyEndpointName");
            configure.DefiningEventsAs(type => type.Name.EndsWith("Event"));

            #endregion
        }
Example #6
0
 Usage(Configure configure)
 {
     #region DefiningEventsAs
     configure.DefiningEventsAs(type =>
     {
         return(type.Namespace != null &&
                type.Namespace.StartsWith("Domain") &&
                type.Name.EndsWith("Event"));
     });
     #endregion
 }
        ServiceControlEventsConfig(Configure configure)
        {
            #region ServiceControlEventsConfig

            Configure.Serialization.Json();
            configure.DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) ||
                                       //include ServiceControl events
                                       t.Namespace != null &&
                                       t.Namespace.StartsWith("ServiceControl.Contracts"));

            #endregion
        }
Example #8
0
        ServiceControlEventsConfig(Configure configure)
        {
            #region ServiceControlEventsConfig

            Configure.Serialization.Json();
            configure.DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) ||
                                       //include ServiceControl events
                                       t.Namespace != null &&
                                       t.Namespace.StartsWith("ServiceControl.Contracts"));

            #endregion
        }
 public void ConfigureBus(Configure config, string endpointName, IWindsorContainer container)
 {
     config.DefineEndpointName(endpointName);
     config.CastleWindsorBuilder(container);
     //config.UseNHibernateTimeoutPersister();
     config.UseNHibernateSubscriptionPersister();
     config.DisableTimeoutManager();
     config.DefiningCommandsAs(t => t.GetInterfaces().Contains(typeof(Contracts.ICommand)));
     config.DefiningEventsAs(t => t.GetInterfaces().Contains(typeof(Contracts.IEvent)));
     config.SetEndpointSLA(TimeSpan.FromSeconds(600));
     config.UnicastBus();
 }
Example #10
0
        void MessageConventions(Configure configure)
        {
            #region 4to5MessageConventions

            // NOTE: When self hosting, '.DefiningXXXAs()' has to be before '.UnicastBus()',
            // otherwise it will result in:
            // 'InvalidOperationException: "No destination specified for message(s): MessageTypeName"
            configure.DefaultBuilder();
            configure.DefiningCommandsAs(
                type =>
            {
                return(type.Namespace == "MyNamespace" &&
                       type.Namespace.EndsWith("Commands"));
            });
            configure.DefiningEventsAs(
                type =>
            {
                return(type.Namespace == "MyNamespace" &&
                       type.Namespace.EndsWith("Events"));
            });
            configure.DefiningMessagesAs(
                type =>
            {
                return(type.Namespace == "Messages");
            });
            configure.DefiningEncryptedPropertiesAs(
                property =>
            {
                return(property.Name.StartsWith("Encrypted"));
            });
            configure.DefiningDataBusPropertiesAs(
                property =>
            {
                return(property.Name.EndsWith("DataBus"));
            });
            configure.DefiningExpressMessagesAs(
                type =>
            {
                return(type.Name.EndsWith("Express"));
            });
            configure.DefiningTimeToBeReceivedAs(
                type =>
            {
                if (type.Name.EndsWith("Expires"))
                {
                    return(TimeSpan.FromSeconds(30));
                }
                return(TimeSpan.MaxValue);
            });

            #endregion
        }
Example #11
0
        Usage(Configure configure)
        {
            #region MessageConventions

            // NOTE: When you're self hosting, '.DefiningXXXAs()' has to be before '.UnicastBus()',
            // otherwise you'll get: 'System.InvalidOperationException: "No destination specified for message(s): MessageTypeName"
            configure.DefiningCommandsAs(t => t.Namespace == "MyNamespace.Messages.Commands");
            configure.DefiningEventsAs(t => t.Namespace == "MyNamespace.Messages.Events");
            configure.DefiningMessagesAs(t => t.Namespace == "MyNamespace.Messages");
            configure.DefiningEncryptedPropertiesAs(p => p.Name.StartsWith("Encrypted"));
            configure.DefiningDataBusPropertiesAs(p =>p.Name.EndsWith("DataBus"));
            configure.DefiningExpressMessagesAs(t =>t.Name.EndsWith("Express"));
            configure.DefiningTimeToBeReceivedAs(t =>
                t.Name.EndsWith("Expires") ? TimeSpan.FromSeconds(30) : TimeSpan.MaxValue);

            #endregion
        }
Example #12
0
        public Bootstrapper(ServiceBase host = null, HostArguments hostArguments = null, Configure configure = null)
        {
            // .NET default limit is 10. RavenDB in conjunction with transports that use HTTP exceeds that limit.
            ServicePointManager.DefaultConnectionLimit = Settings.HttpDefaultConnectionLimit;

            Settings.ServiceName = DetermineServiceName(host, hostArguments);
            ConfigureLogging();
            var containerBuilder = new ContainerBuilder();
            Container = containerBuilder.Build();

            // Disable Auditing for the service control endpoint
            Configure.Features.Disable<Audit>();
            Configure.Features.Enable<Sagas>();
            Feature.Disable<AutoSubscribe>();
            Feature.Disable<SecondLevelRetries>();

            Configure.Serialization.Json();
            Configure.Transactions.Advanced(t => t.DisableDistributedTransactions().DoNotWrapHandlersExecutionInATransactionScope());

            Feature.EnableByDefault<StorageDrivenPublisher>();
            Configure.ScaleOut(s => s.UseSingleBrokerQueue());

            var transportType = DetermineTransportType();

            if (configure == null)
            {
                configure = Configure
                    .With(AllAssemblies.Except("ServiceControl.Plugin"));
            }

            bus = configure
                .DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) || IsExternalContract(t))
                .DefineEndpointName(Settings.ServiceName)
                .AutofacBuilder(Container)
                .UseTransport(transportType)
                .MessageForwardingInCaseOfFault()
                .DefineCriticalErrorAction((s, exception) =>
                {
                    if (host != null)
                    {
                        host.Stop();
                    }
                })
                .UnicastBus()
                .CreateBus();
        }
Example #13
0
        void MessageConventions(Configure configure)
        {
            #region 4to5MessageConventions

            // NOTE: When you're self hosting, '.DefiningXXXAs()' has to be before '.UnicastBus()',
            // otherwise you'll get: 'System.InvalidOperationException: "No destination specified for message(s): MessageTypeName"
            configure.DefaultBuilder();
            configure.DefiningCommandsAs(t => t.Namespace == "MyNamespace" && t.Namespace.EndsWith("Commands"));
            configure.DefiningEventsAs(t => t.Namespace == "MyNamespace" && t.Namespace.EndsWith("Events"));
            configure.DefiningMessagesAs(t => t.Namespace == "Messages");
            configure.DefiningEncryptedPropertiesAs(p => p.Name.StartsWith("Encrypted"));
            configure.DefiningDataBusPropertiesAs(p => p.Name.EndsWith("DataBus"));
            configure.DefiningExpressMessagesAs(t => t.Name.EndsWith("Express"));
            configure.DefiningTimeToBeReceivedAs(t => t.Name.EndsWith("Expires") ? TimeSpan.FromSeconds(30) : TimeSpan.MaxValue);

            #endregion
        }
 public static void ApplyMessageConventions(this Configure configure)
 {
     configure.DefiningCommandsAs(t => IsMessageNamespace(t) && t.Name.EndsWith("Command"));
     configure.DefiningEventsAs(t => IsMessageNamespace(t) && t.Name.EndsWith("Event"));
     configure.DefiningMessagesAs(t => IsMessageNamespace(t) && t.Name.EndsWith("Message"));
 }
Example #15
0
 public static Configure MyMessageConventions(this Configure config)
 {
     config.DefiningEventsAs(t => t.Namespace != null && t.Namespace.EndsWith(".Contracts"));
     return(config);
 }