#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); }