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();
}
private SizedBufferingConsumer(IConsumer <T> consumer, ISizer <T> sizer, int bufferSize)
{
GaxPreconditions.CheckArgument(
bufferSize > 0, nameof(bufferSize), "bufferSize must be greater than 0");
_consumer = GaxPreconditions.CheckNotNull(consumer, nameof(consumer));
_sizer = GaxPreconditions.CheckNotNull(sizer, nameof(sizer));
_bufferSize = bufferSize;
_size = 0;
}
public ReadIndex(IPublisher bus,
ObjectPool <ITransactionFileReader> readerPool,
ITableIndex <TStreamId> tableIndex,
INameIndexConfirmer <TStreamId> streamNameIndex,
IValueLookup <TStreamId> streamIds,
IStreamNamesProvider <TStreamId> streamNamesProvider,
TStreamId emptyStreamName,
IValidator <TStreamId> streamIdValidator,
ISizer <TStreamId> sizer,
INameExistenceFilter streamExistenceFilter,
IExistenceFilterReader <TStreamId> streamExistenceFilterReader,
INameIndexConfirmer <TStreamId> eventTypeIndex,
int streamInfoCacheCapacity,
bool additionalCommitChecks,
long metastreamMaxCount,
int hashCollisionReadLimit,
bool skipIndexScanOnReads,
IReadOnlyCheckpoint replicationCheckpoint,
ICheckpoint indexCheckpoint)
{
Ensure.NotNull(bus, "bus");
Ensure.NotNull(readerPool, "readerPool");
Ensure.NotNull(tableIndex, "tableIndex");
Ensure.NotNull(streamIds, nameof(streamIds));
Ensure.NotNull(streamNamesProvider, nameof(streamNamesProvider));
Ensure.NotNull(streamIdValidator, nameof(streamIdValidator));
Ensure.NotNull(sizer, nameof(sizer));
Ensure.NotNull(streamExistenceFilter, nameof(streamExistenceFilter));
Ensure.NotNull(streamExistenceFilterReader, nameof(streamExistenceFilterReader));
Ensure.Nonnegative(streamInfoCacheCapacity, "streamInfoCacheCapacity");
Ensure.Positive(metastreamMaxCount, "metastreamMaxCount");
Ensure.NotNull(replicationCheckpoint, "replicationCheckpoint");
Ensure.NotNull(indexCheckpoint, "indexCheckpoint");
var metastreamMetadata = new StreamMetadata(maxCount: metastreamMaxCount);
var indexBackend = new IndexBackend <TStreamId>(readerPool, streamInfoCacheCapacity, streamInfoCacheCapacity);
_indexReader = new IndexReader <TStreamId>(indexBackend, tableIndex, streamNamesProvider, streamIdValidator,
streamExistenceFilterReader, metastreamMetadata, hashCollisionReadLimit, skipIndexScanOnReads);
_streamIds = streamIds;
_streamNames = streamNamesProvider.StreamNames;
var systemStreams = streamNamesProvider.SystemStreams;
var eventTypeNames = streamNamesProvider.EventTypes;
var streamExistenceFilterInitializer = streamNamesProvider.StreamExistenceFilterInitializer;
_indexWriter = new IndexWriter <TStreamId>(indexBackend, _indexReader, _streamIds, _streamNames, systemStreams, emptyStreamName, sizer);
_indexCommitter = new IndexCommitter <TStreamId>(bus, indexBackend, _indexReader, tableIndex, streamNameIndex,
_streamNames, eventTypeIndex, eventTypeNames, systemStreams, streamExistenceFilter,
streamExistenceFilterInitializer, indexCheckpoint, additionalCommitChecks);
_allReader = new AllReader <TStreamId>(indexBackend, _indexCommitter, _streamNames, eventTypeNames);
}
public SkGraphicEngine(ISizer sizer, WordCloudInput wordCloud,
SKTypeface?font = null)
{
Sizer = sizer;
Bitmap = new SKBitmap(wordCloud.Width, wordCloud.Height);
canvas = new SKCanvas(Bitmap);
textPaint = new SKPaint
{
Color = SKColor.Parse(wordCloud.TextColor),
Typeface = font
};
this.wordCloud = wordCloud;
}
/// <summary>
/// Gets a <see cref="IConsumer{T}"/> that wraps the passed in consumer based on the buffer options.
/// </summary>
/// <param name="consumer">The consumer to buffer into.</param>
/// <param name="sizer">A sizer for the type</param>
/// <param name="options">Buffer options for the buffered consumer</param>
internal static IConsumer <T> GetConsumer(IConsumer <T> consumer, ISizer <T> sizer, BufferOptions options)
{
GaxPreconditions.CheckNotNull(consumer, nameof(consumer));
GaxPreconditions.CheckNotNull(options, nameof(options));
switch (options.BufferType)
{
case BufferType.Sized:
GaxPreconditions.CheckNotNull(sizer, nameof(sizer));
return(SizedBufferingConsumer <T> .Create(consumer, sizer, options.BufferSizeBytes));
case BufferType.Timed:
return(TimedBufferingConsumer <T> .Create(consumer, options.BufferWaitTime));
case BufferType.None:
return(consumer);
default:
throw new ArgumentException($"Invalid BufferType: {options.BufferType}");
}
}
/// <summary>
/// Creates a new <see cref="SizedBufferingConsumer{T}"/> that will flush to the
/// given <see cref="IConsumer{T}"/>.
/// </summary>
/// <param name="consumer">The consumer to flush to, cannot be null.</param>
/// <param name="bufferSize">The buffer size in bytes.</param>
/// <param name="sizer">The sizer for the given type. Cannot be null.</param>
public static SizedBufferingConsumer <T> Create(IConsumer <T> consumer, ISizer <T> sizer, int bufferSize)
=> new SizedBufferingConsumer <T>(consumer, sizer, bufferSize);
