static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var serviceCollection = new ServiceCollection();
var messageStore = new InMemoryMessageStore();
var gatewayConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(gatewayConnection);
serviceCollection
.AddBrighter(options =>
options.BrighterMessaging = new BrighterMessaging(messageStore, producer))
.AutoFromAssemblies();
var serviceProvider = serviceCollection.BuildServiceProvider();
var commandProcessor = serviceProvider.GetService <IAmACommandProcessor>();
for (int i = 0; i < 1000; i++)
{
commandProcessor.Post(new GreetingEvent("Ian"));
}
}
private static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var host = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
var outbox = new InMemoryOutbox();
var gatewayConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
var producer = new RmqMessageProducer(gatewayConnection);
services.AddBrighter(options =>
{
options.BrighterMessaging = new BrighterMessaging(outbox, outbox, producer, null);
}).AutoFromAssemblies(typeof(GreetingEvent).Assembly);
services.AddHostedService <RunCommandProcessor>();
}
)
.UseConsoleLifetime()
.Build();
await host.RunAsync();
}
/// <summary>
/// This method gets called by the runtime. Use this method to add services to the container.
/// </summary>
/// <param name="services"></param>
public void ConfigureServices(IServiceCollection services)
{
var retryPolicy = Policy.Handle <Exception>().WaitAndRetry(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicy = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var retryPolicyAsync = Policy.Handle <Exception>().WaitAndRetryAsync(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicyAsync = Policy.Handle <Exception>().CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy },
{ CommandProcessor.RETRYPOLICYASYNC, retryPolicyAsync },
{ CommandProcessor.CIRCUITBREAKERASYNC, circuitBreakerPolicyAsync }
};
var messageStore = new MySqlOutbox(new MySqlOutboxConfiguration(
Configuration["Database:Bookings"],
Configuration["Database:MessageTableName"]
));
var gatewayConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("hotel.booking.exchange"),
};
var producer = new RmqMessageProducer(gatewayConnection);
services.AddBrighter(options =>
{
options.PolicyRegistry = policyRegistry;
options.BrighterMessaging = new BrighterMessaging(messageStore, producer);
options.CommandProcessorLifetime = ServiceLifetime.Scoped;
})
.AsyncHandlersFromAssemblies(typeof(BookGuestRoomOnAccountHandlerAsync).Assembly)
.MapperRegistryFromAssemblies(typeof(GuestRoomBookingMadeMapper).Assembly);
services.AddDarker(options => options.QueryProcessorLifetime = ServiceLifetime.Scoped)
.AddHandlersFromAssemblies(typeof(GetBookingByIdHandlerAsync).Assembly);
services.AddOpenApiDocument(config =>
{
config.PostProcess = document =>
{
document.Info.Version = "v1";
document.Info.Title = "Accounts API";
document.Info.Description = "Hotel customers who have accounts with us";
document.Info.TermsOfService = "None";
document.Info.Contact = new NSwag.OpenApiContact
{
Name = "Ian Cooper",
Email = string.Empty,
Url = "https://twitter.com/icooper"
};
};
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddDbContext <BookingContext>(options =>
options.UseMySql(Configuration["Database:Bookings"]));
}
public static void Run(UnityContainer container)
{
container.RegisterType <StoreFrontController>();
container.RegisterInstance(typeof(ILog), LogProvider.For <StoreService>(), new ContainerControlledLifetimeManager());
container.RegisterType <AddOrderCommandHandler>();
container.RegisterType <AddProductCommandHandler>();
container.RegisterType <ChangeProductCommandHandler>();
container.RegisterType <RemoveProductCommandHandler>();
container.RegisterType <IProductsDAO, ProductsDAO>();
var logger = container.Resolve <ILog>();
var handlerFactory = new UnityHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <AddOrderCommand, AddOrderCommandHandler>();
subscriberRegistry.Register <AddProductCommand, AddProductCommandHandler>();
subscriberRegistry.Register <ChangeProductCommand, ChangeProductCommandHandler>();
subscriberRegistry.Register <RemoveProductCommand, RemoveProductCommandHandler>();
//create policies
var retryPolicy = Policy
.Handle <Exception>()
.WaitAndRetry(new[]
{
TimeSpan.FromMilliseconds(50),
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
};
var messageMapperFactory = new UnityMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
messageMapperRegistry.Register <AddOrderCommand, AddOrderCommandMessageMapper>();
var gateway = new RmqMessageProducer(container.Resolve <ILog>());
var dbPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase.Substring(8)), "App_Data\\MessageStore.sdf");
IAmAMessageStore <Message> sqlMessageStore = new MsSqlMessageStore(new MsSqlMessageStoreConfiguration("DataSource=\"" + dbPath + "\"", "Messages", MsSqlMessageStoreConfiguration.DatabaseType.SqlCe), logger);
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(logger)
.TaskQueues(new MessagingConfiguration(sqlMessageStore, gateway, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
container.RegisterInstance(typeof(IAmACommandProcessor), commandProcessor);
}
static void Main(string[] args)
{
var container = new TinyIoCContainer();
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(GreetingEvent), typeof(GreetingEventMessageMapper) }
};
var messageStore = new InMemoryOutbox();
var rmqConnnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(rmqConnnection);
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration())
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration(messageStore, producer, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
commandProcessor.Post(new GreetingEvent("Ian"));
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var serviceCollection = new ServiceCollection();
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(rmqConnection, new RmqPublication
{
MakeChannels = OnMissingChannel.Create
});
serviceCollection.AddBrighter(options =>
{
var outBox = new InMemoryOutbox();
options.BrighterMessaging = new BrighterMessaging(outBox, producer);
}).AutoFromAssemblies();
var serviceProvider = serviceCollection.BuildServiceProvider();
var commandProcessor = serviceProvider.GetService <IAmACommandProcessor>();
commandProcessor.Post(new GreetingEvent("Ian says: Hi there!"));
commandProcessor.Post(new FarewellEvent("Ian says: See you later!"));
}
static void Main(string[] args)
{
var container = new Container();
var configBuilder = new ConfigurationBuilder()
.AddEnvironmentVariables();
var configuration = configBuilder.Build();
var messageMapperFactory = new MessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(GreetingEvent), typeof(GreetingEventMessageMapper) }
};
var messageStore = new InMemoryMessageStore();
var amqpUri = configuration["BABEL_BROKER"];
var rmqConnnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri(amqpUri)),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(rmqConnnection);
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration())
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration(messageStore, producer, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
commandProcessor.Post(new GreetingEvent("Ian"));
}
private void TryDoWork(CancellationToken cancellationToken)
{
string uri = Settings.MessageBrokerSettings.BuildUri();
GetMessagingSettingsWithRetry(out ApplicationObject queue, cancellationToken); // out InfoBase infoBase
//EntityDataMapperProvider provider = new EntityDataMapperProvider(
// infoBase,
// Settings.DatabaseSettings.DatabaseProvider,
// Settings.DatabaseSettings.ConnectionString);
//EntityJsonSerializer serializer = new EntityJsonSerializer(provider);
using (IMessageConsumer consumer = GetMessageConsumer(in queue))
{
using (RmqMessageProducer producer = new RmqMessageProducer(uri, string.Empty))
{
if (Settings.MessageBrokerSettings.ExchangeRole == 0)
{
producer.Initialize(ExchangeRoles.Aggregator);
}
else
{
producer.Initialize(ExchangeRoles.Dispatcher);
}
int published = producer.Publish(consumer); // serializer
FileLogger.Log($"Published {published} messages.");
}
}
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <ILoggerFactory>(new SerilogLoggerFactory());
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(rmqConnection);
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqConnection);
var replySubscriptions = new[]
{
new RmqSubscription(typeof(GreetingReply))
};
serviceCollection
.AddBrighter(options =>
{
options.ChannelFactory = new ChannelFactory(rmqMessageConsumerFactory);
})
.UseInMemoryOutbox()
.UseExternalBus(
new RmqProducerRegistryFactory(
rmqConnection,
new RmqPublication[]
{
new RmqPublication()
{
Topic = new RoutingKey("Greeting.Request")
}
}).Create(),
true,
replySubscriptions)
.AutoFromAssemblies();
var serviceProvider = serviceCollection.BuildServiceProvider();
var commandProcessor = serviceProvider.GetService <IAmACommandProcessor>();
Console.WriteLine("Requesting Salutation...");
//blocking call
commandProcessor.Call <GreetingRequest, GreetingReply>(new GreetingRequest {
Name = "Ian", Language = "en-gb"
}, 2000);
Console.WriteLine("Done...");
Console.ReadLine();
}
public RmqMessageProducerConfirmationsSendMessageTests()
{
_message = new Message(
new MessageHeader(Guid.NewGuid(), Guid.NewGuid().ToString(), MessageType.MT_COMMAND),
new MessageBody("test content"));
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
_messageProducer = new RmqMessageProducer(rmqConnection);
_messageProducer.OnMessagePublished += (success, guid) =>
{
if (success)
{
guid.Should().Be(_message.Id);
_messageWasPublished = true;
_messageWasNotPublished = false;
}
else
{
_messageWasNotPublished = true;
}
};
//we need a queue to avoid a discard
new QueueFactory(rmqConnection, _message.Header.Topic).Create(3000);
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.CreateLogger();
var container = new TinyIoCContainer();
container.Register <IHandleRequests <GreetingReply>, GreetingReplyHandler>();
container.Register <IAmAMessageMapper <GreetingReply>, GreetingReplyMessageMapper>();
container.Register <IAmAMessageMapper <GreetingRequest>, GreetingRequestMessageMapper>();
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var handerFactory = new TinyIocHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry()
{
{ typeof(GreetingReply), typeof(GreetingReplyHandler) }
};
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(GreetingRequest), typeof(GreetingRequestMessageMapper) },
{ typeof(GreetingReply), typeof(GreetingReplyMessageMapper) }
};
var rmqConnnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(rmqConnnection);
var inputChannelFactory = new ChannelFactory(new RmqMessageConsumerFactory(rmqConnnection));
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handerFactory))
.DefaultPolicy()
.RequestReplyQueues(
new MessagingConfiguration(
null,
producer,
messageMapperRegistry,
responseChannelFactory: inputChannelFactory))
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
Console.WriteLine("Requesting Salutation...");
//blocking call
commandProcessor.Call <GreetingRequest, GreetingReply>(new GreetingRequest {
Name = "Ian", Language = "en-gb"
}, 2000);
Console.WriteLine("Done...");
}
private void RegisterCommandProcessor()
{
//create handler
var subscriberRegistry = new SubscriberRegistry();
RegisterBrighterHandlersFromAssembly(
typeof(IHandleRequestsAsync <>),
new Assembly[] { typeof(NewShipRegistrationHandlerAsync).Assembly },
typeof(IHandleRequestsAsync <>).GetTypeInfo().Assembly,
subscriberRegistry);
//create policies
var retryPolicy = Policy.Handle <Exception>().WaitAndRetry(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicy = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var retryPolicyAsync = Policy.Handle <Exception>().WaitAndRetryAsync(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicyAsync = Policy.Handle <Exception>().CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new Paramore.Brighter.PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy },
{ CommandProcessor.RETRYPOLICYASYNC, retryPolicyAsync },
{ CommandProcessor.CIRCUITBREAKERASYNC, circuitBreakerPolicyAsync }
};
var servicesHandlerFactory = new ServicesHandlerFactoryAsync(_container);
var messagingGatewayConfiguration = RmqGatewayBuilder.With.Uri(new Uri(Configuration["Broker:Uri"]))
.Exchange(Configuration["Broker:Exchange"])
.DefaultQueues();
var gateway = new RmqMessageProducer(messagingGatewayConfiguration);
var sqlMessageStore = new MySqlMessageStore(new MySqlMessageStoreConfiguration(Configuration["Database:MessageStore"], Configuration["Database:MessageTableName"]));
var messageMapperFactory = new MessageMapperFactory(_container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
RegisterMessageMappersFromAssembly(
new Assembly[] { typeof(LineNameUpdatedEventMessageMapper).Assembly },
typeof(IAmAMessageMapper <>).GetTypeInfo().Assembly,
messageMapperRegistry);
var messagingConfiguration = new MessagingConfiguration(
messageStore: sqlMessageStore,
messageProducer: gateway,
messageMapperRegistry: messageMapperRegistry);
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new Paramore.Brighter.HandlerConfiguration(subscriberRegistry, servicesHandlerFactory))
.Policies(policyRegistry)
.TaskQueues(messagingConfiguration)
.RequestContextFactory(new Paramore.Brighter.InMemoryRequestContextFactory())
.Build();
_container.RegisterInstance <IAmACommandProcessor>(commandProcessor);
}
public static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var host = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
var subscriptions = new Subscription[]
{
new RmqSubscription <GreetingRequest>(
new SubscriptionName("paramore.example.greeting"),
new ChannelName("Greeting.Request"),
new RoutingKey("Greeting.Request"),
timeoutInMilliseconds: 200,
isDurable: true,
highAvailability: true)
};
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange")
};
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqConnection);
ChannelFactory amAChannelFactory = new ChannelFactory(rmqMessageConsumerFactory);
var producer = new RmqMessageProducer(rmqConnection);
services.AddServiceActivator(options =>
{
options.Subscriptions = subscriptions;
options.ChannelFactory = amAChannelFactory;
})
.UseInMemoryOutbox()
.UseExternalBus(
new RmqProducerRegistryFactory(
rmqConnection,
new RmqPublication[]
{
new()
{
//TODO: We don't know the reply routing key, but need a topic name, we could make this simpler
Topic = new RoutingKey("Reply"),
MakeChannels = OnMissingChannel.Assume
}
}).Create(),
true)
.AutoFromAssemblies();
services.AddHostedService <ServiceActivatorHostedService>();
})
static void Main(string[] args)
{
var container = new TinyIoCContainer();
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(GreetingEvent), typeof(GreetingEventMessageMapper) }
};
var messageStore = new InMemoryMessageStore();
var rmqConnnection = new RmqMessagingGatewayConnection
{
//AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@192.168.99.101:30672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(rmqConnnection);
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration())
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration(messageStore, producer, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
Console.WriteLine("Press <ENTER> to stop sending messages");
long loop = 0;
while (true)
{
loop++;
if (Console.KeyAvailable)
{
var key = Console.ReadKey();
if (key.Key == ConsoleKey.Enter)
{
break;
}
}
Console.WriteLine($"Sending message #{loop}");
commandProcessor.Post(new GreetingEvent($"Ian #{loop}"));
if (loop % 100 == 0)
{
Console.WriteLine("Pausing for breath...");
Task.Delay(4000).Wait();
}
}
}
private static paramore.brighter.commandprocessor.CommandProcessor CreateCommandProcesor(UnityContainer container)
{
var logger = container.Resolve <ILog>();
var handlerFactory = new UnityHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <AddOrganizationCommand, AddOrganizationCommandHandler>();
//subscriberRegistry.Register<AddOrganizationCommand, AddEFOrganisationCommandHandler>();
subscriberRegistry.Register <ChangeOrganizationCommand, ChangeOrganizationCommandHandler>();
subscriberRegistry.Register <OrganizationAddedEvent, OrganizationAddedEventHandler>();
subscriberRegistry.Register <OrganizationAddedEvent, OrganizationAddedLegacyEventHandler>();
//create retry policies
var retryPolicy = Policy
.Handle <Exception>()
.WaitAndRetry(new[]
{
TimeSpan.FromMilliseconds(50),
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(150)
});
//create circuit breaker policies
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ paramore.brighter.commandprocessor.CommandProcessor.RETRYPOLICY, retryPolicy },
{ paramore.brighter.commandprocessor.CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
};
var messageMapperFactory = new UnityMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
messageMapperRegistry.Register <AddOrganizationCommand, AddOrganizationCommandMessageMapper>();
string connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
var gateway = new RmqMessageProducer(container.Resolve <ILog>());
IAmAMessageStore <Message> sqlMessageStore = new MsSqlMessageStore(new MsSqlMessageStoreConfiguration(connectionString, "Messages", MsSqlMessageStoreConfiguration.DatabaseType.MsSqlServer), logger);
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.TaskQueues(new MessagingConfiguration(sqlMessageStore, gateway, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
return(commandProcessor);
}
public static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var host = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
var subscriptions = new Subscription[]
{
new RmqSubscription <GreetingRequest>(
new SubscriptionName("paramore.example.greeting"),
new ChannelName("Greeting.Request"),
new RoutingKey("Greeting.Request"),
timeoutInMilliseconds: 200,
isDurable: true,
highAvailability: true)
};
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange")
};
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqConnection);
ChannelFactory amAChannelFactory = new ChannelFactory(rmqMessageConsumerFactory);
var producer = new RmqMessageProducer(rmqConnection);
services.AddServiceActivator(options =>
{
options.Subscriptions = subscriptions;
options.ChannelFactory = amAChannelFactory;
})
.UseInMemoryOutbox()
.UseExternalBus(producer, true)
.AutoFromAssemblies();
services.AddHostedService <ServiceActivatorHostedService>();
})
.UseConsoleLifetime()
.UseSerilog()
.Build();
await host.RunAsync();
}
private CommandProcessor CommandProcessorRegistrar(TinyIoCContainer container)
{
//Database dao
container.Register <ITasksDAO, TasksDAO>().AsSingleton();
//create handler
var handlerFactory = new TinyIocHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry();
container.Register <IHandleRequests <AddTaskCommand>, AddTaskCommandHandler>().AsMultiInstance();
subscriberRegistry.Register <AddTaskCommand, AddTaskCommandHandler>();
//complete handler
container.Register <IHandleRequests <CompleteTaskCommand>, CompleteTaskCommandHandler>().AsMultiInstance();
subscriberRegistry.Register <CompleteTaskCommand, CompleteTaskCommandHandler>();
//create policies
var retryPolicy = Policy.Handle <Exception>().WaitAndRetry(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicy = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy }, { CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
};
//create message mappers
container.Register <IAmAMessageMapper <TaskReminderCommand>, TaskReminderCommandMessageMapper>().AsMultiInstance();
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
messageMapperRegistry.Add(typeof(TaskReminderCommand), typeof(TaskReminderCommandMessageMapper));
messageMapperRegistry.Add(typeof(TaskAddedEvent), typeof(TaskAddedEventMapper));
messageMapperRegistry.Add(typeof(TaskEditedEvent), typeof(TaskEditedEventMapper));
messageMapperRegistry.Add(typeof(TaskCompletedEvent), typeof(TaskCompletedEventMapper));
messageMapperRegistry.Add(typeof(TaskReminderSentEvent), typeof(TaskReminderSentEventMapper));
var gateway = new RmqMessageProducer();
IAmAMessageStore <Message> sqlMessageStore = new MsSqlMessageStore(new MsSqlMessageStoreConfiguration("Server=.;Database=brighterMessageStore;Trusted_Connection=True", "messages", MsSqlMessageStoreConfiguration.DatabaseType.MsSqlServer));
var commandProcessor =
CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.TaskQueues(new MessagingConfiguration(sqlMessageStore, gateway, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
container.Register <IAmACommandProcessor>(commandProcessor);
return(commandProcessor);
}
public RmqBrokerNotPreCreatedTests()
{
_message = new Message(
new MessageHeader(Guid.NewGuid(), Guid.NewGuid().ToString(), MessageType.MT_COMMAND),
new MessageBody("test content"));
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange(Guid.NewGuid().ToString())
};
_messageProducer = new RmqMessageProducer(rmqConnection, new Publication {
MakeChannels = OnMissingChannel.Validate
});
}
private CommandProcessor CommandProcessorRegistrar(TinyIoCContainer container, ILog logger)
{
//Database dao
container.Register <ITasksDAO, TasksDAO>().AsSingleton();
//create handler
var handlerFactory = new TinyIocHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry();
container.Register <IHandleRequests <AddTaskCommand>, AddTaskCommandHandler>().AsMultiInstance();
subscriberRegistry.Register <AddTaskCommand, AddTaskCommandHandler>();
//complete handler
container.Register <IHandleRequests <CompleteTaskCommand>, CompleteTaskCommandHandler>().AsMultiInstance();
subscriberRegistry.Register <CompleteTaskCommand, CompleteTaskCommandHandler>();
//create policies
var retryPolicy = Policy.Handle <Exception>().WaitAndRetry(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicy = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy }, { CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
};
//create message mappers
container.Register <IAmAMessageMapper <TaskReminderCommand>, TaskReminderCommandMessageMapper>().AsMultiInstance();
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
messageMapperRegistry.Add(typeof(TaskReminderCommand), typeof(TaskReminderCommandMessageMapper));
var ravenMessageStore = new RavenMessageStore(new EmbeddableDocumentStore().Initialize(), logger);
var gateway = new RmqMessageProducer(logger);
var commandProcessor =
CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(logger)
.TaskQueues(new MessagingConfiguration(ravenMessageStore, gateway, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
return(commandProcessor);
}
private static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var host = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
var outbox = new InMemoryOutbox();
var gatewayConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
var producer = new RmqMessageProducer(
connection: gatewayConnection,
new RmqPublication
{
MakeChannels = OnMissingChannel.Create
});
services.AddBrighter()
.UseInMemoryOutbox()
.UseExternalBus(producer)
.AutoFromAssemblies(typeof(GreetingEvent).Assembly);
services.AddSingleton <IAmAnOutboxViewer <Message> >(outbox);
services.AddHostedService <RunCommandProcessor>();
services.AddHostedService <TimedOutboxSweeper>();
}
)
.UseConsoleLifetime()
.UseSerilog()
.Build();
await host.RunAsync();
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var serviceCollection = new ServiceCollection();
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(rmqConnection);
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqConnection);
serviceCollection.AddBrighter(options =>
{
var outBox = new InMemoryOutbox();
options.ChannelFactory = new ChannelFactory(rmqMessageConsumerFactory);
options.BrighterMessaging = new BrighterMessaging(outBox, producer);
}).AutoFromAssemblies();
var serviceProvider = serviceCollection.BuildServiceProvider();
var commandProcessor = serviceProvider.GetService <IAmACommandProcessor>();
Console.WriteLine("Requesting Salutation...");
//blocking call
commandProcessor.Call <GreetingRequest, GreetingReply>(new GreetingRequest {
Name = "Ian", Language = "en-gb"
}, 2000);
Console.WriteLine("Done...");
Console.ReadLine();
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <ILoggerFactory>(new SerilogLoggerFactory());
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(rmqConnection, new RmqPublication
{
MaxOutStandingMessages = 5,
MaxOutStandingCheckIntervalMilliSeconds = 500,
WaitForConfirmsTimeOutInMilliseconds = 1000,
MakeChannels = OnMissingChannel.Create
});
serviceCollection.AddBrighter()
.UseInMemoryOutbox()
.UseExternalBus(producer, true)
.AutoFromAssemblies();
var serviceProvider = serviceCollection.BuildServiceProvider();
var commandProcessor = serviceProvider.GetService <IAmACommandProcessor>();
commandProcessor.Post(new GreetingEvent("Ian says: Hi there!"));
commandProcessor.Post(new FarewellEvent("Ian says: See you later!"));
}
public RMQMessageConsumerRetryDLQTests()
{
Guid correlationId = Guid.NewGuid();
string contentType = "text\\plain";
var channelName = $"Requeue-Limit-Tests-{Guid.NewGuid().ToString()}";
_topicName = $"Requeue-Limit-Tests-{Guid.NewGuid().ToString()}";
var routingKey = new RoutingKey(_topicName);
//what do we send
var myCommand = new MyDeferredCommand {
Value = "Hello Requeue"
};
_message = new Message(
new MessageHeader(myCommand.Id, _topicName, MessageType.MT_COMMAND, correlationId, "", contentType),
new MessageBody(JsonSerializer.Serialize((object)myCommand, JsonSerialisationOptions.Options))
);
var deadLetterQueueName = $"{_message.Header.Topic}.DLQ";
var deadLetterRoutingKey = $"{_message.Header.Topic}.DLQ";
var subscription = new RmqSubscription <MyCommand>(
name: new SubscriptionName(channelName),
channelName: new ChannelName(channelName),
routingKey: routingKey,
//after 2 retries, fail and move to the DLQ
requeueCount: 2,
//delay before re-queuing
requeueDelayInMilliseconds: 50,
deadLetterChannelName: new ChannelName(deadLetterQueueName),
deadLetterRoutingKey: deadLetterRoutingKey,
makeChannels: OnMissingChannel.Create
);
var rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange"),
DeadLetterExchange = new Exchange("paramore.brighter.exchange.dlq")
};
//how do we send to the queue
_sender = new RmqMessageProducer(rmqConnection, new RmqPublication());
//set up our receiver
_channelFactory = new ChannelFactory(new RmqMessageConsumerFactory(rmqConnection));
_channel = _channelFactory.CreateChannel(subscription);
//how do we handle a command
IHandleRequests <MyDeferredCommand> handler = new MyDeferredCommandHandler();
//hook up routing for the command processor
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <MyDeferredCommand, MyDeferredCommandHandler>();
//once we read, how do we dispatch to a handler. N.B. we don't use this for reading here
_commandProcessor = new CommandProcessor(
subscriberRegistry: subscriberRegistry,
handlerFactory: new QuickHandlerFactory(() => handler),
requestContextFactory: new InMemoryRequestContextFactory(),
policyRegistry: new PolicyRegistry()
);
//pump messages from a channel to a handler - in essence we are building our own dispatcher in this test
IAmAMessageMapper <MyDeferredCommand> mapper = new MyDeferredCommandMessageMapper(_topicName);
_messagePump = new MessagePumpBlocking <MyDeferredCommand>(_commandProcessor, mapper)
{
Channel = _channel, TimeoutInMilliseconds = 5000, RequeueCount = 3
};
_deadLetterConsumer = new RmqMessageConsumer(
connection: rmqConnection,
queueName: deadLetterQueueName,
routingKey: deadLetterRoutingKey,
isDurable: false,
makeChannels: OnMissingChannel.Assume
);
}
private static IHost BuildHost()
{
return(new HostBuilder()
.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.AddConsole();
loggingBuilder.AddDebug();
})
.ConfigureHostConfiguration(configurationBuilder =>
{
configurationBuilder.SetBasePath(Directory.GetCurrentDirectory());
configurationBuilder.AddEnvironmentVariables(prefix: "OBS_");
})
.ConfigureServices((hostContext, services) =>
{
var retryPolicy = Policy.Handle <Exception>().WaitAndRetry(new[]
{
TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicy = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var retryPolicyAsync = Policy.Handle <Exception>().WaitAndRetryAsync(new[]
{
TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicyAsync = Policy.Handle <Exception>().CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy },
{ CommandProcessor.RETRYPOLICYASYNC, retryPolicyAsync },
{ CommandProcessor.CIRCUITBREAKERASYNC, circuitBreakerPolicyAsync }
};
var messageStore = new MySqlOutbox(new MySqlOutboxConfiguration(
hostContext.Configuration["Database:Bookings"],
hostContext.Configuration["Database:MessageTableName"]
));
services.AddSingleton <IAmAnOutboxViewer <Message> >(messageStore);
var gatewayConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("hotel.booking.exchange"),
};
var producer = new RmqMessageProducer(gatewayConnection);
services.AddBrighter(options =>
{
options.PolicyRegistry = policyRegistry;
options.BrighterMessaging = new BrighterMessaging(messageStore, producer);
});
services.AddHostedService <TimedOutboxSweeper>();
})
.UseConsoleLifetime()
.Build());
}
private PipelineContinuation InitializeContainer(ICommunicationContext arg)
{
var container = new TinyIoCContainer();
container.Register <IHandleRequests <AddTaskCommand>, AddTaskCommandHandler>().AsMultiInstance();
container.Register <ITaskListRetriever, TaskListRetriever>().AsMultiInstance();
container.Register <ITasksDAO, TasksDAO>().AsMultiInstance();
var logger = LogProvider.GetLogger("TaskList");
container.Register <ILog, ILog>(logger);
container.Register <IAmARequestContextFactory, InMemoryRequestContextFactory>().AsMultiInstance();
container.Register <IAmAMessageStore <Message>, RavenMessageStore>().AsSingleton();
container.Register <IAmAMessageProducer, RmqMessageProducer>().AsSingleton();
var handlerFactory = new TinyIocHandlerFactory(container);
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <AddTaskCommand, AddTaskCommandHandler>();
//create policies
var retryPolicy = Policy
.Handle <Exception>()
.WaitAndRetry(new[]
{
TimeSpan.FromMilliseconds(50),
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
};
//create message mappers
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
messageMapperRegistry.Add(typeof(TaskReminderCommand), typeof(TaskReminderCommandMessageMapper));
//create the gateway
var gateway = new RmqMessageProducer(logger);
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(logger)
.TaskQueues(new MessagingConfiguration(
messageStore: new RavenMessageStore(new EmbeddableDocumentStore().Initialize(), logger),
messagingGateway: gateway,
messageMapperRegistry: messageMapperRegistry
))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
resolver.AddDependencyInstance <IAmACommandProcessor>(commandProcessor, DependencyLifetime.Singleton);
resolver.AddDependency <ITaskRetriever, TaskRetriever>(DependencyLifetime.Singleton);
resolver.AddDependency <ITaskListRetriever, TaskListRetriever>(DependencyLifetime.Singleton);
return(PipelineContinuation.Continue);
}
private void RegisterCommandProcessor()
{
//create handler
var subscriberRegistry = new SubscriberRegistry();
_container.Register <IHandleRequestsAsync <AddToDoCommand>, AddToDoCommandHandlerAsync>(Lifestyle.Scoped);
_container.Register <IHandleRequestsAsync <DeleteAllToDosCommand>, DeleteAllToDosCommandHandlerAsync>(Lifestyle.Scoped);
_container.Register <IHandleRequestsAsync <DeleteToDoByIdCommand>, DeleteToDoByIdCommandHandlerAsync>(Lifestyle.Scoped);
_container.Register <IHandleRequestsAsync <UpdateToDoCommand>, UpdateToDoCommandHandlerAsync>(Lifestyle.Scoped);
subscriberRegistry.RegisterAsync <AddToDoCommand, AddToDoCommandHandlerAsync>();
subscriberRegistry.RegisterAsync <DeleteAllToDosCommand, DeleteAllToDosCommandHandlerAsync>();
subscriberRegistry.RegisterAsync <DeleteToDoByIdCommand, DeleteToDoByIdCommandHandlerAsync>();
subscriberRegistry.RegisterAsync <UpdateToDoCommand, UpdateToDoCommandHandlerAsync>();
//create policies
var retryPolicy = Policy.Handle <Exception>().WaitAndRetry(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicy = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var retryPolicyAsync = Policy.Handle <Exception>().WaitAndRetryAsync(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicyAsync = Policy.Handle <Exception>().CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy },
{ CommandProcessor.RETRYPOLICYASYNC, retryPolicyAsync },
{ CommandProcessor.CIRCUITBREAKERASYNC, circuitBreakerPolicyAsync }
};
var servicesHandlerFactory = new ServicesHandlerFactoryAsync(_container);
var messagingGatewayConfiguration = RmqGatewayBuilder.With.Uri(new Uri(Configuration["RabbitMQ:Uri"])).Exchange(Configuration["RabbitMQ:Exchange"]).DefaultQueues();
var gateway = new RmqMessageProducer(messagingGatewayConfiguration);
var sqlMessageStore = new MySqlMessageStore(new MySqlMessageStoreConfiguration(Configuration["Database:MessageStore"], Configuration["Database:MessageTableName"]));
var messageMapperFactory = new MessageMapperFactory(_container);
_container.Register <IAmAMessageMapper <BulkAddToDoCommand>, BulkAddToDoMessageMapper>();
_container.Register <IAmAMessageMapper <TaskCompletedEvent>, TaskCompleteEventMessageMapper>();
_container.Register <IAmAMessageMapper <TaskCreatedEvent>, TaskCreatedEventMessageMapper>();
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(BulkAddToDoCommand), typeof(BulkAddToDoMessageMapper) },
{ typeof(TaskCompletedEvent), typeof(TaskCompleteEventMessageMapper) },
{ typeof(TaskCreatedEvent), typeof(TaskCreatedEventMessageMapper) }
};
var messagingConfiguration = new MessagingConfiguration(
messageStore: sqlMessageStore,
messageProducer: gateway,
messageMapperRegistry: messageMapperRegistry);
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new Paramore.Brighter.HandlerConfiguration(subscriberRegistry, servicesHandlerFactory))
.Policies(policyRegistry)
.TaskQueues(messagingConfiguration)
.RequestContextFactory(new Paramore.Brighter.InMemoryRequestContextFactory())
.Build();
_container.RegisterSingleton <IAmACommandProcessor>(commandProcessor);
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
// Add framework serviceProvider.
services.AddMvc();
services.AddSingleton <ITaskListRetriever, TaskListRetriever>();
services.AddSingleton <ITaskRetriever, TaskRetriever>();
services.AddSingleton <ITasksDAO, TasksDAO>();
//create handler
var subscriberRegistry = new SubscriberRegistry();
services.AddTransient <IHandleRequests <AddTaskCommand>, AddTaskCommandHandler>();
subscriberRegistry.Register <AddTaskCommand, AddTaskCommandHandler>();
//complete handler
services.AddTransient <IHandleRequests <CompleteTaskCommand>, CompleteTaskCommandHandler>();
subscriberRegistry.Register <CompleteTaskCommand, CompleteTaskCommandHandler>();
//create policies
var retryPolicy = Policy.Handle <Exception>().WaitAndRetry(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicy = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy }, { CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
};
//create message mappers
services.AddTransient <IAmAMessageMapper <TaskReminderCommand>, TaskReminderCommandMessageMapper>();
var messagingGatewayConfiguration = RmqGatewayBuilder.With.Uri(new Uri(Configuration["RabbitMQ:Uri"])).Exchange(Configuration["RabbitMQ:Exchange"]).DefaultQueues();
var gateway = new RmqMessageProducer(messagingGatewayConfiguration);
IAmAMessageStore <Message> sqlMessageStore = new SqliteMessageStore(new SqliteMessageStoreConfiguration("Data Source = tasks.db", "MessageStores"));
var container = new Container();
container.Configure(config =>
{
var servicesMessageMapperFactory = new ServicesMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(servicesMessageMapperFactory)
{
{ typeof(TaskReminderCommand), typeof(TaskReminderCommandMessageMapper) },
{ typeof(TaskAddedEvent), typeof(TaskAddedEventMapper) },
{ typeof(TaskEditedEvent), typeof(TaskEditedEventMapper) },
{ typeof(TaskCompletedEvent), typeof(TaskCompletedEventMapper) },
{ typeof(TaskReminderSentEvent), typeof(TaskReminderSentEventMapper) }
};
var servicesHandlerFactory = new ServicesHandlerFactory(container);
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, servicesHandlerFactory))
.Policies(policyRegistry)
.TaskQueues(new MessagingConfiguration(sqlMessageStore, gateway, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
config.For <IAmACommandProcessor>().Singleton().Use(() => commandProcessor);
});
container.Populate(services);
return(container.GetInstance <IServiceProvider>());
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.CreateLogger();
var container = new TinyIoCContainer();
container.Register <IHandleRequests <GreetingRequest>, GreetingRequestHandler>();
container.Register <IAmAMessageMapper <GreetingRequest>, GreetingRequestMessageMapper>();
container.Register <IAmAMessageMapper <GreetingReply>, GreetingReplyMessageMapper>();
var handlerFactory = new TinyIocHandlerFactory(container);
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <GreetingRequest, GreetingRequestHandler>();
//create policies
var retryPolicy = Policy
.Handle <Exception>()
.WaitAndRetry(new[]
{
TimeSpan.FromMilliseconds(50),
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
};
var outbox = new InMemoryOutbox();
//create message mappers
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(GreetingRequest), typeof(GreetingRequestMessageMapper) },
{ typeof(GreetingReply), typeof(GreetingReplyMessageMapper) }
};
//create the gateway
var rmqConnnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var producer = new RmqMessageProducer(rmqConnnection);
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqConnnection);
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.TaskQueues(new MessagingConfiguration(outbox, producer, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
container.Register <IAmACommandProcessor>(commandProcessor);
var dispatcher = DispatchBuilder.With()
.CommandProcessor(commandProcessor)
.MessageMappers(messageMapperRegistry)
.DefaultChannelFactory(new ChannelFactory(rmqMessageConsumerFactory))
.Connections(new Connection[]
{
new Connection <GreetingRequest>(
new ConnectionName("paramore.example.greeting"),
new ChannelName("Greeting.Request"),
new RoutingKey("Greeting.Request"),
timeoutInMilliseconds: 200,
isDurable: true,
highAvailability: true)
}).Build();
dispatcher.Receive();
Console.WriteLine("Press Enter to stop ...");
Console.ReadLine();
dispatcher.End().Wait();
}
