Make ChatWorker stop-able and make sure it gets stopped

whappdc/chat_worker.go

@@ -2,16 +2,36 @@ package whappdc
 
 import "log"
 
+// ChatWorker receives structs of type MessageHandler and executes them sequentially. By
+// executing the handlers sequentially we try to make sure that the messages are sent
+// through deltachat in the right order.
 type ChatWorker struct {
 	incomingHandlers chan MessageHandler
+	quit             chan bool
+}
+
+func NewChatWorker() *ChatWorker {
+	return &ChatWorker{
+		incomingHandlers: make(chan MessageHandler, 3),
+		quit:             make(chan bool),
+	}
+}
+
+func (w *ChatWorker) HandleMessage(m MessageHandler) {
+	w.incomingHandlers <- m
+}
+
+func (w *ChatWorker) Stop() {
+	w.quit <- true
 }
 
 func (w *ChatWorker) Start() {
 	go func() {
 		for {
 			select {
+			case <-w.quit:
+				return
 			case handler := <-w.incomingHandlers:
-				log.Println("Chat worker executing action")
 				err := handler.Action()
 
 				if err != nil {

whappdc/message_worker.go

@@ -1,17 +1,18 @@
 package whappdc
 
-import "log"
-
+// MessageWorker receives structs of type MessageHandler and distributes them across chat
+// workers. Each whatsapp chat should have its own worker. If a message is encountered for
+// a chat that has no worker yet, it is created.
 type MessageWorker struct {
 	incomingHandlers chan MessageHandler
-	chatWorkers      map[string]chan MessageHandler
+	chatWorkers      map[string]*ChatWorker
 	quit             chan bool
 }
 
 func NewMessageWorker() *MessageWorker {
 	return &MessageWorker{
 		incomingHandlers: make(chan MessageHandler),
-		chatWorkers:      make(map[string]chan MessageHandler),
+		chatWorkers:      make(map[string]*ChatWorker),
 		quit:             make(chan bool),
 	}
 }
@@ -22,6 +23,10 @@ func (w *MessageWorker) HandleMessage(m MessageHandler) {
 
 func (w *MessageWorker) Stop() {
 	w.quit <- true
+
+	for _, worker := range w.chatWorkers {
+		worker.Stop()
+	}
 }
 
 func (w *MessageWorker) Start() {
@@ -31,21 +36,16 @@ func (w *MessageWorker) Start() {
 			case <-w.quit:
 				return
 			case handler := <-w.incomingHandlers:
-				log.Println("Got Handler for " + handler.Jid)
-				workerChan, ok := w.chatWorkers[handler.Jid]
+				worker, ok := w.chatWorkers[handler.Jid]
 
 				if !ok {
-					workerChan = make(chan MessageHandler)
-
-					worker := &ChatWorker{
-						incomingHandlers: workerChan,
-					}
-
+					worker = NewChatWorker()
 					worker.Start()
-					w.chatWorkers[handler.Jid] = workerChan
+
+					w.chatWorkers[handler.Jid] = worker
 				}
 
-				workerChan <- handler
+				worker.HandleMessage(handler)
 			}
 		}
 	}()