eth/downloader: use full sync mode for devsync

Author: rjl493456442

eth/downloader/beacondevsync.go

@@ -21,6 +21,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/log"
 )
 
@@ -34,6 +35,9 @@ import (
 // to use this instead of giving us the payload first, then essentially nobody
 // in the network would have the block yet that we'd attempt to retrieve.
 func (d *Downloader) BeaconDevSync(header *types.Header) error {
+	if !d.moder.setMode(ethconfig.FullSync) {
+		return errors.New("full sync is not allowed")
+	}
 	// Be very loud that this code should not be used in a live node
 	log.Warn("----------------------------------")
 	log.Warn("Beacon syncing with hash as target", "number", header.Number, "hash", header.Hash())

eth/downloader/downloader.go

@@ -364,8 +364,7 @@ func (d *Downloader) synchronise(beaconPing chan struct{}) (err error) {
 	mode := d.moder.getMode()
 	defer func() {
 		if err == nil && mode == ethconfig.SnapSync {
-			d.moder.disableSnap()
-			log.Info("Disabled the snap sync after the initial sync cycle")
+			d.moder.setMode(ethconfig.FullSync)
 		}
 	}()
 	if mode == ethconfig.SnapSync {

eth/downloader/syncmode.go

@@ -36,6 +36,24 @@ type moder struct {
 }
 
 func newSyncModer(mode ethconfig.SyncMode, chain BlockChain, disk ethdb.KeyValueReader) *moder {
+	m := &moder{
+		chain: chain,
+		disk:  disk,
+	}
+	valid, reason, suggest := m.validate(mode)
+	if !valid {
+		m.mode = suggest
+		log.Info("Switched sync mode", "want", mode, "use", suggest, "reason", reason)
+	} else {
+		m.mode = mode
+		log.Info("Initialized sync mode", "mode", mode)
+	}
+	return m
+}
+
+// validate checks if the specified sync mode is compatible with local chain and
+// returns the suggested mode if it's not along with the reason.
+func (m *moder) validate(mode ethconfig.SyncMode) (bool, string, ethconfig.SyncMode) {
 	if mode == ethconfig.FullSync {
 		// The database seems empty as the current block is the genesis. Yet the snap
 		// block is ahead, so snap sync was enabled for this node at a certain point.
@@ -45,32 +63,24 @@ func newSyncModer(mode ethconfig.SyncMode, chain BlockChain, disk ethdb.KeyValue
 		// * the last snap sync is not finished while user specifies a full sync this
 		//   time. But we don't have any recent state for full sync.
 		// In these cases however it's safe to reenable snap sync.
-		fullBlock, snapBlock := chain.CurrentBlock(), chain.CurrentSnapBlock()
+		fullBlock, snapBlock := m.chain.CurrentBlock(), m.chain.CurrentSnapBlock()
 		if fullBlock.Number.Uint64() == 0 && snapBlock.Number.Uint64() > 0 {
-			mode = ethconfig.SnapSync
-			log.Warn("Switch sync mode from full sync to snap sync", "reason", "snap sync incomplete")
-		} else if !chain.HasState(fullBlock.Root) {
-			mode = ethconfig.SnapSync
-			log.Warn("Switch sync mode from full sync to snap sync", "reason", "head state missing")
+			return false, "snap sync incomplete", ethconfig.SnapSync
+		} else if !m.chain.HasState(fullBlock.Root) {
+			return false, "head state missing", ethconfig.SnapSync
 		} else {
-			// Grant the full sync mode
-			log.Info("Enabled full sync", "head", fullBlock.Number, "hash", fullBlock.Hash())
+			// If full sync was requested and our chain is stateful, grant it
+			return true, "", ethconfig.FullSync
 		}
 	} else {
-		head := chain.CurrentBlock()
-		if head.Number.Uint64() > 0 && chain.HasState(head.Root) {
-			mode = ethconfig.FullSync
-			log.Info("Switch sync mode from snap sync to full sync", "reason", "snap sync complete")
+		head := m.chain.CurrentBlock()
+		if head.Number.Uint64() > 0 && m.chain.HasState(head.Root) {
+			return false, "snap sync complete", ethconfig.FullSync
 		} else {
 			// If snap sync was requested and our database is empty, grant it
-			log.Info("Enabled snap sync", "head", head.Number, "hash", head.Hash())
+			return true, "", ethconfig.SnapSync
 		}
 	}
-	return &moder{
-		mode:  mode,
-		chain: chain,
-		disk:  disk,
-	}
 }
 
 // getMode retrieves the current sync mode, either explicitly set, or derived
@@ -103,14 +113,19 @@ func (m *moder) getMode() ethconfig.SyncMode {
 	return ethconfig.FullSync
 }
 
-// disableSnap disables the snap sync mode, usually it's called after a successful
-// snap sync.
-func (m *moder) disableSnap() {
+// setMode sets the sync mode with the specified one.
+func (m *moder) setMode(mode ethconfig.SyncMode) bool {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
-	if m.mode == ethconfig.FullSync {
-		return
+	if m.mode == mode {
+		return true
+	}
+	if valid, _, _ := m.validate(mode); !valid {
+		return false
 	}
-	m.mode = ethconfig.FullSync
+	old := m.mode
+	m.mode = mode
+	log.Info("Switched sync mode", "old", old, "new", mode)
+	return true
 }

eth/syncer/syncer.go

@@ -25,7 +25,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
@@ -129,11 +128,7 @@ func (s *Syncer) run() {
 				break
 			}
 			if resync {
-				if mode := s.backend.Downloader().GetSyncMode(); mode != ethconfig.FullSync {
-					req.errc <- fmt.Errorf("unsupported syncmode %v", mode)
-				} else {
-					req.errc <- s.backend.Downloader().BeaconDevSync(target)
-				}
+				req.errc <- s.backend.Downloader().BeaconDevSync(target)
 			}
 
 		case <-ticker.C: