83 lines
2.2 KiB
Go
83 lines
2.2 KiB
Go
package gostream
|
|
|
|
import (
|
|
"context"
|
|
"net"
|
|
"time"
|
|
|
|
"github.com/libp2p/go-libp2p-core/host"
|
|
"github.com/libp2p/go-libp2p-core/network"
|
|
"github.com/libp2p/go-libp2p-core/peer"
|
|
"github.com/libp2p/go-libp2p-core/protocol"
|
|
)
|
|
|
|
// conn is an implementation of net.Conn which wraps
|
|
// libp2p streams.
|
|
type conn struct {
|
|
s network.Stream
|
|
}
|
|
|
|
// newConn creates a conn given a libp2p stream
|
|
func newConn(s network.Stream) net.Conn {
|
|
return &conn{s}
|
|
}
|
|
|
|
// Read reads data from the connection.
|
|
func (c *conn) Read(b []byte) (n int, err error) {
|
|
return c.s.Read(b)
|
|
}
|
|
|
|
// Write writes data to the connection.
|
|
func (c *conn) Write(b []byte) (n int, err error) {
|
|
return c.s.Write(b)
|
|
}
|
|
|
|
// Close closes the connection.
|
|
// Any blocked Read or Write operations will be unblocked and return errors.
|
|
func (c *conn) Close() error {
|
|
return c.s.Close()
|
|
}
|
|
|
|
// LocalAddr returns the local network address.
|
|
func (c *conn) LocalAddr() net.Addr {
|
|
return &addr{c.s.Conn().LocalPeer()}
|
|
}
|
|
|
|
// RemoteAddr returns the remote network address.
|
|
func (c *conn) RemoteAddr() net.Addr {
|
|
return &addr{c.s.Conn().RemotePeer()}
|
|
}
|
|
|
|
// SetDeadline sets the read and write deadlines associated
|
|
// with the connection. It is equivalent to calling both
|
|
// SetReadDeadline and SetWriteDeadline.
|
|
// See https://golang.org/pkg/net/#Conn for more details.
|
|
func (c *conn) SetDeadline(t time.Time) error {
|
|
return c.s.SetDeadline(t)
|
|
}
|
|
|
|
// SetReadDeadline sets the deadline for future Read calls.
|
|
// A zero value for t means Read will not time out.
|
|
func (c *conn) SetReadDeadline(t time.Time) error {
|
|
return c.s.SetReadDeadline(t)
|
|
}
|
|
|
|
// SetWriteDeadline sets the deadline for future Write calls.
|
|
// Even if write times out, it may return n > 0, indicating that
|
|
// some of the data was successfully written.
|
|
// A zero value for t means Write will not time out.
|
|
func (c *conn) SetWriteDeadline(t time.Time) error {
|
|
return c.s.SetWriteDeadline(t)
|
|
}
|
|
|
|
// Dial opens a stream to the destination address
|
|
// (which should parseable to a peer ID) using the given
|
|
// host and returns it as a standard net.Conn.
|
|
func Dial(ctx context.Context, h host.Host, pid peer.ID, tag protocol.ID) (net.Conn, error) {
|
|
s, err := h.NewStream(ctx, pid, tag)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return newConn(s), nil
|
|
}
|