private void AssumeEndpointInstanceBuilderIsInitialised()
{
_endpointInstanceBuilder = Substitute.For <IEndpointInstanceBuilder>();
_endpointInstanceBuilder.ReturnsForAll(_endpointInstanceBuilder);
_startableEndpoint = Substitute.For <IStartableEndpoint>();
_endpointInstanceBuilder.Build().Returns(Task.FromResult(_startableEndpoint));
_endpointInstance = Substitute.For <IEndpointInstance>();
_startableEndpoint.Start().Returns(Task.FromResult(_endpointInstance));
}
public async Task <IEndpointInstance> Start(IStartableEndpoint startableEndpoint)
{
var hostStartupDiagnosticsWriter = HostStartupDiagnosticsWriterFactory.GetDiagnosticsWriter(configuration);
await hostStartupDiagnosticsWriter.Write(configuration.StartupDiagnostics.entries).ConfigureAwait(false);
var endpointInstance = await startableEndpoint.Start().ConfigureAwait(false);
configuration.CriticalError.SetEndpoint(endpointInstance);
return(endpointInstance);
}
async Task Startup()
{
#region Hosting-Startup
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("EndpointName");
//Apply configuration
IStartableEndpoint startableEndpoint = await Endpoint.Create(endpointConfiguration);
IEndpointInstance endpointInstance = await startableEndpoint.Start();
//Shortcut
IEndpointInstance endpointInstance2 = await Endpoint.Start(endpointConfiguration);
#endregion
}
async Task Startup()
{
#region Hosting-Startup
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("TheEndpointName");
//Apply configuration
IInitializableEndpoint initializableEndpoint = Endpoint.Prepare(endpointConfiguration);
IStartableEndpoint startableEndpoint = await initializableEndpoint.Initialize();
IEndpointInstance endpointInstance = await startableEndpoint.Start();
//Shortcut
IEndpointInstance endpointInstance2 = await Endpoint.Start(endpointConfiguration);
#endregion
}
public async Task Startup()
{
#region Hosting-Startup
BusConfiguration busConfiguration = new BusConfiguration();
//Apply configuration
IInitializableEndpoint initializableEndpoint = Endpoint.Prepare(busConfiguration);
IStartableEndpoint startableEndpoint = await initializableEndpoint.Initialize();
IEndpointInstance endpointInstance = await startableEndpoint.Start();
//Shortcut
IEndpointInstance endpointInstance2 = await Endpoint.Start(busConfiguration);
#endregion
}
public async Task Initialize(RunDescriptor run, EndpointBehavior endpointBehavior,
IDictionary <Type, string> routingTable, string endpointName)
{
try
{
behavior = endpointBehavior;
scenarioContext = run.ScenarioContext;
runSettings = run.Settings;
var endpointConfigurationFactory = (IEndpointConfigurationFactory)Activator.CreateInstance(endpointBehavior.EndpointBuilderType);
endpointConfigurationFactory.ScenarioContext = run.ScenarioContext;
configuration = endpointConfigurationFactory.Get();
configuration.EndpointName = endpointName;
if (!string.IsNullOrEmpty(configuration.CustomMachineName))
{
RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName;
}
//apply custom config settings
if (configuration.GetConfiguration == null)
{
throw new Exception($"Missing EndpointSetup<T> in the constructor of {endpointName} endpoint.");
}
endpointConfiguration = await configuration.GetConfiguration(run, routingTable).ConfigureAwait(false);
RegisterInheritanceHierarchyOfContextInSettings(scenarioContext);
endpointBehavior.CustomConfig.ForEach(customAction => customAction(endpointConfiguration, scenarioContext));
if (configuration.SendOnly)
{
endpointConfiguration.SendOnly();
}
startable = await Endpoint.Create(endpointConfiguration).ConfigureAwait(false);
if (!configuration.SendOnly)
{
var transportInfrastructure = endpointConfiguration.GetSettings().Get <TransportInfrastructure>();
scenarioContext.HasNativePubSubSupport = transportInfrastructure.OutboundRoutingPolicy.Publishes == OutboundRoutingType.Multicast;
}
}
catch (Exception ex)
{
Logger.Error("Failed to initialize endpoint " + endpointName, ex);
throw;
}
}
async Task EndpointConfiguration(EndpointConfiguration endpointConfiguration)
{
#region EnableDisableFeatures
// enable delayed delivery feature since SLR relies on it
endpointConfiguration.EnableFeature <DelayedDeliveryFeature>();
// this is not required if the feature uses EnableByDefault()
endpointConfiguration.EnableFeature <SecondLevelRetries>();
// we can disable features we won't use
endpointConfiguration.DisableFeature <Sagas>();
IStartableEndpoint endpoint = await Endpoint.Create(endpointConfiguration);
#endregion
}
public async Task Initialize(RunDescriptor run, EndpointBehavior endpointBehavior,
IDictionary<Type, string> routingTable, string endpointName)
{
try
{
behavior = endpointBehavior;
scenarioContext = run.ScenarioContext;
runSettings = run.Settings;
var endpointConfigurationFactory = (IEndpointConfigurationFactory)Activator.CreateInstance(endpointBehavior.EndpointBuilderType);
endpointConfigurationFactory.ScenarioContext = run.ScenarioContext;
configuration = endpointConfigurationFactory.Get();
configuration.EndpointName = endpointName;
if (!string.IsNullOrEmpty(configuration.CustomMachineName))
{
RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName;
}
//apply custom config settings
if (configuration.GetConfiguration == null)
{
throw new Exception($"Missing EndpointSetup<T> in the constructor of {endpointName} endpoint.");
}
endpointConfiguration = await configuration.GetConfiguration(run, routingTable).ConfigureAwait(false);
RegisterInheritanceHierarchyOfContextInSettings(scenarioContext);
endpointBehavior.CustomConfig.ForEach(customAction => customAction(endpointConfiguration, scenarioContext));
if (configuration.SendOnly)
{
endpointConfiguration.SendOnly();
}
startable = await Endpoint.Create(endpointConfiguration).ConfigureAwait(false);
if (!configuration.SendOnly)
{
var transportInfrastructure = endpointConfiguration.GetSettings().Get<TransportInfrastructure>();
scenarioContext.HasNativePubSubSupport = transportInfrastructure.OutboundRoutingPolicy.Publishes == OutboundRoutingType.Multicast;
}
}
catch (Exception ex)
{
Logger.Error("Failed to initialize endpoint " + endpointName, ex);
throw;
}
}
async Task GettingStartedUsage()
{
#region AzureServiceBusTransportGettingStarted 7
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("myendpoint");
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.SendFailedMessagesTo("error");
var transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>();
transport.UseTopology <ForwardingTopology>();
transport.ConnectionString("Paste connectionstring here");
IStartableEndpoint initializableEndpoint = await Endpoint.Create(endpointConfiguration);
IEndpointInstance endpoint = await initializableEndpoint.Start();
#endregion
}
//public IContainer GetEndpointContainer()
//{
// return _endPointConfig.GetEndpointContainer();
//}
public async Task <IContainer> Create(ContainerBuilder builder)
{
//_nsbConfig = _endPointConfig.BuildConfig();
//return _nsbConfig;
// Variation on https://docs.particular.net/samples/dependency-injection/autofac/
var endpointConfiguration = _endPointConfig.BuildConfig();
builder.Register(x => _endpointInstance)
.As <IEndpointInstance>()
.SingleInstance();
var container = builder.Build();
endpointConfiguration.UseContainer <AutofacBuilder>(c => c.ExistingLifetimeScope(container));
_startableEndpoint = await Endpoint.Create(endpointConfiguration).ConfigureAwait(false);
return(container);
}
public InternallyManagedContainerHost(IStartableEndpoint startableEndpoint, HostingComponent hostingComponent)
{
this.startableEndpoint = startableEndpoint;
this.hostingComponent = hostingComponent;
}
static async Task AsyncMain()
{
Console.Title = "Samples.MultiTenant.Receiver";
Configuration sharedDatabaseConfiguration = CreateBasicNHibernateConfig();
Configuration tenantDatabasesConfiguration = CreateBasicNHibernateConfig();
ModelMapper mapper = new ModelMapper();
mapper.AddMapping <OrderMap>();
tenantDatabasesConfiguration.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("Samples.MultiTenant.Receiver");
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.LimitMessageProcessingConcurrencyTo(1);
endpointConfiguration.SendFailedMessagesTo("error");
#region ReceiverConfiguration
var persistence = endpointConfiguration.UsePersistence <NHibernatePersistence>();
persistence.UseConfiguration(tenantDatabasesConfiguration);
persistence.UseSubscriptionStorageConfiguration(sharedDatabaseConfiguration);
persistence.UseTimeoutStorageConfiguration(sharedDatabaseConfiguration);
persistence.DisableSchemaUpdate();
endpointConfiguration.EnableOutbox();
SettingsHolder settingsHolder = endpointConfiguration.GetSettings();
settingsHolder.Set("NHibernate.Timeouts.AutoUpdateSchema", true);
settingsHolder.Set("NHibernate.Subscriptions.AutoUpdateSchema", true);
#endregion
#region ReplaceOpenSqlConnection
endpointConfiguration.Pipeline.Register <ExtractTenantConnectionStringBehavior.Registration>();
#endregion
#region RegisterPropagateTenantIdBehavior
endpointConfiguration.Pipeline.Register <PropagateOutgoingTenantIdBehavior.Registration>();
endpointConfiguration.Pipeline.Register <PropagateIncomingTenantIdBehavior.Registration>();
#endregion
endpointConfiguration.DisableFeature <SecondLevelRetries>();
#region CreateSchema
#endregion
IStartableEndpoint startableEndpoint = await Endpoint.Create(endpointConfiguration);
IEndpointInstance endpoint = null;
CreateSchema(tenantDatabasesConfiguration, "A");
CreateSchema(tenantDatabasesConfiguration, "B");
try
{
endpoint = await startableEndpoint.Start();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
if (endpoint != null)
{
await endpoint.Stop();
}
}
}
