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);
}
public static void Run(UnityContainer container)
{
container.RegisterType <FeedController>();
container.RegisterType <ProductsController>();
container.RegisterInstance(typeof(ILog), LogProvider.For <ProductService>(), new ContainerControlledLifetimeManager());
container.RegisterType <IProductsDAO, ProductsDAO>();
container.RegisterType <AddProductCommandHandler>();
container.RegisterType <ChangeProductCommandHandler>();
container.RegisterType <ProductAddedEventHandler>();
container.RegisterType <ProductChangedEventHandler>();
container.RegisterType <ProductRemovedEventHandler>();
container.RegisterType <RemoveProductCommandHandler>();
var handlerFactory = new UnityHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry
{
{ typeof(AddProductCommand), typeof(AddProductCommandHandler) },
{ typeof(ChangeProductCommand), typeof(ChangeProductCommandHandler) },
{ typeof(RemoveProductCommand), typeof(RemoveProductCommandHandler) },
{ typeof(ProductAddedEvent), typeof(ProductAddedEventHandler) },
{ typeof(ProductRemovedEvent), typeof(ProductRemovedEventHandler) },
};
//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 commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(container.Resolve <ILog>())
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
container.RegisterInstance(typeof(IAmACommandProcessor), commandProcessor);
}
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);
}
private static Dispatcher BuildDispatcher()
{
var container = new UnityContainer();
var handlerFactory = new UnityHandlerFactory(container);
// var asyncHandlerFactory = new UnityAsyncHandlerFactory(container);
var messageMapperFactory = new UnityMessageMapperFactory(container);
container.RegisterType <IHandleRequests <GreetingEvent>, GreetingEventHandler>();
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <GreetingEvent, GreetingEventHandler>();
subscriberRegistry.Register <GreetingCommand, GreetingCommandHandler>();
//create message mappers
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(GreetingEvent), typeof(GreetingEventMessageMapper) }
};
var connectionString = @"Database=BrighterSqlQueue;Server=localhost;Integrated Security=SSPI;";
var gatewayConfig = new MsSqlMessagingGatewayConfiguration(connectionString, "QueueData");
var messageConsumerFactory = new MsSqlMessageConsumerFactory(gatewayConfig);
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.DefaultPolicy()
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
var dispatcher = DispatchBuilder.With()
.CommandProcessor(commandProcessor)
.MessageMappers(messageMapperRegistry)
.DefaultChannelFactory(new MsSqlInputChannelFactory(messageConsumerFactory))
.Connections(new Connection[]
{
new Connection <GreetingEvent>(
new ConnectionName("paramore.example.greeting"),
new ChannelName("greeting.event"),
new RoutingKey("greeting.event"),
timeoutInMilliseconds: 200)
}
).Build();
container.RegisterInstance <IAmACommandProcessor>(commandProcessor);
container.RegisterType <IHandleRequests <GreetingCommand>, GreetingCommandHandler>();
container.RegisterType <MyValidationHandler <GreetingCommand>, GreetingCommandValidationHandler>();
container.RegisterType <MyPostAuditHandler <GreetingCommand>, GreetingCommandPostAuditHandler>();
return(dispatcher);
}
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 commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
return(commandProcessor);
}
public static void Run(UnityContainer container)
{
container.RegisterType <DomainController>();
container.RegisterType <FeedController>();
container.RegisterType <JoinController>();
container.RegisterType <MessageController>();
container.RegisterType <PipeController>();
container.RegisterType <IAmARepository <Domain>, InMemoryDomainRepository>(new ContainerControlledLifetimeManager());
container.RegisterType <IAmARepository <Feed>, InMemoryFeedRepository>(new ContainerControlledLifetimeManager());
container.RegisterType <IAmARepository <Pipe>, InMemoryPipeRepository>(new ContainerControlledLifetimeManager());
container.RegisterType <IAmARepository <Join>, InMemoryJoinRepository>(new ContainerControlledLifetimeManager());
container.RegisterType <IAmACredentialStore, CredentialStore>(new ContainerControlledLifetimeManager());
container.AddNewExtension <Log4NetExtension>();
container.RegisterType <AddFeedCommandHandler>();
container.RegisterType <AddFeedToDomainCommandHandler>();
container.RegisterType <AddJoinCommandHandler>();
container.RegisterType <AddJoinToFeedCommandHandler>();
container.RegisterType <AddJoinToPipeCommandHandler>();
container.RegisterType <AddMessageToFeedCommandHandler>();
container.RegisterType <AddPipeCommandHandler>();
container.RegisterType <AddPipeToDomainCommandHandler>();
container.RegisterType <DeleteFeedCommandHandler>();
container.RegisterType <DeleteMessageCommandHandler>();
container.RegisterType <DeletePipeCommandHandler>();
container.RegisterType <RemoveFeedFromDomainCommandHandler>();
container.RegisterType <CacheCleaningHandler>();
var handlerFactory = new UnityHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry
{
{ typeof(AddFeedCommand), typeof(AddFeedCommandHandler) },
{ typeof(AddFeedToDomainCommand), typeof(AddFeedToDomainCommandHandler) },
{ typeof(AddJoinCommand), typeof(AddJoinCommandHandler) },
{ typeof(AddJoinToFeedCommand), typeof(AddJoinToFeedCommandHandler) },
{ typeof(AddJoinToPipeCommand), typeof(AddJoinToPipeCommandHandler) },
{ typeof(AddMessageToFeedCommand), typeof(AddMessageToFeedCommandHandler) },
{ typeof(AddPipeCommand), typeof(AddPipeCommandHandler) },
{ typeof(AddPipeToDomainCommand), typeof(AddPipeToDomainCommandHandler) },
{ typeof(DeleteFeedCommand), typeof(DeleteFeedCommandHandler) },
{ typeof(DeleteMessageCommand), typeof(DeleteMessageCommandHandler) },
{ typeof(DeletePipeCommand), typeof(DeletePipeCommandHandler) },
{ typeof(RemoveFeedFromDomainCommand), typeof(RemoveFeedFromDomainCommandHandler) },
{ typeof(InvalidateCacheCommand), typeof(CacheCleaningHandler) }
};
//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 commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
container.RegisterInstance(typeof(IAmACommandProcessor), commandProcessor);
}
public static void Run(UnityContainer container)
{
container.RegisterType <FeedController>();
container.RegisterType <ProductsController>();
container.RegisterInstance(typeof(ILog), LogProvider.For <ProductService>(), new ContainerControlledLifetimeManager());
container.RegisterType <IProductsDAO, ProductsDAO>();
container.RegisterType <AddProductCommandHandler>();
container.RegisterType <ChangeProductCommandHandler>();
container.RegisterType <ProductAddedEventHandler>();
container.RegisterType <ProductChangedEventHandler>();
container.RegisterType <ProductRemovedEventHandler>();
container.RegisterType <RemoveProductCommandHandler>();
var storage = new AtomEventsInFiles(new DirectoryInfo(Globals.StoragePath));
var serializer = new DataContractContentSerializer(
DataContractContentSerializer
.CreateTypeResolver(typeof(ProductEntry).Assembly)
);
var events = new FifoEvents <ProductEntry>(
Globals.EventStreamId,
storage,
serializer);
container.RegisterInstance(typeof(IObserver <ProductEntry>), events, new TransientLifetimeManager());
var handlerFactory = new UnityHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry
{
{ typeof(AddProductCommand), typeof(AddProductCommandHandler) },
{ typeof(ChangeProductCommand), typeof(ChangeProductCommandHandler) },
{ typeof(RemoveProductCommand), typeof(RemoveProductCommandHandler) },
{ typeof(ProductAddedEvent), typeof(ProductAddedEventHandler) },
{ typeof(ProductRemovedEvent), typeof(ProductRemovedEventHandler) },
};
//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 commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(container.Resolve <ILog>())
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
container.RegisterInstance(typeof(IAmACommandProcessor), commandProcessor);
}
