Java DatabaseDescriptor.isAutoSnapshot方法代码示例

import org.apache.cassandra.config.DatabaseDescriptor; //导入方法依赖的package包/类
@Test
public void testTruncateWithoutSnapshot()  throws ExecutionException, InterruptedException
{
    CommitLog.instance.resetUnsafe();
    boolean prev = DatabaseDescriptor.isAutoSnapshot();
    DatabaseDescriptor.setAutoSnapshot(false);
    ColumnFamilyStore cfs1 = Keyspace.open("Keyspace1").getColumnFamilyStore("Standard1");
    ColumnFamilyStore cfs2 = Keyspace.open("Keyspace1").getColumnFamilyStore("Standard2");

    final Mutation rm1 = new Mutation("Keyspace1", bytes("k"));
    rm1.add("Standard1", Util.cellname("c1"), ByteBuffer.allocate(100), 0);
    rm1.apply();
    cfs1.truncateBlocking();
    DatabaseDescriptor.setAutoSnapshot(prev);
    final Mutation rm2 = new Mutation("Keyspace1", bytes("k"));
    rm2.add("Standard2", Util.cellname("c1"), ByteBuffer.allocate(DatabaseDescriptor.getCommitLogSegmentSize() / 4), 0);

    for (int i = 0 ; i < 5 ; i++)
        CommitLog.instance.add(rm2);

    Assert.assertEquals(2, CommitLog.instance.activeSegments());
    ReplayPosition position = CommitLog.instance.getContext();
    for (Keyspace ks : Keyspace.system())
        for (ColumnFamilyStore syscfs : ks.getColumnFamilyStores())
            CommitLog.instance.discardCompletedSegments(syscfs.metadata.cfId, position);
    CommitLog.instance.discardCompletedSegments(cfs2.metadata.cfId, position);
    Assert.assertEquals(1, CommitLog.instance.activeSegments());
}
 

import org.apache.cassandra.config.DatabaseDescriptor; //导入方法依赖的package包/类
@Test
public void testTruncateWithoutSnapshotNonDurable()  throws ExecutionException, InterruptedException
{
    CommitLog.instance.resetUnsafe();
    boolean prevAutoSnapshot = DatabaseDescriptor.isAutoSnapshot();
    DatabaseDescriptor.setAutoSnapshot(false);
    Keyspace notDurableKs = Keyspace.open("NoCommitlogSpace");
    Assert.assertFalse(notDurableKs.metadata.durableWrites);
    ColumnFamilyStore cfs = notDurableKs.getColumnFamilyStore("Standard1");
    CellNameType type = notDurableKs.getColumnFamilyStore("Standard1").getComparator();
    Mutation rm;
    DecoratedKey dk = Util.dk("key1");

    // add data
    rm = new Mutation("NoCommitlogSpace", dk.getKey());
    rm.add("Standard1", Util.cellname("Column1"), ByteBufferUtil.bytes("abcd"), 0);
    rm.apply();

    ReadCommand command = new SliceByNamesReadCommand("NoCommitlogSpace", dk.getKey(), "Standard1", System.currentTimeMillis(), new NamesQueryFilter(FBUtilities.singleton(Util.cellname("Column1"), type)));
    Row row = command.getRow(notDurableKs);
    Cell col = row.cf.getColumn(Util.cellname("Column1"));
    Assert.assertEquals(col.value(), ByteBuffer.wrap("abcd".getBytes()));
    cfs.truncateBlocking();
    DatabaseDescriptor.setAutoSnapshot(prevAutoSnapshot);
    row = command.getRow(notDurableKs);
    Assert.assertEquals(null, row.cf);
}
 

import org.apache.cassandra.config.DatabaseDescriptor; //导入方法依赖的package包/类
private static void dropKeyspace(String ksName)
{
    KSMetaData ksm = Schema.instance.getKSMetaData(ksName);
    String snapshotName = Keyspace.getTimestampedSnapshotName(ksName);

    CompactionManager.instance.interruptCompactionFor(ksm.cfMetaData().values(), true);

    // remove all cfs from the keyspace instance.
    for (CFMetaData cfm : ksm.cfMetaData().values())
    {
        ColumnFamilyStore cfs = Keyspace.open(ksm.name).getColumnFamilyStore(cfm.cfName);

        Schema.instance.purge(cfm);

        if (!StorageService.instance.isClientMode())
        {
            if (DatabaseDescriptor.isAutoSnapshot())
                cfs.snapshot(snapshotName);
            Keyspace.open(ksm.name).dropCf(cfm.cfId);
        }
    }

    // remove the keyspace from the static instances.
    Keyspace.clear(ksm.name);
    Schema.instance.clearKeyspaceDefinition(ksm);
    if (!StorageService.instance.isClientMode())
    {
        MigrationManager.instance.notifyDropKeyspace(ksm);
    }
}
 

import org.apache.cassandra.config.DatabaseDescriptor; //导入方法依赖的package包/类
@Test
public void testTruncateWithoutSnapshot() throws ExecutionException, InterruptedException, IOException
{
    boolean originalState = DatabaseDescriptor.isAutoSnapshot();
    try
    {
        CommitLog.instance.resetUnsafe(true);
        boolean prev = DatabaseDescriptor.isAutoSnapshot();
        DatabaseDescriptor.setAutoSnapshot(false);
        ColumnFamilyStore cfs1 = Keyspace.open(KEYSPACE1).getColumnFamilyStore(STANDARD1);
        ColumnFamilyStore cfs2 = Keyspace.open(KEYSPACE1).getColumnFamilyStore(STANDARD2);

        new RowUpdateBuilder(cfs1.metadata, 0, "k").clustering("bytes").add("val", ByteBuffer.allocate(100)).build().applyUnsafe();
        cfs1.truncateBlocking();
        DatabaseDescriptor.setAutoSnapshot(prev);
        Mutation m2 = new RowUpdateBuilder(cfs2.metadata, 0, "k")
                      .clustering("bytes")
                      .add("val", ByteBuffer.allocate(DatabaseDescriptor.getCommitLogSegmentSize() / 4))
                      .build();

        for (int i = 0 ; i < 5 ; i++)
            CommitLog.instance.add(m2);

        assertEquals(2, CommitLog.instance.activeSegments());
        ReplayPosition position = CommitLog.instance.getContext();
        for (Keyspace ks : Keyspace.system())
            for (ColumnFamilyStore syscfs : ks.getColumnFamilyStores())
                CommitLog.instance.discardCompletedSegments(syscfs.metadata.cfId, ReplayPosition.NONE, position);
        CommitLog.instance.discardCompletedSegments(cfs2.metadata.cfId, ReplayPosition.NONE, position);
        assertEquals(1, CommitLog.instance.activeSegments());
    }
    finally
    {
        DatabaseDescriptor.setAutoSnapshot(originalState);
    }
}
 

import org.apache.cassandra.config.DatabaseDescriptor; //导入方法依赖的package包/类
private static void dropKeyspace(String ksName)
{
    KSMetaData ksm = Schema.instance.getKSMetaData(ksName);
    String snapshotName = Keyspace.getTimestampedSnapshotName(ksName);

    CompactionManager.instance.interruptCompactionFor(ksm.cfMetaData().values(), true);

    Keyspace keyspace = Keyspace.open(ksm.name);

    // remove all cfs from the keyspace instance.
    List<UUID> droppedCfs = new ArrayList<>();
    for (CFMetaData cfm : ksm.cfMetaData().values())
    {
        ColumnFamilyStore cfs = keyspace.getColumnFamilyStore(cfm.cfName);

        Schema.instance.purge(cfm);

        if (!StorageService.instance.isClientMode())
        {
            if (DatabaseDescriptor.isAutoSnapshot())
                cfs.snapshot(snapshotName);
            Keyspace.open(ksm.name).dropCf(cfm.cfId);
        }

        droppedCfs.add(cfm.cfId);
    }

    // remove the keyspace from the static instances.
    Keyspace.clear(ksm.name);
    Schema.instance.clearKeyspaceDefinition(ksm);

    keyspace.writeOrder.awaitNewBarrier();

    // force a new segment in the CL
    CommitLog.instance.forceRecycleAllSegments(droppedCfs);

    if (!StorageService.instance.isClientMode())
    {
        MigrationManager.instance.notifyDropKeyspace(ksm);
    }
}
 

import org.apache.cassandra.config.DatabaseDescriptor; //导入方法依赖的package包/类
/**
 * Truncate deletes the entire column family's data with no expensive tombstone creation
 */
public void truncateBlocking()
{
    // We have two goals here:
    // - truncate should delete everything written before truncate was invoked
    // - but not delete anything that isn't part of the snapshot we create.
    // We accomplish this by first flushing manually, then snapshotting, and
    // recording the timestamp IN BETWEEN those actions. Any sstables created
    // with this timestamp or greater time, will not be marked for delete.
    //
    // Bonus complication: since we store replay position in sstable metadata,
    // truncating those sstables means we will replay any CL segments from the
    // beginning if we restart before they [the CL segments] are discarded for
    // normal reasons post-truncate.  To prevent this, we store truncation
    // position in the System keyspace.
    logger.debug("truncating {}", name);

    if (DatabaseDescriptor.isAutoSnapshot())
    {
        // flush the CF being truncated before forcing the new segment
        forceBlockingFlush();

        // sleep a little to make sure that our truncatedAt comes after any sstable
        // that was part of the flushed we forced; otherwise on a tie, it won't get deleted.
        Uninterruptibles.sleepUninterruptibly(1, TimeUnit.MILLISECONDS);
    }

    // nuke the memtable data w/o writing to disk first
    Keyspace.switchLock.writeLock().lock();
    try
    {
        for (ColumnFamilyStore cfs : concatWithIndexes())
        {
            Memtable mt = cfs.getMemtableThreadSafe();
            if (!mt.isClean())
                mt.cfs.data.renewMemtable();
        }
    }
    finally
    {
        Keyspace.switchLock.writeLock().unlock();
    }

    Runnable truncateRunnable = new Runnable()
    {
        public void run()
        {
            logger.debug("Discarding sstable data for truncated CF + indexes");

            final long truncatedAt = System.currentTimeMillis();
            if (DatabaseDescriptor.isAutoSnapshot())
                snapshot(Keyspace.getTimestampedSnapshotName(name));

            ReplayPosition replayAfter = discardSSTables(truncatedAt);

            for (SecondaryIndex index : indexManager.getIndexes())
                index.truncateBlocking(truncatedAt);

            SystemKeyspace.saveTruncationRecord(ColumnFamilyStore.this, truncatedAt, replayAfter);

            logger.debug("cleaning out row cache");
            for (RowCacheKey key : CacheService.instance.rowCache.getKeySet())
            {
                if (key.cfId == metadata.cfId)
                    CacheService.instance.rowCache.remove(key);
            }
        }
    };

    runWithCompactionsDisabled(Executors.callable(truncateRunnable), true);
    logger.debug("truncate complete");
}