import org.apache.cassandra.dht.RingPosition; //导入依赖的package包/类
/**
 * get the (possibly cached) endpoints that should store the given Token.
 * Note that while the endpoints are conceptually a Set (no duplicates will be included),
 * we return a List to avoid an extra allocation when sorting by proximity later
 * @param searchPosition the position the natural endpoints are requested for
 * @return a copy of the natural endpoints for the given token
 */
public ArrayList<InetAddress> getNaturalEndpoints(RingPosition searchPosition)
{
    Token searchToken = searchPosition.getToken();
    Token keyToken = TokenMetadata.firstToken(tokenMetadata.sortedTokens(), searchToken);
    ArrayList<InetAddress> endpoints = getCachedEndpoints(keyToken);
    if (endpoints == null)
    {
        TokenMetadata tm = tokenMetadata.cachedOnlyTokenMap();
        // if our cache got invalidated, it's possible there is a new token to account for too
        keyToken = TokenMetadata.firstToken(tm.sortedTokens(), searchToken);
        endpoints = new ArrayList<InetAddress>(calculateNaturalEndpoints(searchToken, tm));
        cachedEndpoints.put(keyToken, endpoints);
    }

    return new ArrayList<InetAddress>(endpoints);
}
 

import org.apache.cassandra.dht.RingPosition; //导入依赖的package包/类
/**
 * get the (possibly cached) endpoints that should store the given Token.
 * Note that while the endpoints are conceptually a Set (no duplicates will be included),
 * we return a List to avoid an extra allocation when sorting by proximity later
 * @param searchPosition the position the natural endpoints are requested for
 * @return a copy of the natural endpoints for the given token
 */
public ArrayList<InetAddress> getNaturalEndpoints(RingPosition searchPosition)
{
    Token searchToken = searchPosition.getToken();
    Token keyToken = TokenMetadata.firstToken(tokenMetadata.sortedTokens(), searchToken);
    ArrayList<InetAddress> endpoints = getCachedEndpoints(keyToken);
    if (endpoints == null)
    {
        TokenMetadata tokenMetadataClone = tokenMetadata.cloneOnlyTokenMap();
        keyToken = TokenMetadata.firstToken(tokenMetadataClone.sortedTokens(), searchToken);
        endpoints = new ArrayList<InetAddress>(calculateNaturalEndpoints(searchToken, tokenMetadataClone));
        cacheEndpoint(keyToken, endpoints);
    }

    return new ArrayList<InetAddress>(endpoints);
}
 

import org.apache.cassandra.dht.RingPosition; //导入依赖的package包/类
/**
 * We need to override this even if we override calculateNaturalEndpoints,
 * because the default implementation depends on token calculations but
 * LocalStrategy may be used before tokens are set up.
 */
@Override
public ArrayList<InetAddress> getNaturalEndpoints(RingPosition searchPosition)
{
    ArrayList<InetAddress> l = new ArrayList<InetAddress>(1);
    l.add(FBUtilities.getBroadcastAddress());
    return l;
}
 

import org.apache.cassandra.dht.RingPosition; //导入依赖的package包/类
public List<InetAddress> getLiveNaturalEndpoints(Keyspace keyspace, RingPosition pos)
{
    List<InetAddress> endpoints = keyspace.getReplicationStrategy().getNaturalEndpoints(pos);
    List<InetAddress> liveEps = new ArrayList<>(endpoints.size());

    for (InetAddress endpoint : endpoints)
    {
        if (FailureDetector.instance.isAlive(endpoint))
            liveEps.add(endpoint);
    }

    return liveEps;
}
 

import org.apache.cassandra.dht.RingPosition; //导入依赖的package包/类
private static List<InetAddress> getLiveSortedEndpoints(Keyspace keyspace, RingPosition pos)
{
    List<InetAddress> liveEndpoints = StorageService.instance.getLiveNaturalEndpoints(keyspace, pos);
    DatabaseDescriptor.getEndpointSnitch().sortByProximity(FBUtilities.getBroadcastAddress(), liveEndpoints);
    return liveEndpoints;
}
 

import org.apache.cassandra.dht.RingPosition; //导入依赖的package包/类
/**
 * Compute all ranges we're going to query, in sorted order. Nodes can be replica destinations for many ranges,
 * so we need to restrict each scan to the specific range we want, or else we'd get duplicate results.
 */
static <T extends RingPosition<T>> List<AbstractBounds<T>> getRestrictedRanges(final AbstractBounds<T> queryRange)
{
    // special case for bounds containing exactly 1 (non-minimum) token
    if (queryRange instanceof Bounds && queryRange.left.equals(queryRange.right) && !queryRange.left.isMinimum(StorageService.getPartitioner()))
    {
        return Collections.singletonList(queryRange);
    }

    TokenMetadata tokenMetadata = StorageService.instance.getTokenMetadata();

    List<AbstractBounds<T>> ranges = new ArrayList<AbstractBounds<T>>();
    // divide the queryRange into pieces delimited by the ring and minimum tokens
    Iterator<Token> ringIter = TokenMetadata.ringIterator(tokenMetadata.sortedTokens(), queryRange.left.getToken(), true);
    AbstractBounds<T> remainder = queryRange;
    while (ringIter.hasNext())
    {
        /*
         * remainder can be a range/bounds of token _or_ keys and we want to split it with a token:
         *   - if remainder is tokens, then we'll just split using the provided token.
         *   - if remainder is keys, we want to split using token.upperBoundKey. For instance, if remainder
         *     is [DK(10, 'foo'), DK(20, 'bar')], and we have 3 nodes with tokens 0, 15, 30. We want to
         *     split remainder to A=[DK(10, 'foo'), 15] and B=(15, DK(20, 'bar')]. But since we can't mix
         *     tokens and keys at the same time in a range, we uses 15.upperBoundKey() to have A include all
         *     keys having 15 as token and B include none of those (since that is what our node owns).
         * asSplitValue() abstracts that choice.
         */
        Token upperBoundToken = ringIter.next();
        T upperBound = (T)upperBoundToken.upperBound(queryRange.left.getClass());
        if (!remainder.left.equals(upperBound) && !remainder.contains(upperBound))
            // no more splits
            break;
        Pair<AbstractBounds<T>,AbstractBounds<T>> splits = remainder.split(upperBound);
        if (splits == null)
            continue;

        ranges.add(splits.left);
        remainder = splits.right;
    }
    ranges.add(remainder);

    return ranges;
}
 

import org.apache.cassandra.dht.RingPosition; //导入依赖的package包/类
/**
 * Compute all ranges we're going to query, in sorted order. Nodes can be replica destinations for many ranges,
 * so we need to restrict each scan to the specific range we want, or else we'd get duplicate results.
 */
static <T extends RingPosition> List<AbstractBounds<T>> getRestrictedRanges(final AbstractBounds<T> queryRange)
{
    // special case for bounds containing exactly 1 (non-minimum) token
    if (queryRange instanceof Bounds && queryRange.left.equals(queryRange.right) && !queryRange.left.isMinimum(StorageService.getPartitioner()))
    {
        return Collections.singletonList(queryRange);
    }

    TokenMetadata tokenMetadata = StorageService.instance.getTokenMetadata();

    List<AbstractBounds<T>> ranges = new ArrayList<AbstractBounds<T>>();
    // divide the queryRange into pieces delimited by the ring and minimum tokens
    Iterator<Token> ringIter = TokenMetadata.ringIterator(tokenMetadata.sortedTokens(), queryRange.left.getToken(), true);
    AbstractBounds<T> remainder = queryRange;
    while (ringIter.hasNext())
    {
        /*
         * remainder can be a range/bounds of token _or_ keys and we want to split it with a token:
         *   - if remainder is tokens, then we'll just split using the provided token.
         *   - if remainder is keys, we want to split using token.upperBoundKey. For instance, if remainder
         *     is [DK(10, 'foo'), DK(20, 'bar')], and we have 3 nodes with tokens 0, 15, 30. We want to
         *     split remainder to A=[DK(10, 'foo'), 15] and B=(15, DK(20, 'bar')]. But since we can't mix
         *     tokens and keys at the same time in a range, we uses 15.upperBoundKey() to have A include all
         *     keys having 15 as token and B include none of those (since that is what our node owns).
         * asSplitValue() abstracts that choice.
         */
        Token upperBoundToken = ringIter.next();
        T upperBound = (T)upperBoundToken.upperBound(queryRange.left.getClass());
        if (!remainder.left.equals(upperBound) && !remainder.contains(upperBound))
            // no more splits
            break;
        Pair<AbstractBounds<T>,AbstractBounds<T>> splits = remainder.split(upperBound);
        if (splits == null)
            continue;

        ranges.add(splits.left);
        remainder = splits.right;
    }
    ranges.add(remainder);

    return ranges;
}
 

import org.apache.cassandra.dht.RingPosition; //导入依赖的package包/类
private static List<InetAddress> getLiveSortedEndpoints(Table table, RingPosition pos)
{
    List<InetAddress> liveEndpoints = StorageService.instance.getLiveNaturalEndpoints(table, pos);
    DatabaseDescriptor.getEndpointSnitch().sortByProximity(FBUtilities.getBroadcastAddress(), liveEndpoints);
    return liveEndpoints;
}