Method synchronize

protocols/cpc/sync.go:188–219

Synchronise tries to sync up our local block chain with a remote peer. It fetches blocks a peer.

(peer *peer)

// Synchronise tries to sync up our local block chain with a remote peer. It fetches blocks a peer.
func (pm *ProtocolManager) synchronize(peer *peer) {
	if peer == nil {
		return
	}

	// make sure the peer has more blocks
	currentBlock := pm.blockchain.CurrentBlock()
	height := currentBlock.Number()
	pHead, pHt := peer.Head()
	if pHt.Cmp(height) <= 0 {
		return
	}

	// full sync with the downloader
	if err := pm.syncer.Synchronise(peer, pHead, pHt, pm.syncMode); err != nil {
		return
	}

	// because we have done the synchronization
	atomic.StoreUint32(&pm.acceptTxs, 1) // Mark initial sync done

	if head := pm.blockchain.CurrentBlock(); head.NumberU64() > 0 {
		// We've completed a sync cycle, notify all peers of new state. This path is
		// essential in star-topology networks where a gateway node needs to notify
		// all its out-of-date peers of the availability of a new block. This failure
		// scenario will most often crop up in private and hackathon networks with
		// degenerate connectivity, but it should be healthy for the mainnet too to
		// more reliably update peers or the local TD state.
		go pm.BroadcastBlock(head, false)
		go pm.BroadcastBlock(head, true)
	}
}