public ServiceBusListenerTests()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
MessageHandlerOptions messageOptions = new MessageHandlerOptions(ExceptionReceivedHandler);
MessageReceiver messageReceiver = new MessageReceiver(_testConnection, _entityPath);
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, messageReceiver, messageOptions);
ServiceBusConfiguration config = new ServiceBusConfiguration
{
MessageOptions = messageOptions
};
_mockMessagingProvider = new Mock <MessagingProvider>(MockBehavior.Strict, config);
config.MessagingProvider = _mockMessagingProvider.Object;
_mockMessagingProvider.Setup(p => p.CreateMessageProcessor(_entityPath, _testConnection))
.Returns(_mockMessageProcessor.Object);
ServiceBusTriggerExecutor triggerExecutor = new ServiceBusTriggerExecutor(_mockExecutor.Object);
var mockServiceBusAccount = new Mock <ServiceBusAccount>(MockBehavior.Strict);
mockServiceBusAccount.Setup(a => a.ConnectionString).Returns(_testConnection);
_listener = new ServiceBusListener(_entityPath, triggerExecutor, config, mockServiceBusAccount.Object);
}
public void UseAzureServiceBus_Should_Populate_ServiceBusConfiguration()
{
// Arrange
ServiceBusConfiguration cachedConfiguration = null !;
var expectedConnectionString = _fixture.Fixture.Create <string>();
var expectedSubscriptionClientName = _fixture.Fixture.Create <string>();
// Act
_fixture.HostBuilder.UseAzureServiceBus(
registerHandlers: collection => { },
subscribeToEvents: processor => { },
options: configuration =>
{
configuration.SubscriptionClientName = expectedSubscriptionClientName;
configuration.AzureServiceBusConnectionString = expectedConnectionString;
cachedConfiguration = configuration;
});
// Assert
cachedConfiguration
.SubscriptionClientName
.Should()
.Be(expectedSubscriptionClientName);
cachedConfiguration
.AzureServiceBusConnectionString
.Should()
.Be(expectedConnectionString);
}
public RouterConfigurationSourceSample()
{
RegisterHandler <IMessageHandler>("handler")
.ToListen(x =>
{
x.AddPublishSubscribeChannel("inputtopicnewrelease2", "subs", "Endpoint=sb://raulqueuetests.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=8WpD2e6cWAW3Qj4AECuzdKCySM4M+ZAIW2VGRHvvXlo=");
x.AddPointToPointChannel("inputqueuenewrelease2", "Endpoint=sb://raulqueuetests.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=8WpD2e6cWAW3Qj4AECuzdKCySM4M+ZAIW2VGRHvvXlo=");
})
.ForMessage <Message>().Using <MessageHandler>(x =>
{
x.With((request, handler, context) => handler.Handle(request, context)).When((request, handler, context) => true);
}).OnEntry(x => x.BuildOperationIdWith(y => "operationid"));
RegisterHandler <IMessageHandler>("handler")
.ToListen(x => {
x.AddPointToPointChannel("outputqueuenewrelease1", "Endpoint=sb://raulqueuetests.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=8WpD2e6cWAW3Qj4AECuzdKCySM4M+ZAIW2VGRHvvXlo=");
x.AddPointToPointChannel("outputqueuenewrelease2", "Endpoint=sb://raulqueuetests.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=8WpD2e6cWAW3Qj4AECuzdKCySM4M+ZAIW2VGRHvvXlo=");
x.AddPointToPointChannel("outputqueuenewrelease3", "Endpoint=sb://raulqueuetests.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=8WpD2e6cWAW3Qj4AECuzdKCySM4M+ZAIW2VGRHvvXlo=");
})
.ForMessage <Message>().Using <MessageHandlerB>(x =>
{
x.With((request, handler, context) => handler.Handle(request, context)).When((request, handler, context) => true);
});
RegisterOrigin("newcoreapp", "123");
RegisterEndPoint("endpoint")
.ForMessage <Message>()
//.AsClaimCheck()
.To(x =>
{
x.Add("Endpoint=sb://raulqueuetests.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=8WpD2e6cWAW3Qj4AECuzdKCySM4M+ZAIW2VGRHvvXlo=", "outputqueuenewrelease1");
x.Add("Endpoint=sb://raulqueuetests.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=8WpD2e6cWAW3Qj4AECuzdKCySM4M+ZAIW2VGRHvvXlo=", "outputqueuenewrelease2");
x.Add("Endpoint=sb://raulqueuetests.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=8WpD2e6cWAW3Qj4AECuzdKCySM4M+ZAIW2VGRHvvXlo=", "outputqueuenewrelease3");
});
var config = new ServiceBusConfiguration()
{
ClientId = "e40d9bbb-c50f-436e-8a5f-8494e0f84242",
ClientSecret = "OkDfucL/DT9h1FISlh79OfAnmwu9/h/TRx4ryFG+hIc=",
ConnectionString = "Endpoint=sb://raulqueuetests.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=8WpD2e6cWAW3Qj4AECuzdKCySM4M+ZAIW2VGRHvvXlo=",
ResourceGroupName = "TestQueueApps",
ResourceName = "raulqueuetests",
SubscriptionId = "e759b3f9-6ac3-4f9d-b479-1ba4471235cd",
TenantId = "77f43f1b-5708-46dd-92a2-5f99f19e9b1f"
};
this.RegisterQueue("inputqueuenewrelease2", config);
this.RegisterTopic("inputtopicnewrelease2", config);
this.RegisterSubscriptionToTopic("subs", "inputtopicnewrelease2", config);
this.RegisterQueue("outputqueuenewrelease1", config);
this.RegisterQueue("outputqueuenewrelease2", config);
this.RegisterQueue("outputqueuenewrelease3", config);
}
// Please set the following connection strings in app.config for this WebJob to run:
// AzureWebJobsDashboard and AzureWebJobsStorage
static void Main()
{
_servicesBusConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.ServiceBus);
var config = new JobHostConfiguration();
try
{
if (config.IsDevelopment)
{
config.UseDevelopmentSettings();
}
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration
{
ConnectionString = _servicesBusConnectionString
};
config.UseServiceBus(serviceBusConfig);
var host = new JobHost(config);
// The following code ensures that the WebJob will be running continuously
host.RunAndBlock();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
///Get message from queue
Console.WriteLine("from webjob");
}
static void Main()
{
try
{
System.Net.ServicePointManager.DefaultConnectionLimit = System.Int32.MaxValue;
XmlConfigurator.Configure();
var config = new JobHostConfiguration
{
JobActivator = new UnityJobActivatorDependencyScope(UnityConfig.GetConfiguredContainer())
};
var sbConfig = new ServiceBusConfiguration
{
MessageOptions = new OnMessageOptions
{
AutoComplete = false
}
};
sbConfig.MessageOptions.MaxConcurrentCalls = 1;
config.UseServiceBus(sbConfig);
var host = new JobHost(config);
//host.CallAsync(typeof(Functions).GetMethod("SyncTest"));
host.RunAndBlock();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public ServiceBusSubscriptionListenerFactory(string topicName, string subscriptionName, ITriggeredFunctionExecutor executor, ServiceBusConfiguration config)
{
_topicName = topicName;
_subscriptionName = subscriptionName;
_executor = executor;
_config = config;
}
/// <summary>
/// Registers all types required to send and receive messages to/from
/// Azure Service Bus.
/// </summary>
/// <param name="hostBuilder">Generic host builder</param>
/// <param name="registerHandlers">Action to register message handlers in DI container</param>
/// <param name="subscribeToEvents">Action to map events to their handlers</param>
/// <param name="options">Azure Service Bus configuration parameters</param>
/// <returns></returns>
public static IHostBuilder UseAzureServiceBus(
this IHostBuilder hostBuilder,
Action <IServiceCollection> registerHandlers,
Action <IEventsProcessor> subscribeToEvents,
Action <ServiceBusConfiguration>?options = null)
{
hostBuilder.ConfigureServices((ctx, services) =>
{
ServiceBusConfiguration?config = null;
if (options is not null)
{
config = new ServiceBusConfiguration();
options(config);
}
// Common services
services.AddScoped <IMessageSerializer, MessageSerializer>();
// Event bus client
services.AddSingleton <IEventBusClient, EventBusClient>(provider =>
{
var configuration = provider.GetRequiredService <IConfiguration>();
return(new EventBusClient(
connectionString: config?.AzureServiceBusConnectionString ??
configuration["ServiceBusSettings:EventBusConnection"]));
});
// Sending message types
services.AddScoped <IEventsPublisher, EventsPublisher>();
// Processing message types
services.AddSingleton <IEventsSubscriptionManager, EventsSubscriptionManager>();
services.AddSingleton <IEventsProcessor, EventsProcessor>(provider =>
{
var subscriptionManager = provider.GetRequiredService <IEventsSubscriptionManager>();
var logger = provider.GetRequiredService <ILogger <EventsProcessor> >();
var configuration = provider.GetRequiredService <IConfiguration>();
var processingPipeline = provider.GetRequiredService <IMessageProcessingPipeline>();
var eventBusClient = provider.GetRequiredService <IEventBusClient>();
var eventProcessor = new EventsProcessor(
subscriptionManager: subscriptionManager,
logger: logger,
subscriptionClientName: config?.SubscriptionClientName ??
configuration["ServiceBusSettings:SubscriptionClientName"],
processingPipeline: processingPipeline,
eventBusClient: eventBusClient);
subscribeToEvents(eventProcessor);
return(eventProcessor);
});
services.AddSingleton <IMessageProcessingPipeline, EventProcessingPipeline>();
services.AddHostedService <EventsProcessorHostedService>();
registerHandlers(services);
});
return(hostBuilder);
}
public ServiceBusTriggerBinding(string parameterName, Type parameterType, ITriggerDataArgumentBinding <Message> argumentBinding, ServiceBusAccount account,
ServiceBusConfiguration config, string queueName)
: this(parameterName, parameterType, argumentBinding, account, config)
{
_queueName = queueName;
_entityPath = queueName;
}
public void Constructor_SetsExpectedDefaults()
{
ServiceBusConfiguration config = new ServiceBusConfiguration();
Assert.Equal(16, config.MessageOptions.MaxConcurrentCalls);
Assert.Equal(0, config.PrefetchCount);
}
public async Task SendAsync(Student student, ServiceBusConfiguration config)
{
queueClient = new QueueClient(config.ConnectionString, config.QueueName);
await SendMessagesAsync(student);
await queueClient.CloseAsync();
}
public ServiceBusArgumentsDisplayTestsFixture()
: base(cleanStorageAccount: true)
{
_hostConfiguration = new JobHostConfiguration(StorageAccount.ConnectionString)
{
TypeLocator = new ExplicitTypeLocator(
typeof(ServiceBusArgumentsDisplayFunctions),
typeof(DoneNotificationFunction))
};
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration();
serviceBusConfig.ConnectionString = ServiceBusAccount;
_serviceBusConnectionString = serviceBusConfig.ConnectionString;
_hostConfiguration.UseServiceBus(serviceBusConfig);
_namespaceManager = NamespaceManager.CreateFromConnectionString(_serviceBusConnectionString);
// ensure we're starting in a clean state
CleanServiceBusQueues();
// now run the entire end to end scenario, causing all the job functions
// to be invoked
RunEndToEnd();
}
public void UseAzureServiceBus_SendOnly_Should_Populate_ServiceBusConfiguration()
{
// Arrange
ServiceBusConfiguration cachedConfiguration = null !;
var expectedConnectionString = _fixture.Fixture.Create <string>();
var expectedSubscriptionClientName = _fixture.Fixture.Create <string>();
// Act
_fixture.HostBuilder.UseAzureServiceBus(configuration =>
{
configuration.SubscriptionClientName = expectedSubscriptionClientName;
configuration.AzureServiceBusConnectionString = expectedConnectionString;
cachedConfiguration = configuration;
});
// Assert
cachedConfiguration
.SubscriptionClientName
.Should()
.Be(expectedSubscriptionClientName);
cachedConfiguration
.AzureServiceBusConnectionString
.Should()
.Be(expectedConnectionString);
}
public async void GetProductChanged()
{
_configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.Build();
serviceBusConfiguration = _configuration.GetSection("serviceBus").Get <ServiceBusConfiguration>();
var serviceBusNamespace = _configuration.GetServiceBusNamespace();
var topic = serviceBusNamespace.Topics.GetByName(TopicName);
await topic.Subscriptions.DeleteByNameAsync(SubscriptionName);
if (!topic.Subscriptions.List()
.Any(subscription => subscription.Name
.Equals(SubscriptionName, StringComparison.InvariantCultureIgnoreCase)))
{
topic.Subscriptions
.Define(SubscriptionName)
.Create();
}
ReceiveMessages();
}
public async Task Initialize_PerformsExpectedRegistrations()
{
JobHostConfiguration config = new JobHostConfiguration();
config.AddService <INameResolver>(new RandomNameResolver());
TestLoggerProvider loggerProvider = new TestLoggerProvider();
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
config.LoggerFactory = loggerFactory;
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration();
ServiceBusExtensionConfig serviceBusExtensionConfig = new ServiceBusExtensionConfig(serviceBusConfig);
IExtensionRegistry extensions = config.GetService <IExtensionRegistry>();
ITriggerBindingProvider[] triggerBindingProviders = extensions.GetExtensions <ITriggerBindingProvider>().ToArray();
Assert.Empty(triggerBindingProviders);
IBindingProvider[] bindingProviders = extensions.GetExtensions <IBindingProvider>().ToArray();
Assert.Empty(bindingProviders);
ExtensionConfigContext context = new ExtensionConfigContext
{
Config = config,
};
serviceBusExtensionConfig.Initialize(context);
// ensure the ServiceBusTriggerAttributeBindingProvider was registered
triggerBindingProviders = extensions.GetExtensions <ITriggerBindingProvider>().ToArray();
Assert.Single(triggerBindingProviders);
ServiceBusTriggerAttributeBindingProvider triggerBindingProvider = (ServiceBusTriggerAttributeBindingProvider)triggerBindingProviders[0];
Assert.NotNull(triggerBindingProvider);
// ensure the ServiceBusAttributeBindingProvider was registered
bindingProviders = extensions.GetExtensions <IBindingProvider>().ToArray();
Assert.Single(bindingProviders);
ServiceBusAttributeBindingProvider bindingProvider = (ServiceBusAttributeBindingProvider)bindingProviders[0];
Assert.NotNull(bindingProvider);
// ensure the default MessageOptions exception handler is wired up
var messageOptions = serviceBusConfig.MessageOptions;
var ex = new ServiceBusException(false);
var args = new ExceptionReceivedEventArgs(ex, "TestAction", "TestEndpoint", "TestEntityPath", "TestClientId");
Assert.NotNull(serviceBusConfig.ExceptionHandler);
// invoke the handler and make sure it logs
await serviceBusConfig.MessageOptions.ExceptionReceivedHandler(args);
string expectedMessage = "MessageReceiver error (Action=TestAction, ClientId=TestClientId, EntityPath=TestEntityPath, Endpoint=TestEndpoint)";
var logMessage = loggerProvider.GetAllLogMessages().Single();
Assert.Equal(LogLevel.Error, logMessage.Level);
Assert.Equal(expectedMessage, logMessage.FormattedMessage);
Assert.Same(ex, logMessage.Exception);
}
protected ServiceBusWriteClient(ServiceBusConfiguration configuration,
ClientSerializer <T> serializer, IServiceBusMessageHandler messageHandler)
{
Serializer = serializer ?? new JsonSerializer <T>();
Configuration = configuration;
MessageHandler = messageHandler;
}
private static StandardKernel SetupIoc()
{
var connectionKey = Environment.GetEnvironmentVariable(ApolloConstants.ConnectionKey, EnvironmentVariableTarget.Process) ??
Environment.GetEnvironmentVariable(ApolloConstants.ConnectionKey, EnvironmentVariableTarget.User) ??
Environment.GetEnvironmentVariable(ApolloConstants.ConnectionKey, EnvironmentVariableTarget.Machine) ??
throw new ArgumentException($"Environment variable '{ApolloConstants.ConnectionKey}' is not configured");
var serverIdentifier = Environment.GetEnvironmentVariable("DOTNET_RUNNING_IN_CONTAINER") == "true"
? $"{Environment.MachineName} {Environment.GetEnvironmentVariable("APOLLO_SERVER_ID")}" // Machine name will be the ID of the container if running in docker
: (Environment.GetEnvironmentVariable("APOLLO_SERVER_ID") ?? $"Server {Guid.NewGuid()}");
var configuration = new ServiceBusConfiguration
(
new ServiceBusConnectionStringBuilder(connectionKey),
serverIdentifier
);
var implementations = new ApolloServiceBusImplementations(configuration)
{
ServerPlugins = new ApolloPlugin[]
{
new EchoListenerPlugin(),
new MessageCounterPlugin()
}
};
var container = new StandardKernel(implementations);
container.Bind <IApolloServerRepository>().To <InMemoryApolloServerRepository>().InSingletonScope();
return(container);
}
public ServiceBusQueueListenerFactory(ServiceBusAccount account, string queueName, ITriggeredFunctionExecutor executor, ServiceBusConfiguration config)
{
_account = account;
_queueName = queueName;
_executor = executor;
_config = config;
}
public async Task CustomMessageProcessorTest()
{
try
{
TestTraceWriter trace = new TestTraceWriter(TraceLevel.Info);
_serviceBusConfig = new ServiceBusConfiguration();
_serviceBusConfig.MessagingProvider = new CustomMessagingProvider(_serviceBusConfig, trace);
JobHostConfiguration config = new JobHostConfiguration()
{
NameResolver = _nameResolver,
TypeLocator = new FakeTypeLocator(typeof(ServiceBusTestJobs))
};
config.Tracing.Tracers.Add(trace);
config.UseServiceBus(_serviceBusConfig);
JobHost host = new JobHost(config);
await ServiceBusEndToEndInternal(typeof(ServiceBusTestJobs), host : host);
// in addition to verifying that our custom processor was called, we're also
// verifying here that extensions can log to the TraceWriter
Assert.Equal(4, trace.Traces.Count(p => p.Message.Contains("Custom processor Begin called!")));
Assert.Equal(4, trace.Traces.Count(p => p.Message.Contains("Custom processor End called!")));
}
finally
{
Cleanup();
}
}
public void Initialize_PerformsExpectedRegistrations()
{
JobHostConfiguration config = new JobHostConfiguration();
config.AddService<INameResolver>(new RandomNameResolver());
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration();
ServiceBusExtensionConfig serviceBusExtensionConfig = new ServiceBusExtensionConfig(serviceBusConfig);
IExtensionRegistry extensions = config.GetService<IExtensionRegistry>();
ITriggerBindingProvider[] triggerBindingProviders = extensions.GetExtensions<ITriggerBindingProvider>().ToArray();
Assert.Equal(0, triggerBindingProviders.Length);
IBindingProvider[] bindingProviders = extensions.GetExtensions<IBindingProvider>().ToArray();
Assert.Equal(0, bindingProviders.Length);
ExtensionConfigContext context = new ExtensionConfigContext
{
Config = config,
Trace = new TestTraceWriter(TraceLevel.Verbose)
};
serviceBusExtensionConfig.Initialize(context);
// ensure the ServiceBusTriggerAttributeBindingProvider was registered
triggerBindingProviders = extensions.GetExtensions<ITriggerBindingProvider>().ToArray();
Assert.Equal(1, triggerBindingProviders.Length);
ServiceBusTriggerAttributeBindingProvider triggerBindingProvider = (ServiceBusTriggerAttributeBindingProvider)triggerBindingProviders[0];
Assert.NotNull(triggerBindingProvider);
// ensure the ServiceBusAttributeBindingProvider was registered
bindingProviders = extensions.GetExtensions<IBindingProvider>().ToArray();
Assert.Equal(1, bindingProviders.Length);
ServiceBusAttributeBindingProvider bindingProvider = (ServiceBusAttributeBindingProvider)bindingProviders[0];
Assert.NotNull(bindingProvider);
}
/// <summary>
/// Registers types required to send messages to Azure Service Bus.
/// </summary>
/// <param name="hostBuilder">Generic host builder</param>
/// <param name="options">Azure Service Bus configuration parameters</param>
/// <returns></returns>
public static IHostBuilder UseAzureServiceBus(
this IHostBuilder hostBuilder,
Action <ServiceBusConfiguration>?options = null)
{
hostBuilder.ConfigureServices((ctx, services) =>
{
ServiceBusConfiguration?config = null;
if (options is not null)
{
config = new ServiceBusConfiguration();
options(config);
}
services.AddSingleton <IEventBusClient, EventBusClient>(provider =>
{
var configuration = provider.GetRequiredService <IConfiguration>();
return(new EventBusClient(
connectionString: config?.AzureServiceBusConnectionString ??
configuration["ServiceBusSettings:EventBusConnection"]));
});
services.AddScoped <IEventsPublisher, EventsPublisher>();
services.AddScoped <IMessageSerializer, MessageSerializer>();
});
return(hostBuilder);
}
// Please set the following connection strings in app.config for this WebJob to run:
// AzureWebJobsDashboard and AzureWebJobsStorage
static void Main()
{
_servicesBusConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.ServiceBus);
_namespaceManager = NamespaceManager.CreateFromConnectionString(_servicesBusConnectionString);
InitializeQueue();
JobHostConfiguration configuration = new JobHostConfiguration
{
DashboardConnectionString = "",
StorageConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage)
};
//configuration.StorageConnectionString = ConfigurationManager.ConnectionStrings[""]
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration
{
ConnectionString = _servicesBusConnectionString
};
configuration.UseServiceBus(serviceBusConfig);
configuration.JobActivator = new AutofacJobActivator(AutofacContainerBuilder.BuildContainer());
var host = new JobHost(configuration);
// The following code ensures that the WebJob will be running continuously
host.RunAndBlock();
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionProcessor"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="serviceBusConfiguration">The configuration for the service bus.</param>
/// <param name="currentStamp">The current stamp configuration.</param>
/// <param name="metricsTracker">The metrics tracker.</param>
/// <param name="subscriptionMonitor">The service monitor.</param>
public SubscriptionProcessor(ILogger <SubscriptionProcessor> logger, IOptions <ServiceBusConfiguration> serviceBusConfiguration, IMonitor subscriptionMonitor)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_serviceBusConfiguration = serviceBusConfiguration?.Value ?? throw new ArgumentNullException(nameof(serviceBusConfiguration));
_serviceBusConfiguration.CheckValidity();
_subscriptionMonitor = subscriptionMonitor ?? throw new ArgumentNullException(nameof(subscriptionMonitor));
}
public static JobHostConfiguration CreateConfig()
{
var config = new JobHostConfiguration();
// The environment is determined by the value of the "AzureWebJobsEnv" environment variable. When this
// is set to "Development", this property will return true.
if (config.IsDevelopment)
{
config.UseDevelopmentSettings();
}
//check app.config if your connectionstrings are setup properly
//if the box has no internet connection you can disable the connectionstrings like this, remember you use any internet enabled functions then.
//config.DashboardConnectionString = null;
//config.StorageConnectionString = null;
//normally use AppSetting and ConfigManager to get paths here.
FilesConfiguration filesConfig = new FilesConfiguration
{
RootPath = @"C:\Users\p.vanek\Desktop\TechDays\FileWatch"
};
//enable what you like to use
config.UseFiles(filesConfig);
config.UseTimers();
//lots of these extensions can be found on the internet on places like nuget
//https://www.nuget.org/packages?q=WebJobs.Extensions
//used for local development without accidently sharing secrets
string storageString = Environment.GetEnvironmentVariable("AzureStorageAccount");
if (!string.IsNullOrWhiteSpace(storageString))
{
config.DashboardConnectionString = storageString;
config.StorageConnectionString = storageString;
}
//find servicebusString in Environment variable, otherwise find it in App.config
string serviceBusConnection = Environment.GetEnvironmentVariable("AzureServiceBus");
if (!string.IsNullOrWhiteSpace(serviceBusConnection))
{
ServiceBusConfiguration sbConfig = new ServiceBusConfiguration
{
ConnectionString = serviceBusConnection
//set other options if you like
};
config.UseServiceBus(sbConfig);
}
else
{
config.UseServiceBus();
}
return(config);
}
public async Task CustomMessageProcessorTest()
{
try
{
// Pass in a separate LoggerFactory to the CusomtMessagingProvider to make validation easier.
LoggerFactory loggerFactory = new LoggerFactory();
TestLoggerProvider loggerProvider = new TestLoggerProvider();
loggerFactory.AddProvider(loggerProvider);
_serviceBusConfig = new ServiceBusConfiguration();
_serviceBusConfig.MessagingProvider = new CustomMessagingProvider(_serviceBusConfig, loggerFactory);
JobHostConfiguration config = new JobHostConfiguration()
{
NameResolver = _nameResolver,
TypeLocator = new FakeTypeLocator(typeof(ServiceBusTestJobs)),
LoggerFactory = _loggerFactory
};
config.UseServiceBus(_serviceBusConfig);
JobHost host = new JobHost(config);
await ServiceBusEndToEndInternal(typeof(ServiceBusTestJobs), host : host);
// in addition to verifying that our custom processor was called, we're also
// verifying here that extensions can log
IEnumerable <LogMessage> messages = loggerProvider.GetAllLogMessages();
Assert.Equal(4, messages.Count(p => p.FormattedMessage.Contains("Custom processor Begin called!")));
Assert.Equal(4, messages.Count(p => p.FormattedMessage.Contains("Custom processor End called!")));
}
finally
{
await Cleanup();
}
}
/// <summary>
/// Entry point for the application.
/// </summary>
internal static void Main()
{
JobHost host;
JobHostConfiguration config;
ServiceBusConfiguration serviceBusConfig;
try
{
ApplicationInsights.Extensibility.TelemetryConfiguration.Active.InstrumentationKey =
Service.Configuration.InstrumentationKey;
config = new JobHostConfiguration(Service.Configuration.StorageConnectionString);
serviceBusConfig = new ServiceBusConfiguration
{
ConnectionString = Service.Configuration.ServiceBusConnectionString
};
config.Queues.MaxDequeueCount = 3;
config.Queues.BatchSize = 10;
config.Queues.NewBatchThreshold = 15;
config.Tracing.ConsoleLevel = TraceLevel.Verbose;
config.UseServiceBus(serviceBusConfig);
config.UseTimers();
host = new JobHost(config);
host.RunAndBlock();
}
finally
{
config = null;
host = null;
serviceBusConfig = null;
}
}
static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
IConfigurationRoot configuration = builder.Build();
var serviceBusConfiguration = new ServiceBusConfiguration();
var section = configuration.GetSection("ServiceBus");
section.Bind(serviceBusConfiguration);
var orderQueueClient = new ServiceBusCommandQueueClient(
new Dictionary <string, Type>(),
new ServiceBusNamespaceFactory(serviceBusConfiguration),
new QueueClientFactory(serviceBusConfiguration));
var rfqQueueClient = new ServiceBusCommandQueueClient(
new Dictionary <string, Type>(),
new ServiceBusNamespaceFactory(serviceBusConfiguration),
new QueueClientFactory(serviceBusConfiguration));
Dictionary <string, ICommandQueueClient> ccqs = new Dictionary <string, ICommandQueueClient>
{
{ "order-service", orderQueueClient },
{ "rfq-service", rfqQueueClient }
};
MainAsync(ccqs).GetAwaiter().GetResult();
}
public ServiceBusListenerTests()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
string testConnection = "Endpoint=sb://test.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=abc123=";
_messagingFactory = MessagingFactory.CreateFromConnectionString(testConnection);
OnMessageOptions messageOptions = new OnMessageOptions();
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, messageOptions);
ServiceBusConfiguration config = new ServiceBusConfiguration
{
MessageOptions = messageOptions
};
_mockMessagingProvider = new Mock <MessagingProvider>(MockBehavior.Strict, config);
config.MessagingProvider = _mockMessagingProvider.Object;
_mockMessagingProvider.Setup(p => p.CreateMessageProcessor(_entityPath))
.Returns(_mockMessageProcessor.Object);
ServiceBusTriggerExecutor triggerExecutor = new ServiceBusTriggerExecutor(_mockExecutor.Object);
_listener = new ServiceBusListener(_messagingFactory, _entityPath, triggerExecutor, config);
}
public void Should_be_able_to_handle_expired_message()
{
var handlerInvoker = new FakeMessageHandlerInvoker();
var fakeQueue = new FakeQueue(2);
var configuration = new ServiceBusConfiguration
{
Inbox = new InboxQueueConfiguration
{
WorkQueue = fakeQueue,
ErrorQueue = fakeQueue,
ThreadCount = 1
},
MessageHandlerInvoker = handlerInvoker
};
using (var bus = new ServiceBus(configuration))
{
bus.Start();
var timeout = DateTime.Now.AddMilliseconds(5000);
while (fakeQueue.MessageCount < 2 && DateTime.Now < timeout)
{
Thread.Sleep(5);
}
}
Assert.AreEqual(1, handlerInvoker.GetInvokeCount("SimpleCommand"), "FakeHandlerInvoker was not invoked exactly once.");
Assert.AreEqual(2, fakeQueue.MessageCount, "FakeQueue was not invoked exactly twice.");
}
public void PrefetchCount_GetSet()
{
ServiceBusConfiguration config = new ServiceBusConfiguration();
Assert.Equal(0, config.PrefetchCount);
config.PrefetchCount = 100;
Assert.Equal(100, config.PrefetchCount);
}
public override void Execute(ServiceBusConfiguration configuration)
{
if (ServiceBusConfiguration.ServiceBusSection == null
||
ServiceBusConfiguration.ServiceBusSection.ControlInbox == null
||
string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.ControlInbox.WorkQueueUri)
||
string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.ControlInbox.ErrorQueueUri))
{
return;
}
configuration.ControlInbox =
new ControlInboxQueueConfiguration
{
WorkQueue = QueueManager.Instance.GetQueue(ServiceBusConfiguration.ServiceBusSection.ControlInbox.WorkQueueUri),
ErrorQueue = QueueManager.Instance.GetQueue(ServiceBusConfiguration.ServiceBusSection.ControlInbox.ErrorQueueUri),
JournalQueue = string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.ControlInbox.JournalQueueUri)
? null
: QueueManager.Instance.GetQueue(ServiceBusConfiguration.ServiceBusSection.ControlInbox.JournalQueueUri),
ThreadCount = ServiceBusConfiguration.ServiceBusSection.ControlInbox.ThreadCount,
MaximumFailureCount = ServiceBusConfiguration.ServiceBusSection.ControlInbox.MaximumFailureCount,
DurationToIgnoreOnFailure = DurationToIgnoreOnFailure(ServiceBusConfiguration.ServiceBusSection.ControlInbox.DurationToIgnoreOnFailure),
DurationToSleepWhenIdle = DurationToSleepWhenIdle(ServiceBusConfiguration.ServiceBusSection.ControlInbox.DurationToSleepWhenIdle)
};
}
public override void Execute(ServiceBusConfiguration configuration)
{
if (ServiceBusConfiguration.ServiceBusSection == null
||
ServiceBusConfiguration.ServiceBusSection.Inbox == null
||
string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.Inbox.WorkQueueUri))
{
return;
}
configuration.Inbox =
new InboxQueueConfiguration
{
WorkQueue = configuration.QueueManager.GetQueue(ServiceBusConfiguration.ServiceBusSection.Inbox.WorkQueueUri),
ErrorQueue = configuration.QueueManager.GetQueue(ServiceBusConfiguration.ServiceBusSection.Inbox.ErrorQueueUri),
JournalQueue = string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.Inbox.JournalQueueUri)
? null
: configuration.QueueManager.GetQueue(ServiceBusConfiguration.ServiceBusSection.Inbox.JournalQueueUri),
WorkQueueStartupAction = ServiceBusConfiguration.ServiceBusSection.Inbox.WorkQueueStartupAction,
ThreadCount = ServiceBusConfiguration.ServiceBusSection.Inbox.ThreadCount,
MaximumFailureCount = ServiceBusConfiguration.ServiceBusSection.Inbox.MaximumFailureCount,
DurationToIgnoreOnFailure = DurationToIgnoreOnFailure(ServiceBusConfiguration.ServiceBusSection.Inbox.DurationToIgnoreOnFailure),
DurationToSleepWhenIdle = DurationToSleepWhenIdle(ServiceBusConfiguration.ServiceBusSection.Inbox.DurationToSleepWhenIdle),
Distribute = ServiceBusConfiguration.ServiceBusSection.Inbox.Distribute
};
}
private SubscriptionManager GetSubscriptionManager(SubscribeOption subscribe)
{
var workQueue = new Mock <IQueue>();
workQueue.Setup(m => m.Uri).Returns(new Uri(WorkQueueUri));
var serviceBusConfiguration = new ServiceBusConfiguration
{
Inbox = new InboxQueueConfiguration
{
WorkQueue = workQueue.Object
}
};
var subscriptionConfiguration = SubscriptionSection.Configuration();
subscriptionConfiguration.Subscribe = subscribe;
var serviceBusEvents = new ServiceBusEvents();
var subscriptionManager = new SubscriptionManager(serviceBusEvents,
serviceBusConfiguration, subscriptionConfiguration,
new ScriptProvider(new ScriptProviderConfiguration()), DatabaseContextFactory, DatabaseGateway);
serviceBusEvents.OnStarted(this, new PipelineEventEventArgs(new Mock <IPipelineEvent>().Object));
return(subscriptionManager);
}
public ServiceBusService(IConfiguration configuration)
{
_configuration = configuration;
_serviceBusConfiguration = _configuration.GetSection("servicebus").Get <ServiceBusConfiguration>();
_namespace = _configuration.GetServiceBusNamespace();
_cancelMessages = new CancellationTokenSource();
}
public ServiceBusListener(MessagingFactory messagingFactory, string entityPath, ServiceBusTriggerExecutor triggerExecutor, ServiceBusConfiguration config)
{
_messagingFactory = messagingFactory;
_entityPath = entityPath;
_triggerExecutor = triggerExecutor;
_cancellationTokenSource = new CancellationTokenSource();
_messageProcessor = config.MessagingProvider.CreateMessageProcessor(entityPath);
}
public ServiceBusQueueListenerFactory(ServiceBusAccount account, string queueName, ITriggeredFunctionExecutor executor, AccessRights accessRights, ServiceBusConfiguration config)
{
_namespaceManager = account.NamespaceManager;
_messagingFactory = account.MessagingFactory;
_queueName = queueName;
_executor = executor;
_accessRights = accessRights;
_config = config;
}
/// <summary>
/// Creates a new <see cref="ServiceBusExtensionConfig"/> instance.
/// </summary>
/// <param name="serviceBusConfig">The <see cref="ServiceBusConfiguration"></see> to use./></param>
public ServiceBusExtensionConfig(ServiceBusConfiguration serviceBusConfig)
{
if (serviceBusConfig == null)
{
throw new ArgumentNullException("serviceBusConfig");
}
_serviceBusConfig = serviceBusConfig;
}
public ServiceBusSubscriptionListenerFactory(ServiceBusAccount account, string topicName, string subscriptionName, ITriggeredFunctionExecutor executor, AccessRights accessRights, ServiceBusConfiguration config)
{
_namespaceManager = account.NamespaceManager;
_messagingFactory = account.MessagingFactory;
_topicName = topicName;
_subscriptionName = subscriptionName;
_executor = executor;
_accessRights = accessRights;
_config = config;
}
public ServiceBusAttributeBindingProviderTests()
{
Mock<INameResolver> mockResolver = new Mock<INameResolver>(MockBehavior.Strict);
ServiceBusConfiguration config = new ServiceBusConfiguration();
_mockMessagingProvider = new Mock<MessagingProvider>(MockBehavior.Strict, config);
config.MessagingProvider = _mockMessagingProvider.Object;
_provider = new ServiceBusAttributeBindingProvider(mockResolver.Object, config);
}
public void ConnectionString_ReturnsExpectedDefaultUntilSetExplicitly()
{
ServiceBusConfiguration config = new ServiceBusConfiguration();
string defaultConnection = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.ServiceBus);
Assert.Equal(defaultConnection, config.ConnectionString);
string testConnection = "testconnection";
config.ConnectionString = testConnection;
Assert.Equal(testConnection, config.ConnectionString);
}
public MessagingProviderTests()
{
string defaultConnection = "Endpoint=sb://default.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=abc123=";
_config = new ServiceBusConfiguration
{
ConnectionString = defaultConnection
};
_provider = new MessagingProvider(_config);
string overrideConnection = "Endpoint=sb://override.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=abc123=";
Environment.SetEnvironmentVariable("AzureWebJobsServiceBusOverride", overrideConnection);
}
public override void Execute(ServiceBusConfiguration configuration)
{
if (ServiceBusConfiguration.ServiceBusSection == null)
{
configuration.RemoveMessagesNotHandled = false;
return;
}
configuration.RemoveMessagesNotHandled = ServiceBusConfiguration.ServiceBusSection.RemoveMessagesNotHandled;
configuration.CompressionAlgorithm = ServiceBusConfiguration.ServiceBusSection.CompressionAlgorithm;
configuration.EncryptionAlgorithm = ServiceBusConfiguration.ServiceBusSection.EncryptionAlgorithm;
}
public ServiceBusTriggerBinding(string parameterName, ITriggerDataArgumentBinding<BrokeredMessage> argumentBinding,
ServiceBusAccount account, string topicName, string subscriptionName, AccessRights accessRights, ServiceBusConfiguration config)
{
_parameterName = parameterName;
_argumentBinding = argumentBinding;
_account = account;
_namespaceName = ServiceBusClient.GetNamespaceName(account);
_topicName = topicName;
_subscriptionName = subscriptionName;
_entityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
_accessRights = accessRights;
_config = config;
}
public ServiceBusTriggerBinding(string parameterName, Type parameterType,
ITriggerDataArgumentBinding<BrokeredMessage> argumentBinding, ServiceBusAccount account, string queueName, AccessRights accessRights, ServiceBusConfiguration config)
{
_parameterName = parameterName;
_converter = CreateConverter(parameterType);
_argumentBinding = argumentBinding;
_account = account;
_namespaceName = ServiceBusClient.GetNamespaceName(account);
_queueName = queueName;
_entityPath = queueName;
_accessRights = accessRights;
_config = config;
}
public ServiceBusAttributeBindingProvider(INameResolver nameResolver, ServiceBusConfiguration config)
{
if (nameResolver == null)
{
throw new ArgumentNullException("nameResolver");
}
if (config == null)
{
throw new ArgumentNullException("config");
}
_nameResolver = nameResolver;
_config = config;
}
public static void Main()
{
_servicesBusConnectionString = ConfigurationManager.ConnectionStrings["AzureWebJobsServiceBus"].ConnectionString;
_namespaceManager = NamespaceManager.CreateFromConnectionString(_servicesBusConnectionString);
CreateStartMessage();
JobHostConfiguration config = new JobHostConfiguration();
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration
{
ConnectionString = _servicesBusConnectionString
};
config.UseServiceBus(serviceBusConfig);
JobHost host = new JobHost(config);
host.RunAndBlock();
}
public static void Main()
{
_servicesBusConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.ServiceBus);
_namespaceManager = NamespaceManager.CreateFromConnectionString(_servicesBusConnectionString);
CreateStartMessage();
JobHostConfiguration config = new JobHostConfiguration();
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration
{
ConnectionString = _servicesBusConnectionString
};
config.UseServiceBus(serviceBusConfig);
JobHost host = new JobHost(config);
host.RunAndBlock();
}
public void Should_be_able_to_set_sender()
{
var configurator = new TransportMessageConfigurator(this);
var configuration = new ServiceBusConfiguration
{
Inbox = new InboxQueueConfiguration
{
WorkQueue = new NullQueue("null-queue://./work-queue")
}
};
Assert.AreEqual("null-queue://./work-queue", configurator.TransportMessage(configuration).SenderInboxWorkQueueUri);
configurator.WithSender("null-queue://./another-queue");
Assert.AreEqual("null-queue://./another-queue", configurator.TransportMessage(configuration).SenderInboxWorkQueueUri);
}
public override void Execute(ServiceBusConfiguration configuration)
{
if (ServiceBusConfiguration.ServiceBusSection == null
||
ServiceBusConfiguration.ServiceBusSection.Worker == null
||
string.IsNullOrEmpty(ServiceBusConfiguration.ServiceBusSection.Worker.DistributorControlWorkQueueUri))
{
return;
}
configuration.Worker =
new WorkerConfiguration(
configuration.QueueManager.CreateQueue(
ServiceBusConfiguration.ServiceBusSection.Worker.DistributorControlWorkQueueUri),
ServiceBusConfiguration.ServiceBusSection.Worker.ThreadAvailableNotificationIntervalSeconds);
}
public void UseServiceBus_ServiceBusConfigurationProvided_PerformsExpectedRegistration()
{
JobHostConfiguration config = new JobHostConfiguration();
IExtensionRegistry extensions = config.GetService<IExtensionRegistry>();
IExtensionConfigProvider[] configProviders = extensions.GetExtensions<IExtensionConfigProvider>().ToArray();
Assert.Equal(0, configProviders.Length);
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration
{
ConnectionString = "test service bus connection"
};
config.UseServiceBus(serviceBusConfig);
// verify that the service bus config provider was registered
configProviders = extensions.GetExtensions<IExtensionConfigProvider>().ToArray();
Assert.Equal(1, configProviders.Length);
ServiceBusExtensionConfig serviceBusExtensionConfig = (ServiceBusExtensionConfig)configProviders.Single();
Assert.Same(serviceBusConfig, serviceBusExtensionConfig.Config);
}
public ServiceBusListenerTests()
{
_mockExecutor = new Mock<ITriggeredFunctionExecutor>(MockBehavior.Strict);
string testConnection = "Endpoint=sb://test.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=abc123=";
MessagingFactory messagingFactory = MessagingFactory.CreateFromConnectionString(testConnection);
OnMessageOptions messageOptions = new OnMessageOptions();
_mockMessageProcessor = new Mock<MessageProcessor>(MockBehavior.Strict, messageOptions);
ServiceBusConfiguration config = new ServiceBusConfiguration
{
MessageOptions = messageOptions
};
Mock<MessagingProvider> mockMessagingProvider = new Mock<MessagingProvider>(MockBehavior.Strict, config);
config.MessagingProvider = mockMessagingProvider.Object;
mockMessagingProvider.Setup(p => p.CreateMessageProcessor(_entityPath))
.Returns(_mockMessageProcessor.Object);
ServiceBusTriggerExecutor triggerExecutor = new ServiceBusTriggerExecutor(_mockExecutor.Object);
_listener = new ServiceBusListener(messagingFactory, _entityPath, triggerExecutor, config);
}
public void Constructor_SetsExpectedDefaults()
{
ServiceBusConfiguration config = new ServiceBusConfiguration();
Assert.Equal(16, config.MessageOptions.MaxConcurrentCalls);
}
