public StartTransactionOperation(TaskCompletionSource<EventStoreTransaction> source, Guid corrId, bool forward, string stream, int expectedVersion, EventStoreConnection parentConnection) { _source = source; _corrId = corrId; _forward = forward; _stream = stream; _expectedVersion = expectedVersion; _parentConnection = parentConnection; }
public EventStoreClient(string connUri, Microsoft.Extensions.Logging.ILogger logger) { _logger = logger; var settings = ConnectionSettings.Create().UseCustomLogger(new EventStoreClientLogger(_logger)).FailOnNoServerResponse().Build(); try { _client = EventStoreConnection.Create(settings, new Uri(connUri)); _client.AuthenticationFailed += this.Handle_AuthenticationFailed; _client.Closed += this.Handle_Closed; _client.Connected += this.Handle_Connected; _client.Disconnected += this.Handle_Disconnected; _client.ErrorOccurred += this.Handle_ErrorOccurred; _client.Reconnecting += this.Handle_Reconnecting; } catch (Exception esException) { logger.LogError(esException, esException.Message); throw; } }
public static async Task JsonFormat() { var conn = EventStoreConnection.Create(new Uri("tcp://*****:*****@localhost:1113")); await conn.ConnectAsync(); var data = Encoding.UTF8.GetBytes("{\"a\":\"2\"}"); var metadata = Encoding.UTF8.GetBytes("{}"); var evt = new EventData(Guid.NewGuid(), "testEvent", true, data, metadata); await conn.AppendToStreamAsync("test-stream", ExpectedVersion.Any, evt); var streamEvents = await conn.ReadStreamEventsForwardAsync("test-stream", 0, 1, false); var returnedEvent = streamEvents.Events[0].Event; Console.WriteLine( "Read event with data: {0}, metadata: {1}", Encoding.UTF8.GetString(returnedEvent.Data), Encoding.UTF8.GetString(returnedEvent.Metadata) ); }
static async Task <IEventStoreConnection> ConfigureEventStore(string connectionString) { var gesConnection = EventStoreConnection.Create( connectionString, ConnectionSettings.Create() .EnableVerboseLogging() .KeepReconnecting() .KeepRetrying() .SetOperationTimeoutTo(FromSeconds(10)) .SetTimeoutCheckPeriodTo(FromSeconds(2)) .SetReconnectionDelayTo(FromSeconds(3)) .SetHeartbeatTimeout(FromSeconds(6)) .SetHeartbeatInterval(FromSeconds(3)) .SetGossipTimeout(FromSeconds(2)), "DCore.Platform.Integration.EventStore.Tests" ); await gesConnection.ConnectAsync(); return(gesConnection); }
protected override async Task Given() { var node = GetFollowers()[0]; await Task.WhenAll(node.AdminUserCreated, node.Started); using var connection = EventStoreConnection.Create(ConnectionSettings.Create() .DisableServerCertificateValidation() .PreferFollowerNode(), node.ExternalTcpEndPoint); await connection.ConnectAsync(); try { await connection.AppendToStreamAsync(ProtectedStream, ExpectedVersion.NoStream, new UserCredentials("admin", "changeit"), new EventData(Guid.NewGuid(), "-", false, Array.Empty <byte>(), Array.Empty <byte>())); } catch (Exception ex) { _caughtException = ex; } await base.Given(); }
public EventStoreSnapshotStore() { var serialization = Context.System.Serialization; _serializer = serialization.FindSerializerForType(typeof(SelectedSnapshot)); _connection = new Lazy <Task <IEventStoreConnection> >(async() => { var settings = ConnectionSettings.Create() //.KeepReconnecting() .UseConsoleLogger() .SetDefaultUserCredentials(new UserCredentials("admin", "changeit")); var endPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113); IEventStoreConnection connection = EventStoreConnection.Create(settings, endPoint, "akka.net-store"); await connection.ConnectAsync(); return(connection); }); }
public void return_empty_slice_if_asked_to_read_from_end() { const string stream = "read_all_events_forward_should_return_empty_slice_if_asked_to_read_from_end"; using (var store = EventStoreConnection.Create()) { store.Connect(Node.TcpEndPoint); var create = store.CreateStreamAsync(stream, false, new byte[0]); Assert.DoesNotThrow(create.Wait); var testEvents = Enumerable.Range(0, 5).Select(x => new TestEvent((x + 1).ToString())).ToArray(); var write5 = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents); Assert.DoesNotThrow(write5.Wait); var read = store.ReadAllEventsForwardAsync(Position.End, 1); Assert.DoesNotThrow(read.Wait); Assert.That(read.Result.Events.Length, Is.EqualTo(0)); } }
public void SetUp() { _logger = new ConsoleLogger(); _eventStoreConnection = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 1113)); _eventStoreConnection.ConnectAsync().Wait(); _eventStoreSession = new EventStoreSession(_eventStoreConnection, _logger); Resolver.Configure( type => { if (type == typeof(ILogger)) { return(_logger); } throw new InvalidOperationException($"No type of {type} registered."); }, type => null, o => { }); }
public void be_able_to_subscribe_to_non_existing_stream_and_then_catch_created_event() { const string stream = "subscribe_should_be_able_to_subscribe_to_non_existing_stream_and_then_catch_created_event"; using (var store = EventStoreConnection.Create()) { store.Connect(MiniNode.Instance.TcpEndPoint); var appeared = new CountdownEvent(1); var dropped = new CountdownEvent(1); Action <RecordedEvent, Position> eventAppeared = (x, p) => appeared.Signal(); Action subscriptionDropped = () => dropped.Signal(); store.SubscribeAsync(stream, eventAppeared, subscriptionDropped); var create = store.CreateStreamAsync(stream, false, new byte[0]); Assert.That(create.Wait(Timeout)); Assert.That(appeared.Wait(Timeout)); } }
public EventStoreJournal() { _log = Context.GetLogger(); var serialization = Context.System.Serialization; _serializer = serialization.FindSerializerForType(typeof(IPersistentRepresentation)); _connection = new Lazy <Task <IEventStoreConnection> >(async() => { var settings = ConnectionSettings.Create() .KeepReconnecting() .SetDefaultUserCredentials(new UserCredentials("admin", "changeit")); var endPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 4532); IEventStoreConnection connection = EventStoreConnection.Create(settings, endPoint, "akka.net"); await connection.ConnectAsync(); return(connection); }); }
public void should_timeout_connection_after_configured_amount_time_on_conenct() { var closed = new ManualResetEventSlim(); var settings = ConnectionSettings.Create() .EnableVerboseLogging() .UseCustomLogger(ClientApiLoggerBridge.Default) .LimitReconnectionsTo(0) .SetReconnectionDelayTo(TimeSpan.FromMilliseconds(0)) .FailOnNoServerResponse() .WithConnectionTimeoutOf(TimeSpan.FromMilliseconds(1000)); if (_tcpType == TcpType.Ssl) { settings.UseSslConnection("ES", false); } var ip = new IPAddress(new byte[] { 8, 8, 8, 8 }); //NOTE: This relies on Google DNS server being configured to swallow nonsense traffic const int port = 4567; using (var connection = EventStoreConnection.Create(settings, new IPEndPoint(ip, port).ToESTcpUri())) { connection.Closed += (s, e) => closed.Set(); connection.Connected += (s, e) => Console.WriteLine("EventStoreConnection '{0}': connected to [{1}]...", e.Connection.ConnectionName, e.RemoteEndPoint); connection.Reconnecting += (s, e) => Console.WriteLine("EventStoreConnection '{0}': reconnecting...", e.Connection.ConnectionName); connection.Disconnected += (s, e) => Console.WriteLine("EventStoreConnection '{0}': disconnected from [{1}]...", e.Connection.ConnectionName, e.RemoteEndPoint); connection.ErrorOccurred += (s, e) => Console.WriteLine("EventStoreConnection '{0}': error = {1}", e.Connection.ConnectionName, e.Exception); connection.ConnectAsync().Wait(); if (!closed.Wait(TimeSpan.FromSeconds(15))) { Assert.Fail("Connection timeout took too long."); } } }
public static void AddMyEventStoreServices(this IServiceCollection services, IConfiguration config) { var consumeEvents = config.GetOptionalValue("eventStore:consume", false); if (consumeEvents) { services.AddTransient <EventConsumerActor>(); } config.ConfigureByOption("eventStore:type", new Options { ["MongoDb"] = () => { var mongoConfiguration = config.GetRequiredValue("eventStore:mongoDb:configuration"); var mongoDatabaseName = config.GetRequiredValue("eventStore:mongoDb:database"); services.AddSingleton(c => { var mongoClient = Singletons <IMongoClient> .GetOrAdd(mongoConfiguration, s => new MongoClient(s)); var mongDatabase = mongoClient.GetDatabase(mongoDatabaseName); return(new MongoEventStore(mongDatabase, c.GetRequiredService <IEventNotifier>())); }) .As <IExternalSystem>() .As <IEventStore>(); }, ["GetEventStore"] = () => { var eventStoreConfiguration = config.GetRequiredValue("eventStore:getEventStore:configuration"); var eventStoreProjectionHost = config.GetRequiredValue("eventStore:getEventStore:projectionHost"); var eventStorePrefix = config.GetValue <string>("eventStore:getEventStore:prefix"); var connection = EventStoreConnection.Create(eventStoreConfiguration); services.AddSingleton(c => new GetEventStore(connection, eventStorePrefix, eventStoreProjectionHost)) .As <IExternalSystem>() .As <IEventStore>(); } }); }
private async Task BuildEventStore(IServiceCollection services) { //Create EventStore Connection var gesConnection = EventStoreConnection.Create( Configuration["EventStore:ConnectionString"], ConnectionSettings.Create() .KeepReconnecting() .EnableVerboseLogging() .SetHeartbeatInterval(TimeSpan.FromMilliseconds(5 * 1000)) .UseDebugLogger(), Environment.ApplicationName ); gesConnection.Connected += (sender, args) => Console.WriteLine($"Connection to {args.RemoteEndPoint} event store established."); gesConnection.ErrorOccurred += (sender, args) => Console.WriteLine($"Connection error : {args.Exception}"); await gesConnection.ConnectAsync(); var serializer = new JsonNetSerializer(); var eventMapper = new EventTypeMapper() .Map <Domain.Events.V1.ReviewCreated>("reviewCreated") .Map <Domain.Events.V1.CaptionAndContentChanged>("reviewUpdated") .Map <Domain.Events.V1.ReviewPublished>("reviewPublished") .Map <Domain.Events.V1.ReviewApproved>("reviewApproved"); var aggregateStore = new GesAggrigateStore( gesConnection, serializer, eventMapper, (type, id) => $"{type.Name}-{id}", null); services.AddSingleton(new ApplicationService(aggregateStore)); }
static async Task Main(string[] args) { var gesConnection = EventStoreConnection.Create(new Uri("tcp://*****:*****@localhost:1113"), "InputFromFileConsoleApp"); await gesConnection.ConnectAsync(); var aggregateStore = new AggregateStore(gesConnection); var orderId = Guid.NewGuid(); var order = Order.Create(orderId, new CustomerId("alper")); order.AddItem(new ProductId("ekmek"), 1, 5); order.AddItem(new ProductId("yumurta"), 5, 2); order.AddItem(new ProductId("sucuk"), 5, 2); order.RemoveItem(new ProductId("sucuk")); order.Ship(); await aggregateStore.Save(order); Console.WriteLine($"Saved Order=>{order.ToString()}"); var orderRead = await aggregateStore.Load <Order>(orderId.ToString()); orderRead.Complate(); await aggregateStore.Save(orderRead); Console.WriteLine(orderRead); Console.ReadKey(); }
public async Task HandleAsync(ICommand _command) { var cmd = _command as I本を延長するCommand; if (cmd == null) { throw new ArgumentException(nameof(_command), "I本を延長するCommand型ではありません。"); } using (var c = EventStoreConnection.Create( ConnectionSettings.Create().SetDefaultUserCredentials(Connection.UserCredentials()) , Connection.EventStoreUri())) { try { await c.ConnectAsync(); await c.AppendToStreamAsync( cmd.本のID.ID文字列, ExpectedVersion.StreamExists, new EventData( Guid.NewGuid(), Domain.RentalSubDomain.Events.Book.ExtendedBookVer100, true, JsonSerializer.Serialize( Domain.RentalSubDomain.Events.Book.ExtendedBookDTOVer100.Create( cmd.本のID.ID文字列, cmd.貸出期間.貸出期間自DateTime, cmd.貸出期間.貸出期間至DateTime ) ), new byte[] {} )); } finally { c.Close(); } } }
public void ConfigureServices(IServiceCollection services) { services.AddAuthorization(options => { options.AddPolicy("SystemMessagingPolicy", policyAdmin => { policyAdmin.RequireClaim("scope", "gofish.messaging"); }); }); services.AddMvc(); services.Configure <ApplicationSettings>(_config.GetSection("ApplicationSettings")); services.AddDbContext <AdvertisingDbContext>(); services.AddTransient <IMessageBroker <Advert>, AdvertMessageBroker>(); services.AddTransient <AdvertRepository, AdvertRepository>(); services.AddTransient <ICommandMediator, CommandMediator>(); services.AddTransient <IAdvertFactory, AdvertFactory>(); services.AddTransient <ILookupCacheProvider, LookupCacheProvider>(); services.AddTransient <ICommandHandler <CreateAdvertCommand, Advert>, CreateAdvertCommandHandler>(); services.AddTransient <ICommandHandler <UpdateAdvertCommand, Advert>, UpdateAdvertCommandHandler>(); services.AddTransient <ICommandHandler <PostAdvertCommand, Advert>, PostAdvertCommandHandler>(); services.AddTransient <ICommandHandler <PublishAdvertCommand, Advert>, PublishAdvertCommandHandler>(); services.AddTransient <ICommandHandler <WithdrawAdvertCommand, Advert>, WithdrawAdvertCommandHandler>(); services.AddTransient <ICommandHandler <StockUpdatedCommand, Advert>, StockUpdatedCommandHandler>(); var config = new AutoMapper.MapperConfiguration(cfg => { cfg.CreateMap <Advert, AdvertDto>(); cfg.CreateMap <Advert, AddAdvertToStockDto>(); }); services.AddSingleton <AutoMapper.IMapper>(sp => config.CreateMapper()); services.AddSingleton <IEventStoreConnection>(sp => EventStoreConnection.Create(new Uri(_config["ApplicationSettings:EventStoreUrl"]))); services.AddScoped <ModelStateActionFilterAttribute>(); }
static void Main(string[] args) { var projector = new SqlProjector( Resolve.WhenEqualToHandlerMessageType(new OnHandInventoryViewProjection()), new TransactionalSqlCommandExecutor( SqlClientFactory.Instance, @"Data Source=localhost;Initial Catalog=InventoryPOC;Integrated Security=SSPI;", IsolationLevel.ReadCommitted)); projector.Project(new List <object> { new DropSchema(), new CreateSchema() }); var credentials = new UserCredentials("admin", "changeit"); var connectionSettings = ConnectionSettings.Create() .KeepReconnecting() .KeepRetrying() .FailOnNoServerResponse() .WithConnectionTimeoutOf(TimeSpan.FromSeconds(20)) .SetOperationTimeoutTo(TimeSpan.FromSeconds(10)) .SetHeartbeatInterval(TimeSpan.FromSeconds(10)) .SetHeartbeatTimeout(TimeSpan.FromSeconds(20)); using (var connection = EventStoreConnection.Create("ConnectTo=tcp://admin:[email protected]:1113; HeartBeatTimeout=5000", connectionSettings)) { connection.ConnectAsync().GetAwaiter().GetResult(); var subscription = connection.SubscribeToStreamFrom("$ce-ledgerEntry", StreamPosition.Start, CatchUpSubscriptionSettings.Default, (_, @event) => { projector.Project( JsonConvert.DeserializeObject( Encoding.UTF8.GetString(@event.Event.Data), Assembly.GetAssembly(typeof(PortfolioRenamed)).GetType(@event.Event.EventType))); }, userCredentials: credentials); var a = subscription.LastProcessedEventNumber; Console.ReadKey(); } }
public async Task <LivenessResult> IsHealthy(LivenessExecutionContext context, CancellationToken cancellationToken = default) { try { _logger?.LogInformation($"{nameof(EventStoreLiveness)} is checking the EventStore host."); var eventStoreUri = new Uri(_uri); ConnectionSettings connectionSettings; if (string.IsNullOrEmpty(_login) || string.IsNullOrEmpty(_password)) { connectionSettings = ConnectionSettings.Create() .KeepRetrying() .Build(); } else { connectionSettings = ConnectionSettings.Create() .KeepRetrying() .SetDefaultUserCredentials(new UserCredentials(_login, _password)) .Build(); } var connection = EventStoreConnection.Create( connectionSettings, new Uri(_uri), "BeatPulse HealthCheck"); await connection.ConnectAsync(); return(LivenessResult.Healthy()); } catch (Exception ex) { _logger?.LogWarning($"The {nameof(EventStoreLiveness)} check fail for Eventstore with the exception {ex.ToString()}."); return(LivenessResult.UnHealthy(ex)); } }
public static IServiceCollection AddClearance(this IServiceCollection services, IConfiguration configuration) { services.Configure <ClearanceDatabaseSettings>(configuration.GetSection("ClearanceDtosDatabaseSettings")); services.AddSingleton <IClearanceDatabaseSettings>(sp => sp.GetRequiredService <IOptions <ClearanceDatabaseSettings> >().Value); var esConnection = EventStoreConnection.Create( ConnectionSettings.Create().KeepReconnecting().DisableServerCertificateValidation().DisableTls(), new System.Uri(configuration["ClearanceEventStoreSettings:ConnectionString"])); esConnection.ConnectAsync().Wait(); services.AddSingleton(esConnection); services.AddTransient <IRepository <ClearanceRoot>, Repository <ClearanceRoot> >(); services.AddTransient <IClearanceDtoRepository, ClearanceDtoRepository>(); services.AddTransient <IUserSettingsService, UserSettingsService>(); services.AddTransient <IAccountDtoService, AccountDtoService>(); services.AddMvcCore().AddApplicationPart(Assembly.GetExecutingAssembly()).AddControllersAsServices(); return(services); }
public static IServiceCollection AddInfrastructure(this IServiceCollection services, IConfiguration configuration) { if (configuration.GetValue <bool>("UseInMemoryDatabase")) //s.n install for getvalue Install-Package Microsoft.Extensions.Configuration.Binder -Version 5.0.0 { services.AddDbContext <ApplicationContext>(options => options.UseInMemoryDatabase("GSNew")); //s.n Install-Package Microsoft.EntityFrameworkCore.InMemory } else { /*S.N for registration ef*/ services.AddDbContext <ApplicationContext>(options => options.UseSqlServer( configuration.GetConnectionString("DefaultConnection"), b => b.MigrationsAssembly(typeof(ApplicationContext).Assembly.FullName))); } //services.AddScoped<IApplicationContext>(provider => provider.GetService<ApplicationContext>()); //return services; services.AddScoped <Func <ApplicationContext> >((provider) => () => provider.GetService <ApplicationContext>()); services.AddScoped <DbFactory>(); services.AddScoped <IUnitOfWork, UnitOfWork>(); /*S.n conifig event store*/ /*S.N Install-Package EventStore.Client -Version 5.0.9*/ var eventStoreConnection = EventStoreConnection.Create( connectionString: configuration.GetValue <string>("EventStore:ConnectionString"), builder: ConnectionSettings.Create().KeepReconnecting(), connectionName: configuration.GetValue <string>("EventStore:ConnectionName")); eventStoreConnection.ConnectAsync().GetAwaiter().GetResult(); services.AddSingleton(eventStoreConnection); services.AddScoped(typeof(IEventRepository), typeof(EventRepository)); /**/ return(services); }
static async Task Main(string[] args) { var gesConnection = EventStoreConnection.Create(new Uri("tcp://*****:*****@localhost:1113"), "InputFromFileConsoleApp"); await gesConnection.ConnectAsync(); var streamName = "abc"; var msg = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new User() { Name = "Alper", Surname = "Hankendi" })); var g = Guid.NewGuid(); //streamName += "_" + g.ToString(); await gesConnection.AppendToStreamAsync(streamName, -1, new List <EventData>() { new EventData(g, "addUser", true, msg, null) }); await gesConnection.AppendToStreamAsync(streamName, 0, new List <EventData>() { new EventData(g, "testUSER", true, msg, null) }); await gesConnection.AppendToStreamAsync(streamName, 1, new List <EventData>() { new EventData(g, "deleteUSER", true, msg, null) }); Console.ReadKey(); }
protected override async Task Given() { _conn = EventStoreConnection.Create(_node.TcpEndPoint); await _conn.ConnectAsync(); await _conn.CreatePersistentSubscriptionAsync(_streamName, _groupName, _settings, DefaultData.AdminCredentials); _sub1 = _conn.ConnectToPersistentSubscription(_streamName, _groupName, (subscription, @event) => { Console.WriteLine(); return(Task.CompletedTask); }, (subscription, reason, arg3) => Console.WriteLine(), DefaultData.AdminCredentials); _sub2 = _conn.ConnectToPersistentSubscription(_streamName, _groupName, (subscription, @event) => { Console.WriteLine(); return(Task.CompletedTask); }, (subscription, reason, arg3) => Console.WriteLine(), DefaultData.AdminCredentials); }
public async Task <IEnumerable <Event> > GetEvents(long firstEventSequenceNumber, long lastEventSequenceNumber) { using var connection = EventStoreConnection.Create( ConnectionSettings.Create().DisableTls().Build(), new Uri(ConnectionString)); await connection.ConnectAsync(); var result = await connection.ReadStreamEventsForwardAsync( "ShoppingCart", start : firstEventSequenceNumber, count : (int)(lastEventSequenceNumber - firstEventSequenceNumber), resolveLinkTos : false); return(result.Events .Select(e => new { Content = Encoding.UTF8.GetString(e.Event.Data), Metadata = JsonSerializer.Deserialize <EventMetadata>(Encoding.UTF8.GetString(e.Event.Metadata), new JsonSerializerOptions { PropertyNameCaseInsensitive = true }) ! })
public void should_fail_to_commit_if_started_with_correct_ver_but_on_commit_stream_was_deleted() { const string stream = "should_fail_to_commit_if_started_with_correct_ver_but_on_commit_stream_was_deleted"; using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint)) store.CreateStream(stream, new byte[0]); using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint)) { var start = store.StartTransactionAsync(stream, ExpectedVersion.EmptyStream); Assert.DoesNotThrow(start.Wait); var write = store.TransactionalWriteAsync(start.Result.TransactionId, start.Result.Stream, new[] { new TestEvent() }); Assert.DoesNotThrow(write.Wait); var delete = store.DeleteStreamAsync(stream, ExpectedVersion.EmptyStream); Assert.DoesNotThrow(delete.Wait); var commit = store.CommitTransactionAsync(start.Result.TransactionId, start.Result.Stream); Assert.That(() => commit.Wait(), Throws.Exception.TypeOf <AggregateException>().With.InnerException.TypeOf <StreamDeletedException>()); } }
public void should_not_fail_to_commit_if_started_with_wrong_ver_but_committing_with_correct_ver() { const string stream = "should_not_fail_to_commit_if_started_with_wrong_ver_but_committing_with_correct_ver"; using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint)) store.CreateStream(stream, new byte[0]); using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint)) { var start = store.StartTransactionAsync(stream, 1); Assert.DoesNotThrow(start.Wait); var append = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, new[] { new TestEvent() }); Assert.DoesNotThrow(append.Wait); var write = store.TransactionalWriteAsync(start.Result.TransactionId, start.Result.Stream, new[] { new TestEvent() }); Assert.DoesNotThrow(write.Wait); var commit = store.CommitTransactionAsync(start.Result.TransactionId, start.Result.Stream); Assert.DoesNotThrow(commit.Wait); } }
static void Main(string[] args) { //Bootstrap var settings = ConnectionSettings.Create() .SetDefaultUserCredentials(new UserCredentials("admin", "changeit")) .KeepReconnecting() .KeepRetrying() //.UseConsoleLogger() .Build(); var conn = EventStoreConnection.Create(settings, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113)); conn.ConnectAsync().Wait(); var eventNamespace = "Administration.EventModel.Events"; var eventAssembly = "Administration"; var repo = new SimpleRepo(conn, eventNamespace, eventAssembly); var roomTypeRm = new RoomTypeReader(() => conn, repo.Deserialize); var mainBus = new SimpleBus(); var adminSvc = new AdminSvc(repo); mainBus.Subscribe <AddRoomType>(adminSvc); mainBus.Subscribe <AddRoom>(adminSvc); var view = new ConsoleView(); var controller = new Controller(view, mainBus); roomTypeRm.Subscribe(model => view.RoomSummaries = model); view.Redraw(); roomTypeRm.Start(); controller.StartCommandLoop(); Console.WriteLine("press enter to exit"); Console.ReadLine(); }
static void Main() { StreamEventsSlice streamEvents; using (var connection = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 1113))) { connection.ConnectAsync().Wait(); streamEvents = connection.ReadStreamEventsForwardAsync( "test-stream", StreamPosition.Start, 2500, true).Result; } var returnedEvents = streamEvents.Events; var streamLength = returnedEvents.Length; var eventDataDictionary = new Dictionary <long, string>(); var eventCount = 0; foreach (ResolvedEvent eve in returnedEvents) { var number = eve.Event.EventNumber; var data = Encoding.UTF8.GetString(eve.Event.Data); eventDataDictionary.Add(number, data); eventCount++; //For testing: //Console.WriteLine($"Caught up on {eventCount}/{streamLength}: {data}"); if (eventCount == 0 || eventCount % 50 == 0) { Console.WriteLine($"Caught up on {eventCount}/{streamLength} events in stream"); } } Console.WriteLine("All caught up"); }
public static void AddEventStore(this IServiceCollection services, IConfiguration configuration) { var eventStoreConfig = configuration.GetSection("EventStore").Get <EventStoreConfig>(); var userCrendetials = new global::EventStore.ClientAPI.SystemData.UserCredentials(eventStoreConfig.Username, eventStoreConfig.Password); var connectionSettings = ConnectionSettings.Create(); connectionSettings.SetDefaultUserCredentials(userCrendetials); connectionSettings.KeepReconnecting(); var eventStoreConnection = EventStoreConnection.Create( connectionSettings: connectionSettings, uri: eventStoreConfig.Host, connectionName: "Meeting.Topics.API"); eventStoreConnection.ConnectAsync().GetAwaiter().GetResult(); services.AddSingleton(eventStoreConnection); services.AddTransient <IEventStore, EventStore>(); }
protected override void Load(ContainerBuilder builder) { builder .Register(x => { var settings = ConnectionSettings .Create() .KeepReconnecting() .KeepRetrying() .FailOnNoServerResponse(); var connection = EventStoreConnection.Create(ConnectionString, settings); connection.ConnectAsync().Wait(); return(connection); }) .As <IEventStoreConnection>() .InstancePerLifetimeScope(); builder.RegisterGeneric(typeof(EventStoreRepository <,>)) .AsImplementedInterfaces(); builder .Register( x => BullOak.Repositories.Configuration .Begin() .WithDefaultCollection() .WithDefaultStateFactory() .AlwaysUseThreadSafe() .WithEventPublisher(new EventPublisher(x.Resolve <IPublishEndpoint>())) .WithAnyAppliersFrom(AppliersAssembly).AndNoMoreAppliers() .WithNoUpconverters() .Build()) .As <IHoldAllConfiguration>(); builder.RegisterType <EventCleaner>() .AsSelf(); base.Load(builder); }
private static void Main(string[] args) { var runtime = Runtime.StartNewAsync().Result; var connection = EventStoreConnection .Create(ConnectionSettings.Create().Build(), new IPEndPoint(IPAddress.Loopback, 1113)); connection.ConnectAsync().Wait(); Console.WriteLine(@"Type ""q"" to quit"); Console.WriteLine(@"Type ""a"" to append an event"); string input; do { input = Console.ReadLine(); if (input != "a") { continue; } var @event = new ItemPurchased(GuidEncoder.Encode(Guid.NewGuid())); var metadata = new Dictionary <string, string> { { "tenantId", "Warehouse A" }, { "$correlationId", GuidEncoder.Encode(Guid.NewGuid()) } }; var eventData = EventSerializer.Serialize(Guid.NewGuid(), @event, metadata); connection.AppendToStreamAsync("ingress", ExpectedVersion.Any, eventData).Wait(); Console.WriteLine("Appended event"); } while (!string.Equals(input, "q")); runtime.Stop(); Console.WriteLine("Stopping..."); }
public async Task SetupFixture() { _embeddedEventStore = new EmbeddedEventStoreFixture(); await _embeddedEventStore.Initialize(); await Task.Delay(5000); var userCredentials = new UserCredentials("admin", "changeit"); var connectionSettings = ConnectionSettings.Create().WithConnectionTimeoutOf(TimeSpan.FromSeconds(10)).SetDefaultUserCredentials(userCredentials); _connection = EventStoreConnection.Create(connectionSettings, new Uri(EventStoreRepositoryConfiguration.Default.ConnectionString)); await _connection.ConnectAsync(); await Task.Delay(200); await CreateSubscription(_connection, euroDolStream, euroDolStream); await Task.Delay(200); await CreateSubscription(_connection, euroJpyStream, euroJpyStream); }