public override void AssertMatch(long txId, long checksum)
{
if (txId == 0)
{
return;
}
long readChecksum;
try
{
readChecksum = _txChecksumLookup.lookup(txId);
}
catch (NoSuchTransactionException)
{
// This can happen if it's the first commit from a slave in a cluster where all instances
// just restored from backup (i.e. no previous tx logs exist), OR if a reporting instance
// is so far behind that logs have been pruned to the point where the slave cannot catch up anymore.
// In the first case it's fine (slave had to do checksum match to join cluster), and the second case
// it's an operational issue solved by making sure enough logs are retained.
return; // Ok!
}
catch (IOException e)
{
_log.error("Couldn't verify checksum for " + Stringify(txId, checksum), e);
throw new BranchedDataException("Unable to perform a mandatory sanity check due to an IO error.", e);
}
if (checksum != readChecksum)
{
throw new BranchedDataException("The cluster contains two logically different versions of the database. " + "This will be automatically resolved. Details: " + Stringify(txId, checksum) + " does not match " + readChecksum);
}
}
public override void FileDeleted(string fileName)
{
if (!_fileNameFilter.test(fileName))
{
_internalLog.error(format("'%s' which belongs to the store was deleted while database was running.", fileName));
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public T readState() throws java.io.IOException
public override T ReadState()
{
try
{
using (ReadableClosableChannel channel = new ReadAheadChannel <>(_fileSystem.open(_file, OpenMode.READ)))
{
return(_marshal.unmarshal(channel));
}
}
catch (EndOfStreamException e)
{
_log.error("End of stream reached: " + _file);
throw new IOException(e);
}
}
/// <summary>
/// Writes logs about database errors.
/// Short one-line message is written to both user and internal log.
/// Large message with stacktrace (if available) is written to internal log.
/// </summary>
/// <param name="error"> the error to log. </param>
/// <seealso cref= StoreLogService </seealso>
/// <seealso cref= DuplicatingLogProvider </seealso>
public virtual void Report(Neo4jError error)
{
if (error.Status().code().classification() == DatabaseError)
{
string message = format("Client triggered an unexpected error [%s]: %s, reference %s.", error.Status().code().serialize(), error.Message(), error.Reference());
// Writing to user log gets duplicated to the internal log
_userLog.error(message);
// If cause/stacktrace is available write it to the internal log
if (error.Cause() != null)
{
_debugLog.error(message, error.Cause());
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void channelRead0(io.netty.channel.ChannelHandlerContext ctx, final TxPullRequest msg) throws Exception
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
protected internal override void ChannelRead0(ChannelHandlerContext ctx, TxPullRequest msg)
{
_monitor.increment();
if (msg.PreviousTxId() <= 0)
{
_log.error("Illegal tx pull request");
EndInteraction(ctx, E_INVALID_REQUEST, -1);
return;
}
StoreId localStoreId = _storeIdSupplier.get();
StoreId expectedStoreId = msg.ExpectedStoreId();
long firstTxId = msg.PreviousTxId() + 1;
/*
* This is the minimum transaction id we must send to consider our streaming operation successful. The kernel can
* concurrently prune even future transactions while iterating and the cursor will silently fail on iteration, so
* we need to add our own protection for this reason and also as a generally important sanity check for the fulfillment
* of the consistent recovery contract which requires us to stream transactions at least as far as the time when the
* file copy operation completed.
*/
long txIdPromise = _transactionIdStore.LastCommittedTransactionId;
IOCursor <CommittedTransactionRepresentation> txCursor = GetCursor(txIdPromise, ctx, firstTxId, localStoreId, expectedStoreId);
if (txCursor != null)
{
ChunkedTransactionStream txStream = new ChunkedTransactionStream(_log, localStoreId, firstTxId, txIdPromise, txCursor, _protocol);
// chunked transaction stream ends the interaction internally and closes the cursor
ctx.writeAndFlush(txStream).addListener(f =>
{
if (_log.DebugEnabled || !f.Success)
{
string message = format("Streamed transactions [%d--%d] to %s", firstTxId, txStream.LastTxId(), ctx.channel().remoteAddress());
if (f.Success)
{
_log.debug(message);
}
else
{
_log.warn(message, f.cause());
}
}
});
}
}
public override void Init()
{
if (_pullIntervalMillis > 0)
{
_intervalJobHandle = _scheduler.scheduleRecurring(Group.PULL_UPDATES, () =>
{
try
{
_updatePuller.pullUpdates();
}
catch (InterruptedException e)
{
_log.error("Pull updates failed", e);
}
}, _pullIntervalMillis, _pullIntervalMillis, TimeUnit.MILLISECONDS);
}
}
public virtual bool Run()
{
if (_tasks == null || _tasks.Length < 1)
{
return(true);
}
foreach (PreflightTask r in _tasks)
{
if (!r.Run())
{
_log.error(r.FailureMessage);
_failedTask = r;
return(false);
}
}
return(true);
}
private void SendRange(long startIndex, long endIndex, LeaderContext leaderContext)
{
if (startIndex > endIndex)
{
return;
}
_lastSentIndex = endIndex;
try
{
int batchSize = ( int )(endIndex - startIndex + 1);
RaftLogEntry[] entries = new RaftLogEntry[batchSize];
long prevLogIndex = startIndex - 1;
long prevLogTerm = _raftLog.readEntryTerm(prevLogIndex);
if (prevLogTerm > leaderContext.Term)
{
_log.warn("%s aborting send. Not leader anymore? %s, prevLogTerm=%d", StatusAsString(), leaderContext, prevLogTerm);
return;
}
bool entryMissing = false;
using (InFlightLogEntryReader logEntrySupplier = new InFlightLogEntryReader(_raftLog, _inFlightCache, false))
{
for (int offset = 0; offset < batchSize; offset++)
{
entries[offset] = logEntrySupplier.Get(startIndex + offset);
if (entries[offset] == null)
{
entryMissing = true;
break;
}
if (entries[offset].Term() > leaderContext.Term)
{
_log.warn("%s aborting send. Not leader anymore? %s, entryTerm=%d", StatusAsString(), leaderContext, entries[offset].Term());
return;
}
}
}
if (entryMissing || DoesNotExistInLog(prevLogIndex, prevLogTerm))
{
if (_raftLog.prevIndex() >= prevLogIndex)
{
SendLogCompactionInfo(leaderContext);
}
else
{
_log.error("%s: Could not send compaction info and entries were missing, but log is not behind.", StatusAsString());
}
}
else
{
Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Request appendRequest = new Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Request(_leader, leaderContext.Term, prevLogIndex, prevLogTerm, entries, leaderContext.CommitIndex);
_outbound.send(_follower, appendRequest);
}
}
catch (IOException e)
{
_log.warn(StatusAsString() + " exception during batch send", e);
}
}