static void Main(string[] args)
{
var random = new Random();
var busConfig = new BusConfiguration();
busConfig.UsePersistence <InMemoryPersistence>();
busConfig.UseTransport <SqlServerTransport>().ConnectionString(ConnectionString);
using (var bus = Bus.Create(busConfig).Start())
{
while (true)
{
Console.WriteLine("Press <enter> to submit an order");
Console.ReadLine();
var orderMessage = new OrderSubmitted
{
OrderId = Guid.NewGuid(),
OrderValue = random.Next(200)
};
bus.Publish(orderMessage);
Console.WriteLine("Order {0} worth {1} submitted.", orderMessage.OrderId, orderMessage.OrderValue);
}
}
}
static void Main()
{
Console.Title = "Samples.SQLNHibernateOutboxEF.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(
dataBaseIntegration: configurationProperties =>
{
configurationProperties.ConnectionStringName = "NServiceBus/Persistence";
configurationProperties.Dialect <MsSql2012Dialect>();
});
hibernateConfig.SetProperty("default_schema", "sender");
var busConfiguration = new BusConfiguration();
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EndpointName("Samples.SQLNHibernateOutboxEF.Sender");
#region SenderConfiguration
var transport = busConfiguration.UseTransport <SqlServerTransport>();
var connectionInfo = EndpointConnectionInfo.For("Samples.SQLNHibernateOutboxEF.Receiver")
.UseSchema("receiver");
transport.UseSpecificConnectionInformation(connectionInfo);
transport.DefaultSchema("sender");
busConfiguration.UsePersistence <NHibernatePersistence>();
busConfiguration.EnableOutbox();
#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);
}
}
}
static async Task AsyncMain()
{
Console.Title = "Samples.SqlNHibernate.Sender";
var endpointConfiguration = new EndpointConfiguration("Samples.SqlNHibernate.Sender");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect <MsSql2012Dialect>();
});
hibernateConfig.SetProperty("default_schema", "sender");
#region SenderConfiguration
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.DefaultSchema("sender");
transport.UseSchemaForQueue("error", "dbo");
transport.UseSchemaForQueue("audit", "dbo");
var persistence = endpointConfiguration.UsePersistence <NHibernatePersistence>();
persistence.UseConfiguration(hibernateConfig);
#endregion
var routing = transport.Routing();
routing.RouteToEndpoint(typeof(OrderAccepted), "Samples.SqlNHibernate.Sender");
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
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)
{
break;
}
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)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
static void Main()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
Random random = new Random();
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MultiTenant.Sender");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.UsePersistence <NHibernatePersistence>();
busConfiguration.EnableOutbox();
using (IBus bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
char uppercaseKey = char.ToUpperInvariant(key.KeyChar);
string orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
OrderSubmitted message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
bus.SetMessageHeader(message, "TenantId", uppercaseKey.ToString());
bus.Publish(message);
}
}
}
public static async Task Main()
{
random = new Random();
Console.Title = "Samples.Sql.Sender";
var endpointConfiguration = new EndpointConfiguration("Samples.Sql.Sender");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
#region SenderConfiguration
var connection = @"Data Source=.\SqlExpress;Database=NsbSamplesSql;Integrated Security=True;Max Pool Size=100";
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.ConnectionString(connection);
transport.DefaultSchema("sender");
transport.UseSchemaForQueue("error", "dbo");
transport.UseSchemaForQueue("audit", "dbo");
transport.NativeDelayedDelivery().DisableTimeoutManagerCompatibility();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
var subscriptions = transport.SubscriptionSettings();
subscriptions.SubscriptionTableName(
tableName: "Subscriptions",
schemaName: "dbo");
#endregion
SqlHelper.CreateSchema(connection, "sender");
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
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)
{
break;
}
var orderSubmitted = new OrderSubmitted
{
OrderId = Guid.NewGuid(),
Value = random.Next(100)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
Console.WriteLine("Published OrderSubmitted message");
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
//-- COMMANDS ------------------------------------------------------------------------------------------------//
private void OnMessage(SubmitOrder command)
{
this.CommandCount++;
this.Logger.LogInformation(LogId.Trading, $"{Received}{Command} {command}.");
var result = this.database.AddOrder(
command.Order,
command.TraderId,
command.AccountId,
command.StrategyId,
command.PositionId);
if (result.IsSuccess)
{
var positionIdBroker = this.database.GetPositionIdBroker(command.PositionId);
this.gateway.SubmitOrder(command.Order, positionIdBroker);
var submitted = new OrderSubmitted(
command.AccountId,
command.Order.Id,
this.TimeNow(),
this.NewGuid(),
this.TimeNow());
command.Order.Apply(submitted);
this.database.UpdateOrder(command.Order);
this.SendToEventPublisher(submitted);
}
else
{
this.Logger.LogError(LogId.Database, $"Cannot execute command {command} ({result.Message}).");
}
}
static async Task Main()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.MultiTenant.Sender");
endpointConfiguration.SendFailedMessagesTo("error");
var connection = @"Data Source=.\SqlExpress;Database=NsbSamplesMultiTenantSender;Integrated Security=True";
var persistence = endpointConfiguration.UsePersistence <NHibernatePersistence>();
persistence.ConnectionString(connection);
endpointConfiguration.UseTransport <MsmqTransport>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.EnableOutbox();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
Console.WriteLine("Press Escape to exit");
var acceptableInput = new List <char> {
'A', 'B'
};
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key == ConsoleKey.Escape)
{
break;
}
var uppercaseKey = char.ToUpperInvariant(key.KeyChar);
if (acceptableInput.Contains(uppercaseKey))
{
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
var options = new PublishOptions();
options.SetHeader("TenantId", uppercaseKey.ToString());
await endpointInstance.Publish(message, options)
.ConfigureAwait(false);
}
else
{
Console.WriteLine($"[{uppercaseKey}] is not a valid tenant identifier.");
}
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
static void Main()
{
var serviceProvider = new ServiceCollection()
.AddRawRabbit(new RawRabbitOptions
{
ClientConfiguration = new RawRabbitConfiguration
{
Username = "******",
Password = "******",
Port = 5672,
VirtualHost = "/",
Hostnames = { "localhost" }
}
})
.BuildServiceProvider();
var client = serviceProvider.GetService <IBusClient>();
Console.WriteLine("Publishing order event...");
var orderSubmitted = new OrderSubmitted(Guid.NewGuid(), $"Order - {DateTime.Now}", 1230);
client.PublishAsync(orderSubmitted).Wait();
Console.WriteLine($"Event {orderSubmitted.Id} published.");
}
static async Task AsyncMain()
{
Console.Title = "Samples.SqlTransportSqlPersistence.Sender";
var endpointConfiguration = new EndpointConfiguration("Samples.SqlTransportSqlPersistence.Sender");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
#region SenderConfiguration
var connectionString = @"Data Source=.\SqlExpress;Database=shared;Integrated Security=True;Min Pool Size=2;Max Pool Size=100";
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.ConnectionString(connectionString);
transport.DefaultSchema("sender");
transport.UseSchemaForQueue("error", "dbo");
transport.UseSchemaForQueue("audit", "dbo");
var persistence = endpointConfiguration.UsePersistence <SqlPersistence>();
persistence.SqlVariant(SqlVariant.MsSqlServer);
persistence.ConnectionBuilder(
connectionBuilder: () =>
{
return(new SqlConnection(connectionString));
});
persistence.Schema("sender");
persistence.TablePrefix("");
var subscriptions = persistence.SubscriptionSettings();
subscriptions.CacheFor(TimeSpan.FromMinutes(1));
#endregion
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
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)
{
break;
}
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)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
static async Task AsyncMain()
{
Console.Title = "Samples.SQLNHibernateOutbox.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.SQLNHibernateOutbox.Sender");
endpointConfiguration.UseSerialization <JsonSerializer>();
#region SenderConfiguration
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.ConnectionString(@"Data Source=.\SqlExpress;Database=nservicebus;Integrated Security=True");
var persistence = endpointConfiguration.UsePersistence <NHibernatePersistence>();
persistence.ConnectionString(@"Data Source=.\SqlExpress;Database=nservicebus;Integrated Security=True");
endpointConfiguration.EnableOutbox();
#endregion
endpointConfiguration.Recoverability()
.Immediate(immediate => immediate.NumberOfRetries(0))
.Delayed(delayed => delayed.NumberOfRetries(0));
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.AuditProcessedMessagesTo("audit");
endpointConfiguration.EnableInstallers();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
Console.WriteLine("Press enter to publish 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)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
public Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
Data.OrderId = message.OrderId;
#region Timeout
return(RequestTimeout <OrderTimeout>(context, TimeSpan.FromSeconds(5)));
#endregion
}
public void Handle(OrderSubmitted message)
{
Data.OrderId = message.OrderId;
#region Timeout
RequestTimeout <OrderTimeout>(TimeSpan.FromSeconds(5));
#endregion
}
public Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
Data.OrderId = message.OrderId;
RequestTimeout <OrderTimeout>(context, TimeSpan.FromSeconds(5));
return(Task.CompletedTask);
}
//-- EVENTS --------------------------------------------------------------------------------------------------//
private void OnMessage(OrderSubmitted @event)
{
this.EventCount++;
this.Logger.LogInformation(LogId.Trading, $"{Received}{Event} {@event}.");
this.ProcessOrderEvent(@event);
this.SendToEventPublisher(@event);
}
public static async Task Main()
{
//required to prevent possible occurrence of .NET Core issue https://github.com/dotnet/coreclr/issues/12668
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
random = new Random();
Console.Title = "Samples.Sql.Sender";
var endpointConfiguration = new EndpointConfiguration("Samples.Sql.Sender");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
#region SenderConfiguration
var connection = @"Data Source=.\SqlExpress;Database=NsbSamplesSql;Integrated Security=True;Max Pool Size=100";
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.ConnectionString(connection);
transport.DefaultSchema("sender");
transport.UseSchemaForQueue("error", "dbo");
transport.UseSchemaForQueue("audit", "dbo");
endpointConfiguration.UsePersistence <InMemoryPersistence>();
#endregion
SqlHelper.CreateSchema(connection, "sender");
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
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)
{
break;
}
var orderSubmitted = new OrderSubmitted
{
OrderId = Guid.NewGuid(),
Value = random.Next(100)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
Console.WriteLine("Published OrderSubmitted message");
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
private void OnMessage(SubmitBracketOrder command)
{
this.CommandCount++;
this.Logger.LogInformation(LogId.Trading, $"{Received}{Command} {command}.");
var result = this.database.AddBracketOrder(
command.BracketOrder,
command.TraderId,
command.AccountId,
command.StrategyId,
command.PositionId);
if (result.IsSuccess)
{
this.gateway.SubmitOrder(command.BracketOrder);
var submitted1 = new OrderSubmitted(
command.AccountId,
command.BracketOrder.Entry.Id,
this.TimeNow(),
this.NewGuid(),
this.TimeNow());
var submitted2 = new OrderSubmitted(
command.AccountId,
command.BracketOrder.StopLoss.Id,
this.TimeNow(),
this.NewGuid(),
this.TimeNow());
command.BracketOrder.Entry.Apply(submitted1);
command.BracketOrder.StopLoss.Apply(submitted2);
this.database.UpdateOrder(command.BracketOrder.Entry);
this.database.UpdateOrder(command.BracketOrder.StopLoss);
this.SendToEventPublisher(submitted1);
this.SendToEventPublisher(submitted2);
if (command.BracketOrder.TakeProfit != null)
{
var submitted3 = new OrderSubmitted(
command.AccountId,
command.BracketOrder.TakeProfit.Id,
this.TimeNow(),
this.NewGuid(),
this.TimeNow());
command.BracketOrder.TakeProfit.Apply(submitted3);
this.database.UpdateOrder(command.BracketOrder.TakeProfit);
this.SendToEventPublisher(submitted3);
}
}
else
{
this.Logger.LogError(LogId.Database, $"Cannot execute command {command} {result.Message}");
}
}
public async Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
Data.OrderId = message.OrderId;
#region Timeout
await RequestTimeout(context, TimeSpan.FromSeconds(5), new OrderTimeout());
#endregion
}
public async Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
#region Timeout
var orderTimeout = new OrderTimeout();
await RequestTimeout(context, TimeSpan.FromSeconds(5), orderTimeout)
.ConfigureAwait(false);
#endregion
}
public void When(OrderSubmitted e)
{
writer.Update <OrdersView>(e.Id, v =>
{
v.Version = e.Version;
v.UpdatedOn = e.CreatedOn;
v.Status = OrderStatus.Submitted;
});
}
private async Task SendMessage()
{
var notification = new OrderSubmitted
{
CustomerIdentifier = customers[random.Next(customers.Length)]
};
await mediator.Publish(notification);
}
private static async Task SendMessage()
{
var message = new OrderSubmitted
{
CustomerId = customers[random.Next(customers.Length)]
};
await endpointInstance.Publish(message).ConfigureAwait(false);
}
static async Task AsyncMain()
{
Console.Title = "Samples.Sql.Sender";
var endpointConfiguration = new EndpointConfiguration("Samples.Sql.Sender");
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
#region SenderConfiguration
var connection = @"Data Source=.\SqlExpress;Database=shared;Integrated Security=True";
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.ConnectionString(connection);
transport.DefaultSchema("sender");
transport.UseSchemaForQueue("error", "dbo");
transport.UseSchemaForQueue("audit", "dbo");
endpointConfiguration.UsePersistence <InMemoryPersistence>();
#endregion
var allText = File.ReadAllText("Startup.sql");
await SqlHelper.ExecuteSql(connection, allText)
.ConfigureAwait(false);
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
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)
{
break;
}
var orderSubmitted = new OrderSubmitted
{
OrderId = Guid.NewGuid(),
Value = random.Next(100)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
Console.WriteLine("Published OrderSubmitted message");
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
static async Task AsyncMain()
{
Console.Title = "Samples.SqlServer.StoreAndForwardSender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.SqlServer.StoreAndForwardSender");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.UsePersistence <InMemoryPersistence>();
#region SenderConfiguration
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.EnableLegacyMultiInstanceMode(ConnectionProvider.GetConnecton);
var pipeline = endpointConfiguration.Pipeline;
pipeline.Register("Forward", new ForwardBehavior(), "Forwards messages to destinations.");
pipeline.Register("Store",
b => new SendThroughLocalQueueRoutingToDispatchConnector(b.Build <ReadOnlySettings>().LocalAddress()),
"Send messages through local endpoint.");
#endregion
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
Console.WriteLine("Press enter to publish a message");
Console.WriteLine("Press any key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
break;
}
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)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
Console.WriteLine($"Order {orderId} placed");
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
static void Main(string[] args)
{
var exchange = "Model.Event:IOrderSubmitted";
var priorityRoutingKey = RoutingKey.Priority;
var regularRoutingKey = RoutingKey.Regular;
var factory = new ConnectionFactory
{
HostName = "localhost",
UserName = "******",
Password = "******"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
var priorityOrderSubmitted = new OrderSubmitted
{
CorrelationId = InVar.CorrelationId,
EventId = Guid.NewGuid(),
OrderType = priorityRoutingKey
};
var regularOrderSubmitted = new OrderSubmitted
{
CorrelationId = InVar.CorrelationId,
EventId = Guid.NewGuid(),
OrderType = regularRoutingKey
};
// Msg should be wrapped in an envelop before sending to RabbitMQ
var priorityEnvelope = new Envelope
{
MessageId = Guid.NewGuid().ToString(),
DestinationAddress = "localhost",
Message = priorityOrderSubmitted,
Headers = { },
MessageType = new[] { $"urn:message:{exchange}" }
};
var regularEnvelope = new Envelope
{
MessageId = Guid.NewGuid().ToString(),
DestinationAddress = "localhost",
Message = priorityOrderSubmitted,
Headers = { },
MessageType = new[] { $"urn:message:{exchange}" }
};
var priorityMsg = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(priorityEnvelope));
var regularMsg = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(regularEnvelope));
channel.BasicPublish(exchange, priorityRoutingKey, null, priorityMsg);
channel.BasicPublish(exchange, regularRoutingKey, null, regularMsg);
}
}
static async Task AsyncMain()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.MultiTenant.Sender");
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.UsePersistence <NHibernatePersistence>();
endpointConfiguration.EnableOutbox();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
var acceptableInput = new List <char> {
'A', 'B'
};
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var uppercaseKey = char.ToUpperInvariant(key.KeyChar);
if (acceptableInput.Contains(uppercaseKey))
{
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
var options = new PublishOptions();
options.SetHeader("TenantId", uppercaseKey.ToString());
await endpointInstance.Publish(message, options)
.ConfigureAwait(false);
}
else
{
Console.WriteLine($"[{uppercaseKey}] is not a valid tenant identifier.");
}
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
static void Main()
{
Console.Title = "Samples.SQLNHibernateOutboxEF.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect<MsSql2012Dialect>();
});
hibernateConfig.SetProperty("default_schema", "sender");
var busConfiguration = new BusConfiguration();
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EndpointName("Samples.SQLNHibernateOutboxEF.Sender");
#region SenderConfiguration
var transport = busConfiguration.UseTransport<SqlServerTransport>();
transport.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("Samples.SQLNHibernateOutboxEF.Receiver").UseSchema("receiver"));
transport.DefaultSchema("sender");
busConfiguration.UsePersistence<NHibernatePersistence>();
busConfiguration.EnableOutbox();
#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);
}
}
}
static async Task AsyncMain()
{
Console.Title = "Samples.SqlServer.StoreAndForwardSender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.SqlServer.StoreAndForwardSender");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.UsePersistence<InMemoryPersistence>();
#region SenderConfiguration
var transport = endpointConfiguration.UseTransport<SqlServerTransport>();
transport.EnableLegacyMultiInstanceMode(ConnectionProvider.GetConnecton);
var pipeline = endpointConfiguration.Pipeline;
pipeline.Register("Forward", new ForwardBehavior(), "Forwards messages to destinations.");
pipeline.Register("Store",
b => new SendThroughLocalQueueRoutingToDispatchConnector(b.Build<ReadOnlySettings>().LocalAddress()),
"Send messages through local endpoint.");
#endregion
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
Console.WriteLine("Press enter to publish a message");
Console.WriteLine("Press any key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
break;
}
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)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
Console.WriteLine($"Order {orderId} placed");
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
static async Task AsyncMain()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var endpointConfiguration = new EndpointConfiguration("Samples.MultiTenant.Sender");
endpointConfiguration.UseSerialization<JsonSerializer>();
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.UsePersistence<NHibernatePersistence>();
endpointConfiguration.EnableOutbox();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
var acceptableInput = new List<char> { 'A', 'B' };
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var uppercaseKey = char.ToUpperInvariant(key.KeyChar);
if (acceptableInput.Contains(uppercaseKey))
{
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
var options = new PublishOptions();
options.SetHeader("TenantId", uppercaseKey.ToString());
await endpointInstance.Publish(message, options)
.ConfigureAwait(false);
}
else
{
Console.WriteLine($"[{uppercaseKey}] is not a valid tenant identifier.");
}
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
public Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
log.Info($"saga for Order {context.MessageId} with orderid {message.OrderId} is started");
Data.OrderId = message.OrderId;
context.SendLocal(new SaveOrder()
{
OrderId = message.OrderId,
Value = message.Value
});
return(Task.FromResult(0));
}
public async Task Handle(OrderSubmitted message, IMessageHandlerContext context)
{
var orderTimeout = new OrderTimeout();
await RequestTimeout(context, TimeSpan.FromSeconds(5), orderTimeout)
.ConfigureAwait(false);
var orderAccepted = new OrderAccepted
{
OrderId = message.OrderId,
};
await context.Reply(orderAccepted)
.ConfigureAwait(false);
}
static void Main()
{
Console.Title = "Samples.SqlServer.StoreAndForwardSender";
var random = new Random();
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.SqlServer.StoreAndForwardSender");
#region SenderConfiguration
var transport = busConfiguration.UseTransport <SqlServerTransport>();
var sender = @"Data Source=.\SqlExpress;Database=NsbSamplesStoreAndForwardSender;Integrated Security=True";
transport.ConnectionString(sender);
var receiver = @"Data Source=.\SqlExpress;Database=NsbSamplesStoreAndForwardReceiver;Integrated Security=True";
transport.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("Samples.SqlServer.StoreAndForwardReceiver")
.UseConnectionString(receiver)
);
busConfiguration.UsePersistence <InMemoryPersistence>();
var pipeline = busConfiguration.Pipeline;
pipeline.Register <ForwardBehavior.Registration>();
pipeline.Register <SendThroughLocalQueueBehavior.Registration>();
#endregion
SqlHelper.EnsureDatabaseExists(sender);
using (var bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press enter to publish 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 = Guid.NewGuid();
var orderSubmitted = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
bus.Publish(orderSubmitted);
Console.WriteLine($"Order {orderId} placed");
}
}
}
static void Main()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MultiTenant.Sender");
var connection = @"Data Source=.\SqlExpress;Database=NsbSamplesMultiTenantSender;Integrated Security=True";
var persistence = busConfiguration.UsePersistence <NHibernatePersistence>();
persistence.ConnectionString(connection);
busConfiguration.EnableOutbox();
SqlHelper.EnsureDatabaseExists(connection);
using (var bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
var acceptableInput = new List <char> {
'A', 'B'
};
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
var uppercaseKey = char.ToUpperInvariant(key.KeyChar);
if (acceptableInput.Contains(uppercaseKey))
{
var orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
var message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
bus.SetMessageHeader(message, "TenantId", uppercaseKey.ToString());
bus.Publish(message);
}
else
{
Console.WriteLine($"[{uppercaseKey}] is not a valid tenant identifier.");
}
}
}
}
public void Handle(OrderSubmitted message)
{
Data.OrderId = message.OrderId;
Data.ThrowSagaTimeoutException = message.ThrowSagaTimeoutException;
#region Timeout
RequestTimeout <OrderTimeout>(TimeSpan.FromSeconds(5));
#endregion
if (message.ThrowSagaTransportException)
{
throw new Exception("Blow up!");
}
Console.WriteLine("Saga Handler Finished");
}
public void Setup()
{
_order = new OrderSubmitted();
_overLimit = MockRepository.GenerateMock<Action<OrderSubmitted>>();
_overLimit.Expect(x => x(_order));
_underLimit = MockRepository.GenerateMock<Action<OrderSubmitted>>();
_underLimit.Expect(x => x(_order)).Repeat.Never();
_engine = new MagnumRulesEngine();
AddOverLimitRule();
AddUnderLimitRule();
StringNodeVisitor visitor = new StringNodeVisitor();
_engine.Visit(visitor);
Trace.WriteLine(visitor.Result);
}
static void Main()
{
Console.Title = "Samples.MultiTenant.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
Random random = new Random();
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MultiTenant.Sender");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.UsePersistence<NHibernatePersistence>();
busConfiguration.EnableOutbox();
using (IBus bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press A or B to publish a message (A and B are tenant IDs)");
List<char> acceptableInput = new List<char> { 'A', 'B' };
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
char uppercaseKey = char.ToUpperInvariant(key.KeyChar);
if (acceptableInput.Contains(uppercaseKey))
{
string orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
OrderSubmitted message = new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
};
bus.SetMessageHeader(message, "TenantId", uppercaseKey.ToString());
bus.Publish(message);
}
else
{
Console.WriteLine("[{0}] is not a valid tenant identifier.", uppercaseKey);
}
}
}
}
static async Task AsyncMain()
{
Console.Title = "Samples.SQLNHibernateOutboxEF.Sender";
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect<MsSql2012Dialect>();
});
hibernateConfig.SetProperty("default_schema", "sender");
var endpointConfiguration = new EndpointConfiguration("Samples.SQLNHibernateOutboxEF.Sender");
endpointConfiguration.UseSerialization<JsonSerializer>();
#region SenderConfiguration
var transport = endpointConfiguration.UseTransport<SqlServerTransport>();
transport.DefaultSchema("sender");
transport.UseSpecificSchema(queueName =>
{
if (queueName.Equals("error", StringComparison.OrdinalIgnoreCase) || queueName.Equals("audit", StringComparison.OrdinalIgnoreCase))
{
return "dbo";
}
return null;
});
endpointConfiguration.UsePersistence<NHibernatePersistence>();
endpointConfiguration.EnableOutbox();
#endregion
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
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)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
static async Task AsyncMain()
{
Console.Title = "Samples.SqlNHibernate.Sender";
var endpointConfiguration = new EndpointConfiguration("Samples.SqlNHibernate.Sender");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect<MsSql2012Dialect>();
});
hibernateConfig.SetProperty("default_schema", "sender");
#region SenderConfiguration
var transport = endpointConfiguration.UseTransport<SqlServerTransport>();
transport.DefaultSchema("sender");
transport.UseSpecificSchema(e =>
{
if (e == "error" || e == "audit")
{
return "dbo";
}
return null;
});
var persistence = endpointConfiguration.UsePersistence<NHibernatePersistence>();
persistence.UseConfiguration(hibernateConfig);
#endregion
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
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)
};
await endpointInstance.Publish(orderSubmitted)
.ConfigureAwait(false);
}
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
