org.apache.cassandra.locator.PendingRangeMaps Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cassandra-all Show documentation
Show all versions of cassandra-all Show documentation
A fork of the Apache Cassandra Project ready to embed Elasticsearch.
/*
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
package org.apache.cassandra.locator;
import com.google.common.collect.Iterators;
import org.apache.cassandra.dht.Range;
import org.apache.cassandra.dht.Token;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.InetAddress;
import java.util.*;
public class PendingRangeMaps implements Iterable, List>>
{
private static final Logger logger = LoggerFactory.getLogger(PendingRangeMaps.class);
/**
* We have for NavigableMap to be able to search for ranges containing a token efficiently.
*
* First two are for non-wrap-around ranges, and the last two are for wrap-around ranges.
*/
// ascendingMap will sort the ranges by the ascending order of right token
final NavigableMap, List> ascendingMap;
/**
* sorting end ascending, if ends are same, sorting begin descending, so that token (end, end) will
* come before (begin, end] with the same end, and (begin, end) will be selected in the tailMap.
*/
static final Comparator> ascendingComparator = new Comparator>()
{
@Override
public int compare(Range o1, Range o2)
{
int res = o1.right.compareTo(o2.right);
if (res != 0)
return res;
return o2.left.compareTo(o1.left);
}
};
// ascendingMap will sort the ranges by the descending order of left token
final NavigableMap, List> descendingMap;
/**
* sorting begin descending, if begins are same, sorting end descending, so that token (begin, begin) will
* come after (begin, end] with the same begin, and (begin, end) won't be selected in the tailMap.
*/
static final Comparator> descendingComparator = new Comparator>()
{
@Override
public int compare(Range o1, Range o2)
{
int res = o2.left.compareTo(o1.left);
if (res != 0)
return res;
// if left tokens are same, sort by the descending of the right tokens.
return o2.right.compareTo(o1.right);
}
};
// these two maps are for warp around ranges.
final NavigableMap, List> ascendingMapForWrapAround;
/**
* for wrap around range (begin, end], which begin > end.
* Sorting end ascending, if ends are same, sorting begin ascending,
* so that token (end, end) will come before (begin, end] with the same end, and (begin, end] will be selected in
* the tailMap.
*/
static final Comparator> ascendingComparatorForWrapAround = new Comparator>()
{
@Override
public int compare(Range o1, Range o2)
{
int res = o1.right.compareTo(o2.right);
if (res != 0)
return res;
return o1.left.compareTo(o2.left);
}
};
final NavigableMap, List> descendingMapForWrapAround;
/**
* for wrap around ranges, which begin > end.
* Sorting end ascending, so that token (begin, begin) will come after (begin, end] with the same begin,
* and (begin, end) won't be selected in the tailMap.
*/
static final Comparator> descendingComparatorForWrapAround = new Comparator>()
{
@Override
public int compare(Range o1, Range o2)
{
int res = o2.left.compareTo(o1.left);
if (res != 0)
return res;
return o1.right.compareTo(o2.right);
}
};
public PendingRangeMaps()
{
this.ascendingMap = new TreeMap, List>(ascendingComparator);
this.descendingMap = new TreeMap, List>(descendingComparator);
this.ascendingMapForWrapAround = new TreeMap, List>(ascendingComparatorForWrapAround);
this.descendingMapForWrapAround = new TreeMap, List>(descendingComparatorForWrapAround);
}
static final void addToMap(Range range,
InetAddress address,
NavigableMap, List> ascendingMap,
NavigableMap, List> descendingMap)
{
List addresses = ascendingMap.get(range);
if (addresses == null)
{
addresses = new ArrayList(1);
ascendingMap.put(range, addresses);
descendingMap.put(range, addresses);
}
addresses.add(address);
}
public void addPendingRange(Range range, InetAddress address)
{
if (Range.isWrapAround(range.left, range.right))
{
addToMap(range, address, ascendingMapForWrapAround, descendingMapForWrapAround);
}
else
{
addToMap(range, address, ascendingMap, descendingMap);
}
}
static final void addIntersections(Set endpointsToAdd,
NavigableMap, List> smallerMap,
NavigableMap, List> biggerMap)
{
// find the intersection of two sets
for (Range range : smallerMap.keySet())
{
List addresses = biggerMap.get(range);
if (addresses != null)
{
endpointsToAdd.addAll(addresses);
}
}
}
public Collection pendingEndpointsFor(Token token)
{
Set endpoints = new HashSet<>();
Range searchRange = new Range(token, token);
// search for non-wrap-around maps
NavigableMap, List> ascendingTailMap = ascendingMap.tailMap(searchRange, true);
NavigableMap, List> descendingTailMap = descendingMap.tailMap(searchRange, false);
// add intersections of two maps
if (ascendingTailMap.size() < descendingTailMap.size())
{
addIntersections(endpoints, ascendingTailMap, descendingTailMap);
}
else
{
addIntersections(endpoints, descendingTailMap, ascendingTailMap);
}
// search for wrap-around sets
ascendingTailMap = ascendingMapForWrapAround.tailMap(searchRange, true);
descendingTailMap = descendingMapForWrapAround.tailMap(searchRange, false);
// add them since they are all necessary.
for (Map.Entry, List> entry : ascendingTailMap.entrySet())
{
endpoints.addAll(entry.getValue());
}
for (Map.Entry, List> entry : descendingTailMap.entrySet())
{
endpoints.addAll(entry.getValue());
}
return endpoints;
}
public String printPendingRanges()
{
StringBuilder sb = new StringBuilder();
for (Map.Entry, List> entry : this)
{
Range range = entry.getKey();
for (InetAddress address : entry.getValue())
{
sb.append(address).append(':').append(range);
sb.append(System.getProperty("line.separator"));
}
}
return sb.toString();
}
@Override
public Iterator, List>> iterator()
{
return Iterators.concat(ascendingMap.entrySet().iterator(), ascendingMapForWrapAround.entrySet().iterator());
}
}