#pragma warning disable PS0018 // A task-returning method should have a CancellationToken parameter unless it has a parameter implementing ICancellableContext
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
#pragma warning restore PS0018 // A task-returning method should have a CancellationToken parameter unless it has a parameter implementing ICancellableContext
{
if (transport == null)
{
var errorQueue = configuration.GetEndpointDefinedErrorQueue();
var connectionString = Utilities.GetEnvConfiguredConnectionString();
transport = Utilities.CreateTransportWithDefaultTestsConfiguration(connectionString, delayedDeliveryPoisonQueue: errorQueue);
}
transport.Subscriptions.DisableCaching = true;
var routingConfig = configuration.UseTransport(transport);
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
routingConfig.RegisterPublisher(eventType, publisher.PublisherName);
}
}
if (endpointName.StartsWith("RegisteringAdditionalDeserializers.CustomSerializationSender"))
{
Assert.Ignore("Ignored since this scenario is not supported by ASQ.");
}
configuration.UseSerialization <XmlSerializer>();
configuration.Pipeline.Register("test-independence-skip", typeof(TestIndependence.SkipBehavior), "Skips messages from other runs");
configuration.Pipeline.Register("test-independence-stamp", typeof(TestIndependence.StampOutgoingBehavior), "Stamps outgoing messages from this run");
return(Task.CompletedTask);
}
static async Task Main()
{
var endpointName = "Samples-Azure-StorageQueues-Endpoint2";
Console.Title = endpointName;
var endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
endpointConfiguration.EnableInstallers();
var transport = new AzureStorageQueueTransport("UseDevelopmentStorage=true", useNativeDelayedDeliveries: false)
{
QueueNameSanitizer = BackwardsCompatibleQueueNameSanitizer.WithMd5Shortener
};
var routingSettings = endpointConfiguration.UseTransport(transport);
routingSettings.DisablePublishing();
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.SendFailedMessagesTo("error");
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
static async Task Main()
{
#region endpointName
var endpointName = "Samples.Azure.StorageQueues.Endpoint1.With.A.Very.Long.Name.And.Invalid.Characters";
var endpointConfiguration = new EndpointConfiguration(endpointName);
#endregion
Console.Title = endpointName;
#region config
var transport = new AzureStorageQueueTransport("UseDevelopmentStorage=true");
var routingSettings = endpointConfiguration.UseTransport(transport);
#endregion
#region sanitization
transport.QueueNameSanitizer = BackwardsCompatibleQueueNameSanitizer.WithMd5Shortener;
#endregion
routingSettings.DisablePublishing();
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.SendFailedMessagesTo("error");
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 message = new Message1
{
Property = "Hello from Endpoint1"
};
await endpointInstance.Send("Samples-Azure-StorageQueues-Endpoint2", message)
.ConfigureAwait(false);
Console.WriteLine("Message1 sent");
}
await endpointInstance.Stop()
.ConfigureAwait(false);
}
void ConfigureCaching(EndpointConfiguration configuration)
{
#region storage_account_configure_subscription_caching
var transport = new AzureStorageQueueTransport("connectionString");
transport.Subscriptions.CacheInvalidationPeriod = TimeSpan.FromSeconds(10);
#endregion
}
public CustomizedServer(bool supportsNativeDelayedDelivery = true, bool supportsPublishSubscribe = true)
{
var transport = new AzureStorageQueueTransport(Utilities.GetEnvConfiguredConnectionString(),
supportsNativeDelayedDelivery, supportsPublishSubscribe);
Utilities.SetTransportDefaultTestsConfiguration(transport);
TransportConfiguration = new ConfigureEndpointAzureStorageQueueTransport(transport);
}
static MessageWrapperSerializer BuildSerializer(ReadOnlySettings settings)
{
if (settings.TryGet <SerializationDefinition>(WellKnownConfigurationKeys.MessageWrapperSerializationDefinition, out var wrapperSerializer))
{
return(new MessageWrapperSerializer(wrapperSerializer.Configure(settings)(MessageWrapperSerializer.GetMapper())));
}
return(new MessageWrapperSerializer(AzureStorageQueueTransport.GetMainSerializer(MessageWrapperSerializer.GetMapper(), settings)));
}
void DisableCaching(EndpointConfiguration configuration)
{
#region storage_account_disable_subscription_caching
var transport = new AzureStorageQueueTransport("connectionString");
transport.Subscriptions.DisableCaching = true;
#endregion
}
public void DisableDelayedDelivery(EndpointConfiguration endpointConfiguration)
{
#region delayed-delivery-disabled
var transport = new AzureStorageQueueTransport("connection string", useNativeDelayedDeliveries: false);
endpointConfiguration.UseTransport(transport);
#endregion
}
void SetSubscriptionTableName(EndpointConfiguration configuration)
{
#region storage_account_subscription_table_name
var transport = new AzureStorageQueueTransport("connectionString");
transport.Subscriptions.SubscriptionTableName = "NewName";
#endregion
}
void UseTransport(EndpointConfiguration endpointConfiguration)
{
#region AzureStorageQueueTransportWithAzure
var transport = new AzureStorageQueueTransport("DefaultEndpointsProtocol=https;AccountName=[ACCOUNT];AccountKey=[KEY];");
endpointConfiguration.UseTransport(transport);
#endregion
}
public void DelayedDeliveryNameOverride(EndpointConfiguration endpointConfiguration)
{
#region delayed-delivery-override-name
var transport = new AzureStorageQueueTransport("connection string");
transport.DelayedDelivery.DelayedDeliveryTableName = "myendpoint";
endpointConfiguration.UseTransport(transport);
#endregion
}
public void Should_throw_exception_when_no_serializer_was_set()
{
var exception = Assert.Throws <Exception>(() =>
{
var settings = new SettingsHolder();
var messageMapper = MessageWrapperSerializer.GetMapper();
AzureStorageQueueTransport.GetMainSerializerHack(messageMapper, settings);
});
Assert.IsTrue(exception.Message.StartsWith("No serializer defined. If the transport is used in combination with NServiceBus, use 'endpointConfiguration.UseSerialization<T>();' to select a serializer."), $"Incorrect exception message: {exception.Message}");
}
public ErrorSpy()
{
var transport = new AzureStorageQueueTransport(Utilities.GetEnvConfiguredConnectionString(), useNativeDelayedDeliveries: false)
{
QueueNameSanitizer = BackwardsCompatibleQueueNameSanitizerForTests.Sanitize
};
EndpointSetup(new CustomizedServer(transport), (config, rd) =>
{
config.UseSerialization <NewtonsoftSerializer>();
});
}
void SanitizeWithMd5BackwardsCompatible(EndpointConfiguration endpointConfiguration)
{
#region azure-storage-queue-backwards-compatible-sanitization-with-md5
var transport = new AzureStorageQueueTransport("connection string")
{
QueueNameSanitizer = BackwardsCompatibleQueueNameSanitizer.WithMd5Shortener
};
endpointConfiguration.UseTransport(transport);
#endregion
}
void CustomSanitization(EndpointConfiguration endpointConfiguration)
{
#region azure-storage-queue-sanitization
var transport = new AzureStorageQueueTransport("connection string")
{
QueueNameSanitizer = queueName => queueName.Replace('.', '-')
};
endpointConfiguration.UseTransport(transport);
#endregion
}
public ReceiverUsingMappedConnectionStrings()
{
var transport = new AzureStorageQueueTransport(Utilities.GetEnvConfiguredConnectionString2(), useNativeDelayedDeliveries: false);
EndpointSetup(new CustomizedServer(transport), (cfg, runDescriptor) =>
{
cfg.UseSerialization <NewtonsoftSerializer>();
cfg.AuditProcessedMessagesTo(AuditName);
transport.AccountRouting.DefaultAccountAlias = AnotherConnectionStringName;
transport.AccountRouting.AddAccount(DefaultConnectionStringName, new QueueServiceClient(Utilities.GetEnvConfiguredConnectionString()), CloudStorageAccount.Parse(Utilities.GetEnvConfiguredConnectionString()).CreateCloudTableClient());
});
CustomEndpointName(ReceiverName);
}
void RegisterEndpoint(EndpointConfiguration configuration)
{
#pragma warning disable CS0618
#region storage_account_routing_registered_endpoint
var transport = new AzureStorageQueueTransport("connectionString");
var anotherAccount = transport.AccountRouting.AddAccount("AnotherAccountName", "anotherConnectionString");
anotherAccount.AddEndpoint("Receiver");
var routingConfig = configuration.UseTransport(transport);
routingConfig.RouteToEndpoint(typeof(MyMessage), "Receiver");
#endregion
#pragma warning restore CS0618
}
void MultipleAccountAliasesInsteadOfConnectionStrings1(EndpointConfiguration endpointConfiguration)
{
#pragma warning disable CS0618
#region AzureStorageQueueUseMultipleAccountAliasesInsteadOfConnectionStrings1
var transport = new AzureStorageQueueTransport("account_A_connection_string");
var accountRouting = transport.AccountRouting;
accountRouting.DefaultAccountAlias = "account_A";
accountRouting.AddAccount("account_B", "account_B_connection_string");
endpointConfiguration.UseTransport(transport);
#endregion
#pragma warning restore CS0618
}
MessageWrapperSerializer(EndpointConfiguration endpointConfiguration)
{
#region SerializerAndMessageWrapperSerializer
// serialize the messages using the XML serializer:
endpointConfiguration.UseSerialization <XmlSerializer>();
var transport = new AzureStorageQueueTransport("connection string")
{
// wrap messages in JSON
MessageWrapperSerializationDefinition = new NewtonsoftSerializer()
};
endpointConfiguration.UseTransport(transport);
#endregion
}
void RegisterSubscriber(EndpointConfiguration configuration)
{
#pragma warning disable CS0618
#region storage_account_routing_registered_subscriber
var transport = new AzureStorageQueueTransport("anotherConnectionString");
transport.AccountRouting.DefaultAccountAlias = "publisher";
var anotherAccount = transport.AccountRouting.AddAccount("subscriber", "connectionString");
anotherAccount.AddEndpoint("Subscriber1");
configuration.UseTransport(transport);
#endregion
#pragma warning restore CS0618
}
void RegisterPublisher(EndpointConfiguration configuration)
{
#pragma warning disable CS0618
#region storage_account_routing_registered_publisher
var transport = new AzureStorageQueueTransport("connectionString");
transport.AccountRouting.DefaultAccountAlias = "subscriber";
var anotherAccount = transport.AccountRouting.AddAccount("publisher", "anotherConnectionString");
anotherAccount.AddEndpoint("Publisher1", new[] { typeof(MyEvent) }, "optionalSubscriptionTableName");
configuration.UseTransport(transport);
#endregion
#pragma warning restore CS0618
}
static async Task Main()
{
var endpointName = "native-integration-asq";
Console.Title = endpointName;
var endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
endpointConfiguration.EnableInstallers();
var transport = new AzureStorageQueueTransport("UseDevelopmentStorage=true", useNativeDelayedDeliveries: false);
var routingSettings = endpointConfiguration.UseTransport(transport);
routingSettings.DisablePublishing();
#region Native-message-mapping
transport.MessageUnwrapper = message => new MessageWrapper
{
Id = message.MessageId,
Body = message.Body.ToArray(),
Headers = new Dictionary <string, string>
{
{ Headers.EnclosedMessageTypes, typeof(NativeMessage).FullName }
}
};
#endregion
endpointConfiguration.Recoverability().Delayed(settings => settings.NumberOfRetries(0));
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.SendFailedMessagesTo("error");
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
public void Should_not_throw_exception_when_serializer_was_set()
{
var settings = new SettingsHolder();
const BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance;
var conventions = settings.GetOrCreate <Conventions>();
var registry = (MessageMetadataRegistry)Activator.CreateInstance(typeof(MessageMetadataRegistry), flags, null, new object[] { new Func <Type, bool>(t => conventions.IsMessageType(t)) }, CultureInfo.InvariantCulture);
settings.Set(registry);
settings.Set(AzureStorageQueueTransport.SerializerSettingsKey, Tuple.Create <SerializationDefinition, SettingsHolder>(new XmlSerializer(), settings));
Assert.DoesNotThrow(() =>
{
var messageMapper = MessageWrapperSerializer.GetMapper();
AzureStorageQueueTransport.GetMainSerializerHack(messageMapper, settings);
});
}
public TransportDefinition CreateTransportDefinition()
{
LogManager.UseFactory(new ConsoleLoggerFactory());
var connectionStringEnvVarName = "AzureStorageQueueTransport_ConnectionString";
var connectionString = Environment.GetEnvironmentVariable(connectionStringEnvVarName);
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new Exception(
$"Connection string is required for Acceptance tests. Set it in an environment variable named '{connectionStringEnvVarName}'");
}
var transport = new AzureStorageQueueTransport(connectionString)
{
MessageWrapperSerializationDefinition = new XmlSerializer(),
QueueNameSanitizer = BackwardsCompatibleQueueNameSanitizerForTests.Sanitize,
Subscriptions = { DisableCaching = true }
};
return(transport);
}
void CodeOnly(EndpointConfiguration endpointConfiguration)
{
var queueServiceClient = new QueueServiceClient("connectionString", new QueueClientOptions());
var blobServiceClient = new BlobServiceClient("connectionString", new BlobClientOptions());
var cloudStorageAccount = CloudStorageAccount.Parse("connectionString");
var cloudTableClient = cloudStorageAccount.CreateCloudTableClient();
#region AzureStorageQueueConfigCodeOnly
var transport = new AzureStorageQueueTransport(queueServiceClient, blobServiceClient, cloudTableClient)
{
ReceiverBatchSize = 20,
MaximumWaitTimeWhenIdle = TimeSpan.FromSeconds(1),
DegreeOfReceiveParallelism = 16,
PeekInterval = TimeSpan.FromMilliseconds(100),
MessageInvisibleTime = TimeSpan.FromSeconds(30)
};
endpointConfiguration.UseTransport(transport);
#endregion
}
CustomEnvelopeUnwrapper(EndpointConfiguration endpointConfiguration)
{
#region CustomEnvelopeUnwrapper
var transport = new AzureStorageQueueTransport("connection string")
{
MessageUnwrapper = queueMessage =>
{
using (var stream = new MemoryStream(Convert.FromBase64String(queueMessage.MessageText)))
using (var streamReader = new StreamReader(stream))
using (var textReader = new JsonTextReader(streamReader))
{
//try deserialize to a NServiceBus envelope first
var wrapper = jsonSerializer.Deserialize <MessageWrapper>(textReader);
if (wrapper.Id != null)
{
//this was a envelope message
return(wrapper);
}
//this was a native message just return the body as is with no headers
return(new MessageWrapper
{
Id = queueMessage.MessageId,
Headers = new Dictionary <string, string>(),
Body = Convert.FromBase64String(queueMessage.MessageText)
});
}
}
};
endpointConfiguration.UseTransport(transport);
#endregion
}
public ConfigureEndpointAzureStorageQueueTransport(AzureStorageQueueTransport transport)
{
this.transport = transport;
}
public void Customize(EndpointConfiguration endpointConfiguration)
{
var transport = new AzureStorageQueueTransport("DefaultEndpointsProtocol=https;AccountName=[ACCOUNT];AccountKey=[KEY];");
endpointConfiguration.UseTransport(transport);
}
public static AzureStorageQueueTransport CreateTransportWithDefaultTestsConfiguration(string connectionString, string delayedDeliveryPoisonQueue = null)
{
var transport = new AzureStorageQueueTransport(connectionString);
return(SetTransportDefaultTestsConfiguration(transport, delayedDeliveryPoisonQueue));
}
public static AzureStorageQueueTransport SetTransportDefaultTestsConfiguration(AzureStorageQueueTransport transport, string delayedDeliveryPoisonQueue = null)
{
transport.MessageInvisibleTime = TimeSpan.FromSeconds(30);
transport.MessageWrapperSerializationDefinition = new TestIndependence.TestIdAppendingSerializationDefinition <NewtonsoftSerializer>();
transport.QueueNameSanitizer = BackwardsCompatibleQueueNameSanitizerForTests.Sanitize;
if (delayedDeliveryPoisonQueue != null)
{
transport.DelayedDelivery.DelayedDeliveryPoisonQueue = delayedDeliveryPoisonQueue;
}
return(transport);
}
