@Test public void testReResolvingLocalhost() { byte size = 2; ArrayList<InetSocketAddress> list = new ArrayList<InetSocketAddress>(size); // Test a hostname that resolves to multiple addresses list.add(InetSocketAddress.createUnresolved("localhost", 1234)); list.add(InetSocketAddress.createUnresolved("localhost", 1235)); StaticHostProvider hostProvider = new StaticHostProvider(list); int sizeBefore = hostProvider.size(); InetSocketAddress next = hostProvider.next(0); next = hostProvider.next(0); assertTrue("Different number of addresses in the list: " + hostProvider.size() + " (after), " + sizeBefore + " (before)", hostProvider.size() == sizeBefore); }
public synchronized InetSocketAddress getServerAtCurrentIndex() { return getServerAtIndex(currentIndex); }
/** * Constructs a SimpleHostSet. This constructor is used from StaticHostProviderTest to produce deterministic test results * by initializing sourceOfRandomness with the same seed * * @param serverAddresses * possibly unresolved ZooKeeper server addresses * @param randomnessSeed a seed used to initialize sourceOfRandomnes * @throws IllegalArgumentException * if serverAddresses is empty or resolves to an empty list */ public StaticHostProvider(Collection<InetSocketAddress> serverAddresses, long randomnessSeed) { init(serverAddresses, randomnessSeed, new Resolver() { @Override public InetAddress[] getAllByName(String name) throws UnknownHostException { return InetAddress.getAllByName(name); } }); }
addr = nextHostInReconfigMode(); if (addr != null) { currentIndex = serverAddresses.indexOf(addr); return resolve(addr); return resolve(addr);
@Test(expected = IllegalArgumentException.class) public void testEmptyServerAddressesList() { HostProvider hp = new StaticHostProvider(new ArrayList<>()); }
StaticHostProvider hostProvider = new StaticHostProvider(list, spyResolver); InetSocketAddress resolvedFirst = hostProvider.next(0); assertFalse("HostProvider should return resolved addresses", resolvedFirst.isUnresolved()); assertThat("Bad IP address returned", ipList, hasItems(resolvedFirst.getAddress().getHostAddress())); hostProvider.onConnected(); // first address worked InetSocketAddress resolvedSecond = hostProvider.next(0); assertFalse("HostProvider should return resolved addresses", resolvedSecond.isUnresolved()); assertThat("Bad IP address returned", ipList, hasItems(resolvedSecond.getAddress().getHostAddress())); InetSocketAddress resolvedThird = hostProvider.next(0); assertFalse("HostProvider should return resolved addresses", resolvedThird.isUnresolved()); assertThat("Bad IP address returned", ipList, hasItems(resolvedThird.getAddress().getHostAddress()));
@Test public void testInvalidHostAddresses() { // Arrange final List<InetSocketAddress> invalidAddresses = new ArrayList<>(); InetSocketAddress unresolved = InetSocketAddress.createUnresolved("a", 1234); invalidAddresses.add(unresolved); StaticHostProvider.Resolver resolver = new StaticHostProvider.Resolver() { @Override public InetAddress[] getAllByName(String name) throws UnknownHostException { throw new UnknownHostException(); } }; StaticHostProvider sp = new StaticHostProvider(invalidAddresses, resolver); // Act & Assert InetSocketAddress n1 = sp.next(0); assertTrue("Provider should return unresolved address is host is unresolvable", n1.isUnresolved()); assertSame("Provider should return original address is host is unresolvable", unresolved, n1); }
curHostForEachClient[i] = hostProviderArray[i].next(0); hostProviderArray[i].updateServerList(newList, curHostForEachClient[i]); disconnectRequired = hostProviderArray[i].updateServerList(newList, myServer); if (disconnectRequired) curHostForEachClient[i] = hostProviderArray[i].next(0); else { .getServerAtCurrentIndex(); hostProviderArray[i].onConnected();
hostProviderArray[i] = getHostProvider((byte) 9); if (i >= (numClients / 2)) { curHostForEachClient[i] = hostProviderArray[i].next(0); } else { disconnectRequired = hostProviderArray[i].updateServerList(newList, curHostForEachClient[i]); if (disconnectRequired) curHostForEachClient[i] = hostProviderArray[i].next(0); else if (curHostForEachClient[i] == null) { .getServerAtIndex(0); hostProviderArray[i].onConnected(); : curHostForEachClient[i]; disconnectRequired = hostProviderArray[i].updateServerList(newList, myServer); if (disconnectRequired) curHostForEachClient[i] = hostProviderArray[i].next(0); numClientsPerHost[curHostForEachClient[i].getPort() - 1235]++; hostProviderArray[i].onConnected();
Collection<InetSocketAddress> serverAddresses, InetSocketAddress currentHost) { List<InetSocketAddress> shuffledList = shuffle(serverAddresses); if (shuffledList.isEmpty()) { throw new IllegalArgumentException( myServer = next(0); currentIndex = shuffledList.indexOf(getServerAtCurrentIndex()); } else { currentIndex = -1;
public InetSocketAddress next(long spinDelay) { currentIndex = ++currentIndex % serverAddresses.size(); if (currentIndex == lastIndex && spinDelay > 0) { try { Thread.sleep(spinDelay); } catch (InterruptedException e) { LOG.warn("Unexpected exception", e); } } else if (lastIndex == -1) { // We don't want to sleep on the first ever connect attempt. lastIndex = 0; } InetSocketAddress curAddr = serverAddresses.get(currentIndex); try { String curHostString = getHostString(curAddr); List<InetAddress> resolvedAddresses = new ArrayList<InetAddress>(Arrays.asList(this.resolver.getAllByName(curHostString))); if (resolvedAddresses.isEmpty()) { return curAddr; } Collections.shuffle(resolvedAddresses); return new InetSocketAddress(resolvedAddresses.get(0), curAddr.getPort()); } catch (UnknownHostException e) { return curAddr; } }
private StaticHostProvider getHostProvider(byte size) { return new StaticHostProvider(getServerAddresses(size), r.nextLong()); }
StaticHostProvider hostProvider = new StaticHostProvider(list, spyResolver); InetSocketAddress resolved = hostProvider.next(0); hostProvider.onConnected(); if (resolved.getHostName().equals("www.google.com")) { assertTrue("HostProvider should return unresolved address if host is unresolvable", resolved.isUnresolved());
@Test public void testReResolvingSingle() throws UnknownHostException { // Arrange byte size = 1; ArrayList<InetSocketAddress> list = new ArrayList<InetSocketAddress>(size); // Test a hostname that resolves to a single address list.add(InetSocketAddress.createUnresolved("issues.apache.org", 1234)); final InetAddress issuesApacheOrg = mock(InetAddress.class); when(issuesApacheOrg.getHostAddress()).thenReturn("192.168.1.1"); when(issuesApacheOrg.toString()).thenReturn("issues.apache.org"); when(issuesApacheOrg.getHostName()).thenReturn("issues.apache.org"); StaticHostProvider.Resolver resolver = new StaticHostProvider.Resolver() { @Override public InetAddress[] getAllByName(String name) { return new InetAddress[] { issuesApacheOrg }; } }; StaticHostProvider.Resolver spyResolver = spy(resolver); // Act StaticHostProvider hostProvider = new StaticHostProvider(list, spyResolver); for (int i = 0; i < 10; i++) { InetSocketAddress next = hostProvider.next(0); assertEquals(issuesApacheOrg, next.getAddress()); } // Assert // Resolver called 10 times, because we shouldn't cache the resolved addresses verify(spyResolver, times(10)).getAllByName("issues.apache.org"); // resolution occurred }
private StaticHostProvider getHostProviderWithUnresolvedHostnames(int size) { return new StaticHostProvider(getUnresolvedHostnames(size), r.nextLong()); }
StaticHostProvider hostProvider = new StaticHostProvider(list, spyResolver); assertEquals(1, hostProvider.size()); // single address not extracted InetSocketAddress next = hostProvider.next(0); assertThat("Bad IP address returned", next.getAddress().getHostAddress(), anyOf(equalTo(apacheOrg1.getHostAddress()), equalTo(apacheOrg2.getHostAddress()))); assertEquals(1, hostProvider.size()); // resolve() call keeps the size of provider
/** * Introduced for testing purposes. getAllByName() is a static method of InetAddress, therefore cannot be easily mocked. * By abstraction of Resolver interface we can easily inject a mocked implementation in tests. * * @param serverAddresses * possibly unresolved ZooKeeper server addresses * @param resolver * custom resolver implementation * @throws IllegalArgumentException * if serverAddresses is empty or resolves to an empty list */ public StaticHostProvider(Collection<InetSocketAddress> serverAddresses, Resolver resolver) { this.resolver = resolver; init(serverAddresses); }
private StaticHostProvider getHostProviderUnresolved(byte size) { return new StaticHostProvider(getUnresolvedServerAddresses(size), r.nextLong()); }
/** * Constructs a SimpleHostSet. * * @param serverAddresses * possibly unresolved ZooKeeper server addresses * @throws IllegalArgumentException * if serverAddresses is empty or resolves to an empty list */ public StaticHostProvider(Collection<InetSocketAddress> serverAddresses) { this.resolver = new Resolver() { @Override public InetAddress[] getAllByName(String name) throws UnknownHostException { return InetAddress.getAllByName(name); } }; init(serverAddresses); }
private static HostProvider createDefaultHostProvider(String connectString) { return new StaticHostProvider( new ConnectStringParser(connectString).getServerAddresses()); }