public async Task Crate() { #region CreatePersistentSubscription var userCredentials = new UserCredentials("admin", "changeit"); var settings = PersistentSubscriptionSettings .Create() .DoNotResolveLinkTos() .StartFromCurrent(); await conn.CreatePersistentSubscriptionAsync( "myStream", "grour1", settings, userCredentials ); var subscription = await conn.ConnectToPersistentSubscriptionAsync( "myStream", "group1", (_, evt) => Console.WriteLine($"Received: {Encoding.UTF8.GetString(evt.Event.Data)}") ); #endregion CreatePersistentSubscription }
public static async Task <int> Main(string[] args) { // enumerate all streams IEventStoreConnection conn = EventStoreConnection.Create(connection); await Task.Run(() => conn.ConnectAsync()); try { await conn.CreatePersistentSubscriptionAsync(stream, group, PersistentSubscriptionSettings.Create(), null); } catch { } dynamic ps = conn.ConnectToPersistentSubscription(stream, group, (s, e) => Process(s, e), (s, r, ex) => HandleException(s, r, ex), null, 2, false); Console.ReadKey(); }
private PersistentSubscriptionSettings CreateSettings() => PersistentSubscriptionSettings .Create() .DoNotResolveLinkTos() .WithNamedConsumerStrategy(SystemConsumerStrategies.DispatchToSingle) .StartFrom(ProcessedEventCountHandler.ReadNumberOfProcessedEvents()) .Build();
private async Task CreateSubscription(IEventStoreConnection connection, string stream, string group) { var persistentSubscriptionSettings = PersistentSubscriptionSettings.Create().DoNotResolveLinkTos().StartFromCurrent(); var userCredentials = new UserCredentials("admin", "changeit"); await connection.CreatePersistentSubscriptionAsync(stream, group, persistentSubscriptionSettings, userCredentials); }
public void Test() { var settings = PersistentSubscriptionSettings .Create() .StartFromCurrent() .ResolveLinkTos() .Build(); _conn.CreatePersistentSubscriptionAsync(StreamName, GroupName, settings, DefaultData.AdminCredentials) .Wait(); _conn.ConnectToPersistentSubscription(StreamName, GroupName, (subscription, resolvedEvent) => { if (Interlocked.Increment(ref _eventReceivedCount) == EventWriteCount) { _eventsReceived.Set(); } return(Task.CompletedTask); }, (sub, reason, exception) => Console.WriteLine("Subscription dropped (reason:{0}, exception:{1}).", reason, exception), userCredentials: DefaultData.AdminCredentials); for (var i = 0; i < EventWriteCount; i++) { var eventData = new EventData(Guid.NewGuid(), "SomeEvent", false, new byte[0], new byte[0]); _conn.AppendToStreamAsync(StreamName, ExpectedVersion.Any, DefaultData.AdminCredentials, eventData); } if (!_eventsReceived.WaitOne(TimeSpan.FromSeconds(5))) { throw new Exception("Timed out waiting for events."); } }
protected override async Task When() { var task = new TaskCompletionSource <string>(); var setts = PersistentSubscriptionSettings.Create() .ResolveLinkTos() .StartFromBeginning(); await _conn.CreatePersistentSubscriptionAsync("link", "Agroup", setts, DefaultData.AdminCredentials); await _conn.ConnectToPersistentSubscriptionAsync( "link", "Agroup", (sub, @event) => { var data = Encoding.Default.GetString(@event.Event.Data); task.TrySetResult(data); return(Task.CompletedTask); }, (sub, reason, ex) => { }, DefaultData.AdminCredentials); await _conn.AppendToStreamAsync("target@me@com", ExpectedVersion.NoStream, TestEvent.NewTestEvent("data", eventName: "AEvent")); await _conn.AppendToStreamAsync("link", ExpectedVersion.NoStream, TestEvent.NewTestEvent("0@target@me@com", eventName: "$>")); _result = await Task.WhenAny(task.Task, Task.Delay(TimeSpan.FromSeconds(30)).ContinueWith(_ => "timeout")).Result; }
private void CreateStream() { var settings = PersistentSubscriptionSettings.Create(); _connectionES.CreatePersistentSubscriptionAsync(streamName, "PictureScan", settings, _connectionES.Settings.DefaultUserCredentials); SetPermisions(); }
private static async Task AccountCreatedEventAppeared( EventStorePersistentSubscriptionBase eventStorePersistentSubscriptionBase, ResolvedEvent resolvedEvent) { var accountEvent = ConvertEventDataToAccountDomainEvent(resolvedEvent); if (accountEvent == null) { return; } try { await _subscriptionConnection.CreatePersistentSubscriptionAsync( $"Account-{accountEvent.StreamId}", "InvoiceGeneration", PersistentSubscriptionSettings .Create() .StartFromBeginning() .CheckPointAfter(TimeSpan.FromSeconds(5)) .ResolveLinkTos() .Build(), new UserCredentials("admin", "changeit")); } catch (Exception e) { Console.WriteLine($"Subscription already exist."); } await _subscriptionConnection.ConnectToPersistentSubscriptionAsync($"Account-{accountEvent.StreamId}", "InvoiceGeneration", AccountEventAppeared); }
protected override async Task OnInitializedAsync() { await base.OnInitializedAsync(); Counters.Clear(); var subSettings = PersistentSubscriptionSettings.Create() .ResolveLinkTos() .StartFromBeginning() .Build(); try { await Connection.CreatePersistentSubscriptionAsync(_subscriptionStream, _channel, subSettings, default); } catch (Exception) { await Connection.UpdatePersistentSubscriptionAsync(_subscriptionStream, _channel, subSettings, default); } _subscription = await Connection.ConnectToPersistentSubscriptionAsync( stream : _subscriptionStream, groupName : _channel, eventAppeared : async(sub, e, position) => { s_log.Information("Received counter-click."); await InvokeAsync(() => { switch (e.Event.EventType) { case "counter-added": var added = JsonSerializer.Deserialize <AddCounter>(new ReadOnlySpan <byte>(e.Event.Data)); Counters.Add(new Counter { CounterId = added.Id, Label = added.Label, NumberOfClicks = 0 }); s_log.Information("Counter added."); break; case "counter-clicked": var clickedOn = JsonSerializer.Deserialize <CounterClicked>(new ReadOnlySpan <byte>(e.Event.Data)); var counter = Counters.SingleOrDefault(c => c.CounterId == clickedOn.CounterId); if (counter != null) { s_log.Information("Counter entry found. Adding +1 to value."); counter.NumberOfClicks += 1; } s_log.Information("Counter clicked."); break; } StateHasChanged(); }); }, subscriptionDropped : (sub, reason, exc) => { }, userCredentials : default
public async Task <bool> ConnectRoundRobinPersistentSubscription(string stream, string group, CancellationToken token, Action <string, long, IFullEvent> callback, Func <Task> disconnected) { var clientsToken = CancellationTokenSource.CreateLinkedTokenSource(token); foreach (var client in _clients) { Logger.Write(LogLevel.Info, () => $"Connecting to persistent subscription stream [{stream}] group [{group}] on client {client.Settings.GossipSeeds[0].EndPoint.Address}"); var settings = PersistentSubscriptionSettings.Create() .StartFromBeginning() .WithMaxRetriesOf(10) .WithReadBatchOf(_readSize) .WithBufferSizeOf(_readSize * 3) .WithLiveBufferSizeOf(_readSize) .DontTimeoutMessages() .CheckPointAfter(TimeSpan.FromSeconds(30)) .MaximumCheckPointCountOf(_readSize * 3) .ResolveLinkTos() .WithNamedConsumerStrategy(SystemConsumerStrategies.RoundRobin); if (_extraStats) { settings.WithExtraStatistics(); } try { await client.CreatePersistentSubscriptionAsync(stream, group, settings, client.Settings.DefaultUserCredentials).ConfigureAwait(false); Logger.Info($"Created ROUND ROBIN persistent subscription stream [{stream}] group [{group}]"); } catch (InvalidOperationException) { // Already created } try { var subscription = await client.ConnectToPersistentSubscriptionAsync(stream, group, eventAppeared : (sub, e) => EventAppeared(sub, e, clientsToken.Token, callback), subscriptionDropped : (sub, reason, ex) => SubscriptionDropped(sub, reason, ex, disconnected), // Let us accept large number of unacknowledged events bufferSize : _readSize, autoAck : false).ConfigureAwait(false); lock (_subLock) _persistentSubs.Add(subscription); Logger.Write(LogLevel.Info, () => $"Connected to persistent subscription stream [{stream}] group [{group}] on client {client.Settings.GossipSeeds[0].EndPoint.Address}"); } catch (OperationTimedOutException) { return(false); } } return(true); }
public async Task Subscribe(string streamName, Func <Guid, object, Task> messageSender) { await DefaultRetryAsync(() => SubscribeImpl()); async Task SubscribeImpl() { await CreateSubscription(); await _conn.ConnectToPersistentSubscriptionAsync( streamName, _options.GroupSubscription, (_, x) => messageSender( GetAggregateId(x.Event.EventStreamId), _eventDeserializer.Deserialize(x.Event))); Guid GetAggregateId(string streamId) { var streamIdParts = streamId.Split('-'); return(streamIdParts.Length == 2 ? Guid.TryParse(streamIdParts[1], out Guid aggregateId) ? aggregateId : Guid.Empty : Guid.Empty); } async Task CreateSubscription() { var settings = PersistentSubscriptionSettings.Create() .ResolveLinkTos() .StartFromCurrent(); await _conn.CreatePersistentSubscriptionAsync(streamName, _options.GroupSubscription, settings, _options.Credentials); } } }
static async Task Main(string[] args) { var builder = ConnectionSettings.Create() .UseConsoleLogger(); var conn = EventStoreConnection.Create("ConnectTo=tcp://admin:changeit@localhost:1113", builder); await conn.ConnectAsync(); const string streamName = "e-commerce-stream"; const string groupName = "start-from-beg"; var settings = PersistentSubscriptionSettings.Create() .DoNotResolveLinkTos() .StartFromBeginning(); try { await conn.CreatePersistentSubscriptionAsync(streamName, groupName, settings, null); } catch (Exception e) { Console.WriteLine(e); } await conn.ConnectToPersistentSubscriptionAsync(streamName, groupName, EventAppeared); Console.WriteLine("Waiting for events. Press a key to quit."); Console.ReadLine(); }
static async Task Step2Subs() { var conn = await Connection.CreateConnection(); var streamName = Globals.StreamName; var adminCredentials = Globals.AdminCredentials; #region PersistentSubscription var settings = PersistentSubscriptionSettings .Create() .DoNotResolveLinkTos() .StartFromCurrent(); await conn.CreatePersistentSubscriptionAsync(streamName, "examplegroup", settings, adminCredentials); await conn.ConnectToPersistentSubscriptionAsync( streamName, "examplegroup", (_, x) => { var data = Encoding.ASCII.GetString(x.Event.Data); Console.WriteLine($"Received: {x.Event.EventStreamId}:{x.Event.EventNumber}"); Console.WriteLine(data); }, (sub, reason, ex) => { }, adminCredentials ); Console.WriteLine("waiting for events. press enter to exit"); Console.ReadLine(); #endregion PersistentSubscription }
public async Task CreatePersistentSubscriptionAsync(string stream, string group) { _logger.LogDebug("CreatePersistentSubscriptionAsync {Stream} {Group}", stream, group); var manager = _provider.CreatePersistentSubscriptionsManager(); var cred = _provider.AdminCredentials; //var con = await _provider.GetActiveConnection().ConfigureAwait(false); var con = _provider.GetActiveConnection(); var list = await manager.List(cred).ConfigureAwait(false); var exists = list.Any(x => string.Equals(x.EventStreamId, stream) && string.Equals(x.GroupName, group)); if (!exists) { _logger.LogInformation("Creating PersistentSubscription {Group} on {Stream}", group, stream); PersistentSubscriptionSettings settings = PersistentSubscriptionSettings.Create() .DoNotResolveLinkTos() .StartFromBeginning(); // configure?.Invoke(settings); await con.CreatePersistentSubscriptionAsync(stream, @group, settings, cred).ConfigureAwait(false); } else { _logger.LogDebug("PersistensSubscription {Group} on {Stream} exists", group, stream); } }
public void should_be_able_to_connect_to_persistent_subscription() { var groupId = "group-" + Guid.NewGuid().ToString(); var settings = PersistentSubscriptionSettings.Create().StartFrom(intMaxValue); Assert.DoesNotThrow(() => _store.CreatePersistentSubscriptionAsync(_streamId, groupId, settings, DefaultData.AdminCredentials).Wait()); var evnt = new EventData(Guid.NewGuid(), "EventType", false, new byte[10], new byte[15]); List <EventStore.ClientAPI.ResolvedEvent> receivedEvents = new List <EventStore.ClientAPI.ResolvedEvent>(); var countdown = new CountdownEvent(3); _store.ConnectToPersistentSubscriptionAsync(_streamId, groupId, (s, e) => { receivedEvents.Add(e); countdown.Signal(); return(Task.CompletedTask); }).Wait(); _store.AppendToStreamAsync(_streamId, intMaxValue + 2, evnt).Wait(); Assert.That(countdown.Wait(TimeSpan.FromSeconds(5)), "Timed out waiting for events to appear"); Assert.AreEqual(_r1.EventId, receivedEvents[0].Event.EventId); Assert.AreEqual(_r2.EventId, receivedEvents[1].Event.EventId); Assert.AreEqual(evnt.EventId, receivedEvents[2].Event.EventId); }
public void should_be_able_to_create_the_persistent_subscription() { var groupId = "group-" + Guid.NewGuid().ToString(); var settings = PersistentSubscriptionSettings.Create().StartFrom(intMaxValue); Assert.DoesNotThrow(() => _store.CreatePersistentSubscriptionAsync(_streamId, groupId, settings, DefaultData.AdminCredentials).Wait()); }
/// <summary> /// Transforms the <see cref="SubscriptionOptionsDto"/> into a new <see cref="PersistentSubscriptionSettings"/> /// </summary> /// <param name="subscriptionOptions">The <see cref="SubscriptionOptionsDto"/> to transform</param> /// <returns>A new <see cref="PersistentSubscriptionSettings"/></returns> public static PersistentSubscriptionSettings ToPersistentSubscriptionSettings(this SubscriptionOptionsDto subscriptionOptions) { PersistentSubscriptionSettingsBuilder builder = PersistentSubscriptionSettings.Create(); if (subscriptionOptions.StreamPosition.HasValue) { switch (subscriptionOptions.StreamPosition.Value) { case StreamPosition.Start: builder.StartFromBeginning(); break; case StreamPosition.End: builder.StartFromCurrent(); break; default: builder.StartFrom(subscriptionOptions.StreamPosition.Value); break; } } builder.ResolveLinkTos(); builder.WithMaxSubscriberCountOf(1); builder.MinimumCheckPointCountOf(1); builder.MaximumCheckPointCountOf(1); return(builder.Build()); }
/// <summary> /// Creates the persistent subscription from position. /// </summary> /// <param name="stream">The stream.</param> /// <param name="groupName">Name of the group.</param> /// <param name="position">The position.</param> /// <returns></returns> public async Task CreatePersistentSubscriptionFromPosition(String stream, String groupName, Int32 position) { PersistentSubscriptionSettingsBuilder settingsBuilder = PersistentSubscriptionSettings.Create() .ResolveLinkTos().WithMaxRetriesOf(10).WithMessageTimeoutOf(TimeSpan.FromSeconds(10)).StartFrom(position); await this.CreatePersistentSubscription(stream, groupName, settingsBuilder.Build()); }
private static async Task CreateSubscription(IEventStoreConnection conn, EventStoreOptions options) { var settings = PersistentSubscriptionSettings.Create() .ResolveLinkTos() .StartFromCurrent(); await conn.CreatePersistentSubscriptionAsync(options.Subscription.stream, options.Subscription.group, settings, options.Credentials); }
public async Task with_credentials(bool useSsl) { var streamName = $"{GetStreamName()}_{useSsl}"; var connection = _fixture.Connections[useSsl]; await connection.CreatePersistentSubscriptionAsync(streamName, Group, PersistentSubscriptionSettings.Create(), DefaultUserCredentials.Admin).WithTimeout(); }
public async Task should_be_able_to_update_the_persistent_subscription() { var groupId = "group-" + Guid.NewGuid().ToString(); var settings = PersistentSubscriptionSettings.Create(); await _store.CreatePersistentSubscriptionAsync(_streamId, groupId, settings, DefaultData.AdminCredentials); settings = PersistentSubscriptionSettings.Create().StartFrom(intMaxValue); await _store.UpdatePersistentSubscriptionAsync(_streamId, groupId, settings, DefaultData.AdminCredentials); }
public async Task without_credentials_throws(bool useSsl) { var streamName = $"{GetStreamName()}_{useSsl}"; var connection = _fixture.Connections[useSsl]; await Assert.ThrowsAsync <AccessDeniedException>(() => connection.CreatePersistentSubscriptionAsync( streamName, Group, PersistentSubscriptionSettings.Create(), null).WithTimeout()); }
public async Task persistent_subscription_delivers_all_events(int iteration) { const int eventCount = 250; const int totalEvents = eventCount * 2; EventStorePersistentSubscriptionBase subscription = null; try { var userCredentials = new UserCredentials("admin", "changeit"); int hitCount = 0; var streamName = $"stream_{iteration}"; var subscriptionName = $"subscription_{iteration}"; var completed = new AutoResetEvent(false); var connection = _fixture.Connection; for (var i = 0; i < eventCount; i++) { await connection.AppendToStreamAsync(streamName, ExpectedVersion.Any, _fixture.CreateTestEvents()) .WithTimeout(); } var builder = PersistentSubscriptionSettings.Create() .StartFromBeginning() .ResolveLinkTos(); await connection.CreatePersistentSubscriptionAsync(streamName, subscriptionName, builder.Build(), userCredentials).WithTimeout(); subscription = await connection.ConnectToPersistentSubscriptionAsync(streamName, subscriptionName, (_, resolvedEvent) => { var result = Interlocked.Increment(ref hitCount); _.Acknowledge(resolvedEvent); if (totalEvents == result) { completed.Set(); } }); for (var i = 0; i < eventCount; i++) { await connection.AppendToStreamAsync(streamName, ExpectedVersion.Any, _fixture.CreateTestEvents()) .WithTimeout(); } completed.WaitOne(TimeSpan.FromSeconds(30)); Assert.Equal(totalEvents, hitCount); } finally { subscription?.Stop(TimeSpan.FromSeconds(5)); } }
public void Test() => Assert.DoesNotThrowAsync(async() => { _attempts++; if (_attempts == 1) { throw new Exception("throw on first attempt to ensure retry is working"); } _conn.Close(); _conn = BuildConnection(_node); await _conn.ConnectAsync(); var streamName = Guid.NewGuid().ToString(); var groupName = Guid.NewGuid().ToString(); var settings = PersistentSubscriptionSettings .Create() .StartFromCurrent() .WithMaxRetriesOf(0) // Don't retry messages .Build(); await _conn.CreatePersistentSubscriptionAsync(streamName, groupName, settings, DefaultData.AdminCredentials); await _conn.ConnectToPersistentSubscriptionAsync(streamName, groupName, (subscription, resolvedEvent) => { _conn.Close(); return(Task.CompletedTask); }, (sub, reason, exception) => { Console.WriteLine("Subscription dropped (reason:{0}, exception:{1}).", reason, exception); _subscriptionDropped.TrySetResult(true); }, bufferSize: 10, autoAck: false, userCredentials: DefaultData.AdminCredentials); var parkedEventData = new EventData(Guid.NewGuid(), "SomeEvent", false, new byte[0], new byte[0]); await _conn.AppendToStreamAsync(streamName, ExpectedVersion.Any, DefaultData.AdminCredentials, parkedEventData); await _subscriptionDropped.Task.WithTimeout(); _conn = BuildConnection(_node); await _conn.ConnectAsync(); await _conn.ConnectToPersistentSubscriptionAsync(streamName, groupName, (subscription, resolvedEvent) => { subscription.Acknowledge(resolvedEvent); _receivedEvent = resolvedEvent; _eventReceived.TrySetResult(true); }, (sub, reason, exception) => { Console.WriteLine("Second Subscription dropped (reason:{0}, exception:{1}).", reason, exception); }, bufferSize: 10, autoAck: false, userCredentials: DefaultData.AdminCredentials); // Ensure we only get the new event, not the previous one var newEventData = new EventData(Guid.NewGuid(), "SomeEvent", false, new byte[0], new byte[0]); await _conn.AppendToStreamAsync(streamName, ExpectedVersion.Any, DefaultData.AdminCredentials, newEventData); await _eventReceived.Task.WithTimeout(); Assert.AreEqual(newEventData.EventId, _receivedEvent.Event.EventId); });
static async Task Main(string[] args) { var streamName = "tcp-person-stream"; var groupName = "tcp-subscription-group"; var userCredentials = new UserCredentials("admin", "changeit"); var connection = CreateEventStoreConnection(userCredentials.Username, userCredentials.Password); /* * do not resolve linktos (todo: add explanation here. reference blog article. * start subscription from current position in stream, * - meaning only act on events coming in after this subscription is created. * - you can start from the beginning, StartFromBeginning, or any given position */ var settings = PersistentSubscriptionSettings .Create() .DoNotResolveLinkTos() .StartFromCurrent(); /* * since a subscription might already have been created * we need to wrap the creation, catch the exception and "silence" it. */ try { await connection.CreatePersistentSubscriptionAsync( streamName, groupName, settings, userCredentials ); } catch (InvalidOperationException e) when(e.Message.Contains($"Subscription group {groupName} on stream {streamName} already exists") ) { //InvalidOperationException: Subscription group tcp-subscription-group on stream tcp-person-stream already exists Console.WriteLine($"subscription {groupName} already exist, continuing"); } /* * as long as the console is not closed the subscription will log new events */ var subscription = connection.ConnectToPersistentSubscriptionAsync( stream: streamName, groupName: groupName, eventAppeared: (_, resolvedEvent) => { Console.WriteLine("Received: " + Encoding.UTF8.GetString(resolvedEvent.Event.Data)); }).Result; Console.WriteLine($"waiting... new events in stream '{streamName}' will be logged to the console. press Enter to Quit"); Console.Read(); }
public async Task that_does_exist_succeeds(bool useSsl) { var streamName = $"{GetStreamName()}_{useSsl}"; var connection = _fixture.Connections[useSsl]; await connection.CreatePersistentSubscriptionAsync(streamName, Group, PersistentSubscriptionSettings.Create(), DefaultUserCredentials.Admin).WithTimeout(); await connection.ConnectToPersistentSubscriptionAsync(streamName, Group, delegate { return(Task.CompletedTask); }).WithTimeout(); }
private static void CreatePersistentSubscription(IEventStoreConnection conn) { try { conn.CreatePersistentSubscriptionAsync(StreamName, GroupName, PersistentSubscriptionSettings.Create().StartFromBeginning(), new UserCredentials("admin", "changeit")).Wait(); } catch (Exception e) { // Already exist } }
public static void Method() { var userCredentials = new UserCredentials("admin", "changeit"); var settings = PersistentSubscriptionSettings.Create() .DoNotResolveLinkTos().StartFromCurrent(); conn.CreatePersistentSubscriptionAsync("newstream", "gr1", settings, userCredentials).Wait(); var subscription = conn.ConnectToPersistentSubscriptionAsync( "newstream", "gr1", (_, evt) => { Console.WriteLine("Received: " + Encoding.UTF8.GetString(evt.Event.Data)); }).Result; }
private async Task EnsureSubscriptionExists(string queue, IEventStoreConnection connection) { try { await connection.CreatePersistentSubscriptionAsync(queue, queue, PersistentSubscriptionSettings.Create(), null).ConfigureAwait(false); } catch (Exception ex) { if (ex.Message != string.Format("Subscription group {0} on stream {0} already exists", queue)) { throw; } } }
static async Task Main(string[] args) { var eventStoreSubscriptionConnection = EventStoreConnectionFactory.Create( new EventStoreSingleNodeConfiguration(), new ConsoleLogger(), "admin", "changeit"); var eventStoreWriteConnection = EventStoreConnectionFactory.Create( new EventStoreSingleNodeConfiguration(), new ConsoleLogger(), "admin", "changeit"); await eventStoreSubscriptionConnection.ConnectAsync(); await eventStoreWriteConnection.ConnectAsync(); _eventStore = new Bank.Persistence.EventStore.EventStore(eventStoreSubscriptionConnection, new List <IEventSchema> { new AccountSchema() }); _repository = new AccountSnapshotRepository(_eventStore); try { await eventStoreSubscriptionConnection.CreatePersistentSubscriptionAsync( "$ce-Account", "Snapshot", PersistentSubscriptionSettings .Create() .StartFromBeginning() .CheckPointAfter(TimeSpan.FromSeconds(5)) .ResolveLinkTos() .Build(), new UserCredentials("admin", "changeit")); } catch (Exception e) { Console.WriteLine($"Subscription already exist."); } await eventStoreSubscriptionConnection.ConnectToPersistentSubscriptionAsync("$ce-Account", "Snapshot", EventAppeared); await eventStoreSubscriptionConnection.ConnectToPersistentSubscriptionAsync("$ce-Account", "Snapshot", EventAppeared); await eventStoreSubscriptionConnection.ConnectToPersistentSubscriptionAsync("$ce-Account", "Snapshot", EventAppeared); await eventStoreSubscriptionConnection.ConnectToPersistentSubscriptionAsync("$ce-Account", "Snapshot", EventAppeared); await eventStoreSubscriptionConnection.ConnectToPersistentSubscriptionAsync("$ce-Account", "Snapshot", EventAppeared); Console.ReadLine(); }