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