public TransportConfigurationResult Configure(SettingsHolder settings, TransportTransactionMode transactionMode)
{
settings.Set("Transport.ConnectionString", Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString"));
var connectionString = settings.Get <string>("Transport.ConnectionString");
settings.Set <Conventions>(new Conventions());
settings.Set(WellKnownConfigurationKeys.Core.MainSerializerSettingsKey, Tuple.Create <SerializationDefinition, SettingsHolder>(new XmlSerializer(), settings));
settings.Set("NServiceBus.SharedQueue", settings.Get("NServiceBus.Routing.EndpointName"));
var topologyName = Environment.GetEnvironmentVariable("AzureServiceBusTransport.Topology", EnvironmentVariableTarget.User);
topologyName = topologyName ?? Environment.GetEnvironmentVariable("AzureServiceBusTransport.Topology");
var transportExtension = new TransportExtensions <AzureServiceBusTransport>(settings);
if (topologyName == "ForwardingTopology")
{
transportExtension.UseForwardingTopology();
}
else
{
transportExtension.UseEndpointOrientedTopology();
}
var transport = new AzureServiceBusTransport();
var infrastructure = transport.Initialize(settings, connectionString);
return(new TransportConfigurationResult
{
PurgeInputQueueOnStartup = false,
TransportInfrastructure = infrastructure
});
}
protected override void SetUp()
{
var connectionString = AsbTestConfig.ConnectionString;
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
using (var transport = new AzureServiceBusTransport(connectionString, QueueName, consoleLoggerFactory, asyncTaskFactory, new DefaultNameFormatter()))
{
transport.PurgeInputQueue();
}
_activator = new BuiltinHandlerActivator();
_busStarter = Configure.With(_activator)
.Transport(t => t.UseAzureServiceBus(connectionString, QueueName))
.Routing(r => r.TypeBased().Map <TimedMessage>(QueueName))
.Options(o =>
{
o.LogPipeline();
})
.Create();
_bus = _busStarter.Bus;
Using(_bus);
}
public TransportConfigurationResult Configure(SettingsHolder settings, TransportTransactionMode transactionMode)
{
settings.Set("Transport.ConnectionString", Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString"));
var connectionString = settings.Get <string>("Transport.ConnectionString");
settings.Set <Conventions>(new Conventions());
settings.Set("NServiceBus.SharedQueue", settings.Get("NServiceBus.Routing.EndpointName"));
var topologyName = Environment.GetEnvironmentVariable("AzureServiceBusTransport.Topology", EnvironmentVariableTarget.User);
topologyName = topologyName ?? Environment.GetEnvironmentVariable("AzureServiceBusTransport.Topology");
if (topologyName == "ForwardingTopology")
{
#pragma warning disable 618
settings.Set <ITopology>(new ForwardingTopology());
#pragma warning restore 618
}
else
{
#pragma warning disable 618
settings.Set <ITopology>(new EndpointOrientedTopology());
#pragma warning restore 618
}
var transport = new AzureServiceBusTransport();
var infrastructure = transport.Initialize(settings, connectionString);
return(new TransportConfigurationResult()
{
PurgeInputQueueOnStartup = false,
TransportInfrastructure = infrastructure
});
}
public ITransport Create(string inputQueueAddress)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
if (inputQueueAddress == null)
{
var transport = new AzureServiceBusTransport(ConnectionString, null, consoleLoggerFactory, asyncTaskFactory);
transport.Initialize();
return(transport);
}
return(_queuesToDelete.GetOrAdd(inputQueueAddress, () =>
{
var transport = new BasicAzureServiceBusTransport(ConnectionString, inputQueueAddress, consoleLoggerFactory, asyncTaskFactory);
transport.PurgeInputQueue();
transport.Initialize();
return transport;
}));
}
static async Task Main()
{
Console.Title = "Samples.ASB.NativeIntegration";
#region EndpointName
var endpointConfiguration = new EndpointConfiguration("Samples.ASB.NativeIntegration");
#endregion
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
endpointConfiguration.Conventions().DefiningMessagesAs(type => type.Name == "NativeMessage");
var connectionString = Environment.GetEnvironmentVariable("AzureServiceBus_ConnectionString");
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new Exception("Could not read the 'AzureServiceBus_ConnectionString' environment variable. Check the sample prerequisites.");
}
var transport = new AzureServiceBusTransport(connectionString);
endpointConfiguration.UseTransport(transport);
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
public ITransport Create(string inputQueueAddress)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
if (inputQueueAddress == null)
{
var transport = new AzureServiceBusTransport(ConnectionString, null, consoleLoggerFactory, asyncTaskFactory);
transport.Initialize();
return transport;
}
return _queuesToDelete.GetOrAdd(inputQueueAddress, () =>
{
var transport = new AzureServiceBusTransport(ConnectionString, inputQueueAddress, consoleLoggerFactory, asyncTaskFactory);
transport.PurgeInputQueue();
transport.Initialize();
return transport;
});
}
static async Task Main()
{
Console.Title = "Samples.ASBS.SendReply.Endpoint2";
var endpointConfiguration = new EndpointConfiguration("Samples.ASBS.SendReply.Endpoint2");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
var connectionString = Environment.GetEnvironmentVariable("AzureServiceBus_ConnectionString");
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new Exception("Could not read the 'AzureServiceBus_ConnectionString' environment variable. Check the sample prerequisites.");
}
var transport = new AzureServiceBusTransport(connectionString);
endpointConfiguration.UseTransport(transport);
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
public MessagePump(
ServiceBusClient serviceBusClient,
ServiceBusAdministrationClient administrativeClient,
AzureServiceBusTransport transportSettings,
string receiveAddress,
ReceiveSettings receiveSettings,
Action <string, Exception, CancellationToken> criticalErrorAction,
NamespacePermissions namespacePermissions)
{
Id = receiveSettings.Id;
ReceiveAddress = receiveAddress;
this.serviceBusClient = serviceBusClient;
this.transportSettings = transportSettings;
this.receiveSettings = receiveSettings;
this.criticalErrorAction = criticalErrorAction;
if (receiveSettings.UsePublishSubscribe)
{
Subscriptions = new SubscriptionManager(
ReceiveAddress,
transportSettings,
administrativeClient,
namespacePermissions);
}
}
protected override void SetUp()
{
_transport = new AzureServiceBusTransport(ConnectionString, QueueName, _consoleLoggerFactory, new TplAsyncTaskFactory(_consoleLoggerFactory), new DefaultNameFormatter());
Using(_transport);
_transport.Initialize();
_transport.PurgeInputQueue();
_activator = new BuiltinHandlerActivator();
_busStarter = Configure.With(_activator)
.Logging(l => l.Use(new ListLoggerFactory(outputToConsole: true, detailed: true)))
.Transport(t => t.UseAzureServiceBus(ConnectionString, QueueName).AutomaticallyRenewPeekLock())
.Options(o =>
{
o.SetNumberOfWorkers(1);
o.SetMaxParallelism(1);
})
.Create();
_bus = _busStarter.Bus;
Using(_bus);
}
public ServerlessTransport(AzureServiceBusTransport baseTransport) : base(
baseTransport.TransportTransactionMode,
baseTransport.SupportsDelayedDelivery,
baseTransport.SupportsPublishSubscribe,
baseTransport.SupportsTTBR)
{
this.baseTransport = baseTransport;
}
static AzureServiceBusTransport GetTransport()
{
var transport = new AzureServiceBusTransport(AzureServiceBusTransportFactory.ConnectionString, QueueName);
transport.Initialize();
transport.PurgeInputQueue();
return(transport);
}
/// <summary>
/// Configures Rebus to use Azure Service Bus queues to transport messages, connecting to the service bus instance pointed to by the connection string
/// (or the connection string with the specified name from the current app.config)
/// </summary>
public static AzureServiceBusTransportSettings UseAzureServiceBus(this StandardConfigurer <ITransport> configurer, string connectionString, string inputQueueAddress, ITokenProvider tokenProvider = null)
{
var settingsBuilder = new AzureServiceBusTransportSettings();
// register the actual transport as itself
configurer
.OtherService <AzureServiceBusTransport>()
.Register(c =>
{
var nameFormatter = c.Get <INameFormatter>();
var cancellationToken = c.Get <CancellationToken>();
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
var asyncTaskFactory = c.Get <IAsyncTaskFactory>();
var transport = new AzureServiceBusTransport(
connectionString: connectionString,
queueName: inputQueueAddress,
rebusLoggerFactory: rebusLoggerFactory,
asyncTaskFactory: asyncTaskFactory,
nameFormatter: nameFormatter,
cancellationToken: cancellationToken,
tokenProvider: tokenProvider
);
if (settingsBuilder.PrefetchingEnabled)
{
transport.PrefetchMessages(settingsBuilder.NumberOfMessagesToPrefetch);
}
transport.AutomaticallyRenewPeekLock = settingsBuilder.AutomaticPeekLockRenewalEnabled;
transport.PartitioningEnabled = settingsBuilder.PartitioningEnabled;
transport.DoNotCreateQueuesEnabled = settingsBuilder.DoNotCreateQueuesEnabled;
transport.DefaultMessageTimeToLive = settingsBuilder.DefaultMessageTimeToLive;
transport.DoNotCheckQueueConfigurationEnabled = settingsBuilder.DoNotCheckQueueConfigurationEnabled;
transport.LockDuration = settingsBuilder.LockDuration;
transport.AutoDeleteOnIdle = settingsBuilder.AutoDeleteOnIdle;
transport.DuplicateDetectionHistoryTimeWindow = settingsBuilder.DuplicateDetectionHistoryTimeWindow;
transport.ReceiveOperationTimeout = settingsBuilder.ReceiveOperationTimeout;
transport.MaximumMessagePayloadBytes = settingsBuilder.MaximumMessagePayloadBytes;
return(transport);
});
RegisterServices(configurer, () => settingsBuilder.LegacyNamingEnabled);
// remove deferred messages step
configurer.OtherService <IPipeline>().Decorate(c =>
{
var pipeline = c.Get <IPipeline>();
return(new PipelineStepRemover(pipeline)
.RemoveIncomingStep(s => s.GetType() == typeof(HandleDeferredMessagesStep)));
});
return(settingsBuilder);
}
public QueueCreator(
AzureServiceBusTransport transportSettings,
ServiceBusAdministrationClient administrativeClient,
NamespacePermissions namespacePermissions)
{
this.transportSettings = transportSettings;
this.administrativeClient = administrativeClient;
this.namespacePermissions = namespacePermissions;
maxSizeInMb = transportSettings.EntityMaximumSize * 1024;
}
protected override void SetUp()
{
_loggerFactory = new ListLoggerFactory(outputToConsole: false);
_deadletters = GetAsbTransport("error");
Using(_deadletters);
_deadletters.Initialize();
_deadletters.PurgeInputQueue();
}
protected override void SetUp()
{
var loggerFactory = new ConsoleLoggerFactory(false);
errorQueueTransport = new AzureServiceBusTransport(AsbTestConfig.ConnectionString, "error", loggerFactory, new TplAsyncTaskFactory(loggerFactory), new DefaultNameFormatter());
Using(errorQueueTransport);
errorQueueTransport.Initialize();
errorQueueTransport.PurgeInputQueue();
}
static void PurgeQueue(string queueName)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var connectionString = AsbTestConfig.ConnectionString;
using (var transport = new AzureServiceBusTransport(connectionString, queueName, consoleLoggerFactory, asyncTaskFactory, new DefaultNameFormatter()))
{
transport.PurgeInputQueue();
}
}
protected override void DoRun()
{
using (var transport = new AzureServiceBusTransport(GetConnectionString(ConnectionStringName), InputQueue, LoggerFactory, new TplAsyncTaskFactory(LoggerFactory)))
{
var returnToSourceQueue = new ReturnToSourceQueue(transport)
{
InputQueue = InputQueue,
DefaultOutputQueue = DefaultOutputQueue
};
returnToSourceQueue.Run();
}
}
public SubscriptionManager(
string subscribingQueue,
AzureServiceBusTransport transportSettings,
ServiceBusAdministrationClient administrativeClient,
NamespacePermissions namespacePermissions)
{
this.subscribingQueue = subscribingQueue;
this.transportSettings = transportSettings;
this.administrativeClient = administrativeClient;
this.namespacePermissions = namespacePermissions;
subscriptionName = transportSettings.SubscriptionNamingConvention(subscribingQueue);
}
public ITransport Create(string inputQueueAddress)
{
return _queuesToDelete.GetOrAdd(inputQueueAddress, () =>
{
var transport = new AzureServiceBusTransport(ConnectionString, inputQueueAddress);
transport.PurgeInputQueue();
transport.Initialize();
return transport;
});
}
public ITransport Create(string inputQueueAddress)
{
return(_queuesToDelete.GetOrAdd(inputQueueAddress, () =>
{
var transport = new AzureServiceBusTransport(ConnectionString, inputQueueAddress);
transport.PurgeInputQueue();
transport.Initialize();
return transport;
}));
}
static async Task Main()
{
Console.Title = "Samples.ASBS.SendReply.Endpoint1";
#region config
var endpointConfiguration = new EndpointConfiguration("Samples.ASBS.SendReply.Endpoint1");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
// var transport = endpointConfiguration.UseTransport<AzureServiceBusTransport>();
var connectionString = Environment.GetEnvironmentVariable("AzureServiceBus_ConnectionString");
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new Exception("Could not read the 'AzureServiceBus_ConnectionString' environment variable. Check the sample prerequisites.");
}
var transport = new AzureServiceBusTransport(connectionString);
endpointConfiguration.UseTransport(transport);
#endregion
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press 'enter' to send a message");
Console.WriteLine("Press any other key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
break;
}
var orderId = Guid.NewGuid();
var message = new Message1
{
Property = "Hello from Endpoint1"
};
await endpointInstance.Send("Samples.ASBS.SendReply.Endpoint2", message)
.ConfigureAwait(false);
Console.WriteLine("Message1 sent");
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
ITransport GetTransport()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var connectionString = StandardAzureServiceBusTransportFactory.ConnectionString;
var transport = new AzureServiceBusTransport(connectionString, _queueName, consoleLoggerFactory, asyncTaskFactory);
Using(transport);
transport.Initialize();
transport.PurgeInputQueue();
return(transport);
}
ITransport GetTransport()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var connectionString = AsbTestConfig.ConnectionString;
//var transport = new AzureServiceBusTransport(connectionString, _queueName, consoleLoggerFactory, asyncTaskFactory);
var transport = new AzureServiceBusTransport(connectionString, _queueName, consoleLoggerFactory, asyncTaskFactory, new AzureServiceBusNameHelper());
Using(transport);
transport.Initialize();
transport.PurgeInputQueue();
return(transport);
}
public void Should_log_a_deprecation_warning()
{
var transport = new AzureServiceBusTransport();
try
{
transport.Initialize(new SettingsHolder(), "connectionString");
}
catch
{
// ignored
}
StringAssert.Contains(AzureServiceBusTransport.DeprecationMessage, logStatements.ToString());
}
ITransport GetTransport()
{
if (_mode == AzureServiceBusMode.Basic)
{
var basicTransport = new BasicAzureServiceBusTransport(StandardAzureServiceBusTransportFactory.ConnectionString, _queueName, new ConsoleLoggerFactory(false));
basicTransport.Initialize();
basicTransport.PurgeInputQueue();
return(basicTransport);
}
var transport = new AzureServiceBusTransport(StandardAzureServiceBusTransportFactory.ConnectionString, _queueName, new ConsoleLoggerFactory(false));
Using(transport);
transport.Initialize();
transport.PurgeInputQueue();
return(transport);
}
static async Task Main()
{
Console.Title = "Samples.ASB.Publisher";
var endpointConfiguration = new EndpointConfiguration("Samples.ASB.Publisher");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
endpointConfiguration.Conventions().DefiningEventsAs(type => type.Name == nameof(EventTwo) || type.Name == nameof(EventOne));
var connectionString = Environment.GetEnvironmentVariable("AzureServiceBus_ConnectionString");
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new Exception("Could not read the 'AzureServiceBus_ConnectionString' environment variable. Check the sample prerequisites.");
}
var transport = new AzureServiceBusTransport(connectionString);
endpointConfiguration.UseTransport(transport);
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press any key to publish events");
Console.ReadKey();
Console.WriteLine();
await endpointInstance.Publish(new EventOne
{
Content = $"{nameof(EventOne)} sample content",
PublishedOnUtc = DateTime.UtcNow
});
await endpointInstance.Publish(new EventTwo
{
Content = $"{nameof(EventTwo)} sample content",
PublishedOnUtc = DateTime.UtcNow
});
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var connectionString = Environment.GetEnvironmentVariable("AzureServiceBus_ConnectionString");
var transport = new AzureServiceBusTransport(connectionString)
{
SubscriptionNamingConvention = name => Shorten(name),
SubscriptionRuleNamingConvention = eventType => Shorten(eventType.FullName)
};
configuration.UseTransport(transport);
configuration.RegisterComponents(c => c.AddSingleton <IMutateOutgoingTransportMessages, TestIndependenceMutator>());
configuration.Pipeline.Register("TestIndependenceBehavior", typeof(TestIndependenceSkipBehavior), "Skips messages not created during the current test.");
return(Task.CompletedTask);
}
public async Task <EndpointConfiguration> GetConfiguration(
RunDescriptor runDescriptor,
EndpointCustomizationConfiguration endpointConfiguration,
Func <EndpointConfiguration, Task> configurationBuilderCustomization)
{
var configuration = new EndpointConfiguration(endpointConfiguration.EndpointName);
configuration.TypesToIncludeInScan(endpointConfiguration.GetTypesScopedByTestClass());
configuration.EnableInstallers();
configuration.RegisterComponents(c => c
.AddSingleton(runDescriptor.ScenarioContext.GetType(), runDescriptor.ScenarioContext));
var recoverability = configuration.Recoverability();
recoverability.Delayed(delayed => delayed.NumberOfRetries(0));
recoverability.Immediate(immediate => immediate.NumberOfRetries(0));
configuration.SendFailedMessagesTo("error");
var connectionString =
Environment.GetEnvironmentVariable(ServiceBusTriggeredEndpointConfiguration
.DefaultServiceBusConnectionName);
var azureServiceBusTransport = new AzureServiceBusTransport(connectionString)
{
SubscriptionRuleNamingConvention = type =>
{
if (type.FullName.Length <= 50)
{
return(type.FullName);
}
return(type.Name);
}
};
var transport = configuration.UseTransport(azureServiceBusTransport);
configuration.Pipeline.Register("TestIndependenceBehavior", b => new TestIndependenceSkipBehavior(runDescriptor.ScenarioContext), "Skips messages not created during the current test.");
configuration.UseSerialization <NewtonsoftSerializer>();
await configurationBuilderCustomization(configuration);
return(configuration);
}
static void RegisterStandardTransport(StandardConfigurer <ITransport> configurer, string inputQueueAddress, string connectionString, AzureServiceBusTransportSettings settings)
{
// register the actual transport as itself
configurer
.OtherService <AzureServiceBusTransport>()
.Register(c =>
{
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
var asyncTaskFactory = c.Get <IAsyncTaskFactory>();
var transport = new AzureServiceBusTransport(connectionString, inputQueueAddress, rebusLoggerFactory, asyncTaskFactory);
if (settings.PrefetchingEnabled)
{
transport.PrefetchMessages(settings.NumberOfMessagesToPrefetch);
}
transport.AutomaticallyRenewPeekLock = settings.AutomaticPeekLockRenewalEnabled;
transport.PartitioningEnabled = settings.PartitioningEnabled;
transport.DoNotCreateQueuesEnabled = settings.DoNotCreateQueuesEnabled;
return(transport);
});
// map subscription storage to transport
configurer
.OtherService <ISubscriptionStorage>()
.Register(c => c.Get <AzureServiceBusTransport>(), description: AsbSubStorageText);
// map ITransport to transport
configurer.Register(c => c.Get <AzureServiceBusTransport>());
// remove deferred messages step
configurer.OtherService <IPipeline>().Decorate(c =>
{
var pipeline = c.Get <IPipeline>();
return(new PipelineStepRemover(pipeline)
.RemoveIncomingStep(s => s.GetType() == typeof(HandleDeferredMessagesStep)));
});
// disable timeout manager
configurer.OtherService <ITimeoutManager>()
.Register(c => new DisabledTimeoutManager(), description: AsbTimeoutManagerText);
}
protected override void SetUp()
{
_transport = new AzureServiceBusTransport(StandardAzureServiceBusTransportFactory.ConnectionString, QueueName, new ConsoleLoggerFactory(false));
_transport.PurgeInputQueue();
_activator = new BuiltinHandlerActivator();
_bus = Configure.With(_activator)
.Transport(t => t.UseAzureServiceBus(StandardAzureServiceBusTransportFactory.ConnectionString, QueueName, _azureServiceBusMode)
.AutomaticallyRenewPeekLock())
.Options(o =>
{
o.SetNumberOfWorkers(1);
o.SetMaxParallelism(1);
})
.Start();
Using(_bus);
}
Usage(EndpointConfiguration endpointConfiguration)
{
#region azure-service-bus-for-dotnet-standard
var transport = new AzureServiceBusTransport("Endpoint=sb://[NAMESPACE].servicebus.windows.net/;SharedAccessKeyName=[KEYNAME];SharedAccessKey=[KEY]");
endpointConfiguration.UseTransport(transport);
#endregion
#region custom-prefetch-multiplier
transport.PrefetchMultiplier = 3;
#endregion
#region custom-prefetch-count
transport.PrefetchCount = 100;
#endregion
#region asb-sanitization-compatibility
string HashName(string input)
{
var inputBytes = Encoding.Default.GetBytes(input);
// use MD5 hash to get a 16-byte hash of the string
using (var provider = new MD5CryptoServiceProvider())
{
var hashBytes = provider.ComputeHash(inputBytes);
return(new Guid(hashBytes).ToString());
}
}
const int MaxEntityName = 50;
transport.SubscriptionNamingConvention = n => n.Length > MaxEntityName?HashName(n) : n;
transport.SubscriptionRuleNamingConvention = n => n.FullName.Length > MaxEntityName?HashName(n.FullName) : n.FullName;
#endregion
}
protected override void SetUp()
{
_transport = new AzureServiceBusTransport(AzureServiceBusTransportFactory.ConnectionString, QueueName);
_transport.PurgeInputQueue();
_activator = new BuiltinHandlerActivator();
_bus = Configure.With(_activator)
.Transport(t => t.UseAzureServiceBus(AzureServiceBusTransportFactory.ConnectionString, QueueName)
.AutomaticallyRenewPeekLock())
.Options(o =>
{
o.SetNumberOfWorkers(1);
o.SetMaxParallelism(1);
})
.Start();
Using(_bus);
}
/// <summary>
/// Configures Rebus to use Azure Service Bus to transport messages as a one-way client (i.e. will not be able to receive any messages)
/// </summary>
public static AzureServiceBusTransportClientSettings UseAzureServiceBusAsOneWayClient(this StandardConfigurer <ITransport> configurer, string connectionString, ITokenProvider tokenProvider = null)
{
var settingsBuilder = new AzureServiceBusTransportClientSettings();
configurer.OtherService <Options>().Decorate(c =>
{
var options = c.Get <Options>();
options.ExternalTimeoutManagerAddressOrNull = AzureServiceBusTransport.MagicDeferredMessagesAddress;
return(options);
});
configurer
.OtherService <AzureServiceBusTransport>()
.Register(c =>
{
var cancellationToken = c.Get <CancellationToken>();
var rebusLoggerFactory = c.Get <IRebusLoggerFactory>();
var asyncTaskFactory = c.Get <IAsyncTaskFactory>();
var nameFormatter = c.Get <INameFormatter>();
var transport = new AzureServiceBusTransport(
connectionString: connectionString,
queueName: null,
rebusLoggerFactory: rebusLoggerFactory,
asyncTaskFactory: asyncTaskFactory,
nameFormatter: nameFormatter,
cancellationToken: cancellationToken,
tokenProvider: tokenProvider
);
transport.MaximumMessagePayloadBytes = settingsBuilder.MaximumMessagePayloadBytes;
return(transport);
});
RegisterServices(configurer, () => settingsBuilder.LegacyNamingEnabled);
OneWayClientBackdoor.ConfigureOneWayClient(configurer);
return(settingsBuilder);
}
public ITransport Create(string inputQueueAddress)
{
if (inputQueueAddress == null)
{
var transport = new AzureServiceBusTransport(ConnectionString, null, new ConsoleLoggerFactory(false));
transport.Initialize();
return transport;
}
return _queuesToDelete.GetOrAdd(inputQueueAddress, () =>
{
var transport = new BasicAzureServiceBusTransport(ConnectionString, inputQueueAddress, new ConsoleLoggerFactory(false));
transport.PurgeInputQueue();
transport.Initialize();
return transport;
});
}
ITransport GetTransport()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var connectionString = StandardAzureServiceBusTransportFactory.ConnectionString;
var busLifetimeEvents = new BusLifetimeEvents();
if (_mode == AzureServiceBusMode.Basic)
{
var basicTransport = new BasicAzureServiceBusTransport(connectionString, _queueName, consoleLoggerFactory, asyncTaskFactory, busLifetimeEvents);
Using(basicTransport);
basicTransport.Initialize();
basicTransport.PurgeInputQueue();
return basicTransport;
}
var transport = new AzureServiceBusTransport(connectionString, _queueName, consoleLoggerFactory, asyncTaskFactory, busLifetimeEvents);
Using(transport);
transport.Initialize();
transport.PurgeInputQueue();
return transport;
}
static AzureServiceBusTransport GetTransport()
{
var transport = new AzureServiceBusTransport(AzureServiceBusTransportFactory.ConnectionString, QueueName);
transport.Initialize();
transport.PurgeInputQueue();
return transport;
}
ITransport GetTransport()
{
if (_mode == AzureServiceBusMode.Basic)
{
var basicTransport = new BasicAzureServiceBusTransport(StandardAzureServiceBusTransportFactory.ConnectionString, _queueName, new ConsoleLoggerFactory(false));
basicTransport.Initialize();
basicTransport.PurgeInputQueue();
return basicTransport;
}
var transport = new AzureServiceBusTransport(StandardAzureServiceBusTransportFactory.ConnectionString, _queueName, new ConsoleLoggerFactory(false));
Using(transport);
transport.Initialize();
transport.PurgeInputQueue();
return transport;
}
public async void ShouldBeAbleToRecieveEvenWhenNotCreatingQueue(AzureServiceBusMode mode)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var transport = new AzureServiceBusTransport(StandardAzureServiceBusTransportFactory.ConnectionString, QueueName, consoleLoggerFactory, new TplAsyncTaskFactory(consoleLoggerFactory), new BusLifetimeEvents());
transport.PurgeInputQueue();
//Create the queue for the receiver since it cannot create it self beacuse of lacking rights on the namespace
transport.CreateQueue(QueueName);
var recieverActivator = new BuiltinHandlerActivator();
var senderActivator = new BuiltinHandlerActivator();
var receiverBus = Configure.With(recieverActivator)
.Logging(l => l.ColoredConsole())
.Transport(t =>
t.UseAzureServiceBus(StandardAzureServiceBusTransportFactory.ConnectionString, QueueName)
.DoNotCreateQueues())
.Start();
var senderBus = Configure.With(senderActivator)
.Transport(t => t.UseAzureServiceBus(StandardAzureServiceBusTransportFactory.ConnectionString, "sender", mode))
.Start();
Using(receiverBus);
Using(senderBus);
var gotMessage = new ManualResetEvent(false);
recieverActivator.Handle<string>(async (bus, context, message) =>
{
gotMessage.Set();
Console.WriteLine("got message in readonly mode");
});
await senderBus.Advanced.Routing.Send(QueueName, "message to receiver");
gotMessage.WaitOrDie(TimeSpan.FromSeconds(10));
}
public async void DoesntIgnoreDefinedTimeoutWhenReceiving(AzureServiceBusMode mode, int operationTimeoutInSeconds)
{
var operationTimeout = TimeSpan.FromSeconds(operationTimeoutInSeconds);
var connString = StandardAzureServiceBusTransportFactory.ConnectionString;
var builder = new ServiceBusConnectionStringBuilder(connString)
{
OperationTimeout = operationTimeout
};
var newConnString = builder.ToString();
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var transport = new AzureServiceBusTransport(newConnString, QueueName, consoleLoggerFactory, new TplAsyncTaskFactory(consoleLoggerFactory), new BusLifetimeEvents());
Using(transport);
transport.PurgeInputQueue();
//Create the queue for the receiver since it cannot create it self beacuse of lacking rights on the namespace
transport.CreateQueue(QueueName);
var senderActivator = new BuiltinHandlerActivator();
var senderBus = Configure.With(senderActivator)
.Transport(t => t.UseAzureServiceBus(newConnString, "sender", mode))
.Start();
Using(senderBus);
// queue 3 messages
await senderBus.Advanced.Routing.Send(QueueName, "message to receiver");
await senderBus.Advanced.Routing.Send(QueueName, "message to receiver2");
await senderBus.Advanced.Routing.Send(QueueName, "message to receiver3");
await Task.Delay(TimeSpan.FromSeconds(2)); // wait a bit to make sure the messages are queued.
// receive 1
using (var transactionContext = new DefaultTransactionContext())
{
var sw = System.Diagnostics.Stopwatch.StartNew();
var msg = await transport.Receive(transactionContext);
sw.Stop();
await transactionContext.Complete();
msg.Should().NotBeNull();
sw.Elapsed.Should().BeLessThan(TimeSpan.FromMilliseconds(1500));
}
// receive 2
using (var transactionContext = new DefaultTransactionContext())
{
var sw = System.Diagnostics.Stopwatch.StartNew();
var msg = await transport.Receive(transactionContext);
sw.Stop();
await transactionContext.Complete();
msg.Should().NotBeNull();
sw.Elapsed.Should().BeLessThan(TimeSpan.FromMilliseconds(1500));
}
// receive 3
using (var transactionContext = new DefaultTransactionContext())
{
var sw = System.Diagnostics.Stopwatch.StartNew();
var msg = await transport.Receive(transactionContext);
sw.Stop();
await transactionContext.Complete();
msg.Should().NotBeNull();
sw.Elapsed.Should().BeLessThan(TimeSpan.FromMilliseconds(1500));
}
// receive 4 - NOTHING
using (var transactionContext = new DefaultTransactionContext())
{
var sw = System.Diagnostics.Stopwatch.StartNew();
var msg = await transport.Receive(transactionContext);
sw.Stop();
await transactionContext.Complete();
msg.Should().BeNull();
sw.Elapsed.Should().BeCloseTo(operationTimeout, 2000);
}
// put 1 more message
await senderBus.Advanced.Routing.Send(QueueName, "message to receiver5");
await Task.Delay(TimeSpan.FromSeconds(2)); // wait a bit to make sure the messages are queued.
// receive 5
using (var transactionContext = new DefaultTransactionContext())
{
var sw = System.Diagnostics.Stopwatch.StartNew();
var msg = await transport.Receive(transactionContext);
sw.Stop();
await transactionContext.Complete();
msg.Should().NotBeNull();
sw.Elapsed.Should().BeLessThan(TimeSpan.FromMilliseconds(1500));
}
// receive 6 - NOTHING
using (var transactionContext = new DefaultTransactionContext())
{
var sw = System.Diagnostics.Stopwatch.StartNew();
var msg = await transport.Receive(transactionContext);
sw.Stop();
await transactionContext.Complete();
msg.Should().BeNull();
sw.Elapsed.Should().BeCloseTo(operationTimeout, 2000);
}
}
