coosld/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2026-03-07 09:17:49 +08:00
Code Issues Actions 14 Packages Projects Releases Wiki Activity

fixed old swarm test

Browse Source
This commit is contained in:
Juan Batiz-Benet 2014-10-16 03:26:33 -07:00
parent 3a284661fc
commit f10b4bd8b3
1 changed files with 101 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

195
net/swarm/swarm_test.go
View File

@ -1,147 +1,154 @@
package swarm
import (
"bytes"
"fmt"
"testing"
"time"
ci "github.com/jbenet/go-ipfs/crypto"
msg "github.com/jbenet/go-ipfs/net/message"
peer "github.com/jbenet/go-ipfs/peer"
u "github.com/jbenet/go-ipfs/util"
context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
msgio "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-msgio"
ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
manet "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net"
mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
)
func pingListen(t *testing.T, listener manet.Listener, peer *peer.Peer) {
func pong(ctx context.Context, swarm *Swarm) {
for {
c, err := listener.Accept()
if err == nil {
go pong(t, c, peer)
select {
case <-ctx.Done():
return
case m1 := <-swarm.Incoming:
if bytes.Equal(m1.Data(), []byte("ping")) {
m2 := msg.New(m1.Peer(), []byte("pong"))
swarm.Outgoing <- m2
}
}
}
}
func pong(t *testing.T, c manet.Conn, peer *peer.Peer) {
mrw := msgio.NewReadWriter(c)
for {
data := make([]byte, 1024)
n, err := mrw.ReadMsg(data)
if err != nil {
fmt.Printf("error %v\n", err)
return
}
d := string(data[:n])
if d != "ping" {
t.Errorf("error: didn't receive ping: '%v'\n", d)
return
}
err = mrw.WriteMsg([]byte("pong"))
if err != nil {
fmt.Printf("error %v\n", err)
return
}
}
}
func setupPeer(id string, addr string) (*peer.Peer, error) {
func setupPeer(t *testing.T, id string, addr string) *peer.Peer {
tcp, err := ma.NewMultiaddr(addr)
if err != nil {
return nil, err
t.Fatal(err)
}
mh, err := mh.FromHexString(id)
if err != nil {
return nil, err
t.Fatal(err)
}
p := &peer.Peer{ID: peer.ID(mh)}
sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
if err != nil {
t.Fatal(err)
}
p.PrivKey = sk
p.PubKey = pk
p.AddAddress(tcp)
return p, nil
return p
}
func makeSwarms(ctx context.Context, t *testing.T, peers map[string]string) []*Swarm {
swarms := []*Swarm{}
for key, addr := range peers {
local := setupPeer(t, key, addr)
peerstore := peer.NewPeerstore()
swarm, err := NewSwarm(ctx, local, peerstore)
if err != nil {
t.Fatal(err)
}
swarms = append(swarms, swarm)
}
return swarms
}
func TestSwarm(t *testing.T) {
t.Skip("TODO FIXME nil pointer")
local, err := setupPeer("11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a30",
"/ip4/127.0.0.1/tcp/1234")
if err != nil {
t.Fatal("error setting up peer", err)
}
peerstore := peer.NewPeerstore()
swarm, err := NewSwarm(context.Background(), local, peerstore)
if err != nil {
t.Error(err)
}
var peers []*peer.Peer
var listeners []manet.Listener
peerNames := map[string]string{
peers := map[string]string{
"11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a30": "/ip4/127.0.0.1/tcp/1234",
"11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a31": "/ip4/127.0.0.1/tcp/2345",
"11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a32": "/ip4/127.0.0.1/tcp/3456",
"11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33": "/ip4/127.0.0.1/tcp/4567",
"11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a34": "/ip4/127.0.0.1/tcp/5678",
}
for k, n := range peerNames {
peer, err := setupPeer(k, n)
ctx := context.Background()
swarms := makeSwarms(ctx, t, peers)
// connect everyone
for _, s := range swarms {
peers, err := s.peers.All()
if err != nil {
t.Fatal("error setting up peer", err)
t.Fatal(err)
}
a := peer.NetAddress("tcp")
if a == nil {
t.Fatal("error setting up peer (addr is nil)", peer)
for _, p := range *peers {
fmt.Println("dialing")
if _, err := s.Dial(p); err != nil {
t.Fatal("error swarm dialing to peer", err)
}
fmt.Println("dialed")
}
listener, err := manet.Listen(a)
}
// ping/pong
for _, s1 := range swarms {
ctx, cancel := context.WithCancel(ctx)
// setup all others to pong
for _, s2 := range swarms {
if s1 == s2 {
continue
}
go pong(ctx, s2)
}
peers, err := s1.peers.All()
if err != nil {
t.Fatal("error setting up listener", err)
}
go pingListen(t, listener, peer)
_, err = swarm.Dial(peer)
if err != nil {
t.Fatal("error swarm dialing to peer", err)
t.Fatal(err)
}
// ok done, add it.
peers = append(peers, peer)
listeners = append(listeners, listener)
}
MsgNum := 1000
for k := 0; k < MsgNum; k++ {
for _, p := range peers {
swarm.Outgoing <- msg.New(p, []byte("ping"))
}
}
got := map[u.Key]int{}
for k := 0; k < (MsgNum * len(peers)); k++ {
msg := <-swarm.Incoming
if string(msg.Data()) != "pong" {
t.Error("unexpected conn output", msg.Data)
MsgNum := 1000
for k := 0; k < MsgNum; k++ {
for _, p := range *peers {
s1.Outgoing <- msg.New(p, []byte("ping"))
}
}
n, _ := got[msg.Peer().Key()]
got[msg.Peer().Key()] = n + 1
}
got := map[u.Key]int{}
for k := 0; k < (MsgNum * len(*peers)); k++ {
msg := <-s1.Incoming
if string(msg.Data()) != "pong" {
t.Error("unexpected conn output", msg.Data)
}
if len(peers) != len(got) {
t.Error("got less messages than sent")
}
for p, n := range got {
if n != MsgNum {
t.Error("peer did not get all msgs", p, n, "/", MsgNum)
n, _ := got[msg.Peer().Key()]
got[msg.Peer().Key()] = n + 1
}
if len(*peers) != len(got) {
t.Error("got less messages than sent")
}
for p, n := range got {
if n != MsgNum {
t.Error("peer did not get all msgs", p, n, "/", MsgNum)
}
}
cancel()
<-time.After(50 * time.Millisecond)
}
swarm.Close()
for _, listener := range listeners {
listener.Close()
for _, s := range swarms {
s.Close()
}
}