public IndexReadEventResult(ReadEventResult result, EventRecord record, StreamMetadata metadata, int lastEventNumber) { Result = result; Record = record; Metadata = metadata; LastEventNumber = lastEventNumber; }
public IndexReadEventResult(ReadEventResult result, EventRecord record, StreamMetadata metadata, int lastEventNumber, bool originalStreamExists) { Result = result; Record = record; Metadata = metadata; LastEventNumber = lastEventNumber; OriginalStreamExists = originalStreamExists; }
public IndexReadEventResult(ReadEventResult result, StreamMetadata metadata) { if (result == ReadEventResult.Success) throw new ArgumentException(string.Format("Wrong ReadEventResult provided for failure constructor: {0}.", result), "result"); Result = result; Record = null; Metadata = metadata; }
public StreamMetadata UpdateStreamMetadata(int cacheVersion, string streamId, StreamMetadata metadata) { var res = _streamMetadataCache.Put( streamId, new KeyValuePair<int, StreamMetadata>(cacheVersion, metadata), (key, d) => d.Key == 0 ? new MetadataCached(1, d.Value) : new MetadataCached(1, null), (key, old, d) => old.Version == d.Key ? new MetadataCached(d.Key + 1, d.Value ?? old.Metadata) : old); return res.Metadata; }
/// <summary> /// Constructs a new instance of <see cref="StreamMetadataResult"/>. /// </summary> /// <param name="stream">The name of the stream.</param> /// <param name="isStreamDeleted">True if the stream is soft-deleted.</param> /// <param name="metastreamVersion">The version of the metadata format.</param> /// <param name="streamMetadata">A <see cref="StreamMetadataResult"/> containing user-specified metadata.</param> public StreamMetadataResult(string stream, bool isStreamDeleted, int metastreamVersion, StreamMetadata streamMetadata) { Ensure.NotNullOrEmpty(stream, "stream"); Stream = stream; IsStreamDeleted = isStreamDeleted; MetastreamVersion = metastreamVersion; StreamMetadata = streamMetadata; }
public IndexReadEventResult(ReadEventResult result, StreamMetadata metadata, int lastEventNumber, bool originalStreamExists) { if (result == ReadEventResult.Success) throw new ArgumentException(string.Format("Wrong ReadEventResult provided for failure constructor: {0}.", result), "result"); Result = result; Record = null; Metadata = metadata; LastEventNumber = lastEventNumber; OriginalStreamExists = originalStreamExists; }
public IndexReader(IIndexBackend backend, ITableIndex tableIndex, StreamMetadata metastreamMetadata, int hashCollisionReadLimit) { Ensure.NotNull(backend, "backend"); Ensure.NotNull(tableIndex, "tableIndex"); Ensure.NotNull(metastreamMetadata, "metastreamMetadata"); _backend = backend; _tableIndex = tableIndex; _metastreamMetadata = metastreamMetadata; _hashCollisionReadLimit = hashCollisionReadLimit; }
public IndexReader(IIndexBackend backend, IHasher hasher, ITableIndex tableIndex, StreamMetadata metastreamMetadata) { Ensure.NotNull(backend, "backend"); Ensure.NotNull(hasher, "hasher"); Ensure.NotNull(tableIndex, "tableIndex"); Ensure.NotNull(metastreamMetadata, "metastreamMetadata"); _backend = backend; _hasher = hasher; _tableIndex = tableIndex; _metastreamMetadata = metastreamMetadata; }
public IndexReader(IIndexCache cache, IHasher hasher, ITableIndex tableIndex, StreamMetadata metastreamMetadata) { Ensure.NotNull(cache, "backend"); Ensure.NotNull(hasher, "hasher"); Ensure.NotNull(tableIndex, "tableIndex"); Ensure.NotNull(metastreamMetadata, "metastreamMetadata"); _cache = cache; _hasher = hasher; _tableIndex = tableIndex; _metastreamMetadata = metastreamMetadata; }
public IndexReadStreamResult(int fromEventNumber, int maxCount, ReadStreamResult result, StreamMetadata metadata, int lastEventNumber) { if (result == ReadStreamResult.Success) throw new ArgumentException(String.Format("Wrong ReadStreamResult provided for failure constructor: {0}.", result), "result"); FromEventNumber = fromEventNumber; MaxCount = maxCount; Result = result; NextEventNumber = -1; LastEventNumber = lastEventNumber; IsEndOfStream = true; Records = EmptyRecords; Metadata = metadata; }
public IndexReadAllResult(List<CommitEventRecord> records, StreamMetadata metadata, int maxCount, TFPos currentPos, TFPos nextPos, TFPos prevPos, long tfEofPosition) { Ensure.NotNull(records, "records"); Records = records; Metadata = metadata; MaxCount = maxCount; CurrentPos = currentPos; NextPos = nextPos; PrevPos = prevPos; TfEofPosition = tfEofPosition; }
public IndexReadStreamResult(int fromEventNumber, int maxCount, EventRecord[] records, StreamMetadata metadata, int nextEventNumber, int lastEventNumber, bool isEndOfStream) { Ensure.NotNull(records, "records"); FromEventNumber = fromEventNumber; MaxCount = maxCount; Result = ReadStreamResult.Success; Records = records; Metadata = metadata; NextEventNumber = nextEventNumber; LastEventNumber = lastEventNumber; IsEndOfStream = isEndOfStream; }
public ReadIndex(IPublisher bus, ObjectPool<ITransactionFileReader> readerPool, ITableIndex tableIndex, int streamInfoCacheCapacity, bool additionalCommitChecks, int metastreamMaxCount, int hashCollisionReadLimit) { Ensure.NotNull(bus, "bus"); Ensure.NotNull(readerPool, "readerPool"); Ensure.NotNull(tableIndex, "tableIndex"); Ensure.Nonnegative(streamInfoCacheCapacity, "streamInfoCacheCapacity"); Ensure.Positive(metastreamMaxCount, "metastreamMaxCount"); var metastreamMetadata = new StreamMetadata(maxCount: metastreamMaxCount); _indexBackend = new IndexBackend(readerPool, streamInfoCacheCapacity, streamInfoCacheCapacity); _indexReader = new IndexReader(_indexBackend, tableIndex, metastreamMetadata, hashCollisionReadLimit); _indexWriter = new IndexWriter(_indexBackend, _indexReader); _indexCommitter = new IndexCommitter(bus, _indexBackend, _indexReader, tableIndex, additionalCommitChecks); _allReader = new AllReader(_indexBackend, _indexCommitter); }
public ReadIndex(IPublisher bus, ObjectPool<ITransactionFileReader> readerPool, ITableIndex tableIndex, IHasher hasher, int streamInfoCacheCapacity, bool additionalCommitChecks, int metastreamMaxCount) { Ensure.NotNull(bus, "bus"); Ensure.NotNull(readerPool, "readerPool"); Ensure.NotNull(tableIndex, "tableIndex"); Ensure.NotNull(hasher, "hasher"); Ensure.Nonnegative(streamInfoCacheCapacity, "streamInfoCacheCapacity"); Ensure.Positive(metastreamMaxCount, "metastreamMaxCount"); var metastreamMetadata = new StreamMetadata(maxCount: metastreamMaxCount); _indexCache = new IndexCache(readerPool, streamInfoCacheCapacity, streamInfoCacheCapacity); _indexReader = new IndexReader(_indexCache, hasher, tableIndex, metastreamMetadata); var writer = new IndexWriter(bus, tableIndex, hasher, _indexCache, _indexReader, additionalCommitChecks); _indexWriter = writer; _indexCommitter = writer; _allReader = new AllReader(_indexCache); }
public Rec(RecType type, int transaction, string streamId, string eventType, DateTime?timestamp, StreamMetadata metadata = null) { Ensure.NotNullOrEmpty(streamId, "streamId"); Ensure.Nonnegative(transaction, "transaction"); Type = type; Id = Guid.NewGuid(); Transaction = transaction; StreamId = streamId; EventType = eventType ?? string.Empty; TimeStamp = timestamp ?? DateTime.UtcNow; Metadata = metadata; }
public IndexReadEventResult(ReadEventResult result, EventRecord record, StreamMetadata metadata) { Result = result; Record = record; Metadata = metadata; }
public WriteResult SetStreamMetadata(string stream, int expectedMetastreamVersion, StreamMetadata metadata, UserCredentials userCredentials = null) { return SetStreamMetadataAsync(stream, expectedMetastreamVersion, metadata, userCredentials).Result; }
private async Task AppendEventToStreamAsync() { await connection.AppendToStreamAsync(stream, ExpectedVersion.NoStream, new EventData(Guid.NewGuid(), "test1", true, Encoding.UTF8.GetBytes("{'a': '1'}"), StreamMetadata.Create().AsJsonBytes())); }
public MetadataCached(int version, StreamMetadata metadata) { Version = version; Metadata = metadata; }
StreamMetadata IIndexBackend.SetStreamMetadata(string streamId, StreamMetadata metadata) { var res = _streamMetadataCache.Put(streamId, metadata, (key, meta) => new MetadataCached(1, meta), (key, old, meta) => new MetadataCached(old.Version + 1, meta)); return res.Metadata; }
public async Task TestPerformance() { for (int i = 0; i < 10; i++) { await connection.AppendToStreamAsync(stream, i - 1, new EventData(Guid.NewGuid(), "test", true, Encoding.UTF8.GetBytes("{{'a': '" + i + "'}}"), StreamMetadata.Create().AsJsonBytes())); } }
public void SetStreamMetadata(string stream, int expectedMetastreamVersion, StreamMetadata metadata, UserCredentials userCredentials = null) { SetStreamMetadataAsync(stream, expectedMetastreamVersion, metadata, userCredentials).Wait(); }
public ReadIndex(IPublisher bus, int initialReaderCount, int maxReaderCount, Func<ITransactionFileReader> readerFactory, ITableIndex tableIndex, IHasher hasher, ILRUCache<string, StreamCacheInfo> streamInfoCache, bool additionalCommitChecks, int metastreamMaxCount) { Ensure.NotNull(bus, "bus"); Ensure.Positive(initialReaderCount, "initialReaderCount"); Ensure.Positive(maxReaderCount, "maxReaderCount"); if (initialReaderCount > maxReaderCount) throw new ArgumentOutOfRangeException("initialReaderCount", "initialReaderCount is greater than maxReaderCount."); Ensure.NotNull(readerFactory, "readerFactory"); Ensure.NotNull(tableIndex, "tableIndex"); Ensure.NotNull(hasher, "hasher"); Ensure.NotNull(streamInfoCache, "streamInfoCache"); Ensure.Positive(metastreamMaxCount, "metastreamMaxCount"); _tableIndex = tableIndex; _hasher = hasher; _bus = bus; _streamInfoCache = streamInfoCache; _readers = new ObjectPool<ITransactionFileReader>("ReadIndex readers pool", initialReaderCount, maxReaderCount, readerFactory); _additionalCommitChecks = additionalCommitChecks; _metastreamMetadata = new StreamMetadata(metastreamMaxCount, null, null, null); }
public Rec(RecType type, int transaction, string streamId, string eventType, DateTime? timestamp, StreamMetadata? metadata = null) { Ensure.NotNullOrEmpty(streamId, "streamId"); Ensure.Nonnegative(transaction, "transaction"); Type = type; Id = Guid.NewGuid(); Transaction = transaction; StreamId = streamId; EventType = eventType ?? string.Empty; TimeStamp = timestamp ?? DateTime.UtcNow; Metadata = metadata; }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); _node = new MiniNode(PathName, enableTrustedAuth: true); try { _node.Start(); var userCreateEvent1 = new ManualResetEventSlim(); _node.Node.MainQueue.Publish( new UserManagementMessage.Create( new CallbackEnvelope( m => { Assert.IsTrue(m is UserManagementMessage.UpdateResult); var msg = (UserManagementMessage.UpdateResult)m; Assert.IsTrue(msg.Success); userCreateEvent1.Set(); }), SystemAccount.Principal, "user1", "Test User 1", new string[0], "pa$$1")); var userCreateEvent2 = new ManualResetEventSlim(); _node.Node.MainQueue.Publish( new UserManagementMessage.Create( new CallbackEnvelope( m => { Assert.IsTrue(m is UserManagementMessage.UpdateResult); var msg = (UserManagementMessage.UpdateResult)m; Assert.IsTrue(msg.Success); userCreateEvent2.Set(); }), SystemAccount.Principal, "user2", "Test User 2", new string[0], "pa$$2")); var adminCreateEvent2 = new ManualResetEventSlim(); _node.Node.MainQueue.Publish( new UserManagementMessage.Create( new CallbackEnvelope( m => { Assert.IsTrue(m is UserManagementMessage.UpdateResult); var msg = (UserManagementMessage.UpdateResult)m; Assert.IsTrue(msg.Success); adminCreateEvent2.Set(); }), SystemAccount.Principal, "adm", "Administrator User", new[] { SystemRoles.Admins }, "admpa$$")); Assert.IsTrue(userCreateEvent1.Wait(10000), "User 1 creation failed"); Assert.IsTrue(userCreateEvent2.Wait(10000), "User 2 creation failed"); Assert.IsTrue(adminCreateEvent2.Wait(10000), "Administrator User creation failed"); Connection = TestConnection.Create(_node.TcpEndPoint, TcpType.Normal, _userCredentials); Connection.ConnectAsync().Wait(); Connection.SetStreamMetadataAsync("noacl-stream", ExpectedVersion.NoStream, StreamMetadata.Build()) .Wait(); Connection.SetStreamMetadataAsync( "read-stream", ExpectedVersion.NoStream, StreamMetadata.Build().SetReadRole("user1")).Wait(); Connection.SetStreamMetadataAsync( "write-stream", ExpectedVersion.NoStream, StreamMetadata.Build().SetWriteRole("user1")).Wait(); Connection.SetStreamMetadataAsync( "metaread-stream", ExpectedVersion.NoStream, StreamMetadata.Build().SetMetadataReadRole("user1")).Wait(); Connection.SetStreamMetadataAsync( "metawrite-stream", ExpectedVersion.NoStream, StreamMetadata.Build().SetMetadataWriteRole("user1")).Wait(); Connection.SetStreamMetadataAsync( "$all", ExpectedVersion.Any, StreamMetadata.Build().SetReadRole("user1"), new UserCredentials("adm", "admpa$$")).Wait(); Connection.SetStreamMetadataAsync( "$system-acl", ExpectedVersion.NoStream, StreamMetadata.Build() .SetReadRole("user1") .SetWriteRole("user1") .SetMetadataReadRole("user1") .SetMetadataWriteRole("user1"), new UserCredentials("adm", "admpa$$")).Wait(); Connection.SetStreamMetadataAsync( "$system-adm", ExpectedVersion.NoStream, StreamMetadata.Build() .SetReadRole(SystemRoles.Admins) .SetWriteRole(SystemRoles.Admins) .SetMetadataReadRole(SystemRoles.Admins) .SetMetadataWriteRole(SystemRoles.Admins), new UserCredentials("adm", "admpa$$")).Wait(); Connection.SetStreamMetadataAsync( "normal-all", ExpectedVersion.NoStream, StreamMetadata.Build() .SetReadRole(SystemRoles.All) .SetWriteRole(SystemRoles.All) .SetMetadataReadRole(SystemRoles.All) .SetMetadataWriteRole(SystemRoles.All)).Wait(); Connection.SetStreamMetadataAsync( "$system-all", ExpectedVersion.NoStream, StreamMetadata.Build() .SetReadRole(SystemRoles.All) .SetWriteRole(SystemRoles.All) .SetMetadataReadRole(SystemRoles.All) .SetMetadataWriteRole(SystemRoles.All), new UserCredentials("adm", "admpa$$")).Wait(); } catch { if (_node != null) { try { _node.Shutdown(); } catch { } } throw; } }
/* * * public Task<PersistentSubscriptionDeleteResult> DeletePersistentSubscriptionForAllAsync(string groupName, UserCredentials userCredentials = null) * { * Ensure.NotNullOrEmpty(groupName, "groupName"); * var source = new TaskCompletionSource<PersistentSubscriptionDeleteResult>(TaskCreationOptions.RunContinuationsAsynchronously); * EnqueueOperation(new DeletePersistentSubscriptionOperation(_settings.Log, source, SystemStreams.AllStream, groupName, userCredentials)); * return source.Task; * } * */ public Task <WriteResult> SetStreamMetadataAsync(string stream, long expectedMetastreamVersion, StreamMetadata metadata, UserCredentials userCredentials = null) { return(SetStreamMetadataAsync(stream, expectedMetastreamVersion, metadata.AsJsonBytes(), userCredentials)); }
public Task <StreamMetadataResult> GetStreamMetadataAsync(string stream, UserCredentials userCredentials = null) { return(GetStreamMetadataAsRawBytesAsync(stream, userCredentials).ContinueWith(t => { if (t.Exception != null) { throw t.Exception.InnerException; } var res = t.Result; if (res.StreamMetadata == null || res.StreamMetadata.Length == 0) { return new StreamMetadataResult(res.Stream, res.IsStreamDeleted, res.MetastreamVersion, StreamMetadata.Create()); } var metadata = StreamMetadata.FromJsonBytes(res.StreamMetadata); return new StreamMetadataResult(res.Stream, res.IsStreamDeleted, res.MetastreamVersion, metadata); })); }
// // Metadata // internal static Task <WriteResult> SetCheckpointStreamMetadata(this EventStoreContext context, Flow flow, StreamMetadata value) => context.Connection.SetStreamMetadataAsync(flow.Context.Key.GetCheckpointStream(), ExpectedVersion.Any, value);
public void SetStreamMetadata(string stream, int expectedMetastreamVersion, StreamMetadata metadata, UserCredentials userCredentials = null) { _conn.SetStreamMetadata(stream, expectedMetastreamVersion, metadata, userCredentials); }
public async Task WriteMetadata(string stream, long?maxCount = null, long?truncateBefore = null, TimeSpan?maxAge = null, TimeSpan?cacheControl = null, bool?frozen = null, Guid?owner = null, bool force = false, IDictionary <string, string> custom = null) { var bucket = Math.Abs(stream.GetHashCode() % _clients.Count()); Logger.Write(LogLevel.Debug, () => $"Writing metadata to stream [{stream}] [ {nameof(maxCount)}: {maxCount}, {nameof(maxAge)}: {maxAge}, {nameof(cacheControl)}: {cacheControl}, {nameof(frozen)}: {frozen} ]"); var existing = await _clients[bucket].GetStreamMetadataAsync(stream).ConfigureAwait(false); try { if ((existing.StreamMetadata?.CustomKeys.Contains("frozen") ?? false) && existing.StreamMetadata?.GetValue <string>("owner") != Defaults.Instance.ToString()) { FrozenExceptions.Mark(); throw new VersionException("Stream is frozen - we are not the owner"); } if (frozen.HasValue && !force && frozen == false && ( existing.StreamMetadata == null || (existing.StreamMetadata?.CustomKeys.Contains("frozen") ?? false) == false || existing.StreamMetadata?.GetValue <string>("owner") != Defaults.Instance.ToString())) { FrozenExceptions.Mark(); throw new FrozenException(); } // If we are trying to freeze the stream that we've already frozen (to prevent multiple threads from attempting to process the same frozen data) if (frozen.HasValue && frozen == true && (existing.StreamMetadata?.CustomKeys.Contains("frozen") ?? false) && existing.StreamMetadata?.GetValue <string>("owner") == Defaults.Instance.ToString()) { FrozenExceptions.Mark(); throw new FrozenException(); } } catch (FrozenException) { var time = existing.StreamMetadata.GetValue <long>("frozen"); if ((DateTime.UtcNow.ToUnixTime() - time) > 60) { SlowLogger.Write(LogLevel.Warn, () => $"Stream [{stream}] has been frozen for {DateTime.UtcNow.ToUnixTime() - time} seconds!"); } throw; } var metadata = StreamMetadata.Build(); if ((maxCount ?? existing.StreamMetadata?.MaxCount).HasValue) { metadata.SetMaxCount((maxCount ?? existing.StreamMetadata?.MaxCount).Value); } if ((truncateBefore ?? existing.StreamMetadata?.TruncateBefore).HasValue) { metadata.SetTruncateBefore(Math.Max(truncateBefore ?? 0, (truncateBefore ?? existing.StreamMetadata?.TruncateBefore).Value)); } if ((maxAge ?? existing.StreamMetadata?.MaxAge).HasValue) { metadata.SetMaxAge((maxAge ?? existing.StreamMetadata?.MaxAge).Value); } if ((cacheControl ?? existing.StreamMetadata?.CacheControl).HasValue) { metadata.SetCacheControl((cacheControl ?? existing.StreamMetadata?.CacheControl).Value); } if (frozen.HasValue && frozen == true) { metadata.SetCustomProperty("frozen", DateTime.UtcNow.ToUnixTime()); } if (owner.HasValue) { metadata.SetCustomProperty("owner", Defaults.Instance.ToString()); } if (custom != null) { foreach (var kv in custom) { metadata.SetCustomProperty(kv.Key, kv.Value.ToString()); } } try { Logger.Write(LogLevel.Debug, () => $"Writing metadata to stream [{stream}] version {existing.MetastreamVersion} "); await _clients[bucket].SetStreamMetadataAsync(stream, existing.MetastreamVersion, metadata).ConfigureAwait(false); } catch (WrongExpectedVersionException e) { throw new VersionException(e.Message, e); } catch (CannotEstablishConnectionException e) { throw new PersistenceException(e.Message, e); } catch (OperationTimedOutException e) { throw new PersistenceException(e.Message, e); } catch (EventStoreConnectionException e) { throw new PersistenceException(e.Message, e); } }
public Task SetStreamMetadataAsync(string stream, int expectedMetastreamVersion, StreamMetadata metadata, UserCredentials userCredentials = null) { return _conn.SetStreamMetadataAsync(stream, expectedMetastreamVersion, metadata, userCredentials); }
protected override async Task DeleteMessagesToAsync(string persistenceId, long toSequenceNr) { if (toSequenceNr == long.MaxValue) { var slice = await _eventStoreConnection.ReadStreamEventsBackwardAsync(persistenceId, StreamPosition.End, 1, false); if (slice.Events.Any()) { var @event = slice.Events.First(); var highestEventPosition = @event.OriginalEventNumber; await _eventStoreConnection.SetStreamMetadataAsync(persistenceId, ExpectedVersion.Any, StreamMetadata.Create(truncateBefore: highestEventPosition + 1)); } } else { await _eventStoreConnection.SetStreamMetadataAsync(persistenceId, ExpectedVersion.Any, StreamMetadata.Create(truncateBefore: toSequenceNr)); } }
public EventStoreDomainRepository(string category, IEventStoreConnection connection, StreamMetadata metadata, int?expectedMetastreamVersion = null) { Category = category; _connection = connection; _expectedVersion = expectedMetastreamVersion ?? ExpectedVersion.Any; _metadata = metadata; }
public StreamMeta(byte[] rawMeta, StreamMetadata meta) { RawMeta = rawMeta; Meta = meta; }
private static int?GetCacheSeconds(StreamMetadata metadata) { return(metadata != null && metadata.CacheControl.HasValue ? (int)metadata.CacheControl.Value.TotalSeconds : (int?)null); }
public Task<WriteResult> SetStreamMetadataAsync(string stream, int expectedMetastreamVersion, StreamMetadata metadata, UserCredentials userCredentials = null) { return SetStreamMetadataAsync(stream, expectedMetastreamVersion, metadata.AsJsonBytes(), userCredentials); }
public static Rec Prepare(int transaction, string stream, string eventType = null, DateTime?timestamp = null, StreamMetadata metadata = null) { return(new Rec(RecType.Prepare, transaction, stream, eventType, timestamp, metadata)); }
public StreamCacheInfo(int? lastEventNumber, StreamMetadata metadata) { LastEventNumber = lastEventNumber; Metadata = metadata; }
public static Rec Prepare(int transaction, string stream, string eventType = null, DateTime?timestamp = null, StreamMetadata metadata = null, PrepareFlags prepareFlags = PrepareFlags.Data, byte version = PrepareLogRecord.PrepareRecordVersion) { return(new Rec(RecType.Prepare, transaction, stream, eventType, timestamp, version, metadata, prepareFlags)); }
public static Rec Create(int transaction, string stream, StreamMetadata? metadata = null, bool isImplicit = false, DateTime? timestamp = null) { return new Rec(RecType.Create, transaction, stream, isImplicit ? SystemEventTypes.StreamCreatedImplicit : SystemEventTypes.StreamCreated, timestamp, metadata); }
Task <WriteResult> IEventStoreConnection.SetStreamMetadataAsync(string stream, int expectedMetastreamVersion, StreamMetadata metadata, UserCredentials userCredentials) { return(_connection.SetStreamMetadataAsync(stream, expectedMetastreamVersion, metadata, userCredentials)); }