Unnamed: 0
int64 0
6.7k
| func
stringlengths 12
89.6k
| target
bool 2
classes | project
stringlengths 45
151
|
|---|---|---|---|
5,100
|
TO_SLAVE
{
@Override
public HighAvailabilityMemberState masterIsElected( HighAvailabilityMemberContext context,
InstanceId masterId )
{
if ( masterId.equals( context.getElectedMasterId() ) )
{
// A member joined and we all got the same event
return this;
}
if ( masterId.equals( context.getMyId() ) )
{
return TO_MASTER;
}
// This may mean the master changed from the time we transitioned here
return PENDING;
}
@Override
public HighAvailabilityMemberState masterIsAvailable( HighAvailabilityMemberContext context,
InstanceId masterId,
URI masterHaURI )
{
if ( masterId.equals( context.getMyId() ) )
{
throw new RuntimeException( "i (" + context.getMyId() + ") am trying to become a slave but " +
"someone said i am available as master" );
}
if ( masterId.equals( context.getElectedMasterId() ) )
{
// A member joined and we all got the same event
return this;
}
throw new RuntimeException( "my (" + context.getMyId() + ") current master is " + context
.getAvailableHaMaster() + " (elected as " + context.getElectedMasterId() + " but i got a " +
"masterIsAvailable event for " + masterHaURI );
}
@Override
public HighAvailabilityMemberState slaveIsAvailable( HighAvailabilityMemberContext context,
InstanceId slaveId,
URI slaveUri )
{
if ( slaveId.equals( context.getMyId() ) )
{
return SLAVE;
}
return this;
}
@Override
public boolean isEligibleForElection()
{
return false;
}
@Override
public boolean isAccessAllowed()
{
return false;
}
},
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberState.java
|
5,101
|
{
@Override
protected Response<LockResult> lock( Master master, RequestContext context, long... ids )
{
return master.acquireNodeWriteLock( context, ids );
}
}, LOCK_SERIALIZER, true )
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_HaRequestType18.java
|
5,102
|
public class SlaveClient extends Client<Slave> implements Slave
{
private final int machineId;
public SlaveClient( int machineId, String hostNameOrIp, int port, Logging logging, Monitors monitors,
StoreId storeId, int maxConcurrentChannels, int chunkSize )
{
super( hostNameOrIp, port, logging, monitors, storeId, Protocol.DEFAULT_FRAME_LENGTH,
SlaveServer.APPLICATION_PROTOCOL_VERSION,
HaSettings.read_timeout.apply( Functions.<String, String>nullFunction() ),
maxConcurrentChannels, chunkSize );
this.machineId = machineId;
}
@Override
public Response<Void> pullUpdates( final String resource, final long upToAndIncludingTxId )
{
return sendRequest( SlaveRequestType.PULL_UPDATES, RequestContext.EMPTY, new Serializer()
{
@Override
public void write( ChannelBuffer buffer ) throws IOException
{
writeString( buffer, resource );
buffer.writeLong( upToAndIncludingTxId );
}
}, Protocol.VOID_DESERIALIZER );
}
public static enum SlaveRequestType implements RequestType<Slave>
{
PULL_UPDATES( new TargetCaller<Slave, Void>()
{
@Override
public Response<Void> call( Slave master, RequestContext context, ChannelBuffer input,
ChannelBuffer target )
{
return master.pullUpdates( readString( input ), input.readLong() );
}
}, VOID_SERIALIZER );
private final TargetCaller caller;
private final ObjectSerializer serializer;
private SlaveRequestType( TargetCaller caller, ObjectSerializer serializer )
{
this.caller = caller;
this.serializer = serializer;
}
@Override
public TargetCaller getTargetCaller()
{
return caller;
}
@Override
public ObjectSerializer getObjectSerializer()
{
return serializer;
}
@Override
public byte id()
{
return (byte) ordinal();
}
}
@Override
public int getServerId()
{
return machineId;
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_SlaveClient.java
|
5,103
|
public class MasterServer extends Server<Master, Void>
{
public static final int FRAME_LENGTH = Protocol.DEFAULT_FRAME_LENGTH;
public MasterServer( Master requestTarget, Logging logging, Configuration config,
TxChecksumVerifier txVerifier, Monitors monitors )
{
super( requestTarget, config, logging, FRAME_LENGTH, MasterClient201.PROTOCOL_VERSION, txVerifier,
SYSTEM_CLOCK, monitors );
}
@Override
protected RequestType<Master> getRequestContext( byte id )
{
return HaRequestType201.values()[id];
}
@Override
protected void finishOffChannel( Channel channel, RequestContext context )
{
try
{
getRequestTarget().finishTransaction( context, false );
}
catch ( TransactionNotPresentOnMasterException e )
{
// This is OK. This method has been called due to some connection problem or similar,
// it's a best-effort to finish of a channel and transactions associated with it.
}
}
@Override
protected boolean shouldLogFailureToFinishOffChannel( Throwable failure )
{
return !(failure instanceof TransactionAlreadyActiveException);
}
public Map<Integer, Collection<RequestContext>> getSlaveInformation()
{
// Which slaves are connected a.t.m?
Set<Integer> machineIds = new HashSet<>();
Map<Channel, RequestContext> channels = getConnectedSlaveChannels();
synchronized ( channels )
{
for ( RequestContext context : channels.values() )
{
machineIds.add( context.machineId() );
}
}
// Insert missing slaves into the map so that all connected slave
// are in the returned map
Map<Integer, Collection<RequestContext>> ongoingTransactions =
((MasterImpl) getRequestTarget()).getOngoingTransactions();
for ( Integer machineId : machineIds )
{
if ( !ongoingTransactions.containsKey( machineId ) )
{
ongoingTransactions.put( machineId, Collections.<RequestContext>emptyList() );
}
}
return new TreeMap<>( ongoingTransactions );
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_MasterServer.java
|
5,104
|
public class MasterImplTest
{
@Test
public void givenStartedAndInaccessibleWhenInitializeTxThenThrowException() throws Throwable
{
// Given
MasterImpl.SPI spi = mock( MasterImpl.SPI.class );
Logging logging = new DevNullLoggingService();
Config config = config( 20 );
when( spi.isAccessible() ).thenReturn( false );
MasterImpl instance = new MasterImpl( spi, mock( MasterImpl.Monitor.class ), logging, config );
instance.start();
// When
try
{
instance.initializeTx( new RequestContext( 0, 1, 2, new RequestContext.Tx[0], 1, 0 ) );
fail();
}
catch ( TransactionFailureException e )
{
// Ok
}
}
@Test
public void givenStartedAndAccessibleWhenInitializeTxThenSucceeds() throws Throwable
{
// Given
MasterImpl.SPI spi = mock( MasterImpl.SPI.class );
Logging logging = new DevNullLoggingService();
Config config = config( 20 );
when( spi.isAccessible() ).thenReturn( true );
when( spi.beginTx() ).thenReturn( mock( Transaction.class ) );
when( spi.getMasterIdForCommittedTx( anyLong() ) ).thenReturn( Pair.of( 1, 1L ) );
MasterImpl instance = new MasterImpl( spi, mock( MasterImpl.Monitor.class ), logging, config );
instance.start();
HandshakeResult handshake = instance.handshake( 1, new StoreId() ).response();
// When
try
{
instance.initializeTx( new RequestContext( handshake.epoch(), 1, 2, new RequestContext.Tx[0], 1, 0 ) );
}
catch ( Exception e )
{
fail( e.getMessage() );
}
}
@Test
public void failingToStartTxShouldNotLeadToNPE() throws Throwable
{
// Given
MasterImpl.SPI spi = mock( MasterImpl.SPI.class );
Config config = config( 20 );
when( spi.isAccessible() ).thenReturn( true );
when( spi.beginTx() ).thenThrow( new SystemException("Nope") );
when( spi.getMasterIdForCommittedTx( anyLong() ) ).thenReturn( Pair.of( 1, 1L ) );
MasterImpl instance = new MasterImpl( spi, mock( MasterImpl.Monitor.class ),
new DevNullLoggingService(), config );
instance.start();
HandshakeResult handshake = instance.handshake( 1, new StoreId() ).response();
// When
try
{
instance.initializeTx( new RequestContext( handshake.epoch(), 1, 2, new RequestContext.Tx[0], 1, 0 ) );
fail("Should have failed.");
}
catch ( Exception e )
{
// Then
assertThat(e.getCause(), instanceOf( SystemException.class ));
assertThat(e.getCause().getMessage(), equalTo( "Nope" ));
}
}
private Config config( int lockReadTimeout )
{
Map<String, String> params = new HashMap<String, String>();
params.put( HaSettings.lock_read_timeout.name(), lockReadTimeout + "s" );
params.put( ClusterSettings.server_id.name(), "1" );
return new Config( params, HaSettings.class );
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_com_master_MasterImplTest.java
|
5,105
|
private class UnfinishedTransactionReaper implements Runnable
{
@Override
public void run()
{
try
{
Map<RequestContext, MasterTransaction> safeTransactions;
synchronized ( transactions )
{
safeTransactions = new HashMap<>( transactions );
}
for ( Map.Entry<RequestContext, MasterTransaction> entry : safeTransactions.entrySet() )
{
long time = entry.getValue().timeLastSuspended.get();
if ( (time != 0 && System.currentTimeMillis() - time >= unfinishedTransactionThresholdMillis)
|| entry.getValue().finishAsap() )
{
long displayableTime = (time == 0 ? 0 : (System.currentTimeMillis() - time));
String oldTxDescription = format( "old tx %s: %s at age %s ms",
entry.getKey(), entry.getValue().transaction, displayableTime );
try
{
resumeTransaction( entry.getKey() );
finishTransaction0( entry.getKey(), false );
msgLog.info( "Rolled back " + oldTxDescription );
}
catch ( TransactionAlreadyActiveException e )
{
// Expected for transactions awaiting locks, just leave them be
}
catch ( Throwable t )
{
// Not really expected
msgLog.warn( "Unable to roll back " + oldTxDescription, t );
}
}
}
}
catch ( Throwable t )
{
// The show must go on
msgLog.warn( "Exception running " + getClass().getName() + ", although will continue...", t );
}
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_MasterImpl.java
|
5,106
|
private static class MasterTransaction
{
private final Transaction transaction;
private final AtomicLong timeLastSuspended = new AtomicLong();
private volatile boolean finishAsap;
MasterTransaction( Transaction transaction )
{
this.transaction = transaction;
}
void updateTime()
{
this.timeLastSuspended.set( System.currentTimeMillis() );
}
void resetTime()
{
this.timeLastSuspended.set( 0 );
}
void markAsFinishAsap()
{
this.finishAsap = true;
}
@Override
public String toString()
{
return transaction + "[lastSuspended=" + timeLastSuspended + ", finishAsap=" + finishAsap + "]";
}
boolean finishAsap()
{
return this.finishAsap;
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_MasterImpl.java
|
5,107
|
{
@Override
public void grab( LockManager lockManager, TransactionState state, Object entity )
{
state.acquireWriteLock( entity );
}
};
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_MasterImpl.java
|
5,108
|
{
@Override
public void grab( LockManager lockManager, TransactionState state, Object entity )
{
state.acquireReadLock( entity );
}
};
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_MasterImpl.java
|
5,109
|
{
@Override
public boolean accept( Long item )
{
return item < txId;
}
};
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_MasterImpl.java
|
5,110
|
public class MasterImpl extends LifecycleAdapter implements Master
{
public interface Monitor
{
void initializeTx( RequestContext context );
}
public static final int TX_TIMEOUT_ADDITION = 5 * 1000;
// This is a bridge SPI that MasterImpl requires to function. Eventually this should be split
// up into many smaller APIs implemented by other services so that this is not needed.
// This SPI allows MasterImpl to have no direct dependencies, and instead puts those dependencies into the
// SPI implementation, thus making it easier to test this class by mocking the SPI.
public interface SPI
{
boolean isAccessible();
void acquireLock( LockGrabber grabber, Object... entities );
Transaction beginTx() throws SystemException, NotSupportedException;
void finishTransaction( boolean success );
void suspendTransaction() throws SystemException;
void resumeTransaction( Transaction transaction );
GraphProperties graphProperties();
IdAllocation allocateIds( IdType idType );
StoreId storeId();
long applyPreparedTransaction( String resource, ReadableByteChannel extract ) throws IOException;
Integer createRelationshipType( String name );
Pair<Integer, Long> getMasterIdForCommittedTx( long txId ) throws IOException;
RequestContext rotateLogsAndStreamStoreFiles( StoreWriter writer );
Response<Void> copyTransactions( String dsName, long startTxId, long endTxId );
<T> Response<T> packResponse( RequestContext context, T response, Predicate<Long> filter );
void pushTransaction( String resourceName, int eventIdentifier, long tx, int machineId );
int getOrCreateLabel( String name );
int getOrCreateProperty( String name );
}
public static final int UNFINISHED_TRANSACTION_CLEANUP_DELAY = 1;
private final SPI spi;
private final StringLogger msgLog;
private final Config config;
private final Monitor monitor;
private final long epoch;
private Map<RequestContext, MasterTransaction> transactions = new ConcurrentHashMap<>();
private ScheduledExecutorService unfinishedTransactionsExecutor;
private long unfinishedTransactionThresholdMillis;
public MasterImpl( SPI spi, Monitor monitor, Logging logging, Config config )
{
this.spi = spi;
this.msgLog = logging.getMessagesLog( getClass() );
this.config = config;
this.monitor = monitor;
this.epoch = generateEpoch();
}
private long generateEpoch()
{
return (((long)config.get( ClusterSettings.server_id )) << 48) | System.currentTimeMillis();
}
@Override
public void start() throws Throwable
{
this.unfinishedTransactionThresholdMillis = config.get( HaSettings.lock_read_timeout ) + TX_TIMEOUT_ADDITION;
this.unfinishedTransactionsExecutor =
Executors.newSingleThreadScheduledExecutor( new NamedThreadFactory( "Unfinished transaction reaper" ) );
this.unfinishedTransactionsExecutor.scheduleWithFixedDelay( new UnfinishedTransactionReaper(),
UNFINISHED_TRANSACTION_CLEANUP_DELAY, UNFINISHED_TRANSACTION_CLEANUP_DELAY, TimeUnit.SECONDS );
}
@Override
public void stop()
{
unfinishedTransactionsExecutor.shutdown();
transactions = null;
}
@Override
public Response<Void> initializeTx( RequestContext context )
{
monitor.initializeTx( context );
if ( !spi.isAccessible() )
{
throw new TransactionFailureException( "Database is currently not available" );
}
assertCorrectEpoch( context );
boolean beganTx = false;
try
{
Transaction tx = spi.beginTx();
transactions.put( context, new MasterTransaction( tx ) );
beganTx = true;
return packResponse( context, null );
}
catch ( NotSupportedException | SystemException e )
{
throw Exceptions.launderedException( e );
}
finally
{
if(beganTx)
{
suspendTransaction( context );
}
}
}
/**
* Basically for all public methods call this assertion to verify that the caller meant to call this
* master. The epoch is the one handed out from {@link #handshake(long, StoreId)}.
* Exceptions to the above are:
* o {@link #handshake(long, StoreId)}
* o {@link #copyStore(RequestContext, StoreWriter)}
* o {@link #copyTransactions(RequestContext, String, long, long)}
* o {@link #pullUpdates(RequestContext)}
*
* all other methods must have this.
* @param context the request context containing the epoch the request thinks it's for.
*/
private void assertCorrectEpoch( RequestContext context )
{
if ( this.epoch != context.getEpoch() )
{
throw new InvalidEpochException( epoch, context.getEpoch() );
}
}
private Response<LockResult> acquireLock( RequestContext context,
LockGrabber lockGrabber, Object... entities )
{
assertCorrectEpoch( context );
resumeTransaction( context );
try
{
spi.acquireLock( lockGrabber, entities );
return packResponse( context, new LockResult( LockStatus.OK_LOCKED ) );
}
catch ( DeadlockDetectedException e )
{
return packResponse( context, new LockResult( e.getMessage() ) );
}
catch ( IllegalResourceException e )
{
return packResponse( context, new LockResult( LockStatus.NOT_LOCKED ) );
}
finally
{
suspendTransaction( context );
}
}
private <T> Response<T> packResponse( RequestContext context, T response )
{
return packResponse( context, response, ServerUtil.ALL );
}
private <T> Response<T> packResponse( RequestContext context, T response, Predicate<Long> filter )
{
return spi.packResponse( context, response, filter );
}
private Transaction getTx( RequestContext txId )
{
MasterTransaction result = transactions.get( txId );
if ( result == null )
{
throw new TransactionNotPresentOnMasterException( txId );
}
// set time stamp to zero so that we don't even try to finish it off
// if getting old. This is because if the tx is active and old then
// it means it's waiting for a lock and we cannot do anything about it.
result.resetTime();
return result.transaction;
}
private void resumeTransaction( RequestContext txId )
{
spi.resumeTransaction( getTx( txId ) );
}
private void suspendTransaction( RequestContext context )
{
try
{
MasterTransaction tx = transactions.get( context );
if ( tx.finishAsap() )
{ // If we've tried to finish this tx off earlier then do it now when we have the chance.
finishTransaction( context, false );
return;
}
// update time stamp to current time so that we know that this tx just completed
// a request and can now again start to be monitored, so that it can be
// rolled back if it's getting old.
tx.updateTime();
}
finally
{
try
{
spi.suspendTransaction();
}
catch ( SystemException e )
{
throw Exceptions.launderedException( e );
}
}
}
private void finishTransaction0( RequestContext txId, boolean success )
{
try
{
spi.finishTransaction( success );
}
catch ( Exception e )
{
throw Exceptions.launderedException( e );
}
finally
{
transactions.remove( txId );
}
}
@Override
public Response<LockResult> acquireNodeReadLock( RequestContext context, long... nodes )
{
return acquireLock( context, READ_LOCK_GRABBER, (Object[])nodesById( nodes ) );
}
@Override
public Response<LockResult> acquireNodeWriteLock( RequestContext context, long... nodes )
{
return acquireLock( context, WRITE_LOCK_GRABBER, (Object[])nodesById( nodes ) );
}
@Override
public Response<LockResult> acquireRelationshipReadLock( RequestContext context,
long... relationships )
{
return acquireLock( context, READ_LOCK_GRABBER, (Object[])relationshipsById( relationships ) );
}
@Override
public Response<LockResult> acquireRelationshipWriteLock( RequestContext context,
long... relationships )
{
return acquireLock( context, WRITE_LOCK_GRABBER, (Object[])relationshipsById( relationships ) );
}
@Override
public Response<LockResult> acquireGraphReadLock( RequestContext context )
{
return acquireLock( context, READ_LOCK_GRABBER, spi.graphProperties() );
}
@Override
public Response<LockResult> acquireGraphWriteLock( RequestContext context )
{
return acquireLock( context, WRITE_LOCK_GRABBER, spi.graphProperties() );
}
private Node[] nodesById( long[] ids )
{
Node[] result = new Node[ids.length];
for ( int i = 0; i < ids.length; i++ )
{
result[i] = new LockableNode( ids[i] );
}
return result;
}
private Relationship[] relationshipsById( long[] ids )
{
Relationship[] result = new Relationship[ids.length];
for ( int i = 0; i < ids.length; i++ )
{
result[i] = new LockableRelationship( ids[i] );
}
return result;
}
@Override
public Response<IdAllocation> allocateIds( RequestContext context, IdType idType )
{
assertCorrectEpoch( context );
IdAllocation result = spi.allocateIds( idType );
return ServerUtil.packResponseWithoutTransactionStream( spi.storeId(), result );
}
@Override
public Response<Long> commitSingleResourceTransaction( RequestContext context, String resource,
TxExtractor txGetter )
{
assertCorrectEpoch( context );
resumeTransaction( context );
try
{
final long txId = spi.applyPreparedTransaction( resource, txGetter.extract() );
Predicate<Long> upUntilThisTx = new Predicate<Long>()
{
@Override
public boolean accept( Long item )
{
return item < txId;
}
};
return packResponse( context, txId, upUntilThisTx );
}
catch ( IOException e )
{
throw new RuntimeException( e );
}
finally
{
suspendTransaction( context );
}
}
@Override
public Response<Void> finishTransaction( RequestContext context, boolean success )
{
assertCorrectEpoch( context );
try
{
resumeTransaction( context );
}
catch ( TransactionNotPresentOnMasterException e )
{ // Let these ones through straight away
throw e;
}
catch ( RuntimeException e )
{
MasterTransaction masterTransaction = transactions.get( context );
// It is possible that the transaction is not there anymore, or never was. No need for an NPE to be thrown.
if ( masterTransaction != null )
{
masterTransaction.markAsFinishAsap();
}
throw e;
}
finishTransaction0( context, success );
return packResponse( context, null );
}
@Override
public Response<Integer> createRelationshipType( RequestContext context, String name )
{
assertCorrectEpoch( context );
return packResponse( context, spi.createRelationshipType( name ) );
}
@Override
public Response<Integer> createPropertyKey( RequestContext context, String name )
{
assertCorrectEpoch( context );
return packResponse( context, spi.getOrCreateProperty( name ) );
}
@Override
public Response<Integer> createLabel( RequestContext context, String name )
{
assertCorrectEpoch( context );
return packResponse( context, spi.getOrCreateLabel( name ) );
}
@Override
public Response<Void> pullUpdates( RequestContext context )
{
return packResponse( context, null );
}
@Override
public Response<HandshakeResult> handshake( long txId, StoreId storeId )
{
try
{
Pair<Integer, Long> masterId = spi.getMasterIdForCommittedTx( txId );
return ServerUtil.packResponseWithoutTransactionStream( spi.storeId(),
new HandshakeResult( masterId.first(), masterId.other(), epoch ) );
}
catch ( IOException e )
{
throw new RuntimeException( "Couldn't get master ID for " + txId, e );
}
}
@Override
public Response<Void> copyStore( RequestContext context, StoreWriter writer )
{
context = spi.rotateLogsAndStreamStoreFiles( writer );
writer.done();
return packResponse( context, null );
}
@Override
public Response<Void> copyTransactions( RequestContext context,
String dsName, long startTxId, long endTxId )
{
return spi.copyTransactions( dsName, startTxId, endTxId );
}
public static interface LockGrabber
{
void grab( LockManager lockManager, TransactionState state, Object entity );
}
private static LockGrabber READ_LOCK_GRABBER = new LockGrabber()
{
@Override
public void grab( LockManager lockManager, TransactionState state, Object entity )
{
state.acquireReadLock( entity );
}
};
private static LockGrabber WRITE_LOCK_GRABBER = new LockGrabber()
{
@Override
public void grab( LockManager lockManager, TransactionState state, Object entity )
{
state.acquireWriteLock( entity );
}
};
@Override
public Response<LockResult> acquireIndexReadLock( RequestContext context, String index, String key )
{
return acquireLock( context, READ_LOCK_GRABBER, new IndexLock( index, key ) );
}
@Override
public Response<LockResult> acquireIndexWriteLock( RequestContext context, String index,
String key )
{
return acquireLock( context, WRITE_LOCK_GRABBER, new IndexLock( index, key ) );
}
@Override
public Response<LockResult> acquireSchemaReadLock( RequestContext context )
{
return acquireLock( context, READ_LOCK_GRABBER, new SchemaLock() );
}
@Override
public Response<LockResult> acquireSchemaWriteLock( RequestContext context )
{
return acquireLock( context, WRITE_LOCK_GRABBER, new SchemaLock() );
}
@Override
public Response<LockResult> acquireIndexEntryWriteLock( RequestContext context, long labelId, long propertyKeyId,
String propertyValue )
{
return acquireLock( context, WRITE_LOCK_GRABBER, new IndexEntryLock(
safeCastLongToInt( labelId ), safeCastLongToInt( propertyKeyId ), propertyValue ) );
}
@Override
public Response<Void> pushTransaction( RequestContext context, String resourceName, long tx )
{
assertCorrectEpoch( context );
spi.pushTransaction( resourceName, context.getEventIdentifier(), tx, context.machineId() );
return new Response<>( null, spi.storeId(), TransactionStream.EMPTY, ResourceReleaser.NO_OP );
}
// =====================================================================
// Just some methods which aren't really used when running a HA cluster,
// but exposed so that other tools can reach that information.
// =====================================================================
public Map<Integer, Collection<RequestContext>> getOngoingTransactions()
{
Map<Integer, Collection<RequestContext>> result = new HashMap<>();
Set<RequestContext> contexts = transactions.keySet();
for ( RequestContext context : contexts.toArray( new RequestContext[contexts.size()] ) )
{
Collection<RequestContext> txs = result.get( context.machineId() );
if ( txs == null )
{
txs = new ArrayList<>();
result.put( context.machineId(), txs );
}
txs.add( context );
}
return result;
}
private static class MasterTransaction
{
private final Transaction transaction;
private final AtomicLong timeLastSuspended = new AtomicLong();
private volatile boolean finishAsap;
MasterTransaction( Transaction transaction )
{
this.transaction = transaction;
}
void updateTime()
{
this.timeLastSuspended.set( System.currentTimeMillis() );
}
void resetTime()
{
this.timeLastSuspended.set( 0 );
}
void markAsFinishAsap()
{
this.finishAsap = true;
}
@Override
public String toString()
{
return transaction + "[lastSuspended=" + timeLastSuspended + ", finishAsap=" + finishAsap + "]";
}
boolean finishAsap()
{
return this.finishAsap;
}
}
private class UnfinishedTransactionReaper implements Runnable
{
@Override
public void run()
{
try
{
Map<RequestContext, MasterTransaction> safeTransactions;
synchronized ( transactions )
{
safeTransactions = new HashMap<>( transactions );
}
for ( Map.Entry<RequestContext, MasterTransaction> entry : safeTransactions.entrySet() )
{
long time = entry.getValue().timeLastSuspended.get();
if ( (time != 0 && System.currentTimeMillis() - time >= unfinishedTransactionThresholdMillis)
|| entry.getValue().finishAsap() )
{
long displayableTime = (time == 0 ? 0 : (System.currentTimeMillis() - time));
String oldTxDescription = format( "old tx %s: %s at age %s ms",
entry.getKey(), entry.getValue().transaction, displayableTime );
try
{
resumeTransaction( entry.getKey() );
finishTransaction0( entry.getKey(), false );
msgLog.info( "Rolled back " + oldTxDescription );
}
catch ( TransactionAlreadyActiveException e )
{
// Expected for transactions awaiting locks, just leave them be
}
catch ( Throwable t )
{
// Not really expected
msgLog.warn( "Unable to roll back " + oldTxDescription, t );
}
}
}
}
catch ( Throwable t )
{
// The show must go on
msgLog.warn( "Exception running " + getClass().getName() + ", although will continue...", t );
}
}
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_MasterImpl.java
|
5,111
|
public class InvalidEpochException extends ComException
{
public InvalidEpochException( long correctEpoch, long invalidEpoch )
{
super( "Invalid epoch " + invalidEpoch + ", correct epoch is " + correctEpoch );
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_InvalidEpochException.java
|
5,112
|
public class HandshakeResult
{
private final int txAuthor;
private final long txChecksum;
private final long epoch;
public HandshakeResult( int txAuthor, long txChecksum, long epoch )
{
this.txAuthor = txAuthor;
this.txChecksum = txChecksum;
this.epoch = epoch;
}
public long epoch()
{
return epoch;
}
public int txAuthor()
{
return txAuthor;
}
public long txChecksum()
{
return txChecksum;
}
@Override
public String toString()
{
return getClass().getSimpleName() + "[author:" + txAuthor + ", checksum:" + txChecksum +
", epoch:" + epoch + "]";
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_HandshakeResult.java
|
5,113
|
private class StoreIdSettingListener extends DataSourceRegistrationListener.Adapter
{
@Override
public void registeredDataSource( XaDataSource ds )
{
if ( ds instanceof NeoStoreXaDataSource)
storeId = ((NeoStoreXaDataSource) ds).getStoreId();
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_DefaultSlaveFactory.java
|
5,114
|
public class DefaultSlaveFactory implements SlaveFactory
{
private final Logging logging;
private final Monitors monitors;
private final int chunkSize;
private StoreId storeId;
public DefaultSlaveFactory( XaDataSourceManager xaDsm, Logging logging, Monitors monitors, int chunkSize )
{
this.logging = logging;
this.monitors = monitors;
this.chunkSize = chunkSize;
xaDsm.addDataSourceRegistrationListener( new StoreIdSettingListener() );
}
@Override
public Slave newSlave( ClusterMember clusterMember )
{
return new SlaveClient( clusterMember.getInstanceId(), clusterMember.getHAUri().getHost(),
clusterMember.getHAUri().getPort(), logging, monitors, storeId,
2, // and that's 1 too many, because we push from the master from one thread only anyway
chunkSize );
}
private class StoreIdSettingListener extends DataSourceRegistrationListener.Adapter
{
@Override
public void registeredDataSource( XaDataSource ds )
{
if ( ds instanceof NeoStoreXaDataSource)
storeId = ((NeoStoreXaDataSource) ds).getStoreId();
}
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_master_DefaultSlaveFactory.java
|
5,115
|
public class RequestContextFactory
{
private long epoch;
private final int serverId;
private final XaDataSourceManager xaDsm;
private final DependencyResolver resolver;
private AbstractTransactionManager txManager;
public RequestContextFactory( int serverId, XaDataSourceManager xaDsm, DependencyResolver resolver )
{
this.resolver = resolver;
this.epoch = -1;
this.serverId = serverId;
this.xaDsm = xaDsm;
}
public void setEpoch( long epoch )
{
this.epoch = epoch;
this.txManager = resolver.resolveDependency( AbstractTransactionManager.class );
}
public RequestContext newRequestContext( int eventIdentifier )
{
// Constructs a slave context from scratch.
try
{
Collection<XaDataSource> dataSources = xaDsm.getAllRegisteredDataSources();
RequestContext.Tx[] txs = new RequestContext.Tx[dataSources.size()];
int i = 0;
Pair<Integer,Long> master = null;
for ( XaDataSource dataSource : dataSources )
{
long txId = dataSource.getLastCommittedTxId();
if( dataSource.getName().equals( NeoStoreXaDataSource.DEFAULT_DATA_SOURCE_NAME ) )
{
master = dataSource.getMasterForCommittedTx( txId );
}
txs[i++] = RequestContext.lastAppliedTx( dataSource.getName(), txId );
}
assert master != null : "master should not be null, since we should have found " + NeoStoreXaDataSource.DEFAULT_DATA_SOURCE_NAME;
return new RequestContext( epoch, serverId, eventIdentifier, txs, master.first(), master.other() );
}
catch ( IOException e )
{
throw new RuntimeException( e );
}
}
public RequestContext newRequestContext( long sessionId, int machineId, int eventIdentifier )
{
try
{
Collection<XaDataSource> dataSources = xaDsm.getAllRegisteredDataSources();
RequestContext.Tx[] txs = new RequestContext.Tx[dataSources.size()];
int i = 0;
Pair<Integer,Long> master = null;
for ( XaDataSource dataSource : dataSources )
{
long txId = dataSource.getLastCommittedTxId();
if( dataSource.getName().equals( NeoStoreXaDataSource.DEFAULT_DATA_SOURCE_NAME ) )
{
master = dataSource.getMasterForCommittedTx( txId );
}
txs[i++] = RequestContext.lastAppliedTx( dataSource.getName(), txId );
}
assert master != null : "master should not be null, since we should have found " + NeoStoreXaDataSource.DEFAULT_DATA_SOURCE_NAME;
return new RequestContext( sessionId, machineId, eventIdentifier, txs, master.first(), master.other() );
}
catch ( IOException e )
{
throw new RuntimeException( e );
}
}
public RequestContext newRequestContext( XaDataSource dataSource, long sessionId, int machineId, int eventIdentifier )
{
try
{
long txId = dataSource.getLastCommittedTxId();
RequestContext.Tx[] txs = new RequestContext.Tx[] { RequestContext.lastAppliedTx( dataSource.getName(), txId ) };
Pair<Integer,Long> master = dataSource.getName().equals( NeoStoreXaDataSource.DEFAULT_DATA_SOURCE_NAME ) ?
dataSource.getMasterForCommittedTx( txId ) : Pair.of( XaLogicalLog.MASTER_ID_REPRESENTING_NO_MASTER, 0L );
return new RequestContext( sessionId, machineId, eventIdentifier, txs, master.first(), master.other() );
}
catch ( IOException e )
{
throw new RuntimeException( e );
}
}
public RequestContext newRequestContext( XaDataSource dataSource )
{
return newRequestContext( dataSource, epoch, serverId, txManager.getEventIdentifier() );
}
public RequestContext newRequestContext()
{
return newRequestContext( epoch, serverId, txManager.getEventIdentifier() );
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_RequestContextFactory.java
|
5,116
|
ACQUIRE_RELATIONSHIP_WRITE_LOCK( new AquireLockCall()
{
@Override
protected Response<LockResult> lock( Master master, RequestContext context, long... ids )
{
return master.acquireRelationshipWriteLock( context, ids );
}
}, LOCK_SERIALIZER, true )
{
@Override
public boolean isLock()
{
return true;
}
},
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_HaRequestType18.java
|
5,117
|
{
@Override
protected Response<LockResult> lock( Master master, RequestContext context, long... ids )
{
return master.acquireRelationshipWriteLock( context, ids );
}
}, LOCK_SERIALIZER, true )
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_HaRequestType18.java
|
5,118
|
ACQUIRE_NODE_READ_LOCK( new AquireLockCall()
{
@Override
protected Response<LockResult> lock( Master master, RequestContext context, long... ids )
{
return master.acquireNodeReadLock( context, ids );
}
}, LOCK_SERIALIZER, true )
{
@Override
public boolean isLock()
{
return true;
}
},
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_HaRequestType18.java
|
5,119
|
{
@Override
protected Response<LockResult> lock( Master master, RequestContext context, long... ids )
{
return master.acquireNodeReadLock( context, ids );
}
}, LOCK_SERIALIZER, true )
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_HaRequestType18.java
|
5,120
|
ACQUIRE_NODE_WRITE_LOCK( new AquireLockCall()
{
@Override
protected Response<LockResult> lock( Master master, RequestContext context, long... ids )
{
return master.acquireNodeWriteLock( context, ids );
}
}, LOCK_SERIALIZER, true )
{
@Override
public boolean isLock()
{
return true;
}
},
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_com_HaRequestType18.java
|
5,121
|
public class HighAvailabilitySlavesTest
{
private static InstanceId instanceId1 = new InstanceId( 1 );
private static URI clusterUri1 = create( "cluster://server1" );
private static URI haUri1 = create( "ha://server1?serverId="+ instanceId1.toIntegerIndex() );
private static InstanceId instanceId2 = new InstanceId( 2 );
private static URI clusterUri2 = create( "cluster://server2" );
private static URI haUri2 = create( "ha://server2?serverId="+ instanceId2.toIntegerIndex() );
private static InstanceId instanceId3 = new InstanceId( 3 );
private static URI clusterUri3 = create( "cluster://server3" );
private static URI haUri3 = create( "ha://server3?serverId="+ instanceId3.toIntegerIndex() );
@Test
public void shouldRegisterItselfOnMonitors() throws Throwable
{
// given
ClusterMembers clusterMembers = mock( ClusterMembers.class );
Cluster cluster = mock( Cluster.class );
SlaveFactory slaveFactory = mock( SlaveFactory.class );
// when
new HighAvailabilitySlaves( clusterMembers, cluster, slaveFactory).init();
// then
verify( cluster ).addClusterListener( Mockito.<ClusterListener>any() );
}
@Test
public void shouldNotReturnUnavailableSlaves() throws Throwable
{
// given
Cluster cluster = mock( Cluster.class);
ClusterMembers clusterMembers = mock( ClusterMembers.class);
when( clusterMembers.getMembers() ).thenReturn( Iterables.<ClusterMember,ClusterMember>iterable(
new ClusterMember( instanceId1 ) ) );
SlaveFactory slaveFactory = mock( SlaveFactory.class );
HighAvailabilitySlaves slaves = new HighAvailabilitySlaves( clusterMembers, cluster, slaveFactory);
slaves.init();
// when
Iterable<Slave> memberSlaves = slaves.getSlaves();
// then
Assert.assertThat( count( memberSlaves ), CoreMatchers.equalTo( 0L ));
}
@Test
public void shouldNotReturnAvailableButFailedSlaves() throws Throwable
{
// given
Cluster cluster = mock( Cluster.class);
ClusterMembers clusterMembers = mock( ClusterMembers.class);
when( clusterMembers.getMembers() ).thenReturn( Iterables.<ClusterMember,ClusterMember>iterable(
new ClusterMember( instanceId1 ).availableAs( "SLAVE", haUri1 ).failed() ) );
SlaveFactory slaveFactory = mock( SlaveFactory.class );
HighAvailabilitySlaves slaves = new HighAvailabilitySlaves( clusterMembers, cluster, slaveFactory);
slaves.init();
// when
Iterable<Slave> memberSlaves = slaves.getSlaves();
// then
Assert.assertThat( count( memberSlaves ), CoreMatchers.equalTo( 0L ));
}
@Test
public void shouldReturnAvailableAndAliveSlaves() throws Throwable
{
// given
Cluster cluster = mock( Cluster.class);
ClusterMembers clusterMembers = mock( ClusterMembers.class);
when( clusterMembers.getMembers() ).thenReturn( Iterables.<ClusterMember,ClusterMember>iterable(
new ClusterMember( instanceId1 ).availableAs( HighAvailabilityModeSwitcher.SLAVE, haUri1) ) );
SlaveFactory slaveFactory = mock( SlaveFactory.class );
when( slaveFactory.newSlave( (ClusterMember)any() ) ).thenReturn( mock(Slave.class));
HighAvailabilitySlaves slaves = new HighAvailabilitySlaves( clusterMembers, cluster, slaveFactory);
slaves.init();
// when
Iterable<Slave> memberSlaves = slaves.getSlaves();
// then
Assert.assertThat( count( memberSlaves ), CoreMatchers.equalTo( 1L ));
}
@Test
public void shouldClearSlavesWhenNewMasterElected() throws Throwable
{
// given
Cluster cluster = mock( Cluster.class );
ClusterMembers clusterMembers = mock( ClusterMembers.class);
when( clusterMembers.getMembers() ).thenReturn( Iterables.<ClusterMember,ClusterMember>iterable(
new ClusterMember( instanceId1 ).availableAs( HighAvailabilityModeSwitcher.SLAVE, haUri1 ) ) );
SlaveFactory slaveFactory = mock( SlaveFactory.class );
when( slaveFactory.newSlave( (ClusterMember)any() ) ).thenReturn( mock(Slave.class), mock(Slave.class) );
HighAvailabilitySlaves slaves = new HighAvailabilitySlaves( clusterMembers, cluster, slaveFactory);
slaves.init();
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
// when
Slave slave1 = slaves.getSlaves().iterator().next();
listener.getValue().elected( ClusterConfiguration.COORDINATOR, instanceId1, clusterUri2 );
Slave slave2 = slaves.getSlaves().iterator().next();
// then
Assert.assertThat( slave2, not( sameInstance( slave1 ) ));
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_member_HighAvailabilitySlavesTest.java
|
5,122
|
public class HighAvailabilitySlavesIT
{
private final TargetDirectory DIR = TargetDirectory.forTest( getClass() );
private ClusterManager clusterManager;
@After
public void after() throws Throwable
{
clusterManager.stop();
}
@Test
public void transactionsGetsPushedToSlaves() throws Throwable
{
// given
clusterManager = new ClusterManager( clusterOfSize( 3 ), DIR.cleanDirectory( "dbs" ),
stringMap( tx_push_factor.name(), "2" ) );
clusterManager.start();
ManagedCluster cluster = clusterManager.getDefaultCluster();
// when
String name = "a node";
long node = createNode( cluster.getMaster(), name );
// then
for ( HighlyAvailableGraphDatabase db : cluster.getAllMembers() ) {
Transaction transaction = db.beginTx();
try
{
assertEquals( node, getNodeByName( db, name ) );
}
finally
{
transaction.finish();
}
}
}
private long getNodeByName( HighlyAvailableGraphDatabase db, String name )
{
for ( Node node : GlobalGraphOperations.at( db ).getAllNodes() )
if ( name.equals( node.getProperty( "name", null ) ) )
return node.getId();
fail( "No node '" + name + "' found in " + db );
return 0; // Never called
}
private long createNode( HighlyAvailableGraphDatabase db, String name )
{
Transaction tx = db.beginTx();
try
{
Node node = db.createNode();
node.setProperty( "name", name );
tx.success();
return node.getId();
}
finally
{
tx.finish();
}
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_member_HighAvailabilitySlavesIT.java
|
5,123
|
private class HASClusterListener extends ClusterListener.Adapter
{
@Override
public void elected( String role, InstanceId instanceId, URI electedMember )
{
if ( role.equals( ClusterConfiguration.COORDINATOR ) )
{
life.clear();
slaves.clear();
}
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_member_HighAvailabilitySlaves.java
|
5,124
|
{
@Override
public Slave apply( ClusterMember from )
{
Slave slave = life.add( slaveFactory.newSlave( from ));
slaves.put( from, slave );
return slave;
}
};
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_member_HighAvailabilitySlaves.java
|
5,125
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,126
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,127
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,128
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,129
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,130
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,131
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,132
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,133
|
public class HighAvailabilityMemberStateMachineTest
{
@Test
public void shouldStartFromPending() throws Exception
{
// Given
HighAvailabilityMemberContext context = mock( HighAvailabilityMemberContext.class );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
// Then
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.PENDING ) );
}
@Test
public void shouldMoveToToMasterFromPendingOnMasterElectedForItself() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
// When
theListener.coordinatorIsElected( me );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.TO_MASTER ) );
}
@Test
public void shouldRemainToPendingOnMasterElectedForSomeoneElse() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
// When
theListener.coordinatorIsElected( new InstanceId( 2 ) );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.PENDING ) );
}
@Test
public void shouldSwitchToToSlaveOnMasterAvailableForSomeoneElse() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
HAStateChangeListener probe = new HAStateChangeListener();
toTest.addHighAvailabilityMemberListener( probe );
// When
theListener.memberIsAvailable( HighAvailabilityModeSwitcher.MASTER, new InstanceId( 2 ), URI.create( "ha://whatever" ) );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.TO_SLAVE ) );
assertThat( probe.masterIsAvailable, is( true ) );
}
@Test
public void whenInMasterStateLosingQuorumShouldPutInPending() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
InstanceId other = new InstanceId( 2 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
List<ClusterMember> membersList = new LinkedList<ClusterMember>();
// we cannot set outside of the package the isAlive to return false. So do it with a mock
ClusterMember otherMemberMock = mock( ClusterMember.class );
when ( otherMemberMock.getInstanceId() ).thenReturn( other.toIntegerIndex() );
when( otherMemberMock.isAlive() ).thenReturn( false );
membersList.add( otherMemberMock );
membersList.add( new ClusterMember( me ) );
when( members.getMembers() ).thenReturn( membersList );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
HAStateChangeListener probe = new HAStateChangeListener();
toTest.addHighAvailabilityMemberListener( probe );
// Send it to MASTER
theListener.coordinatorIsElected( me );
theListener.memberIsAvailable( HighAvailabilityModeSwitcher.MASTER, me, URI.create("ha://whatever") );
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.MASTER) );
// When
theListener.memberIsFailed( new InstanceId( 2 ) );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.PENDING ) );
assertThat( probe.instanceStops, is( true ) );
verify(guard, times(1)).deny( any( AvailabilityGuard.AvailabilityRequirement.class) );
}
@Test
public void whenInSlaveStateLosingQuorumShouldPutInPending() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
InstanceId other = new InstanceId( 2 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
List<ClusterMember> membersList = new LinkedList<ClusterMember>();
// we cannot set outside of the package the isAlive to return false. So do it with a mock
ClusterMember otherMemberMock = mock( ClusterMember.class );
when ( otherMemberMock.getInstanceId() ).thenReturn( other.toIntegerIndex() );
when( otherMemberMock.isAlive() ).thenReturn( false );
membersList.add( otherMemberMock );
membersList.add( new ClusterMember( me ) );
when( members.getMembers() ).thenReturn( membersList );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
HAStateChangeListener probe = new HAStateChangeListener();
toTest.addHighAvailabilityMemberListener( probe );
// Send it to MASTER
theListener.memberIsAvailable( HighAvailabilityModeSwitcher.MASTER, other, URI.create( "ha://whatever" ) );
theListener.memberIsAvailable( HighAvailabilityModeSwitcher.SLAVE, me, URI.create( "ha://whatever2" ) );
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.SLAVE) );
// When
theListener.memberIsFailed( new InstanceId( 2 ) );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.PENDING ) );
assertThat( probe.instanceStops, is( true ) );
verify(guard, times(1)).deny( any( AvailabilityGuard.AvailabilityRequirement.class) );
}
@Test
public void whenInToMasterStateLosingQuorumShouldPutInPending() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
InstanceId other = new InstanceId( 2 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
List<ClusterMember> membersList = new LinkedList<ClusterMember>();
// we cannot set outside of the package the isAlive to return false. So do it with a mock
ClusterMember otherMemberMock = mock( ClusterMember.class );
when ( otherMemberMock.getInstanceId() ).thenReturn( other.toIntegerIndex() );
when( otherMemberMock.isAlive() ).thenReturn( false );
membersList.add( otherMemberMock );
membersList.add( new ClusterMember( me ) );
when( members.getMembers() ).thenReturn( membersList );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
HAStateChangeListener probe = new HAStateChangeListener();
toTest.addHighAvailabilityMemberListener( probe );
// Send it to MASTER
theListener.coordinatorIsElected( me );
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.TO_MASTER) );
// When
theListener.memberIsFailed( new InstanceId( 2 ) );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.PENDING ) );
assertThat( probe.instanceStops, is( true ) );
verify(guard, times(0)).deny( any( AvailabilityGuard.AvailabilityRequirement.class) );
}
@Test
public void whenInToSlaveStateLosingQuorumShouldPutInPending() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
InstanceId other = new InstanceId( 2 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
List<ClusterMember> membersList = new LinkedList<ClusterMember>();
// we cannot set outside of the package the isAlive to return false. So do it with a mock
ClusterMember otherMemberMock = mock( ClusterMember.class );
when ( otherMemberMock.getInstanceId() ).thenReturn( other.toIntegerIndex() );
when( otherMemberMock.isAlive() ).thenReturn( false );
membersList.add( otherMemberMock );
membersList.add( new ClusterMember( me ) );
when( members.getMembers() ).thenReturn( membersList );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
HAStateChangeListener probe = new HAStateChangeListener();
toTest.addHighAvailabilityMemberListener( probe );
// Send it to MASTER
theListener.memberIsAvailable( HighAvailabilityModeSwitcher.MASTER, other, URI.create("ha://whatever") );
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.TO_SLAVE) );
// When
theListener.memberIsFailed( new InstanceId( 2 ) );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.PENDING ) );
assertThat( probe.instanceStops, is( true ) );
verify(guard, times(0)).deny( any( AvailabilityGuard.AvailabilityRequirement.class) );
}
@Test
public void whenListenerThrowsExceptionOnMasterElectedStateDoesNotChange() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
HAStateChangeListener probe = new HAStateChangeListener();
toTest.addHighAvailabilityMemberListener( new HAPoisonousStateChangeListener() );
toTest.addHighAvailabilityMemberListener( probe );
// When
// Send it to TO_MASTER
theListener.coordinatorIsElected( me );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.PENDING) );
verify(guard, times(0)).deny( any( AvailabilityGuard.AvailabilityRequirement.class) );
}
@Test
public void whenListenerThrowsExceptionOnMasterAvailableStateDoesNotChange() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
InstanceId master = new InstanceId( 2 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
HAStateChangeListener probe = new HAStateChangeListener();
toTest.addHighAvailabilityMemberListener( new HAPoisonousStateChangeListener() );
toTest.addHighAvailabilityMemberListener( probe );
// When
// Send it to TO_SLAVE
theListener.memberIsAvailable( HighAvailabilityModeSwitcher.MASTER, master, URI.create( "ha://wherever" ) );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.PENDING) );
verify(guard, times(0)).deny( any( AvailabilityGuard.AvailabilityRequirement.class) );
}
@Test
public void whenListenerThrowsExceptionOnSlaveAvailableStateDoesNotChange() throws Throwable
{
// Given
InstanceId me = new InstanceId( 1 );
HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext( me );
AvailabilityGuard guard = mock( AvailabilityGuard.class );
ClusterMembers members = mock( ClusterMembers.class );
ClusterMemberEvents events = mock( ClusterMemberEvents.class );
final Set<ClusterMemberListener> listener = new HashSet<ClusterMemberListener>();
doAnswer( new Answer()
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
Election election = mock( Election.class );
StringLogger logger = mock( StringLogger.class );
HighAvailabilityMemberStateMachine toTest =
new HighAvailabilityMemberStateMachine( context, guard, members, events, election, logger );
toTest.init();
ClusterMemberListener theListener = listener.iterator().next();
HAStateChangeListener probe = new HAStateChangeListener();
toTest.addHighAvailabilityMemberListener( probe );
// When
// Send it to TO_MASTER
theListener.coordinatorIsElected( me );
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.TO_MASTER ) );
// then ensure it'll fail
toTest.addHighAvailabilityMemberListener( new HAPoisonousStateChangeListener() );
// Send it to MASTER
theListener.memberIsAvailable( HighAvailabilityModeSwitcher.MASTER, me, URI.create( "ha://wherever" ) );
// Then
assertThat( listener.size(), equalTo( 1 ) ); // Sanity check.
assertThat( toTest.getCurrentState(), equalTo( HighAvailabilityMemberState.TO_MASTER ) );
verify(guard, times(0)).deny( any( AvailabilityGuard.AvailabilityRequirement.class) );
}
private static final class HAStateChangeListener implements HighAvailabilityMemberListener
{
boolean masterIsElected = false;
boolean masterIsAvailable = false;
boolean slaveIsAvailable = false;
boolean instanceStops = false;
HighAvailabilityMemberChangeEvent lastEvent = null;
@Override
public void masterIsElected( HighAvailabilityMemberChangeEvent event )
{
masterIsElected = true;
masterIsAvailable = false;
slaveIsAvailable = false;
instanceStops = false;
lastEvent = event;
}
@Override
public void masterIsAvailable( HighAvailabilityMemberChangeEvent event )
{
masterIsElected = false;
masterIsAvailable = true;
slaveIsAvailable = false;
instanceStops = false;
lastEvent = event;
}
@Override
public void slaveIsAvailable( HighAvailabilityMemberChangeEvent event )
{
masterIsElected = false;
masterIsAvailable = false;
slaveIsAvailable = true;
instanceStops = false;
lastEvent = event;
}
@Override
public void instanceStops( HighAvailabilityMemberChangeEvent event )
{
masterIsElected = false;
masterIsAvailable = false;
slaveIsAvailable = false;
instanceStops = true;
lastEvent = event;
}
}
private static final class HAPoisonousStateChangeListener implements HighAvailabilityMemberListener
{
@Override
public void masterIsElected( HighAvailabilityMemberChangeEvent event )
{
throw new NullPointerException( "Sample exception" );
}
@Override
public void masterIsAvailable( HighAvailabilityMemberChangeEvent event )
{
throw new NullPointerException( "Sample exception" );
}
@Override
public void slaveIsAvailable( HighAvailabilityMemberChangeEvent event )
{
throw new NullPointerException( "Sample exception" );
}
@Override
public void instanceStops( HighAvailabilityMemberChangeEvent event )
{
throw new NullPointerException( "Sample exception" );
}
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,134
|
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.instanceStops( event );
}
} );
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachine.java
|
5,135
|
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.slaveIsAvailable( event );
}
} );
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachine.java
|
5,136
|
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.masterIsAvailable( event );
}
} );
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachine.java
|
5,137
|
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.masterIsElected( event );
}
} );
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachine.java
|
5,138
|
private class StateMachineClusterEventListener extends ClusterMemberListener.Adapter
{
@Override
public synchronized void coordinatorIsElected( InstanceId coordinatorId )
{
try
{
HighAvailabilityMemberState oldState = state;
InstanceId previousElected = context.getElectedMasterId();
// Check if same coordinator was elected
// if ( !coordinatorId.equals( previousElected ) )
{
state = state.masterIsElected( context, coordinatorId );
context.setElectedMasterId( coordinatorId );
final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent( oldState,
state, coordinatorId,
null );
boolean successful = Listeners.notifyListeners( memberListeners,
new Listeners.Notification<HighAvailabilityMemberListener>()
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.masterIsElected( event );
}
} );
if ( successful )
{
context.setAvailableHaMasterId( null );
if ( oldState.isAccessAllowed() && oldState != state )
{
availabilityGuard.deny(HighAvailabilityMemberStateMachine.this);
}
logger.debug( "Got masterIsElected(" + coordinatorId + "), changed " + oldState + " -> " +
state + ". Previous elected master is " + previousElected );
}
else
{
logger.debug( "Got masterIsElected(" + coordinatorId +
"), but applying it was not successful so keeps state " + oldState +
" even though the desired state transaction would have been to " + state );
state = oldState;
}
}
}
catch ( Throwable t )
{
throw new RuntimeException( t );
}
}
@Override
public synchronized void memberIsAvailable( String role, InstanceId instanceId, URI roleUri )
{
try
{
if ( role.equals( HighAvailabilityModeSwitcher.MASTER ) )
{
// if ( !roleUri.equals( context.getAvailableHaMaster() ) )
{
HighAvailabilityMemberState oldState = state;
context.setAvailableHaMasterId( roleUri );
state = state.masterIsAvailable( context, instanceId, roleUri );
logger.debug( "Got masterIsAvailable(" + instanceId + "), moved to " + state + " from " +
oldState );
final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent( oldState,
state, instanceId, roleUri );
boolean successful = Listeners.notifyListeners( memberListeners,
new Listeners.Notification<HighAvailabilityMemberListener>()
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.masterIsAvailable( event );
}
} );
if ( successful )
{
if ( oldState == HighAvailabilityMemberState.TO_MASTER && state ==
HighAvailabilityMemberState.MASTER )
{
availabilityGuard.grant(HighAvailabilityMemberStateMachine.this);
}
}
else
{
logger.debug( "Got masterIsAvailable(" + instanceId +
"), but applying it was not successful so keeps state " + oldState +
" even though the desired state transaction would have been to " + state );
state = oldState;
}
}
}
else if ( role.equals( HighAvailabilityModeSwitcher.SLAVE ) )
{
HighAvailabilityMemberState oldState = state;
state = state.slaveIsAvailable( context, instanceId, roleUri );
logger.debug( "Got slaveIsAvailable(" + instanceId + "), " +
"moved to " + state + " from " + oldState );
final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent( oldState,
state, instanceId, roleUri );
boolean successful = Listeners.notifyListeners( memberListeners,
new Listeners.Notification<HighAvailabilityMemberListener>()
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.slaveIsAvailable( event );
}
} );
if ( successful )
{
if ( oldState == HighAvailabilityMemberState.TO_SLAVE &&
state == HighAvailabilityMemberState.SLAVE )
{
availabilityGuard.grant(HighAvailabilityMemberStateMachine.this);
}
}
else
{
logger.debug( "Got slaveIsAvailable(" + instanceId +
"), but applying it was not successful so keeps state " + oldState +
" even though the desired state transaction would have been to " + state );
state = oldState;
}
}
}
catch ( Throwable throwable )
{
logger.warn( "Exception while receiving member availability notification", throwable );
}
}
@Override
public void memberIsFailed( InstanceId instanceId )
{
if ( !isQuorum(getAliveCount(), getTotalCount()) )
{
try
{
if(state.isAccessAllowed())
{
availabilityGuard.deny(HighAvailabilityMemberStateMachine.this);
}
final HighAvailabilityMemberChangeEvent event =
new HighAvailabilityMemberChangeEvent(
state, HighAvailabilityMemberState.PENDING, null, null );
state = HighAvailabilityMemberState.PENDING;
Listeners.notifyListeners( memberListeners, new Listeners
.Notification<HighAvailabilityMemberListener>()
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.instanceStops( event );
}
} );
context.setAvailableHaMasterId( null );
context.setElectedMasterId( null );
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
}
}
@Override
public void memberIsAlive( InstanceId instanceId )
{
if ( isQuorum(getAliveCount(), getTotalCount()) && state.equals( HighAvailabilityMemberState.PENDING ) )
{
election.performRoleElections();
}
}
private long getAliveCount()
{
return Iterables.count( Iterables.filter( ClusterMembers.ALIVE, members.getMembers() ) );
}
private long getTotalCount()
{
return Iterables.count( members.getMembers() );
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachine.java
|
5,139
|
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.instanceStops( event );
}
} );
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachine.java
|
5,140
|
public class HighAvailabilityMemberStateMachine extends LifecycleAdapter implements HighAvailability,
AvailabilityGuard.AvailabilityRequirement
{
private final HighAvailabilityMemberContext context;
private final AvailabilityGuard availabilityGuard;
private final ClusterMemberEvents events;
private final StringLogger logger;
private Iterable<HighAvailabilityMemberListener> memberListeners = Listeners.newListeners();
private volatile HighAvailabilityMemberState state;
private StateMachineClusterEventListener eventsListener;
private final ClusterMembers members;
private final Election election;
public HighAvailabilityMemberStateMachine( HighAvailabilityMemberContext context,
AvailabilityGuard availabilityGuard,
ClusterMembers members, ClusterMemberEvents events, Election election,
StringLogger logger )
{
this.context = context;
this.availabilityGuard = availabilityGuard;
this.members = members;
this.events = events;
this.election = election;
this.logger = logger;
state = HighAvailabilityMemberState.PENDING;
}
@Override
public void init() throws Throwable
{
events.addClusterMemberListener( eventsListener = new StateMachineClusterEventListener() );
}
@Override
public void stop() throws Throwable
{
events.removeClusterMemberListener( eventsListener );
HighAvailabilityMemberState oldState = state;
state = HighAvailabilityMemberState.PENDING;
final HighAvailabilityMemberChangeEvent event =
new HighAvailabilityMemberChangeEvent( oldState, state, null, null );
Listeners.notifyListeners( memberListeners, new Listeners.Notification<HighAvailabilityMemberListener>()
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.instanceStops( event );
}
} );
// If we are in a state that allows access, we must deny now that we shut down.
if ( oldState.isAccessAllowed() )
{
availabilityGuard.deny(this);
}
context.setAvailableHaMasterId( null );
}
@Override
public void addHighAvailabilityMemberListener( HighAvailabilityMemberListener toAdd )
{
memberListeners = Listeners.addListener( toAdd, memberListeners );
}
@Override
public void removeHighAvailabilityMemberListener( HighAvailabilityMemberListener toRemove )
{
memberListeners = Listeners.removeListener( toRemove, memberListeners );
}
public HighAvailabilityMemberState getCurrentState()
{
return state;
}
@Override
public String description()
{
return getClass().getSimpleName() + "[" + getCurrentState() + "]";
}
private class StateMachineClusterEventListener extends ClusterMemberListener.Adapter
{
@Override
public synchronized void coordinatorIsElected( InstanceId coordinatorId )
{
try
{
HighAvailabilityMemberState oldState = state;
InstanceId previousElected = context.getElectedMasterId();
// Check if same coordinator was elected
// if ( !coordinatorId.equals( previousElected ) )
{
state = state.masterIsElected( context, coordinatorId );
context.setElectedMasterId( coordinatorId );
final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent( oldState,
state, coordinatorId,
null );
boolean successful = Listeners.notifyListeners( memberListeners,
new Listeners.Notification<HighAvailabilityMemberListener>()
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.masterIsElected( event );
}
} );
if ( successful )
{
context.setAvailableHaMasterId( null );
if ( oldState.isAccessAllowed() && oldState != state )
{
availabilityGuard.deny(HighAvailabilityMemberStateMachine.this);
}
logger.debug( "Got masterIsElected(" + coordinatorId + "), changed " + oldState + " -> " +
state + ". Previous elected master is " + previousElected );
}
else
{
logger.debug( "Got masterIsElected(" + coordinatorId +
"), but applying it was not successful so keeps state " + oldState +
" even though the desired state transaction would have been to " + state );
state = oldState;
}
}
}
catch ( Throwable t )
{
throw new RuntimeException( t );
}
}
@Override
public synchronized void memberIsAvailable( String role, InstanceId instanceId, URI roleUri )
{
try
{
if ( role.equals( HighAvailabilityModeSwitcher.MASTER ) )
{
// if ( !roleUri.equals( context.getAvailableHaMaster() ) )
{
HighAvailabilityMemberState oldState = state;
context.setAvailableHaMasterId( roleUri );
state = state.masterIsAvailable( context, instanceId, roleUri );
logger.debug( "Got masterIsAvailable(" + instanceId + "), moved to " + state + " from " +
oldState );
final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent( oldState,
state, instanceId, roleUri );
boolean successful = Listeners.notifyListeners( memberListeners,
new Listeners.Notification<HighAvailabilityMemberListener>()
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.masterIsAvailable( event );
}
} );
if ( successful )
{
if ( oldState == HighAvailabilityMemberState.TO_MASTER && state ==
HighAvailabilityMemberState.MASTER )
{
availabilityGuard.grant(HighAvailabilityMemberStateMachine.this);
}
}
else
{
logger.debug( "Got masterIsAvailable(" + instanceId +
"), but applying it was not successful so keeps state " + oldState +
" even though the desired state transaction would have been to " + state );
state = oldState;
}
}
}
else if ( role.equals( HighAvailabilityModeSwitcher.SLAVE ) )
{
HighAvailabilityMemberState oldState = state;
state = state.slaveIsAvailable( context, instanceId, roleUri );
logger.debug( "Got slaveIsAvailable(" + instanceId + "), " +
"moved to " + state + " from " + oldState );
final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent( oldState,
state, instanceId, roleUri );
boolean successful = Listeners.notifyListeners( memberListeners,
new Listeners.Notification<HighAvailabilityMemberListener>()
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.slaveIsAvailable( event );
}
} );
if ( successful )
{
if ( oldState == HighAvailabilityMemberState.TO_SLAVE &&
state == HighAvailabilityMemberState.SLAVE )
{
availabilityGuard.grant(HighAvailabilityMemberStateMachine.this);
}
}
else
{
logger.debug( "Got slaveIsAvailable(" + instanceId +
"), but applying it was not successful so keeps state " + oldState +
" even though the desired state transaction would have been to " + state );
state = oldState;
}
}
}
catch ( Throwable throwable )
{
logger.warn( "Exception while receiving member availability notification", throwable );
}
}
@Override
public void memberIsFailed( InstanceId instanceId )
{
if ( !isQuorum(getAliveCount(), getTotalCount()) )
{
try
{
if(state.isAccessAllowed())
{
availabilityGuard.deny(HighAvailabilityMemberStateMachine.this);
}
final HighAvailabilityMemberChangeEvent event =
new HighAvailabilityMemberChangeEvent(
state, HighAvailabilityMemberState.PENDING, null, null );
state = HighAvailabilityMemberState.PENDING;
Listeners.notifyListeners( memberListeners, new Listeners
.Notification<HighAvailabilityMemberListener>()
{
@Override
public void notify( HighAvailabilityMemberListener listener )
{
listener.instanceStops( event );
}
} );
context.setAvailableHaMasterId( null );
context.setElectedMasterId( null );
}
catch ( Throwable throwable )
{
throw new RuntimeException( throwable );
}
}
}
@Override
public void memberIsAlive( InstanceId instanceId )
{
if ( isQuorum(getAliveCount(), getTotalCount()) && state.equals( HighAvailabilityMemberState.PENDING ) )
{
election.performRoleElections();
}
}
private long getAliveCount()
{
return Iterables.count( Iterables.filter( ClusterMembers.ALIVE, members.getMembers() ) );
}
private long getTotalCount()
{
return Iterables.count( members.getMembers() );
}
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachine.java
|
5,141
|
SLAVE
{
@Override
public HighAvailabilityMemberState masterIsElected( HighAvailabilityMemberContext context,
InstanceId masterId )
{
if ( masterId.equals( context.getMyId() ) )
{
return TO_MASTER;
}
if ( masterId.equals( context.getElectedMasterId() ) )
{
return this;
}
else
{
return PENDING;
}
}
@Override
public HighAvailabilityMemberState masterIsAvailable( HighAvailabilityMemberContext context,
InstanceId masterId,
URI masterHaURI )
{
if ( masterId.equals( context.getMyId() ) )
{
throw new RuntimeException( "Cannot transition to MASTER directly from SLAVE state" );
}
else if ( masterId.equals( context.getElectedMasterId() ) )
{
// this is just someone else that joined the cluster
return this;
}
throw new RuntimeException( "Received a MasterIsAvailable event for " + masterId +
" which is different from the current master (" + context.getElectedMasterId() +
") while in the SLAVE state (probably missed a MasterIsElected event)" );
}
@Override
public HighAvailabilityMemberState slaveIsAvailable( HighAvailabilityMemberContext context, InstanceId slaveId, URI slaveUri )
{
return this;
}
@Override
public boolean isEligibleForElection()
{
return true;
}
@Override
public boolean isAccessAllowed()
{
return true;
}
};
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberState.java
|
5,142
|
MASTER
{
@Override
public HighAvailabilityMemberState masterIsElected( HighAvailabilityMemberContext context,
InstanceId masterId )
{
if ( masterId.equals( context.getMyId() ) )
{
return this;
}
// This means we (probably) were disconnected and got back in the cluster
// and we find out that we are not the master anymore.
return PENDING;
}
@Override
public HighAvailabilityMemberState masterIsAvailable( HighAvailabilityMemberContext context,
InstanceId masterId,
URI masterHaURI )
{
if ( masterId.equals( context.getMyId() ) )
{
return this;
}
throw new RuntimeException( "I, " + context.getMyId() + " got a masterIsAvailable for " +
masterHaURI + " (id is " + masterId + " ) while in MASTER state. Probably missed a " +
"MasterIsElected event." );
}
@Override
public HighAvailabilityMemberState slaveIsAvailable( HighAvailabilityMemberContext context,
InstanceId slaveId,
URI slaveUri )
{
if ( slaveId.equals( context.getMyId() ) )
{
throw new RuntimeException( "Cannot be master and transition to slave at the same time" );
}
return this;
}
@Override
public boolean isEligibleForElection()
{
return true;
}
@Override
public boolean isAccessAllowed()
{
return true;
}
},
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberState.java
|
5,143
|
TO_MASTER
{
@Override
public HighAvailabilityMemberState masterIsElected( HighAvailabilityMemberContext context,
InstanceId masterId )
{
assert context.getAvailableHaMaster() == null;
if ( masterId.equals( context.getMyId() ) )
{
return this;
}
return PENDING; // everything still goes
}
@Override
public HighAvailabilityMemberState masterIsAvailable( HighAvailabilityMemberContext context,
InstanceId masterId,
URI masterHaURI )
{
if ( masterId.equals( context.getMyId() ) )
{
return MASTER;
}
throw new RuntimeException( "Received a MasterIsAvailable event for instance " + masterId
+ " while in TO_MASTER state");
}
@Override
public HighAvailabilityMemberState slaveIsAvailable( HighAvailabilityMemberContext context,
InstanceId slaveId,
URI slaveUri )
{
if ( slaveId.equals( context.getMyId() ) )
{
throw new RuntimeException( "Cannot be transitioning to master and slave at the same time" );
}
return this;
}
@Override
public boolean isEligibleForElection()
{
return true;
}
@Override
public boolean isAccessAllowed()
{
return false;
}
},
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberState.java
|
5,144
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,145
|
{
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
listener.add( (ClusterMemberListener) invocation.getArguments()[0] );
return null;
}
} ).when( events ).addClusterMemberListener( Matchers.<ClusterMemberListener>any() );
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,146
|
private static final class HAPoisonousStateChangeListener implements HighAvailabilityMemberListener
{
@Override
public void masterIsElected( HighAvailabilityMemberChangeEvent event )
{
throw new NullPointerException( "Sample exception" );
}
@Override
public void masterIsAvailable( HighAvailabilityMemberChangeEvent event )
{
throw new NullPointerException( "Sample exception" );
}
@Override
public void slaveIsAvailable( HighAvailabilityMemberChangeEvent event )
{
throw new NullPointerException( "Sample exception" );
}
@Override
public void instanceStops( HighAvailabilityMemberChangeEvent event )
{
throw new NullPointerException( "Sample exception" );
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,147
|
public class ClusterMemberMatcher extends BaseMatcher<Iterable<ClusterMemberInfo>>
{
private boolean trueForExactFalseForContains;
private ClusterMemberMatch[] expectedMembers;
public ClusterMemberMatcher( boolean trueForExactFalseForContains, ClusterMemberMatch[] expected )
{
this.trueForExactFalseForContains = trueForExactFalseForContains;
this.expectedMembers = expected;
}
@Override
public void describeTo( Description description )
{
description.appendText( Arrays.toString( expectedMembers ) );
}
public static Matcher<ClusterMember> sameMemberAs( final ClusterMember clusterMember)
{
return new BaseMatcher<ClusterMember>()
{
@Override
public boolean matches( Object instance )
{
if (!(instance instanceof ClusterMember))
return false;
ClusterMember member = ClusterMember.class.cast( instance );
if (!member.getMemberId().equals( clusterMember.getMemberId() ))
return false;
if (!member.isAlive()==clusterMember.isAlive())
return false;
HashSet<URI> memberUris = new HashSet<URI>( Iterables.toList( member.getRoleURIs() ) );
HashSet<URI> clusterMemberUris = new HashSet<URI>( Iterables.toList( clusterMember.getRoleURIs() ) );
if (!memberUris.equals( clusterMemberUris ))
return false;
return true;
}
@Override
public void describeTo( Description description )
{
description.appendText( "member should match " ).appendValue( clusterMember );
}
};
}
@Override
public boolean matches( Object item )
{
if ( !( item instanceof Iterable ) )
return false;
@SuppressWarnings( "unchecked" )
Iterable<ClusterMemberInfo> other = (Iterable<ClusterMemberInfo>) item;
int foundCount = 0;
for ( ClusterMemberMatch expectedMember : expectedMembers )
{
boolean found = false;
for ( ClusterMemberInfo member : other )
{
if ( expectedMember.match( member ) )
{
found = true;
foundCount++;
break;
}
}
if ( !found )
return false;
}
if ( trueForExactFalseForContains == true && foundCount != expectedMembers.length )
return false;
return true;
}
public static ClusterMemberMatch member( URI member )
{
return new ClusterMemberMatch( member );
}
public static ClusterMemberMatcher containsMembers( ClusterMemberMatch... expected )
{
return new ClusterMemberMatcher( false, expected );
}
public static ClusterMemberMatcher containsOnlyMembers( ClusterMemberMatch... expected )
{
return new ClusterMemberMatcher( true, expected );
}
public static class ClusterMemberMatch
{
private URI member;
private Boolean available;
private Boolean alive;
private String haRole;
private Set<String> uris;
ClusterMemberMatch( URI member )
{
this.member = member;
}
public ClusterMemberMatch available( boolean available )
{
this.available = available;
return this;
}
public ClusterMemberMatch alive( boolean alive )
{
this.alive = alive;
return this;
}
private boolean match( ClusterMemberInfo toMatch )
{
if ( !member.toString().equals( toMatch.getInstanceId() ) )
return false;
if ( available != null && toMatch.isAvailable() != available )
return false;
if ( alive != null && toMatch.isAlive() != alive )
return false;
if ( haRole != null && !haRole.equals( toMatch.getHaRole() ) )
return false;
if ( uris != null && !uris.equals( new HashSet<String>( asList( toMatch.getUris() ) ) ) )
return false;
return true;
}
@Override
public String toString()
{
StringBuilder builder = new StringBuilder( "Member[" + member );
if ( available != null )
builder.append( ", available:" + available );
if ( alive != null )
builder.append( ", alive:" + alive );
if ( haRole != null )
builder.append( ", haRole:" + haRole );
if ( uris != null )
builder.append( ", uris:" + uris );
return builder.append( "]" ).toString();
}
public ClusterMemberMatch haRole( String role )
{
this.haRole = role;
return this;
}
public ClusterMemberMatch uris( URI... uris )
{
this.uris = new HashSet<String>();
for ( URI uri : uris )
this.uris.add( uri.toString() );
return this;
}
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_member_ClusterMemberMatcher.java
|
5,148
|
public class HighAvailabilitySlaves implements Lifecycle, Slaves
{
private final LifeSupport life = new LifeSupport();
private final Map<ClusterMember, Slave> slaves = new CopyOnWriteHashMap<ClusterMember, Slave>();
private ClusterMembers clusterMembers;
private Cluster cluster;
private SlaveFactory slaveFactory;
private HighAvailabilitySlaves.HASClusterListener clusterListener;
public HighAvailabilitySlaves( ClusterMembers clusterMembers, Cluster cluster, SlaveFactory slaveFactory)
{
this.clusterMembers = clusterMembers;
this.cluster = cluster;
this.slaveFactory = slaveFactory;
}
private Function<ClusterMember, Slave> slaveForMember()
{
return new Function<ClusterMember, Slave>()
{
@Override
public Slave apply( ClusterMember from )
{
Slave slave = life.add( slaveFactory.newSlave( from ));
slaves.put( from, slave );
return slave;
}
};
}
@Override
public Iterable<Slave> getSlaves()
{
// Return all cluster members which are currently SLAVEs,
// are alive, and convert to Slave with a cache if possible
return map( withDefaults( slaveForMember(), Functions.map( slaves ) ),
filter( ClusterMembers.ALIVE,
filter( inRole( HighAvailabilityModeSwitcher.SLAVE ),
clusterMembers.getMembers() ) ) );
}
@Override
public void init()
{
life.init();
clusterListener = new HASClusterListener();
cluster.addClusterListener( clusterListener );
}
@Override
public void start() throws Throwable
{
life.start();
}
@Override
public void stop() throws Throwable
{
life.stop();
}
@Override
public void shutdown() throws Throwable
{
cluster.removeClusterListener( clusterListener );
life.shutdown();
slaves.clear();
}
private class HASClusterListener extends ClusterListener.Adapter
{
@Override
public void elected( String role, InstanceId instanceId, URI electedMember )
{
if ( role.equals( ClusterConfiguration.COORDINATOR ) )
{
life.clear();
slaves.clear();
}
}
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_member_HighAvailabilitySlaves.java
|
5,149
|
public class ClusterMembersTest
{
private static InstanceId clusterId1 = new InstanceId( 1 );
private static InstanceId clusterId2 = new InstanceId( 2 );
private static InstanceId clusterId3 = new InstanceId( 3 );
private static URI clusterUri1 = create( "cluster://server1" );
private static URI clusterUri2 = create( "cluster://server2" );
private static URI clusterUri3 = create( "cluster://server3" );
private static URI haUri1 = create( "ha://server1?serverId="+clusterId1.toIntegerIndex() );
private static URI haUri2 = create( "ha://server2?serverId="+clusterId2.toIntegerIndex() );
private static URI haUri3 = create( "ha://server3?serverId="+clusterId3.toIntegerIndex() );
@Test
public void shouldRegisterItselfOnListeners() throws Exception
{
// given
Cluster cluster = mock( Cluster.class );
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
// when
new ClusterMembers( cluster, heartbeat, clusterMemberEvents, null );
// then
verify( cluster ).addClusterListener( Mockito.<ClusterListener>any() );
verify( heartbeat ).addHeartbeatListener( Mockito.<HeartbeatListener>any() );
verify( clusterMemberEvents ).addClusterMemberListener( Mockito.<ClusterMemberListener>any() );
}
@Test
public void shouldContainMemberListAfterEnteringCluster() throws Exception
{
// given
Cluster cluster = mock( Cluster.class );
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
ClusterMembers members = new ClusterMembers( cluster, heartbeat, clusterMemberEvents, null );
// when
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
listener.getValue().enteredCluster( clusterConfiguration( clusterUri1, clusterUri2, clusterUri3 ) );
// then
assertThat( members.getMembers(), CoreMatchers.<ClusterMember>hasItems(
sameMemberAs( new ClusterMember( clusterId1 ) ),
sameMemberAs( new ClusterMember( clusterId2 ) ),
sameMemberAs( new ClusterMember( clusterId3 ) ) ));
}
@Test
public void joinedMemberShowsInList() throws Exception
{
// given
Cluster cluster = mock( Cluster.class );
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
ClusterMembers members = new ClusterMembers( cluster, heartbeat, clusterMemberEvents, null );
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
listener.getValue().enteredCluster( clusterConfiguration( clusterUri1, clusterUri2 ) );
// when
listener.getValue().joinedCluster( clusterId3, clusterUri3 );
// then
assertThat( members.getMembers(), CoreMatchers.<ClusterMember>hasItems(
sameMemberAs( new ClusterMember( clusterId1 ) ),
sameMemberAs( new ClusterMember( clusterId2 ) ),
sameMemberAs( new ClusterMember( clusterId3 ) ) ) );
}
@Test
public void iCanGetToMyself() throws Exception
{
// given
Cluster cluster = mock( Cluster.class );
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
ClusterMembers members = new ClusterMembers( cluster, heartbeat, clusterMemberEvents, clusterId1 );
// when
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
listener.getValue().enteredCluster( clusterConfiguration( clusterUri1, clusterUri2 ) );
ClusterMember me = members.getSelf();
assertNotNull( me );
assertEquals( 1, me.getInstanceId() );
assertEquals( clusterId1, me.getMemberId() );
}
@Test
public void leftMemberDisappearsFromList() throws Exception
{
// given
Cluster cluster = mock( Cluster.class );
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
ClusterMembers members = new ClusterMembers( cluster, heartbeat, clusterMemberEvents, null );
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
listener.getValue().enteredCluster( clusterConfiguration( clusterUri1, clusterUri2, clusterUri3 ) );
// when
listener.getValue().leftCluster( clusterId3 );
// then
assertThat(
members.getMembers(),
CoreMatchers.not( CoreMatchers.<ClusterMember>hasItems(
sameMemberAs( new ClusterMember( clusterId3 ) ) ) ));
}
@Test
public void availableMasterShowsProperInformation() throws Exception
{
// given
Cluster cluster = mock(Cluster.class);
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
ClusterMembers members = new ClusterMembers( cluster, heartbeat, clusterMemberEvents, null );
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
listener.getValue().enteredCluster( clusterConfiguration( clusterUri1, clusterUri2, clusterUri3 ) );
ArgumentCaptor<ClusterMemberListener> clusterMemberListener = ArgumentCaptor.forClass( ClusterMemberListener.class );
verify( clusterMemberEvents ).addClusterMemberListener( clusterMemberListener.capture() );
// when
clusterMemberListener.getValue().memberIsAvailable( MASTER, clusterId1, haUri1 );
// then
assertThat(
members.getMembers(),
CoreMatchers.<ClusterMember>hasItem( sameMemberAs( new ClusterMember( clusterId1 ).availableAs(
MASTER, haUri1 ) ) ) );
}
@Test
public void availableSlaveShowsProperInformation() throws Exception
{
// given
Cluster cluster = mock(Cluster.class);
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
ClusterMembers members = new ClusterMembers( cluster, heartbeat, clusterMemberEvents, null );
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
listener.getValue().enteredCluster( clusterConfiguration( clusterUri1, clusterUri2, clusterUri3 ) );
ArgumentCaptor<ClusterMemberListener> clusterMemberListener = ArgumentCaptor.forClass( ClusterMemberListener.class );
verify( clusterMemberEvents ).addClusterMemberListener( clusterMemberListener.capture() );
// when
clusterMemberListener.getValue().memberIsAvailable( SLAVE, clusterId1, haUri1 );
// then
assertThat(
members.getMembers(),
CoreMatchers.<ClusterMember>hasItem( sameMemberAs( new ClusterMember(
clusterId1 ).availableAs( SLAVE, haUri1 ) ) ) );
}
@Test
public void membersShowsAsUnavailableWhenNewMasterElectedBeforeTheyBecomeAvailable() throws Exception
{
// given
Cluster cluster = mock(Cluster.class);
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
ClusterMembers members = new ClusterMembers( cluster, heartbeat, clusterMemberEvents, null );
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
listener.getValue().enteredCluster( clusterConfiguration( clusterUri1, clusterUri2, clusterUri3 ) );
ArgumentCaptor<ClusterMemberListener> clusterMemberListener = ArgumentCaptor.forClass( ClusterMemberListener.class );
verify( clusterMemberEvents ).addClusterMemberListener( clusterMemberListener.capture() );
clusterMemberListener.getValue().memberIsAvailable( SLAVE, clusterId1, haUri1 );
// when
clusterMemberListener.getValue().coordinatorIsElected( clusterId2 );
// then
assertThat(
members.getMembers(),
CoreMatchers.<ClusterMember>hasItem( sameMemberAs( new ClusterMember( clusterId1 ) ) ) );
}
@Test
public void failedMemberShowsAsSuch() throws Exception
{
// given
Cluster cluster = mock(Cluster.class);
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
ClusterMembers members = new ClusterMembers( cluster, heartbeat, clusterMemberEvents, null );
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
listener.getValue().enteredCluster( clusterConfiguration( clusterUri1, clusterUri2, clusterUri3 ) );
ArgumentCaptor<HeartbeatListener> heartBeatListener = ArgumentCaptor.forClass( HeartbeatListener.class );
verify( heartbeat ).addHeartbeatListener( heartBeatListener.capture() );
// when
heartBeatListener.getValue().failed( clusterId1);
// then
assertThat(
members.getMembers(),
CoreMatchers.<ClusterMember>hasItem( sameMemberAs( new ClusterMember(
clusterId1 ).failed() ) ) );
}
@Test
public void failedThenAliveMemberShowsAsAlive() throws Exception
{
// given
Cluster cluster = mock(Cluster.class);
Heartbeat heartbeat = mock( Heartbeat.class );
ClusterMemberEvents clusterMemberEvents = mock(ClusterMemberEvents.class);
ClusterMembers members = new ClusterMembers( cluster, heartbeat, clusterMemberEvents, null );
ArgumentCaptor<ClusterListener> listener = ArgumentCaptor.forClass( ClusterListener.class );
verify( cluster ).addClusterListener( listener.capture() );
listener.getValue().enteredCluster( clusterConfiguration( clusterUri1, clusterUri2, clusterUri3 ) );
ArgumentCaptor<HeartbeatListener> heartBeatListener = ArgumentCaptor.forClass( HeartbeatListener.class );
verify( heartbeat ).addHeartbeatListener( heartBeatListener.capture() );
// when
heartBeatListener.getValue().failed( clusterId1 );
heartBeatListener.getValue().alive( clusterId1 );
// then
assertThat(
members.getMembers(),
CoreMatchers.<ClusterMember>hasItem( sameMemberAs( new ClusterMember( clusterId1 ) ) ) );
}
private ClusterConfiguration clusterConfiguration( URI... uris )
{
ClusterConfiguration toReturn = new ClusterConfiguration( "neo4j.ha", StringLogger.SYSTEM, asList( uris ) );
toReturn.joined( clusterId1, clusterUri1 );
toReturn.joined( clusterId2, clusterUri2 );
if ( uris.length == 3 )
{
toReturn.joined( clusterId3, clusterUri3 );
}
return toReturn;
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_member_ClusterMembersTest.java
|
5,150
|
private class HAMHeartbeatListener extends HeartbeatListener.Adapter
{
@Override
public void failed( InstanceId server )
{
if (members.containsKey( server ))
{
members.put( server, getMember( server ).failed() );
}
}
@Override
public void alive( InstanceId server )
{
if (members.containsKey( server ))
members.put( server, getMember( server ).alive() );
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_member_ClusterMembers.java
|
5,151
|
private class HAMClusterMemberListener extends ClusterMemberListener.Adapter
{
private InstanceId masterId = null;
@Override
public void coordinatorIsElected( InstanceId coordinatorId )
{
if ( coordinatorId.equals( this.masterId ) )
{
return;
}
this.masterId = coordinatorId;
Map<InstanceId, ClusterMember> newMembers = new CopyOnWriteHashMap<InstanceId, ClusterMember>();
for ( Map.Entry<InstanceId, ClusterMember> memberEntry : members.entrySet() )
{
newMembers.put( memberEntry.getKey(), memberEntry.getValue().unavailableAs(
HighAvailabilityModeSwitcher.MASTER ).unavailableAs( HighAvailabilityModeSwitcher.SLAVE ) );
}
members.clear();
members.putAll( newMembers );
}
@Override
public void memberIsAvailable( String role, InstanceId instanceId, URI roleUri )
{
members.put( instanceId, getMember( instanceId ).availableAs( role, roleUri ) );
}
@Override
public void memberIsUnavailable( String role, InstanceId unavailableId )
{
ClusterMember member = null;
try
{
member = getMember( unavailableId );
members.put( unavailableId, member.unavailableAs( role ) );
}
catch ( IllegalStateException e )
{
// Unknown member
}
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_member_ClusterMembers.java
|
5,152
|
{
@Override
public boolean accept( ClusterMember item )
{
return item.hasRole( role );
}
};
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_member_ClusterMembers.java
|
5,153
|
{
@Override
public boolean accept( ClusterMember item )
{
return item.isAlive();
}
};
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_member_ClusterMembers.java
|
5,154
|
public static class ClusterMemberMatch
{
private URI member;
private Boolean available;
private Boolean alive;
private String haRole;
private Set<String> uris;
ClusterMemberMatch( URI member )
{
this.member = member;
}
public ClusterMemberMatch available( boolean available )
{
this.available = available;
return this;
}
public ClusterMemberMatch alive( boolean alive )
{
this.alive = alive;
return this;
}
private boolean match( ClusterMemberInfo toMatch )
{
if ( !member.toString().equals( toMatch.getInstanceId() ) )
return false;
if ( available != null && toMatch.isAvailable() != available )
return false;
if ( alive != null && toMatch.isAlive() != alive )
return false;
if ( haRole != null && !haRole.equals( toMatch.getHaRole() ) )
return false;
if ( uris != null && !uris.equals( new HashSet<String>( asList( toMatch.getUris() ) ) ) )
return false;
return true;
}
@Override
public String toString()
{
StringBuilder builder = new StringBuilder( "Member[" + member );
if ( available != null )
builder.append( ", available:" + available );
if ( alive != null )
builder.append( ", alive:" + alive );
if ( haRole != null )
builder.append( ", haRole:" + haRole );
if ( uris != null )
builder.append( ", uris:" + uris );
return builder.append( "]" ).toString();
}
public ClusterMemberMatch haRole( String role )
{
this.haRole = role;
return this;
}
public ClusterMemberMatch uris( URI... uris )
{
this.uris = new HashSet<String>();
for ( URI uri : uris )
this.uris.add( uri.toString() );
return this;
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_member_ClusterMemberMatcher.java
|
5,155
|
{
@Override
public boolean matches( Object instance )
{
if (!(instance instanceof ClusterMember))
return false;
ClusterMember member = ClusterMember.class.cast( instance );
if (!member.getMemberId().equals( clusterMember.getMemberId() ))
return false;
if (!member.isAlive()==clusterMember.isAlive())
return false;
HashSet<URI> memberUris = new HashSet<URI>( Iterables.toList( member.getRoleURIs() ) );
HashSet<URI> clusterMemberUris = new HashSet<URI>( Iterables.toList( clusterMember.getRoleURIs() ) );
if (!memberUris.equals( clusterMemberUris ))
return false;
return true;
}
@Override
public void describeTo( Description description )
{
description.appendText( "member should match " ).appendValue( clusterMember );
}
};
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_member_ClusterMemberMatcher.java
|
5,156
|
public class ClusterMember
{
private final InstanceId memberId;
private final Map<String, URI> roles;
private final boolean alive;
public ClusterMember( InstanceId memberId )
{
this( memberId, Collections.<String, URI>emptyMap(), true );
}
ClusterMember( InstanceId memberId, Map<String, URI> roles, boolean alive )
{
this.memberId = memberId;
this.roles = roles;
this.alive = alive;
}
public InstanceId getMemberId()
{
return memberId;
}
public int getInstanceId()
{
// URI haURI = getHAUri();
//
// if ( haURI != null )
// {
// // Get serverId parameter, default to -1 if it is missing, and parse to integer
// return INTEGER.apply( withDefaults( Functions.<URI, String>constant( "-1" ), parameter( "serverId" ) ).apply( haURI ));
// } else
// {
// return -1;
// }
return getMemberId().toIntegerIndex();
}
public URI getHAUri()
{
URI haURI = roles.get( HighAvailabilityModeSwitcher.MASTER );
if ( haURI == null )
{
haURI = roles.get( HighAvailabilityModeSwitcher.SLAVE );
}
return haURI;
}
public String getHARole()
{
if ( roles.containsKey( HighAvailabilityModeSwitcher.MASTER ) )
{
return HighAvailabilityModeSwitcher.MASTER;
}
if ( roles.containsKey( HighAvailabilityModeSwitcher.SLAVE ) )
{
return HighAvailabilityModeSwitcher.SLAVE;
}
return "UNKNOWN";
}
public boolean hasRole( String role )
{
return roles.containsKey( role );
}
public URI getRoleURI( String role )
{
return roles.get( role );
}
public Iterable<String> getRoles()
{
return roles.keySet();
}
public Iterable<URI> getRoleURIs()
{
return roles.values();
}
public boolean isAlive()
{
return alive;
}
ClusterMember availableAs( String role, URI roleUri )
{
return new ClusterMember( this.memberId, MapUtil.copyAndPut( roles, role, roleUri ), this.alive );
}
ClusterMember unavailableAs( String role )
{
return new ClusterMember( this.memberId, MapUtil.copyAndRemove( roles, role ), this.alive );
}
ClusterMember alive()
{
return new ClusterMember( this.memberId, roles, true );
}
ClusterMember failed()
{
return new ClusterMember( this.memberId, roles, false );
}
@Override
public String toString()
{
return String.format( "cluster URI=%s, alive=%s, roles=%s", memberId.toString(), alive, roles.toString() );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
ClusterMember that = (ClusterMember) o;
if ( !memberId.equals( that.memberId ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return memberId.hashCode();
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_member_ClusterMember.java
|
5,157
|
private static final class HAStateChangeListener implements HighAvailabilityMemberListener
{
boolean masterIsElected = false;
boolean masterIsAvailable = false;
boolean slaveIsAvailable = false;
boolean instanceStops = false;
HighAvailabilityMemberChangeEvent lastEvent = null;
@Override
public void masterIsElected( HighAvailabilityMemberChangeEvent event )
{
masterIsElected = true;
masterIsAvailable = false;
slaveIsAvailable = false;
instanceStops = false;
lastEvent = event;
}
@Override
public void masterIsAvailable( HighAvailabilityMemberChangeEvent event )
{
masterIsElected = false;
masterIsAvailable = true;
slaveIsAvailable = false;
instanceStops = false;
lastEvent = event;
}
@Override
public void slaveIsAvailable( HighAvailabilityMemberChangeEvent event )
{
masterIsElected = false;
masterIsAvailable = false;
slaveIsAvailable = true;
instanceStops = false;
lastEvent = event;
}
@Override
public void instanceStops( HighAvailabilityMemberChangeEvent event )
{
masterIsElected = false;
masterIsAvailable = false;
slaveIsAvailable = false;
instanceStops = true;
lastEvent = event;
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateMachineTest.java
|
5,158
|
public class SimpleHighAvailabilityMemberContext implements HighAvailabilityMemberContext
{
private InstanceId electedMasterId;
private URI availableHaMasterId;
private final InstanceId myId;
public SimpleHighAvailabilityMemberContext( InstanceId myId )
{
this.myId = myId;
}
@Override
public InstanceId getMyId()
{
return myId;
}
@Override
public InstanceId getElectedMasterId()
{
return electedMasterId;
}
@Override
public void setElectedMasterId( InstanceId electedMasterId )
{
this.electedMasterId = electedMasterId;
}
@Override
public URI getAvailableHaMaster()
{
return availableHaMasterId;
}
@Override
public void setAvailableHaMasterId( URI availableHaMasterId )
{
this.availableHaMasterId = availableHaMasterId;
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_SimpleHighAvailabilityMemberContext.java
|
5,159
|
public class HighAvailabilityModeSwitcherTest
{
@Test
public void shouldBroadcastMasterIsAvailableIfMasterAndReceiveMasterIsElected() throws Exception
{
// Given
ClusterMemberAvailability availability = mock( ClusterMemberAvailability.class );
HighAvailabilityModeSwitcher toTest = new HighAvailabilityModeSwitcher( mock( BindingNotifier.class ),
mock( DelegateInvocationHandler.class ), availability,
mock( HighAvailabilityMemberStateMachine.class), mock( GraphDatabaseAPI.class ),
mock( HaIdGeneratorFactory.class ), mock( Config.class ), mock( Logging.class ), mock(
UpdateableSchemaState.class), Iterables.<KernelExtensionFactory<?>>empty(), new Monitors(),
mock( RequestContextFactory.class ) );
// When
toTest.masterIsElected( new HighAvailabilityMemberChangeEvent( HighAvailabilityMemberState.MASTER,
HighAvailabilityMemberState.MASTER, new InstanceId( 2 ), URI.create( "ha://someone" ) ) );
// Then
/*
* The second argument to memberIsAvailable below is null because it has not been set yet. This would require
* a switch to master which we don't do here.
*/
verify( availability, times( 1 ) ).memberIsAvailable( HighAvailabilityModeSwitcher.MASTER, null );
}
@Test
public void shouldBroadcastSlaveIsAvailableIfSlaveAndReceivesMasterIsAvailable() throws Exception
{
// Given
ClusterMemberAvailability availability = mock( ClusterMemberAvailability.class );
HighAvailabilityModeSwitcher toTest = new HighAvailabilityModeSwitcher( mock( BindingNotifier.class ),
mock( DelegateInvocationHandler.class ), availability,
mock( HighAvailabilityMemberStateMachine.class), mock( GraphDatabaseAPI.class ),
mock( HaIdGeneratorFactory.class ), mock( Config.class ), mock( Logging.class ), mock(
UpdateableSchemaState.class), Iterables.<KernelExtensionFactory<?>>empty(),
new Monitors(), mock( RequestContextFactory.class ) );
// When
toTest.masterIsAvailable( new HighAvailabilityMemberChangeEvent( HighAvailabilityMemberState.SLAVE,
HighAvailabilityMemberState.SLAVE, new InstanceId( 2 ), URI.create( "ha://someone" ) ) );
// Then
/*
* The second argument to memberIsAvailable below is null because it has not been set yet. This would require
* a switch to master which we don't do here.
*/
verify( availability, times( 1 ) ).memberIsAvailable( HighAvailabilityModeSwitcher.SLAVE, null );
}
@Test
public void shouldNotBroadcastIfSlaveAndReceivesMasterIsElected() throws Exception
{
// Given
ClusterMemberAvailability availability = mock( ClusterMemberAvailability.class );
HighAvailabilityModeSwitcher toTest = new HighAvailabilityModeSwitcher( mock( BindingNotifier.class ),
mock( DelegateInvocationHandler.class ), availability,
mock( HighAvailabilityMemberStateMachine.class), mock( GraphDatabaseAPI.class ),
mock( HaIdGeneratorFactory.class ), mock( Config.class ), mock( Logging.class ), mock(
UpdateableSchemaState.class), Iterables.<KernelExtensionFactory<?>>empty(),
new Monitors(), mock( RequestContextFactory.class ) );
// When
toTest.masterIsElected( new HighAvailabilityMemberChangeEvent( HighAvailabilityMemberState.SLAVE,
HighAvailabilityMemberState.SLAVE, new InstanceId( 2 ), URI.create( "ha://someone" ) ) );
// Then
/*
* The second argument to memberIsAvailable below is null because it has not been set yet. This would require
* a switch to master which we don't do here.
*/
verifyZeroInteractions( availability );
}
@Test
public void shouldNotBroadcastIfMasterAndReceivesSlaveIsAvailable() throws Exception
{
// Given
ClusterMemberAvailability availability = mock( ClusterMemberAvailability.class );
HighAvailabilityModeSwitcher toTest = new HighAvailabilityModeSwitcher( mock( BindingNotifier.class ),
mock( DelegateInvocationHandler.class ), availability,
mock( HighAvailabilityMemberStateMachine.class), mock( GraphDatabaseAPI.class ),
mock( HaIdGeneratorFactory.class ), mock( Config.class ), mock( Logging.class ), mock(
UpdateableSchemaState.class), Iterables.<KernelExtensionFactory<?>>empty(),
new Monitors(), mock( RequestContextFactory.class ) );
// When
toTest.slaveIsAvailable( new HighAvailabilityMemberChangeEvent( HighAvailabilityMemberState.MASTER,
HighAvailabilityMemberState.MASTER, new InstanceId( 2 ), URI.create( "ha://someone" ) ) );
// Then
/*
* The second argument to memberIsAvailable below is null because it has not been set yet. This would require
* a switch to master which we don't do here.
*/
verifyZeroInteractions( availability );
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityModeSwitcherTest.java
|
5,160
|
{
@Override
public Response<?> copyStore( StoreWriter writer )
{
return copyMaster.copyStore( new RequestContext( 0,
config.get( ClusterSettings.server_id ), 0, new RequestContext.Tx[0], 0, 0 ), writer );
}
@Override
public void done()
{
}
} );
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityModeSwitcher.java
|
5,161
|
{
@Override
public long getOldChannelThreshold()
{
return config.get( HaSettings.lock_read_timeout );
}
@Override
public int getMaxConcurrentTransactions()
{
return config.get( HaSettings.max_concurrent_channels_per_slave );
}
@Override
public int getChunkSize()
{
return config.get( HaSettings.com_chunk_size ).intValue();
}
@Override
public HostnamePort getServerAddress()
{
return config.get( HaSettings.ha_server );
}
};
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityModeSwitcher.java
|
5,162
|
{
@Override
public void run()
{
if (haCommunicationLife.getStatus() == LifecycleStatus.STARTED)
{
return; // Already switched - this can happen if a second master becomes available while waiting
}
try
{
haCommunicationLife = new LifeSupport();
URI masterUri = availableMasterId;
console.log( "ServerId " + config.get( ClusterSettings.server_id ) + ", moving to slave for master " +
masterUri );
assert masterUri != null; // since we are here it must already have been set from outside
DependencyResolver resolver = graphDb.getDependencyResolver();
HaXaDataSourceManager xaDataSourceManager = resolver.resolveDependency(
HaXaDataSourceManager.class );
idGeneratorFactory.switchToSlave();
synchronized ( xaDataSourceManager )
{
if ( !isStorePresent( resolver.resolveDependency( FileSystemAbstraction.class ), config ) )
{
copyStoreFromMaster( masterUri );
}
/*
* We get here either with a fresh store from the master copy above so we need to start the ds
* or we already had a store, so we have already started the ds. Either way, make sure it's there.
*/
NeoStoreXaDataSource nioneoDataSource = ensureDataSourceStarted( xaDataSourceManager, resolver );
if ( checkDataConsistency( xaDataSourceManager,
resolver.resolveDependency( RequestContextFactory.class ), nioneoDataSource, masterUri ) )
{
if ( startHaCommunication( xaDataSourceManager, nioneoDataSource, masterUri ) )
{
console.log( "ServerId " + config.get( ClusterSettings.server_id ) +
", successfully moved to slave for master " + masterUri );
return; // Done
}
}
}
}
catch ( Throwable t )
{
msgLog.logMessage( "Error while trying to switch to slave", t );
}
haCommunicationLife.shutdown();
// Try again later
wait.set( (1 + wait.get()*2) ); // Exponential backoff
wait.set(Math.min(wait.get(), 5*60)); // Wait maximum 5 minutes
scheduledExecutorService.schedule( this, wait.get(), TimeUnit.SECONDS );
msgLog.logMessage( "Attempting to switch to slave in "+wait.get()+"s");
}
}, wait.get(), TimeUnit.SECONDS);
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityModeSwitcher.java
|
5,163
|
{
@Override
public void listeningAt( URI myUri )
{
me = myUri;
}
};
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityModeSwitcher.java
|
5,164
|
public class HighAvailabilityModeSwitcher implements HighAvailabilityMemberListener, Lifecycle
{
// TODO solve this with lifecycle instance grouping or something
@SuppressWarnings( "rawtypes" )
private static final Class[] SERVICES_TO_RESTART_FOR_STORE_COPY = new Class[] {
StoreLockerLifecycleAdapter.class,
XaDataSourceManager.class,
TransactionManager.class,
NodeManager.class,
IndexStore.class
};
public static final String MASTER = "master";
public static final String SLAVE = "slave";
private URI masterHaURI;
public static final String INADDR_ANY = "0.0.0.0";
private URI slaveHaURI;
private BindingListener bindingListener;
public static int getServerId( URI haUri )
{
// Get serverId parameter, default to -1 if it is missing, and parse to integer
return INTEGER.apply( withDefaults(
Functions.<URI, String>constant( "-1" ), parameter( "serverId" ) ).apply( haUri ));
}
private URI availableMasterId;
private final HighAvailabilityMemberStateMachine stateHandler;
private final BindingNotifier bindingNotifier;
private final DelegateInvocationHandler<Master> masterDelegateHandler;
private final ClusterMemberAvailability clusterMemberAvailability;
private final GraphDatabaseAPI graphDb;
private final Config config;
private LifeSupport haCommunicationLife;
private final StringLogger msgLog;
private final ConsoleLogger console;
private final HaIdGeneratorFactory idGeneratorFactory;
private final Logging logging;
private final UpdateableSchemaState updateableSchemaState;
private final Iterable<KernelExtensionFactory<?>> kernelExtensions;
private final Monitors monitors;
private final RequestContextFactory requestContextFactory;
private MasterClientResolver masterClientResolver;
private ScheduledExecutorService scheduledExecutorService;
private volatile URI me;
public HighAvailabilityModeSwitcher( BindingNotifier bindingNotifier,
DelegateInvocationHandler<Master> delegateHandler,
ClusterMemberAvailability clusterMemberAvailability,
HighAvailabilityMemberStateMachine stateHandler, GraphDatabaseAPI graphDb,
HaIdGeneratorFactory idGeneratorFactory, Config config, Logging logging,
UpdateableSchemaState updateableSchemaState,
Iterable<KernelExtensionFactory<?>> kernelExtensions, Monitors monitors,
RequestContextFactory requestContextFactory )
{
this.bindingNotifier = bindingNotifier;
this.masterDelegateHandler = delegateHandler;
this.clusterMemberAvailability = clusterMemberAvailability;
this.graphDb = graphDb;
this.idGeneratorFactory = idGeneratorFactory;
this.config = config;
this.logging = logging;
this.updateableSchemaState = updateableSchemaState;
this.kernelExtensions = kernelExtensions;
this.monitors = monitors;
this.requestContextFactory = requestContextFactory;
this.msgLog = logging.getMessagesLog( getClass() );
this.haCommunicationLife = new LifeSupport();
this.stateHandler = stateHandler;
this.console = logging.getConsoleLog( getClass() );
}
@Override
public synchronized void init() throws Throwable
{
scheduledExecutorService = Executors.newSingleThreadScheduledExecutor( );
stateHandler.addHighAvailabilityMemberListener( this );
bindingListener = new BindingListener()
{
@Override
public void listeningAt( URI myUri )
{
me = myUri;
}
};
bindingNotifier.addBindingListener( bindingListener );
haCommunicationLife.init();
}
@Override
public synchronized void start() throws Throwable
{
haCommunicationLife.start();
}
@Override
public synchronized void stop() throws Throwable
{
haCommunicationLife.stop();
}
@Override
public synchronized void shutdown() throws Throwable
{
stateHandler.removeHighAvailabilityMemberListener( this );
bindingNotifier.removeBindingListener( bindingListener );
scheduledExecutorService.shutdown();
scheduledExecutorService.awaitTermination( 60, TimeUnit.SECONDS );
haCommunicationLife.shutdown();
}
@Override
public void masterIsElected( HighAvailabilityMemberChangeEvent event )
{
if ( event.getNewState() == event.getOldState() && event.getOldState() == HighAvailabilityMemberState.MASTER )
{
clusterMemberAvailability.memberIsAvailable( MASTER, masterHaURI );
}
else
{
stateChanged( event );
}
}
@Override
public void masterIsAvailable( HighAvailabilityMemberChangeEvent event )
{
if ( event.getNewState() == event.getOldState() && event.getOldState() == HighAvailabilityMemberState.SLAVE )
{
clusterMemberAvailability.memberIsAvailable( SLAVE, slaveHaURI );
}
else
{
stateChanged( event );
}
}
@Override
public void slaveIsAvailable( HighAvailabilityMemberChangeEvent event )
{
// ignored, we don't do any mode switching in slave available events
}
@Override
public void instanceStops( HighAvailabilityMemberChangeEvent event )
{
stateChanged( event );
}
private void stateChanged( HighAvailabilityMemberChangeEvent event )
{
availableMasterId = event.getServerHaUri();
if ( event.getNewState() == event.getOldState() )
{
return;
}
switch ( event.getNewState() )
{
case TO_MASTER:
haCommunicationLife.shutdown();
haCommunicationLife = new LifeSupport();
if ( event.getOldState().equals( HighAvailabilityMemberState.SLAVE ) )
{
clusterMemberAvailability.memberIsUnavailable( SLAVE );
}
switchToMaster();
break;
case TO_SLAVE:
haCommunicationLife.shutdown();
switchToSlave();
break;
case PENDING:
if ( event.getOldState().equals( HighAvailabilityMemberState.SLAVE ) )
{
clusterMemberAvailability.memberIsUnavailable( SLAVE );
}
else if ( event.getOldState().equals( HighAvailabilityMemberState.MASTER ) )
{
clusterMemberAvailability.memberIsUnavailable( MASTER );
}
haCommunicationLife.shutdown();
haCommunicationLife = new LifeSupport();
break;
default:
// do nothing
}
}
private void switchToMaster()
{
msgLog.logMessage( "I am " + config.get( ClusterSettings.server_id ) + ", moving to master" );
try
{
DependencyResolver resolver = graphDb.getDependencyResolver();
HaXaDataSourceManager xaDataSourceManager = resolver.resolveDependency( HaXaDataSourceManager.class );
synchronized ( xaDataSourceManager )
{
//noinspection SynchronizationOnLocalVariableOrMethodParameter
final TransactionManager txManager = graphDb.getDependencyResolver()
.resolveDependency( TransactionManager.class );
idGeneratorFactory.switchToMaster();
Monitors monitors = graphDb.getDependencyResolver().resolveDependency( Monitors.class );
MasterImpl.SPI spi = new DefaultMasterImplSPI( graphDb, logging, txManager, monitors );
MasterImpl masterImpl = new MasterImpl( spi, monitors.newMonitor( MasterImpl.Monitor.class ),
logging, config );
MasterServer masterServer = new MasterServer( masterImpl, logging, serverConfig(),
new BranchDetectingTxVerifier( graphDb ),
monitors );
haCommunicationLife.add( masterImpl );
haCommunicationLife.add( masterServer );
assignMaster( masterImpl );
idGeneratorFactory.switchToMaster();
haCommunicationLife.start();
masterHaURI = URI.create( "ha://" + (ServerUtil.getHostString( masterServer.getSocketAddress() ).contains
( "0.0.0.0" ) ? me.getHost() : ServerUtil.getHostString( masterServer.getSocketAddress() )) + ":" +
masterServer.getSocketAddress().getPort() + "?serverId=" +
config.get( ClusterSettings.server_id ) );
clusterMemberAvailability.memberIsAvailable( MASTER, masterHaURI );
msgLog.logMessage( "I am " + config.get( ClusterSettings.server_id ) +
", successfully moved to master" );
}
}
catch ( Throwable e )
{
msgLog.logMessage( "Failed to switch to master", e );
}
}
private void assignMaster( Master master )
{
masterDelegateHandler.setDelegate( master );
}
private URI createHaURI( Server<?,?> server )
{
String hostString = ServerUtil.getHostString( server.getSocketAddress() );
int port = server.getSocketAddress().getPort();
Integer serverId = config.get( ClusterSettings.server_id );
String host = hostString.contains( INADDR_ANY ) ? me.getHost() : hostString;
return URI.create( "ha://" + host + ":" + port + "?serverId=" + serverId );
}
private void switchToSlave()
{
this.masterClientResolver = new MasterClientResolver( logging,
config.get( HaSettings.read_timeout ).intValue(),
config.get( HaSettings.lock_read_timeout ).intValue(),
config.get( HaSettings.max_concurrent_channels_per_slave ).intValue(),
config.get( HaSettings.com_chunk_size ).intValue() );
// Do this with a scheduler, so that if it fails, it can retry later with an exponential backoff with max wait time.
final AtomicLong wait = new AtomicLong();
scheduledExecutorService.schedule( new Runnable()
{
@Override
public void run()
{
if (haCommunicationLife.getStatus() == LifecycleStatus.STARTED)
{
return; // Already switched - this can happen if a second master becomes available while waiting
}
try
{
haCommunicationLife = new LifeSupport();
URI masterUri = availableMasterId;
console.log( "ServerId " + config.get( ClusterSettings.server_id ) + ", moving to slave for master " +
masterUri );
assert masterUri != null; // since we are here it must already have been set from outside
DependencyResolver resolver = graphDb.getDependencyResolver();
HaXaDataSourceManager xaDataSourceManager = resolver.resolveDependency(
HaXaDataSourceManager.class );
idGeneratorFactory.switchToSlave();
synchronized ( xaDataSourceManager )
{
if ( !isStorePresent( resolver.resolveDependency( FileSystemAbstraction.class ), config ) )
{
copyStoreFromMaster( masterUri );
}
/*
* We get here either with a fresh store from the master copy above so we need to start the ds
* or we already had a store, so we have already started the ds. Either way, make sure it's there.
*/
NeoStoreXaDataSource nioneoDataSource = ensureDataSourceStarted( xaDataSourceManager, resolver );
if ( checkDataConsistency( xaDataSourceManager,
resolver.resolveDependency( RequestContextFactory.class ), nioneoDataSource, masterUri ) )
{
if ( startHaCommunication( xaDataSourceManager, nioneoDataSource, masterUri ) )
{
console.log( "ServerId " + config.get( ClusterSettings.server_id ) +
", successfully moved to slave for master " + masterUri );
return; // Done
}
}
}
}
catch ( Throwable t )
{
msgLog.logMessage( "Error while trying to switch to slave", t );
}
haCommunicationLife.shutdown();
// Try again later
wait.set( (1 + wait.get()*2) ); // Exponential backoff
wait.set(Math.min(wait.get(), 5*60)); // Wait maximum 5 minutes
scheduledExecutorService.schedule( this, wait.get(), TimeUnit.SECONDS );
msgLog.logMessage( "Attempting to switch to slave in "+wait.get()+"s");
}
}, wait.get(), TimeUnit.SECONDS);
}
private boolean startHaCommunication( HaXaDataSourceManager xaDataSourceManager,
NeoStoreXaDataSource nioneoDataSource, URI masterUri )
{
try
{
MasterClient master = newMasterClient( masterUri, nioneoDataSource.getStoreId(), haCommunicationLife );
Slave slaveImpl = new SlaveImpl( nioneoDataSource.getStoreId(), master,
new RequestContextFactory( getServerId( masterUri ), xaDataSourceManager,
graphDb.getDependencyResolver() ), xaDataSourceManager );
SlaveServer server = new SlaveServer( slaveImpl, serverConfig(), logging,
graphDb.getDependencyResolver().resolveDependency( Monitors.class ) );
assignMaster( master );
haCommunicationLife.add( slaveImpl );
haCommunicationLife.add( server );
haCommunicationLife.start();
slaveHaURI = createHaURI( server );
clusterMemberAvailability.memberIsAvailable( SLAVE, slaveHaURI );
return true;
}
catch ( Throwable t )
{
msgLog.logMessage( "Got exception while starting HA communication", t );
haCommunicationLife.shutdown();
haCommunicationLife = new LifeSupport();
}
return false;
}
private Server.Configuration serverConfig()
{
return new Server.Configuration()
{
@Override
public long getOldChannelThreshold()
{
return config.get( HaSettings.lock_read_timeout );
}
@Override
public int getMaxConcurrentTransactions()
{
return config.get( HaSettings.max_concurrent_channels_per_slave );
}
@Override
public int getChunkSize()
{
return config.get( HaSettings.com_chunk_size ).intValue();
}
@Override
public HostnamePort getServerAddress()
{
return config.get( HaSettings.ha_server );
}
};
}
private boolean checkDataConsistency( HaXaDataSourceManager xaDataSourceManager,
RequestContextFactory requestContextFactory,
NeoStoreXaDataSource nioneoDataSource, URI masterUri ) throws Throwable
{
// Must be called under lock on XaDataSourceManager
LifeSupport checkConsistencyLife = new LifeSupport();
try
{
MasterClient checkConsistencyMaster = newMasterClient( masterUri, nioneoDataSource.getStoreId(),
checkConsistencyLife );
checkConsistencyLife.start();
console.log( "Checking store consistency with master" );
checkDataConsistencyWithMaster( checkConsistencyMaster, nioneoDataSource );
console.log( "Store is consistent" );
/*
* Pull updates, since the store seems happy and everything. No matter how far back we are, this is just
* one thread doing the pulling, while the guard is up. This will prevent a race between all transactions
* that may start the moment the database becomes available, where all of them will pull the same txs from
* the master but eventually only one will get to apply them.
*/
console.log( "Catching up with master" );
RequestContext context = requestContextFactory.newRequestContext( -1 );
xaDataSourceManager.applyTransactions( checkConsistencyMaster.pullUpdates( context ) );
console.log( "Now consistent with master" );
return true;
}
catch ( StoreUnableToParticipateInClusterException upe )
{
console.log( "The store is inconsistent. Will treat it as branched and fetch a new one from the master" );
msgLog.warn( "Current store is unable to participate in the cluster; fetching new store from master", upe );
try
{
// Unregistering from a running DSManager stops the datasource
xaDataSourceManager.unregisterDataSource( NeoStoreXaDataSource.DEFAULT_DATA_SOURCE_NAME );
stopServicesAndHandleBranchedStore( config.get( HaSettings.branched_data_policy ) );
}
catch ( IOException e )
{
msgLog.warn( "Failed while trying to handle branched data", e );
}
}
catch ( MismatchingStoreIdException e )
{
console.log( "The store does not represent the same database as master. Will remove and fetch a new one from master" );
if ( nioneoDataSource.getNeoStore().getLastCommittedTx() == 1 )
{
msgLog.warn( "Found and deleting empty store with mismatching store id " + e.getMessage() );
stopServicesAndHandleBranchedStore( BranchedDataPolicy.keep_none );
}
else
{
msgLog.error( "Store cannot participate in cluster due to mismatching store IDs" );
throw e;
}
}
catch ( Throwable throwable )
{
msgLog.warn( "Consistency checker failed", throwable );
}
finally
{
checkConsistencyLife.shutdown();
}
return false;
}
private NeoStoreXaDataSource ensureDataSourceStarted( XaDataSourceManager xaDataSourceManager, DependencyResolver resolver )
{
// Must be called under lock on XaDataSourceManager
NeoStoreXaDataSource nioneoDataSource = (NeoStoreXaDataSource) xaDataSourceManager.getXaDataSource(
NeoStoreXaDataSource.DEFAULT_DATA_SOURCE_NAME );
if ( nioneoDataSource == null )
{
nioneoDataSource = new NeoStoreXaDataSource( config,
resolver.resolveDependency( StoreFactory.class ),
resolver.resolveDependency( StringLogger.class ),
resolver.resolveDependency( XaFactory.class ),
resolver.resolveDependency( TransactionStateFactory.class ),
resolver.resolveDependency( TransactionInterceptorProviders.class ),
resolver.resolveDependency( JobScheduler.class ),
logging,
updateableSchemaState,
new NonTransactionalTokenNameLookup(
resolver.resolveDependency( LabelTokenHolder.class ),
resolver.resolveDependency( PropertyKeyTokenHolder.class ) ),
resolver,
resolver.resolveDependency( AbstractTransactionManager.class ),
resolver.resolveDependency( PropertyKeyTokenHolder.class ),
resolver.resolveDependency( LabelTokenHolder.class ),
resolver.resolveDependency( RelationshipTypeTokenHolder.class ),
resolver.resolveDependency( PersistenceManager.class ),
resolver.resolveDependency( LockManager.class ),
(SchemaWriteGuard)graphDb, monitors.newMonitor( IndexingService.Monitor.class ));
xaDataSourceManager.registerDataSource( nioneoDataSource );
/*
* CAUTION: The next line may cause severe eye irritation, mental instability and potential
* emotional breakdown. On the plus side, it is correct.
* See, it is quite possible to get here without the NodeManager having stopped, because we don't
* properly manage lifecycle in this class (this is the cause of this ugliness). So, after we
* register the datasource with the DsMgr we need to make sure that NodeManager re-reads the reltype
* and propindex information. Normally, we would have shutdown everything before getting here.
*/
resolver.resolveDependency( NodeManager.class ).start();
}
return nioneoDataSource;
}
private void copyStoreFromMaster( URI masterUri ) throws Throwable
{
FileSystemAbstraction fs = graphDb.getDependencyResolver().resolveDependency( FileSystemAbstraction.class );
// Must be called under lock on XaDataSourceManager
LifeSupport life = new LifeSupport();
try
{
// Remove the current store - neostore file is missing, nothing we can really do
stopServicesAndHandleBranchedStore( BranchedDataPolicy.keep_none );
final MasterClient copyMaster = newMasterClient( masterUri, null, life );
life.start();
// This will move the copied db to the graphdb location
console.log( "Copying store from master" );
new RemoteStoreCopier( config, kernelExtensions, console,
fs ).copyStore( new RemoteStoreCopier.StoreCopyRequester()
{
@Override
public Response<?> copyStore( StoreWriter writer )
{
return copyMaster.copyStore( new RequestContext( 0,
config.get( ClusterSettings.server_id ), 0, new RequestContext.Tx[0], 0, 0 ), writer );
}
@Override
public void done()
{
}
} );
startServicesAgain();
console.log( "Finished copying store from master" );
}
finally
{
life.stop();
}
}
private MasterClient newMasterClient( URI masterUri, StoreId storeId, LifeSupport life )
{
return masterClientResolver.instantiate( masterUri.getHost(), masterUri.getPort(),
graphDb.getDependencyResolver().resolveDependency( Monitors.class ), storeId, life );
}
private void startServicesAgain() throws Throwable
{
@SuppressWarnings( "rawtypes" )
List<Class> services = new ArrayList<>( Arrays.asList( SERVICES_TO_RESTART_FOR_STORE_COPY ) );
for ( Class<?> serviceClass : services )
{
Lifecycle service = (Lifecycle) graphDb.getDependencyResolver().resolveDependency( serviceClass );
service.start();
}
}
private void stopServicesAndHandleBranchedStore( BranchedDataPolicy branchPolicy ) throws Throwable
{
List<Class> services = new ArrayList<>( Arrays.asList( SERVICES_TO_RESTART_FOR_STORE_COPY ) );
Collections.reverse( services );
for ( Class<?> serviceClass : services )
{
Lifecycle service = (Lifecycle) graphDb.getDependencyResolver().resolveDependency( serviceClass );
service.stop();
}
branchPolicy.handle( config.get( InternalAbstractGraphDatabase.Configuration.store_dir ) );
}
private void checkDataConsistencyWithMaster( Master master, NeoStoreXaDataSource nioneoDataSource )
{
long myLastCommittedTx = nioneoDataSource.getLastCommittedTxId();
Pair<Integer, Long> myMaster;
try
{
myMaster = nioneoDataSource.getMasterForCommittedTx( myLastCommittedTx );
}
catch ( NoSuchLogVersionException e )
{
msgLog.logMessage(
"Logical log file for txId "
+ myLastCommittedTx
+ " missing [version="
+ e.getVersion()
+ "]. If this is startup then it will be recovered later, " +
"otherwise it might be a problem." );
return;
}
catch ( IOException e )
{
msgLog.logMessage( "Failed to get master ID for txId " + myLastCommittedTx + ".", e );
return;
}
catch ( Exception e )
{
throw new BranchedDataException( "Exception while getting master ID for txId "
+ myLastCommittedTx + ".", e );
}
HandshakeResult handshake;
try ( Response<HandshakeResult> response = master.handshake( myLastCommittedTx, nioneoDataSource.getStoreId() ) )
{
handshake = response.response();
requestContextFactory.setEpoch( handshake.epoch() );
}
catch( BranchedDataException e )
{
// Rethrow wrapped in a branched data exception on our side, to clarify where the problem originates.
throw new BranchedDataException( "Master detected branched data for this machine.", e );
}
catch ( RuntimeException e )
{
// Checked exceptions will be wrapped as the cause if this was a serialized
// server-side exception
if ( e.getCause() instanceof MissingLogDataException )
{
/*
* This means the master was unable to find a log entry for the txid we just asked. This
* probably means the thing we asked for is too old or too new. Anyway, since it doesn't
* have the tx it is better if we just throw our store away and ask for a new copy. Next
* time around it shouldn't have to even pass from here.
*/
throw new StoreOutOfDateException( "The master is missing the log required to complete the " +
"consistency check", e.getCause() );
}
throw e;
}
if ( myMaster.first() != XaLogicalLog.MASTER_ID_REPRESENTING_NO_MASTER &&
(myMaster.first() != handshake.txAuthor() || myMaster.other() != handshake.txChecksum()) )
{
String msg = "Branched data, I (machineId:" + config.get( ClusterSettings.server_id ) + ") think machineId for" +
" txId (" +
myLastCommittedTx + ") is " + myMaster + ", but master (machineId:" +
getServerId( availableMasterId ) + ") says that it's " + handshake;
throw new BranchedDataException( msg );
}
msgLog.logMessage( "Master id for last committed tx ok with highestTxId=" +
myLastCommittedTx + " with masterId=" + myMaster, true );
}
}
| false
|
enterprise_ha_src_main_java_org_neo4j_kernel_ha_cluster_HighAvailabilityModeSwitcher.java
|
5,165
|
public class HighAvailabilityMemberStateTest
{
public static final URI SampleUri = URI.create( "ha://foo" );
private InstanceId myId;
private HighAvailabilityMemberContext context;
@Before
public void setup()
{
myId = new InstanceId( 1 );
context = mock( HighAvailabilityMemberContext.class );
when( context.getMyId() ).thenReturn( myId );
}
@Test
public void testPendingMasterIsElected()
{
// CASE 1: Got MasterIsElected for me - should switch to TO_MASTER
HighAvailabilityMemberState newState = PENDING.masterIsElected( context, myId );
assertEquals( TO_MASTER, newState );
// CASE 2: Got MasterIsElected for someone else - should remain to PENDING
HighAvailabilityMemberState newStateCase2 = PENDING.masterIsElected( context, new InstanceId( 2 ) );
assertEquals( PENDING, newStateCase2 );
}
@Test
public void testPendingMasterIsAvailable()
{
// CASE 1: Got MasterIsAvailable for me - should not happen
try
{
PENDING.masterIsAvailable( context, myId, SampleUri );
fail( "Should not accept MasterIsAvailable for myself from PENDING" );
}
catch( RuntimeException e )
{
// marvellous
}
// CASE 2: Got MasterIsAvailable for someone else - should transition to TO_SLAVE
// TODO test correct info is passed through to context
HighAvailabilityMemberState newState = PENDING.masterIsAvailable( context, new InstanceId( 2 ), SampleUri );
assertEquals( TO_SLAVE, newState );
}
@Test
public void testPendingSlaveIsAvailable()
{
// CASE 1: Got SlaveIsAvailable for me - should not happen, that's what TO_SLAVE exists for
try
{
PENDING.slaveIsAvailable( context, myId, SampleUri );
fail( "Should not accept SlaveIsAvailable for myself from PENDING" );
}
catch( RuntimeException e )
{
// marvellous
}
// CASE 2: Got SlaveIsAvailable for someone else - it's ok, remain in PENDING
HighAvailabilityMemberState newState = PENDING.slaveIsAvailable( context, new InstanceId( 2 ), SampleUri );
assertEquals( PENDING, newState );
}
@Test
public void testToMasterMasterIsElected()
{
// CASE 1: Got MasterIsElected for me - it's ok, continue in TO_MASTER
HighAvailabilityMemberState newState = TO_MASTER.masterIsElected( context, myId );
assertEquals( TO_MASTER, newState );
// CASE 2: Got MasterIsElected for someone else - switch to PENDING
HighAvailabilityMemberState newStateCase2 = TO_MASTER.masterIsElected( context, new InstanceId( 2 ) );
assertEquals( PENDING, newStateCase2 );
}
@Test
public void testToMasterMasterIsAvailable()
{
// CASE 1: Got MasterIsAvailable for me - it's ok, that means we completed switching and should to to MASTER
HighAvailabilityMemberState newState = TO_MASTER.masterIsAvailable( context, myId, SampleUri );
assertEquals( MASTER, newState );
// CASE 2: Got MasterIsAvailable for someone else - should not happen, should have received a MasterIsElected
try
{
TO_MASTER.masterIsAvailable( context, new InstanceId( 2 ), SampleUri );
fail( "Should not accept MasterIsAvailable for someone else from TO_MASTER" );
}
catch( RuntimeException e )
{
// marvellous
}
}
@Test
public void testToMasterSlaveIsAvailable()
{
// CASE 1: Got SlaveIsAvailable for me - not ok, i'm currently switching to master
try
{
TO_MASTER.slaveIsAvailable( context, myId, SampleUri );
fail( "Should not accept SlaveIsAvailable for me while in TO_MASTER" );
}
catch( RuntimeException e )
{
// marvellous
}
// CASE 2: Got SlaveIsAvailable for someone else - don't really care
HighAvailabilityMemberState newState = TO_MASTER.slaveIsAvailable( context, new InstanceId( 2 ), SampleUri );
assertEquals( TO_MASTER, newState );
}
@Test
public void testMasterMasterIsElected()
{
// CASE 1: Got MasterIsElected for me. Should remain master.
HighAvailabilityMemberState newState = MASTER.masterIsElected( context, myId );
assertEquals( MASTER, newState );
// CASE 2: Got MasterIsElected for someone else. Should switch to pending.
HighAvailabilityMemberState newStateCase2 = MASTER.masterIsElected( context, new InstanceId( 2 ) );
assertEquals( PENDING, newStateCase2 );
}
@Test
public void testMasterMasterIsAvailable()
{
// CASE 1: Got MasterIsAvailable for someone else - should fail.
try
{
MASTER.masterIsAvailable( context, new InstanceId( 2 ), SampleUri );
fail( "Should not allow master switch with missing masterIsElected" );
}
catch ( RuntimeException e )
{
// wonderful
}
// CASE 2: Got MasterIsAvailable for us - it's ok, should pass
HighAvailabilityMemberState newState = MASTER.masterIsAvailable( context, myId, SampleUri );
assertEquals( MASTER, newState );
}
@Test
public void testMasterSlaveIsAvailable()
{
// CASE 1: Got SlaveIsAvailable for me - should fail.
try
{
MASTER.slaveIsAvailable( context, myId, SampleUri );
fail( "MASTER to SLAVE is not allowed" );
}
catch( RuntimeException e )
{
// awesome
}
// CASE 2: Got SlaveIsAvailable for someone else - who cares? Should succeed.
HighAvailabilityMemberState newState = MASTER.slaveIsAvailable( context, new InstanceId( 2 ), SampleUri );
assertEquals( MASTER, newState );
}
@Test
public void testToSlaveMasterIsElected()
{
// CASE 1: Got MasterIsElected for me - should switch to TO_MASTER
HighAvailabilityMemberState newState = TO_SLAVE.masterIsElected( context, myId );
assertEquals( TO_MASTER, newState );
// CASE 2: Got MasterIsElected for someone else - should switch to PENDING
HighAvailabilityMemberState newStateCase2 = TO_SLAVE.masterIsElected( context, new InstanceId( 2 ) );
assertEquals( PENDING, newStateCase2 );
}
@Test
public void testToSlaveMasterIsAvailable()
{
// CASE 1: Got MasterIsAvailable for me - should fail, i am currently trying to become slave
try
{
TO_SLAVE.masterIsAvailable( context, myId, SampleUri );
fail( "TO_SLAVE to MASTER is not allowed" );
}
catch( RuntimeException e )
{
// fantastic
}
// CASE 2: Got MasterIsAvailable for someone else who is already the master - should continue switching
InstanceId currentMaster = new InstanceId( 2 );
when( context.getElectedMasterId() ).thenReturn( currentMaster );
HighAvailabilityMemberState newState = TO_SLAVE.masterIsAvailable( context, currentMaster, SampleUri );
assertEquals( TO_SLAVE, newState );
// CASE 3: Got MasterIsAvailable for someone else who is not the master - should fail
try
{
TO_SLAVE.masterIsAvailable( context, new InstanceId( 3 ), SampleUri );
fail( "Should have gotten an election result first" );
}
catch( RuntimeException e )
{
// phenomenal
}
}
@Test
public void testToSlaveSlaveIsAvailable()
{
// CASE 1: It is me that that is available as slave - cool, go to SLAVE
HighAvailabilityMemberState newState = TO_SLAVE.slaveIsAvailable( context, myId, SampleUri );
assertEquals( SLAVE, newState );
// CASE 2: It is someone else that completed the switch - ignore, continue
HighAvailabilityMemberState newStateCase2 = TO_SLAVE.slaveIsAvailable( context, new InstanceId( 2 ), SampleUri );
assertEquals( TO_SLAVE, newStateCase2 );
}
@Test
public void testSlaveMasterIsElected()
{
// CASE 1: It is me that got elected master - should switch to TO_MASTER
HighAvailabilityMemberState newState = SLAVE.masterIsElected( context, myId );
assertEquals( TO_MASTER, newState );
InstanceId masterInstanceId = new InstanceId( 2 );
when( context.getElectedMasterId() ).thenReturn( masterInstanceId );
// CASE 2: It is someone else that got elected master - should switch to PENDING
HighAvailabilityMemberState newStateCase2 = SLAVE.masterIsElected( context, new InstanceId( 3 ) );
assertEquals( PENDING, newStateCase2 );
// CASE 3: It is the current master that got elected again - ignore
HighAvailabilityMemberState newStateCase3 = SLAVE.masterIsElected( context, masterInstanceId );
assertEquals( SLAVE, newStateCase3 );
}
@Test
public void testSlaveMasterIsAvailable()
{
// CASE 1: It is me who is available as master - i don't think so
try
{
SLAVE.masterIsAvailable( context, myId, SampleUri );
fail( "Should have gotten an election result first" );
}
catch( RuntimeException e )
{
// outstanding
}
// CASE 2: It is someone else that is available as master and is not the master now - missed the election, fail
InstanceId masterInstanceId = new InstanceId( 2 );
when( context.getElectedMasterId() ).thenReturn( masterInstanceId );
try
{
SLAVE.masterIsAvailable( context, new InstanceId( 3 ), SampleUri );
fail( "Should have gotten an election result first" );
}
catch( RuntimeException e )
{
// outstanding
}
// CASE 3: It is the same master as now - it's ok, stay calm and carry on
HighAvailabilityMemberState newState = SLAVE.masterIsAvailable( context, masterInstanceId, SampleUri );
assertEquals( SLAVE, newState );
}
@Test
public void testSlaveSlaveIsAvailable()
{
// CASE 1 and only - always remain in SLAVE
assertEquals( SLAVE, SLAVE.slaveIsAvailable( mock( HighAvailabilityMemberContext.class ), mock( InstanceId.class), SampleUri ) );
}
}
| false
|
enterprise_ha_src_test_java_org_neo4j_kernel_ha_cluster_HighAvailabilityMemberStateTest.java
|
5,166
|
public final class IndexProxyAlreadyClosedKernelException extends FlipFailedKernelException
{
public IndexProxyAlreadyClosedKernelException( Class<?> proxyClazz )
{
super( proxyClazz.getSimpleName() + " has been closed. No more interactions allowed." );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_index_IndexProxyAlreadyClosedKernelException.java
|
5,167
|
public class IndexNotFoundKernelException extends KernelException
{
public IndexNotFoundKernelException( String message, Throwable cause )
{
super( Status.Schema.NoSuchIndex, cause, message );
}
public IndexNotFoundKernelException( String msg )
{
super( Status.Schema.NoSuchIndex, msg );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_api_exceptions_index_IndexNotFoundKernelException.java
|
5,168
|
{
@Override
public Object initialState( Path path )
{
return null;
}
};
| false
|
community_kernel_src_main_java_org_neo4j_graphdb_traversal_InitialStateFactory.java
|
5,169
|
class FromValue<T> implements ValueGetter<T>
{
private final T value;
public FromValue( T value )
{
this.value = value;
}
@Override
public T get()
{
return value;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_ValueGetter.java
|
5,170
|
{
@Override
public String apply( URI uri )
{
if ( uri == null )
{
return null;
}
String query = uri.getQuery();
if (query != null)
{
for ( String param : query.split( "&" ) )
{
String[] keyValue = param.split( "=" );
if ( keyValue[0].equalsIgnoreCase( name ) )
{
if ( keyValue.length == 2 )
{
return keyValue[1];
}
else
{
return "true";
}
}
}
}
return null;
}
};
| false
|
community_kernel_src_main_java_org_neo4j_helpers_Uris.java
|
5,171
|
public final class Uris
{
/**
* Extract a named parameter from the query of a URI. If a parameter is set but no value defined,
* then "true" is returned
*
* @param name of the parameter
* @return value of named parameter or null if missing
*/
public static Function<URI, String> parameter( final String name )
{
return new Function<URI, String>()
{
@Override
public String apply( URI uri )
{
if ( uri == null )
{
return null;
}
String query = uri.getQuery();
if (query != null)
{
for ( String param : query.split( "&" ) )
{
String[] keyValue = param.split( "=" );
if ( keyValue[0].equalsIgnoreCase( name ) )
{
if ( keyValue.length == 2 )
{
return keyValue[1];
}
else
{
return "true";
}
}
}
}
return null;
}
};
}
private Uris()
{
}
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_Uris.java
|
5,172
|
{
@Override
public String apply( byte[] bytes )
{
return decode( bytes );
}
};
| false
|
community_kernel_src_main_java_org_neo4j_helpers_UTF8.java
|
5,173
|
{
@Override
public byte[] apply( String s )
{
return encode( s );
}
};
| false
|
community_kernel_src_main_java_org_neo4j_helpers_UTF8.java
|
5,174
|
public final class UTF8
{
public static final Function<String, byte[]> encode = new Function<String, byte[]>()
{
@Override
public byte[] apply( String s )
{
return encode( s );
}
};
public static final Function<byte[], String> decode = new Function<byte[], String>()
{
@Override
public String apply( byte[] bytes )
{
return decode( bytes );
}
};
public static byte[] encode( String string )
{
try
{
return string.getBytes( "UTF-8" );
}
catch ( UnsupportedEncodingException e )
{
throw cantBelieveUtf8IsntAvailableInThisJvmError( e );
}
}
public static String decode( byte[] bytes )
{
try
{
return new String( bytes, "UTF-8" );
}
catch ( UnsupportedEncodingException e )
{
throw cantBelieveUtf8IsntAvailableInThisJvmError( e );
}
}
public static String decode( byte[] bytes, int offset, int length )
{
try
{
return new String( bytes, offset, length, "UTF-8" );
}
catch ( UnsupportedEncodingException e )
{
throw cantBelieveUtf8IsntAvailableInThisJvmError( e );
}
}
public static String getDecodedStringFrom( ByteBuffer source )
{
// Currently only one key is supported although the data format supports multiple
int count = source.getInt();
byte[] data = new byte[count];
source.get( data );
return UTF8.decode( data );
}
public static void putEncodedStringInto( String text, ByteBuffer target )
{
byte[] data = encode( text );
target.putInt( data.length );
target.put( data );
}
public static int computeRequiredByteBufferSize( String text )
{
return encode( text ).length + 4;
}
private static Error cantBelieveUtf8IsntAvailableInThisJvmError( UnsupportedEncodingException e )
{
return new Error( "UTF-8 should be available on all JVMs", e );
}
private UTF8()
{
// No need to instantiate, all methods are static
}
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_UTF8.java
|
5,175
|
public class Triplet<T1, T2, T3> extends Pair<T1, Pair<T2, T3>>
{
/**
* Create a new triplet of objects.
*
* @param first the {@link #first() first value} of the triplet.
* @param second the {@link #second() second value} of the triplet.
* @param third the {@link #third() third value} of the triplet.
* @return a new triplet of the supplied objects.
*/
public static <T1, T2, T3> Triplet<T1, T2, T3> of( T1 first, T2 second, T3 third )
{
return new Triplet<T1, T2, T3>( first, second, third );
}
private final T1 first;
private final T2 second;
private final T3 third;
private Triplet( T1 first, T2 second, T3 third )
{
this.first = first;
this.second = second;
this.third = third;
}
@Override
public T1 first()
{
return this.first;
}
/**
* @return the second object in the triplet.
*/
public T2 second()
{
return this.second;
}
/**
* @return the third object in the triplet.
*/
public T3 third()
{
return this.third;
}
@Override
public Pair<T2, T3> other()
{
return Pair.of( second, third );
}
@Override
public String toString()
{
return "(" + first + ", " + second + ", " + third + ")";
}
@Override
public int hashCode()
{
return ( ( 31 * hashCode( first ) ) | hashCode( second ) ) * 31 | hashCode( third );
}
@Override
public boolean equals( Object obj )
{
if ( this == obj ) return true;
if ( obj instanceof Triplet )
{
@SuppressWarnings( "rawtypes" ) Triplet that = (Triplet) obj;
return equals( this.first, that.first ) && equals( this.second, that.second )
&& equals( this.third, that.third );
}
if ( obj instanceof Pair )
{
@SuppressWarnings( "rawtypes" ) Pair that = (Pair) obj;
Object other = that.other();
if ( other instanceof Pair )
{
@SuppressWarnings( "rawtypes" ) Pair pair = (Pair) other;
return equals( this.first, that.first() ) && equals( this.second, pair.first() )
&& equals( this.third, pair.other() );
}
}
return false;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_Triplet.java
|
5,176
|
{
@Override
public Long apply( String timeWithOrWithoutUnit )
{
int unitIndex = -1;
for ( int i = 0; i < timeWithOrWithoutUnit.length(); i++ )
{
char ch = timeWithOrWithoutUnit.charAt( i );
if ( !Character.isDigit( ch ) )
{
unitIndex = i;
break;
}
}
if ( unitIndex == -1 )
{
return DEFAULT_TIME_UNIT.toMillis( Integer.parseInt( timeWithOrWithoutUnit ) );
}
else
{
int amount = Integer.parseInt( timeWithOrWithoutUnit.substring( 0, unitIndex ) );
String unit = timeWithOrWithoutUnit.substring( unitIndex ).toLowerCase();
TimeUnit timeUnit = null;
int multiplyFactor = 1;
if ( unit.equals( "ms" ) )
{
timeUnit = TimeUnit.MILLISECONDS;
}
else if ( unit.equals( "s" ) )
{
timeUnit = TimeUnit.SECONDS;
}
else if ( unit.equals( "m" ) )
{
// This is only for having to rely on 1.6
timeUnit = TimeUnit.SECONDS;
multiplyFactor = 60;
}
else
{
throw new RuntimeException( "Unrecognized unit " + unit );
}
return timeUnit.toMillis( amount * multiplyFactor );
}
}
};
| false
|
community_kernel_src_main_java_org_neo4j_helpers_TimeUtil.java
|
5,177
|
public final class TimeUtil
{
private static final TimeUnit DEFAULT_TIME_UNIT = TimeUnit.SECONDS;
public static final Function<String, Long> parseTimeMillis = new Function<String, Long>()
{
@Override
public Long apply( String timeWithOrWithoutUnit )
{
int unitIndex = -1;
for ( int i = 0; i < timeWithOrWithoutUnit.length(); i++ )
{
char ch = timeWithOrWithoutUnit.charAt( i );
if ( !Character.isDigit( ch ) )
{
unitIndex = i;
break;
}
}
if ( unitIndex == -1 )
{
return DEFAULT_TIME_UNIT.toMillis( Integer.parseInt( timeWithOrWithoutUnit ) );
}
else
{
int amount = Integer.parseInt( timeWithOrWithoutUnit.substring( 0, unitIndex ) );
String unit = timeWithOrWithoutUnit.substring( unitIndex ).toLowerCase();
TimeUnit timeUnit = null;
int multiplyFactor = 1;
if ( unit.equals( "ms" ) )
{
timeUnit = TimeUnit.MILLISECONDS;
}
else if ( unit.equals( "s" ) )
{
timeUnit = TimeUnit.SECONDS;
}
else if ( unit.equals( "m" ) )
{
// This is only for having to rely on 1.6
timeUnit = TimeUnit.SECONDS;
multiplyFactor = 60;
}
else
{
throw new RuntimeException( "Unrecognized unit " + unit );
}
return timeUnit.toMillis( amount * multiplyFactor );
}
}
};
private TimeUtil()
{
}
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_TimeUtil.java
|
5,178
|
public class TickingClock implements Clock
{
private long current;
private long tick;
private Map<Long, List<Runnable>> actions = new HashMap<>();
public TickingClock( long current, long tick )
{
this.current = current;
this.tick = tick;
}
public TickingClock at( long time, Runnable action )
{
List<Runnable> actionList = actions.get( time );
if ( actionList == null )
{
actionList = new ArrayList<>();
actions.put( time, actionList );
}
actionList.add( action );
return this;
}
@Override
public long currentTimeMillis()
{
List<Runnable> actionList = actions.get( current );
if ( actionList != null )
{
for ( Runnable runnable : actionList )
{
runnable.run();
}
}
try
{
return current;
}
finally
{
current += tick;
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_TickingClock.java
|
5,179
|
{
@Override
public Boolean evaluate()
{
return Boolean.TRUE;
}
};
| false
|
community_kernel_src_main_java_org_neo4j_helpers_Thunks.java
|
5,180
|
public class Thunks
{
private Thunks()
{
}
public static final Thunk<Boolean> TRUE = new Thunk<Boolean>()
{
@Override
public Boolean evaluate()
{
return Boolean.TRUE;
}
};
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_Thunks.java
|
5,181
|
public class ThisShouldNotHappenError extends Error
{
public ThisShouldNotHappenError( String developer, String message )
{
super( "Developer: " + developer + " claims that: " + message );
}
public ThisShouldNotHappenError( String developer, String message, Throwable cause )
{
super( "Developer: " + developer + " claims that: " + message, cause );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_ThisShouldNotHappenError.java
|
5,182
|
public class TestFormat
{
@Test
public void dateTime() throws Exception
{
// Date
long timeWithDate = System.currentTimeMillis();
String dateAsString = Format.date( timeWithDate );
assertEquals( timeWithDate, new SimpleDateFormat( Format.DATE_FORMAT ).parse( dateAsString ).getTime() );
// Time
String timeAsString = Format.time( timeWithDate );
assertEquals( timeWithDate, translateToDate( timeWithDate,
new SimpleDateFormat( Format.TIME_FORMAT ).parse( timeAsString ).getTime(), Format.DEFAULT_TIME_ZONE ) );
}
@Test
public void dateTimeWithTimeZone() throws Exception
{
String zoneOffset = "+03:00";
TimeZone zone = TimeZone.getTimeZone( "GMT" + zoneOffset );
// Date
String asString = Format.date( zone );
assertTrue( asString.endsWith( withoutColon( zoneOffset ) ) );
long timeWithDate = new SimpleDateFormat( Format.DATE_FORMAT ).parse( asString ).getTime();
asString = Format.date( timeWithDate, zone );
assertTrue( asString.endsWith( withoutColon( zoneOffset ) ) );
assertEquals( timeWithDate, new SimpleDateFormat( Format.DATE_FORMAT ).parse( asString ).getTime() );
asString = Format.date( new Date( timeWithDate ), zone );
assertTrue( asString.endsWith( withoutColon( zoneOffset ) ) );
assertEquals( timeWithDate, new SimpleDateFormat( Format.DATE_FORMAT ).parse( asString ).getTime() );
// Time
asString = Format.time( timeWithDate, zone );
assertEquals( timeWithDate, translateToDate( timeWithDate,
new SimpleDateFormat( Format.TIME_FORMAT ).parse( asString ).getTime(), zone ) );
asString = Format.time( new Date( timeWithDate ), zone );
assertEquals( timeWithDate, translateToDate( timeWithDate,
new SimpleDateFormat( Format.TIME_FORMAT ).parse( asString ).getTime(), zone ) );
}
private long translateToDate( long timeWithDate, long time, TimeZone timeIsGivenInThisTimeZone )
{
Calendar calendar = Calendar.getInstance(timeIsGivenInThisTimeZone);
calendar.setTimeInMillis( timeWithDate );
Calendar timeCalendar = Calendar.getInstance();
timeCalendar.setTimeInMillis( time );
timeCalendar.setTimeZone( timeIsGivenInThisTimeZone );
timeCalendar.set( Calendar.YEAR, calendar.get( Calendar.YEAR ) );
timeCalendar.set( Calendar.MONTH, calendar.get( Calendar.MONTH ) );
boolean crossedDayBoundary = !timeIsGivenInThisTimeZone.equals( Format.DEFAULT_TIME_ZONE ) &&
timeCalendar.get( Calendar.HOUR_OF_DAY ) < calendar.get( Calendar.HOUR_OF_DAY );
timeCalendar.set( Calendar.DAY_OF_MONTH, calendar.get( Calendar.DAY_OF_MONTH ) + (crossedDayBoundary ? 1 : 0) );
return timeCalendar.getTimeInMillis();
}
private String withoutColon( String zoneOffset )
{
return zoneOffset.replaceAll( ":", "" );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_TestFormat.java
|
5,183
|
private static class LevelTwoException extends LevelOneException
{
public LevelTwoException( String message )
{
super( message );
}
public LevelTwoException( String message, Throwable cause )
{
super( message, cause );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_TestExceptions.java
|
5,184
|
private static class LevelThreeException extends LevelTwoException
{
public LevelThreeException( String message )
{
super( message );
}
public LevelThreeException( String message, Throwable cause )
{
super( message, cause );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_TestExceptions.java
|
5,185
|
private static class LevelOneException extends Exception
{
public LevelOneException( String message )
{
super( message );
}
public LevelOneException( String message, Throwable cause )
{
super( message, cause );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_TestExceptions.java
|
5,186
|
private static class LevelFourException extends LevelThreeException
{
public LevelFourException( String message )
{
super( message );
}
public LevelFourException( String message, Throwable cause )
{
super( message, cause );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_TestExceptions.java
|
5,187
|
private static class AnotherRuntimeException extends RuntimeException
{
public AnotherRuntimeException( Throwable cause )
{
super( cause );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_TestExceptions.java
|
5,188
|
private static class ARuntimeException extends RuntimeException
{
public ARuntimeException( Throwable cause )
{
super( cause );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_TestExceptions.java
|
5,189
|
public class UrisTest
{
@Test
public void testParam()
{
URI uri = URI.create("http://localhost/foo?x=a&y=b&z");
assertThat( parameter( "x" ).apply( uri ), equalTo( "a" ) );
assertThat( parameter( "y" ).apply( uri ), equalTo( "b" ) );
assertThat( parameter( "z" ).apply( uri ), equalTo( "true" ) );
assertThat( parameter( "foo" ).apply( uri ), nullValue() );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_UrisTest.java
|
5,190
|
public class ArrayIterator<T> implements Iterator<T>
{
private final T[] array;
private int index;
public ArrayIterator( T[] array )
{
this.array = array;
}
public boolean hasNext()
{
return index < array.length;
}
public T next()
{
if ( !hasNext() ) throw new NoSuchElementException();
return array[index++];
}
public void remove()
{
throw new UnsupportedOperationException();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_collection_ArrayIterator.java
|
5,191
|
public class TestExceptions
{
@Test
public void canPeelExceptions() throws Exception
{
// given
Throwable expected;
Throwable exception =
new LevelOneException( "",
new LevelTwoException( "",
new LevelThreeException( "",
expected = new LevelThreeException( "include",
new LevelFourException( "" ) ) ) ) );
// when
Throwable peeled = Exceptions.peel( exception, new Predicate<Throwable>()
{
@Override
public boolean accept( Throwable item )
{
return !(item instanceof LevelThreeException) || !item.getMessage().contains( "include" );
}
} );
// then
assertEquals( expected, peeled );
}
@Test
public void canPeelUsingConveniencePredicate() throws Exception
{
// given
Throwable expected;
Throwable exception =
new ARuntimeException(
new AnotherRuntimeException(
new LevelFourException( "",
expected = new LevelThreeException( "",
new LevelFourException( "" ) ) ) ) );
// when
Throwable peeled = Exceptions.peel( exception, Exceptions.exceptionsOfType( RuntimeException.class, LevelFourException.class ) );
// then
assertEquals( expected, peeled );
}
@Test
public void shouldDetectContainsOneOfSome() throws Exception
{
// GIVEN
Throwable cause = new ARuntimeException( new AnotherRuntimeException( new NullPointerException( "Some words" ) ) );
// THEN
assertTrue( Exceptions.contains( cause, NullPointerException.class ) );
assertTrue( Exceptions.contains( cause, "words", NullPointerException.class ) );
assertFalse( Exceptions.contains( cause, "not", NullPointerException.class ) );
}
private static class LevelOneException extends Exception
{
public LevelOneException( String message )
{
super( message );
}
public LevelOneException( String message, Throwable cause )
{
super( message, cause );
}
}
private static class LevelTwoException extends LevelOneException
{
public LevelTwoException( String message )
{
super( message );
}
public LevelTwoException( String message, Throwable cause )
{
super( message, cause );
}
}
private static class LevelThreeException extends LevelTwoException
{
public LevelThreeException( String message )
{
super( message );
}
public LevelThreeException( String message, Throwable cause )
{
super( message, cause );
}
}
private static class LevelFourException extends LevelThreeException
{
public LevelFourException( String message )
{
super( message );
}
public LevelFourException( String message, Throwable cause )
{
super( message, cause );
}
}
private static class ARuntimeException extends RuntimeException
{
public ARuntimeException( Throwable cause )
{
super( cause );
}
}
private static class AnotherRuntimeException extends RuntimeException
{
public AnotherRuntimeException( Throwable cause )
{
super( cause );
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_helpers_TestExceptions.java
|
5,192
|
public class CachingIterator<T> implements ListIterator<T>
{
private final Iterator<T> source;
private final List<T> visited = new ArrayList<T>();
private int position;
private T current;
/**
* Creates a new caching iterator using {@code source} as its underlying
* {@link Iterator} to get items lazily from.
* @param source the underlying {@link Iterator} to lazily get items from.
*/
public CachingIterator( Iterator<T> source )
{
this.source = source;
}
/**
* Returns whether a call to {@link #next()} will be able to return
* an item or not. If the current {@link #position()} is beyond the size
* of the cache (as will be the case if only calls to
* {@link #hasNext()}/{@link #next()} has been made up to this point)
* the underlying iterator is asked, else {@code true} since it can be
* returned from the cache.
*
* @return whether or not there are more items in this iteration given the
* current {@link #position()}.
*/
public boolean hasNext()
{
return visited.size() > position ? true : source.hasNext();
}
/**
* Returns the next item given the current {@link #position()}.
* If the current {@link #position()} is beyond the size
* of the cache (as will be the case if only calls to
* {@link #hasNext()}/{@link #next()} has been made up to this point) the
* underlying iterator is asked for the next item (and cached if there
* was one), else the item is returned from the cache.
*
* @return the next item given the current {@link #position()}.
*/
public T next()
{
if ( visited.size() > position )
{
current = visited.get( position );
}
else
{
if ( !source.hasNext() )
{
throw new NoSuchElementException();
}
current = source.next();
visited.add( current );
}
position++;
return current;
}
/**
* Returns the current position of the iterator, initially 0. The position
* represents the index of the item which will be returned by the next call
* to {@link #next()} and also the index of the next item returned by
* {@link #previous()} plus one. An example:
*
* <ul>
* <li>Instantiate an iterator which would iterate over the strings "first", "second" and "third".</li>
* <li>Get the two first items ("first" and "second") from it by using {@link #next()},
* {@link #position()} will now return 2.</li>
* <li>Call {@link #previous()} (which will return "second") and {@link #position()} will now be 1</li>
* </ul>
*
* @return the position of the iterator.
*/
public int position()
{
return position;
}
/**
* Sets the position of the iterator. {@code 0} means all the way back to
* the beginning. It is also possible to set the position to one higher
* than the last item, so that the next call to {@link #previous()} would
* return the last item. Items will be cached along the way if necessary.
*
* @param newPosition the position to set for the iterator, must be
* non-negative.
* @return the position before changing to the new position.
*/
public int position( int newPosition )
{
if ( newPosition < 0 )
{
throw new IllegalArgumentException( "Position must be non-negative, was " + newPosition );
}
int previousPosition = position;
boolean overTheEdge = false;
while ( visited.size() < newPosition )
{
T next = source.hasNext() ? source.next() : null;
if ( next != null )
{
visited.add( next );
}
else
{
if ( !overTheEdge )
{
overTheEdge = true;
}
else
{
throw new NoSuchElementException( "Requested position " + newPosition +
", but didn't get further than to " + visited.size() );
}
}
}
current = null;
position = newPosition;
return previousPosition;
}
/**
* Returns whether or not a call to {@link #previous()} will be able to
* return an item or not. So it will return {@code true} if
* {@link #position()} is bigger than 0.
*
* {@inheritDoc}
*/
public boolean hasPrevious()
{
return position > 0;
}
/**
* {@inheritDoc}
*/
public T previous()
{
if ( !hasPrevious() )
{
throw new NoSuchElementException( "Position is " + position );
}
current = visited.get( --position );
return current;
}
/**
* Returns the last item returned by {@link #next()}/{@link #previous()}.
* If no call has been made to {@link #next()} or {@link #previous()} since
* this iterator was created or since a call to {@link #position(int)} has
* been made a {@link NoSuchElementException} will be thrown.
*
* @return the last item returned by {@link #next()}/{@link #previous()}.
* @throws NoSuchElementException if no call has been made to {@link #next()}
* or {@link #previous()} since this iterator was created or since a call to
* {@link #position(int)} has been made.
*/
public T current()
{
if ( current == null )
{
throw new NoSuchElementException();
}
return current;
}
/**
* {@inheritDoc}
*/
public int nextIndex()
{
return position;
}
/**
* {@inheritDoc}
*/
public int previousIndex()
{
return position-1;
}
/**
* Not supported by this implement.
*
* {@inheritDoc}
*/
public void remove()
{
throw new UnsupportedOperationException();
}
/**
* Not supported by this implement.
*
* {@inheritDoc}
*/
public void set( T e )
{
throw new UnsupportedOperationException();
}
/**
* Not supported by this implement.
*
* {@inheritDoc}
*/
public void add( T e )
{
throw new UnsupportedOperationException();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_collection_CachingIterator.java
|
5,193
|
public class FilteringIterable<T> implements Iterable<T>
{
private final Iterable<T> source;
private final Predicate<T> predicate;
public FilteringIterable( Iterable<T> source, Predicate<T> predicate )
{
this.source = source;
this.predicate = predicate;
}
public Iterator<T> iterator()
{
return new FilteringIterator<T>( source.iterator(), predicate );
}
public static <T> Iterable<T> notNull( Iterable<T> source )
{
return new FilteringIterable<T>( source, FilteringIterable.<T>notNullPredicate() );
}
public static <T> Iterable<T> noDuplicates( Iterable<T> source )
{
return new FilteringIterable<T>( source, FilteringIterable.<T>noDuplicatesPredicate() );
}
public static <T> Predicate<T> noDuplicatesPredicate()
{
return new Predicate<T>()
{
private final Set<T> visitedItems = new HashSet<T>();
public boolean accept( T item )
{
return visitedItems.add( item );
}
};
}
@SuppressWarnings("unchecked")
public static <T> Predicate<T> notNullPredicate()
{
return (Predicate<T>) NOT_NULL_PREDICATE;
}
@SuppressWarnings("unchecked")
private static final Predicate NOT_NULL_PREDICATE = new Predicate()
{
public boolean accept( Object item )
{
return item != null;
}
};
}
| false
|
community_kernel_src_main_java_org_neo4j_helpers_collection_FilteringIterable.java
|
5,194
|
}){
@Override
protected boolean exceptionOnHasNext(Throwable t) {
rethrow(new IllegalStateException());
return super.exceptionOnHasNext(t);
}
});
| false
|
community_kernel_src_test_java_org_neo4j_helpers_collection_ExceptionHandlingIterableTest.java
|
5,195
|
return new Iterator() {
public boolean hasNext() {
throw new RuntimeException("exception on next");
}
public Object next() {
return null;
}
public void remove() {
}
};
| false
|
community_kernel_src_test_java_org_neo4j_helpers_collection_ExceptionHandlingIterableTest.java
|
5,196
|
IteratorUtil.count(new ExceptionHandlingIterable(new Iterable() {
public Iterator iterator() {
return new Iterator() {
public boolean hasNext() {
throw new RuntimeException("exception on next");
}
public Object next() {
return null;
}
public void remove() {
}
};
}
}){
| false
|
community_kernel_src_test_java_org_neo4j_helpers_collection_ExceptionHandlingIterableTest.java
|
5,197
|
}){
@Override
protected Object exceptionOnNext(Throwable t) {
rethrow(new IllegalStateException());
return super.exceptionOnNext(t);
}
});
| false
|
community_kernel_src_test_java_org_neo4j_helpers_collection_ExceptionHandlingIterableTest.java
|
5,198
|
return new Iterator() {
public boolean hasNext() {
return true;
}
public Object next() {
throw new RuntimeException("exception on next");
}
public void remove() {
}
};
| false
|
community_kernel_src_test_java_org_neo4j_helpers_collection_ExceptionHandlingIterableTest.java
|
5,199
|
IteratorUtil.count(new ExceptionHandlingIterable(new Iterable() {
public Iterator iterator() {
return new Iterator() {
public boolean hasNext() {
return true;
}
public Object next() {
throw new RuntimeException("exception on next");
}
public void remove() {
}
};
}
}){
| false
|
community_kernel_src_test_java_org_neo4j_helpers_collection_ExceptionHandlingIterableTest.java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.