static void Main(string[] args)
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
Uri address = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "SimpleWebTokenAuthenticationService");
TransportClientEndpointBehavior behavior = new TransportClientEndpointBehavior();
behavior.TokenProvider = TokenProvider.CreateSimpleWebTokenProvider(
ComputeSimpleWebTokenString(issuerName, issuerSecret));
ServiceHost host = new ServiceHost(typeof(EchoService), address);
host.Description.Endpoints[0].Behaviors.Add(behavior);
host.Open();
Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
host.Close();
}
static void Main(string[] args)
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "SimpleWebTokenAuthenticationService");
TransportClientEndpointBehavior behavior = new TransportClientEndpointBehavior();
behavior.TokenProvider = TokenProvider.CreateSimpleWebTokenProvider(
ComputeSimpleWebTokenString(issuerName, issuerSecret));
ChannelFactory <IEchoChannel> channelFactory = new ChannelFactory <IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
channelFactory.Endpoint.Behaviors.Add(behavior);
IEchoChannel channel = channelFactory.CreateChannel();
channel.Open();
Console.WriteLine("Enter text to echo (or [Enter] to exit):");
string input = Console.ReadLine();
while (input != String.Empty)
{
try
{
Console.WriteLine("Server echoed: {0}", channel.Echo(input));
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.Message);
}
input = Console.ReadLine();
}
channel.Close();
channelFactory.Close();
}
public async Task UseAzureServiceBus_GivenStaticOptions_ThenValid()
{
var batchFlushInterval = TimeSpan.FromMilliseconds(100);
var options = new ServiceBusOptions
{
ConnectionName = "connection-name-test",
HostAddress = new Uri("sb://namespace.servicebus.windows.net/scope"),
TokenProvider = TokenProvider.CreateSimpleWebTokenProvider("token-test"),
OperationTimeout = TimeSpan.FromMilliseconds(101),
RetryMinBackoff = TimeSpan.FromMilliseconds(102),
RetryMaxBackoff = TimeSpan.FromMilliseconds(103),
RetryLimit = 9,
TransportType = TransportType.NetMessaging,
BatchFlushInterval = batchFlushInterval,
AmqpTransportSettings = new AmqpTransportSettings {
BatchFlushInterval = batchFlushInterval
},
NetMessagingTransportSettings = new NetMessagingTransportSettings {
BatchFlushInterval = batchFlushInterval
},
};
var mockBusHandle = new Mock <BusHandle>(MockBehavior.Strict);
var mockBusControl = new Mock <IBusControl>(MockBehavior.Strict);
var mockAzureServiceBusBusFactory = new Mock <IBusFactory <IServiceBusBusFactoryConfigurator> >(MockBehavior.Strict);
var mockAzureServiceBusBusFactoryConfigurator = new Mock <IServiceBusBusFactoryConfigurator>(MockBehavior.Strict);
var mockAzureServiceBusHost = new Mock <IServiceBusHost>(MockBehavior.Strict);
mockBusControl
.Setup(_ => _.StartAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(mockBusHandle.Object)
.Verifiable();
mockBusControl
.Setup(_ => _.StopAsync(It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
mockAzureServiceBusBusFactory
.Setup(_ => _.Create(It.IsAny <Action <IServiceBusBusFactoryConfigurator> >()))
.Callback((Action <IServiceBusBusFactoryConfigurator> configure) => configure(mockAzureServiceBusBusFactoryConfigurator.Object))
.Returns(mockBusControl.Object)
.Verifiable();
mockAzureServiceBusBusFactoryConfigurator
.Setup(_ => _.Host(It.IsAny <ServiceBusHostSettings>()))
.Callback((ServiceBusHostSettings settings) =>
{
Assert.Equal(options.HostAddress, settings.ServiceUri);
Assert.Same(options.TokenProvider, settings.TokenProvider);
Assert.Equal(options.OperationTimeout, settings.OperationTimeout);
Assert.Equal(options.RetryMinBackoff, settings.RetryMinBackoff);
Assert.Equal(options.RetryMaxBackoff, settings.RetryMaxBackoff);
Assert.Equal(options.RetryLimit, settings.RetryLimit);
Assert.Equal(options.TransportType, settings.TransportType);
Assert.Equal(options.BatchFlushInterval, settings.AmqpTransportSettings.BatchFlushInterval);
Assert.Equal(options.BatchFlushInterval, settings.NetMessagingTransportSettings.BatchFlushInterval);
Assert.Equal(JsonConvert.SerializeObject(options.AmqpTransportSettings), JsonConvert.SerializeObject(settings.AmqpTransportSettings));
Assert.Equal(JsonConvert.SerializeObject(options.NetMessagingTransportSettings), JsonConvert.SerializeObject(settings.NetMessagingTransportSettings));
})
.Returns(mockAzureServiceBusHost.Object)
.Verifiable();
var services = new ServiceCollection();
services.AddSingleton(mockAzureServiceBusBusFactory.Object);
services.AddLogging(builder =>
{
builder.SetMinimumLevel(LogLevel.Trace);
builder.AddXUnit(_output);
});
services.AddMassTransit(builder =>
{
builder.UseAzureServiceBus(options);
});
using (var serviceProvider = services.BuildServiceProvider())
{
var busManager = serviceProvider.GetRequiredService <IBusManager>();
await busManager.StartAsync(CancellationToken.None).ConfigureAwait(false);
var bus = busManager.GetBus(options.ConnectionName);
Assert.NotNull(bus);
await busManager.StopAsync(CancellationToken.None).ConfigureAwait(false);
}
mockAzureServiceBusHost.Verify();
mockAzureServiceBusBusFactoryConfigurator.Verify();
mockAzureServiceBusBusFactory.Verify();
mockBusControl.Verify();
mockBusHandle.Verify();
}
private static void ConfigureServices(HostBuilderContext context, IServiceCollection services)
{
services.AddTransient <IWidgetService, WidgetService>();
// add other DI services...
// optionally use configuration for any settings
var configuration = context.Configuration;
// the following adds IBusManager which is also an IHostedService that is started/stopped by HostBuilder
services.AddMassTransit(busBuilder =>
{
// configure RabbitMQ
busBuilder.UseRabbitMq(configuration.GetSection("MassTransit:RabbitMq"), hostBuilder =>
{
// use scopes for all downstream filters and consumers
// i.e. per-request lifetime
hostBuilder.UseServiceScope();
// example adding an optional configurator to the bus
// using IRabbitMqBusFactoryConfigurator
hostBuilder.AddConfigurator(configureBus =>
{
configureBus.UseRetry(r => r.Immediate(1));
});
// example adding a receive endpoint to the bus
hostBuilder.AddReceiveEndpoint("example-queue-1", endpointBuilder =>
{
// example adding an optional configurator to the receive endpoint
// using IRabbitMqReceiveEndpointConfigurator
endpointBuilder.AddConfigurator(configureEndpoint =>
{
configureEndpoint.UseRetry(r => r.Immediate(3));
});
// example adding a consumer to the receive endpoint
endpointBuilder.AddConsumer <ExampleConsumer>(configureConsumer =>
{
// example adding an optional configurator to the consumer
// using IConsumerConfigurator<TConsumer>
configureConsumer.UseRateLimit(10);
});
});
});
// adding more bus instances...
// InMemory
busBuilder.UseInMemory("connection-name-2", hostBuilder =>
{
hostBuilder.UseServiceScope();
hostBuilder.AddReceiveEndpoint("example-queue-2", endpointBuilder =>
{
endpointBuilder.AddConsumer <ExampleConsumer>();
});
});
// ActiveMQ
busBuilder.UseActiveMq(configuration.GetSection("MassTransit:ActiveMq"), hostBuilder =>
{
hostBuilder.UseServiceScope();
hostBuilder.AddReceiveEndpoint("example-queue-3", endpointBuilder =>
{
endpointBuilder.AddConsumer <ExampleConsumer>();
});
});
// AmazonSQS
busBuilder.UseAmazonSqs(configuration.GetSection("MassTransit:AmazonSqs"), hostBuilder =>
{
hostBuilder.UseServiceScope();
hostBuilder.AddReceiveEndpoint("example-queue-4", endpointBuilder =>
{
endpointBuilder.AddConsumer <ExampleConsumer>();
});
});
// AzureServiceBus or
// AzureServiceBusCore
busBuilder.UseAzureServiceBus(configuration.GetSection("MassTransit:AzureServiceBus"), hostBuilder =>
{
hostBuilder.UseServiceScope();
hostBuilder.UseTokenProvider(TokenProvider.CreateSimpleWebTokenProvider("web-token-example"));
hostBuilder.AddConfigurator(configureBus =>
{
configureBus.SelectBasicTier();
});
hostBuilder.AddReceiveEndpoint("example-queue-5", endpointBuilder =>
{
endpointBuilder.AddConsumer <ExampleConsumer>();
});
});
// HTTP
busBuilder.UseHttp(configuration.GetSection("MassTransit:Http"), hostBuilder =>
{
hostBuilder.UseServiceScope();
hostBuilder.UseMethod(HttpMethod.Post);
hostBuilder.AddReceiveEndpoint("example-queue-6", endpointBuilder =>
{
endpointBuilder.AddConsumer <ExampleConsumer>();
});
});
});
}
