mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-08-17 09:23:48 +00:00
457 lines
11 KiB
Go
457 lines
11 KiB
Go
// Copyright 2018 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package stream
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
crand "crypto/rand"
|
|
"fmt"
|
|
"io"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/log"
|
|
"github.com/ethereum/go-ethereum/p2p/discover"
|
|
"github.com/ethereum/go-ethereum/p2p/simulations"
|
|
p2ptest "github.com/ethereum/go-ethereum/p2p/testing"
|
|
"github.com/ethereum/go-ethereum/swarm/network"
|
|
streamTesting "github.com/ethereum/go-ethereum/swarm/network/stream/testing"
|
|
"github.com/ethereum/go-ethereum/swarm/storage"
|
|
)
|
|
|
|
var (
|
|
deliveries map[discover.NodeID]*Delivery
|
|
stores map[discover.NodeID]storage.ChunkStore
|
|
toAddr func(discover.NodeID) *network.BzzAddr
|
|
)
|
|
|
|
func TestStreamerRetrieveRequest(t *testing.T) {
|
|
tester, streamer, _, teardown, err := newStreamerTester(t)
|
|
defer teardown()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
peerID := tester.IDs[0]
|
|
|
|
streamer.delivery.RequestFromPeers(hash0[:], true)
|
|
|
|
err = tester.TestExchanges(p2ptest.Exchange{
|
|
Label: "RetrieveRequestMsg",
|
|
Expects: []p2ptest.Expect{
|
|
p2ptest.Expect{
|
|
Code: 5,
|
|
Msg: &RetrieveRequestMsg{
|
|
Key: hash0[:],
|
|
SkipCheck: true,
|
|
},
|
|
Peer: peerID,
|
|
},
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestStreamerUpstreamRetrieveRequestMsgExchangeWithoutStore(t *testing.T) {
|
|
tester, streamer, _, teardown, err := newStreamerTester(t)
|
|
defer teardown()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
peerID := tester.IDs[0]
|
|
|
|
chunk := storage.NewChunk(storage.Key(hash0[:]), nil)
|
|
|
|
peer := streamer.getPeer(peerID)
|
|
|
|
peer.handleSubscribeMsg(&SubscribeMsg{
|
|
Stream: swarmChunkServerStreamName,
|
|
Key: nil,
|
|
From: 0,
|
|
To: 0,
|
|
Priority: Top,
|
|
})
|
|
|
|
err = tester.TestExchanges(p2ptest.Exchange{
|
|
Label: "RetrieveRequestMsg",
|
|
Triggers: []p2ptest.Trigger{
|
|
p2ptest.Trigger{
|
|
Code: 5,
|
|
Msg: &RetrieveRequestMsg{
|
|
Key: chunk.Key[:],
|
|
},
|
|
Peer: peerID,
|
|
},
|
|
},
|
|
Expects: []p2ptest.Expect{
|
|
p2ptest.Expect{
|
|
Code: 1,
|
|
Msg: &OfferedHashesMsg{
|
|
HandoverProof: nil,
|
|
Hashes: nil,
|
|
From: 0,
|
|
To: 0,
|
|
},
|
|
Peer: peerID,
|
|
},
|
|
},
|
|
})
|
|
|
|
expectedError := "exchange 0: 'RetrieveRequestMsg' timed out"
|
|
if err == nil || err.Error() != expectedError {
|
|
t.Fatalf("Expected error %v, got %v", expectedError, err)
|
|
}
|
|
}
|
|
|
|
// upstream request server receives a retrieve Request and responds with
|
|
// offered hashes or delivery if skipHash is set to true
|
|
func TestStreamerUpstreamRetrieveRequestMsgExchange(t *testing.T) {
|
|
tester, streamer, localStore, teardown, err := newStreamerTester(t)
|
|
defer teardown()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
peerID := tester.IDs[0]
|
|
peer := streamer.getPeer(peerID)
|
|
|
|
peer.handleSubscribeMsg(&SubscribeMsg{
|
|
Stream: swarmChunkServerStreamName,
|
|
Key: nil,
|
|
From: 0,
|
|
To: 0,
|
|
Priority: Top,
|
|
})
|
|
|
|
hash := storage.Key(hash0[:])
|
|
chunk := storage.NewChunk(hash, nil)
|
|
chunk.SData = hash
|
|
localStore.Put(chunk)
|
|
chunk.WaitToStore()
|
|
|
|
err = tester.TestExchanges(p2ptest.Exchange{
|
|
Label: "RetrieveRequestMsg",
|
|
Triggers: []p2ptest.Trigger{
|
|
p2ptest.Trigger{
|
|
Code: 5,
|
|
Msg: &RetrieveRequestMsg{
|
|
Key: hash,
|
|
},
|
|
Peer: peerID,
|
|
},
|
|
},
|
|
Expects: []p2ptest.Expect{
|
|
p2ptest.Expect{
|
|
Code: 1,
|
|
Msg: &OfferedHashesMsg{
|
|
HandoverProof: &HandoverProof{
|
|
Handover: &Handover{},
|
|
},
|
|
Hashes: hash,
|
|
From: 0,
|
|
// TODO: why is this 32???
|
|
To: 32,
|
|
Key: []byte{},
|
|
Stream: swarmChunkServerStreamName,
|
|
},
|
|
Peer: peerID,
|
|
},
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
hash = storage.Key(hash1[:])
|
|
chunk = storage.NewChunk(hash, nil)
|
|
chunk.SData = hash1[:]
|
|
localStore.Put(chunk)
|
|
chunk.WaitToStore()
|
|
|
|
err = tester.TestExchanges(p2ptest.Exchange{
|
|
Label: "RetrieveRequestMsg",
|
|
Triggers: []p2ptest.Trigger{
|
|
p2ptest.Trigger{
|
|
Code: 5,
|
|
Msg: &RetrieveRequestMsg{
|
|
Key: hash,
|
|
SkipCheck: true,
|
|
},
|
|
Peer: peerID,
|
|
},
|
|
},
|
|
Expects: []p2ptest.Expect{
|
|
p2ptest.Expect{
|
|
Code: 6,
|
|
Msg: &ChunkDeliveryMsg{
|
|
Key: hash,
|
|
SData: hash,
|
|
},
|
|
Peer: peerID,
|
|
},
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestStreamerDownstreamChunkDeliveryMsgExchange(t *testing.T) {
|
|
tester, streamer, localStore, teardown, err := newStreamerTester(t)
|
|
defer teardown()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
streamer.RegisterClientFunc("foo", func(p *Peer, t []byte) (Client, error) {
|
|
return &testClient{
|
|
t: t,
|
|
}, nil
|
|
})
|
|
|
|
peerID := tester.IDs[0]
|
|
|
|
err = streamer.Subscribe(peerID, "foo", []byte{}, 5, 8, Top, true)
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got %v", err)
|
|
}
|
|
|
|
chunkKey := hash0[:]
|
|
chunkData := hash1[:]
|
|
chunk, created := localStore.GetOrCreateRequest(chunkKey)
|
|
|
|
if !created {
|
|
t.Fatal("chunk already exists")
|
|
}
|
|
select {
|
|
case <-chunk.ReqC:
|
|
t.Fatal("chunk is already received")
|
|
default:
|
|
}
|
|
|
|
err = tester.TestExchanges(p2ptest.Exchange{
|
|
Label: "Subscribe message",
|
|
Expects: []p2ptest.Expect{
|
|
p2ptest.Expect{
|
|
Code: 4,
|
|
Msg: &SubscribeMsg{
|
|
Stream: "foo",
|
|
Key: []byte{},
|
|
From: 5,
|
|
To: 8,
|
|
Priority: Top,
|
|
},
|
|
Peer: peerID,
|
|
},
|
|
},
|
|
},
|
|
p2ptest.Exchange{
|
|
Label: "ChunkDeliveryRequest message",
|
|
Triggers: []p2ptest.Trigger{
|
|
p2ptest.Trigger{
|
|
Code: 6,
|
|
Msg: &ChunkDeliveryMsg{
|
|
Key: chunkKey,
|
|
SData: chunkData,
|
|
},
|
|
Peer: peerID,
|
|
},
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got %v", err)
|
|
}
|
|
|
|
timeout := time.NewTimer(1 * time.Second)
|
|
|
|
select {
|
|
case <-timeout.C:
|
|
t.Fatal("timeout receiving chunk")
|
|
case <-chunk.ReqC:
|
|
}
|
|
|
|
storedChunk, err := localStore.Get(chunkKey)
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got %v", err)
|
|
}
|
|
|
|
if !bytes.Equal(storedChunk.SData, chunkData) {
|
|
t.Fatal("Retrieved chunk has different data than original")
|
|
}
|
|
|
|
}
|
|
|
|
func TestDeliveryFromNodes(t *testing.T) {
|
|
testDeliveryFromNodes(t, 2, 1, 8100, true)
|
|
testDeliveryFromNodes(t, 2, 1, 8100, false)
|
|
testDeliveryFromNodes(t, 3, 1, 8100, true)
|
|
testDeliveryFromNodes(t, 3, 1, 8100, false)
|
|
}
|
|
|
|
func testDeliveryFromNodes(t *testing.T, nodes, conns, size int, skipCheck bool) {
|
|
toAddr = network.NewAddrFromNodeID
|
|
conf := &streamTesting.RunConfig{
|
|
Adapter: *adapter,
|
|
NodeCount: nodes,
|
|
ConnLevel: conns,
|
|
ToAddr: toAddr,
|
|
Services: services,
|
|
}
|
|
|
|
sim, teardown, err := streamTesting.NewSimulation(conf)
|
|
defer teardown()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
stores = make(map[discover.NodeID]storage.ChunkStore)
|
|
deliveries = make(map[discover.NodeID]*Delivery)
|
|
for i, id := range sim.IDs {
|
|
stores[id] = sim.Stores[i]
|
|
}
|
|
|
|
// here we distribute chunks of a random file into Stores of nodes 1 to nodes
|
|
rrdpa := storage.NewDPA(newRoundRobinStore(sim.Stores[1:]...), storage.NewChunkerParams())
|
|
rrdpa.Start()
|
|
fileHash, wait, err := rrdpa.Store(io.LimitReader(crand.Reader, int64(size)), int64(size))
|
|
defer rrdpa.Stop()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
// wait until all chunks stored
|
|
// TODO: is wait() necessary?
|
|
wait()
|
|
// each node Subscribes to each other's swarmChunkServerStreamName
|
|
// need to wait till an aynchronous process registers the peers in streamer.peers
|
|
// that is used by Subscribe
|
|
// time.Sleep(1 * time.Second)
|
|
// err := streamer.Subscribe(p.ID(), swarmChunkServerStreamName, nil, 0, 0, Top, true)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
waitPeerErrC = make(chan error)
|
|
|
|
action := func(context.Context) error {
|
|
|
|
i := 0
|
|
for err := range waitPeerErrC {
|
|
if err != nil {
|
|
return fmt.Errorf("error waiting for peers: %s", err)
|
|
}
|
|
i++
|
|
if i == nodes {
|
|
break
|
|
}
|
|
}
|
|
|
|
for i := 0; i < len(sim.IDs)-1; i++ {
|
|
id := sim.IDs[i]
|
|
node := sim.Net.GetNode(id)
|
|
if node == nil {
|
|
return fmt.Errorf("unknown node: %s", id)
|
|
}
|
|
client, err := node.Client()
|
|
if err != nil {
|
|
return fmt.Errorf("error getting node client: %s", err)
|
|
}
|
|
sid := sim.IDs[i+1]
|
|
if err := client.Call(nil, "stream_subscribeStream", sid, swarmChunkServerStreamName, nil, 0, 0, Top, false); err != nil {
|
|
return fmt.Errorf("error subscribing: %s", err)
|
|
}
|
|
}
|
|
|
|
// create a retriever dpa for the pivot node
|
|
delivery := deliveries[sim.IDs[0]]
|
|
dpacs := storage.NewNetStore(sim.Stores[0].(*storage.LocalStore), func(chunk *storage.Chunk) error { return delivery.RequestFromPeers(chunk.Key[:], skipCheck) })
|
|
dpa := storage.NewDPA(dpacs, storage.NewChunkerParams())
|
|
dpa.Start()
|
|
|
|
go func() {
|
|
defer dpa.Stop()
|
|
log.Debug(fmt.Sprintf("retrieve %v", fileHash))
|
|
// start the retrieval on the pivot node - this will spawn retrieve requests for missing chunks
|
|
// we must wait for the peer connections to have started before requesting
|
|
n, err := mustReadAll(dpa, fileHash)
|
|
log.Debug(fmt.Sprintf("retrieved %v", fileHash), "read", n, "err", err)
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
check := func(ctx context.Context, id discover.NodeID) (bool, error) {
|
|
select {
|
|
case <-ctx.Done():
|
|
return false, ctx.Err()
|
|
default:
|
|
}
|
|
// try to locally retrieve the file to check if retrieve requests have been successful
|
|
node := sim.Net.GetNode(id)
|
|
if node == nil {
|
|
return false, fmt.Errorf("unknown node: %s", id)
|
|
}
|
|
client, err := node.Client()
|
|
if err != nil {
|
|
return false, fmt.Errorf("error getting node client: %s", err)
|
|
}
|
|
var total int64
|
|
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
|
|
defer cancel()
|
|
err = client.CallContext(ctx, &total, "stream_readAll", fileHash)
|
|
// total, err := mustReadAll(dpa, fileHash)
|
|
log.Debug(fmt.Sprintf("check if %08x is available locally: number of bytes read %v/%v (error: %v)", fileHash, total, size, err))
|
|
if err != nil || total != int64(size) {
|
|
return false, nil
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
trigger := make(chan discover.NodeID)
|
|
ticker := time.NewTicker(500 * time.Millisecond)
|
|
go func() {
|
|
defer ticker.Stop()
|
|
// we are only testing the pivot node (net.Nodes[0])
|
|
for range ticker.C {
|
|
trigger <- sim.Net.Nodes[0].ID()
|
|
}
|
|
}()
|
|
|
|
conf.Step = &simulations.Step{
|
|
Action: action,
|
|
Trigger: trigger,
|
|
Expect: &simulations.Expectation{
|
|
Nodes: sim.IDs[0:1],
|
|
Check: check,
|
|
},
|
|
}
|
|
startedAt := time.Now()
|
|
result, err := sim.Run(conf)
|
|
finishedAt := time.Now()
|
|
if err != nil {
|
|
t.Fatalf("Setting up simulation failed: %v", err)
|
|
}
|
|
if result.Error != nil {
|
|
t.Fatalf("Simulation failed: %s", result.Error)
|
|
}
|
|
streamTesting.CheckResult(t, result, startedAt, finishedAt)
|
|
}
|