From d563062747618ae68644c8984ed43f6447c5e685 Mon Sep 17 00:00:00 2001 From: David Hoover Date: Mon, 20 Apr 2015 13:28:54 -0700 Subject: [PATCH 1/2] [FIXED JENKINS-28245] Allow finer-grained tuning of ChannelPinger. * Allows customization in seconds, not minutes * Allows customization of the ping timeout (before, you could set a custom interval, but the timeout would always be PingThread's 4 minute default) This also drops the serialVersionUID from ChannelPinger.SetUpRemotePing; without one provided, the JVM will generate one on demand which is sufficient for the purposes here since these are never persisted and master & slave run the same compiled code. (And it demonstrably works since countless other MasterToSlaveCallables fail to specify their own custom IDs) --- core/pom.xml | 13 +- .../java/hudson/slaves/ChannelPinger.java | 104 ++++++++++++---- .../java/hudson/slaves/ChannelPingerTest.java | 117 ++++++++++++++++++ pom.xml | 8 +- 4 files changed, 212 insertions(+), 30 deletions(-) create mode 100644 core/src/test/java/hudson/slaves/ChannelPingerTest.java diff --git a/core/pom.xml b/core/pom.xml index 54c75ac4de..405941a161 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -606,10 +606,15 @@ THE SOFTWARE. /usr/local/yjp/lib/yjp.jar - - com.google.guava - guava - + + com.google.guava + guava + + + com.google.guava + guava-testlib + test + com.jcraft diff --git a/core/src/main/java/hudson/slaves/ChannelPinger.java b/core/src/main/java/hudson/slaves/ChannelPinger.java index 2bc6d4cffb..88de99270c 100644 --- a/core/src/main/java/hudson/slaves/ChannelPinger.java +++ b/core/src/main/java/hudson/slaves/ChannelPinger.java @@ -35,11 +35,11 @@ import jenkins.security.MasterToSlaveCallable; import jenkins.slaves.PingFailureAnalyzer; import java.io.IOException; +import java.util.Arrays; import java.util.concurrent.atomic.AtomicBoolean; +import java.util.logging.Level; import java.util.logging.Logger; -import static java.util.logging.Level.*; - /** * Establish a periodic ping to keep connections between {@link Slave slaves} * and the main Jenkins node alive. This prevents network proxies from @@ -50,16 +50,43 @@ import static java.util.logging.Level.*; @Extension public class ChannelPinger extends ComputerListener { private static final Logger LOGGER = Logger.getLogger(ChannelPinger.class.getName()); - private static final String SYS_PROPERTY_NAME = ChannelPinger.class.getName() + ".pingInterval"; - private static final int DEFAULT_PING_INTERVAL_MIN = 5; - + private static final String TIMEOUT_SECONDS_PROPERTY = ChannelPinger.class.getName() + ".pingTimeoutSeconds"; + private static final String INTERVAL_MINUTES_PROPERTY = ChannelPinger.class.getName() + ".pingInterval"; + private static final String INTERVAL_SECONDS_PROPERTY = ChannelPinger.class.getName() + ".pingIntervalSeconds"; + /** - * Interval for the ping in minutes. + * Timeout for the ping in seconds. */ - private final int pingInterval; + private final int pingTimeoutSeconds; + + /** + * Interval for the ping in seconds. + */ + private final int pingIntervalSeconds; public ChannelPinger() { - pingInterval = SystemProperties.getInteger(SYS_PROPERTY_NAME, DEFAULT_PING_INTERVAL_MIN); + pingTimeoutSeconds = Integer.getInteger(TIMEOUT_SECONDS_PROPERTY, 4 * 60); + + // A little extra hoop-jumping to migrate from the old system property + Integer intervalSeconds = Integer.getInteger(INTERVAL_SECONDS_PROPERTY); + Integer intervalMinutes = Integer.getInteger(INTERVAL_MINUTES_PROPERTY); + if (intervalMinutes != null) { + LOGGER.warning("Property '" + INTERVAL_MINUTES_PROPERTY + "' is deprecated. Please migrate to '" + INTERVAL_SECONDS_PROPERTY + "'"); + + if (intervalSeconds != null) { + LOGGER.log(Level.WARNING, "Ignoring {0}={1} because {2}={3}", + new Object[] { INTERVAL_MINUTES_PROPERTY, intervalMinutes, INTERVAL_SECONDS_PROPERTY, intervalSeconds }); + } else { + intervalSeconds = intervalMinutes * 60; + } + } + + pingIntervalSeconds = intervalSeconds == null ? 5 * 60 : intervalSeconds; + + if (pingIntervalSeconds < pingTimeoutSeconds) { + LOGGER.log(Level.WARNING, "Ping interval ({0}) is less than ping timeout ({1})", + new Object[] { pingIntervalSeconds, pingTimeoutSeconds }); + } } @Override @@ -68,13 +95,13 @@ public class ChannelPinger extends ComputerListener { } public void install(Channel channel) { - if (pingInterval < 1) { + if (pingTimeoutSeconds < 1 || pingIntervalSeconds < 1) { LOGGER.fine("Agent ping is disabled"); return; } try { - channel.call(new SetUpRemotePing(pingInterval)); + channel.call(new SetUpRemotePing(pingTimeoutSeconds, pingIntervalSeconds)); LOGGER.fine("Set up a remote ping for " + channel.getName()); } catch (Exception e) { LOGGER.severe("Failed to set up a ping for " + channel.getName()); @@ -82,40 +109,66 @@ public class ChannelPinger extends ComputerListener { // set up ping from both directions, so that in case of a router dropping a connection, // both sides can notice it and take compensation actions. - setUpPingForChannel(channel, pingInterval, true); + setUpPingForChannel(channel, pingTimeoutSeconds, pingIntervalSeconds, true); } - private static class SetUpRemotePing extends MasterToSlaveCallable { - private static final long serialVersionUID = -2702219700841759872L; - private int pingInterval; - public SetUpRemotePing(int pingInterval) { - this.pingInterval = pingInterval; + static class SetUpRemotePing extends MasterToSlaveCallable { + private final int pingTimeoutSeconds; + private final int pingIntervalSeconds; + + SetUpRemotePing(int pingTimeoutSeconds, int pingIntervalSeconds) { + this.pingTimeoutSeconds = pingTimeoutSeconds; + this.pingIntervalSeconds = pingIntervalSeconds; } + @Override public Void call() throws IOException { - setUpPingForChannel(Channel.current(), pingInterval, false); + setUpPingForChannel(Channel.current(), pingTimeoutSeconds, pingIntervalSeconds, false); return null; } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + SetUpRemotePing that = (SetUpRemotePing) o; + return this.pingTimeoutSeconds == that.pingTimeoutSeconds + && this.pingIntervalSeconds == that.pingIntervalSeconds; + } + + @Override + public int hashCode() { + // TODO(deadmoose): switch to Objects.hash once Java 7's fully available + return Arrays.hashCode(new Object[] { pingTimeoutSeconds, pingIntervalSeconds }); + } + + @Override + public String toString() { + return "SetUpRemotePing(" + pingTimeoutSeconds + "," + pingIntervalSeconds + ")"; + } } - private static void setUpPingForChannel(final Channel channel, int interval, final boolean analysis) { - LOGGER.log(FINE, "setting up ping on {0} at interval {1}m", new Object[] {channel.getName(), interval}); + static void setUpPingForChannel(final Channel channel, int timeoutSeconds, int intervalSeconds, final boolean analysis) { final AtomicBoolean isInClosed = new AtomicBoolean(false); - final PingThread t = new PingThread(channel, interval * 60 * 1000) { - @Override + final PingThread t = new PingThread(channel, timeoutSeconds * 1000L, intervalSeconds * 1000L) { protected void onDead(Throwable cause) { try { if (analysis) { analyze(cause); } if (isInClosed.get()) { - LOGGER.log(FINE,"Ping failed after the channel "+channel.getName()+" is already partially closed.",cause); + LOGGER.log(Level.FINE,"Ping failed after the channel "+channel.getName()+" is already partially closed.",cause); } else { - LOGGER.log(INFO,"Ping failed. Terminating the channel "+channel.getName()+".",cause); + LOGGER.log(Level.INFO,"Ping failed. Terminating the channel "+channel.getName()+".",cause); channel.close(cause); } } catch (IOException e) { - LOGGER.log(SEVERE,"Failed to terminate the channel "+channel.getName(),e); + LOGGER.log(Level.SEVERE,"Failed to terminate the channel "+channel.getName(),e); } } /** Keep in a separate method so we do not even try to do class loading on {@link PingFailureAnalyzer} from an agent JVM. */ @@ -141,6 +194,7 @@ public class ChannelPinger extends ComputerListener { }); t.start(); - LOGGER.fine("Ping thread started for " + channel + " with a " + interval + " minute interval"); + LOGGER.log(Level.FINE, "Ping thread started for {0} with a {1} second interval and a {2} second timeout.", + new Object[] { channel, intervalSeconds, timeoutSeconds }); } } diff --git a/core/src/test/java/hudson/slaves/ChannelPingerTest.java b/core/src/test/java/hudson/slaves/ChannelPingerTest.java new file mode 100644 index 0000000000..9018ea55ee --- /dev/null +++ b/core/src/test/java/hudson/slaves/ChannelPingerTest.java @@ -0,0 +1,117 @@ +package hudson.slaves; + +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.powermock.api.mockito.PowerMockito.mockStatic; +import static org.powermock.api.mockito.PowerMockito.verifyNoMoreInteractions; +import static org.powermock.api.mockito.PowerMockito.verifyStatic; + +import com.google.common.testing.EqualsTester; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import hudson.remoting.Channel; + +import java.util.Map; +import java.util.HashMap; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ ChannelPinger.class }) +public class ChannelPingerTest { + + @Mock private Channel mockChannel; + + private Map savedSystemProperties = new HashMap(); + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + mockStatic(ChannelPinger.class); + } + + @Before + public void preserveSystemProperties() throws Exception { + preserveSystemProperty("hudson.slaves.ChannelPinger.pingInterval"); + preserveSystemProperty("hudson.slaves.ChannelPinger.pingIntervalSeconds"); + preserveSystemProperty("hudson.slaves.ChannelPinger.pingTimeoutSeconds"); + } + + @After + public void restoreSystemProperties() throws Exception { + for (Map.Entry entry : savedSystemProperties.entrySet()) { + if (entry.getValue() != null) { + System.setProperty(entry.getKey(), entry.getValue()); + } else { + System.clearProperty(entry.getKey()); + } + } + } + + private void preserveSystemProperty(String propertyName) { + savedSystemProperties.put(propertyName, System.getProperty(propertyName)); + System.clearProperty(propertyName); + } + + @Test + public void testDefaults() throws Exception { + ChannelPinger channelPinger = new ChannelPinger(); + channelPinger.install(mockChannel); + + verify(mockChannel).call(eq(new ChannelPinger.SetUpRemotePing(240, 300))); + verifyStatic(); + ChannelPinger.setUpPingForChannel(mockChannel, 240, 300); + } + + @Test + public void testFromSystemProperties() throws Exception { + System.setProperty("hudson.slaves.ChannelPinger.pingTimeoutSeconds", "42"); + System.setProperty("hudson.slaves.ChannelPinger.pingIntervalSeconds", "73"); + + ChannelPinger channelPinger = new ChannelPinger(); + channelPinger.install(mockChannel); + + verify(mockChannel).call(new ChannelPinger.SetUpRemotePing(42, 73)); + verifyStatic(); + ChannelPinger.setUpPingForChannel(mockChannel, 42, 73); + } + + @Test + public void testFromOldSystemProperty() throws Exception { + System.setProperty("hudson.slaves.ChannelPinger.pingInterval", "7"); + + ChannelPinger channelPinger = new ChannelPinger(); + channelPinger.install(mockChannel); + + verify(mockChannel).call(eq(new ChannelPinger.SetUpRemotePing(240, 420))); + verifyStatic(); + ChannelPinger.setUpPingForChannel(mockChannel, 240, 420); + } + + @Test + public void testNewSystemPropertyTrumpsOld() throws Exception { + System.setProperty("hudson.slaves.ChannelPinger.pingIntervalSeconds", "73"); + System.setProperty("hudson.slaves.ChannelPinger.pingInterval", "7"); + + ChannelPinger channelPinger = new ChannelPinger(); + channelPinger.install(mockChannel); + + verify(mockChannel).call(eq(new ChannelPinger.SetUpRemotePing(240, 73))); + verifyStatic(); + ChannelPinger.setUpPingForChannel(mockChannel, 240, 73); + } + + @Test + public void testSetUpRemotePingEquality() { + new EqualsTester() + .addEqualityGroup(new ChannelPinger.SetUpRemotePing(1, 2), new ChannelPinger.SetUpRemotePing(1, 2)) + .addEqualityGroup(new ChannelPinger.SetUpRemotePing(2, 3), new ChannelPinger.SetUpRemotePing(2, 3)) + .testEquals(); + } +} diff --git a/pom.xml b/pom.xml index 7b20746edd..00eb5100f5 100644 --- a/pom.xml +++ b/pom.xml @@ -91,6 +91,7 @@ THE SOFTWARE. https://api.github.com jenkins-jira + 11.0.1 1.7.7 2.14 1.4.1 @@ -186,7 +187,12 @@ THE SOFTWARE. com.google.guava guava - 11.0.1 + ${guavaVersion} + + + com.google.guava + guava-testlib + ${guavaVersion} From 6dea3c3f70968d18482e2f650be8fd597b4d1ce1 Mon Sep 17 00:00:00 2001 From: Alvaro Lobato Date: Tue, 29 Nov 2016 11:15:16 +0100 Subject: [PATCH 2/2] [JENKINS-28245] - Finish deadmoose's work to allow defining agent ping interval and ping timeout in seconds --- .../java/hudson/slaves/ChannelPinger.java | 96 +++++++++++-------- .../java/hudson/slaves/ChannelPingerTest.java | 19 ++-- 2 files changed, 63 insertions(+), 52 deletions(-) diff --git a/core/src/main/java/hudson/slaves/ChannelPinger.java b/core/src/main/java/hudson/slaves/ChannelPinger.java index 88de99270c..0d4dae702c 100644 --- a/core/src/main/java/hudson/slaves/ChannelPinger.java +++ b/core/src/main/java/hudson/slaves/ChannelPinger.java @@ -35,7 +35,6 @@ import jenkins.security.MasterToSlaveCallable; import jenkins.slaves.PingFailureAnalyzer; import java.io.IOException; -import java.util.Arrays; import java.util.concurrent.atomic.AtomicBoolean; import java.util.logging.Level; import java.util.logging.Logger; @@ -49,43 +48,39 @@ import java.util.logging.Logger; */ @Extension public class ChannelPinger extends ComputerListener { + static final int PING_TIMEOUT_SECONDS_DEFAULT = 4 * 60; + static final int PING_INTERVAL_SECONDS_DEFAULT = 5 * 60; + private static final Logger LOGGER = Logger.getLogger(ChannelPinger.class.getName()); private static final String TIMEOUT_SECONDS_PROPERTY = ChannelPinger.class.getName() + ".pingTimeoutSeconds"; - private static final String INTERVAL_MINUTES_PROPERTY = ChannelPinger.class.getName() + ".pingInterval"; + private static final String INTERVAL_MINUTES_PROPERTY_DEPRECATED = ChannelPinger.class.getName() + ".pingInterval"; private static final String INTERVAL_SECONDS_PROPERTY = ChannelPinger.class.getName() + ".pingIntervalSeconds"; /** * Timeout for the ping in seconds. */ - private final int pingTimeoutSeconds; + private int pingTimeoutSeconds = SystemProperties.getInteger(TIMEOUT_SECONDS_PROPERTY, PING_TIMEOUT_SECONDS_DEFAULT, Level.WARNING); /** * Interval for the ping in seconds. */ - private final int pingIntervalSeconds; + private int pingIntervalSeconds = PING_INTERVAL_SECONDS_DEFAULT; public ChannelPinger() { - pingTimeoutSeconds = Integer.getInteger(TIMEOUT_SECONDS_PROPERTY, 4 * 60); - - // A little extra hoop-jumping to migrate from the old system property - Integer intervalSeconds = Integer.getInteger(INTERVAL_SECONDS_PROPERTY); - Integer intervalMinutes = Integer.getInteger(INTERVAL_MINUTES_PROPERTY); - if (intervalMinutes != null) { - LOGGER.warning("Property '" + INTERVAL_MINUTES_PROPERTY + "' is deprecated. Please migrate to '" + INTERVAL_SECONDS_PROPERTY + "'"); - - if (intervalSeconds != null) { - LOGGER.log(Level.WARNING, "Ignoring {0}={1} because {2}={3}", - new Object[] { INTERVAL_MINUTES_PROPERTY, intervalMinutes, INTERVAL_SECONDS_PROPERTY, intervalSeconds }); - } else { - intervalSeconds = intervalMinutes * 60; + + Integer interval = SystemProperties.getInteger(INTERVAL_SECONDS_PROPERTY, null, Level.WARNING); + + // if interval wasn't set we read the deprecated property in minutes + if (interval == null) { + interval = SystemProperties.getInteger(INTERVAL_MINUTES_PROPERTY_DEPRECATED,null, Level.WARNING); + if (interval != null) { + LOGGER.warning(INTERVAL_MINUTES_PROPERTY_DEPRECATED + " property is deprecated, " + INTERVAL_SECONDS_PROPERTY + " should be used"); + interval *= 60; //to seconds } } - - pingIntervalSeconds = intervalSeconds == null ? 5 * 60 : intervalSeconds; - - if (pingIntervalSeconds < pingTimeoutSeconds) { - LOGGER.log(Level.WARNING, "Ping interval ({0}) is less than ping timeout ({1})", - new Object[] { pingIntervalSeconds, pingTimeoutSeconds }); + + if (interval != null) { + pingIntervalSeconds = interval; } } @@ -96,7 +91,7 @@ public class ChannelPinger extends ComputerListener { public void install(Channel channel) { if (pingTimeoutSeconds < 1 || pingIntervalSeconds < 1) { - LOGGER.fine("Agent ping is disabled"); + LOGGER.warning("Agent ping is disabled"); return; } @@ -113,6 +108,9 @@ public class ChannelPinger extends ComputerListener { } static class SetUpRemotePing extends MasterToSlaveCallable { + private static final long serialVersionUID = -2702219700841759872L; + @Deprecated + private transient int pingInterval; private final int pingTimeoutSeconds; private final int pingIntervalSeconds; @@ -128,34 +126,48 @@ public class ChannelPinger extends ComputerListener { } @Override - public boolean equals(Object o) { - if (this == o) { + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + pingIntervalSeconds; + result = prime * result + pingTimeoutSeconds; + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { return true; } - if (o == null || getClass() != o.getClass()) { + if (obj == null) { return false; } - - SetUpRemotePing that = (SetUpRemotePing) o; - return this.pingTimeoutSeconds == that.pingTimeoutSeconds - && this.pingIntervalSeconds == that.pingIntervalSeconds; + if (getClass() != obj.getClass()) { + return false; + } + SetUpRemotePing other = (SetUpRemotePing) obj; + if (pingIntervalSeconds != other.pingIntervalSeconds) { + return false; + } + if (pingTimeoutSeconds != other.pingTimeoutSeconds) { + return false; + } + return true; } - @Override - public int hashCode() { - // TODO(deadmoose): switch to Objects.hash once Java 7's fully available - return Arrays.hashCode(new Object[] { pingTimeoutSeconds, pingIntervalSeconds }); - } - - @Override - public String toString() { - return "SetUpRemotePing(" + pingTimeoutSeconds + "," + pingIntervalSeconds + ")"; + protected Object readResolve() { + if (pingInterval != 0) { + return new SetUpRemotePing(PING_TIMEOUT_SECONDS_DEFAULT, pingInterval * 60); + } + return this; } } static void setUpPingForChannel(final Channel channel, int timeoutSeconds, int intervalSeconds, final boolean analysis) { + LOGGER.log(Level.FINE, "setting up ping on {0} with a {1} seconds interval and {2} seconds timeout", new Object[] {channel.getName(), intervalSeconds, timeoutSeconds}); final AtomicBoolean isInClosed = new AtomicBoolean(false); final PingThread t = new PingThread(channel, timeoutSeconds * 1000L, intervalSeconds * 1000L) { + @Override protected void onDead(Throwable cause) { try { if (analysis) { @@ -194,7 +206,7 @@ public class ChannelPinger extends ComputerListener { }); t.start(); - LOGGER.log(Level.FINE, "Ping thread started for {0} with a {1} second interval and a {2} second timeout.", - new Object[] { channel, intervalSeconds, timeoutSeconds }); + LOGGER.log(Level.FINE, "Ping thread started for {0} with a {1} seconds interval and a {2} seconds timeout", + new Object[] { channel, intervalSeconds, timeoutSeconds }); } } diff --git a/core/src/test/java/hudson/slaves/ChannelPingerTest.java b/core/src/test/java/hudson/slaves/ChannelPingerTest.java index 9018ea55ee..e3e67a1b26 100644 --- a/core/src/test/java/hudson/slaves/ChannelPingerTest.java +++ b/core/src/test/java/hudson/slaves/ChannelPingerTest.java @@ -2,9 +2,7 @@ package hudson.slaves; import static org.mockito.Matchers.eq; import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; import static org.powermock.api.mockito.PowerMockito.mockStatic; -import static org.powermock.api.mockito.PowerMockito.verifyNoMoreInteractions; import static org.powermock.api.mockito.PowerMockito.verifyStatic; import com.google.common.testing.EqualsTester; @@ -14,7 +12,6 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.powermock.api.mockito.PowerMockito; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; import hudson.remoting.Channel; @@ -64,9 +61,11 @@ public class ChannelPingerTest { ChannelPinger channelPinger = new ChannelPinger(); channelPinger.install(mockChannel); - verify(mockChannel).call(eq(new ChannelPinger.SetUpRemotePing(240, 300))); + verify(mockChannel).call(eq(new ChannelPinger.SetUpRemotePing(ChannelPinger.PING_TIMEOUT_SECONDS_DEFAULT, + ChannelPinger.PING_INTERVAL_SECONDS_DEFAULT))); verifyStatic(); - ChannelPinger.setUpPingForChannel(mockChannel, 240, 300); + ChannelPinger.setUpPingForChannel(mockChannel, ChannelPinger.PING_TIMEOUT_SECONDS_DEFAULT, + ChannelPinger.PING_INTERVAL_SECONDS_DEFAULT, true); } @Test @@ -79,7 +78,7 @@ public class ChannelPingerTest { verify(mockChannel).call(new ChannelPinger.SetUpRemotePing(42, 73)); verifyStatic(); - ChannelPinger.setUpPingForChannel(mockChannel, 42, 73); + ChannelPinger.setUpPingForChannel(mockChannel, 42, 73, true); } @Test @@ -89,9 +88,9 @@ public class ChannelPingerTest { ChannelPinger channelPinger = new ChannelPinger(); channelPinger.install(mockChannel); - verify(mockChannel).call(eq(new ChannelPinger.SetUpRemotePing(240, 420))); + verify(mockChannel).call(eq(new ChannelPinger.SetUpRemotePing(ChannelPinger.PING_TIMEOUT_SECONDS_DEFAULT, 420))); verifyStatic(); - ChannelPinger.setUpPingForChannel(mockChannel, 240, 420); + ChannelPinger.setUpPingForChannel(mockChannel, ChannelPinger.PING_TIMEOUT_SECONDS_DEFAULT, 420, true); } @Test @@ -102,9 +101,9 @@ public class ChannelPingerTest { ChannelPinger channelPinger = new ChannelPinger(); channelPinger.install(mockChannel); - verify(mockChannel).call(eq(new ChannelPinger.SetUpRemotePing(240, 73))); + verify(mockChannel).call(eq(new ChannelPinger.SetUpRemotePing(ChannelPinger.PING_TIMEOUT_SECONDS_DEFAULT, 73))); verifyStatic(); - ChannelPinger.setUpPingForChannel(mockChannel, 240, 73); + ChannelPinger.setUpPingForChannel(mockChannel, ChannelPinger.PING_TIMEOUT_SECONDS_DEFAULT, 73, true); } @Test