a246104d04
* MM-21012: Revamp websocket implementation We replace the old gorilla/websocket implementation with the gobwas/ws library. The gorilla library was in maintenance mode and had a high level API due to which we cannot use that for situations where a large number of concurrent connections needs to be supported. The ws library is a very low-level library that allows us to work with raw net.Conns. We make several improvements: - We completely remove the reader goroutines, and instead replace them with a manual epoll implementation which sends off messages to be read when it receives any data on the connection. This lets us scale to a much larger number of connections. - The reader buffer is eliminated, because we directly read from the connection now. https://mattermost.atlassian.net/browse/MM-21012 ```release-notes Improved the websocket implementation by using epoll manually to read from a websocket. As a result, the number of goroutines is expected to go down by half. ``` * fix tests * fix shadowing errors * final changes * windows support! * Remove pointer to waitgroup * Fix edge case * Trigger CI * Trigger CI Co-authored-by: Mattermod <mattermod@users.noreply.github.com>
60 строки
1.4 KiB
Go
60 строки
1.4 KiB
Go
// +build !pool_sanitize
|
|
|
|
package pbytes
|
|
|
|
import "github.com/gobwas/pool"
|
|
|
|
// Pool contains logic of reusing byte slices of various size.
|
|
type Pool struct {
|
|
pool *pool.Pool
|
|
}
|
|
|
|
// New creates new Pool that reuses slices which size is in logarithmic range
|
|
// [min, max].
|
|
//
|
|
// Note that it is a shortcut for Custom() constructor with Options provided by
|
|
// pool.WithLogSizeMapping() and pool.WithLogSizeRange(min, max) calls.
|
|
func New(min, max int) *Pool {
|
|
return &Pool{pool.New(min, max)}
|
|
}
|
|
|
|
// New creates new Pool with given options.
|
|
func Custom(opts ...pool.Option) *Pool {
|
|
return &Pool{pool.Custom(opts...)}
|
|
}
|
|
|
|
// Get returns probably reused slice of bytes with at least capacity of c and
|
|
// exactly len of n.
|
|
func (p *Pool) Get(n, c int) []byte {
|
|
if n > c {
|
|
panic("requested length is greater than capacity")
|
|
}
|
|
|
|
v, x := p.pool.Get(c)
|
|
if v != nil {
|
|
bts := v.([]byte)
|
|
bts = bts[:n]
|
|
return bts
|
|
}
|
|
|
|
return make([]byte, n, x)
|
|
}
|
|
|
|
// Put returns given slice to reuse pool.
|
|
// It does not reuse bytes whose size is not power of two or is out of pool
|
|
// min/max range.
|
|
func (p *Pool) Put(bts []byte) {
|
|
p.pool.Put(bts, cap(bts))
|
|
}
|
|
|
|
// GetCap returns probably reused slice of bytes with at least capacity of n.
|
|
func (p *Pool) GetCap(c int) []byte {
|
|
return p.Get(0, c)
|
|
}
|
|
|
|
// GetLen returns probably reused slice of bytes with at least capacity of n
|
|
// and exactly len of n.
|
|
func (p *Pool) GetLen(n int) []byte {
|
|
return p.Get(n, n)
|
|
}
|