bootstrap.go

package main

import (
	"context"
	"errors"
	"fmt"
	"sync"

	host "github.com/libp2p/go-libp2p-host"
	pstore "github.com/libp2p/go-libp2p-peerstore"
	ma "github.com/multiformats/go-multiaddr"
)

func convertPeers(peers []string) ([]pstore.PeerInfo, error) {
	pinfos := make([]pstore.PeerInfo, len(peers))
	for i, peer := range peers {
		maddr := ma.StringCast(peer)
		p, err := pstore.InfoFromP2pAddr(maddr)
		if err != nil {
			return nil, err
		}
		pinfos[i] = *p
	}
	return pinfos, nil
}

// This code is borrowed from the go-ipfs bootstrap process
func bootstrapConnect(ctx context.Context, ph host.Host, peers []pstore.PeerInfo) error {
	if len(peers) < 1 {
		return errors.New("not enough bootstrap peers")
	}

	errs := make(chan error, len(peers))
	var wg sync.WaitGroup
	for _, p := range peers {

		// performed asynchronously because when performed synchronously, if
		// one `Connect` call hangs, subsequent calls are more likely to
		// fail/abort due to an expiring context.
		// Also, performed asynchronously for dial speed.

		wg.Add(1)
		go func(p pstore.PeerInfo) {
			defer wg.Done()
			defer logger.Debug(ctx, "bootstrapDial", ph.ID(), p.ID)
			logger.Debugf("%s bootstrapping to %s", ph.ID(), p.ID)

			ph.Peerstore().AddAddrs(p.ID, p.Addrs, pstore.PermanentAddrTTL)
			if err := ph.Connect(ctx, p); err != nil {
				logger.Errorf("Failed to bootstrap with %v: %s", p.ID, err)
				errs <- err
				return
			}
			logger.Debug(ctx, "bootstrapDialSuccess", p.ID)
			logger.Debugf("Bootstrapped with %v", p.ID)
		}(p)
	}
	wg.Wait()

	// our failure condition is when no connection attempt succeeded.
	// So drain the errs channel, counting the results.
	close(errs)
	count := 0
	var err error
	for err = range errs {
		if err != nil {
			count++
		}
	}
	if count == len(peers) {
		return fmt.Errorf("Failed to bootstrap. %s", err)
	}
	return nil
}