public AppSettings(
ServiceBusSettings serviceBusSettings,
ConfigurationSettings configurationSettings)
{
ServiceBusSettings = serviceBusSettings;
ConfigurationSettings = configurationSettings;
}
private static void ConfigureServiceBus()
{
var serviceBusSettings = new ServiceBusSettings();
_config.GetSection("ServiceBus").Bind(serviceBusSettings);
var serviceBusQueuesSettings = new ServiceBusQueuesSettings();
_config.GetSection("ServiceBusQueues").Bind(serviceBusQueuesSettings);
_bus = BusConfigurator.ConfigureBus(serviceBusSettings,
(sbc, host) =>
{
sbc.ReceiveEndpoint(serviceBusQueuesSettings.ProductServiceQueue,
e =>
{
e.Consumer <CreateProductConusmer>();
e.Consumer <UpdateProductConusmer>();
e.Consumer <DeleteProductConusmer>();
e.Consumer <GetProductConusmer>();
e.Consumer <GetAllProductConusmer>();
});
});
try
{
Console.WriteLine("Starting Service Bus....");
_bus.Start();
Console.WriteLine("Service Bus Started....");
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void Durable_consequenters_can_be_simulated_for_unit_testing_and_receive_messages()
{
var consequenter1WasCalled = false;
var consequenter2WasCalled = false;
var uselessSettings = new ServiceBusSettings();
using (ServiceBusDurabilityExtensions.Simulate())
{
var consequenter1 = Consequenter.Create <Order.Cancelled>(
e => { consequenter1WasCalled = true; });
var consequenter2 = Consequenter.Create <Order.CreditCardCharged>(
e => { consequenter2WasCalled = true; });
var bus = new InProcessEventBus();
bus.Subscribe(
consequenter1.UseServiceBusForDurability(uselessSettings),
consequenter2.UseServiceBusForDurability(uselessSettings));
bus.PublishAsync(new Order.Cancelled()).Wait();
consequenter1WasCalled.Should().BeTrue();
consequenter2WasCalled.Should().BeFalse();
}
}
public static void Main(string[] args)
{
var configBuilder = new ConfigurationBuilder();
var config = configBuilder.AddJsonFile("appsettings.json").Build();
var serviceBusSettings = new ServiceBusSettings
{
ConnectionString = config.GetSection("ServiceBus:ConnectionString").Value,
QueueName = config.GetSection("ServiceBus:QueueName").Value,
};
var myHandler = new MyTaskExecutionHandler();
var listener = new ServiceBusMessageListener(serviceBusSettings, myHandler);
Console.WriteLine(
"Starting the VSTS request listener on queue '{0}'", serviceBusSettings.QueueName);
listener.Start();
Console.WriteLine("Press any key to exit after receiving all the messages ...");
Console.ReadKey();
listener.Stop();
Console.WriteLine("Shutting down VSTS request listener ...");
}
private void ConfigureLocalServices(IServiceCollection services)
{
var config = Configuration.GetSection("ServiceBus");
var settings = new ServiceBusSettings {
Address = config.GetValue <string>("Address"),
AppName = config.GetValue <string>("AppName"),
Protocol = config.GetValue <string>("Protocol"),
PolicyName = config.GetValue <string>("Policy"),
Key = config.GetValue <string>("Key"),
Namespace = config.GetValue <string>("Namespace")
};
services.AddSingleton(settings);
services.AddSingleton <IDomainEventReceiver, DomainEventReceiver>();
services.AddSingleton <IHashProvider, HashProvider>();
services.AddSingleton <IAuthenticator, Authenticator>();
Assembly.GetEntryAssembly().GetTypes()
.Where(x => (x.Name.EndsWith("Service") || x.Name.EndsWith("Handler") || x.Name.EndsWith("Factory")) &&
x.GetTypeInfo().IsClass &&
!x.GetTypeInfo().IsAbstract &&
x.GetInterfaces().Any())
.ToList().ForEach(x => {
x.GetInterfaces().ToList()
.ForEach(i => services.AddSingleton(i, x));
});
}
public SettingsAdapter(ServiceBusSettings settings, string serviceName)
{
_settings = settings;
if (string.IsNullOrWhiteSpace(settings.ConnectionString))
{
if (string.IsNullOrWhiteSpace(_settings.Namespace))
{
throw new ConfigurationException("The ServiceBus Namespace setting has not been configured");
}
if (string.IsNullOrEmpty(settings.KeyName))
{
throw new ConfigurationException("The ServiceBus KeyName setting has not been configured");
}
if (string.IsNullOrEmpty(settings.SharedAccessKey))
{
throw new ConfigurationException("The ServiceBus SharedAccessKey setting has not been configured");
}
ServiceUri = AzureServiceBusEndpointUriCreator.Create(_settings.Namespace, _settings.ServicePath ?? serviceName);
TokenProvider = Microsoft.Azure.ServiceBus.Primitives.TokenProvider.CreateSharedAccessSignatureTokenProvider(settings.KeyName,
settings.SharedAccessKey);
}
else
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(settings.ConnectionString);
ServiceUri = namespaceManager.Address;
TokenProvider = namespaceManager.Settings.TokenProvider;
}
}
/// <summary>
/// The entry point of the application.
/// </summary>
public static void Main()
{
var unityContainer = new UnityContainer();
unityContainer.LoadConfiguration();
var components =
from registration in unityContainer.Registrations
where typeof(IServiceBusComponent).IsAssignableFrom(registration.MappedToType)
select(IServiceBusComponent) unityContainer.Resolve(registration.RegisteredType, registration.Name);
var serviceBusSettings = new ServiceBusSettings
{
Components = components.ToList()
};
var serviceBus = new ServiceBus(serviceBusSettings, unityContainer.Resolve <ILogger>());
serviceBus.Start();
Console.WriteLine("Service Bus started.\nPress any key to shutdown...");
Console.ReadKey();
serviceBus.Stop();
Environment.Exit(0);
}
/// <summary>
/// Method is used for abandoned subscriptions deleting (subscriptions to temporaries queues on fanout topics).
/// Should be fixed in new Masstransit releases.
/// </summary>
/// <param name="settings">Service bus settings.</param>
private static void DeleteAbandonedSubscriptions(ServiceBusSettings settings)
{
var serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", settings.AzureNamespace, string.Empty);
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", settings.AzureSharedAccessKey, TokenScope.Namespace);
var namespaceManager = new NamespaceManager(serviceUri, tokenProvider);
var queues = namespaceManager.GetQueues().Select(q => $"{namespaceManager.Address.AbsoluteUri.ToLower()}{q.Path.ToLower()}").ToList();
var toExecute = new List <Action>();
foreach (var topic in namespaceManager.GetTopics().Where(t => t.SubscriptionCount > 0))
{
foreach (var subscription in namespaceManager.GetSubscriptions(topic.Path).Where(s => !string.IsNullOrEmpty(s.ForwardTo)))
{
if (!queues.Contains(subscription.ForwardTo.ToLower()))
{
toExecute.Add(() =>
{
namespaceManager.DeleteSubscription(topic.Path, subscription.Name);
Log.Information("Abandoned subscription removed: {topic} -> {subscription} -> {queue}",
topic.Path, subscription.Name, subscription.ForwardTo);
});
}
Log.Debug("Found abandoned subscription: {topic} -> {subscription} -> {queue}", topic.Path, subscription.Name, subscription.ForwardTo);
}
}
foreach (var execute in toExecute)
{
execute();
}
}
public ServiceBusConfiguration()
{
_settings = new ServiceBusSettings
{
SubscriptionName = null,
};
}
public void TestTimelyOnlyOneCallPrepare()
{
Mock <IServiceBusComponent> mockService1 = new Mock <IServiceBusComponent>();
Mock <IServiceBusComponent> mockService2 = new Mock <IServiceBusComponent>();
// Arrange.
var settings = new ServiceBusSettings
{
Components = new[]
{
mockService1.Object,
mockService2.Object,
}
};
var sb = new ServiceBus(settings, GetMockLogger());
sb.Start();
mockService1.Verify(m => m.Prepare());
mockService1.Verify(m => m.Start());
mockService2.Verify(n => n.Prepare());
mockService2.Verify(n => n.Start());
sb.Stop();
mockService1.Verify(m => m.Stop());
mockService2.Verify(n => n.Stop());
}
public static async Task MainAsync(string[] args)
{
var hostBuilder = new HostBuilder()
.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables();
})
.ConfigureAppConfiguration((hostContext, config) =>
{
config.SetBasePath(Environment.CurrentDirectory);
config.AddJsonFile("appsettings.json", false);
config.AddEnvironmentVariables();
_configuration = config.Build();
_busSettings = _configuration.GetSection("ServiceBusSettings").Get <ServiceBusSettings>();
})
.ConfigureLogging((hostContext, config) =>
{
config.AddConsole();
})
.ConfigureServices(ConfigureServices);
await hostBuilder.RunConsoleAsync();
}
public void TestAllComponentsReceiveTheirCallStop()
{
Mock <IServiceBusComponent> mockService1 = new Mock <IServiceBusComponent>();
Mock <IServiceBusComponent> mockService3 = new Mock <IServiceBusComponent>();
foreach (var ex in GetListException())
{
var settings = new ServiceBusSettings
{
Components = new[]
{
mockService1.Object,
new ErrorServiceTest(null, ex, null),
mockService3.Object
}
};
var sb = new ServiceBus(settings, GetMockLogger());
sb.Start();
try
{
sb.Stop();
Assert.True(false, "");
}
catch (Exception)
{
mockService1.Verify(m => m.Stop());
mockService3.Verify(n => n.Stop());
}
}
}
public SendDataService(ILogger <SendDataService> logger, IBus bus, IOptionsMonitor <ServiceBusSettings> options)
{
this.logger = logger;
this.bus = bus;
serviceBusSettings = options.CurrentValue;
logger.LogInformation("SendDataProcess.SendDataProcess has been called");
}
public static IServiceCollection AddServiceBus(this IServiceCollection builder, IConfiguration config, string serviceName = null)
{
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder
.AddSingleton <IMessengerService, QueueMessengerService>((ctx) =>
{
Common.ServiceBus.QueueClient queueClient = new Common.ServiceBus.QueueClient("UseDevelopmentStorage=true");
return(new QueueMessengerService(queueClient, serviceName));
});
}
else
{
ServiceBusSettings serviceBusSettings = new ServiceBusSettings();
config.Bind("ServiceBusSettings", serviceBusSettings);
builder.AddSingleton(serviceBusSettings);
builder
.AddSingleton <IMessengerService, MessengerService>((ctx) =>
{
MessageReceiverFactory messageReceiverFactory = new MessageReceiverFactory(serviceBusSettings.ConnectionString);
ManagementClient managementClient = new ManagementClient(serviceBusSettings.ConnectionString);
return(new MessengerService(serviceBusSettings, managementClient, messageReceiverFactory, serviceName));
});
}
return(builder);
}
private InfrastructureSettings()
{
ConnectionStringSettings = new ConnectionStringSettings();
ServiceBusQueuesSettings = new ServiceBusQueuesSettings();
ServiceBusSettings = new ServiceBusSettings();
BlobStorageSettings = new BlobStorageSettings();
}
public static void CreateTopic(this ServiceBusSettings settings, string topic)
{
new NamespaceManager(
ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath),
TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey))
.CreateTopic(topic);
}
private static void ConfigureServices(IServiceCollection serviceCollection)
{
//add logging
serviceCollection.AddSingleton(new LoggerFactory().AddConsole());
serviceCollection.AddLogging();
//add services
serviceCollection.AddTransient <IAppService, AppService>();
//MassTransit
var serviceBusSettings = new ServiceBusSettings
{
ServiceBusConnectionString = "",
ServiceBusKeyName = "",
ServiceBusSharedAccessKey = ""
};
serviceCollection.AddSingleton(provider => BusConfigurator.ConfigureBus(serviceBusSettings));
serviceCollection.AddSingleton <ISendEndpointProvider>(provider => provider.GetRequiredService <IBusControl>());
serviceCollection.AddSingleton <IPublishEndpoint>(provider => provider.GetRequiredService <IBusControl>());
serviceCollection.AddSingleton <IBus>(provider => provider.GetRequiredService <IBusControl>());
//add Services
serviceCollection.AddSingleton <IMassTransitService, MassTransitService>();
serviceCollection.AddTransient <IMessageSender, MessageSender>();
}
static void Main(string[] args)
{
try
{
Console.Title = ServiceName;
_config = Config.Build();
var serviceBusSettings = new ServiceBusSettings();
var serviceBusQueuesSettings = new ServiceBusQueuesSettings();
var connectionStringSettings = new ConnectionStringSettings();
var blobSettings = new BlobStorageSettings();
_config.GetSection("ServiceBus").Bind(serviceBusSettings);
_config.GetSection("ServiceBusQueues").Bind(serviceBusQueuesSettings);
_config.GetSection("ConnectionStrings").Bind(connectionStringSettings);
_config.GetSection("BlobStorage").Bind(blobSettings);
_infrastructureSettings = InfrastructureSettings.Create(connectionStringSettings,
serviceBusQueuesSettings, serviceBusSettings, blobSettings);
DisplayConfiguration();
ProductServiceBus.Instance.GetProductServiceBus();
Console.ReadLine();
ProductServiceBus.Instance.StopProductServiceBus();
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadLine();
}
}
public ServiceBusHostBusFactory(ISettingsProvider settingsProvider)
{
ServiceBusSettings settings;
if (!settingsProvider.TryGetSettings("ServiceBus", out settings))
{
throw new ConfigurationException("The ServiceBus settings were not available");
}
_settings = settings;
ServiceBusAmqpTransportSettings amqpTransportSettings;
if (!settingsProvider.TryGetSettings("ServiceBusAmqpTransport", out amqpTransportSettings))
{
throw new ConfigurationException("The ServiceBusAmqpTransport settings were not available");
}
_ampAmqpTransportSettings = amqpTransportSettings;
ServiceBusNetMessagingTransportSettings netMessagingTransportSettings;
if (!settingsProvider.TryGetSettings("ServiceBusNetMessagingTransport", out netMessagingTransportSettings))
{
throw new ConfigurationException("The ServiceBusNetMessagingTransport settings were not available");
}
_netMessagingTransportSettings = netMessagingTransportSettings;
}
public SettingsAdapter(ServiceBusSettings settings, ServiceBusAmqpTransportSettings ampAmqpTransportSettings,
ServiceBusNetMessagingTransportSettings netMessagingTransportSettings, string serviceName)
{
_settings = settings;
_ampAmqpTransportSettings = ampAmqpTransportSettings;
_netMessagingTransportSettings = netMessagingTransportSettings;
if (string.IsNullOrWhiteSpace(settings.ConnectionString))
{
if (string.IsNullOrWhiteSpace(_settings.Namespace))
{
throw new ConfigurationException("The ServiceBus Namespace setting has not been configured");
}
if (string.IsNullOrEmpty(settings.KeyName))
{
throw new ConfigurationException("The ServiceBus KeyName setting has not been configured");
}
if (string.IsNullOrEmpty(settings.SharedAccessKey))
{
throw new ConfigurationException("The ServiceBus SharedAccessKey setting has not been configured");
}
ServiceUri = ServiceBusEnvironment.CreateServiceUri("sb", settings.Namespace, settings.ServicePath ?? serviceName);
TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(settings.KeyName, settings.SharedAccessKey);
}
else
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(settings.ConnectionString);
ServiceUri = namespaceManager.Address;
TokenProvider = namespaceManager.Settings.TokenProvider;
}
}
public void TestAnyErrorsInPrepareProcessedAndLogged()
{
foreach (var ex in GetListException())
{
var settings = new ServiceBusSettings
{
Components = new IServiceBusComponent[]
{
new ErrorServiceTest(null, null, ex)
}
};
Mock <ILogger> mock = new Mock <ILogger>();
var sb = new ServiceBus(settings, mock.Object);
try
{
sb.Start();
Assert.True(false, "");
}
catch (Exception e)
{
mock.Verify(m => m.LogUnhandledException(e, null, null, null));
}
}
}
public static IBusControl Create(
IComponentContext context,
ServiceBusSettings settings,
Action <IReceiveEndpointConfigurator> receiveEndpointConfigurator,
Action <IReceiveEndpointConfigurator> fanoutReceiveEndpointConfigurator)
{
if (fanoutReceiveEndpointConfigurator != null)
{
DeleteAbandonedSubscriptions(settings);
}
return(Bus.Factory.CreateUsingAzureServiceBus(x =>
{
x.UseSerilog();
var serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", settings.AzureNamespace, GetPath(settings));
var host = x.Host(serviceUri, h =>
{
h.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", settings.AzureSharedAccessKey, TokenScope.Namespace);
});
if (receiveEndpointConfigurator != null)
{
x.ReceiveEndpoint(settings.QueueName, receiveEndpointConfigurator);
}
if (fanoutReceiveEndpointConfigurator != null)
{
x.ReceiveEndpoint(host, fanoutReceiveEndpointConfigurator);
}
x.ConfigurePublish(cfg => cfg.UseSendExecute(sendContext => sendContext.ApplyInterceptors()));
}));
}
public ApplicationSettings()
{
Hosting = new HostingSettings();
ServiceBus = new ServiceBusSettings();
InteropServiceBus = new ServiceBusSettings();
Logging = new LoggingSettings();
Persistence = new PersistenceSettings();
}
public static TopicClient CreateTopicClient(this ServiceBusSettings settings, string topic)
{
var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey);
var serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath);
var messagingFactory = MessagingFactory.Create(serviceUri, tokenProvider);
return(messagingFactory.CreateTopicClient(topic));
}
public static MessageReceiver CreateMessageReceiver(this ServiceBusSettings settings, string topic, string subscription)
{
var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey);
var serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath);
var messagingFactory = MessagingFactory.Create(serviceUri, tokenProvider);
return(messagingFactory.CreateMessageReceiver(SubscriptionClient.FormatDeadLetterPath(topic, subscription)));
}
public QueueClientFactory(ISettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
_serviceBusSetting = settings.ServiceBusSettings;
}
public static void Example(ServiceBusSettings settings)
{
_connection
= new ServiceBarSubscriber <string>("HowToSubscribe example", settings)
.SetDeserializer(new TestDeseializer())
.Subscribe(MessageHandler)
.Start();
}
public static SubscriptionClient CreateSubscriptionClient(this ServiceBusSettings settings, string topic, string subscription, ReceiveMode mode = ReceiveMode.PeekLock)
{
var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey);
var serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath);
var messagingFactory = MessagingFactory.Create(serviceUri, tokenProvider);
return(messagingFactory.CreateSubscriptionClient(topic, subscription, mode));
}
public static void Example(ServiceBusSettings settings)
{
_connection
= new ServiceBusPublisher <string>("HowToPublish example", settings)
.SetLog(new LogToConsole())
.SetSerializer(new TestServiceBusSerializer())
.Start();
}
public ServiceBusHostBusFactory(ISettingsProvider settingsProvider)
{
ServiceBusSettings settings;
if (!settingsProvider.TryGetSettings("ServiceBus", out settings))
throw new ConfigurationException("The ServiceBus settings were not available");
_settings = settings;
}
private IEnumerable <Dictionary <string, object> > RecieveMessages(ServiceBusSettings settings, ServiceBusReceiver reciever, ILogger logger)
{
int total = 0;
int batchSize;
while (true)
{
if (settings.MaxNumberOfMessages - total >= settings.BatchSize)
{
batchSize = settings.BatchSize;
}
else
{
batchSize = settings.MaxNumberOfMessages - total;
}
var messages = new IServiceBusMessage[0];
if (batchSize <= 0)
{
break;
}
var messagesTask = Task.Run(() =>
{
try
{
return(reciever.ReceiveMessageBatchAsync(batchSize, TimeSpan.FromSeconds(MessageBusWaitTime)));
}
catch (Exception ex)
{
logger.Error($"Cannot receive messages. {Environment.NewLine}{ex}");
return(Task.FromResult(new IServiceBusMessage[0]));
}
});
messages = messagesTask.Result ?? new IServiceBusMessage[0];
total += messages.Length;
// no message in queue => let's finish
if (messages.Length == 0)
{
break;
}
// enumerate messages
for (int j = 0; j < messages.Length; j++)
{
var oneLevelMessage = new Dictionary <string, object>(messages[j].Properties);
oneLevelMessage.Add("ID", messages[j].Id);
logger.Debug($"Enumerating message with consultant '{messages[j].Id}'.");
logger.Debug($"oneLevelMessage: '{string.Join(";", oneLevelMessage)}'.");
yield return(oneLevelMessage);
}
}
}
public SubscriptionReceiver(ServiceBusSettings settings, string topic, string subscription, bool processInParallel, ISubscriptionReceiverInstrumentation instrumentation)
: this(settings,
topic,
subscription,
processInParallel,
instrumentation,
10,
new ExponentialBackoff(10, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(1)))
{
}
public SessionSubscriptionReceiver(ServiceBusSettings settings, string topic, string subscription, bool requiresSequentialProcessing, ISessionSubscriptionReceiverInstrumentation instrumentation)
: this(settings,
topic,
subscription,
requiresSequentialProcessing,
instrumentation,
10,
new ExponentialBackoff(10, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(1)))
{
}
public ServiceBusHostBusFactory(ISettingsProvider settingsProvider)
{
ServiceBusSettings settings;
if (!settingsProvider.TryGetSettings("ServiceBus", out settings))
throw new ConfigurationException("The ServiceBus settings were not available");
_settings = settings;
ServiceBusAmqpTransportSettings amqpTransportSettings;
if (!settingsProvider.TryGetSettings("ServiceBusAmqpTransport", out amqpTransportSettings))
throw new ConfigurationException("The ServiceBusAmqpTransport settings were not available");
_ampAmqpTransportSettings = amqpTransportSettings;
ServiceBusNetMessagingTransportSettings netMessagingTransportSettings;
if (!settingsProvider.TryGetSettings("ServiceBusNetMessagingTransport", out netMessagingTransportSettings))
throw new ConfigurationException("The ServiceBusNetMessagingTransport settings were not available");
_netMessagingTransportSettings = netMessagingTransportSettings;
}
protected SubscriptionReceiver(ServiceBusSettings settings, string topic, string subscription, bool processInParallel, ISubscriptionReceiverInstrumentation instrumentation, int maxNumberRetry, RetryStrategy backgroundRetryStrategy)
{
this.settings = settings;
this.topic = topic;
this.subscription = subscription;
this.processInParallel = processInParallel;
this.instrumentation = instrumentation;
var messagingFactory = MessagingFactory.CreateFromConnectionString(this.settings.ConnectionString);
this.client = messagingFactory.CreateSubscriptionClient(topic, subscription);
if (this.processInParallel)
{
this.client.PrefetchCount = 500;
}
else
{
this.client.PrefetchCount = 100;
}
this.dynamicThrottling =
new DynamicThrottling(
maxDegreeOfParallelism: 10000,
minDegreeOfParallelism: 50,
penaltyAmount: 3,
workFailedPenaltyAmount: 5,
workCompletedParallelismGain: 1,
intervalForRestoringDegreeOfParallelism: 8000);
this.retryStrategy = backgroundRetryStrategy;
this.maxNumberRetry = maxNumberRetry;
this.receiveRetryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(backgroundRetryStrategy);
this.receiveRetryPolicy.Retrying += (s, e) =>
{
this.dynamicThrottling.Penalize();
Trace.TraceWarning(
"An error occurred in attempt number {1} to receive a message from subscription {2}: {0}",
e.LastException.Message,
e.CurrentRetryCount,
this.subscription);
};
}
/// <summary>
/// Initializes a new instance of the <see cref="TopicSender"/> class,
/// automatically creating the given topic if it does not exist.
/// </summary>
protected TopicSender(ServiceBusSettings settings, string topic, int maxNumberRetry, RetryStrategy retryStrategy)
{
this.settings = settings;
this.topic = topic;
this.retryStrategy = retryStrategy;
this.maxNumberRetry = maxNumberRetry;
this.messagingFactory = MessagingFactory.CreateFromConnectionString(settings.ConnectionString);
this.topicClient = messagingFactory.CreateTopicClient(this.topic);
this.retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(this.retryStrategy);
this.retryPolicy.Retrying += (s, e) =>
{
var handler = this.Retrying;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
Trace.TraceWarning("An error occurred in attempt number {1} to send a message: {0}", e.LastException.Message, e.CurrentRetryCount);
};
}
public SettingsAdapter(ServiceBusSettings settings, string serviceName)
{
_settings = settings;
if (string.IsNullOrWhiteSpace(settings.ConnectionString))
{
if (string.IsNullOrWhiteSpace(_settings.Namespace))
throw new ConfigurationException("The ServiceBus Namespace setting has not been configured");
if (string.IsNullOrEmpty(settings.KeyName))
throw new ConfigurationException("The ServiceBus KeyName setting has not been configured");
if (string.IsNullOrEmpty(settings.SharedAccessKey))
throw new ConfigurationException("The ServiceBus SharedAccessKey setting has not been configured");
ServiceUri = ServiceBusEnvironment.CreateServiceUri("sb", settings.Namespace, settings.ServicePath ?? serviceName);
TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(settings.KeyName, settings.SharedAccessKey);
}
else
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(settings.ConnectionString);
ServiceUri = namespaceManager.Address;
TokenProvider = namespaceManager.Settings.TokenProvider;
}
}
public SettingsAdapter(ServiceBusSettings settings)
{
_settings = settings;
}
public ServiceBusConfig(ServiceBusSettings settings)
{
this.settings = settings;
}
/// <summary>
/// Initializes a new instance of the <see cref="TopicSender"/> class,
/// automatically creating the given topic if it does not exist.
/// </summary>
public TopicSender(ServiceBusSettings settings, string topic)
: this(settings, topic, 10, new ExponentialBackoff(10, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(1)))
{
}
