public void addBootstrapToken(Token token, InetAddress endpoint) {
assert token != null;
assert endpoint != null;
lock.writeLock().lock();
try {
InetAddress oldEndPoint = null;
oldEndPoint = bootstrapTokens.get(token);
if (oldEndPoint != null && !oldEndPoint.equals(endpoint))
throw new RuntimeException(
"Bootstrap Token collision between "
+ oldEndPoint
+ " and "
+ endpoint
+ " (token "
+ token);
oldEndPoint = tokenToEndPointMap.get(token);
if (oldEndPoint != null && !oldEndPoint.equals(endpoint))
throw new RuntimeException(
"Bootstrap Token collision between "
+ oldEndPoint
+ " and "
+ endpoint
+ " (token "
+ token);
bootstrapTokens.inverse().remove(endpoint);
bootstrapTokens.put(token, endpoint);
} finally {
lock.writeLock().unlock();
}
}
/**
* Store an end-point to host ID mapping. Each ID must be unique, and cannot be changed after the
* fact.
*
* @param hostId
* @param endpoint
*/
public void updateHostId(UUID hostId, InetAddress endpoint) {
assert hostId != null;
assert endpoint != null;
lock.writeLock().lock();
try {
InetAddress storedEp = endpointToHostIdMap.inverse().get(hostId);
if (storedEp != null) {
if (!storedEp.equals(endpoint) && (FailureDetector.instance.isAlive(storedEp))) {
throw new RuntimeException(
String.format(
"Host ID collision between active endpoint %s and %s (id=%s)",
storedEp, endpoint, hostId));
}
}
UUID storedId = endpointToHostIdMap.get(endpoint);
if ((storedId != null) && (!storedId.equals(hostId)))
logger.warn("Changing {}'s host ID from {} to {}", endpoint, storedId, hostId);
endpointToHostIdMap.forcePut(endpoint, hostId);
} finally {
lock.writeLock().unlock();
}
}
public InetAddress getFirstEndpoint() {
assert tokenToEndPointMap.size() > 0;
lock.readLock().lock();
try {
return tokenToEndPointMap.get(sortedTokens.get(0));
} finally {
lock.readLock().unlock();
}
}
public void removeEndpoint(InetAddress endpoint) {
assert endpoint != null;
lock.writeLock().lock();
try {
bootstrapTokens.inverse().remove(endpoint);
tokenToEndPointMap.inverse().remove(endpoint);
leavingEndPoints.remove(endpoint);
sortedTokens = sortTokens();
} finally {
lock.writeLock().unlock();
}
}
public Token getSuccessor(Token token) {
List tokens = sortedTokens();
int index = Collections.binarySearch(tokens, token);
assert index >= 0
: token + " not found in " + StringUtils.join(tokenToEndPointMap.keySet(), ", ");
return (Token) ((index == (tokens.size() - 1)) ? tokens.get(0) : tokens.get(index + 1));
}
public void updateNormalToken(Token token, InetAddress endpoint) {
assert token != null;
assert endpoint != null;
lock.writeLock().lock();
try {
bootstrapTokens.inverse().remove(endpoint);
tokenToEndPointMap.inverse().remove(endpoint);
if (!endpoint.equals(tokenToEndPointMap.put(token, endpoint))) {
sortedTokens = sortTokens();
}
leavingEndPoints.remove(endpoint);
} finally {
lock.writeLock().unlock();
}
}
public Set<InetAddress> getAllEndpoints() {
lock.readLock().lock();
try {
return ImmutableSet.copyOf(endpointToHostIdMap.keySet());
} finally {
lock.readLock().unlock();
}
}
public String toString() {
StringBuilder sb = new StringBuilder();
lock.readLock().lock();
try {
Set<InetAddress> eps = tokenToEndPointMap.inverse().keySet();
if (!eps.isEmpty()) {
sb.append("Normal Tokens:");
sb.append(System.getProperty("line.separator"));
for (InetAddress ep : eps) {
sb.append(ep);
sb.append(":");
sb.append(tokenToEndPointMap.inverse().get(ep));
sb.append(System.getProperty("line.separator"));
}
}
if (!bootstrapTokens.isEmpty()) {
sb.append("Bootstrapping Tokens:");
sb.append(System.getProperty("line.separator"));
for (Map.Entry<Token, InetAddress> entry : bootstrapTokens.entrySet()) {
sb.append(entry.getValue() + ":" + entry.getKey());
sb.append(System.getProperty("line.separator"));
}
}
if (!leavingEndPoints.isEmpty()) {
sb.append("Leaving EndPoints:");
sb.append(System.getProperty("line.separator"));
for (InetAddress ep : leavingEndPoints) {
sb.append(ep);
sb.append(System.getProperty("line.separator"));
}
}
if (!pendingRanges.isEmpty()) {
sb.append("Pending Ranges:");
sb.append(System.getProperty("line.separator"));
sb.append(printPendingRanges());
}
} finally {
lock.readLock().unlock();
}
return sb.toString();
}
/** Return the end-point for a unique host ID */
public InetAddress getEndpointForHostId(UUID hostId) {
lock.readLock().lock();
try {
return endpointToHostIdMap.inverse().get(hostId);
} finally {
lock.readLock().unlock();
}
}
public InetAddress getEndPoint(Token token) {
lock.readLock().lock();
try {
return tokenToEndPointMap.get(token);
} finally {
lock.readLock().unlock();
}
}
/** Return the unique host ID for an end-point. */
public UUID getHostId(InetAddress endpoint) {
lock.readLock().lock();
try {
return endpointToHostIdMap.get(endpoint);
} finally {
lock.readLock().unlock();
}
}
public UUID convertOldCfId(Integer oldCfId) throws UnknownColumnFamilyException {
UUID cfId = oldCfIdMap.get(oldCfId);
if (cfId == null)
throw new UnknownColumnFamilyException(
"ColumnFamily identified by old " + oldCfId + " was not found.", null);
return cfId;
}
public boolean isMember(InetAddress endpoint) {
assert endpoint != null;
lock.readLock().lock();
try {
return tokenToEndPointMap.inverse().containsKey(endpoint);
} finally {
lock.readLock().unlock();
}
}
public void removeBootstrapToken(Token token) {
assert token != null;
lock.writeLock().lock();
try {
bootstrapTokens.remove(token);
} finally {
lock.writeLock().unlock();
}
}
public Token getToken(InetAddress endpoint) {
assert endpoint != null;
assert isMember(endpoint); // don't want to return nulls
lock.readLock().lock();
try {
return tokenToEndPointMap.inverse().get(endpoint);
} finally {
lock.readLock().unlock();
}
}
/** used by tests */
public void clearUnsafe() {
lock.writeLock().lock();
try {
bootstrapTokens.clear();
tokenToEndpointMap.clear();
topology.clear();
leavingEndpoints.clear();
pendingRanges.clear();
endpointToHostIdMap.clear();
invalidateCachedRings();
} finally {
lock.writeLock().unlock();
}
}
public void removeEndpoint(InetAddress endpoint) {
assert endpoint != null;
lock.writeLock().lock();
try {
bootstrapTokens.removeValue(endpoint);
tokenToEndpointMap.removeValue(endpoint);
topology.removeEndpoint(endpoint);
leavingEndpoints.remove(endpoint);
endpointToHostIdMap.remove(endpoint);
sortedTokens = sortTokens();
invalidateCachedRings();
} finally {
lock.writeLock().unlock();
}
}
/** @return the number of nodes bootstrapping into source's primary range */
public int pendingRangeChanges(InetAddress source) {
int n = 0;
Range sourceRange = getPrimaryRangeFor(getToken(source));
for (Token token : bootstrapTokens.keySet()) if (sourceRange.contains(token)) n++;
return n;
}
private List<Token> sortTokens() {
List<Token> tokens = new ArrayList<Token>(tokenToEndPointMap.keySet());
Collections.sort(tokens);
return Collections.unmodifiableList(tokens);
}
/** used by tests */
public void clearUnsafe() {
bootstrapTokens.clear();
tokenToEndPointMap.clear();
leavingEndPoints.clear();
pendingRanges.clear();
}
public void addOldCfIdMapping(Integer oldId, UUID newId) {
if (oldId == null) return;
oldCfIdMap.put(oldId, newId);
}
public Integer convertNewCfId(UUID newCfId) {
return oldCfIdMap.containsValue(newCfId) ? oldCfIdMap.inverse().get(newCfId) : null;
}
