Add backoff to reconnects.

[xudocci.git] / src / main / java / net / pterodactylus / xdcc / core / Core.java

diff --git a/src/main/java/net/pterodactylus/xdcc/core/Core.java b/src/main/java/net/pterodactylus/xdcc/core/Core.java
index 6da5dbd..ca91805 100644 (file)
--- a/src/main/java/net/pterodactylus/xdcc/core/Core.java
+++ b/src/main/java/net/pterodactylus/xdcc/core/Core.java
@@ -31,11 +31,15 @@ import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Set;
+import java.util.TreeMap;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import net.pterodactylus.irc.Connection;
@@ -111,6 +115,7 @@ public class Core extends AbstractExecutionThreadService {
        private final ConnectionFactory connectionFactory;
        private final ChannelBanManager channelBanManager =
                        new ChannelBanManager();
+       private final ConnectionBackoff connectionBackoff = new ConnectionBackoff();
 
        /** The temporary directory to download files to. */
        private final String temporaryDirectory;
@@ -123,6 +128,7 @@ public class Core extends AbstractExecutionThreadService {
 
        /** The channels that are currentlymonitored. */
        private final Collection<Channel> joinedChannels = Sets.newHashSet();
+       private final Set<Channel> channelsBeingJoined = new HashSet<>();
 
        /** The channels that are joined but not configured. */
        private final Collection<Channel> extraChannels = Sets.newHashSet();
@@ -377,39 +383,68 @@ public class Core extends AbstractExecutionThreadService {
        @Override
        protected void run() throws Exception {
                while (isRunning()) {
-                       synchronized (syncObject) {
-                               try {
-                                       syncObject.wait(TimeUnit.MINUTES.toMillis(1));
-                               } catch (InterruptedException ie1) {
-                                       /* ignore. */
-                               }
-                       }
-                       if (!isRunning()) {
-                               break;
-                       }
 
-                       /* find channels that should be monitored but are not. */
+                       Set<Channel> missingChannels = new HashSet<>();
                        for (Channel channel : channels) {
-                               if (joinedChannels.contains(channel)) {
+                               if (joinedChannels.contains(channel) || channelsBeingJoined.contains(channel)) {
                                        continue;
                                }
-
-                               /* are we banned from this channel? */
                                if (channelBanManager.isBanned(channel)) {
                                        continue;
                                }
-
-                               connectNetwork(channel.network());
-                               Connection connection = networkConnections.get(channel.network());
-                               if (connection.established()) {
-                                       eventBus.post(new GenericMessage(String.format("Trying to join %s on %s.", channel.name(), channel.network().name())));
+                               if (networkConnections.containsKey(channel.network())) {
+                                       if (networkConnections.get(channel.network()).established()) {
+                                               missingChannels.add(channel);
+                                       }
+                               }
+                       }
+                       Set<Network> missingNetworks = missingChannels.stream()
+                                       .map(Channel::network)
+                                       .distinct()
+                                       .filter((network) -> !networkConnections.containsKey(network))
+                                       .collect(Collectors.toSet());
+
+                       if (!missingChannels.isEmpty()) {
+                               for (Channel missingChannel : missingChannels) {
+                                       Network network = missingChannel.network();
+                                       eventBus.post(new GenericMessage(String.format("Trying to join %s on %s...", missingChannel.name(), network)));
                                        try {
-                                               connection.joinChannel(channel.name());
+                                               channelsBeingJoined.add(missingChannel);
+                                               networkConnections.get(network).joinChannel(missingChannel.name());
                                        } catch (IOException ioe1) {
-                                               eventBus.post(new GenericMessage(String.format("Could not join %s on %s.", channel.name(), channel.network().name())));
+                                               logger.warn(String.format("Could not join %s on %s!", missingChannel.name(), network.name()), ioe1);
                                        }
                                }
+                       } else if (missingNetworks.isEmpty()) {
+                               synchronized (syncObject) {
+                                       try {
+                                               syncObject.wait(TimeUnit.MINUTES.toMillis(1));
+                                       } catch (InterruptedException ie1) {
+                                               /* ignore. */
+                                       }
+                               }
+                               continue;
+                       }
+
+                       Map<Long, Network> timesForNextConnects = new TreeMap<>(missingNetworks.stream()
+                                       .collect(Collectors.toMap(connectionBackoff::getBackoff, Function.identity(), (network, ignore) -> network)));
+
+                       Entry<Long, Network> firstNetwork = timesForNextConnects.entrySet().stream().findFirst().get();
+                       if (firstNetwork.getKey() > 0) {
+                               eventBus.post(new GenericMessage(String.format("Waiting %d seconds to connect to %s...", TimeUnit.MILLISECONDS.toMinutes(firstNetwork.getKey()), firstNetwork.getValue().name())));
+                               synchronized (syncObject) {
+                                       try {
+                                               syncObject.wait(firstNetwork.getKey());
+                                       } catch (InterruptedException ie1) {
+                                               /* ignore. */
+                                       }
+                               }
+                               if (!isRunning()) {
+                                       break;
+                               }
                        }
+
+                       connectNetwork(firstNetwork.getValue());
                }
        }
 
@@ -510,6 +545,7 @@ public class Core extends AbstractExecutionThreadService {
                        return;
                }
 
+               connectionBackoff.connectionSuccessful(network.get());
                eventBus.post(new GenericMessage(String.format("Connected to network %s.", network.get().name())));
 
                /* join all channels on this network. */
@@ -534,6 +570,7 @@ public class Core extends AbstractExecutionThreadService {
        @Subscribe
        public void connectionClosed(ConnectionClosed connectionClosed) {
                removeConnection(connectionClosed.connection());
+               connectionBackoff.connectionFailed(getNetwork(connectionClosed.connection()).get());
                eventBus.post(new GenericMessage(String.format("Connection closed by %s.", connectionClosed.connection().hostname())));
        }
 
@@ -546,6 +583,7 @@ public class Core extends AbstractExecutionThreadService {
        @Subscribe
        public void connectionFailed(ConnectionFailed connectionFailed) {
                removeConnection(connectionFailed.connection());
+               connectionBackoff.connectionFailed(getNetwork(connectionFailed.connection()).get());
                eventBus.post(new GenericMessage(String.format("Could not connect to %s: %s.", connectionFailed.connection().hostname(), connectionFailed.cause())));
        }
 
@@ -573,6 +611,7 @@ public class Core extends AbstractExecutionThreadService {
 
                        channelBanManager.unban(channel.get());
                        joinedChannels.add(channel.get());
+                       channelsBeingJoined.remove(channel.get());
                        logger.info(String.format("Joined Channel %s on %s.", channelJoined.channel(), network.get().name()));
                }
        }
@@ -590,6 +629,8 @@ public class Core extends AbstractExecutionThreadService {
                        return;
                }
 
+               channelsBeingJoined.remove(channel.get());
+
                /* remove all bots for this channel, we might have been kicked. */
                Collection<Bot> botsToRemove = networkBots.row(network.get())
                                .values().stream()