How to fix buffered write sigterm in gorilla websocket?

I'm writing a websocket client in Go that sends out a control message to request a data stream and then processes the incoming data using a custom message hander. I thought this would be pretty standard, but meanwhile I am debugging this for quite some time.

The app uses multiple websockets for handling different streams, therefore I have encapsulated the web socket client into a separate struct to isolate everything.

The code listing is quite verbose, so I made a gist with a self contained test.

The critical part though are the struct init & write function, as shown below.

// WebSocketClient return websocket client connection
type WebSocketClient struct {
	url       string
	sendBuf   chan []byte
	ctx       context.Context
	ctxCancel context.CancelFunc
	mu        sync.RWMutex
	wsconn    *websocket.Conn
}

// NewWebSocketClient create new websocket connection
func NewWebSocketClient(url string, messageHandler WsHandler, errorHandler WsErrHandler) (*WebSocketClient, error) {
	client := new(WebSocketClient)
	client.ctx, client.ctxCancel = context.WithCancel(context.Background())
	client.url = url
	client.sendBuf = make(chan []byte, 1)

	go client.listen(messageHandler, errorHandler)
	go client.listenWrite()
	go client.ping()
	return client, nil
}

...
// Write data to the websocket server
func (conn *WebSocketClient) Write(data []byte) error {
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*150)
	defer cancel()

	for {
		select {
		case conn.sendBuf <- data: // : runtime error: invalid memory address or nil pointer dereference
			return nil
		case <-ctx.Done():
			return fmt.Errorf("context canceled")
		}
	}
}

func (conn *WebSocketClient) listenWrite() {
	for data := range conn.sendBuf {
		ws := conn.Connect()
		if ws == nil {
			err := fmt.Errorf("conn.ws is nil")
			logError(err)
			log.Println("listenWrite No websocket connection")
			continue
		}

		if err := ws.WriteMessage(
			websocket.TextMessage,
			data,
		); err != nil {
			log.Println("listenWrite", nil, "WebSocket Write Error")
		}
	}
}

The strange thing I am observing:

• If the mutex & send buffer are part of the struct, I get sigterms all over the place

• When the mutex & send buffer are declared as var outside the struct, reading & writing works nicely, but closing the connection ends with a sigtmerm....

I am bit perplex and have no practical explanation, but because the client gets embedded into a microservice, a proper connection close would be welcome.

The other thing is, as seen in the test, I get frequently the following warning;

" use of closed network connection Cannot read websocket message"

Honestly, I think this code isn't right in the first place, but I haven't found a simpler and more robust solution yet.

Any pointers towards how write a robust web socket client that can run in multiple instances with each one handling read/ write connection to a different web sockets?

A couple of things:

• closeWS misuses the Mutex

it acquires the lock at the top of the function - but there's return points where the lock will not be released. Just put this at the top of the function:

conn.mu.Lock()
defer conn.mu.Unlock()

When you close the client in your test - this will presumable cancel the connnection context etc. - but in your listener loop the context cancelation is only polled outside the connection/read/processing:

for {
	select {
	case <-conn.ctx.Done():
		return
	case <-ticker.C:
		for {
			// get conn
            // get msg
            // process msg
		}
	}
}

if you want to avoid seeing a connection close error message - recheck the context cancelation like so:

ws := conn.Connect()
if ws == nil {
	return
}

_, bytMsg, err := ws.ReadMessage()
if err != nil {

    // poll context cancelation again - as this may be the real reason for the error
    select {
    case <-conn.ctx.Done():
	    return
    default:
    }

    errorHandler(err)
    log.Println("listen", err, "Cannot read websocket message")
    conn.closeWs()
	return
}