Java Keyspace类代码示例

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
@Override protected void before() throws Throwable {
  if (server != null) return;

  DatabaseDescriptor.daemonInitialization();

  // Cleanup first
  try {
    cleanupAndLeaveDirs();
  } catch (IOException e) {
    throw new RuntimeException("Failed to cleanup and recreate directories.", e);
  }

  Keyspace.setInitialized();
  SystemKeyspace.persistLocalMetadata();
  SystemKeyspace.finishStartup();
  StorageService.instance.initServer();

  server = new Server.Builder().withHost(nativeAddr).withPort(nativePort).build();
  server.start();
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
private ColumnFamilyStore getStore(String ksName, String cfName) {
    // Start by validating keyspace name
    if (Schema.instance.getKSMetaData(ksName) == null) {
        System.err.println(String.format("Reference to nonexistent keyspace: %s!", ksName));
        System.exit(1);
    }
    Keyspace keyspace = Keyspace.open(ksName);

    // Make it works for indexes too - find parent cf if necessary
    String baseName = cfName;
    if (cfName.contains(".")) {
        String[] parts = cfName.split("\\.", 2);
        baseName = parts[0];
    }

    // IllegalArgumentException will be thrown here if ks/cf pair does not exist
    try {
        return keyspace.getColumnFamilyStore(baseName);
    } catch (Throwable t) {
        System.err.println(String.format(
                "The provided column family is not part of this cassandra keyspace: keyspace = %s, column family = %s",
                ksName, cfName));
        System.exit(1);
    }
    return null;
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
/**
 * Get a map of all ranges and their respective sources that are candidates for streaming the given ranges
 * to us. For each range, the list of sources is sorted by proximity relative to the given destAddress.
 */
private Multimap<Range<Token>, InetAddress> getAllRangesWithSourcesFor(String keyspaceName, Collection<Range<Token>> desiredRanges)
{
    AbstractReplicationStrategy strat = Keyspace.open(keyspaceName).getReplicationStrategy();
    Multimap<Range<Token>, InetAddress> rangeAddresses = strat.getRangeAddresses(metadata.cloneOnlyTokenMap());

    Multimap<Range<Token>, InetAddress> rangeSources = ArrayListMultimap.create();
    for (Range<Token> desiredRange : desiredRanges)
    {
        for (Range<Token> range : rangeAddresses.keySet())
        {
            if (range.contains(desiredRange))
            {
                List<InetAddress> preferred = DatabaseDescriptor.getEndpointSnitch().getSortedListByProximity(address, rangeAddresses.get(range));
                rangeSources.putAll(desiredRange, preferred);
                break;
            }
        }

        if (!rangeSources.keySet().contains(desiredRange))
            throw new IllegalStateException("No sources found for " + desiredRange);
    }

    return rangeSources;
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
@Test
public void testConversionsInverses() throws Exception
{
    for (String keyspaceName : Schema.instance.getNonSystemKeyspaces())
    {
        for (ColumnFamilyStore cfs : Keyspace.open(keyspaceName).getColumnFamilyStores())
        {
            CFMetaData cfm = cfs.metadata;
            if (!cfm.isThriftCompatible())
                continue;

            checkInverses(cfm);

            // Testing with compression to catch #3558
            CFMetaData withCompression = cfm.copy();
            withCompression.compression(CompressionParams.snappy(32768));
            checkInverses(withCompression);
        }
    }
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
/**
 * Remove the snapshot with the given name from the given keyspaces.
 * If no tag is specified we will remove all snapshots.
 */
public void clearSnapshot(String tag, String... keyspaceNames) throws IOException
{
    if(tag == null)
        tag = "";

    Set<String> keyspaces = new HashSet<>();
    for (String dataDir : DatabaseDescriptor.getAllDataFileLocations())
    {
        for(String keyspaceDir : new File(dataDir).list())
        {
            // Only add a ks if it has been specified as a param, assuming params were actually provided.
            if (keyspaceNames.length > 0 && !Arrays.asList(keyspaceNames).contains(keyspaceDir))
                continue;
            keyspaces.add(keyspaceDir);
        }
    }

    for (String keyspace : keyspaces)
        Keyspace.clearSnapshot(tag, keyspace);

    if (logger.isDebugEnabled())
        logger.debug("Cleared out snapshot directories");
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
private static void commitPaxos(Commit proposal, ConsistencyLevel consistencyLevel) throws WriteTimeoutException
{
    Keyspace keyspace = Keyspace.open(proposal.update.metadata().ksName);

    Token tk = StorageService.getPartitioner().getToken(proposal.key);
    List<InetAddress> naturalEndpoints = StorageService.instance.getNaturalEndpoints(keyspace.getName(), tk);
    Collection<InetAddress> pendingEndpoints = StorageService.instance.getTokenMetadata().pendingEndpointsFor(tk, keyspace.getName());

    AbstractReplicationStrategy rs = keyspace.getReplicationStrategy();
    AbstractWriteResponseHandler responseHandler = rs.getWriteResponseHandler(naturalEndpoints, pendingEndpoints, consistencyLevel, null, WriteType.SIMPLE);

    MessageOut<Commit> message = new MessageOut<Commit>(MessagingService.Verb.PAXOS_COMMIT, proposal, Commit.serializer);
    for (InetAddress destination : Iterables.concat(naturalEndpoints, pendingEndpoints))
    {
        if (FailureDetector.instance.isAlive(destination))
            MessagingService.instance().sendRR(message, destination, responseHandler);
    }

    responseHandler.get();
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
/**
 * @return list of Token ranges (_not_ keys!) together with estimated key count,
 *      breaking up the data this node is responsible for into pieces of roughly keysPerSplit
 */
public List<Pair<Range<Token>, Long>> getSplits(String keyspaceName, String cfName, Range<Token> range, int keysPerSplit)
{
    Keyspace t = Keyspace.open(keyspaceName);
    ColumnFamilyStore cfs = t.getColumnFamilyStore(cfName);
    List<DecoratedKey> keys = keySamples(Collections.singleton(cfs), range);

    long totalRowCountEstimate = cfs.estimatedKeysForRange(range);

    // splitCount should be much smaller than number of key samples, to avoid huge sampling error
    int minSamplesPerSplit = 4;
    int maxSplitCount = keys.size() / minSamplesPerSplit + 1;
    int splitCount = Math.max(1, Math.min(maxSplitCount, (int)(totalRowCountEstimate / keysPerSplit)));

    List<Token> tokens = keysToTokens(range, keys);
    return getSplits(tokens, splitCount, cfs);
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
private void complete()
{
    if (!SSTableReader.acquireReferences(sstables))
        throw new AssertionError("We shouldn't fail acquiring a reference on a sstable that has just been transferred");
    try
    {
        Pair<String, String> kscf = Schema.instance.getCF(cfId);
        ColumnFamilyStore cfs = Keyspace.open(kscf.left).getColumnFamilyStore(kscf.right);
        // add sstables and build secondary indexes
        cfs.addSSTables(sstables);
        cfs.indexManager.maybeBuildSecondaryIndexes(sstables, cfs.indexManager.allIndexesNames());
    }
    finally
    {
        SSTableReader.releaseReferences(sstables);
    }

    session.taskCompleted(this);
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
private void testCompaction(String columnFamilyName, int insertsPerTable) throws IOException, ExecutionException, InterruptedException
{
    CompactionManager.instance.disableAutoCompaction();

    Keyspace keyspace = Keyspace.open("Keyspace1");
    ColumnFamilyStore store = keyspace.getColumnFamilyStore(columnFamilyName);

    Set<DecoratedKey> inserted = new HashSet<DecoratedKey>();
    for (int j = 0; j < insertsPerTable; j++) {
        DecoratedKey key = Util.dk(String.valueOf(j));
        RowMutation rm = new RowMutation("Keyspace1", key.key);
        rm.add(columnFamilyName, ByteBufferUtil.bytes("0"), ByteBufferUtil.EMPTY_BYTE_BUFFER, j);
        rm.apply();
        inserted.add(key);
        store.forceBlockingFlush();
        assertEquals(inserted.size(), Util.getRangeSlice(store).size());
    }
    CompactionManager.instance.performMaximal(store);
    assertEquals(1, store.getSSTables().size());
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
@Test
public void testGetNeighborsPlusOneInLocalDC() throws Throwable
{
    TokenMetadata tmd = StorageService.instance.getTokenMetadata();

    // generate rf+1 nodes, and ensure that all nodes are returned
    Set<InetAddress> expected = addTokens(1 + Keyspace.open(KEYSPACE5).getReplicationStrategy().getReplicationFactor());
    expected.remove(FBUtilities.getBroadcastAddress());
    // remove remote endpoints
    TokenMetadata.Topology topology = tmd.cloneOnlyTokenMap().getTopology();
    HashSet<InetAddress> localEndpoints = Sets.newHashSet(topology.getDatacenterEndpoints().get(DatabaseDescriptor.getLocalDataCenter()));
    expected = Sets.intersection(expected, localEndpoints);

    Collection<Range<Token>> ranges = StorageService.instance.getLocalRanges(KEYSPACE5);
    Set<InetAddress> neighbors = new HashSet<>();
    for (Range<Token> range : ranges)
    {
        neighbors.addAll(ActiveRepairService.getNeighbors(KEYSPACE5, ranges, range, Arrays.asList(DatabaseDescriptor.getLocalDataCenter()), null));
    }
    assertEquals(expected, neighbors);
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
public void setup(Class stratClass, Map<String, String> strategyOptions) throws Exception
{
    tmd = new TokenMetadata();
    searchToken = new BigIntegerToken(String.valueOf(15));

    strategy = getStrategyWithNewTokenMetadata(Keyspace.open("Keyspace3").getReplicationStrategy(), tmd);

    tmd.updateNormalToken(new BigIntegerToken(String.valueOf(10)), InetAddress.getByName("127.0.0.1"));
    tmd.updateNormalToken(new BigIntegerToken(String.valueOf(20)), InetAddress.getByName("127.0.0.2"));
    tmd.updateNormalToken(new BigIntegerToken(String.valueOf(30)), InetAddress.getByName("127.0.0.3"));
    tmd.updateNormalToken(new BigIntegerToken(String.valueOf(40)), InetAddress.getByName("127.0.0.4"));
    //tmd.updateNormalToken(new BigIntegerToken(String.valueOf(50)), InetAddress.getByName("127.0.0.5"));
    tmd.updateNormalToken(new BigIntegerToken(String.valueOf(60)), InetAddress.getByName("127.0.0.6"));
    tmd.updateNormalToken(new BigIntegerToken(String.valueOf(70)), InetAddress.getByName("127.0.0.7"));
    tmd.updateNormalToken(new BigIntegerToken(String.valueOf(80)), InetAddress.getByName("127.0.0.8"));
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
@Test
public void testTrackMetadata_rowMarker() throws Throwable
{
    createTable("CREATE TABLE %s (a int, PRIMARY KEY (a))");
    ColumnFamilyStore cfs = Keyspace.open(keyspace()).getColumnFamilyStore(currentTable());
    execute("INSERT INTO %s (a) VALUES (1) USING TIMESTAMP 9999");

    cfs.forceBlockingFlush();
    assertEquals(1, cfs.getLiveSSTables().size());
    StatsMetadata metadata = cfs.getLiveSSTables().iterator().next().getSSTableMetadata();
    assertEquals(9999, metadata.minTimestamp);
    assertEquals(9999, metadata.maxTimestamp);
    assertEquals(Integer.MAX_VALUE, metadata.maxLocalDeletionTime);
    cfs.forceMajorCompaction();
    StatsMetadata metadata2 = cfs.getLiveSSTables().iterator().next().getSSTableMetadata();
    assertEquals(metadata.maxLocalDeletionTime, metadata2.maxLocalDeletionTime);
    assertEquals(metadata.minTimestamp, metadata2.minTimestamp);
    assertEquals(metadata.maxTimestamp, metadata2.maxTimestamp);
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
@Test
public void testGetNeighborsPlusOneInLocalDC() throws Throwable
{
    TokenMetadata tmd = StorageService.instance.getTokenMetadata();
    
    // generate rf+1 nodes, and ensure that all nodes are returned
    Set<InetAddress> expected = addTokens(1 + Keyspace.open(keyspaceName).getReplicationStrategy().getReplicationFactor());
    expected.remove(FBUtilities.getBroadcastAddress());
    // remove remote endpoints
    TokenMetadata.Topology topology = tmd.cloneOnlyTokenMap().getTopology();
    HashSet<InetAddress> localEndpoints = Sets.newHashSet(topology.getDatacenterEndpoints().get(DatabaseDescriptor.getLocalDataCenter()));
    expected = Sets.intersection(expected, localEndpoints);

    Collection<Range<Token>> ranges = StorageService.instance.getLocalRanges(keyspaceName);
    Set<InetAddress> neighbors = new HashSet<InetAddress>();
    for (Range<Token> range : ranges)
    {
        neighbors.addAll(ActiveRepairService.getNeighbors(keyspaceName, range, true));
    }
    assertEquals(expected, neighbors);
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
/**
 * Returns a Pair of all compacting and non-compacting sstables.  Non-compacting sstables will be marked as
 * compacting.
 */
private Pair<List<SSTableReader>, Multimap<DataTracker, SSTableReader>> getCompactingAndNonCompactingSSTables()
{
    List<SSTableReader> allCompacting = new ArrayList<>();
    Multimap<DataTracker, SSTableReader> allNonCompacting = HashMultimap.create();
    for (Keyspace ks : Keyspace.all())
    {
        for (ColumnFamilyStore cfStore: ks.getColumnFamilyStores())
        {
            Set<SSTableReader> nonCompacting, allSSTables;
            do
            {
                allSSTables = cfStore.getDataTracker().getSSTables();
                nonCompacting = Sets.newHashSet(cfStore.getDataTracker().getUncompactingSSTables(allSSTables));
            }
            while (!(nonCompacting.isEmpty() || cfStore.getDataTracker().markCompacting(nonCompacting)));
            allNonCompacting.putAll(cfStore.getDataTracker(), nonCompacting);
            allCompacting.addAll(Sets.difference(allSSTables, nonCompacting));
        }
    }
    return Pair.create(allCompacting, allNonCompacting);
}
 

import org.apache.cassandra.db.Keyspace; //导入依赖的package包/类
public static void handleFSError(FSError e)
{
    JVMStabilityInspector.inspectThrowable(e);
    switch (DatabaseDescriptor.getDiskFailurePolicy())
    {
        case stop_paranoid:
        case stop:
            StorageService.instance.stopTransports();
            break;
        case best_effort:
            // for both read and write errors mark the path as unwritable.
            BlacklistedDirectories.maybeMarkUnwritable(e.path);
            if (e instanceof FSReadError)
            {
                File directory = BlacklistedDirectories.maybeMarkUnreadable(e.path);
                if (directory != null)
                    Keyspace.removeUnreadableSSTables(directory);
            }
            break;
        case ignore:
            // already logged, so left nothing to do
            break;
        default:
            throw new IllegalStateException();
    }
}