static void Main()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.ASB.Polymorphic.Subscriber");
busConfiguration.ScaleOut().UseSingleBrokerQueue();
busConfiguration.UseTransport<AzureServiceBusTransport>()
.ConnectionString(Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString"));
#region DisableAutoSubscripton
busConfiguration.DisableFeature<AutoSubscribe>();
#endregion
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.DisableFeature<SecondLevelRetries>();
using (IBus bus = Bus.Create(busConfiguration).Start())
{
#region ControledSubscriptions
bus.Subscribe<BaseEvent>();
#endregion
Console.WriteLine("Subscriber is ready to receive events");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
protected override void OnStart(string[] args)
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("EndpointName");
busConfiguration.EnableInstallers();
bus = Bus.Create(busConfiguration).Start();
}
public void Customize(BusConfiguration configuration)
{
configuration.UseTransport<RabbitMQTransport>();
configuration.UsePersistence<InMemoryPersistence>();
configuration.RijndaelEncryptionService();
UnobtrusiveMessageConventions.Init(configuration.Conventions());
}
public void Customize(BusConfiguration configuration)
{
configuration.UsePersistence<DatabaseRoutingInMemoryPersistence>();
configuration.DisableFeature<AutoSubscribe>();
configuration.Pipeline.Register<DatabaseRouting.DatabaseRoutingStepInPipeline>();
configuration.CustomConfigurationSource(new DatabaseRoutingConfiguration());
}
protected void Application_Start()
{
#region ApplicationStart
ContainerBuilder builder = new ContainerBuilder();
// Register your MVC controllers.
builder.RegisterControllers(typeof(MvcApplication).Assembly);
// Set the dependency resolver to be Autofac.
IContainer container = builder.Build();
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MvcInjection.WebApplication");
// ExistingLifetimeScope() ensures that IBus is added to the container as well,
// allowing you to resolve IBus from your own components.
busConfiguration.UseContainer<AutofacBuilder>(c => c.ExistingLifetimeScope(container));
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.EnableInstallers();
bus = Bus.CreateSendOnly(busConfiguration);
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
#endregion
}
static void Main()
{
Console.Title = "Samples.MongoDB.Client";
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MongoDB.Client");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence<InMemoryPersistence>();
using (var bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press 'enter' to send a StartOrder messages");
Console.WriteLine("Press any other key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
return;
}
var orderId = Guid.NewGuid();
var startOrder = new StartOrder
{
OrderId = orderId
};
bus.Send("Samples.MongoDB.Server", startOrder);
Console.WriteLine($"StartOrder Message sent with OrderId {orderId}");
}
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.RavenDB.Client");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence<InMemoryPersistence>();
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
Console.WriteLine("Press 'enter' to send a StartOrder messages");
Console.WriteLine("Press any other key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
break;
}
Guid orderId = Guid.NewGuid();
await endpoint.Send(new StartOrder
{
OrderId = orderId
});
Console.WriteLine("StartOrder Message sent with OrderId " + orderId);
}
await endpoint.Stop();
}
void DisableFeature()
{
#region DisableBestPracticeEnforcementPerEndpoint
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.DisableFeature<BestPracticeEnforcement>();
#endregion
}
static void Main()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.DataBus.Sender");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UseDataBus<FileShareDataBus>().BasePath(BasePath);
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.EnableInstallers();
using (IBus bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press 'D' to send a databus large message");
Console.WriteLine("Press 'N' to send a normal large message exceed the size limit and throw");
Console.WriteLine("Press any other key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key == ConsoleKey.N)
{
SendMessageTooLargePayload(bus);
continue;
}
if (key.Key == ConsoleKey.D)
{
SendMessageLargePayload(bus);
continue;
}
return;
}
}
}
static void Main()
{
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName( "UserInterface" );
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UsePersistence<NHibernatePersistence>();
busConfiguration.Conventions()
.DefiningCommandsAs(t => t.Namespace != null && t.Namespace.EndsWith(".Commands"))
.DefiningEventsAs(t => t.Namespace != null && t.Namespace.EndsWith(".Events"));
//TODO: talk about encryption of sensitive data
//.DefiningEncryptedPropertiesAs(t => t.Name.Equals("Password"));
if( Environment.UserInteractive && Debugger.IsAttached )
{
busConfiguration.EnableInstallers();
}
using( var bus = Bus.Create( busConfiguration ).Start() )
{
Console.ReadKey();
}
}
protected override void OnStart(string[] args)
{
try
{
container = new Container(x => x.AddRegistry<DependencyRegistry>());
var myDocumentStore = new DocumentStore { ConnectionStringName = "EpiFlowDB" };
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("EpiFlow.Messages");
busConfiguration.UseContainer<StructureMapBuilder>(c => c.ExistingContainer(container));
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UsePersistence<RavenDBPersistence>()
.UseDocumentStoreForSubscriptions(myDocumentStore)
.UseDocumentStoreForSagas(myDocumentStore)
.UseDocumentStoreForTimeouts(myDocumentStore);
busConfiguration.UseTransport<RabbitMQTransport>();
busConfiguration.DefineCriticalErrorAction(OnCriticalError);
busConfiguration.Transactions().DisableDistributedTransactions();
if (Environment.UserInteractive && Debugger.IsAttached)
{
busConfiguration.EnableInstallers();
}
var startableBus = Bus.Create(busConfiguration);
bus = startableBus.Start();
}
catch (Exception exception)
{
OnCriticalError("Failed to start the bus.", exception);
}
}
public void Simple()
{
#region MutatorRegistration
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.RegisterComponents(c => c.ConfigureComponent<MyMutator>(DependencyLifecycle.InstancePerCall));
#endregion
}
static async Task AsyncMain()
{
#region ContainerConfiguration
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Unity");
UnityContainer container = new UnityContainer();
container.RegisterInstance(new MyService());
busConfiguration.UseContainer<UnityBuilder>(c => c.UseExistingContainer(container));
#endregion
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusSession busSession = endpoint.CreateBusSession();
await busSession.SendLocal(new MyMessage());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static void Main()
{
LogManager.Use<DefaultFactory>()
.Level(LogLevel.Warn);
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.ErrorHandling.WithSLR");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.EnableInstallers();
using (IBus bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press enter to send a message that will throw an exception.");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
if (key.Key != ConsoleKey.Enter)
{
return;
}
MyMessage m = new MyMessage
{
Id = Guid.NewGuid()
};
bus.SendLocal(m);
}
}
}
Usage(BusConfiguration busConfiguration)
{
#region DefiningEncryptedPropertiesAs
ConventionsBuilder conventions = busConfiguration.Conventions();
conventions.DefiningEncryptedPropertiesAs(info => info.Name.EndsWith("EncryptedProperty"));
#endregion
}
EndpointNameRequired()
{
#region 5to6-endpointNameRequired
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("MyEndpointName");
#endregion
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MessageMutators");
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.SendFailedMessagesTo("error");
#region ComponentRegistartion
busConfiguration.RegisterComponents(components =>
{
components.ConfigureComponent<ValidationMessageMutator>(DependencyLifecycle.InstancePerCall);
components.ConfigureComponent<TransportMessageCompressionMutator>(DependencyLifecycle.InstancePerCall);
});
#endregion
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusSession busSession = endpoint.CreateBusSession();
await Runner.Run(busSession);
}
finally
{
await endpoint.Stop();
}
}
public void Unreliable()
{
#region TransactionsDisable
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.Transactions().Disable();
#endregion
}
static void Main()
{
LogManager.Use<DefaultFactory>().Level(LogLevel.Error);
#region Program
Logger.WriteLine("Starting configuration");
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.StartupShutdown");
busConfiguration.EnableInstallers();
busConfiguration.EnableFeature<MyFeature>();
busConfiguration.UsePersistence<InMemoryPersistence>();
Logger.WriteLine("Calling Bus.Create");
using (IStartableBus bus = Bus.Create(busConfiguration))
{
Logger.WriteLine("Calling IStartableBus.Create");
bus.Start();
//simulate some bus activity
Thread.Sleep(500);
Logger.WriteLine("Bus is processing messages");
Logger.WriteLine("Calling IStartableBus.Dispose");
}
Logger.WriteLine("Finished");
#endregion
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
public void CustomTransactionTimeout()
{
#region CustomTransactionTimeout
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.Transactions().DefaultTimeout(TimeSpan.FromSeconds(30));
#endregion
}
public void CustomTransactionIsolationLevel()
{
#region CustomTransactionIsolationLevel
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.Transactions().IsolationLevel(IsolationLevel.RepeatableRead);
#endregion
}
public void Customize(BusConfiguration config)
{
config.Conventions()
.DefiningCommandsAs(t => t.Namespace != null && t.Namespace.StartsWith("Example2.Internal.Commands"))
.DefiningEventsAs(t => t.Namespace != null && t.Namespace.StartsWith("Example2.Contracts"))
.DefiningMessagesAs(t => t.Namespace != null && t.Namespace.StartsWith("Example2.Internal.Messages"));
}
static async Task AsyncMain()
{
using (new RavenHost())
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.RavenDBCustomSagaFinder");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
DocumentStore documentStore = new DocumentStore
{
Url = "http://localhost:32076",
DefaultDatabase = "NServiceBus"
};
documentStore.RegisterListener(new UniqueConstraintsStoreListener());
documentStore.Initialize();
busConfiguration.UsePersistence<RavenDBPersistence>()
.DoNotSetupDatabasePermissions() //Only required to simplify the sample setup
.SetDefaultDocumentStore(documentStore);
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
await endpoint.SendLocal(new StartOrder
{
OrderId = "123"
});
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
#region ContainerConfiguration
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.Castle");
WindsorContainer container = new WindsorContainer();
container.Register(Component.For<MyService>().Instance(new MyService()));
busConfiguration.UseContainer<WindsorBuilder>(c => c.ExistingContainer(container));
#endregion
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.SendFailedMessagesTo("error");
busConfiguration.EnableInstallers();
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
await endpoint.SendLocal(new MyMessage());
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
public void Config_file_connection_string_convention_has_precedence_over_code_configured_endpoint_connection_info()
{
var busConfig = new BusConfiguration();
busConfig.UseTransport<SqlServerTransport>().UseSpecificConnectionInformation(
EndpointConnectionInfo.For("Endpoint1").UseConnectionString("Source=Code").UseSchema("CodeSchema"),
EndpointConnectionInfo.For("Endpoint2").UseConnectionString("Source=Code").UseSchema("CodeSchema"));
var connectionConfig = new ConnectionConfig(new List<ConnectionStringSettings>()
{
new ConnectionStringSettings("NServiceBus/Transport/Endpoint1", "Source=Config; Queue Schema=ConfigSchema")
});
var builder = Activate(busConfig, connectionConfig);
var connectionProvider = builder.Build<IConnectionStringProvider>();
//Config
var connectionParams = connectionProvider.GetForDestination(Address.Parse("Endpoint1"));
Assert.IsTrue("Source=Config".Equals(connectionParams.ConnectionString, StringComparison.InvariantCultureIgnoreCase));
Assert.AreEqual("ConfigSchema", connectionParams.Schema);
//Fallback - code
connectionParams = connectionProvider.GetForDestination(Address.Parse("Endpoint2"));
Assert.IsTrue("Source=Code".Equals(connectionParams.ConnectionString, StringComparison.InvariantCultureIgnoreCase));
Assert.AreEqual("CodeSchema", connectionParams.Schema);
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.WcfCallbacks");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.EnableInstallers();
busConfiguration.SendFailedMessagesTo("error");
#region startbus
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusSession busSession = endpoint.CreateBusSession();
using (StartWcfHost(busSession))
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
finally
{
await endpoint.Stop();
}
#endregion
}
public static void Run(
int maximumNumberOfTweetsPerCatchUp,
TimeSpan defaultTransactionTimeout,
string nserviceBusConnectionString,
string endpointName,
string consumerKey,
string consumerSecret,
string accessToken,
string accessTokenSecret)
{
var busConfiguration = new BusConfiguration();
busConfiguration.Transactions().DoNotWrapHandlersExecutionInATransactionScope();
busConfiguration.Transactions().DefaultTimeout(defaultTransactionTimeout);
busConfiguration.EndpointName(endpointName);
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence<NHibernatePersistence>().ConnectionString(nserviceBusConnectionString);
busConfiguration.ApplyMessageConventions();
busConfiguration.RegisterComponents(c=>c.RegisterSingleton<ITweetService>(
new TweetService(maximumNumberOfTweetsPerCatchUp, consumerKey, consumerSecret, accessToken, accessTokenSecret)));
using (Bus.Create(busConfiguration).Start())
{
Console.ReadLine();
}
}
public void Customize(BusConfiguration config)
{
config.DisableFeature<TimeoutManager>();
config.DisableFeature<SecondLevelRetries>();
config.DisableFeature<Sagas>();
}
static void Main()
{
Console.Title = "Samples.CustomNhMappings.XmlMapping";
var nhConfiguration = new Configuration();
nhConfiguration.SetProperty(Environment.ConnectionProvider, "NHibernate.Connection.DriverConnectionProvider");
nhConfiguration.SetProperty(Environment.ConnectionDriver, "NHibernate.Driver.Sql2008ClientDriver");
nhConfiguration.SetProperty(Environment.Dialect, "NHibernate.Dialect.MsSql2008Dialect");
nhConfiguration.SetProperty(Environment.ConnectionStringName, "NServiceBus/Persistence");
AddMappingsFromFilesystem(nhConfiguration);
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.CustomNhMappings.XmlMapping");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EnableInstallers();
var persistence = busConfiguration.UsePersistence<NHibernatePersistence>();
persistence.UseConfiguration(nhConfiguration);
using (var bus = Bus.Create(busConfiguration).Start())
{
var startOrder = new StartOrder
{
OrderId = "123"
};
bus.SendLocal(startOrder);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
public void TransportTransactionsWithScope()
{
#region TransactionsWrapHandlersExecutionInATransactionScope
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.Transactions().DisableDistributedTransactions().WrapHandlersExecutionInATransactionScope();
#endregion
}
public void Customize(BusConfiguration busConfiguration)
{
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
}
static async Task AsyncMain()
{
Configuration hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect <MsSql2012Dialect>();
});
#region NHibernate
hibernateConfig.SetProperty("default_schema", "receiver");
#endregion
ModelMapper mapper = new ModelMapper();
mapper.AddMapping <OrderMap>();
hibernateConfig.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
new SchemaExport(hibernateConfig).Execute(false, true, false);
#region ReceiverConfiguration
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.SendFailedMessagesTo("error");
busConfiguration.AuditProcessedMessagesTo("audit");
busConfiguration.EnableInstallers();
busConfiguration.UseTransport <SqlServerTransport>()
.DefaultSchema("receiver")
.UseSpecificSchema(e =>
{
switch (e)
{
case "error":
return("dbo");
case "audit":
return("dbo");
default:
string schema = e.Split(new[]
{
'.'
}, StringSplitOptions.RemoveEmptyEntries)[0].ToLowerInvariant();
return(schema);
}
});
busConfiguration.UsePersistence <NHibernatePersistence>()
.UseConfiguration(hibernateConfig)
.RegisterManagedSessionInTheContainer();
#endregion
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
public void Customize(BusConfiguration configuration)
{
configuration.UsePersistence <InMemoryPersistence>();
Console.WriteLine("Ready to place orders");
}
public void Customize(BusConfiguration configuration)
{
configuration.UsePersistence <InMemoryPersistence>();
}
static void Main()
{
Console.Title = "Samples.MultiTenant.Receiver";
Configuration hibernateConfig = CreateBasicNHibernateConfig();
ModelMapper mapper = new ModelMapper();
mapper.AddMapping <OrderMap>();
hibernateConfig.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EndpointName("Samples.MultiTenant.Receiver");
#region ReceiverConfiguration
var persistence = busConfiguration.UsePersistence <NHibernatePersistence>();
persistence.RegisterManagedSessionInTheContainer();
persistence.UseConfiguration(hibernateConfig);
persistence.UseSubscriptionStorageConfiguration(CreateBasicNHibernateConfig());
persistence.UseTimeoutStorageConfiguration(CreateBasicNHibernateConfig());
persistence.DisableSchemaUpdate();
busConfiguration.EnableOutbox();
SettingsHolder settingsHolder = busConfiguration.GetSettings();
settingsHolder.Set("NHibernate.Timeouts.AutoUpdateSchema", true);
settingsHolder.Set("NHibernate.Subscriptions.AutoUpdateSchema", true);
#endregion
#region ReplaceOpenSqlConnection
busConfiguration.Pipeline.Replace("OpenSqlConnection", typeof(MultiTenantOpenSqlConnectionBehavior));
#endregion
#region RegisterPropagateTenantIdBehavior
busConfiguration.Pipeline.Register <PropagateTenantIdBehavior.Registration>();
#endregion
busConfiguration.DisableFeature <SecondLevelRetries>();
#region CreateSchema
IStartableBus startableBus = Bus.Create(busConfiguration);
CreateSchema(hibernateConfig, "A");
CreateSchema(hibernateConfig, "B");
#endregion
#region CapturePipelineExecutor
PipelineExecutor = ((UnicastBus)startableBus).Builder.Build <PipelineExecutor>();
#endregion
using (startableBus.Start())
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
// ... the config
#endregion
public void Customize(BusConfiguration busConfiguration)
{
}
Usage(BusConfiguration busConfiguration)
{
#region FLRConfigurationSourceUsage
busConfiguration.CustomConfigurationSource(new ConfigurationSource());
#endregion
}
public void Customize(BusConfiguration configuration)
{
configuration.RegisterComponents(Registration);
}
public void Customize(BusConfiguration busConfiguration)
{
busConfiguration.ExecuteTheseHandlersFirst(typeof(HandlerB), typeof(HandlerA), typeof(HandlerC));
}
public void ProfileActivated(BusConfiguration busConfiguration)
{
// set something else in dependency injection
}
public void ProfileActivated(BusConfiguration busConfiguration)
{
// set something else in the container
}
public void Customize(BusConfiguration configuration)
{
configuration.UsePersistence <RavenDBPersistence>();
configuration.ApplyCustomMessageConventions();
}
public static BusConfiguration GetBusConfiguration(IBusSettings settings,
bool useDefaultAutofacContainer = false, IContainer autofacContainer = null,
Action <BusConfiguration> registerIocContainer = null, string licenseFilePath = null)
{
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName(settings.EndpointName);
//busConfiguration.UseSerialization(settings.SerializerType ?? typeof(JsonSerializer));
busConfiguration.UseSerialization(settings.SerializerType ?? typeof(NewtonsoftSerializer));
var transport = busConfiguration.UseTransport <RabbitMQTransport>();
transport.ConnectionString(settings.MqConnectionString);
licenseFilePath = licenseFilePath ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "License.xml");
busConfiguration.LicensePath(licenseFilePath);
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <NHibernatePersistence>()
.ConnectionString(settings.PersistenceStoreConnectionString);
busConfiguration.Conventions().DefiningCommandsAs(commandType =>
commandType.Namespace != null && BusCommandType.IsAssignableFrom(commandType));
busConfiguration.Conventions().DefiningEventsAs(
eventType => eventType.Namespace != null && BusEventType.IsAssignableFrom(eventType));
busConfiguration.Conventions().DefiningMessagesAs(messageType =>
messageType.Namespace != null && BusMessageType.IsAssignableFrom(messageType));
busConfiguration.PurgeOnStartup(settings.PurgeOnStartup);
busConfiguration.DisableFeature <SecondLevelRetries>();
if (registerIocContainer == null)
{
if (useDefaultAutofacContainer)
{
busConfiguration.RegisterWithAutofac();
}
else if (autofacContainer != null)
{
busConfiguration.RegisterWithAutofac(autofacContainer);
}
}
else
{
registerIocContainer(busConfiguration);
}
var loggingFactory = LogManager.Use <DefaultFactory>();
var logFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, settings.LogFolderRelativePath);
if (!Directory.Exists(logFolder))
{
Directory.CreateDirectory(logFolder);
}
loggingFactory.Directory(logFolder);
loggingFactory.Level(LogLevel.Debug);
return(busConfiguration);
}
static void Main()
{
var connectionString = @"Data Source=.\SqlExpress;Initial Catalog=nservicebus;Integrated Security=True;Max Pool Size=100;Min Pool Size=10";
Console.Title = "Samples.ServiceControl.SqlServerTransportAdapter.Shipping";
var endpointConfiguration = new BusConfiguration();
endpointConfiguration.EndpointName("Samples.ServiceControl.SqlServerTransportAdapter.Shipping");
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.ConnectionString(connectionString);
SqlHelper.EnsureDatabaseExists(connectionString);
SqlHelper.CreateSchema(connectionString, "shipping");
SqlHelper.CreateSchema(connectionString, "adapter");
#region SchemaV5
//Use custom schema shipping for this endpoint
transport.DefaultSchema("shipping");
transport.UseSpecificConnectionInformation(
//Configure schema for sales endpoint so that the subscribe message is sent to the correct address
EndpointConnectionInfo.For("Samples.ServiceControl.SqlServerTransportAdapter.Sales").UseSchema("sales"),
//Configure schemas for ServiceControl queues to point to the adapter
EndpointConnectionInfo.For("audit").UseSchema("adapter"),
EndpointConnectionInfo.For("error").UseSchema("adapter"),
EndpointConnectionInfo.For("Particular.ServiceControl").UseSchema("adapter")
);
#endregion
endpointConfiguration.UsePersistence <InMemoryPersistence>();
var chaos = new ChaosGenerator();
endpointConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent(() => chaos, DependencyLifecycle.SingleInstance);
});
endpointConfiguration.DisableFeature <SecondLevelRetries>();
var conventions = endpointConfiguration.Conventions();
conventions.DefiningEventsAs(t => t == typeof(OrderAccepted) || t == typeof(OrderShipped));
endpointConfiguration.EnableInstallers();
using (var endpointInstance = Bus.Create(endpointConfiguration).Start())
{
Console.WriteLine("Press enter to exit");
Console.WriteLine("Press 'f' to toggle simulating of message processing failure");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key == ConsoleKey.Enter)
{
break;
}
var lowerInvariant = char.ToLowerInvariant(key.KeyChar);
if (lowerInvariant == 'f')
{
chaos.IsFailing = !chaos.IsFailing;
Console.WriteLine($"Failure simulation is now turned {(chaos.IsFailing ? "on" : "off")}");
}
}
}
}
static void Main()
{
Console.Title = "Samples.SqlNHibernate.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.SqlNHibernate.Sender");
busConfiguration.EnableInstallers();
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect <MsSql2012Dialect>();
});
hibernateConfig.SetProperty("default_schema", "sender");
#region SenderConfiguration
var transport = busConfiguration.UseTransport <SqlServerTransport>();
transport.DefaultSchema("sender");
transport.UseSpecificConnectionInformation(endpoint =>
{
if (endpoint == "error" || endpoint == "audit")
{
return(ConnectionInfo.Create().UseSchema("dbo"));
}
if (endpoint == "Samples.SqlNHibernate.Receiver")
{
return(ConnectionInfo.Create().UseSchema("receiver"));
}
return(null);
});
var persistence = busConfiguration.UsePersistence <NHibernatePersistence>();
persistence.UseConfiguration(hibernateConfig);
#endregion
using (var bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
return;
}
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var orderSubmitted = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
bus.Publish(orderSubmitted);
}
}
}
public void Run(BusConfiguration busConfiguration)
{
log.Info("Setting serializer to XML in an extension");
busConfiguration.UseSerialization <XmlSerializer>();
}
public void Customize(BusConfiguration builder)
{
builder.UseTransport <AzureServiceBusTransport>();
builder.UsePersistence <AzureStoragePersistence>();
}
public void Customize(BusConfiguration configuration)
{
configuration.RegisterComponents(c => c.ConfigureComponent <GetValueOfIncomingCorrelationId>(DependencyLifecycle.InstancePerCall));
}
public void ProfileActivated(BusConfiguration busConfiguration)
{
// set the NullEmailSender in the container
}
public void Customize(BusConfiguration configuration)
{
configuration.UsePersistence <InMemoryPersistence>();
configuration.Pipeline.Register <RegisterOriginalSenderCheckStep>();
configuration.EndpointName(ConfigurationManager.AppSettings["IntegrationPointName"]);
}
/// <summary>
/// Provides config options for the mailer feature.
/// </summary>
public static MailerConfigurationSettings EnableMailer(this BusConfiguration config)
{
config.EnableFeature <MailerFeature>();
return(new MailerConfigurationSettings(config));
}
private void InitializeServiceControl(ScenarioContext context)
{
LogManager.Use <NLogFactory>();
NLog.LogManager.Configuration = SetupLogging(Settings.DEFAULT_SERVICE_NAME);
var settings = new Settings
{
Port = port,
DbPath = ravenPath,
ForwardErrorMessages = false,
ForwardAuditMessages = false,
TransportType = transportToUse.TypeName,
TransportConnectionString = transportToUse.ConnectionString,
ProcessRetryBatchesFrequency = TimeSpan.FromSeconds(2),
MaximumConcurrencyLevel = 2,
HttpDefaultConnectionLimit = int.MaxValue
};
SetSettings(settings);
var configuration = new BusConfiguration();
configuration.TypesToScan(GetTypesScopedByTestClass(transportToUse).Concat(new[]
{
typeof(MessageMapperInterceptor),
typeof(RegisterWrappers),
typeof(SessionCopInBehavior),
typeof(SessionCopInBehaviorForMainPipe),
typeof(TraceIncomingBehavior),
typeof(TraceOutgoingBehavior)
}));
configuration.EnableInstallers();
configuration.GetSettings().SetDefault("ScaleOut.UseSingleBrokerQueue", true);
configuration.GetSettings().Set("SC.ScenarioContext", context);
// This is a hack to ensure ServiceControl picks the correct type for the messages that come from plugins otherwise we pick the type from the plugins assembly and that is not the type we want, we need to pick the type from ServiceControl assembly.
// This is needed because we no longer use the AppDomain separation.
configuration.EnableFeature <MessageMapperInterceptor>();
configuration.RegisterComponents(r => { configuration.GetSettings().Set("SC.ConfigureComponent", r); });
configuration.RegisterComponents(r =>
{
r.RegisterSingleton(context.GetType(), context);
r.RegisterSingleton(typeof(ScenarioContext), context);
});
configuration.Pipeline.Register <SessionCopInBehavior.Registration>();
configuration.Pipeline.Register <SessionCopInBehaviorForMainPipe.Registration>();
configuration.Pipeline.Register <TraceIncomingBehavior.Registration>();
configuration.Pipeline.Register <TraceOutgoingBehavior.Registration>();
CustomConfiguration(configuration);
using (new DiagnosticTimer("Initializing Bootstrapper"))
{
bootstrapper = new Bootstrapper(settings, configuration);
}
using (new DiagnosticTimer("Initializing AppBuilder"))
{
var app = new AppBuilder();
bootstrapper.Startup.Configuration(app);
var appFunc = app.Build();
Handler = new OwinHttpMessageHandler(appFunc)
{
UseCookies = false,
AllowAutoRedirect = false
};
httpClient = new HttpClient(Handler);
}
using (new DiagnosticTimer("Creating and starting Bus"))
{
bus = bootstrapper.Start(true);
}
}
public void Customize(BusConfiguration configuration)
{
configuration.RegisterComponents(c => c.ConfigureComponent <KnownEndpointsCache>(DependencyLifecycle.SingleInstance));
}
Usage(BusConfiguration busConfiguration)
{
#region UseCustomConfigurationSourceForGatewayChannelsConfig
busConfiguration.CustomConfigurationSource(new ConfigurationSource());
#endregion
}
public static void Msmq(BusConfiguration endpointConfiguration)
{
endpointConfiguration.UsePersistence <MsmqPersistence>();
}
public void Customize(BusConfiguration configuration)
{
configuration.EndpointName(EndpointName);
}
public static void None(BusConfiguration endpointConfiguration)
{
// Having no persistence configured is only suitable for transports which support native publish-subscribe
// http://docs.particular.net/nservicebus/messaging/publish-subscribe/#mechanics-native-based
}
public static void NHibernate(BusConfiguration endpointConfiguration)
{
//# throw new NotImplementedException("You need to configure your connection string");
endpointConfiguration.UsePersistence <NHibernatePersistence>().ConnectionString("Connection_string_goes_here");
}
public void Customize(BusConfiguration configuration)
{
configuration.UsePersistence <NHibernatePersistence>();
}
public static void InMemory(BusConfiguration endpointConfiguration)
{
// This is not suitable for production use
endpointConfiguration.UsePersistence <InMemoryPersistence>();
}
