Update vendor

vendor/github.com/eclipse/paho.mqtt.golang/router.go

@@ -1,10 +1,14 @@
 /*
- * Copyright (c) 2013 IBM Corp.
+ * Copyright (c) 2021 IBM Corp and others.
  *
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * are made available under the terms of the Eclipse Public License v2.0
+ * and Eclipse Distribution License v1.0 which accompany this distribution.
+ *
+ * The Eclipse Public License is available at
+ *    https://www.eclipse.org/legal/epl-2.0/
+ * and the Eclipse Distribution License is available at
+ *   http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * Contributors:
  *    Seth Hoenig
@@ -132,13 +136,46 @@ func (r *router) setDefaultHandler(handler MessageHandler) {
 // associated callback (or the defaultHandler, if one exists and no other route matched). If
 // anything is sent down the stop channel the function will end.
 func (r *router) matchAndDispatch(messages <-chan *packets.PublishPacket, order bool, client *client) <-chan *PacketAndToken {
-	ackChan := make(chan *PacketAndToken)
-	go func() {
+	var wg sync.WaitGroup
+	ackOutChan := make(chan *PacketAndToken) // Channel returned to caller; closed when messages channel closed
+	var ackInChan chan *PacketAndToken       // ACKs generated by ackFunc get put onto this channel
+
+	stopAckCopy := make(chan struct{})    // Closure requests stop of go routine copying ackInChan to ackOutChan
+	ackCopyStopped := make(chan struct{}) // Closure indicates that it is safe to close ackOutChan
+	goRoutinesDone := make(chan struct{}) // closed on wg.Done()
+	if order {
+		ackInChan = ackOutChan // When order = true no go routines are used so safe to use one channel and close when done
+	} else {
+		// When order = false ACK messages are sent in go routines so ackInChan cannot be closed until all goroutines done
+		ackInChan = make(chan *PacketAndToken)
+		go func() { // go routine to copy from ackInChan to ackOutChan until stopped
+			for {
+				select {
+				case a := <-ackInChan:
+					ackOutChan <- a
+				case <-stopAckCopy:
+					close(ackCopyStopped) // Signal main go routine that it is safe to close ackOutChan
+					for {
+						select {
+						case <-ackInChan: // drain ackInChan to ensure all goRoutines can complete cleanly (ACK dropped)
+							DEBUG.Println(ROU, "matchAndDispatch received acknowledgment after processing stopped (ACK dropped).")
+						case <-goRoutinesDone:
+							close(ackInChan) // Nothing further should be sent (a panic is probably better than silent failure)
+							DEBUG.Println(ROU, "matchAndDispatch order=false copy goroutine exiting.")
+							return
+						}
+					}
+				}
+			}
+		}()
+	}
+
+	go func() { // Main go routine handling inbound messages
 		for message := range messages {
 			// DEBUG.Println(ROU, "matchAndDispatch received message")
 			sent := false
 			r.RLock()
-			m := messageFromPublish(message, ackFunc(ackChan, client.persist, message))
+			m := messageFromPublish(message, ackFunc(ackInChan, client.persist, message))
 			var handlers []MessageHandler
 			for e := r.routes.Front(); e != nil; e = e.Next() {
 				if e.Value.(*route).match(message.TopicName) {
@@ -146,9 +183,13 @@ func (r *router) matchAndDispatch(messages <-chan *packets.PublishPacket, order
 						handlers = append(handlers, e.Value.(*route).callback)
 					} else {
 						hd := e.Value.(*route).callback
+						wg.Add(1)
 						go func() {
 							hd(client, m)
-							m.Ack()
+							if !client.options.AutoAckDisabled {
+								m.Ack()
+							}
+							wg.Done()
 						}()
 					}
 					sent = true
@@ -159,9 +200,13 @@ func (r *router) matchAndDispatch(messages <-chan *packets.PublishPacket, order
 					if order {
 						handlers = append(handlers, r.defaultHandler)
 					} else {
+						wg.Add(1)
 						go func() {
 							r.defaultHandler(client, m)
-							m.Ack()
+							if !client.options.AutoAckDisabled {
+								m.Ack()
+							}
+							wg.Done()
 						}()
 					}
 				} else {
@@ -171,12 +216,24 @@ func (r *router) matchAndDispatch(messages <-chan *packets.PublishPacket, order
 			r.RUnlock()
 			for _, handler := range handlers {
 				handler(client, m)
-				m.Ack()
+				if !client.options.AutoAckDisabled {
+					m.Ack()
+				}
 			}
 			// DEBUG.Println(ROU, "matchAndDispatch handled message")
 		}
-		close(ackChan)
+		if order {
+			close(ackOutChan)
+		} else { // Ensure that nothing further will be written to ackOutChan before closing it
+			close(stopAckCopy)
+			<-ackCopyStopped
+			close(ackOutChan)
+			go func() {
+				wg.Wait() // Note: If this remains running then the user has handlers that are not returning
+				close(goRoutinesDone)
+			}()
+		}
 		DEBUG.Println(ROU, "matchAndDispatch exiting")
 	}()
-	return ackChan
+	return ackOutChan
 }