Changeset 313 in code for trunk/user.go

Timestamp:

Jun 4, 2020, 11:04:39 AM (5 years ago)

Author:

contact

Message:

Add network update command

The user.updateNetwork function is a bit involved because we need to
make sure that the upstream connection is closed before re-connecting
(would otherwise cause "Nick already used" errors) and that the
downstream connections' state is kept in sync.

References: ​https://todo.sr.ht/~emersion/soju/17

File:

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

trunk/user.go

@@ -273 +273 @@
 }
 
+func (u *user) getNetworkByID(id int64) *network {
+        for _, net := range u.networks {
+                if net.ID == id {
+                        return net
+                }
+        }
+        return nil
+}
+
 func (u *user) run() {
         networks, err := u.srv.db.ListNetworks(u.Username)
@@ -310 +319 @@
                         uc.network.lastError = nil
                 case eventUpstreamDisconnected:
-                        uc := e.uc
-
-                        uc.network.conn = nil
-
-                        for _, ml := range uc.messageLoggers {
-                                if err := ml.Close(); err != nil {
-                                        uc.logger.Printf("failed to close message logger: %v", err)
-                                }
-                        }
-
-                        uc.endPendingLISTs(true)
-
-                        uc.forEachDownstream(func(dc *downstreamConn) {
-                                dc.updateSupportedCaps()
-                        })
-
-                        if uc.network.lastError == nil {
-                                uc.forEachDownstream(func(dc *downstreamConn) {
-                                        sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s", uc.network.GetName()))
-                                })
-                        }
+                        u.handleUpstreamDisconnected(e.uc)
                 case eventUpstreamConnectionError:
                         net := e.net
 
-                        if net.lastError == nil || net.lastError.Error() != e.err.Error() {
+                        stopped := false
+                        select {
+                        case <-net.stopped:
+                                stopped = true
+                        default:
+                        }
+
+                        if !stopped && (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.GetName(), e.err))
@@ -426 +422 @@
 }
 
-func (u *user) createNetwork(net *Network) (*network, error) {
-        if net.ID != 0 {
+func (u *user) handleUpstreamDisconnected(uc *upstreamConn) {
+        uc.network.conn = nil
+
+        for _, ml := range uc.messageLoggers {
+                if err := ml.Close(); err != nil {
+                        uc.logger.Printf("failed to close message logger: %v", err)
+                }
+        }
+
+        uc.endPendingLISTs(true)
+
+        uc.forEachDownstream(func(dc *downstreamConn) {
+                dc.updateSupportedCaps()
+        })
+
+        if uc.network.lastError == nil {
+                uc.forEachDownstream(func(dc *downstreamConn) {
+                        sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s", uc.network.GetName()))
+                })
+        }
+}
+
+func (u *user) addNetwork(network *network) {
+        u.networks = append(u.networks, network)
+        go network.run()
+}
+
+func (u *user) removeNetwork(network *network) {
+        network.stop()
+
+        u.forEachDownstream(func(dc *downstreamConn) {
+                if dc.network != nil && dc.network == network {
+                        dc.Close()
+                }
+        })
+
+        for i, net := range u.networks {
+                if net == network {
+                        u.networks = append(u.networks[:i], u.networks[i+1:]...)
+                        return
+                }
+        }
+
+        panic("tried to remove a non-existing network")
+}
+
+func (u *user) createNetwork(record *Network) (*network, error) {
+        if record.ID != 0 {
                 panic("tried creating an already-existing network")
         }
 
-        network := newNetwork(u, net, nil)
+        network := newNetwork(u, record, nil)
         err := u.srv.db.StoreNetwork(u.Username, &network.Network)
         if err != nil {
@@ -437 +479 @@
         }
 
-        u.networks = append(u.networks, network)
-
-        go network.run()
+        u.addNetwork(network)
+
         return network, nil
 }
 
+func (u *user) updateNetwork(record *Network) (*network, error) {
+        if record.ID == 0 {
+                panic("tried updating a new network")
+        }
+
+        network := u.getNetworkByID(record.ID)
+        if network == nil {
+                panic("tried updating a non-existing network")
+        }
+
+        if err := u.srv.db.StoreNetwork(u.Username, record); err != nil {
+                return nil, err
+        }
+
+        // Most network changes require us to re-connect to the upstream server
+
+        channels := make([]Channel, 0, len(network.channels))
+        for _, ch := range network.channels {
+                channels = append(channels, *ch)
+        }
+
+        updatedNetwork := newNetwork(u, record, channels)
+
+        // If we're currently connected, disconnect and perform the necessary
+        // bookkeeping
+        if network.conn != nil {
+                network.stop()
+                // Note: this will set network.conn to nil
+                u.handleUpstreamDisconnected(network.conn)
+        }
+
+        // Patch downstream connections to use our fresh updated network
+        u.forEachDownstream(func(dc *downstreamConn) {
+                if dc.network != nil && dc.network == network {
+                        dc.network = updatedNetwork
+                }
+        })
+
+        // We need to remove the network after patching downstream connections,
+        // otherwise they'll get closed
+        u.removeNetwork(network)
+
+        // This will re-connect to the upstream server
+        u.addNetwork(updatedNetwork)
+
+        return updatedNetwork, nil
+}
+
 func (u *user) deleteNetwork(id int64) error {
-        for i, net := range u.networks {
-                if net.ID != id {
-                        continue
-                }
-
-                if err := u.srv.db.DeleteNetwork(net.ID); err != nil {
-                        return err
-                }
-
-                u.forEachDownstream(func(dc *downstreamConn) {
-                        if dc.network != nil && dc.network == net {
-                                dc.Close()
-                        }
-                })
-
-                net.stop()
-                u.networks = append(u.networks[:i], u.networks[i+1:]...)
-                return nil
-        }
-
-        panic("tried deleting a non-existing network")
+        network := u.getNetworkByID(id)
+        if network == nil {
+                panic("tried deleting a non-existing network")
+        }
+
+        if err := u.srv.db.DeleteNetwork(network.ID); err != nil {
+                return err
+        }
+
+        u.removeNetwork(network)
+        return nil
 }