StaticUsage(ServiceBusTriggeredEndpointConfiguration serviceBusTriggeredEndpointConfiguration, FunctionExecutionContext executionContext)
{
#region asb-enable-diagnostics
serviceBusTriggeredEndpointConfiguration.LogDiagnostics();
#endregion
}
public override void Configure(IFunctionsHostBuilder builder)
{
builder.UseNServiceBus(() => {
var configuration = new ServiceBusTriggeredEndpointConfiguration("MyFunctionsEndpoint");
configuration.LogDiagnostics();
return(configuration);
});
}
public static void EnableDelayedRetries(ServiceBusTriggeredEndpointConfiguration serviceBusTriggeredEndpointConfiguration)
{
#region asb-configure-error-queue
serviceBusTriggeredEndpointConfiguration.AdvancedConfiguration.SendFailedMessagesTo("error");
#endregion
}
public override void Configure(IFunctionsHostBuilder builder)
{
builder.UseNServiceBus(() => {
var configuration = new ServiceBusTriggeredEndpointConfiguration("MyFunctionsEndpoint");
configuration.AdvancedConfiguration.SendFailedMessagesTo("error");
return(configuration);
});
}
public static ServiceBusTriggeredEndpointConfiguration BuildEndpointConfiguration(IFunctionsHostBuilder builder, IConfiguration configuration)
{
var endpointConfiguration = new ServiceBusTriggeredEndpointConfiguration(configuration["NServiceBus:EndpointName"]);
endpointConfiguration.LogDiagnostics();
var e = endpointConfiguration.AdvancedConfiguration;
var serialization = e.UseSerialization <NewtonsoftSerializer>();
// Newtonsoft serializer doesn't properly deserialize properties with protected setter,
// the following serializer settings will be applied by NServiceBus during all messages's deserializations
serialization.Settings(EventSerialization.Settings);
e.Conventions().DefiningEventsAs(t => t.Namespace != null && t.Namespace.EndsWith("Events"));
e.AuditProcessedMessagesTo(configuration["NServiceBus:AuditQueue"]);
e.SendFailedMessagesTo(configuration["NServiceBus:ErrorQueue"]);
//e.SendHeartbeatTo(serviceControlQueue: configuration["NServiceBus:ServiceControlInstance"],
// frequency: TimeSpan.FromSeconds(15),
// timeToLive: TimeSpan.FromSeconds(30));
//var endpointName = configuration["NServiceBus:EndpointName"];
//var machineName = $"{Dns.GetHostName()}.{IPGlobalProperties.GetIPGlobalProperties().DomainName}";
//var instanceIdentifier = $"{endpointName}@{machineName}";
//var metrics = e.EnableMetrics();
//metrics.SendMetricDataToServiceControl(serviceControlMetricsAddress: configuration["NServiceBus:ServiceControlMonitoringInstance"],
// interval: TimeSpan.FromSeconds(10),
// instanceId: instanceIdentifier);
//This instruction checks every time the application starts up in order to create
//all the necessary NServiceBus objects in the database automatically
var settings = e.GetSettings();
settings.Set("SqlPersistence.ScriptDirectory", builder.GetContext().ApplicationRootPath);
e.EnableInstallers();
return(endpointConfiguration);
}
public async Task Should_load_handlers_from_assembly_when_using_FunctionsHostBuilder()
{
// The message handler assembly shouldn't be loaded at this point because there is no reference in the code to it.
Assert.False(AppDomain.CurrentDomain.GetAssemblies().Any(a => a.FullName == "Testing.Handlers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"));
var serviceCollection = new ServiceCollection();
var configuration = new ServiceBusTriggeredEndpointConfiguration("assemblyTest");
configuration.UseSerialization <XmlSerializer>();
configuration.EndpointConfiguration.UsePersistence <LearningPersistence>();
var settings = configuration.AdvancedConfiguration.GetSettings();
var endpointFactory = FunctionsHostBuilderExtensions.Configure(configuration, serviceCollection,
Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ExternalHandlers"));
var serviceProvider = serviceCollection.BuildServiceProvider();
var endpoint = endpointFactory(serviceProvider);
// we need to process an actual message to have the endpoint being created
await endpoint.Process(GenerateMessage(), new ExecutionContext());
// The message handler assembly should be loaded now because scanning should find and load the handler assembly
Assert.True(AppDomain.CurrentDomain.GetAssemblies().Any(a => a.FullName == "Testing.Handlers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"));
// Verify the handler and message type have been identified and loaded:
var registry = settings.Get <MessageHandlerRegistry>();
var dummyMessageType = registry.GetMessageTypes().FirstOrDefault(t => t.FullName == "Testing.Handlers.DummyMessage");
Assert.NotNull(dummyMessageType);
var dummyMessageHandler = registry.GetHandlersFor(dummyMessageType).SingleOrDefault();
Assert.AreEqual("Testing.Handlers.DummyMessageHandler", dummyMessageHandler.HandlerType.FullName);
// ensure the assembly is loaded into the right context
Assert.AreEqual(AssemblyLoadContext.GetLoadContext(Assembly.GetExecutingAssembly()), AssemblyLoadContext.GetLoadContext(dummyMessageType.Assembly));
}
public override void Configure(IFunctionsHostBuilder builder)
{
var context = builder.GetContext();
builder.UseNServiceBus(() =>
{
string endpointPostfix = "";
// Workaround for unstable EnvironmentName in Azure
// (see https://github.com/Azure/azure-functions-host/issues/6239)
var environmentName = context.Configuration.GetValue <string>("DOTNET_ENVIRONMENT") ??
Environment.GetEnvironmentVariable("AZURE_FUNCTIONS_ENVIRONMENT") ??
Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ??
context.EnvironmentName;
if (environmentName == "Development")
{
endpointPostfix += $".{Environment.MachineName}";
}
string endpointName = $"FplBot.Functions.{environmentName}{endpointPostfix}";
var configuration = new ServiceBusTriggeredEndpointConfiguration(endpointName, "ASB_CONNECTIONSTRING");
Console.WriteLine($"ENDPOINTNAME: {endpointName}");
configuration.Transport.SubscriptionRuleNamingConvention(t =>
{
return(Shorten(t.ToString()));
static string Shorten(string current)
{
if (current.Length <= 50)
{
return(current);
}
var strings = current.Split('.');
if (strings.Length == 1)
{
return(current.Length > 48 ? $"Z.{current[^48..]}" : $"Z.{current}");
public override void Configure(IFunctionsHostBuilder builder)
{
var services = builder.Services;
// register custom service in the container
services.AddSingleton(_ =>
{
var configurationRoot = builder.GetContext().Configuration;
var customComponentInitializationValue = configurationRoot.GetValue <string>("CustomComponentValue");
return(new CustomComponent(customComponentInitializationValue));
});
builder.UseNServiceBus(() =>
{
var configuration = new ServiceBusTriggeredEndpointConfiguration(Startup.EndpointName);
// optional: log startup diagnostics using Functions provided logger
configuration.LogDiagnostics();
return(configuration);
});
}
public override void Configure(IFunctionsHostBuilder builder)
{
var services = builder.Services;
services.AddScoped(typeof(MyService));
services.AddScoped <IMyService>(sp => sp.GetRequiredService <MyService>());
services.AddDbContext <MyDbContext>(options =>
{
var connectionString = builder.GetContext().Configuration.GetConnectionString("MyDbConnectionString");
options.UseSqlServer(connectionString);
});
services.AddSingleton(sp => new FunctionEndpoint(executionContext =>
{
var configuration = ServiceBusTriggeredEndpointConfiguration.FromAttributes();
configuration.UseSerialization <NewtonsoftSerializer>();
// configuration.LogDiagnostics();
var containerSettings = configuration.AdvancedConfiguration.UseContainer(new DefaultServiceProviderFactory());
// var serviceCollection = containerSettings.ServiceCollection;
containerSettings.ServiceCollection.Add(services);
// serviceCollection.AddDbContext<MyDbContext>(delegate (DbContextOptionsBuilder options)
// {
// var connectionString = builder.GetContext().Configuration.GetConnectionString("MyDbConnectionString");
// options.UseSqlServer(connectionString);
// });
//
// serviceCollection.AddScoped(typeof(MyService));
// serviceCollection.AddScoped<IMyService>(provider => provider.GetRequiredService<MyService>());
return(configuration);
}));
}
public override Task Start(CancellationToken token)
{
endpoint = new TestableFunctionEndpoint(context =>
{
var functionEndpointConfiguration = new ServiceBusTriggeredEndpointConfiguration(Name);
var endpointConfiguration = functionEndpointConfiguration.AdvancedConfiguration;
endpointConfiguration.TypesToIncludeInScan(functionComponentType.GetTypesScopedByTestClass());
endpointConfiguration.Recoverability()
.Immediate(i => i.NumberOfRetries(0))
.Delayed(d => d.NumberOfRetries(0))
.Failed(c => c
// track messages sent to the error queue to fail the test
.OnMessageSentToErrorQueue(failedMessage =>
{
scenarioContext.FailedMessages.AddOrUpdate(
Name,
new[] { failedMessage },
(_, fm) =>
{
var messages = fm.ToList();
messages.Add(failedMessage);
return(messages);
});
return(Task.CompletedTask);
}));
endpointConfiguration.RegisterComponents(c => c.RegisterSingleton(scenarioContext.GetType(), scenarioContext));
configurationCustomization(functionEndpointConfiguration);
return(functionEndpointConfiguration);
});
return(Task.CompletedTask);
}
public override void Configure(IFunctionsHostBuilder builder)
{
var services = builder.Services;
var configurationRoot = builder.GetContext().Configuration;
services.AddSingleton <IConfiguration>(configurationRoot);
services.AddDbContext <MyDbContext>(options =>
{
var connectionString = configurationRoot.GetConnectionString("MyDbConnectionString");
options.UseSqlServer(connectionString);
options.EnableServiceProviderCaching(false);
});
builder.UseNServiceBus(() =>
{
//TODO FromAttributes does not work as the function declaration is not in the stack when this method is called.
//var configuration = ServiceBusTriggeredEndpointConfiguration.FromAttributes();
var configuration = new ServiceBusTriggeredEndpointConfiguration(AzureServiceBusTriggerFunction.EndpointName, "AzureWebJobsServiceBus");
return(configuration);
});
}
