public static async Task PublishEventToAzure(string messageText, NServiceBusConfiguration nServiceBusSettings,
bool useLearningTransport = false)
{
var endpointConfiguration = new EndpointConfiguration(nServiceBusSettings.Endpoint)
.UseLicense(nServiceBusSettings.LicenceText)
.UseAzureServiceBusTransport(false, () => nServiceBusSettings.ServiceBusConnectionString,
r =>
{
r.RouteToEndpoint(typeof(StringMessageEvent), nServiceBusSettings.Endpoint + "/my-topic");
})
.UseNewtonsoftJsonSerializer();
endpointConfiguration.SendOnly();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
//var options = new PublishOptions();
var message = new StringMessageEvent(messageText);
await endpointInstance.Publish(message) //, options)
.ConfigureAwait(false);
System.Console.WriteLine($"Published event: {message}");
}
static async Task Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var configuration = builder.Build();
var nServiceBusSettings = new NServiceBusConfiguration();
configuration.GetSection("NServiceBusConfiguration").Bind(nServiceBusSettings);
var useLearningTransport = configuration.GetValue <bool>("UseLearningTransport");
System.Console.WriteLine($"NServiceBus Settings:");
System.Console.WriteLine($" UseLearningTransport {useLearningTransport}");
System.Console.WriteLine($" Local Endpoint {nServiceBusSettings.LocalEndpoint}");
System.Console.WriteLine($" Endpoint {nServiceBusSettings.Endpoint}");
System.Console.WriteLine($" Service bus {nServiceBusSettings.ServiceBusConnectionString}");
System.Console.WriteLine($" License {nServiceBusSettings.LicenceText}");
var runOptionKey = GetRunOption();
while (runOptionKey != ConsoleKey.Q && runOptionKey != ConsoleKey.Escape)
{
try
{
switch (runOptionKey)
{
case ConsoleKey.D1:
case ConsoleKey.NumPad1:
await SendMessage("Hello World", nServiceBusSettings, useLearningTransport);
break;
case ConsoleKey.D2:
case ConsoleKey.NumPad2:
case ConsoleKey.Enter: //Default
await SendMessageToAzure("Hello World", nServiceBusSettings, false);
break;
case ConsoleKey.D3:
case ConsoleKey.NumPad3:
await PublishEventToAzure("Hello World", nServiceBusSettings, false);
break;
}
}
catch (Exception ex)
{
Debug.Print($"An exception has occurred. {ex}");
System.Console.WriteLine($"An exception has occurred. {ex}");
}
System.Console.WriteLine("....");
runOptionKey = GetRunOption();
}
}
public static void StartConfiguredEndpoints(
IConfigurationRoot configurationRoot,
IContainer container,
IDictionary <string, string[]> endpointToTopicMapping,
Action <EndpointConfiguration> allEndpointSetupOptions = null,
IDictionary <string, Action <EndpointConfiguration> > setupEndpointOptions = null)
{
var endpointInstanceProvider = container.Resolve <IEndpointInstanceProvider>() as EndpointInstanceProvider;
if (endpointInstanceProvider == null)
{
throw new Exception("Could not resolve IEndpointInstanceProvider from given container. Make sure its registered with AddNServiceBus or manually.");
}
var section = configurationRoot.GetSection(nameof(NServiceBusConfiguration));
var nServiceBusConfiguration = new NServiceBusConfiguration();
section.Bind(nServiceBusConfiguration);
var busEndpointConfigurations = nServiceBusConfiguration.Endpoints;
foreach (var busEndpointOptions in busEndpointConfigurations)
{
var endpointConfiguration = new EndpointConfiguration(busEndpointOptions.Name);
endpointConfiguration.SendFailedMessagesTo(busEndpointOptions.FailedMessagesQueueName);
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.UseContainer <AutofacBuilder>(
customizations => customizations.ExistingLifetimeScope(container));
allEndpointSetupOptions?.Invoke(endpointConfiguration);
if (setupEndpointOptions != null && setupEndpointOptions.ContainsKey(busEndpointOptions.Name))
{
var setupFunc = setupEndpointOptions[busEndpointOptions.Name];
setupFunc?.Invoke(endpointConfiguration);
}
var endpointInstance = Endpoint.Start(endpointConfiguration).ConfigureAwait(false).GetAwaiter().GetResult();
if (endpointToTopicMapping.ContainsKey(busEndpointOptions.Name))
{
var topicNames = endpointToTopicMapping[busEndpointOptions.Name];
foreach (var topicName in topicNames)
{
endpointInstanceProvider.Add(topicName, busEndpointOptions.Name, endpointInstance);
}
}
else
{
// Todo: throw warning that no mapping exist to an endpoint (maybe no need for handler only)
var loggerFactory = container.Resolve <ILoggerFactory>();
var logger = loggerFactory.CreateLogger(typeof(NServiceBusServiceCollectionExtensions));
logger.LogWarning($"Endpoint instance {busEndpointOptions.Name} does not have mapping to topics. Make sure you did not forget to add mappings.");
}
}
}
public void ConfigureServices(IServiceCollection services)
{
//#region EndpointConfiguration
//var builder = new ConfigurationBuilder().AddCloudFoundry();
//Console.WriteLine("Building the configuration");
//var config = builder.Build();
//Console.WriteLine("Looking for the RabbitMQ URI");
//string uri = config["vcap:services:p-rabbitmq:0:credentials:dashboard_url"];
//Console.WriteLine(uri);
//var endpointConfiguration = new EndpointConfiguration("Samples.ASPNETCore.Sender");
//var transport = endpointConfiguration.UseTransport<RabbitMQTransport>();
//transport.UseConventionalRoutingTopology();
//transport.ConnectionString(uri);
////endpointConfiguration.EnableInstallers();
//endpointConfiguration.UsePersistence<InMemoryPersistence>();
//endpointConfiguration.SendOnly();
//#endregion
//#region Routing
//var routing = transport.Routing();
//routing.RouteToEndpoint(
// assembly: typeof(MyMessage).Assembly,
// destination: "Samples.ASPNETCore.Endpoint");
//#endregion
//#region EndpointStart
//Console.WriteLine("Starting endpoint");
//var endpointInstance = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
//Console.WriteLine("Started endpoint");
//#endregion
var endpointInstance = NServiceBusConfiguration.Setup();
#region ServiceRegistration
Console.WriteLine("Setting IMessageSession");
services.AddSingleton <IMessageSession>(endpointInstance);
#endregion
services.AddMvc();
}
public Sender(NServiceBusConfiguration nServiceBusConfig,
IEndpointInstance endpointInstance,
IEventPublisher publisher,
IUnitOfWorkContext unitOfWorkContext)
//, ILog log)
{
//_log = log;
_nServiceBusConfig = nServiceBusConfig;
Publisher = publisher;
EndpointInstance = endpointInstance;
_unitOfWorkContext = unitOfWorkContext;
}
static async Task MainAsync(string[] args)
{
try
{
NServiceBusConfiguration.Setup();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
await Task.Delay(-1);
}
public void GivenJsonConfigurationGivenBadNameShouldThrow()
{
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("TestSettings.json");
var root = configurationBuilder.Build();
var section = root.GetSection(nameof(NServiceBusConfiguration));
var configuration = new NServiceBusConfiguration();
section.Bind(configuration);
var config = configuration.GetByName("non existing one");
}
public void GivenJsonConfigurationShouldParseCorrectly()
{
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("TestSettings.json");
var root = configurationBuilder.Build();
var section = root.GetSection(nameof(NServiceBusConfiguration));
var configuration = new NServiceBusConfiguration();
section.Bind(configuration);
Assert.AreEqual(2, configuration.Endpoints.Length);
}
public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args)
.ConfigureServices((context, container) => {
container.AddSingleton <IEventsFactory, EventsFactory>();
container.AddScoped <IPortfolioHistoryRepository, PortfolioHistoryRepository>();
container.AddDbContext <PortfolioHistoryContext>(options => options.UseSqlServer(context.Configuration.GetValue <string>(ConfigurationConstants.HistoryConnectionString),
b => b.MigrationsAssembly("FundAggregator.Portfolio.Service")));;
})
.UseNServiceBus(context => {
var nServiceBusConfigurations = new NServiceBusSettings()
{
EndpointName = context.Configuration.GetValue <string>(ConfigurationConstants.ServiceName),
PersistenceConnectionString = context.Configuration.GetValue <string>(ConfigurationConstants.PersistenceConnectionString)
};
var endpointConfiguration = NServiceBusConfiguration.ConfigureEndpoint(nServiceBusConfigurations);
return(endpointConfiguration);
});
public void GivenJsonConfigurationShouldGetByName()
{
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("TestSettings.json");
var root = configurationBuilder.Build();
var section = root.GetSection(nameof(NServiceBusConfiguration));
var configuration = new NServiceBusConfiguration();
section.Bind(configuration);
var config = configuration.GetByName("Schroders.Product.Handler");
Assert.IsNotNull(config);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddTransient <DbConnection>(provider =>
new SqlConnection(Configuration.GetConnectionString("DatabaseConnectionString")));
//Need the serviceprovider so we can get the DBConnection back
var sp = services.BuildServiceProvider();
services.AddMvc();
var container = ConfigureIOC(services);
var nServiceBusSettings = new NServiceBusConfiguration();
Configuration.GetSection("NServiceBusConfiguration").Bind(nServiceBusSettings);
var useLearningTransport = Configuration.GetValue <bool>("UseLearningTransport");
var endpointConfiguration = new EndpointConfiguration(nServiceBusSettings.Endpoint)
//.UseAzureServiceBusTransport(useLearningTransport, () => nServiceBusSettings.ServiceBusConnectionString, r => { })
.UseAzureServiceBusTransport(useLearningTransport,
() => nServiceBusSettings.ServiceBusConnectionString,
r =>
{
//r.RouteToEndpoint(typeof(StringMessage),
// nServiceBusSettings.Endpoint);
//r.RouteToEndpoint(typeof(StringMessageEvent),
// nServiceBusSettings.Endpoint + "/my-topic");
})
.UseLicense(nServiceBusSettings.LicenceText)
.UseInstallers()
.UseSqlServerPersistence(() => sp.GetService <DbConnection>())
.UseStructureMapBuilder(container)
.UseNewtonsoftJsonSerializer()
//.UseErrorQueue()
//.UseNLogFactory()
.UseOutbox()
.UseUnitOfWork();
services.AddNServiceBus(endpointConfiguration);
container.Populate(services);
return(container.GetInstance <IServiceProvider>());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
var nsb = new NServiceBusConfiguration();
//nsb.RegisterTypes(services);
nsb.Configure(services);
}
public static async Task SendMessageToAzure(string messageText, NServiceBusConfiguration nServiceBusSettings, bool useLearningTransport = false)
{
var endpointConfiguration = new EndpointConfiguration("ClientEndpoint")
.UseLicense(nServiceBusSettings.LicenceText)
.UseAzureServiceBusTransport(false,
() => nServiceBusSettings.ServiceBusConnectionString,
r => r.RouteToEndpoint(typeof(StringMessage).GetAssembly(), nServiceBusSettings.Endpoint))
.UseNewtonsoftJsonSerializer();
endpointConfiguration.SendOnly();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
var message = new StringMessage(messageText);
await endpointInstance.Send(message) //, options)
.ConfigureAwait(false);
System.Console.WriteLine($"Sent message: {message}");
}
public static async Task SendMessage(string messageText, NServiceBusConfiguration nServiceBusSettings, bool useLearningTransport = false)
{
var endpointConfiguration = new EndpointConfiguration(nServiceBusSettings.LocalEndpoint);
endpointConfiguration.License(nServiceBusSettings.LicenceText);
if (useLearningTransport)
{
endpointConfiguration.UseTransport <LearningTransport>();
}
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
var options = new SendOptions();
options.SetDestination(nServiceBusSettings.Endpoint);
var message = new StringMessage(messageText);
await endpointInstance.Send(message, options)
.ConfigureAwait(false);
System.Console.WriteLine($"Sent message: {message}");
}
public NServiceBusEndpoint(IConfiguration _configuration)
{
config = _configuration.GetSection("NServiceBusConfiguration").Get <NServiceBusConfiguration>();
Initialize().Wait();
}
