Changeset 218 in code for trunk/user.go

Timestamp:

Apr 4, 2020, 3:33:09 PM (5 years ago)

Author:

delthas

Message:

Send one NOTICE on new upstream disconnect/connect errors

In order to notify the user when we are disconnected from a network
(either due to an error, or due a QUIT), and when we fail reconnecting,
this commit adds support for sending a short NOTICE message from the
service user to all relevant downstreams.

The last error is stored, and cleared on successful connection, to
ensure that the user is *not* flooded with identical connection error
messages, which can often happen when a server is down.

No lock is needed on lastError because it is only read and modified from
the user goroutine.

Closes: ​https://todo.sr.ht/~emersion/soju/27

File:

• trunk/user.go (modified) (10 diffs)

trunk/user.go

@@ -2 +2 @@
 
 import (
+        "fmt"
         "sync"
         "time"
@@ -15 +16 @@
 }
 
+type eventUpstreamConnectionError struct {
+        net *network
+        err error
+}
+
 type eventUpstreamConnected struct {
         uc *upstreamConn
@@ -21 +27 @@
 type eventUpstreamDisconnected struct {
         uc *upstreamConn
+}
+
+type eventUpstreamError struct {
+        uc  *upstreamConn
+        err error
 }
 
@@ -42 +53 @@
         stopped chan struct{}
 
-        history map[string]uint64
+        history   map[string]uint64
+        lastError error
 
         lock sync.Mutex
@@ -56 +68 @@
                 history: make(map[string]uint64),
         }
+}
+
+func (net *network) forEachDownstream(f func(*downstreamConn)) {
+        net.user.forEachDownstream(func(dc *downstreamConn) {
+                if dc.network != nil && dc.network != net {
+                        return
+                }
+                f(dc)
+        })
 }
 
@@ -78 +99 @@
                 if err != nil {
                         net.user.srv.Logger.Printf("failed to connect to upstream server %q: %v", net.Addr, err)
+                        net.user.events <- eventUpstreamConnectionError{net, fmt.Errorf("failed to connect: %v", err)}
                         continue
                 }
@@ -84 +106 @@
                 if err := uc.runUntilRegistered(); err != nil {
                         uc.logger.Printf("failed to register: %v", err)
+                        net.user.events <- eventUpstreamConnectionError{net, fmt.Errorf("failed to register: %v", err)}
                         uc.Close()
                         continue
@@ -91 +114 @@
                 if err := uc.readMessages(net.user.events); err != nil {
                         uc.logger.Printf("failed to handle messages: %v", err)
+                        net.user.events <- eventUpstreamError{uc, fmt.Errorf("failed to handle messages: %v", err)}
                 }
                 uc.Close()
@@ -201 +225 @@
 
                         uc.updateAway()
+
+                        uc.forEachDownstream(func(dc *downstreamConn) {
+                                sendServiceNOTICE(dc, fmt.Sprintf("connected to %s", uc.network.Name))
+                        })
+                        uc.network.lastError = nil
                 case eventUpstreamDisconnected:
                         uc := e.uc
@@ -215 +244 @@
 
                         uc.endPendingLISTs(true)
+
+                        if uc.network.lastError == nil {
+                                uc.forEachDownstream(func(dc *downstreamConn) {
+                                        sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s", uc.network.Name))
+                                })
+                        }
+                case eventUpstreamConnectionError:
+                        net := e.net
+
+                        if net.lastError == nil || net.lastError.Error() != e.err.Error() {
+                                net.forEachDownstream(func(dc *downstreamConn) {
+                                        sendServiceNOTICE(dc, fmt.Sprintf("failed connecting/registering to %s: %v", net.Name, e.err))
+                                })
+                        }
+                        net.lastError = e.err
+                case eventUpstreamError:
+                        uc := e.uc
+
+                        uc.forEachDownstream(func(dc *downstreamConn) {
+                                sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s: %v", uc.network.Name, e.err))
+                        })
+                        uc.network.lastError = e.err
                 case eventUpstreamMessage:
                         msg, uc := e.msg, e.uc