Example usage for com.google.common.collect Range.OrderedRangeContainmentChecker contains

Introduction

In this page you can find the example usage for com.google.common.collect Range.OrderedRangeContainmentChecker contains.

Prototype

public boolean contains(C value) 

Source Link

Document

Returns true if value is within the bounds of this range.

Usage

From source file:org.apache.cassandra.db.compaction.CompactionManager.java

private int antiCompactGroup(ColumnFamilyStore cfs, Collection<Range<Token>> ranges,
        LifecycleTransaction anticompactionGroup, long repairedAt) {
    long groupMaxDataAge = -1;

    // check that compaction hasn't stolen any sstables used in previous repair sessions
    // if we need to skip the anticompaction, it will be carried out by the next repair
    for (Iterator<SSTableReader> i = anticompactionGroup.originals().iterator(); i.hasNext();) {
        SSTableReader sstable = i.next();
        if (!new File(sstable.getFilename()).exists()) {
            logger.info(/*from   w w w. j av a 2s . c o m*/
                    "Skipping anticompaction for {}, required sstable was compacted and is no longer available.",
                    sstable);
            i.remove();
            continue;
        }
        if (groupMaxDataAge < sstable.maxDataAge)
            groupMaxDataAge = sstable.maxDataAge;
    }

    if (anticompactionGroup.originals().size() == 0) {
        logger.info(
                "No valid anticompactions for this group, All sstables were compacted and are no longer available");
        return 0;
    }

    logger.info("Anticompacting {}", anticompactionGroup);
    Set<SSTableReader> sstableAsSet = anticompactionGroup.originals();

    File destination = cfs.directories.getWriteableLocationAsFile(
            cfs.getExpectedCompactedFileSize(sstableAsSet, OperationType.ANTICOMPACTION));
    long repairedKeyCount = 0;
    long unrepairedKeyCount = 0;
    AbstractCompactionStrategy strategy = cfs.getCompactionStrategy();
    try (SSTableRewriter repairedSSTableWriter = new SSTableRewriter(cfs, anticompactionGroup, groupMaxDataAge,
            false, false);
            SSTableRewriter unRepairedSSTableWriter = new SSTableRewriter(cfs, anticompactionGroup,
                    groupMaxDataAge, false, false);
            AbstractCompactionStrategy.ScannerList scanners = strategy
                    .getScanners(anticompactionGroup.originals());
            CompactionController controller = new CompactionController(cfs, sstableAsSet,
                    getDefaultGcBefore(cfs))) {
        int expectedBloomFilterSize = Math.max(cfs.metadata.getMinIndexInterval(),
                (int) (SSTableReader.getApproximateKeyCount(sstableAsSet)));

        repairedSSTableWriter.switchWriter(CompactionManager.createWriterForAntiCompaction(cfs, destination,
                expectedBloomFilterSize, repairedAt, sstableAsSet));
        unRepairedSSTableWriter.switchWriter(CompactionManager.createWriterForAntiCompaction(cfs, destination,
                expectedBloomFilterSize, ActiveRepairService.UNREPAIRED_SSTABLE, sstableAsSet));

        CompactionIterable ci = new CompactionIterable(OperationType.ANTICOMPACTION, scanners.scanners,
                controller, DatabaseDescriptor.getSSTableFormat(), UUIDGen.getTimeUUID());
        metrics.beginCompaction(ci);
        try {
            @SuppressWarnings("resource")
            CloseableIterator<AbstractCompactedRow> iter = ci.iterator();
            Range.OrderedRangeContainmentChecker containmentChecker = new Range.OrderedRangeContainmentChecker(
                    ranges);
            while (iter.hasNext()) {
                @SuppressWarnings("resource")
                AbstractCompactedRow row = iter.next();
                // if current range from sstable is repaired, save it into the new repaired sstable
                if (containmentChecker.contains(row.key.getToken())) {
                    repairedSSTableWriter.append(row);
                    repairedKeyCount++;
                }
                // otherwise save into the new 'non-repaired' table
                else {
                    unRepairedSSTableWriter.append(row);
                    unrepairedKeyCount++;
                }
            }
        } finally {
            metrics.finishCompaction(ci);
        }

        List<SSTableReader> anticompactedSSTables = new ArrayList<>();
        // since both writers are operating over the same Transaction, we cannot use the convenience Transactional.finish() method,
        // as on the second finish() we would prepareToCommit() on a Transaction that has already been committed, which is forbidden by the API
        // (since it indicates misuse). We call permitRedundantTransitions so that calls that transition to a state already occupied are permitted.
        anticompactionGroup.permitRedundantTransitions();
        repairedSSTableWriter.setRepairedAt(repairedAt).prepareToCommit();
        unRepairedSSTableWriter.prepareToCommit();
        anticompactedSSTables.addAll(repairedSSTableWriter.finished());
        anticompactedSSTables.addAll(unRepairedSSTableWriter.finished());
        repairedSSTableWriter.commit();
        unRepairedSSTableWriter.commit();

        logger.trace("Repaired {} keys out of {} for {}/{} in {}", repairedKeyCount,
                repairedKeyCount + unrepairedKeyCount, cfs.keyspace.getName(), cfs.getColumnFamilyName(),
                anticompactionGroup);
        return anticompactedSSTables.size();
    } catch (Throwable e) {
        JVMStabilityInspector.inspectThrowable(e);
        logger.error("Error anticompacting " + anticompactionGroup, e);
    }
    return 0;
}

---