public ServiceBusArgumentsDisplayTestsFixture()
: base(cleanStorageAccount: true)
{
_hostConfiguration = new JobHostConfiguration(StorageAccount.ConnectionString)
{
TypeLocator = new ExplicitTypeLocator(
typeof(ServiceBusArgumentsDisplayFunctions),
typeof(DoneNotificationFunction))
};
#if VNEXT_SDK
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration();
serviceBusConfig.ConnectionString = ServiceBusAccount;
_serviceBusConnectionString = serviceBusConfig.ConnectionString;
_hostConfiguration.UseServiceBus(serviceBusConfig);
#else
_serviceBusConnectionString = ServiceBusAccount;
_hostConfiguration.ServiceBusConnectionString = _serviceBusConnectionString;
#endif
_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();
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="config">The <see cref="ServiceBusConfiguration"/>.</param>
public MessagingProvider(ServiceBusConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
_config = config;
}
public ServiceBusEndToEndTests()
{
_serviceBusConfig = new ServiceBusConfiguration();
_nameResolver = new RandomNameResolver();
_namespaceManager = NamespaceManager.CreateFromConnectionString(_serviceBusConfig.ConnectionString);
_secondaryConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString("ServiceBusSecondary");
_secondaryNamespaceManager = NamespaceManager.CreateFromConnectionString(_secondaryConnectionString);
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="config">The <see cref="ServiceBusConfiguration"/>.</param>
public MessagingProvider(ServiceBusConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
_config = config;
}
static void Main(string[] args)
{
var config = new JobHostConfiguration();
var serviceBusConfig = new ServiceBusConfiguration();
config.UseServiceBus(serviceBusConfig);
var jobHost = new JobHost(config);
}
/// <summary>
/// Enables use of ServiceBus job extensions
/// </summary>
/// <param name="config">The <see cref="JobHostConfiguration"/> to configure.</param>
public static void UseServiceBus(this JobHostConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration();
config.UseServiceBus(serviceBusConfig);
}
public static void Main(string[] args)
{
JobHostConfiguration config = new JobHostConfiguration();
ServiceBusConfiguration servicebusConfig = new ServiceBusConfiguration
{
ConnectionString = sbConnectionString
};
config.UseServiceBus(servicebusConfig);
JobHost host = new JobHost(config);
host.RunAndBlock();
}
public static void Main()
{
var config = new JobHostConfiguration();
var serviceBusConfig = new ServiceBusConfiguration()
{
ConnectionString = AmbientConnectionStringProvider
.Instance
.GetConnectionString(ConnectionStringNames.ServiceBus)
};
config.UseServiceBus(serviceBusConfig);
var host = new JobHost(config);
host.RunAndBlock();
}
public static void Main()
{
_servicesBusConnectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.ServiceBus);
_namespaceManager = NamespaceManager.CreateFromConnectionString(_servicesBusConnectionString);
JobHostConfiguration config = new JobHostConfiguration();
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration
{
ConnectionString = _servicesBusConnectionString
};
config.UseServiceBus(serviceBusConfig);
JobHost host = new JobHost(config);
host.RunAndBlock();
}
/// <summary>
/// Enables use of ServiceBus job extensions
/// </summary>
/// <param name="config">The <see cref="JobHostConfiguration"/> to configure.</param>
/// <param name="serviceBusConfig">The <see cref="ServiceBusConfiguration"></see> to use./></param>
public static void UseServiceBus(this JobHostConfiguration config, ServiceBusConfiguration serviceBusConfig)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (serviceBusConfig == null)
{
throw new ArgumentNullException("serviceBusConfig");
}
ServiceBusExtensionConfig extensionConfig = new ServiceBusExtensionConfig(serviceBusConfig);
IExtensionRegistry extensions = config.GetService<IExtensionRegistry>();
extensions.RegisterExtension<IExtensionConfigProvider>(extensionConfig);
}
static void Main(string[] args)
{
Console.WriteLine("Starting ServiceBus Trigger...");
Console.WriteLine();
var connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.ServiceBus);
JobHostConfiguration config = new JobHostConfiguration();
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration
{
ConnectionString = connectionString
};
config.UseServiceBus(serviceBusConfig);
JobHost host = new JobHost(config);
host.RunAndBlock();
}
/// <summary>
/// Enables use of ServiceBus job extensions
/// </summary>
/// <param name="config">The <see cref="JobHostConfiguration"/> to configure.</param>
public static void UseServiceBus(this JobHostConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration
{
// Can remove this pragma in a future release after
// JobHostConfiguration.ServiceBusConnectionString is removed
#pragma warning disable 0618
ConnectionString = config.ServiceBusConnectionString
#pragma warning restore 0618
};
config.UseServiceBus(serviceBusConfig);
}
public override void Initialize()
{
// Apply ServiceBus configuration
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration();
JObject configSection = (JObject)Metadata.GetValue("serviceBus", StringComparison.OrdinalIgnoreCase);
JToken value = null;
if (configSection != null)
{
if (configSection.TryGetValue("maxConcurrentCalls", StringComparison.OrdinalIgnoreCase, out value))
{
serviceBusConfig.MessageOptions.MaxConcurrentCalls = (int)value;
}
if (configSection.TryGetValue("autoRenewTimeout", StringComparison.OrdinalIgnoreCase, out value))
{
serviceBusConfig.MessageOptions.AutoRenewTimeout = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture);
}
if (configSection.TryGetValue("prefetchCount", StringComparison.OrdinalIgnoreCase, out value))
{
serviceBusConfig.PrefetchCount = (int)value;
}
}
EventProcessorOptions eventProcessorOptions = EventProcessorOptions.DefaultOptions;
eventProcessorOptions.MaxBatchSize = 1000;
configSection = (JObject)Metadata.GetValue("eventHub", StringComparison.OrdinalIgnoreCase);
if (configSection != null)
{
if (configSection.TryGetValue("maxBatchSize", StringComparison.OrdinalIgnoreCase, out value))
{
eventProcessorOptions.MaxBatchSize = (int)value;
}
if (configSection.TryGetValue("prefetchCount", StringComparison.OrdinalIgnoreCase, out value))
{
eventProcessorOptions.PrefetchCount = (int)value;
}
}
_eventHubConfiguration = new EventHubConfiguration(eventProcessorOptions);
Config.UseServiceBus(serviceBusConfig);
Config.UseEventHub(_eventHubConfiguration);
}
internal static void ApplyConfiguration(JObject config, ScriptHostConfiguration scriptConfig)
{
JobHostConfiguration hostConfig = scriptConfig.HostConfig;
JArray functions = (JArray)config["functions"];
if (functions != null && functions.Count > 0)
{
scriptConfig.Functions = new Collection<string>();
foreach (var function in functions)
{
scriptConfig.Functions.Add((string)function);
}
}
// We may already have a host id, but the one from the JSON takes precedence
JToken hostId = (JToken)config["id"];
if (hostId != null)
{
hostConfig.HostId = (string)hostId;
}
else if (hostConfig.HostId == null)
{
throw new InvalidOperationException("An 'id' must be specified in the host configuration.");
}
JToken watchFiles = (JToken)config["watchFiles"];
if (watchFiles != null && watchFiles.Type == JTokenType.Boolean)
{
scriptConfig.FileWatchingEnabled = (bool)watchFiles;
}
// Apply Queues configuration
JObject configSection = (JObject)config["queues"];
JToken value = null;
if (configSection != null)
{
if (configSection.TryGetValue("maxPollingInterval", out value))
{
hostConfig.Queues.MaxPollingInterval = TimeSpan.FromMilliseconds((int)value);
}
if (configSection.TryGetValue("batchSize", out value))
{
hostConfig.Queues.BatchSize = (int)value;
}
if (configSection.TryGetValue("maxDequeueCount", out value))
{
hostConfig.Queues.MaxDequeueCount = (int)value;
}
if (configSection.TryGetValue("newBatchThreshold", out value))
{
hostConfig.Queues.NewBatchThreshold = (int)value;
}
}
// Apply Singleton configuration
configSection = (JObject)config["singleton"];
value = null;
if (configSection != null)
{
if (configSection.TryGetValue("lockPeriod", out value))
{
hostConfig.Singleton.LockPeriod = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture);
}
if (configSection.TryGetValue("listenerLockPeriod", out value))
{
hostConfig.Singleton.ListenerLockPeriod = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture);
}
if (configSection.TryGetValue("listenerLockRecoveryPollingInterval", out value))
{
hostConfig.Singleton.ListenerLockRecoveryPollingInterval = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture);
}
if (configSection.TryGetValue("lockAcquisitionTimeout", out value))
{
hostConfig.Singleton.LockAcquisitionTimeout = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture);
}
if (configSection.TryGetValue("lockAcquisitionPollingInterval", out value))
{
hostConfig.Singleton.LockAcquisitionPollingInterval = TimeSpan.Parse((string)value, CultureInfo.InvariantCulture);
}
}
// Apply ServiceBus configuration
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration();
configSection = (JObject)config["serviceBus"];
value = null;
if (configSection != null)
{
if (configSection.TryGetValue("maxConcurrentCalls", out value))
{
serviceBusConfig.MessageOptions.MaxConcurrentCalls = (int)value;
}
}
hostConfig.UseServiceBus(serviceBusConfig);
// Apply Tracing/Logging configuration
configSection = (JObject)config["tracing"];
if (configSection != null)
{
if (configSection.TryGetValue("consoleLevel", out value))
{
TraceLevel consoleLevel;
if (Enum.TryParse<TraceLevel>((string)value, true, out consoleLevel))
{
hostConfig.Tracing.ConsoleLevel = consoleLevel;
}
}
if (configSection.TryGetValue("fileLoggingEnabled", out value))
{
scriptConfig.FileLoggingEnabled = (bool)value;
}
}
hostConfig.UseTimers();
hostConfig.UseCore();
}
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 CustomMessagingProvider(ServiceBusConfiguration config, TraceWriter trace)
: base(config)
{
_config = config;
_trace = trace;
}
public ServiceBusEndToEndTests()
{
_serviceBusConfig = new ServiceBusConfiguration();
_nameResolver = new RandomNameResolver();
_namespaceManager = NamespaceManager.CreateFromConnectionString(_serviceBusConfig.ConnectionString);
}
internal static void ApplyConfiguration(JObject config, JobHostConfiguration jobHostConfig)
{
JToken hostId = (JToken)config["id"];
if (hostId == null)
{
throw new InvalidOperationException("An 'id' must be specified in the host configuration.");
}
jobHostConfig.HostId = (string)hostId;
// Apply Queues configuration
JObject configSection = (JObject)config["queues"];
JToken value = null;
if (configSection != null)
{
if (configSection.TryGetValue("maxPollingInterval", out value))
{
jobHostConfig.Queues.MaxPollingInterval = TimeSpan.FromMilliseconds((int)value);
}
if (configSection.TryGetValue("batchSize", out value))
{
jobHostConfig.Queues.BatchSize = (int)value;
}
if (configSection.TryGetValue("maxDequeueCount", out value))
{
jobHostConfig.Queues.MaxDequeueCount = (int)value;
}
if (configSection.TryGetValue("newBatchThreshold", out value))
{
jobHostConfig.Queues.NewBatchThreshold = (int)value;
}
}
// Apply Singleton configuration
configSection = (JObject)config["singleton"];
value = null;
if (configSection != null)
{
if (configSection.TryGetValue("lockPeriod", out value))
{
jobHostConfig.Singleton.LockPeriod = TimeSpan.Parse((string)value);
}
if (configSection.TryGetValue("listenerLockPeriod", out value))
{
jobHostConfig.Singleton.ListenerLockPeriod = TimeSpan.Parse((string)value);
}
if (configSection.TryGetValue("listenerLockRecoveryPollingInterval", out value))
{
jobHostConfig.Singleton.ListenerLockRecoveryPollingInterval = TimeSpan.Parse((string)value);
}
if (configSection.TryGetValue("lockAcquisitionTimeout", out value))
{
jobHostConfig.Singleton.LockAcquisitionTimeout = TimeSpan.Parse((string)value);
}
if (configSection.TryGetValue("lockAcquisitionPollingInterval", out value))
{
jobHostConfig.Singleton.LockAcquisitionPollingInterval = TimeSpan.Parse((string)value);
}
}
// Apply ServiceBus configuration
ServiceBusConfiguration sbConfig = new ServiceBusConfiguration();
configSection = (JObject)config["serviceBus"];
value = null;
if (configSection != null)
{
if (configSection.TryGetValue("maxConcurrentCalls", out value))
{
sbConfig.MessageOptions.MaxConcurrentCalls = (int)value;
}
}
jobHostConfig.UseServiceBus(sbConfig);
// Apply Tracing configuration
configSection = (JObject)config["tracing"];
if (configSection != null && configSection.TryGetValue("consoleLevel", out value))
{
TraceLevel consoleLevel;
if (Enum.TryParse<TraceLevel>((string)value, true, out consoleLevel))
{
jobHostConfig.Tracing.ConsoleLevel = consoleLevel;
}
}
// Apply WebHooks configuration
WebHooksConfiguration webHooksConfig = new WebHooksConfiguration();
configSection = (JObject)config["webhooks"];
if (configSection != null && configSection.TryGetValue("port", out value))
{
webHooksConfig = new WebHooksConfiguration((int)value);
}
jobHostConfig.UseWebHooks(webHooksConfig);
jobHostConfig.UseTimers();
}
public ServiceBusAccount(ServiceBusConfiguration config, IConnectionProvider connectionProvider = null)
{
_config = config ?? throw new ArgumentNullException(nameof(config));
_config = config;
_connectionProvider = connectionProvider;
}
public CustomMessagingProvider(ServiceBusConfiguration config)
: base(config)
{
_config = config;
}
static void Main()
{
CreateTestQueues();
CreateServiceBusQueues();
CreateServiceBusTestMessage();
// This test message kicks off the sample on how to perform graceful
// shutdown. It will shut down the host, so if you want to run other
// samples, comment this out.
CreateShutdownTestMessage();
JobHostConfiguration config = new JobHostConfiguration()
{
NameResolver = new ConfigNameResolver(),
};
// Demonstrates the global queue processing settings that can
// be configured
config.Queues.MaxPollingInterval = TimeSpan.FromSeconds(3);
config.Queues.MaxDequeueCount = 3;
config.Queues.BatchSize = 16;
config.Queues.NewBatchThreshold = 20;
// Demonstrates how queue processing can be customized further
// by defining a custom QueueProcessor Factory
config.Queues.QueueProcessorFactory = new CustomQueueProcessorFactory();
// Demonstrates how the console trace level can be customized
config.Tracing.ConsoleLevel = TraceLevel.Verbose;
// Demonstrates how a custom TraceWriter can be plugged into the
// host to capture all logging/traces.
config.Tracing.Trace = new CustomTraceWriter(TraceLevel.Info);
ServiceBusConfiguration serviceBusConfig = new ServiceBusConfiguration
{
ConnectionString = _servicesBusConnectionString,
// demonstrates global customization of the default OnMessageOptions
// that will be used by MessageReceivers
MessageOptions = new OnMessageOptions
{
MaxConcurrentCalls = 10
}
};
// demonstrates use of a custom MessagingProvider to perform deeper
// customizations of the message processing pipeline
serviceBusConfig.MessagingProvider = new CustomMessagingProvider(serviceBusConfig);
config.UseServiceBus(serviceBusConfig);
try
{
SetEnvironmentVariable(Functions.ShutDownFilePath);
JobHost host = new JobHost(config);
host.RunAndBlock();
}
finally
{
ClearEnvironmentVariable();
}
Console.WriteLine("\nDone");
Console.ReadLine();
}
private void ApplyConfiguration(JobHostConfiguration config)
{
// Apply Queues configuration
JObject configSection = (JObject)Configuration["queues"];
JToken value = null;
if (configSection != null)
{
if (configSection.TryGetValue("maxPollingInterval", out value))
{
config.Queues.MaxPollingInterval = TimeSpan.FromMilliseconds((int)value);
}
if (configSection.TryGetValue("batchSize", out value))
{
config.Queues.BatchSize = (int)value;
}
if (configSection.TryGetValue("maxDequeueCount", out value))
{
config.Queues.MaxDequeueCount = (int)value;
}
if (configSection.TryGetValue("newBatchThreshold", out value))
{
config.Queues.NewBatchThreshold = (int)value;
}
}
// Apply ServiceBus configuration
ServiceBusConfiguration sbConfig = new ServiceBusConfiguration();
configSection = (JObject)Configuration["serviceBus"];
value = null;
if (configSection != null)
{
if (configSection.TryGetValue("maxConcurrentCalls", out value))
{
sbConfig.MessageOptions.MaxConcurrentCalls = (int)value;
}
}
config.UseServiceBus(sbConfig);
// Apply Tracing configuration
configSection = (JObject)Configuration["tracing"];
if (configSection != null && configSection.TryGetValue("consoleLevel", out value))
{
TraceLevel consoleLevel;
if (Enum.TryParse<TraceLevel>((string)value, true, out consoleLevel))
{
config.Tracing.ConsoleLevel = consoleLevel;
}
}
// Apply WebHooks configuration
WebHooksConfiguration webHooksConfig = new WebHooksConfiguration();
configSection = (JObject)Configuration["webhooks"];
if (configSection != null && configSection.TryGetValue("port", out value))
{
webHooksConfig = new WebHooksConfiguration((int)value);
}
config.UseWebHooks(webHooksConfig);
config.UseTimers();
}
public async Task MultipleAccountTest()
{
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);
string queueName = ResolveName(StartQueueName);
string queuePrefix = queueName.Replace("-queue-start", "");
string firstTopicName = string.Format("{0}-topic/Subscriptions/{0}-queue-topic-1", queuePrefix);
WriteQueueMessage(_secondaryNamespaceManager, _secondaryConnectionString, queueName, "Test");
_topicSubscriptionCalled1 = new ManualResetEvent(initialState: false);
await host.StartAsync();
_topicSubscriptionCalled1.WaitOne(SBTimeout);
// ensure all logs have had a chance to flush
await Task.Delay(3000);
// Wait for the host to terminate
await host.StopAsync();
host.Dispose();
Assert.Equal("Test-topic-1", _resultMessage1);
}
finally
{
Cleanup();
}
}
