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"));
}
public MagnetClient(
MessageMapperFactory messageMapper,
IMessageStreamClient messageStreamClient,
MagnetOptions options)
{
MessageMapper = messageMapper;
MessageStreamClient = messageStreamClient;
Options = options;
}
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);
}
private static Dispatcher CreateDispatcher(
Container container,
List <Connection> connections, RmqMessageConsumerFactory rmqMessageConsumerFactory,
RmqMessageProducerFactory rmqMessageProducerFactory
)
{
var handlerFactoryAsync = new ServicesHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <BulkAddToDoCommand>, BulkAddToDoCommandHandlerAsync>();
var messageMapperFactory = new MessageMapperFactory(container);
container.Register <IAmAMessageMapper <BulkAddToDoCommand>, BulkAddToDoMessageMapper>();
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.RegisterAsync <BulkAddToDoCommand, BulkAddToDoCommandHandlerAsync>();
//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 }
};
//create message mappers
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(BulkAddToDoCommand), typeof(BulkAddToDoMessageMapper) }
};
var builder = DispatchBuilder
.With()
.CommandProcessor(CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactoryAsync))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build()
)
.MessageMappers(messageMapperRegistry)
.DefaultChannelFactory(new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory))
.Connections(connections);
var dispatcher = builder.Build();
return(dispatcher);
}
public bool Start(HostControl hostControl)
{
log4net.Config.XmlConfigurator.Configure();
var handlers = new HandlerFactory(_container);
var mappers = new MessageMapperFactory(_container);
var config = new HandlerConfig(mappers, handlers);
RegisterHandlers(config);
_dispatcher = BuildDispatcher(config);
_container.Register <IAmACommandProcessor>(_dispatcher.CommandProcessor);
_dispatcher.Receive();
return(true);
}
public HandlerConfig(MessageMapperFactory mappers, HandlerFactory handlers)
{
_mappers = mappers;
_handlers = handlers;
}
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 static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.AddEnvironmentVariables();
var configuration = builder.Build();
Log.Logger = new LoggerConfiguration()
.WriteTo.LiterateConsole()
.CreateLogger();
var container = new Container();
var handlerFactory = new HandlerFactory(container);
var messageMapperFactory = new MessageMapperFactory(container);
container.Register <IHandleRequests <GreetingEvent>, GreetingEventHandler>();
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <GreetingEvent, GreetingEventHandler>();
//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)
{
{ typeof(GreetingEvent), typeof(GreetingEventMessageMapper) }
};
var amqpUri = configuration["BABEL_BROKER"];
//create the gateway
var rmqConnnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri(amqpUri)),
//AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqConnnection);
var dispatcher = DispatchBuilder.With()
.CommandProcessor(CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build())
.MessageMappers(messageMapperRegistry)
.DefaultChannelFactory(new InputChannelFactory(rmqMessageConsumerFactory, null))
.Connections(new Connection[]
{
new Connection <GreetingEvent>(
new ConnectionName("paramore.example.greeting"),
new ChannelName("greeting.event"),
new RoutingKey("greeting.event"),
timeoutInMilliseconds: 200)
}).Build();
dispatcher.Receive();
Console.WriteLine("Press Enter to stop ...");
Console.ReadLine();
dispatcher.End().Wait();
}
