Skip to content

G
go-ipfs
提交 a3c84e20 作者: Łukasz Magiera
操作

p2p: refactor review 

License: MIT
Signed-off-by: 's avatarŁukasz Magiera <magik6k@gmail.com>
上级 f5ab137f
正在显示 包含 259 行增加 和 172 行删除
core/commands/p2p.go
......@@ -14,9 +14,11 @@ import (
core "github.com/ipfs/go-ipfs/core"
p2p "github.com/ipfs/go-ipfs/p2p"
pstore "gx/ipfs/QmXauCuJzmzapetmC6W4TuDJLL1yFFrVzSHoWv8YdbmnxH/go-libp2p-peerstore"
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
"gx/ipfs/QmZNkThpqfVXs9GNbexPrfBbXSLNYeKrE7jwFM2oqHbyqN/go-libp2p-protocol"
pstore "gx/ipfs/QmZR2XWVVBCtbgBWnQhWk2xcQfaR3W8faQPriAiaaj7rsr/go-libp2p-peerstore"
"gx/ipfs/QmdE4gMduCKCGAcczM2F5ioYDfdeKuPix138wrES1YSr7f/go-ipfs-cmdkit"
"gx/ipfs/Qme4QgoVPyQqxVc4G1c2L2wc9TDa6o294rtspGMnBNRujm/go-ipfs-addr"
)
// P2PProtoPrefix is the default required prefix for protocol names
......@@ -98,9 +100,23 @@ Example:
return
}
proto := req.Arguments()[0]
listen := req.Arguments()[1]
target := req.Arguments()[2]
protoOpt := req.Arguments()[0]
listenOpt := req.Arguments()[1]
targetOpt := req.Arguments()[2]
proto := protocol.ID(protoOpt)
listen, err := ma.NewMultiaddr(listenOpt)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
}
target, err := ipfsaddr.ParseString(targetOpt)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
}
allowCustom, _, err := req.Option("allow-custom-protocol").Bool()
if err != nil {
......@@ -108,7 +124,7 @@ Example:
return
}
if !allowCustom && !strings.HasPrefix(proto, P2PProtoPrefix) {
if !allowCustom && !strings.HasPrefix(string(proto), P2PProtoPrefix) {
res.SetError(errors.New("protocol name must be within '"+P2PProtoPrefix+"' namespace"), cmdkit.ErrNormal)
return
}
......@@ -149,8 +165,16 @@ Example:
return
}
proto := req.Arguments()[0]
target := req.Arguments()[1]
protoOpt := req.Arguments()[0]
targetOpt := req.Arguments()[1]
proto := protocol.ID(protoOpt)
target, err := ma.NewMultiaddr(targetOpt)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
}
allowCustom, _, err := req.Option("allow-custom-protocol").Bool()
if err != nil {
......@@ -158,7 +182,7 @@ Example:
return
}
if !allowCustom && !strings.HasPrefix(proto, P2PProtoPrefix) {
if !allowCustom && !strings.HasPrefix(string(proto), P2PProtoPrefix) {
res.SetError(errors.New("protocol name must be within '"+P2PProtoPrefix+"' namespace"), cmdkit.ErrNormal)
return
}
......@@ -173,39 +197,20 @@ Example:
}
// forwardRemote forwards libp2p service connections to a manet address
func forwardRemote(ctx context.Context, p *p2p.P2P, proto string, target string) error {
if strings.HasPrefix(target, "/ipfs") {
return errors.New("cannot forward libp2p service connections to another libp2p service")
}
addr, err := ma.NewMultiaddr(target)
if err != nil {
return err
}
func forwardRemote(ctx context.Context, p *p2p.P2P, proto protocol.ID, target ma.Multiaddr) error {
// TODO: return some info
_, err = p.ForwardRemote(ctx, proto, addr)
_, err := p.ForwardRemote(ctx, proto, target)
return err
}
// forwardLocal forwards local connections to a libp2p service
func forwardLocal(ctx context.Context, p *p2p.P2P, ps pstore.Peerstore, proto string, listen string, target string) error {
bindAddr, err := ma.NewMultiaddr(listen)
if err != nil {
return err
}
addr, peer, err := ParsePeerParam(target)
if err != nil {
return err
}
func forwardLocal(ctx context.Context, p *p2p.P2P, ps pstore.Peerstore, proto protocol.ID, bindAddr ma.Multiaddr, addr ipfsaddr.IPFSAddr) error {
if addr != nil {
ps.AddAddr(peer, addr, pstore.TempAddrTTL)
ps.AddAddr(addr.ID(), addr.Multiaddr(), pstore.TempAddrTTL)
}
// TODO: return some info
_, err = p.ForwardLocal(ctx, peer, proto, bindAddr)
_, err := p.ForwardLocal(ctx, addr.ID(), proto, bindAddr)
return err
}
......@@ -227,9 +232,9 @@ var p2pLsCmd = &cmds.Command{
for _, listener := range n.P2P.Listeners.Listeners {
output.Listeners = append(output.Listeners, P2PListenerInfoOutput{
Protocol: listener.Protocol(),
ListenAddress: listener.ListenAddress(),
TargetAddress: listener.TargetAddress(),
Protocol: string(listener.Protocol()),
ListenAddress: listener.ListenAddress().String(),
TargetAddress: listener.TargetAddress().String(),
})
}
......@@ -272,8 +277,6 @@ var p2pCloseCmd = &cmds.Command{
cmdkit.StringOption("target-address", "t", "Match target address"),
},
Run: func(req cmds.Request, res cmds.Response) {
res.SetOutput(nil)
n, err := p2pGetNode(req)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
......@@ -281,12 +284,26 @@ var p2pCloseCmd = &cmds.Command{
}
closeAll, _, _ := req.Option("all").Bool()
proto, p, _ := req.Option("protocol").String()
listen, l, _ := req.Option("listen-address").String()
target, t, _ := req.Option("target-address").String()
protoOpt, p, _ := req.Option("protocol").String()
listenOpt, l, _ := req.Option("listen-address").String()
targetOpt, t, _ := req.Option("target-address").String()
proto := protocol.ID(protoOpt)
listen, err := ma.NewMultiaddr(listenOpt)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
}
target, err := ma.NewMultiaddr(targetOpt)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
}
if !(closeAll || p || l || t) {
res.SetError(errors.New("no connection matching options given"), cmdkit.ErrNormal)
res.SetError(errors.New("no matching options given"), cmdkit.ErrNormal)
return
}
......@@ -296,31 +313,36 @@ var p2pCloseCmd = &cmds.Command{
}
match := func(listener p2p.Listener) bool {
out := true
if p {
out = out && (proto == listener.Protocol())
if closeAll {
return true
}
if l {
out = out && (listen == listener.ListenAddress())
if p && proto != listener.Protocol() {
return false
}
if t {
out = out && (target == listener.TargetAddress())
if l && !listen.Equal(listener.ListenAddress()) {
return false
}
out = out || closeAll
return out
if t && !target.Equal(listener.TargetAddress()) {
return false
}
return true
}
var closed int
for _, listener := range n.P2P.Listeners.Listeners {
if !match(listener) {
todo := make([]p2p.Listener, 0)
n.P2P.Listeners.Lock()
for _, l := range n.P2P.Listeners.Listeners {
if !match(l) {
continue
}
listener.Close()
closed++
todo = append(todo, l)
}
res.SetOutput(closed)
n.P2P.Listeners.Unlock()
for _, l := range todo {
l.Close()
}
res.SetOutput(len(todo))
},
Type: int(0),
Marshalers: cmds.MarshalerMap{
......
docs/experimental-features.md
......@@ -357,7 +357,7 @@ with `ssh [user]@127.0.0.1 -p 2222`.
### Road to being a real feature
- [ ] Needs more people to use and report on how well it works / fits use cases
- [ ] More documentation
- [ ] Support other protocols (e.g, unix domain sockets)
- [ ] Support other protocols (e.g, unix domain sockets, websockets, etc.)
---
......
p2p/listener.go
......@@ -3,13 +3,18 @@ package p2p
import (
"errors"
"sync"
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
"gx/ipfs/QmZNkThpqfVXs9GNbexPrfBbXSLNYeKrE7jwFM2oqHbyqN/go-libp2p-protocol"
)
// Listener listens for connections and proxies them to a target
type Listener interface {
Protocol() string
ListenAddress() string
TargetAddress() string
Protocol() protocol.ID
ListenAddress() ma.Multiaddr
TargetAddress() ma.Multiaddr
start() error
// Close closes the listener. Does not affect child streams
Close() error
......@@ -23,43 +28,49 @@ type listenerKey struct {
// ListenerRegistry is a collection of local application proto listeners.
type ListenerRegistry struct {
sync.Mutex
Listeners map[listenerKey]Listener
lk sync.Mutex
}
func (r *ListenerRegistry) lock(l Listener) error {
r.lk.Lock()
// Register registers listenerInfo into this registry and starts it
func (r *ListenerRegistry) Register(l Listener) error {
r.Lock()
if _, ok := r.Listeners[getListenerKey(l)]; ok {
r.lk.Unlock()
r.Unlock()
return errors.New("listener already registered")
}
return nil
}
func (r *ListenerRegistry) unlock() {
r.lk.Unlock()
}
r.Listeners[getListenerKey(l)] = l
// Register registers listenerInfo in this registry
func (r *ListenerRegistry) Register(l Listener) {
defer r.lk.Unlock()
r.Unlock()
r.Listeners[getListenerKey(l)] = l
if err := l.start(); err != nil {
r.Lock()
defer r.Lock()
delete(r.Listeners, getListenerKey(l))
return err
}
return nil
}
// Deregister removes p2p listener from this registry
func (r *ListenerRegistry) Deregister(k listenerKey) {
r.lk.Lock()
defer r.lk.Unlock()
func (r *ListenerRegistry) Deregister(k listenerKey) bool {
r.Lock()
defer r.Unlock()
_, ok := r.Listeners[k]
delete(r.Listeners, k)
return ok
}
func getListenerKey(l Listener) listenerKey {
return listenerKey{
proto: l.Protocol(),
listen: l.ListenAddress(),
target: l.TargetAddress(),
proto: string(l.Protocol()),
listen: l.ListenAddress().String(),
target: l.TargetAddress().String(),
}
}
p2p/local.go
......@@ -2,14 +2,15 @@ package p2p
import (
"context"
"errors"
"time"
manet "gx/ipfs/QmNqRnejxJxjRroz7buhrjfU8i3yNBLa81hFtmf2pXEffN/go-multiaddr-net"
ma "gx/ipfs/QmUxSEGbv2nmYNnfXi7839wwQqTN3kwQeUxe8dTjZWZs7J/go-multiaddr"
peer "gx/ipfs/QmVf8hTAsLLFtn4WPCRNdnaF2Eag2qTBS6uR8AiHPZARXy/go-libp2p-peer"
net "gx/ipfs/QmXdgNhVEgjLxjUoMs5ViQL7pboAt3Y7V7eGHRiE4qrmTE/go-libp2p-net"
protocol "gx/ipfs/QmZNkThpqfVXs9GNbexPrfBbXSLNYeKrE7jwFM2oqHbyqN/go-libp2p-protocol"
pstore "gx/ipfs/QmZhsmorLpD9kmQ4ynbAu4vbKv2goMUnXazwGA4gnWHDjB/go-libp2p-peerstore"
"gx/ipfs/QmV6FjemM1K8oXjrvuq3wuVWWoU2TLDPmNnKrxHzY3v6Ai/go-multiaddr-net"
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
"gx/ipfs/QmdVrMn1LhB4ybb8hMVaMLXnA8XRSewMnK6YqXKXoTcRvN/go-libp2p-peer"
tec "gx/ipfs/QmWHgLqrghM9zw77nF6gdvT9ExQ2RB9pLxkd8sDHZf1rWb/go-temp-err-catcher"
"gx/ipfs/QmPjvxTpVH8qJyQDnxnsxF9kv9jezKD1kozz1hs3fCGsNh/go-libp2p-net"
"gx/ipfs/QmZNkThpqfVXs9GNbexPrfBbXSLNYeKrE7jwFM2oqHbyqN/go-libp2p-protocol"
)
// localListener manet streams and proxies them to libp2p services
......@@ -27,98 +28,106 @@ type localListener struct {
}
// ForwardLocal creates new P2P stream to a remote listener
func (p2p *P2P) ForwardLocal(ctx context.Context, peer peer.ID, proto string, bindAddr ma.Multiaddr) (Listener, error) {
func (p2p *P2P) ForwardLocal(ctx context.Context, peer peer.ID, proto protocol.ID, bindAddr ma.Multiaddr) (Listener, error) {
listener := &localListener{
ctx: ctx,
p2p: p2p,
id: p2p.identity,
proto: protocol.ID(proto),
proto: proto,
laddr: bindAddr,
peer: peer,
}
if err := p2p.Listeners.lock(listener); err != nil {
if err := p2p.Listeners.Register(listener); err != nil {
return nil, err
}
maListener, err := manet.Listen(bindAddr)
if err != nil {
p2p.Listeners.unlock()
return nil, err
}
listener.listener = maListener
p2p.Listeners.Register(listener)
go listener.acceptConns()
return listener, nil
}
func (l *localListener) dial() (net.Stream, error) {
ctx, cancel := context.WithTimeout(l.ctx, time.Second*30) //TODO: configurable?
func (l *localListener) dial(ctx context.Context) (net.Stream, error) {
cctx, cancel := context.WithTimeout(ctx, time.Second*30) //TODO: configurable?
defer cancel()
err := l.p2p.peerHost.Connect(ctx, pstore.PeerInfo{ID: l.peer})
if err != nil {
return nil, err
}
return l.p2p.peerHost.NewStream(l.ctx, l.peer, l.proto)
return l.p2p.peerHost.NewStream(cctx, l.peer, l.proto)
}
func (l *localListener) acceptConns() {
for {
local, err := l.listener.Accept()
if err != nil {
if tec.ErrIsTemporary(err) {
continue
}
return
}
remote, err := l.dial()
if err != nil {
local.Close()
return
}
go l.setupStream(local)
}
}
tgt, err := ma.NewMultiaddr(l.TargetAddress())
if err != nil {
local.Close()
return
}
func (l *localListener) setupStream(local manet.Conn) {
remote, err := l.dial(l.ctx)
if err != nil {
local.Close()
log.Warningf("failed to dial to remote %s/%s", l.peer.Pretty(), l.proto)
return
}
stream := &Stream{
Protocol: l.proto,
stream := &Stream{
Protocol: l.proto,
OriginAddr: local.RemoteMultiaddr(),
TargetAddr: tgt,
OriginAddr: local.RemoteMultiaddr(),
TargetAddr: l.TargetAddress(),
Local: local,
Remote: remote,
Local: local,
Remote: remote,
Registry: l.p2p.Streams,
}
Registry: l.p2p.Streams,
}
l.p2p.Streams.Register(stream)
stream.startStreaming()
}
l.p2p.Streams.Register(stream)
stream.startStreaming()
func (l *localListener) start() error {
maListener, err := manet.Listen(l.laddr)
if err != nil {
return err
}
l.listener = maListener
return nil
}
func (l *localListener) Close() error {
l.listener.Close()
l.p2p.Listeners.Deregister(getListenerKey(l))
if l.listener == nil {
return errors.New("uninitialized")
}
if l.p2p.Listeners.Deregister(getListenerKey(l)) {
l.listener.Close()
l.listener = nil
}
return nil
}
func (l *localListener) Protocol() string {
return string(l.proto)
func (l *localListener) Protocol() protocol.ID {
return l.proto
}
func (l *localListener) ListenAddress() string {
return l.laddr.String()
func (l *localListener) ListenAddress() ma.Multiaddr {
return l.laddr
}
func (l *localListener) TargetAddress() string {
return "/ipfs/" + l.peer.Pretty()
func (l *localListener) TargetAddress() ma.Multiaddr {
addr, err := ma.NewMultiaddr(maPrefix + l.peer.Pretty())
if err != nil {
panic(err)
}
return addr
}
p2p/p2p.go
package p2p
import (
"sync"
logging "gx/ipfs/QmcVVHfdyv15GVPk7NrxdWjh2hLVccXnoD8j2tyQShiXJb/go-log"
pstore "gx/ipfs/QmZR2XWVVBCtbgBWnQhWk2xcQfaR3W8faQPriAiaaj7rsr/go-libp2p-peerstore"
p2phost "gx/ipfs/Qmb8T6YBBsjYsVGfrihQLfCJveczZnneSBqBKkYEBWDjge/go-libp2p-host"
peer "gx/ipfs/QmdVrMn1LhB4ybb8hMVaMLXnA8XRSewMnK6YqXKXoTcRvN/go-libp2p-peer"
)
var log = logging.Logger("p2p-mount")
// P2P structure holds information on currently running streams/listeners
type P2P struct {
Listeners *ListenerRegistry
......@@ -27,11 +28,9 @@ func NewP2P(identity peer.ID, peerHost p2phost.Host, peerstore pstore.Peerstore)
Listeners: &ListenerRegistry{
Listeners: map[listenerKey]Listener{},
lk: sync.Mutex{},
},
Streams: &StreamRegistry{
Streams: map[uint64]*Stream{},
lk: sync.Mutex{},
},
}
}
......
p2p/remote.go
......@@ -2,13 +2,16 @@ package p2p
import (
"context"
"errors"
manet "gx/ipfs/QmNqRnejxJxjRroz7buhrjfU8i3yNBLa81hFtmf2pXEffN/go-multiaddr-net"
ma "gx/ipfs/QmUxSEGbv2nmYNnfXi7839wwQqTN3kwQeUxe8dTjZWZs7J/go-multiaddr"
net "gx/ipfs/QmXdgNhVEgjLxjUoMs5ViQL7pboAt3Y7V7eGHRiE4qrmTE/go-libp2p-net"
manet "gx/ipfs/QmV6FjemM1K8oXjrvuq3wuVWWoU2TLDPmNnKrxHzY3v6Ai/go-multiaddr-net"
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
net "gx/ipfs/QmPjvxTpVH8qJyQDnxnsxF9kv9jezKD1kozz1hs3fCGsNh/go-libp2p-net"
protocol "gx/ipfs/QmZNkThpqfVXs9GNbexPrfBbXSLNYeKrE7jwFM2oqHbyqN/go-libp2p-protocol"
)
var maPrefix = "/" + ma.ProtocolWithCode(ma.P_IPFS).Name + "/"
// remoteListener accepts libp2p streams and proxies them to a manet host
type remoteListener struct {
p2p *P2P
......@@ -18,70 +21,85 @@ type remoteListener struct {
// Address to proxy the incoming connections to
addr ma.Multiaddr
initialized bool
}
// ForwardRemote creates new p2p listener
func (p2p *P2P) ForwardRemote(ctx context.Context, proto string, addr ma.Multiaddr) (Listener, error) {
func (p2p *P2P) ForwardRemote(ctx context.Context, proto protocol.ID, addr ma.Multiaddr) (Listener, error) {
listener := &remoteListener{
p2p: p2p,
proto: protocol.ID(proto),
proto: proto,
addr: addr,
}
if err := p2p.Listeners.lock(listener); err != nil {
if err := p2p.Listeners.Register(listener); err != nil {
return nil, err
}
p2p.peerHost.SetStreamHandler(listener.proto, func(remote net.Stream) {
local, err := manet.Dial(addr)
return listener, nil
}
func (l *remoteListener) start() error {
// TODO: handle errors when https://github.com/libp2p/go-libp2p-host/issues/16 will be done
l.p2p.peerHost.SetStreamHandler(l.proto, func(remote net.Stream) {
local, err := manet.Dial(l.addr)
if err != nil {
remote.Reset()
return
}
//TODO: review: is there a better way to do this?
peerMa, err := ma.NewMultiaddr("/ipfs/" + remote.Conn().RemotePeer().Pretty())
peerMa, err := ma.NewMultiaddr(maPrefix + remote.Conn().RemotePeer().Pretty())
if err != nil {
remote.Reset()
return
}
stream := &Stream{
Protocol: listener.proto,
Protocol: l.proto,
OriginAddr: peerMa,
TargetAddr: addr,
TargetAddr: l.addr,
Local: local,
Remote: remote,
Registry: p2p.Streams,
Registry: l.p2p.Streams,
}
p2p.Streams.Register(stream)
l.p2p.Streams.Register(stream)
stream.startStreaming()
})
p2p.Listeners.Register(listener)
return listener, nil
l.initialized = true
return nil
}
func (l *remoteListener) Protocol() string {
return string(l.proto)
func (l *remoteListener) Protocol() protocol.ID {
return l.proto
}
func (l *remoteListener) ListenAddress() string {
return "/ipfs"
func (l *remoteListener) ListenAddress() ma.Multiaddr {
addr, err := ma.NewMultiaddr(maPrefix + l.p2p.identity.Pretty())
if err != nil {
panic(err)
}
return addr
}
func (l *remoteListener) TargetAddress() string {
return l.addr.String()
func (l *remoteListener) TargetAddress() ma.Multiaddr {
return l.addr
}
func (l *remoteListener) Close() error {
l.p2p.peerHost.RemoveStreamHandler(protocol.ID(l.proto))
l.p2p.Listeners.Deregister(getListenerKey(l))
if !l.initialized {
return errors.New("uninitialized")
}
if l.p2p.Listeners.Deregister(getListenerKey(l)) {
l.p2p.peerHost.RemoveStreamHandler(l.proto)
l.initialized = false
}
return nil
}
p2p/stream.go
......@@ -4,9 +4,9 @@ import (
"io"
"sync"
manet "gx/ipfs/QmNqRnejxJxjRroz7buhrjfU8i3yNBLa81hFtmf2pXEffN/go-multiaddr-net"
ma "gx/ipfs/QmUxSEGbv2nmYNnfXi7839wwQqTN3kwQeUxe8dTjZWZs7J/go-multiaddr"
net "gx/ipfs/QmXdgNhVEgjLxjUoMs5ViQL7pboAt3Y7V7eGHRiE4qrmTE/go-libp2p-net"
manet "gx/ipfs/QmV6FjemM1K8oXjrvuq3wuVWWoU2TLDPmNnKrxHzY3v6Ai/go-multiaddr-net"
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
net "gx/ipfs/QmPjvxTpVH8qJyQDnxnsxF9kv9jezKD1kozz1hs3fCGsNh/go-libp2p-net"
"gx/ipfs/QmZNkThpqfVXs9GNbexPrfBbXSLNYeKrE7jwFM2oqHbyqN/go-libp2p-protocol"
)
......@@ -43,8 +43,12 @@ func (s *Stream) Reset() error {
func (s *Stream) startStreaming() {
go func() {
io.Copy(s.Local, s.Remote)
s.Reset()
_, err := io.Copy(s.Local, s.Remote)
if err != nil {
s.Reset()
} else {
s.Close()
}
}()
go func() {
......
package.json
......@@ -487,6 +487,12 @@
"version": "0.1.8"
},
{
"author": "whyrusleeping",
"hash": "QmWHgLqrghM9zw77nF6gdvT9ExQ2RB9pLxkd8sDHZf1rWb",
"name": "go-temp-err-catcher",
"version": "0.0.0"
},
{
"author": "why",
"hash": "QmVDDgboX5nPUE4pBcK2xC1b9XbStA4t2KrUWBRMr9AiFd",
"name": "go-bitswap",
......
test/sharness/t0180-p2p.sh
......@@ -127,7 +127,7 @@ check_test_ports
# Listing streams
test_expect_success "'ipfs p2p ls' succeeds" '
echo "/x/p2p-test /ipfs /ip4/127.0.0.1/tcp/10101" > expected &&
echo "/x/p2p-test /ipfs/$PEERID_0 /ip4/127.0.0.1/tcp/10101" > expected &&
ipfsi 0 p2p ls > actual
'
......@@ -144,10 +144,12 @@ test_expect_success "'ipfs p2p stream ls' output is empty" '
test_must_be_empty actual
'
check_test_ports
test_expect_success "Setup: Idle stream" '
ma-pipe-unidir --listen --pidFile=listener.pid recv /ip4/127.0.0.1/tcp/10101 &
ipfsi 1 p2p forward /x/p2p-test /ip4/127.0.0.1/tcp/10102 /ipfs/$PEERID_0 2>&1 > dialer-stdouterr.log &&
ipfsi 1 p2p forward /x/p2p-test /ip4/127.0.0.1/tcp/10102 /ipfs/$PEERID_0 &&
ma-pipe-unidir --pidFile=client.pid recv /ip4/127.0.0.1/tcp/10102 &
test_wait_for_file 30 100ms listener.pid &&
......@@ -231,8 +233,22 @@ test_expect_success "'ipfs p2p close' closes app numeric handlers" '
test_must_be_empty actual
'
test_expect_success "'ipfs p2p close' closes by listen addr" '
ipfsi 0 p2p listen /x/p2p-test /ip4/127.0.0.1/tcp/10101 &&
ipfsi 0 p2p close -l /ipfs/$PEERID_0 &&
ipfsi 0 p2p ls > actual &&
test_must_be_empty actual
'
test_expect_success "'ipfs p2p close' closes by target addr" '
ipfsi 0 p2p listen /x/p2p-test /ip4/127.0.0.1/tcp/10101 &&
ipfsi 0 p2p close -t /ip4/127.0.0.1/tcp/10101 &&
ipfsi 0 p2p ls > actual &&
test_must_be_empty actual
'
test_expect_success "non /x/ scoped protocols are not allowed" '
test_must_fail ipfsi 0 p2p forward /its/not/a/x/path /ipfs /ip4/127.0.0.1/tcp/10101 2> actual &&
test_must_fail ipfsi 0 p2p listen /its/not/a/x/path /ip4/127.0.0.1/tcp/10101 2> actual &&
echo "Error: protocol name must be within '"'"'/x/'"'"' namespace" > expected
test_cmp expected actual
'
......@@ -246,6 +262,8 @@ test_expect_success 'start p2p listener on custom proto' '
test_expect_success 'C->S Close local listener' '
ipfsi 0 p2p close -p /p2p-test
ipfsi 0 p2p ls > actual &&
test_must_be_empty actual
'
test_expect_success 'stop iptb' '
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论