From b3b8ea4351870f15159b9655e7b608650d9eb293 Mon Sep 17 00:00:00 2001 From: Anton Klaren Date: Fri, 2 Feb 2018 13:34:49 +0100 Subject: [PATCH] Fix compilation errors after remove redundant throws --- .../neo4j/bolt/v1/messaging/Neo4jPack.java | 18 ++++----- .../neo4j/bolt/v1/messaging/Neo4jPackV1.java | 1 - .../internal/gbptree/SeekCursorTestBase.java | 40 ++++++------------- .../api/KernelTransactionImplementation.java | 15 ++----- .../NodePropertyUniqueConstraintCreator.java | 18 ++------- .../community/CommunityLockClient.java | 8 ++-- .../Neo4jTransactionalContextFactory.java | 4 +- .../participant/StoreMigrator.java | 3 +- .../explicitindex/IndexImplementation.java | 24 ----------- .../impl/batchimport/input/BadCollector.java | 4 -- .../api/index/inmemory/HashBasedIndex.java | 6 +-- .../org/neo4j/concurrent/AsyncEventsTest.java | 9 +---- .../neo4j/server/modules/RESTApiModule.java | 30 +++----------- .../server/rest/web/TransactionalService.java | 38 ++++++------------ .../org/neo4j/server/web/AsyncRequestLog.java | 4 +- .../core/BatchingMessageHandler.java | 29 +++++++------- .../core/ClusterBindingHandler.java | 13 +++--- .../core/RaftServerModule.java | 12 +++--- .../consensus/LeaderAvailabilityHandler.java | 15 ++++--- .../RaftMessageMonitoringHandler.java | 17 ++++---- .../consensus/RaftMessageNettyHandler.java | 10 ++--- .../core/consensus/RaftMessages.java | 6 +-- .../core/server/CoreServerModule.java | 2 +- .../core/state/CommandBatcher.java | 5 +-- .../core/state/RaftMessageApplier.java | 4 +- .../id/ReplicatedIdRangeAcquirer.java | 3 +- .../machines/locks/LeaderOnlyLockManager.java | 4 -- .../machines/token/ReplicatedTokenHolder.java | 3 +- .../ReplicatedTransactionCommitProcess.java | 5 --- .../messaging/ComposableMessageHandler.java | 4 +- .../core/BatchingMessageHandlerTest.java | 20 +++++----- .../core/ClusterBindingHandlerTest.java | 4 +- .../LeaderAvailabilityHandlerTest.java | 12 +++--- .../RaftMessageMonitoringHandlerTest.java | 4 +- .../RaftMessageEncodingDecodingTest.java | 4 +- .../scenarios/ReadReplicaReplicationIT.java | 4 -- .../test/java/org/neo4j/com/MadeUpServer.java | 15 +------ .../kernel/impl/ha/ParallelLifecycle.java | 2 +- .../org/neo4j/metrics/output/CsvOutput.java | 3 +- 39 files changed, 142 insertions(+), 280 deletions(-) diff --git a/community/bolt/src/main/java/org/neo4j/bolt/v1/messaging/Neo4jPack.java b/community/bolt/src/main/java/org/neo4j/bolt/v1/messaging/Neo4jPack.java index b0ab07d3b2206..367db96454203 100644 --- a/community/bolt/src/main/java/org/neo4j/bolt/v1/messaging/Neo4jPack.java +++ b/community/bolt/src/main/java/org/neo4j/bolt/v1/messaging/Neo4jPack.java @@ -35,34 +35,34 @@ public interface Neo4jPack { interface Packer { - void pack( String value ); + void pack( String value ) throws IOException; void pack( AnyValue value ) throws IOException; - void packStructHeader( int size, byte signature ); + void packStructHeader( int size, byte signature ) throws IOException; - void packMapHeader( int size ); + void packMapHeader( int size ) throws IOException; - void packListHeader( int size ); + void packListHeader( int size ) throws IOException; IOException consumeError(); - void flush(); + void flush() throws IOException; } interface Unpacker { AnyValue unpack() throws IOException; - String unpackString(); + String unpackString() throws IOException; MapValue unpackMap() throws IOException; - long unpackStructHeader(); + long unpackStructHeader() throws IOException; - char unpackStructSignature(); + char unpackStructSignature() throws IOException; - long unpackListHeader(); + long unpackListHeader() throws IOException; Neo4jError consumeError(); } diff --git a/community/bolt/src/main/java/org/neo4j/bolt/v1/messaging/Neo4jPackV1.java b/community/bolt/src/main/java/org/neo4j/bolt/v1/messaging/Neo4jPackV1.java index c956c3b8de665..d15a0ef4c308d 100644 --- a/community/bolt/src/main/java/org/neo4j/bolt/v1/messaging/Neo4jPackV1.java +++ b/community/bolt/src/main/java/org/neo4j/bolt/v1/messaging/Neo4jPackV1.java @@ -444,7 +444,6 @@ public void writeByteArray( byte[] value ) throws IOException private static class Unpacker extends PackStream.Unpacker implements Neo4jPack.Unpacker { - private List errors = new ArrayList<>( 2 ); Unpacker( PackInput input ) diff --git a/community/index/src/test/java/org/neo4j/index/internal/gbptree/SeekCursorTestBase.java b/community/index/src/test/java/org/neo4j/index/internal/gbptree/SeekCursorTestBase.java index 5ac75b060b82c..d96ff0f79e98d 100644 --- a/community/index/src/test/java/org/neo4j/index/internal/gbptree/SeekCursorTestBase.java +++ b/community/index/src/test/java/org/neo4j/index/internal/gbptree/SeekCursorTestBase.java @@ -1903,22 +1903,15 @@ public void shouldCatchupRootWhenNodeHasTooNewGenerationWhileTraversingDownTree( // a root catchup that records usage Supplier rootCatchup = () -> { - try - { - triggered.setTrue(); + triggered.setTrue(); - // and set child generation to match pointer - cursor.next( leftChild ); - cursor.zapPage(); - node.initializeLeaf( cursor, stableGeneration, unstableGeneration ); + // and set child generation to match pointer + cursor.next( leftChild ); + cursor.zapPage(); + node.initializeLeaf( cursor, stableGeneration, unstableGeneration ); - cursor.next( rootId ); - return new Root( rootId, generation ); - } - catch ( IOException e ) - { - throw new RuntimeException( e ); - } + cursor.next( rootId ); + return new Root( rootId, generation ); }; // when @@ -1950,17 +1943,10 @@ public void shouldCatchupRootWhenNodeHasTooNewGenerationWhileTraversingLeaves() Supplier rootCatchup = () -> { - try - { - // Use right child as new start over root to terminate test - cursor.next( rightChild ); - triggered.setTrue(); - return new Root( cursor.getCurrentPageId(), TreeNode.generation( cursor ) ); - } - catch ( IOException e ) - { - throw new RuntimeException( e ); - } + // Use right child as new start over root to terminate test + cursor.next( rightChild ); + triggered.setTrue(); + return new Root( cursor.getCurrentPageId(), TreeNode.generation( cursor ) ); }; // a left leaf @@ -2132,7 +2118,7 @@ private void checkpoint() unstableGeneration++; } - private void newRootFromSplit( StructurePropagation split ) throws IOException + private void newRootFromSplit( StructurePropagation split ) { assertTrue( split.hasRightKeyInsert ); long rootId = id.acquireNewId( stableGeneration, unstableGeneration ); @@ -2177,7 +2163,7 @@ private void remove( long key ) throws IOException handleAfterChange(); } - private void handleAfterChange() throws IOException + private void handleAfterChange() { if ( structurePropagation.hasRightKeyInsert ) { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java index 32da234c1e5ab..c73b2e6415126 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java @@ -59,7 +59,6 @@ import org.neo4j.kernel.api.exceptions.Status; import org.neo4j.kernel.api.exceptions.TransactionFailureException; import org.neo4j.kernel.api.exceptions.schema.CreateConstraintFailureException; -import org.neo4j.kernel.api.exceptions.schema.DropIndexFailureException; import org.neo4j.kernel.api.explicitindex.AutoIndexing; import org.neo4j.kernel.api.schema.index.IndexDescriptor; import org.neo4j.kernel.api.txstate.ExplicitIndexTransactionState; @@ -160,7 +159,7 @@ public class KernelTransactionImplementation implements KernelTransaction, TxSta private Type type; private long transactionId; private long commitTime; - private volatile int reuseCount; + private volatile int reuseCount; // TODO: why volatile? private volatile Map userMetaData; private final Operations operations; @@ -395,16 +394,8 @@ private void dropCreatedConstraintIndexes() throws TransactionFailureException { for ( IndexDescriptor createdConstraintIndex : txState().constraintIndexesCreatedInTx() ) { - try - { - // TODO logically, which statement should this operation be performed on? - constraintIndexCreator.dropUniquenessConstraintIndex( createdConstraintIndex ); - } - catch ( DropIndexFailureException e ) - { - throw new IllegalStateException( "Constraint index that was created in a transaction should be " + - "possible to drop during rollback of that transaction.", e ); - } + // TODO logically, which statement should this operation be performed on? + constraintIndexCreator.dropUniquenessConstraintIndex( createdConstraintIndex ); } } } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/coreapi/schema/NodePropertyUniqueConstraintCreator.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/coreapi/schema/NodePropertyUniqueConstraintCreator.java index 3e8dfb8a1cae9..447a618d933f4 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/coreapi/schema/NodePropertyUniqueConstraintCreator.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/coreapi/schema/NodePropertyUniqueConstraintCreator.java @@ -21,10 +21,8 @@ import java.util.ArrayList; -import org.neo4j.graphdb.ConstraintViolationException; import org.neo4j.graphdb.Label; import org.neo4j.graphdb.schema.ConstraintDefinition; -import org.neo4j.internal.kernel.api.exceptions.KernelException; public class NodePropertyUniqueConstraintCreator extends BaseNodeConstraintCreator { @@ -47,17 +45,9 @@ public final ConstraintDefinition create() { assertInUnterminatedTransaction(); - try - { - IndexDefinitionImpl definition = - new IndexDefinitionImpl( actions, label, propertyKeys.toArray( new String[propertyKeys.size()] ), - true ); - return actions.createPropertyUniquenessConstraint( definition ); - } - catch ( KernelException e ) - { - String userMessage = actions.getUserMessage( e ); - throw new ConstraintViolationException( userMessage, e ); - } + IndexDefinitionImpl definition = + new IndexDefinitionImpl( actions, label, propertyKeys.toArray( new String[propertyKeys.size()] ), + true ); + return actions.createPropertyUniquenessConstraint( definition ); } } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/locking/community/CommunityLockClient.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/locking/community/CommunityLockClient.java index b9feb619ceff4..51b2543d40459 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/locking/community/CommunityLockClient.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/locking/community/CommunityLockClient.java @@ -68,25 +68,25 @@ public CommunityLockClient( LockManagerImpl manager ) { this.manager = manager; - readReleaser = ( long key, LockResource lockResource ) -> + readReleaser = ( key, lockResource ) -> { manager.releaseReadLock( lockResource, lockTransaction ); return false; }; - writeReleaser = ( long key, LockResource lockResource ) -> + writeReleaser = ( key, lockResource ) -> { manager.releaseWriteLock( lockResource, lockTransaction ); return false; }; - typeReadReleaser = ( int key, PrimitiveLongObjectMap value ) -> + typeReadReleaser = ( key, value ) -> { value.visitEntries( readReleaser ); return false; }; - typeWriteReleaser = ( int key, PrimitiveLongObjectMap value ) -> + typeWriteReleaser = ( key, value ) -> { value.visitEntries( writeReleaser ); return false; diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContextFactory.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContextFactory.java index c21743c397896..b62fa27b98db4 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContextFactory.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContextFactory.java @@ -48,7 +48,7 @@ public static TransactionalContextFactory create( { Supplier queryService = lazySingleton( spi::queryService ); Neo4jTransactionalContext.Creator contextCreator = - ( Supplier statementSupplier, InternalTransaction tx, Statement initialStatement, ExecutingQuery executingQuery ) -> + ( statementSupplier, tx, initialStatement, executingQuery ) -> new Neo4jTransactionalContext( queryService.get(), statementSupplier, @@ -72,7 +72,7 @@ public static TransactionalContextFactory create( ThreadToStatementContextBridge txBridge = resolver.resolveDependency( ThreadToStatementContextBridge.class ); Guard guard = resolver.resolveDependency( Guard.class ); Neo4jTransactionalContext.Creator contextCreator = - ( Supplier statementSupplier, InternalTransaction tx, Statement initialStatement, ExecutingQuery executingQuery ) -> + ( statementSupplier, tx, initialStatement, executingQuery ) -> new Neo4jTransactionalContext( queryService, statementSupplier, diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/participant/StoreMigrator.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/participant/StoreMigrator.java index 80375375b8a94..3a5d933f80df1 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/participant/StoreMigrator.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/participant/StoreMigrator.java @@ -614,8 +614,7 @@ private BiConsumer p } final StorePropertyCursor cursor = new StorePropertyCursor( cursors, ignored -> {} ); - return ( InputEntityVisitor entity, RECORD record ) -> - { + return ( entity, record ) -> { cursor.init( record.getNextProp(), LockService.NO_LOCK, AssertOpen.ALWAYS_OPEN ); while ( cursor.next() ) { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/spi/explicitindex/IndexImplementation.java b/community/kernel/src/main/java/org/neo4j/kernel/spi/explicitindex/IndexImplementation.java index 26b036da1cefd..10178dc3d291d 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/spi/explicitindex/IndexImplementation.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/spi/explicitindex/IndexImplementation.java @@ -82,28 +82,4 @@ public interface IndexImplementation extends Lifecycle * @throws IOException depends on the implementation */ ResourceIterator listStoreFiles() throws IOException; - - /** - * Makes available index resource for recovery. - */ - @Override - void init(); - - /** - * Makes available index resource for online transaction processing. - */ - @Override - void start() throws Throwable; - - /** - * Makes unavailable index resource from online transaction processing. - */ - @Override - void stop() throws Throwable; - - /** - * Makes unavailable the index resource as a whole. - */ - @Override - void shutdown() throws Throwable; } diff --git a/community/kernel/src/main/java/org/neo4j/unsafe/impl/batchimport/input/BadCollector.java b/community/kernel/src/main/java/org/neo4j/unsafe/impl/batchimport/input/BadCollector.java index 18ab8bf521fe7..38c7ac3d344e3 100644 --- a/community/kernel/src/main/java/org/neo4j/unsafe/impl/batchimport/input/BadCollector.java +++ b/community/kernel/src/main/java/org/neo4j/unsafe/impl/batchimport/input/BadCollector.java @@ -150,10 +150,6 @@ public void close() { logger.awaitTermination(); } - catch ( InterruptedException e ) - { - Thread.currentThread().interrupt(); - } finally { out.flush(); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/index/inmemory/HashBasedIndex.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/index/inmemory/HashBasedIndex.java index 8a3715b88f91f..8397afdca8af4 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/index/inmemory/HashBasedIndex.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/index/inmemory/HashBasedIndex.java @@ -150,17 +150,17 @@ private synchronized PrimitiveLongResourceIterator rangeSeekByString( String low private synchronized PrimitiveLongResourceIterator rangeSeekByPrefix( String prefix ) { - return stringSearch( ( String entry ) -> entry.startsWith( prefix ) ); + return stringSearch( entry -> entry.startsWith( prefix ) ); } private synchronized PrimitiveLongResourceIterator containsString( String exactTerm ) { - return stringSearch( ( String entry ) -> entry.contains( exactTerm ) ); + return stringSearch( entry -> entry.contains( exactTerm ) ); } private PrimitiveLongResourceIterator endsWith( String suffix ) { - return stringSearch( ( String entry ) -> entry.endsWith( suffix ) ); + return stringSearch( entry -> entry.endsWith( suffix ) ); } private synchronized PrimitiveLongResourceIterator scan() diff --git a/community/primitive-collections/src/test/java/org/neo4j/concurrent/AsyncEventsTest.java b/community/primitive-collections/src/test/java/org/neo4j/concurrent/AsyncEventsTest.java index e35e60f44b54d..3f5a8a2f640e4 100644 --- a/community/primitive-collections/src/test/java/org/neo4j/concurrent/AsyncEventsTest.java +++ b/community/primitive-collections/src/test/java/org/neo4j/concurrent/AsyncEventsTest.java @@ -214,14 +214,7 @@ public void awaitingShutdownMustBlockUntilAllMessagesHaveBeenProcessed() throws Future awaitShutdownFuture = executor.submit( () -> { awaitStartLatch.countDown(); - try - { - asyncEvents.awaitTermination(); - } - catch ( InterruptedException e ) - { - throw new RuntimeException( e ); - } + asyncEvents.awaitTermination(); consumer.eventsProcessed.offer( specialShutdownObservedEvent ); } ); diff --git a/community/server/src/main/java/org/neo4j/server/modules/RESTApiModule.java b/community/server/src/main/java/org/neo4j/server/modules/RESTApiModule.java index 64b562a8f47a3..efeaf21f4b537 100644 --- a/community/server/src/main/java/org/neo4j/server/modules/RESTApiModule.java +++ b/community/server/src/main/java/org/neo4j/server/modules/RESTApiModule.java @@ -20,13 +20,11 @@ package org.neo4j.server.modules; import java.net.URI; -import java.net.URISyntaxException; import java.util.List; import org.neo4j.concurrent.RecentK; import org.neo4j.graphdb.DependencyResolver; import org.neo4j.kernel.configuration.Config; -import org.neo4j.logging.Log; import org.neo4j.logging.LogProvider; import org.neo4j.server.configuration.ServerSettings; import org.neo4j.server.plugins.PluginManager; @@ -53,7 +51,6 @@ public class RESTApiModule implements ServerModule private final WebServer webServer; private DependencyResolver dependencyResolver; private final LogProvider logProvider; - private final Log log; private PluginManager plugins; @@ -64,24 +61,16 @@ public RESTApiModule( WebServer webServer, Config config, DependencyResolver dep this.config = config; this.dependencyResolver = dependencyResolver; this.logProvider = logProvider; - this.log = logProvider.getLog( getClass() ); } @Override public void start() { - try - { - URI restApiUri = restApiUri( ); + URI restApiUri = restApiUri( ); - webServer.addFilter( new CollectUserAgentFilter( clientNames() ), "/*" ); - webServer.addJAXRSClasses( getClassNames(), restApiUri.toString(), null ); - loadPlugins(); - } - catch ( URISyntaxException e ) - { - log.warn( "Unable to mount REST API", e ); - } + webServer.addFilter( new CollectUserAgentFilter( clientNames() ), "/*" ); + webServer.addJAXRSClasses( getClassNames(), restApiUri.toString(), null ); + loadPlugins(); } /** @@ -111,15 +100,8 @@ private List getClassNames() @Override public void stop() { - try - { - webServer.removeJAXRSClasses( getClassNames(), restApiUri().toString() ); - unloadPlugins(); - } - catch ( URISyntaxException e ) - { - log.warn( "Unable to unmount REST API", e ); - } + webServer.removeJAXRSClasses( getClassNames(), restApiUri().toString() ); + unloadPlugins(); } private URI restApiUri() diff --git a/community/server/src/main/java/org/neo4j/server/rest/web/TransactionalService.java b/community/server/src/main/java/org/neo4j/server/rest/web/TransactionalService.java index 15d6bc7b6ce35..770d1735a1ba9 100644 --- a/community/server/src/main/java/org/neo4j/server/rest/web/TransactionalService.java +++ b/community/server/src/main/java/org/neo4j/server/rest/web/TransactionalService.java @@ -80,22 +80,15 @@ public TransactionalService( @Context TransactionFacade facade, @Context UriInfo public Response executeStatementsInNewTransaction( final InputStream input, @Context final UriInfo uriInfo, @Context final HttpServletRequest request ) { - try - { - usage.get( features ).flag( http_tx_endpoint ); - LoginContext loginContext = AuthorizedRequestWrapper.getLoginContextFromHttpServletRequest( request ); - long customTransactionTimeout = HttpHeaderUtils.getTransactionTimeout( request, log ); - TransactionHandle transactionHandle = - facade.newTransactionHandle( uriScheme, false, loginContext, customTransactionTimeout ); - return createdResponse( - transactionHandle, - executeStatements( input, transactionHandle, uriInfo.getBaseUri(), request ) - ); - } - catch ( TransactionLifecycleException e ) - { - return invalidTransaction( e, uriInfo.getBaseUri() ); - } + usage.get( features ).flag( http_tx_endpoint ); + LoginContext loginContext = AuthorizedRequestWrapper.getLoginContextFromHttpServletRequest( request ); + long customTransactionTimeout = HttpHeaderUtils.getTransactionTimeout( request, log ); + TransactionHandle transactionHandle = + facade.newTransactionHandle( uriScheme, false, loginContext, customTransactionTimeout ); + return createdResponse( + transactionHandle, + executeStatements( input, transactionHandle, uriInfo.getBaseUri(), request ) + ); } @POST @@ -145,16 +138,9 @@ public Response commitNewTransaction( final InputStream input, @Context final Ur @Context final HttpServletRequest request ) { final TransactionHandle transactionHandle; - try - { - LoginContext loginContext = AuthorizedRequestWrapper.getLoginContextFromHttpServletRequest( request ); - long customTransactionTimeout = HttpHeaderUtils.getTransactionTimeout( request, log ); - transactionHandle = facade.newTransactionHandle( uriScheme, true, loginContext, customTransactionTimeout ); - } - catch ( TransactionLifecycleException e ) - { - return invalidTransaction( e, uriInfo.getBaseUri() ); - } + LoginContext loginContext = AuthorizedRequestWrapper.getLoginContextFromHttpServletRequest( request ); + long customTransactionTimeout = HttpHeaderUtils.getTransactionTimeout( request, log ); + transactionHandle = facade.newTransactionHandle( uriScheme, true, loginContext, customTransactionTimeout ); final StreamingOutput streamingResults = executeStatementsAndCommit( input, transactionHandle, uriInfo.getBaseUri(), request ); return okResponse( streamingResults ); diff --git a/community/server/src/main/java/org/neo4j/server/web/AsyncRequestLog.java b/community/server/src/main/java/org/neo4j/server/web/AsyncRequestLog.java index e17803b0561ae..f0f6a1831aaef 100644 --- a/community/server/src/main/java/org/neo4j/server/web/AsyncRequestLog.java +++ b/community/server/src/main/java/org/neo4j/server/web/AsyncRequestLog.java @@ -80,8 +80,8 @@ public void log( Request request, Response response ) swallowExceptions( request, HttpServletRequest::getQueryString ); int statusCode = response.getStatus(); long length = response.getContentLength(); - String referer = swallowExceptions( request, ( HttpServletRequest r ) -> r.getHeader( "Referer" ) ); - String userAgent = swallowExceptions( request, ( HttpServletRequest r ) -> r.getHeader( "User-Agent" ) ); + String referer = swallowExceptions( request, r -> r.getHeader( "Referer" ) ); + String userAgent = swallowExceptions( request, r -> r.getHeader( "User-Agent" ) ); long requestTimeStamp = request != null ? request.getTimeStamp() : -1; long now = System.currentTimeMillis(); long serviceTime = requestTimeStamp < 0 ? -1 : now - requestTimeStamp; diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/BatchingMessageHandler.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/BatchingMessageHandler.java index 68bb9f9ae5e60..0b7e72ba0c3a7 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/BatchingMessageHandler.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/BatchingMessageHandler.java @@ -30,27 +30,27 @@ import org.neo4j.causalclustering.core.consensus.RaftMessages; import org.neo4j.causalclustering.core.replication.ReplicatedContent; import org.neo4j.causalclustering.identity.ClusterId; -import org.neo4j.causalclustering.messaging.LifecycleMessageHandler; import org.neo4j.causalclustering.messaging.ComposableMessageHandler; +import org.neo4j.causalclustering.messaging.LifecycleMessageHandler; import org.neo4j.logging.Log; import org.neo4j.logging.LogProvider; import static java.util.concurrent.TimeUnit.SECONDS; import static org.neo4j.function.Predicates.awaitForever; -class BatchingMessageHandler implements Runnable, LifecycleMessageHandler +class BatchingMessageHandler implements Runnable, LifecycleMessageHandler> { - private final LifecycleMessageHandler handler; + private final LifecycleMessageHandler> handler; private final Log log; private final int maxBatch; - private final List batch; - private final BlockingQueue messageQueue; + private final List> batch; + private final BlockingQueue> messageQueue; private final ContinuousJob job; private final ContentHandler contentHandler = new ContentHandler(); private volatile boolean stopped; - BatchingMessageHandler( LifecycleMessageHandler handler, int queueSize, int maxBatch, + BatchingMessageHandler( LifecycleMessageHandler> handler, int queueSize, int maxBatch, Function jobSchedulerFactory, LogProvider logProvider ) { this.handler = handler; @@ -63,8 +63,7 @@ class BatchingMessageHandler implements Runnable, LifecycleMessageHandler jobSchedulerFactory, LogProvider logProvider ) { - return ( LifecycleMessageHandler delegate ) -> - new BatchingMessageHandler( delegate, queueSize, maxBatch, jobSchedulerFactory, logProvider ); + return delegate -> new BatchingMessageHandler( delegate, queueSize, maxBatch, jobSchedulerFactory, logProvider ); } @Override public void start( ClusterId clusterId ) throws Throwable @@ -82,7 +81,7 @@ public void stop() throws Throwable } @Override - public void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage message ) + public void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage message ) { if ( stopped ) { @@ -97,7 +96,7 @@ public void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage message ) @Override public void run() { - RaftMessages.ReceivedInstantClusterIdAwareMessage message = null; + RaftMessages.ReceivedInstantClusterIdAwareMessage message = null; try { message = messageQueue.poll( 1, SECONDS ); @@ -123,19 +122,19 @@ public void run() } } - private void drain( BlockingQueue messageQueue, - List batch, int maxElements ) + private void drain( BlockingQueue> messageQueue, + List> batch, int maxElements ) { - List tempDraining = new ArrayList<>(); + List> tempDraining = new ArrayList<>(); messageQueue.drainTo( tempDraining, maxElements ); batch.addAll( tempDraining ); } - private void collateAndHandleBatch( List batch ) + private void collateAndHandleBatch( List> batch ) { RaftMessages.ReceivedInstantClusterIdAwareMessage batchRequest = null; - for ( RaftMessages.ReceivedInstantClusterIdAwareMessage message : batch ) + for ( RaftMessages.ReceivedInstantClusterIdAwareMessage message : batch ) { if ( batchRequest != null && !message.clusterId().equals( batchRequest.clusterId() ) ) { diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/ClusterBindingHandler.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/ClusterBindingHandler.java index abe11935a100e..e377978243b06 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/ClusterBindingHandler.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/ClusterBindingHandler.java @@ -23,18 +23,18 @@ import org.neo4j.causalclustering.core.consensus.RaftMessages; import org.neo4j.causalclustering.identity.ClusterId; -import org.neo4j.causalclustering.messaging.LifecycleMessageHandler; import org.neo4j.causalclustering.messaging.ComposableMessageHandler; +import org.neo4j.causalclustering.messaging.LifecycleMessageHandler; import org.neo4j.logging.Log; import org.neo4j.logging.LogProvider; -public class ClusterBindingHandler implements LifecycleMessageHandler +public class ClusterBindingHandler implements LifecycleMessageHandler> { - private final LifecycleMessageHandler delegateHandler; + private final LifecycleMessageHandler> delegateHandler; private volatile ClusterId boundClusterId; private final Log log; - public ClusterBindingHandler( LifecycleMessageHandler delegateHandler, LogProvider logProvider ) + public ClusterBindingHandler( LifecycleMessageHandler> delegateHandler, LogProvider logProvider ) { this.delegateHandler = delegateHandler; log = logProvider.getLog( getClass() ); @@ -42,8 +42,7 @@ public ClusterBindingHandler( LifecycleMessageHandler delegate ) -> - new ClusterBindingHandler( delegate, logProvider ); + return delegate -> new ClusterBindingHandler( delegate, logProvider ); } @Override @@ -61,7 +60,7 @@ public void stop() throws Throwable } @Override - public void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage message ) + public void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage message ) { if ( Objects.isNull( boundClusterId ) ) { diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/RaftServerModule.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/RaftServerModule.java index 167af1456bf70..0a0267725be56 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/RaftServerModule.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/RaftServerModule.java @@ -70,12 +70,12 @@ class RaftServerModule this.logProvider = platformModule.logging.getInternalLogProvider(); this.pipelineBuilderFactory = pipelineBuilderFactory; - LifecycleMessageHandler messageHandlerChain = createMessageHandlerChain( coreServerModule ); + LifecycleMessageHandler> messageHandlerChain = createMessageHandlerChain( coreServerModule ); createRaftServer( coreServerModule, messageHandlerChain ); } - private void createRaftServer( CoreServerModule coreServerModule, LifecycleMessageHandler messageHandlerChain ) + private void createRaftServer( CoreServerModule coreServerModule, LifecycleMessageHandler> messageHandlerChain ) { ProtocolRepository protocolRepository = new ProtocolRepository( Protocol.Protocols.values() ); @@ -89,8 +89,8 @@ private void createRaftServer( CoreServerModule coreServerModule, LifecycleMessa RaftServer raftServer = new RaftServer( handshakeServerInitializer, platformModule.config, logProvider, platformModule.logging.getUserLogProvider() ); - LoggingInbound loggingRaftInbound = new LoggingInbound<>( nettyHandler, - messageLogger, identityModule.myself() ); + LoggingInbound> loggingRaftInbound = + new LoggingInbound<>( nettyHandler, messageLogger, identityModule.myself() ); loggingRaftInbound.registerHandler( messageHandlerChain ); platformModule.life.add( raftServer ); // must start before core state so that it can trigger snapshot downloads when necessary @@ -99,7 +99,7 @@ private void createRaftServer( CoreServerModule coreServerModule, LifecycleMessa platformModule.life.add( coreServerModule.downloadService() ); } - private LifecycleMessageHandler createMessageHandlerChain( CoreServerModule coreServerModule ) + private LifecycleMessageHandler> createMessageHandlerChain( CoreServerModule coreServerModule ) { RaftMessageApplier messageApplier = new RaftMessageApplier( localDatabase, logProvider, consensusModule.raftMachine(), coreServerModule.downloadService(), coreServerModule.commandApplicationProcess() ); @@ -108,7 +108,7 @@ private LifecycleMessageHandler createMess int queueSize = platformModule.config.get( CausalClusteringSettings.raft_in_queue_size ); int maxBatch = platformModule.config.get( CausalClusteringSettings.raft_in_queue_max_batch ); - Function jobFactory = ( Runnable runnable ) -> + Function jobFactory = runnable -> new ContinuousJob( platformModule.jobScheduler.threadFactory( new JobScheduler.Group( "raft-batch-handler" ) ), runnable, logProvider ); ComposableMessageHandler batchingMessageHandler = BatchingMessageHandler.composable( queueSize, maxBatch, jobFactory, logProvider ); diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/LeaderAvailabilityHandler.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/LeaderAvailabilityHandler.java index 55046f00c3e9a..9d89aed6087bb 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/LeaderAvailabilityHandler.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/LeaderAvailabilityHandler.java @@ -22,16 +22,16 @@ import java.util.function.LongSupplier; import org.neo4j.causalclustering.identity.ClusterId; -import org.neo4j.causalclustering.messaging.LifecycleMessageHandler; import org.neo4j.causalclustering.messaging.ComposableMessageHandler; +import org.neo4j.causalclustering.messaging.LifecycleMessageHandler; -public class LeaderAvailabilityHandler implements LifecycleMessageHandler +public class LeaderAvailabilityHandler implements LifecycleMessageHandler> { - private final LifecycleMessageHandler delegateHandler; + private final LifecycleMessageHandler> delegateHandler; private final LeaderAvailabilityTimers leaderAvailabilityTimers; private final ShouldRenewElectionTimeout shouldRenewElectionTimeout; - public LeaderAvailabilityHandler( LifecycleMessageHandler delegateHandler, + public LeaderAvailabilityHandler( LifecycleMessageHandler> delegateHandler, LeaderAvailabilityTimers leaderAvailabilityTimers, LongSupplier term ) { this.delegateHandler = delegateHandler; @@ -41,8 +41,7 @@ public LeaderAvailabilityHandler( LifecycleMessageHandler delegate ) -> - new LeaderAvailabilityHandler( delegate, leaderAvailabilityTimers, term ); + return delegate -> new LeaderAvailabilityHandler( delegate, leaderAvailabilityTimers, term ); } @Override @@ -58,13 +57,13 @@ public synchronized void stop() throws Throwable } @Override - public void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage message ) + public void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage message ) { handleTimeouts( message ); delegateHandler.handle( message ); } - private void handleTimeouts( RaftMessages.ReceivedInstantClusterIdAwareMessage message ) + private void handleTimeouts( RaftMessages.ReceivedInstantClusterIdAwareMessage message ) { if ( message.dispatch( shouldRenewElectionTimeout ) ) { diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessageMonitoringHandler.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessageMonitoringHandler.java index 2eff3ce41e6b8..b4ed80a7647cb 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessageMonitoringHandler.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessageMonitoringHandler.java @@ -24,17 +24,17 @@ import java.time.Instant; import org.neo4j.causalclustering.identity.ClusterId; -import org.neo4j.causalclustering.messaging.LifecycleMessageHandler; import org.neo4j.causalclustering.messaging.ComposableMessageHandler; +import org.neo4j.causalclustering.messaging.LifecycleMessageHandler; import org.neo4j.kernel.monitoring.Monitors; -public class RaftMessageMonitoringHandler implements LifecycleMessageHandler +public class RaftMessageMonitoringHandler implements LifecycleMessageHandler> { - private final LifecycleMessageHandler raftMessageHandler; + private final LifecycleMessageHandler> raftMessageHandler; private final Clock clock; private final RaftMessageProcessingMonitor raftMessageDelayMonitor; - public RaftMessageMonitoringHandler( LifecycleMessageHandler raftMessageHandler, + public RaftMessageMonitoringHandler( LifecycleMessageHandler> raftMessageHandler, Clock clock, Monitors monitors ) { this.raftMessageHandler = raftMessageHandler; @@ -44,12 +44,11 @@ public RaftMessageMonitoringHandler( LifecycleMessageHandler delegate ) -> - new RaftMessageMonitoringHandler( delegate, clock, monitors ); + return delegate -> new RaftMessageMonitoringHandler( delegate, clock, monitors ); } @Override - public synchronized void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage incomingMessage ) + public synchronized void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage incomingMessage ) { Instant start = clock.instant(); @@ -58,7 +57,7 @@ public synchronized void handle( RaftMessages.ReceivedInstantClusterIdAwareMessa timeHandle( incomingMessage, start ); } - private void timeHandle( RaftMessages.ReceivedInstantClusterIdAwareMessage incomingMessage, Instant start ) + private void timeHandle( RaftMessages.ReceivedInstantClusterIdAwareMessage incomingMessage, Instant start ) { try { @@ -71,7 +70,7 @@ private void timeHandle( RaftMessages.ReceivedInstantClusterIdAwareMessage incom } } - private void logDelay( RaftMessages.ReceivedInstantClusterIdAwareMessage incomingMessage, Instant start ) + private void logDelay( RaftMessages.ReceivedInstantClusterIdAwareMessage incomingMessage, Instant start ) { Duration delay = Duration.between( incomingMessage.receivedAt(), start ); diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessageNettyHandler.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessageNettyHandler.java index bcabf2a8fea01..b741efa554275 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessageNettyHandler.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessageNettyHandler.java @@ -30,10 +30,10 @@ import static java.lang.String.format; @ChannelHandler.Sharable -public class RaftMessageNettyHandler extends SimpleChannelInboundHandler - implements Inbound +public class RaftMessageNettyHandler extends SimpleChannelInboundHandler> + implements Inbound> { - private Inbound.MessageHandler actual; + private Inbound.MessageHandler> actual; private Log log; public RaftMessageNettyHandler( LogProvider logProvider ) @@ -42,13 +42,13 @@ public RaftMessageNettyHandler( LogProvider logProvider ) } @Override - public void registerHandler( Inbound.MessageHandler actual ) + public void registerHandler( Inbound.MessageHandler> actual ) { this.actual = actual; } @Override - protected void channelRead0( ChannelHandlerContext channelHandlerContext, RaftMessages.ReceivedInstantClusterIdAwareMessage incomingMessage ) + protected void channelRead0( ChannelHandlerContext channelHandlerContext, RaftMessages.ReceivedInstantClusterIdAwareMessage incomingMessage ) { try { diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessages.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessages.java index 7740e67d6b773..71c928fb0c43c 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessages.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/consensus/RaftMessages.java @@ -1030,7 +1030,7 @@ public boolean equals( Object o ) { return false; } - ClusterIdAwareMessageImpl that = (ClusterIdAwareMessageImpl) o; + ClusterIdAwareMessageImpl that = (ClusterIdAwareMessageImpl) o; return Objects.equals( clusterId, that.clusterId ) && Objects.equals( message(), that.message() ); } @@ -1082,7 +1082,7 @@ public boolean equals( Object o ) { return false; } - ReceivedInstantAwareMessageImpl that = (ReceivedInstantAwareMessageImpl) o; + ReceivedInstantAwareMessageImpl that = (ReceivedInstantAwareMessageImpl) o; return Objects.equals( receivedAt, that.receivedAt ) && Objects.equals( message(), that.message() ); } @@ -1142,7 +1142,7 @@ public boolean equals( Object o ) { return false; } - ReceivedInstantClusterIdAwareMessageImpl that = (ReceivedInstantClusterIdAwareMessageImpl) o; + ReceivedInstantClusterIdAwareMessageImpl that = (ReceivedInstantClusterIdAwareMessageImpl) o; return Objects.equals( receivedAt, that.receivedAt ) && Objects.equals( clusterId, that.clusterId ) && Objects.equals( message(), that.message() ); } diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/server/CoreServerModule.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/server/CoreServerModule.java index 25a0f7a0f394d..e82bf675ed1f5 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/server/CoreServerModule.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/server/CoreServerModule.java @@ -209,7 +209,7 @@ public CatchupServer catchupServer() return catchupServer; } - public CoreLife createCoreLife( LifecycleMessageHandler handler ) + public CoreLife createCoreLife( LifecycleMessageHandler> handler ) { return new CoreLife( consensusModule.raftMachine(), localDatabase, clusteringModule.clusterBinder(), commandApplicationProcess, coreStateMachinesModule.coreStateMachines, diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/CommandBatcher.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/CommandBatcher.java index 74b696e695db6..f17c36f78b632 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/CommandBatcher.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/CommandBatcher.java @@ -41,10 +41,7 @@ class CommandBatcher void add( long index, DistributedOperation operation ) throws Exception { - if ( batch.size() > 0 ) - { - assert index == (lastIndex + 1); - } + assert batch.size() <= 0 || index == (lastIndex + 1); batch.add( operation ); lastIndex = index; diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/RaftMessageApplier.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/RaftMessageApplier.java index ffbb05a8cee22..c863c948c5708 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/RaftMessageApplier.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/RaftMessageApplier.java @@ -29,7 +29,7 @@ import org.neo4j.logging.Log; import org.neo4j.logging.LogProvider; -public class RaftMessageApplier implements LifecycleMessageHandler +public class RaftMessageApplier implements LifecycleMessageHandler> { private final LocalDatabase localDatabase; private final Log log; @@ -49,7 +49,7 @@ public RaftMessageApplier( LocalDatabase localDatabase, LogProvider logProvider, } @Override - public synchronized void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage wrappedMessage ) + public synchronized void handle( RaftMessages.ReceivedInstantClusterIdAwareMessage wrappedMessage ) { try { diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/id/ReplicatedIdRangeAcquirer.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/id/ReplicatedIdRangeAcquirer.java index 73b96915c886d..804db9f6e2c3c 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/id/ReplicatedIdRangeAcquirer.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/id/ReplicatedIdRangeAcquirer.java @@ -22,7 +22,6 @@ import java.util.Map; import java.util.concurrent.ExecutionException; -import org.neo4j.causalclustering.core.consensus.NoLeaderFoundException; import org.neo4j.causalclustering.core.replication.Replicator; import org.neo4j.causalclustering.identity.MemberId; import org.neo4j.kernel.impl.store.id.IdRange; @@ -83,7 +82,7 @@ private boolean replicateIdAllocationRequest( IdType idType, ReplicatedIdAllocat { return (Boolean) replicator.replicate( idAllocationRequest, true ).get(); } - catch ( InterruptedException | ExecutionException | NoLeaderFoundException e ) + catch ( InterruptedException | ExecutionException e ) { log.error( format( "Failed to acquire id range for idType %s", idType ), e ); throw new IdGenerationException( e ); diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/locks/LeaderOnlyLockManager.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/locks/LeaderOnlyLockManager.java index 199323d61130d..ce810cd733aaf 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/locks/LeaderOnlyLockManager.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/locks/LeaderOnlyLockManager.java @@ -115,10 +115,6 @@ private synchronized int acquireTokenOrThrow() { throw new AcquireLockTimeoutException( e, "Interrupted acquiring token.", Interrupted ); } - catch ( NoLeaderFoundException e ) - { - throw new AcquireLockTimeoutException( e, "Could not acquire lock token because no leader was found.", NoLeaderAvailable ); - } try { diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/token/ReplicatedTokenHolder.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/token/ReplicatedTokenHolder.java index 6dc3f3a40c6a3..9407a1ffd6f44 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/token/ReplicatedTokenHolder.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/token/ReplicatedTokenHolder.java @@ -25,7 +25,6 @@ import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; -import org.neo4j.causalclustering.core.consensus.NoLeaderFoundException; import org.neo4j.causalclustering.core.replication.Replicator; import org.neo4j.internal.kernel.api.exceptions.schema.ConstraintValidationException; import org.neo4j.kernel.api.exceptions.TransactionFailureException; @@ -99,7 +98,7 @@ private int requestToken( String tokenName ) Future future = replicator.replicate( tokenRequest, true ); return (int) future.get(); } - catch ( InterruptedException | NoLeaderFoundException e ) + catch ( InterruptedException e ) { throw new org.neo4j.graphdb.TransactionFailureException( "Could not create token", e ); } diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/tx/ReplicatedTransactionCommitProcess.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/tx/ReplicatedTransactionCommitProcess.java index 491cb0d54df87..dd27dc8852a32 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/tx/ReplicatedTransactionCommitProcess.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/core/state/machines/tx/ReplicatedTransactionCommitProcess.java @@ -22,7 +22,6 @@ import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; -import org.neo4j.causalclustering.core.consensus.NoLeaderFoundException; import org.neo4j.causalclustering.core.replication.Replicator; import org.neo4j.kernel.api.exceptions.TransactionFailureException; import org.neo4j.kernel.impl.api.TransactionCommitProcess; @@ -56,10 +55,6 @@ public long commit( final TransactionToApply tx, { throw new TransactionFailureException( "Interrupted replicating transaction.", e ); } - catch ( NoLeaderFoundException e ) - { - throw new TransactionFailureException( "No leader found while replicating transaction.", e ); - } try { diff --git a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/messaging/ComposableMessageHandler.java b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/messaging/ComposableMessageHandler.java index 76ea78fcdc664..ca2e6690dd40b 100644 --- a/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/messaging/ComposableMessageHandler.java +++ b/enterprise/causal-clustering/src/main/java/org/neo4j/causalclustering/messaging/ComposableMessageHandler.java @@ -25,7 +25,7 @@ @FunctionalInterface public interface ComposableMessageHandler - extends Function, LifecycleMessageHandler> + extends Function>, LifecycleMessageHandler>> { - LifecycleMessageHandler apply( LifecycleMessageHandler messageHandler ); + LifecycleMessageHandler> apply( LifecycleMessageHandler> messageHandler ); } diff --git a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/BatchingMessageHandlerTest.java b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/BatchingMessageHandlerTest.java index 33ddc7c5d5001..a415047d0ee4d 100644 --- a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/BatchingMessageHandlerTest.java +++ b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/BatchingMessageHandlerTest.java @@ -50,10 +50,10 @@ public class BatchingMessageHandlerTest private static final int QUEUE_SIZE = 64; private final Instant now = Instant.now(); @SuppressWarnings( "unchecked" ) - private LifecycleMessageHandler downstreamHandler = mock( LifecycleMessageHandler.class ); + private LifecycleMessageHandler> downstreamHandler = mock( LifecycleMessageHandler.class ); private ClusterId localClusterId = new ClusterId( UUID.randomUUID() ); private ContinuousJob mockJob = mock( ContinuousJob.class ); - private Function jobSchedulerFactory = ( Runnable ignored ) -> mockJob; + private Function jobSchedulerFactory = ignored -> mockJob; @Test public void shouldInvokeInnerHandlerWhenRun() @@ -62,7 +62,7 @@ public void shouldInvokeInnerHandlerWhenRun() BatchingMessageHandler batchHandler = new BatchingMessageHandler( downstreamHandler, QUEUE_SIZE, MAX_BATCH, jobSchedulerFactory, NullLogProvider.getInstance() ); - RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( + RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, new RaftMessages.NewEntry.Request( null, null ) ); batchHandler.handle( message ); verifyZeroInteractions( downstreamHandler ); @@ -80,7 +80,7 @@ public void shouldInvokeHandlerOnQueuedMessage() throws Throwable // given BatchingMessageHandler batchHandler = new BatchingMessageHandler( downstreamHandler, QUEUE_SIZE, MAX_BATCH, jobSchedulerFactory, NullLogProvider.getInstance() ); - RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, + RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, new RaftMessages.NewEntry.Request( null, null ) ); ExecutorService executor = Executors.newCachedThreadPool(); @@ -160,13 +160,13 @@ public void shouldBatchNewEntriesAndHandleOtherMessagesSingularly() ReplicatedString contentA = new ReplicatedString( "A" ); ReplicatedString contentC = new ReplicatedString( "C" ); - RaftMessages.ReceivedInstantClusterIdAwareMessage messageA = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, + RaftMessages.ReceivedInstantClusterIdAwareMessage messageA = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, new RaftMessages.NewEntry.Request( null, contentA ) ); - RaftMessages.ReceivedInstantClusterIdAwareMessage messageB = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, + RaftMessages.ReceivedInstantClusterIdAwareMessage messageB = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, new RaftMessages.Heartbeat( null, 0, 0, 0 ) ); - RaftMessages.ReceivedInstantClusterIdAwareMessage messageC = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, + RaftMessages.ReceivedInstantClusterIdAwareMessage messageC = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, new RaftMessages.NewEntry.Request( null, contentC ) ); - RaftMessages.ReceivedInstantClusterIdAwareMessage messageD = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, + RaftMessages.ReceivedInstantClusterIdAwareMessage messageD = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, new RaftMessages.Heartbeat( null, 1, 1, 1 ) ); batchHandler.handle( messageA ); @@ -196,7 +196,7 @@ public void shouldDropMessagesAfterBeingStopped() throws Throwable BatchingMessageHandler batchHandler = new BatchingMessageHandler( downstreamHandler, QUEUE_SIZE, MAX_BATCH, jobSchedulerFactory, logProvider ); - RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, + RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, new RaftMessages.NewEntry.Request( null, null ) ); batchHandler.stop(); @@ -217,7 +217,7 @@ public void shouldGiveUpAddingMessagesInTheQueueIfTheHandlerHasBeenStopped() thr int queueSize = 1; BatchingMessageHandler batchHandler = new BatchingMessageHandler( downstreamHandler, queueSize, MAX_BATCH, jobSchedulerFactory, NullLogProvider.getInstance() ); - RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, + RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, localClusterId, new RaftMessages.NewEntry.Request( null, null ) ); batchHandler.handle( message ); // fill the queue diff --git a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/ClusterBindingHandlerTest.java b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/ClusterBindingHandlerTest.java index cb71d1ae30f5f..40fbad213c239 100644 --- a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/ClusterBindingHandlerTest.java +++ b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/ClusterBindingHandlerTest.java @@ -38,12 +38,12 @@ public class ClusterBindingHandlerTest { private ClusterId clusterId = new ClusterId( UUID.randomUUID() ); - private RaftMessages.ReceivedInstantClusterIdAwareMessage heartbeat = + private RaftMessages.ReceivedInstantClusterIdAwareMessage heartbeat = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( Instant.now(), clusterId, new RaftMessages.Heartbeat( new MemberId( UUID.randomUUID() ), 0L, 0, 0 ) ); @SuppressWarnings( "unchecked" ) - private LifecycleMessageHandler delegate = Mockito.mock( LifecycleMessageHandler.class ); + private LifecycleMessageHandler> delegate = Mockito.mock( LifecycleMessageHandler.class ); private ClusterBindingHandler handler = new ClusterBindingHandler( delegate , NullLogProvider.getInstance() ); diff --git a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/consensus/LeaderAvailabilityHandlerTest.java b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/consensus/LeaderAvailabilityHandlerTest.java index 4bdb899fa63a8..510cb7f1680d5 100644 --- a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/consensus/LeaderAvailabilityHandlerTest.java +++ b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/consensus/LeaderAvailabilityHandlerTest.java @@ -36,7 +36,7 @@ public class LeaderAvailabilityHandlerTest { @SuppressWarnings( "unchecked" ) - private LifecycleMessageHandler delegate = Mockito.mock( LifecycleMessageHandler.class ); + private LifecycleMessageHandler> delegate = Mockito.mock( LifecycleMessageHandler.class ); private LeaderAvailabilityTimers leaderAvailabilityTimers = Mockito.mock( LeaderAvailabilityTimers.class ); private ClusterId clusterId = new ClusterId( UUID.randomUUID() ); private LongSupplier term = () -> 3; @@ -44,13 +44,13 @@ public class LeaderAvailabilityHandlerTest private LeaderAvailabilityHandler handler = new LeaderAvailabilityHandler( delegate, leaderAvailabilityTimers, term ); private MemberId leader = new MemberId( UUID.randomUUID() ); - private RaftMessages.ReceivedInstantClusterIdAwareMessage heartbeat = + private RaftMessages.ReceivedInstantClusterIdAwareMessage heartbeat = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( Instant.now(), clusterId, new RaftMessages.Heartbeat( leader, term.getAsLong(), 0, 0 ) ); - private RaftMessages.ReceivedInstantClusterIdAwareMessage appendEntries = + private RaftMessages.ReceivedInstantClusterIdAwareMessage appendEntries = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( Instant.now(), clusterId, new RaftMessages.AppendEntries.Request( leader, term.getAsLong(), 0, 0, RaftLogEntry.empty, 0 ) ); - private RaftMessages.ReceivedInstantClusterIdAwareMessage voteResponse = + private RaftMessages.ReceivedInstantClusterIdAwareMessage voteResponse = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( Instant.now(), clusterId, new RaftMessages.Vote.Response( leader, term.getAsLong(), false ) ); @Test @@ -96,7 +96,7 @@ public void shouldNotRenewElectionForOtherMessages() throws Throwable public void shouldNotRenewElectionTimeoutsForHeartbeatsFromEarlierTerm() throws Throwable { // given - RaftMessages.ReceivedInstantClusterIdAwareMessage heartbeat = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( + RaftMessages.ReceivedInstantClusterIdAwareMessage heartbeat = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( Instant.now(), clusterId, new RaftMessages.Heartbeat( leader, term.getAsLong() - 1, 0, 0 ) ); handler.start( clusterId ); @@ -111,7 +111,7 @@ public void shouldNotRenewElectionTimeoutsForHeartbeatsFromEarlierTerm() throws @Test public void shouldNotRenewElectionTimeoutsForAppendEntriesRequestsFromEarlierTerms() throws Throwable { - RaftMessages.ReceivedInstantClusterIdAwareMessage appendEntries = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( + RaftMessages.ReceivedInstantClusterIdAwareMessage appendEntries = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( Instant.now(), clusterId, new RaftMessages.AppendEntries.Request( leader, term.getAsLong() - 1, 0, 0, RaftLogEntry.empty, 0 ) diff --git a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/consensus/RaftMessageMonitoringHandlerTest.java b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/consensus/RaftMessageMonitoringHandlerTest.java index 2b3fbefaef584..4d800652a6762 100644 --- a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/consensus/RaftMessageMonitoringHandlerTest.java +++ b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/core/consensus/RaftMessageMonitoringHandlerTest.java @@ -43,11 +43,11 @@ public class RaftMessageMonitoringHandlerTest private Monitors monitors = new Monitors(); private RaftMessageProcessingMonitor monitor = mock( RaftMessageProcessingMonitor.class ); @SuppressWarnings( "unchecked" ) - private LifecycleMessageHandler downstream = mock( LifecycleMessageHandler.class ); + private LifecycleMessageHandler> downstream = mock( LifecycleMessageHandler.class ); private Duration messageQueueDelay = Duration.ofMillis( 5 ); private Duration messageProcessingDelay = Duration.ofMillis( 7 ); - private RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( + private RaftMessages.ReceivedInstantClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now.minus( messageQueueDelay ), new ClusterId( UUID.randomUUID() ), new RaftMessages.Heartbeat( new MemberId( UUID.randomUUID() ), 0, 0, 0 ) ); private Clock clock = Clocks.tickOnAccessClock( now, messageProcessingDelay ); diff --git a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/messaging/marshalling/RaftMessageEncodingDecodingTest.java b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/messaging/marshalling/RaftMessageEncodingDecodingTest.java index 453ab0930410d..65dc59cc2aae3 100644 --- a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/messaging/marshalling/RaftMessageEncodingDecodingTest.java +++ b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/messaging/marshalling/RaftMessageEncodingDecodingTest.java @@ -105,7 +105,7 @@ public void shouldSerializeHeartbeats() throws Exception // When MemberId sender = new MemberId( UUID.randomUUID() ); - RaftMessages.ClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, clusterId, + RaftMessages.ClusterIdAwareMessage message = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, clusterId, new RaftMessages.Heartbeat( sender, 1, 2, 3 ) ); ChannelHandlerContext ctx = setupContext(); ByteBuf buffer = null; @@ -168,7 +168,7 @@ private void serializeReadBackAndVerifyMessage( RaftMessages.RaftMessage message ArrayList thingsRead = new ArrayList<>( 1 ); // When - RaftMessages.ClusterIdAwareMessage decoratedMessage = + RaftMessages.ClusterIdAwareMessage decoratedMessage = RaftMessages.ReceivedInstantClusterIdAwareMessage.of( now, clusterId, message ); ChannelHandlerContext ctx = setupContext(); ByteBuf buffer = null; diff --git a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/scenarios/ReadReplicaReplicationIT.java b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/scenarios/ReadReplicaReplicationIT.java index 4ceecb2ab5932..635b2002b5188 100644 --- a/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/scenarios/ReadReplicaReplicationIT.java +++ b/enterprise/causal-clustering/src/test/java/org/neo4j/causalclustering/scenarios/ReadReplicaReplicationIT.java @@ -240,10 +240,6 @@ private void gatherLabelScanStoreFiles( GraphDatabaseAPI db, Set labelScan Path relativePath = dbStoreDirectory.relativize( files.next().toPath().toAbsolutePath() ); labelScanStoreFiles.add( relativePath ); } - catch ( IOException e ) - { - throw new RuntimeException( e ); - } } @Test diff --git a/enterprise/com/src/test/java/org/neo4j/com/MadeUpServer.java b/enterprise/com/src/test/java/org/neo4j/com/MadeUpServer.java index b40864fdca756..17c502b9a1755 100644 --- a/enterprise/com/src/test/java/org/neo4j/com/MadeUpServer.java +++ b/enterprise/com/src/test/java/org/neo4j/com/MadeUpServer.java @@ -21,8 +21,6 @@ import org.jboss.netty.channel.Channel; -import java.io.IOException; - import org.neo4j.com.monitor.RequestMonitor; import org.neo4j.helpers.HostnamePort; import org.neo4j.kernel.monitoring.ByteCounterMonitor; @@ -133,21 +131,10 @@ enum MadeUpRequestType implements RequestType SEND_DATA_STREAM( ( master, context, input, target ) -> { - BlockLogReader reader = new BlockLogReader( input ); - try + try ( BlockLogReader reader = new BlockLogReader( input ) ) { return master.sendDataStream( reader ); } - finally - { - try - { - reader.close(); - } - catch ( IOException ignored ) - { - } - } }, Protocol.VOID_SERIALIZER ) { @Override diff --git a/enterprise/ha/src/test/java/org/neo4j/kernel/impl/ha/ParallelLifecycle.java b/enterprise/ha/src/test/java/org/neo4j/kernel/impl/ha/ParallelLifecycle.java index 7eed7eb95ad8b..9ce7292762296 100644 --- a/enterprise/ha/src/test/java/org/neo4j/kernel/impl/ha/ParallelLifecycle.java +++ b/enterprise/ha/src/test/java/org/neo4j/kernel/impl/ha/ParallelLifecycle.java @@ -130,6 +130,6 @@ private void perform( Action action ) throws Exception private interface Action { - void act( Lifecycle lifecycle ); + void act( Lifecycle lifecycle ) throws Throwable; } } diff --git a/enterprise/metrics/src/main/java/org/neo4j/metrics/output/CsvOutput.java b/enterprise/metrics/src/main/java/org/neo4j/metrics/output/CsvOutput.java index b537730936fab..b8d5d75efce9d 100644 --- a/enterprise/metrics/src/main/java/org/neo4j/metrics/output/CsvOutput.java +++ b/enterprise/metrics/src/main/java/org/neo4j/metrics/output/CsvOutput.java @@ -119,8 +119,7 @@ public void report( SortedMap gauges, SortedMap co private BiFunction getFileRotatingFileOutputStreamSupplier( Long rotationThreshold, Integer maxArchives ) { - return ( File file, RotatingFileOutputStreamSupplier.RotationListener listener ) -> - { + return ( file, listener ) -> { try { return new RotatingFileOutputStreamSupplier( fileSystem, file, rotationThreshold, 0, maxArchives,