Mod: add pkg/errors alias

client.go

@@ -25,7 +25,7 @@ import (
 	"github.com/AlexStocks/goext/net"
 	log "github.com/dubbogo/log4go"
 	"github.com/gorilla/websocket"
-	"github.com/pkg/errors"
+	perrors "github.com/pkg/errors"
 )
 
 const (
@@ -185,7 +185,7 @@ func (c *client) dialUDP() Session {
 		}
 		conn.SetReadDeadline(time.Now().Add(1e9))
 		length, err = conn.Read(buf)
-		if netErr, ok := errors.Cause(err).(net.Error); ok && netErr.Timeout() {
+		if netErr, ok := perrors.Cause(err).(net.Error); ok && netErr.Timeout() {
 			err = nil
 		}
 		if err != nil {

conn.go

@@ -24,7 +24,7 @@ import (
 	log "github.com/dubbogo/log4go"
 	"github.com/golang/snappy"
 	"github.com/gorilla/websocket"
-	"github.com/pkg/errors"
+	perrors "github.com/pkg/errors"
 	"golang.org/x/net/ipv4"
 	"golang.org/x/net/ipv6"
 )
@@ -32,7 +32,7 @@ import (
 var (
 	launchTime = time.Now()
 
-// ErrInvalidConnection = errors.New("connection has been closed.")
+// ErrInvalidConnection = perrors.New("connection has been closed.")
 )
 
 /////////////////////////////////////////
@@ -193,10 +193,10 @@ func (t *writeFlusher) Write(p []byte) (int, error) {
 	defer t.lock.Unlock()
 	n, err = t.flusher.Write(p)
 	if err != nil {
-		return n, errors.WithStack(err)
+		return n, perrors.WithStack(err)
 	}
 	if err := t.flusher.Flush(); err != nil {
-		return 0, errors.WithStack(err)
+		return 0, perrors.WithStack(err)
 	}
 
 	return n, nil
@@ -243,7 +243,7 @@ func (t *gettyTCPConn) read(p []byte) (int, error) {
 		currentTime = time.Now()
 		if currentTime.Sub(t.rLastDeadline) > (t.rTimeout >> 2) {
 			if err = t.conn.SetReadDeadline(currentTime.Add(t.rTimeout)); err != nil {
-				return 0, errors.WithStack(err)
+				return 0, perrors.WithStack(err)
 			}
 			t.rLastDeadline = currentTime
 		}
@@ -252,7 +252,7 @@ func (t *gettyTCPConn) read(p []byte) (int, error) {
 	length, err = t.reader.Read(p)
 	log.Debug("now:%s, length:%d, err:%s", currentTime, length, err)
 	atomic.AddUint32(&t.readBytes, uint32(length))
-	return length, errors.WithStack(err)
+	return length, perrors.WithStack(err)
 	//return length, err
 }
 
@@ -267,7 +267,7 @@ func (t *gettyTCPConn) Write(pkg interface{}) (int, error) {
 	)
 
 	if p, ok = pkg.([]byte); !ok {
-		return 0, errors.Errorf("illegal @pkg{%#v} type", pkg)
+		return 0, perrors.Errorf("illegal @pkg{%#v} type", pkg)
 	}
 	if t.compress == CompressNone && t.wTimeout > 0 {
 		// Optimization: update write deadline only if more than 25%
@@ -276,7 +276,7 @@ func (t *gettyTCPConn) Write(pkg interface{}) (int, error) {
 		currentTime = time.Now()
 		if currentTime.Sub(t.wLastDeadline) > (t.wTimeout >> 2) {
 			if err = t.conn.SetWriteDeadline(currentTime.Add(t.wTimeout)); err != nil {
-				return 0, errors.WithStack(err)
+				return 0, perrors.WithStack(err)
 			}
 			t.wLastDeadline = currentTime
 		}
@@ -286,7 +286,7 @@ func (t *gettyTCPConn) Write(pkg interface{}) (int, error) {
 		atomic.AddUint32(&t.writeBytes, (uint32)(len(p)))
 	}
 	log.Debug("now:%s, length:%d, err:%s", currentTime, length, err)
-	return length, errors.WithStack(err)
+	return length, perrors.WithStack(err)
 	//return length, err
 }
 
@@ -333,7 +333,7 @@ func setUDPSocketOptions(conn *net.UDPConn) error {
 	err6 := ipv6.NewPacketConn(conn).SetControlMessage(ipv6.FlagDst|ipv6.FlagInterface, true)
 	err4 := ipv4.NewPacketConn(conn).SetControlMessage(ipv4.FlagDst|ipv4.FlagInterface, true)
 	if err6 != nil && err4 != nil {
-		return errors.WithStack(err4)
+		return perrors.WithStack(err4)
 	}
 	return nil
 }
@@ -393,7 +393,7 @@ func (u *gettyUDPConn) read(p []byte) (int, *net.UDPAddr, error) {
 		currentTime = time.Now()
 		if currentTime.Sub(u.rLastDeadline) > (u.rTimeout >> 2) {
 			if err = u.conn.SetReadDeadline(currentTime.Add(u.rTimeout)); err != nil {
-				return 0, nil, errors.WithStack(err)
+				return 0, nil, perrors.WithStack(err)
 			}
 			u.rLastDeadline = currentTime
 		}
@@ -406,7 +406,7 @@ func (u *gettyUDPConn) read(p []byte) (int, *net.UDPAddr, error) {
 	}
 
 	//return length, addr, err
-	return length, addr, errors.WithStack(err)
+	return length, addr, perrors.WithStack(err)
 }
 
 // write udp packet, @ctx should be of type UDPContext
@@ -422,10 +422,10 @@ func (u *gettyUDPConn) Write(udpCtx interface{}) (int, error) {
 	)
 
 	if ctx, ok = udpCtx.(UDPContext); !ok {
-		return 0, errors.Errorf("illegal @udpCtx{%s} type, @udpCtx type:%T", udpCtx, udpCtx)
+		return 0, perrors.Errorf("illegal @udpCtx{%s} type, @udpCtx type:%T", udpCtx, udpCtx)
 	}
 	if buf, ok = ctx.Pkg.([]byte); !ok {
-		return 0, errors.Errorf("illegal @udpCtx.Pkg{%#v} type", udpCtx)
+		return 0, perrors.Errorf("illegal @udpCtx.Pkg{%#v} type", udpCtx)
 	}
 	if u.ss.EndPoint().EndPointType() == UDP_ENDPOINT {
 		peerAddr = ctx.PeerAddr
@@ -441,7 +441,7 @@ func (u *gettyUDPConn) Write(udpCtx interface{}) (int, error) {
 		currentTime = time.Now()
 		if currentTime.Sub(u.wLastDeadline) > (u.wTimeout >> 2) {
 			if err = u.conn.SetWriteDeadline(currentTime.Add(u.wTimeout)); err != nil {
-				return 0, errors.WithStack(err)
+				return 0, perrors.WithStack(err)
 			}
 			u.wLastDeadline = currentTime
 		}
@@ -452,7 +452,7 @@ func (u *gettyUDPConn) Write(udpCtx interface{}) (int, error) {
 	}
 	log.Debug("WriteMsgUDP(peerAddr:%s) = {length:%d, error:%s}", peerAddr, length, err)
 
-	return length, errors.WithStack(err)
+	return length, perrors.WithStack(err)
 	//return length, err
 }
 
@@ -529,7 +529,7 @@ func (w *gettyWSConn) handlePing(message string) error {
 		w.UpdateActive()
 	}
 
-	return errors.WithStack(err)
+	return perrors.WithStack(err)
 }
 
 func (w *gettyWSConn) handlePong(string) error {
@@ -550,7 +550,7 @@ func (w *gettyWSConn) read() ([]byte, error) {
 		}
 	}
 
-	return b, errors.WithStack(e)
+	return b, perrors.WithStack(e)
 	//return b, e
 }
 
@@ -567,7 +567,7 @@ func (w *gettyWSConn) updateWriteDeadline() error {
 		currentTime = time.Now()
 		if currentTime.Sub(w.wLastDeadline) > (w.wTimeout >> 2) {
 			if err = w.conn.SetWriteDeadline(currentTime.Add(w.wTimeout)); err != nil {
-				return errors.WithStack(err)
+				return perrors.WithStack(err)
 			}
 			w.wLastDeadline = currentTime
 		}
@@ -585,25 +585,25 @@ func (w *gettyWSConn) Write(pkg interface{}) (int, error) {
 	)
 
 	if p, ok = pkg.([]byte); !ok {
-		return 0, errors.Errorf("illegal @pkg{%#v} type", pkg)
+		return 0, perrors.Errorf("illegal @pkg{%#v} type", pkg)
 	}
 
 	w.updateWriteDeadline()
 	if err = w.conn.WriteMessage(websocket.BinaryMessage, p); err == nil {
 		atomic.AddUint32(&w.writeBytes, (uint32)(len(p)))
 	}
-	return len(p), errors.WithStack(err)
+	return len(p), perrors.WithStack(err)
 	//return len(p), err
 }
 
 func (w *gettyWSConn) writePing() error {
 	w.updateWriteDeadline()
-	return errors.WithStack(w.conn.WriteMessage(websocket.PingMessage, []byte{}))
+	return perrors.WithStack(w.conn.WriteMessage(websocket.PingMessage, []byte{}))
 }
 
 func (w *gettyWSConn) writePong(message []byte) error {
 	w.updateWriteDeadline()
-	return errors.WithStack(w.conn.WriteMessage(websocket.PongMessage, message))
+	return perrors.WithStack(w.conn.WriteMessage(websocket.PongMessage, message))
 }
 
 // close websocket connection

getty.go

@@ -119,9 +119,9 @@ type Connection interface {
 /////////////////////////////////////////
 
 var (
-	ErrSessionClosed  = errors.New("session Already Closed")
-	ErrSessionBlocked = errors.New("session Full Blocked")
-	ErrNullPeerAddr   = errors.New("peer address is nil")
+	ErrSessionClosed  = perrors.New("session Already Closed")
+	ErrSessionBlocked = perrors.New("session Full Blocked")
+	ErrNullPeerAddr   = perrors.New("peer address is nil")
 )
 
 type Session interface {

go.mod

@@ -16,6 +16,9 @@ require (
 	github.com/mattn/go-colorable v0.1.1 // indirect
 	github.com/pkg/errors v0.8.1
 	github.com/stretchr/testify v1.3.0 // indirect
+	go.uber.org/atomic v1.4.0 // indirect
+	go.uber.org/multierr v1.1.0 // indirect
+	go.uber.org/zap v1.10.0 // indirect
 	golang.org/x/net v0.0.0-20190320064053-1272bf9dcd53
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce // indirect

go.sum

@@ -40,6 +40,12 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+go.uber.org/atomic v1.4.0 h1:cxzIVoETapQEqDhQu3QfnvXAV4AlzcvUCxkVUFw3+EU=
+go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/multierr v1.1.0 h1:HoEmRHQPVSqub6w2z2d2EOVs2fjyFRGyofhKuyDq0QI=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/zap v1.10.0 h1:ORx85nbTijNz8ljznvCMR1ZBIPKFn3jQrag10X2AsuM=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/net v0.0.0-20190320064053-1272bf9dcd53 h1:kcXqo9vE6fsZY5X5Rd7R1l7fTgnWaDCVmln65REefiE=

server.go

@@ -26,11 +26,11 @@ import (
 	"github.com/AlexStocks/goext/time"
 	log "github.com/dubbogo/log4go"
 	"github.com/gorilla/websocket"
-	"github.com/pkg/errors"
+	perrors "github.com/pkg/errors"
 )
 
 var (
-	errSelfConnect        = errors.New("connect self!")
+	errSelfConnect        = perrors.New("connect self!")
 	serverFastFailTimeout = gxtime.TimeSecondDuration(1)
 )
 
@@ -157,7 +157,7 @@ func (s *server) listenTCP() error {
 
 	streamListener, err = net.Listen("tcp", s.addr)
 	if err != nil {
-		return errors.Wrapf(err, "net.Listen(tcp, addr:%s))", s.addr)
+		return perrors.Wrapf(err, "net.Listen(tcp, addr:%s))", s.addr)
 	}
 
 	s.streamListener = streamListener
@@ -174,14 +174,14 @@ func (s *server) listenUDP() error {
 
 	localAddr, err = net.ResolveUDPAddr("udp", s.addr)
 	if err != nil {
-		return errors.Wrapf(err, "net.ResolveUDPAddr(udp, addr:%s)", s.addr)
+		return perrors.Wrapf(err, "net.ResolveUDPAddr(udp, addr:%s)", s.addr)
 	}
 	pktListener, err = net.ListenUDP("udp", localAddr)
 	if err != nil {
-		return errors.Wrapf(err, "net.ListenUDP((udp, localAddr:%#v)", localAddr)
+		return perrors.Wrapf(err, "net.ListenUDP((udp, localAddr:%#v)", localAddr)
 	}
 	// if err = setUDPSocketOptions(pktListener); err != nil {
-	//  	return errors.Wrapf(err, "setUDPSocketOptions(pktListener:%#v)", pktListener)
+	//  	return perrors.Wrapf(err, "setUDPSocketOptions(pktListener:%#v)", pktListener)
 	// }
 
 	s.pktListener = pktListener
@@ -193,9 +193,9 @@ func (s *server) listenUDP() error {
 func (s *server) listen() error {
 	switch s.endPointType {
 	case TCP_SERVER, WS_SERVER, WSS_SERVER:
-		return errors.WithStack(s.listenTCP())
+		return perrors.WithStack(s.listenTCP())
 	case UDP_ENDPOINT:
-		return errors.WithStack(s.listenUDP())
+		return perrors.WithStack(s.listenUDP())
 	}
 
 	return nil
@@ -204,7 +204,7 @@ func (s *server) listen() error {
 func (s *server) accept(newSession NewSessionCallback) (Session, error) {
 	conn, err := s.streamListener.Accept()
 	if err != nil {
-		return nil, errors.WithStack(err)
+		return nil, perrors.WithStack(err)
 	}
 	if gxnet.IsSameAddr(conn.RemoteAddr(), conn.LocalAddr()) {
 		log.Warn("conn.localAddr{%s} == conn.RemoteAddr", conn.LocalAddr().String(), conn.RemoteAddr().String())
@@ -215,7 +215,7 @@ func (s *server) accept(newSession NewSessionCallback) (Session, error) {
 	err = newSession(ss)
 	if err != nil {
 		conn.Close()
-		return nil, errors.WithStack(err)
+		return nil, perrors.WithStack(err)
 	}
 
 	return ss, nil

session.go

@@ -22,7 +22,7 @@ import (
 import (
 	log "github.com/dubbogo/log4go"
 	"github.com/gorilla/websocket"
-	"github.com/pkg/errors"
+	perrors "github.com/pkg/errors"
 )
 
 import (
@@ -337,7 +337,7 @@ func (s *session) WritePkg(pkg interface{}, timeout time.Duration) error {
 			s.incWritePkgNum()
 			// gxlog.CError("after incWritePkgNum, ss:%s", s.Stat())
 		}
-		return errors.WithStack(err)
+		return perrors.WithStack(err)
 	}
 	select {
 	case s.wQ <- pkg:
@@ -359,7 +359,7 @@ func (s *session) WriteBytes(pkg []byte) error {
 
 	// s.conn.SetWriteTimeout(time.Now().Add(s.wTimeout))
 	if _, err := s.Connection.Write(pkg); err != nil {
-		return errors.Wrapf(err, "s.Connection.Write(pkg len:%d)", len(pkg))
+		return perrors.Wrapf(err, "s.Connection.Write(pkg len:%d)", len(pkg))
 	}
 
 	s.incWritePkgNum()
@@ -400,7 +400,7 @@ func (s *session) WriteBytesArray(pkgs ...[]byte) error {
 
 	// return s.Connection.Write(arr)
 	if err = s.WriteBytes(arr); err != nil {
-		return errors.WithStack(err)
+		return perrors.WithStack(err)
 	}
 
 	num := len(pkgs) - 1
@@ -603,7 +603,7 @@ func (s *session) handleTCPPackage() error {
 			// s.conn.SetReadTimeout(time.Now().Add(s.rTimeout))
 			bufLen, err = conn.read(buf)
 			if err != nil {
-				if netError, ok = errors.Cause(err).(net.Error); ok && netError.Timeout() {
+				if netError, ok = perrors.Cause(err).(net.Error); ok && netError.Timeout() {
 					break
 				}
 				log.Error("%s, [session.conn.read] = error:%+v", s.sessionToken(), err)
@@ -627,7 +627,7 @@ func (s *session) handleTCPPackage() error {
 			// pkg, err = s.pkgHandler.Read(s, pktBuf)
 			pkg, pkgLen, err = s.reader.Read(s, pktBuf.Bytes())
 			if err == nil && s.maxMsgLen > 0 && pkgLen > int(s.maxMsgLen) {
-				err = errors.Errorf("pkgLen %d > session max message len %d", pkgLen, s.maxMsgLen)
+				err = perrors.Errorf("pkgLen %d > session max message len %d", pkgLen, s.maxMsgLen)
 			}
 			if err != nil {
 				log.Warn("%s, [session.handleTCPPackage] = len{%d}, error:%+v",
@@ -649,7 +649,7 @@ func (s *session) handleTCPPackage() error {
 		}
 	}
 
-	return errors.WithStack(err)
+	return perrors.WithStack(err)
 }
 
 // get package from udp packet
@@ -679,13 +679,13 @@ func (s *session) handleUDPPackage() error {
 
 		bufLen, addr, err = conn.read(buf)
 		log.Debug("conn.read() = bufLen:%d, addr:%#v, err:%+v", bufLen, addr, err)
-		if netError, ok = errors.Cause(err).(net.Error); ok && netError.Timeout() {
+		if netError, ok = perrors.Cause(err).(net.Error); ok && netError.Timeout() {
 			continue
 		}
 		if err != nil {
 			log.Error("%s, [session.handleUDPPackage] = len{%d}, error{%+s}",
 				s.sessionToken(), bufLen, err)
-			err = errors.Wrapf(err, "conn.read()")
+			err = perrors.Wrapf(err, "conn.read()")
 			break
 		}
 
@@ -702,7 +702,7 @@ func (s *session) handleUDPPackage() error {
 		pkg, pkgLen, err = s.reader.Read(s, buf[:bufLen])
 		log.Debug("s.reader.Read() = pkg:%#v, pkgLen:%d, err:%+v", pkg, pkgLen, err)
 		if err == nil && s.maxMsgLen > 0 && bufLen > int(s.maxMsgLen) {
-			err = errors.Errorf("Message Too Long, bufLen %d, session max message len %d", bufLen, s.maxMsgLen)
+			err = perrors.Errorf("Message Too Long, bufLen %d, session max message len %d", bufLen, s.maxMsgLen)
 		}
 		if err != nil {
 			log.Warn("%s, [session.handleUDPPackage] = len{%d}, error:%+v",
@@ -718,7 +718,7 @@ func (s *session) handleUDPPackage() error {
 		s.rQ <- UDPContext{Pkg: pkg, PeerAddr: addr}
 	}
 
-	return errors.WithStack(err)
+	return perrors.WithStack(err)
 }
 
 // get package from websocket stream
@@ -739,20 +739,20 @@ func (s *session) handleWSPackage() error {
 			break
 		}
 		pkg, err = conn.read()
-		if netError, ok = errors.Cause(err).(net.Error); ok && netError.Timeout() {
+		if netError, ok = perrors.Cause(err).(net.Error); ok && netError.Timeout() {
 			continue
 		}
 		if err != nil {
 			log.Warn("%s, [session.handleWSPackage] = error{%+s}",
 				s.sessionToken(), err)
 			// s.errFlag = true
-			return errors.WithStack(err)
+			return perrors.WithStack(err)
 		}
 		s.UpdateActive()
 		if s.reader != nil {
 			unmarshalPkg, length, err = s.reader.Read(s, pkg)
 			if err == nil && s.maxMsgLen > 0 && length > int(s.maxMsgLen) {
-				err = errors.Errorf("Message Too Long, length %d, session max message len %d", length, s.maxMsgLen)
+				err = perrors.Errorf("Message Too Long, length %d, session max message len %d", length, s.maxMsgLen)
 			}
 			if err != nil {
 				log.Warn("%s, [session.handleWSPackage] = len{%d}, error:%+v",