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  }