Merge pull request #112 from ShaneMcC/SeparatePendingKeys

Make ProcessJoin handle the pendingJoins queue.

common/src/com/dmdirc/parser/events/DataOutEvent.java

 import static com.google.common.base.Preconditions.checkNotNull;
 
 /**
- * Called on every incoming line BEFORE being sent.
+ * Called on every outgoing line BEFORE being sent.
  */
 public class DataOutEvent extends ParserEvent {
 

irc/src/com/dmdirc/parser/irc/IRCParser.java

 import com.dmdirc.parser.interfaces.EncodingParser;
 import com.dmdirc.parser.interfaces.SecureParser;
 import com.dmdirc.parser.irc.IRCReader.ReadLine;
+import com.dmdirc.parser.irc.events.IRCDataOutEvent;
 import com.dmdirc.parser.irc.outputqueue.OutputQueue;
 
 import java.io.IOException;
     private final WhoisResponseHandler whoisHandler;
     /** Used to synchronize calls to resetState. */
     private final Object resetStateSync = new Object();
-    /** Pending Joins. */
-    private final Queue<String> pendingJoins = new LinkedList<>();
-    /** Pending Join Keys. */
-    private final Queue<String> pendingJoinKeys = new LinkedList<>();
 
     /**
      * Default constructor, ServerInfo and MyInfo need to be added separately (using IRC.me and IRC.server).
      * @param fromParser True if parser sent the data, false if sent using .sendLine
      */
     protected void callDataOut(final String data, final boolean fromParser) {
-        getCallbackManager().publish(new DataOutEvent(this, LocalDateTime.now(), data));
+        getCallbackManager().publish(new IRCDataOutEvent(this, LocalDateTime.now(), data));
     }
 
     /**
                     }
                 }
             }
-        } else if ("join".equalsIgnoreCase(newLine[0]) && newLine.length > 1) {
-            final Queue<String> keys = new LinkedList<>();
-
-            if (newLine.length > 2) {
-                keys.addAll(Arrays.asList(newLine[2].split(",")));
-            }
-
-            // PendingJoins and PendingJoinKeys should always be the same length (even if no key was given).
-            //
-            // We don't get any errors for channels we try to join that we are already in
-            // But the IRCD will still swallow the key attempt.
-            //
-            // Make sure that we always have a guessed key for every channel (even if null) and that we
-            // don't have guesses for channels we are already in.
-            for (final String chan : newLine[1].split(",")) {
-                final String key = keys.poll();
-                if (getChannel(chan) == null) {
-                    pendingJoins.add(chan);
-                    pendingJoinKeys.add(key);
-                }
-            }
         }
 
         return true;
     }
 
-    /**
-     * Get the current pending Joins.
-     *
-     * @return Current pending Joins
-     */
-    public Queue<String> getPendingJoins() {
-        return pendingJoins;
-    }
-
-    /**
-     * Get the current pending join keys.
-     *
-     * @return Current pending join keys.
-     */
-    public Queue<String> getPendingJoinKeys() {
-        return pendingJoinKeys;
-    }
-
     @Override
     public String getNetworkName() {
         return networkName;

irc/src/com/dmdirc/parser/irc/events/IRCDataOutEvent.java

+/*
+ * Copyright (c) 2006-2014 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.parser.irc.events;
+
+import com.dmdirc.parser.events.DataOutEvent;
+import com.dmdirc.parser.interfaces.Parser;
+import com.dmdirc.parser.irc.IRCParser;
+
+import java.time.LocalDateTime;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Called on every outgoing line BEFORE being sent.
+ *
+ * This extends the standard DataOutEvent to also pre-tokenise the data.
+ */
+public class IRCDataOutEvent extends DataOutEvent {
+
+    private final String[] tokenisedData;
+    private final String action;
+
+    public IRCDataOutEvent(final Parser parser, final LocalDateTime date, final String data) {
+        super(parser, date, data);
+        tokenisedData = IRCParser.tokeniseLine(checkNotNull(data));
+        action = tokenisedData[0].toUpperCase();
+    }
+
+    public String[] getTokenisedData() {
+        return tokenisedData;
+    }
+
+    public String getAction() {
+        return action;
+    }
+}

irc/src/com/dmdirc/parser/irc/processors/ProcessJoin.java

 import com.dmdirc.parser.common.QueuePriority;
 import com.dmdirc.parser.events.ChannelJoinEvent;
 import com.dmdirc.parser.events.ChannelSelfJoinEvent;
+import com.dmdirc.parser.events.DataOutEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.irc.CapabilityState;
 import com.dmdirc.parser.irc.ModeManager;
 import com.dmdirc.parser.irc.PrefixModeManager;
 import com.dmdirc.parser.irc.ProcessorNotFoundException;
+import com.dmdirc.parser.irc.events.IRCDataOutEvent;
+import net.engio.mbassy.listener.Handler;
+import net.engio.mbassy.listener.Invoke;
 
 import java.time.LocalDateTime;
 import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
 
 import javax.inject.Inject;
 import javax.inject.Named;
     private final ModeManager userModeManager;
     /** Mode manager to use for channel modes. */
     private final ModeManager chanModeManager;
+    /** Pending Joins. */
+    private final Queue<String> pendingJoins = new LinkedList<>();
+    /** Pending Join Keys. */
+    private final Queue<String> pendingJoinKeys = new LinkedList<>();
 
     /**
      * Create a new instance of the IRCProcessor Object.
         this.prefixModeManager = prefixModeManager;
         this.userModeManager = userModeManager;
         this.chanModeManager = chanModeManager;
+
+        getCallbackManager().subscribe(this);
     }
 
     /**
             parser.addChannel(iChannel);
             sendString("MODE " + iChannel.getName(), QueuePriority.LOW);
 
-            final String pendingJoin = parser.getPendingJoins().poll();
-            final String pendingJoinKey = parser.getPendingJoinKeys().poll();
-            if (pendingJoin.equalsIgnoreCase(channelName)) {
+            final String pendingJoin = pendingJoins.poll();
+            final String pendingJoinKey = pendingJoinKeys.poll();
+            if (pendingJoin != null && pendingJoin.equalsIgnoreCase(channelName)) {
                 callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: Guessing channel Key: " + pendingJoin + " -> " + pendingJoinKey);
                 iChannel.setInternalPassword(pendingJoinKey == null ? "" : pendingJoinKey);
             } else {
-                // Out of sync, clear.
-                parser.getPendingJoins().clear();
-                parser.getPendingJoinKeys().clear();
+                // Out of sync, clear
+                callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: pending join keys out of sync (Got: " + pendingJoin + ", Wanted: " + channelName + ") - Clearing.");
+                pendingJoins.clear();
+                pendingJoinKeys.clear();
             }
 
             callChannelSelfJoin(iChannel);
         } else {
             // Some kind of failed to join, pop the pending join queues.
-            parser.getPendingJoins().poll();
-            parser.getPendingJoinKeys().poll();
+            final String pendingJoin = pendingJoins.poll();
+            final String pendingJoinKey = pendingJoinKeys.poll();
+            callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: Failed to join channel (" + sParam + ") - Skipping " + pendingJoin + " (" + pendingJoinKey + ")");
+        }
+    }
+
+    @Handler(condition = "msg.action == 'JOIN'")
+    public void handleDataOut(final IRCDataOutEvent event) {
+        // As long as this is called before the resulting DataIn
+        // Processors fire then this will work, otherwise we'll end
+        // up with an out-of-sync pendingJoins list.
+
+        final String[] newLine = event.getTokenisedData();
+        if (newLine.length > 1) {
+            final Queue<String> keys = new LinkedList<>();
+
+            if (newLine.length > 2) {
+                keys.addAll(Arrays.asList(newLine[2].split(",")));
+            }
+
+            // PendingJoins and PendingJoinKeys should always be the same length (even if no key was given).
+            //
+            // We don't get any errors for channels we try to join that we are already in
+            // But the IRCD will still swallow the key attempt.
+            //
+            // Make sure that we always have a guessed key for every channel (even if null) and that we
+            // don't have guesses for channels we are already in.
+            for (final String chan : newLine[1].split(",")) {
+                final String key = keys.poll();
+                if (getChannel(chan) == null) {
+                    callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: Intercepted possible channel Key: " + chan + " -> " + key);
+                    pendingJoins.add(chan);
+                    pendingJoinKeys.add(key);
+                } else {
+                    callDebugInfo(IRCParser.DEBUG_INFO, "processJoin: Ignoring possible channel Key for existing channel: " + chan + " -> " + key);
+                }
+            }
         }
     }