deprecate this repo

README.md

@@ -1,3 +1,7 @@
+# DEPRECATION NOTICE
+
+This package has moved into go-libp2p as a sub-package, github.com/libp2p/go-libp2p/p2p/transport/websocket.
+
 # go-ws-transport
 
 [![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](https://protocol.ai)

addrs.go

@@ -1,26 +1,16 @@
 package websocket
 
 import (
-	"fmt"
 	"net"
-	"net/url"
-	"strconv"
+
+	"github.com/libp2p/go-libp2p/p2p/transport/websocket"
 
 	ma "github.com/multiformats/go-multiaddr"
-	manet "github.com/multiformats/go-multiaddr/net"
 )
 
 // Addr is an implementation of net.Addr for WebSocket.
-type Addr struct {
-	*url.URL
-}
-
-var _ net.Addr = (*Addr)(nil)
-
-// Network returns the network type for a WebSocket, "websocket".
-func (addr *Addr) Network() string {
-	return "websocket"
-}
+// Deprecated: use github.com/libp2p/go-libp2p/p2p/transport/websocket.Addr instead.
+type Addr = websocket.Addr
 
 // NewAddr creates an Addr with `ws` scheme (insecure).
 //
@@ -33,105 +23,17 @@ func NewAddr(host string) *Addr {
 
 // NewAddrWithScheme creates a new Addr using the given host string. isSecure
 // should be true for WSS connections and false for WS.
+// Deprecated: use github.com/libp2p/go-libp2p/p2p/transport/websocket.NewAddrWithScheme instead.
 func NewAddrWithScheme(host string, isSecure bool) *Addr {
-	scheme := "ws"
-	if isSecure {
-		scheme = "wss"
-	}
-	return &Addr{
-		URL: &url.URL{
-			Scheme: scheme,
-			Host:   host,
-		},
-	}
+	return websocket.NewAddrWithScheme(host, isSecure)
 }
 
+// Deprecated: use github.com/libp2p/go-libp2p/p2p/transport/websocket.ConvertWebsocketMultiaddrToNetAddr instead.
 func ConvertWebsocketMultiaddrToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
-	url, err := parseMultiaddr(maddr)
-	if err != nil {
-		return nil, err
-	}
-	return &Addr{URL: url}, nil
+	return websocket.ConvertWebsocketMultiaddrToNetAddr(maddr)
 }
 
+// Deprecated: use github.com/libp2p/go-libp2p/p2p/transport/websocket.ParseWebsocketNetAddr instead.
 func ParseWebsocketNetAddr(a net.Addr) (ma.Multiaddr, error) {
-	wsa, ok := a.(*Addr)
-	if !ok {
-		return nil, fmt.Errorf("not a websocket address")
-	}
-
-	var (
-		tcpma ma.Multiaddr
-		err   error
-		port  int
-		host  = wsa.Hostname()
-	)
-
-	// Get the port
-	if portStr := wsa.Port(); portStr != "" {
-		port, err = strconv.Atoi(portStr)
-		if err != nil {
-			return nil, fmt.Errorf("failed to parse port '%q': %s", portStr, err)
-		}
-	} else {
-		return nil, fmt.Errorf("invalid port in url: '%q'", wsa.URL)
-	}
-
-	// NOTE: Ignoring IPv6 zones...
-	// Detect if host is IP address or DNS
-	if ip := net.ParseIP(host); ip != nil {
-		// Assume IP address
-		tcpma, err = manet.FromNetAddr(&net.TCPAddr{
-			IP:   ip,
-			Port: port,
-		})
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		// Assume DNS name
-		tcpma, err = ma.NewMultiaddr(fmt.Sprintf("/dns/%s/tcp/%d", host, port))
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	wsma, err := ma.NewMultiaddr("/" + wsa.Scheme)
-	if err != nil {
-		return nil, err
-	}
-
-	return tcpma.Encapsulate(wsma), nil
-}
-
-func parseMultiaddr(maddr ma.Multiaddr) (*url.URL, error) {
-	// Only look at the _last_ component.
-	maddr, wscomponent := ma.SplitLast(maddr)
-	if maddr == nil || wscomponent == nil {
-		return nil, fmt.Errorf("websocket addrs need at least two components")
-	}
-
-	var scheme string
-	switch wscomponent.Protocol().Code {
-	case ma.P_WS:
-		scheme = "ws"
-	case ma.P_WSS:
-		scheme = "wss"
-	default:
-		return nil, fmt.Errorf("not a websocket multiaddr")
-	}
-
-	network, host, err := manet.DialArgs(maddr)
-	if err != nil {
-		return nil, err
-	}
-	switch network {
-	case "tcp", "tcp4", "tcp6":
-	default:
-		return nil, fmt.Errorf("unsupported websocket network %s", network)
-	}
-	return &url.URL{
-		Scheme: scheme,
-		Host:   host,
-	}, nil
+	return websocket.ParseWebsocketNetAddr(a)
 }

conn.go

@@ -1,151 +1,22 @@
 package websocket
 
 import (
-	"io"
-	"net"
-	"sync"
-	"time"
+	"github.com/libp2p/go-libp2p/p2p/transport/websocket"
 
 	ws "github.com/gorilla/websocket"
 )
 
 // GracefulCloseTimeout is the time to wait trying to gracefully close a
 // connection before simply cutting it.
-var GracefulCloseTimeout = 100 * time.Millisecond
+// Deprecated: use github.com/libp2p/go-libp2p/p2p/transport/websocket.GracefulCloseTimeout instead.
+var GracefulCloseTimeout = websocket.GracefulCloseTimeout
 
 // Conn implements net.Conn interface for gorilla/websocket.
-type Conn struct {
-	*ws.Conn
-	secure             bool
-	DefaultMessageType int
-	reader             io.Reader
-	closeOnce          sync.Once
-
-	readLock, writeLock sync.Mutex
-}
-
-var _ net.Conn = (*Conn)(nil)
+// Deprecated: use github.com/libp2p/go-libp2p/p2p/transport/websocket.Conn instead.
+type Conn = websocket.Conn
 
 // NewConn creates a Conn given a regular gorilla/websocket Conn.
+// Deprecated: use github.com/libp2p/go-libp2p/p2p/transport/websocket.NewConn instead.
 func NewConn(raw *ws.Conn, secure bool) *Conn {
-	return &Conn{
-		Conn:               raw,
-		secure:             secure,
-		DefaultMessageType: ws.BinaryMessage,
-	}
-}
-
-func (c *Conn) Read(b []byte) (int, error) {
-	c.readLock.Lock()
-	defer c.readLock.Unlock()
-
-	if c.reader == nil {
-		if err := c.prepNextReader(); err != nil {
-			return 0, err
-		}
-	}
-
-	for {
-		n, err := c.reader.Read(b)
-		switch err {
-		case io.EOF:
-			c.reader = nil
-
-			if n > 0 {
-				return n, nil
-			}
-
-			if err := c.prepNextReader(); err != nil {
-				return 0, err
-			}
-
-			// explicitly looping
-		default:
-			return n, err
-		}
-	}
-}
-
-func (c *Conn) prepNextReader() error {
-	t, r, err := c.Conn.NextReader()
-	if err != nil {
-		if wserr, ok := err.(*ws.CloseError); ok {
-			if wserr.Code == 1000 || wserr.Code == 1005 {
-				return io.EOF
-			}
-		}
-		return err
-	}
-
-	if t == ws.CloseMessage {
-		return io.EOF
-	}
-
-	c.reader = r
-	return nil
-}
-
-func (c *Conn) Write(b []byte) (n int, err error) {
-	c.writeLock.Lock()
-	defer c.writeLock.Unlock()
-
-	if err := c.Conn.WriteMessage(c.DefaultMessageType, b); err != nil {
-		return 0, err
-	}
-
-	return len(b), nil
-}
-
-// Close closes the connection. Only the first call to Close will receive the
-// close error, subsequent and concurrent calls will return nil.
-// This method is thread-safe.
-func (c *Conn) Close() error {
-	var err error
-	c.closeOnce.Do(func() {
-		err1 := c.Conn.WriteControl(
-			ws.CloseMessage,
-			ws.FormatCloseMessage(ws.CloseNormalClosure, "closed"),
-			time.Now().Add(GracefulCloseTimeout),
-		)
-		err2 := c.Conn.Close()
-		switch {
-		case err1 != nil:
-			err = err1
-		case err2 != nil:
-			err = err2
-		}
-	})
-	return err
-}
-
-func (c *Conn) LocalAddr() net.Addr {
-	return NewAddrWithScheme(c.Conn.LocalAddr().String(), c.secure)
-}
-
-func (c *Conn) RemoteAddr() net.Addr {
-	return NewAddrWithScheme(c.Conn.RemoteAddr().String(), c.secure)
-}
-
-func (c *Conn) SetDeadline(t time.Time) error {
-	if err := c.SetReadDeadline(t); err != nil {
-		return err
-	}
-
-	return c.SetWriteDeadline(t)
-}
-
-func (c *Conn) SetReadDeadline(t time.Time) error {
-	// Don't lock when setting the read deadline. That would prevent us from
-	// interrupting an in-progress read.
-	return c.Conn.SetReadDeadline(t)
-}
-
-func (c *Conn) SetWriteDeadline(t time.Time) error {
-	// Unlike the read deadline, we need to lock when setting the write
-	// deadline.
-
-	c.writeLock.Lock()
-	defer c.writeLock.Unlock()
-
-	return c.Conn.SetWriteDeadline(t)
+	return websocket.NewConn(raw, secure)
 }