How to stop stacking on high load websocket app - go

Question

Wrote an app for collecting transactions from equities of NYSE and sending it through websocket. I am using gorilla websocket and what I have:
import (
"log"
"net/http"
"github.com/gorilla/websocket"
)
func (tm *TicksModel) websocketConnection() {
go tm.writeMessages()
http.HandleFunc("/", tm.echo)
log.Println("http server started on :", 8126)
err := http.ListenAndServe("0.0.0.0:8126", nil)
if err != nil {
log.Fatal("8126 ERROR ListenAndServe: ", err)
}
}
func (tm *TicksModel) echo(w http.ResponseWriter, r *http.Request, Collectingchan chan string) {
var (
message []byte
ticker string
sendMessage string
err error
v *websocket.Conn
i int
whichS int
tickerObj *tickerModel
ok bool
)
tm.upgrader.CheckOrigin = func(r *http.Request) bool { return true }
c, err := tm.upgrader.Upgrade(w, r, nil)
if err != nil {
log.Print("upgrade:", err)
return
}
defer c.Close()
for {
message, err = nil, nil
_, message, err = c.ReadMessage()
log.Println(">>", string(message))
if err != nil {
log.Println("ERROR", err)
tm.removeConnection(c)
return
}
if string(message) == "Client" {
log.Println("NEW CLIENT", c.RemoteAddr())
}
if message[0] == 'a' {
ticker = string(message)[1:]
tm.mx.Lock()
if tickerObj, ok = tm.Tickers[ticker]; ok {
if len(tickerObj.WSclients) == 0 {
Collectingchan <- message
}
tickerObj.WSclients = append(tickerObj.WSclients, c)
log.Println("TICK LISTENERS ADD", ticker, tickerObj)
} else {
tickerObj = &tickerModel{}
Collectingchan <- message
tickerObj.WSclients = append(tickerObj.WSclients, c)
tm.Tickers[ticker] = tickerObj
log.Println("TICK LISTENERS ADD", ticker, tickerObj)
}
tm.mx.Unlock()
} else if message[0] == 'r' {
ticker = string(message)[1:]
tm.mx.Lock()
if tickerObj, ok = tm.Tickers[ticker]; ok {
for i, v = range tickerObj.WSclients {
if v == c {
tickerObj.WSclients = append(tickerObj.WSclients[:i], tickerObj.WSclients[i+1:]...)
if len(tickerObj.WSclients) == 0 {
sendMessage = "r" + ticker + "\n"
Collectingchan <- message
}
log.Println("TICK LISTENERS REMOVE", ticker, tickerObj)
}
}
}
tm.mx.Unlock()
}
}
}
func (tm *TicksModel) writeMessages() {
var (
toWSMessage wsSendModel
tickerObj *tickerModel
wsocket *websocket.Conn
err error
ok bool
)
for {
toWSMessage = <-tm.WSocketChan
if tickerObj, ok = tm.Tickers[toWSMessage.Ticker]; ok {
for _, wsocket = range tickerObj.WSclients {
err = wsocket.WriteJSON(toWSMessage)
if err != nil {
log.Println("write error ticks", wsocket.RemoteAddr(), ":", err)
tm.removeConnection(wsocket)
}
}
}
}
}
func (tm *TicksModel) removeConnection(c *websocket.Conn) {
var (
wsocket *websocket.Conn
i int
sendMessage string
)
tm.mx.Lock()
for ticker, tickerObj := range tm.Tickers {
for i, wsocket = range tickerObj.WSclients {
if wsocket == c {
tickerObj.WSclients = append(tickerObj.WSclients[:i], tickerObj.WSclients[i+1:]...)
if len(tickerObj.WSclients) == 0 {
tm.socketChanObject.getChan(tickerObj.SocketNumber, true) <- "r" + ticker
}
log.Println("REMOVE CONNECTION FROM TICK", ticker, tickerObj)
}
}
}
tm.mx.Unlock()
}
The map looks like this:
type TicksModel struct {
Tickers map[string]*tickerModel
upgrader websocket.Upgrader
socketChanObject socketModel
WSocketChan chan wsSendModel
mx sync.Mutex
}
type tickerModel struct {
WSclients []*websocket.Conn
SocketNumber int
}
After some time, new connections connects than disconnects after a minute. Application doesn't send new data, it stacks. What do you think?