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"));
}
public MessageDispatcherRoutingTests()
{
_channel = new FakeChannel();
_commandProcessor = new SpyCommandProcessor();
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory((_) => new MyEventMessageMapper()));
messageMapperRegistry.Register <MyEvent, MyEventMessageMapper>();
var connection = new Subscription <MyEvent>(
new SubscriptionName("test"),
noOfPerformers: 1,
timeoutInMilliseconds: 1000,
channelFactory: new InMemoryChannelFactory(_channel),
channelName: new ChannelName("fakeChannel"),
routingKey: new RoutingKey("fakekey"));
_dispatcher = new Dispatcher(_commandProcessor, messageMapperRegistry, new List <Subscription> {
connection
});
var @event = new MyEvent();
var message = new MyEventMessageMapper().MapToMessage(@event);
_channel.Enqueue(message);
_dispatcher.State.Should().Be(DispatcherState.DS_AWAITING);
_dispatcher.Receive();
}
public DispatcherRestartConnectionTests()
{
_channel = new FakeChannel();
_commandProcessor = new SpyCommandProcessor();
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory((_) => new MyEventMessageMapper()));
messageMapperRegistry.Register <MyEvent, MyEventMessageMapper>();
_connection = new Connection <MyEvent>(new ConnectionName("test"), noOfPerformers: 1, timeoutInMilliseconds: 100, channelFactory: new InMemoryChannelFactory(_channel), channelName: new ChannelName("fakeChannel"), routingKey: new RoutingKey("fakekey"));
_newConnection = new Connection <MyEvent>(new ConnectionName("newTest"), noOfPerformers: 1, timeoutInMilliseconds: 100, channelFactory: new InMemoryChannelFactory(_channel), channelName: new ChannelName("fakeChannel"), routingKey: new RoutingKey("fakekey"));
_dispatcher = new Dispatcher(_commandProcessor, messageMapperRegistry, new List <Connection> {
_connection, _newConnection
});
var @event = new MyEvent();
var message = new MyEventMessageMapper().MapToMessage(@event);
_channel.Enqueue(message);
_dispatcher.State.Should().Be(DispatcherState.DS_AWAITING);
_dispatcher.Receive();
Task.Delay(250).Wait();
_dispatcher.Shut("test");
_dispatcher.Shut("newTest");
Task.Delay(1000).Wait();
_dispatcher.Consumers.Should().HaveCount(0);
}
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 MessageDispatcherShutConnectionTests()
{
var channel = new FakeChannel();
IAmACommandProcessor commandProcessor = new SpyCommandProcessor();
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory(() => new MyEventMessageMapper()));
messageMapperRegistry.Register <MyEvent, MyEventMessageMapper>();
_connection = new Connection <MyEvent>(new ConnectionName("test"), noOfPerformers: 3, timeoutInMilliseconds: 1000, channelFactory: new InMemoryChannelFactory(channel), channelName: new ChannelName("fakeChannel"), routingKey: new RoutingKey("fakekey"));
_dispatcher = new Dispatcher(commandProcessor, messageMapperRegistry, new List <Connection> {
_connection
});
var @event = new MyEvent();
var message = new MyEventMessageMapper().MapToMessage(@event);
for (var i = 0; i < 6; i++)
{
channel.Add(message);
}
_dispatcher.State.Should().Be(DispatcherState.DS_AWAITING);
_dispatcher.Receive();
}
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>();
var retryPolicy = Policy
.Handle <Exception>()
.RetryAsync();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(1));
_commandProcessor = new CommandProcessor(
new InMemoryRequestContextFactory(),
new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICYASYNC, retryPolicy }, { CommandProcessor.CIRCUITBREAKERASYNC, circuitBreakerPolicy }
},
messageMapperRegistry,
(IAmAMessageStoreAsync <Message>)_fakeMessageStore,
(IAmAMessageProducerAsync)_fakeMessageProducer);
}
public CommandProcessorNoOutboxTests()
{
_myCommand.Value = "Hello World";
_fakeMessageProducer = new FakeMessageProducer();
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory((_) => new MyCommandMessageMapper()));
messageMapperRegistry.Register <MyCommand, MyCommandMessageMapper>();
var retryPolicy = Policy
.Handle <Exception>()
.Retry();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(1));
_commandProcessor = new CommandProcessor(
new InMemoryRequestContextFactory(),
new PolicyRegistry {
{ CommandProcessor.RETRYPOLICY, retryPolicy }, { CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
},
messageMapperRegistry,
null,
(IAmAMessageProducer)_fakeMessageProducer);
}
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);
}
public CommandProcessorDepositPostTestsAsync()
{
_myCommand.Value = "Hello World";
_fakeOutbox = new FakeOutbox();
_fakeMessageProducer = new FakeMessageProducer();
_message = new Message(
new MessageHeader(_myCommand.Id, "MyCommand", MessageType.MT_COMMAND),
new MessageBody(JsonConvert.SerializeObject(_myCommand))
);
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory((_) => new MyCommandMessageMapper()));
messageMapperRegistry.Register <MyCommand, MyCommandMessageMapper>();
var retryPolicy = Policy
.Handle <Exception>()
.RetryAsync();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(1));
PolicyRegistry policyRegistry = new PolicyRegistry {
{ CommandProcessor.RETRYPOLICYASYNC, retryPolicy }, { CommandProcessor.CIRCUITBREAKERASYNC, circuitBreakerPolicy }
};
_commandProcessor = new CommandProcessor(
new InMemoryRequestContextFactory(),
policyRegistry,
messageMapperRegistry,
(IAmAnOutboxAsync <Message>)_fakeOutbox,
(IAmAMessageProducerAsync)_fakeMessageProducer);
}
public CommandProcessorWithInMemoryOutboxTests()
{
_myCommand.Value = "Hello World";
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>();
var retryPolicy = Policy
.Handle <Exception>()
.Retry();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(1));
_commandProcessor = new CommandProcessor(
new InMemoryRequestContextFactory(),
new PolicyRegistry {
{ CommandProcessor.RETRYPOLICY, retryPolicy }, { CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
},
messageMapperRegistry,
_outbox,
new ProducerRegistry(new Dictionary <string, IAmAMessageProducer>()
{
{ topic, _fakeMessageProducerWithPublishConfirmation },
}));
}
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 CommandProcessorPostBoxClearTests()
{
var myCommand = new MyCommand {
Value = "Hello World"
};
_fakeOutbox = new FakeOutbox();
_fakeMessageProducer = new FakeMessageProducer();
_message = new Message(
new MessageHeader(myCommand.Id, "MyCommand", MessageType.MT_COMMAND),
new MessageBody(JsonSerializer.Serialize(myCommand, JsonSerialisationOptions.Options))
);
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory((_) => new MyCommandMessageMapper()));
messageMapperRegistry.Register <MyCommand, MyCommandMessageMapper>();
var retryPolicy = Policy
.Handle <Exception>()
.Retry();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(1));
_commandProcessor = new CommandProcessor(
new InMemoryRequestContextFactory(),
new PolicyRegistry {
{ CommandProcessor.RETRYPOLICY, retryPolicy }, { CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
},
messageMapperRegistry,
(IAmAnOutbox <Message>)_fakeOutbox,
(IAmAMessageProducer)_fakeMessageProducer);
}
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()
{
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"));
}
protected override void ConfigureApplicationContainer(TinyIoCContainer container)
{
base.ConfigureApplicationContainer(container);
var logger = LogProvider.GetLogger(this.GetType().Namespace);
container.Register(logger);
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register<AddTaskCommand, AddTaskCommandHandler>();
subscriberRegistry.Register<CompleteTaskCommand, CompleteTaskCommandHandler>();
container.Register<IHandleRequests<AddTaskCommand>, AddTaskCommandHandler>().AsMultiInstance();
container.Register<IHandleRequests<CompleteTaskCommand>, CompleteTaskCommandHandler>().AsMultiInstance();
var handlerFactory = new TinyIoCHandlerFactory(container);
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 sqlMessageStore = new MsSqlMessageStore(new MsSqlMessageStoreConfiguration("Server=.;Database=brighterMessageStore;Trusted_Connection=True", "messages", MsSqlMessageStoreConfiguration.DatabaseType.MsSqlServer), logger);
var gateway = new AzureServiceBusMessageProducer(logger);
container.Register<IAmAMessageMapper<TaskReminderCommand>, TaskReminderCommandMessageMapper>().AsMultiInstance();
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
messageMapperRegistry.Add(typeof(TaskReminderCommand), typeof(TaskReminderCommandMessageMapper));
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);
}
public CommandProcessorNoMessageMapperTests()
{
_myCommand.Value = "Hello World";
_fakeMessageStore = new FakeMessageStore();
_fakeMessageProducer = new FakeMessageProducer();
_message = new Message(
new MessageHeader(_myCommand.Id, "MyCommand", MessageType.MT_COMMAND),
new MessageBody(JsonConvert.SerializeObject(_myCommand))
);
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory(() => new MyCommandMessageMapper()));
var retryPolicy = Policy
.Handle <Exception>()
.Retry();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(1));
_commandProcessor = new CommandProcessor(
new InMemoryRequestContextFactory(),
new PolicyRegistry {
{ CommandProcessor.RETRYPOLICY, retryPolicy }, { CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
},
messageMapperRegistry,
(IAmAMessageStore <Message>)_fakeMessageStore,
(IAmAMessageProducer)_fakeMessageProducer);
}
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 void Establish()
{
_channel = new FakeChannel();
_commandProcessor = new SpyCommandProcessor();
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory(() => new MyEventMessageMapper()));
messageMapperRegistry.Register <MyEvent, MyEventMessageMapper>();
var connection = new Connection(
name: new ConnectionName("test"),
dataType: typeof(MyEvent),
noOfPerformers: 1,
timeoutInMilliseconds: 1000,
channelFactory: new InMemoryChannelFactory(_channel),
channelName: new ChannelName("fakeChannel"),
routingKey: "fakekey");
_dispatcher = new Dispatcher(_commandProcessor, messageMapperRegistry, new List <Connection> {
connection
});
var @event = new MyEvent();
var message = new MyEventMessageMapper().MapToMessage(@event);
_channel.Add(message);
Assert.AreEqual(DispatcherState.DS_AWAITING, _dispatcher.State);
_dispatcher.Receive();
}
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 CommandProcessorCallTestsNoTimeout()
{
_myRequest.RequestValue = "Hello World";
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory((type) =>
{
if (type == typeof(MyRequestMessageMapper))
{
return(new MyRequestMessageMapper());
}
if (type == typeof(MyResponseMessageMapper))
{
return(new MyResponseMessageMapper());
}
throw new ConfigurationException($"No mapper found for {type.Name}");
}));
messageMapperRegistry.Register <MyRequest, MyRequestMessageMapper>();
messageMapperRegistry.Register <MyResponse, MyResponseMessageMapper>();
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <MyResponse, MyResponseHandler>();
var handlerFactory = new TestHandlerFactorySync <MyResponse, MyResponseHandler>(() => new MyResponseHandler());
var retryPolicy = Policy
.Handle <Exception>()
.Retry();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(1));
var replySubs = new List <Subscription>
{
new Subscription <MyResponse>()
};
_commandProcessor = new CommandProcessor(
subscriberRegistry,
handlerFactory,
new InMemoryRequestContextFactory(),
new PolicyRegistry
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
},
messageMapperRegistry,
new InMemoryOutbox(),
new ProducerRegistry(new Dictionary <string, IAmAMessageProducer>()
{
{ "MyRequest", new FakeMessageProducerWithPublishConfirmation() },
}),
replySubs,
responseChannelFactory: new InMemoryChannelFactory());
PipelineBuilder <MyRequest> .ClearPipelineCache();
}
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 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 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)
});
}
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();
}
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 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 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();
}
public OrganizationApplicationService()
{
log4net.Config.XmlConfigurator.Configure();
var container = new UnityContainer();
var logger = LogProvider.For <OrganizationApplicationService>();
container.RegisterInstance(typeof(ILog), LogProvider.For <OrganizationApplicationService>(), new ContainerControlledLifetimeManager());
container.RegisterType <AddOrganizationCommandHandler>();
//container.RegisterType<AddEFOrganisationCommandHandler>();
container.RegisterType <ChangeOrganizationCommandHandler>();
container.RegisterType <OrganizationAddedEventHandler>();
container.RegisterType <OrganizationAddedLegacyEventHandler>();
//Factories
//container.RegisterType(typeof(ICommandFactory<AddOrganizationCommand>),typeof(CommandFactory<AddOrganizationCommand, AxaAddOrganizationCommandExtension>));
//container.RegisterType<IDomainFactory, AxaDomainFactory>();
//container.RegisterType(typeof(ICommandFactory<>), typeof(CommandFactory<>));
container.RegisterType <IDomainFactory, DomainFactory>();
container.RegisterType(typeof(IDomainTracking <>), typeof(DomainTracking <>));
//Repositories
container.RegisterType <IOrganizationRepository, OrganizationRepository>();
container.RegisterType(typeof(IEFGenericRepository <>), typeof(EFGenericRepository <>));
container.RegisterType(typeof(IDapperGenericRepository <>), typeof(DapperGenericRepository <>));
//container.RegisterType<DbContext, OrganisationDbContext>(new ContainerControlledLifetimeManager());
container.RegisterType(typeof(IGenericRepository <>), typeof(EFGenericRepository <>));
//Command Processor
paramore.brighter.commandprocessor.CommandProcessor commandProcessor = CreateCommandProcesor(container);
container.RegisterInstance(typeof(IAmACommandProcessor), commandProcessor);
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(logger);
var rmqMessageProducerFactory = new RmqMessageProducerFactory(logger);
var messageMapperFactory = new UnityMessageMapperFactory(container);
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
messageMapperRegistry.Register <AddOrganizationCommand, AddOrganizationCommandMessageMapper>();
_dispatcher = DispatchBuilder.With()
.CommandProcessor(commandProcessor)
.MessageMappers(messageMapperRegistry)
.ChannelFactory(new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory))
.ConnectionsFromConfiguration()
.Build();
}
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);
}
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();
}
}
}
/// <summary>
/// Creates the specified configuration.
/// </summary>
/// <param name="gateway">The gateway to the control bus to send messages</param>
/// <param name="logger">The logger to use</param>
/// <param name="messageStore">The message store for outgoing messages to the control bus</param>
/// <returns>IAmAControlBusSender.</returns>
public IAmAControlBusSender Create(IAmAMessageStore<Message> messageStore, IAmAMessageProducer gateway)
{
var mapper = new MessageMapperRegistry(new SimpleMessageMapperFactory(() => new MonitorEventMessageMapper()));
mapper.Register<MonitorEvent, MonitorEventMessageMapper>();
return new ControlBusSender(CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration())
.DefaultPolicy()
.TaskQueues(new MessagingConfiguration(messageStore, gateway, mapper))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build()
);
}
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 ManagementAndMonitoringService()
{
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("messages");
var rmqMessageProducerFactory = new RmqMessageProducerFactory("messages");
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();
var controlBusBuilder = ControlBusReceiverBuilder
.With()
.Dispatcher(_dispatcher)
.ProducerFactory(rmqMessageProducerFactory)
.ChannelFactory(new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory)) as ControlBusReceiverBuilder;
_controlDispatcher = controlBusBuilder.Build(Environment.MachineName + "." + "ManagementAndMonitoring");
container.Register<IAmAControlBusSender>(new ControlBusSenderFactory().Create(
new MsSqlMessageStore(
new MsSqlMessageStoreConfiguration(
"DataSource=\"" + Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase.Substring(8)), "App_Data\\MessageStore.sdf") + "\"", "Messages",
MsSqlMessageStoreConfiguration.DatabaseType.SqlCe)
),
new RmqMessageProducer("monitoring")));
}
public TaskMailerService()
{
//Create a logger
var properties = new NameValueCollection();
properties["showDateTime"] = "true";
LogManager.Adapter = new ConsoleOutLoggerFactoryAdapter(properties);
var logger = LogManager.GetLogger(typeof (Dispatcher));
var container = new TinyIoCContainer();
container.Register<IAmAMessageMapper<TaskReminderCommand>, TaskReminderCommandMessageMapper>();
var handlerFactory = new TinyIocHandlerFactory(container);
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var subscriberRegistry = new 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 policyRegistry = new PolicyRegistry()
{
{CommandProcessor.RETRYPOLICY, retryPolicy},
{CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy}
};
//create message mappers
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
//create the gateway
var gateway = new RMQMessagingGateway(logger);
var builder = DispatchBuilder.With()
.WithLogger(logger)
.WithCommandProcessor(CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(logger)
.TaskQueues(new MessagingConfiguration(
messageStore: new RavenMessageStore(new EmbeddableDocumentStore(), logger),
messagingGateway: gateway,
messageMapperRegistry: messageMapperRegistry
))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build()
)
.WithMessageMappers(null)
.WithChannelFactory(new RMQInputChannelfactory(gateway))
.ConnectionsFromConfiguration();
dispatcher = builder.Build();
}
public static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
var messageMapperFactory = new TinyIoCMessageMapperFactory(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)}
};
//create the gateway
var rmqConnnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqConnnection );
var rmqMessageProducerFactory = new RmqMessageProducerFactory(rmqConnnection );
// Service Activator connections
var connections = new List<paramore.brighter.serviceactivator.Connection>
{
new paramore.brighter.serviceactivator.Connection(
new ConnectionName("paramore.example.greeting"),
new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory),
typeof(GreetingEvent),
new ChannelName("greeting.event"),
"greeting.event",
timeoutInMilliseconds: 200)
};
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))
.Connections(connections);
var dispatcher = builder.Build();
dispatcher.Receive();
Console.WriteLine("Press Enter to stop ...");
Console.ReadLine();
dispatcher.End().Wait();
}
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>();
}
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 = LogManager.GetLogger("TaskList");
container.Register<ILog, ILog>(logger);
container.Register<IAmARequestContextFactory, InMemoryRequestContextFactory>().AsMultiInstance();
container.Register<IAmAMessageStore<Message>, RavenMessageStore>().AsSingleton();
container.Register<IAmAMessagingGateway, RMQMessagingGateway>().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);
//create the gateway
var gateway = new RMQMessagingGateway(logger);
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(logger)
.TaskQueues(new MessagingConfiguration(
messageStore: new RavenMessageStore(new EmbeddableDocumentStore(), 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;
}
public GreetingService()
{
log4net.Config.XmlConfigurator.Configure(new FileInfo("log4net.config"));
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
var messageMapperFactory = new TinyIoCMessageMapperFactory(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)}
};
//create the gateway
var rmqConnnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqConnnection);
var rmqMessageProducerFactory = new RmqMessageProducerFactory(rmqConnnection);
// < add connectionName = "paramore.example.greeting" channelName = "greeting." routingKey = "greeting.command" dataType = "Greetings.Ports.Commands.GreetingEvent" timeOutInMilliseconds = "200" />
// Service Activator connections
var connections = new List<paramore.brighter.serviceactivator.Connection>
{
new paramore.brighter.serviceactivator.Connection(
new ConnectionName("paramore.example.greeting"),
new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory),
typeof(GreetingEvent),
new ChannelName("greeting.event"),
"greeting.event",
timeoutInMilliseconds: 200)
};
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))
.Connections(connections);
_dispatcher = builder.Build();
}
public ManagementAndMonitoringService()
{
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)}
};
var rmqGatewayMessages = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
var rmqGatewayMonitoring = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672/%2f")),
Exchange = new Exchange("paramore.brighter.exchange"),
};
//create the gateway
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(rmqGatewayMessages);
var rmqMessageProducerFactory = new RmqMessageProducerFactory(rmqGatewayMessages);
var connections = new List<Connection>
{
};
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))
.Connections(connections);
_dispatcher = builder.Build();
var controlBusBuilder = ControlBusReceiverBuilder
.With()
.Dispatcher(_dispatcher)
.ProducerFactory(rmqMessageProducerFactory)
.ChannelFactory(new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory)) as ControlBusReceiverBuilder;
_controlDispatcher = controlBusBuilder.Build(Environment.MachineName + "." + "ManagementAndMonitoring");
container.Register<IAmAControlBusSender>(new ControlBusSenderFactory().Create(
new SqliteMessageStore(
new SqliteMessageStoreConfiguration(
"DataSource=\"" + Path.Combine(Path.GetDirectoryName(typeof(GreetingCommand).GetTypeInfo().Assembly.CodeBase.Substring(8)), "App_Data\\MessageStore.sdf") + "\"", "Messages")
),
new RmqMessageProducer(rmqGatewayMonitoring)));
}
public OrderService()
{
log4net.Config.XmlConfigurator.Configure();
var logger = LogProvider.For<OrderService>();
var container = new UnityContainer();
container.RegisterInstance(typeof(ILog), LogProvider.For<OrderService>(), new ContainerControlledLifetimeManager());
container.RegisterType<OrderUpdateCommandMessageMapper>();
container.RegisterType<OrderUpdateCommandHandler>();
container.RegisterType<IOrdersDAO, OrdersDAO>();
container.RegisterType<IAmAMailGateway, MailGateway>();
container.RegisterType<IAmAMailTranslator, MailTranslator>();
var handlerFactory = new UnityHandlerFactory(container);
var messageMapperFactory = new UnityMessageMapperFactory(container);
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register<OrderUpdateCommand, OrderUpdateCommandHandler>();
//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();
//create message mappers
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory);
messageMapperRegistry.Register<OrderUpdateCommand, OrderUpdateCommandMessageMapper>();
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(logger);
_dispatcher = DispatchBuilder.With()
.Logger(logger)
.CommandProcessor(commandProcessor)
.MessageMappers(messageMapperRegistry)
.ChannelFactory(new InputChannelFactory(rmqMessageConsumerFactory))
.ConnectionsFromConfiguration()
.Build();
}
public DocumentService()
{
log4net.Config.XmlConfigurator.Configure();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
container.Register<IHandleRequests<DocumentCreatedEvent>, DocumentCreatedEventHandler>();
container.Register<IHandleRequests<DocumentUpdatedEvent>, DocumentUpdatedEventHandler>();
container.Register<IHandleRequests<FolderCreatedEvent>, FolderCreatedEventHandler>();
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register<DocumentCreatedEvent, DocumentCreatedEventHandler>();
subscriberRegistry.Register<DocumentUpdatedEvent, DocumentUpdatedEventHandler>();
subscriberRegistry.Register<FolderCreatedEvent, FolderCreatedEventHandler>();
//create policies
var retryPolicy = Policy
.Handle<Exception>()
.WaitAndRetry(new[]
{
TimeSpan.FromMilliseconds(5000),
TimeSpan.FromMilliseconds(10000),
TimeSpan.FromMilliseconds(10000)
});
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(FolderCreatedEvent), typeof(FolderCreatedEventMessageMapper)},
{typeof(DocumentCreatedEvent), typeof(DocumentCreatedEventMessageMapper)},
{typeof(DocumentUpdatedEvent), typeof(DocumentUpdatedEventMessageMapper)}
};
var awsCredentials = new StoredProfileAWSCredentials();
var sqsMessageConsumerFactory = new SqsMessageConsumerFactory(awsCredentials );
var sqsMessageProducerFactory = new SqsMessageProducerFactory(awsCredentials );
var connections = new List<paramore.brighter.serviceactivator.Connection>
{
new paramore.brighter.serviceactivator.Connection(
new ConnectionName("paramore.example.documentsandfolders.documentcreatedevent"),
new InputChannelFactory(sqsMessageConsumerFactory, sqsMessageProducerFactory),
typeof(DocumentCreatedEvent),
new ChannelName("https://sqs.eu-west-1.amazonaws.com/027649620536/DocumentCreatedEvent"),
"DocumentCreatedEvent",
timeoutInMilliseconds: 5000,
noOfPerformers: 10),
new paramore.brighter.serviceactivator.Connection(
new ConnectionName("paramore.example.documentsandfolders.documentupdatedevent"),
new InputChannelFactory(sqsMessageConsumerFactory, sqsMessageProducerFactory),
typeof(DocumentUpdatedEvent),
new ChannelName("https://sqs.eu-west-1.amazonaws.com/027649620536/DocumentUpdatedEvent"),
"DocumentUpdatedEvent",
timeoutInMilliseconds: 5000,
noOfPerformers: 10),
new paramore.brighter.serviceactivator.Connection(
new ConnectionName("paramore.example.documentsandfolders.foldercreateddevent"),
new InputChannelFactory(sqsMessageConsumerFactory, sqsMessageProducerFactory),
typeof(FolderCreatedEvent),
new ChannelName("https://sqs.eu-west-1.amazonaws.com/027649620536/FolderCreatedEvent"),
"FolderCreatedEvent",
timeoutInMilliseconds: 5000,
noOfPerformers: 10)
};
var builder = DispatchBuilder
.With()
.CommandProcessor(CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build()
)
.MessageMappers(messageMapperRegistry)
.ChannelFactory(new InputChannelFactory(sqsMessageConsumerFactory, sqsMessageProducerFactory))
.Connections(connections);
_dispatcher = builder.Build();
}
/// <summary>
/// Builds this instance.
/// </summary>
/// <param name="hostName">Name of the host.</param>
/// <returns>Dispatcher.</returns>
public Dispatcher Build(string hostName)
{
var connections = new List<ConnectionElement>();
/*
* These are the control bus channels, we hardcode them because we want to know they exist, but we use
a base naming scheme to allow centralized management.
*/
var configurationElement = new ConnectionElement
{
ChannelName = CONFIGURATION,
ConnectionName = CONFIGURATION,
IsDurable = true,
DataType = typeof(ConfigurationCommand).FullName,
RoutingKey = hostName + "." + CONFIGURATION,
};
connections.Add(configurationElement);
var heartbeatElement = new ConnectionElement
{
ChannelName = HEARTBEAT,
ConnectionName = HEARTBEAT,
IsDurable = false,
DataType = typeof(HeartBeatCommand).FullName,
RoutingKey = hostName + "." + HEARTBEAT,
};
connections.Add(heartbeatElement);
/* We want to register policies, messages and handlers for receiving built in commands. It's simple enough to do this for
the registries, but we cannot know your HandlerFactory implementation in order to insert. So we have to rely on
an internal HandlerFactory to build these for you.
* We also need to pass the supervised dispatcher as a dependency to our command handlers, so this allows us to manage
* the injection of the dependency as part of our handler factory
*/
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.CIRCUITBREAKER, circuitBreakerPolicy},
{CommandProcessor.RETRYPOLICY, retryPolicy}
};
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register<ConfigurationCommand, ConfigurationCommandHandler>();
var messageMapperRegistry = new MessageMapperRegistry(new ControlBusMessageMapperFactory());
messageMapperRegistry.Register<ConfigurationCommand, ConfigurationCommandMessageMapper>();
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, new ControlBusHandlerFactory(_dispatcher, _logger)))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
return DispatchBuilder
.With()
.CommandProcessor(commandProcessor)
.MessageMappers(messageMapperRegistry)
.ChannelFactory(_channelFactory)
.ConnectionsFromElements(connections)
.Build();
}
public static void Main()
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
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)}
};
var rmqGatewayMessages = RmqGatewayBuilder.With
.Uri(new Uri("amqp://*****:*****@localhost:5672/%2f"))
.Exchange("paramore.brighter.exchange")
.DefaultQueues();
var rmqMessageProducerFactory = new RmqMessageProducerFactory(rmqGatewayMessages);
var inputChannelFactory = new InputChannelFactory(new RmqMessageConsumerFactory(rmqGatewayMessages), rmqMessageProducerFactory);
var builder = DispatchBuilder
.With()
.CommandProcessor(CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build()
)
.MessageMappers(messageMapperRegistry)
.ChannelFactory(inputChannelFactory)
.Connections(new[]
{
ConnectionBuilder.With
.Name("paramore.example.greeting")
.ChannelFactory(inputChannelFactory)
.Type(typeof(GreetingCommand))
.ChannelName("greeting.event")
.RoutingKey("greeting.event")
.Timeout(200)
.Build()
});
_dispatcher = builder.Build();
var controlBusBuilder = ControlBusReceiverBuilder
.With()
.Dispatcher(_dispatcher)
.ProducerFactory(rmqMessageProducerFactory)
.ChannelFactory(inputChannelFactory) as ControlBusReceiverBuilder;
var controlDispatcher = controlBusBuilder.Build(Environment.MachineName + "." + "ManagementAndMonitoring");
container.Register<IAmAControlBusSender>(new ControlBusSenderFactory().Create(
new SqliteMessageStore(
new SqliteMessageStoreConfiguration(
"DataSource=\"" + Path.Combine(Path.GetDirectoryName(typeof(GreetingCommand).GetTypeInfo().Assembly.CodeBase.Substring(8)), "App_Data\\MessageStore.sdf") + "\"", "Messages")
),
new RmqMessageProducer(RmqGatewayBuilder.With
.Uri(new Uri("amqp://*****:*****@localhost:5672/%2f"))
.Exchange("paramore.brighter.exchange")
.DefaultQueues())));
controlDispatcher.Receive();
_dispatcher.Receive();
Console.WriteLine("Press Enter to stop ...");
Console.ReadLine();
controlDispatcher.End(); //Don't wait on the control bus, we are stopping so we don't want any more control messages, just terminate
_dispatcher.End().Wait();
}
public TaskMailerService()
{
log4net.Config.XmlConfigurator.Configure();
var logger = LogProvider.For<TaskMailerService>();
var container = new TinyIoCContainer();
container.Register<IAmAMessageMapper<TaskReminderCommand>, TaskReminderCommandMessageMapper>();
container.Register<MailTaskReminderHandler, MailTaskReminderHandler>();
container.Register<IAmAMailGateway, MailGateway>();
container.Register<ILog>(logger);
container.Register<IAmAMailTranslator, MailTranslator>();
var handlerFactory = new TinyIocHandlerFactory(container);
var messageMapperFactory = new TinyIoCMessageMapperFactory(container);
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register<TaskReminderCommand, MailTaskReminderHandler>();
//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();
//create message mappers
var messageMapperRegistry = new MessageMapperRegistry(messageMapperFactory)
{
{typeof (TaskReminderCommand), typeof(TaskReminderCommandMessageMapper)}
};
var rmqMessageConsumerFactory = new RmqMessageConsumerFactory(logger);
var rmqMessageProducerFactory = new RmqMessageProducerFactory(logger);
_dispatcher = DispatchBuilder.With()
.Logger(logger)
.CommandProcessor(commandProcessor)
.MessageMappers(messageMapperRegistry)
.ChannelFactory(new InputChannelFactory(rmqMessageConsumerFactory, rmqMessageProducerFactory))
.ConnectionsFromConfiguration()
.Build();
}
