private Throwable checkpoint(Throwable accumulate) {
if (logger.isDebugEnabled())
logger.debug("Checkpointing update:{}, obsolete:{}", staged.update, staged.obsolete);
if (staged.isEmpty()) return accumulate;
Set<SSTableReader> toUpdate = toUpdate();
Set<SSTableReader> fresh = copyOf(fresh());
// check the current versions of the readers we're replacing haven't somehow been replaced by
// someone else
checkNotReplaced(filterIn(toUpdate, staged.update));
// ensure any new readers are in the compacting set, since we aren't done with them yet
// and don't want anyone else messing with them
// apply atomically along with updating the live set of readers
tracker.apply(
compose(updateCompacting(emptySet(), fresh), updateLiveSet(toUpdate, staged.update)));
// log the staged changes and our newly marked readers
marked.addAll(fresh);
logged.log(staged);
// setup our tracker, and mark our prior versions replaced, also releasing our references to
// them
// we do not replace/release obsoleted readers, since we may need to restore them on rollback
accumulate = setReplaced(filterOut(toUpdate, staged.obsolete), accumulate);
accumulate = release(selfRefs(filterOut(toUpdate, staged.obsolete)), accumulate);
staged.clear();
return accumulate;
}
/** construct a Transaction for use in an offline operation */
public static LifecycleTransaction offline(
OperationType operationType, Iterable<SSTableReader> readers) {
// if offline, for simplicity we just use a dummy tracker
Tracker dummy = new Tracker(null, false);
dummy.addInitialSSTables(readers);
dummy.apply(updateCompacting(emptySet(), readers));
return new LifecycleTransaction(dummy, operationType, readers);
}
private Throwable unmarkCompacting(Set<SSTableReader> unmark, Throwable accumulate) {
accumulate = tracker.apply(updateCompacting(unmark, emptySet()), accumulate);
// when the CFS is invalidated, it will call unreferenceSSTables(). However,
// unreferenceSSTables only deals
// with sstables that aren't currently being compacted. If there are ongoing compactions that
// finish or are
// interrupted after the CFS is invalidated, those sstables need to be unreferenced as well, so
// we do that here.
accumulate = tracker.dropSSTablesIfInvalid(accumulate);
return accumulate;
}
/** undo all of the changes made by this transaction, resetting the state to its original form */
public Throwable doAbort(Throwable accumulate) {
if (logger.isDebugEnabled())
logger.debug(
"Aborting transaction over {}, with ({},{}) logged and ({},{}) staged",
originals,
logged.update,
logged.obsolete,
staged.update,
staged.obsolete);
if (logged.isEmpty() && staged.isEmpty()) return accumulate;
// mark obsolete all readers that are not versions of those present in the original set
Iterable<SSTableReader> obsolete =
filterOut(concatUniq(staged.update, logged.update), originals);
logger.debug("Obsoleting {}", obsolete);
// we don't pass the tracker in for the obsoletion, since these readers have never been notified
// externally
// nor had their size accounting affected
accumulate = markObsolete(null, obsolete, accumulate);
// replace all updated readers with a version restored to its original state
accumulate = tracker.apply(updateLiveSet(logged.update, restoreUpdatedOriginals()), accumulate);
// setReplaced immediately preceding versions that have not been obsoleted
accumulate = setReplaced(logged.update, accumulate);
// we have replaced all of logged.update and never made visible staged.update,
// and the files we have logged as obsolete we clone fresh versions of, so they are no longer
// needed either
// any _staged_ obsoletes should either be in staged.update already, and dealt with there,
// or is still in its original form (so left as is); in either case no extra action is needed
accumulate =
release(selfRefs(concat(staged.update, logged.update, logged.obsolete)), accumulate);
logged.clear();
staged.clear();
return accumulate;
}