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 CommandProcessorWithRetryPolicyAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyFailsWithFallbackDivideByZeroHandlerAsync>();
var container = new ServiceCollection();
container.AddSingleton <MyFailsWithFallbackDivideByZeroHandlerAsync>();
container.AddSingleton <ExceptionPolicyHandlerAsync <MyCommand> >();
container.AddSingleton <FallbackPolicyHandlerRequestHandlerAsync <MyCommand> >();
_provider = container.BuildServiceProvider();
var handlerFactory = new ServiceProviderHandlerFactory(_provider);
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.WaitAndRetryAsync(new[]
{
10.Milliseconds(),
20.Milliseconds(),
30.Milliseconds()
}, (exception, timeSpan) =>
{
_retryCount++;
});
policyRegistry.Add("MyDivideByZeroPolicy", policy);
_provider.GetService <MyFailsWithFallbackDivideByZeroHandlerAsync>().ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactoryAsync)handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Setup needed for memory cache
services.AddMemoryCache();
services.AddSingleton <Polly.Caching.IAsyncCacheProvider, MemoryCacheProvider>();
services.AddSingleton <Polly.Registry.IReadOnlyPolicyRegistry <string>, Polly.Registry.PolicyRegistry>((serviceProvider) =>
{
PolicyRegistry registry = new PolicyRegistry();
registry.Add("myCachePolicy",
Policy.CacheAsync <HttpResponseMessage>(
serviceProvider
.GetRequiredService <IAsyncCacheProvider>()
.AsyncFor <HttpResponseMessage>(),
TimeSpan.FromMinutes(5)));
return(registry);
});
// use HttpClientFactory in real apps
HttpClient httpClient = new HttpClient()
{
BaseAddress = new Uri("https://localhost:44354/")
};
httpClient.DefaultRequestHeaders.Accept.Clear();
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
services.AddSingleton <HttpClient>(httpClient);
services.AddControllers();
}
public virtual void AddPolicies(IServiceCollection services)
{
services.AddSingleton <IReadOnlyPolicyRegistry <string>, PolicyRegistry>((serviceProvider) =>
{
PolicyRegistry registry = new PolicyRegistry();
Action <Exception, TimeSpan> onBreak = (exception, timespan) =>
{
serviceProvider.GetRequiredService <ILogger>().Error($"Utilizando CircuitBreaker durante {timespan.TotalSeconds} segundo(s) tras el error: {exception}");
};
Action onReset = () =>
{
serviceProvider.GetRequiredService <ILogger>().Info($"Finalizando CircuitBreaker.");
};
AsyncCircuitBreakerPolicy breaker = Policy
.Handle <Exception>()
.CircuitBreakerAsync(2, TimeSpan.FromSeconds(30), onBreak, onReset);
AsyncPolicy policyCache = Policy
.Handle <Exception>()
.RetryAsync(3, onRetry: (exception, retryCount) =>
{
serviceProvider.GetRequiredService <ILogger>().Warn($"Error en el intento {retryCount}: {exception}");
})
.WrapAsync(breaker);
registry.Add(Claves.CLAVE_POLITICA_CACHE, policyCache);
return(registry);
});
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices((hostContext, services) =>
{
// Setup services
services.AddScoped <ILogic, Logic>();
services.AddScoped <IDummyService1, DummyService1>();
services.AddScoped <IDummyService2, DummyService2>();
services.AddScoped <IDummyService3, DummyService3>();
services.AddScoped <IDummyService4, DummyService4>();
// Setup polly
PolicyRegistry policyRegistry = new PolicyRegistry();
var asyncRetryPolicy1 = Policy.Handle <Exception>().RetryAsync(1);
policyRegistry.Add(PolicyNames.AsyncPolicyName, asyncRetryPolicy1);
var syncRetryPolicy1 = Policy.Handle <Exception>().Retry(1);
policyRegistry.Add(PolicyNames.SyncPolicyName, syncRetryPolicy1);
services.AddSingleton <IReadOnlyPolicyRegistry <string>, PolicyRegistry>(a => policyRegistry);
// Add PolicyScope
services.AddPolicyScope();
// Add worker service
services.AddHostedService <Worker>();
});
static DynamicPolicy()
{
var defaultRegistry = new PolicyRegistry();
_defaultRegistryLocator = () => defaultRegistry;
_registryLocator = _defaultRegistryLocator;
}
public void Arrange()
{
_accountId = 123;
_testData = JsonConvert.SerializeObject(new List <Reservation> {
new Reservation {
AccountId = _accountId
}
});
_reservations = JsonConvert.DeserializeObject <IEnumerable <Reservation> >(_testData);
_mockReservationsApiClient = new Mock <IReservationsApiClient>();
_mockReservationsApiClient
.Setup(m => m.Get(_accountId))
.ReturnsAsync(_testData);
_policy = Policy.NoOpAsync();
var registryPolicy = new PolicyRegistry();
registryPolicy.Add(Constants.DefaultServiceTimeout, _policy);
_reservationsService = new Mock <IReservationsService>();
_reservationsService
.Setup(rs => rs.Get(_accountId))
.ReturnsAsync(_reservations);
_reservationsServiceWithTimeout = new ReservationsServiceWithTimeout(_reservationsService.Object, registryPolicy);
}
/// <summary>
/// Initializes a new instance of the <see cref="Policies"/> class.
/// </summary>
/// <param name="policyRegistry">The policy registry.</param>
/// <param name="definitions">The send policy definitions.</param>
public Policies(PolicyRegistry policyRegistry,
PolicyDefinitions definitions)
{
Registry = policyRegistry;
Definition = definitions;
TransportDefinition = new ConcurrentDictionary <string, TransportPolicyDefinition>();
}
public CommandProcessorWithRetryPolicyTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyFailsWithDivideByZeroHandler>();
var container = new ServiceCollection();
container.AddSingleton <MyFailsWithDivideByZeroHandler>();
container.AddSingleton <ExceptionPolicyHandler <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.WaitAndRetry(new[]
{
1.Seconds(),
2.Seconds(),
3.Seconds()
}, (exception, timeSpan) =>
{
_retryCount++;
});
policyRegistry.Add("MyDivideByZeroPolicy", policy);
MyFailsWithDivideByZeroHandler.ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactory)handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
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);
}
private static IHost BuildHost()
{
return(new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
var retryPolicy = Policy.Handle <Exception>().WaitAndRetry(new[]
{
TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicy =
Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var retryPolicyAsync = Policy.Handle <Exception>().WaitAndRetryAsync(new[]
{
TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicyAsync = Policy.Handle <Exception>()
.CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy },
{ CommandProcessor.RETRYPOLICYASYNC, retryPolicyAsync },
{ CommandProcessor.CIRCUITBREAKERASYNC, circuitBreakerPolicyAsync }
};
var producer = new KafkaMessageProducerFactory(
new KafkaMessagingGatewayConfiguration()
{
Name = "paramore.brighter.greetingsender",
BootStrapServers = new[] { "localhost:9092" }
},
new KafkaPublication()
{
Topic = new RoutingKey("greeting.event"),
MessageSendMaxRetries = 3,
MessageTimeoutMs = 1000,
MaxInFlightRequestsPerConnection = 1
})
.Create();
services.AddSingleton <IAmAMessageProducer>(producer);
services.AddBrighter(options =>
{
options.PolicyRegistry = policyRegistry;
options.BrighterMessaging = new BrighterMessaging(new InMemoryOutbox(), producer);
}).MapperRegistryFromAssemblies(typeof(GreetingEvent).Assembly);
services.AddHostedService <TimedMessageGenerator>();
})
.UseSerilog()
.UseConsoleLifetime()
.Build());
}
public IXboxGameRepository Create()
{
Policy ftpPolicy = Policy.Handle <FtpException>().RetryForever((exception) =>
{
if (exception.InnerException is TimeoutException)
{
return;
}
if (exception is FtpCommandException commandException)
{
Console.WriteLine($"FtpException code: {commandException.CompletionCode}");
if (commandException.ResponseType != FtpResponseType.TransientNegativeCompletion)
{
throw new PersistenceException("Non transient error occurred", false, commandException);
}
}
throw new PersistenceException("Non transient error occurred", false, exception);
});
PolicyRegistry policyRegistry = new PolicyRegistry();
policyRegistry.Add("Ftp", ftpPolicy);
var ftpXboxGameRepository = new FtpXboxGameRepository(_ftpClientFactory, _ftpXboxSettings, policyRegistry);
return(ftpXboxGameRepository);
}
public void WithCustomPolicy()
{
var serviceCollection = new ServiceCollection();
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 }
};
serviceCollection
.AddBrighter(options => options.PolicyRegistry = policyRegistry)
.AutoFromAssemblies();
var serviceProvider = serviceCollection.BuildServiceProvider();
var commandProcessor = serviceProvider.GetService <IAmACommandProcessor>();
Assert.NotNull(commandProcessor);
}
/// <summary>
/// Adds all internal services required by the Cirrus library
/// </summary>
/// <param name="services">Service collection.</param>
/// <param name="setupAction">Cirrus configuration class for API Keys, MacAddresses, and Application Key</param>
/// <returns>Service Collection.</returns>
public static IServiceCollection AddCirrusServices(this IServiceCollection services, Action <CirrusConfig> setupAction)
{
var policyRegistry = new PolicyRegistry
{
{ nameof(Policies.GetRetryPolicy), Policies.GetRetryPolicy() },
{ nameof(Policies.CheckAuthorizedPolicy), Policies.CheckAuthorizedPolicy() },
{ nameof(Policies.GetCircuitBreakerPolicy), Policies.GetCircuitBreakerPolicy() },
{ nameof(Policies.GetTooManyRequestsPolicy), Policies.GetTooManyRequestsPolicy() }
};
services
.Configure(setupAction)
.AddTransient <LoggingContext>()
.AddScoped <Limiter>()
.AddScoped <ICirrusRealtime, CirrusRealtime>()
.AddScoped <ICirrusRestWrapper, CirrusRestWrapper>()
.AddScoped <ICirrusWrapper, CirrusWrapper>()
.AddPolicyRegistry(policyRegistry);
services
.AddHttpClient <ICirrusService, CirrusService>("CirrusService", client =>
{
client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json");
client.BaseAddress = new Uri("https://api.ambientweather.net");
})
.AddHttpMessageHandler <LoggingContext>()
.AddHttpMessageHandler <Limiter>()
.SetHandlerLifetime(Timeout.InfiniteTimeSpan)
.AddPolicyHandlerFromRegistry(nameof(Policies.GetRetryPolicy))
.AddPolicyHandlerFromRegistry(nameof(Policies.CheckAuthorizedPolicy))
.AddPolicyHandlerFromRegistry(nameof(Policies.GetCircuitBreakerPolicy))
.AddPolicyHandlerFromRegistry(nameof(Policies.GetTooManyRequestsPolicy));
return(services);
}
/// <summary>
/// This method gets called by the runtime. Use this method to add services to the container.
/// </summary>
/// <param name="services"></param>
public void ConfigureServices(IServiceCollection services)
{
var retryPolicy = Policy.Handle <Exception>().WaitAndRetry(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicy = Policy.Handle <Exception>().CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var retryPolicyAsync = Policy.Handle <Exception>().WaitAndRetryAsync(new[] { TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(150) });
var circuitBreakerPolicyAsync = Policy.Handle <Exception>().CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy },
{ CommandProcessor.RETRYPOLICYASYNC, retryPolicyAsync },
{ CommandProcessor.CIRCUITBREAKERASYNC, circuitBreakerPolicyAsync }
};
var messageStore = new MySqlOutbox(new MySqlOutboxConfiguration(
Configuration["Database:Bookings"],
Configuration["Database:MessageTableName"]
));
var gatewayConnection = new RmqMessagingGatewayConnection
{
AmpqUri = new AmqpUriSpecification(new Uri("amqp://*****:*****@localhost:5672")),
Exchange = new Exchange("hotel.booking.exchange"),
};
var producer = new RmqMessageProducer(gatewayConnection);
services.AddBrighter(options =>
{
options.PolicyRegistry = policyRegistry;
options.BrighterMessaging = new BrighterMessaging(messageStore, producer);
options.CommandProcessorLifetime = ServiceLifetime.Scoped;
})
.AsyncHandlersFromAssemblies(typeof(BookGuestRoomOnAccountHandlerAsync).Assembly)
.MapperRegistryFromAssemblies(typeof(GuestRoomBookingMadeMapper).Assembly);
services.AddDarker(options => options.QueryProcessorLifetime = ServiceLifetime.Scoped)
.AddHandlersFromAssemblies(typeof(GetBookingByIdHandlerAsync).Assembly);
services.AddOpenApiDocument(config =>
{
config.PostProcess = document =>
{
document.Info.Version = "v1";
document.Info.Title = "Accounts API";
document.Info.Description = "Hotel customers who have accounts with us";
document.Info.TermsOfService = "None";
document.Info.Contact = new NSwag.OpenApiContact
{
Name = "Ian Cooper",
Email = string.Empty,
Url = "https://twitter.com/icooper"
};
};
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddDbContext <BookingContext>(options =>
options.UseMySql(Configuration["Database:Bookings"]));
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder.Register(context =>
{
var configHelper = context.Resolve <Configuration>();
return(new TestPaymentsDataContext(configHelper.PaymentsConnectionString));
}).As <TestPaymentsDataContext>().InstancePerLifetimeScope();
builder.Register(context =>
{
var registry = new PolicyRegistry();
registry.Add("HttpRetryPolicy",
Policy.Handle <HttpRequestException>()
.WaitAndRetryAsync(
3, // number of retries
retryAttempt =>
TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), // exponential backoff
(exception, timeSpan, retryCount, executionContext) =>
{
// add logging
}));
return(registry);
}).As <IReadOnlyPolicyRegistry <string> >()
.SingleInstance();
builder.RegisterType <JobService>().As <IJobService>().InstancePerLifetimeScope();
builder.RegisterType <BespokeHttpClient>().As <IBespokeHttpClient>().InstancePerLifetimeScope();
builder.RegisterType <JsonSerializationService>().As <IJsonSerializationService>()
.InstancePerLifetimeScope();
}
public CommandProcessorWithCircuitBreakerTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyFailsWithDivideByZeroHandler>();
var container = new ServiceCollection();
container.AddSingleton <MyFailsWithDivideByZeroHandler>();
container.AddSingleton <ExceptionPolicyHandler <MyCommand> >();
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.CircuitBreaker(2, TimeSpan.FromMinutes(1));
policyRegistry.Add("MyDivideByZeroPolicy", policy);
MyFailsWithDivideByZeroHandler.ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
protected override void Load(ContainerBuilder builder)
{
// Creating policy registry.
var registry = new PolicyRegistry();
// Creating a retry policy.
var retryPolicy = Policy
.Handle <Exception>()
.WaitAndRetry(4, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (exception, timeSpan, retryCount, context) =>
{
Console.WriteLine($"Retry {retryCount}");
});
// Creating a fallback policy to execute a function,
// presumably a ServiceEventSource logger.
var fallback = Policy
.Handle <Exception>()
.Fallback(
(exception, context, token) => {},
(exception, context) =>
{
if (!(context is PolicyDelegateContext delegateContext))
{
throw exception;
}
if (delegateContext.FallbackAction != null)
{
delegateContext.FallbackAction.Invoke(exception);
}
}
private PolicyRegistry BuildPolicyRegistry()
{
var circuitBreakerPolicy = Policy.Handle <HttpRequestException>()
.CircuitBreakerAsync(1, TimeSpan.FromMinutes(1));
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var memoryCacheProvider = new Polly.Caching.MemoryCache.MemoryCacheProvider(memoryCache);
var cachePolicy = Policy.CacheAsync(memoryCacheProvider, TimeSpan.FromSeconds(30));
var cacheAndCircuitBreakerPolicy = cachePolicy.WrapAsync(Policy.Handle <HttpRequestException>()
.CircuitBreakerAsync(1, TimeSpan.FromMinutes(1)));
var fallbackCacheAndBreaker = Policy <Promotion>
.Handle <BrokenCircuitException>()
.Or <HttpRequestException>()
.FallbackAsync <Promotion>(new Promotion()
{
Title = "Some Fallback Promotion",
Description = "The Promotion API is down so we're showing something else",
GeneratedTimestamp = DateTime.UtcNow
}
)
.WrapAsync(cacheAndCircuitBreakerPolicy);
var registry = new PolicyRegistry();
registry.Add("PromoFallback", fallbackCacheAndBreaker);
registry.Add("Promo", cacheAndCircuitBreakerPolicy);
registry.Add("Merchant", circuitBreakerPolicy);
return(registry);
}
private IPolicyRegistry <string> ConfigurePolicies()
{
var defaultRetryPolicy = Policy
.Handle <Exception>()
.WaitAndRetryAsync(new[]
{
TimeSpan.FromMilliseconds(50),
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(500));
var circuitBreakTheWorstCaseScenario = Policy
.Handle <SomethingWentTerriblyWrongException>()
.CircuitBreakerAsync(1, TimeSpan.FromSeconds(5));
var policyRegistry = new PolicyRegistry
{
{ Paramore.Darker.Policies.Constants.RetryPolicyName, defaultRetryPolicy },
{ Paramore.Darker.Policies.Constants.CircuitBreakerPolicyName, circuitBreakerPolicy },
{ SomethingWentTerriblyWrongCircuitBreakerName, circuitBreakTheWorstCaseScenario }
};
return(policyRegistry);
}
/// <summary>
/// Registers an empty <see cref="PolicyRegistry"/> in the service collection with service types
/// <see cref="IPolicyRegistry{String}"/>, <see cref="IReadOnlyPolicyRegistry{String}"/>, and
/// <see cref="IConcurrentPolicyRegistry{String}"/> and uses the specified delegate to configure it.
/// </summary>
/// <param name="services">The <see cref="IServiceCollection"/>.</param>
/// <param name="configureRegistry">A delegate that is used to configure an <see cref="IPolicyRegistry{String}"/>.</param>
/// <returns>The provided <see cref="IServiceCollection"/>.</returns>
public static IServiceCollection AddPolicyRegistry(this IServiceCollection services, Action <IServiceProvider, IPolicyRegistry <string> > configureRegistry)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (configureRegistry == null)
{
throw new ArgumentNullException(nameof(configureRegistry));
}
// Create an empty registry, configure it and register it as an instance.
// This is the best way to get a single instance registered using both interfaces.
services.AddSingleton(serviceProvider =>
{
var registry = new PolicyRegistry();
configureRegistry(serviceProvider, registry);
return(registry);
});
services.AddSingleton <IConcurrentPolicyRegistry <string> >(serviceProvider => serviceProvider.GetRequiredService <PolicyRegistry>());
services.AddSingleton <IPolicyRegistry <string> >(serviceProvider => serviceProvider.GetRequiredService <PolicyRegistry>());
services.AddSingleton <IReadOnlyPolicyRegistry <string> >(serviceProvider => serviceProvider.GetRequiredService <PolicyRegistry>());
return(services);
}
public CommandProcessorWithExceptionPolicyNothingThrowTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyDoesNotFailPolicyHandler>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
container.Register <IHandleRequests <MyCommand>, MyDoesNotFailPolicyHandler>("MyDoesNotFailPolicyHandler");
container.Register <IHandleRequests <MyCommand>, ExceptionPolicyHandler <MyCommand> >("MyExceptionPolicyHandler");
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.WaitAndRetry(new[]
{
1.Seconds(),
2.Seconds(),
3.Seconds()
}, (exception, timeSpan) =>
{
_retryCount++;
});
policyRegistry.Add("MyDivideByZeroPolicy", policy);
MyDoesNotFailPolicyHandler.ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
public CommandProcessorWithCircuitBreakerAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyFailsWithDivideByZeroHandlerAsync>();
var container = new ServiceCollection();
container.AddSingleton <MyFailsWithDivideByZeroHandlerAsync>();
container.AddSingleton <ExceptionPolicyHandlerAsync <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.CircuitBreakerAsync(2, TimeSpan.FromMinutes(1));
policyRegistry.Add("MyDivideByZeroPolicy", policy);
MyFailsWithDivideByZeroHandlerAsync.ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactoryAsync)handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices((hostContext, services) =>
{
// Setup services
services.AddScoped <IWithPolicyScope, WithPolicyScope>();
services.AddScoped <IWithoutPolicyScope, WithoutPolicyScope>();
services.AddScoped <IDatabaseRemover, DatabaseRemover>();
services.AddScoped <IDatabaseUpdater, DatabaseUpdater>();
services.AddScoped <IMultiplePolicyScope, MultiplePolicyScope>();
services.AddScoped <MyDatabaseContext>();
// Setup polly
PolicyRegistry policyRegistry = new PolicyRegistry();
var primaryPolicy = Policy.Handle <Exception>().RetryAsync(1);
policyRegistry.Add(PolicyNames.Primary, primaryPolicy);
var secondaryPolicy = Policy.Handle <Exception>().RetryAsync(2);
policyRegistry.Add(PolicyNames.Secondary, secondaryPolicy);
// Setup policy registry
services.AddSingleton <IReadOnlyPolicyRegistry <string>, PolicyRegistry>(a => policyRegistry);
// Add PolicyScope
services.AddPolicyScope();
// Add worker service
services.AddHostedService <Worker>();
});
public void StoreWithStream_WhenPolicyResult_HasFailed_ShouldThrowPersistenceException()
{
bool policyExecuted = false;
_policyRegistry = new PolicyRegistry();
_policyRegistry.Add("Ftp", Policy.Handle <FtpException>((ex) =>
{
policyExecuted = true;
return(true);
}).Retry(0));
_mockFtpClient.Setup(x => x.Connect());
_mockFtpClient.Setup(x => x.IsConnected).Returns(true);
_mockFtpClient.Setup(x => x.Upload(It.IsAny <Stream>(), It.IsAny <string>(), It.IsAny <FtpRemoteExists>(),
It.IsAny <bool>(), null)).Throws(new FtpException(""));
var sut = CreateSut();
sut.Connect();
MemoryStream memoryStream = new MemoryStream(new byte[] { 1, 2, 3, 4 });
Action executeStore = () => sut.Store("GameA", "file1.txt", memoryStream);
// act
executeStore.Should().Throw <PersistenceException>();
// assert
policyExecuted.Should().BeTrue();
}
public void Setup()
{
_mockFtpClient = new Mock <IFtpClient>();
_ftpClientFactory = new MoqFtpClientFactory(_mockFtpClient);
_policyRegistry = new PolicyRegistry();
_policyRegistry.Add("Ftp", Policy.NoOp());
}
private static IAmAPolicyRegistry GetPolicies()
{
var policyRegistry = new PolicyRegistry();
// These are the default policies that must exist.
// We're not using them, so we're setting them to No-op.
policyRegistry.Add(CommandProcessor.RETRYPOLICY, Policy.NoOp());
policyRegistry.Add(CommandProcessor.RETRYPOLICYASYNC, Policy.NoOpAsync());
policyRegistry.Add(CommandProcessor.CIRCUITBREAKER, Policy.NoOp());
policyRegistry.Add(CommandProcessor.CIRCUITBREAKERASYNC, Policy.NoOpAsync());
// Sets up the policy that we're going to use for the SaluationHandler
var greetingRetryPolicy = Policy
.Handle <Exception>()
.WaitAndRetry(new[]
{
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(2),
TimeSpan.FromSeconds(4)
},
(exception, timeSpan) =>
{
Console.WriteLine($" ** An error occurred: {exception.Message}");
Console.WriteLine($" ** Waiting {timeSpan.Seconds} seconds until retry.");
});
policyRegistry.Add("GreetingRetryPolicy", greetingRetryPolicy);
return(policyRegistry);
}
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 void Establish()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyFailsWithFallbackDivideByZeroHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyFailsWithFallbackDivideByZeroHandlerAsync>().AsSingleton();
container.Register <IHandleRequestsAsync <MyCommand>, ExceptionPolicyHandlerAsync <MyCommand> >().AsSingleton();
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.WaitAndRetryAsync(new[]
{
1.Seconds(),
2.Seconds(),
3.Seconds()
}, (exception, timeSpan) =>
{
s_retryCount++;
});
policyRegistry.Add("MyDivideByZeroPolicy", policy);
MyFailsWithFallbackDivideByZeroHandlerAsync.ReceivedCommand = false;
s_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
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 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 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 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 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);
}
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 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()
{
//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 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 =
//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: null
))
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build()
)
.WithMessageMappers(null)
.WithChannelFactory(new RMQInputChannelfactory(gateway))
.ConnectionsFromConfiguration();
dispatcher = builder.Build();
}
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 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 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 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 static void Run(UnityContainer container)
{
container.RegisterType<DomainController>();
container.RegisterType<FeedController>();
container.RegisterType<JoinController>();
container.RegisterType<MessageController>();
container.RegisterType<PipeController>();
container.RegisterType<IAmARepository<Domain>, InMemoryDomainRepository>(new ContainerControlledLifetimeManager());
container.RegisterType<IAmARepository<Feed>, InMemoryFeedRepository>(new ContainerControlledLifetimeManager());
container.RegisterType<IAmARepository<Pipe>, InMemoryPipeRepository>(new ContainerControlledLifetimeManager());
container.RegisterType<IAmARepository<Join>, InMemoryJoinRepository>(new ContainerControlledLifetimeManager());
container.RegisterType<IAmACredentialStore, CredentialStore>(new ContainerControlledLifetimeManager());
container.RegisterInstance(typeof(ILog), LogProvider.For<RestMSService>(), new ContainerControlledLifetimeManager());
container.RegisterType<AddFeedCommandHandler>();
container.RegisterType<AddFeedToDomainCommandHandler>();
container.RegisterType<AddJoinCommandHandler>();
container.RegisterType<AddJoinToFeedCommandHandler>();
container.RegisterType<AddJoinToPipeCommandHandler>();
container.RegisterType<AddMessageToFeedCommandHandler>();
container.RegisterType<AddPipeCommandHandler>();
container.RegisterType<AddPipeToDomainCommandHandler>();
container.RegisterType<DeleteFeedCommandHandler>();
container.RegisterType<DeleteMessageCommandHandler>();
container.RegisterType<DeletePipeCommandHandler>();
container.RegisterType<RemoveFeedFromDomainCommandHandler>();
container.RegisterType<CacheCleaningHandler>();
var handlerFactory = new UnityHandlerFactory(container);
var subscriberRegistry = new SubscriberRegistry
{
{typeof(AddFeedCommand), typeof(AddFeedCommandHandler)},
{typeof(AddFeedToDomainCommand), typeof(AddFeedToDomainCommandHandler)},
{typeof(AddJoinCommand), typeof(AddJoinCommandHandler)},
{typeof(AddJoinToFeedCommand), typeof(AddJoinToFeedCommandHandler)},
{typeof(AddJoinToPipeCommand), typeof(AddJoinToPipeCommandHandler)},
{typeof(AddMessageToFeedCommand), typeof(AddMessageToFeedCommandHandler)},
{typeof(AddPipeCommand), typeof(AddPipeCommandHandler)},
{typeof(AddPipeToDomainCommand), typeof(AddPipeToDomainCommandHandler)},
{typeof(DeleteFeedCommand), typeof(DeleteFeedCommandHandler)},
{typeof(DeleteMessageCommand), typeof(DeleteMessageCommandHandler)},
{typeof(DeletePipeCommand), typeof(DeletePipeCommandHandler)},
{typeof(RemoveFeedFromDomainCommand), typeof(RemoveFeedFromDomainCommandHandler)},
{typeof(InvalidateCacheCommand), typeof(CacheCleaningHandler)}
};
//create policies
var retryPolicy = Policy
.Handle<Exception>()
.WaitAndRetry(new[]
{
TimeSpan.FromMilliseconds(50),
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(150)
});
var circuitBreakerPolicy = Policy
.Handle<Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(500));
var policyRegistry = new PolicyRegistry()
{
{CommandProcessor.RETRYPOLICY, retryPolicy},
{CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy}
};
var commandProcessor = CommandProcessorBuilder.With()
.Handlers(new HandlerConfiguration(subscriberRegistry, handlerFactory))
.Policies(policyRegistry)
.Logger(container.Resolve<ILog>())
.NoTaskQueues()
.RequestContextFactory(new InMemoryRequestContextFactory())
.Build();
container.RegisterInstance(typeof(IAmACommandProcessor), commandProcessor);
}
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();
}
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 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();
}
/// <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 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)));
}
