public override async Task TestFixtureSetUp()
{
await base.TestFixtureSetUp();
_logFormat = LogFormatHelper <TLogFormat, TStreamId> .LogFormatFactory.Create(new() {
IndexDirectory = GetFilePathFor("index"),
});
_provider = _logFormat.StreamNamesProvider;
_publisher = new InMemoryBus("publisher");
_tfReader = new FakeInMemoryTfReader(RecordOffset);
_tableIndex = new FakeInMemoryTableIndex <TStreamId>();
_provider.SetTableIndex(_tableIndex);
_readerPool = new ObjectPool <ITransactionFileReader>(
"ReadIndex readers pool", 5, 100,
() => _tfReader);
_indexBackend = new IndexBackend <TStreamId>(_readerPool, 100000, 100000);
_streamIds = _logFormat.StreamIds;
_validator = _logFormat.StreamIdValidator;
var emptyStreamId = _logFormat.EmptyStreamId;
_sizer = _logFormat.StreamIdSizer;
_indexReader = new IndexReader <TStreamId>(_indexBackend, _tableIndex, _provider, _validator,
_logFormat.StreamExistenceFilterReader, new StreamMetadata(maxCount: 100000), 100, false);
_streamNames = _logFormat.StreamNames;
_systemStreams = _logFormat.SystemStreams;
_indexWriter = new IndexWriter <TStreamId>(_indexBackend, _indexReader, _streamIds, _streamNames,
_systemStreams, emptyStreamId, _sizer);
_indexCommitter = new IndexCommitter <TStreamId>(_publisher, _indexBackend, _indexReader, _tableIndex,
_logFormat.StreamNameIndexConfirmer, _streamNames, _logFormat.EventTypeIndexConfirmer, _logFormat.EventTypes,
_systemStreams, _logFormat.StreamExistenceFilter, _logFormat.StreamExistenceFilterInitializer, new InMemoryCheckpoint(-1), false);
WriteEvents();
}
public virtual void TestFixtureSetUp()
{
_logFormat = LogFormatHelper <TLogFormat, TStreamId> .LogFormat;
_publisher = new InMemoryBus("publisher");
_tfReader = new FakeInMemoryTfReader(RecordOffset);
_tableIndex = new FakeInMemoryTableIndex <TStreamId>();
_readerPool = new ObjectPool <ITransactionFileReader>(
"ReadIndex readers pool", 5, 100,
() => _tfReader);
_indexBackend = new IndexBackend <TStreamId>(_readerPool, 100000, 100000);
var logFormat = LogFormatHelper <TLogFormat, TStreamId> .LogFormat;
_streamIds = logFormat.StreamIds;
_streamNames = logFormat.StreamNames;
_systemStreams = logFormat.SystemStreams;
_factory = logFormat.StreamNamesProvider;
_validator = logFormat.StreamIdValidator;
var emptyStreamId = logFormat.EmptyStreamId;
_sizer = logFormat.StreamIdSizer;
_indexReader = new IndexReader <TStreamId>(_indexBackend, _tableIndex, _factory, _validator, new StreamMetadata(maxCount: 100000), 100, false);
_indexWriter = new IndexWriter <TStreamId>(_indexBackend, _indexReader, _streamIds, _streamNames, _systemStreams, emptyStreamId, _sizer);
_indexCommitter = new Core.Services.Storage.ReaderIndex.IndexCommitter <TStreamId>(_publisher, _indexBackend, _indexReader, _tableIndex, _streamNames, _systemStreams, new InMemoryCheckpoint(-1), false);
WriteEvents();
}
public AllReader(IIndexBackend backend, IIndexCommitter indexCommitter)
{
Ensure.NotNull(backend, "backend");
Ensure.NotNull(indexCommitter, "indexCommitter");
_backend = backend;
_indexCommitter = indexCommitter;
}
public AllReader(IIndexBackend backend, IIndexCommitter indexCommitter)
{
Ensure.NotNull(backend, "backend");
Ensure.NotNull(indexCommitter, "indexCommitter");
_backend = backend;
_indexCommitter = indexCommitter;
}
public void Setup()
{
given();
_indexDir = PathName;
_fakeReader = new TFReaderLease(new FakeReader());
_indexBackend = new FakeIndexBackend <string>(_fakeReader);
_logFormat = LogFormatHelper <LogFormat.V2, string> .LogFormatFactory.Create(new() {
InMemory = true,
});
_lowHasher = _logFormat.LowHasher;
_highHasher = _logFormat.HighHasher;
_tableIndex = new TableIndex <string>(_indexDir, _lowHasher, _highHasher, _logFormat.EmptyStreamId,
() => new HashListMemTable(PTableVersions.IndexV1, maxSize: _maxMemTableSize),
() => _fakeReader,
PTableVersions.IndexV1,
5, Constants.PTableMaxReaderCountDefault,
maxSizeForMemory: _maxMemTableSize,
maxTablesPerLevel: 2);
_logFormat.StreamNamesProvider.SetTableIndex(_tableIndex);
_tableIndex.Initialize(long.MaxValue);
_indexReader = new IndexReader <string>(_indexBackend, _tableIndex,
_logFormat.StreamNamesProvider,
_logFormat.StreamIdValidator,
_logFormat.StreamExistenceFilterReader,
new EventStore.Core.Data.StreamMetadata(),
_hashCollisionReadLimit, skipIndexScanOnRead: false);
when();
//wait for the mem table to be dumped
System.Threading.Thread.Sleep(500);
}
public ReadIndex(IPublisher bus,
ObjectPool <ITransactionFileReader> readerPool,
ITableIndex tableIndex,
int streamInfoCacheCapacity,
bool additionalCommitChecks,
long metastreamMaxCount,
int hashCollisionReadLimit,
bool skipIndexScanOnReads,
ICheckpoint replicationCheckpoint)
{
Ensure.NotNull(bus, "bus");
Ensure.NotNull(readerPool, "readerPool");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.Nonnegative(streamInfoCacheCapacity, "streamInfoCacheCapacity");
Ensure.Positive(metastreamMaxCount, "metastreamMaxCount");
Ensure.NotNull(replicationCheckpoint, "replicationCheckpoint");
var metastreamMetadata = new StreamMetadata(maxCount: metastreamMaxCount);
_indexBackend = new IndexBackend(readerPool, streamInfoCacheCapacity, streamInfoCacheCapacity);
_indexReader = new IndexReader(_indexBackend, tableIndex, metastreamMetadata, hashCollisionReadLimit, skipIndexScanOnReads);
_indexWriter = new IndexWriter(_indexBackend, _indexReader);
_indexCommitter = new IndexCommitter(bus, _indexBackend, _indexReader, tableIndex, additionalCommitChecks);
_allReader = new AllReader(_indexBackend, _indexCommitter, replicationCheckpoint);
_replicationCheckpoint = replicationCheckpoint;
}
public IndexWriter(IIndexBackend indexBackend, IIndexReader indexReader)
{
Ensure.NotNull(indexBackend, "indexBackend");
Ensure.NotNull(indexReader, "indexReader");
_indexBackend = indexBackend;
_indexReader = indexReader;
}
public IndexWriter(IIndexBackend indexBackend, IIndexReader indexReader)
{
Ensure.NotNull(indexBackend, "indexBackend");
Ensure.NotNull(indexReader, "indexReader");
_indexBackend = indexBackend;
_indexReader = indexReader;
}
public AllReader(IIndexBackend backend, IIndexCommitter indexCommitter, INameLookup <TStreamId> streamNames)
{
Ensure.NotNull(backend, "backend");
Ensure.NotNull(indexCommitter, "indexCommitter");
Ensure.NotNull(indexCommitter, nameof(streamNames));
_backend = backend;
_indexCommitter = indexCommitter;
_streamNames = streamNames;
}
public IndexCommitter(IPublisher bus, IIndexBackend backend, IIndexReader indexReader,
ITableIndex tableIndex, bool additionalCommitChecks)
{
_bus = bus;
_backend = backend;
_indexReader = indexReader;
_tableIndex = tableIndex;
_additionalCommitChecks = additionalCommitChecks;
}
public IndexCommitter(IPublisher bus, IIndexBackend backend, IIndexReader indexReader,
ITableIndex tableIndex, bool additionalCommitChecks)
{
_bus = bus;
_backend = backend;
_indexReader = indexReader;
_tableIndex = tableIndex;
_additionalCommitChecks = additionalCommitChecks;
}
public AllReader(IIndexBackend backend, IIndexCommitter indexCommitter, ICheckpoint replicationCheckpoint)
{
Ensure.NotNull(backend, "backend");
Ensure.NotNull(indexCommitter, "indexCommitter");
Ensure.NotNull(replicationCheckpoint, "replicationCheckpoint");
_backend = backend;
_indexCommitter = indexCommitter;
_replicationCheckpoint = replicationCheckpoint;
}
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, 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(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 virtual void TestFixtureSetUp()
{
_publisher = new InMemoryBus("publisher");
_tfReader = new FakeInMemoryTfReader(RecordOffset);
_tableIndex = new FakeInMemoryTableIndex();
_readerPool = new ObjectPool <ITransactionFileReader>(
"ReadIndex readers pool", 5, 100,
() => _tfReader);
_indexBackend = new IndexBackend(_readerPool, 100000, 100000);
_indexReader = new IndexReader(_indexBackend, _tableIndex, new StreamMetadata(maxCount: 100000), 100, false);
_indexWriter = new IndexWriter(_indexBackend, _indexReader);
_indexCommitter = new IndexCommitter(_publisher, _indexBackend, _indexReader, _tableIndex, false);
WriteEvents();
}
// must use the commit to see if these are the first events in the stream
// and for checkpointing.
public void Confirm(
IList <IPrepareLogRecord <string> > prepares,
CommitLogRecord commit,
bool catchingUp,
IIndexBackend <string> backend)
{
if (catchingUp)
{
// after the main index is caught up we will initialize the stream existence filter
return;
}
if (prepares.Count != 0 && commit.FirstEventNumber == 0)
{
var lastPrepare = prepares[prepares.Count - 1];
_existenceFilter.Add(lastPrepare.EventStreamId);
}
_existenceFilter.CurrentCheckpoint = commit.LogPosition;
}
public void Setup(){
given();
_indexDir = PathName;
_fakeReader = new TFReaderLease(new FakeReader());
_indexBackend = new FakeIndexBackend(_fakeReader);
_lowHasher = new XXHashUnsafe();
_highHasher = new Murmur3AUnsafe();
_tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
() => new HashListMemTable(PTableVersions.Index32Bit, maxSize: _maxMemTableSize),
() => _fakeReader,
PTableVersions.Index32Bit,
maxSizeForMemory: _maxMemTableSize,
maxTablesPerLevel: 2);
_tableIndex.Initialize(long.MaxValue);
_indexReader = new IndexReader(_indexBackend, _tableIndex, new EventStore.Core.Data.StreamMetadata(), _hashCollisionReadLimit);
when();
//wait for the mem table to be dumped
System.Threading.Thread.Sleep(500);
}
public void Setup()
{
given();
_indexDir = PathName;
_fakeReader = new TFReaderLease(new FakeReader());
_indexBackend = new FakeIndexBackend(_fakeReader);
_lowHasher = new XXHashUnsafe();
_highHasher = new Murmur3AUnsafe();
_tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
() => new HashListMemTable(PTableVersions.IndexV1, maxSize: _maxMemTableSize),
() => _fakeReader,
PTableVersions.IndexV1,
maxSizeForMemory: _maxMemTableSize,
maxTablesPerLevel: 2);
_tableIndex.Initialize(long.MaxValue);
_indexReader = new IndexReader(_indexBackend, _tableIndex, new EventStore.Core.Data.StreamMetadata(), _hashCollisionReadLimit);
when();
//wait for the mem table to be dumped
System.Threading.Thread.Sleep(500);
}
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);
_indexBackend = new IndexBackend(readerPool, streamInfoCacheCapacity, streamInfoCacheCapacity);
_indexReader = new IndexReader(_indexBackend, hasher, tableIndex, metastreamMetadata);
_indexWriter = new IndexWriter(_indexBackend, _indexReader);
_indexCommitter = new IndexCommitter(bus, _indexBackend, _indexReader, tableIndex, hasher, additionalCommitChecks);
_allReader = new AllReader(_indexBackend, _indexCommitter);
}
public void Confirm(IList <IPrepareLogRecord <string> > prepares, bool catchingUp, IIndexBackend <string> backend)
{
if (catchingUp)
{
// after the main index is caught up we will initialize the stream existence filter
return;
}
if (prepares.Count == 0)
{
return;
}
var lastPrepare = prepares[prepares.Count - 1];
if (prepares[0].ExpectedVersion == ExpectedVersion.NoStream)
{
_existenceFilter.Add(lastPrepare.EventStreamId);
}
_existenceFilter.CurrentCheckpoint = lastPrepare.LogPosition;
}
public AllReader(IIndexBackend backend)
{
Ensure.NotNull(backend, "backend");
_backend = backend;
}
public AllReader(IIndexBackend backend)
{
Ensure.NotNull(backend, "backend");
_backend = backend;
}
public void Confirm(
IList<IPrepareLogRecord<string>> prepares,
CommitLogRecord commit,
bool catchingUp,
IIndexBackend<string> backend) {
}
