public void setting_metadata_for_deleted_stream_throws_stream_deleted_exception() { _connection.DeleteStreamAsync(_stream, ExpectedVersion.NoStream, hardDelete: true).Wait(); var metadataBytes = Guid.NewGuid().ToByteArray(); Assert.That(() => _connection.SetStreamMetadataAsync(_stream, ExpectedVersion.EmptyStream, metadataBytes).Wait(), Throws.Exception.InstanceOf <AggregateException>() .With.InnerException.InstanceOf <StreamDeletedException>()); }
public async Task setting_metadata_for_deleted_stream_throws_stream_deleted_exception() { const string stream = "setting_metadata_for_deleted_stream_throws_stream_deleted_exception"; await _connection.DeleteStreamAsync(stream, ExpectedVersion.NoStream, hardDelete : true); var metadataBytes = Guid.NewGuid().ToByteArray(); await AssertEx.ThrowsAsync <StreamDeletedException>( () => _connection.SetStreamMetadataAsync(stream, ExpectedVersion.NoStream, metadataBytes)); }
public async Task soft_deleted_stream_returns_no_stream_and_no_events_on_read() { const string stream = "soft_deleted_stream_returns_no_stream_and_no_events_on_read"; Assert.AreEqual(1, (await _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent())).NextExpectedVersion); await _conn.DeleteStreamAsync(stream, 1); var res = await _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false); Assert.AreEqual(SliceReadStatus.StreamNotFound, res.Status); Assert.AreEqual(0, res.Events.Length); Assert.AreEqual(1, res.LastEventNumber); }
public async Task SoftDelete(TId selector) { var id = selector.ToString(); var expectedVersion = await GetLastEventNumber(id); await connection.DeleteStreamAsync(id, expectedVersion); }
public static async Task DeleteStreamsByCategory(IEventStoreConnection conn, string category, bool hardDelete = false) { IEnumerable <string> streamIds = await GetStreamIdsByCategoryBy(conn, category); if (!streamIds.Any()) { Console.WriteLine("INFO: No stream was found. Exitting."); return; } Console.WriteLine($"[{streamIds.Count()}] streams for category [{category}] will be deleted. Are you sure? (press any key to confirm or ctrl-c to exit)"); Console.ReadLine(); foreach (var id in streamIds) { try { await conn.DeleteStreamAsync(id, ExpectedVersion.Any, hardDelete); Console.WriteLine($"DEBUG: [{id}]"); } catch (StreamDeletedException e) { Console.WriteLine($"INFO: Stream [{e.Stream} is already deleted. Skipped]"); } } Console.WriteLine("INFO: Success"); }
async Task SagaConsumeContext <TSaga> .SetCompleted() { await _connection.DeleteStreamAsync(Saga.StreamName, Saga.ExpectedVersion, false); IsCompleted = true; this.LogRemoved(); }
public async Task Delete(TId selector) { var id = selector.ToString(); var eventsTail = await connection.ReadStreamEventsBackwardAsync(id, 0, 1, false); var expectedVersion = eventsTail.LastEventNumber; await connection.DeleteStreamAsync(id, expectedVersion); }
public Task Delete(T aggregate) { var streamName = AggregateIdToStreamName(typeof(T), aggregate.Id); var newEvents = aggregate.GetUncommittedChanges().Cast <object>().ToList(); var originalVersion = aggregate.Version - newEvents.Count; var expectedVersion = originalVersion < 0 ? ExpectedVersion.NoStream : originalVersion; return(_eventStoreConnection.DeleteStreamAsync(streamName, expectedVersion)); }
public async Task DeleteAggregateAsync <TIdentity, TAggregate>( TIdentity id, AggregateConfiguration <TIdentity, TAggregate> configuration, long expectedVersion, CancellationToken cancellationToken = default ) where TAggregate : Aggregate <TIdentity, TAggregate> { var stream = _streamNameResolver.Stream(id, configuration); await _connection.DeleteStreamAsync(stream, expectedVersion); }
public void ThrowsOnGetDeletedAggregate() { var aggregateId = SaveTestAggregateWithoutCustomHeaders(_repo, 10); var streamName = $"testWoftamAggregate-{aggregateId.ToString("N")}"; _connection.DeleteStreamAsync(streamName, 10).Wait(); // Assert.Throws<AggregateDeletedException>(() => _repo.GetById<TestAggregate>(aggregateId)); //Looks like an api change Assert.Throws <AggregateNotFoundException>(() => _repo.GetById <TestWoftamAggregate>(aggregateId)); }
async Task SagaConsumeContext <TSaga> .SetCompleted() { await _connection.DeleteStreamAsync(Saga.StreamName, Saga.ExpectedVersion, false); IsCompleted = true; if (Log.IsDebugEnabled) { Log.DebugFormat("SAGA:{0}:{1} Removed {2}", TypeMetadataCache <TSaga> .ShortName, TypeMetadataCache <TMessage> .ShortName, Saga.CorrelationId); } }
public void getting_metadata_for_deleted_stream_returns_empty_stream_metadata_and_signals_stream_deletion() { var metadata = StreamMetadata.Create(17, TimeSpan.FromSeconds(0xDEADBEEF), 10, TimeSpan.FromSeconds(0xABACABA)); _connection.SetStreamMetadataAsync(_stream, ExpectedVersion.EmptyStream, metadata).Wait(); _connection.DeleteStreamAsync(_stream, ExpectedVersion.EmptyStream, hardDelete: true).Wait(); var meta = _connection.GetStreamMetadataAsync(_stream).Result; Assert.AreEqual(_stream, meta.Stream); Assert.AreEqual(true, meta.IsStreamDeleted); Assert.AreEqual(EventNumber.DeletedStream, meta.MetastreamVersion); Assert.AreEqual(null, meta.StreamMetadata.MaxCount); Assert.AreEqual(null, meta.StreamMetadata.MaxAge); Assert.AreEqual(null, meta.StreamMetadata.TruncateBefore); Assert.AreEqual(null, meta.StreamMetadata.CacheControl); Assert.AreEqual(null, meta.StreamMetadata.Acl); }
public async Task getting_metadata_for_deleted_stream_returns_empty_stream_metadata_and_signals_stream_deletion() { const string stream = "getting_metadata_for_deleted_stream_returns_empty_stream_metadata_and_signals_stream_deletion"; var metadata = StreamMetadata.Create(17, TimeSpan.FromSeconds(0xDEADBEEF), 10, TimeSpan.FromSeconds(0xABACABA)); await _connection.SetStreamMetadataAsync(stream, ExpectedVersion.NoStream, metadata); await _connection.DeleteStreamAsync(stream, ExpectedVersion.NoStream, hardDelete : true); var meta = await _connection.GetStreamMetadataAsync(stream); Assert.AreEqual(stream, meta.Stream); Assert.AreEqual(true, meta.IsStreamDeleted); Assert.AreEqual(EventNumber.DeletedStream, meta.MetastreamVersion); Assert.AreEqual(null, meta.StreamMetadata.MaxCount); Assert.AreEqual(null, meta.StreamMetadata.MaxAge); Assert.AreEqual(null, meta.StreamMetadata.TruncateBefore); Assert.AreEqual(null, meta.StreamMetadata.CacheControl); Assert.AreEqual(null, meta.StreamMetadata.Acl); }
public static void DeleteAllStreams(this IEventStoreConnection connection) { var slice = connection. ReadAllEventsForwardAsync( Position.Start, Int32.MaxValue, false, EmbeddedEventStore.Credentials); slice.Wait(); var streams = slice.Result. Events. Select(_ => _.OriginalStreamId). Where(StreamNameIsNotReserved). Distinct(); foreach (var stream in streams) { var streamStatusSlice = connection.ReadStreamEventsForwardAsync(stream, 0, 1, false); streamStatusSlice.Wait(); if (streamStatusSlice.Result.Status != SliceReadStatus.StreamDeleted && streamStatusSlice.Result.Status != SliceReadStatus.StreamNotFound) { connection.DeleteStreamAsync(stream, ExpectedVersion.Any, EmbeddedEventStore.Credentials).Wait(); } } }
public void Dispose() { connection.DeleteStreamAsync(stream, ExpectedVersion.Any).Wait(); connection.Dispose(); }
public Task DeleteEventsAsync(IIdentity id, CancellationToken cancellationToken) { return(_connection.DeleteStreamAsync(id.Value, ExpectedVersion.Any)); }
public Task DeleteStreamAsync(string streamName) { return(connection.DeleteStreamAsync(streamName, ExpectedVersion.Any)); }
public Task <DeleteResult> Delete(string streamId, int expectedVersion) { return(_eventStoreConnection.DeleteStreamAsync(streamId, expectedVersion)); }
public Task DeleteStreamAsync(string streamName) { Guard.NotNullOrEmpty(streamName, nameof(streamName)); return(connection.DeleteStreamAsync(GetStreamName(streamName), ExpectedVersion.Any)); }
protected void DeleteStream(string streamId, string login, string password) { Connection.DeleteStreamAsync(streamId, ExpectedVersion.Any, true, login == null && password == null ? null : new UserCredentials(login, password)).Wait(); }
public override void DeleteAggregate <TAggregate>(string correlationId, bool hard) { var streamName = AggregateToStreamName(typeof(TAggregate), correlationId); _connection.DeleteStreamAsync(streamName, ExpectedVersion.Any, hard).Wait(); }
public async Task DeleteStreamAsync(string streamName, int expectedVersion, bool hardDelete = false) { await connection.DeleteStreamAsync(streamName, expectedVersion, hardDelete).ConfigureAwait(false); }
public override Task DeleteAggregateAsync <TAggregate, TIdentity>( TIdentity id, CancellationToken cancellationToken) { return(_connection.DeleteStreamAsync(id.Value, ExpectedVersion.Any)); }
public async Task InitializeAsync() { _eventStoreContainer = "es" + Guid.NewGuid().ToString("N"); var address = Environment.OSVersion.Platform == PlatformID.Unix ? new Uri("unix:///var/run/docker.sock") : new Uri("npipe://./pipe/docker_engine"); var config = new DockerClientConfiguration(address); _client = config.CreateClient(); var images = await _client.Images.ListImagesAsync(new ImagesListParameters { MatchName = EventStoreImage }); if (images.Count == 0) { Console.WriteLine("[docker] no image found - pulling latest"); await _client.Images.CreateImageAsync( new ImagesCreateParameters { FromImage = EventStoreImage, Tag = "latest" }, null, IgnoreProgress.Forever); } Console.WriteLine("[docker] creating container " + _eventStoreContainer); var port = 1113; await _client.Containers.CreateContainerAsync( new CreateContainerParameters { Image = EventStoreImage, Name = _eventStoreContainer, Tty = true, HostConfig = new HostConfig { PortBindings = new Dictionary <string, IList <PortBinding> > { { "1113/tcp", new List <PortBinding> { new PortBinding { HostPort = $"{port}" } } } } } }); Console.WriteLine("[docker] starting container " + _eventStoreContainer); await _client.Containers.StartContainerAsync(_eventStoreContainer, new ContainerStartParameters { }); var endpoint = new Uri($"tcp://127.0.0.1:{port}"); var settings = ConnectionSettings .Create() .KeepReconnecting() .KeepRetrying() .SetDefaultUserCredentials(new UserCredentials("admin", "changeit")); var connectionName = $"M={Environment.MachineName},P={Process.GetCurrentProcess().Id},T={DateTimeOffset.UtcNow.Ticks}"; EventStoreConnection = EventStore.ClientAPI.EventStoreConnection.Create(settings, endpoint, connectionName); Console.WriteLine("[docker] connecting to EventStore"); await EventStoreConnection.ConnectAsync(); // Fix for EventStore throwing NotAuthenticatedException // because of not being ready but accepting connections var connected = false; while (!connected) { try { await EventStoreConnection.DeleteStreamAsync("stream", -1); connected = true; } catch (NotAuthenticatedException ex) { Console.WriteLine(ex); } } }
/// <inheritdoc /> protected override async Task TruncateStreamStore(IStream stream, int version) { await _connection.DeleteStreamAsync(stream.Key, version); }
protected Task DeleteStream(string streamId, string login, string password) { return(Connection.DeleteStreamAsync(streamId, ExpectedVersion.Any, true, login == null && password == null ? null : new UserCredentials(login, password))); }
protected Task HardDeleteStream(string stream) { return(_conn.DeleteStreamAsync(stream, ExpectedVersion.Any, true, _admin)); }
protected void HardDeleteStream(string stream) { _conn.DeleteStreamAsync(stream, ExpectedVersion.Any, true, _admin).Wait(); }
public Task DeleteEventsAsync <TAggregate, TIdentity>(IIdentity id, CancellationToken cancellationToken) where TAggregate : IAggregateRoot <TIdentity> where TIdentity : IIdentity { return(_connection.DeleteStreamAsync(_eventStoreStreamNameFactory.GetStreamName(typeof(TAggregate), id), ExpectedVersion.Any)); }