Changeset 253 in code for trunk/user.go

Timestamp:

Apr 10, 2020, 5:22:47 PM (5 years ago)

Author:

contact

Message:

Per-entity ring buffers

Instead of having one ring buffer per network, each network has one ring
buffer per entity (channel or nick). This allows history to be more
fair: if there's a lot of activity in a channel, it won't prune activity
in other channels.

We now track history sequence numbers per client and per network in
networkHistory. The overall list of offline clients is still tracked in
network.offlineClients.

When all clients have received history, the ring buffer can be released.

In the future, we should get rid of too-old offline clients to avoid
having to maintain history for them forever. We should also add a
per-user limit on the number of ring buffers.

File:

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

trunk/user.go

@@ -46 +46 @@
 }
 
+type networkHistory struct {
+        offlineClients map[string]uint64 // indexed by client name
+        ring           *Ring             // can be nil if there are no offline clients
+}
+
 type network struct {
         Network
         user    *user
-        ring    *Ring
         stopped chan struct{}
 
-        conn      *upstreamConn
-        history   map[string]uint64
-        lastError error
+        conn           *upstreamConn
+        history        map[string]*networkHistory // indexed by entity
+        offlineClients map[string]struct{}        // indexed by client name
+        lastError      error
 }
 
 func newNetwork(user *user, record *Network) *network {
         return &network{
-                Network: *record,
-                user:    user,
-                ring:    NewRing(user.srv.RingCap),
-                stopped: make(chan struct{}),
-                history: make(map[string]uint64),
+                Network:        *record,
+                user:           user,
+                stopped:        make(chan struct{}),
+                history:        make(map[string]*networkHistory),
+                offlineClients: make(map[string]struct{}),
         }
 }
@@ -295 +300 @@
                         dc := e.dc
 
-                        dc.forEachNetwork(func(net *network) {
-                                seq := net.ring.Cur()
-                                net.history[dc.clientName] = seq
-                        })
-
                         for i := range u.downstreamConns {
                                 if u.downstreamConns[i] == dc {
@@ -306 +306 @@
                                 }
                         }
+
+                        // Save history if we're the last client with this name
+                        skipHistory := make(map[*network]bool)
+                        u.forEachDownstream(func(conn *downstreamConn) {
+                                if dc.clientName == conn.clientName {
+                                        skipHistory[conn.network] = true
+                                }
+                        })
+
+                        dc.forEachNetwork(func(net *network) {
+                                if skipHistory[net] || skipHistory[nil] {
+                                        return
+                                }
+
+                                net.offlineClients[dc.clientName] = struct{}{}
+                                for _, history := range net.history {
+                                        history.offlineClients[dc.clientName] = history.ring.Cur()
+                                }
+                        })
 
                         u.forEachUpstream(func(uc *upstreamConn) {