/** * * Copyright 2012-2018 Florian Schmaus * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.jivesoftware.smackx.ping; import java.util.Map; import java.util.Set; import java.util.WeakHashMap; import java.util.concurrent.CopyOnWriteArraySet; import java.util.concurrent.TimeUnit; import java.util.logging.Logger; import org.jivesoftware.smack.AbstractConnectionClosedListener; import org.jivesoftware.smack.ConnectionCreationListener; import org.jivesoftware.smack.Manager; import org.jivesoftware.smack.ScheduledAction; import org.jivesoftware.smack.SmackException.NoResponseException; import org.jivesoftware.smack.SmackException.NotConnectedException; import org.jivesoftware.smack.SmackFuture; import org.jivesoftware.smack.SmackFuture.InternalProcessStanzaSmackFuture; import org.jivesoftware.smack.XMPPConnection; import org.jivesoftware.smack.XMPPConnectionRegistry; import org.jivesoftware.smack.XMPPException.XMPPErrorException; import org.jivesoftware.smack.iqrequest.AbstractIqRequestHandler; import org.jivesoftware.smack.iqrequest.IQRequestHandler.Mode; import org.jivesoftware.smack.packet.IQ; import org.jivesoftware.smack.packet.IQ.Type; import org.jivesoftware.smack.packet.Stanza; import org.jivesoftware.smack.packet.StanzaError; import org.jivesoftware.smack.util.ExceptionCallback; import org.jivesoftware.smack.util.SuccessCallback; import org.jivesoftware.smackx.disco.ServiceDiscoveryManager; import org.jivesoftware.smackx.ping.packet.Ping; import org.jxmpp.jid.Jid; /** * Implements the XMPP Ping as defined by XEP-0199. The XMPP Ping protocol allows one entity to * ping any other entity by simply sending a ping to the appropriate JID. PingManger also * periodically sends XMPP pings to the server to avoid NAT timeouts and to test * the connection status. *
* The default server ping interval is 30 minutes and can be modified with * {@link #setDefaultPingInterval(int)} and {@link #setPingInterval(int)}. *
* * @author Florian Schmaus * @see XEP-0199:XMPP Ping */ public final class PingManager extends Manager { private static final Logger LOGGER = Logger.getLogger(PingManager.class.getName()); private static final Map
* Use {@link #isPingSupported(Jid)} to determine if XMPP Ping is supported
* by the entity.
*
* @param jid The id of the entity the ping is being sent to
* @param pingTimeout The time to wait for a reply in milliseconds
* @return true if a reply was received from the entity, false otherwise.
* @throws NoResponseException if there was no response from the jid.
* @throws NotConnectedException if the XMPP connection is not connected.
* @throws InterruptedException if the calling thread was interrupted.
*/
public boolean ping(Jid jid, long pingTimeout) throws NotConnectedException, NoResponseException, InterruptedException {
final XMPPConnection connection = connection();
// Packet collector for IQs needs an connection that was at least authenticated once,
// otherwise the client JID will be null causing an NPE
if (!connection.isAuthenticated()) {
throw new NotConnectedException();
}
Ping ping = new Ping(connection, jid);
try {
connection.createStanzaCollectorAndSend(ping).nextResultOrThrow(pingTimeout);
}
catch (XMPPErrorException e) {
return isValidErrorPong(jid, e);
}
return true;
}
/**
* Same as calling {@link #ping(Jid, long)} with the defaultpacket reply
* timeout.
*
* @param jid The id of the entity the ping is being sent to
* @return true if a reply was received from the entity, false otherwise.
* @throws NotConnectedException if the XMPP connection is not connected.
* @throws NoResponseException if there was no response from the jid.
* @throws InterruptedException if the calling thread was interrupted.
*/
public boolean ping(Jid jid) throws NotConnectedException, NoResponseException, InterruptedException {
return ping(jid, connection().getReplyTimeout());
}
/**
* Query the specified entity to see if it supports the Ping protocol (XEP-0199).
*
* @param jid The id of the entity the query is being sent to
* @return true if it supports ping, false otherwise.
* @throws XMPPErrorException An XMPP related error occurred during the request
* @throws NoResponseException if there was no response from the jid.
* @throws NotConnectedException if the XMPP connection is not connected.
* @throws InterruptedException if the calling thread was interrupted.
*/
public boolean isPingSupported(Jid jid) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
return ServiceDiscoveryManager.getInstanceFor(connection()).supportsFeature(jid, Ping.NAMESPACE);
}
/**
* Pings the server. This method will return true if the server is reachable. It
* is the equivalent of calling ping
with the XMPP domain.
*
* Unlike the {@link #ping(Jid)} case, this method will return true even if
* {@link #isPingSupported(Jid)} is false.
*
* @return true if a reply was received from the server, false otherwise.
* @throws NotConnectedException if the XMPP connection is not connected.
* @throws InterruptedException if the calling thread was interrupted.
*/
public boolean pingMyServer() throws NotConnectedException, InterruptedException {
return pingMyServer(true);
}
/**
* Pings the server. This method will return true if the server is reachable. It
* is the equivalent of calling ping
with the XMPP domain.
*
* Unlike the {@link #ping(Jid)} case, this method will return true even if
* {@link #isPingSupported(Jid)} is false.
*
* @param notifyListeners Notify the PingFailedListener in case of error if true
* @return true if the user's server could be pinged.
* @throws NotConnectedException if the XMPP connection is not connected.
* @throws InterruptedException if the calling thread was interrupted.
*/
public boolean pingMyServer(boolean notifyListeners) throws NotConnectedException, InterruptedException {
return pingMyServer(notifyListeners, connection().getReplyTimeout());
}
/**
* Pings the server. This method will return true if the server is reachable. It
* is the equivalent of calling ping
with the XMPP domain.
*
* Unlike the {@link #ping(Jid)} case, this method will return true even if
* {@link #isPingSupported(Jid)} is false.
*
* @param notifyListeners Notify the PingFailedListener in case of error if true
* @param pingTimeout The time to wait for a reply in milliseconds
* @return true if the user's server could be pinged.
* @throws NotConnectedException if the XMPP connection is not connected.
* @throws InterruptedException if the calling thread was interrupted.
*/
public boolean pingMyServer(boolean notifyListeners, long pingTimeout) throws NotConnectedException, InterruptedException {
boolean res;
try {
res = ping(connection().getXMPPServiceDomain(), pingTimeout);
}
catch (NoResponseException e) {
res = false;
}
if (!res && notifyListeners) {
for (PingFailedListener l : pingFailedListeners)
l.pingFailed();
}
return res;
}
/**
* Set the interval in seconds between a automated server ping is send. A negative value disables automatic server
* pings. All settings take effect immediately. If there is an active scheduled server ping it will be canceled and,
* if pingInterval
is positive, a new one will be scheduled in pingInterval seconds.
*
* If the ping fails after 3 attempts waiting the connections reply timeout for an answer, then the ping failed * listeners will be invoked. *
* * @param pingInterval the interval in seconds between the automated server pings */ public void setPingInterval(int pingInterval) { this.pingInterval = pingInterval; maybeSchedulePingServerTask(); } /** * Get the current ping interval. * * @return the interval between pings in seconds */ public int getPingInterval() { return pingInterval; } /** * Register a new PingFailedListener. * * @param listener the listener to invoke */ public void registerPingFailedListener(PingFailedListener listener) { pingFailedListeners.add(listener); } /** * Unregister a PingFailedListener. * * @param listener the listener to remove */ public void unregisterPingFailedListener(PingFailedListener listener) { pingFailedListeners.remove(listener); } private void maybeSchedulePingServerTask() { maybeSchedulePingServerTask(0); } /** * Cancels any existing periodic ping task if there is one and schedules a new ping task if * pingInterval is greater then zero. * * @param delta the delta to the last received stanza in seconds */ private synchronized void maybeSchedulePingServerTask(int delta) { maybeStopPingServerTask(); if (pingInterval > 0) { int nextPingIn = pingInterval - delta; LOGGER.fine("Scheduling ServerPingTask in " + nextPingIn + " seconds (pingInterval=" + pingInterval + ", delta=" + delta + ")"); nextAutomaticPing = schedule(pingServerRunnable, nextPingIn, TimeUnit.SECONDS); } } private void maybeStopPingServerTask() { final ScheduledAction nextAutomaticPing = this.nextAutomaticPing; if (nextAutomaticPing != null) { nextAutomaticPing.cancel(); this.nextAutomaticPing = null; } } /** * Ping the server if deemed necessary because automatic server pings are * enabled ({@link #setPingInterval(int)}) and the ping interval has expired. */ public void pingServerIfNecessary() { final XMPPConnection connection = connection(); if (connection == null) { // connection has been collected by GC // which means we can stop the thread by breaking the loop return; } if (pingInterval <= 0) { // Ping has been disabled return; } long lastStanzaReceived = connection.getLastStanzaReceived(); if (lastStanzaReceived > 0) { long now = System.currentTimeMillis(); // Delta since the last stanza was received int deltaInSeconds = (int) ((now - lastStanzaReceived) / 1000); // If the delta is small then the ping interval, then we can defer the ping if (deltaInSeconds < pingInterval) { maybeSchedulePingServerTask(deltaInSeconds); return; } } if (!connection.isAuthenticated()) { LOGGER.warning(connection + " was not authenticated"); return; } final long minimumTimeout = TimeUnit.MINUTES.toMillis(2); final long connectionReplyTimeout = connection.getReplyTimeout(); final long timeout = connectionReplyTimeout > minimumTimeout ? connectionReplyTimeout : minimumTimeout; SmackFuture