public async Task Should_not_create_bus_endpoint_queue_on_startup()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace);
var bus = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(serviceUri, h => h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
}));
});
var busHandle = await bus.StartAsync();
try
{
}
finally
{
await busHandle.StopAsync();
}
}
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 = 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;
});
});
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(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 AzureServiceBusTestFixture(string inputQueueName = null, Uri serviceUri = null, ServiceBusTokenProviderSettings settings = null)
: this(new AzureServiceBusTestHarness(
serviceUri ?? AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace, "MassTransit.Azure.ServiceBus.Core.Tests"),
settings?.KeyName ?? ((ServiceBusTokenProviderSettings) new TestAzureServiceBusAccountSettings()).KeyName,
settings?.SharedAccessKey ?? ((ServiceBusTokenProviderSettings) new TestAzureServiceBusAccountSettings()).SharedAccessKey,
inputQueueName))
{
}
public async Task Should_create_receive_endpoint_and_start()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
Uri serviceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace);
TaskCompletionSource <PingMessage> handled = new TaskCompletionSource <PingMessage>();
IBusControl bus = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(serviceUri, h =>
{
#if NET461
h.TransportType = TransportType.AmqpWebSockets;
#endif
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
x.ReceiveEndpoint("test-input-queue", e =>
{
e.Handler <PingMessage>(async context =>
{
handled.TrySetResult(context.Message);
});
});
});
BusHandle busHandle = await bus.StartAsync();
try
{
var endpoint = await bus.GetSendEndpoint(new Uri("queue:test-input-queue"));
await endpoint.Send(new PingMessage());
await handled.Task.OrTimeout(TimeSpan.FromSeconds(10000));
}
finally
{
await busHandle.StopAsync(new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token);
}
}
Task CreateHostQueue(ITokenProvider tokenProvider)
{
var serviceUri = AzureServiceBusEndpointUriCreator.Create(
Configuration.ServiceNamespace,
Environment.MachineName
);
var settings = new NamespaceManagerSettings
{
TokenProvider = tokenProvider
};
var namespaceManager = new NamespaceManager(serviceUri, settings);
return(CreateQueue(namespaceManager, serviceUri, "Control"));
}
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 = await MessagingFactory.CreateAsync(serviceUri, mfs);
var receiver = factory.CreateQueueClient("Control");
receiver.PrefetchCount = 100;
var done = new TaskCompletionSource <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_support_the_new_syntax()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceBusNamespace = Configuration.ServiceNamespace;
var serviceUri = AzureServiceBusEndpointUriCreator.Create(
serviceBusNamespace,
"MassTransit.Azure.ServiceBus.Core.Tests"
);
TaskCompletionSource <A> completed = TaskUtil.GetTask <A>();
var bus = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
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("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));
});
});
});
var busHandle = await bus.StartAsync(TestCancellationToken);
try
{
}
finally
{
await busHandle.StopAsync();
}
// }))
// {
// var queueAddress = new Uri(hostAddress, "input_queue");
// ISendEndpoint endpoint = bus.GetSendEndpoint(queueAddress);
//
// await endpoint.Send(new A());
// }
}
