Added fixed peer list

distinct.go

@@ -16,6 +16,7 @@ type distinctPeers struct {
 	bp                        *blacklistedPeers
 	whitelistedPeers          map[string]struct{}
 	peers                     map[string]struct{}
+	startingPeers             []string
 	maxPeers                  int
 	db                        *pebble.DB
 	mux                       sync.RWMutex
@@ -27,6 +28,7 @@ func newDistinctPeers(startingPeers []string, whitelistedPeers []string, maxPeer
 		bp:                        bp,
 		peers:                     make(map[string]struct{}, maxPeers),
 		whitelistedPeers:          createWhitelistedPeersMap(whitelistedPeers),
+		startingPeers:             startingPeers,
 		maxPeers:                  maxPeers,
 		db:                        db,
 		exchangeConnectionTimeout: exchangeConnectionTimeout,
@@ -64,7 +66,11 @@ func (p *distinctPeers) isWhitelisted(peer string) bool {
 	return ok
 }
 
-func (p *distinctPeers) build() ([]string, error) {
+func (p *distinctPeers) build(fixedPeerList bool) ([]string, error) {
+	if fixedPeerList {
+		return p.startingPeers, nil
+	}
+
 	peer, err := p.getRandomPeer()
 	if err != nil {
 		return nil, errors.Wrap(err, "getting random peer")

main.go

@@ -28,7 +28,8 @@ func run() error {
 			ShutdownTimeout time.Duration `conf:"default:5s"`
 		}
 		Qubic struct {
-			StartingPeerIP  string `conf:"default:95.156.231.18"`
+			FixedPeerList   bool     `conf:"default:false"`
+			StartingPeersIP []string `conf:"default:185.70.186.149;185.70.186.153"`
 			WhitelistPeers  []string
 			MaxPeers        int           `conf:"default:50"`
 			ExchangeTimeout time.Duration `conf:"default:2s"`
@@ -66,7 +67,7 @@ func run() error {
 		log.Fatalf("err opening pebble: %s", err.Error())
 	}
 
-	rp, err := NewPeers(cfg.Qubic.StartingPeerIP, cfg.Qubic.WhitelistPeers, cfg.Qubic.MaxPeers, cfg.Qubic.ExchangeTimeout, db)
+	rp, err := NewPeers(cfg.Qubic.FixedPeerList, cfg.Qubic.StartingPeersIP, cfg.Qubic.WhitelistPeers, cfg.Qubic.MaxPeers, cfg.Qubic.ExchangeTimeout, db)
 	if err != nil {
 		return errors.Wrap(err, "creating new peers")
 	}
@@ -78,7 +79,7 @@ func run() error {
 	h := Handler{rp: rp}
 
 	go func() {
-		ticker := time.NewTicker(1 * time.Minute)
+		ticker := time.NewTicker(15 * time.Second)
 		for {
 			select {
 			case <-ticker.C:

peers.go

@@ -7,33 +7,39 @@ import (
 )
 
 type Peers struct {
-	dp *distinctPeers
-	rp *reliablePeers
+	dp            *distinctPeers
+	rp            *reliablePeers
+	fixedPeerList bool
 }
 
 type PeersResponse struct {
 	Peers     []string
 	UpdatedAt int64
 }
 
-func NewPeers(startingPeer string, whitelistedPeers []string, maxPeers int, exchangeConnectionTimeout time.Duration, db *pebble.DB) (*Peers, error) {
-	storedPeers, err := retrievePeers(db)
-	if err != nil {
-		return nil, errors.Wrap(err, "retrieving peers from store")
+func NewPeers(fixedPeerList bool, startingPeers []string, whitelistedPeers []string, maxPeers int, exchangeConnectionTimeout time.Duration, db *pebble.DB) (*Peers, error) {
+
+	if !fixedPeerList {
+		storedPeers, err := retrievePeers(db)
+		if err != nil {
+			return nil, errors.Wrap(err, "retrieving peers from store")
+		}
+
+		startingPeers = append(startingPeers, storedPeers...)
 	}
 
-	initialPeers := append(storedPeers, startingPeer)
 	bp := newBlacklistedPeers()
 	p := Peers{
-		dp: newDistinctPeers(initialPeers, whitelistedPeers, maxPeers, exchangeConnectionTimeout, bp, db),
-		rp: newReliablePeers(bp),
+		dp:            newDistinctPeers(startingPeers, whitelistedPeers, maxPeers, exchangeConnectionTimeout, bp, db),
+		rp:            newReliablePeers(bp),
+		fixedPeerList: fixedPeerList,
 	}
 
 	return &p, nil
 }
 
 func (p *Peers) Compute() error {
-	peers, err := p.dp.build()
+	peers, err := p.dp.build(p.fixedPeerList)
 	if err != nil {
 		return errors.Wrapf(err, "building distinct peers")
 	}