From 25d67db067fecc8551d65cbc7fd12fdb3819fa8c Mon Sep 17 00:00:00 2001 From: Chris Gioran Date: Thu, 4 Feb 2016 14:06:26 +0200 Subject: [PATCH] Decouples PhysicalLogFile from transaction specific concepts TransactionMetadataCache is split into transaction specific cache and log header cache, which follows better the way it is used. PhysicalLogFile needs a LogHeaderCache and a last committed id provider, which removes all dependence on transaction concepts. This is in preparation for using PhysicalLogFile to implement a new version of the RaftLog. --- .../org/neo4j/kernel/NeoStoreDataSource.java | 11 ++- .../neo4j/kernel/impl/store/NeoStores.java | 3 +- .../impl/transaction/log/LogHeaderCache.java | 48 ++++++++++++ .../impl/transaction/log/PhysicalLogFile.java | 25 ++++--- .../log/PhysicalLogFileInformation.java | 10 +-- .../log/ReadOnlyTransactionStore.java | 8 +- .../log/TransactionMetadataCache.java | 16 +--- .../java/org/neo4j/kernel/RecoveryTest.java | 9 ++- .../KernelTransactionImplementationTest.java | 19 ----- .../state/NoChangeWriteTransactionTest.java | 1 - .../kernel/impl/store/NeoStoresTest.java | 2 +- .../impl/transaction/LogHeaderCacheTest.java | 74 +++++++++++++++++++ .../PhysicalLogFileInformationTest.java | 49 ++++++------ .../TransactionMetadataCacheTest.java | 40 ++-------- ...ingTransactionAppenderConcurrencyTest.java | 2 +- .../log/BatchingTransactionAppenderTest.java | 6 +- .../transaction/log/PhysicalLogFileTest.java | 17 ++--- .../PhysicalLogicalTransactionStoreTest.java | 33 +++++---- .../log/stresstest/workload/Runner.java | 13 ++-- .../org/neo4j/backup/BackupServiceIT.java | 2 - .../neo4j/com/storecopy/StoreCopyClient.java | 11 ++- .../com/storecopy/ResponsePackerTest.java | 2 +- .../tx/edge/TransactionLogCatchUpWriter.java | 5 +- .../catchup/tx/edge/TxPollingClient.java | 1 - .../java/upgrade/StoreMigratorFrom20IT.java | 6 +- 25 files changed, 243 insertions(+), 170 deletions(-) create mode 100644 community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/LogHeaderCache.java create mode 100644 community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/LogHeaderCacheTest.java diff --git a/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java b/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java index b431c46489242..bbd8c15d9c195 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java @@ -95,6 +95,7 @@ import org.neo4j.kernel.impl.transaction.log.LogFile; import org.neo4j.kernel.impl.transaction.log.LogFileInformation; import org.neo4j.kernel.impl.transaction.log.LogFileRecoverer; +import org.neo4j.kernel.impl.transaction.log.LogHeaderCache; import org.neo4j.kernel.impl.transaction.log.LogPosition; import org.neo4j.kernel.impl.transaction.log.LogVersionRepository; import org.neo4j.kernel.impl.transaction.log.LogVersionedStoreChannel; @@ -571,13 +572,15 @@ private TransactionLogModule buildTransactionLogs( SynchronizedArrayIdOrderingQueue legacyIndexTransactionOrdering, TransactionIdStore transactionIdStore, LogVersionRepository logVersionRepository ) { - TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache( 1000, 100_000 ); + TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache( 100_000 ); + LogHeaderCache logHeaderCache = new LogHeaderCache( 1000 ); final PhysicalLogFiles logFiles = new PhysicalLogFiles( storeDir, PhysicalLogFile.DEFAULT_NAME, fileSystemAbstraction ); final PhysicalLogFile logFile = life.add( new PhysicalLogFile( fileSystemAbstraction, logFiles, - config.get( GraphDatabaseSettings.logical_log_rotation_threshold ), transactionIdStore, - logVersionRepository, physicalLogMonitor, transactionMetadataCache ) ); + config.get( GraphDatabaseSettings.logical_log_rotation_threshold ), + transactionIdStore::getLastCommittedTransactionId, logVersionRepository, physicalLogMonitor, + logHeaderCache ) ); final PhysicalLogFileInformation.LogVersionToTimestamp logInformation = new PhysicalLogFileInformation.LogVersionToTimestamp() @@ -601,7 +604,7 @@ public long getTimestampForVersion( long version ) throws IOException } }; final LogFileInformation logFileInformation = - new PhysicalLogFileInformation( logFiles, transactionMetadataCache, transactionIdStore, logInformation ); + new PhysicalLogFileInformation( logFiles, logHeaderCache, transactionIdStore, logInformation ); String pruningConf = config.get( config.get( GraphDatabaseFacadeFactory.Configuration.ephemeral ) diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/store/NeoStores.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/store/NeoStores.java index ff72f5d3308ff..fb9e2e356eefe 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/store/NeoStores.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/store/NeoStores.java @@ -566,8 +566,7 @@ public void initialize( CountsAccessor.Updater updater ) @Override public long initialVersion() { - return ((MetaDataStore) getOrCreateStore( StoreType.META_DATA )) - .getLastCommittedTransactionId(); + return ((MetaDataStore) getOrCreateStore( StoreType.META_DATA )).getLastCommittedTransactionId(); } } ); diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/LogHeaderCache.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/LogHeaderCache.java new file mode 100644 index 0000000000000..43a60aae50b89 --- /dev/null +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/LogHeaderCache.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2002-2016 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.kernel.impl.transaction.log; + +import org.neo4j.helpers.collection.LruCache; + +public class LogHeaderCache +{ + private final LruCache logHeaderCache; + + public LogHeaderCache( int headerCacheSize ) + { + this.logHeaderCache = new LruCache<>( "Log header cache", headerCacheSize ); + } + + public void clear() + { + logHeaderCache.clear(); + } + + public void putHeader( long logVersion, long previousLogLastCommittedTx ) + { + logHeaderCache.put( logVersion, previousLogLastCommittedTx ); + } + + public long getLogHeader( long logVersion ) + { + Long value = logHeaderCache.get( logVersion ); + return value == null ? -1 : value; + } +} diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFile.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFile.java index f55f60c53f110..70f8c2c1a3bc8 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFile.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFile.java @@ -23,6 +23,7 @@ import java.io.FileNotFoundException; import java.io.IOException; import java.nio.ByteBuffer; +import java.util.function.Supplier; import org.neo4j.helpers.Exceptions; import org.neo4j.io.fs.FileSystemAbstraction; @@ -59,9 +60,9 @@ public void opened( File logFile, long logVersion, long lastTransactionId, boole public static final String REGEX_DEFAULT_VERSION_SUFFIX = "\\."; private final long rotateAtSize; private final FileSystemAbstraction fileSystem; - private final TransactionIdStore transactionIdStore; + private final Supplier lastCommittedId; private final PhysicalLogFiles logFiles; - private final TransactionMetadataCache transactionMetadataCache; + private final LogHeaderCache logHeaderCache; private final Monitor monitor; private final ByteBuffer headerBuffer = ByteBuffer.allocate( LOG_HEADER_SIZE ); private PositionAwarePhysicalFlushableChannel writer; @@ -71,16 +72,16 @@ public void opened( File logFile, long logVersion, long lastTransactionId, boole private volatile PhysicalLogVersionedStoreChannel channel; public PhysicalLogFile( FileSystemAbstraction fileSystem, PhysicalLogFiles logFiles, long rotateAtSize, - TransactionIdStore transactionIdStore, - LogVersionRepository logVersionRepository, Monitor monitor, - TransactionMetadataCache transactionMetadataCache ) + Supplier lastCommittedId, LogVersionRepository logVersionRepository, + Monitor monitor, LogHeaderCache logHeaderCache + ) { this.fileSystem = fileSystem; this.rotateAtSize = rotateAtSize; - this.transactionIdStore = transactionIdStore; + this.lastCommittedId = lastCommittedId; this.logVersionRepository = logVersionRepository; this.monitor = monitor; - this.transactionMetadataCache = transactionMetadataCache; + this.logHeaderCache = logHeaderCache; this.logFiles = logFiles; this.readerLogVersionBridge = new ReaderLogVersionBridge( fileSystem, logFiles ); } @@ -170,9 +171,9 @@ private PhysicalLogVersionedStoreChannel openLogChannelForVersion( long forVersi if ( header == null ) { // Either the header is not there in full or the file was new. Don't care - long lastTxId = transactionIdStore.getLastCommittedTransactionId(); + long lastTxId = lastCommittedId.get(); writeLogHeader( headerBuffer, forVersion, lastTxId ); - transactionMetadataCache.putHeader( forVersion, lastTxId ); + logHeaderCache.putHeader( forVersion, lastTxId ); storeChannel.writeAll( headerBuffer ); monitor.opened( toOpen, forVersion, lastTxId, true ); } @@ -252,15 +253,15 @@ public void accept( LogHeaderVisitor visitor ) throws IOException { // Start from the where we're currently at and go backwards in time (versions) long logVersion = logFiles.getHighestLogVersion(); - long highTransactionId = transactionIdStore.getLastCommittedTransactionId(); + long highTransactionId = lastCommittedId.get(); while ( logFiles.versionExists( logVersion ) ) { - long previousLogLastTxId = transactionMetadataCache.getLogHeader( logVersion ); + long previousLogLastTxId = logHeaderCache.getLogHeader( logVersion ); if ( previousLogLastTxId == -1 ) { LogHeader header = readLogHeader( fileSystem, logFiles.getLogFileForVersion( logVersion ) ); assert logVersion == header.logVersion; - transactionMetadataCache.putHeader( header.logVersion, header.lastCommittedTxId ); + logHeaderCache.putHeader( header.logVersion, header.lastCommittedTxId ); previousLogLastTxId = header.lastCommittedTxId; } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFileInformation.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFileInformation.java index 305b680d8b5ec..59390bb202f4f 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFileInformation.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFileInformation.java @@ -29,17 +29,17 @@ public interface LogVersionToTimestamp } private final PhysicalLogFiles logFiles; - private final TransactionMetadataCache transactionMetadataCache; + private final LogHeaderCache logHeaderCache; private final TransactionIdStore transactionIdStore; private final LogVersionToTimestamp logVersionToTimestamp; public PhysicalLogFileInformation( PhysicalLogFiles logFiles, - TransactionMetadataCache transactionMetadataCache, + LogHeaderCache logHeaderCache, TransactionIdStore transactionIdStore, LogVersionToTimestamp logVersionToTimestamp ) { this.logFiles = logFiles; - this.transactionMetadataCache = transactionMetadataCache; + this.logHeaderCache = logHeaderCache; this.transactionIdStore = transactionIdStore; this.logVersionToTimestamp = logVersionToTimestamp; } @@ -64,7 +64,7 @@ public long getFirstExistingTxId() throws IOException @Override public long getFirstCommittedTxId( long version ) throws IOException { - long logHeader = transactionMetadataCache.getLogHeader( version ); + long logHeader = logHeaderCache.getLogHeader( version ); if ( logHeader != -1 ) { // It existed in cache return logHeader + 1; @@ -74,7 +74,7 @@ public long getFirstCommittedTxId( long version ) throws IOException if ( logFiles.versionExists( version ) ) { long previousVersionLastCommittedTx = logFiles.extractHeader( version ).lastCommittedTxId; - transactionMetadataCache.putHeader( version, previousVersionLastCommittedTx ); + logHeaderCache.putHeader( version, previousVersionLastCommittedTx ); return previousVersionLastCommittedTx + 1; } return -1; diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/ReadOnlyTransactionStore.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/ReadOnlyTransactionStore.java index 223e8417c3dcc..a2d518a3a4c2d 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/ReadOnlyTransactionStore.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/ReadOnlyTransactionStore.java @@ -46,11 +46,13 @@ public ReadOnlyTransactionStore( PageCache pageCache, FileSystemAbstraction fs, throws IOException { PhysicalLogFiles logFiles = new PhysicalLogFiles( fromPath, fs ); - TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache( 10, 100 ); + TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache( 100 ); + LogHeaderCache logHeaderCache = new LogHeaderCache( 10 ); final ReadOnlyTransactionIdStore transactionIdStore = new ReadOnlyTransactionIdStore( pageCache, fromPath ); PhysicalLogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, 0, - transactionIdStore, new ReadOnlyLogVersionRepository( pageCache, fromPath ), - monitors.newMonitor( PhysicalLogFile.Monitor.class ), transactionMetadataCache ) ); + transactionIdStore::getLastCommittedTransactionId, + new ReadOnlyLogVersionRepository( pageCache, fromPath ), + monitors.newMonitor( PhysicalLogFile.Monitor.class ), logHeaderCache ) ); LogEntryReader logEntryReader = new VersionAwareLogEntryReader<>( new RecordStorageCommandReaderFactory() ); physicalStore = new PhysicalLogicalTransactionStore( logFile, transactionMetadataCache, logEntryReader ); diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/TransactionMetadataCache.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/TransactionMetadataCache.java index e26c57989de25..33d3220940356 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/TransactionMetadataCache.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/log/TransactionMetadataCache.java @@ -24,31 +24,17 @@ public class TransactionMetadataCache { private final LruCache txStartPositionCache; - private final LruCache logHeaderCache; - public TransactionMetadataCache( int headerCacheSize, int transactionCacheSize ) + public TransactionMetadataCache( int transactionCacheSize ) { - this.logHeaderCache = new LruCache<>( "Log header cache", headerCacheSize ); this.txStartPositionCache = new LruCache<>( "Tx start position cache", transactionCacheSize ); } public void clear() { - logHeaderCache.clear(); txStartPositionCache.clear(); } - public void putHeader( long logVersion, long previousLogLastCommittedTx ) - { - logHeaderCache.put( logVersion, previousLogLastCommittedTx ); - } - - public long getLogHeader( long logVersion ) - { - Long value = logHeaderCache.get( logVersion ); - return value == null ? -1 : value; - } - public TransactionMetadata getTransactionMetadata( long txId ) { return txStartPositionCache.get( txId ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/RecoveryTest.java b/community/kernel/src/test/java/org/neo4j/kernel/RecoveryTest.java index 07fc59c2fb328..407be04e10e04 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/RecoveryTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/RecoveryTest.java @@ -35,6 +35,7 @@ import org.neo4j.kernel.impl.storageengine.impl.recordstorage.RecordStorageCommandReaderFactory; import org.neo4j.kernel.impl.transaction.DeadSimpleLogVersionRepository; import org.neo4j.kernel.impl.transaction.DeadSimpleTransactionIdStore; +import org.neo4j.kernel.impl.transaction.log.LogHeaderCache; import org.neo4j.kernel.impl.transaction.log.LogPosition; import org.neo4j.kernel.impl.transaction.log.LogPositionMarker; import org.neo4j.kernel.impl.transaction.log.LogVersionRepository; @@ -177,8 +178,8 @@ public void recoveryRequired() } }, monitor ) ); - life.add( new PhysicalLogFile( fs, logFiles, 50, transactionIdStore, logVersionRepository, - mock( PhysicalLogFile.Monitor.class ), new TransactionMetadataCache( 10, 100 ) ) ); + life.add( new PhysicalLogFile( fs, logFiles, 50, transactionIdStore::getLastCommittedTransactionId, + logVersionRepository, mock( PhysicalLogFile.Monitor.class ), new LogHeaderCache( 10 ) ) ); life.start(); @@ -247,8 +248,8 @@ public void recoveryRequired() } }, monitor )); - life.add( new PhysicalLogFile( fs, logFiles, 50, transactionIdStore, logVersionRepository, mock( PhysicalLogFile.Monitor.class), - new TransactionMetadataCache( 10, 100 )) ); + life.add( new PhysicalLogFile( fs, logFiles, 50, transactionIdStore::getLastCommittedTransactionId, + logVersionRepository, mock( PhysicalLogFile.Monitor.class), new LogHeaderCache( 10 ) ) ); life.start(); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionImplementationTest.java b/community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionImplementationTest.java index c993f89ef3ddd..0d7ecface958b 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionImplementationTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionImplementationTest.java @@ -19,7 +19,6 @@ */ package org.neo4j.kernel.api; -import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; @@ -30,31 +29,13 @@ import java.util.Collection; import org.neo4j.function.ThrowingConsumer; -import org.neo4j.helpers.FakeClock; import org.neo4j.kernel.api.exceptions.TransactionFailureException; -import org.neo4j.kernel.api.txstate.LegacyIndexTransactionState; import org.neo4j.kernel.api.txstate.TransactionState; import org.neo4j.kernel.impl.api.KernelStatement; import org.neo4j.kernel.impl.api.KernelTransactionImplementation; -import org.neo4j.kernel.impl.api.KernelTransactions; -import org.neo4j.kernel.impl.api.TransactionCommitProcess; -import org.neo4j.kernel.impl.api.TransactionHeaderInformation; -import org.neo4j.kernel.impl.api.TransactionHooks; -import org.neo4j.kernel.impl.api.TransactionToApply; -import org.neo4j.kernel.impl.api.store.StoreStatement; -import org.neo4j.kernel.impl.locking.NoOpClient; -import org.neo4j.kernel.impl.store.MetaDataStore; -import org.neo4j.kernel.impl.store.NeoStores; -import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory; import org.neo4j.kernel.impl.transaction.TransactionMonitor; -import org.neo4j.kernel.impl.transaction.TransactionRepresentation; import org.neo4j.kernel.impl.transaction.command.Command; -import org.neo4j.kernel.impl.transaction.tracing.CommitEvent; -import org.neo4j.kernel.impl.transaction.tracing.TransactionTracer; import org.neo4j.storageengine.api.StorageCommand; -import org.neo4j.storageengine.api.StorageEngine; -import org.neo4j.storageengine.api.StoreReadLayer; -import org.neo4j.storageengine.api.TransactionApplicationMode; import org.neo4j.storageengine.api.lock.ResourceLocker; import org.neo4j.test.DoubleLatch; diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/NoChangeWriteTransactionTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/NoChangeWriteTransactionTest.java index 75ef90ee4c9ca..d2c76587c1322 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/NoChangeWriteTransactionTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/state/NoChangeWriteTransactionTest.java @@ -27,7 +27,6 @@ import org.neo4j.graphdb.Transaction; import org.neo4j.graphdb.index.Index; import org.neo4j.kernel.GraphDatabaseAPI; -import org.neo4j.kernel.impl.store.NeoStores; import org.neo4j.kernel.impl.transaction.log.TransactionIdStore; import org.neo4j.test.DatabaseRule; import org.neo4j.test.ImpermanentDatabaseRule; diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/store/NeoStoresTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/store/NeoStoresTest.java index d9f202f9b2d7c..845a4f6789b37 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/store/NeoStoresTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/store/NeoStoresTest.java @@ -238,7 +238,7 @@ public void testCreateStore() throws Exception { nodeIds[i] = nextId( Node.class ); transaction.nodeDoCreate( nodeIds[i] ); - nodeAddProperty( nodeIds[i], index( "nisse" ), new Integer( 10 - i ) ); + nodeAddProperty( nodeIds[i], index( "nisse" ), 10 - i ); } for ( int i = 0; i < 2; i++ ) { diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/LogHeaderCacheTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/LogHeaderCacheTest.java new file mode 100644 index 0000000000000..7829191b0cba9 --- /dev/null +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/LogHeaderCacheTest.java @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2002-2016 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.kernel.impl.transaction; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.fail; + +import org.junit.Test; +import org.neo4j.kernel.impl.transaction.log.LogHeaderCache; +import org.neo4j.kernel.impl.transaction.log.LogPosition; +import org.neo4j.kernel.impl.transaction.log.TransactionMetadataCache; + +public class LogHeaderCacheTest +{ + @Test + public void shouldReturnNegativeNumberWhenThereIsNoHeaderInTheCache() + { + // given + final LogHeaderCache cache = new LogHeaderCache( 2 ); + + // when + final long logHeader = cache.getLogHeader( 5 ); + + // then + assertEquals( -1, logHeader ); + } + + @Test + public void shouldReturnTheHeaderIfInTheCache() + { + // given + final LogHeaderCache cache = new LogHeaderCache( 2 ); + + // when + cache.putHeader( 5, 3 ); + final long logHeader = cache.getLogHeader( 5 ); + + // then + assertEquals( 3, logHeader ); + } + + @Test + public void shouldClearTheCache() + { + // given + final LogHeaderCache cache = new LogHeaderCache( 2 ); + + // when + cache.putHeader( 5, 3 ); + cache.clear(); + final long logHeader = cache.getLogHeader( 5 ); + + // then + assertEquals( -1, logHeader ); + } +} diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/PhysicalLogFileInformationTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/PhysicalLogFileInformationTest.java index 8fd6b3f73e74e..8058470579f6f 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/PhysicalLogFileInformationTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/PhysicalLogFileInformationTest.java @@ -21,6 +21,7 @@ import org.junit.Test; +import org.neo4j.kernel.impl.transaction.log.LogHeaderCache; import org.neo4j.kernel.impl.transaction.log.PhysicalLogFileInformation; import org.neo4j.kernel.impl.transaction.log.PhysicalLogFiles; import org.neo4j.kernel.impl.transaction.log.TransactionIdStore; @@ -37,7 +38,7 @@ public class PhysicalLogFileInformationTest { private PhysicalLogFiles logFiles = mock( PhysicalLogFiles.class ); - private TransactionMetadataCache transactionMetadataCache = mock( TransactionMetadataCache.class ); + private LogHeaderCache logHeaderCache = mock( LogHeaderCache.class ); private TransactionIdStore transactionIdStore = mock( TransactionIdStore.class ); private PhysicalLogFileInformation.LogVersionToTimestamp logVersionToTimestamp = mock( PhysicalLogFileInformation.LogVersionToTimestamp.class ); @@ -45,31 +46,31 @@ public class PhysicalLogFileInformationTest @Test public void shouldReadAndCacheFirstCommittedTransactionIdForAGivenVersionWhenNotCached() throws Exception { - PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, - transactionMetadataCache, transactionIdStore, logVersionToTimestamp ); + PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, logHeaderCache, transactionIdStore, + logVersionToTimestamp ); long expected = 5; - long version = 10l; - when( transactionMetadataCache.getLogHeader( version ) ).thenReturn( -1l ); + long version = 10L; + when( logHeaderCache.getLogHeader( version ) ).thenReturn( -1L ); when( logFiles.versionExists( version ) ).thenReturn( true ); when( logFiles.extractHeader( version ) ).thenReturn( - new LogHeader( (byte) -1/*ignored*/, -1l/*ignored*/, expected - 1l ) + new LogHeader( (byte) -1/*ignored*/, -1L/*ignored*/, expected - 1L ) ); long firstCommittedTxId = info.getFirstCommittedTxId( version ); assertEquals( expected, firstCommittedTxId ); - verify( transactionMetadataCache, times( 1 ) ).putHeader( version, expected - 1 ); + verify( logHeaderCache, times( 1 ) ).putHeader( version, expected - 1 ); } @Test public void shouldReadFirstCommittedTransactionIdForAGivenVersionWhenCached() throws Exception { - PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, - transactionMetadataCache, transactionIdStore, logVersionToTimestamp ); + PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, logHeaderCache, transactionIdStore, + logVersionToTimestamp ); long expected = 5; - long version = 10l; - when( transactionMetadataCache.getLogHeader( version ) ).thenReturn( expected - 1 ); + long version = 10L; + when( logHeaderCache.getLogHeader( version ) ).thenReturn( expected - 1 ); long firstCommittedTxId = info.getFirstCommittedTxId( version ); assertEquals( expected, firstCommittedTxId ); @@ -78,35 +79,35 @@ public void shouldReadFirstCommittedTransactionIdForAGivenVersionWhenCached() th @Test public void shouldReadAndCacheFirstCommittedTransactionIdWhenNotCached() throws Exception { - PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, - transactionMetadataCache, transactionIdStore, logVersionToTimestamp ); + PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, logHeaderCache, transactionIdStore, + logVersionToTimestamp ); long expected = 5; - long version = 10l; + long version = 10L; when( logFiles.getHighestLogVersion() ).thenReturn( version ); - when( transactionMetadataCache.getLogHeader( version ) ).thenReturn( -1l ); + when( logHeaderCache.getLogHeader( version ) ).thenReturn( -1L ); when( logFiles.versionExists( version ) ).thenReturn( true ); when( logFiles.extractHeader( version ) ).thenReturn( - new LogHeader( (byte) -1/*ignored*/, -1l/*ignored*/, expected - 1l ) + new LogHeader( (byte) -1/*ignored*/, -1L/*ignored*/, expected - 1L ) ); when( logFiles.hasAnyTransaction( version ) ).thenReturn( true ); long firstCommittedTxId = info.getFirstExistingTxId(); assertEquals( expected, firstCommittedTxId ); - verify( transactionMetadataCache, times( 1 ) ).putHeader( version, expected - 1 ); + verify( logHeaderCache, times( 1 ) ).putHeader( version, expected - 1 ); } @Test public void shouldReadFirstCommittedTransactionIdWhenCached() throws Exception { - PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, - transactionMetadataCache, transactionIdStore, logVersionToTimestamp ); + PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, logHeaderCache, transactionIdStore, + logVersionToTimestamp ); long expected = 5; - long version = 10l; + long version = 10L; when( logFiles.getHighestLogVersion() ).thenReturn( version ); when( logFiles.versionExists( version ) ).thenReturn( true ); - when( transactionMetadataCache.getLogHeader( version ) ).thenReturn( expected -1 ); + when( logHeaderCache.getLogHeader( version ) ).thenReturn( expected -1 ); when( logFiles.hasAnyTransaction( version ) ).thenReturn( true ); long firstCommittedTxId = info.getFirstExistingTxId(); @@ -116,10 +117,10 @@ public void shouldReadFirstCommittedTransactionIdWhenCached() throws Exception @Test public void shouldReturnNothingWhenThereAreNoTransactions() throws Exception { - PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, - transactionMetadataCache, transactionIdStore, logVersionToTimestamp ); + PhysicalLogFileInformation info = new PhysicalLogFileInformation( logFiles, logHeaderCache, transactionIdStore, + logVersionToTimestamp ); - long version = 10l; + long version = 10L; when( logFiles.getHighestLogVersion() ).thenReturn( version ); when( logFiles.hasAnyTransaction( version ) ).thenReturn( false ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/TransactionMetadataCacheTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/TransactionMetadataCacheTest.java index 142da8aaa851f..e6d1dbd0fa429 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/TransactionMetadataCacheTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/TransactionMetadataCacheTest.java @@ -33,7 +33,7 @@ public class TransactionMetadataCacheTest public void shouldReturnNullWhenMissingATxInTheCache() { // given - final TransactionMetadataCache cache = new TransactionMetadataCache( 2, 2 ); + final TransactionMetadataCache cache = new TransactionMetadataCache( 2 ); // when final TransactionMetadataCache.TransactionMetadata metadata = cache.getTransactionMetadata( 42 ); @@ -46,7 +46,7 @@ public void shouldReturnNullWhenMissingATxInTheCache() public void shouldReturnTheTxValueTIfInTheCached() { // given - final TransactionMetadataCache cache = new TransactionMetadataCache( 2, 2 ); + final TransactionMetadataCache cache = new TransactionMetadataCache( 2 ); final LogPosition position = new LogPosition( 3, 4 ); final int txId = 42; final int masterId = 0; @@ -66,7 +66,7 @@ public void shouldReturnTheTxValueTIfInTheCached() public void shouldThrowWhenCachingATxWithNegativeOffsetPosition() { // given - final TransactionMetadataCache cache = new TransactionMetadataCache( 2, 2 ); + final TransactionMetadataCache cache = new TransactionMetadataCache( 2 ); final LogPosition position = new LogPosition( 3, -1 ); final int txId = 42; final int masterId = 0; @@ -84,37 +84,10 @@ public void shouldThrowWhenCachingATxWithNegativeOffsetPosition() } @Test - public void shouldReturnNegativeNumberWhenThereIsNoHeaderInTheCache() + public void shouldClearTheCache() { // given - final TransactionMetadataCache cache = new TransactionMetadataCache( 2, 2 ); - - // when - final long logHeader = cache.getLogHeader( 5 ); - - // then - assertEquals( -1, logHeader ); - } - - @Test - public void shouldReturnTheHeaderIfInTheCache() - { - // given - final TransactionMetadataCache cache = new TransactionMetadataCache( 2, 2 ); - - // when - cache.putHeader( 5, 3 ); - final long logHeader = cache.getLogHeader( 5 ); - - // then - assertEquals( 3, logHeader ); - } - - @Test - public void shouldClearTheCaches() - { - // given - final TransactionMetadataCache cache = new TransactionMetadataCache( 2, 2 ); + final TransactionMetadataCache cache = new TransactionMetadataCache( 2 ); final LogPosition position = new LogPosition( 3, 4 ); final int txId = 42; final int masterId = 0; @@ -123,13 +96,10 @@ public void shouldClearTheCaches() // when cache.cacheTransactionMetadata( txId, position, masterId, authorId, checksum ); - cache.putHeader( 5, 3 ); cache.clear(); - final long logHeader = cache.getLogHeader( 5 ); final TransactionMetadataCache.TransactionMetadata metadata = cache.getTransactionMetadata( txId ); // then - assertEquals( -1, logHeader ); assertNull( metadata ); } } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/BatchingTransactionAppenderConcurrencyTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/BatchingTransactionAppenderConcurrencyTest.java index 0535e0af39eee..d5fe5fa379bbe 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/BatchingTransactionAppenderConcurrencyTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/BatchingTransactionAppenderConcurrencyTest.java @@ -81,7 +81,7 @@ public static void tearDownExecutor() private final LogAppendEvent logAppendEvent = LogAppendEvent.NULL; private final LogFile logFile = mock( LogFile.class ); private final LogRotation logRotation = LogRotation.NO_ROTATION; - private final TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache( 10, 10 ); + private final TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache( 10 ); private final TransactionIdStore transactionIdStore = new DeadSimpleTransactionIdStore(); private final IdOrderingQueue legacyIndexTransactionOrdering = IdOrderingQueue.BYPASS; private final DatabaseHealth databaseHealth = mock( DatabaseHealth.class ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/BatchingTransactionAppenderTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/BatchingTransactionAppenderTest.java index 13b4f889fb570..93216b6575d02 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/BatchingTransactionAppenderTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/BatchingTransactionAppenderTest.java @@ -82,7 +82,7 @@ public class BatchingTransactionAppenderTest private final DatabaseHealth databaseHealth = mock( DatabaseHealth.class ); private final LogFile logFile = mock( LogFile.class ); private final TransactionIdStore transactionIdStore = mock( TransactionIdStore.class ); - private final TransactionMetadataCache positionCache = new TransactionMetadataCache( 10, 10 ); + private final TransactionMetadataCache positionCache = new TransactionMetadataCache( 10 ); @Test public void shouldAppendSingleTransaction() throws Exception @@ -208,7 +208,7 @@ public void shouldNotAppendCommittedTransactionsWhenTooFarAhead() throws Excepti when( transactionIdStore.getLastCommittedTransactionId() ).thenReturn( latestCommittedTxWhenStarted ); - LogEntryStart start = new LogEntryStart( 0, 0, 0l, latestCommittedTxWhenStarted, null, + LogEntryStart start = new LogEntryStart( 0, 0, 0L, latestCommittedTxWhenStarted, null, LogPosition.UNSPECIFIED ); LogEntryCommit commit = new OnePhaseCommit( latestCommittedTxWhenStarted + 2, 0l ); CommittedTransactionRepresentation transaction = @@ -280,7 +280,7 @@ public Flushable answer( InvocationOnMock invocation ) throws Throwable doThrow( failure ).when( flushable ).flush(); LogFile logFile = mock( LogFile.class ); when( logFile.getWriter() ).thenReturn( channel ); - TransactionMetadataCache metadataCache = new TransactionMetadataCache( 10, 10 ); + TransactionMetadataCache metadataCache = new TransactionMetadataCache( 10 ); TransactionIdStore transactionIdStore = mock( TransactionIdStore.class ); when( transactionIdStore.nextCommittingTransactionId() ).thenReturn( txId ); Mockito.reset( databaseHealth ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFileTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFileTest.java index 893e172b0f04b..8facde133b20e 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFileTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogFileTest.java @@ -58,9 +58,8 @@ public void shouldOpenInFreshDirectoryAndFinallyAddHeader() throws Exception String name = "log"; LifeSupport life = new LifeSupport(); PhysicalLogFiles logFiles = new PhysicalLogFiles( directory.directory(), name, fs ); - life.add( new PhysicalLogFile( fs, logFiles, 1000, - transactionIdStore, logVersionRepository, mock( Monitor.class ), - new TransactionMetadataCache( 10, 100 ) )); + life.add( new PhysicalLogFile( fs, logFiles, 1000, transactionIdStore::getLastCommittedTransactionId, + logVersionRepository, mock( Monitor.class ), new LogHeaderCache( 10 ) ) ); // WHEN life.start(); @@ -82,8 +81,8 @@ public void shouldWriteSomeDataIntoTheLog() throws Exception PhysicalLogFiles logFiles = new PhysicalLogFiles( directory.directory(), name, fs ); Monitor monitor = mock( Monitor.class ); LogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, 1000, - transactionIdStore, logVersionRepository, monitor, - new TransactionMetadataCache( 10, 100 ) ) ); + transactionIdStore::getLastCommittedTransactionId, logVersionRepository, monitor, + new LogHeaderCache( 10 ) ) ); // WHEN try @@ -120,8 +119,8 @@ public void shouldReadOlderLogs() throws Exception LifeSupport life = new LifeSupport(); PhysicalLogFiles logFiles = new PhysicalLogFiles( directory.directory(), name, fs ); LogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, 50, - transactionIdStore, logVersionRepository, mock( Monitor.class ), - new TransactionMetadataCache( 10, 100 ) ) ); + transactionIdStore::getLastCommittedTransactionId, logVersionRepository, mock( Monitor.class ), + new LogHeaderCache( 10 ) ) ); // WHEN life.start(); @@ -172,8 +171,8 @@ public void shouldVisitLogFile() throws Exception LifeSupport life = new LifeSupport(); PhysicalLogFiles logFiles = new PhysicalLogFiles( directory.directory(), name, fs ); LogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, 50, - transactionIdStore, logVersionRepository, mock( Monitor.class ), - new TransactionMetadataCache( 10, 100 )) ); + transactionIdStore::getLastCommittedTransactionId, logVersionRepository, mock( Monitor.class ), + new LogHeaderCache( 10 ) ) ); life.start(); FlushablePositionAwareChannel writer = logFile.getWriter(); LogPositionMarker mark = new LogPositionMarker(); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogicalTransactionStoreTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogicalTransactionStoreTest.java index 0b1ca8191e402..d57f0b3358c96 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogicalTransactionStoreTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/PhysicalLogicalTransactionStoreTest.java @@ -91,13 +91,15 @@ public void shouldOpenCleanStore() throws Exception { // GIVEN TransactionIdStore transactionIdStore = new DeadSimpleTransactionIdStore(); - TransactionMetadataCache positionCache = new TransactionMetadataCache( 10, 1000 ); + TransactionMetadataCache positionCache = new TransactionMetadataCache( 1000 ); + LogHeaderCache logHeaderCache = new LogHeaderCache( 10 ); LifeSupport life = new LifeSupport(); PhysicalLogFiles logFiles = new PhysicalLogFiles( testDir, DEFAULT_NAME, fs ); Monitor monitor = new Monitors().newMonitor( PhysicalLogFile.Monitor.class ); LogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, 1000, - transactionIdStore, mock( LogVersionRepository.class ), monitor, positionCache ) ); + transactionIdStore::getLastCommittedTransactionId, mock( LogVersionRepository.class ), monitor, + logHeaderCache ) ); life.add( new BatchingTransactionAppender( logFile, NO_ROTATION, positionCache, transactionIdStore, BYPASS, DATABASE_HEALTH ) ); @@ -118,15 +120,17 @@ public void shouldOpenAndRecoverExistingData() throws Exception { // GIVEN TransactionIdStore transactionIdStore = new DeadSimpleTransactionIdStore(); - TransactionMetadataCache positionCache = new TransactionMetadataCache( 10, 100 ); + TransactionMetadataCache positionCache = new TransactionMetadataCache( 100 ); + LogHeaderCache logHeaderCache = new LogHeaderCache( 10 ); final byte[] additionalHeader = new byte[]{1, 2, 5}; final int masterId = 2, authorId = 1; final long timeStarted = 12345, latestCommittedTxWhenStarted = 4545, timeCommitted = timeStarted + 10; LifeSupport life = new LifeSupport(); final PhysicalLogFiles logFiles = new PhysicalLogFiles( testDir, DEFAULT_NAME, fs ); Monitor monitor = new Monitors().newMonitor( PhysicalLogFile.Monitor.class ); - LogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, 1000, transactionIdStore, - mock( LogVersionRepository.class ), monitor, positionCache ) ); + LogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, 1000, + transactionIdStore::getLastCommittedTransactionId, mock( LogVersionRepository.class ), monitor, + logHeaderCache ) ); life.start(); try @@ -145,7 +149,8 @@ public void shouldOpenAndRecoverExistingData() throws Exception authorId, timeStarted, timeCommitted, latestCommittedTxWhenStarted ); final LogFileRecoverer recoverer = new LogFileRecoverer( new VersionAwareLogEntryReader<>( new RecordStorageCommandReaderFactory() ), visitor ); - logFile = life.add( new PhysicalLogFile( fs, logFiles, 1000, transactionIdStore, mock( LogVersionRepository.class ), monitor, positionCache ) ); + logFile = life.add( new PhysicalLogFile( fs, logFiles, 1000, transactionIdStore::getLastCommittedTransactionId, + mock( LogVersionRepository.class ), monitor, logHeaderCache ) ); life.add( new BatchingTransactionAppender( logFile, NO_ROTATION, positionCache, transactionIdStore, BYPASS, DATABASE_HEALTH ) ); @@ -236,7 +241,8 @@ public void shouldExtractMetadataFromExistingTransaction() throws Exception { // GIVEN TransactionIdStore transactionIdStore = new DeadSimpleTransactionIdStore(); - TransactionMetadataCache positionCache = new TransactionMetadataCache( 10, 100 ); + TransactionMetadataCache positionCache = new TransactionMetadataCache( 100 ); + LogHeaderCache logHeaderCache = new LogHeaderCache( 10 ); final byte[] additionalHeader = new byte[]{1, 2, 5}; final int masterId = 2, authorId = 1; final long timeStarted = 12345, latestCommittedTxWhenStarted = 4545, timeCommitted = timeStarted + 10; @@ -244,8 +250,8 @@ public void shouldExtractMetadataFromExistingTransaction() throws Exception PhysicalLogFiles logFiles = new PhysicalLogFiles( testDir, DEFAULT_NAME, fs ); Monitor monitor = new Monitors().newMonitor( PhysicalLogFile.Monitor.class ); LogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, 1000, - transactionIdStore, mock( LogVersionRepository.class ), monitor, - positionCache ) ); + transactionIdStore::getLastCommittedTransactionId, mock( LogVersionRepository.class ), monitor, + logHeaderCache ) ); life.start(); try @@ -263,9 +269,8 @@ transactionIdStore, mock( LogVersionRepository.class ), monitor, authorId, timeStarted, timeCommitted, latestCommittedTxWhenStarted ); final LogFileRecoverer recoverer = new LogFileRecoverer( new VersionAwareLogEntryReader<>( new RecordStorageCommandReaderFactory() ), visitor ); - logFile = life.add( new PhysicalLogFile( fs, logFiles, 1000, - transactionIdStore, mock( LogVersionRepository.class ), monitor, - positionCache ) ); + logFile = life.add( new PhysicalLogFile( fs, logFiles, 1000, transactionIdStore::getLastCommittedTransactionId, + mock( LogVersionRepository.class ), monitor, logHeaderCache ) ); final LogicalTransactionStore store = new PhysicalLogicalTransactionStore( logFile, positionCache, new VersionAwareLogEntryReader<>( new RecordStorageCommandReaderFactory() ) ); @@ -293,7 +298,7 @@ public void shouldThrowNoSuchTransactionExceptionIfMetadataNotFound() throws Exc { // GIVEN LogFile logFile = mock( LogFile.class ); - TransactionMetadataCache cache = new TransactionMetadataCache( 10, 10 ); + TransactionMetadataCache cache = new TransactionMetadataCache( 10 ); LifeSupport life = new LifeSupport(); @@ -325,7 +330,7 @@ public void shouldThrowNoSuchTransactionExceptionIfLogFileIsMissing() throws Exc // a missing file when( logFile.getReader( any( LogPosition.class) ) ).thenThrow( new FileNotFoundException() ); // Which is nevertheless in the metadata cache - TransactionMetadataCache cache = new TransactionMetadataCache( 10, 10 ); + TransactionMetadataCache cache = new TransactionMetadataCache( 10 ); cache.cacheTransactionMetadata( 10, new LogPosition( 2, 130 ), 1, 1, 100 ); LifeSupport life = new LifeSupport(); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/stresstest/workload/Runner.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/stresstest/workload/Runner.java index 67ce77dc22e87..a5bd06401ef25 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/stresstest/workload/Runner.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/log/stresstest/workload/Runner.java @@ -35,6 +35,7 @@ import org.neo4j.kernel.impl.transaction.DeadSimpleTransactionIdStore; import org.neo4j.kernel.impl.transaction.log.BatchingTransactionAppender; import org.neo4j.kernel.impl.transaction.log.LogFile; +import org.neo4j.kernel.impl.transaction.log.LogHeaderCache; import org.neo4j.kernel.impl.transaction.log.PhysicalLogFile; import org.neo4j.kernel.impl.transaction.log.PhysicalLogFiles; import org.neo4j.kernel.impl.transaction.log.TransactionAppender; @@ -69,9 +70,10 @@ public Long call() throws Exception try ( Lifespan life = new Lifespan() ) { TransactionIdStore transactionIdStore = new DeadSimpleTransactionIdStore(); - TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache( 1000, 100_000 ); + TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache( 100_000 ); + LogHeaderCache logHeaderCache = new LogHeaderCache( 1000 ); - LogFile logFile = life.add( createPhysicalLogFile( transactionIdStore, transactionMetadataCache ) ); + LogFile logFile = life.add( createPhysicalLogFile( transactionIdStore, logHeaderCache ) ); TransactionAppender transactionAppender = life.add( createBatchingTransactionAppender( transactionIdStore, transactionMetadataCache, logFile ) ); @@ -117,15 +119,16 @@ private BatchingTransactionAppender createBatchingTransactionAppender( Transacti } private PhysicalLogFile createPhysicalLogFile( TransactionIdStore transactionIdStore, - TransactionMetadataCache transactionMetadataCache ) + LogHeaderCache logHeaderCache ) { DefaultFileSystemAbstraction fs = new DefaultFileSystemAbstraction(); PhysicalLogFiles logFiles = new PhysicalLogFiles( workingDirectory, fs ); long rotateAtSize = Settings.BYTES.apply( GraphDatabaseSettings.logical_log_rotation_threshold.getDefaultValue() ); DeadSimpleLogVersionRepository logVersionRepository = new DeadSimpleLogVersionRepository( 0 ); - return new PhysicalLogFile( fs, logFiles, rotateAtSize, transactionIdStore, - logVersionRepository, NOOP_LOGFILE_MONITOR, transactionMetadataCache ); + return new PhysicalLogFile( fs, logFiles, rotateAtSize, + transactionIdStore::getLastCommittedTransactionId, logVersionRepository, NOOP_LOGFILE_MONITOR, + logHeaderCache ); } private static final PhysicalLogFile.Monitor NOOP_LOGFILE_MONITOR = new PhysicalLogFile.Monitor() diff --git a/enterprise/backup/src/test/java/org/neo4j/backup/BackupServiceIT.java b/enterprise/backup/src/test/java/org/neo4j/backup/BackupServiceIT.java index 466bfdcee1f4b..a99569527d5ed 100644 --- a/enterprise/backup/src/test/java/org/neo4j/backup/BackupServiceIT.java +++ b/enterprise/backup/src/test/java/org/neo4j/backup/BackupServiceIT.java @@ -22,13 +22,11 @@ import org.hamcrest.BaseMatcher; import org.hamcrest.Description; import org.junit.Before; -import org.junit.Ignore; import org.junit.Rule; import org.junit.Test; import java.io.File; import java.io.FileFilter; -import java.io.FilenameFilter; import java.io.IOException; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; diff --git a/enterprise/com/src/main/java/org/neo4j/com/storecopy/StoreCopyClient.java b/enterprise/com/src/main/java/org/neo4j/com/storecopy/StoreCopyClient.java index 587c1028fe380..2d29ec2c5217e 100644 --- a/enterprise/com/src/main/java/org/neo4j/com/storecopy/StoreCopyClient.java +++ b/enterprise/com/src/main/java/org/neo4j/com/storecopy/StoreCopyClient.java @@ -25,6 +25,7 @@ import java.nio.ByteBuffer; import java.nio.channels.ReadableByteChannel; import java.util.concurrent.atomic.AtomicLong; +import java.util.function.Supplier; import org.neo4j.com.Response; import org.neo4j.graphdb.GraphDatabaseService; @@ -41,6 +42,7 @@ import org.neo4j.kernel.impl.store.MetaDataStore; import org.neo4j.kernel.impl.transaction.CommittedTransactionRepresentation; import org.neo4j.kernel.impl.transaction.log.LogFile; +import org.neo4j.kernel.impl.transaction.log.LogHeaderCache; import org.neo4j.kernel.impl.transaction.log.LogPosition; import org.neo4j.kernel.impl.transaction.log.PhysicalLogFile; import org.neo4j.kernel.impl.transaction.log.PhysicalLogFiles; @@ -228,12 +230,13 @@ private void writeTransactionsToActiveLogFile( File tempStoreDir, Response re { // Start the log and appender PhysicalLogFiles logFiles = new PhysicalLogFiles( tempStoreDir, fs ); - TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache( 10, 100 ); + LogHeaderCache logHeaderCache = new LogHeaderCache( 10 ); ReadOnlyLogVersionRepository logVersionRepository = new ReadOnlyLogVersionRepository( pageCache, tempStoreDir ); + ReadOnlyTransactionIdStore readOnlyTransactionIdStore = new ReadOnlyTransactionIdStore( + pageCache, tempStoreDir ); LogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, Long.MAX_VALUE /*don't rotate*/, - new ReadOnlyTransactionIdStore( pageCache, tempStoreDir ), logVersionRepository, - new Monitors().newMonitor( PhysicalLogFile.Monitor.class ), - transactionMetadataCache ) ); + readOnlyTransactionIdStore::getLastCommittedTransactionId, logVersionRepository, + new Monitors().newMonitor( PhysicalLogFile.Monitor.class ), logHeaderCache ) ); life.start(); // Just write all transactions to the active log version. Remember that this is after a store copy diff --git a/enterprise/com/src/test/java/org/neo4j/com/storecopy/ResponsePackerTest.java b/enterprise/com/src/test/java/org/neo4j/com/storecopy/ResponsePackerTest.java index 31ac236647abf..f49263fbe29be 100644 --- a/enterprise/com/src/test/java/org/neo4j/com/storecopy/ResponsePackerTest.java +++ b/enterprise/com/src/test/java/org/neo4j/com/storecopy/ResponsePackerTest.java @@ -85,7 +85,7 @@ public boolean visit( CommittedTransactionRepresentation element ) // Move the target transaction id forward one step, effectively always keeping it out of reach transactionIdStore.setLastCommittedAndClosedTransactionId( - transactionIdStore.getLastCommittedTransactionId()+1, 0, 0, 0 ); + transactionIdStore.getLastCommittedTransactionId() + 1, 0, 0, 0 ); return true; } }; diff --git a/enterprise/core-edge/src/main/java/org/neo4j/coreedge/catchup/tx/edge/TransactionLogCatchUpWriter.java b/enterprise/core-edge/src/main/java/org/neo4j/coreedge/catchup/tx/edge/TransactionLogCatchUpWriter.java index 832296e838676..227b55de4c610 100644 --- a/enterprise/core-edge/src/main/java/org/neo4j/coreedge/catchup/tx/edge/TransactionLogCatchUpWriter.java +++ b/enterprise/core-edge/src/main/java/org/neo4j/coreedge/catchup/tx/edge/TransactionLogCatchUpWriter.java @@ -26,6 +26,7 @@ import org.neo4j.io.pagecache.PageCache; import org.neo4j.kernel.impl.transaction.CommittedTransactionRepresentation; import org.neo4j.kernel.impl.transaction.log.LogFile; +import org.neo4j.kernel.impl.transaction.log.LogHeaderCache; import org.neo4j.kernel.impl.transaction.log.LogPosition; import org.neo4j.kernel.impl.transaction.log.PhysicalLogFile; import org.neo4j.kernel.impl.transaction.log.PhysicalLogFiles; @@ -61,9 +62,9 @@ public TransactionLogCatchUpWriter( File storeDir, FileSystemAbstraction fs, Pag logFiles = new PhysicalLogFiles( storeDir, fs ); logVersionRepository = new ReadOnlyLogVersionRepository( pageCache, storeDir ); LogFile logFile = life.add( new PhysicalLogFile( fs, logFiles, Long.MAX_VALUE /*don't rotate*/, - new ReadOnlyTransactionIdStore( pageCache, storeDir ), logVersionRepository, + new ReadOnlyTransactionIdStore( pageCache, storeDir )::getLastCommittedTransactionId, logVersionRepository, new Monitors().newMonitor( PhysicalLogFile.Monitor.class ), - new TransactionMetadataCache( 10, 100 ) ) ); + new LogHeaderCache( 10 ) ) ); life.start(); FlushableChannel channel = logFile.getWriter(); diff --git a/enterprise/core-edge/src/main/java/org/neo4j/coreedge/catchup/tx/edge/TxPollingClient.java b/enterprise/core-edge/src/main/java/org/neo4j/coreedge/catchup/tx/edge/TxPollingClient.java index c1fe51f4a9a99..4c83280fef5b7 100644 --- a/enterprise/core-edge/src/main/java/org/neo4j/coreedge/catchup/tx/edge/TxPollingClient.java +++ b/enterprise/core-edge/src/main/java/org/neo4j/coreedge/catchup/tx/edge/TxPollingClient.java @@ -22,7 +22,6 @@ import java.util.function.Supplier; import org.neo4j.coreedge.catchup.storecopy.edge.CoreClient; -import org.neo4j.coreedge.discovery.EdgeDiscoveryService; import org.neo4j.coreedge.server.edge.EdgeToCoreConnectionStrategy; import org.neo4j.kernel.impl.transaction.log.TransactionIdStore; import org.neo4j.kernel.impl.util.JobScheduler; diff --git a/enterprise/neo4j-enterprise/src/test/java/upgrade/StoreMigratorFrom20IT.java b/enterprise/neo4j-enterprise/src/test/java/upgrade/StoreMigratorFrom20IT.java index 58c0e7fc0fc15..144eb568a3eac 100644 --- a/enterprise/neo4j-enterprise/src/test/java/upgrade/StoreMigratorFrom20IT.java +++ b/enterprise/neo4j-enterprise/src/test/java/upgrade/StoreMigratorFrom20IT.java @@ -186,11 +186,11 @@ public static void verifyNeoStore( NeoStores neoStores ) { MetaDataStore metaDataStore = neoStores.getMetaDataStore(); assertEquals( 1317392957120L, metaDataStore.getCreationTime() ); - assertEquals( -472309512128245482l, metaDataStore.getRandomNumber() ); - assertEquals( 5l, metaDataStore.getCurrentLogVersion() ); + assertEquals( -472309512128245482L, metaDataStore.getRandomNumber() ); + assertEquals( 5L, metaDataStore.getCurrentLogVersion() ); assertEquals( LowLimit.STORE_VERSION, MetaDataStore.versionLongToString( metaDataStore.getStoreVersion() ) ); - assertEquals( 1042l, metaDataStore.getLastCommittedTransactionId() ); + assertEquals( 1042L, metaDataStore.getLastCommittedTransactionId() ); } private StoreUpgrader upgrader( SchemaIndexMigrator indexMigrator, StoreMigrator storeMigrator )