Skip to content
Permalink
Browse files
GEODE-9987: Refactored/Removal of deprecated API (#7303)
* The tests were refactored to remove deprecated functions.
* This was done so that the starting and stopping of members are
handled correctly.
  • Loading branch information
nabarunnag committed May 20, 2022
1 parent fdb972e commit 3ae2218cfa781f671ab4af3c00bbcc0f58a53baf
Showing 1 changed file with 176 additions and 163 deletions.
@@ -14,35 +14,29 @@
*/
package org.apache.geode.distributed;

import static java.util.concurrent.TimeUnit.MINUTES;
import static org.apache.geode.distributed.ConfigurationProperties.LOCATORS;
import static org.apache.geode.internal.AvailablePortHelper.getRandomAvailableTCPPorts;
import static org.apache.geode.test.dunit.Host.getHost;
import static org.assertj.core.api.Assertions.assertThat;

import java.io.File;
import java.io.Serializable;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;

import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.springframework.shell.support.util.FileUtils;

import org.apache.geode.distributed.AbstractLauncher.Status;
import org.apache.geode.distributed.LocatorLauncher.Builder;
import org.apache.geode.distributed.LocatorLauncher.LocatorState;
import org.apache.geode.distributed.internal.ClusterDistributionManager;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
import org.apache.geode.internal.inet.LocalHostUtil;
import org.apache.geode.internal.util.StopWatch;
import org.apache.geode.test.dunit.SerializableCallable;
import org.apache.geode.test.dunit.SerializableRunnable;
import org.apache.geode.test.dunit.internal.JUnit4DistributedTestCase;
import org.apache.geode.test.dunit.rules.ClusterStartupRule;
import org.apache.geode.test.dunit.rules.MemberVM;
import org.apache.geode.test.junit.categories.ClientServerTest;

/**
@@ -51,182 +45,201 @@
* @since GemFire 8.0
*/
@Category({ClientServerTest.class})
public class HostedLocatorsDUnitTest extends JUnit4DistributedTestCase {
@SuppressWarnings("serial")
public class HostedLocatorsDUnitTest implements Serializable {

private static final int TIMEOUT_MILLISECONDS = (int) MINUTES.toMillis(5);

private transient volatile LocatorLauncher launcher;

@Override
public final void postSetUp() throws Exception {
disconnectAllFromDS();
}

@Override
public final void preTearDown() throws Exception {
disconnectAllFromDS();
}

private String getUniqueLocatorName() {
return getHost(0).getHostName() + "_" + getUniqueName();
}
@Rule
public ClusterStartupRule clusterStartupRule = new ClusterStartupRule();

@Test
public void testGetAllHostedLocators() throws Exception {
final InternalDistributedSystem system = getSystem();
final String dunitLocator = system.getConfig().getLocators();
assertThat(dunitLocator).isNotEmpty();

final int[] ports = getRandomAvailableTCPPorts(4);
public void testGetAllHostedLocators() {
// Get the localhost IP address
String ipAddress = getIPAddress().getHostAddress();

final String uniqueName = getUniqueLocatorName();
for (int whichVm = 0; whichVm < 4; whichVm++) {
getHost(0).getVM(whichVm)
.invoke(new LocatorStarter(uniqueName, whichVm, ports, dunitLocator));
}
// Collection of expected locator addresses.
final Set<String> locators = new HashSet<>();
// Starting 4 locators
MemberVM locator1 = clusterStartupRule.startLocatorVM(0);
int locator1Port = locator1.getPort();
locators.add(ipAddress + "[" + locator1Port + "]");

MemberVM locator2 =
clusterStartupRule.startLocatorVM(1, l -> l.withConnectionToLocator(locator1Port));
int locator2Port = locator2.getPort();
locators.add(ipAddress + "[" + locator2Port + "]");

MemberVM locator3 =
clusterStartupRule.startLocatorVM(2,
l -> l.withConnectionToLocator(locator1Port, locator2Port));
int locator3Port = locator3.getPort();
locators.add(ipAddress + "[" + locator3Port + "]");

MemberVM locator4 =
clusterStartupRule.startLocatorVM(3,
l -> l.withConnectionToLocator(locator1Port, locator2Port, locator3Port));
int locator4Port = locator4.getPort();
locators.add(ipAddress + "[" + locator4Port + "]");

MemberVM server1 =
clusterStartupRule.startServerVM(4,
s -> s.withConnectionToLocator(locator1Port, locator2Port, locator3Port, locator4Port));
// validation within non-locator
server1.invoke(() -> validateLocators(locators));

validateLocators(dunitLocator, ports, system);
// validations within the locators
locator1.invoke(() -> validateHostedLocators(locators));
locator2.invoke(() -> validateHostedLocators(locators));
locator3.invoke(() -> validateHostedLocators(locators));
locator4.invoke(() -> validateHostedLocators(locators));
}

@Test
public void testGetAllHostedLocatorsUsingPortZero() throws Exception {
final InternalDistributedSystem system = getSystem();
final String dunitLocator = system.getConfig().getLocators();
assertThat(dunitLocator).isNotEmpty();

// This will eventually contain the ports used by locators
final int[] ports = new int[] {0, 0, 0, 0};

final String uniqueName = getUniqueLocatorName();
for (int whichVm = 0; whichVm < 4; whichVm++) {
ports[whichVm] = (Integer) getHost(0).getVM(whichVm).invoke(
new LocatorStarter(uniqueName, whichVm, ports, dunitLocator));
}

validateLocators(dunitLocator, ports, system);
}

private void validateLocators(final String dunitLocator, final int[] ports,
final InternalDistributedSystem system) throws UnknownHostException {
final String host = LocalHostUtil.getLocalHost().getHostAddress();
public void testGetAllHostedLocatorsWhenLocatorIsStartedWithPortZero() {
// Get the localhost IP address
String ipAddress = getIPAddress().getHostAddress();

// Collection of expected locator addresses.
final Set<String> locators = new HashSet<>();
locators.add(host + "["
+ dunitLocator.substring(dunitLocator.indexOf("[") + 1, dunitLocator.indexOf("]")) + "]");
for (int port : ports) {
locators.add(host + "[" + port + "]");
}

// Starting 4 locators
MemberVM locator1 = clusterStartupRule.startLocatorVM(0, l -> l.withPort(0));
int locator1Port = locator1.getPort();
locators.add(ipAddress + "[" + locator1Port + "]");

MemberVM locator2 =
clusterStartupRule.startLocatorVM(1,
l -> l.withConnectionToLocator(locator1Port).withPort(0));
int locator2Port = locator2.getPort();
locators.add(ipAddress + "[" + locator2Port + "]");

MemberVM locator3 =
clusterStartupRule.startLocatorVM(2,
l -> l.withConnectionToLocator(locator1Port, locator2Port).withPort(0));
int locator3Port = locator3.getPort();
locators.add(ipAddress + "[" + locator3Port + "]");

MemberVM locator4 =
clusterStartupRule.startLocatorVM(3,
l -> l.withConnectionToLocator(locator1Port, locator2Port, locator3Port).withPort(0));
int locator4Port = locator4.getPort();
locators.add(ipAddress + "[" + locator4Port + "]");

MemberVM server1 =
clusterStartupRule.startServerVM(4,
s -> s.withConnectionToLocator(locator1Port, locator2Port, locator3Port, locator4Port));
// validation within non-locator
final ClusterDistributionManager dm =
(ClusterDistributionManager) system.getDistributionManager();

validateWithLocators(dm, locators);

for (int whichVm = 0; whichVm < 4; whichVm++) {
getHost(0).getVM(whichVm).invoke(new SerializableRunnable() {
@Override
public void run() {
final ClusterDistributionManager dm =
(ClusterDistributionManager) InternalDistributedSystem.getAnyInstance()
.getDistributionManager();
final InternalDistributedMember self = dm.getDistributionManagerId();

final Set<InternalDistributedMember> locatorIds = dm.getLocatorDistributionManagerIds();
assertThat(locatorIds).contains(self);

final Map<InternalDistributedMember, Collection<String>> hostedLocators =
dm.getAllHostedLocators();
assertThat(hostedLocators).containsKey(self);
}
});
}
server1.invoke(() -> validateLocators(locators));

for (int whichVm = 0; whichVm < 4; whichVm++) {
getHost(0).getVM(whichVm).invoke(new SerializableRunnable() {
@Override
public void run() {
final ClusterDistributionManager dm1 =
(ClusterDistributionManager) InternalDistributedSystem.getAnyInstance()
.getDistributionManager();

validateWithLocators(dm1, locators);
}
});
}
// validations within the locators
locator1.invoke(() -> validateHostedLocators(locators));
locator2.invoke(() -> validateHostedLocators(locators));
locator3.invoke(() -> validateHostedLocators(locators));
locator4.invoke(() -> validateHostedLocators(locators));
}

private void validateWithLocators(final ClusterDistributionManager dm,
final Set<String> locators) {
private void validateLocators(Set<String> locators) {
ClusterDistributionManager dm =
(ClusterDistributionManager) ClusterStartupRule.getCache().getDistributionManager();
final Set<InternalDistributedMember> locatorIds = dm.getLocatorDistributionManagerIds();
assertThat(locatorIds).hasSize(5);

assertThat(locatorIds.size()).isEqualTo(4);
final Map<InternalDistributedMember, Collection<String>> hostedLocators =
dm.getAllHostedLocators();
assertThat(hostedLocators).hasSize(5);

assertThat(hostedLocators).isNotEmpty();
assertThat(hostedLocators.size()).isEqualTo(4);
for (InternalDistributedMember member : hostedLocators.keySet()) {
final Collection<String> hostedLocator = hostedLocators.get(member);
assertThat(hostedLocator).hasSize(1);
assertThat(locators).containsAll(hostedLocator);
assertThat(hostedLocators.get(member).size()).isEqualTo(1);
final String hostedLocator = hostedLocators.get(member).iterator().next();
assertThat(locators).contains(hostedLocator);
}
}

private void waitForLocatorToStart(final LocatorLauncher launcher, int timeout, int interval)
throws Exception {
assertEventuallyTrue("waiting for process to start: " + launcher.status(),
() -> {
try {
final LocatorState LocatorState = launcher.status();
return (LocatorState != null && Status.ONLINE.equals(LocatorState.getStatus()));
} catch (RuntimeException e) {
return false;
}
}, timeout, interval);
private void validateHostedLocators(Set<String> locators) {
ClusterDistributionManager dm =
(ClusterDistributionManager) ClusterStartupRule.getCache().getDistributionManager();
final InternalDistributedMember self = dm.getDistributionManagerId();
final Set<InternalDistributedMember> locatorIDs = dm.getLocatorDistributionManagerIds();
assertThat(locatorIDs.size()).isEqualTo(4);
assertThat(locatorIDs).contains(self);
final Map<InternalDistributedMember, Collection<String>> hostedLocators =
dm.getAllHostedLocators();
assertThat(hostedLocators).isNotEmpty();
assertThat(hostedLocators.size()).isEqualTo(4);
assertThat(hostedLocators).containsKey(self);
for (InternalDistributedMember member : hostedLocators.keySet()) {
assertThat(hostedLocators.get(member).size()).isEqualTo(1);
final String hostedLocator = hostedLocators.get(member).iterator().next();
assertThat(locators).contains(hostedLocator);
}
}

private static void assertEventuallyTrue(final String message, final Callable<Boolean> callable,
final int timeout, final int interval) throws Exception {
boolean done = false;
for (StopWatch time = new StopWatch(true); !done && time.elapsedTimeMillis() < timeout; done =
(callable.call())) {
Thread.sleep(interval);
}
assertThat(done).as(message).isTrue();
private static InetAddress getIPAddress() {
return Boolean.getBoolean("java.net.preferIPv6Addresses") ? getIPv6Address() : getIPv4Address();
}

private class LocatorStarter extends SerializableCallable<Object> {
private final String uniqueName;
private final int whichVm;
private final int[] ports;
private final String dunitLocator;

public LocatorStarter(final String uniqueName, final int whichVm, final int[] ports,
final String dunitLocator) {
this.uniqueName = uniqueName;
this.whichVm = whichVm;
this.ports = ports;
this.dunitLocator = dunitLocator;
private static InetAddress getIPv4Address() {
InetAddress host;
try {
host = InetAddress.getLocalHost();
if (host instanceof Inet4Address && !host.isLinkLocalAddress() && !host.isLoopbackAddress()) {
return host;
}
} catch (UnknownHostException e) {
String s = "Local host not found";
throw new RuntimeException(s, e);
}

@Override
public Object call() throws Exception {
final String name = uniqueName + "-" + whichVm;
final File directory = new File(name);
if (directory.exists()) {
FileUtils.deleteRecursively(directory);
try {
Enumeration<NetworkInterface> i = NetworkInterface.getNetworkInterfaces();
while (i.hasMoreElements()) {
NetworkInterface ni = i.nextElement();
Enumeration<InetAddress> j = ni.getInetAddresses();
while (j.hasMoreElements()) {
InetAddress inetAddress = j.nextElement();
// gemfire won't form connections using link-local addresses
if (!inetAddress.isLinkLocalAddress() && !inetAddress.isLoopbackAddress()
&& (inetAddress instanceof Inet4Address)) {
return inetAddress;
}
}
}
directory.mkdir();
assertThat(directory).exists().isDirectory();

final Builder builder = new Builder().setMemberName(name).setPort(ports[whichVm])
.set(LOCATORS, dunitLocator)
.setRedirectOutput(true).setWorkingDirectory(name);
String s = "IPv4 address not found";
throw new RuntimeException(s);
} catch (SocketException e) {
String s = "Problem reading IPv4 address";
throw new RuntimeException(s, e);
}
}

launcher = builder.build();
assertThat(launcher.start().getStatus()).isSameAs(Status.ONLINE);
waitForLocatorToStart(launcher, TIMEOUT_MILLISECONDS, 10);
return launcher.getPort();
private static InetAddress getIPv6Address() {
try {
Enumeration<NetworkInterface> i = NetworkInterface.getNetworkInterfaces();
while (i.hasMoreElements()) {
NetworkInterface ni = i.nextElement();
Enumeration<InetAddress> j = ni.getInetAddresses();
while (j.hasMoreElements()) {
InetAddress inetAddress = j.nextElement();
// gemfire won't form connections using link-local addresses
if (!inetAddress.isLinkLocalAddress() && !inetAddress.isLoopbackAddress()
&& (inetAddress instanceof Inet6Address)
&& !isIPv6LinkLocalAddress((Inet6Address) inetAddress)) {
return inetAddress;
}
}
}
String s = "IPv6 address not found";
throw new RuntimeException(s);
} catch (SocketException e) {
String s = "Problem reading IPv6 address";
throw new RuntimeException(s, e);
}
}

/**
* Detect LinkLocal IPv6 address where the interface is missing, ie %[0-9].
*
* @see InetAddress#isLinkLocalAddress()
*/
private static boolean isIPv6LinkLocalAddress(Inet6Address inet6Address) {
byte[] addressBytes = inet6Address.getAddress();
return ((addressBytes[0] == (byte) 0xfe) && (addressBytes[1] == (byte) 0x80));
}
}

0 comments on commit 3ae2218

Please sign in to comment.