fix: lint errors (#572)

Author: sshaplygin

.github/workflows/ci.yaml

@@ -38,16 +38,16 @@ jobs:
       - name: Go Tidy
         run: go mod tidy && git diff --exit-code
 
-      - name: Go Mod
-        run: go mod download
-
       - name: Go Mod Verify
         run: go mod verify
 
       - name: Run linter
         uses: golangci/golangci-lint-action@v3
         with:
           version: latest
+          skip-cache: true
+          skip-pkg-cache: true
+          skip-build-cache: true
 
       - name: Run tests
         run: |

.golangci.yml

@@ -1,3 +1,4 @@
+# More info on config here: https://github.com/golangci/golangci-lint#config-file
 run:
   timeout: 3m
   deadline: 5m
@@ -6,3 +7,9 @@ output:
   format: colored-line-number
   print-issued-lines: true
   print-linter-name: true
+
+issues:
+  exclude-use-default: false
+  exclude:
+    # support go 1.13 with deprecated APIs
+    - SA1019

connection.go

@@ -84,7 +84,7 @@ func (c *conn) connect() error {
 	root := newNamespaceConn(c, aliasRootNamespace, rootHandler.broadcast)
 	c.namespaces.Set(rootNamespace, root)
 
-	root.Join(root.ID())
+	root.Join(root.Conn.ID())
 
 	c.namespaces.Range(func(ns string, nc *namespaceConn) {
 		nc.SetContext(c.Conn.Context())

connection_handlers.go

@@ -73,7 +73,7 @@ func connectPacketHandler(c *conn, header parser.Header) error {
 	if !ok {
 		conn = newNamespaceConn(c, header.Namespace, handler.broadcast)
 		c.namespaces.Set(header.Namespace, conn)
-		conn.Join(c.ID())
+		conn.Join(c.Conn.ID())
 	}
 
 	_, err := handler.dispatch(conn, header)

engineio/client.go

@@ -1,7 +1,6 @@
 package engineio
 
 import (
-	"fmt"
 	"io"
 	"net"
 	"net/http"
@@ -13,14 +12,9 @@ import (
 	"github.com/googollee/go-socket.io/engineio/packet"
 	"github.com/googollee/go-socket.io/engineio/session"
 	"github.com/googollee/go-socket.io/engineio/transport"
+	"github.com/googollee/go-socket.io/logger"
 )
 
-// Pauser is connection which can be paused and resumes.
-type Pauser interface {
-	Pause()
-	Resume()
-}
-
 // Opener is client connection which need receive open message first.
 type Opener interface {
 	Open() (transport.ConnParameters, error)
@@ -72,14 +66,19 @@ func (c *client) NextReader() (session.FrameType, io.ReadCloser, error) {
 			}
 
 		case packet.CLOSE:
-			c.Close()
+			if err = c.Close(); err != nil {
+				logger.Error("close client with packet close:", err)
+			}
+
 			return 0, nil, io.EOF
 
 		case packet.MESSAGE:
 			return session.FrameType(ft), r, nil
 		}
 
-		r.Close()
+		if err = r.Close(); err != nil {
+			logger.Error("close reader:", err)
+		}
 	}
 }
 
@@ -104,7 +103,11 @@ func (c *client) RemoteHeader() http.Header {
 }
 
 func (c *client) serve() {
-	defer c.conn.Close()
+	defer func() {
+		if closeErr := c.conn.Close(); closeErr != nil {
+			logger.Error("close connect:", closeErr)
+		}
+	}()
 
 	for {
 		select {
@@ -115,15 +118,19 @@ func (c *client) serve() {
 
 		w, err := c.conn.NextWriter(frame.String, packet.PING)
 		if err != nil {
+			logger.Error("get next writer with string frame and packet ping:", err)
+
 			return
 		}
 
-		if err := w.Close(); err != nil {
+		if err = w.Close(); err != nil {
+			logger.Error("close writer:", err)
+
 			return
 		}
 
 		if err = c.conn.SetWriteDeadline(time.Now().Add(c.params.PingInterval + c.params.PingTimeout)); err != nil {
-			fmt.Printf("set writer's deadline error,msg:%s\n", err.Error())
+			logger.Error("set writer deadline:", err)
 		}
 	}
 }

engineio/dialer.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/googollee/go-socket.io/engineio/packet"
 	"github.com/googollee/go-socket.io/engineio/transport"
+	"github.com/googollee/go-socket.io/logger"
 )
 
 // Dialer is dialer configure.
@@ -19,6 +20,8 @@ type Dialer struct {
 func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (Conn, error) {
 	u, err := url.Parse(urlStr)
 	if err != nil {
+		logger.Error("parse url str:", err)
+
 		return nil, err
 	}
 
@@ -30,44 +33,62 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (Conn, error) {
 
 	for i := len(d.Transports) - 1; i >= 0; i-- {
 		if conn != nil {
-			conn.Close()
+			if closeErr := conn.Close(); closeErr != nil {
+				logger.Error("close connect:", closeErr)
+			}
 		}
 
 		t := d.Transports[i]
 
 		conn, err = t.Dial(u, requestHeader)
 		if err != nil {
+			logger.Error("transport dial:", err)
+
 			continue
 		}
 
 		var params transport.ConnParameters
 		if p, ok := conn.(Opener); ok {
 			params, err = p.Open()
 			if err != nil {
+				logger.Error("open transport connect:", err)
+
 				continue
 			}
 		} else {
 			var pt packet.Type
 			var r io.ReadCloser
+
 			_, pt, r, err = conn.NextReader()
 			if err != nil {
 				continue
 			}
+
 			func() {
-				defer r.Close()
+				defer func() {
+					if closeErr := r.Close(); closeErr != nil {
+						logger.Error("close connect reader:", closeErr)
+					}
+				}()
+
 				if pt != packet.OPEN {
 					err = errors.New("invalid open")
+
 					return
 				}
+
 				params, err = transport.ReadConnParameters(r)
 				if err != nil {
 					return
 				}
 			}()
 		}
 		if err != nil {
+			logger.Error("transport dialer:", err)
+
 			continue
 		}
+
 		ret := &client{
 			conn:      conn,
 			params:    params,

engineio/packet/decoder_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/googollee/go-socket.io/engineio/frame"
 )
@@ -58,7 +59,8 @@ var tests = []struct {
 }
 
 func TestDecoder(t *testing.T) {
-	at := assert.New(t)
+	should := assert.New(t)
+	must := require.New(t)
 
 	for _, test := range tests {
 		r := NewFakeConnReader(test.frames)
@@ -67,20 +69,23 @@ func TestDecoder(t *testing.T) {
 		for {
 			ft, pt, fr, err := decoder.NextReader()
 			if err != nil {
-				at.Equal(io.EOF, err)
+				should.Equal(io.EOF, err)
 				break
 			}
+
 			b, err := ioutil.ReadAll(fr)
-			at.Nil(err)
-			fr.Close()
+			must.NoError(err)
+
+			err = fr.Close()
+			must.NoError(err)
 
 			output = append(output, Packet{
 				FType: ft,
 				PType: pt,
 				Data:  b,
 			})
 		}
-		at.Equal(test.packets, output)
+		should.Equal(test.packets, output)
 	}
 }
 
@@ -90,9 +95,24 @@ func BenchmarkDecoder(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, _, fr, _ := decoder.NextReader()
-		fr.Close()
-		_, _, fr, _ = decoder.NextReader()
-		fr.Close()
+		_, _, fr, err := decoder.NextReader()
+		if err != nil {
+			b.Error(err)
+		}
+
+		err = fr.Close()
+		if err != nil {
+			b.Error(err)
+		}
+
+		_, _, fr, err = decoder.NextReader()
+		if err != nil {
+			b.Error(err)
+		}
+
+		err = fr.Close()
+		if err != nil {
+			b.Error(err)
+		}
 	}
 }

engineio/packet/encoder.go

@@ -4,6 +4,7 @@ import (
 	"io"
 
 	"github.com/googollee/go-socket.io/engineio/frame"
+	"github.com/googollee/go-socket.io/logger"
 )
 
 // FrameWriter is the writer which supports framing.
@@ -35,7 +36,10 @@ func (e *Encoder) NextWriter(ft frame.Type, pt Type) (io.WriteCloser, error) {
 	}
 
 	if _, err := w.Write(b[:]); err != nil {
-		w.Close()
+		if closeErr := w.Close(); closeErr != nil {
+			logger.Error("close writer after write:", closeErr)
+		}
+
 		return nil, err
 	}
 

engineio/packet/encoder_test.go

@@ -32,10 +32,24 @@ func BenchmarkEncoder(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		w, _ := encoder.NextWriter(frame.String, MESSAGE)
-		w.Close()
+		w, err := encoder.NextWriter(frame.String, MESSAGE)
+		if err != nil {
+			b.Error(err)
+		}
+
+		err = w.Close()
+		if err != nil {
+			b.Error(err)
+		}
 
-		w, _ = encoder.NextWriter(frame.Binary, MESSAGE)
-		w.Close()
+		w, err = encoder.NextWriter(frame.Binary, MESSAGE)
+		if err != nil {
+			b.Error(err)
+		}
+
+		err = w.Close()
+		if err != nil {
+			b.Error(err)
+		}
 	}
 }

engineio/payload/encoder.go

@@ -61,7 +61,9 @@ func (e *encoder) Write(p []byte) (int, error) {
 
 func (e *encoder) Close() error {
 	if e.b64Writer != nil {
-		e.b64Writer.Close()
+		if err := e.b64Writer.Close(); err != nil {
+			return err
+		}
 	}
 
 	var writeHeader func() error