// Agent created
public void AddAgent(string agentId, EndpointConnectionInfo info)
{
// all public functions should have locks since we concurrent access
lock (lockObj)
{
using (Trace.Log($"agentId: {agentId}, info: {info}"))
{
if (agents.ContainsKey(agentId))
{
return;
}
var agent = new AgentInfo()
{
id = agentId,
jobId = null,
info = info,
};
agents[agentId] = agent;
if (!AssignAgentAsLoopback(agentId))
{
unassignedAgents.Add(agentId);
UpdateAllocations();
}
}
}
}
void MultiInstance(BusConfiguration busConfiguration)
{
#region sqlserver-multiinstance-upgrade [2.1,3.0)
var transport = busConfiguration.UseTransport <SqlServerTransport>();
// Option 1
transport
.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("RemoteEndpoint")
.UseConnectionString("SomeConnectionString"),
EndpointConnectionInfo.For("AnotherEndpoint")
.UseConnectionString("SomeOtherConnectionString"));
// Option 2
transport
.UseSpecificConnectionInformation(x =>
{
if (x == "RemoteEndpoint")
{
var connectionInfo = ConnectionInfo.Create();
return(connectionInfo.UseConnectionString("SomeConnectionString"));
}
if (x == "AnotherEndpoint")
{
var connectionInfo = ConnectionInfo.Create();
return(connectionInfo.UseConnectionString("SomeOtherConnectionString"));
}
return(null);
});
#endregion
}
static void Main()
{
Console.Title = "Samples.SqlServer.StoreAndForwardReceiver";
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.SqlServer.StoreAndForwardReceiver");
#region ReceiverConfiguration
var transport = busConfiguration.UseTransport <SqlServerTransport>();
var receiver = @"Data Source=.\SqlExpress;Database=NsbSamplesStoreAndForwardReceiver;Integrated Security=True";
transport.ConnectionString(receiver);
var sender = @"Data Source=.\SqlExpress;Database=NsbSamplesStoreAndForwardSender;Integrated Security=True";
var connectionInfo = EndpointConnectionInfo.For("Samples.SqlServer.StoreAndForwardSender")
.UseConnectionString(sender);
transport.UseSpecificConnectionInformation(connectionInfo);
busConfiguration.UsePersistence <InMemoryPersistence>();
#endregion
busConfiguration.DisableFeature <SecondLevelRetries>();
SqlHelper.EnsureDatabaseExists(receiver);
using (Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
public override Endpoint CreateEndpoint(EndpointConnectionInfo info)
{
using (Trace.Log())
{
return(new Agent(dispatcher, info));
}
}
public AgentConnection(Distributed.Dispatcher dispatcher, EndpointConnectionInfo info)
{
using (Trace.Log())
{
connection = new HubConnection($"http://{info.signalrUrl}/", dispatcher.Identifier, dispatcher.SignalrUrl, dispatcher.WebUrl, "DispatcherHub");
connection.StateChanged += s =>
{
currentState = s.NewState;
StateChanged?.Invoke(s);
if (currentState == ConnectionState.Disconnected)
{
if (s.OldState == ConnectionState.Connecting)
{
if (retryCount++ > MaxRetryCount)
{
connection.Stop();
dispatcher.ReleaseAgent(info.name);
}
}
if (disposed)
{
stopped.Set();
}
}
};
connection.Proxy.On <string, bool>("SetAgentState", (id, active) => SetAgentState?.Invoke(id, active));
connection.Proxy.On <TaskItem, TaskResult>("CompleteTask", (taskItem, taskResult) => TaskCompleted?.Invoke(taskItem, taskResult));
}
}
private void OnDispatcherRemoveAgent(string dispatcherId, EndpointConnectionInfo agentInfo)
{
using (Trace.Log())
{
DispatcherConnections[dispatcherId].EndpointRemoved(agentInfo.name);
}
}
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 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);
}
}
}
CompositeConnectionStringProvider ConfigureConnectionStringProvider(FeatureConfigurationContext context, LocalConnectionParams localConnectionParams)
{
const string transportConnectionStringPrefix = "NServiceBus/Transport/";
var configConnectionStrings =
connectionStrings
.Where(x => x.Name.StartsWith(transportConnectionStringPrefix))
.Select(x =>
{
string schema;
var connectionString = x.ConnectionString.ExtractSchemaName(out schema);
var endpoint = x.Name.Replace(transportConnectionStringPrefix, String.Empty);
return(EndpointConnectionInfo.For(endpoint).UseConnectionString(connectionString).UseSchema(schema));
});
var configProvidedPerEndpointConnectionStrings = new CollectionConnectionStringProvider(configConnectionStrings, localConnectionParams);
var programmaticallyProvidedPerEndpointConnectionStrings = CreateProgrammaticPerEndpointConnectionStringProvider(context, localConnectionParams);
var connectionStringProvider = new CompositeConnectionStringProvider(
configProvidedPerEndpointConnectionStrings,
programmaticallyProvidedPerEndpointConnectionStrings,
new DefaultConnectionStringProvider(localConnectionParams)
);
return(connectionStringProvider);
}
static void Main()
{
Console.Title = "Samples.SQLOutboxStoreAndForward.Receiver";
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.SQLOutboxStoreAndForward.Receiver");
#region ReceiverConfiguration
busConfiguration.UseTransport <SqlServerTransport>()
.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("Samples.SQLOutboxStoreAndForward.Sender")
.UseConnectionString(@"Data Source=.\SQLEXPRESS;Initial Catalog=sender;Integrated Security=True"));
busConfiguration.UsePersistence <NHibernatePersistence>();
busConfiguration.EnableOutbox();
#endregion
busConfiguration.DisableFeature <SecondLevelRetries>();
using (Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
IConnectionStringProvider CreateConfigPerEndpointConnectionStringProvider(LocalConnectionParams localConnectionParams)
{
const string transportConnectionStringPrefix = "NServiceBus/Transport/";
var configConnectionStrings =
connectionStrings
.Where(x => x.Name.StartsWith(transportConnectionStringPrefix))
.Select(x =>
{
string schema;
var connectionString = x.ConnectionString.ExtractSchemaName(out schema);
var endpoint = x.Name.Replace(transportConnectionStringPrefix, String.Empty);
var connectionInfo = EndpointConnectionInfo.For(endpoint).UseSchema(schema);
var localConnectionStringBuilder = new DbConnectionStringBuilder {
ConnectionString = localConnectionParams.ConnectionString
};
var overriddenConnectionStringBuilder = new DbConnectionStringBuilder {
ConnectionString = connectionString
};
if (!localConnectionStringBuilder.EquivalentTo(overriddenConnectionStringBuilder))
{
connectionInfo = connectionInfo.UseConnectionString(connectionString);
}
return(connectionInfo);
})
.ToArray();
return(new CollectionConnectionStringProvider(configConnectionStrings, localConnectionParams));
}
static void Main(string[] args)
{
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
var random = new Random();
var busConfig = new BusConfiguration();
#region SenderConfiguration
busConfig.UseTransport <SqlServerTransport>().DefaultSchema("sender")
.UseSpecificConnectionInformation(EndpointConnectionInfo.For("receiver").UseSchema("receiver"));
busConfig.UsePersistence <NHibernatePersistence>();
#endregion
var bus = Bus.Create(busConfig).Start();
while (true)
{
Console.WriteLine("Press <enter> to send a message");
Console.ReadLine();
var orderId = new String(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
bus.Publish(new OrderSubmitted()
{
OrderId = orderId,
Value = random.Next(100)
});
}
}
public void Configure(BusConfiguration busConfiguration)
{
busConfiguration.UseTransport <SqlServerTransport>()
.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("UsingDifferentConnectionStringsForEachEndpoint.Sender").UseConnectionString("ToBeOverridenViaConfig").UseSchema("ToBeOverridenViaConfig"))
.ConnectionString(ReceiverConnectionStringWithSchema);
}
static void Main()
{
using (ReceiverDataContext ctx = new ReceiverDataContext())
{
ctx.Database.Initialize(true);
}
#region ReceiverConfiguration
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.UseTransport <SqlServerTransport>().UseSpecificConnectionInformation(
EndpointConnectionInfo.For("sender")
.UseConnectionString(@"Data Source=.\SQLEXPRESS;Initial Catalog=sender;Integrated Security=True"));
busConfiguration.UsePersistence <NHibernatePersistence>().RegisterManagedSessionInTheContainer();
busConfiguration.EnableOutbox();
#endregion
using (Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press <enter> to exit");
Console.ReadLine();
}
}
static void Main(string[] args)
{
#region NHibernate
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect <MsSql2012Dialect>();
});
var mapper = new ModelMapper();
mapper.AddMapping <OrderMap>();
hibernateConfig.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
SessionFactory = hibernateConfig.BuildSessionFactory();
#endregion
new SchemaExport(hibernateConfig).Execute(false, true, false);
#region ReceiverConfiguration
var busConfig = new BusConfiguration();
busConfig.UseTransport <SqlServerTransport>().UseSpecificConnectionInformation(
EndpointConnectionInfo.For("sender")
.UseConnectionString(@"Data Source=.\SQLEXPRESS;Initial Catalog=sender;Integrated Security=True"));
busConfig.UsePersistence <NHibernatePersistence>();
busConfig.EnableOutbox();
#endregion
using (Bus.Create(busConfig).Start())
{
Console.WriteLine("Press <enter> to exit");
Console.ReadLine();
}
}
public virtual Endpoint CreateEndpoint(EndpointConnectionInfo info)
{
using (Trace.Log($"{info}"))
{
return(new Endpoint(info));
}
}
private void OnAgentAdded(string agentId, string endpointData, EndpointConnectionInfo info)
{
using (Trace.Log())
{
agentAllocator.AddAgent(agentId, info);
}
}
private void OnDispatcherAdded(string dispatcherId, string connectionId, EndpointConnectionInfo info)
{
using (Trace.Log())
{
agentAllocator.AddDispatcher(dispatcherId, info);
}
}
public void Configure(BusConfiguration busConfiguration)
{
busConfiguration.UseTransport <SqlServerTransport>()
.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("Basic.Sender.WhenUsingDifferentConnectionStringsForEachEndpoint.SqlServerTransport").UseConnectionString("ToBeOverridenViaConfig").UseSchema("ToBeOverridenViaConfig"))
.ConnectionString(ReceiverConnectionStringWithSchema);
busConfiguration.Transactions().DisableDistributedTransactions();
}
private void OnDispatcherAssignAgent(string dispatcherId, EndpointConnectionInfo agentInfo)
{
var connection = DispatcherConnections[dispatcherId];
using (Trace.Log($"{connection}[{dispatcherId}].EndpointAdded({agentInfo})"))
{
connection.EndpointAdded(agentInfo);
}
}
public Sender()
{
EndpointSetup <DefaultServer>(x => x
.UseTransport <SqlServerTransport>()
.DefaultSchema("sender")
.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("UsingNonStandardSchema.Receiver").UseSchema("receiver")
))
.AddMapping <MyMessage>(typeof(Receiver));
}
static void Main()
{
const string letters = "ABCDEFGHIJKLMNOPQRSTUVXYZ";
Random random = new Random();
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EnableInstallers();
Configuration hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect <MsSql2012Dialect>();
});
hibernateConfig.SetProperty("default_schema", "sender");
#region SenderConfiguration
busConfiguration.UseTransport <SqlServerTransport>()
.DefaultSchema("sender")
.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("receiver")
.UseSchema("receiver"));
busConfiguration.UsePersistence <NHibernatePersistence>()
.UseConfiguration(hibernateConfig);
#endregion
using (IBus bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
return;
}
string orderId = new string(Enumerable.Range(0, 4).Select(x => letters[random.Next(letters.Length)]).ToArray());
bus.Publish(new OrderSubmitted
{
OrderId = orderId,
Value = random.Next(100)
});
}
}
}
public void OnConnect(string name, string connectionId, string signalrUrl, string webUrl)
{
if (Connections.Add(name, connectionId))
{
var info = new EndpointConnectionInfo(name, signalrUrl, webUrl);
lock (Endpoints)
{
Endpoints[name] = info;
}
EndpointAdded?.Invoke(name, connectionId, info);
}
}
public void When_multi_db_via_code_it_fails_to_start()
{
var context = new Context();
Scenario.Define(context)
.WithEndpoint <Receiver>(b => b.CustomConfig(c => c.UseTransport <SqlServerTransport>().UseSpecificConnectionInformation(
EndpointConnectionInfo.For("A").UseConnectionString(OtherDatabaseConnectionString)
)))
.AllowExceptions()
.Done(c => true)
.Run();
StringAssert.Contains(ExceptionText, context.Exceptions);
}
void OtherEndpointConnectionParamsPush(BusConfiguration busConfiguration)
{
#region sqlserver-singledb-multidb-push [2.1,2.0]
busConfiguration.UseTransport <SqlServerTransport>()
.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("AnotherEndpoint")
.UseSchema("receiver1"),
EndpointConnectionInfo.For("YetAnotherEndpoint")
.UseSchema("receiver2")
);
#endregion
}
void ConfigureCustomSchemaForEndpoint(BusConfiguration busConfiguration)
{
#region sqlserver-multischema-config-push
var transport = busConfiguration.UseTransport <SqlServerTransport>();
transport.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("sales")
.UseSchema("sender"),
EndpointConnectionInfo.For("billing")
.UseSchema("receiver")
);
#endregion
}
void ConfigureCustomSchemaForEndpointAndQueue(BusConfiguration busConfiguration)
{
#region sqlserver-multischema-config-for-endpoint-and-queue
var transport = busConfiguration.UseTransport <SqlServerTransport>();
transport.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("sales")
.UseSchema("sender"),
EndpointConnectionInfo.For("error")
.UseSchema("control")
);
#endregion
}
void RedirectAuditAndError(BusConfiguration busConfiguration)
{
#region sqlserver-multidb-redirect-audit-error 2.1
busConfiguration.UseTransport <SqlServerTransport>()
.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("error")
.UseConnectionString("ServiceControl connection string"),
EndpointConnectionInfo.For("audit")
.UseConnectionString("ServiceControl connection string")
);
#endregion
}
void OtherEndpointConnectionParamsPush(BusConfiguration busConfiguration)
{
#region sqlserver-multischema-config-push [2.1,3.0)
var transport = busConfiguration.UseTransport <SqlServerTransport>();
transport.UseSpecificConnectionInformation(
EndpointConnectionInfo.For("sales")
.UseSchema("sender"),
EndpointConnectionInfo.For("billing")
.UseSchema("receiver")
);
#endregion
}
public void When_multi_schema_via_code_it_starts()
{
var context = new Context();
Scenario.Define(context)
.WithEndpoint <Receiver>(b => b.CustomConfig(c => c.UseTransport <SqlServerTransport>().UseSpecificConnectionInformation(
EndpointConnectionInfo.For("A").UseSchema("A"),
EndpointConnectionInfo.For("B").UseSchema("B")
)))
.Done(c => true)
.Run();
Assert.IsNull(context.Exceptions);
}
