github.com/lazyledger/lazyledger-core@v0.35.0-dev.0.20210613111200-4c651f053571/p2p/ipld/net_test.go (about)

     1  package ipld
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/ipfs/go-bitswap"
     9  	"github.com/ipfs/go-bitswap/network"
    10  	"github.com/ipfs/go-blockservice"
    11  	ds "github.com/ipfs/go-datastore"
    12  	dssync "github.com/ipfs/go-datastore/sync"
    13  	blockstore "github.com/ipfs/go-ipfs-blockstore"
    14  	ipld "github.com/ipfs/go-ipld-format"
    15  	"github.com/ipfs/go-merkledag"
    16  	"github.com/lazyledger/rsmt2d"
    17  	dht "github.com/libp2p/go-libp2p-kad-dht"
    18  	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
    19  	"github.com/stretchr/testify/assert"
    20  	"github.com/stretchr/testify/require"
    21  
    22  	"github.com/lazyledger/lazyledger-core/ipfs/plugin"
    23  	"github.com/lazyledger/lazyledger-core/libs/log"
    24  	"github.com/lazyledger/lazyledger-core/types"
    25  	"github.com/lazyledger/lazyledger-core/types/consts"
    26  )
    27  
    28  func TestDiscovery(t *testing.T) {
    29  	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    30  	defer cancel()
    31  
    32  	dhts := dhtNet(ctx, t, 2)
    33  	dht1, dht2 := dhts[0], dhts[0]
    34  
    35  	data := generateRandomBlockData(64, consts.MsgShareSize-2)
    36  	b := &types.Block{
    37  		Data:       data,
    38  		LastCommit: &types.Commit{},
    39  	}
    40  	b.Hash()
    41  
    42  	id, err := plugin.CidFromNamespacedSha256(b.DataAvailabilityHeader.RowsRoots[0].Bytes())
    43  	require.NoError(t, err)
    44  
    45  	err = dht1.Provide(ctx, id, false)
    46  	require.NoError(t, err)
    47  
    48  	prvs, err := dht2.FindProviders(ctx, id)
    49  	require.NoError(t, err)
    50  	assert.Equal(t, dht1.PeerID(), prvs[0].ID, "peer not found")
    51  }
    52  
    53  func TestWriteDiscoveryReadData(t *testing.T) {
    54  	logger := log.TestingLogger()
    55  	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
    56  	defer cancel()
    57  
    58  	dags, dhts := dagNet(ctx, t, 5)
    59  	blocks := make([]*types.Block, len(dags))
    60  	for i, dag := range dags {
    61  		data := generateRandomBlockData(64, consts.MsgShareSize-2)
    62  		b := &types.Block{
    63  			Data:       data,
    64  			LastCommit: &types.Commit{},
    65  		}
    66  		b.Hash()
    67  		blocks[i] = b
    68  
    69  		err := PutBlock(ctx, dag, blocks[i], dhts[i], logger)
    70  		require.NoError(t, err)
    71  	}
    72  
    73  	for i, dag := range dags {
    74  		if i == len(dags)-1 {
    75  			i = 0
    76  		}
    77  
    78  		exp := blocks[i+1]
    79  		actual, err := RetrieveBlockData(ctx, &exp.DataAvailabilityHeader, dag, rsmt2d.NewRSGF8Codec())
    80  		assert.NoError(t, err)
    81  		assert.EqualValues(t, exp.Data.Txs, actual.Txs, "blocks are not equal")
    82  	}
    83  }
    84  
    85  func dagNet(ctx context.Context, t *testing.T, num int) ([]ipld.DAGService, []*dht.IpfsDHT) {
    86  	net := mocknet.New(ctx)
    87  	_, medium := dagNode(ctx, t, net)
    88  	dags, dhts := make([]ipld.DAGService, num), make([]*dht.IpfsDHT, num)
    89  	for i := range dags {
    90  		dags[i], dhts[i] = dagNode(ctx, t, net)
    91  	}
    92  	bootstrap(ctx, t, net, medium, dhts...)
    93  	return dags, dhts
    94  }
    95  
    96  func dhtNet(ctx context.Context, t *testing.T, num int) []*dht.IpfsDHT {
    97  	net := mocknet.New(ctx)
    98  	medium := dhtNode(ctx, t, net)
    99  	dhts := make([]*dht.IpfsDHT, num)
   100  	for i := range dhts {
   101  		dhts[i] = dhtNode(ctx, t, net)
   102  	}
   103  	bootstrap(ctx, t, net, medium, dhts...)
   104  	return dhts
   105  }
   106  
   107  func dagNode(ctx context.Context, t *testing.T, net mocknet.Mocknet) (ipld.DAGService, *dht.IpfsDHT) {
   108  	dstore := dssync.MutexWrap(ds.NewMapDatastore())
   109  	bstore := blockstore.NewBlockstore(dstore)
   110  	routing := dhtNode(ctx, t, net)
   111  	bs := bitswap.New(ctx, network.NewFromIpfsHost(routing.Host(), routing), bstore, bitswap.ProvideEnabled(false))
   112  	return merkledag.NewDAGService(blockservice.New(bstore, bs)), routing
   113  }
   114  
   115  func dhtNode(ctx context.Context, t *testing.T, net mocknet.Mocknet) *dht.IpfsDHT {
   116  	host, err := net.GenPeer()
   117  	require.NoError(t, err)
   118  	dstore := dssync.MutexWrap(ds.NewMapDatastore())
   119  	routing, err := dht.New(ctx, host, dht.Datastore(dstore), dht.Mode(dht.ModeServer), dht.BootstrapPeers())
   120  	require.NoError(t, err)
   121  	return routing
   122  }
   123  
   124  func bootstrap(ctx context.Context, t *testing.T, net mocknet.Mocknet, bstrapper *dht.IpfsDHT, peers ...*dht.IpfsDHT) {
   125  	err := net.LinkAll()
   126  	require.NoError(t, err)
   127  	for _, p := range peers {
   128  		_, err := net.ConnectPeers(bstrapper.PeerID(), p.PeerID())
   129  		require.NoError(t, err)
   130  		err = bstrapper.Bootstrap(ctx)
   131  		require.NoError(t, err)
   132  	}
   133  	err = bstrapper.Bootstrap(ctx)
   134  	require.NoError(t, err)
   135  }