go-ethereum/eth/downloader/synchronous.go

package downloader

import (
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/logger"
	"github.com/ethereum/go-ethereum/logger/glog"
)

// THIS IS PENDING AND TO DO CHANGES FOR MAKING THE DOWNLOADER SYNCHRONOUS

// SynchroniseWithPeer will select the peer and use it for synchronising. If an empty string is given
// it will use the best peer possible and synchronise if it's TD is higher than our own. If any of the
// checks fail an error will be returned. This method is synchronous
func (d *Downloader) SynchroniseWithPeer(id string) (types.Blocks, error) {
	// Check if we're busy
	if d.isBusy() {
		return nil, errBusy
	}

	// Attempt to select a peer. This can either be nothing, which returns, best peer
	// or selected peer. If no peer could be found an error will be returned
	var p *peer
	if len(id) == 0 {
		p = d.peers[id]
		if p == nil {
			return nil, errUnknownPeer
		}
	} else {
		p = d.peers.bestPeer()
	}

	// Make sure our td is lower than the peer's td
	if p.td.Cmp(d.currentTd()) <= 0 || d.hasBlock(p.recentHash) {
		return nil, errLowTd
	}

	// Get the hash from the peer and initiate the downloading progress.
	err := d.getFromPeer(p, p.recentHash, false)
	if err != nil {
		return nil, err
	}

	return d.queue.blocks, nil
}

// Synchronise will synchronise using the best peer.
func (d *Downloader) Synchronise() (types.Blocks, error) {
	return d.SynchroniseWithPeer("")
}

func (d *Downloader) getFromPeer(p *peer, hash common.Hash, ignoreInitial bool) error {
	d.activePeer = p.id

	glog.V(logger.Detail).Infoln("Synchronising with the network using:", p.id)
	// Start the fetcher. This will block the update entirely
	// interupts need to be send to the appropriate channels
	// respectively.
	if err := d.startFetchingHashes(p, hash, ignoreInitial); err != nil {
		// handle error
		glog.V(logger.Debug).Infoln("Error fetching hashes:", err)
		// XXX Reset
		return err
	}

	// Start fetching blocks in paralel. The strategy is simple
	// take any available peers, seserve a chunk for each peer available,
	// let the peer deliver the chunkn and periodically check if a peer
	// has timedout. When done downloading, process blocks.
	if err := d.startFetchingBlocks(p); err != nil {
		glog.V(logger.Debug).Infoln("Error downloading blocks:", err)
		// XXX reset
		return err
	}

	glog.V(logger.Detail).Infoln("Sync completed")

	return nil
}