//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRespondNegativelyToAppendEntriesRequestFromEarlierTerm() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldRespondNegativelyToAppendEntriesRequestFromEarlierTerm()
{
// given
long leaderTerm = 5;
long leaderCommitIndex = 10;
long rivalTerm = leaderTerm - 1;
long logIndex = 20;
RaftLogEntry[] entries = new RaftLogEntry[] { new RaftLogEntry(rivalTerm, ReplicatedInteger.valueOf(99)) };
Leader leader = new Leader();
RaftState state = raftState().term(leaderTerm).commitIndex(leaderCommitIndex).build();
// when
Outcome outcome = leader.Handle(new Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Request(_member1, rivalTerm, logIndex, leaderTerm, entries, leaderCommitIndex), state, Log());
// then
assertThat(outcome.Role, equalTo(LEADER));
assertThat(outcome.Term, equalTo(leaderTerm));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage response = messageFor(outcome, _member1);
assertThat(response, instanceOf(typeof(Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Response)));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Response typedResponse = (Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Response)response;
assertThat(typedResponse.Term(), equalTo(leaderTerm));
assertThat(typedResponse.Success(), equalTo(false));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldStepDownIfAppendEntriesRequestFromLaterTerm() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldStepDownIfAppendEntriesRequestFromLaterTerm()
{
// given
long leaderTerm = 1;
long leaderCommitIndex = 10;
long rivalTerm = leaderTerm + 1;
long logIndex = 20;
RaftLogEntry[] entries = new RaftLogEntry[] { new RaftLogEntry(rivalTerm, ReplicatedInteger.valueOf(99)) };
Leader leader = new Leader();
RaftState state = raftState().term(leaderTerm).commitIndex(leaderCommitIndex).build();
// when
Outcome outcome = leader.Handle(new Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Request(_member1, rivalTerm, logIndex, leaderTerm, entries, leaderCommitIndex), state, Log());
// then
assertThat(outcome.Role, equalTo(FOLLOWER));
assertThat(outcome.Leader, equalTo(_member1));
assertThat(outcome.Term, equalTo(rivalTerm));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage response = messageFor(outcome, _member1);
assertThat(response, instanceOf(typeof(Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Response)));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Response typedResponse = (Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Response)response;
assertThat(typedResponse.Term(), equalTo(rivalTerm));
// Not checking success or failure of append
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSendCompactionInfoIfFailureWithNoEarlierEntries() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSendCompactionInfoIfFailureWithNoEarlierEntries()
{
// given
Leader leader = new Leader();
long term = 1;
long leaderPrevIndex = 3;
long followerIndex = leaderPrevIndex - 1;
InMemoryRaftLog raftLog = new InMemoryRaftLog();
raftLog.Skip(leaderPrevIndex, term);
RaftState state = raftState().term(term).entryLog(raftLog).build();
Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Response incomingResponse = appendEntriesResponse().failure().term(term).appendIndex(followerIndex).from(_member1).build();
// when
Outcome outcome = leader.Handle(incomingResponse, state, Log());
// then
Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage outgoingMessage = messageFor(outcome, _member1);
assertThat(outgoingMessage, instanceOf(typeof(Org.Neo4j.causalclustering.core.consensus.RaftMessages_LogCompactionInfo)));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_LogCompactionInfo typedOutgoingMessage = (Org.Neo4j.causalclustering.core.consensus.RaftMessages_LogCompactionInfo)outgoingMessage;
assertThat(typedOutgoingMessage.PrevIndex(), equalTo(leaderPrevIndex));
}
public override ClusterState Advance(ClusterState previous)
{
ClusterState newClusterState = new ClusterState(previous);
LinkedList <Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage> inboundQueue = new LinkedList <Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage>(previous.Queues[_member]);
Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage message = inboundQueue.RemoveFirst();
if (message == null)
{
return(previous);
}
newClusterState.Queues[_member] = inboundQueue;
return(newClusterState);
}
public override ClusterState Advance(ClusterState previous)
{
ClusterState newClusterState = new ClusterState(previous);
LinkedList <Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage> inboundQueue = new LinkedList <Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage>(previous.Queues[_member]);
if (inboundQueue.Count < 2)
{
return(previous);
}
Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage message = inboundQueue.RemoveFirst();
//JAVA TO C# CONVERTER TODO TASK: There is no .NET LinkedList equivalent to the 2-parameter Java 'add' method:
inboundQueue.Add(1, message);
newClusterState.Queues[_member] = inboundQueue;
return(newClusterState);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public synchronized void encode(io.netty.channel.ChannelHandlerContext ctx, org.neo4j.causalclustering.core.consensus.RaftMessages_ClusterIdAwareMessage decoratedMessage, io.netty.buffer.ByteBuf out) throws Exception
public override void Encode(ChannelHandlerContext ctx, Org.Neo4j.causalclustering.core.consensus.RaftMessages_ClusterIdAwareMessage decoratedMessage, ByteBuf @out)
{
lock (this)
{
Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage message = decoratedMessage.message();
ClusterId clusterId = decoratedMessage.clusterId();
MemberId.Marshal memberMarshal = new MemberId.Marshal();
NetworkWritableChannel channel = new NetworkWritableChannel(@out);
ClusterId.Marshal.INSTANCE.marshal(clusterId, channel);
channel.PutInt(message.Type().ordinal());
memberMarshal.MarshalConflict(message.From(), channel);
message.Dispatch(new Handler(_marshal, memberMarshal, channel));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSendNegativeResponseForVoteRequestFromTermNotGreaterThanLeader() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSendNegativeResponseForVoteRequestFromTermNotGreaterThanLeader()
{
// given
long leaderTerm = 5;
long leaderCommitIndex = 10;
long rivalTerm = leaderTerm - 1;
Leader leader = new Leader();
RaftState state = raftState().term(leaderTerm).commitIndex(leaderCommitIndex).build();
// when
Outcome outcome = leader.Handle(new Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Request(_member1, rivalTerm, _member1, leaderCommitIndex, leaderTerm), state, Log());
// then
assertThat(outcome.Role, equalTo(LEADER));
assertThat(outcome.Term, equalTo(leaderTerm));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage response = messageFor(outcome, _member1);
assertThat(response, instanceOf(typeof(Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Response)));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Response typedResponse = (Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Response)response;
assertThat(typedResponse.VoteGranted(), equalTo(false));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void serializeReadBackAndVerifyMessage(org.neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage message) throws Exception
private void SerializeReadBackAndVerifyMessage(Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage message)
{
// Given
Instant now = Instant.now();
Clock clock = Clock.@fixed(now, ZoneOffset.UTC);
RaftMessageEncoder encoder = new RaftMessageEncoder(marshal);
RaftMessageDecoder decoder = new RaftMessageDecoder(marshal, clock);
// Deserialization adds read objects in this list
List <object> thingsRead = new List <object>(1);
// When
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.causalclustering.core.consensus.RaftMessages_ClusterIdAwareMessage<?> decoratedMessage = org.neo4j.causalclustering.core.consensus.RaftMessages_ReceivedInstantClusterIdAwareMessage.of(now, clusterId, message);
Org.Neo4j.causalclustering.core.consensus.RaftMessages_ClusterIdAwareMessage <object> decoratedMessage = Org.Neo4j.causalclustering.core.consensus.RaftMessages_ReceivedInstantClusterIdAwareMessage.of(now, _clusterId, message);
ChannelHandlerContext ctx = SetupContext();
ByteBuf buffer = null;
try
{
buffer = ctx.alloc().buffer();
encoder.Encode(ctx, decoratedMessage, buffer);
// When
decoder.Decode(null, buffer, thingsRead);
// Then
assertEquals(1, thingsRead.Count);
assertEquals(decoratedMessage, thingsRead[0]);
}
finally
{
if (buffer != null)
{
buffer.release();
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldStepDownIfReceiveVoteRequestFromGreaterTermThanLeader() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldStepDownIfReceiveVoteRequestFromGreaterTermThanLeader()
{
// given
long leaderTerm = 1;
long leaderCommitIndex = 10;
long rivalTerm = leaderTerm + 1;
Leader leader = new Leader();
RaftState state = raftState().term(leaderTerm).commitIndex(leaderCommitIndex).build();
// when
Outcome outcome = leader.Handle(new Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Request(_member1, rivalTerm, _member1, leaderCommitIndex, leaderTerm), state, Log());
// then
assertThat(outcome.Role, equalTo(FOLLOWER));
assertThat(outcome.Leader, nullValue());
assertThat(outcome.Term, equalTo(rivalTerm));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage response = messageFor(outcome, _member1);
assertThat(response, instanceOf(typeof(Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Response)));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Response typedResponse = (Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Response)response;
assertThat(typedResponse.VoteGranted(), equalTo(true));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void raftMessageEquals(org.neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage raftMessage, org.neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage message) throws Exception
private void RaftMessageEquals(Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage raftMessage, Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage message)
{
if (raftMessage is Org.Neo4j.causalclustering.core.consensus.RaftMessages_NewEntry_Request)
{
assertEquals(message.From(), raftMessage.From());
assertEquals(message.Type(), raftMessage.Type());
ContentEquals(((Org.Neo4j.causalclustering.core.consensus.RaftMessages_NewEntry_Request)raftMessage).Content(), ((Org.Neo4j.causalclustering.core.consensus.RaftMessages_NewEntry_Request)raftMessage).Content());
}
else if (raftMessage is Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Request)
{
assertEquals(message.From(), raftMessage.From());
assertEquals(message.Type(), raftMessage.Type());
RaftLogEntry[] entries1 = ((Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Request)raftMessage).Entries();
RaftLogEntry[] entries2 = ((Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Request)message).Entries();
for (int i = 0; i < entries1.Length; i++)
{
RaftLogEntry raftLogEntry1 = entries1[i];
RaftLogEntry raftLogEntry2 = entries2[i];
assertEquals(raftLogEntry1.Term(), raftLogEntry2.Term());
ContentEquals(raftLogEntry1.Content(), raftLogEntry2.Content());
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.causalclustering.core.consensus.outcome.Outcome handle(org.neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage message, org.neo4j.causalclustering.core.consensus.state.ReadableRaftState ctx, org.neo4j.logging.Log log) throws java.io.IOException
public override Outcome Handle(Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage message, ReadableRaftState ctx, Log log)
{
return(message.Dispatch(new Handler(ctx, log)));
}
private static Stream <object[]> Params(Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage raftMessage)
{
return(Arrays.stream(_protocols).mapToObj(p => new object[] { raftMessage, p }));
}
