func TestValueGetSet(t *testing.T) {
u.Debug = false
addrA, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/1235")
if err != nil {
t.Fatal(err)
}
addrB, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/5679")
if err != nil {
t.Fatal(err)
}
peerA := makePeer(addrA)
peerB := makePeer(addrB)
neta := swarm.NewSwarm(peerA)
err = neta.Listen()
if err != nil {
t.Fatal(err)
}
dhtA := NewDHT(peerA, neta, ds.NewMapDatastore())
netb := swarm.NewSwarm(peerB)
err = netb.Listen()
if err != nil {
t.Fatal(err)
}
dhtB := NewDHT(peerB, netb, ds.NewMapDatastore())
dhtA.Start()
dhtB.Start()
errsa := dhtA.network.GetErrChan()
errsb := dhtB.network.GetErrChan()
go func() {
select {
case err := <-errsa:
t.Fatal(err)
case err := <-errsb:
t.Fatal(err)
}
}()
_, err = dhtA.Connect(addrB)
if err != nil {
t.Fatal(err)
}
dhtA.PutValue("hello", []byte("world"))
val, err := dhtA.GetValue("hello", time.Second*2)
if err != nil {
t.Fatal(err)
}
if string(val) != "world" {
t.Fatalf("Expected 'world' got '%s'", string(val))
}
}
// NewIpfsNode constructs a new IpfsNode based on the given config.
func NewIpfsNode(cfg *config.Config, online bool) (*IpfsNode, error) {
if cfg == nil {
return nil, fmt.Errorf("configuration required")
}
d, err := makeDatastore(cfg.Datastore)
if err != nil {
return nil, err
}
local, err := initIdentity(cfg)
if err != nil {
return nil, err
}
var (
net *swarm.Swarm
peers *peer.Map
// TODO: refactor so we can use IpfsRouting interface instead of being DHT-specific
route *dht.IpfsDHT
swap *bitswap.BitSwap
)
if online {
net = swarm.NewSwarm(local)
err = net.Listen()
if err != nil {
return nil, err
}
peers = &peer.Map{}
route = dht.NewDHT(local, net, d)
route.Start()
swap = bitswap.NewBitSwap(local, net, d, route)
swap.SetStrategy(bitswap.YesManStrategy)
go initConnections(cfg, peers, route)
}
bs, err := bserv.NewBlockService(d, swap)
if err != nil {
return nil, err
}
dag := &merkledag.DAGService{Blocks: bs}
return &IpfsNode{
Config: cfg,
PeerMap: peers,
Datastore: d,
Blocks: bs,
DAG: dag,
Resolver: &path.Resolver{DAG: dag},
BitSwap: swap,
Identity: local,
Routing: route,
}, nil
}
func TestPing(t *testing.T) {
u.Debug = true
addrA, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/2222")
if err != nil {
t.Fatal(err)
}
addrB, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/5678")
if err != nil {
t.Fatal(err)
}
peerA := makePeer(addrA)
peerB := makePeer(addrB)
neta := swarm.NewSwarm(peerA)
err = neta.Listen()
if err != nil {
t.Fatal(err)
}
dhtA := NewDHT(peerA, neta, ds.NewMapDatastore())
netb := swarm.NewSwarm(peerB)
err = netb.Listen()
if err != nil {
t.Fatal(err)
}
dhtB := NewDHT(peerB, netb, ds.NewMapDatastore())
dhtA.Start()
dhtB.Start()
_, err = dhtA.Connect(addrB)
if err != nil {
t.Fatal(err)
}
//Test that we can ping the node
err = dhtA.Ping(peerB, time.Second*2)
if err != nil {
t.Fatal(err)
}
dhtA.Halt()
dhtB.Halt()
}
func setupDHTS(n int, t *testing.T) ([]*ma.Multiaddr, []*peer.Peer, []*IpfsDHT) {
var addrs []*ma.Multiaddr
for i := 0; i < 4; i++ {
a, err := ma.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", 5000+i))
if err != nil {
t.Fatal(err)
}
addrs = append(addrs, a)
}
var peers []*peer.Peer
for i := 0; i < 4; i++ {
p := new(peer.Peer)
p.AddAddress(addrs[i])
sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
if err != nil {
panic(err)
}
p.PubKey = pk
p.PrivKey = sk
id, err := identify.IDFromPubKey(pk)
if err != nil {
panic(err)
}
p.ID = id
peers = append(peers, p)
}
var dhts []*IpfsDHT
for i := 0; i < 4; i++ {
net := swarm.NewSwarm(peers[i])
err := net.Listen()
if err != nil {
t.Fatal(err)
}
d := NewDHT(peers[i], net, ds.NewMapDatastore())
dhts = append(dhts, d)
d.Start()
}
return addrs, peers, dhts
}