Merge branch 'master' of github.com:The-K-R-O-K/flow-go into illia-malachyn/6635-tests-for-websocket-controller

Author: Guitarheroua

Makefile

@@ -205,6 +205,7 @@ generate-mocks: install-mock-generators
 	mockery --name 'BlockTracker' --dir="./engine/access/subscription" --case=underscore --output="./engine/access/subscription/mock"  --outpkg="mock"
 	mockery --name 'DataProvider' --dir="./engine/access/rest/websockets/data_providers" --case=underscore --output="./engine/access/rest/websockets/data_providers/mock"  --outpkg="mock"
 	mockery --name 'DataProviderFactory' --dir="./engine/access/rest/websockets/data_providers" --case=underscore --output="./engine/access/rest/websockets/data_providers/mock"  --outpkg="mock"
+	mockery --name 'WebsocketConnection' --dir="./engine/access/rest/websockets" --case=underscore --output="./engine/access/rest/websockets/mock"  --outpkg="mock"
 	mockery --name 'ExecutionDataTracker' --dir="./engine/access/subscription" --case=underscore --output="./engine/access/subscription/mock"  --outpkg="mock"
 	mockery --name 'ConnectionFactory' --dir="./engine/access/rpc/connection" --case=underscore --output="./engine/access/rpc/connection/mock" --outpkg="mock"
 	mockery --name 'Communicator' --dir="./engine/access/rpc/backend" --case=underscore --output="./engine/access/rpc/backend/mock" --outpkg="mock"

engine/access/rest/websockets/config.go

@@ -4,6 +4,33 @@ import (
 	"time"
 )
 
+const (
+	// PingPeriod defines the interval at which ping messages are sent to the client.
+	// This value must be less than pongWait, cause it that case the server ensures it sends a ping well before the PongWait
+	// timeout elapses. Each new pong message resets the server's read deadline, keeping the connection alive as long as
+	// the client is responsive.
+	//
+	// Example:
+	// At t=9, the server sends a ping, initial read deadline is t=10 (for the first message)
+	// At t=10, the client responds with a pong. The server resets its read deadline to t=20.
+	// At t=18, the server sends another ping. If the client responds with a pong at t=19, the read deadline is extended to t=29.
+	//
+	// In case of failure:
+	// If the client stops responding, the server will send a ping at t=9 but won't receive a pong by t=10. The server then closes the connection.
+	PingPeriod = (PongWait * 9) / 10
+
+	// PongWait specifies the maximum time to wait for a pong response message from the peer
+	// after sending a ping
+	PongWait = 10 * time.Second
+
+	// WriteWait specifies a timeout for the write operation. If the write
+	// isn't completed within this duration, it fails with a timeout error.
+	// SetWriteDeadline ensures the write operation does not block indefinitely
+	// if the client is slow or unresponsive. This prevents resource exhaustion
+	// and allows the server to gracefully handle timeouts for delayed writes.
+	WriteWait = 10 * time.Second
+)
+
 type Config struct {
 	MaxSubscriptionsPerConnection uint64
 	MaxResponsesPerSecond         uint64

engine/access/rest/websockets/connection.go

@@ -1,42 +1,57 @@
 package websockets
 
 import (
+	"time"
+
 	"github.com/gorilla/websocket"
 )
 
-// We wrap gorilla's websocket connection with interface
-// to be able to mock it in order to test the types dependent on it
-
 type WebsocketConnection interface {
 	ReadJSON(v interface{}) error
 	WriteJSON(v interface{}) error
+	WriteControl(messageType int, deadline time.Time) error
 	Close() error
+	SetReadDeadline(deadline time.Time) error
+	SetWriteDeadline(deadline time.Time) error
+	SetPongHandler(h func(string) error)
 }
 
-type GorillaWebsocketConnection struct {
+type WebsocketConnectionImpl struct {
 	conn *websocket.Conn
 }
 
-func NewGorillaWebsocketConnection(conn *websocket.Conn) *GorillaWebsocketConnection {
-	return &GorillaWebsocketConnection{
+func NewWebsocketConnection(conn *websocket.Conn) *WebsocketConnectionImpl {
+	return &WebsocketConnectionImpl{
 		conn: conn,
 	}
 }
 
-var _ WebsocketConnection = (*GorillaWebsocketConnection)(nil)
+var _ WebsocketConnection = (*WebsocketConnectionImpl)(nil)
+
+func (c *WebsocketConnectionImpl) ReadJSON(v interface{}) error {
+	return c.conn.ReadJSON(v)
+}
+
+func (c *WebsocketConnectionImpl) WriteJSON(v interface{}) error {
+	return c.conn.WriteJSON(v)
+}
+
+func (c *WebsocketConnectionImpl) WriteControl(messageType int, deadline time.Time) error {
+	return c.conn.WriteControl(messageType, nil, deadline)
+}
 
-func (m *GorillaWebsocketConnection) ReadJSON(v interface{}) error {
-	return m.conn.ReadJSON(v)
+func (c *WebsocketConnectionImpl) Close() error {
+	return c.conn.Close()
 }
 
-func (m *GorillaWebsocketConnection) WriteJSON(v interface{}) error {
-	return m.conn.WriteJSON(v)
+func (c *WebsocketConnectionImpl) SetReadDeadline(deadline time.Time) error {
+	return c.conn.SetReadDeadline(deadline)
 }
 
-func (m *GorillaWebsocketConnection) SetCloseHandler(handler func(code int, text string) error) {
-	m.conn.SetCloseHandler(handler)
+func (c *WebsocketConnectionImpl) SetWriteDeadline(deadline time.Time) error {
+	return c.conn.SetWriteDeadline(deadline)
 }
 
-func (m *GorillaWebsocketConnection) Close() error {
-	return m.conn.Close()
+func (c *WebsocketConnectionImpl) SetPongHandler(h func(string) error) {
+	c.conn.SetPongHandler(h)
 }