protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
configurator.ReceiveEndpoint(host, "input_queue_error", x =>
{
x.PurgeOnStartup = true;
_errorHandler = Handled<PingMessage>(x);
});
}
static IBusControl CreateBus()
{
return Bus.Factory.CreateUsingRabbitMq(x =>
{
_host = x.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), h =>
{
h.Username("guest");
h.Password("guest");
});
});
}
private void ConfigureEndPoints(IRabbitMqBusFactoryConfigurator cfg, IRabbitMqHost host, IComponentContext context)
{
cfg.ReceiveEndpoint(host, RabbitMQConstants.PetManagementWriteQueue, e =>
{
e.Consumer(context.Resolve <IConsumerFactory <CreatePetCommandConsumer> >());
});
}
/// <summary>
/// Create a request client from the bus, creating a response endpoint, and publishing the request versus sending it.
/// </summary>
/// <param name="host">The host to connect the new receive endpoint</param>
/// <param name="timeout">The default request timeout</param>
/// <returns></returns>
public static async Task <IRequestClient <T> > CreateRequestClient <T>(this IRabbitMqHost host, RequestTimeout timeout = default)
where T : class
{
var clientFactory = await CreateClientFactory(host, timeout).ConfigureAwait(false);
return(clientFactory.CreateRequestClient <T>());
}
public static IServiceCollection AddMassTransit(this IServiceCollection services)
{
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri("rabbitmq://localhost/"), h =>
{
h.Username("guest");
h.Password("guest");
});
x.ReceiveEndpoint(host, "request_service", e =>
{
IReceiveEndpointConfigurator xxxx = e;
var assembly = typeof(ConsumerExtensions).Assembly;
var methods = GetExtensionMethods(assembly, typeof(IReceiveEndpointConfigurator));
e.Consumer <TestConsumer>();
});
});
TaskUtil.Await(() => _busControl.StartAsync());
return(services);
}
public bool Start(HostControl hostControl)
{
log.Info("Creating bus...");
string serviceQueueName = ConfigurationManager.AppSettings["ServiceQueueName"];
busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri(ConfigurationManager.AppSettings["RabbitMQHost"]), h =>
{
h.Username(ConfigurationManager.AppSettings["RabbitMQUserName"]);
h.Password(ConfigurationManager.AppSettings["RabbitMQPassword"]);
});
x.ReceiveEndpoint(host, serviceQueueName, e =>
{
e.Consumer(typeof(RequestAppEventConsumer),
t => UnityConfig.GetConfiguredContainer().Resolve <IConsumer <IRequestAppEvent> >());
e.Consumer(typeof(RequestDeedlineAppEventConsumer),
t => UnityConfig.GetConfiguredContainer().Resolve <IConsumer <IRequestDeedlineAppEvent> >());
e.Consumer(typeof(UserPasswordRecoveryAppEventConsumer),
t => UnityConfig.GetConfiguredContainer().Resolve <IConsumer <IUserPasswordRecoveryAppEvent> >());
e.Consumer(typeof(UserRegisterAppEventConsumer),
t => UnityConfig.GetConfiguredContainer().Resolve <IConsumer <IUserRegisterAppEvent> >());
});
});
log.Info("Starting bus...");
TaskUtil.Await(() => busControl.StartAsync());
return(true);
}
private static void ConfigureBus(IRabbitMqBusFactoryConfigurator cfg, IRabbitMqHost host)
{
container = CreateContainer();
cfg.ReceiveEndpoint(host, RabbitMqConstants.ProductViewQueue + ".product.updated",
ConfigureEndpoint <ProductUpdatedEventConsumer>);
cfg.ReceiveEndpoint(host, RabbitMqConstants.ProductViewQueue + ".product.inventoryupdated",
ConfigureEndpoint <ProductInventoryUpdatedEventConsumer>);
cfg.ReceiveEndpoint(host, RabbitMqConstants.ProductViewQueue + ".product.priceupdated",
ConfigureEndpoint <ProductPriceUpdatedEventConsumer>);
cfg.ReceiveEndpoint(host, RabbitMqConstants.ProductViewQueue + ".product.ratingupdated",
ConfigureEndpoint <ProductRatingUpdatedEventConsumer>);
cfg.ReceiveEndpoint(host, RabbitMqConstants.ProductViewQueue + ".product.deleted",
ConfigureEndpoint <ProductDeletedEventConsumer>);
cfg.ReceiveEndpoint(host, RabbitMqConstants.ProductViewQueue + ".category.deleted",
ConfigureEndpoint <CategoryDeletedEventConsumer>);
cfg.ReceiveEndpoint(host, RabbitMqConstants.ProductViewQueue + ".category.updated",
ConfigureEndpoint <CategoryUpdatedEventConsumer>);
}
public bool Start(HostControl hostControl)
{
Console.WriteLine("Creating bus...");
_busControl = MassTransit.Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri(/*rabbitMQ server*/), h =>
{
/*credentials*/
});
x.UseInMemoryScheduler();
x.UseMessageScheduler(new Uri(RabbitMqServerAddress));
x.ReceiveEndpoint(host, "validation_needed", e =>
{
e.PrefetchCount = 1;
e.Durable = true;
//again this is how the consumer is registered
e.Consumer <RequestConsumer>();
});
});
Console.WriteLine("Starting bus...");
try
{
_busHandle = MassTransit.Util.TaskUtil.Await <BusHandle>(() => _busControl.StartAsync());
_scheduler.JobFactory = new MassTransitJobFactory(_busControl);
_scheduler.Start();
}
catch (Exception)
{
_scheduler.Shutdown();
throw;
}
return(true);
}
static IBusControl ConfigureBus(IRegistrationContext <IServiceProvider> provider)
{
AppConfig = provider.GetRequiredService <IOptions <AppConfig> >().Value;
return(Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost host = cfg.Host(AppConfig.Host, AppConfig.VirtualHost, h =>
{
h.Username(AppConfig.Username);
h.Password(AppConfig.Password);
});
// 1. Configuring consistent exchange
string consistentExchangeName = "x-consistent-hash";
DeclareConsistentExchange(host, consistentExchangeName);
// 2. Configuring endpoints bindings to queues
cfg.ReceiveEndpoint("qq1", ep =>
{
ep.ConfigureConsumeTopology = false;
ep.Bind(
"x-consistent-hash",
x =>
{
x.Durable = true;
x.ExchangeType = "x-consistent-hash";
x.RoutingKey = "10";
});
ep.PrefetchCount = 1;
ep.Consumer <QuoteCreatedConsumer1>(provider.Container);
});
cfg.ReceiveEndpoint("qq2", ep =>
{
ep.ConfigureConsumeTopology = false;
ep.Bind(
"x-consistent-hash",
x =>
{
x.Durable = true;
x.ExchangeType = "x-consistent-hash";
x.RoutingKey = "10";
});
ep.PrefetchCount = 1;
ep.Consumer <QuoteCreatedConsumer2>(provider.Container);
});
// 3. Binding message endpoints to consistent exchange
cfg.ConnectBusObserver(new BindIncomingMessageExchangeAction(
host,
consistentExchangeName,
typeof(IQuoteCreated)
));
}));
}
public static string GetTemporaryQueueName(this IRabbitMqHost ignored, string prefix)
{
var sb = new StringBuilder(prefix);
var host = HostMetadataCache.Host;
foreach (char c in host.MachineName)
{
if (char.IsLetterOrDigit(c))
{
sb.Append(c);
}
else if (c == '.' || c == '_' || c == '-' || c == ':')
{
sb.Append(c);
}
}
sb.Append('-');
foreach (char c in host.ProcessName)
{
if (char.IsLetterOrDigit(c))
{
sb.Append(c);
}
else if (c == '.' || c == '_' || c == '-' || c == ':')
{
sb.Append(c);
}
}
sb.Append('-');
sb.Append(NewId.Next().ToString(_formatter));
return(sb.ToString());
}
public void SetUpBus()
{
bus = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
host = sbc.Host(new Uri("rabbitmq://localhost"), h =>
{
h.Username("guest");
h.Password("guest");
});
//setting up sending
sbc.Send <Document>(x => { x.UseRoutingKeyFormatter(e => e.Message.Type); });
sbc.Message <Document>(x => x.SetEntityName("document"));
sbc.Publish <Document>(x => { x.ExchangeType = ExchangeType.Direct; });
sbc.Message <DocumentCreatedEvent>(x => x.SetEntityName("document_created"));
sbc.Publish <DocumentCreatedEvent>(x => x.ExchangeType = ExchangeType.Direct);
sbc.Message <UpdateDocumentCommand>(x => x.SetEntityName("updatedoc"));
sbc.Publish <UpdateDocumentCommand>(x => x.ExchangeType = ExchangeType.Direct);
sbc.Send <UpdateDocumentCommand>(x => x.UseRoutingKeyFormatter(e => e.Message.Type));
});
}
private static void Initialize()
{
_busControl = MassTransit.Bus.Factory.CreateUsingRabbitMq(cfg =>
{
_rabbitMqHost = cfg.Host(_rabbitConfig.ConnectionString, h =>
{
h.Username(_rabbitConfig.UserName);
h.Password(_rabbitConfig.Password);
});
foreach (var queueConfiguration in _queueConfigurations)
{
cfg.ReceiveEndpoint(queueConfiguration.Key, queueConfiguration.Value);
}
//if (RetryCount > 0)
//{
// cfg.UseRetry(config =>
// {
// config.Interval(RetryCount, TimeSpan.FromSeconds(RetryIntervalInSec));
// });
//}
//cfg.UseSerilog();
});
}
public bool UpdateVoice(int invoiceId, int status)
{
try
{
var ipValue = "192.168.43.51";
var invoice = _invoiceRepository.UpdateVoice(invoiceId, status);
if (invoice != null)
{
IBus rabbitBusControl = Bus.Factory.CreateUsingRabbitMq(
rabbit =>
{
IRabbitMqHost rabbitMqHost = rabbit.Host(new Uri($"rabbitmq://{ipValue}/"), settings =>
{
settings.Username("tuandv");
settings.Password("tuandv");
});
}
);
rabbitBusControl.Publish <InvoiceReadModel>(invoice);
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
private static IRabbitMqHost EnsureStoveDefaults(IRabbitMqBusFactoryConfigurator cfg, IStoveRabbitMQConfiguration configuration)
{
IRabbitMqHost host = cfg.Host(new Uri(configuration.HostAddress), h =>
{
h.Username(configuration.Username);
h.Password(configuration.Password);
});
if (configuration.UseRetryMechanism)
{
cfg.UseRetry(rtryConf => { rtryConf.Immediate(configuration.MaxRetryCount); });
}
if (configuration.PrefetchCount.HasValue)
{
cfg.PrefetchCount = (ushort)configuration.PrefetchCount;
}
if (configuration.ConcurrencyLimit.HasValue)
{
cfg.UseConcurrencyLimit(configuration.ConcurrencyLimit.Value);
}
return(host);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddMassTransit(x =>
{
// x.AddConsumer<SomeConsumer>();
});
services.AddSingleton(provider => Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost host = cfg.Host(new Uri("rabbitmq://localhost"), h =>
{
h.Username("guest");
h.Password("guest");
});
cfg.ReceiveEndpoint(host, "submit.registration.queue", endpointConfigurator =>
{
endpointConfigurator.PrefetchCount = 16;
endpointConfigurator.LoadFrom(provider);
EndpointConvention.Map <ISubmitRegistration>(endpointConfigurator.InputAddress);
});
}));
services.AddSingleton <IPublishEndpoint>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <ISendEndpointProvider>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <IBus>(provider => provider.GetRequiredService <IBusControl>());
}
public bool Start(HostControl hostControl)
{
_log.Info("Creating bus...");
_machine = new LoadDataSaga();
SagaDbContextFactory sagaDbContextFactory = () => new SagaDbContext <LoadData, LoadDataMap>(DbContextFactoryProvider.ConnectionString);
//_repository = new Lazy<ISagaRepository<LoadData>>(() => new EntityFrameworkSagaRepository<LoadData>(sagaDbContextFactory));
_repository = new InMemorySagaRepository <LoadData>();
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri(Consts.RabbitMqAddress), h =>
{
h.Username(Consts.User);
h.Password(Consts.Pass);
});
x.ReceiveEndpoint(host, Consts.LoadDataQueue, e =>
{
e.PrefetchCount = 8;
e.StateMachineSaga(_machine, _repository);
});
});
_log.Info("Starting bus...");
TaskUtil.Await(() => _busControl.StartAsync());
return(true);
}
public static IServiceCollection AddServiceBus(this IServiceCollection services, Action <ServiceBusOptions> setupAction)
{
ServiceBusOptions options = new ServiceBusOptions();
setupAction.Invoke(options);
services.AddMassTransit(cfg =>
{
cfg.AddConsumer <Community.Domain.IntegrationEventHandlers.Identity.IdentityIntegrationEventHandler>();
});
services.AddSingleton(provider => Bus.Factory.CreateUsingRabbitMq(transport =>
{
Uri hostAddress = new Uri(options.HostAddress);
IRabbitMqHost host = transport.Host(hostAddress, cfg =>
{
cfg.Username(options.RabbitMqHostUser);
cfg.Password(options.RabbitMqHostPassword);
});
transport.ReceiveEndpoint(host, options.RabbitMqQueueName, endpoint =>
{
endpoint.UseRetry(r => r.Immediate(3));
endpoint.Consumer <Community.Domain.IntegrationEventHandlers.Identity.IdentityIntegrationEventHandler>(provider);
});
}));
services.AddSingleton <IIntegrationServiceBus, IntegrationServiceBus>();
services.AddHostedService <MassTransitProcess>();
return(services);
}
protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
configurator.ReceiveEndpoint(host, "monitor", e =>
{
_pingsHandled = Handled<PingMessage>(e, 1000);
});
}
public RabbitMqReceiveEndpointConfigurator(IRabbitMqHost host, RabbitMqReceiveSettings settings, IConsumePipe consumePipe)
: base(consumePipe)
{
_host = host;
_settings = settings;
}
public async Task Should_startup_and_shut_down_cleanly_with_an_endpoint()
{
IBusControl busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
IRabbitMqHost host = x.Host(new Uri("rabbitmq://localhost/"), h =>
{
});
x.ReceiveEndpoint(host, "input_queue", e =>
{
e.Handler <Test>(async context =>
{
});
});
});
BusHandle handle = await busControl.StartAsync(TestCancellationToken);
try
{
Console.WriteLine("Waiting for connection...");
await handle.Ready;
await Task.Delay(60000);
}
finally
{
await handle.StopAsync(TestCancellationToken);
}
}
private static void Run()
{
IBusControl busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost host = cfg.Host(new Uri("rabbitmq://localhost"), h =>
{
h.Username("guest");
h.Password("guest");
});
cfg.ReceiveEndpoint(host, "submit.registration.queue", endpointConfigurator =>
{
endpointConfigurator.PrefetchCount = 16;
endpointConfigurator.Consumer <SubmitRegistrationConsumer>();
});
cfg.ReceiveEndpoint(host, "process.registration.queue", endpointConfigurator =>
{
endpointConfigurator.PrefetchCount = 16;
endpointConfigurator.Consumer <ProcessRegistrationConsumer>();
});
});
busControl.StartAsync();
ReadKey();
busControl.StopAsync();
}
void CleanUpVirtualHost(IRabbitMqHost host)
{
try
{
_nameFormatter = new RabbitMqMessageNameFormatter();
var connectionFactory = host.Settings.GetConnectionFactory();
using (
var connection = host.Settings.ClusterMembers?.Any() ?? false
? connectionFactory.CreateConnection(host.Settings.ClusterMembers, host.Settings.Host)
: connectionFactory.CreateConnection())
using (var model = connection.CreateModel())
{
model.ExchangeDelete("input_queue");
model.QueueDelete("input_queue");
model.ExchangeDelete("input_queue_skipped");
model.QueueDelete("input_queue_skipped");
model.ExchangeDelete("input_queue_error");
model.QueueDelete("input_queue_error");
model.ExchangeDelete("input_queue_delay");
model.QueueDelete("input_queue_delay");
OnCleanupVirtualHost(model);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
public void ConfigureServices(IServiceCollection services)
{
RabbitConfig rabbitConfig = Configuration.GetSection("RabbitConfig").Get <RabbitConfig>();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddMassTransit(x =>
{
x.AddBus(provider => Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost host = cfg.Host(new Uri($"rabbitmq://{rabbitConfig.Host}/"), h =>
{
h.Username(rabbitConfig.User);
h.Password(rabbitConfig.Password);
});
EndpointConvention.Map <IBusMessageCommand>(new Uri($"rabbitmq://localhost/{rabbitConfig.InitializeQueue}"));
}));
});
services.AddScoped(provider => provider.GetRequiredService <IBus>()
.CreateRequestClient <IBusMessageCommand>());
services.AddSingleton <Microsoft.Extensions.Hosting.IHostedService, BusService>();
}
public bool Start()
{
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
var username = _configuration.GetConnectionString(MicroservicesConstants.MessageBusUsername);
var password = _configuration.GetConnectionString(MicroservicesConstants.MessageBusPassword);
IRabbitMqHost host = x.Host(new Uri(_configuration.GetConnectionString(MicroservicesConstants.MessageBusHost)), h =>
{
if (!string.IsNullOrEmpty(username))
{
h.Username(_configuration.GetConnectionString(MicroservicesConstants.MessageBusUsername));
}
if (!string.IsNullOrEmpty(password))
{
h.Password(_configuration.GetConnectionString(MicroservicesConstants.MessageBusPassword));
}
});
x.ReceiveEndpoint(host, _serviceQueueName, Configure());
});
TaskUtil.Await(() => _busControl.StartAsync());
return(true);
}
public static IServiceCollection AddRequestResponseBus(this IServiceCollection services)
{
IBusControl bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost host = cfg.Host("localhost", "/", config =>
{
config.Username("guest");
config.Password("guest");
});
});
services.AddSingleton <IPublishEndpoint>(bus);
services.AddSingleton <ISendEndpointProvider>(bus);
services.AddSingleton <IBus>(bus);
TimeSpan timeout = TimeSpan.FromSeconds(10);
Uri serviceAddress = new Uri("rabbitmq://localhost/requestService");
services.AddScoped <IRequestClient <RequestMessage, RequestResponse> >(x =>
new MessageRequestClient <RequestMessage, RequestResponse>(x.GetRequiredService <IBus>(), serviceAddress, timeout, timeout));
bus.Start();
return(services);
}
/// <summary>
/// Registers a management endpoint on the bus, which can be used to control
/// filters and other management control points on the bus.
/// </summary>
/// <param name="configurator"></param>
/// <param name="host">The host where the endpoint is to be created</param>
/// <param name="configure">Configure additional values of the underlying receive endpoint</param>
/// <returns></returns>
public static IManagementEndpointConfigurator ManagementEndpoint(this IRabbitMqBusFactoryConfigurator configurator,
IRabbitMqHost host, Action <IRabbitMqReceiveEndpointConfigurator> configure = null)
{
if (configurator == null)
{
throw new ArgumentNullException(nameof(configurator));
}
if (host == null)
{
throw new ArgumentNullException(nameof(host));
}
var queueName = host.Topology.CreateTemporaryQueueName("manage-");
IRabbitMqReceiveEndpointConfigurator specification = null;
configurator.ReceiveEndpoint(host, queueName, x =>
{
x.AutoDelete = true;
x.Durable = false;
configure?.Invoke(x);
specification = x;
});
var managementEndpointConfigurator = new ManagementEndpointConfigurator(specification);
return(managementEndpointConfigurator);
}
static void Main(string[] args)
{
Console.Title = "Subscriber1";
Console.WriteLine($"Subscriber1 start at {DateTime.Now}");
IBusControl rabbitBusControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
{
IRabbitMqHost rabbitMqHost = rabbit.Host(new Uri("rabbitmq://localhost:5672"), settings =>
{
settings.Password("ninisite");
settings.Username("ninisite");
});
rabbit.ReceiveEndpoint(rabbitMqHost, "masstransitsample.queues.events.subscriber1", conf =>
{
//conf.PrefetchCount = 5;
conf.Consumer <Consumer>();
});
});
rabbitBusControl.Start();
Console.ReadKey();
rabbitBusControl.Stop();
}
static async Task Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
string host = "host";
string vhost = "vhost";
string username = "******";
string password = "******";
var bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost rmqHost = cfg.Host(host, vhost, h =>
{
h.Username(username);
h.Password(password);
});
});
bus.Start();
Console.WriteLine("Нажмите Enter, чтобы опубликовать событийное сообщение.");
Console.ReadKey();
await bus.Publish <EventMessage>(new { Text = "Событийное сообщение: приходит ко всем потребителям." });
Console.WriteLine("Нажмите Enter, чтобы опубликовать соревновательное сообщение.");
Console.ReadKey();
await bus.Publish <CompetingConsumersMessage>(new { Text = "Соревновательное сообщение: принимается только одним из подписчиков очереди." });
Console.ReadKey();
bus.Stop();
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
AddUseCases(services);
AddConsumers(services);
string rabbitMQHost = $"rabbitmq://{Environment.GetEnvironmentVariable("RABBITMQ_HOST")}";
services.AddSingleton(provider => Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost host = cfg.Host(new Uri(rabbitMQHost), h =>
{
h.Username(Environment.GetEnvironmentVariable("RABBITMQ_USERNAME"));
h.Password(Environment.GetEnvironmentVariable("RABBITMQ_PASSWORD"));
});
SetEndPoints(cfg, host, provider);
}));
AddGateways(services);
services.AddSingleton <IPublishEndpoint>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <ISendEndpointProvider>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <IBus>(provider => provider.GetRequiredService <IBusControl>());
AddRequestClients(services);
AddAdaptors(services);
services.AddSingleton <IHostedService, BusService>();
}
IBusControl CreateBus()
{
return(MassTransit.Bus.Factory.CreateUsingRabbitMq(x =>
{
ConfigureBus(x);
IRabbitMqHost host = x.Host(_hostAddress, h =>
{
h.Username("guest");
h.Password("guest");
});
CleanUpVirtualHost(host);
ConfigureBusHost(x, host);
x.ReceiveEndpoint(host, "input_queue", e =>
{
e.PrefetchCount = 16;
e.PurgeOnStartup = true;
ConfigureInputQueueEndpoint(e);
});
}));
}
private static void RunMessageBuss()
{
IBusControl rabbitBusControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
{
IRabbitMqHost rabbitMqHost = rabbit.Host(new Uri("rabbitmq://localhost:5672/payment"), settings =>
{
settings.Password("guest");
settings.Username("guest");
});
rabbit.ReceiveEndpoint(rabbitMqHost, "superdigital.payments.events.resumeaccount", conf =>
{
conf.PrefetchCount = 1;
conf.Consumer <PaymentCreatedConsumer>(paymentCreatedConfig =>
{
paymentCreatedConfig.UseContextFilter((context) =>
{
bool valid = context.TryGetMessage <IPaymentCreated>(out var message);
if (valid)
{
valid = message.Message?.CreatedBy == "wololo";
Console.WriteLine("Skipped message " + context.MessageId);
}
return(Task.FromResult(valid));
});
});
});
});
rabbitBusControl.Start();
Console.ReadKey();
rabbitBusControl.Stop();
}
private IBusControl ConfigureBus()
{
return(Bus.Factory.CreateUsingRabbitMq(cfg =>
{
IRabbitMqHost host = cfg.Host(new Uri("rabbitmq://localhost"), h =>
{
h.Username("guest");
h.Password("guest");
});
cfg.ReceiveEndpoint("issue_request_state", endpoint =>
{
var optionsBuilder = new DbContextOptionsBuilder <IssueRequestDbContext>();
optionsBuilder.UseSqlServer(connectionString);
var repository = new EntityFrameworkSagaRepository <IssueRequest>(() => new IssueRequestDbContext(optionsBuilder.Options));
//var repository = new InMemorySagaRepository<CustomerRequest>();
var machine = new IssueRequestSagaStateMachine();
endpoint.StateMachineSaga(machine, repository);
});
}));
}
/// <summary>
/// Registers a management endpoint on the bus, which can be used to control
/// filters and other management control points on the bus.
/// </summary>
/// <param name="configurator"></param>
/// <param name="host">The host where the endpoint is to be created</param>
/// <param name="configure">Configure additional values of the underlying receive endpoint</param>
/// <returns></returns>
public static IManagementEndpointConfigurator ManagementEndpoint(this IRabbitMqBusFactoryConfigurator configurator,
IRabbitMqHost host, Action <IRabbitMqReceiveEndpointConfigurator> configure = null)
{
if (configurator == null)
{
throw new ArgumentNullException(nameof(configurator));
}
if (host == null)
{
throw new ArgumentNullException(nameof(host));
}
var queueName = host.GetTemporaryQueueName("manage-");
var endpointConfigurator = new RabbitMqReceiveEndpointSpecification(host, queueName)
{
AutoDelete = true,
Durable = false
};
configure?.Invoke(endpointConfigurator);
configurator.AddReceiveEndpointSpecification(endpointConfigurator);
var managementEndpointConfigurator = new ManagementEndpointConfigurator(endpointConfigurator);
return(managementEndpointConfigurator);
}
public RabbitMqReceiveEndpointConfigurator(IRabbitMqHost host, RabbitMqReceiveSettings settings, IConsumePipe consumePipe)
: base(consumePipe)
{
_host = host;
_settings = settings;
}
public RabbitMqPublishEndpointProvider(IRabbitMqHost host, IMessageSerializer serializer, Uri sourceAddress)
{
_host = host;
_serializer = serializer;
_sourceAddress = sourceAddress;
_messageNameFormatter = host.MessageNameFormatter;
_cachedEndpoints = new ConcurrentDictionary<Type, Lazy<ISendEndpoint>>();
_publishObservable = new PublishObservable();
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings,
params ExchangeBindingSettings[] exchangeBindings)
{
_host = host;
_settings = settings;
_exchangeBindings = exchangeBindings;
_receiveObservers = new ReceiveObservable();
_endpointObservers = new ReceiveEndpointObservable();
}
public RabbitMqPublishEndpointProvider(IRabbitMqHost host, IMessageSerializer serializer, Uri sourceAddress, IPublishPipe publishPipe)
{
_host = host;
_serializer = serializer;
_sourceAddress = sourceAddress;
_publishPipe = publishPipe;
_cachedEndpoints = new LazyConcurrentDictionary<Type, ISendEndpoint>(CreateSendEndpoint);
_publishObservable = new PublishObservable();
}
protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
configurator.ReceiveEndpoint(host, "input_queue_error", x =>
{
x.PurgeOnStartup = true;
_errorHandler = Handled<PingMessage>(x, context => context.Message.CorrelationId == _pingMessage.CorrelationId);
_errorHandler2 = Handled<PingMessage>(x, context => context.Message.CorrelationId == _pingMessage2.CorrelationId);
});
}
public RabbitMqReceiveEndpointConfigurator(IRabbitMqHost host, RabbitMqReceiveSettings settings, IConsumePipe consumePipe)
: base(consumePipe)
{
_host = host;
_settings = settings;
_mediator = new Mediator<ISetPrefetchCount>();
_exchangeBindings = new List<ExchangeBindingSettings>();
}
/// <summary>
/// Adds a RabbitMQ Basic Consumer to the pipeline
/// </summary>
/// <param name="configurator"></param>
/// <param name="pipe"></param>
/// <param name="settings"></param>
/// <param name="receiveObserver"></param>
/// <param name="transportObserver"></param>
/// <param name="exchangeBindings"></param>
/// <param name="supervisor"></param>
/// <param name="managementPipe"></param>
/// <param name="sendEndpointProvider"></param>
/// <param name="publishEndpointProvider"></param>
/// <param name="host"></param>
public static void RabbitMqConsumer(this IPipeConfigurator<ConnectionContext> configurator, IPipe<ReceiveContext> pipe, ReceiveSettings settings, IReceiveObserver receiveObserver, IReceiveTransportObserver transportObserver, IEnumerable<ExchangeBindingSettings> exchangeBindings, ITaskSupervisor supervisor, IManagementPipe managementPipe, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider, IRabbitMqHost host)
{
if (configurator == null)
throw new ArgumentNullException(nameof(configurator));
var pipeBuilderConfigurator = new RabbitMqConsumerPipeSpecification(pipe, settings, receiveObserver, transportObserver, exchangeBindings,
supervisor, managementPipe, sendEndpointProvider, publishEndpointProvider, host);
configurator.AddPipeSpecification(pipeBuilderConfigurator);
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings, IManagementPipe managementPipe,
params ExchangeBindingSettings[] bindings)
{
_host = host;
_settings = settings;
_bindings = bindings;
_managementPipe = managementPipe;
_receiveObservable = new ReceiveObservable();
_receiveEndpointObservable = new ReceiveEndpointObservable();
}
public RabbitMqReceiveEndpointConfigurator(IRabbitMqHost host, string queueName = null, IConsumePipe consumePipe = null)
: base(consumePipe)
{
_host = host;
_settings = new RabbitMqReceiveSettings
{
QueueName = queueName,
ExchangeName = queueName
};
}
/// <summary>
/// Declare a ReceiveEndpoint using a broker-assigned queue name. This queue defaults to auto-delete
/// and non-durable. By default all services bus instances include a default receiveEndpoint that is
/// of this type (created automatically upon the first receiver binding).
/// </summary>
/// <param name="configurator"></param>
/// <param name="host"></param>
/// <param name="configure"></param>
public static void ReceiveEndpoint(this IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host,
Action<IRabbitMqReceiveEndpointConfigurator> configure)
{
configurator.ReceiveEndpoint(host, null, x =>
{
x.AutoDelete = true;
x.Durable = false;
configure(x);
});
}
public RabbitMqReceiveEndpointConfigurator(IRabbitMqHost host, string queueName = null, IConsumePipe consumePipe = null)
: base(consumePipe)
{
_host = host;
_settings = new RabbitMqReceiveSettings
{
QueueName = queueName,
};
_mediator = new Mediator<ISetPrefetchCount>();
_exchangeBindings = new List<ExchangeBindingSettings>();
}
protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
base.ConfigureBusHost(configurator, host);
configurator.ReceiveEndpoint(host, "priority_input_queue", x =>
{
x.EnablePriority(4);
_endpointAddress = x.InputAddress;
x.Handler<PingMessage>(context => context.RespondAsync(new PongMessage(context.Message.CorrelationId)));
});
}
/// <summary>
/// Declare a ReceiveEndpoint using a unique generated queue name. This queue defaults to auto-delete
/// and non-durable. By default all services bus instances include a default receiveEndpoint that is
/// of this type (created automatically upon the first receiver binding).
/// </summary>
/// <param name="configurator"></param>
/// <param name="host"></param>
/// <param name="configure"></param>
public static void ReceiveEndpoint(this IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host,
Action<IRabbitMqReceiveEndpointConfigurator> configure)
{
var queueName = configurator.GetTemporaryQueueName("receiveEndpoint-");
configurator.ReceiveEndpoint(host, queueName, x =>
{
x.AutoDelete = true;
x.Durable = false;
configure(x);
});
}
public void Start()
{
_busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
_host = x.Host(new Uri(_baseurl), h =>
{
h.Username("iot");
h.Password("iot");
});
x.ReceiveEndpoint(_host, "rest_requests", e => { e.Consumer<RequestConsumer>(); });
});
_busHandle = _busControl.Start();
}
protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
configurator.UseDelayedExchangeMessageScheduler();
base.ConfigureBusHost(configurator, host);
configurator.TurnoutEndpoint<ProcessFile>(host, "process_queue", endpoint =>
{
endpoint.SuperviseInterval = TimeSpan.FromSeconds(1);
endpoint.SetJobFactory(async context => await Task.Delay(TimeSpan.FromSeconds(context.Command.Size)).ConfigureAwait(false));
_commandEndpointAddress = endpoint.InputAddress;
});
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings, IManagementPipe managementPipe, ExchangeBindingSettings[] bindings, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_host = host;
_settings = settings;
_bindings = bindings;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
_managementPipe = managementPipe;
_receiveObservable = new ReceiveObservable();
_receiveTransportObservable = new ReceiveTransportObservable();
_inputAddress = _settings.GetInputAddress(_host.Settings.HostAddress);
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings, Mediator<ISetPrefetchCount> mediator,
params ExchangeBindingSettings[] bindings)
{
_host = host;
_settings = settings;
_bindings = bindings;
_mediator = mediator;
_receiveObservable = new ReceiveObservable();
_receiveEndpointObservable = new ReceiveEndpointObservable();
var exceptionFilter = Retry.Selected<RabbitMqConnectionException>();
_connectionRetryPolicy = exceptionFilter.Exponential(1000, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(1));
}
RabbitMqModelContext(ConnectionContext connectionContext, IModel model, IRabbitMqHost host, ITaskParticipant participant)
: base(new PayloadCacheScope(connectionContext))
{
_connectionContext = connectionContext;
_model = model;
_host = host;
_participant = participant;
_published = new ConcurrentDictionary<ulong, PendingPublish>();
_taskScheduler = new LimitedConcurrencyLevelTaskScheduler(1);
_model.ModelShutdown += OnModelShutdown;
_model.BasicAcks += OnBasicAcks;
_model.BasicNacks += OnBasicNacks;
_model.BasicReturn += OnBasicReturn;
if (host.Settings.PublisherConfirmation)
{
_model.ConfirmSelect();
}
_participant.SetReady();
}
protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
configurator.UseDelayedExchangeMessageScheduler();
base.ConfigureBusHost(configurator, host);
configurator.TurnoutEndpoint<ProcessFile>(host, "process_queue", endpoint =>
{
endpoint.SuperviseInterval = TimeSpan.FromSeconds(1);
endpoint.SetJobFactory(async context =>
{
try
{
await Task.Delay(TimeSpan.FromSeconds(context.Command.Size), context.CancellationToken).ConfigureAwait(false);
}
catch (TaskCanceledException ex)
{
Console.WriteLine("Task was canceled!");
throw;
}
});
_commandEndpointAddress = endpoint.InputAddress;
});
}
protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
base.ConfigureBusHost(configurator, host);
configurator.OverrideDefaultBusEndpointQueueName($"super-bus-{NewId.NextGuid().ToString("N")}");
}
protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
base.ConfigureBusHost(configurator, host);
_host = host;
}
public void ReceiveEndpoint(IRabbitMqHost host, string queueName, Action<IRabbitMqReceiveEndpointConfigurator> configure)
{
if (host == null)
throw new EndpointNotFoundException("The host address specified was not configured.");
var endpointConfigurator = new RabbitMqReceiveEndpointConfigurator(host, queueName);
configure(endpointConfigurator);
AddBusFactorySpecification(endpointConfigurator);
}
protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
base.ConfigureBusHost(configurator, host);
configurator.PrefetchCount = 100;
configurator.ReceiveEndpoint(host, "input_queue_express", x =>
{
x.AutoDelete = true;
x.Durable = false;
x.PrefetchCount = 100;
_serviceAddress = x.InputAddress;
x.Handler<PingMessage>(async context =>
{
try
{
await context.RespondAsync(new PongMessage(context.Message.CorrelationId));
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
});
});
}
public RabbitMqModelContext(ConnectionContext connectionContext, IModel model, ITaskScope taskScope, IRabbitMqHost host)
: this(connectionContext, model, host,
taskScope.CreateParticipant($"{TypeMetadataCache<RabbitMqModelContext>.ShortName} - {connectionContext.HostSettings.ToDebugString()}"))
{
}
protected override void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
_management = configurator.ManagementEndpoint(host);
}
protected virtual void ConfigureBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
}
void CleanUpVirtualHost(IRabbitMqHost host)
{
_nameFormatter = new RabbitMqMessageNameFormatter();
ConnectionFactory connectionFactory = host.Settings.GetConnectionFactory();
using (IConnection connection = connectionFactory.CreateConnection())
using (IModel model = connection.CreateModel())
{
model.ExchangeDelete("input_queue");
model.QueueDelete("input_queue");
OnCleanupVirtualHost(model);
}
}
