public override async Task TestFixtureSetUp()
        {
            await base.TestFixtureSetUp();

            _indexDir = PathName;

            var fakeReader  = new TFReaderLease(new FakeIndexReader());
            int readerCount = 0;

            _lowHasher  = new XXHashUnsafe();
            _highHasher = new Murmur3AUnsafe();
            _tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
                                         () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                         () => {
                readerCount++;
                if (readerCount < 4)                         // One for each table add.
                {
                    return(fakeReader);
                }

                throw new Exception("Expected exception");
            },
                                         PTableVersions.IndexV4,
                                         5, Constants.PTableMaxReaderCountDefault,
                                         maxSizeForMemory: 2,
                                         maxTablesPerLevel: 5);
            _tableIndex.Initialize(long.MaxValue);

            _tableIndex.Add(1, "testStream-1", 0, 0);
            _tableIndex.Add(1, "testStream-1", 1, 100);
            _tableIndex.Add(1, "testStream-1", 2, 200);
            _tableIndex.Add(1, "testStream-1", 3, 300);
            _tableIndex.Add(1, "testStream-1", 4, 400);
            _tableIndex.Add(1, "testStream-1", 5, 500);

            _log = new FakeTFScavengerLog();
            Assert.That(() => _tableIndex.Scavenge(_log, CancellationToken.None),
                        Throws.Exception.With.Message.EqualTo("Expected exception"));

            // Check it's loadable still.
            _tableIndex.Close(false);

            _tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
                                         () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                         () => fakeReader,
                                         PTableVersions.IndexV4,
                                         5, Constants.PTableMaxReaderCountDefault,
                                         maxSizeForMemory: 2,
                                         maxTablesPerLevel: 5);

            _tableIndex.Initialize(long.MaxValue);
        }
Exemple #2
0
        public override async Task TestFixtureSetUp()
        {
            await base.TestFixtureSetUp();

            _indexDir = PathName;

            var cancellationTokenSource = new CancellationTokenSource();

            var fakeReader = new TFReaderLease(new FakeIndexReader(l => {
                cancellationTokenSource.Cancel();
                return(true);
            }));

            _lowHasher  = new XXHashUnsafe();
            _highHasher = new Murmur3AUnsafe();
            _tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
                                         () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                         () => fakeReader,
                                         PTableVersions.IndexV4,
                                         5, Constants.PTableMaxReaderCountDefault,
                                         maxSizeForMemory: 2,
                                         maxTablesPerLevel: 5);
            _tableIndex.Initialize(long.MaxValue);

            _tableIndex.Add(1, "testStream-1", 0, 0);
            _tableIndex.Add(1, "testStream-1", 1, 100);
            _tableIndex.Add(1, "testStream-1", 2, 200);
            _tableIndex.Add(1, "testStream-1", 3, 300);
            _tableIndex.Add(1, "testStream-1", 4, 400);
            _tableIndex.Add(1, "testStream-1", 5, 500);

            _log = new FakeTFScavengerLog();


            Assert.That(() => _tableIndex.Scavenge(_log, cancellationTokenSource.Token),
                        Throws.InstanceOf <OperationCanceledException>());

            // Check it's loadable still.
            _tableIndex.Close(false);

            _tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
                                         () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                         () => fakeReader,
                                         PTableVersions.IndexV4,
                                         5, Constants.PTableMaxReaderCountDefault,
                                         maxSizeForMemory: 2,
                                         maxTablesPerLevel: 5);

            _tableIndex.Initialize(long.MaxValue);
        }
        public override async Task TestFixtureSetUp()
        {
            await base.TestFixtureSetUp();

            _indexDir = PathName;

            var fakeReader = new TFReaderLease(new FakeIndexReader());

            _lowHasher  = new XXHashUnsafe();
            _highHasher = new Murmur3AUnsafe();
            _tableIndex = new TableIndex <string>(_indexDir, _lowHasher, _highHasher, "",
                                                  () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                                  () => throw new Exception("Expected exception") /* throw an exception when the first PTable scavenge starts and tries to acquire a reader */,
                                                  PTableVersions.IndexV4,
                                                  5, Constants.PTableMaxReaderCountDefault,
                                                  maxSizeForMemory: 2,
                                                  maxTablesPerLevel: 5,
                                                  useBloomFilter: _useBloomFilter);
            _tableIndex.Initialize(long.MaxValue);

            _tableIndex.Add(1, "testStream-1", 0, 0);
            _tableIndex.Add(1, "testStream-1", 1, 100);
            _tableIndex.Add(1, "testStream-1", 2, 200);
            _tableIndex.Add(1, "testStream-1", 3, 300);
            _tableIndex.Add(1, "testStream-1", 4, 400);
            _tableIndex.Add(1, "testStream-1", 5, 500);

            _log = new FakeTFScavengerLog();
            Assert.That(() => _tableIndex.Scavenge(_log, CancellationToken.None),
                        Throws.Exception.With.Message.EqualTo("Expected exception"));

            // Check it's loadable still.
            _tableIndex.Close(false);

            _tableIndex = new TableIndex <string>(_indexDir, _lowHasher, _highHasher, "",
                                                  () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                                  () => fakeReader,
                                                  PTableVersions.IndexV4,
                                                  5, Constants.PTableMaxReaderCountDefault,
                                                  maxSizeForMemory: 2,
                                                  maxTablesPerLevel: 5,
                                                  useBloomFilter: _useBloomFilter);

            _tableIndex.Initialize(long.MaxValue);
        }
        public override async Task TestFixtureSetUp()
        {
            await base.TestFixtureSetUp();

            _indexDir = PathName;

            var fakeReader = new TFReaderLease(new FakeIndexReader(l => !Deleted.Contains(l)));

            _lowHasher  = new XXHashUnsafe();
            _highHasher = new Murmur3AUnsafe();
            _tableIndex = new TableIndex <string>(_indexDir, _lowHasher, _highHasher, "",
                                                  () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                                  () => fakeReader,
                                                  PTableVersions.IndexV4,
                                                  5, Constants.PTableMaxReaderCountDefault,
                                                  maxSizeForMemory: 2,
                                                  maxTablesPerLevel: 5, skipIndexVerify: _skipIndexVerify,
                                                  useBloomFilter: _useBloomFilter);
            _tableIndex.Initialize(long.MaxValue);


            _tableIndex.Add(1, "testStream-1", 0, 0);
            _tableIndex.Add(1, "testStream-1", 1, 100);
            _tableIndex.Add(1, "testStream-1", 2, 200);
            _tableIndex.Add(1, "testStream-1", 3, 300);
            _tableIndex.Add(1, "testStream-1", 4, 400);
            _tableIndex.Add(1, "testStream-1", 5, 500);

            _log = new FakeTFScavengerLog();
            _tableIndex.Scavenge(_log, CancellationToken.None);

            // Check it's loadable.
            _tableIndex.Close(false);

            _tableIndex = new TableIndex <string>(_indexDir, _lowHasher, _highHasher, "",
                                                  () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                                  () => fakeReader,
                                                  PTableVersions.IndexV4,
                                                  5, Constants.PTableMaxReaderCountDefault,
                                                  maxSizeForMemory: 2,
                                                  maxTablesPerLevel: 5,
                                                  useBloomFilter: _useBloomFilter);

            _tableIndex.Initialize(long.MaxValue);
        }
Exemple #5
0
        public override void TestFixtureSetUp()
        {
            base.TestFixtureSetUp();

            _indexDir = PathName;

            var scavengeBlocker = new ManualResetEventSlim(false);
            var scavengeStarted = new ManualResetEventSlim(false);

            var fakeReader = new TFReaderLease(new FakeIndexReader(l =>
            {
                scavengeStarted.Set();
                if (!scavengeBlocker.Wait(5000))
                {
                    throw new Exception("Failed to continue.");
                }
                return(false);
            }));

            _lowHasher  = new XXHashUnsafe();
            _highHasher = new Murmur3AUnsafe();
            _tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
                                         () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                         () => fakeReader,
                                         PTableVersions.IndexV4,
                                         maxSizeForMemory: 2,
                                         maxTablesPerLevel: 5);
            _tableIndex.Initialize(long.MaxValue);


            _tableIndex.Add(1, "testStream-1", 0, 0);
            _tableIndex.Add(1, "testStream-1", 1, 100);
            _tableIndex.WaitForBackgroundTasks();

            _log = new FakeTFScavengerLog();
            var task = Task.Run(() => _tableIndex.Scavenge(_log, CancellationToken.None));

            Assert.That(scavengeStarted.Wait(5000));

            // Add enough for 2 more tables
            _tableIndex.Add(1, "testStream-1", 2, 200);
            _tableIndex.Add(1, "testStream-1", 3, 300);
            _tableIndex.Add(1, "testStream-1", 4, 400);
            _tableIndex.Add(1, "testStream-1", 5, 500);

            // Release the scavenge process
            scavengeBlocker.Set();
            task.Wait();

            // Check it's loadable.
            _tableIndex.Close(false);

            _tableIndex = new TableIndex(_indexDir, _lowHasher, _highHasher,
                                         () => new HashListMemTable(PTableVersions.IndexV4, maxSize: 5),
                                         () => fakeReader,
                                         PTableVersions.IndexV4,
                                         maxSizeForMemory: 2,
                                         maxTablesPerLevel: 5);

            _tableIndex.Initialize(long.MaxValue);
        }