private void RegisterCommandProcessor(ILifetimeScope container)
{
var builder = new ContainerBuilder();
builder
.RegisterType <CreateAnEmailCommandHandler>()
.AsSelf();
IAmASubscriberRegistry subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <CreateAnEmailCommand, CreateAnEmailCommandHandler>();
IAmAHandlerFactory handlerFactory = new InMemoryHandlerFactory(container);
var handlerConfiguration = new HandlerConfiguration(subscriberRegistry, handlerFactory);
IAmARequestContextFactory requestContextFactory = new InMemoryRequestContextFactory();
var commnadProcessor = CommandProcessorBuilder
.With()
.Handlers(handlerConfiguration)
.DefaultPolicy()
.Logger(container.Resolve <ILog>())
.NoTaskQueues()
.RequestContextFactory(requestContextFactory)
.Build();
builder.Register(context => commnadProcessor)
.AsImplementedInterfaces()
.SingleInstance();
builder.Update(container.ComponentRegistry);
}
private void RegisterCommandProcessor()
{
//create handler
var servicesHandlerFactory = new ServicesHandlerFactoryAsync(_container);
var subscriberRegistry = new SubscriberRegistry();
_container.Register <IHandleRequestsAsync <AddGreetingCommand>, AddGreetingCommandHandlerAsync>(Lifestyle.Scoped);
subscriberRegistry.RegisterAsync <AddGreetingCommand, AddGreetingCommandHandlerAsync>();
//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 commandProcessor = CommandProcessorBuilder.With()
.Handlers(new Paramore.Brighter.HandlerConfiguration(subscriberRegistry, servicesHandlerFactory))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new Paramore.Brighter.InMemoryRequestContextFactory())
.Build();
_container.RegisterSingleton <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) }
};
if (new CredentialProfileStoreChain().TryGetAWSCredentials("default", out var credentials))
{
var awsConnection = new AWSMessagingGatewayConnection(credentials, RegionEndpoint.EUWest1);
var producer = new SqsMessageProducer(awsConnection);
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration())
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration(new InMemoryMessageStore(), producer, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
commandProcessor.Post(new GreetingEvent("Ian"));
}
}
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 static CommandProcessor BuildCommandProcessor()
{
var messageStore = new InMemoryMessageStore();
var container = new UnityContainer();
var messageMapperFactory = new UnityMessageMapperFactory(container);
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 producer = new MsSqlMessageProducer(gatewayConfig);
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration())
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration((IAmAMessageStore <Message>)messageStore, producer,
messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
return(commandProcessor);
}
static void Main(string[] args)
{
var logger = LogProvider.For <Program>();
var registry = new SubscriberRegistry();
registry.Register <GreetingCommand, GreetingCommandHandler>();
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(
subscriberRegistry: registry,
handlerFactory: new SimpleHandlerFactory(logger)
))
.NoPolicy()
.Logger(logger)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
commandProcessor.Send(new GreetingCommand("Ian"));
Console.ReadLine();
}
static void Main(string[] args)
{
var properties = new NameValueCollection();
properties["showDateTime"] = "true";
LogManager.Adapter = new ConsoleOutLoggerFactoryAdapter(properties);
var logger = LogManager.GetLogger(typeof(Program));
var registry = new SubscriberRegistry();
registry.Register <GreetingCommand, GreetingCommandHandler>();
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(
subscriberRegistry: registry,
handlerFactory: new SimpleHandlerFactory(logger)
))
.NoPolicy()
.Logger(logger)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
commandProcessor.Send(new GreetingCommand("Ian"));
}
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"));
}
public void Establish()
{
_myCommand.Value = "Hello World";
_fakeMessageStore = new FakeMessageStore();
_fakeMessageProducer = new FakeMessageProducer();
_message = new Message(
header:
new MessageHeader(messageId: _myCommand.Id, topic: "MyCommand", messageType: MessageType.MT_COMMAND),
body: new MessageBody(JsonConvert.SerializeObject(_myCommand))
);
var messageMapperRegistry =
new MessageMapperRegistry(new SimpleMessageMapperFactory(() => new MyCommandMessageMapper()));
messageMapperRegistry.Register <MyCommand, MyCommandMessageMapper>();
_commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(new SubscriberRegistry(), new EmptyHandlerFactory()))
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration((IAmAMessageStore <Message>)_fakeMessageStore, (IAmAMessageProducer)_fakeMessageProducer, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
}
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 redisConnection = new RedisMessagingGatewayConfiguration
{
RedisConnectionString = "localhost:6379?connectTimeout=1&sendTImeout=1000&",
MaxPoolSize = 10,
MessageTimeToLive = TimeSpan.FromMinutes(10)
};
var producer = new RedisMessageProducer(redisConnection);
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()
{
var container = new TinyIoCContainer();
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(GreetingEvent), typeof(GreetingEventMessageMapper) }
};
var messageStore = new InMemoryMessageStore();
var messagingConfiguration = new MsSqlMessagingGatewayConfiguration(@"Database=BrighterSqlQueue;Server=.\sqlexpress;Integrated Security=SSPI;", "QueueData");
var producer = new MsSqlMessageProducer(messagingConfiguration);
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration())
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration((IAmAMessageStore <Message>)messageStore, producer, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
commandProcessor.Post(new GreetingEvent("Ian"));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton <IGameRepository, GameRepository>();
services.AddDarker()
.AddHandlersFromAssemblies(typeof(GameQueryHandler).Assembly);
services.AddTransient <NewGameActionHandlerAsync>();
services.AddTransient <IAmACommandProcessor>((provider) => {
var registry = new SubscriberRegistry();
registry.RegisterAsync <NewGameAction, NewGameActionHandlerAsync>();
var commandProcessorBuilder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(registry, new ActionHandlerFactoryAsync(provider)))
.DefaultPolicy()
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory());
return(commandProcessorBuilder.Build());
});
services.AddControllers();
services.AddCors();
// Register the Swagger generator, defining 1 or more Swagger documents
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Yacht Tea API", Version = "v1"
});
});
}
public static IBrighterHandlerBuilder AddBrighter(this IServiceCollection services, Action <BrighterOptions> configure = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
var options = new BrighterOptions();
configure?.Invoke(options);
var subscriberRegistry = new AspNetSubscriberRegistry(services, options.HandlerLifetime);
var handlerFactory = new AspNetHandlerFactory(services);
var handlerConfiguration = new HandlerConfiguration(subscriberRegistry, handlerFactory, handlerFactory);
var policyBuilder = CommandProcessorBuilder.With()
.Handlers(handlerConfiguration);
var messagingBuilder = options.PolicyRegistry == null
? policyBuilder.DefaultPolicy()
: policyBuilder.Policies(options.PolicyRegistry);
var builder = options.MessagingConfiguration == null
? messagingBuilder.NoTaskQueues()
: messagingBuilder.TaskQueues(options.MessagingConfiguration);
var commandProcessor = builder
.RequestContextFactory(options.RequestContextFactory)
.Build();
services.AddSingleton <IAmACommandProcessor>(commandProcessor);
return(new AspNetHandlerBuilder(services, subscriberRegistry));
}
public PostCommandTests()
{
_myCommand.Value = "Hello World";
_fakeOutboxSync = new FakeOutboxSync();
_fakeMessageProducerWithPublishConfirmation = new FakeMessageProducerWithPublishConfirmation();
const string topic = "MyCommand";
_message = new Message(
new MessageHeader(_myCommand.Id, topic, MessageType.MT_COMMAND),
new MessageBody(JsonSerializer.Serialize(_myCommand, JsonSerialisationOptions.Options))
);
var messageMapperRegistry =
new MessageMapperRegistry(new SimpleMessageMapperFactory((_) => new MyCommandMessageMapper()));
messageMapperRegistry.Register <MyCommand, MyCommandMessageMapper>();
_commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(new SubscriberRegistry(), new EmptyHandlerFactorySync()))
.DefaultPolicy()
.ExternalBus(new ExternalBusConfiguration(
new ProducerRegistry(new Dictionary <string, IAmAMessageProducer>()
{
{ topic, _fakeMessageProducerWithPublishConfirmation },
}),
messageMapperRegistry),
_fakeOutboxSync)
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
}
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);
}
private static CommandProcessor BuildCommandProcessor(IServiceProvider provider)
{
var options = provider.GetService <IBrighterOptions>();
var subscriberRegistry = provider.GetService <ServiceCollectionSubscriberRegistry>();
var handlerFactory = new ServiceProviderHandlerFactory(provider);
var handlerConfiguration = new HandlerConfiguration(subscriberRegistry, handlerFactory, handlerFactory);
var messageMapperRegistry = MessageMapperRegistry(provider);
var policyBuilder = CommandProcessorBuilder.With()
.Handlers(handlerConfiguration);
var messagingBuilder = options.PolicyRegistry == null
? policyBuilder.DefaultPolicy()
: policyBuilder.Policies(options.PolicyRegistry);
var builder = options.BrighterMessaging == null
? messagingBuilder.NoTaskQueues()
: messagingBuilder.TaskQueues(new MessagingConfiguration(options.BrighterMessaging.MessageStore, options.BrighterMessaging.Producer, messageMapperRegistry));
var commandProcessor = builder
.RequestContextFactory(options.RequestContextFactory)
.Build();
return(commandProcessor);
}
public void Establish()
{
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory(() => new MyEventMessageMapper()));
messageMapperRegistry.Register <MyEvent, MyEventMessageMapper>();
var policyRegistry = new PolicyRegistry
{
{
CommandProcessor.RETRYPOLICY, Policy
.Handle <Exception>()
.WaitAndRetry(new[] { TimeSpan.FromMilliseconds(50) })
},
{
CommandProcessor.CIRCUITBREAKER, Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(500))
}
};
var connection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(connection);
var rmqMessageProducerFactory = new RmqMessageProducerFactory(connection);
var connections = new List <Connection>
{
new Connection(
new ConnectionName("foo"),
new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory),
typeof(MyEvent),
new ChannelName("mary"),
"bob",
timeoutInMilliseconds: 200),
new Connection(
new ConnectionName("bar"),
new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory),
typeof(MyEvent),
new ChannelName("alice"),
"simon",
timeoutInMilliseconds: 200)
};
_builder = DispatchBuilder.With()
.CommandProcessor(CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(new SubscriberRegistry(),
new TinyIocHandlerFactory(new TinyIoCContainer())))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build()
)
.MessageMappers(messageMapperRegistry)
.ChannelFactory(new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory))
.Connections(connections);
}
public GreetingService()
{
log4net.Config.XmlConfigurator.Configure();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
container.Register <IHandleRequests <GreetingCommand>, GreetingCommandHandler>();
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <GreetingCommand, GreetingCommandHandler>();
//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(GreetingCommand), typeof(GreetingCommandMessageMapper) }
};
//create the gateway
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory();
var rmqMessageProducerFactory = new RmqMessageProducerFactory();
var builder = DispatchBuilder
.With()
.CommandProcessor(CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build()
)
.MessageMappers(messageMapperRegistry)
.ChannelFactory(new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory))
.ConnectionsFromConfiguration();
_dispatcher = builder.Build();
}
public void CreateShouldReturnBuilder()
{
// Act.
var config = CommandProcessorBuilder.Create();
// Assert.
Assert.NotNull(config);
}
private static CommandProcessor BuildCommandProcessor(IServiceProvider provider)
{
var options = provider.GetService <IBrighterOptions>();
var subscriberRegistry = provider.GetService <ServiceCollectionSubscriberRegistry>();
var handlerFactory = new ServiceProviderHandlerFactory(provider);
var handlerConfiguration = new HandlerConfiguration(subscriberRegistry, handlerFactory, handlerFactory);
var messageMapperRegistry = MessageMapperRegistry(provider);
var policyBuilder = CommandProcessorBuilder.With()
.Handlers(handlerConfiguration);
var messagingBuilder = options.PolicyRegistry == null
? policyBuilder.DefaultPolicy()
: policyBuilder.Policies(options.PolicyRegistry);
var loggerFactory = provider.GetService <ILoggerFactory>();
ApplicationLogging.LoggerFactory = loggerFactory;
INeedARequestContext taskQueuesBuilder;
if (options.ChannelFactory is null)
{
//TODO: Need to add async outbox
taskQueuesBuilder = options.BrighterMessaging == null
? messagingBuilder.NoTaskQueues()
: messagingBuilder.TaskQueues(new MessagingConfiguration(options.BrighterMessaging.OutBox,
options.BrighterMessaging.AsyncOutBox, options.BrighterMessaging.Producer,
options.BrighterMessaging.AsyncProducer, messageMapperRegistry));
}
else
{
if (options.BrighterMessaging == null)
{
taskQueuesBuilder = messagingBuilder.NoTaskQueues();
}
else
{
taskQueuesBuilder = options.BrighterMessaging.UseRequestReplyQueues
? messagingBuilder.RequestReplyQueues(new MessagingConfiguration(
options.BrighterMessaging.OutBox,
options.BrighterMessaging.Producer, messageMapperRegistry,
responseChannelFactory: options.ChannelFactory))
: messagingBuilder.TaskQueues(new MessagingConfiguration(options.BrighterMessaging.OutBox,
options.BrighterMessaging.AsyncOutBox, options.BrighterMessaging.Producer,
options.BrighterMessaging.AsyncProducer, messageMapperRegistry));
}
}
var commandProcessor = taskQueuesBuilder
.RequestContextFactory(options.RequestContextFactory)
.Build();
return(commandProcessor);
}
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...");
}
public void BuildShouldCreateProcessor()
{
// Act.
var processor = CommandProcessorBuilder.Create()
.Build();
// Assert.
Assert.NotNull(processor);
}
public DispatchBuilderTests()
{
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory((_) => new MyEventMessageMapper()));
messageMapperRegistry.Register <MyEvent, MyEventMessageMapper>();
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 rmqConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange")
};
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqConnection);
var container = new ServiceCollection();
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(new SubscriberRegistry(), (IAmAHandlerFactory) new ServiceProviderHandlerFactory(container.BuildServiceProvider())))
.Policies(new PolicyRegistry
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
})
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
_builder = DispatchBuilder.With()
.CommandProcessor(commandProcessor)
.MessageMappers(messageMapperRegistry)
.DefaultChannelFactory(new ChannelFactory(rmqMessageConsumerFactory))
.Connections(new []
{
new Connection <MyEvent>(
new ConnectionName("foo"),
new ChannelName("mary"),
new RoutingKey("bob"),
timeoutInMilliseconds: 200),
new Connection <MyEvent>(
new ConnectionName("bar"),
new ChannelName("alice"),
new RoutingKey("simon"),
timeoutInMilliseconds: 200)
});
}
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 void StartDispatcher(IContainer container)
{
var handlerFactory = container.Resolve <IAmAHandlerFactory>();
var messageMapperFactory = container.Resolve <IAmAMessageMapperFactory>();
var options = container.Resolve <IOptions <FourSettings> >();
var authSettings = options.Value;
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <ArticoloCreated, ArticoloCreatedEventHandler>();
subscriberRegistry.Register <ClienteCreated, ClienteCreatedEventHandler>();
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(ArticoloCreated), typeof(ArticoloCreatedMapper) },
{ typeof(ClienteCreated), typeof(ClienteCreatedMapper) },
};
var handlerConfiguration = new HandlerConfiguration(subscriberRegistry, handlerFactory);
var rmqConnnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri(authSettings.RabbitMq.Uri)),
Exchange = new Exchange(authSettings.RabbitMq.Events, "topic")
};
this._commandProcessor = CommandProcessorBuilder.With()
.Handlers(handlerConfiguration)
.Policies(PolicyRegistry())
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
this._dispatcher = DispatchBuilder.With()
.CommandProcessor(this._commandProcessor)
.MessageMappers(messageMapperRegistry)
.DefaultChannelFactory(new InputChannelFactory(new RmqMessageConsumerFactory(rmqConnnection)))
.Connections(new Connection[]
{
new Connection <ArticoloCreated>(new ConnectionName("ArticoloCreatedEvent"),
new ChannelName("ArticoloCreated"),
new RoutingKey("ArticoloCreated"),
timeoutInMilliseconds: 200),
new Connection <ClienteCreated>(new ConnectionName("ClienteCreatedEvent"),
new ChannelName("ClienteCreated"),
new RoutingKey("ClienteCreated"),
timeoutInMilliseconds: 200),
}).Build();
this._dispatcher.Receive();
}
private static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("usage: MultipleSender <count>");
Console.WriteLine("eg : MultipleSender 500");
return;
}
if (!int.TryParse(args[0], out int repeatCount))
{
Console.WriteLine($"{args[0]} is not a valid number");
return;
}
var container = new TinyIoCContainer();
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{ typeof(CompetingConsumerCommand), typeof(CompetingConsumerCommandMessageMapper) }
};
var outbox = new InMemoryOutbox();
var messagingConfiguration =
new MsSqlMessagingGatewayConfiguration(
@"Database=BrighterSqlQueue;Server=.\sqlexpress;Integrated Security=SSPI;", "QueueData");
var producer = new MsSqlMessageProducer(messagingConfiguration);
var builder = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration())
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration((IAmAnOutbox <Message>)outbox, producer, messageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory());
var commandProcessor = builder.Build();
using (new TransactionScope(TransactionScopeOption.RequiresNew,
new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
},
TransactionScopeAsyncFlowOption.Enabled))
{
Console.WriteLine($"Sending {repeatCount} command messages");
var sequenceNumber = 1;
for (int i = 0; i < repeatCount; i++)
{
commandProcessor.Post(new CompetingConsumerCommand(sequenceNumber++));
}
// We do NOT complete the transaction here to show that a message is
// always queued, whether the transaction commits or aborts!
}
}
public PipelineInvoker(string requestId, TraceWriter traceWriter, Assembly coreAssembly, IAmAMessageProducer producer = null)
{
// todo: logger is static, but traceWriter is not. probably bad.
Log.Logger = new LoggerConfiguration()
.WriteTo.Sink(new TraceWriterSink(traceWriter))
.CreateLogger();
// todo: again, logg provider is static, but traceWriter is not. probably bad.
// yep, turns out this doesn't work at all
//LogProvider.SetCurrentLogProvider(new TraceWriterLogProvider(log));
TinyIoCContainer.Current.Register(Log.Logger);
if (_handlerConfig == null)
{
lock (_initialisationLock)
{
if (_handlerConfig == null)
{
Log.Logger.Information("Initialising ({requestId})...", requestId);
_initialisedByRequestId = requestId;
_handlerConfig = new HandlerConfig();
_handlerConfig.RegisterDefaultHandlers();
_handlerConfig.RegisterMappersFromAssembly(coreAssembly);
_handlerConfig.RegisterSubscribersFromAssembly(coreAssembly);
if (producer != null)
{
_commandProcessor = CommandProcessorBuilder.With()
.Handlers(_handlerConfig.HandlerConfiguration)
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration(new InMemoryMessageStore(), producer, _handlerConfig.MessageMapperRegistry))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
}
else
{
_commandProcessor = CommandProcessorBuilder.With()
.Handlers(_handlerConfig.HandlerConfiguration)
.DefaultPolicy()
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
}
TinyIoCContainer.Current.Register <IAmACommandProcessor>(_commandProcessor);
}
}
}
else
{
Log.Logger.Information("Already initialised by {requestId}", _initialisedByRequestId);
}
}
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);
}
public StoreService()
{
log4net.Config.XmlConfigurator.Configure();
var logger = LogProvider.For <StoreService>();
var container = new UnityContainer();
container.RegisterInstance(typeof(ILog), LogProvider.For <StoreService>(), new ContainerControlledLifetimeManager());
container.RegisterType <IProductsDAO, ProductsDAO>();
container.RegisterType <ILastReadFeedItemDAO, LastReadFeedItemDAO>();
container.RegisterType <AddProductCommandHandler>();
container.RegisterType <ChangeProductCommandHandler>();
container.RegisterType <RemoveProductCommandHandler>();
var handlerFactory = new UnityHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry
{
{ typeof(AddProductCommand), typeof(AddProductCommandHandler) },
{ typeof(ChangeProductCommand), typeof(ChangeProductCommandHandler) },
{ typeof(RemoveProductCommand), typeof(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 commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(logger)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
_consumer = new Consumer(new LastReadFeedItemDAO(), commandProcessor, logger);
}
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();
}
}
}
