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 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();
}
}
/**
* 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 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();
}
}
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 boolean isMember(InetAddress endpoint) {
assert endpoint != null;
lock.readLock().lock();
try {
return tokenToEndPointMap.inverse().containsKey(endpoint);
} finally {
lock.readLock().unlock();
}
}
@Test
public void whenCreateBiMap_thenCreated() {
final BiMap<String, Integer> words = HashBiMap.create();
words.put("First", 1);
words.put("Second", 2);
words.put("Third", 3);
assertEquals(2, words.get("Second").intValue());
assertEquals("Third", words.inverse().get(3));
}
public void testConstrainedBiMapIllegal() {
BiMap<String, Integer> map =
new AbstractBiMap<String, Integer>(
Maps.<String, Integer>newLinkedHashMap(), Maps.<Integer, String>newLinkedHashMap()) {};
BiMap<String, Integer> constrained = MapConstraints.constrainedBiMap(map, TEST_CONSTRAINT);
try {
constrained.put(TEST_KEY, TEST_VALUE);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.put("baz", TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.put(TEST_KEY, 3);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.putAll(ImmutableMap.of("baz", 3, TEST_KEY, 4));
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.forcePut(TEST_KEY, 3);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.inverse().forcePut(TEST_VALUE, "baz");
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.inverse().forcePut(3, TEST_KEY);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
assertEquals(Collections.emptySet(), map.entrySet());
assertEquals(Collections.emptySet(), constrained.entrySet());
}
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();
}
}
@Override
protected void assertMoreInvariants(Map<String, Integer> map) {
BiMap<String, Integer> bimap = (BiMap<String, Integer>) map;
BiMap<Integer, String> inverse = bimap.inverse();
assertEquals(bimap.size(), inverse.size());
for (Entry<String, Integer> entry : bimap.entrySet()) {
assertEquals(entry.getKey(), inverse.get(entry.getValue()));
}
for (Entry<Integer, String> entry : inverse.entrySet()) {
assertEquals(entry.getKey(), bimap.get(entry.getValue()));
}
}
@Override
protected void assertMoreInvariants(Map<K, V> map) {
BiMap<K, V> bimap = (BiMap<K, V>) map;
for (Entry<K, V> entry : map.entrySet()) {
assertEquals(entry.getKey() + "=" + entry.getValue(), entry.toString());
assertEquals(entry.getKey(), bimap.inverse().get(entry.getValue()));
}
assertEquals("{" + joiner.join(map.entrySet()) + "}", map.toString());
assertEquals("[" + joiner.join(map.entrySet()) + "]", map.entrySet().toString());
assertEquals("[" + joiner.join(map.keySet()) + "]", map.keySet().toString());
assertEquals("[" + joiner.join(map.values()) + "]", map.values().toString());
assertEquals(Sets.newHashSet(map.entrySet()), map.entrySet());
assertEquals(Sets.newHashSet(map.keySet()), map.keySet());
}
public Integer convertNewCfId(UUID newCfId) {
return oldCfIdMap.containsValue(newCfId) ? oldCfIdMap.inverse().get(newCfId) : null;
}
