private static IEventFlowOptions ConfigureFirebase( this IEventFlowOptions eventFlowOptions, Func <IFirebaseClient> firebaseClientFactory, bool useBackupStore) { if (useBackupStore) { return(eventFlowOptions.RegisterServices(sr => { sr.Register(f => firebaseClientFactory(), Lifetime.Singleton); sr.Register <IReadModelDescriptionProvider, ReadModelDescriptionProvider>(Lifetime.Singleton, true); sr.Register <IReadModelBackUpStore, ReadModelBackUpStore>(); sr.Register <IFirebaseReadStoreConfiguration>(f => new FirebaseReadStoreConfiguration(useBackupStore), Lifetime.Singleton); })); } else { return(eventFlowOptions.RegisterServices(sr => { sr.Register(f => firebaseClientFactory(), Lifetime.Singleton); sr.Register <IReadModelDescriptionProvider, ReadModelDescriptionProvider>(Lifetime.Singleton, true); sr.Register <IReadModelBackUpStore, MockReadModelBackUpStore>(); sr.Register <IFirebaseReadStoreConfiguration>(f => new FirebaseReadStoreConfiguration(useBackupStore), Lifetime.Singleton); })); } }
public AspNetCoreEventFlowOptions AddUserClaimsMetadata(params string[] includedClaimTypes) { var options = new DefaultUserClaimsMetadataOptions(includedClaimTypes); _options.RegisterServices(s => s.Register <IUserClaimsMetadataOptions>(_ => options)); return(RegisterMetadataProvider <AddUserClaimsMetadataProvider>()); }
public static IEventFlowOptions UseEventStoreEventStore( this IEventFlowOptions eventFlowOptions, Uri uri, ConnectionSettings connectionSettings, string connectionNamePrefix = null) { var sanitizedConnectionNamePrefix = string.IsNullOrEmpty(connectionNamePrefix) ? string.Empty : connectionNamePrefix + " - "; var eventStoreConnection = EventStoreConnection.Create( connectionSettings, uri, $"{sanitizedConnectionNamePrefix}EventFlow v{typeof(EventFlowOptionsExtensions).Assembly.GetName().Version}"); #pragma warning disable 618 // TODO: Figure out bootstrapping alternative for 1.0 using (var a = AsyncHelper.Wait) { a.Run(eventStoreConnection.ConnectAsync()); } #pragma warning restore 618 return(eventFlowOptions .RegisterServices(f => f.Register(r => eventStoreConnection, Lifetime.Singleton)) .UseEventStore <EventStoreEventPersistence>()); }
public static IEventFlowOptions AddAspNetCoreMetadataProviders( this IEventFlowOptions eventFlowOptions) { return(eventFlowOptions .RegisterServices(sr => sr.Register(typeof(IHttpContextAccessor), typeof(HttpContextAccessor), Lifetime.Singleton)) .AddMetadataProviders(EventFlowAspNetCore.Assembly)); }
public static IEventFlowOptions AddQueryHandlers( this IEventFlowOptions eventFlowOptions, IEnumerable <Type> queryHandlerTypes) { foreach (var queryHandlerType in queryHandlerTypes) { var t = queryHandlerType; var queryHandlerInterfaces = t .GetInterfaces() .Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IQueryHandler <,>)) .ToList(); if (!queryHandlerInterfaces.Any()) { throw new ArgumentException($"Type '{t.PrettyPrint()}' is not an '{typeof(IQueryHandler<,>).PrettyPrint()}'"); } eventFlowOptions.RegisterServices(sr => { foreach (var queryHandlerInterface in queryHandlerInterfaces) { sr.Register(queryHandlerInterface, t); } }); } return(eventFlowOptions); }
public static IEventFlowOptions UseSnapshotStore<TSnapshotStore>( this IEventFlowOptions eventFlowOptions, Lifetime lifetime = Lifetime.AlwaysUnique) where TSnapshotStore : class, ISnapshotPersistence { return eventFlowOptions.RegisterServices(sr => sr.Register<ISnapshotPersistence, TSnapshotStore>(lifetime)); }
public static IEventFlowOptions UseStreamsDbEventStore( this IEventFlowOptions eventFlowOptions, string connectionString, string service) { StreamsDBClient client = null; using (var a = AsyncHelper.Wait) { a.Run(StreamsDBClient.Connect(connectionString), c => client = c); } return(eventFlowOptions .RegisterServices(f => { f.Register(r => client, Lifetime.Singleton); f.Register <NullReadModelLocator, NullReadModelLocator>(); // todo: move to own extension method //f.Register<IStreamsDbMessageFactory, StreamsDbMessageFactory>(Lifetime.Singleton); //f.Register<IStreamsDbPublisher, StreamsDbPublisher>(Lifetime.Singleton); //f.Register<ISubscribeSynchronousToAll, StreamsDbDomainEventPublisher>(); // f.Register(rc => new StreamsDbServiceConfiguration(service), Lifetime.Singleton); }) //.AddMetadataProvider<ServiceMetadataProvider>() .UseEventStore <StreamsDbEventPersistence>()); }
public static IEventFlowOptions IncludeLocations(this IEventFlowOptions eventFlowOptions) { return(eventFlowOptions .RegisterServices(sr => { sr.RegisterType(typeof(Invitations)); }) .UseEntityFrameworkReadModel <Location, ApplicationContext>() .UseEntityFrameworkReadModel <Invitation, ApplicationContext, Invitations>()); }
private static void registerCommon(IEventFlowOptions options, ILxSettings configuration) { options.RegisterServices(sr => { sr.Register(rc => configuration, Lifetime.Singleton); }); }
public static IEventFlowOptions UseEventStore <TEventStore>( this IEventFlowOptions eventFlowOptions, Lifetime lifetime = Lifetime.AlwaysUnique) where TEventStore : class, IEventPersistence { return(eventFlowOptions.RegisterServices(f => f.Register <IEventPersistence, TEventStore>(lifetime))); }
public static IEventFlowOptions UseEventStoreEventStore( this IEventFlowOptions eventFlowOptions, Uri uri, ConnectionSettings connectionSettings, string connectionNamePrefix = null) { var sanitizedConnectionNamePrefix = string.IsNullOrEmpty(connectionNamePrefix) ? string.Empty : connectionNamePrefix + " - "; var eventStoreConnection = EventStoreConnection.Create( connectionSettings, uri, $"{sanitizedConnectionNamePrefix}EventFlow v{typeof(EventFlowOptionsExtensions).Assembly.GetName().Version}"); using (var a = AsyncHelper.Wait) { a.Run(eventStoreConnection.ConnectAsync()); } return(eventFlowOptions .RegisterServices(f => f.Register(r => eventStoreConnection, Lifetime.Singleton)) .RegisterServices(f => f.Register <IEventPersistence, EventStoreEventPersistence>()) .RegisterServices(f => f.Register <IEventStore, EventStoreBase>()) .RegisterServices(f => f.Register <IEventPersistence, EventStoreEventPersistence>())); }
protected override IRootResolver CreateRootResolver(IEventFlowOptions eventFlowOptions) { _elasticsearchUrl = Environment.GetEnvironmentVariable("ELASTICSEARCH_URL"); _indexName = $"eventflow-test-{Guid.NewGuid():D}"; var testReadModelDescriptionProvider = new TestReadModelDescriptionProvider(_indexName); var resolver = eventFlowOptions .RegisterServices(sr => { sr.RegisterType(typeof(ThingyMessageLocator)); sr.Register <IReadModelDescriptionProvider>(c => testReadModelDescriptionProvider); }) .ConfigureElasticsearch(_elasticsearchUrl) .UseElasticsearchReadModelFor <ThingyAggregate, ThingyId, ElasticsearchThingyReadModel>() .UseElasticsearchReadModel <ElasticsearchThingyMessageReadModel, ThingyMessageLocator>() .AddQueryHandlers( typeof(ElasticsearchThingyGetQueryHandler), typeof(ElasticsearchThingyGetVersionQueryHandler), typeof(ElasticsearchThingyGetMessagesQueryHandler)) .CreateResolver(); _elasticClient = resolver.Resolve <IElasticClient>(); _elasticClient.CreateIndex(_indexName, c => c .Settings(s => s .NumberOfShards(1) .NumberOfReplicas(0)) .Mappings(m => m .Map <ElasticsearchThingyMessageReadModel>(d => d .AutoMap()))); return(resolver); }
public static IEventFlowOptions UsePermanentMemoryCache( this IEventFlowOptions eventFlowOptions) { return (eventFlowOptions.RegisterServices( r => r.Register <IMemoryCache, DictionaryMemoryCache>(Lifetime.Singleton))); }
public static IEventFlowOptions AddCommandHandlers( this IEventFlowOptions eventFlowOptions, IEnumerable <Type> commandHandlerTypes) { foreach (var commandHandlerType in commandHandlerTypes) { var t = commandHandlerType; if (t.GetTypeInfo().IsAbstract) { continue; } var handlesCommandTypes = t .GetTypeInfo() .GetInterfaces() .Where( i => i.GetTypeInfo().IsGenericType&& i.GetGenericTypeDefinition() == typeof(ICommandHandler <, , ,>)) .ToList(); if (!handlesCommandTypes.Any()) { throw new ArgumentException( $"Type '{commandHandlerType.PrettyPrint()}' does not implement '{typeof(ICommandHandler<,,,>).PrettyPrint()}'"); } eventFlowOptions.RegisterServices(sr => { foreach (var handlesCommandType in handlesCommandTypes) { sr.Register(handlesCommandType, t); } }); } return(eventFlowOptions); }
public static IEventFlowOptions AddSubscribers( this IEventFlowOptions eventFlowOptions, IEnumerable <Type> subscribeSynchronousToTypes) { foreach (var subscribeSynchronousToType in subscribeSynchronousToTypes) { var t = subscribeSynchronousToType; var subscribeTos = t .GetInterfaces() .Where(i => (i.IsGenericType && i.GetGenericTypeDefinition() == typeof(ISubscribeSynchronousTo <, ,>)) || i == typeof(ISubscribeSynchronousToAll)) .ToList(); if (!subscribeTos.Any()) { throw new ArgumentException($"Type '{t.PrettyPrint()}' is not an '{typeof(ISubscribeSynchronousTo<,,>).PrettyPrint()}'"); } eventFlowOptions.RegisterServices(sr => { foreach (var subscribeTo in subscribeTos) { sr.Register(subscribeTo, t); } }); } return(eventFlowOptions); }
protected override IRootResolver CreateRootResolver(IEventFlowOptions eventFlowOptions) { var elasticsearchUrl = Environment.GetEnvironmentVariable("ELASTICSEARCH_URL") ?? "http://localhost:9200"; // Setup connection settings separateley as by default EventFlow uses SniffingConnectionPool // which is not working well with elasticserch hosted in local docker var connectionSettings = new ConnectionSettings(new Uri(elasticsearchUrl)) .ThrowExceptions() .SniffLifeSpan(TimeSpan.FromMinutes(5)) .DisablePing(); var resolver = eventFlowOptions .RegisterServices(sr => { sr.RegisterType(typeof(ThingyMessageLocator)); }) .ConfigureElasticsearch(connectionSettings) .UseElasticsearchReadModel <ElasticsearchThingyReadModel>() .UseElasticsearchReadModel <ElasticsearchThingyMessageReadModel, ThingyMessageLocator>() .AddQueryHandlers( typeof(ElasticsearchThingyGetQueryHandler), typeof(ElasticsearchThingyGetVersionQueryHandler), typeof(ElasticsearchThingyGetMessagesQueryHandler)) .CreateResolver(); PrepareIndexes(resolver); return(resolver); }
public static IEventFlowOptions AddQueryHandler <TQueryHandler, TQuery, TResult>( this IEventFlowOptions eventFlowOptions) where TQueryHandler : class, IQueryHandler <TQuery, TResult> where TQuery : IQuery <TResult> { return(eventFlowOptions.RegisterServices(sr => sr.Register <IQueryHandler <TQuery, TResult>, TQueryHandler>())); }
public static IEventFlowOptions AddSubscribers( this IEventFlowOptions eventFlowOptions, IEnumerable <Type> subscribeSynchronousToTypes) { foreach (var subscribeSynchronousToType in subscribeSynchronousToTypes) { var t = subscribeSynchronousToType; if (t.GetTypeInfo().IsAbstract) { continue; } var subscribeTos = t .GetTypeInfo() .GetInterfaces() .Where(IsSubscriberInterface) .ToList(); if (!subscribeTos.Any()) { throw new ArgumentException($"Type '{t.PrettyPrint()}' is not an '{ISubscribeSynchronousToType.PrettyPrint()}', '{ISubscribeAsynchronousToType.PrettyPrint()}' or '{ISubscribeSynchronousToAllType.PrettyPrint()}'"); } eventFlowOptions.RegisterServices(sr => { foreach (var subscribeTo in subscribeTos) { sr.Register(subscribeTo, t); } }); } return(eventFlowOptions); }
public static IEventFlowOptions AddQueryHandlers( this IEventFlowOptions eventFlowOptions, IEnumerable <Type> queryHandlerTypes) { foreach (var queryHandlerType in queryHandlerTypes) { var t = queryHandlerType; var queryHandlerInterfaces = t .GetInterfaces() .Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IQueryHandler <,>)) .ToList(); if (!queryHandlerInterfaces.Any()) { throw new ArgumentException(string.Format( "Type '{0}' is not a ISubscribeSynchronousTo<TEvent>", t.Name)); } eventFlowOptions.RegisterServices(sr => { foreach (var queryHandlerInterface in queryHandlerInterfaces) { sr.Register(queryHandlerInterface, t); } }); } return(eventFlowOptions); }
public void Register(IEventFlowOptions eventFlowOptions) { // Not sure why this not work eventFlowOptions.AddQueryHandlers(typeof(QueryHandlersModule).Assembly); eventFlowOptions.RegisterServices(r => { r.Register <BookingQueryHandler, BookingQueryHandler>(); }); }
public static IEventFlowOptions AddQueryHandlers( this IEventFlowOptions eventFlowOptions, IEnumerable <Type> queryHandlerTypes) { foreach (var queryHandlerType in queryHandlerTypes) { var t = queryHandlerType; if (t.GetTypeInfo().IsAbstract) { continue; } var queryHandlerInterfaces = t .GetTypeInfo() .GetInterfaces() .Where(IsQueryHandlerInterface) .ToList(); if (!queryHandlerInterfaces.Any()) { throw new ArgumentException($"Type '{t.PrettyPrint()}' is not an '{typeof(IQueryHandler<,>).PrettyPrint()}'"); } eventFlowOptions.RegisterServices(sr => { foreach (var queryHandlerInterface in queryHandlerInterfaces) { sr.Register(queryHandlerInterface, t); } }); } return(eventFlowOptions); }
public static IEventFlowOptions UseEventStore( this IEventFlowOptions eventFlowOptions, Func <IResolverContext, IEventStore> eventStoreResolver, Lifetime lifetime = Lifetime.AlwaysUnique) { return(eventFlowOptions.RegisterServices(f => f.Register(eventStoreResolver, lifetime))); }
public static IEventFlowOptions AddEventUpgraders( this IEventFlowOptions eventFlowOptions, IEnumerable <Type> eventUpgraderTypes) { foreach (var eventUpgraderType in eventUpgraderTypes) { var t = eventUpgraderType; if (t.GetTypeInfo().IsAbstract) { continue; } var eventUpgraderForAggregateType = t .GetTypeInfo() .GetInterfaces() .SingleOrDefault(IsEventUpgraderInterface); if (eventUpgraderForAggregateType == null) { throw new ArgumentException($"Type '{eventUpgraderType.Name}' does not have the '{typeof(IEventUpgrader<,>).PrettyPrint()}' interface"); } eventFlowOptions.RegisterServices(sr => sr.Register(eventUpgraderForAggregateType, t)); } return(eventFlowOptions); }
public static IEventFlowOptions UseInMemoryReadStoreFor <TReadModel>( this IEventFlowOptions eventFlowOptions) where TReadModel : class, IReadModel { return(eventFlowOptions .RegisterServices(RegisterInMemoryReadStore <TReadModel>) .UseReadStoreFor <IInMemoryReadStore <TReadModel>, TReadModel>()); }
public static IEventFlowOptions AddMetadataProvider <TMetadataProvider>( this IEventFlowOptions eventFlowOptions, Lifetime lifetime = Lifetime.AlwaysUnique) where TMetadataProvider : class, IMetadataProvider { return(eventFlowOptions .RegisterServices(f => f.Register <IMetadataProvider, TMetadataProvider>(lifetime))); }
public static IEventFlowOptions UseElasticsearchReadModel <TReadModel>( this IEventFlowOptions eventFlowOptions) where TReadModel : class, IReadModel { return(eventFlowOptions .RegisterServices(RegisterElasticsearchReadStore <TReadModel>) .UseReadStoreFor <IElasticsearchReadModelStore <TReadModel>, TReadModel>()); }
public static IEventFlowOptions AddEventUpgrader <TAggregate, TIdentity>( this IEventFlowOptions eventFlowOptions, Func <IResolverContext, IEventUpgrader <TAggregate, TIdentity> > factory) where TAggregate : IAggregateRoot <TIdentity> where TIdentity : IIdentity { return(eventFlowOptions.RegisterServices(f => f.Register(factory))); }
public static IEventFlowOptions AddEventUpgrader <TAggregate, TIdentity, TEventUpgrader>( this IEventFlowOptions eventFlowOptions) where TAggregate : IAggregateRoot <TIdentity> where TIdentity : IIdentity where TEventUpgrader : class, IEventUpgrader <TAggregate, TIdentity> { return(eventFlowOptions.RegisterServices(f => f.Register <IEventUpgrader <TAggregate, TIdentity>, TEventUpgrader>())); }
public static IEventFlowOptions UseMssqlReadModel <TReadModel, TReadModelLocator>( this IEventFlowOptions eventFlowOptions) where TReadModel : class, IReadModel where TReadModelLocator : IReadModelLocator { return(eventFlowOptions .RegisterServices(RegisterMssqlReadStore <TReadModel>) .UseReadStoreFor <IMssqlReadModelStore <TReadModel>, TReadModel, TReadModelLocator>()); }
public static IEventFlowOptions AddMsSqlReadModel(this IEventFlowOptions efo) { return(efo .RegisterServices(sr => sr.Register <IEntryLocator, EntryLocator>()) .UseMssqlReadModel <CompetitionReadModel>() .UseMssqlReadModel <EntryReadModel, IEntryLocator>() .AddQueryHandler <GetAllEntriesQueryHandler, GetAllEntriesQuery, EntryReadModel[]>() .ConfigureMsSql(MsSqlConfiguration.New.SetConnectionString(ConfigurationManager.ConnectionStrings["ReadModel"].ConnectionString))); }
protected override IRootResolver CreateRootResolver(IEventFlowOptions eventFlowOptions) { var resolver = eventFlowOptions .RegisterServices(sr => sr.RegisterType(typeof(ThingyMessageLocator))) .UseInMemoryReadStoreFor<InMemoryThingyReadModel>() .UseInMemoryReadStoreFor<InMemoryThingyMessageReadModel, ThingyMessageLocator>() .AddQueryHandlers( typeof(InMemoryThingyGetQueryHandler), typeof(InMemoryThingyGetVersionQueryHandler), typeof(InMemoryThingyGetMessagesQueryHandler)) .CreateResolver(); return resolver; }
protected override IRootResolver CreateRootResolver(IEventFlowOptions eventFlowOptions) { _testDatabase = MsSqlHelpz.CreateDatabase("eventflow"); var resolver = eventFlowOptions .RegisterServices(sr => sr.RegisterType(typeof (ThingyMessageLocator))) .ConfigureMsSql(MsSqlConfiguration.New.SetConnectionString(_testDatabase.ConnectionString.Value)) .UseMssqlReadModel<MsSqlThingyReadModel>() .UseMssqlReadModel<MsSqlThingyMessageReadModel, ThingyMessageLocator>() .AddQueryHandlers( typeof(MsSqlThingyGetQueryHandler), typeof(MsSqlThingyGetVersionQueryHandler), typeof(MsSqlThingyGetMessagesQueryHandler)) .CreateResolver(); var databaseMigrator = resolver.Resolve<IMsSqlDatabaseMigrator>(); EventFlowEventStoresMsSql.MigrateDatabase(databaseMigrator); databaseMigrator.MigrateDatabaseUsingEmbeddedScripts(GetType().Assembly); return resolver; }