Changeset 284 in code for trunk

Timestamp:

May 1, 2020, 1:18:14 PM (5 years ago)

Author:

contact

Message:

Add support for detached channels

Channels can now be detached by leaving them with the reason "detach",
and re-attached by joining them again. Upon detaching the channel is
no longer forwarded to downstream connections. Upon re-attaching the
history buffer is sent.

Location:

trunk

Files:

• db.go (modified) (6 diffs)
• doc/soju.1.scd (modified) (1 diff)
• downstream.go (modified) (4 diffs)
• upstream.go (modified) (3 diffs)
• user.go (modified) (2 diffs)

trunk/db.go

@@ -44 +44 @@
 
 type Channel struct {
-        ID   int64
-        Name string
-        Key  string
+        ID       int64
+        Name     string
+        Key      string
+        Detached bool
 }
 
@@ -77 +78 @@
         name VARCHAR(255) NOT NULL,
         key VARCHAR(255),
+        detached INTEGER NOT NULL DEFAULT 0,
         FOREIGN KEY(network) REFERENCES Network(id),
         UNIQUE(network, name)
@@ -85 +87 @@
         "", // migration #0 is reserved for schema initialization
         "ALTER TABLE Network ADD COLUMN connect_commands VARCHAR(1023)",
+        "ALTER TABLE Channel ADD COLUMN detached INTEGER NOT NULL DEFAULT 0",
 }
 
@@ -347 +350 @@
         defer db.lock.RUnlock()
 
-        rows, err := db.db.Query("SELECT id, name, key FROM Channel WHERE network = ?", networkID)
+        rows, err := db.db.Query(`SELECT id, name, key, detached
+                FROM Channel
+                WHERE network = ?`, networkID)
         if err != nil {
                 return nil, err
@@ -357 +362 @@
                 var ch Channel
                 var key *string
-                if err := rows.Scan(&ch.ID, &ch.Name, &key); err != nil {
+                if err := rows.Scan(&ch.ID, &ch.Name, &key, &ch.Detached); err != nil {
                         return nil, err
                 }
@@ -379 +384 @@
         if ch.ID != 0 {
                 _, err = db.db.Exec(`UPDATE Channel
-                        SET network = ?, name = ?, key = ?
-                        WHERE id = ?`, networkID, ch.Name, key, ch.ID)
+                        SET network = ?, name = ?, key = ?, detached = ?
+                        WHERE id = ?`,
+                        networkID, ch.Name, key, ch.Detached, ch.ID)
         } else {
                 var res sql.Result
-                res, err = db.db.Exec(`INSERT INTO Channel(network, name, key)
-                        VALUES (?, ?, ?)`, networkID, ch.Name, key)
+                res, err = db.db.Exec(`INSERT INTO Channel(network, name, key, detached)
+                        VALUES (?, ?, ?, ?)`,
+                        networkID, ch.Name, key, ch.Detached)
                 if err != nil {
                         return err

trunk/doc/soju.1.scd

@@ -24 +24 @@
 the next connection. When registering or authenticating with NickServ, the
 credentials will be saved and automatically used on the next connection if the
-server supports SASL.
+server supports SASL. When parting a channel with the reason "detach", the
+channel will be detached instead of being left.
 
 When all clients are disconnected from the bouncer, the user is automatically

trunk/downstream.go

@@ -768 +768 @@
         dc.forEachUpstream(func(uc *upstreamConn) {
                 for _, ch := range uc.channels {
-                        if ch.complete {
-                                dc.SendMessage(&irc.Message{
-                                        Prefix:  dc.prefix(),
-                                        Command: "JOIN",
-                                        Params:  []string{dc.marshalEntity(ch.conn.network, ch.Name)},
-                                })
-
-                                forwardChannel(dc, ch)
-                        }
+                        if !ch.complete {
+                                continue
+                        }
+                        if record, ok := uc.network.channels[ch.Name]; ok && record.Detached {
+                                continue
+                        }
+
+                        dc.SendMessage(&irc.Message{
+                                Prefix:  dc.prefix(),
+                                Command: "JOIN",
+                                Params:  []string{dc.marshalEntity(ch.conn.network, ch.Name)},
+                        })
+
+                        forwardChannel(dc, ch)
                 }
         })
@@ -794 +799 @@
 func (dc *downstreamConn) sendNetworkHistory(net *network) {
         for target, history := range net.history {
+                if ch, ok := net.channels[target]; ok && ch.Detached {
+                        continue
+                }
+
                 seq, ok := history.offlineClients[dc.clientName]
                 if !ok {
@@ -946 +955 @@
                         })
 
-                        ch := &Channel{Name: upstreamName, Key: key}
+                        ch := &Channel{Name: upstreamName, Key: key, Detached: false}
                         if err := uc.network.createUpdateChannel(ch); err != nil {
                                 dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
@@ -968 +977 @@
                         }
 
-                        params := []string{upstreamName}
-                        if reason != "" {
-                                params = append(params, reason)
-                        }
-                        uc.SendMessage(&irc.Message{
-                                Command: "PART",
-                                Params:  params,
-                        })
-
-                        if err := uc.network.deleteChannel(upstreamName); err != nil {
-                                dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
+                        if strings.EqualFold(reason, "detach") {
+                                ch := &Channel{Name: upstreamName, Detached: true}
+                                if err := uc.network.createUpdateChannel(ch); err != nil {
+                                        dc.logger.Printf("failed to detach channel %q: %v", upstreamName, err)
+                                }
+                        } else {
+                                params := []string{upstreamName}
+                                if reason != "" {
+                                        params = append(params, reason)
+                                }
+                                uc.SendMessage(&irc.Message{
+                                        Command: "PART",
+                                        Params:  params,
+                                })
+
+                                if err := uc.network.deleteChannel(upstreamName); err != nil {
+                                        dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
+                                }
                         }
                 }

trunk/upstream.go

@@ -1406 +1406 @@
 // appendHistory appends a message to the history. entity can be empty.
 func (uc *upstreamConn) appendHistory(entity string, msg *irc.Message) {
+        detached := false
+        if ch, ok := uc.network.channels[entity]; ok {
+                detached = ch.Detached
+        }
+
         // If no client is offline, no need to append the message to the buffer
-        if len(uc.network.offlineClients) == 0 {
+        if len(uc.network.offlineClients) == 0 && !detached {
                 return
         }
@@ -1421 +1426 @@
                 for clientName, _ := range uc.network.offlineClients {
                         history.offlineClients[clientName] = 0
+                }
+
+                if detached {
+                        // If the channel is detached, online clients act as offline
+                        // clients too
+                        uc.forEachDownstream(func(dc *downstreamConn) {
+                                history.offlineClients[dc.clientName] = 0
+                        })
                 }
         }
@@ -1439 +1452 @@
         uc.appendHistory(target, msg)
 
+        // Don't forward messages if it's a detached channel
+        if ch, ok := uc.network.channels[target]; ok && ch.Detached {
+                return
+        }
+
         uc.forEachDownstream(func(dc *downstreamConn) {
                 if dc != origin || dc.caps["echo-message"] {

trunk/user.go

@@ -151 +151 @@
                 return err
         }
+        prev := net.channels[ch.Name]
         net.channels[ch.Name] = ch
+
+        if prev != nil && prev.Detached != ch.Detached {
+                history := net.history[ch.Name]
+                if ch.Detached {
+                        net.user.srv.Logger.Printf("network %q: detaching channel %q", net.GetName(), ch.Name)
+                        net.forEachDownstream(func(dc *downstreamConn) {
+                                net.offlineClients[dc.clientName] = struct{}{}
+                                if history != nil {
+                                        history.offlineClients[dc.clientName] = history.ring.Cur()
+                                }
+
+                                dc.SendMessage(&irc.Message{
+                                        Prefix:  dc.prefix(),
+                                        Command: "PART",
+                                        Params:  []string{dc.marshalEntity(net, ch.Name), "Detach"},
+                                })
+                        })
+                } else {
+                        net.user.srv.Logger.Printf("network %q: attaching channel %q", net.GetName(), ch.Name)
+
+                        var uch *upstreamChannel
+                        if net.conn != nil {
+                                uch = net.conn.channels[ch.Name]
+                        }
+
+                        net.forEachDownstream(func(dc *downstreamConn) {
+                                dc.SendMessage(&irc.Message{
+                                        Prefix:  dc.prefix(),
+                                        Command: "JOIN",
+                                        Params:  []string{dc.marshalEntity(net, ch.Name)},
+                                })
+
+                                if uch != nil {
+                                        forwardChannel(dc, uch)
+                                }
+
+                                if history != nil {
+                                        dc.sendNetworkHistory(net)
+                                }
+                        })
+                }
+        }
+
         return nil
 }
@@ -343 +387 @@
 
                                 net.offlineClients[dc.clientName] = struct{}{}
-                                for _, history := range net.history {
+                                for target, history := range net.history {
+                                        if ch, ok := net.channels[target]; ok && ch.Detached {
+                                                continue
+                                        }
                                         history.offlineClients[dc.clientName] = history.ring.Cur()
                                 }