How to use

updateSizeTracking

method

in

org.apache.cassandra.db.lifecycle.Tracker

/**
 * point of no return: commit all changes, but leave all readers marked as compacting
 */
public Throwable doCommit(Throwable accumulate)
{
  assert staged.isEmpty() : "must be no actions introduced between prepareToCommit and a commit";
  if (logger.isTraceEnabled())
    logger.trace("Committing transaction over {} staged: {}, logged: {}", originals, staged, logged);
  // accumulate must be null if we have been used correctly, so fail immediately if it is not
  maybeFail(accumulate);
  // transaction log commit failure means we must abort; safe commit is not possible
  maybeFail(log.commit(null));
  // this is now the point of no return; we cannot safely rollback, so we ignore exceptions until we're done
  // we restore state by obsoleting our obsolete files, releasing our references to them, and updating our size
  // and notification status for the obsolete and new files
  accumulate = markObsolete(obsoletions, accumulate);
  accumulate = tracker.updateSizeTracking(logged.obsolete, logged.update, accumulate);
  accumulate = release(selfRefs(logged.obsolete), accumulate);
  //accumulate = tracker.notifySSTablesChanged(originals, logged.update, log.type(), accumulate);
  return accumulate;
}

/**
 * point of no return: commit all changes, but leave all readers marked as compacting
 */
public Throwable doCommit(Throwable accumulate)
{
  assert staged.isEmpty() : "must be no actions introduced between prepareToCommit and a commit";
  if (logger.isTraceEnabled())
    logger.trace("Committing transaction over {} staged: {}, logged: {}", originals, staged, logged);
  // accumulate must be null if we have been used correctly, so fail immediately if it is not
  maybeFail(accumulate);
  // transaction log commit failure means we must abort; safe commit is not possible
  maybeFail(log.commit(null));
  // this is now the point of no return; we cannot safely rollback, so we ignore exceptions until we're done
  // we restore state by obsoleting our obsolete files, releasing our references to them, and updating our size
  // and notification status for the obsolete and new files
  accumulate = markObsolete(obsoletions, accumulate);
  accumulate = tracker.updateSizeTracking(logged.obsolete, logged.update, accumulate);
  accumulate = release(selfRefs(logged.obsolete), accumulate);
  accumulate = tracker.notifySSTablesChanged(originals, logged.update, log.type(), accumulate);
  return accumulate;
}

/**
 * point of no return: commit all changes, but leave all readers marked as compacting
 */
public Throwable doCommit(Throwable accumulate)
{
  assert staged.isEmpty() : "must be no actions introduced between prepareToCommit and a commit";
  if (logger.isTraceEnabled())
    logger.trace("Committing transaction over {} staged: {}, logged: {}", originals, staged, logged);
  // accumulate must be null if we have been used correctly, so fail immediately if it is not
  maybeFail(accumulate);
  // transaction log commit failure means we must abort; safe commit is not possible
  maybeFail(log.commit(null));
  // this is now the point of no return; we cannot safely rollback, so we ignore exceptions until we're done
  // we restore state by obsoleting our obsolete files, releasing our references to them, and updating our size
  // and notification status for the obsolete and new files
  accumulate = markObsolete(obsoletions, accumulate);
  accumulate = tracker.updateSizeTracking(logged.obsolete, logged.update, accumulate);
  accumulate = release(selfRefs(logged.obsolete), accumulate);
  accumulate = tracker.notifySSTablesChanged(originals, logged.update, log.type(), accumulate);
  return accumulate;
}

/**
 * point of no return: commit all changes, but leave all readers marked as compacting
 */
public Throwable doCommit(Throwable accumulate)
{
  assert staged.isEmpty() : "must be no actions introduced between prepareToCommit and a commit";
  if (logger.isTraceEnabled())
    logger.trace("Committing transaction over {} staged: {}, logged: {}", originals, staged, logged);
  // accumulate must be null if we have been used correctly, so fail immediately if it is not
  maybeFail(accumulate);
  // transaction log commit failure means we must abort; safe commit is not possible
  maybeFail(log.commit(null));
  // this is now the point of no return; we cannot safely rollback, so we ignore exceptions until we're done
  // we restore state by obsoleting our obsolete files, releasing our references to them, and updating our size
  // and notification status for the obsolete and new files
  accumulate = markObsolete(obsoletions, accumulate);
  accumulate = tracker.updateSizeTracking(logged.obsolete, logged.update, accumulate);
  accumulate = release(selfRefs(logged.obsolete), accumulate);
  accumulate = tracker.notifySSTablesChanged(originals, logged.update, log.type(), accumulate);
  return accumulate;
}

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}

accumulate = updateSizeTracking(removed, emptySet(), accumulate);
accumulate = release(selfRefs(removed), accumulate);

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}

accumulate = updateSizeTracking(removed, emptySet(), accumulate);
accumulate = release(selfRefs(removed), accumulate);

accumulate = updateSizeTracking(removed, emptySet(), accumulate);
accumulate = release(selfRefs(removed), accumulate);

public void replaceFlushed(Memtable memtable, Iterable<SSTableReader> sstables)
{
  assert !isDummy();
  if (Iterables.isEmpty(sstables))
  {
    // sstable may be null if we flushed batchlog and nothing needed to be retained
    // if it's null, we don't care what state the cfstore is in, we just replace it and continue
    apply(View.replaceFlushed(memtable, null));
    return;
  }
  sstables.forEach(SSTableReader::setupOnline);
  // back up before creating a new Snapshot (which makes the new one eligible for compaction)
  maybeIncrementallyBackup(sstables);
  apply(View.replaceFlushed(memtable, sstables));
  Throwable fail;
  fail = updateSizeTracking(emptySet(), sstables, null);
  notifyDiscarded(memtable);
  // TODO: if we're invalidated, should we notifyadded AND removed, or just skip both?
  fail = notifyAdded(sstables, memtable, fail);
  if (!isDummy() && !cfstore.isValid())
    dropSSTables();
  maybeFail(fail);
}

public void replaceFlushed(Memtable memtable, Iterable<SSTableReader> sstables)
{
  assert !isDummy();
  if (Iterables.isEmpty(sstables))
  {
    // sstable may be null if we flushed batchlog and nothing needed to be retained
    // if it's null, we don't care what state the cfstore is in, we just replace it and continue
    apply(View.replaceFlushed(memtable, null));
    return;
  }
  sstables.forEach(SSTableReader::setupOnline);
  // back up before creating a new Snapshot (which makes the new one eligible for compaction)
  maybeIncrementallyBackup(sstables);
  apply(View.replaceFlushed(memtable, sstables));
  Throwable fail;
  fail = updateSizeTracking(emptySet(), sstables, null);
  notifyDiscarded(memtable);
  // TODO: if we're invalidated, should we notifyadded AND removed, or just skip both?
  fail = notifyAdded(sstables, fail);
  if (!isDummy() && !cfstore.isValid())
    dropSSTables();
  maybeFail(fail);
}

public void replaceFlushed(Memtable memtable, Iterable<SSTableReader> sstables)
{
  assert !isDummy();
  if (Iterables.isEmpty(sstables))
  {
    // sstable may be null if we flushed batchlog and nothing needed to be retained
    // if it's null, we don't care what state the cfstore is in, we just replace it and continue
    apply(View.replaceFlushed(memtable, null));
    return;
  }
  sstables.forEach(SSTableReader::setupOnline);
  // back up before creating a new Snapshot (which makes the new one eligible for compaction)
  maybeIncrementallyBackup(sstables);
  apply(View.replaceFlushed(memtable, sstables));
  Throwable fail;
  fail = updateSizeTracking(emptySet(), sstables, null);
  notifyDiscarded(memtable);
  // TODO: if we're invalidated, should we notifyadded AND removed, or just skip both?
  fail = notifyAdded(sstables, fail);
  if (!isDummy() && !cfstore.isValid())
    dropSSTables();
  maybeFail(fail);
}

accumulate = updateSizeTracking(removed, emptySet(), accumulate);
accumulate = release(selfRefs(removed), accumulate);