refactor(p2p): Use PeerIDStore iface instead of direct impol

p2p/exchange_test.go

@@ -20,6 +20,7 @@ import (
 
 	"github.com/celestiaorg/go-libp2p-messenger/serde"
 
+	"github.com/celestiaorg/go-header"
 	"github.com/celestiaorg/go-header/headertest"
 	p2p_pb "github.com/celestiaorg/go-header/p2p/pb"
 )

p2p/peer_tracker.go

@@ -10,8 +10,6 @@ import (
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/p2p/net/conngater"
-
-	"github.com/celestiaorg/go-header/p2p/persisted_peerstore"
 )
 
 const (
@@ -42,8 +40,8 @@ type PeerTracker struct {
 	// online until pruneDeadline, it will be removed and its score will be lost.
 	disconnectedPeers map[peer.ID]*peerStat
 
-	// peerstore is used to store peers periodically.
-	peerstore *persisted_peerstore.PersistedPeerstore
+	// pidstore is used to store peers periodically.
+	pidstore PeerIDStore
 
 	ctx    context.Context
 	cancel context.CancelFunc
@@ -55,15 +53,15 @@ type PeerTracker struct {
 func NewPeerTracker(
 	h host.Host,
 	connGater *conngater.BasicConnectionGater,
-	peerstore *persisted_peerstore.PersistedPeerstore,
+	pidstore PeerIDStore,
 ) *PeerTracker {
 	ctx, cancel := context.WithCancel(context.Background())
 	return &PeerTracker{
 		host:              h,
 		connGater:         connGater,
 		disconnectedPeers: make(map[peer.ID]*peerStat),
 		trackedPeers:      make(map[peer.ID]*peerStat),
-		peerstore:         peerstore,
+		pidstore:          pidstore,
 		ctx:               ctx,
 		cancel:            cancel,
 		done:              make(chan struct{}, 2),
@@ -211,11 +209,11 @@ func (p *PeerTracker) gc() {
 }
 
 func (p *PeerTracker) persistPeers(trackedPeers []peer.ID) {
-	if p.peerstore == nil {
+	if p.pidstore == nil {
 		return
 	}
 
-	err := p.peerstore.Put(p.ctx, trackedPeers)
+	err := p.pidstore.Put(p.ctx, trackedPeers)
 	if err != nil {
 		log.Errorw("persisting updated peer list", "err", err)
 	}

p2p/peer_tracker_test.go

@@ -2,18 +2,20 @@ package p2p
 
 import (
 	"context"
+	"crypto/rand"
+	"crypto/rsa"
+	"encoding/json"
 	"errors"
+	"github.com/libp2p/go-libp2p/core/crypto"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"testing"
 	"time"
 
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/sync"
-	"github.com/libp2p/go-libp2p/p2p/host/peerstore/pstoremem"
 	"github.com/libp2p/go-libp2p/p2p/net/conngater"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	"github.com/celestiaorg/go-header/p2p/persisted_peerstore"
 )
 
 func TestPeerTracker_GC(t *testing.T) {
@@ -27,20 +29,16 @@ func TestPeerTracker_GC(t *testing.T) {
 	connGater, err := conngater.NewBasicConnectionGater(sync.MutexWrap(datastore.NewMapDatastore()))
 	require.NoError(t, err)
 
-	ds := sync.MutexWrap(datastore.NewMapDatastore())
-	addrBook, err := pstoremem.NewPeerstore()
-	require.NoError(t, err)
-
-	mockPeerStore := persisted_peerstore.NewPersistedPeerstore(ds, addrBook)
+	mockPeerStore := newMockPIDStore()
 	p := NewPeerTracker(h[0], connGater, mockPeerStore)
 
-	peerlist, err := persisted_peerstore.GenerateRandomPeerlist(4)
+	peerlist, err := generateRandomPeerlist(4)
 	require.NoError(t, err)
 
-	pid1 := peerlist[0].ID
-	pid2 := peerlist[1].ID
-	pid3 := peerlist[2].ID
-	pid4 := peerlist[3].ID
+	pid1 := peerlist[0]
+	pid2 := peerlist[1]
+	pid3 := peerlist[2]
+	pid4 := peerlist[3]
 
 	// Add peer with low score to test if it will be GC'ed (it should)
 	p.trackedPeers[pid1] = &peerStat{peerID: pid1, peerScore: 0.5}
@@ -73,7 +71,7 @@ func TestPeerTracker_GC(t *testing.T) {
 	peers, err := mockPeerStore.Load(ctx)
 	require.NoError(t, err)
 
-	assert.Equal(t, peers[0].ID, p.trackedPeers[pid2].peerID)
+	assert.Equal(t, peers[0], p.trackedPeers[pid2].peerID)
 	assert.Equal(t, 1, len(p.trackedPeers))
 }
 
@@ -87,3 +85,55 @@ func TestPeerTracker_BlockPeer(t *testing.T) {
 	require.Len(t, connGater.ListBlockedPeers(), 1)
 	require.True(t, connGater.ListBlockedPeers()[0] == h[1].ID())
 }
+
+type mockPIDStore struct {
+	ds datastore.Datastore
+}
+
+func (m mockPIDStore) Put(ctx context.Context, peers []peer.ID) error {
+	bin, err := json.Marshal(peers)
+	if err != nil {
+		return err
+	}
+
+	return m.ds.Put(ctx, datastore.NewKey("peers"), bin)
+}
+
+func (m mockPIDStore) Load(ctx context.Context) ([]peer.ID, error) {
+	bin, err := m.ds.Get(ctx, datastore.NewKey("peers"))
+	if err != nil {
+		return nil, err
+	}
+
+	var peers []peer.ID
+	err = json.Unmarshal(bin, &peers)
+	return peers, err
+}
+
+func newMockPIDStore() PeerIDStore {
+	return &mockPIDStore{ds: sync.MutexWrap(datastore.NewMapDatastore())}
+}
+
+func generateRandomPeerlist(length int) ([]peer.ID, error) {
+	peerlist := make([]peer.ID, length)
+	for i := range peerlist {
+		key, err := rsa.GenerateKey(rand.Reader, 2096)
+		if err != nil {
+			return nil, err
+		}
+
+		_, pubkey, err := crypto.KeyPairFromStdKey(key)
+		if err != nil {
+			return nil, err
+		}
+
+		peerID, err := peer.IDFromPublicKey(pubkey)
+		if err != nil {
+			return nil, err
+		}
+
+		peerlist[i] = peerID
+	}
+
+	return peerlist, nil
+}