123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169 |
- // Copyright 2020 The go-ethereum Authors
- // This file is part of the go-ethereum library.
- //
- // The go-ethereum library is free software: you can redistribute it and/or modify
- // it under the terms of the GNU Lesser General Public License as published by
- // the Free Software Foundation, either version 3 of the License, or
- // (at your option) any later version.
- //
- // The go-ethereum library is distributed in the hope that it will be useful,
- // but WITHOUT ANY WARRANTY; without even the implied warranty of
- // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- // GNU Lesser General Public License for more details.
- //
- // You should have received a copy of the GNU Lesser General Public License
- // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
- // Tests that setting the chain head backwards doesn't leave the database in some
- // strange state with gaps in the chain, nor with block data dangling in the future.
- package core
- import (
- "fmt"
- "io/ioutil"
- "math/big"
- "os"
- "strings"
- "testing"
- "time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/core/vm"
- "github.com/ethereum/go-ethereum/params"
- )
- // rewindTest is a test case for chain rollback upon user request.
- type rewindTest struct {
- canonicalBlocks int // Number of blocks to generate for the canonical chain (heavier)
- sidechainBlocks int // Number of blocks to generate for the side chain (lighter)
- freezeThreshold uint64 // Block number until which to move things into the freezer
- commitBlock uint64 // Block number for which to commit the state to disk
- pivotBlock *uint64 // Pivot block number in case of fast sync
- setheadBlock uint64 // Block number to set head back to
- expCanonicalBlocks int // Number of canonical blocks expected to remain in the database (excl. genesis)
- expSidechainBlocks int // Number of sidechain blocks expected to remain in the database (excl. genesis)
- expFrozen int // Number of canonical blocks expected to be in the freezer (incl. genesis)
- expHeadHeader uint64 // Block number of the expected head header
- expHeadFastBlock uint64 // Block number of the expected head fast sync block
- expHeadBlock uint64 // Block number of the expected head full block
- }
- func (tt *rewindTest) dump(crash bool) string {
- buffer := new(strings.Builder)
- fmt.Fprint(buffer, "Chain:\n G")
- for i := 0; i < tt.canonicalBlocks; i++ {
- fmt.Fprintf(buffer, "->C%d", i+1)
- }
- fmt.Fprint(buffer, " (HEAD)\n")
- if tt.sidechainBlocks > 0 {
- fmt.Fprintf(buffer, " └")
- for i := 0; i < tt.sidechainBlocks; i++ {
- fmt.Fprintf(buffer, "->S%d", i+1)
- }
- fmt.Fprintf(buffer, "\n")
- }
- fmt.Fprintf(buffer, "\n")
- if tt.canonicalBlocks > int(tt.freezeThreshold) {
- fmt.Fprint(buffer, "Frozen:\n G")
- for i := 0; i < tt.canonicalBlocks-int(tt.freezeThreshold); i++ {
- fmt.Fprintf(buffer, "->C%d", i+1)
- }
- fmt.Fprintf(buffer, "\n\n")
- } else {
- fmt.Fprintf(buffer, "Frozen: none\n")
- }
- fmt.Fprintf(buffer, "Commit: G")
- if tt.commitBlock > 0 {
- fmt.Fprintf(buffer, ", C%d", tt.commitBlock)
- }
- fmt.Fprint(buffer, "\n")
- if tt.pivotBlock == nil {
- fmt.Fprintf(buffer, "Pivot : none\n")
- } else {
- fmt.Fprintf(buffer, "Pivot : C%d\n", *tt.pivotBlock)
- }
- if crash {
- fmt.Fprintf(buffer, "\nCRASH\n\n")
- } else {
- fmt.Fprintf(buffer, "\nSetHead(%d)\n\n", tt.setheadBlock)
- }
- fmt.Fprintf(buffer, "------------------------------\n\n")
- if tt.expFrozen > 0 {
- fmt.Fprint(buffer, "Expected in freezer:\n G")
- for i := 0; i < tt.expFrozen-1; i++ {
- fmt.Fprintf(buffer, "->C%d", i+1)
- }
- fmt.Fprintf(buffer, "\n\n")
- }
- if tt.expFrozen > 0 {
- if tt.expFrozen >= tt.expCanonicalBlocks {
- fmt.Fprintf(buffer, "Expected in leveldb: none\n")
- } else {
- fmt.Fprintf(buffer, "Expected in leveldb:\n C%d)", tt.expFrozen-1)
- for i := tt.expFrozen - 1; i < tt.expCanonicalBlocks; i++ {
- fmt.Fprintf(buffer, "->C%d", i+1)
- }
- fmt.Fprint(buffer, "\n")
- if tt.expSidechainBlocks > tt.expFrozen {
- fmt.Fprintf(buffer, " └")
- for i := tt.expFrozen - 1; i < tt.expSidechainBlocks; i++ {
- fmt.Fprintf(buffer, "->S%d", i+1)
- }
- fmt.Fprintf(buffer, "\n")
- }
- }
- } else {
- fmt.Fprint(buffer, "Expected in leveldb:\n G")
- for i := tt.expFrozen; i < tt.expCanonicalBlocks; i++ {
- fmt.Fprintf(buffer, "->C%d", i+1)
- }
- fmt.Fprint(buffer, "\n")
- if tt.expSidechainBlocks > tt.expFrozen {
- fmt.Fprintf(buffer, " └")
- for i := tt.expFrozen; i < tt.expSidechainBlocks; i++ {
- fmt.Fprintf(buffer, "->S%d", i+1)
- }
- fmt.Fprintf(buffer, "\n")
- }
- }
- fmt.Fprintf(buffer, "\n")
- fmt.Fprintf(buffer, "Expected head header : C%d\n", tt.expHeadHeader)
- fmt.Fprintf(buffer, "Expected head fast block: C%d\n", tt.expHeadFastBlock)
- if tt.expHeadBlock == 0 {
- fmt.Fprintf(buffer, "Expected head block : G\n")
- } else {
- fmt.Fprintf(buffer, "Expected head block : C%d\n", tt.expHeadBlock)
- }
- return buffer.String()
- }
- // Tests a sethead for a short canonical chain where a recent block was already
- // committed to disk and then the sethead called. In this case we expect the full
- // chain to be rolled back to the committed block. Everything above the sethead
- // point should be deleted. In between the committed block and the requested head
- // the data can remain as "fast sync" data to avoid redownloading it.
- func TestShortSetHead(t *testing.T) { testShortSetHead(t, false) }
- func TestShortSetHeadWithSnapshots(t *testing.T) { testShortSetHead(t, true) }
- func testShortSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
- //
- // Frozen: none
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 8,
- sidechainBlocks: 0,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 0,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain where the fast sync pivot point was
- // already committed, after which sethead was called. In this case we expect the
- // chain to behave like in full sync mode, rolling back to the committed block
- // Everything above the sethead point should be deleted. In between the committed
- // block and the requested head the data can remain as "fast sync" data to avoid
- // redownloading it.
- func TestShortFastSyncedSetHead(t *testing.T) { testShortFastSyncedSetHead(t, false) }
- func TestShortFastSyncedSetHeadWithSnapshots(t *testing.T) { testShortFastSyncedSetHead(t, true) }
- func testShortFastSyncedSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
- //
- // Frozen: none
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 8,
- sidechainBlocks: 0,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 0,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain where the fast sync pivot point was
- // not yet committed, but sethead was called. In this case we expect the chain to
- // detect that it was fast syncing and delete everything from the new head, since
- // we can just pick up fast syncing from there. The head full block should be set
- // to the genesis.
- func TestShortFastSyncingSetHead(t *testing.T) { testShortFastSyncingSetHead(t, false) }
- func TestShortFastSyncingSetHeadWithSnapshots(t *testing.T) { testShortFastSyncingSetHead(t, true) }
- func testShortFastSyncingSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
- //
- // Frozen: none
- // Commit: G
- // Pivot : C4
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 8,
- sidechainBlocks: 0,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 0,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain and a shorter side chain, where a
- // recent block was already committed to disk and then sethead was called. In this
- // test scenario the side chain is below the committed block. In this case we expect
- // the canonical full chain to be rolled back to the committed block. Everything
- // above the sethead point should be deleted. In between the committed block and
- // the requested head the data can remain as "fast sync" data to avoid redownloading
- // it. The side chain should be left alone as it was shorter.
- func TestShortOldForkedSetHead(t *testing.T) { testShortOldForkedSetHead(t, false) }
- func TestShortOldForkedSetHeadWithSnapshots(t *testing.T) { testShortOldForkedSetHead(t, true) }
- func testShortOldForkedSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
- // └->S1->S2->S3
- //
- // Frozen: none
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- // └->S1->S2->S3
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 8,
- sidechainBlocks: 3,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 3,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain and a shorter side chain, where
- // the fast sync pivot point was already committed to disk and then sethead was
- // called. In this test scenario the side chain is below the committed block. In
- // this case we expect the canonical full chain to be rolled back to the committed
- // block. Everything above the sethead point should be deleted. In between the
- // committed block and the requested head the data can remain as "fast sync" data
- // to avoid redownloading it. The side chain should be left alone as it was shorter.
- func TestShortOldForkedFastSyncedSetHead(t *testing.T) {
- testShortOldForkedFastSyncedSetHead(t, false)
- }
- func TestShortOldForkedFastSyncedSetHeadWithSnapshots(t *testing.T) {
- testShortOldForkedFastSyncedSetHead(t, true)
- }
- func testShortOldForkedFastSyncedSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
- // └->S1->S2->S3
- //
- // Frozen: none
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- // └->S1->S2->S3
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 8,
- sidechainBlocks: 3,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 3,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain and a shorter side chain, where
- // the fast sync pivot point was not yet committed, but sethead was called. In this
- // test scenario the side chain is below the committed block. In this case we expect
- // the chain to detect that it was fast syncing and delete everything from the new
- // head, since we can just pick up fast syncing from there. The head full block
- // should be set to the genesis.
- func TestShortOldForkedFastSyncingSetHead(t *testing.T) {
- testShortOldForkedFastSyncingSetHead(t, false)
- }
- func TestShortOldForkedFastSyncingSetHeadWithSnapshots(t *testing.T) {
- testShortOldForkedFastSyncingSetHead(t, true)
- }
- func testShortOldForkedFastSyncingSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
- // └->S1->S2->S3
- //
- // Frozen: none
- // Commit: G
- // Pivot : C4
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- // └->S1->S2->S3
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 8,
- sidechainBlocks: 3,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 3,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain and a shorter side chain, where a
- // recent block was already committed to disk and then sethead was called. In this
- // test scenario the side chain reaches above the committed block. In this case we
- // expect the canonical full chain to be rolled back to the committed block. All
- // data above the sethead point should be deleted. In between the committed block
- // and the requested head the data can remain as "fast sync" data to avoid having
- // to redownload it. The side chain should be truncated to the head set.
- //
- // The side chain could be left to be if the fork point was before the new head
- // we are deleting to, but it would be exceedingly hard to detect that case and
- // properly handle it, so we'll trade extra work in exchange for simpler code.
- func TestShortNewlyForkedSetHead(t *testing.T) { testShortNewlyForkedSetHead(t, false) }
- func TestShortNewlyForkedSetHeadWithSnapshots(t *testing.T) { testShortNewlyForkedSetHead(t, true) }
- func testShortNewlyForkedSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8
- //
- // Frozen: none
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- // └->S1->S2->S3->S4->S5->S6->S7
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 10,
- sidechainBlocks: 8,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 7,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain and a shorter side chain, where
- // the fast sync pivot point was already committed to disk and then sethead was
- // called. In this case we expect the canonical full chain to be rolled back to
- // between the committed block and the requested head the data can remain as
- // "fast sync" data to avoid having to redownload it. The side chain should be
- // truncated to the head set.
- //
- // The side chain could be left to be if the fork point was before the new head
- // we are deleting to, but it would be exceedingly hard to detect that case and
- // properly handle it, so we'll trade extra work in exchange for simpler code.
- func TestShortNewlyForkedFastSyncedSetHead(t *testing.T) {
- testShortNewlyForkedFastSyncedSetHead(t, false)
- }
- func TestShortNewlyForkedFastSyncedSetHeadWithSnapshots(t *testing.T) {
- testShortNewlyForkedFastSyncedSetHead(t, true)
- }
- func testShortNewlyForkedFastSyncedSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8
- //
- // Frozen: none
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- // └->S1->S2->S3->S4->S5->S6->S7
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 10,
- sidechainBlocks: 8,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 7,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain and a shorter side chain, where
- // the fast sync pivot point was not yet committed, but sethead was called. In
- // this test scenario the side chain reaches above the committed block. In this
- // case we expect the chain to detect that it was fast syncing and delete
- // everything from the new head, since we can just pick up fast syncing from
- // there.
- //
- // The side chain could be left to be if the fork point was before the new head
- // we are deleting to, but it would be exceedingly hard to detect that case and
- // properly handle it, so we'll trade extra work in exchange for simpler code.
- func TestShortNewlyForkedFastSyncingSetHead(t *testing.T) {
- testShortNewlyForkedFastSyncingSetHead(t, false)
- }
- func TestShortNewlyForkedFastSyncingSetHeadWithSnapshots(t *testing.T) {
- testShortNewlyForkedFastSyncingSetHead(t, true)
- }
- func testShortNewlyForkedFastSyncingSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8
- //
- // Frozen: none
- // Commit: G
- // Pivot : C4
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- // └->S1->S2->S3->S4->S5->S6->S7
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 10,
- sidechainBlocks: 8,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 7,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain and a longer side chain, where a
- // recent block was already committed to disk and then sethead was called. In this
- // case we expect the canonical full chain to be rolled back to the committed block.
- // All data above the sethead point should be deleted. In between the committed
- // block and the requested head the data can remain as "fast sync" data to avoid
- // having to redownload it. The side chain should be truncated to the head set.
- //
- // The side chain could be left to be if the fork point was before the new head
- // we are deleting to, but it would be exceedingly hard to detect that case and
- // properly handle it, so we'll trade extra work in exchange for simpler code.
- func TestShortReorgedSetHead(t *testing.T) { testShortReorgedSetHead(t, false) }
- func TestShortReorgedSetHeadWithSnapshots(t *testing.T) { testShortReorgedSetHead(t, true) }
- func testShortReorgedSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10
- //
- // Frozen: none
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- // └->S1->S2->S3->S4->S5->S6->S7
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 8,
- sidechainBlocks: 10,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 7,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain and a longer side chain, where
- // the fast sync pivot point was already committed to disk and then sethead was
- // called. In this case we expect the canonical full chain to be rolled back to
- // the committed block. All data above the sethead point should be deleted. In
- // between the committed block and the requested head the data can remain as
- // "fast sync" data to avoid having to redownload it. The side chain should be
- // truncated to the head set.
- //
- // The side chain could be left to be if the fork point was before the new head
- // we are deleting to, but it would be exceedingly hard to detect that case and
- // properly handle it, so we'll trade extra work in exchange for simpler code.
- func TestShortReorgedFastSyncedSetHead(t *testing.T) {
- testShortReorgedFastSyncedSetHead(t, false)
- }
- func TestShortReorgedFastSyncedSetHeadWithSnapshots(t *testing.T) {
- testShortReorgedFastSyncedSetHead(t, true)
- }
- func testShortReorgedFastSyncedSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10
- //
- // Frozen: none
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- // └->S1->S2->S3->S4->S5->S6->S7
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 8,
- sidechainBlocks: 10,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 7,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a short canonical chain and a longer side chain, where
- // the fast sync pivot point was not yet committed, but sethead was called. In
- // this case we expect the chain to detect that it was fast syncing and delete
- // everything from the new head, since we can just pick up fast syncing from
- // there.
- //
- // The side chain could be left to be if the fork point was before the new head
- // we are deleting to, but it would be exceedingly hard to detect that case and
- // properly handle it, so we'll trade extra work in exchange for simpler code.
- func TestShortReorgedFastSyncingSetHead(t *testing.T) {
- testShortReorgedFastSyncingSetHead(t, false)
- }
- func TestShortReorgedFastSyncingSetHeadWithSnapshots(t *testing.T) {
- testShortReorgedFastSyncingSetHead(t, true)
- }
- func testShortReorgedFastSyncingSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10
- //
- // Frozen: none
- // Commit: G
- // Pivot : C4
- //
- // SetHead(7)
- //
- // ------------------------------
- //
- // Expected in leveldb:
- // G->C1->C2->C3->C4->C5->C6->C7
- // └->S1->S2->S3->S4->S5->S6->S7
- //
- // Expected head header : C7
- // Expected head fast block: C7
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 8,
- sidechainBlocks: 10,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 7,
- expCanonicalBlocks: 7,
- expSidechainBlocks: 7,
- expFrozen: 0,
- expHeadHeader: 7,
- expHeadFastBlock: 7,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks where a recent
- // block - newer than the ancient limit - was already committed to disk and then
- // sethead was called. In this case we expect the full chain to be rolled back
- // to the committed block. Everything above the sethead point should be deleted.
- // In between the committed block and the requested head the data can remain as
- // "fast sync" data to avoid redownloading it.
- func TestLongShallowSetHead(t *testing.T) { testLongShallowSetHead(t, false) }
- func TestLongShallowSetHeadWithSnapshots(t *testing.T) { testLongShallowSetHead(t, true) }
- func testLongShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 0,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks where a recent
- // block - older than the ancient limit - was already committed to disk and then
- // sethead was called. In this case we expect the full chain to be rolled back
- // to the committed block. Since the ancient limit was underflown, everything
- // needs to be deleted onwards to avoid creating a gap.
- func TestLongDeepSetHead(t *testing.T) { testLongDeepSetHead(t, false) }
- func TestLongDeepSetHeadWithSnapshots(t *testing.T) { testLongDeepSetHead(t, true) }
- func testLongDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4
- //
- // Expected in leveldb: none
- //
- // Expected head header : C4
- // Expected head fast block: C4
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 0,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 6,
- expCanonicalBlocks: 4,
- expSidechainBlocks: 0,
- expFrozen: 5,
- expHeadHeader: 4,
- expHeadFastBlock: 4,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks where the fast
- // sync pivot point - newer than the ancient limit - was already committed, after
- // which sethead was called. In this case we expect the full chain to be rolled
- // back to the committed block. Everything above the sethead point should be
- // deleted. In between the committed block and the requested head the data can
- // remain as "fast sync" data to avoid redownloading it.
- func TestLongFastSyncedShallowSetHead(t *testing.T) {
- testLongFastSyncedShallowSetHead(t, false)
- }
- func TestLongFastSyncedShallowSetHeadWithSnapshots(t *testing.T) {
- testLongFastSyncedShallowSetHead(t, true)
- }
- func testLongFastSyncedShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 0,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks where the fast
- // sync pivot point - older than the ancient limit - was already committed, after
- // which sethead was called. In this case we expect the full chain to be rolled
- // back to the committed block. Since the ancient limit was underflown, everything
- // needs to be deleted onwards to avoid creating a gap.
- func TestLongFastSyncedDeepSetHead(t *testing.T) { testLongFastSyncedDeepSetHead(t, false) }
- func TestLongFastSyncedDeepSetHeadWithSnapshots(t *testing.T) { testLongFastSyncedDeepSetHead(t, true) }
- func testLongFastSyncedDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4
- //
- // Expected in leveldb: none
- //
- // Expected head header : C4
- // Expected head fast block: C4
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 0,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 4,
- expSidechainBlocks: 0,
- expFrozen: 5,
- expHeadHeader: 4,
- expHeadFastBlock: 4,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks where the fast
- // sync pivot point - newer than the ancient limit - was not yet committed, but
- // sethead was called. In this case we expect the chain to detect that it was fast
- // syncing and delete everything from the new head, since we can just pick up fast
- // syncing from there.
- func TestLongFastSyncingShallowSetHead(t *testing.T) {
- testLongFastSyncingShallowSetHead(t, false)
- }
- func TestLongFastSyncingShallowSetHeadWithSnapshots(t *testing.T) {
- testLongFastSyncingShallowSetHead(t, true)
- }
- func testLongFastSyncingShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 0,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks where the fast
- // sync pivot point - older than the ancient limit - was not yet committed, but
- // sethead was called. In this case we expect the chain to detect that it was fast
- // syncing and delete everything from the new head, since we can just pick up fast
- // syncing from there.
- func TestLongFastSyncingDeepSetHead(t *testing.T) {
- testLongFastSyncingDeepSetHead(t, false)
- }
- func TestLongFastSyncingDeepSetHeadWithSnapshots(t *testing.T) {
- testLongFastSyncingDeepSetHead(t, true)
- }
- func testLongFastSyncingDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4->C5->C6
- //
- // Expected in leveldb: none
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 0,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 7,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter side
- // chain, where a recent block - newer than the ancient limit - was already committed
- // to disk and then sethead was called. In this case we expect the canonical full
- // chain to be rolled back to the committed block. Everything above the sethead point
- // should be deleted. In between the committed block and the requested head the data
- // can remain as "fast sync" data to avoid redownloading it. The side chain is nuked
- // by the freezer.
- func TestLongOldForkedShallowSetHead(t *testing.T) {
- testLongOldForkedShallowSetHead(t, false)
- }
- func TestLongOldForkedShallowSetHeadWithSnapshots(t *testing.T) {
- testLongOldForkedShallowSetHead(t, true)
- }
- func testLongOldForkedShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- // └->S1->S2->S3
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 3,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter side
- // chain, where a recent block - older than the ancient limit - was already committed
- // to disk and then sethead was called. In this case we expect the canonical full
- // chain to be rolled back to the committed block. Since the ancient limit was
- // underflown, everything needs to be deleted onwards to avoid creating a gap. The
- // side chain is nuked by the freezer.
- func TestLongOldForkedDeepSetHead(t *testing.T) { testLongOldForkedDeepSetHead(t, false) }
- func TestLongOldForkedDeepSetHeadWithSnapshots(t *testing.T) { testLongOldForkedDeepSetHead(t, true) }
- func testLongOldForkedDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- // └->S1->S2->S3
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4
- //
- // Expected in leveldb: none
- //
- // Expected head header : C4
- // Expected head fast block: C4
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 3,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 6,
- expCanonicalBlocks: 4,
- expSidechainBlocks: 0,
- expFrozen: 5,
- expHeadHeader: 4,
- expHeadFastBlock: 4,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where the fast sync pivot point - newer than the ancient limit -
- // was already committed to disk and then sethead was called. In this test scenario
- // the side chain is below the committed block. In this case we expect the canonical
- // full chain to be rolled back to the committed block. Everything above the
- // sethead point should be deleted. In between the committed block and the
- // requested head the data can remain as "fast sync" data to avoid redownloading
- // it. The side chain is nuked by the freezer.
- func TestLongOldForkedFastSyncedShallowSetHead(t *testing.T) {
- testLongOldForkedFastSyncedShallowSetHead(t, false)
- }
- func TestLongOldForkedFastSyncedShallowSetHeadWithSnapshots(t *testing.T) {
- testLongOldForkedFastSyncedShallowSetHead(t, true)
- }
- func testLongOldForkedFastSyncedShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- // └->S1->S2->S3
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 3,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where the fast sync pivot point - older than the ancient limit -
- // was already committed to disk and then sethead was called. In this test scenario
- // the side chain is below the committed block. In this case we expect the canonical
- // full chain to be rolled back to the committed block. Since the ancient limit was
- // underflown, everything needs to be deleted onwards to avoid creating a gap. The
- // side chain is nuked by the freezer.
- func TestLongOldForkedFastSyncedDeepSetHead(t *testing.T) {
- testLongOldForkedFastSyncedDeepSetHead(t, false)
- }
- func TestLongOldForkedFastSyncedDeepSetHeadWithSnapshots(t *testing.T) {
- testLongOldForkedFastSyncedDeepSetHead(t, true)
- }
- func testLongOldForkedFastSyncedDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- // └->S1->S2->S3
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4->C5->C6
- //
- // Expected in leveldb: none
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 3,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 4,
- expSidechainBlocks: 0,
- expFrozen: 5,
- expHeadHeader: 4,
- expHeadFastBlock: 4,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where the fast sync pivot point - newer than the ancient limit -
- // was not yet committed, but sethead was called. In this test scenario the side
- // chain is below the committed block. In this case we expect the chain to detect
- // that it was fast syncing and delete everything from the new head, since we can
- // just pick up fast syncing from there. The side chain is completely nuked by the
- // freezer.
- func TestLongOldForkedFastSyncingShallowSetHead(t *testing.T) {
- testLongOldForkedFastSyncingShallowSetHead(t, false)
- }
- func TestLongOldForkedFastSyncingShallowSetHeadWithSnapshots(t *testing.T) {
- testLongOldForkedFastSyncingShallowSetHead(t, true)
- }
- func testLongOldForkedFastSyncingShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- // └->S1->S2->S3
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 3,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where the fast sync pivot point - older than the ancient limit -
- // was not yet committed, but sethead was called. In this test scenario the side
- // chain is below the committed block. In this case we expect the chain to detect
- // that it was fast syncing and delete everything from the new head, since we can
- // just pick up fast syncing from there. The side chain is completely nuked by the
- // freezer.
- func TestLongOldForkedFastSyncingDeepSetHead(t *testing.T) {
- testLongOldForkedFastSyncingDeepSetHead(t, false)
- }
- func TestLongOldForkedFastSyncingDeepSetHeadWithSnapshots(t *testing.T) {
- testLongOldForkedFastSyncingDeepSetHead(t, true)
- }
- func testLongOldForkedFastSyncingDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- // └->S1->S2->S3
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4->C5->C6
- //
- // Expected in leveldb: none
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 3,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 7,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where a recent block - newer than the ancient limit - was already
- // committed to disk and then sethead was called. In this test scenario the side
- // chain is above the committed block. In this case the freezer will delete the
- // sidechain since it's dangling, reverting to TestLongShallowSetHead.
- func TestLongNewerForkedShallowSetHead(t *testing.T) {
- testLongNewerForkedShallowSetHead(t, false)
- }
- func TestLongNewerForkedShallowSetHeadWithSnapshots(t *testing.T) {
- testLongNewerForkedShallowSetHead(t, true)
- }
- func testLongNewerForkedShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 12,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where a recent block - older than the ancient limit - was already
- // committed to disk and then sethead was called. In this test scenario the side
- // chain is above the committed block. In this case the freezer will delete the
- // sidechain since it's dangling, reverting to TestLongDeepSetHead.
- func TestLongNewerForkedDeepSetHead(t *testing.T) {
- testLongNewerForkedDeepSetHead(t, false)
- }
- func TestLongNewerForkedDeepSetHeadWithSnapshots(t *testing.T) {
- testLongNewerForkedDeepSetHead(t, true)
- }
- func testLongNewerForkedDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4
- //
- // Expected in leveldb: none
- //
- // Expected head header : C4
- // Expected head fast block: C4
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 12,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 6,
- expCanonicalBlocks: 4,
- expSidechainBlocks: 0,
- expFrozen: 5,
- expHeadHeader: 4,
- expHeadFastBlock: 4,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where the fast sync pivot point - newer than the ancient limit -
- // was already committed to disk and then sethead was called. In this test scenario
- // the side chain is above the committed block. In this case the freezer will delete
- // the sidechain since it's dangling, reverting to TestLongFastSyncedShallowSetHead.
- func TestLongNewerForkedFastSyncedShallowSetHead(t *testing.T) {
- testLongNewerForkedFastSyncedShallowSetHead(t, false)
- }
- func TestLongNewerForkedFastSyncedShallowSetHeadWithSnapshots(t *testing.T) {
- testLongNewerForkedFastSyncedShallowSetHead(t, true)
- }
- func testLongNewerForkedFastSyncedShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 12,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where the fast sync pivot point - older than the ancient limit -
- // was already committed to disk and then sethead was called. In this test scenario
- // the side chain is above the committed block. In this case the freezer will delete
- // the sidechain since it's dangling, reverting to TestLongFastSyncedDeepSetHead.
- func TestLongNewerForkedFastSyncedDeepSetHead(t *testing.T) {
- testLongNewerForkedFastSyncedDeepSetHead(t, false)
- }
- func TestLongNewerForkedFastSyncedDeepSetHeadWithSnapshots(t *testing.T) {
- testLongNewerForkedFastSyncedDeepSetHead(t, true)
- }
- func testLongNewerForkedFastSyncedDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4
- //
- // Expected in leveldb: none
- //
- // Expected head header : C4
- // Expected head fast block: C4
- // Expected head block : C
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 12,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 4,
- expSidechainBlocks: 0,
- expFrozen: 5,
- expHeadHeader: 4,
- expHeadFastBlock: 4,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where the fast sync pivot point - newer than the ancient limit -
- // was not yet committed, but sethead was called. In this test scenario the side
- // chain is above the committed block. In this case the freezer will delete the
- // sidechain since it's dangling, reverting to TestLongFastSyncinghallowSetHead.
- func TestLongNewerForkedFastSyncingShallowSetHead(t *testing.T) {
- testLongNewerForkedFastSyncingShallowSetHead(t, false)
- }
- func TestLongNewerForkedFastSyncingShallowSetHeadWithSnapshots(t *testing.T) {
- testLongNewerForkedFastSyncingShallowSetHead(t, true)
- }
- func testLongNewerForkedFastSyncingShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 12,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a shorter
- // side chain, where the fast sync pivot point - older than the ancient limit -
- // was not yet committed, but sethead was called. In this test scenario the side
- // chain is above the committed block. In this case the freezer will delete the
- // sidechain since it's dangling, reverting to TestLongFastSyncingDeepSetHead.
- func TestLongNewerForkedFastSyncingDeepSetHead(t *testing.T) {
- testLongNewerForkedFastSyncingDeepSetHead(t, false)
- }
- func TestLongNewerForkedFastSyncingDeepSetHeadWithSnapshots(t *testing.T) {
- testLongNewerForkedFastSyncingDeepSetHead(t, true)
- }
- func testLongNewerForkedFastSyncingDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4->C5->C6
- //
- // Expected in leveldb: none
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 12,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 7,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a longer side
- // chain, where a recent block - newer than the ancient limit - was already committed
- // to disk and then sethead was called. In this case the freezer will delete the
- // sidechain since it's dangling, reverting to TestLongShallowSetHead.
- func TestLongReorgedShallowSetHead(t *testing.T) { testLongReorgedShallowSetHead(t, false) }
- func TestLongReorgedShallowSetHeadWithSnapshots(t *testing.T) { testLongReorgedShallowSetHead(t, true) }
- func testLongReorgedShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 26,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a longer side
- // chain, where a recent block - older than the ancient limit - was already committed
- // to disk and then sethead was called. In this case the freezer will delete the
- // sidechain since it's dangling, reverting to TestLongDeepSetHead.
- func TestLongReorgedDeepSetHead(t *testing.T) { testLongReorgedDeepSetHead(t, false) }
- func TestLongReorgedDeepSetHeadWithSnapshots(t *testing.T) { testLongReorgedDeepSetHead(t, true) }
- func testLongReorgedDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G, C4
- // Pivot : none
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4
- //
- // Expected in leveldb: none
- //
- // Expected head header : C4
- // Expected head fast block: C4
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 26,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: nil,
- setheadBlock: 6,
- expCanonicalBlocks: 4,
- expSidechainBlocks: 0,
- expFrozen: 5,
- expHeadHeader: 4,
- expHeadFastBlock: 4,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a longer
- // side chain, where the fast sync pivot point - newer than the ancient limit -
- // was already committed to disk and then sethead was called. In this case the
- // freezer will delete the sidechain since it's dangling, reverting to
- // TestLongFastSyncedShallowSetHead.
- func TestLongReorgedFastSyncedShallowSetHead(t *testing.T) {
- testLongReorgedFastSyncedShallowSetHead(t, false)
- }
- func TestLongReorgedFastSyncedShallowSetHeadWithSnapshots(t *testing.T) {
- testLongReorgedFastSyncedShallowSetHead(t, true)
- }
- func testLongReorgedFastSyncedShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 26,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a longer
- // side chain, where the fast sync pivot point - older than the ancient limit -
- // was already committed to disk and then sethead was called. In this case the
- // freezer will delete the sidechain since it's dangling, reverting to
- // TestLongFastSyncedDeepSetHead.
- func TestLongReorgedFastSyncedDeepSetHead(t *testing.T) {
- testLongReorgedFastSyncedDeepSetHead(t, false)
- }
- func TestLongReorgedFastSyncedDeepSetHeadWithSnapshots(t *testing.T) {
- testLongReorgedFastSyncedDeepSetHead(t, true)
- }
- func testLongReorgedFastSyncedDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G, C4
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4
- //
- // Expected in leveldb: none
- //
- // Expected head header : C4
- // Expected head fast block: C4
- // Expected head block : C4
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 26,
- freezeThreshold: 16,
- commitBlock: 4,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 4,
- expSidechainBlocks: 0,
- expFrozen: 5,
- expHeadHeader: 4,
- expHeadFastBlock: 4,
- expHeadBlock: 4,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a longer
- // side chain, where the fast sync pivot point - newer than the ancient limit -
- // was not yet committed, but sethead was called. In this case we expect the
- // chain to detect that it was fast syncing and delete everything from the new
- // head, since we can just pick up fast syncing from there. The side chain is
- // completely nuked by the freezer.
- func TestLongReorgedFastSyncingShallowSetHead(t *testing.T) {
- testLongReorgedFastSyncingShallowSetHead(t, false)
- }
- func TestLongReorgedFastSyncingShallowSetHeadWithSnapshots(t *testing.T) {
- testLongReorgedFastSyncingShallowSetHead(t, true)
- }
- func testLongReorgedFastSyncingShallowSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
- //
- // Frozen:
- // G->C1->C2
- //
- // Commit: G
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2
- //
- // Expected in leveldb:
- // C2)->C3->C4->C5->C6
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 18,
- sidechainBlocks: 26,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 3,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 0,
- }, snapshots)
- }
- // Tests a sethead for a long canonical chain with frozen blocks and a longer
- // side chain, where the fast sync pivot point - older than the ancient limit -
- // was not yet committed, but sethead was called. In this case we expect the
- // chain to detect that it was fast syncing and delete everything from the new
- // head, since we can just pick up fast syncing from there. The side chain is
- // completely nuked by the freezer.
- func TestLongReorgedFastSyncingDeepSetHead(t *testing.T) {
- testLongReorgedFastSyncingDeepSetHead(t, false)
- }
- func TestLongReorgedFastSyncingDeepSetHeadWithSnapshots(t *testing.T) {
- testLongReorgedFastSyncingDeepSetHead(t, true)
- }
- func testLongReorgedFastSyncingDeepSetHead(t *testing.T, snapshots bool) {
- // Chain:
- // G->C1->C2->C3->C4->C5->C6->C7->C8->C9->C10->C11->C12->C13->C14->C15->C16->C17->C18->C19->C20->C21->C22->C23->C24 (HEAD)
- // └->S1->S2->S3->S4->S5->S6->S7->S8->S9->S10->S11->S12->S13->S14->S15->S16->S17->S18->S19->S20->S21->S22->S23->S24->S25->S26
- //
- // Frozen:
- // G->C1->C2->C3->C4->C5->C6->C7->C8
- //
- // Commit: G
- // Pivot : C4
- //
- // SetHead(6)
- //
- // ------------------------------
- //
- // Expected in freezer:
- // G->C1->C2->C3->C4->C5->C6
- //
- // Expected in leveldb: none
- //
- // Expected head header : C6
- // Expected head fast block: C6
- // Expected head block : G
- testSetHead(t, &rewindTest{
- canonicalBlocks: 24,
- sidechainBlocks: 26,
- freezeThreshold: 16,
- commitBlock: 0,
- pivotBlock: uint64ptr(4),
- setheadBlock: 6,
- expCanonicalBlocks: 6,
- expSidechainBlocks: 0,
- expFrozen: 7,
- expHeadHeader: 6,
- expHeadFastBlock: 6,
- expHeadBlock: 0,
- }, snapshots)
- }
- func testSetHead(t *testing.T, tt *rewindTest, snapshots bool) {
- // It's hard to follow the test case, visualize the input
- // log.Root().SetHandler(log.LvlFilterHandler(log.LvlTrace, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
- // fmt.Println(tt.dump(false))
- // Create a temporary persistent database
- datadir, err := ioutil.TempDir("", "")
- if err != nil {
- t.Fatalf("Failed to create temporary datadir: %v", err)
- }
- os.RemoveAll(datadir)
- db, err := rawdb.NewLevelDBDatabaseWithFreezer(datadir, 0, 0, datadir, "", false)
- if err != nil {
- t.Fatalf("Failed to create persistent database: %v", err)
- }
- defer db.Close()
- // Initialize a fresh chain
- var (
- genesis = new(Genesis).MustCommit(db)
- engine = ethash.NewFullFaker()
- config = &CacheConfig{
- TrieCleanLimit: 256,
- TrieDirtyLimit: 256,
- TrieTimeLimit: 5 * time.Minute,
- SnapshotLimit: 0, // Disable snapshot
- }
- )
- if snapshots {
- config.SnapshotLimit = 256
- config.SnapshotWait = true
- }
- chain, err := NewBlockChain(db, config, params.AllEthashProtocolChanges, engine, vm.Config{}, nil, nil, nil)
- if err != nil {
- t.Fatalf("Failed to create chain: %v", err)
- }
- // If sidechain blocks are needed, make a light chain and import it
- var sideblocks types.Blocks
- if tt.sidechainBlocks > 0 {
- sideblocks, _ = GenerateChain(params.TestChainConfig, genesis, engine, rawdb.NewMemoryDatabase(), tt.sidechainBlocks, func(i int, b *BlockGen) {
- b.SetCoinbase(common.Address{0x01})
- })
- if _, err := chain.InsertChain(sideblocks); err != nil {
- t.Fatalf("Failed to import side chain: %v", err)
- }
- }
- canonblocks, _ := GenerateChain(params.TestChainConfig, genesis, engine, rawdb.NewMemoryDatabase(), tt.canonicalBlocks, func(i int, b *BlockGen) {
- b.SetCoinbase(common.Address{0x02})
- b.SetDifficulty(big.NewInt(1000000))
- })
- if _, err := chain.InsertChain(canonblocks[:tt.commitBlock]); err != nil {
- t.Fatalf("Failed to import canonical chain start: %v", err)
- }
- if tt.commitBlock > 0 {
- chain.stateCache.TrieDB().Commit(canonblocks[tt.commitBlock-1].Root(), true, nil)
- if snapshots {
- if err := chain.snaps.Cap(canonblocks[tt.commitBlock-1].Root(), 0); err != nil {
- t.Fatalf("Failed to flatten snapshots: %v", err)
- }
- }
- }
- if _, err := chain.InsertChain(canonblocks[tt.commitBlock:]); err != nil {
- t.Fatalf("Failed to import canonical chain tail: %v", err)
- }
- // Manually dereference anything not committed to not have to work with 128+ tries
- for _, block := range sideblocks {
- chain.stateCache.TrieDB().Dereference(block.Root())
- }
- for _, block := range canonblocks {
- chain.stateCache.TrieDB().Dereference(block.Root())
- }
- // Force run a freeze cycle
- type freezer interface {
- Freeze(threshold uint64) error
- Ancients() (uint64, error)
- }
- db.(freezer).Freeze(tt.freezeThreshold)
- // Set the simulated pivot block
- if tt.pivotBlock != nil {
- rawdb.WriteLastPivotNumber(db, *tt.pivotBlock)
- }
- // Set the head of the chain back to the requested number
- chain.SetHead(tt.setheadBlock)
- // Iterate over all the remaining blocks and ensure there are no gaps
- verifyNoGaps(t, chain, true, canonblocks)
- verifyNoGaps(t, chain, false, sideblocks)
- verifyCutoff(t, chain, true, canonblocks, tt.expCanonicalBlocks)
- verifyCutoff(t, chain, false, sideblocks, tt.expSidechainBlocks)
- if head := chain.CurrentHeader(); head.Number.Uint64() != tt.expHeadHeader {
- t.Errorf("Head header mismatch: have %d, want %d", head.Number, tt.expHeadHeader)
- }
- if head := chain.CurrentFastBlock(); head.NumberU64() != tt.expHeadFastBlock {
- t.Errorf("Head fast block mismatch: have %d, want %d", head.NumberU64(), tt.expHeadFastBlock)
- }
- if head := chain.CurrentBlock(); head.NumberU64() != tt.expHeadBlock {
- t.Errorf("Head block mismatch: have %d, want %d", head.NumberU64(), tt.expHeadBlock)
- }
- if frozen, err := db.(freezer).Ancients(); err != nil {
- t.Errorf("Failed to retrieve ancient count: %v\n", err)
- } else if int(frozen) != tt.expFrozen {
- t.Errorf("Frozen block count mismatch: have %d, want %d", frozen, tt.expFrozen)
- }
- }
- // verifyNoGaps checks that there are no gaps after the initial set of blocks in
- // the database and errors if found.
- func verifyNoGaps(t *testing.T, chain *BlockChain, canonical bool, inserted types.Blocks) {
- t.Helper()
- var end uint64
- for i := uint64(0); i <= uint64(len(inserted)); i++ {
- header := chain.GetHeaderByNumber(i)
- if header == nil && end == 0 {
- end = i
- }
- if header != nil && end > 0 {
- if canonical {
- t.Errorf("Canonical header gap between #%d-#%d", end, i-1)
- } else {
- t.Errorf("Sidechain header gap between #%d-#%d", end, i-1)
- }
- end = 0 // Reset for further gap detection
- }
- }
- end = 0
- for i := uint64(0); i <= uint64(len(inserted)); i++ {
- block := chain.GetBlockByNumber(i)
- if block == nil && end == 0 {
- end = i
- }
- if block != nil && end > 0 {
- if canonical {
- t.Errorf("Canonical block gap between #%d-#%d", end, i-1)
- } else {
- t.Errorf("Sidechain block gap between #%d-#%d", end, i-1)
- }
- end = 0 // Reset for further gap detection
- }
- }
- end = 0
- for i := uint64(1); i <= uint64(len(inserted)); i++ {
- receipts := chain.GetReceiptsByHash(inserted[i-1].Hash())
- if receipts == nil && end == 0 {
- end = i
- }
- if receipts != nil && end > 0 {
- if canonical {
- t.Errorf("Canonical receipt gap between #%d-#%d", end, i-1)
- } else {
- t.Errorf("Sidechain receipt gap between #%d-#%d", end, i-1)
- }
- end = 0 // Reset for further gap detection
- }
- }
- }
- // verifyCutoff checks that there are no chain data available in the chain after
- // the specified limit, but that it is available before.
- func verifyCutoff(t *testing.T, chain *BlockChain, canonical bool, inserted types.Blocks, head int) {
- t.Helper()
- for i := 1; i <= len(inserted); i++ {
- if i <= head {
- if header := chain.GetHeader(inserted[i-1].Hash(), uint64(i)); header == nil {
- if canonical {
- t.Errorf("Canonical header #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- } else {
- t.Errorf("Sidechain header #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- }
- }
- if block := chain.GetBlock(inserted[i-1].Hash(), uint64(i)); block == nil {
- if canonical {
- t.Errorf("Canonical block #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- } else {
- t.Errorf("Sidechain block #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- }
- }
- if receipts := chain.GetReceiptsByHash(inserted[i-1].Hash()); receipts == nil {
- if canonical {
- t.Errorf("Canonical receipts #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- } else {
- t.Errorf("Sidechain receipts #%2d [%x...] missing before cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- }
- }
- } else {
- if header := chain.GetHeader(inserted[i-1].Hash(), uint64(i)); header != nil {
- if canonical {
- t.Errorf("Canonical header #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- } else {
- t.Errorf("Sidechain header #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- }
- }
- if block := chain.GetBlock(inserted[i-1].Hash(), uint64(i)); block != nil {
- if canonical {
- t.Errorf("Canonical block #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- } else {
- t.Errorf("Sidechain block #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- }
- }
- if receipts := chain.GetReceiptsByHash(inserted[i-1].Hash()); receipts != nil {
- if canonical {
- t.Errorf("Canonical receipts #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- } else {
- t.Errorf("Sidechain receipts #%2d [%x...] present after cap %d", inserted[i-1].Number(), inserted[i-1].Hash().Bytes()[:3], head)
- }
- }
- }
- }
- }
- // uint64ptr is a weird helper to allow 1-line constant pointer creation.
- func uint64ptr(n uint64) *uint64 {
- return &n
- }
|