//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_NewEntry_Request req) throws java.io.IOException
public override Outcome Handle(Org.Neo4j.causalclustering.core.consensus.RaftMessages_NewEntry_Request req)
{
ReplicatedContent content = req.Content();
Appending.AppendNewEntry(Ctx, Outcome, content);
return(Outcome);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private java.util.concurrent.Future<Object> replicate0(ReplicatedContent command, boolean trackResult, org.neo4j.causalclustering.identity.MemberId leader) throws ReplicationFailureException
private Future <object> Replicate0(ReplicatedContent command, bool trackResult, MemberId leader)
{
_replicationMonitor.startReplication();
try
{
OperationContext session = _sessionPool.acquireSession();
DistributedOperation operation = new DistributedOperation(command, session.GlobalSession(), session.LocalOperationId());
Progress progress = _progressTracker.start(operation);
Org.Neo4j.causalclustering.helper.TimeoutStrategy_Timeout progressTimeout = _progressTimeoutStrategy.newTimeout();
int attempts = 0;
try
{
while (true)
{
attempts++;
if (attempts > 1)
{
_log.info("Retrying replication. Current attempt: %d Content: %s", attempts, command);
}
_replicationMonitor.replicationAttempt();
AssertDatabaseAvailable();
// blocking at least until the send has succeeded or failed before retrying
_outbound.send(leader, new Org.Neo4j.causalclustering.core.consensus.RaftMessages_NewEntry_Request(_me, operation), true);
progress.AwaitReplication(progressTimeout.Millis);
if (progress.Replicated)
{
break;
}
progressTimeout.Increment();
leader = _leaderProvider.awaitLeader();
}
}
catch (InterruptedException e)
{
_progressTracker.abort(operation);
throw new ReplicationFailureException("Interrupted while replicating", e);
}
System.Action <object, Exception> cleanup = (ignored1, ignored2) => _sessionPool.releaseSession(session);
if (trackResult)
{
progress.FutureResult().whenComplete(cleanup);
}
else
{
cleanup(null, null);
}
_replicationMonitor.successfulReplication();
return(progress.FutureResult());
}
catch (Exception t)
{
_replicationMonitor.failedReplication(t);
throw t;
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public java.util.concurrent.Future<Object> replicate(ReplicatedContent command, boolean trackResult) throws ReplicationFailureException
public override Future <object> Replicate(ReplicatedContent command, bool trackResult)
{
MemberId currentLeader = _leaderProvider.currentLeader();
if (currentLeader == null)
{
throw new ReplicationFailureException("Replication aborted since no leader was available");
}
return(Replicate0(command, trackResult, currentLeader));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: static void appendNewEntry(org.neo4j.causalclustering.core.consensus.state.ReadableRaftState ctx, org.neo4j.causalclustering.core.consensus.outcome.Outcome outcome, org.neo4j.causalclustering.core.replication.ReplicatedContent content) throws java.io.IOException
internal static void AppendNewEntry(ReadableRaftState ctx, Outcome outcome, ReplicatedContent content)
{
long prevLogIndex = ctx.EntryLog().appendIndex();
long prevLogTerm = prevLogIndex == -1 ? -1 : prevLogIndex > ctx.LastLogIndexBeforeWeBecameLeader() ? ctx.Term() : ctx.EntryLog().readEntryTerm(prevLogIndex);
RaftLogEntry newLogEntry = new RaftLogEntry(ctx.Term(), content);
outcome.AddShipCommand(new ShipCommand.NewEntries(prevLogIndex, prevLogTerm, new RaftLogEntry[] { newLogEntry }));
outcome.AddLogCommand(new AppendLogEntry(prevLogIndex + 1, newLogEntry));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private java.util.List<int> integerValues(org.neo4j.causalclustering.core.consensus.log.ReadableRaftLog log) throws java.io.IOException
private IList <int> IntegerValues(ReadableRaftLog log)
{
IList <int> actual = new List <int>();
for (long logIndex = 0; logIndex <= log.AppendIndex(); logIndex++)
{
ReplicatedContent content = readLogEntry(log, logIndex).content();
if (content is ReplicatedInteger)
{
ReplicatedInteger integer = ( ReplicatedInteger )content;
actual.Add(integer.Get());
}
}
return(actual);
}
public override Optional <Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage> MaybeComplete(LinkedList <long> terms, LinkedList <ReplicatedContent> contents)
{
if (terms.Count < EntryCount || contents.Count < EntryCount)
{
return(null);
}
RaftLogEntry[] entries = new RaftLogEntry[EntryCount];
for (int i = 0; i < EntryCount; i++)
{
long term = terms.RemoveFirst();
ReplicatedContent content = contents.RemoveFirst();
entries[i] = new RaftLogEntry(term, content);
}
return(new Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Request(From, Term, PrevLogIndex, PrevLogTerm, entries, LeaderCommit));
}
public override Future <object> Replicate(ReplicatedContent content, bool trackResult)
{
lock (this)
{
AtomicReference <CompletableFuture <object> > futureResult = new AtomicReference <CompletableFuture <object> >(new CompletableFuture <>());
_stateMachine.applyCommand((Command)content, _commandIndex++, result =>
{
if (trackResult)
{
futureResult.getAndUpdate(result.apply);
}
});
return(futureResult.get());
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void assertMarshalingEquality(io.netty.buffer.ByteBuf buffer, org.neo4j.causalclustering.core.state.machines.tx.TransactionRepresentationReplicatedTransaction replicatedTx) throws java.io.IOException, org.neo4j.causalclustering.messaging.EndOfStreamException
private void AssertMarshalingEquality(ByteBuf buffer, TransactionRepresentationReplicatedTransaction replicatedTx)
{
_marshal.marshal(replicatedTx, new NetworkWritableChannel(buffer));
ReplicatedContent unmarshal = _marshal.unmarshal(new NetworkReadableClosableChannelNetty4(buffer));
TransactionRepresentation tx = replicatedTx.Tx();
sbyte[] extraHeader = tx.AdditionalHeader();
if (extraHeader == null)
{
// hackishly set additional header to empty array...
(( PhysicalTransactionRepresentation )tx).setHeader(new sbyte[0], tx.MasterId, tx.AuthorId, tx.TimeStarted, tx.LatestCommittedTxWhenStarted, tx.TimeCommitted, tx.LockSessionId);
extraHeader = tx.AdditionalHeader();
}
TransactionRepresentation representation = ReplicatedTransactionFactory.extractTransactionRepresentation(( ReplicatedTransaction )unmarshal, extraHeader);
assertThat(representation, equalTo(tx));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void main(String[] args) throws java.io.IOException
public static void Main(string[] args)
{
Args arg = Args.parse(args);
string from = arg.Get("from");
Console.WriteLine("From is " + from);
string to = arg.Get("to");
Console.WriteLine("to is " + to);
File logDirectory = new File(from);
Console.WriteLine("logDirectory = " + logDirectory);
Config config = Config.defaults(stringMap());
using (DefaultFileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction())
{
LogProvider logProvider = Instance;
CoreLogPruningStrategy pruningStrategy = (new CoreLogPruningStrategyFactory(config.Get(raft_log_pruning_strategy), logProvider)).newInstance();
SegmentedRaftLog log = new SegmentedRaftLog(fileSystem, logDirectory, config.Get(raft_log_rotation_size), CoreReplicatedContentMarshal.marshaller(), logProvider, config.Get(raft_log_reader_pool_size), Clocks.systemClock(), new ThreadPoolJobScheduler(), pruningStrategy);
long totalCommittedEntries = log.AppendIndex(); // Not really, but we need to have a way to pass in the commit index
for (int i = 0; i <= totalCommittedEntries; i++)
{
ReplicatedContent content = readLogEntry(log, i).content();
if (content is ReplicatedTransaction)
{
ReplicatedTransaction tx = ( ReplicatedTransaction )content;
ReplicatedTransactionFactory.extractTransactionRepresentation(tx, new sbyte[0]).accept(element =>
{
Console.WriteLine(element);
return(false);
});
}
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void assertMarshalingEquality(io.netty.buffer.ByteBuf buffer, ReplicatedContent replicatedTx) throws java.io.IOException, org.neo4j.causalclustering.messaging.EndOfStreamException
private void AssertMarshalingEquality(ByteBuf buffer, ReplicatedContent replicatedTx)
{
_marshal.marshal(replicatedTx, new NetworkWritableChannel(buffer));
assertThat(_marshal.unmarshal(new NetworkReadableClosableChannelNetty4(buffer)), equalTo(replicatedTx));
}
public DistributedOperation(ReplicatedContent content, GlobalSession globalSession, LocalOperationId operationId)
{
this._content = content;
this._globalSession = globalSession;
this._operationId = operationId;
}
public virtual void Replicate(ReplicatedContent content)
{
_outbound.send(_myself, new Org.Neo4j.causalclustering.core.consensus.RaftMessages_NewEntry_Request(_myself, content));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void decode(io.netty.channel.ChannelHandlerContext ctx, io.netty.buffer.ByteBuf buffer, java.util.List<Object> list) throws Exception
public override void Decode(ChannelHandlerContext ctx, ByteBuf buffer, IList <object> list)
{
ReadableChannel channel = new NetworkReadableClosableChannelNetty4(buffer);
ClusterId clusterId = ClusterId.Marshal.INSTANCE.unmarshal(channel);
int messageTypeWire = channel.Int;
Org.Neo4j.causalclustering.core.consensus.RaftMessages_Type[] values = Enum.GetValues(typeof(Org.Neo4j.causalclustering.core.consensus.RaftMessages_Type));
Org.Neo4j.causalclustering.core.consensus.RaftMessages_Type messageType = values[messageTypeWire];
MemberId from = RetrieveMember(channel);
Org.Neo4j.causalclustering.core.consensus.RaftMessages_RaftMessage result;
if (messageType.Equals(VOTE_REQUEST))
{
MemberId candidate = RetrieveMember(channel);
long term = channel.Long;
long lastLogIndex = channel.Long;
long lastLogTerm = channel.Long;
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Request(from, term, candidate, lastLogIndex, lastLogTerm);
}
else if (messageType.Equals(VOTE_RESPONSE))
{
long term = channel.Long;
bool voteGranted = channel.Get() == 1;
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_Vote_Response(from, term, voteGranted);
}
else if (messageType.Equals(PRE_VOTE_REQUEST))
{
MemberId candidate = RetrieveMember(channel);
long term = channel.Long;
long lastLogIndex = channel.Long;
long lastLogTerm = channel.Long;
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_PreVote_Request(from, term, candidate, lastLogIndex, lastLogTerm);
}
else if (messageType.Equals(PRE_VOTE_RESPONSE))
{
long term = channel.Long;
bool voteGranted = channel.Get() == 1;
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_PreVote_Response(from, term, voteGranted);
}
else if (messageType.Equals(APPEND_ENTRIES_REQUEST))
{
// how many
long term = channel.Long;
long prevLogIndex = channel.Long;
long prevLogTerm = channel.Long;
long leaderCommit = channel.Long;
long count = channel.Long;
RaftLogEntry[] entries = new RaftLogEntry[( int )count];
for (int i = 0; i < count; i++)
{
long entryTerm = channel.Long;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.causalclustering.core.replication.ReplicatedContent content = marshal.unmarshal(channel);
ReplicatedContent content = _marshal.unmarshal(channel);
entries[i] = new RaftLogEntry(entryTerm, content);
}
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Request(from, term, prevLogIndex, prevLogTerm, entries, leaderCommit);
}
else if (messageType.Equals(APPEND_ENTRIES_RESPONSE))
{
long term = channel.Long;
bool success = channel.Get() == 1;
long matchIndex = channel.Long;
long appendIndex = channel.Long;
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Response(from, term, success, matchIndex, appendIndex);
}
else if (messageType.Equals(NEW_ENTRY_REQUEST))
{
ReplicatedContent content = _marshal.unmarshal(channel);
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_NewEntry_Request(from, content);
}
else if (messageType.Equals(HEARTBEAT))
{
long leaderTerm = channel.Long;
long commitIndexTerm = channel.Long;
long commitIndex = channel.Long;
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_Heartbeat(from, leaderTerm, commitIndex, commitIndexTerm);
}
else if (messageType.Equals(HEARTBEAT_RESPONSE))
{
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_HeartbeatResponse(from);
}
else if (messageType.Equals(LOG_COMPACTION_INFO))
{
long leaderTerm = channel.Long;
long prevIndex = channel.Long;
result = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_LogCompactionInfo(from, leaderTerm, prevIndex);
}
else
{
throw new System.ArgumentException("Unknown message type");
}
list.Add(Org.Neo4j.causalclustering.core.consensus.RaftMessages_ReceivedInstantClusterIdAwareMessage.of(_clock.instant(), clusterId, result));
}
public RaftMessages_NewEntry_Request(MemberId from, ReplicatedContent content) : base(from, RaftMessages_Type.NewEntryRequest)
{
this.ContentConflict = content;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void serializableContents(org.neo4j.causalclustering.core.replication.ReplicatedContent content, java.util.List<Object> out) throws java.io.IOException
internal virtual void SerializableContents(ReplicatedContent content, IList <object> @out)
{
@out.Add(ContentType.ReplicatedContent);
outerInstance.codec.Encode(content, @out);
}
