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))) { }