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);
}
public ServiceBusPublishEndpointProvider(IServiceBusHost host, ISendEndpointProvider sendEndpointProvider)
{
_host = host;
_sendEndpointProvider = sendEndpointProvider;
_nameFormatter = host.MessageNameFormatter;
_publishObservable = new PublishObservable();
}
/// <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>());
}
public ServiceBusReceiveEndpointConfigurator(IServiceBusHost host, ReceiveEndpointSettings settings, IConsumePipe consumePipe = null)
: base(consumePipe)
{
_host = host;
_settings = settings;
_subscribeMessageTopics = true;
}
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();
}
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)
{
}
