mirror of
https://github.com/status-im/status-go.git
synced 2025-01-09 14:16:21 +00:00
eeca435064
Update vendor Integrate rendezvous into status node Add a test with failover using rendezvous Use multiple servers in client Use discovery V5 by default and test that node can be started with rendezvous discovet Fix linter Update rendezvous client to one with instrumented stream Address feedback Fix test with updated topic limits Apply several suggestions Change log to debug for request errors because we continue execution Remove web3js after rebase Update rendezvous package
104 lines
2.9 KiB
Go
104 lines
2.9 KiB
Go
// Copyright 2017 The Gorilla WebSocket Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package websocket
|
|
|
|
import (
|
|
"bytes"
|
|
"net"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// PreparedMessage caches on the wire representations of a message payload.
|
|
// Use PreparedMessage to efficiently send a message payload to multiple
|
|
// connections. PreparedMessage is especially useful when compression is used
|
|
// because the CPU and memory expensive compression operation can be executed
|
|
// once for a given set of compression options.
|
|
type PreparedMessage struct {
|
|
messageType int
|
|
data []byte
|
|
err error
|
|
mu sync.Mutex
|
|
frames map[prepareKey]*preparedFrame
|
|
}
|
|
|
|
// prepareKey defines a unique set of options to cache prepared frames in PreparedMessage.
|
|
type prepareKey struct {
|
|
isServer bool
|
|
compress bool
|
|
compressionLevel int
|
|
}
|
|
|
|
// preparedFrame contains data in wire representation.
|
|
type preparedFrame struct {
|
|
once sync.Once
|
|
data []byte
|
|
}
|
|
|
|
// NewPreparedMessage returns an initialized PreparedMessage. You can then send
|
|
// it to connection using WritePreparedMessage method. Valid wire
|
|
// representation will be calculated lazily only once for a set of current
|
|
// connection options.
|
|
func NewPreparedMessage(messageType int, data []byte) (*PreparedMessage, error) {
|
|
pm := &PreparedMessage{
|
|
messageType: messageType,
|
|
frames: make(map[prepareKey]*preparedFrame),
|
|
data: data,
|
|
}
|
|
|
|
// Prepare a plain server frame.
|
|
_, frameData, err := pm.frame(prepareKey{isServer: true, compress: false})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// To protect against caller modifying the data argument, remember the data
|
|
// copied to the plain server frame.
|
|
pm.data = frameData[len(frameData)-len(data):]
|
|
return pm, nil
|
|
}
|
|
|
|
func (pm *PreparedMessage) frame(key prepareKey) (int, []byte, error) {
|
|
pm.mu.Lock()
|
|
frame, ok := pm.frames[key]
|
|
if !ok {
|
|
frame = &preparedFrame{}
|
|
pm.frames[key] = frame
|
|
}
|
|
pm.mu.Unlock()
|
|
|
|
var err error
|
|
frame.once.Do(func() {
|
|
// Prepare a frame using a 'fake' connection.
|
|
// TODO: Refactor code in conn.go to allow more direct construction of
|
|
// the frame.
|
|
mu := make(chan bool, 1)
|
|
mu <- true
|
|
var nc prepareConn
|
|
c := &Conn{
|
|
conn: &nc,
|
|
mu: mu,
|
|
isServer: key.isServer,
|
|
compressionLevel: key.compressionLevel,
|
|
enableWriteCompression: true,
|
|
writeBuf: make([]byte, defaultWriteBufferSize+maxFrameHeaderSize),
|
|
}
|
|
if key.compress {
|
|
c.newCompressionWriter = compressNoContextTakeover
|
|
}
|
|
err = c.WriteMessage(pm.messageType, pm.data)
|
|
frame.data = nc.buf.Bytes()
|
|
})
|
|
return pm.messageType, frame.data, err
|
|
}
|
|
|
|
type prepareConn struct {
|
|
buf bytes.Buffer
|
|
net.Conn
|
|
}
|
|
|
|
func (pc *prepareConn) Write(p []byte) (int, error) { return pc.buf.Write(p) }
|
|
func (pc *prepareConn) SetWriteDeadline(t time.Time) error { return nil }
|