github.com/core-coin/go-core/v2@v2.1.9/core/chain_indexer_test.go (about) 1 // Copyright 2017 by the Authors 2 // This file is part of the go-core library. 3 // 4 // The go-core library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-core library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-core library. If not, see <http://www.gnu.org/licenses/>. 16 17 package core 18 19 import ( 20 "context" 21 "fmt" 22 "math/big" 23 "math/rand" 24 "testing" 25 "time" 26 27 "github.com/core-coin/go-core/v2/common" 28 "github.com/core-coin/go-core/v2/core/rawdb" 29 "github.com/core-coin/go-core/v2/core/types" 30 ) 31 32 // Runs multiple tests with randomized parameters. 33 func TestChainIndexerSingle(t *testing.T) { 34 for i := 0; i < 10; i++ { 35 testChainIndexer(t, 1) 36 } 37 } 38 39 // Runs multiple tests with randomized parameters and different number of 40 // chain backends. 41 func TestChainIndexerWithChildren(t *testing.T) { 42 for i := 2; i < 8; i++ { 43 testChainIndexer(t, i) 44 } 45 } 46 47 // testChainIndexer runs a test with either a single chain indexer or a chain of 48 // multiple backends. The section size and required confirmation count parameters 49 // are randomized. 50 func testChainIndexer(t *testing.T, count int) { 51 db := rawdb.NewMemoryDatabase() 52 defer db.Close() 53 54 // Create a chain of indexers and ensure they all report empty 55 backends := make([]*testChainIndexBackend, count) 56 for i := 0; i < count; i++ { 57 var ( 58 sectionSize = uint64(rand.Intn(100) + 1) 59 confirmsReq = uint64(rand.Intn(10)) 60 ) 61 backends[i] = &testChainIndexBackend{t: t, processCh: make(chan uint64)} 62 backends[i].indexer = NewChainIndexer(db, rawdb.NewTable(db, string([]byte{byte(i)})), backends[i], sectionSize, confirmsReq, 0, fmt.Sprintf("indexer-%d", i)) 63 64 if sections, _, _ := backends[i].indexer.Sections(); sections != 0 { 65 t.Fatalf("Canonical section count mismatch: have %v, want %v", sections, 0) 66 } 67 if i > 0 { 68 backends[i-1].indexer.AddChildIndexer(backends[i].indexer) 69 } 70 } 71 defer backends[0].indexer.Close() // parent indexer shuts down children 72 // notify pings the root indexer about a new head or reorg, then expect 73 // processed blocks if a section is processable 74 notify := func(headNum, failNum uint64, reorg bool) { 75 backends[0].indexer.newHead(headNum, reorg) 76 if reorg { 77 for _, backend := range backends { 78 headNum = backend.reorg(headNum) 79 backend.assertSections() 80 } 81 return 82 } 83 var cascade bool 84 for _, backend := range backends { 85 headNum, cascade = backend.assertBlocks(headNum, failNum) 86 if !cascade { 87 break 88 } 89 backend.assertSections() 90 } 91 } 92 // inject inserts a new random canonical header into the database directly 93 inject := func(number uint64) { 94 header := &types.Header{Number: big.NewInt(int64(number)), Extra: big.NewInt(rand.Int63()).Bytes()} 95 if number > 0 { 96 header.ParentHash = rawdb.ReadCanonicalHash(db, number-1) 97 } 98 rawdb.WriteHeader(db, header) 99 rawdb.WriteCanonicalHash(db, header.Hash(), number) 100 } 101 // Start indexer with an already existing chain 102 for i := uint64(0); i <= 100; i++ { 103 inject(i) 104 } 105 notify(100, 100, false) 106 107 // Add new blocks one by one 108 for i := uint64(101); i <= 1000; i++ { 109 inject(i) 110 notify(i, i, false) 111 } 112 // Do a reorg 113 notify(500, 500, true) 114 115 // Create new fork 116 for i := uint64(501); i <= 1000; i++ { 117 inject(i) 118 notify(i, i, false) 119 } 120 for i := uint64(1001); i <= 1500; i++ { 121 inject(i) 122 } 123 // Failed processing scenario where less blocks are available than notified 124 notify(2000, 1500, false) 125 126 // Notify about a reorg (which could have caused the missing blocks if happened during processing) 127 notify(1500, 1500, true) 128 129 // Create new fork 130 for i := uint64(1501); i <= 2000; i++ { 131 inject(i) 132 notify(i, i, false) 133 } 134 } 135 136 // testChainIndexBackend implements ChainIndexerBackend 137 type testChainIndexBackend struct { 138 t *testing.T 139 indexer *ChainIndexer 140 section, headerCnt, stored uint64 141 processCh chan uint64 142 } 143 144 // assertSections verifies if a chain indexer has the correct number of section. 145 func (b *testChainIndexBackend) assertSections() { 146 // Keep trying for 3 seconds if it does not match 147 var sections uint64 148 for i := 0; i < 300; i++ { 149 sections, _, _ = b.indexer.Sections() 150 if sections == b.stored { 151 return 152 } 153 time.Sleep(10 * time.Millisecond) 154 } 155 b.t.Fatalf("Canonical section count mismatch: have %v, want %v", sections, b.stored) 156 } 157 158 // assertBlocks expects processing calls after new blocks have arrived. If the 159 // failNum < headNum then we are simulating a scenario where a reorg has happened 160 // after the processing has started and the processing of a section fails. 161 func (b *testChainIndexBackend) assertBlocks(headNum, failNum uint64) (uint64, bool) { 162 var sections uint64 163 if headNum >= b.indexer.confirmsReq { 164 sections = (headNum + 1 - b.indexer.confirmsReq) / b.indexer.sectionSize 165 if sections > b.stored { 166 // expect processed blocks 167 for expectd := b.stored * b.indexer.sectionSize; expectd < sections*b.indexer.sectionSize; expectd++ { 168 if expectd > failNum { 169 // rolled back after processing started, no more process calls expected 170 // wait until updating is done to make sure that processing actually fails 171 var updating bool 172 for i := 0; i < 300; i++ { 173 b.indexer.lock.Lock() 174 updating = b.indexer.knownSections > b.indexer.storedSections 175 b.indexer.lock.Unlock() 176 if !updating { 177 break 178 } 179 time.Sleep(10 * time.Millisecond) 180 } 181 if updating { 182 b.t.Fatalf("update did not finish") 183 } 184 sections = expectd / b.indexer.sectionSize 185 break 186 } 187 select { 188 case <-time.After(10 * time.Second): 189 b.t.Fatalf("Expected processed block #%d, got nothing", expectd) 190 case processed := <-b.processCh: 191 if processed != expectd { 192 b.t.Errorf("Expected processed block #%d, got #%d", expectd, processed) 193 } 194 } 195 } 196 b.stored = sections 197 } 198 } 199 if b.stored == 0 { 200 return 0, false 201 } 202 return b.stored*b.indexer.sectionSize - 1, true 203 } 204 205 func (b *testChainIndexBackend) reorg(headNum uint64) uint64 { 206 firstChanged := (headNum + 1) / b.indexer.sectionSize 207 if firstChanged < b.stored { 208 b.stored = firstChanged 209 } 210 return b.stored * b.indexer.sectionSize 211 } 212 213 func (b *testChainIndexBackend) Reset(ctx context.Context, section uint64, prevHead common.Hash) error { 214 b.section = section 215 b.headerCnt = 0 216 return nil 217 } 218 219 func (b *testChainIndexBackend) Process(ctx context.Context, header *types.Header) error { 220 b.headerCnt++ 221 if b.headerCnt > b.indexer.sectionSize { 222 b.t.Error("Processing too many headers") 223 } 224 //t.processCh <- header.Number.Uint64() 225 select { 226 case <-time.After(10 * time.Second): 227 b.t.Fatal("Unexpected call to Process") 228 case b.processCh <- header.Number.Uint64(): 229 } 230 return nil 231 } 232 233 func (b *testChainIndexBackend) Commit() error { 234 if b.headerCnt != b.indexer.sectionSize { 235 b.t.Error("Not enough headers processed") 236 } 237 return nil 238 } 239 240 func (b *testChainIndexBackend) Prune(threshold uint64) error { 241 return nil 242 }