public ServiceBusReceiveEndpointConfigurator(IServiceBusHost host, ReceiveEndpointSettings settings, IConsumePipe consumePipe = null) : base(consumePipe) { _host = host; _settings = settings; _subscribeMessageTopics = true; }
public static string GetTemporaryQueueName(this IServiceBusHost ignored, string prefix) { var sb = new StringBuilder(); var host = HostMetadataCache.Host; foreach (var c in host.MachineName) { if (char.IsLetterOrDigit(c)) { sb.Append(c); } else if (c == '_') { sb.Append(c); } } sb.Append('_'); foreach (var c in host.ProcessName) { if (char.IsLetterOrDigit(c)) { sb.Append(c); } else if (c == '_') { sb.Append(c); } } sb.AppendFormat("_{0}_", prefix); sb.Append(NewId.Next().ToString(_formatter)); return(sb.ToString()); }
public void Build(IServiceBusHost host, IServiceBusBusFactoryConfigurator configurator) { addressProvider.Register("error"); var consumerTypes = GetConsumerTypes(); var messageTypes = GetMessageTypes(); foreach (var messageType in messageTypes) { addressProvider.Register(messageType); var messageConsumerTypes = GetConsumerTypes(messageType, consumerTypes); if (messageConsumerTypes.Any()) { foreach (var consumerType in messageConsumerTypes) { RegisterConsumerType(consumerType); var queueName = addressProvider.GetQueueName(messageType); var receiveConfigurator = GetReceiveEndpointConfigurator(messageType, consumerType); configurator.ReceiveEndpoint(host, queueName, receiveConfigurator); } } } }
/// <summary> /// Adds endpoints to service bus. /// </summary> /// <param name="busCfg">Service bus configuration.</param> /// <param name="host">Service bus host.</param> private void AddEndpoints(IServiceBusBusFactoryConfigurator busCfg, IServiceBusHost host) { foreach (Endpoint endpoint in _endpoints) { endpoint.SetEndpoint(busCfg, host); } }
public ServiceBusConnectionContext(IServiceBusHost host, CancellationToken cancellationToken) { _host = host; CancellationToken = cancellationToken; _payloadCache = new PayloadCache(); }
IBusControl CreateSecondBus() { return(MassTransit.Bus.Factory.CreateUsingAzureServiceBus(x => { ConfigureSecondBus(x); ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings(); IServiceBusHost host = x.Host(_secondServiceUri, h => { h.SharedAccessSignature(s => { s.KeyName = settings.KeyName; s.SharedAccessKey = settings.SharedAccessKey; s.TokenTimeToLive = settings.TokenTimeToLive; s.TokenScope = settings.TokenScope; }); }); ConfigureSecondBusHost(x, host); x.ReceiveEndpoint(host, "input_queue", e => { _secondInputQueueAddress = e.InputAddress; ConfigureSecondInputQueueEndpoint(e); }); })); }
public IBusControl GetBusControl(Action <IReceiveEndpointConfigurator> callback) { IBusControl busControl = Bus.Factory.CreateUsingAzureServiceBus(x => { IServiceBusHost host = x.Host(_hostSettings); x.ReceiveEndpoint(host, "latency_consumer" + (_settings.Durable ? "" : "_express"), e => { e.PrefetchCount = _settings.PrefetchCount; if (_settings.ConcurrencyLimit > 0) { e.MaxConcurrentCalls = _settings.ConcurrencyLimit; } callback(e); _targetAddress = e.InputAddress; }); }); TaskUtil.Await(() => busControl.StartAsync()); _targetEndpoint = busControl.GetSendEndpoint(_targetAddress); return(busControl); }
static HostReceiveEndpointHandle ConnectResponseEndpoint(IServiceBusHost host) { return(host.ConnectReceiveEndpoint(host.Topology.CreateTemporaryResponseQueueName(), x => { x.AutoDeleteOnIdle = Defaults.TemporaryAutoDeleteOnIdle; })); }
private static IBusControl ConfigureReadBus() { var expertTaggingStateMachine = new SampleSaga(); SagaDbContextFactory sagaDbContextFactory = () => new SagaDbContext <SampleSagaState, SampleSagaMapping>("default"); var stateMachineRepository = new EntityFrameworkSagaRepository <SampleSagaState>(sagaDbContextFactory); var busControl = Bus.Factory.CreateUsingAzureServiceBus(cfg => { cfg.UseNLog(); IServiceBusHost host = cfg.Host(ConfigurationManager.AppSettings["azureServiceBus:ConnectionString"], hcfg => { }); cfg.ReceiveEndpoint(host, "sample_queue", ecfg => { ecfg.StateMachineSaga(expertTaggingStateMachine, stateMachineRepository); }); }); var observer = new ReceiveObserver(true); busControl.ConnectReceiveObserver(observer); return(busControl); }
IBusControl CreateBus() { return(MassTransit.Bus.Factory.CreateUsingAzureServiceBus(x => { ConfigureBus(x); ServiceBusTokenProviderSettings settings = GetAccountSettings(); _host = x.Host(_serviceUri, h => { h.SharedAccessSignature(s => { s.KeyName = settings.KeyName; s.SharedAccessKey = settings.SharedAccessKey; s.TokenTimeToLive = settings.TokenTimeToLive; s.TokenScope = settings.TokenScope; }); }); x.UseServiceBusMessageScheduler(); ConfigureBusHost(x, _host); x.ReceiveEndpoint(_host, _inputQueueName, e => { _inputQueueAddress = e.InputAddress; ConfigureInputQueueEndpoint(e); }); })); }
public ServiceBusPublishEndpointProvider(IServiceBusHost host, ISendEndpointProvider sendEndpointProvider) { _host = host; _sendEndpointProvider = sendEndpointProvider; _nameFormatter = host.MessageNameFormatter; _publishObservable = new PublishObservable(); }
protected override IBusControl CreateBus() { return(MassTransit.Bus.Factory.CreateUsingAzureServiceBus(x => { Host = x.Host(_serviceUri, h => { h.SharedAccessSignature(s => { s.KeyName = SharedAccessKeyName; s.SharedAccessKey = SharedAccessKeyValue; s.TokenTimeToLive = TokenTimeToLive; s.TokenScope = TokenScope; }); }); ConfigureBus(x); ConfigureServiceBusBus(x); x.UseServiceBusMessageScheduler(); ConfigureServiceBusBusHost(x, Host); x.ReceiveEndpoint(Host, InputQueueName, e => { ConfigureReceiveEndpoint(e); ConfigureServiceBusReceiveEndpoint(e); _inputQueueAddress = e.InputAddress; }); })); }
protected ServiceBusEndpointSpecification(IServiceBusHost host, BaseClientSettings settings, IEndpointEntityConfigurator configurator, IServiceBusEndpointConfiguration configuration) : base(configuration) { Host = host; _settings = settings; _configurator = configurator; }
public PublishSendEndpointProvider(IMessageSerializer serializer, Uri sourceAddress, IServiceBusHost[] hosts) { _hosts = hosts; _sourceAddress = sourceAddress; _serializer = serializer; _sendObservable = new SendObservable(); }
public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) .ConfigureServices((hostContext, services) => { services.AddScoped <MyConsumer>(); services.AddMassTransit(serviceConfigurator => { serviceConfigurator.AddConsumer <MyConsumer>(); serviceConfigurator.AddBus(provider => Bus.Factory.CreateUsingAzureServiceBus(busConfiguration => { IServiceBusHost host = busConfiguration.Host(new Uri("sb://lennartazuretest.servicebus.windows.net/"), (sbCfg) => { sbCfg.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", "HUFMOfa23zFs+nt43t0enAdKnDBObcJOEfsqj/cqPoc="); }); busConfiguration.SubscriptionEndpoint("pelle1", "mtcommoncontract/icontract", ep => { ep.PrefetchCount = 4; ep.ConfigureConsumer <MyConsumer>(provider); }); })); services.AddHostedService <Worker>(); }); });
public async Task Should_support_the_new_syntax() { ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings(); var serviceBusNamespace = Configuration.ServiceNamespace; Uri serviceUri = AzureServiceBusEndpointUriCreator.Create( serviceBusNamespace, "MassTransit.Azure.ServiceBus.Core.Tests" ); var completed = new TaskCompletionSource <A>(); IBusControl bus = Bus.Factory.CreateUsingAzureServiceBus(x => { IServiceBusHost host = x.Host(serviceUri, h => { h.SharedAccessSignature(s => { s.KeyName = settings.KeyName; s.SharedAccessKey = settings.SharedAccessKey; s.TokenTimeToLive = settings.TokenTimeToLive; s.TokenScope = settings.TokenScope; }); }); x.ReceiveEndpoint(host, "input_queue", e => { e.PrefetchCount = 16; e.UseLog(Console.Out, async l => string.Format("Logging: {0}", l.Context.MessageId.Value)); e.Handler <A>(async context => completed.TrySetResult(context.Message)); // Add a message handler and configure the pipeline to retry the handler // if an exception is thrown e.Handler <A>(Handle, h => { h.UseRetry(r => r.Interval(5, 100)); }); }); }); BusHandle busHandle = await bus.StartAsync(); try { } finally { await busHandle.StopAsync(); } // })) // { // var queueAddress = new Uri(hostAddress, "input_queue"); // ISendEndpoint endpoint = bus.GetSendEndpoint(queueAddress); // // await endpoint.Send(new A()); // } }
public static async Task <IBusControl> StartBusControl( Action <IServiceBusBusFactoryConfigurator, IServiceBusHost> configurator = null) { Write("Starting service bus ...", ConsoleColor.Magenta); var cstrBuilder = new ServiceBusConnectionStringBuilder(Consts.CstrManagement); IBusControl bus = Bus.Factory.CreateUsingAzureServiceBus(busCfg => { IServiceBusHost host = busCfg.Host(cstrBuilder.Endpoint, hostCfg => { hostCfg.SharedAccessSignature(sasCfg => { sasCfg.KeyName = cstrBuilder.SasKeyName; sasCfg.SharedAccessKey = cstrBuilder.SasKey; sasCfg.TokenTimeToLive = Consts.DefaultTokenTimeToLive; }); }); busCfg.UseJsonSerializer(); busCfg.DefaultMessageTimeToLive = Consts.DefaultMessageTimeToLive; busCfg.EnableDeadLetteringOnMessageExpiration = true; busCfg.LockDuration = Consts.DefaultLockDuration; busCfg.AutoDeleteOnIdle = Consts.DefaultAutoDeleteOnIdle; busCfg.MaxDeliveryCount = Consts.DefaultMaxDeliveryCount; busCfg.EnableDuplicateDetection(Consts.DefaultDuplicateDetectionWindow); configurator?.Invoke(busCfg, host); }); await bus.StartAsync(); WriteLine(" started.", ConsoleColor.Magenta); return(bus); }
/// <summary> /// Create a request client from the bus, creating a response endpoint, and publishing the request versus sending it. /// </summary> /// <param name="host">The host to connect the new receive endpoint</param> /// <param name="timeout">The default request timeout</param> /// <returns></returns> public static async Task <IRequestClient <T> > CreateRequestClient <T>(this IServiceBusHost host, RequestTimeout timeout = default) where T : class { var clientFactory = await CreateClientFactory(host, timeout).ConfigureAwait(false); return(clientFactory.CreateRequestClient <T>()); }
protected override void ConfigureBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host) { configurator.ReceiveEndpoint(host, "input_queue_error", x => { _errorHandler = Handled<PingMessage>(x); }); }
public ServiceBusReceiveEndpointBuilder(IConsumePipe consumePipe, IBusBuilder busBuilder, bool subscribeMessageTopics, IServiceBusHost host) : base(consumePipe, busBuilder) { _subscribeMessageTopics = subscribeMessageTopics; _host = host; _topicSubscriptions = new List <TopicSubscriptionSettings>(); }
public void ReceiveEndpoint(IServiceBusHost host, string queueName, Action <IServiceBusReceiveEndpointConfigurator> configure) { var endpointConfigurator = new ServiceBusReceiveEndpointConfigurator(host, queueName); configure(endpointConfigurator); AddBusFactorySpecification(endpointConfigurator); }
public ReceiveTransport(IServiceBusHost host, ClientSettings settings, IPipeSpecification <NamespaceContext>[] specifications) { _host = host; _settings = settings; _specifications = specifications; _receiveObservers = new ReceiveObservable(); _endpointObservers = new ReceiveTransportObservable(); }
public ReceiveTransport(IServiceBusHost host, ClientSettings settings, IPipeSpecification<NamespaceContext>[] specifications) { _host = host; _settings = settings; _specifications = specifications; _receiveObservers = new ReceiveObservable(); _endpointObservers = new ReceiveTransportObservable(); }
public ServiceBusSubscriptionEndpointSpecification(IServiceBusHost host, SubscriptionEndpointSettings settings, IServiceBusEndpointConfiguration configuration, ISendTransportProvider sendTransportProvider) : base(host, settings, settings.SubscriptionConfigurator, configuration) { _settings = settings; _configuration = configuration; _sendTransportProvider = sendTransportProvider; }
public PublishSendEndpointProvider(IMessageSerializer serializer, Uri sourceAddress, IServiceBusHost host) { _host = host; _sourceAddress = sourceAddress; _serializer = serializer; _sendObservable = new SendObservable(); }
public ServiceBusSubscriptionEndpointBuilder(IBusBuilder busBuilder, IServiceBusHost host, IServiceBusEndpointConfiguration configuration, ISendTransportProvider sendTransportProvider) : base(busBuilder, configuration) { _configuration = configuration; _host = host; _sendTransportProvider = sendTransportProvider; }
public async Task Should_support_the_new_syntax() { ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings(); Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", Configuration.ServiceNamespace, "MassTransit.AzureServiceBusTransport.Tests"); var completed = TaskUtil.GetTask <A>(); IBusControl bus = Bus.Factory.CreateUsingAzureServiceBus(x => { IServiceBusHost host = x.Host(serviceUri, h => { h.SharedAccessSignature(s => { s.KeyName = settings.KeyName; s.SharedAccessKey = settings.SharedAccessKey; s.TokenTimeToLive = settings.TokenTimeToLive; s.TokenScope = settings.TokenScope; }); }); x.ReceiveEndpoint(host, "input_queue", e => { e.PrefetchCount = 16; e.UseExecute(context => Console.WriteLine( $"Received (input_queue): {context.ReceiveContext.TransportHeaders.Get("MessageId", "N/A")}, Types = ({string.Join(",", context.SupportedMessageTypes)})")); e.Handler <A>(async context => completed.TrySetResult(context.Message)); // Add a message handler and configure the pipeline to retry the handler // if an exception is thrown e.Handler <A>(Handle, h => { h.UseRetry(r => r.Interval(5, 100)); }); }); }); BusHandle busHandle = await bus.StartAsync(); try { } finally { await busHandle.StopAsync(); } // })) // { // var queueAddress = new Uri(hostAddress, "input_queue"); // ISendEndpoint endpoint = bus.GetSendEndpoint(queueAddress); // // await endpoint.Send(new A()); // } }
public void SubscriptionEndpoint(IServiceBusHost host, string subscriptionName, string topicName, Action <IServiceBusSubscriptionEndpointConfigurator> configure) { var specification = new ServiceBusSubscriptionEndpointSpecification(host, subscriptionName, topicName); AddReceiveEndpointSpecification(specification); configure?.Invoke(specification); }
public ServiceBusReceiveEndpointBuilder(IBusBuilder busBuilder, IServiceBusHost host, bool subscribeMessageTopics, IServiceBusEndpointConfiguration configuration, ISendTransportProvider sendTransportProvider) : base(busBuilder, configuration) { _subscribeMessageTopics = subscribeMessageTopics; _configuration = configuration; _sendTransportProvider = sendTransportProvider; _host = host; }
public ReceiveTransport(IServiceBusHost host, ClientSettings settings, IClientContextSupervisor clientContextSupervisor, IPipe <ClientContext> clientPipe, ServiceBusReceiveEndpointContext context) { _host = host; _settings = settings; _clientContextSupervisor = clientContextSupervisor; _clientPipe = clientPipe; _context = context; }
public ServiceBusNamespaceContext(IServiceBusHost host, IReceiveObserver receiveObserver, IReceiveTransportObserver receiveTransportObserver, TaskSupervisor supervisor) : base(new PayloadCache(), supervisor.StoppingToken) { _host = host; _receiveObserver = receiveObserver; _receiveTransportObserver = receiveTransportObserver; _supervisor = supervisor; }
bool TryGetMatchingHost(Uri address, out IServiceBusHost host) { host = _hosts .Where(x => x.Settings.ServiceUri.GetLeftPart(UriPartial.Authority).Equals(address.GetLeftPart(UriPartial.Authority), StringComparison.OrdinalIgnoreCase)) .OrderByDescending(x => address.AbsolutePath.StartsWith(x.Settings.ServiceUri.AbsolutePath, StringComparison.OrdinalIgnoreCase) ? 1 : 0) .FirstOrDefault(); return(host != null); }
public ServiceBusReceiveTransport(IServiceBusHost host, ReceiveSettings settings, params TopicSubscriptionSettings[] subscriptionSettings) { _host = host; _settings = settings; _subscriptionSettings = subscriptionSettings; _receiveObservers = new ReceiveObservable(); _endpointObservers = new ReceiveEndpointObservable(); }
bool TryGetMatchingHost(Uri address, out IServiceBusHost host) { host = _hosts .Where(x => x.Settings.ServiceUri.GetLeftPart(UriPartial.Authority).Equals(address.GetLeftPart(UriPartial.Authority), StringComparison.OrdinalIgnoreCase)) .OrderByDescending(x => address.AbsolutePath.StartsWith(x.Settings.ServiceUri.AbsolutePath, StringComparison.OrdinalIgnoreCase) ? 1 : 0) .FirstOrDefault(); return host != null; }
public ServiceBusReceiveTransport(IServiceBusHost host, ReceiveSettings settings, params TopicSubscriptionSettings[] subscriptionSettings) { _host = host; _settings = settings; _subscriptionSettings = subscriptionSettings; _receiveObservers = new ReceiveObservable(); _endpointObservers = new ReceiveEndpointObservable(); _connectionRetryPolicy = Retry.Exponential(1000, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(1)); }
bool TryGetMatchingHost(Uri address, out IServiceBusHost host) { host = _hosts.GetHosts(address) .Cast<IServiceBusHost>() .OrderByDescending(x => address.AbsolutePath.StartsWith(x.Settings.ServiceUri.AbsolutePath, StringComparison.OrdinalIgnoreCase) ? 1 : 0) .FirstOrDefault(); return host != null; }
public static Uri GetTopicAddress(this IMessageNameFormatter messageNameFormatter, IServiceBusHost host, Type messageType) { string messageName = messageNameFormatter.GetMessageName(messageType).ToString(); var builder = new UriBuilder(host.Settings.ServiceUri) { Path = messageName }; return builder.Uri; }
protected override void ConfigureBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host) { base.ConfigureBusHost(configurator, host); configurator.ReceiveEndpoint(host, "input_express", x => { x.EnableExpress = true; x.AutoDeleteOnIdle = TimeSpan.FromMinutes(5); _handled = Handled<PingMessage>(x); }); }
protected override void ConfigureBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host) { configurator.UseServiceBusMessageScheduler(); base.ConfigureBusHost(configurator, host); configurator.TurnoutEndpoint<ProcessFile>(host, "process_queue", endpoint => { endpoint.SuperviseInterval = TimeSpan.FromSeconds(1); endpoint.SetJobFactory(async context => await Task.Delay(TimeSpan.FromSeconds(context.Command.Size)).ConfigureAwait(false)); _commandEndpointAddress = endpoint.InputAddress; }); }
protected override void ConfigureBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host) { configurator.UseServiceBusMessageScheduler(); base.ConfigureBusHost(configurator, host); configurator.TurnoutEndpoint<ProcessFile>(host, "process_queue", endpoint => { endpoint.SuperviseInterval = TimeSpan.FromSeconds(1); endpoint.SetJobFactory(async context => { try { await Task.Delay(TimeSpan.FromSeconds(context.Command.Size), context.CancellationToken).ConfigureAwait(false); } catch (TaskCanceledException ex) { Console.WriteLine("Task was canceled!"); throw; } }); _commandEndpointAddress = endpoint.InputAddress; }); }
/// <summary> /// Declare a ReceiveEndpoint using a unique generated queue name. This queue defaults to auto-delete /// and non-durable. By default all services bus instances include a default receiveEndpoint that is /// of this type (created automatically upon the first receiver binding). /// </summary> /// <param name="configurator"></param> /// <param name="host"></param> /// <param name="configure"></param> public static void ReceiveEndpoint(this IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host, Action<IServiceBusReceiveEndpointConfigurator> configure) { var queueName = host.GetTemporaryQueueName("endpoint"); configurator.ReceiveEndpoint(host, queueName, x => { x.AutoDeleteOnIdle = TimeSpan.FromMinutes(5); x.EnableExpress = true; configure(x); }); }
public void ReceiveEndpoint(IServiceBusHost host, string queueName, Action<IServiceBusReceiveEndpointConfigurator> configure) { var endpointConfigurator = new ServiceBusReceiveEndpointConfigurator(host, queueName); configure(endpointConfigurator); AddBusFactorySpecification(endpointConfigurator); }
IBusControl CreateBus() { return MassTransit.Bus.Factory.CreateUsingAzureServiceBus(x => { ConfigureBus(x); ServiceBusTokenProviderSettings settings = GetAccountSettings(); _host = x.Host(_serviceUri, h => { h.SharedAccessSignature(s => { s.KeyName = settings.KeyName; s.SharedAccessKey = settings.SharedAccessKey; s.TokenTimeToLive = settings.TokenTimeToLive; s.TokenScope = settings.TokenScope; }); }); x.UseServiceBusMessageScheduler(); ConfigureBusHost(x, _host); x.ReceiveEndpoint(_host, _inputQueueName, e => { _inputQueueAddress = e.InputAddress; ConfigureInputQueueEndpoint(e); }); }); }
public ServiceBusSubscriptionEndpointSpecification(IServiceBusHost host, string subscriptionName, string topicName, IConsumePipe consumePipe = null) : this(host, new SubscriptionEndpointSettings(topicName, subscriptionName), consumePipe) { }
public ServiceBusSubscriptionEndpointSpecification(IServiceBusHost host, SubscriptionEndpointSettings settings, IConsumePipe consumePipe = null) : base(host, settings, consumePipe) { _settings = settings; }
public ServiceBusSendTransportProvider(IServiceBusHost[] hosts) { _hosts = hosts; }
protected virtual void ConfigureBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host) { }
public ServiceBusReceiveEndpointConfigurator(IServiceBusHost host, ReceiveEndpointSettings settings, IConsumePipe consumePipe = null) : base(consumePipe) { _host = host; _settings = settings; }
/// <summary> /// Creates a management endpoint which can be used by controllable filters on a bus intance /// </summary> /// <param name="configurator"></param> /// <param name="host">The service bus host</param> /// <param name="configure"></param> /// <returns></returns> public static IManagementEndpointConfigurator ManagementEndpoint(this IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host, Action<IReceiveEndpointConfigurator> configure = null) { var queueName = host.GetTemporaryQueueName("manage-"); var specification = new ServiceBusReceiveEndpointSpecification(host, queueName) { AutoDeleteOnIdle = TimeSpan.FromMinutes(5), EnableExpress = true, }; configure?.Invoke(specification); configurator.AddReceiveEndpointSpecification(specification); var managementEndpointConfigurator = new ManagementEndpointConfigurator(specification); return managementEndpointConfigurator; }
public ServiceBusReceiveEndpointConfigurator(IServiceBusHost host, string queueName, IConsumePipe consumePipe = null) : this(host, new ReceiveEndpointSettings(queueName), consumePipe) { }
public ServiceBusReceiveEndpointSpecification(IServiceBusHost host, ReceiveEndpointSettings settings, IConsumePipe consumePipe = null) : base(host, settings, consumePipe) { _settings = settings; _subscribeMessageTopics = true; }
protected override void ConfigureBusHost(IServiceBusBusFactoryConfigurator configurator, IServiceBusHost host) { base.ConfigureBusHost(configurator, host); configurator.UseServiceBusMessageScheduler(); }
public ServiceBusConnectionContext(IServiceBusHost host, CancellationToken cancellationToken) : base(new PayloadCache(), cancellationToken) { _host = host; }
public ServiceBusReceiveEndpointSpecification(IServiceBusHost host, string queueName, IConsumePipe consumePipe = null) : this(host, new ReceiveEndpointSettings(Defaults.CreateQueueDescription(queueName)), consumePipe) { }