Tabnine Logo
Tracker.updateSizeTracking
Code IndexAdd Tabnine to your IDE (free)

How to use
updateSizeTracking
method
in
org.apache.cassandra.db.lifecycle.Tracker

Best Java code snippets using org.apache.cassandra.db.lifecycle.Tracker.updateSizeTracking (Showing top 15 results out of 315)

origin: com.netflix.sstableadaptor/sstable-adaptor-cassandra

/**
 * 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;
}
origin: jsevellec/cassandra-unit

/**
 * 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;
}
origin: org.apache.cassandra/cassandra-all

/**
 * 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;
}
origin: com.strapdata.cassandra/cassandra-all

/**
 * 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;
}
origin: com.netflix.sstableadaptor/sstable-adaptor-cassandra

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

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}
origin: org.apache.cassandra/cassandra-all

accumulate = updateSizeTracking(removed, emptySet(), accumulate);
accumulate = release(selfRefs(removed), accumulate);
origin: org.apache.cassandra/cassandra-all

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}
origin: com.strapdata.cassandra/cassandra-all

public void addInitialSSTables(Iterable<SSTableReader> sstables)
{
  if (!isDummy())
    setupOnline(sstables);
  apply(updateLiveSet(emptySet(), sstables));
  maybeFail(updateSizeTracking(emptySet(), sstables, null));
  // no notifications or backup necessary
}
origin: com.netflix.sstableadaptor/sstable-adaptor-cassandra

accumulate = updateSizeTracking(removed, emptySet(), accumulate);
accumulate = release(selfRefs(removed), accumulate);
origin: com.strapdata.cassandra/cassandra-all

accumulate = updateSizeTracking(removed, emptySet(), accumulate);
accumulate = release(selfRefs(removed), accumulate);
origin: com.strapdata.cassandra/cassandra-all

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);
}
origin: org.apache.cassandra/cassandra-all

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);
}
origin: jsevellec/cassandra-unit

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);
}
origin: jsevellec/cassandra-unit

accumulate = updateSizeTracking(removed, emptySet(), accumulate);
accumulate = release(selfRefs(removed), accumulate);
org.apache.cassandra.db.lifecycleTrackerupdateSizeTracking

Popular methods of Tracker

  • tryModify
  • <init>
  • addInitialSSTables
  • apply
    atomically tests permit against the view and applies function to it, if permit yields true, returnin
  • dropSSTables
  • dropSSTablesIfInvalid
  • emptySet
  • isDummy
  • addSSTables
  • getCompacting
  • getMemtableFor
    get the Memtable that the ordered writeOp should be directed to
  • getUncompacting
  • getMemtableFor,
  • getUncompacting,
  • getView,
  • markFlushing,
  • maybeIncrementallyBackup,
  • notify,
  • notifyAdded,
  • notifyDeleting,
  • notifyDiscarded

Popular in Java

  • Reactive rest calls using spring rest template
  • onCreateOptionsMenu (Activity)
  • scheduleAtFixedRate (Timer)
  • startActivity (Activity)
  • OutputStream (java.io)
    A writable sink for bytes.Most clients will use output streams that write data to the file system (
  • Time (java.sql)
    Java representation of an SQL TIME value. Provides utilities to format and parse the time's represen
  • Scanner (java.util)
    A parser that parses a text string of primitive types and strings with the help of regular expressio
  • TreeMap (java.util)
    Walk the nodes of the tree left-to-right or right-to-left. Note that in descending iterations, next
  • Stream (java.util.stream)
    A sequence of elements supporting sequential and parallel aggregate operations. The following exampl
  • IsNull (org.hamcrest.core)
    Is the value null?
  • Top Vim plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now