@Override public void shutdown() { for ( KernelEventHandler kernelEventHandler : kernelEventHandlers ) { kernelEventHandler.beforeShutdown(); } }
@Override @SuppressWarnings( "unchecked" ) public void afterRollback( ReadableTransactionState state, KernelTransaction transaction, TransactionHandlerState handlerState ) { if ( handlerState == null ) { // For legacy reasons, we don't call transaction handlers on implicit rollback. return; } for ( HandlerAndState handlerAndState : handlerState.states ) { handlerAndState.handler.afterRollback( handlerState.txData, handlerAndState.state ); } }
@Override @SuppressWarnings( "unchecked" ) public void afterCommit( ReadableTransactionState state, KernelTransaction transaction, TransactionHandlerState handlerState ) { if ( handlerState == null ) { // As per beforeCommit, 'null' means no handlers were registered in time for this transaction to // observe them. return; } for ( HandlerAndState handlerAndState : handlerState.states ) { handlerAndState.handler.afterCommit( handlerState.txData, handlerAndState.state ); } }
@Override public void afterCommit( TransactionData data, Object state ) { for ( PropertyEntry<Node> entry : data.removedNodeProperties() ) { String key = entry.key(); Object value = entry.previouslyCommitedValue(); nodeProps.put( key, value ); } for ( PropertyEntry<Relationship> entry : data.removedRelationshipProperties() ) { relProps.put( entry.key(), entry.previouslyCommitedValue() ); } }
void basicCompareTo( PropertyEntry<T> entry ) { assertEquals( entry.entity(), entity() ); assertEquals( entry.key(), key() ); assertEqualsMaybeNull( entry.previouslyCommitedValue(), previouslyCommitedValue(), entry.entity(), entry.key() ); }
@Override public Void beforeCommit( TransactionData data ) { if ( active ) { check( added, "added to", data.assignedLabels() ); check( removed, "removed from", data.removedLabels() ); } active = false; return null; }
<T extends PropertyContainer> PropertyEntryImpl<T> fetchExpectedPropertyEntry( Map<T, Map<String, PropertyEntryImpl<T>>> map, PropertyEntry<T> entry ) { T entity = entry.entity(); boolean hasEntity = map.containsKey( entity ); if ( ignoreAdditionalData && !hasEntity ) { return null; } assertTrue( "Unexpected entity " + entry, hasEntity ); Map<String, PropertyEntryImpl<T>> innerMap = map.get( entity ); PropertyEntryImpl<T> expectedEntry = innerMap.remove( entry.key() ); if ( expectedEntry == null && ignoreAdditionalData ) { return null; } assertNotNull( "Unexpected property entry " + entry, expectedEntry ); if ( innerMap.isEmpty() ) { map.remove( entity ); } return expectedEntry; } }
@Override public Object beforeCommit( TransactionData data ) { Iterator<Node> nodes = data.createdNodes().iterator(); if ( nodes.hasNext() ) { Node node = nodes.next(); index.add( node, "key", "value" ); } return null; }
@Override public void afterCommit( TransactionData data, Object state ) { commitTimeAfterCommit = data.getCommitTime(); transactionIdAfterCommit = data.getTransactionId(); super.afterCommit( data, state ); }
@SuppressWarnings( "boxing" ) @Override public Void beforeCommit( TransactionData data ) { if ( Iterables.count( data.createdRelationships() ) == 0 ) { return null; } node.setProperty( "counter", ((Long) node.removeProperty( "counter" )) + 1 ); return null; }
void compareToRemoved( PropertyEntry<T> entry ) { basicCompareTo( entry ); try { entry.value(); fail( "Should throw IllegalStateException" ); } catch ( IllegalStateException e ) { // OK } assertNull( value() ); }
@Override public T beforeCommit( TransactionData data ) throws Exception { try { return source.beforeCommit( data ); } finally { if ( willFail ) { throw new Exception( "Just failing commit, that's all" ); } } } }
@Test public void shouldGetEmptyUsernameOnAuthDisabled() { db.registerTransactionEventHandler( getBeforeCommitHandler( txData -> { assertThat( "Should have no username", txData.username(), equalTo( "" ) ); assertThat( "Should have no metadata", txData.metaData(), equalTo( Collections.emptyMap() ) ); }) ); runTransaction(); }
@Override public Object beforeCommit( TransactionData data ) throws Exception { return super.beforeCommit( data ); }
public KernelEventHandler registerKernelEventHandler( KernelEventHandler handler ) { if ( this.kernelEventHandlers.contains( handler ) ) { return handler; } // Some algo for putting it in the right place for ( KernelEventHandler registeredHandler : this.kernelEventHandlers ) { KernelEventHandler.ExecutionOrder order = handler.orderComparedTo( registeredHandler ); int index = this.kernelEventHandlers.indexOf( registeredHandler ); if ( order == KernelEventHandler.ExecutionOrder.BEFORE ) { this.kernelEventHandlers.add( index, handler ); return handler; } else if ( order == KernelEventHandler.ExecutionOrder.AFTER ) { this.kernelEventHandlers.add( index + 1, handler ); return handler; } } this.kernelEventHandlers.add( handler ); return handler; }
public void kernelPanic( ErrorState error, Throwable cause ) { for ( KernelEventHandler handler : kernelEventHandlers ) { try { handler.kernelPanic( error ); } catch ( Throwable e ) { if ( cause != null ) { e.addSuppressed( cause ); } log.error( "FATAL: Error while handling kernel panic.", e ); } } } }
private Object verify( TransactionData data ) { // TODO Hmm, makes me think... should we really call transaction event handlers // for these relationship type / property index transactions? if ( Iterables.count( data.createdNodes() ) == 0 ) { return null; } try { this.expectedData.compareTo( data ); this.hasBeenCalled = true; return null; } catch ( Exception e ) { failure = e; throw e; } }
@Override public void afterCommit( TransactionData data, T state ) { source.afterCommit( data, state ); }
@Override public void afterRollback( TransactionData data, T state ) { source.afterRollback( data, state ); }