public async void Should_Support_NetMessaging_Protocol() { ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings(); Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build", "MassTransit.AzureServiceBusTransport.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; }); h.TransportType = TransportType.NetMessaging; h.OperationTimeout = TimeSpan.FromSeconds(30); h.BatchFlushInterval = TimeSpan.FromMilliseconds(50); }); x.ReceiveEndpoint(host, "input_queue", e => { e.PrefetchCount = 16; e.UseLog(Console.Out, async (c, l) => string.Format("Logging: {0}", c.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(Retry.Interval(5, 100)); }); }); }); // TODO: Assert something here, need to get a hook to the underlying MessageReceiver using (bus.Start()) { } // })) // { // var queueAddress = new Uri(hostAddress, "input_queue"); // ISendEndpoint endpoint = bus.GetSendEndpoint(queueAddress); // // await endpoint.Send(new A()); // } }
public async Task Should_support_the_new_syntax() { ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings(); var serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build", "MassTransit.AzureServiceBusTransport.Tests"); var completed = new TaskCompletionSource<A>(); var bus = Bus.Factory.CreateUsingAzureServiceBus(x => { var 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(Retry.Interval(5, 100)); }); }); }); var 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 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 = 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 async Task Should_be_configured_and_working() { var settings = new TestAzureServiceBusAccountSettings(); var provider = new SharedAccessKeyTokenProvider(settings); var tokenProvider = provider.GetTokenProvider(); var namespaceSettings = new NamespaceManagerSettings { TokenProvider = tokenProvider }; var serviceUri = AzureServiceBusEndpointUriCreator.Create( Configuration.ServiceNamespace, "MassTransit.Azure.ServiceBus.Core.Tests" ); var namespaceManager = new NamespaceManager(serviceUri, namespaceSettings); await CreateQueue(namespaceManager, serviceUri, "TestClient"); await CreateHostQueue(tokenProvider); var mfs = new MessagingFactorySettings { TokenProvider = tokenProvider, OperationTimeout = TimeSpan.FromSeconds(30), TransportType = TransportType.Amqp }; var factory = MessagingFactory.Create(serviceUri, mfs); var receiver = factory.CreateQueueClient("Control"); receiver.PrefetchCount = 100; var done = TaskUtil.GetTask <bool>(); var count = 0; const int limit = 1000; receiver.RegisterMessageHandler(async(message, cancellationToken) => { await receiver.CompleteAsync(message.SystemProperties.LockToken); var received = Interlocked.Increment(ref count); if (received == limit) { done.TrySetResult(true); } }, new MessageHandlerOptions(ExceptionReceivedHandler) { AutoComplete = false, MaxConcurrentCalls = 100, MaxAutoRenewDuration = TimeSpan.FromSeconds(60) }); var client = factory.CreateMessageSender("Control"); var stopwatch = Stopwatch.StartNew(); var tasks = new Task[limit]; for (var i = 0; i < limit; i++) { tasks[i] = SendAMessage(client); } await done.Task; stopwatch.Stop(); await Task.WhenAll(tasks); await receiver.CloseAsync(); Console.WriteLine("Performance: {0:F2}/s", limit * 1000 / stopwatch.ElapsedMilliseconds); }
public async Task Should_be_configured_and_working() { var settings = new TestAzureServiceBusAccountSettings(); var provider = new SharedAccessKeyTokenProvider(settings); TokenProvider tokenProvider = provider.GetTokenProvider(); Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build", "MassTransit.AzureServiceBusTransport.Tests"); var namespaceManager = new NamespaceManager(serviceUri, tokenProvider); CreateQueue(namespaceManager, serviceUri, "TestClient"); CreateHostQueue(tokenProvider); var mfs = new MessagingFactorySettings { TokenProvider = tokenProvider, OperationTimeout = TimeSpan.FromSeconds(30), TransportType = TransportType.Amqp, AmqpTransportSettings = new AmqpTransportSettings { BatchFlushInterval = TimeSpan.FromMilliseconds(50), }, }; MessagingFactory factory = MessagingFactory.Create( ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build", Environment.MachineName), mfs); MessageReceiver receiver = await factory.CreateMessageReceiverAsync("Control"); receiver.PrefetchCount = 100; var done = new TaskCompletionSource<bool>(); int count = 0; const int limit = 1000; receiver.OnMessageAsync(async message => { var receiveContext = new ServiceBusReceiveContext(new Uri("sb://localhost/queue"), message, new ReceiveObservable()); await message.CompleteAsync(); int received = Interlocked.Increment(ref count); if (received == limit) done.TrySetResult(true); }, new OnMessageOptions { AutoComplete = false, MaxConcurrentCalls = 100, AutoRenewTimeout = TimeSpan.FromSeconds(60), }); MessageSender client = await factory.CreateMessageSenderAsync("Control"); Stopwatch stopwatch = Stopwatch.StartNew(); Task[] tasks = new Task[limit]; for (int i = 0; i < limit; i++) { tasks[i] = SendAMessage(client); } await done.Task; stopwatch.Stop(); await Task.WhenAll(tasks); await receiver.CloseAsync(); Console.WriteLine("Performance: {0:F2}/s", limit * 1000 / stopwatch.ElapsedMilliseconds); }
public async void Should_be_configured_and_working() { var settings = new TestAzureServiceBusAccountSettings(); var provider = new SharedAccessKeyTokenProvider(settings); TokenProvider tokenProvider = provider.GetTokenProvider(); Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build", "MassTransit.AzureServiceBusTransport.Tests"); var namespaceManager = new NamespaceManager(serviceUri, tokenProvider); CreateQueue(namespaceManager, serviceUri, "TestClient"); CreateHostQueue(tokenProvider); var mfs = new MessagingFactorySettings { TokenProvider = tokenProvider, OperationTimeout = TimeSpan.FromSeconds(30), TransportType = TransportType.Amqp, AmqpTransportSettings = new AmqpTransportSettings { BatchFlushInterval = TimeSpan.FromMilliseconds(50), }, }; MessagingFactory factory = MessagingFactory.Create( ServiceBusEnvironment.CreateServiceUri("sb", "masstransit-build", Environment.MachineName), mfs); MessageReceiver receiver = await factory.CreateMessageReceiverAsync("Control"); receiver.PrefetchCount = 100; var done = new TaskCompletionSource <bool>(); int count = 0; const int limit = 1000; receiver.OnMessageAsync(async message => { var receiveContext = new ServiceBusReceiveContext(new Uri("sb://localhost/queue"), message, new ReceiveObservable()); await message.CompleteAsync(); int received = Interlocked.Increment(ref count); if (received == limit) { done.TrySetResult(true); } }, new OnMessageOptions { AutoComplete = false, MaxConcurrentCalls = 100, AutoRenewTimeout = TimeSpan.FromSeconds(60), }); MessageSender client = await factory.CreateMessageSenderAsync("Control"); Stopwatch stopwatch = Stopwatch.StartNew(); Task[] tasks = new Task[limit]; for (int i = 0; i < limit; i++) { tasks[i] = SendAMessage(client); } await done.Task; stopwatch.Stop(); await Task.WhenAll(tasks); await receiver.CloseAsync(); Console.WriteLine("Performance: {0:F2}/s", limit * 1000 / stopwatch.ElapsedMilliseconds); }