func GenSwarmNetwork(t *testing.T, ctx context.Context) *swarm.Network {
p := tu.RandPeerNetParamsOrFatal(t)
ps := peer.NewPeerstore()
ps.AddPubKey(p.ID, p.PubKey)
ps.AddPrivKey(p.ID, p.PrivKey)
n, err := swarm.NewNetwork(ctx, []ma.Multiaddr{p.Addr}, p.ID, ps, metrics.NewBandwidthCounter())
if err != nil {
t.Fatal(err)
}
ps.AddAddrs(p.ID, n.ListenAddresses(), peer.PermanentAddrTTL)
return n
}
// New constructs and sets up a new *BasicHost with given Network
func New(net inet.Network, opts ...interface{}) *BasicHost {
h := &BasicHost{
network: net,
mux: msmux.NewMultistreamMuxer(),
bwc: metrics.NewBandwidthCounter(),
}
h.proc = goprocess.WithTeardown(func() error {
if h.natmgr != nil {
h.natmgr.Close()
}
return h.Network().Close()
})
// setup host services
h.ids = identify.NewIDService(h)
muxh := h.Mux().Handle
handle := func(s inet.Stream) {
muxh(s)
}
h.relay = relay.NewRelayService(h, handle)
for _, o := range opts {
switch o := o.(type) {
case Option:
switch o {
case NATPortMap:
h.natmgr = newNatManager(h)
}
case metrics.Reporter:
h.bwc = o
}
}
net.SetConnHandler(h.newConnHandler)
net.SetStreamHandler(h.newStreamHandler)
return h
}
func makeSwarms(ctx context.Context, t *testing.T, num int) []*Swarm {
swarms := make([]*Swarm, 0, num)
for i := 0; i < num; i++ {
localnp := testutil.RandPeerNetParamsOrFatal(t)
peerstore := peer.NewPeerstore()
peerstore.AddPubKey(localnp.ID, localnp.PubKey)
peerstore.AddPrivKey(localnp.ID, localnp.PrivKey)
addrs := []ma.Multiaddr{localnp.Addr}
swarm, err := NewSwarm(ctx, addrs, localnp.ID, peerstore, metrics.NewBandwidthCounter())
if err != nil {
t.Fatal(err)
}
swarm.SetStreamHandler(EchoStreamHandler)
swarms = append(swarms, swarm)
}
return swarms
}
// create a 'Host' with a random peer to listen on the given address
func makeDummyHost(listen string) (host.Host, error) {
addr, err := ma.NewMultiaddr(listen)
if err != nil {
return nil, err
}
pid, err := testutil.RandPeerID()
if err != nil {
return nil, err
}
// bandwidth counter, should be optional in the future
bwc := metrics.NewBandwidthCounter()
// create a new swarm to be used by the service host
netw, err := swarm.NewNetwork(context.Background(), []ma.Multiaddr{addr}, pid, pstore.NewPeerstore(), bwc)
if err != nil {
return nil, err
}
log.Printf("I am %s/ipfs/%s\n", addr, pid.Pretty())
return bhost.New(netw), nil
}
func main() {
if len(os.Args) < 3 {
fmt.Println("to run a listener, specify peer id and listen port")
fmt.Println("to run a dialer, specify our id and port, and the target id and port")
Fatal("must specify at least three args")
}
// any valid multihash works if we have the secio disabled
id, err := peer.IDB58Decode(os.Args[1])
if err != nil {
Fatal(err)
}
addr, err := ma.NewMultiaddr("/ip4/0.0.0.0/tcp/" + os.Args[2])
if err != nil {
Fatal(err)
}
var dialPeer peer.ID
var dialAddr ma.Multiaddr
if len(os.Args) >= 5 {
p, err := peer.IDB58Decode(os.Args[3])
if err != nil {
Fatal(err)
}
a, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/" + os.Args[4])
if err != nil {
Fatal(err)
}
dialPeer = p
dialAddr = a
}
// new empty peerstore
pstore := peerstore.NewPeerstore()
ctx := context.Background()
// construct ourselves a swarmy thingy
s, err := swarm.NewSwarm(ctx, []ma.Multiaddr{addr}, id, pstore, metrics.NewBandwidthCounter())
if err != nil {
Fatal(err)
}
// if we are the dialer, do a dial!
if dialAddr != nil {
// add the targets address to the peerstore
pstore.AddAddr(dialPeer, dialAddr, peer.PermanentAddrTTL)
dialAndSend(s, dialPeer)
return
}
// set a function to handle streams
s.SetStreamHandler(func(st net.Stream) {
out, err := ioutil.ReadAll(st)
if err != nil {
Fatal(err)
}
fmt.Println(string(out))
})
// just wait around
time.Sleep(time.Hour)
}
func TestFilterAddrs(t *testing.T) {
m := func(s string) ma.Multiaddr {
maddr, err := ma.NewMultiaddr(s)
if err != nil {
t.Fatal(err)
}
return maddr
}
bad := []ma.Multiaddr{
m("/ip4/1.2.3.4/udp/1234"), // unreliable
m("/ip4/1.2.3.4/udp/1234/sctp/1234"), // not in manet
m("/ip4/1.2.3.4/udp/1234/utp"), // utp is broken
m("/ip4/1.2.3.4/udp/1234/udt"), // udt is broken on arm
m("/ip6/fe80::1/tcp/0"), // link local
m("/ip6/fe80::100/tcp/1234"), // link local
}
good := []ma.Multiaddr{
m("/ip4/127.0.0.1/tcp/0"),
m("/ip6/::1/tcp/0"),
}
goodAndBad := append(good, bad...)
// test filters
for _, a := range bad {
if addrutil.AddrUsable(a, true) {
t.Errorf("addr %s should be unusable", a)
}
}
for _, a := range good {
if !addrutil.AddrUsable(a, true) {
t.Errorf("addr %s should be usable", a)
}
}
subtestAddrsEqual(t, addrutil.FilterUsableAddrs(bad), []ma.Multiaddr{})
subtestAddrsEqual(t, addrutil.FilterUsableAddrs(good), good)
subtestAddrsEqual(t, addrutil.FilterUsableAddrs(goodAndBad), good)
// now test it with swarm
id, err := testutil.RandPeerID()
if err != nil {
t.Fatal(err)
}
ps := peer.NewPeerstore()
ctx := context.Background()
if _, err := NewNetwork(ctx, bad, id, ps, metrics.NewBandwidthCounter()); err == nil {
t.Fatal("should have failed to create swarm")
}
if _, err := NewNetwork(ctx, goodAndBad, id, ps, metrics.NewBandwidthCounter()); err != nil {
t.Fatal("should have succeeded in creating swarm", err)
}
}
