Examples with LifecycleTransaction org.apache.cassandra.db.lifecycle.LifecycleTransaction used on opensource projects

Example 31 with LifecycleTransaction

use of org.apache.cassandra.db.lifecycle.LifecycleTransaction in project cassandra by apache.

the class StandaloneScrubber method main.

public static void main(String[] args) {
    Options options = Options.parseArgs(args);
    Util.initDatabaseDescriptor();
    try {
        // load keyspace descriptions.
        Schema.instance.loadFromDisk(false);
        if (Schema.instance.getKeyspaceMetadata(options.keyspaceName) == null)
            throw new IllegalArgumentException(String.format("Unknown keyspace %s", options.keyspaceName));
        // Do not load sstables since they might be broken
        Keyspace keyspace = Keyspace.openWithoutSSTables(options.keyspaceName);
        ColumnFamilyStore cfs = null;
        for (ColumnFamilyStore c : keyspace.getValidColumnFamilies(true, false, options.cfName)) {
            if (c.name.equals(options.cfName)) {
                cfs = c;
                break;
            }
        }
        if (cfs == null)
            throw new IllegalArgumentException(String.format("Unknown table %s.%s", options.keyspaceName, options.cfName));
        String snapshotName = "pre-scrub-" + System.currentTimeMillis();
        OutputHandler handler = new OutputHandler.SystemOutput(options.verbose, options.debug);
        Directories.SSTableLister lister = cfs.getDirectories().sstableLister(Directories.OnTxnErr.THROW).skipTemporary(true);
        List<SSTableReader> sstables = new ArrayList<>();
        // Scrub sstables
        for (Map.Entry<Descriptor, Set<Component>> entry : lister.list().entrySet()) {
            Set<Component> components = entry.getValue();
            if (!components.contains(Component.DATA))
                continue;
            try {
                SSTableReader sstable = SSTableReader.openNoValidation(entry.getKey(), components, cfs);
                sstables.add(sstable);
                File snapshotDirectory = Directories.getSnapshotDirectory(sstable.descriptor, snapshotName);
                sstable.createLinks(snapshotDirectory.getPath());
            } catch (Exception e) {
                JVMStabilityInspector.inspectThrowable(e);
                System.err.println(String.format("Error Loading %s: %s", entry.getKey(), e.getMessage()));
                if (options.debug)
                    e.printStackTrace(System.err);
            }
        }
        System.out.println(String.format("Pre-scrub sstables snapshotted into snapshot %s", snapshotName));
        if (!options.manifestCheckOnly) {
            for (SSTableReader sstable : sstables) {
                try (LifecycleTransaction txn = LifecycleTransaction.offline(OperationType.SCRUB, sstable)) {
                    // make sure originals are deleted and avoid NPE if index is missing, CASSANDRA-9591
                    txn.obsoleteOriginals();
                    try (Scrubber scrubber = new Scrubber(cfs, txn, options.skipCorrupted, handler, !options.noValidate)) {
                        scrubber.scrub();
                    } catch (Throwable t) {
                        if (!cfs.rebuildOnFailedScrub(t)) {
                            System.out.println(t.getMessage());
                            throw t;
                        }
                    }
                } catch (Exception e) {
                    System.err.println(String.format("Error scrubbing %s: %s", sstable, e.getMessage()));
                    e.printStackTrace(System.err);
                }
            }
        }
        // Check (and repair) manifests
        checkManifest(cfs.getCompactionStrategyManager(), cfs, sstables);
        CompactionManager.instance.finishCompactionsAndShutdown(5, TimeUnit.MINUTES);
        LifecycleTransaction.waitForDeletions();
        // We need that to stop non daemonized threads
        System.exit(0);
    } catch (Exception e) {
        System.err.println(e.getMessage());
        if (options.debug)
            e.printStackTrace(System.err);
        System.exit(1);
    }
}

Example 32 with LifecycleTransaction

use of org.apache.cassandra.db.lifecycle.LifecycleTransaction in project cassandra by apache.

the class StandaloneUpgrader method main.

public static void main(String[] args) {
    Options options = Options.parseArgs(args);
    Util.initDatabaseDescriptor();
    try {
        // load keyspace descriptions.
        Schema.instance.loadFromDisk(false);
        if (Schema.instance.getTableMetadataRef(options.keyspace, options.cf) == null)
            throw new IllegalArgumentException(String.format("Unknown keyspace/table %s.%s", options.keyspace, options.cf));
        Keyspace keyspace = Keyspace.openWithoutSSTables(options.keyspace);
        ColumnFamilyStore cfs = keyspace.getColumnFamilyStore(options.cf);
        OutputHandler handler = new OutputHandler.SystemOutput(false, options.debug);
        Directories.SSTableLister lister = cfs.getDirectories().sstableLister(Directories.OnTxnErr.THROW);
        if (options.snapshot != null)
            lister.onlyBackups(true).snapshots(options.snapshot);
        else
            lister.includeBackups(false);
        Collection<SSTableReader> readers = new ArrayList<>();
        // Upgrade sstables
        for (Map.Entry<Descriptor, Set<Component>> entry : lister.list().entrySet()) {
            Set<Component> components = entry.getValue();
            if (!components.contains(Component.DATA) || !components.contains(Component.PRIMARY_INDEX))
                continue;
            try {
                SSTableReader sstable = SSTableReader.openNoValidation(entry.getKey(), components, cfs);
                if (sstable.descriptor.version.equals(SSTableFormat.Type.current().info.getLatestVersion())) {
                    sstable.selfRef().release();
                    continue;
                }
                readers.add(sstable);
            } catch (Exception e) {
                JVMStabilityInspector.inspectThrowable(e);
                System.err.println(String.format("Error Loading %s: %s", entry.getKey(), e.getMessage()));
                if (options.debug)
                    e.printStackTrace(System.err);
            }
        }
        int numSSTables = readers.size();
        handler.output("Found " + numSSTables + " sstables that need upgrading.");
        for (SSTableReader sstable : readers) {
            try (LifecycleTransaction txn = LifecycleTransaction.offline(OperationType.UPGRADE_SSTABLES, sstable)) {
                Upgrader upgrader = new Upgrader(cfs, txn, handler);
                upgrader.upgrade(options.keepSource);
            } catch (Exception e) {
                System.err.println(String.format("Error upgrading %s: %s", sstable, e.getMessage()));
                if (options.debug)
                    e.printStackTrace(System.err);
            } finally {
                // we should have released this through commit of the LifecycleTransaction,
                // but in case the upgrade failed (or something else went wrong) make sure we don't retain a reference
                sstable.selfRef().ensureReleased();
            }
        }
        CompactionManager.instance.finishCompactionsAndShutdown(5, TimeUnit.MINUTES);
        LifecycleTransaction.waitForDeletions();
        System.exit(0);
    } catch (Exception e) {
        System.err.println(e.getMessage());
        if (options.debug)
            e.printStackTrace(System.err);
        System.exit(1);
    }
}

Example 33 with LifecycleTransaction

use of org.apache.cassandra.db.lifecycle.LifecycleTransaction in project cassandra by apache.

the class CompactionManager method doAntiCompaction.

/**
     * Splits up an sstable into two new sstables. The first of the new tables will store repaired ranges, the second
     * will store the non-repaired ranges. Once anticompation is completed, the original sstable is marked as compacted
     * and subsequently deleted.
     * @param cfs
     * @param repaired a transaction over the repaired sstables to anticompacy
     * @param ranges Repaired ranges to be placed into one of the new sstables. The repaired table will be tracked via
     * the {@link org.apache.cassandra.io.sstable.metadata.StatsMetadata#repairedAt} field.
     */
private void doAntiCompaction(ColumnFamilyStore cfs, Collection<Range<Token>> ranges, LifecycleTransaction repaired, long repairedAt, UUID pendingRepair) {
    logger.info("Performing anticompaction on {} sstables", repaired.originals().size());
    //Group SSTables
    Collection<Collection<SSTableReader>> groupedSSTables = cfs.getCompactionStrategyManager().groupSSTablesForAntiCompaction(repaired.originals());
    // iterate over sstables to check if the repaired / unrepaired ranges intersect them.
    int antiCompactedSSTableCount = 0;
    for (Collection<SSTableReader> sstableGroup : groupedSSTables) {
        try (LifecycleTransaction txn = repaired.split(sstableGroup)) {
            int antiCompacted = antiCompactGroup(cfs, ranges, txn, repairedAt, pendingRepair);
            antiCompactedSSTableCount += antiCompacted;
        }
    }
    String format = "Anticompaction completed successfully, anticompacted from {} to {} sstable(s).";
    logger.info(format, repaired.originals().size(), antiCompactedSSTableCount);
}

Example 34 with LifecycleTransaction

use of org.apache.cassandra.db.lifecycle.LifecycleTransaction in project cassandra by apache.

the class CompactionManager method forceUserDefinedCleanup.

public void forceUserDefinedCleanup(String dataFiles) {
    String[] filenames = dataFiles.split(",");
    HashMap<ColumnFamilyStore, Descriptor> descriptors = Maps.newHashMap();
    for (String filename : filenames) {
        // extract keyspace and columnfamily name from filename
        Descriptor desc = Descriptor.fromFilename(filename.trim());
        if (Schema.instance.getTableMetadataRef(desc) == null) {
            logger.warn("Schema does not exist for file {}. Skipping.", filename);
            continue;
        }
        // group by keyspace/columnfamily
        ColumnFamilyStore cfs = Keyspace.open(desc.ksname).getColumnFamilyStore(desc.cfname);
        desc = cfs.getDirectories().find(new File(filename.trim()).getName());
        if (desc != null)
            descriptors.put(cfs, desc);
    }
    for (Map.Entry<ColumnFamilyStore, Descriptor> entry : descriptors.entrySet()) {
        ColumnFamilyStore cfs = entry.getKey();
        Keyspace keyspace = cfs.keyspace;
        Collection<Range<Token>> ranges = StorageService.instance.getLocalRanges(keyspace.getName());
        boolean hasIndexes = cfs.indexManager.hasIndexes();
        SSTableReader sstable = lookupSSTable(cfs, entry.getValue());
        if (ranges.isEmpty()) {
            logger.error("Cleanup cannot run before a node has joined the ring");
            return;
        }
        if (sstable == null) {
            logger.warn("Will not clean {}, it is not an active sstable", entry.getValue());
        } else {
            CleanupStrategy cleanupStrategy = CleanupStrategy.get(cfs, ranges, FBUtilities.nowInSeconds());
            try (LifecycleTransaction txn = cfs.getTracker().tryModify(sstable, OperationType.CLEANUP)) {
                doCleanupOne(cfs, txn, cleanupStrategy, ranges, hasIndexes);
            } catch (IOException e) {
                logger.error("forceUserDefinedCleanup failed: {}", e.getLocalizedMessage());
            }
        }
    }
}

Example 35 with LifecycleTransaction

use of org.apache.cassandra.db.lifecycle.LifecycleTransaction in project cassandra by apache.

the class DateTieredCompactionStrategy method getNextBackgroundTask.

@Override
@SuppressWarnings("resource")
public AbstractCompactionTask getNextBackgroundTask(int gcBefore) {
    while (true) {
        List<SSTableReader> latestBucket = getNextBackgroundSSTables(gcBefore);
        if (latestBucket.isEmpty())
            return null;
        LifecycleTransaction modifier = cfs.getTracker().tryModify(latestBucket, OperationType.COMPACTION);
        if (modifier != null)
            return new CompactionTask(cfs, modifier, gcBefore);
    }
}