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));
}
