2019-02-20 14:24:25 +00:00
|
|
|
package crdt
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
|
|
|
"fmt"
|
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/ipfs/ipfs-cluster/api"
|
|
|
|
"github.com/ipfs/ipfs-cluster/datastore/inmem"
|
|
|
|
"github.com/ipfs/ipfs-cluster/test"
|
|
|
|
|
2019-06-14 10:41:11 +00:00
|
|
|
cid "github.com/ipfs/go-cid"
|
2020-04-06 22:00:51 +00:00
|
|
|
ipns "github.com/ipfs/go-ipns"
|
2019-02-20 14:24:25 +00:00
|
|
|
libp2p "github.com/libp2p/go-libp2p"
|
2019-06-14 10:41:11 +00:00
|
|
|
host "github.com/libp2p/go-libp2p-core/host"
|
|
|
|
peerstore "github.com/libp2p/go-libp2p-core/peerstore"
|
2019-02-20 14:24:25 +00:00
|
|
|
dht "github.com/libp2p/go-libp2p-kad-dht"
|
2020-04-14 20:03:24 +00:00
|
|
|
dual "github.com/libp2p/go-libp2p-kad-dht/dual"
|
2019-02-20 14:24:25 +00:00
|
|
|
pubsub "github.com/libp2p/go-libp2p-pubsub"
|
2020-04-06 22:00:51 +00:00
|
|
|
record "github.com/libp2p/go-libp2p-record"
|
2019-02-20 14:24:25 +00:00
|
|
|
routedhost "github.com/libp2p/go-libp2p/p2p/host/routed"
|
|
|
|
)
|
|
|
|
|
2020-04-14 20:03:24 +00:00
|
|
|
func makeTestingHost(t *testing.T) (host.Host, *pubsub.PubSub, *dual.DHT) {
|
2019-02-20 14:24:25 +00:00
|
|
|
ctx := context.Background()
|
|
|
|
h, err := libp2p.New(
|
|
|
|
ctx,
|
|
|
|
libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"),
|
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
psub, err := pubsub.NewGossipSub(
|
|
|
|
ctx,
|
|
|
|
h,
|
|
|
|
pubsub.WithMessageSigning(true),
|
|
|
|
pubsub.WithStrictSignatureVerification(true),
|
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
h.Close()
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2020-04-14 20:03:24 +00:00
|
|
|
idht, err := dual.New(ctx, h,
|
2020-09-02 10:06:47 +00:00
|
|
|
dual.DHTOption(dht.NamespacedValidator("pk", record.PublicKeyValidator{})),
|
|
|
|
dual.DHTOption(dht.NamespacedValidator("ipns", ipns.Validator{KeyBook: h.Peerstore()})),
|
|
|
|
dual.DHTOption(dht.Concurrency(10)),
|
|
|
|
dual.DHTOption(dht.RoutingTableRefreshPeriod(200*time.Millisecond)),
|
|
|
|
dual.DHTOption(dht.RoutingTableRefreshQueryTimeout(100*time.Millisecond)),
|
2020-03-13 20:40:02 +00:00
|
|
|
)
|
2019-02-20 14:24:25 +00:00
|
|
|
if err != nil {
|
|
|
|
h.Close()
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
rHost := routedhost.Wrap(h, idht)
|
|
|
|
return rHost, psub, idht
|
|
|
|
}
|
|
|
|
|
|
|
|
func testingConsensus(t *testing.T, idn int) *Consensus {
|
|
|
|
h, psub, dht := makeTestingHost(t)
|
|
|
|
|
|
|
|
cfg := &Config{}
|
|
|
|
cfg.Default()
|
|
|
|
cfg.DatastoreNamespace = fmt.Sprintf("crdttest-%d", idn)
|
|
|
|
cfg.hostShutdown = true
|
|
|
|
|
|
|
|
cc, err := New(h, dht, psub, cfg, inmem.New())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("cannot create Consensus:", err)
|
|
|
|
}
|
|
|
|
cc.SetClient(test.NewMockRPCClientWithHost(t, h))
|
|
|
|
<-cc.Ready(context.Background())
|
|
|
|
return cc
|
|
|
|
}
|
|
|
|
|
|
|
|
func clean(t *testing.T, cc *Consensus) {
|
|
|
|
err := cc.Clean(context.Background())
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func testPin(c cid.Cid) *api.Pin {
|
|
|
|
p := api.PinCid(c)
|
|
|
|
p.ReplicationFactorMin = -1
|
|
|
|
p.ReplicationFactorMax = -1
|
|
|
|
return p
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestShutdownConsensus(t *testing.T) {
|
|
|
|
ctx := context.Background()
|
|
|
|
cc := testingConsensus(t, 1)
|
|
|
|
defer clean(t, cc)
|
|
|
|
err := cc.Shutdown(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("Consensus cannot shutdown:", err)
|
|
|
|
}
|
|
|
|
err = cc.Shutdown(ctx) // should be fine to shutdown twice
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("Consensus should be able to shutdown several times")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestConsensusPin(t *testing.T) {
|
|
|
|
ctx := context.Background()
|
|
|
|
cc := testingConsensus(t, 1)
|
|
|
|
defer clean(t, cc)
|
|
|
|
defer cc.Shutdown(ctx)
|
|
|
|
|
|
|
|
err := cc.LogPin(ctx, testPin(test.Cid1))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
time.Sleep(250 * time.Millisecond)
|
|
|
|
st, err := cc.State(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("error getting state:", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
pins, err := st.List(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(pins) != 1 || !pins[0].Cid.Equals(test.Cid1) {
|
|
|
|
t.Error("the added pin should be in the state")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestConsensusUnpin(t *testing.T) {
|
|
|
|
ctx := context.Background()
|
|
|
|
cc := testingConsensus(t, 1)
|
|
|
|
defer clean(t, cc)
|
|
|
|
defer cc.Shutdown(ctx)
|
|
|
|
|
|
|
|
err := cc.LogPin(ctx, testPin(test.Cid1))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = cc.LogUnpin(ctx, api.PinCid(test.Cid1))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestConsensusUpdate(t *testing.T) {
|
|
|
|
ctx := context.Background()
|
|
|
|
cc := testingConsensus(t, 1)
|
|
|
|
defer clean(t, cc)
|
|
|
|
defer cc.Shutdown(ctx)
|
|
|
|
|
|
|
|
// Pin first
|
|
|
|
pin := testPin(test.Cid1)
|
|
|
|
pin.Type = api.ShardType
|
|
|
|
err := cc.LogPin(ctx, pin)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
time.Sleep(250 * time.Millisecond)
|
|
|
|
|
|
|
|
// Update pin
|
|
|
|
pin.Reference = &test.Cid2
|
|
|
|
err = cc.LogPin(ctx, pin)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
time.Sleep(250 * time.Millisecond)
|
|
|
|
st, err := cc.State(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("error getting state:", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
pins, err := st.List(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(pins) != 1 || !pins[0].Cid.Equals(test.Cid1) {
|
|
|
|
t.Error("the added pin should be in the state")
|
|
|
|
}
|
|
|
|
if !pins[0].Reference.Equals(test.Cid2) {
|
|
|
|
t.Error("pin updated incorrectly")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestConsensusAddRmPeer(t *testing.T) {
|
|
|
|
ctx := context.Background()
|
|
|
|
cc := testingConsensus(t, 1)
|
|
|
|
cc2 := testingConsensus(t, 2)
|
|
|
|
defer clean(t, cc)
|
|
|
|
defer clean(t, cc)
|
|
|
|
defer cc.Shutdown(ctx)
|
|
|
|
defer cc2.Shutdown(ctx)
|
|
|
|
|
|
|
|
cc.host.Peerstore().AddAddrs(cc2.host.ID(), cc2.host.Addrs(), peerstore.PermanentAddrTTL)
|
|
|
|
_, err := cc.host.Network().DialPeer(ctx, cc2.host.ID())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
|
|
|
|
err = cc.AddPeer(ctx, cc2.host.ID())
|
|
|
|
if err != nil {
|
|
|
|
t.Error("could not add peer:", err)
|
|
|
|
}
|
|
|
|
|
2019-05-09 17:48:40 +00:00
|
|
|
err = cc2.Trust(ctx, cc.host.ID())
|
|
|
|
if err != nil {
|
|
|
|
t.Error("could not trust peer:", err)
|
|
|
|
}
|
|
|
|
|
2019-02-20 14:24:25 +00:00
|
|
|
// Make a pin on peer1 and check it arrived to peer2
|
|
|
|
err = cc.LogPin(ctx, testPin(test.Cid1))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
time.Sleep(250 * time.Millisecond)
|
|
|
|
st, err := cc2.State(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("error getting state:", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
pins, err := st.List(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(pins) != 1 || !pins[0].Cid.Equals(test.Cid1) {
|
|
|
|
t.Error("the added pin should be in the state")
|
|
|
|
}
|
|
|
|
|
|
|
|
err = cc2.RmPeer(ctx, cc.host.ID())
|
|
|
|
if err == nil {
|
|
|
|
t.Error("crdt consensus should not remove pins")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-13 21:11:02 +00:00
|
|
|
func TestConsensusDistrustPeer(t *testing.T) {
|
|
|
|
ctx := context.Background()
|
|
|
|
cc := testingConsensus(t, 1)
|
|
|
|
cc2 := testingConsensus(t, 2)
|
|
|
|
defer clean(t, cc)
|
|
|
|
defer clean(t, cc)
|
|
|
|
defer cc.Shutdown(ctx)
|
|
|
|
defer cc2.Shutdown(ctx)
|
|
|
|
|
|
|
|
cc.host.Peerstore().AddAddrs(cc2.host.ID(), cc2.host.Addrs(), peerstore.PermanentAddrTTL)
|
|
|
|
_, err := cc.host.Network().DialPeer(ctx, cc2.host.ID())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
|
|
|
|
err = cc2.Trust(ctx, cc.host.ID())
|
|
|
|
if err != nil {
|
|
|
|
t.Error("could not trust peer:", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make a pin on peer1 and check it arrived to peer2
|
|
|
|
err = cc.LogPin(ctx, testPin(test.Cid1))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
time.Sleep(250 * time.Millisecond)
|
|
|
|
|
|
|
|
err = cc2.Distrust(ctx, cc.host.ID())
|
|
|
|
if err != nil {
|
|
|
|
t.Error("could not distrust peer:", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Another pin should never get to peer2
|
|
|
|
err = cc.LogPin(ctx, testPin(test.Cid2))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verify we only got the first pin
|
|
|
|
st, err := cc2.State(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("error getting state:", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
pins, err := st.List(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(pins) != 1 || !pins[0].Cid.Equals(test.Cid1) {
|
2019-10-31 20:51:13 +00:00
|
|
|
t.Error("only first pin should be in the state")
|
2019-05-13 21:11:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-20 14:24:25 +00:00
|
|
|
func TestPeers(t *testing.T) {
|
|
|
|
ctx := context.Background()
|
|
|
|
cc := testingConsensus(t, 1)
|
|
|
|
defer clean(t, cc)
|
|
|
|
defer cc.Shutdown(ctx)
|
|
|
|
|
|
|
|
peers, err := cc.Peers(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// 1 is ourselves and the other comes from rpc
|
|
|
|
// mock PeerMonitorLatestMetrics
|
|
|
|
if len(peers) != 2 {
|
|
|
|
t.Error("unexpected number of peers")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestOfflineState(t *testing.T) {
|
|
|
|
ctx := context.Background()
|
|
|
|
cc := testingConsensus(t, 1)
|
|
|
|
defer clean(t, cc)
|
|
|
|
defer cc.Shutdown(ctx)
|
|
|
|
|
|
|
|
// Make pin 1
|
|
|
|
err := cc.LogPin(ctx, testPin(test.Cid1))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make pin 2
|
|
|
|
err = cc.LogPin(ctx, testPin(test.Cid2))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = cc.Shutdown(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
offlineState, err := OfflineState(cc.config, cc.store)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
pins, err := offlineState.List(ctx)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(pins) != 2 {
|
|
|
|
t.Error("there should be two pins in the state")
|
|
|
|
}
|
|
|
|
}
|