static EndpointConfiguration DistributionConfig(string endpointName)
{
#region DistributionEndpointName
var distributionEndpointName = $"{endpointName}.{Utils.GetUniqueDataDistributionId()}";
var distributionConfig = new EndpointConfiguration(distributionEndpointName);
#endregion
#region DistributionEndpointTypes
var typesToExclude = AllTypes
.Where(t => t.Namespace != "DataDistribution")
.ToArray();
var assemblyScanner = distributionConfig.AssemblyScanner();
assemblyScanner.ExcludeTypes(typesToExclude);
#endregion
var transport = distributionConfig.UseTransport <MsmqTransport>();
var routing = transport.Routing();
routing.RegisterPublisher(
publisherEndpoint: "Samples.DataDistribution.Server",
eventType: typeof(OrderAccepted));
ApplyDefaults(distributionConfig);
return(distributionConfig);
}
public static Task <IStartableEndpoint> Create(Settings.Settings settings, TransportCustomization transportCustomization, TransportSettings transportSettings, LoggingSettings loggingSettings, IContainer container, Action <ICriticalErrorContext> onCriticalError, EmbeddableDocumentStore documentStore, EndpointConfiguration configuration, bool isRunningAcceptanceTests)
{
var endpointName = settings.ServiceName;
if (configuration == null)
{
configuration = new EndpointConfiguration(endpointName);
var assemblyScanner = configuration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("ServiceControl.Plugin");
}
configuration.Pipeline.Register(typeof(FullTypeNameOnlyBehavior), "Remove asm qualified name from the message type header");
// HACK: Yes I know, I am hacking it to pass it to RavenBootstrapper!
configuration.GetSettings().Set(documentStore);
configuration.GetSettings().Set("ServiceControl.Settings", settings);
configuration.SendOnly();
transportCustomization.CustomizeSendOnlyEndpoint(configuration, transportSettings);
//DisablePublishing API is available only on TransportExtensions for transports that implement IMessageDrivenPubSub so we need to set settings directly
configuration.GetSettings().Set("NServiceBus.PublishSubscribe.EnablePublishing", false);
var routing = new RoutingSettings(configuration.GetSettings());
routing.RouteToEndpoint(typeof(RegisterNewEndpoint), settings.ServiceControlQueueAddress);
routing.RouteToEndpoint(typeof(MarkMessageFailureResolvedByRetry), settings.ServiceControlQueueAddress);
configuration.GetSettings().Set(loggingSettings);
configuration.SetDiagnosticsPath(loggingSettings.LogPath);
// sagas are not auto-disabled for send-only endpoints
configuration.DisableFeature <Sagas>();
configuration.UseSerialization <NewtonsoftSerializer>();
configuration.Conventions().DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) || IsExternalContract(t));
if (!isRunningAcceptanceTests)
{
configuration.ReportCustomChecksTo(settings.ServiceControlQueueAddress);
}
#pragma warning disable CS0618 // Type or member is obsolete
configuration.UseContainer <AutofacBuilder>(c => c.ExistingLifetimeScope(container));
#pragma warning restore CS0618 // Type or member is obsolete
configuration.DefineCriticalErrorAction(criticalErrorContext =>
{
onCriticalError(criticalErrorContext);
return(Task.FromResult(0));
});
if (Environment.UserInteractive && Debugger.IsAttached)
{
configuration.EnableInstallers();
}
return(Endpoint.Create(configuration));
}
static IHostBuilder ConfigureEndpointOne(IHostBuilder builder)
{
builder.UseConsoleLifetime();
builder.ConfigureLogging((ctx, logging) =>
{
logging.AddConfiguration(ctx.Configuration.GetSection("Logging"));
logging.AddEventLog();
logging.AddConsole();
});
builder.UseNServiceBus(ctx =>
{
#region multi-hosting-assembly-scan
var endpointConfiguration = new EndpointConfiguration("Instance1");
var scanner = endpointConfiguration.AssemblyScanner();
scanner.ExcludeAssemblies("Instance2");
#endregion
endpointConfiguration.UseTransport <LearningTransport>();
endpointConfiguration.DefineCriticalErrorAction(OnCriticalError);
return(endpointConfiguration);
});
return(builder);
}
private static async Task <IEndpointInstance> ServiceCollection(string endpointName, string connectionString)
{
var endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.EnableInstallers();
endpointConfiguration.SendFailedMessagesTo("error");
var transport = endpointConfiguration.UseTransport <RabbitMQTransport>()
.UseConventionalRoutingTopology();
transport.ConnectionString(connectionString);
var routing = transport
.Routing();
routing.RouteToEndpoint(typeof(ItemSoldOutEvent), endpointName);
var conventions = endpointConfiguration.Conventions();
conventions.DefiningEventsAs(
type => type.Namespace != null && type.Namespace.Contains("Catalog.Infrastructure"));
var scanner = endpointConfiguration.AssemblyScanner();
scanner.ScanAssembliesInNestedDirectories = true;
return(await Endpoint.Start(endpointConfiguration).ConfigureAwait(false));
}
public static Configure NServiceBus(this Configure config, EndpointConfiguration endpointConfig)
{
{
var settings = endpointConfig.GetSettings();
var conventions = endpointConfig.Conventions();
// set the configured endpoint name to the one NSB config was constructed with
config.SetEndpointName(settings.Get <string>("NServiceBus.Routing.EndpointName"));
conventions.DefiningCommandsAs(type => typeof(Messages.ICommand).IsAssignableFrom(type));
conventions.DefiningEventsAs(type => typeof(Messages.IEvent).IsAssignableFrom(type));
conventions.DefiningMessagesAs(type => typeof(Messages.IMessage).IsAssignableFrom(type));
endpointConfig.AssemblyScanner().ScanAppDomainAssemblies = true;
endpointConfig.EnableCallbacks();
endpointConfig.EnableInstallers();
endpointConfig.UseSerialization <Internal.AggregatesSerializer>();
endpointConfig.EnableFeature <Feature>();
}
config.RegistrationTasks.Add(c =>
{
var container = c.Container;
container.Register(factory => new Aggregates.Internal.DelayedRetry(factory.Resolve <IMetrics>(), factory.Resolve <IMessageDispatcher>()), Lifestyle.Singleton);
return(Task.CompletedTask);
});
config.SetupTasks.Add((c) =>
{
var settings = endpointConfig.GetSettings();
settings.Set("Retries", config.Retries);
settings.Set("SlowAlertThreshold", config.SlowAlertThreshold);
// Set immediate retries to 0 - we handle retries ourselves any message which throws should be sent to error queue
endpointConfig.Recoverability().Immediate(x =>
{
x.NumberOfRetries(0);
});
endpointConfig.Recoverability().Delayed(x =>
{
x.NumberOfRetries(0);
});
endpointConfig.MakeInstanceUniquelyAddressable(c.UniqueAddress);
endpointConfig.LimitMessageProcessingConcurrencyTo(c.ParallelMessages);
// NSB doesn't have an endpoint name setter other than the constructor, hack it in
settings.Set("NServiceBus.Routing.EndpointName", c.Endpoint);
return(Aggregates.Bus.Start(endpointConfig));
});
return(config);
}
//static EndpointConfiguration DistributionConfig(string endpointName)
//{
// #region DistributionEndpointName
// var distributionEndpointName = $"{endpointName}.{Utils.GetUniqueDataDistributionId()}";
// var distributionConfig = new EndpointConfiguration(distributionEndpointName);
// #endregion
// #region DistributionEndpointTypes
// var typesToExclude = AllTypes
// .Where(t => t.Namespace != "DataDistribution")
// .ToArray();
// var scanner = distributionConfig.AssemblyScanner();
// scanner.ExcludeTypes(typesToExclude);
// #endregion
// var transport = distributionConfig.UseTransport<MsmqTransport>();
// var routing = transport.Routing();
// routing.RegisterPublisher(
// publisherEndpoint: "Samples.DataDistribution.Server-2",
// eventType: typeof(OrderAccepted));
// ApplyDefaults(distributionConfig);
// return distributionConfig;
//}
static EndpointConfiguration MainConfig(string endpointName)
{
#region MainConfig
var mainConfig = new EndpointConfiguration(endpointName);
var typesToExclude = AllTypes
.Where(t => t.Namespace == "DataDistribution")
.ToArray();
var scanner = mainConfig.AssemblyScanner();
scanner.ExcludeTypes(typesToExclude);
var transport = mainConfig.UseTransport <MsmqTransport>();
var mainRouting = transport.Routing();
mainRouting.RouteToEndpoint(
messageType: typeof(PlaceOrder),
destination: "Samples.DataDistribution.Server-2");
//mainRouting.RegisterPublisher(
// publisherEndpoint: "Samples.DataDistribution.Server-2",
// eventType: typeof(OrderAccepted));
#endregion
ApplyDefaults(mainConfig);
return(mainConfig);
}
public static void AddEndpointInstance(this IServiceCollection services, ApplicationSettings applicationSettings)
{
var endpointConfiguration = new EndpointConfiguration(applicationSettings.MatchedLearnerImportQueue);
var conventions = endpointConfiguration.Conventions();
conventions.DefiningEventsAs(t => typeof(SubmissionJobSucceeded).IsAssignableFrom(t));
conventions.DefiningCommandsAs(t => typeof(ImportMatchedLearnerData).IsAssignableFrom(t));
endpointConfiguration.UseTransport <AzureServiceBusTransport>().ConnectionString(applicationSettings.PaymentsServiceBusConnectionString);
endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
endpointConfiguration.SendOnly();
endpointConfiguration.CustomDiagnosticsWriter(diagnostics => Task.CompletedTask);
endpointConfiguration.DisableFeature <TimeoutManager>();
endpointConfiguration.EnableInstallers();
if (!string.IsNullOrEmpty(applicationSettings.NServiceBusLicense))
{
var license = WebUtility.HtmlDecode(applicationSettings.NServiceBusLicense);
endpointConfiguration.License(license);
}
#if DEBUG
//NOTE: This is required to run the function from Acceptance test project
var assemblyScanner = endpointConfiguration.AssemblyScanner();
assemblyScanner.ThrowExceptions = false;
#endif
var endpointInstance = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
services.AddSingleton(endpointInstance);
}
public override async Task Execute(HostArguments args)
{
var settings = new Settings(args.ServiceName)
{
IngestErrorMessages = false,
RunRetryProcessor = false
};
var busConfiguration = new EndpointConfiguration(settings.ServiceName);
var assemblyScanner = busConfiguration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("ServiceControl.Plugin");
var tokenSource = new CancellationTokenSource();
var loggingSettings = new LoggingSettings(settings.ServiceName, false, defaultLevel: LogLevel.Info, defaultRavenDBLevel: LogLevel.Info);
var bootstrapper = new Bootstrapper(settings, busConfiguration, loggingSettings);
var instance = await bootstrapper.Start().ConfigureAwait(false);
var errorIngestion = instance.ErrorIngestion;
Console.CancelKeyPress += (sender, eventArgs) => { tokenSource.Cancel(); };
try
{
await errorIngestion.ImportFailedErrors(tokenSource.Token).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
// no-op
}
finally
{
await bootstrapper.Stop().ConfigureAwait(false);
}
}
protected override IHostBuilder CreateHostBuilder()
{
return(Host.CreateDefaultBuilder()
.UseMicrosoftLogFactoryLogging()
.UseNServiceBus(hostBuilderContext =>
{
var endpoint = new EndpointConfiguration(WebApplication.Program.EndpointName);
endpoint.AssemblyScanner().ExcludeAssemblies("ChildWorkerService.dll", "WorkerService.dll");
endpoint.ConfigureTestEndpoint(transport =>
{
var routing = transport.Routing();
routing.RouteToEndpoint(typeof(SaySomething).Assembly, WorkerService.Program.EndpointName);
});
endpoint.UsePersistence <LearningPersistence>();
endpoint.UseSerialization <SystemJsonSerializer>();
return endpoint;
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <WebApplication.Startup>();
}));
}
void ScanningExcludeByWildcard(EndpointConfiguration endpointConfiguration)
{
#region ScanningAssembliesWildcard
var scanner = endpointConfiguration.AssemblyScanner();
var excludeRegexs = new List <string>
{
@"App_Web_.*\.dll",
@".*\.resources\.dll"
};
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
foreach (var fileName in Directory.EnumerateFiles(baseDirectory, "*.dll")
.Select(Path.GetFileName))
{
foreach (var pattern in excludeRegexs)
{
if (Regex.IsMatch(fileName, pattern, RegexOptions.IgnoreCase))
{
scanner.ExcludeAssemblies(fileName);
break;
}
}
}
#endregion
}
// TODO: 2.8
public static void AddNServiceBus(this IServiceCollection services)
{
var endpointConfiguration = new EndpointConfiguration("front-stateless");
endpointConfiguration.SendOnly();
var transport = endpointConfiguration.UseTransport <RabbitMQTransport>();
#region Not Important
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.EnableInstallers();
var provider = services.BuildServiceProvider();
var context = provider.GetService <StatelessServiceContext>();
var connectionString = context.GetTransportConnectionString();
transport.ConnectionString(connectionString);
var delayedDelivery = transport.DelayedDelivery();
delayedDelivery.DisableTimeoutManager();
var assemblyScanner = endpointConfiguration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("netstandard");
#endregion
var routing = transport.Routing();
var backStateless = "back-stateless";
routing.RouteToEndpoint(typeof(SubmitOrder), backStateless);
routing.RouteToEndpoint(typeof(CancelOrder), backStateless);
var endpointInstance = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
services.AddSingleton <IMessageSession>(endpointInstance);
}
void RunAndWait(HostArguments args)
{
var settings = new Settings
{
IngestAuditMessages = false,
IngestErrorMessages = false
};
var busConfiguration = new EndpointConfiguration(settings.ServiceName);
var assemblyScanner = busConfiguration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("ServiceControl.Plugin");
var tokenSource = new CancellationTokenSource();
var loggingSettings = new LoggingSettings(settings.ServiceName, LogLevel.Info, LogLevel.Info);
var bootstrapper = new Bootstrapper(ctx => { tokenSource.Cancel(); }, settings, busConfiguration, loggingSettings);
var importer = bootstrapper.Start().GetAwaiter().GetResult().ImportFailedAudits;
Console.CancelKeyPress += (sender, eventArgs) => { tokenSource.Cancel(); };
var importTask = importer.Run(tokenSource);
Console.WriteLine("Press Ctrl+C to exit");
importTask.GetAwaiter().GetResult();
}
public static async Task <IEndpointInstance> CreateEndPoint(string connectionString, string queueName)
{
var endpointConfiguration = new EndpointConfiguration(queueName);
//var performanceCounters = endpointConfiguration.EnableWindowsPerformanceCounters();
//performanceCounters.EnableSLAPerformanceCounters(TimeSpan.FromMinutes(3));
//performanceCounters.UpdateCounterEvery(TimeSpan.FromSeconds(2));
var transport = endpointConfiguration.UseTransport <RabbitMQTransport>();
transport.ConnectionString(connectionString);
// for RabbitMQ transport only
var delayedDelivery = transport.DelayedDelivery();
delayedDelivery.DisableTimeoutManager();
var assemblyScanner = endpointConfiguration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("Common.dll", "NServiceBus.Persistence.Sql.dll");
assemblyScanner.ExcludeTypes(typeof(ArtifactsPublishedMessageHandler));
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.LimitMessageProcessingConcurrencyTo(1);
endpointConfiguration.SendFailedMessagesTo("errors");
endpointConfiguration.License(LicenseInfo);
endpointConfiguration.SendOnly();
return(await Endpoint.Start(endpointConfiguration));
}
public static Task <IStartableEndpoint> Create(Settings.Settings settings, TransportCustomization transportCustomization, TransportSettings transportSettings, LoggingSettings loggingSettings, IContainer container, Action <ICriticalErrorContext> onCriticalError, EmbeddableDocumentStore documentStore, EndpointConfiguration configuration, bool isRunningAcceptanceTests)
{
var endpointName = settings.ServiceName;
if (configuration == null)
{
configuration = new EndpointConfiguration(endpointName);
var assemblyScanner = configuration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("ServiceControl.Plugin");
}
// HACK: Yes I know, I am hacking it to pass it to RavenBootstrapper!
configuration.GetSettings().Set(documentStore);
configuration.GetSettings().Set("ServiceControl.Settings", settings);
MapSettings(transportSettings, settings);
transportCustomization.CustomizeEndpoint(configuration, transportSettings);
configuration.GetSettings().Set(loggingSettings);
// Disable Auditing for the service control endpoint
configuration.DisableFeature <Audit>();
configuration.DisableFeature <AutoSubscribe>();
configuration.DisableFeature <TimeoutManager>();
configuration.DisableFeature <Outbox>();
var recoverability = configuration.Recoverability();
recoverability.Immediate(c => c.NumberOfRetries(3));
recoverability.Delayed(c => c.NumberOfRetries(0));
configuration.SendFailedMessagesTo($"{endpointName}.Errors");
configuration.UseSerialization <NewtonsoftSerializer>();
configuration.LimitMessageProcessingConcurrencyTo(settings.MaximumConcurrencyLevel);
configuration.Conventions().DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) || IsExternalContract(t));
if (!isRunningAcceptanceTests)
{
configuration.ReportCustomChecksTo(endpointName);
}
configuration.UseContainer <AutofacBuilder>(c => c.ExistingLifetimeScope(container));
configuration.DefineCriticalErrorAction(criticalErrorContext =>
{
onCriticalError(criticalErrorContext);
return(Task.FromResult(0));
});
if (Environment.UserInteractive && Debugger.IsAttached)
{
configuration.EnableInstallers();
}
return(Endpoint.Create(configuration));
}
void SwallowScanningExceptions(EndpointConfiguration endpointConfiguration)
{
#region SwallowScanningExceptions
var scanner = endpointConfiguration.AssemblyScanner();
scanner.ThrowExceptions = false;
#endregion
}
void ScanningExcludeTypes(EndpointConfiguration endpointConfiguration, Type type1, Type type2)
{
#region ScanningExcludeTypes
var scanner = endpointConfiguration.AssemblyScanner();
scanner.ExcludeTypes(type1, type2);
#endregion
}
void ScanningApDomainAssemblies(EndpointConfiguration endpointConfiguration)
{
#region ScanningApDomainAssemblies
var scanner = endpointConfiguration.AssemblyScanner();
scanner.ScanAppDomainAssemblies = false;
#endregion
}
void ScanningExcludeByName(EndpointConfiguration endpointConfiguration)
{
#region ScanningExcludeByName
var scanner = endpointConfiguration.AssemblyScanner();
scanner.ExcludeAssemblies("MyAssembly1.dll", "MyAssembly2.dll");
#endregion
}
void ScanningNestedAssembliesEnabled(EndpointConfiguration endpointConfiguration)
{
#region ScanningNestedAssebliesEnabled
var scanner = endpointConfiguration.AssemblyScanner();
scanner.ScanAssembliesInNestedDirectories = true;
#endregion
}
static Task <IEndpointInstance> StartSendOnlyEndpoint()
{
var endpointConfiguration = new EndpointConfiguration("Samples.MultiHosting.SendOnly");
var scanner = endpointConfiguration.AssemblyScanner();
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.UseTransport <LearningTransport>();
return(Endpoint.Start(endpointConfiguration));
}
void ScanningUpgrade(EndpointConfiguration endpointConfiguration)
{
#region 5to6ScanningUpgrade
endpointConfiguration.AssemblyScanner().ExcludeAssemblies(
"BadAssembly1.dll",
"BadAssembly2.dll");
#endregion
}
void AdditionalAssemblyScanningPath(EndpointConfiguration endpointConfiguration)
{
var additionalPathToScanAssemblies = "";
#region AdditionalAssemblyScanningPath
var scanner = endpointConfiguration.AssemblyScanner();
scanner.AdditionalAssemblyScanningPath = additionalPathToScanAssemblies;
#endregion
}
static Task <IEndpointInstance> StartInstance2()
{
var endpointConfiguration = new EndpointConfiguration("Samples.MultiHosting.Instance2");
var scanner = endpointConfiguration.AssemblyScanner();
scanner.ExcludeAssemblies("Instance1");
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.UseTransport <LearningTransport>();
return(Endpoint.Start(endpointConfiguration));
}
/// <summary>
/// This method is responsible for initializing the echo endpoint used to receive events and commands
/// </summary>
/// <returns>Nothing.</returns>
static async Task AsyncMain()
{
Console.Title = "Weather";
//Create a new Endpoint configuration with the name "Echo"
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("Weather");
//These two lines prevemt the endpoint configuration from scanning the MySql dll.
//This is done because it speeds up the startup time, and it prevents a rare but
//very confusing error sometimes caused by NServiceBus scanning the file. If you
//wish to know morw about this, google it, then ask your TA(since they will probably
//just google it anyway)
var scanner = endpointConfiguration.AssemblyScanner();
scanner.ExcludeAssemblies("MySql.Data.dll");
//Allows the endpoint to run installers upon startup. This includes things such as the creation of message queues.
endpointConfiguration.EnableInstallers();
//Instructs the queue to serialize messages with Json, should it need to serialize them
endpointConfiguration.UseSerialization <JsonSerializer>();
//Instructs the endpoint to use local RAM to store queues.Good during development, not during deployment (According to the NServiceBus tutorial)
endpointConfiguration.UsePersistence <InMemoryPersistence>();
//Instructs the endpoint to send messages it cannot process to a queue named "error"
endpointConfiguration.SendFailedMessagesTo("error");
//Instructs the endpoint to use Microsoft Message Queuing
var transport = endpointConfiguration.UseTransport <MsmqTransport>();
//This variable is used to configure how messages are routed. Using this, you may set the default reciever of a particular command, and/or subscribe to any number of events
var routing = transport.Routing();
//Register to the AsIsEcho event published by the Authentication endpoint
//Start the endpoint with the configuration defined above. It should be noted that any changes made to the endpointConfiguration after an endpoint is instantiated will not apply to any endpoints that have already been instantiated
var endpointInstance = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false);
Debug.consoleMsg("Press Enter to exit.");
string entry;
do
{
entry = Console.ReadLine();
switch (entry)
{
default:
Debug.consoleMsg("Command not understood");
break;
}
} while (!entry.Equals(""));
await endpointInstance.Stop().ConfigureAwait(false);
}
protected override void OnStart(string[] args)
{
var busConfiguration = new EndpointConfiguration(ServiceName);
var assemblyScanner = busConfiguration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("ServiceControl.Plugin");
var loggingSettings = new LoggingSettings(ServiceName);
bootstrapper = new Bootstrapper(ctx => Stop(), new Settings(ServiceName), busConfiguration, loggingSettings);
bootstrapper.Start().GetAwaiter().GetResult();
}
public EndpointConfiguration CreateConfiguration()
{
var config = new EndpointConfiguration("DebtCollection");
config.UseTransport <LearningTransport>();
config.SendFailedMessagesTo("error");
var scanner = config.AssemblyScanner();
scanner.IncludeOnlyThisAssemblyAndReferences();
return(config);
}
static Task <IEndpointInstance> StartInstance2()
{
var endpointConfiguration = new EndpointConfiguration("Samples.MultiHosting.Instance2");
var assemblyScanner = endpointConfiguration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("Instance1");
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.SendFailedMessagesTo("error");
return(Endpoint.Start(endpointConfiguration));
}
public async Task Start()
{
var configuration = new EndpointConfiguration("trace");
configuration.UseTransport <LearningTransport>();
conversationTracker = new ConversationTracker();
configuration.RegisterComponents(cc => cc.RegisterSingleton(conversationTracker));
configuration.AssemblyScanner().ExcludeAssemblies("Marketing.exe", "Orders.exe");
tracer = await Endpoint.Start(configuration);
}
public async Task Should_throw()
{
var configuration = new EndpointConfiguration("Endpoint1");
configuration.UseTransport <LearningTransport>();
var scanner = configuration.AssemblyScanner();
scanner.ExcludeAssemblies("NServiceBus.Core.Tests.dll");
await Endpoint.Create(configuration).ConfigureAwait(false);
Assert.ThrowsAsync <ArgumentException>(async() => await Endpoint.Create(configuration).ConfigureAwait(false));
}
public static TransportExtensions ApplyCommonConfiguration(this EndpointConfiguration endpointConfiguration, IReliableStateManager stateManager, ServicePartitionInformation partitionInformation, StatefulServiceContext context)
{
var assemblyScanner = endpointConfiguration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("netstandard");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.AuditProcessedMessagesTo("audit");
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.EnableInstallers();
var instance = partitionInformation as NamedPartitionInformation;
if (instance != null)
{
endpointConfiguration.RegisterComponents(c => c.RegisterSingleton(instance));
}
var information = partitionInformation as Int64RangePartitionInformation;
if (information != null)
{
endpointConfiguration.RegisterComponents(c => c.RegisterSingleton(information));
}
var persistence = endpointConfiguration.UsePersistence <ServiceFabricPersistence>();
persistence.StateManager(stateManager);
var recoverability = endpointConfiguration.Recoverability();
recoverability.DisableLegacyRetriesSatellite();
// for demo purposes
recoverability.Immediate(d => d.NumberOfRetries(0));
recoverability.Delayed(d => d.NumberOfRetries(0));
var configurationPackage = context.CodePackageActivationContext.GetConfigurationPackageObject("Config");
var connectionString = configurationPackage.Settings.Sections["NServiceBus"].Parameters["ConnectionString"];
var transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>();
if (string.IsNullOrWhiteSpace(connectionString.Value))
{
throw new Exception("Could not read the 'NServiceBus.ConnectionString'. Check the sample prerequisites.");
}
transport.ConnectionString(connectionString.Value);
transport.UseForwardingTopology();
return(transport);
}
