Changeset 280 in code for trunk/conn.go

Timestamp:

Apr 30, 2020, 8:35:02 AM (5 years ago)

Author:

contact

Message:

Use a lock to protect conn.{closed,outgoing}

Unfortunately, I don't think there's a good way to implement net.Conn
semantics on top of channels. The Close and SendMessage methods should
gracefully fail without panicking if the connection is already closed.
Using only channels leads to race conditions.

We could remove the lock if Close and SendMessage are only called from a
single goroutine. However that's not the case right now.

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

File:

• trunk/conn.go (modified) (5 diffs)

trunk/conn.go

@@ -4 +4 @@
         "fmt"
         "net"
+        "sync"
         "time"
 
@@ -21 +22 @@
 
 type conn struct {
-        net      net.Conn
-        irc      *irc.Conn
-        srv      *Server
-        logger   Logger
+        net    net.Conn
+        irc    *irc.Conn
+        srv    *Server
+        logger Logger
+
+        lock     sync.Mutex
         outgoing chan<- *irc.Message
-        closed   chan struct{}
+        closed   bool
 }
 
@@ -39 +42 @@
                 outgoing: outgoing,
                 logger:   logger,
-                closed:   make(chan struct{}),
         }
 
@@ -69 +71 @@
 
 func (c *conn) isClosed() bool {
-        select {
-        case <-c.closed:
-                return true
-        default:
-                return false
-        }
+        c.lock.Lock()
+        defer c.lock.Unlock()
+        return c.closed
 }
 
 // Close closes the connection. It is safe to call from any goroutine.
 func (c *conn) Close() error {
-        if c.isClosed() {
+        c.lock.Lock()
+        defer c.lock.Unlock()
+
+        if c.closed {
                 return fmt.Errorf("connection already closed")
         }
-        close(c.closed)
+
+        c.closed = true
         close(c.outgoing)
         return nil
@@ -102 +105 @@
 // SendMessage queues a new outgoing message. It is safe to call from any
 // goroutine.
+//
+// If the connection is closed before the message is sent, SendMessage silently
+// drops the message.
 func (c *conn) SendMessage(msg *irc.Message) {
-        if c.isClosed() {
+        c.lock.Lock()
+        defer c.lock.Unlock()
+
+        if c.closed {
                 return
         }