/
mock.go
122 lines (108 loc) · 2.57 KB
/
mock.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package mock
import (
"context"
"crypto/rand"
"fmt"
"net"
"github.com/libp2p/go-libp2p-core/crypto"
"github.com/libp2p/go-libp2p-core/host"
peer "github.com/libp2p/go-libp2p-core/peer"
mnet "github.com/libp2p/go-libp2p/p2p/net/mock"
ma "github.com/multiformats/go-multiaddr"
)
// Net creates a mock network for testing.
type Net struct {
mnet.Mocknet
}
// NewMockNet return a mock.Net instance
func NewMockNet() *Net {
return &Net{
Mocknet: mnet.New(context.Background()),
}
}
var blackholeIP6 = net.ParseIP("100::")
// GenPeerWithMarshalablePrivKey is the alternative GenPeer(),
// to avoid the unmarshal failure when checking the sign
func (mn *Net) GenPeerWithMarshalablePrivKey() (host.Host, error) {
sk, _, err := crypto.GenerateECDSAKeyPair(rand.Reader)
if err != nil {
return nil, err
}
id, err := peer.IDFromPrivateKey(sk)
if err != nil {
return nil, err
}
suffix := id
if len(id) > 8 {
suffix = id[len(id)-8:]
}
ip := append(net.IP{}, blackholeIP6...)
copy(ip[net.IPv6len-len(suffix):], suffix)
a, err := ma.NewMultiaddr(fmt.Sprintf("/ip6/%s/tcp/4242", ip))
if err != nil {
return nil, fmt.Errorf("failed to create test multiaddr: %s", err)
}
h, err := mn.AddPeer(sk, a)
if err != nil {
return nil, err
}
return h, nil
}
// MustNewLinkedPeer returns a full-mesh-linked host
func (mn *Net) MustNewLinkedPeer() host.Host {
h, err := mn.NewLinkedPeer()
if err != nil {
panic(err)
}
return h
}
// MustNewConnectedPeer returns a full-mesh-connected host
func (mn *Net) MustNewConnectedPeer() host.Host {
h, err := mn.NewConnectedPeer()
if err != nil {
panic(err)
}
return h
}
// NewLinkedPeer returns a full-mesh-linked host
func (mn *Net) NewLinkedPeer() (host.Host, error) {
h, err := mn.GenPeerWithMarshalablePrivKey()
if err == nil {
err = mn.LinkAllButSelf(h)
}
return h, err
}
// NewConnectedPeer returns a full-mesh-connected host
func (mn *Net) NewConnectedPeer() (host.Host, error) {
h, err := mn.NewLinkedPeer()
if err == nil {
err = mn.ConnectAllButSelf(h)
}
return h, err
}
// LinkAllButSelf makes h links to every node in net
func (mn *Net) LinkAllButSelf(h host.Host) error {
peers := mn.Peers()
for _, p := range peers {
if p == h.ID() {
continue
}
if _, err := mn.LinkPeers(h.ID(), p); err != nil {
return err
}
}
return nil
}
// ConnectAllButSelf makes h connects to every node in net
func (mn *Net) ConnectAllButSelf(h host.Host) error {
peers := mn.Peers()
for _, p := range peers {
if p == h.ID() {
continue
}
if _, err := mn.ConnectPeers(h.ID(), p); err != nil {
return err
}
}
return nil
}