Unnamed: 0
int64 0
6.7k
| func
stringlengths 12
89.6k
| target
bool 2
classes | project
stringlengths 45
151
|
|---|---|---|---|
3,700
|
{
@Override
public void call( ConstraintDefinition self )
{
self.getLabel();
}
};
| false
|
community_kernel_src_test_java_org_neo4j_graphdb_ConstraintDefinitionFacadeMethods.java
|
3,701
|
public class ConstraintDefinitionFacadeMethods
{
private static final FacadeMethod<ConstraintDefinition> GET_LABEL =
new FacadeMethod<ConstraintDefinition>( "Label getLabel()" )
{
@Override
public void call( ConstraintDefinition self )
{
self.getLabel();
}
};
private static final FacadeMethod<ConstraintDefinition> DROP =
new FacadeMethod<ConstraintDefinition>( "void drop()" )
{
@Override
public void call( ConstraintDefinition self )
{
self.drop();
}
};
private static final FacadeMethod<ConstraintDefinition> IS_CONSTRAINT_TYPE =
new FacadeMethod<ConstraintDefinition>( "boolean isConstraintType( ConstraintType type )" )
{
@Override
public void call( ConstraintDefinition self )
{
self.isConstraintType( ConstraintType.UNIQUENESS );
}
};
private static final FacadeMethod<ConstraintDefinition> GET_PROPERTY_KEYS =
new FacadeMethod<ConstraintDefinition>( "Iterable<String> getPropertyKeys()" )
{
@Override
public void call( ConstraintDefinition self )
{
self.getPropertyKeys();
}
};
static final Iterable<FacadeMethod<ConstraintDefinition>> ALL_CONSTRAINT_DEFINITION_FACADE_METHODS =
unmodifiableCollection( asList(
GET_LABEL,
GET_PROPERTY_KEYS,
DROP,
IS_CONSTRAINT_TYPE
) );
}
| false
|
community_kernel_src_test_java_org_neo4j_graphdb_ConstraintDefinitionFacadeMethods.java
|
3,702
|
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
NeoStoreRecord record = new NeoStoreRecord();
record.setNextProp( next.property() );
tx.update( record );
// We get exceptions when only the above happens in a transaction...
tx.create( new NodeRecord( next.node(), -1, -1 ) );
}
} );
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_incremental_IncrementalCheckIntegrationTest.java
|
3,703
|
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
int ruleId1 = (int) next.schema();
int ruleId2 = (int) next.schema();
int labelId = (int) next.label();
int propertyKeyId = next.propertyKey();
DynamicRecord record1 = new DynamicRecord( ruleId1 );
DynamicRecord record2 = new DynamicRecord( ruleId2 );
DynamicRecord record1Before = record1.clone();
DynamicRecord record2Before = record2.clone();
SchemaIndexProvider.Descriptor providerDescriptor = new SchemaIndexProvider.Descriptor( "in-memory",
"1.0" );
IndexRule rule1 = IndexRule.constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor,
(long) ruleId2 );
UniquenessConstraintRule rule2 = UniquenessConstraintRule.uniquenessConstraintRule( ruleId2, labelId,
propertyKeyId, ruleId2 );
Collection<DynamicRecord> records1 = serializeRule( rule1, record1 );
Collection<DynamicRecord> records2 = serializeRule( rule2, record2 );
assertEquals( asList( record1 ), records1 );
assertEquals( asList( record2 ), records2 );
tx.nodeLabel( labelId, "label" );
tx.propertyKey( propertyKeyId, "property" );
tx.createSchema( asList(record1Before), records1 );
tx.createSchema( asList(record2Before), records2 );
}
} );
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_incremental_IncrementalCheckIntegrationTest.java
|
3,704
|
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
int ruleId1 = (int) next.schema();
int ruleId2 = (int) next.schema();
int labelId = (int) next.label();
int propertyKeyId = next.propertyKey();
DynamicRecord record1 = new DynamicRecord( ruleId1 );
DynamicRecord record2 = new DynamicRecord( ruleId2 );
DynamicRecord record1Before = record1.clone();
DynamicRecord record2Before = record2.clone();
SchemaIndexProvider.Descriptor providerDescriptor = new SchemaIndexProvider.Descriptor( "in-memory", "1.0" );
IndexRule rule1 = IndexRule.constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId1);
IndexRule rule2 = IndexRule.constraintIndexRule( ruleId2, labelId, propertyKeyId, providerDescriptor, (long) ruleId1);
Collection<DynamicRecord> records1 = serializeRule( rule1, record1 );
Collection<DynamicRecord> records2 = serializeRule( rule2, record2 );
assertEquals( asList( record1 ), records1 );
assertEquals( asList( record2 ), records2 );
tx.nodeLabel( labelId, "label" );
tx.propertyKey( propertyKeyId, "property" );
tx.createSchema( asList(record1Before), records1 );
tx.createSchema( asList(record2Before), records2 );
}
} );
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_incremental_IncrementalCheckIntegrationTest.java
|
3,705
|
{
@Override
public void enteredCluster( ClusterConfiguration clusterConfiguration )
{
semaphore.release();
}
@Override
public void joinedCluster( InstanceId instanceId, URI member )
{
logger.info( "1 sees join by " + instanceId + " at URI " + member );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosNetworkTest.java
|
3,706
|
{
@Override
public void listeningAt( URI me )
{
server2.newClient( Cluster.class ).join( "default", me );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosNetworkTest.java
|
3,707
|
{
@Override
public void listeningAt( URI me )
{
server1.newClient( Cluster.class ).create( "default" );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosNetworkTest.java
|
3,708
|
@Ignore
public class MultiPaxosNetworkTest
{
@Test
@Ignore
public void testBroadcast()
throws ExecutionException, InterruptedException, URISyntaxException, BrokenBarrierException
{
final LifeSupport life = new LifeSupport();
Config config = new Config( MapUtil.stringMap( GraphDatabaseSettings.store_dir.name(),
TargetDirectory.forTest( getClass() ).cleanDirectory( "cluster" ).getAbsolutePath() ),
GraphDatabaseSettings.class );
final LoggerContext loggerContext = new LoggerContext();
loggerContext.putProperty( "host", "none" );
LogbackService logging = life.add( new LogbackService( config, loggerContext ) );
MessageTimeoutStrategy timeoutStrategy = new MessageTimeoutStrategy( new FixedTimeoutStrategy( 10000 ) )
.timeout( AtomicBroadcastMessage.broadcastTimeout, 30000 )
.timeout( ClusterMessage.configurationTimeout, 3000 )
.timeout( HeartbeatMessage.sendHeartbeat, 10000 )
.relativeTimeout( HeartbeatMessage.timed_out, HeartbeatMessage.sendHeartbeat, 10000 );
NetworkedServerFactory serverFactory = new NetworkedServerFactory( life,
new MultiPaxosServerFactory(
new ClusterConfiguration( "default", logging.getMessagesLog( ClusterConfiguration.class ),
"cluster://localhost:5001",
"cluster://localhost:5002",
"cluster://localhost:5003" ),
logging ),
timeoutStrategy, logging, new ObjectStreamFactory(), new ObjectStreamFactory() );
ServerIdElectionCredentialsProvider serverIdElectionCredentialsProvider = new
ServerIdElectionCredentialsProvider();
final ProtocolServer server1 = serverFactory.newNetworkedServer( new Config( MapUtil.stringMap(
ClusterSettings.cluster_server.name(),
":5001" ), ClusterSettings.class ),
new InMemoryAcceptorInstanceStore(), serverIdElectionCredentialsProvider );
server1.addBindingListener( serverIdElectionCredentialsProvider );
serverIdElectionCredentialsProvider = new ServerIdElectionCredentialsProvider();
final ProtocolServer server2 = serverFactory.newNetworkedServer( new Config( MapUtil.stringMap(
ClusterSettings.cluster_server.name(),
":5002" ), ClusterSettings.class ), new InMemoryAcceptorInstanceStore(),
serverIdElectionCredentialsProvider );
server2.addBindingListener( serverIdElectionCredentialsProvider );
serverIdElectionCredentialsProvider = new ServerIdElectionCredentialsProvider();
final ProtocolServer server3 = serverFactory.newNetworkedServer( new Config( MapUtil.stringMap(
ClusterSettings.cluster_server.name(),
":5003" ), ClusterSettings.class ), new InMemoryAcceptorInstanceStore(),
serverIdElectionCredentialsProvider );
server3.addBindingListener( serverIdElectionCredentialsProvider );
server1.addBindingListener( new BindingListener()
{
@Override
public void listeningAt( URI me )
{
server1.newClient( Cluster.class ).create( "default" );
}
} );
server2.addBindingListener( new BindingListener()
{
@Override
public void listeningAt( URI me )
{
server2.newClient( Cluster.class ).join( "default", me );
}
} );
server3.addBindingListener( new BindingListener()
{
@Override
public void listeningAt( URI me )
{
server3.newClient( Cluster.class ).join( "default", me );
}
} );
AtomicBroadcast atomicBroadcast1 = server1.newClient( AtomicBroadcast.class );
AtomicBroadcast atomicBroadcast2 = server2.newClient( AtomicBroadcast.class );
AtomicBroadcast atomicBroadcast3 = server3.newClient( AtomicBroadcast.class );
Snapshot snapshot1 = server1.newClient( Snapshot.class );
Snapshot snapshot2 = server2.newClient( Snapshot.class );
Snapshot snapshot3 = server3.newClient( Snapshot.class );
final AtomicBroadcastMap<String, String> map = new AtomicBroadcastMap<String, String>( atomicBroadcast1,
snapshot1 );
final AtomicBroadcastMap<String, String> map2 = new AtomicBroadcastMap<String, String>( atomicBroadcast2,
snapshot2 );
final AtomicBroadcastMap<String, String> map3 = new AtomicBroadcastMap<String, String>( atomicBroadcast3,
snapshot3 );
final Semaphore semaphore = new Semaphore( -2 );
final Logger logger = loggerContext.getLogger( getClass() );
server1.newClient( Cluster.class ).addClusterListener( new ClusterListener.Adapter()
{
@Override
public void enteredCluster( ClusterConfiguration clusterConfiguration )
{
semaphore.release();
}
@Override
public void joinedCluster( InstanceId instanceId, URI member )
{
logger.info( "1 sees join by " + instanceId + " at URI " + member );
}
} );
server2.newClient( Cluster.class ).addClusterListener( new ClusterListener.Adapter()
{
@Override
public void enteredCluster( ClusterConfiguration clusterConfiguration )
{
semaphore.release();
}
@Override
public void joinedCluster( InstanceId instanceId, URI member )
{
logger.info( "2 sees join by " + instanceId + " at URI " + member );
}
} );
server3.newClient( Cluster.class ).addClusterListener( new ClusterListener.Adapter()
{
@Override
public void enteredCluster( ClusterConfiguration clusterConfiguration )
{
semaphore.release();
}
@Override
public void joinedCluster( org.neo4j.cluster.InstanceId instanceId, URI member )
{
logger.info( "3 sees join by " + instanceId + " at URI " + member );
}
} );
life.start();
semaphore.acquire();
logger.info( "Joined cluster - set data" );
for ( int i = 0; i < 50; i++ )
{
map.put( "foo" + i, "bar" + i );
}
logger.info( "Set all values" );
String value = map.get( "foo1" );
/*
LoggerFactory.getLogger( getClass() ).info( "3 joins 1" );
server3.newClient( Cluster.class ).addClusterListener( new ClusterListener.Adapter()
{
@Override
public void enteredCluster( ClusterConfiguration clusterConfiguration )
{
LoggerFactory.getLogger( getClass() ).info( "3 entered cluster of:" + clusterConfiguration.getMembers
() );
semaphore.release();
}
} );
server3.newClient( Cluster.class ).join( server1.getServerId() );
semaphore.acquire();
*/
logger.info( "Read value1" );
Assert.assertThat( value, CoreMatchers.equalTo( "bar1" ) );
map2.put( "foo2", "666" );
logger.warn( "Read value2:" + map2.get( "foo1" ) );
logger.warn( "Read value3:" + map2.get( "foo2" ) );
logger.warn( "Read value4:" + map3.get( "foo1" ) );
logger.warn( "Read value5:" + map3.get( "foo99" ) );
Assert.assertThat( map3.get( "foo1" ), CoreMatchers.equalTo( "bar1" ) );
Assert.assertThat( map3.get( "foo99" ), CoreMatchers.equalTo( "bar99" ) );
map.close();
map2.close();
map3.close();
life.stop();
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosNetworkTest.java
|
3,709
|
public class MultiPaxosContextTest
{
@Test
public void shouldNotConsiderInstanceJoiningWithSameIdAndIpAProblem() throws Exception
{
// Given
MultiPaxosContext ctx = new MultiPaxosContext( new InstanceId( 1 ),
Collections.<ElectionRole>emptyList(),
mock( ClusterConfiguration.class ), mock( Executor.class ),
new TestLogging(), new ObjectStreamFactory(),
new ObjectStreamFactory(), mock( AcceptorInstanceStore.class ), mock( Timeouts.class ),
mock( ElectionCredentialsProvider.class) );
InstanceId joiningId = new InstanceId( 12 );
String joiningUri = "http://127.0.0.1:900";
// When
ctx.getClusterContext().instanceIsJoining( joiningId, new URI( joiningUri ) );
// Then
assertFalse( ctx.getClusterContext().isInstanceJoiningFromDifferentUri( joiningId, new URI( joiningUri ) ));
assertTrue( ctx.getClusterContext().isInstanceJoiningFromDifferentUri( joiningId, new URI("http://127.0.0.1:80")));
assertFalse( ctx.getClusterContext().isInstanceJoiningFromDifferentUri( new InstanceId( 13 ), new URI( joiningUri ) ) );
}
@Test
public void shouldDeepClone() throws Exception
{
// Given
ObjectStreamFactory objStream = new ObjectStreamFactory();
AcceptorInstanceStore acceptorInstances = mock( AcceptorInstanceStore.class );
Executor executor = mock( Executor.class );
Timeouts timeouts = mock( Timeouts.class );
TestLogging logging = new TestLogging();
ClusterConfiguration clusterConfig = new ClusterConfiguration( "myCluster", StringLogger.DEV_NULL );
ElectionCredentialsProvider electionCredentials = mock( ElectionCredentialsProvider.class );
MultiPaxosContext ctx = new MultiPaxosContext( new InstanceId( 1 ),
Collections.<ElectionRole>emptyList(),
clusterConfig, executor,
logging, objStream,
objStream, acceptorInstances, timeouts, electionCredentials );
// When
MultiPaxosContext snapshot = ctx.snapshot( logging, timeouts, executor, acceptorInstances, objStream, objStream,
electionCredentials );
// Then
assertEquals( ctx, snapshot );
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosContextTest.java
|
3,710
|
public class LearnerStateTest
{
@Test
public void shouldUseLastKnownOnlineClusterMemberAndSetTimeoutForCatchup() throws Throwable
{
// Given
LearnerState state = LearnerState.learner;
LearnerContext ctx = mock(LearnerContext.class);
MessageHolder outgoing = mock( MessageHolder.class );
org.neo4j.cluster.InstanceId upToDateClusterMember = new org.neo4j.cluster.InstanceId( 1 );
// What we know
when(ctx.getLastLearnedInstanceId()).thenReturn( 0l );
when(ctx.getPaxosInstance( new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( 1l ) )).thenReturn( new PaxosInstance( null, new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( 1l )));
when(ctx.getLastKnownAliveUpToDateInstance()).thenReturn( upToDateClusterMember );
when(ctx.getUriForId( upToDateClusterMember )).thenReturn( new URI("c:/1") );
// What we know the cluster knows
when( ctx.getLastKnownLearnedInstanceInCluster() ).thenReturn( 1l );
// When
Message<LearnerMessage> message = Message.to( LearnerMessage.catchUp, new URI( "c:/2" ), 2l )
.setHeader( Message.FROM, "c:/2" );
State newState = state.handle( ctx, message, outgoing );
// Then
assertThat(newState, equalTo((State)LearnerState.learner));
verify(outgoing).offer( Message.to( LearnerMessage.learnRequest, new URI( "c:/1" ),
new LearnerMessage.LearnRequestState() ).setHeader(
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE,
Long.toString( 1l ) ) );
verify(ctx).setTimeout( "learn", Message.timeout( LearnerMessage.learnTimedout, message ) );
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_LearnerStateTest.java
|
3,711
|
learner
{
@Override
public LearnerState handle( LearnerContext context,
Message<LearnerMessage> message,
MessageHolder outgoing
)
throws Throwable
{
switch ( message.getMessageType() )
{
case learn:
{
LearnerMessage.LearnState learnState = message.getPayload();
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId instanceId = new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( message );
PaxosInstance instance = context.getPaxosInstance( instanceId );
StringLogger logger = context.getLogger( getClass() );
// Skip if we already know about this
if ( instanceId.getId() <= context.getLastDeliveredInstanceId() )
{
break;
}
context.learnedInstanceId( instanceId.getId() );
instance.closed( learnState.getValue(), message.getHeader( Message.CONVERSATION_ID ) );
/*
* The conditional below is simply so that no expensive deserialization will happen if we
* are not to print anything anyway if debug is not enabled.
*/
if ( logger.isDebugEnabled() )
{
String description;
if ( instance.value_2 instanceof Payload )
{
AtomicBroadcastSerializer atomicBroadcastSerializer = context.newSerializer();
description = atomicBroadcastSerializer.receive( (Payload) instance.value_2 ).toString();
}
else
{
description = instance.value_2.toString();
}
logger.debug(
"Learned and closed instance "+instance.id +
" from conversation " +
instance.conversationIdHeader +
" and the content was " +
description );
}
// If this is the next instance to be learned, then do so and check if we have anything
// pending to be learned
if ( instanceId.getId() == context.getLastDeliveredInstanceId() + 1 )
{
instance.delivered();
outgoing.offer( Message.internal( AtomicBroadcastMessage.broadcastResponse,
learnState.getValue() ) );
context.setLastDeliveredInstanceId( instanceId.getId() );
long checkInstanceId = instanceId.getId() + 1;
while ( (instance = context.getPaxosInstance( new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId(
checkInstanceId ) )).isState( PaxosInstance.State.closed ) )
{
instance.delivered();
context.setLastDeliveredInstanceId( checkInstanceId );
Message<AtomicBroadcastMessage> learnMessage = Message.internal(
AtomicBroadcastMessage.broadcastResponse, instance.value_2 )
.setHeader( org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE, instance.id.toString() )
.setHeader( Message.CONVERSATION_ID, instance.conversationIdHeader );
outgoing.offer( learnMessage );
checkInstanceId++;
}
if ( checkInstanceId == context.getLastKnownLearnedInstanceInCluster()
+ 1 )
{
// No hole - all is ok
// Cancel potential timeout, if one is active
context.cancelTimeout( "learn" );
}
else
{
// Found hole - we're waiting for this to be filled, i.e. timeout already set
context.getLogger( LearnerState.class ).debug( "*** HOLE! WAITING " +
"FOR " + (context.getLastDeliveredInstanceId() + 1) );
}
}
else
{
// Found hole - we're waiting for this to be filled, i.e. timeout already set
context.getLogger( LearnerState.class ).debug( "*** GOT " + instanceId
+ ", WAITING FOR " + (context.getLastDeliveredInstanceId() + 1) );
context.setTimeout( "learn", Message.timeout( LearnerMessage.learnTimedout,
message ) );
}
break;
}
case learnTimedout:
{
// Timed out waiting for learned values - send explicit request to everyone that is not failed
if ( !context.hasDeliveredAllKnownInstances() )
{
for ( long instanceId = context.getLastDeliveredInstanceId() + 1;
instanceId < context.getLastKnownLearnedInstanceInCluster();
instanceId++ )
{
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId id =
new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( instanceId );
PaxosInstance instance = context.getPaxosInstance( id );
if ( !instance.isState( PaxosInstance.State.closed ) && !instance.isState(
PaxosInstance.State.delivered ) )
{
for ( org.neo4j.cluster.InstanceId node : context.getAlive() )
{
URI nodeUri = context.getUriForId( node );
if ( !node.equals( context.getMyId() ) )
{
outgoing.offer( Message.to( LearnerMessage.learnRequest, nodeUri,
new LearnerMessage.LearnRequestState() ).setHeader(
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE,
id.toString() ) );
}
}
}
}
// Set another timeout
context.setTimeout( "learn", Message.timeout( LearnerMessage.learnTimedout,
message ) );
}
break;
}
case learnRequest:
{
// Someone wants to learn a value that we might have
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId instanceId =
new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( message );
PaxosInstance instance = context.getPaxosInstance( instanceId );
if ( instance.isState( PaxosInstance.State.closed )
|| instance.isState( PaxosInstance.State.delivered ) )
{
outgoing.offer( Message.respond( LearnerMessage.learn, message,
new LearnerMessage.LearnState( instance.value_2 ) ).
setHeader( org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE, instanceId.toString() ).
setHeader( Message.CONVERSATION_ID, instance.conversationIdHeader ) );
}
else
{
context.notifyLearnMiss(instanceId);
outgoing.offer( message.copyHeadersTo( Message.respond( LearnerMessage.learnFailed,
message,
new LearnerMessage.LearnFailedState() ), org.neo4j.cluster.protocol
.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
break;
}
case learnFailed:
{
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId instanceId = new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( message );
PaxosInstance instance = context.getPaxosInstance( instanceId );
if ( !(instance.isState( PaxosInstance.State.closed ) || instance.isState( PaxosInstance
.State.delivered )) )
{
List<URI> nodes = context.getMemberURIs();
URI learnDeniedNode = new URI( message.getHeader( Message.FROM ) );
int nextPotentialLearnerIndex = (nodes.indexOf( learnDeniedNode ) + 1) % nodes.size();
URI learnerNode = nodes.get( nextPotentialLearnerIndex );
outgoing.offer( message.copyHeadersTo( Message.to( LearnerMessage.learnRequest,
learnerNode,
new LearnerMessage.LearnRequestState() ), org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
break;
}
case catchUp:
{
Long catchUpTo = message.getPayload();
if ( context.getLastKnownLearnedInstanceInCluster() < catchUpTo )
{
context.setNextInstanceId(catchUpTo + 1);
// Try to get up to date
for ( long instanceId = context.getLastLearnedInstanceId() + 1;
instanceId <= catchUpTo; instanceId++ )
{
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId id = new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( instanceId );
PaxosInstance instance = context.getPaxosInstance( id );
if ( !instance.isState( PaxosInstance.State.closed ) && !instance.isState( PaxosInstance.State.delivered ) )
{
URI nodeUri = context.getUriForId( context.getLastKnownAliveUpToDateInstance() );
outgoing.offer( Message.to( LearnerMessage.learnRequest,
nodeUri,
new LearnerMessage.LearnRequestState() ).setHeader(
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE,
id.toString() ) );
context.setTimeout( "learn",
Message.timeout( LearnerMessage.learnTimedout, message ) );
break;
}
}
context.setLastKnownLearnedInstanceInCluster( catchUpTo,
context.getIdForUri( new URI(message.getHeader( Message.FROM )) ) );
}
break;
}
case leave:
{
context.leave();
return start;
}
}
return this;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_LearnerState.java
|
3,712
|
start
{
@Override
public LearnerState handle( LearnerContext context,
Message<LearnerMessage> message,
MessageHolder outgoing
)
throws Throwable
{
switch ( message.getMessageType() )
{
case join:
{
return learner;
}
}
return this;
}
},
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_LearnerState.java
|
3,713
|
public static class LearnState
implements Serializable
{
private final Object value;
public LearnState( Object value )
{
this.value = value;
}
public Object getValue()
{
return value;
}
@Override
public String toString()
{
return value.toString();
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
LearnState that = (LearnState) o;
if ( value != null ? !value.equals( that.value ) : that.value != null )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return value != null ? value.hashCode() : 0;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_LearnerMessage.java
|
3,714
|
public static class LearnRequestState
implements Serializable
{
public LearnRequestState()
{
}
@Override
public boolean equals( Object obj )
{
if(obj == null)
{
return false;
}
return getClass() == obj.getClass();
}
@Override
public int hashCode()
{
return 1;
}
@Override
public String toString()
{
return "Learn request";
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_LearnerMessage.java
|
3,715
|
public static class LearnFailedState
implements Serializable
{
public LearnFailedState()
{
}
@Override
public String toString()
{
return "Learn failed";
}
@Override
public int hashCode()
{
return 0;
}
@Override
public boolean equals( Object obj )
{
return obj instanceof LearnFailedState;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_LearnerMessage.java
|
3,716
|
public class LearnerContextTest
{
@Test
public void shouldOnlyAllowHigherLastLearnedInstanceId() throws Exception
{
// Given
MultiPaxosContext mpCtx = new MultiPaxosContext( null, Iterables.<ElectionRole>empty(), mock( ClusterConfiguration.class ), null, null, null, null, null, null, null );
LearnerContext state = mpCtx.getLearnerContext();
// When
state.setLastKnownLearnedInstanceInCluster( 1, new InstanceId( 2 ) );
state.setLastKnownLearnedInstanceInCluster( 0, new InstanceId( 3 ) );
// Then
assertThat( state.getLastKnownLearnedInstanceInCluster(), equalTo( 1l ) );
}
@Test
public void shouldTrackLastKnownUpToDateAliveInstance() throws Exception
{
// Given
MultiPaxosContext mpCtx = new MultiPaxosContext( null, Iterables.<ElectionRole>empty(), mock( ClusterConfiguration.class ), null, null, null, null, null, null, null );
LearnerContext state = mpCtx.getLearnerContext();
// When
state.setLastKnownLearnedInstanceInCluster( 1, new InstanceId( 2 ) );
state.setLastKnownLearnedInstanceInCluster( 1, new InstanceId( 3 ) );
state.setLastKnownLearnedInstanceInCluster( 0, new InstanceId( 4 ) );
// Then
assertThat( state.getLastKnownLearnedInstanceInCluster(), equalTo( 1l ) );
assertThat( state.getLastKnownAliveUpToDateInstance(), equalTo( new InstanceId( 3 ) ));
}
@Test
public void settingLastLearnedInstanceToNegativeOneShouldAlwaysWin() throws Exception
{
// Given
MultiPaxosContext mpCtx = new MultiPaxosContext( null, Iterables.<ElectionRole>empty(), mock( ClusterConfiguration.class ), null, null, null, null, null, null, null );
LearnerContext state = mpCtx.getLearnerContext();
// When
state.setLastKnownLearnedInstanceInCluster( 1, new InstanceId( 2 ) );
state.setLastKnownLearnedInstanceInCluster( -1, null );
// Then
assertThat( state.getLastKnownLearnedInstanceInCluster(), equalTo( -1l ) );
assertThat( state.getLastKnownAliveUpToDateInstance(), equalTo( new org.neo4j.cluster.InstanceId( 2 ) ));
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_LearnerContextTest.java
|
3,717
|
public class InstanceId
implements Serializable, Comparable<InstanceId>
{
public static final String INSTANCE = "instance";
long id;
public InstanceId( Message message )
{
this( message.getHeader( INSTANCE ) );
}
public InstanceId( String string )
{
this( Long.parseLong( string ) );
}
public InstanceId( long id )
{
this.id = id;
}
public long getId()
{
return id;
}
@Override
public int compareTo( InstanceId o )
{
return (int) (id - o.getId());
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
InstanceId that = (InstanceId) o;
if ( id != that.id )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return (int) (id ^ (id >>> 32));
}
@Override
public String toString()
{
return Long.toString( id );
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_InstanceId.java
|
3,718
|
public class InMemoryAcceptorInstanceStore
implements AcceptorInstanceStore
{
private final Map<InstanceId, AcceptorInstance> instances;
private long lastDeliveredInstanceId;
public InMemoryAcceptorInstanceStore()
{
this(new HashMap<InstanceId, AcceptorInstance>(), -1);
}
private InMemoryAcceptorInstanceStore(Map<InstanceId, AcceptorInstance> instances, long lastDeliveredInstanceId)
{
this.instances = instances;
this.lastDeliveredInstanceId = lastDeliveredInstanceId;
}
@Override
public AcceptorInstance getAcceptorInstance( InstanceId instanceId )
{
AcceptorInstance instance = instances.get( instanceId );
if ( instance == null )
{
instance = new AcceptorInstance();
instances.put( instanceId, instance );
}
return instance;
}
@Override
public void promise( AcceptorInstance instance, long ballot )
{
instance.promise( ballot );
}
@Override
public void accept( AcceptorInstance instance, Object value )
{
instance.accept( value );
}
@Override
public void lastDelivered( InstanceId instanceId )
{
for ( long i = lastDeliveredInstanceId; i <= instanceId.getId(); i++ )
{
instances.remove( new InstanceId(i) );
}
lastDeliveredInstanceId = instanceId.getId();
}
@Override
public void clear()
{
instances.clear();
}
public InMemoryAcceptorInstanceStore snapshot()
{
return new InMemoryAcceptorInstanceStore( new HashMap<>(instances), lastDeliveredInstanceId );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
InMemoryAcceptorInstanceStore that = (InMemoryAcceptorInstanceStore) o;
if ( lastDeliveredInstanceId != that.lastDeliveredInstanceId )
{
return false;
}
if ( !instances.equals( that.instances ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = instances.hashCode();
result = 31 * result + (int) (lastDeliveredInstanceId ^ (lastDeliveredInstanceId >>> 32));
return result;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_InMemoryAcceptorInstanceStore.java
|
3,719
|
broadcasting
{
@Override
public AtomicBroadcastState handle( AtomicBroadcastContext context,
Message<AtomicBroadcastMessage> message,
MessageHolder outgoing
)
throws Throwable
{
switch ( message.getMessageType() )
{
case broadcast:
case failed:
{
org.neo4j.cluster.InstanceId coordinator = context.getCoordinator();
if ( coordinator != null )
{
URI coordinatorUri = context.getUriForId( coordinator );
outgoing.offer( message.copyHeadersTo(
to( ProposerMessage.propose, coordinatorUri, message.getPayload() ) ) );
context.setTimeout( "broadcast-" + message.getHeader( Message.CONVERSATION_ID ),
timeout( AtomicBroadcastMessage.broadcastTimeout, message,
message.getPayload() ) );
}
else
{
outgoing.offer( message.copyHeadersTo( internal( ProposerMessage.propose,
message.getPayload() ), Message.CONVERSATION_ID, org.neo4j.cluster.protocol
.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
break;
}
case broadcastResponse:
{
context.cancelTimeout( "broadcast-" + message.getHeader( Message.CONVERSATION_ID ) );
// TODO FILTER MESSAGES
if ( message.getPayload() instanceof ClusterMessage.ConfigurationChangeState )
{
outgoing.offer( message.copyHeadersTo( internal( ClusterMessage.configurationChanged,
message.getPayload() ) ) );
ClusterMessage.ConfigurationChangeState change = message.getPayload();
if ( change.getJoinUri() != null )
{
outgoing.offer( message.copyHeadersTo(
Message.internal( HeartbeatMessage.i_am_alive,
new HeartbeatMessage.IAmAliveState( change.getJoin() ) ),
Message.FROM ) );
}
}
else
{
context.receive( message.<Payload>getPayload() );
}
break;
}
case broadcastTimeout:
{
/*
* There is never the need to rebroadcast on broadcast timeout. The propose message always
* circulates on the wire until it is accepted - it comes back here when it fails just to
* check if the coordinator changed (look at "failed/broadcast" handling above).
*/
// outgoing.offer( internal( AtomicBroadcastMessage.broadcast, message.getPayload() ) );
break;
}
case leave:
{
return start;
}
default:
{
defaultHandling( context, message, outgoing );
}
}
return this;
}
};
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_AtomicBroadcastState.java
|
3,720
|
joining
{
@Override
public State<?, ?> handle( AtomicBroadcastContext context,
Message<AtomicBroadcastMessage> message,
MessageHolder outgoing
)
throws Throwable
{
switch ( message.getMessageType() )
{
case failed:
{
// Joining failed
outgoing.offer( internal( ClusterMessage.joinFailure,
new TimeoutException( "Could not join cluster" ) ) );
return start;
}
case broadcastResponse:
{
if ( message.getPayload() instanceof ClusterMessage.ConfigurationChangeState )
{
outgoing.offer( message.copyHeadersTo( internal( ClusterMessage.configurationChanged,
message.getPayload() ) ) );
}
break;
}
case entered:
{
return broadcasting;
}
default:
{
defaultHandling( context, message, outgoing );
}
}
return this;
}
},
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_AtomicBroadcastState.java
|
3,721
|
start
{
@Override
public AtomicBroadcastState handle( AtomicBroadcastContext context,
Message<AtomicBroadcastMessage> message,
MessageHolder outgoing
)
throws Throwable
{
switch ( message.getMessageType() )
{
case entered:
{
return broadcasting;
}
case join:
{
return joining;
}
default:
{
defaultHandling( context, message, outgoing );
}
}
return this;
}
},
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_AtomicBroadcastState.java
|
3,722
|
acceptor
{
@Override
public AcceptorState handle( AcceptorContext context,
Message<AcceptorMessage> message,
MessageHolder outgoing
)
throws Throwable
{
switch ( message.getMessageType() )
{
case prepare:
{
AcceptorMessage.PrepareState incomingState = message.getPayload();
InstanceId instanceId = new InstanceId( message );
// This creates the instance if not already present
AcceptorInstance localState = context.getAcceptorInstance( instanceId );
/*
* If the incoming messages has a ballot greater than the local one, send back a promise.
* This is always true for newly seen instances, the local state has ballot initialized
* to -1
*/
if ( incomingState.getBallot() >= localState.getBallot() )
{
context.promise( localState, incomingState.getBallot() );
outgoing.offer( message.copyHeadersTo( Message.respond( ProposerMessage.promise,
message, new ProposerMessage.PromiseState( incomingState.getBallot(),
localState.getValue() ) ), InstanceId.INSTANCE ) );
}
else
{
// Optimization - explicit reject
context.getLogger( AcceptorState.class ).debug("Rejecting prepare from "
+ message.getHeader( Message.FROM ) + " for instance "
+ message.getHeader( InstanceId.INSTANCE ) + " and ballot "
+ incomingState.getBallot() + " (i had a prepare state ballot = "
+ localState.getBallot() + ")" );
outgoing.offer( message.copyHeadersTo( Message.respond( ProposerMessage
.rejectPrepare, message,
new ProposerMessage.RejectPrepare( localState.getBallot() ) ),
InstanceId.INSTANCE ) );
}
break;
}
case accept:
{
// Task 4
AcceptorMessage.AcceptState acceptState = message.getPayload();
InstanceId instanceId = new InstanceId( message );
AcceptorInstance instance = context.getAcceptorInstance( instanceId );
if ( acceptState.getBallot() == instance.getBallot() )
{
context.accept( instance, acceptState.getValue() );
instance.accept( acceptState.getValue() );
outgoing.offer( message.copyHeadersTo( Message.respond( ProposerMessage.accepted,
message,
new ProposerMessage.AcceptedState() ), InstanceId.INSTANCE ) );
}
else
{
context.getLogger( AcceptorState.class ).debug( "Reject " + instanceId
+ " accept ballot:" + acceptState.getBallot() + " actual ballot:" +
instance.getBallot() );
outgoing.offer( message.copyHeadersTo( Message.respond( ProposerMessage
.rejectAccept, message,
new ProposerMessage.RejectAcceptState() ), InstanceId.INSTANCE ) );
}
break;
}
case leave:
{
context.leave();
return start;
}
}
return this;
}
},
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_AcceptorState.java
|
3,723
|
start
{
@Override
public AcceptorState handle( AcceptorContext context,
Message<AcceptorMessage> message,
MessageHolder outgoing
)
throws Throwable
{
switch ( message.getMessageType() )
{
case join:
{
return acceptor;
}
}
return this;
}
},
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_AcceptorState.java
|
3,724
|
public static class PrepareState
implements Serializable
{
private final long ballot;
public PrepareState( long ballot )
{
this.ballot = ballot;
}
public long getBallot()
{
return ballot;
}
@Override
public String toString()
{
return "PrepareState{" +
"ballot=" + ballot +
'}';
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
PrepareState that = (PrepareState) o;
if ( ballot != that.ballot )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return (int) (ballot ^ (ballot >>> 32));
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_AcceptorMessage.java
|
3,725
|
{
@Override
public void listeningAt( URI me )
{
server3.newClient( Cluster.class ).join( "default", me );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosNetworkTest.java
|
3,726
|
{
@Override
public void enteredCluster( ClusterConfiguration clusterConfiguration )
{
semaphore.release();
}
@Override
public void joinedCluster( InstanceId instanceId, URI member )
{
logger.info( "2 sees join by " + instanceId + " at URI " + member );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosNetworkTest.java
|
3,727
|
public class AcceptorInstance
{
private long ballot = -1;
private Object value;
public long getBallot()
{
return ballot;
}
public Object getValue()
{
return value;
}
public void promise( long ballot )
{
this.ballot = ballot;
}
public void accept( Object value )
{
this.value = value;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_AcceptorInstance.java
|
3,728
|
{
@Override
public void enteredCluster( ClusterConfiguration clusterConfiguration )
{
semaphore.release();
}
@Override
public void joinedCluster( org.neo4j.cluster.InstanceId instanceId, URI member )
{
logger.info( "3 sees join by " + instanceId + " at URI " + member );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosNetworkTest.java
|
3,729
|
class AbstractContextImpl
implements TimeoutsContext, LoggingContext, ConfigurationContext
{
protected final org.neo4j.cluster.InstanceId me;
protected final CommonContextState commonState;
protected final Logging logging;
protected final Timeouts timeouts;
AbstractContextImpl( org.neo4j.cluster.InstanceId me, CommonContextState commonState,
Logging logging,
Timeouts timeouts )
{
this.me = me;
this.commonState = commonState;
this.logging = logging;
this.timeouts = timeouts;
}
@Override
public StringLogger getLogger( Class loggingClass )
{
return logging.getMessagesLog( loggingClass );
}
// TimeoutsContext
@Override
public void setTimeout( Object key, Message<? extends MessageType> timeoutMessage )
{
timeouts.setTimeout( key, timeoutMessage );
}
@Override
public void cancelTimeout( Object key )
{
timeouts.cancelTimeout( key );
}
// ConfigurationContext
@Override
public List<URI> getMemberURIs()
{
return Iterables.toList( commonState.configuration().getMemberURIs() );
}
@Override
public org.neo4j.cluster.InstanceId getMyId()
{
return me;
}
@Override
public URI boundAt()
{
return commonState.boundAt();
}
@Override
public List<URI> getAcceptors()
{
// Only use 2f+1 acceptors
return Iterables.toList( limit( commonState.configuration()
.getAllowedFailures() * 2 + 1, commonState.configuration().getMemberURIs() ) );
}
@Override
public Map<InstanceId, URI> getMembers()
{
return commonState.configuration().getMembers();
}
@Override
public InstanceId getCoordinator()
{
return commonState.configuration().getElected( ClusterConfiguration.COORDINATOR );
}
@Override
public URI getUriForId(InstanceId node )
{
return commonState.configuration().getUriForId( node );
}
@Override
public InstanceId getIdForUri( URI uri )
{
return commonState.configuration().getIdForUri( uri );
}
@Override
public synchronized boolean isMe( InstanceId server )
{
return me.equals( server );
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_context_AbstractContextImpl.java
|
3,730
|
public class Vote
implements Comparable<Vote>
{
private final InstanceId suggestedNode;
private final Comparable<Object> voteCredentials;
public Vote( InstanceId suggestedNode, Comparable<Object> voteCredentials )
{
this.suggestedNode = suggestedNode;
this.voteCredentials = voteCredentials;
}
public org.neo4j.cluster.InstanceId getSuggestedNode()
{
return suggestedNode;
}
public Comparable<Object> getCredentials()
{
return voteCredentials;
}
@Override
public String toString()
{
return suggestedNode + ":" + voteCredentials;
}
@Override
public int compareTo( Vote o )
{
return this.voteCredentials.compareTo( o.voteCredentials );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
Vote vote = (Vote) o;
if ( !suggestedNode.equals( vote.suggestedNode ) )
{
return false;
}
if ( !voteCredentials.equals( vote.voteCredentials ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = suggestedNode.hashCode();
result = 31 * result + voteCredentials.hashCode();
return result;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_Vote.java
|
3,731
|
public class ProposerStateTest
{
@SuppressWarnings( { "unchecked", "rawtypes" } )
@Test
public void ifProposingWithClosedInstanceThenRetryWithNextInstance() throws Throwable
{
ProposerContext context = Mockito.mock(ProposerContext.class);
when(context.getLogger( any(Class.class) )).thenReturn( StringLogger.DEV_NULL );
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId instanceId = new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( 42 );
PaxosInstanceStore paxosInstanceStore = new PaxosInstanceStore();
// The instance is closed
PaxosInstance paxosInstance = new PaxosInstance( paxosInstanceStore, instanceId ); // the instance
paxosInstance.closed( instanceId, "1/15#" ); // is closed for that conversation, not really important
when( context.unbookInstance( instanceId ) ).thenReturn( Message.internal( ProposerMessage.accepted, "the closed payload" ) );
when( context.getPaxosInstance( instanceId ) ).thenReturn( paxosInstance ); // required for
// But in the meantime it was reused and has now (of course) timed out
String theTimedoutPayload = "the timed out payload";
Message message = Message.internal( ProposerMessage.phase1Timeout, theTimedoutPayload );
message.setHeader( org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE, instanceId.toString() );
// Handle it
MessageHolder mockHolder = mock( MessageHolder.class );
ProposerState.proposer.handle( context, message, mockHolder );
// Verify it was resent as a propose with the same value
verify( mockHolder, times(1) ).offer(
Matchers.<Message<? extends MessageType>>argThat(
new MessageArgumentMatcher().onMessageType( ProposerMessage.propose ).withPayload( theTimedoutPayload )
) );
verify( context, times(1) ).unbookInstance( instanceId );
}
@Test
public void proposer_proposePhase1TimeoutShouldCarryOnPayload() throws Throwable
{
// GIVEN
PaxosInstance instance = mock( PaxosInstance.class );
ProposerContext context = mock( ProposerContext.class );
when( context.getPaxosInstance( any( org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.class ) ) ).thenReturn( instance );
when( context.getMyId() ).thenReturn( new org.neo4j.cluster.InstanceId( 0 ) );
TrackingMessageHolder outgoing = new TrackingMessageHolder();
String instanceId = "1";
Serializable payload = "myPayload";
Message<ProposerMessage> message = to( propose, create( "http://something" ), payload )
.setHeader( INSTANCE, instanceId );
// WHEN
ProposerState.proposer.handle( context, message, outgoing );
// THEN
verify( context ).setTimeout( eq( new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( instanceId ) ),
argThat( new MessageArgumentMatcher<>().withPayload( payload ) ) );
}
@Test
public void proposer_phase1TimeoutShouldCarryOnPayload() throws Throwable
{
// GIVEN
PaxosInstance instance = mock( PaxosInstance.class );
when( instance.isState( State.p1_pending ) ).thenReturn( true );
ProposerContext context = mock( ProposerContext.class );
when( context.getPaxosInstance( any( org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.class ) ) ).thenReturn( instance );
TrackingMessageHolder outgoing = new TrackingMessageHolder();
String instanceId = "1";
Serializable payload = "myPayload";
Message<ProposerMessage> message = to( phase1Timeout, create( "http://something" ), payload )
.setHeader( INSTANCE, instanceId );
// WHEN
ProposerState.proposer.handle( context, message, outgoing );
// THEN
verify( context ).setTimeout( eq( new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( instanceId ) ),
argThat( new MessageArgumentMatcher<>().withPayload( payload ) ) );
}
@Test
public void proposer_rejectAcceptShouldCarryOnPayload() throws Throwable
{
// GIVEN
String instanceId = "1";
PaxosInstance instance = new PaxosInstance( mock( PaxosInstanceStore.class ), new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( instanceId ) );
Serializable payload = "myPayload";
instance.propose( 1, asList( create( "http://some-guy" ) ) );
instance.ready( payload, true );
instance.pending();
ProposerContext context = mock( ProposerContext.class );
when( context.getLogger( any(Class.class) ) ).thenReturn( StringLogger.DEV_NULL );
when( context.getPaxosInstance( any( org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.class ) ) ).thenReturn( instance );
when( context.getMyId() ).thenReturn( new org.neo4j.cluster.InstanceId( parseInt( instanceId ) ) );
TrackingMessageHolder outgoing = new TrackingMessageHolder();
Message<ProposerMessage> message = to( rejectAccept, create( "http://something" ),
new ProposerMessage.RejectAcceptState() )
.setHeader( INSTANCE, instanceId );
// WHEN
ProposerState.proposer.handle( context, message, outgoing );
// THEN
verify( context ).setTimeout( eq( new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( instanceId ) ),
argThat( new MessageArgumentMatcher<>().withPayload( payload ) ) );
}
@SuppressWarnings( "unchecked" )
@Test
public void proposer_promiseShouldCarryOnPayloadToPhase2Timeout() throws Throwable
{
// GIVEN
String instanceId = "1";
Serializable payload = "myPayload";
PaxosInstance instance = new PaxosInstance( mock( PaxosInstanceStore.class ), new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( instanceId ) );
instance.propose( 1, asList( create( "http://some-guy" ) ) );
instance.value_2 = payload; // don't blame me for making it package access.
ProposerContext context = mock( ProposerContext.class );
when( context.getPaxosInstance( any( org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.class ) ) ).thenReturn( instance );
when( context.getMinimumQuorumSize( anyList() ) ).thenReturn( 1 );
TrackingMessageHolder outgoing = new TrackingMessageHolder();
Message<ProposerMessage> message = to( promise, create( "http://something" ),
new ProposerMessage.PromiseState( 1, payload ) ).setHeader( INSTANCE, instanceId );
// WHEN
ProposerState.proposer.handle( context, message, outgoing );
// THEN
verify( context ).setTimeout( eq( new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( instanceId ) ),
argThat( new MessageArgumentMatcher<>().withPayload( payload ) ) );
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_ProposerStateTest.java
|
3,732
|
proposer
{
@Override
public ProposerState handle( ProposerContext context,
Message<ProposerMessage> message,
MessageHolder outgoing
)
throws Throwable
{
switch ( message.getMessageType() )
{
case propose:
{
propose( context, message, outgoing, determineAcceptorSet( message, context ) );
break;
}
case rejectPrepare:
{
// Denial of prepare
ProposerMessage.RejectPrepare rejectPropose = message.getPayload();
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId instanceId = new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( message );
PaxosInstance instance = context.getPaxosInstance( instanceId );
context.getLogger( ProposerState.class ).debug( "Propose for instance " + instance
+ " rejected from " + message.getHeader( Message.FROM ) + " with ballot "
+ rejectPropose.getBallot() );
if ( instance.isState( PaxosInstance.State.p1_pending ) )
{
long ballot = instance.ballot;
while ( ballot <= rejectPropose.getBallot() )
{
ballot += 1000; // Make sure we win next time
}
instance.phase1Timeout( ballot );
context.getLogger( ProposerState.class ).debug(
"Reproposing instance " + instance + " at ballot " + instance.ballot
+ " after rejectPrepare" );
for ( URI acceptor : instance.getAcceptors() )
{
outgoing.offer( message.copyHeadersTo( Message.to( AcceptorMessage.prepare,
acceptor, new AcceptorMessage.PrepareState( ballot ) ),
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
assert instance.value_1 == null : "value_1 should have been null at this point";
Object payload = context.getBookedInstance( instanceId ).getPayload();
assert payload != null : "Should have a booked instance payload for " + instanceId;
// This will reset the phase1Timeout if existing
context.setTimeout( instanceId, message.copyHeadersTo( Message.timeout(
ProposerMessage.phase1Timeout, message, payload ), org.neo4j.cluster.protocol
.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
break;
}
case phase1Timeout:
{
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId instanceId = new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( message );
PaxosInstance instance = context.getPaxosInstance( instanceId );
if ( instance.isState( PaxosInstance.State.p1_pending ) )
{
if ( instance.ballot > 10000 )
{
context.getLogger( ProposerState.class ).warn( "Propose failed due to phase 1 " +
"timeout" );
// Fail this propose
Message originalMessage = context.getBookedInstance( instance.id );
// Also make sure that all headers are copied over
outgoing.offer( originalMessage.copyHeadersTo(
Message.internal( AtomicBroadcastMessage.failed,
originalMessage.getPayload() ) ) );
context.cancelTimeout( instanceId );
}
else
{
long ballot = instance.ballot + 1000;
instance.phase1Timeout( ballot );
for ( URI acceptor : instance.getAcceptors() )
{
outgoing.offer( message.copyHeadersTo( Message.to( AcceptorMessage.prepare,
acceptor, new AcceptorMessage.PrepareState( ballot ) ),
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
context.setTimeout( instanceId, message.copyHeadersTo( Message.timeout(
ProposerMessage.phase1Timeout, message, message.getPayload() ),
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
}
else if ( instance.isState( PaxosInstance.State.closed ) || instance.isState(
PaxosInstance.State.delivered ) )
{
// Retry
Message oldMessage = context.unbookInstance( instance.id );
context.getLogger( getClass() ).debug( "Retrying instance " + instance.id +
" with message " + message.getPayload() +
". Previous instance was " + oldMessage );
outgoing.offer( Message.internal( ProposerMessage.propose, message.getPayload() ) );
}
break;
}
case promise:
{
// P
ProposerMessage.PromiseState promiseState = message.getPayload();
PaxosInstance instance = context.getPaxosInstance( new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( message ) );
if ( instance.isState( PaxosInstance.State.p1_pending ) && instance.ballot ==
promiseState.getBallot() )
{
instance.promise( promiseState );
if ( instance.isPromised( context.getMinimumQuorumSize( instance.getAcceptors() ) ) )
{
context.cancelTimeout( instance.id );
// No promises contained a value
Object readyValue = instance.value_2 == null ?
context.getBookedInstance( instance.id ).getPayload() : instance
.value_2;
if ( instance.value_1 == null )
{
// R0
instance.ready( readyValue, true );
}
else
{
// R1
if ( instance.value_2 == null )
{
// Another value was already associated with this instance. Push value
// back onto pending list
context.pendingValue( context.unbookInstance( instance.id ) );
instance.ready( instance.value_1, false );
}
else if ( instance.value_1.equals( readyValue ) )
{
instance.ready( instance.value_2, instance.clientValue );
}
else if ( instance.clientValue )
{
// Another value was already associated with this instance. Push value
// back onto pending list
context.pendingValue( context.unbookInstance( instance.id ) );
instance.ready( instance.value_1, false );
}
else
{
// Another value was already associated with this instance. Push value
// back onto pending list
context.pendingValue( context.unbookInstance( instance.id ) );
instance.ready( instance.value_1, false );
}
}
// E: Send to Acceptors
instance.pending();
for ( URI acceptor : instance.getAcceptors() )
{
outgoing.offer( message.copyHeadersTo( Message.to( AcceptorMessage.accept,
acceptor,
new AcceptorMessage.AcceptState( instance.ballot,
instance.value_2 ) ), org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
context.setTimeout( instance.id,
message.copyHeadersTo( Message.timeout( ProposerMessage.phase2Timeout,
message, readyValue ), org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
else
{
}
}
else
{
}
break;
}
case rejectAccept:
{
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId instanceId = new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( message );
PaxosInstance instance = context.getPaxosInstance( instanceId );
if ( instance.isState( PaxosInstance.State.p2_pending ) )
{
ProposerMessage.RejectAcceptState state = message.getPayload();
instance.rejected( state );
if ( !instance.isAccepted( context.getMinimumQuorumSize( instance.getAcceptors() ) ) )
{
context.cancelTimeout( instanceId );
context.getLogger( ProposerState.class ).warn( "Accept rejected:" +
instance.state );
if ( instance.clientValue )
{
Message copyWithValue = Message.internal( ProposerMessage.propose,
instance.value_2 );
message.copyHeadersTo( copyWithValue );
propose( context, copyWithValue, outgoing, instance.getAcceptors() );
}
}
}
break;
}
case phase2Timeout:
{
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId instanceId = new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId( message );
PaxosInstance instance = context.getPaxosInstance( instanceId );
if ( instance.isState( PaxosInstance.State.p2_pending ) )
{
long ballot = instance.ballot + 1000;
instance.phase2Timeout( ballot );
for ( URI acceptor : instance.getAcceptors() )
{
outgoing.offer( message.copyHeadersTo( Message.to( AcceptorMessage.prepare,
acceptor, new AcceptorMessage.PrepareState( ballot ) ),
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
context.setTimeout( instanceId, message.copyHeadersTo( Message.timeout(
ProposerMessage.phase1Timeout, message, message.getPayload() ),
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
else if ( instance.isState( PaxosInstance.State.closed )
|| instance.isState( PaxosInstance.State.delivered ) )
{
outgoing.offer( message.copyHeadersTo( Message.internal( ProposerMessage.propose,
message.getPayload() ) ) );
}
break;
}
case accepted:
{
PaxosInstance instance = context.getPaxosInstance( new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId(
message ) );
if ( instance.isState( PaxosInstance.State.p2_pending ) )
{
ProposerMessage.AcceptedState acceptedState = message.getPayload();
instance.accepted( acceptedState );
// Value has been accepted! Now distribute to all learners
if ( instance.accepts.size() >= context.getMinimumQuorumSize( instance.getAcceptors()
) )
{
context.cancelTimeout( instance.id );
// Might have to extra-tell myself if not yet officially part of cluster
if ( instance.value_2 instanceof ClusterMessage.ConfigurationChangeState )
{
context.patchBookedInstances( (ClusterMessage.ConfigurationChangeState) instance.value_2);
ClusterMessage.ConfigurationChangeState state = (ClusterMessage
.ConfigurationChangeState) instance.value_2;
// TODO getLearners might return wrong list if another join happens at the
// same time
// Proper fix is to wait with this learn until we have learned all previous
// configuration changes
// TODO Fix this to use InstanceId instead of URI
for ( URI learner : context.getMemberURIs() )
{
if ( learner.equals( context.boundAt() ) )
{
outgoing.offer( message.copyHeadersTo( Message.internal( LearnerMessage
.learn, new LearnerMessage.LearnState( instance.value_2 ) ),
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
else
{
outgoing.offer( message.copyHeadersTo( Message.to( LearnerMessage
.learn, learner,
new LearnerMessage.LearnState( instance.value_2 ) ),
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
}
// Tell joiner of this cluster configuration change
if ( state.getJoin() != null )
{
outgoing.offer( message.copyHeadersTo( Message.to( LearnerMessage
.learn, state.getJoinUri(),
new LearnerMessage.LearnState( instance.value_2 ) ),
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
}
else
{
// Tell learners
for ( URI learner : context.getMemberURIs() )
{
outgoing.offer( message.copyHeadersTo( Message.to( LearnerMessage
.learn, learner,
new LearnerMessage.LearnState( instance.value_2 ) ),
org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.InstanceId.INSTANCE ) );
}
}
context.unbookInstance( instance.id );
// Check if we have anything pending - try to start process for it
if ( context.hasPendingValues() && context.canBookInstance() )
{
Message proposeMessage = context.popPendingValue();
context.getLogger( ProposerState.class ).debug( "Restarting "
+ proposeMessage + " booked:"
+ context.nrOfBookedInstances() );
outgoing.offer( proposeMessage );
}
}
} else
{
context.getLogger( ProposerState.class ).debug( "Instance receiving an accepted is in the wrong state:"+instance );
}
break;
}
case leave:
{
context.leave();
return start;
}
}
return this;
}
};
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_ProposerState.java
|
3,733
|
start
{
@Override
public ProposerState handle( ProposerContext context,
Message<ProposerMessage> message,
MessageHolder outgoing
)
throws Throwable
{
switch ( message.getMessageType() )
{
case join:
{
return proposer;
}
}
return this;
}
},
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_ProposerState.java
|
3,734
|
public static class RejectPrepare
implements Serializable
{
private long ballot;
public RejectPrepare( long ballot )
{
this.ballot = ballot;
}
public long getBallot()
{
return ballot;
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
RejectPrepare that = (RejectPrepare) o;
if ( ballot != that.ballot )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return (int) (ballot ^ (ballot >>> 32));
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_ProposerMessage.java
|
3,735
|
public static class RejectAcceptState
implements Serializable
{
public RejectAcceptState()
{
}
@Override
public boolean equals( Object obj )
{
return obj instanceof RejectAcceptState;
}
@Override
public int hashCode()
{
return 0;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_ProposerMessage.java
|
3,736
|
public static class PromiseState
implements Serializable
{
private long ballot;
private Object value;
public PromiseState( long ballot, Object value )
{
this.ballot = ballot;
this.value = value;
}
public long getBallot()
{
return ballot;
}
public Object getValue()
{
return value;
}
@Override
public String toString()
{
return "PromiseState{" +
"ballot=" + ballot +
", value=" + value +
'}';
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
PromiseState that = (PromiseState) o;
if ( ballot != that.ballot )
{
return false;
}
if ( value != null ? !value.equals( that.value ) : that.value != null )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = (int) (ballot ^ (ballot >>> 32));
result = 31 * result + (value != null ? value.hashCode() : 0);
return result;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_ProposerMessage.java
|
3,737
|
public static class AcceptedState
implements Serializable
{
public AcceptedState()
{
}
@Override
public boolean equals( Object obj )
{
return obj instanceof AcceptedState;
}
@Override
public int hashCode()
{
return 0;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_ProposerMessage.java
|
3,738
|
public class PaxosInstanceStore
{
private static final int MAX_STORED = 100;
private int queued = 0;
private Queue<InstanceId> delivered = new LinkedList<InstanceId>();
private Map<InstanceId, PaxosInstance> instances = new HashMap<InstanceId, PaxosInstance>();
public PaxosInstance getPaxosInstance( InstanceId instanceId )
{
if ( instanceId == null )
{
throw new NullPointerException( "InstanceId may not be null" );
}
PaxosInstance instance = instances.get( instanceId );
if ( instance == null )
{
instance = new PaxosInstance( this, instanceId );
instances.put( instanceId, instance );
}
return instance;
}
public void delivered( InstanceId instanceId )
{
queued++;
delivered.offer( instanceId );
if ( queued > MAX_STORED )
{
InstanceId removeInstanceId = delivered.poll();
instances.remove( removeInstanceId );
queued--;
}
}
public void leave()
{
queued = 0;
delivered.clear();
instances.clear();
}
public PaxosInstanceStore snapshot()
{
PaxosInstanceStore snapshotStore = new PaxosInstanceStore();
snapshotStore.queued = queued;
snapshotStore.delivered = new LinkedList<>(delivered);
for ( Map.Entry<InstanceId, PaxosInstance> instance : instances.entrySet() )
{
snapshotStore.instances.put( instance.getKey(), instance.getValue().snapshot(snapshotStore) );
}
return snapshotStore;
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
PaxosInstanceStore that = (PaxosInstanceStore) o;
if ( queued != that.queued )
{
return false;
}
if ( !delivered.equals( that.delivered ) )
{
return false;
}
if ( !instances.equals( that.instances ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = queued;
result = 31 * result + delivered.hashCode();
result = 31 * result + instances.hashCode();
return result;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_PaxosInstanceStore.java
|
3,739
|
public class PaxosInstance
{
enum State
{
empty,
p1_pending,
p1_ready,
p2_pending,
closed,
delivered;
}
PaxosInstanceStore store;
InstanceId id = null;
State state = State.empty;
long ballot = 0;
List<URI> acceptors;
List<ProposerMessage.PromiseState> promises = new ArrayList<ProposerMessage.PromiseState>();
List<ProposerMessage.AcceptedState> accepts = new ArrayList<ProposerMessage.AcceptedState>();
List<ProposerMessage.RejectAcceptState> rejectedAccepts = new ArrayList<ProposerMessage.RejectAcceptState>();
Object value_1;
long phase1Ballot = 0;
Object value_2;
// This is true iff the acceptors did not already have a value for this instance
boolean clientValue = false;
String conversationIdHeader;
public PaxosInstance( PaxosInstanceStore store, InstanceId instanceId )
{
this.store = store;
this.id = instanceId;
}
public boolean isState( State s )
{
return state.equals( s );
}
public void propose( long ballot, List<URI> acceptors )
{
this.state = State.p1_pending;
this.acceptors = acceptors;
this.ballot = ballot;
}
public void phase1Timeout( long ballot )
{
this.ballot = ballot;
promises.clear();
}
public void promise( ProposerMessage.PromiseState promiseState )
{
promises.add( promiseState );
if ( promiseState.getValue() != null && promiseState.getBallot() > phase1Ballot )
{
value_1 = promiseState.getValue();
phase1Ballot = promiseState.getBallot();
}
}
public boolean isPromised( int minimumQuorumSize )
{
return promises.size() == minimumQuorumSize;
}
public void ready( Object value, boolean clientValue )
{
assertNotNull( value );
state = State.p1_ready;
promises.clear();
value_1 = null;
phase1Ballot = 0;
value_2 = value;
this.clientValue = clientValue;
}
public void pending()
{
state = State.p2_pending;
}
public void phase2Timeout( long ballot )
{
state = State.p1_pending;
this.ballot = ballot;
promises.clear();
value_1 = null;
phase1Ballot = 0;
}
public void accepted( ProposerMessage.AcceptedState acceptedState )
{
accepts.add( acceptedState );
}
public void rejected( ProposerMessage.RejectAcceptState rejectAcceptState )
{
rejectedAccepts.add( rejectAcceptState );
}
public boolean isAccepted( int minimumQuorumSize )
{
// If we have received enough responses to meet quorum and a majority
// are accepts, then the instance is considered accepted
return accepts.size() + rejectedAccepts.size() == minimumQuorumSize &&
accepts.size() > rejectedAccepts.size();
}
public void closed( Object value, String conversationIdHeader )
{
assertNotNull( value );
value_2 = value;
state = State.closed;
accepts.clear();
rejectedAccepts.clear();
acceptors = null;
this.conversationIdHeader = conversationIdHeader;
}
private void assertNotNull( Object value )
{
if ( value == null )
{
throw new IllegalArgumentException( "value null" );
}
}
public void delivered()
{
state = State.delivered;
store.delivered( id );
}
public List<URI> getAcceptors()
{
return acceptors;
}
public PaxosInstance snapshot(PaxosInstanceStore store)
{
PaxosInstance snap = new PaxosInstance( store, id );
snap.state = state;
snap.ballot = ballot;
snap.acceptors = acceptors == null ? null : new ArrayList<>(acceptors);
snap.promises = promises == null ? null : new ArrayList<>(promises);
snap.accepts = accepts == null ? null : new ArrayList<>(accepts);
snap.rejectedAccepts = rejectedAccepts == null ? null : new ArrayList<>(rejectedAccepts);
snap.value_1 = value_1;
snap.phase1Ballot = phase1Ballot;
snap.value_2 = value_2;
snap.clientValue = clientValue;
snap.conversationIdHeader = conversationIdHeader;
return snap;
}
@Override
public String toString()
{
return "[id:" + id +
" state:" + state.name() +
" b:" + ballot +
" v1:" + value_1 +
" v2:" + value_2 + "]";
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_PaxosInstance.java
|
3,740
|
public class PaxosClusterConfiguration
{
List<String> proposers = new ArrayList<String>();
List<String> acceptors = new ArrayList<String>();
List<String> learners = new ArrayList<String>();
String coordinator;
int allowedFailures = 1; // Number of allowed failures
public PaxosClusterConfiguration(List<String> proposers, List<String> acceptors, List<String> learners, String coordinator, int allowedFailures)
{
this.proposers = proposers;
this.acceptors = acceptors;
this.learners = learners;
this.coordinator = coordinator;
this.allowedFailures = allowedFailures;
}
public List<String> getProposers()
{
return proposers;
}
public List<String> getAcceptors()
{
return acceptors;
}
public List<String> getLearners()
{
return learners;
}
public String getCoordinator()
{
return coordinator;
}
public int getAllowedFailures()
{
return allowedFailures;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_PaxosClusterConfiguration.java
|
3,741
|
private static final class DaPayload implements Serializable
{}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosTest.java
|
3,742
|
public class MultiPaxosTest
{
/*
private NetworkMock network = new NetworkMock( 50,
new MultipleFailureLatencyStrategy( new FixedNetworkLatencyStrategy( 0 ) ),
new MessageTimeoutStrategy( new FixedTimeoutStrategy( 1000 ) ) );
@Rule
public ClusterRule cluster = new ClusterRule( network, 3 );
@Test
public void testDecision()
throws ExecutionException, InterruptedException, URISyntaxException
{
Map<String, String> map1 = new AtomicBroadcastMap<String, String>( cluster.getNodes().get( 0 ).newClient(
AtomicBroadcast.class ), cluster.getNodes().get( 0 ).newClient( Snapshot.class ) );
Map<String, String> map2 = new AtomicBroadcastMap<String, String>( cluster.getNodes().get( 1 ).newClient(
AtomicBroadcast.class ), cluster.getNodes().get( 1 ).newClient( Snapshot.class ) );
map1.put( "foo", "bar" );
network.tick( 30 );
Object foo = map1.get( "foo" );
Assert.assertThat( foo.toString(), equalTo( "bar" ) );
map1.put( "bar", "foo" );
network.tick( 30 );
Object bar = map2.get( "bar" );
Assert.assertThat( bar.toString(), equalTo( "foo" ) );
map1.put( "foo", "bar2" );
network.tick( 30 );
foo = map2.get( "foo" );
Assert.assertThat( foo.toString(), equalTo( "bar2" ) );
map1.clear();
network.tick( 30 );
foo = map2.get( "foo" );
Assert.assertThat( foo, CoreMatchers.nullValue() );
}
*/
@Test
public void testFailure() throws Exception
{
ScriptableNetworkFailureLatencyStrategy networkLatency = new ScriptableNetworkFailureLatencyStrategy();
NetworkMock network = new NetworkMock( 50,
new MultipleFailureLatencyStrategy( networkLatency ),
new MessageTimeoutStrategy( new FixedTimeoutStrategy( 1000 ) ) );
List<TestProtocolServer> nodes = new ArrayList<TestProtocolServer>();
TestProtocolServer server = network.addServer( 1, URI.create( "cluster://server1" ) );
server.newClient( Cluster.class ).create( "default" );
network.tickUntilDone();
nodes.add( server );
for ( int i = 1; i < 3; i++ )
{
TestProtocolServer protocolServer = network.addServer( i + 1, new URI( "cluster://server" + (i + 1) ) );
protocolServer.newClient( Cluster.class ).join( "default", new URI( "cluster://server1" ) );
network.tick( 10 );
nodes.add( protocolServer );
}
final AtomicBroadcast atomicBroadcast = nodes.get( 0 ).newClient( AtomicBroadcast.class );
ObjectStreamFactory objectStreamFactory = new ObjectStreamFactory();
final AtomicBroadcastSerializer serializer = new AtomicBroadcastSerializer( objectStreamFactory,
objectStreamFactory );
atomicBroadcast.broadcast( serializer.broadcast( new DaPayload() ) );
networkLatency.nodeIsDown( "cluster://server2" );
networkLatency.nodeIsDown( "cluster://server3" );
atomicBroadcast.broadcast( serializer.broadcast( new DaPayload() ) );
network.tick( 100 );
networkLatency.nodeIsUp( "cluster://server3" );
network.tick( 1000 );
for ( TestProtocolServer node : nodes )
{
node.newClient( Cluster.class ).leave();
network.tick( 10 );
}
}
private static final class DaPayload implements Serializable
{}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosTest.java
|
3,743
|
public static class PaxosServer
{
Process server;
ProcessStreamHandler handler;
BufferedWriter writer;
public PaxosServer( Process server, String prefix )
{
this.server = server;
handler = new ProcessStreamHandler( server, false, prefix, PRINT_FAILURES );
handler.launch();
writer = new BufferedWriter( new OutputStreamWriter(server.getOutputStream()));
}
public void command(String cmd)
throws IOException
{
System.out.println( "Send command:"+cmd );
writer.write( cmd+"\n" );
writer.flush();
}
public void quit()
throws IOException
{
command( "quit" );
handler.done();
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosServerCluster.java
|
3,744
|
public class MultiPaxosServerCluster
{
public static void main( String[] args )
throws IOException, InterruptedException
{
new MultiPaxosServerCluster(3);
}
List<PaxosServer> servers = new ArrayList<PaxosServer>( );
public MultiPaxosServerCluster(int count)
throws IOException, InterruptedException
{
String processCommand = "java "+ MultiPaxosServer.class.getName();
System.out.println( processCommand );
for (int i = 0; i < count; i++)
{
Process server = Runtime.getRuntime().exec( processCommand, new String[]{"CLASSPATH=\"" + System.getProperty( "java.class.path" )+"\""} );
sleep( 500 );
servers.add( new PaxosServer( server, "["+(i+1)+"] " ) );
}
sleep( 3000 );
// all( "logging org.neo4j.kernel.ha2.protocol off" );
send( 1, "create default" );
send( 2, "join neo4j://localhost:5001" );
send( 3, "join neo4j://localhost:5001" );
sleep( 6000 );
send( 1, "broadcast hello" );
sleep( 10000 );
send( 1, "leave");
sleep( 1000 );
send( 2, "leave");
sleep( 1000 );
send( 1, "join neo4j://localhost:5003");
send( 2, "join neo4j://localhost:5003");
sleep( 6000 );
send( 3, "promote neo4j://127.0.0.1:5001 coordinator" );
sleep( 6000 );
send( 1, "broadcast hello2" );
for( int i = 0; i < servers.size(); i++ )
{
sleep( 3000 );
PaxosServer paxosServer = servers.get( i );
paxosServer.quit();
}
}
private void sleep( int i )
throws InterruptedException
{
Thread.sleep( i );
}
private void send( int i, String s )
throws IOException
{
servers.get( i-1 ).command( s );
}
private void all(String command)
throws IOException
{
for( PaxosServer server : servers )
{
server.command( command );
}
}
public static class PaxosServer
{
Process server;
ProcessStreamHandler handler;
BufferedWriter writer;
public PaxosServer( Process server, String prefix )
{
this.server = server;
handler = new ProcessStreamHandler( server, false, prefix, PRINT_FAILURES );
handler.launch();
writer = new BufferedWriter( new OutputStreamWriter(server.getOutputStream()));
}
public void command(String cmd)
throws IOException
{
System.out.println( "Send command:"+cmd );
writer.write( cmd+"\n" );
writer.flush();
}
public void quit()
throws IOException
{
command( "quit" );
handler.done();
}
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosServerCluster.java
|
3,745
|
{
@Override
public void receive( Payload value )
{
try
{
System.out.println( broadcastSerializer.receive( value ) );
}
catch ( IOException e )
{
e.printStackTrace();
}
catch ( ClassNotFoundException e )
{
e.printStackTrace();
}
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosServer.java
|
3,746
|
{
@Override
public void failed( InstanceId server )
{
System.out.println( server + " failed" );
}
@Override
public void alive( InstanceId server )
{
System.out.println( server + " alive" );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosServer.java
|
3,747
|
{
@Override
public void listeningAt( URI me )
{
System.out.println( "Listening at:" + me );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_MultiPaxosServer.java
|
3,748
|
public static class AcceptState
implements Serializable
{
private long ballot;
private Object value;
public AcceptState( long ballot, Object value )
{
this.ballot = ballot;
this.value = value;
}
public long getBallot()
{
return ballot;
}
public Object getValue()
{
return value;
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
AcceptState that = (AcceptState) o;
if ( ballot != that.ballot )
{
return false;
}
if ( value != null ? !value.equals( that.value ) : that.value != null )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = (int) (ballot ^ (ballot >>> 32));
result = 31 * result + (value != null ? value.hashCode() : 0);
return result;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_AcceptorMessage.java
|
3,749
|
public class VersionMapper
{
private static final Map<String, Long> classNameToSerialVersionUID = new HashMap<String, Long>();
public long mappingFor( String className )
{
return classNameToSerialVersionUID.get( className );
}
public boolean hasMappingFor( String className )
{
return classNameToSerialVersionUID.containsKey( className );
}
public void addMappingFor( String wireClassDescriptorName, long serialVersionUID )
{
classNameToSerialVersionUID.put(wireClassDescriptorName, serialVersionUID);
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_VersionMapper.java
|
3,750
|
{
@Override
public HostnamePort clusterServer()
{
return conf.get( ClusterSettings.cluster_server );
}
@Override
public int defaultPort()
{
return 5001;
}
@Override
public String name()
{
return null;
}
}, new DevNullLoggingService()));
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_com_message_NetworkSenderReceiverTest.java
|
3,751
|
private class HeartbeatListenerImpl implements HeartbeatListener
{
@Override
public void failed( final InstanceId server )
{
Listeners.notifyListeners( listeners, new Listeners.Notification<ClusterMemberListener>()
{
@Override
public void notify( ClusterMemberListener listener )
{
listener.memberIsFailed( server );
}
} );
}
@Override
public void alive( final InstanceId server )
{
Listeners.notifyListeners( listeners, new Listeners.Notification<ClusterMemberListener>()
{
@Override
public void notify( ClusterMemberListener listener )
{
listener.memberIsAlive( server );
}
} );
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,752
|
{
@Override
public boolean accept( MemberIsAvailable item )
{
return !(item.getClusterUri().equals( member ) && item.getRole().equals( role ));
}
}, availableMembers));
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,753
|
{
@Override
public boolean accept( MemberIsAvailable item )
{
return !item.getInstanceId().equals( member );
}
}, availableMembers ) );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,754
|
public static class ClusterMembersSnapshot
implements Serializable
{
private final
Function2<Iterable<MemberIsAvailable>, MemberIsAvailable, Iterable<MemberIsAvailable>> nextSnapshotFunction;
private Iterable<MemberIsAvailable> availableMembers = new ArrayList<MemberIsAvailable>();
public ClusterMembersSnapshot( Function2<Iterable<MemberIsAvailable>, MemberIsAvailable, Iterable<MemberIsAvailable>> nextSnapshotFunction )
{
this.nextSnapshotFunction = nextSnapshotFunction;
}
public void availableMember( MemberIsAvailable memberIsAvailable )
{
availableMembers = toList( nextSnapshotFunction.apply( availableMembers, memberIsAvailable ) );
}
public void unavailableMember( final InstanceId member )
{
availableMembers = toList( filter( new Predicate<MemberIsAvailable>()
{
@Override
public boolean accept( MemberIsAvailable item )
{
return !item.getInstanceId().equals( member );
}
}, availableMembers ) );
}
public void unavailableMember( final URI member, final String role )
{
availableMembers = toList( filter(new Predicate<MemberIsAvailable>()
{
@Override
public boolean accept( MemberIsAvailable item )
{
return !(item.getClusterUri().equals( member ) && item.getRole().equals( role ));
}
}, availableMembers));
}
public Iterable<MemberIsAvailable> getCurrentAvailableMembers()
{
return availableMembers;
}
public Iterable<MemberIsAvailable> getCurrentAvailable( final InstanceId memberId )
{
return toList( Iterables.filter( new Predicate<MemberIsAvailable>()
{
@Override
public boolean accept( MemberIsAvailable item )
{
return item.getInstanceId().equals( memberId );
}
}, availableMembers) );
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,755
|
{
@Override
public void notify( ClusterMemberListener listener )
{
listener.coordinatorIsElected( instanceId );
}
} );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,756
|
{
@Override
public void notify( ClusterMemberListener listener )
{
listener.memberIsUnavailable( memberIsUnavailable.getRole(),
memberIsUnavailable.getInstanceId() );
}
} );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,757
|
{
@Override
public void notify( ClusterMemberListener listener )
{
listener.memberIsAvailable( memberIsAvailable.getRole(),
memberIsAvailable.getInstanceId(), memberIsAvailable.getRoleUri() );
}
} );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,758
|
private class AtomicBroadcastListenerImpl implements AtomicBroadcastListener
{
@Override
public void receive( Payload payload )
{
try
{
final Object value = serializer.receive( payload );
if ( value instanceof MemberIsAvailable )
{
final MemberIsAvailable memberIsAvailable = (MemberIsAvailable) value;
// Update snapshot
clusterMembersSnapshot.availableMember( memberIsAvailable );
logger.info("Snapshot:"+clusterMembersSnapshot.getCurrentAvailableMembers());
Listeners.notifyListeners( listeners, new Listeners.Notification<ClusterMemberListener>()
{
@Override
public void notify( ClusterMemberListener listener )
{
listener.memberIsAvailable( memberIsAvailable.getRole(),
memberIsAvailable.getInstanceId(), memberIsAvailable.getRoleUri() );
}
} );
}
else if ( value instanceof MemberIsUnavailable )
{
final MemberIsUnavailable memberIsUnavailable = (MemberIsUnavailable) value;
// Update snapshot
clusterMembersSnapshot.unavailableMember( memberIsUnavailable.getClusterUri(),
memberIsUnavailable.getRole() );
Listeners.notifyListeners( listeners, new Listeners.Notification<ClusterMemberListener>()
{
@Override
public void notify( ClusterMemberListener listener )
{
listener.memberIsUnavailable( memberIsUnavailable.getRole(),
memberIsUnavailable.getInstanceId() );
}
} );
}
}
catch ( Throwable t )
{
logger.error( "Could not handle cluster member available message", t );
}
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,759
|
{
@Override
public void listeningAt( URI me )
{
serverClusterId = me;
PaxosClusterMemberAvailability.this.logger.logMessage( "Listening at:" + me );
}
};
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberAvailability.java
|
3,760
|
public class PaxosClusterMemberAvailability implements ClusterMemberAvailability, Lifecycle
{
private volatile URI serverClusterId;
private StringLogger logger;
protected AtomicBroadcastSerializer serializer;
private final InstanceId myId;
private BindingNotifier binding;
private AtomicBroadcast atomicBroadcast;
private BindingListener bindingListener;
private ObjectInputStreamFactory objectInputStreamFactory;
private ObjectOutputStreamFactory objectOutputStreamFactory;
public PaxosClusterMemberAvailability( InstanceId myId, BindingNotifier binding, AtomicBroadcast atomicBroadcast,
Logging logging, ObjectInputStreamFactory objectInputStreamFactory,
ObjectOutputStreamFactory objectOutputStreamFactory )
{
this.myId = myId;
this.binding = binding;
this.atomicBroadcast = atomicBroadcast;
this.objectInputStreamFactory = objectInputStreamFactory;
this.objectOutputStreamFactory = objectOutputStreamFactory;
this.logger = logging.getMessagesLog( getClass() );
bindingListener = new BindingListener()
{
@Override
public void listeningAt( URI me )
{
serverClusterId = me;
PaxosClusterMemberAvailability.this.logger.logMessage( "Listening at:" + me );
}
};
}
@Override
public void init()
throws Throwable
{
serializer = new AtomicBroadcastSerializer( objectInputStreamFactory, objectOutputStreamFactory );
binding.addBindingListener( bindingListener );
}
@Override
public void start()
throws Throwable
{
}
@Override
public void stop()
throws Throwable
{
}
@Override
public void shutdown()
throws Throwable
{
binding.removeBindingListener( bindingListener );
}
@Override
public void memberIsAvailable( String role, URI roleUri )
{
try
{
Payload payload = serializer.broadcast( new MemberIsAvailable( role, myId, serverClusterId, roleUri ) );
serializer.receive( payload );
atomicBroadcast.broadcast( payload );
}
catch ( Throwable e )
{
logger.warn( "Could not distribute member availability", e );
}
}
@Override
public void memberIsUnavailable( String role )
{
try
{
Payload payload = serializer.broadcast( new MemberIsUnavailable( role, myId, serverClusterId ) );
serializer.receive( payload );
atomicBroadcast.broadcast( payload );
}
catch ( Throwable e )
{
logger.warn( "Could not distribute member unavailability", e );
}
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberAvailability.java
|
3,761
|
public class MemberIsUnavailable
implements Externalizable
{
private String role;
private InstanceId instanceId;
private URI clusterUri;
public MemberIsUnavailable()
{
}
public MemberIsUnavailable( String role, InstanceId instanceId, URI clusterUri)
{
this.role = role;
this.instanceId = instanceId;
this.clusterUri = clusterUri;
}
public String getRole()
{
return role;
}
public InstanceId getInstanceId()
{
return instanceId;
}
public URI getClusterUri()
{
return clusterUri;
}
@Override
public void writeExternal( ObjectOutput out ) throws IOException
{
out.writeUTF( role );
out.writeObject( instanceId );
out.writeUTF( clusterUri.toString() );
}
@Override
public void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException
{
role = in.readUTF();
instanceId = (InstanceId) in.readObject();
clusterUri = URI.create( in.readUTF() );
}
@Override
public String toString()
{
return String.format( "MemberIsUnavailable[ Role: %s, InstanceId: %s, ClusterURI: %s ]",
role, instanceId.toString(), clusterUri.toString() );
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_MemberIsUnavailable.java
|
3,762
|
public class MemberIsAvailable
implements Externalizable
{
private String role;
private InstanceId instanceId;
private URI clusterUri;
private URI roleUri;
public MemberIsAvailable()
{
}
public MemberIsAvailable( String role, InstanceId instanceId, URI clusterUri, URI roleUri )
{
this.role = role;
this.instanceId = instanceId;
this.clusterUri = clusterUri;
this.roleUri = roleUri;
}
public String getRole()
{
return role;
}
public InstanceId getInstanceId()
{
return instanceId;
}
public URI getClusterUri()
{
return clusterUri;
}
public URI getRoleUri()
{
return roleUri;
}
@Override
public void writeExternal( ObjectOutput out ) throws IOException
{
out.writeUTF( role );
out.writeObject( instanceId );
out.writeUTF( clusterUri.toString() );
out.writeUTF( roleUri.toString() );
}
@Override
public void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException
{
role = in.readUTF();
instanceId = (InstanceId) in.readObject();
clusterUri = URI.create( in.readUTF() );
roleUri = URI.create(in.readUTF() );
}
@Override
public String toString()
{
return String.format( "MemberIsAvailable[ Role: %s, InstanceId: %s, Role URI: %s, Cluster URI: %s]",
role, instanceId.toString(), roleUri.toString(), clusterUri.toString() );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
MemberIsAvailable that = (MemberIsAvailable) o;
if ( !clusterUri.equals( that.clusterUri ) )
{
return false;
}
if ( !instanceId.equals( that.instanceId ) )
{
return false;
}
if ( !role.equals( that.role ) )
{
return false;
}
if ( !roleUri.equals( that.roleUri ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = role.hashCode();
result = 31 * result + instanceId.hashCode();
result = 31 * result + clusterUri.hashCode();
result = 31 * result + roleUri.hashCode();
return result;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_MemberIsAvailable.java
|
3,763
|
{
@Override
public boolean matches( Object item )
{
MemberIsAvailable input = (MemberIsAvailable) item;
return nullSafeEquals( input.getClusterUri(), expected.getClusterUri() ) &&
nullSafeEquals( input.getRole(), expected.getRole() ) &&
nullSafeEquals( input.getRoleUri(), expected.getRoleUri() );
}
@Override
public void describeTo( Description description )
{
}
};
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_member_paxos_ClusterMembersSnapshotTest.java
|
3,764
|
@Ignore("Ignored temporarily, pending review for extracting useful bits. The bulk of the test is now in HA, HaNewSnapshotFunctionTest")
public class ClusterMembersSnapshotTest
{
@Test
public void snapshotListPrunesSameMemberOnIdenticalAvailabilityEvents() throws Exception
{
// GIVEN
// -- a snapshot containing one member with a role
ClusterMembersSnapshot snapshot = new ClusterMembersSnapshot( new PaxosClusterMemberEvents.UniqueRoleFilter(ROLE_1) );
URI clusterUri = new URI( URI );
InstanceId instanceId = new InstanceId( 1 );
MemberIsAvailable memberIsAvailable = new MemberIsAvailable( ROLE_1, instanceId, clusterUri, new URI( URI + "?something" ) );
snapshot.availableMember( memberIsAvailable );
// WHEN
// -- the same member and role gets added to the snapshot
snapshot.availableMember( memberIsAvailable );
// THEN
// -- getting the snapshot list should only reveal the last one
assertEquals( 1, count( snapshot.getCurrentAvailable( instanceId ) ) );
assertThat(
snapshot.getCurrentAvailable( instanceId ),
CoreMatchers.<MemberIsAvailable>hasItem( memberIsAvailable( memberIsAvailable ) ) );
assertEquals( 1, count( snapshot.getCurrentAvailableMembers() ) );
assertThat(
snapshot.getCurrentAvailableMembers(),
CoreMatchers.<MemberIsAvailable>hasItems( memberIsAvailable( memberIsAvailable ) ) );
}
@Test
public void snapshotListCanContainMultipleEventsWithSameMemberWithDifferentRoles() throws Exception
{
// GIVEN
// -- a snapshot containing one member with a role
ClusterMembersSnapshot snapshot = new ClusterMembersSnapshot(null);
URI clusterUri = new URI( URI );
InstanceId instanceId = new InstanceId( 1 );
MemberIsAvailable event1 = new MemberIsAvailable( ROLE_1, instanceId, clusterUri, new URI( URI + "?something" ) );
snapshot.availableMember( event1 );
// WHEN
// -- the same member, although different role, gets added to the snapshot
MemberIsAvailable event2 = new MemberIsAvailable( ROLE_2, instanceId, clusterUri, new URI( URI + "?something" ) );
snapshot.availableMember( event2 );
// THEN
// -- getting the snapshot list should reveal both
assertEquals( 2, count( snapshot.getCurrentAvailable( instanceId ) ) );
assertThat(
snapshot.getCurrentAvailable( instanceId ),
CoreMatchers.<MemberIsAvailable>hasItems(
memberIsAvailable( event1 ), memberIsAvailable( event2 ) ) );
assertEquals( 2, count( snapshot.getCurrentAvailableMembers() ) );
assertThat(
snapshot.getCurrentAvailableMembers(),
CoreMatchers.<MemberIsAvailable>hasItems(
memberIsAvailable( event1 ), memberIsAvailable( event2 ) ) );
}
@Test
public void snapshotListPrunesOtherMemberWithSameRole() throws Exception
{
// GIVEN
// -- a snapshot containing one member with a role
ClusterMembersSnapshot snapshot = new ClusterMembersSnapshot(null);
URI clusterUri = new URI( URI );
InstanceId instanceId = new InstanceId( 1 );
MemberIsAvailable event = new MemberIsAvailable( ROLE_1, instanceId, clusterUri, new URI( URI + "?something1" ) );
snapshot.availableMember( event );
// WHEN
// -- another member, but with same role, gets added to the snapshot
URI otherClusterUri = new URI( URI );
InstanceId otherInstanceId = new InstanceId( 2 );
MemberIsAvailable otherEvent = new MemberIsAvailable( ROLE_1, otherInstanceId, otherClusterUri, new URI( URI + "?something2" ) );
snapshot.availableMember( otherEvent );
// THEN
// -- getting the snapshot list should only reveal the last member added, as it had the same role
assertEquals( 1, count( snapshot.getCurrentAvailable( otherInstanceId ) ) );
assertThat(
snapshot.getCurrentAvailable( otherInstanceId ),
CoreMatchers.<MemberIsAvailable>hasItems( memberIsAvailable( otherEvent ) ) );
assertEquals( 1, count( snapshot.getCurrentAvailableMembers() ) );
assertThat(
snapshot.getCurrentAvailableMembers(),
CoreMatchers.<MemberIsAvailable>hasItems( memberIsAvailable( otherEvent ) ) );
}
private static final String URI = "http://me";
private static final String ROLE_1 = "r1";
private static final String ROLE_2 = "r2";
private static Matcher<MemberIsAvailable> memberIsAvailable( final MemberIsAvailable expected )
{
return new BaseMatcher<MemberIsAvailable>()
{
@Override
public boolean matches( Object item )
{
MemberIsAvailable input = (MemberIsAvailable) item;
return nullSafeEquals( input.getClusterUri(), expected.getClusterUri() ) &&
nullSafeEquals( input.getRole(), expected.getRole() ) &&
nullSafeEquals( input.getRoleUri(), expected.getRoleUri() );
}
@Override
public void describeTo( Description description )
{
}
};
}
protected static <T> boolean nullSafeEquals( T o1, T o2 )
{
return o1 == null || o2 == null ? o1 == o2 : o1.equals( o2 );
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_member_paxos_ClusterMembersSnapshotTest.java
|
3,765
|
public abstract class Adapter
implements ClusterMemberListener
{
@Override
public void coordinatorIsElected( InstanceId coordinatorId )
{
}
@Override
public void memberIsAvailable( String role, InstanceId availableId, URI atURI )
{
}
@Override
public void memberIsUnavailable( String role, InstanceId unavailableId )
{
}
@Override
public void memberIsFailed( InstanceId instanceId )
{
}
@Override
public void memberIsAlive( InstanceId instanceId )
{
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_ClusterMemberListener.java
|
3,766
|
{
@Override
public boolean isDebugEnabled()
{
return false;
}
@Override
public boolean isInfoEnabled()
{
return true;
}
@Override
public boolean isWarnEnabled()
{
return true;
}
@Override
public boolean isErrorEnabled()
{
return true;
}
@Override
public boolean isEnabled( InternalLogLevel level )
{
return true;
}
@Override
public void debug( String msg )
{
finalLogger.debug( msg );
}
@Override
public void debug( String msg, Throwable cause )
{
finalLogger.debug( msg, cause );
}
@Override
public void info( String msg )
{
finalLogger.info( msg );
}
@Override
public void info( String msg, Throwable cause )
{
finalLogger.info( msg, cause );
}
@Override
public void warn( String msg )
{
finalLogger.warn( msg );
}
@Override
public void warn( String msg, Throwable cause )
{
finalLogger.warn( msg, cause );
}
@Override
public void error( String msg )
{
finalLogger.error( msg );
}
@Override
public void error( String msg, Throwable cause )
{
finalLogger.error( msg, cause );
}
};
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_logging_NettyLoggerFactory.java
|
3,767
|
public class NettyLoggerFactory
extends InternalLoggerFactory
{
private Logging logging;
public NettyLoggerFactory( Logging logging )
{
this.logging = logging;
}
@Override
public InternalLogger newInstance( String name )
{
StringLogger logger;
try
{
logger = logging.getMessagesLog( getClass().getClassLoader().loadClass( name ) );
}
catch ( ClassNotFoundException e )
{
logger = logging.getMessagesLog( getClass() );
}
final StringLogger finalLogger = logger;
return new AbstractInternalLogger()
{
@Override
public boolean isDebugEnabled()
{
return false;
}
@Override
public boolean isInfoEnabled()
{
return true;
}
@Override
public boolean isWarnEnabled()
{
return true;
}
@Override
public boolean isErrorEnabled()
{
return true;
}
@Override
public boolean isEnabled( InternalLogLevel level )
{
return true;
}
@Override
public void debug( String msg )
{
finalLogger.debug( msg );
}
@Override
public void debug( String msg, Throwable cause )
{
finalLogger.debug( msg, cause );
}
@Override
public void info( String msg )
{
finalLogger.info( msg );
}
@Override
public void info( String msg, Throwable cause )
{
finalLogger.info( msg, cause );
}
@Override
public void warn( String msg )
{
finalLogger.warn( msg );
}
@Override
public void warn( String msg, Throwable cause )
{
finalLogger.warn( msg, cause );
}
@Override
public void error( String msg )
{
finalLogger.error( msg );
}
@Override
public void error( String msg, Throwable cause )
{
finalLogger.error( msg, cause );
}
};
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_logging_NettyLoggerFactory.java
|
3,768
|
public class TrackingMessageHolder implements MessageHolder
{
private final List<Message> messages = new ArrayList<>();
@Override
public void offer( Message<? extends MessageType> message )
{
messages.add( message );
}
public <T extends MessageType> Message<T> single()
{
return IteratorUtil.single( messages );
}
public <T extends MessageType> Message<T> first()
{
return IteratorUtil.first( messages );
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_com_message_TrackingMessageHolder.java
|
3,769
|
{
@Override
public boolean process( Message<? extends MessageType> message )
{
// server receives a message
processedMessage.set(true);
latch.countDown();
return true;
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_com_message_NetworkSenderReceiverTest.java
|
3,770
|
{
@Override
public void start() throws Throwable
{
networkReceiver.addMessageProcessor( new MessageProcessor()
{
@Override
public boolean process( Message<? extends MessageType> message )
{
// server receives a message
processedMessage.set(true);
latch.countDown();
return true;
}
} );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_com_message_NetworkSenderReceiverTest.java
|
3,771
|
{
@Override
public boolean accept( MemberIsAvailable item )
{
return item.getInstanceId().equals( memberId );
}
}, availableMembers) );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,772
|
{
@Override
public void notify( ClusterMemberListener listener )
{
listener.memberIsFailed( server );
}
} );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,773
|
public class Payload
implements Externalizable
{
private byte[] buf;
private int len;
/**
* Externalizable constructor
*/
public Payload()
{
}
public Payload( byte[] buf, int len )
{
this.buf = buf;
this.len = len;
}
public byte[] getBuf()
{
return buf;
}
public int getLen()
{
return len;
}
@Override
public void writeExternal( ObjectOutput out )
throws IOException
{
out.write( len );
out.write( buf, 0, len );
}
@Override
public void readExternal( ObjectInput in )
throws IOException, ClassNotFoundException
{
len = in.read();
buf = new byte[len];
in.read( buf, 0, len );
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_Payload.java
|
3,774
|
{
@Override
public void notify( ClusterMemberListener listener )
{
listener.memberIsAlive( server );
}
} );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,775
|
public class ObjectStreamFactory implements ObjectInputStreamFactory, ObjectOutputStreamFactory
{
private final VersionMapper versionMapper;
public ObjectStreamFactory()
{
versionMapper = new VersionMapper();
}
@Override
public ObjectOutputStream create( ByteArrayOutputStream bout ) throws IOException
{
return new LenientObjectOutputStream( bout, versionMapper );
}
@Override
public ObjectInputStream create( ByteArrayInputStream in ) throws IOException
{
return new LenientObjectInputStream( in, versionMapper );
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_ObjectStreamFactory.java
|
3,776
|
public class LenientObjectOutputStreamTest
{
@Test
public void shouldUseStoredSerialVersionUIDWhenSerialisingAnObject() throws IOException, ClassNotFoundException
{
// given
MemberIsAvailable memberIsAvailable = memberIsAvailable();
VersionMapper versionMapper = new VersionMapper();
versionMapper.addMappingFor( memberIsAvailable.getClass().getName(), 12345l );
// when
Object deserialisedObject = deserialise( serialise( memberIsAvailable, versionMapper ) );
// then
assertEquals( 12345l, serialVersionUIDFor( deserialisedObject ));
}
@Test
public void shouldUseDefaultSerialVersionUIDWhenSerialisingAnObjectifNoMappingExists()
throws IOException, ClassNotFoundException
{
// given
VersionMapper emptyVersionMapper = new VersionMapper();
MemberIsAvailable memberIsAvailable = memberIsAvailable();
// when
Object deserialisedObject = deserialise( serialise( memberIsAvailable, emptyVersionMapper ) );
// then
assertEquals( serialVersionUIDFor( memberIsAvailable ), serialVersionUIDFor( deserialisedObject ));
}
private Object deserialise( byte[] bytes ) throws IOException, ClassNotFoundException
{
return new ObjectInputStream( inputStreamFor( new Payload( bytes, bytes.length ) ) ).readObject();
}
private long serialVersionUIDFor( Object memberIsAvailable )
{
return ObjectStreamClass.lookup( memberIsAvailable.getClass() ).getSerialVersionUID();
}
private ByteArrayInputStream inputStreamFor( Payload payload )
{
return new ByteArrayInputStream( payload.getBuf(), 0, payload.getLen() );
}
private byte[] serialise( Object value, VersionMapper versionMapper ) throws IOException
{
ByteArrayOutputStream bout = new ByteArrayOutputStream( );
ObjectOutputStream oout = new LenientObjectOutputStream( bout, versionMapper );
oout.writeObject( value );
oout.close();
return bout.toByteArray();
}
private MemberIsAvailable memberIsAvailable()
{
return new MemberIsAvailable( "r1", new InstanceId( 1 ), URI.create( "http://me" ), URI.create( "http://me?something" ) );
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_LenientObjectOutputStreamTest.java
|
3,777
|
public class LenientObjectOutputStream extends ObjectOutputStream
{
private VersionMapper versionMapper;
public LenientObjectOutputStream( ByteArrayOutputStream bout, VersionMapper versionMapper ) throws IOException
{
super( bout );
this.versionMapper = versionMapper;
}
@Override
protected void writeClassDescriptor( ObjectStreamClass desc ) throws IOException
{
if ( versionMapper.hasMappingFor( desc.getName() ) )
{
updateWirePayloadSuid( desc );
}
super.writeClassDescriptor( desc );
}
private void updateWirePayloadSuid( ObjectStreamClass wirePayload )
{
try
{
Field field = getAccessibleSuidField( wirePayload );
field.set( wirePayload, versionMapper.mappingFor( wirePayload.getName() ) );
}
catch ( NoSuchFieldException e )
{
throw new RuntimeException( e );
}
catch ( IllegalAccessException e )
{
throw new RuntimeException( e );
}
}
private Field getAccessibleSuidField( ObjectStreamClass localClassDescriptor ) throws NoSuchFieldException
{
Field suidField = localClassDescriptor.getClass().getDeclaredField( "suid" );
suidField.setAccessible( true );
return suidField;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_LenientObjectOutputStream.java
|
3,778
|
public class LenientObjectInputStreamTest
{
@Test
public void shouldStoreTheSerialVersionIdOfAClassTheFirstTimeItsDeserialised() throws IOException,
ClassNotFoundException
{
// given
MemberIsAvailable memberIsAvailable = memberIsAvailable();
Payload payload = payloadFor( memberIsAvailable );
VersionMapper versionMapper = new VersionMapper();
// when
new LenientObjectInputStream( inputStreamFor( payload ), versionMapper ).readObject();
// then
assertTrue( versionMapper.hasMappingFor( memberIsAvailable.getClass().getName() ) );
assertEquals( serialVersionUIDFor( memberIsAvailable ),
versionMapper.mappingFor( memberIsAvailable.getClass().getName() ) );
}
private long serialVersionUIDFor( MemberIsAvailable memberIsAvailable )
{
return ObjectStreamClass.lookup( memberIsAvailable.getClass() ).getSerialVersionUID();
}
private ByteArrayInputStream inputStreamFor( Payload payload )
{
return new ByteArrayInputStream( payload.getBuf(), 0, payload.getLen() );
}
private MemberIsAvailable memberIsAvailable()
{
return new MemberIsAvailable( "r1", new InstanceId( 1 ), URI.create( "http://me" ), URI.create( "http://me?something" ) );
}
private Payload payloadFor( Object value ) throws IOException
{
ByteArrayOutputStream bout = new ByteArrayOutputStream( );
ObjectOutputStream oout = new ObjectOutputStream( bout );
oout.writeObject( value );
oout.close();
byte[] bytes = bout.toByteArray();
return new Payload( bytes, bytes.length );
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_LenientObjectInputStreamTest.java
|
3,779
|
public class LenientObjectInputStream extends ObjectInputStream
{
private VersionMapper versionMapper;
public LenientObjectInputStream( ByteArrayInputStream fis, VersionMapper versionMapper ) throws IOException
{
super( fis );
this.versionMapper = versionMapper;
}
@Override
protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException
{
ObjectStreamClass wireClassDescriptor = super.readClassDescriptor();
if(!versionMapper.hasMappingFor( wireClassDescriptor.getName() )) {
versionMapper.addMappingFor( wireClassDescriptor.getName(), wireClassDescriptor.getSerialVersionUID() );
}
Class localClass; // the class in the local JVM that this descriptor represents.
try {
localClass = Class.forName( wireClassDescriptor.getName() );
} catch (ClassNotFoundException e) {
return wireClassDescriptor;
}
ObjectStreamClass localClassDescriptor = ObjectStreamClass.lookup(localClass);
if (localClassDescriptor != null) {
final long localSUID = localClassDescriptor.getSerialVersionUID();
final long wireSUID = wireClassDescriptor.getSerialVersionUID();
if (wireSUID != localSUID) {
wireClassDescriptor = localClassDescriptor;
}
}
return wireClassDescriptor;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_LenientObjectInputStream.java
|
3,780
|
public class AtomicBroadcastSerializer
{
private ObjectInputStreamFactory objectInputStreamFactory;
private ObjectOutputStreamFactory objectOutputStreamFactory;
public AtomicBroadcastSerializer( ObjectInputStreamFactory objectInputStreamFactory,
ObjectOutputStreamFactory objectOutputStreamFactory )
{
this.objectInputStreamFactory = objectInputStreamFactory;
this.objectOutputStreamFactory = objectOutputStreamFactory;
}
public Payload broadcast(Object value)
throws IOException
{
ByteArrayOutputStream bout = new ByteArrayOutputStream( );
ObjectOutputStream oout = objectOutputStreamFactory.create(bout);
oout.writeObject( value );
oout.close();
byte[] bytes = bout.toByteArray();
return new Payload( bytes, bytes.length );
}
public Object receive( Payload payload )
throws IOException, ClassNotFoundException
{
ByteArrayInputStream in = new ByteArrayInputStream( payload.getBuf(), 0, payload.getLen() );
ObjectInputStream oin = objectInputStreamFactory.create( in );
return oin.readObject();
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_AtomicBroadcastSerializer.java
|
3,781
|
public static class Remove
implements Serializable, MapCommand
{
Object key;
public Remove( Object key )
{
this.key = key;
}
@Override
public void execute( Map map )
{
map.remove( key );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
Remove remove = (Remove) o;
if ( !key.equals( remove.key ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return key.hashCode();
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_AtomicBroadcastMap.java
|
3,782
|
public static class PutAll
implements Serializable, MapCommand
{
Map map;
public PutAll( Map map )
{
this.map = map;
}
@Override
public void execute( Map map )
{
map.putAll( this.map );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
PutAll putAll = (PutAll) o;
if ( !map.equals( putAll.map ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return map.hashCode();
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_AtomicBroadcastMap.java
|
3,783
|
public static class Put
implements Serializable, MapCommand
{
Object key;
Object value;
public Put( Object key, Object value )
{
this.key = key;
this.value = value;
}
@Override
public void execute( Map map )
{
map.put( key, value );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
Put put = (Put) o;
if ( !key.equals( put.key ) )
{
return false;
}
if ( !value.equals( put.value ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = key.hashCode();
result = 31 * result + value.hashCode();
return result;
}
@Override
public String toString()
{
return "Put: " + key + "=" + value;
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_AtomicBroadcastMap.java
|
3,784
|
public static class Clear
implements Serializable, MapCommand
{
@Override
public void execute( Map map )
{
map.clear();
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
return true;
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_AtomicBroadcastMap.java
|
3,785
|
{
@Override
public void receive( Payload value )
{
try
{
MapCommand command = (MapCommand) serializer.receive( value );
command.execute( map );
// LoggerFactory.getLogger( getClass() ).info( "Map:"+map );
synchronized ( AtomicBroadcastMap.this )
{
if ( command.equals( lastCommand ) )
{
lastCommand = null;
AtomicBroadcastMap.this.notifyAll();
}
}
}
catch ( IOException e )
{
e.printStackTrace();
}
catch ( ClassNotFoundException e )
{
e.printStackTrace();
}
}
};
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_AtomicBroadcastMap.java
|
3,786
|
{
@Override
public void getState( ObjectOutputStream output )
throws IOException
{
output.writeObject( new HashMap( map ) );
}
@Override
public void setState( ObjectInputStream input )
throws IOException, ClassNotFoundException
{
map = new ConcurrentHashMap( (Map<K, V>) input.readObject() );
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_AtomicBroadcastMap.java
|
3,787
|
public class AtomicBroadcastMap<K, V>
implements Map<K, V>
{
private Map<K, V> map = new ConcurrentHashMap<K, V>();
private AtomicBroadcast atomicBroadcast;
private volatile MapCommand lastCommand;
protected final AtomicBroadcastListener atomicBroadcastListener;
private final AtomicBroadcastSerializer serializer = new AtomicBroadcastSerializer(new ObjectStreamFactory(), new ObjectStreamFactory());
public AtomicBroadcastMap( AtomicBroadcast atomicBroadcast, Snapshot snapshot )
{
snapshot.setSnapshotProvider( new SnapshotProvider()
{
@Override
public void getState( ObjectOutputStream output )
throws IOException
{
output.writeObject( new HashMap( map ) );
}
@Override
public void setState( ObjectInputStream input )
throws IOException, ClassNotFoundException
{
map = new ConcurrentHashMap( (Map<K, V>) input.readObject() );
}
} );
this.atomicBroadcast = atomicBroadcast;
atomicBroadcastListener = new AtomicBroadcastListener()
{
@Override
public void receive( Payload value )
{
try
{
MapCommand command = (MapCommand) serializer.receive( value );
command.execute( map );
// LoggerFactory.getLogger( getClass() ).info( "Map:"+map );
synchronized ( AtomicBroadcastMap.this )
{
if ( command.equals( lastCommand ) )
{
lastCommand = null;
AtomicBroadcastMap.this.notifyAll();
}
}
}
catch ( IOException e )
{
e.printStackTrace();
}
catch ( ClassNotFoundException e )
{
e.printStackTrace();
}
}
};
atomicBroadcast.addAtomicBroadcastListener( atomicBroadcastListener );
}
@Override
public int size()
{
checkUpToDate();
return map.size();
}
@Override
public boolean isEmpty()
{
checkUpToDate();
return map.isEmpty();
}
@Override
public boolean containsKey( Object key )
{
checkUpToDate();
return map.containsKey( key );
}
@Override
public boolean containsValue( Object value )
{
checkUpToDate();
return map.containsValue( value );
}
@Override
public V get( Object key )
{
checkUpToDate();
return map.get( key );
}
@Override
public V put( K key, V value )
{
try
{
atomicBroadcast.broadcast( serializer.broadcast( lastCommand = new Put( key, value ) ) );
return map.get( key );
}
catch ( IOException e )
{
throw new IllegalStateException( e );
}
}
@Override
public V remove( Object key )
{
try
{
atomicBroadcast.broadcast( serializer.broadcast( lastCommand = new Remove( key ) ) );
return map.get( key );
}
catch ( IOException e )
{
throw new IllegalStateException( e );
}
}
@Override
public void putAll( Map<? extends K, ? extends V> m )
{
try
{
atomicBroadcast.broadcast( serializer.broadcast( lastCommand = new PutAll( m ) ) );
}
catch ( IOException e )
{
throw new IllegalStateException( e );
}
}
@Override
public void clear()
{
try
{
atomicBroadcast.broadcast( serializer.broadcast( lastCommand = new Clear() ) );
}
catch ( IOException e )
{
throw new IllegalStateException( e );
}
}
@Override
public Set<K> keySet()
{
checkUpToDate();
return map.keySet();
}
@Override
public Collection<V> values()
{
checkUpToDate();
return map.values();
}
@Override
public Set<Entry<K, V>> entrySet()
{
checkUpToDate();
return map.entrySet();
}
public void close()
{
checkUpToDate();
atomicBroadcast.removeAtomicBroadcastListener( atomicBroadcastListener );
}
private synchronized void checkUpToDate()
{
int tries = 100;
while ( lastCommand != null && tries > 0)
{
try
{
this.wait( 5000 );
}
catch ( InterruptedException e )
{
e.printStackTrace();
}
tries--;
}
if (tries == 0)
throw new IllegalStateException( "Timed out waiting for state to be synchronized" );
}
public interface MapCommand
{
void execute( Map map );
}
public static class Put
implements Serializable, MapCommand
{
Object key;
Object value;
public Put( Object key, Object value )
{
this.key = key;
this.value = value;
}
@Override
public void execute( Map map )
{
map.put( key, value );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
Put put = (Put) o;
if ( !key.equals( put.key ) )
{
return false;
}
if ( !value.equals( put.value ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = key.hashCode();
result = 31 * result + value.hashCode();
return result;
}
@Override
public String toString()
{
return "Put: " + key + "=" + value;
}
}
public static class Remove
implements Serializable, MapCommand
{
Object key;
public Remove( Object key )
{
this.key = key;
}
@Override
public void execute( Map map )
{
map.remove( key );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
Remove remove = (Remove) o;
if ( !key.equals( remove.key ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return key.hashCode();
}
}
public static class Clear
implements Serializable, MapCommand
{
@Override
public void execute( Map map )
{
map.clear();
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
return true;
}
}
public static class PutAll
implements Serializable, MapCommand
{
Map map;
public PutAll( Map map )
{
this.map = map;
}
@Override
public void execute( Map map )
{
map.putAll( this.map );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
PutAll putAll = (PutAll) o;
if ( !map.equals( putAll.map ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return map.hashCode();
}
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_atomicbroadcast_AtomicBroadcastMap.java
|
3,788
|
{
@Override
public boolean accept( MemberIsAvailable item )
{
return not( in( newMessage.getInstanceId() ) ).accept( item.getInstanceId() );
}
}, previousSnapshot));
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,789
|
public static class UniqueRoleFilter
implements Function2<Iterable<MemberIsAvailable>, MemberIsAvailable, Iterable<MemberIsAvailable>>
{
private final String role;
private final Set<String> roles = new HashSet<String>();
public UniqueRoleFilter( String role )
{
this.role = role;
}
@Override
public Iterable<MemberIsAvailable> apply( Iterable<MemberIsAvailable> previousSnapshot, final MemberIsAvailable newMessage )
{
return Iterables.append( newMessage, Iterables.filter( new Predicate<MemberIsAvailable>()
{
@Override
public boolean accept( MemberIsAvailable item )
{
return not( in( newMessage.getInstanceId() ) ).accept( item.getInstanceId() );
}
}, previousSnapshot));
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,790
|
private static class UniqueInstanceFilter implements Predicate<MemberIsAvailable>
{
private final Set<InstanceId> roles = new HashSet<InstanceId>();
@Override
public boolean accept( MemberIsAvailable item )
{
return roles.add( item.getInstanceId() );
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,791
|
{
@Override
public void notify( ClusterMemberListener listener )
{
for ( MemberIsAvailable memberIsAvailable : clusterMembersSnapshot.getCurrentAvailableMembers() )
{
listener.memberIsAvailable( memberIsAvailable.getRole(),
memberIsAvailable.getInstanceId(), memberIsAvailable.getRoleUri() );
}
}
} );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,792
|
{
@Override
public void run()
{
cluster.leave();
}
} );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,793
|
private class HighAvailabilitySnapshotProvider implements SnapshotProvider
{
@Override
public void getState( ObjectOutputStream output ) throws IOException
{
output.writeObject( clusterMembersSnapshot );
}
@Override
public void setState( ObjectInputStream input ) throws IOException, ClassNotFoundException
{
clusterMembersSnapshot = ClusterMembersSnapshot.class.cast(input.readObject());
if ( !snapshotValidator.accept( clusterMembersSnapshot ) )
{
executor.submit( new Runnable()
{
@Override
public void run()
{
cluster.leave();
}
} );
}
else
{
// Send current availability events to listeners
Listeners.notifyListeners( listeners, executor, new Listeners.Notification<ClusterMemberListener>()
{
@Override
public void notify( ClusterMemberListener listener )
{
for ( MemberIsAvailable memberIsAvailable : clusterMembersSnapshot.getCurrentAvailableMembers() )
{
listener.memberIsAvailable( memberIsAvailable.getRole(),
memberIsAvailable.getInstanceId(), memberIsAvailable.getRoleUri() );
}
}
} );
}
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_member_paxos_PaxosClusterMemberEvents.java
|
3,794
|
class AcceptorContextImpl
extends AbstractContextImpl
implements AcceptorContext
{
private final AcceptorInstanceStore instanceStore;
AcceptorContextImpl( org.neo4j.cluster.InstanceId me, CommonContextState commonState,
Logging logging,
Timeouts timeouts, AcceptorInstanceStore instanceStore )
{
super( me, commonState, logging, timeouts );
this.instanceStore = instanceStore;
}
@Override
public AcceptorInstance getAcceptorInstance( InstanceId instanceId )
{
return instanceStore.getAcceptorInstance( instanceId );
}
@Override
public void promise( AcceptorInstance instance, long ballot )
{
instanceStore.promise( instance, ballot );
}
@Override
public void accept( AcceptorInstance instance, Object value )
{
instanceStore.accept( instance, value );
}
@Override
public void leave()
{
instanceStore.clear();
}
public AcceptorContextImpl snapshot( CommonContextState commonStateSnapshot, Logging logging, Timeouts timeouts,
AcceptorInstanceStore instanceStore )
{
return new AcceptorContextImpl( me, commonStateSnapshot, logging, timeouts, instanceStore );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
AcceptorContextImpl that = (AcceptorContextImpl) o;
if ( instanceStore != null ? !instanceStore.equals( that.instanceStore ) : that.instanceStore != null )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return instanceStore != null ? instanceStore.hashCode() : 0;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_context_AcceptorContextImpl.java
|
3,795
|
class AtomicBroadcastContextImpl
extends AbstractContextImpl
implements AtomicBroadcastContext
{
private Iterable<AtomicBroadcastListener> listeners = Listeners.newListeners();
private final Executor executor;
AtomicBroadcastContextImpl( org.neo4j.cluster.InstanceId me, CommonContextState commonState,
Logging logging,
Timeouts timeouts, Executor executor )
{
super( me, commonState, logging, timeouts );
this.executor = executor;
}
@Override
public void addAtomicBroadcastListener( AtomicBroadcastListener listener )
{
listeners = Listeners.addListener( listener, listeners );
}
@Override
public void removeAtomicBroadcastListener( AtomicBroadcastListener listener )
{
listeners = Listeners.removeListener( listener, listeners );
}
@Override
public void receive( final Payload value )
{
Listeners.notifyListeners( listeners, executor, new Listeners.Notification<AtomicBroadcastListener>()
{
@Override
public void notify( final AtomicBroadcastListener listener )
{
listener.receive( value );
}
} );
}
public AtomicBroadcastContextImpl snapshot( CommonContextState commonStateSnapshot, Logging logging,
Timeouts timeouts, Executor executor )
{
return new AtomicBroadcastContextImpl( me, commonStateSnapshot, logging, timeouts, executor );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
return 0;
}
}
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_context_AtomicBroadcastContextImpl.java
|
3,796
|
{
@Override
public void notify( final AtomicBroadcastListener listener )
{
listener.receive( value );
}
} );
| false
|
enterprise_cluster_src_main_java_org_neo4j_cluster_protocol_atomicbroadcast_multipaxos_context_AtomicBroadcastContextImpl.java
|
3,797
|
public static class ClusterTestScriptRandom
implements ClusterTestScript
{
private final long seed;
private final Random random;
public ClusterTestScriptRandom( long seed )
{
if ( seed == -1 )
{
seed = System.nanoTime();
}
this.seed = seed;
random = new Random( seed );
}
@Override
public void tick( long time )
{
if ( time == 0 )
{
logger.getLogger().debug( "Random seed:" + seed );
}
if ( random.nextDouble() >= 0.9 )
{
if ( random.nextDouble() > 0.5 && !out.isEmpty() )
{
int idx = random.nextInt( out.size() );
Cluster cluster = out.remove( idx );
if ( in.isEmpty() )
{
cluster.create( "default" );
}
else
{
try
{
cluster.join( "default", new URI( in.get( 0 ).toString() ) );
}
catch ( URISyntaxException e )
{
e.printStackTrace();
}
}
logger.getLogger().debug( "Enter cluster:" + cluster.toString() );
}
else if ( !in.isEmpty() )
{
int idx = random.nextInt( in.size() );
Cluster cluster = in.remove( idx );
cluster.leave();
logger.getLogger().debug( "Leave cluster:" + cluster.toString() );
}
}
}
@Override
public long getLength()
{
return 5000;
}
}
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_cluster_ClusterNetworkTest.java
|
3,798
|
{
@Override
public void run()
{
Cluster leaveCluster = servers.get( leaveServer - 1 );
for ( Cluster cluster : in )
{
if ( cluster.equals( leaveCluster ) )
{
in.remove( cluster );
cluster.leave();
logger.getLogger().debug( "Leave:" + cluster.toString() );
break;
}
}
}
};
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_cluster_ClusterNetworkTest.java
|
3,799
|
{
@Override
public void run()
{
try
{
ClusterConfiguration clusterConfiguration = result.get();
logger.getLogger().debug( "**** Cluster configuration:" +
clusterConfiguration );
}
catch ( Exception e )
{
if ( !(e.getCause() instanceof IllegalStateException ))
{
cluster.create( "default" );
}
else
{
logger.getLogger().debug( "*** Incorrectly configured cluster? "
+ e.getCause().getMessage() );
}
}
}
} );
| false
|
enterprise_cluster_src_test_java_org_neo4j_cluster_protocol_cluster_ClusterNetworkTest.java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.