Changeset 681 in code for trunk/upstream.go

Timestamp:

Nov 9, 2021, 8:32:26 PM (4 years ago)

Author:

contact

Message:

Remove support for mixed multi-upstream LIST

Multi-upstream connections can still send LIST commands with a
network suffix.

File:

• trunk/upstream.go (modified) (6 diffs)

trunk/upstream.go

@@ -73 +73 @@
 }
 
+type pendingUpstreamCommand struct {
+        downstreamID uint64
+        cmd          *irc.Message
+}
+
 type upstreamConn struct {
         conn
@@ -105 +110 @@
         casemapIsSet bool
 
-        // set of LIST commands in progress, per downstream
-        pendingLISTDownstreamSet map[uint64]struct{}
+        // Queue of LIST commands in progress. The first entry has been sent to the
+        // server and is awaiting reply. The following entries have not been sent
+        // yet.
+        pendingLIST []pendingUpstreamCommand
 
         gotMotd bool
@@ -191 +198 @@
 
         uc := &upstreamConn{
-                conn:                     *newConn(network.user.srv, newNetIRCConn(netConn), &options),
-                network:                  network,
-                user:                     network.user,
-                channels:                 upstreamChannelCasemapMap{newCasemapMap(0)},
-                supportedCaps:            make(map[string]string),
-                caps:                     make(map[string]bool),
-                batches:                  make(map[string]batch),
-                availableChannelTypes:    stdChannelTypes,
-                availableChannelModes:    stdChannelModes,
-                availableMemberships:     stdMemberships,
-                isupport:                 make(map[string]*string),
-                pendingLISTDownstreamSet: make(map[uint64]struct{}),
+                conn:                  *newConn(network.user.srv, newNetIRCConn(netConn), &options),
+                network:               network,
+                user:                  network.user,
+                channels:              upstreamChannelCasemapMap{newCasemapMap(0)},
+                supportedCaps:         make(map[string]string),
+                caps:                  make(map[string]bool),
+                batches:               make(map[string]batch),
+                availableChannelTypes: stdChannelTypes,
+                availableChannelModes: stdChannelModes,
+                availableMemberships:  stdMemberships,
+                isupport:              make(map[string]*string),
         }
         return uc, nil
@@ -236 +242 @@
 }
 
-func (uc *upstreamConn) getPendingLIST() *pendingLIST {
-        for _, pl := range uc.user.pendingLISTs {
-                if _, ok := pl.pendingCommands[uc.network.ID]; !ok {
-                        continue
-                }
-                return &pl
-        }
-        return nil
-}
-
-func (uc *upstreamConn) endPendingLISTs(all bool) (found bool) {
-        found = false
-        for i := 0; i < len(uc.user.pendingLISTs); i++ {
-                pl := uc.user.pendingLISTs[i]
-                if _, ok := pl.pendingCommands[uc.network.ID]; !ok {
-                        continue
-                }
-                delete(pl.pendingCommands, uc.network.ID)
-                if len(pl.pendingCommands) == 0 {
-                        uc.user.pendingLISTs = append(uc.user.pendingLISTs[:i], uc.user.pendingLISTs[i+1:]...)
-                        i--
-                        uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
-                                dc.SendMessage(&irc.Message{
-                                        Prefix:  dc.srv.prefix(),
-                                        Command: irc.RPL_LISTEND,
-                                        Params:  []string{dc.nick, "End of /LIST"},
-                                })
-                        })
-                }
-                found = true
-                if !all {
-                        delete(uc.pendingLISTDownstreamSet, pl.downstreamID)
-                        uc.user.forEachUpstream(func(uc *upstreamConn) {
-                                uc.trySendLIST(pl.downstreamID)
-                        })
-                        return
-                }
-        }
-        return
-}
-
-func (uc *upstreamConn) trySendLIST(downstreamID uint64) {
-        if _, ok := uc.pendingLISTDownstreamSet[downstreamID]; ok {
-                // a LIST command is already pending
-                // we will try again when that command is completed
+func (uc *upstreamConn) endPendingLISTs() {
+        for _, pendingCmd := range uc.pendingLIST {
+                uc.forEachDownstreamByID(pendingCmd.downstreamID, func(dc *downstreamConn) {
+                        dc.SendMessage(&irc.Message{
+                                Prefix:  dc.srv.prefix(),
+                                Command: irc.RPL_LISTEND,
+                                Params:  []string{dc.nick, "End of /LIST"},
+                        })
+                })
+        }
+        uc.pendingLIST = nil
+}
+
+func (uc *upstreamConn) sendNextPendingLIST() {
+        if len(uc.pendingLIST) == 0 {
                 return
         }
-
-        for _, pl := range uc.user.pendingLISTs {
-                if pl.downstreamID != downstreamID {
-                        continue
-                }
-                // this is the first pending LIST command list of the downstream
-                listCommand, ok := pl.pendingCommands[uc.network.ID]
-                if !ok {
-                        // there is no command for this upstream in these LIST commands
-                        // do not send anything
-                        continue
-                }
-                // there is a command for this upstream in these LIST commands
-                // send it now
-
-                uc.SendMessageLabeled(downstreamID, listCommand)
-
-                uc.pendingLISTDownstreamSet[downstreamID] = struct{}{}
-                return
-        }
+        uc.SendMessage(uc.pendingLIST[0].cmd)
+}
+
+func (uc *upstreamConn) enqueueLIST(dc *downstreamConn, cmd *irc.Message) {
+        uc.pendingLIST = append(uc.pendingLIST, pendingUpstreamCommand{
+                downstreamID: dc.id,
+                cmd:          cmd,
+        })
+
+        if len(uc.pendingLIST) == 1 {
+                uc.sendNextPendingLIST()
+        }
+}
+
+func (uc *upstreamConn) currentPendingLIST() (*downstreamConn, *irc.Message) {
+        if len(uc.pendingLIST) == 0 {
+                return nil, nil
+        }
+
+        pendingCmd := uc.pendingLIST[0]
+        for _, dc := range uc.user.downstreamConns {
+                if dc.id == pendingCmd.downstreamID {
+                        return dc, pendingCmd.cmd
+                }
+        }
+
+        return nil, pendingCmd.cmd
+}
+
+func (uc *upstreamConn) dequeueLIST() (*downstreamConn, *irc.Message) {
+        dc, cmd := uc.currentPendingLIST()
+
+        if len(uc.pendingLIST) > 0 {
+                copy(uc.pendingLIST, uc.pendingLIST[1:])
+                uc.pendingLIST = uc.pendingLIST[:len(uc.pendingLIST)-1]
+        }
+
+        uc.sendNextPendingLIST()
+
+        return dc, cmd
 }
 
@@ -1100 +1096 @@
                 }
 
-                pl := uc.getPendingLIST()
-                if pl == nil {
+                dc, cmd := uc.currentPendingLIST()
+                if cmd == nil {
                         return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
-                }
-
-                uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
-                        dc.SendMessage(&irc.Message{
-                                Prefix:  dc.srv.prefix(),
-                                Command: irc.RPL_LIST,
-                                Params:  []string{dc.nick, dc.marshalEntity(uc.network, channel), clients, topic},
-                        })
+                } else if dc == nil {
+                        return nil
+                }
+
+                dc.SendMessage(&irc.Message{
+                        Prefix:  dc.srv.prefix(),
+                        Command: irc.RPL_LIST,
+                        Params:  []string{dc.nick, dc.marshalEntity(uc.network, channel), clients, topic},
                 })
         case irc.RPL_LISTEND:
-                ok := uc.endPendingLISTs(false)
-                if !ok {
+                dc, cmd := uc.dequeueLIST()
+                if cmd == nil {
                         return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
-                }
+                } else if dc == nil {
+                        return nil
+                }
+
+                dc.SendMessage(&irc.Message{
+                        Prefix:  dc.srv.prefix(),
+                        Command: irc.RPL_LISTEND,
+                        Params:  []string{dc.nick, "End of /LIST"},
+                })
         case irc.RPL_NAMREPLY:
                 var name, statusStr, members string
@@ -1434 +1438 @@
 
                 if command == "LIST" {
-                        ok := uc.endPendingLISTs(false)
-                        if !ok {
-                                return fmt.Errorf("unexpected response for LIST: %q: no matching pending LIST", msg.Command)
-                        }
+                        uc.endPendingLISTs()
                 }