org.neo4j.kernel.impl.api.commit.ChunkCommitter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-kernel Show documentation
Show all versions of neo4j-kernel Show documentation
Neo4j kernel is a lightweight, embedded Java database designed to
store data structured as graphs rather than tables. For more
information, see http://neo4j.org.
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [https://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see extractedCommands = ktx.extractCommands(memoryTracker);
if (!extractedCommands.isEmpty() || (commit && transactionPayload != null)) {
serialExecutionGuard.check();
if (kernelVersion == null) {
this.kernelVersion = kernelVersionProvider.kernelVersion();
this.lastTransactionIdWhenStarted = lastTransactionIdWhenStarted;
this.startTimeMillis = lastTransactionIdWhenStarted;
this.leaseClient = leaseClient;
}
if (commit) {
validateCurrentKernelVersion();
}
try {
transactionValidator.validate(
extractedCommands, cursorContext, lockClient, lockTracer, validationLockDumper);
var chunkMetadata = new ChunkMetadata(
chunkNumber == BASE_CHUNK_NUMBER,
commit,
false,
previousBatchLogPosition,
chunkNumber,
new MutableLong(UNKNOWN_CONSENSUS_INDEX),
startTimeMillis,
lastTransactionIdWhenStarted,
commitTime,
leaseClient.leaseId(),
kernelVersion,
ktx.securityContext().subject().userSubject());
if (transactionPayload == null) {
transactionPayload = new ChunkedTransaction(
cursorContext,
ktx.getTransactionSequenceNumber(),
transactionalCursors,
commitmentFactory.newCommitment(),
transactionIdGenerator);
}
CommandChunk chunk = new CommandChunk(extractedCommands, chunkMetadata);
transactionPayload.init(chunk);
commitProcess.commit(transactionPayload, transactionWriteEvent, mode);
validationLockDumper.dumpLocks(
transactionValidator, lockClient, chunkNumber, transactionPayload.transactionId());
transactionWriteEvent.chunkAppended(
chunkNumber, ktx.getTransactionSequenceNumber(), transactionPayload.transactionId());
} catch (TransactionConflictException tce) {
throw tce;
} catch (Exception e) {
log.debug("Transaction chunk commit failure.", e);
throw e;
}
previousBatchLogPosition = transactionPayload.lastBatchLogPosition();
chunkNumber++;
}
return transactionPayload != null ? transactionPayload.transactionId() : KernelTransaction.READ_ONLY_ID;
} finally {
lockClient.reset();
}
}
@Override
public void rollback(TransactionRollbackEvent rollbackEvent) {
if (transactionPayload != null) {
try {
validateCurrentKernelVersion();
rollbackBatches(rollbackEvent);
writeRollbackEntry(rollbackEvent);
} catch (Exception e) {
databaseHealth.panic(e);
Exceptions.throwIfInstanceOf(e, TransactionRollbackException.class);
throw new TransactionRollbackException("Transaction rollback failed", e);
}
}
}
private void writeRollbackEntry(TransactionRollbackEvent transactionRollbackEvent)
throws TransactionFailureException {
var chunkMetadata = new ChunkMetadata(
false,
true,
true,
LogPosition.UNSPECIFIED,
chunkNumber,
new MutableLong(UNKNOWN_CONSENSUS_INDEX),
startTimeMillis,
lastTransactionIdWhenStarted,
clocks.systemClock().millis(),
leaseClient.leaseId(),
kernelVersion,
ktx.securityContext().subject().userSubject());
CommandChunk chunk = new CommandChunk(emptyList(), chunkMetadata);
transactionPayload.init(chunk);
try (var writeEvent = transactionRollbackEvent.beginRollbackWriteEvent()) {
commitProcess.commit(transactionPayload, writeEvent, INTERNAL);
}
}
// kernel version can be updated by upgrade listener and for now we only fail to commit such
// transactions.
private void validateCurrentKernelVersion() {
if (kernelVersion != kernelVersionProvider.kernelVersion()) {
throw new UnsupportedOperationException("We do not support upgrade during chunked transaction.");
}
}
private void rollbackBatches(TransactionRollbackEvent transactionRollbackEvent) throws Exception {
long transactionIdToRollback = transactionPayload.transactionId();
int rolledbackBatches = 0;
int chunksToRollback = chunkNumber - 1;
LogPosition logPosition = transactionPayload.lastBatchLogPosition();
try (var rollbackDataEvent = transactionRollbackEvent.beginRollbackDataEvent()) {
while (rolledbackBatches != chunksToRollback) {
try (CommandBatchCursor commandBatches = transactionStore.getCommandBatches(logPosition)) {
if (!commandBatches.next()) {
throw new TransactionRollbackException(format(
"Transaction rollback failed. Expected to rollback %d batches, but was able to undo only %d for transaction with id %d.",
chunksToRollback, rolledbackBatches, transactionIdToRollback));
}
CommittedCommandBatch commandBatch = commandBatches.get();
if (commandBatch.txId() != transactionIdToRollback) {
throw new TransactionRollbackException(String.format(
"Transaction rollback failed. Batch with transaction id %d encountered, while it was expected to belong to transaction id %d. Batch id: %s.",
commandBatch.txId(), transactionIdToRollback, chunkId(commandBatch)));
}
transactionPayload.init((CommandChunk) commandBatch.commandBatch());
storageEngine.apply(transactionPayload, TransactionApplicationMode.MVCC_ROLLBACK);
rolledbackBatches++;
logPosition = commandBatch.previousBatchLogPosition();
}
}
if (logPosition != LogPosition.UNSPECIFIED) {
throw new TransactionRollbackException(String.format(
"Transaction rollback failed. All expected %d batches in transaction id %d were rolled back but chain claims to have more at: %s.",
chunksToRollback, transactionIdToRollback, logPosition));
}
rollbackDataEvent.batchedRolledBack(chunksToRollback, transactionIdToRollback);
}
}
private String chunkId(CommittedCommandBatch commandBatch) {
return commandBatch.commandBatch() instanceof CommandChunk cc
? String.valueOf(cc.chunkMetadata().chunkId())
: "N/A";
}
@Override
public void reset() {
chunkNumber = BASE_CHUNK_NUMBER;
kernelVersion = null;
transactionPayload = null;
lastTransactionIdWhenStarted = 0;
startTimeMillis = 0;
leaseClient = null;
}
}