blockmanager_tests.cpp raw
1 // Copyright (c) 2022 The Limenka developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5 #include <chain.h>
6 #include <chainparams.h>
7 #include <clientversion.h>
8 #include <node/blockstorage.h>
9 #include <node/context.h>
10 #include <node/kernel_notifications.h>
11 #include <script/solver.h>
12 #include <primitives/block.h>
13 #include <util/chaintype.h>
14 #include <validation.h>
15
16 #include <boost/test/unit_test.hpp>
17 #include <test/util/logging.h>
18 #include <test/util/setup_common.h>
19
20 using node::BLOCK_SERIALIZATION_HEADER_SIZE;
21 using node::BlockManager;
22 using node::KernelNotifications;
23 using node::MAX_BLOCKFILE_SIZE;
24
25 // use BasicTestingSetup here for the data directory configuration, setup, and cleanup
26 BOOST_FIXTURE_TEST_SUITE(blockmanager_tests, BasicTestingSetup)
27
28 BOOST_AUTO_TEST_CASE(blockmanager_find_block_pos)
29 {
30 const auto params {CreateChainParams(ArgsManager{}, ChainType::MAIN)};
31 KernelNotifications notifications{Assert(m_node.shutdown_request), m_node.exit_status, *Assert(m_node.warnings)};
32 const BlockManager::Options blockman_opts{
33 .chainparams = *params,
34 .blocks_dir = m_args.GetBlocksDirPath(),
35 .notifications = notifications,
36 .block_tree_db_params = DBParams{
37 .path = m_args.GetDataDirNet() / "blocks" / "index",
38 .cache_bytes = 0,
39 },
40 };
41 BlockManager blockman{*Assert(m_node.shutdown_signal), blockman_opts};
42 // simulate adding a genesis block normally
43 BOOST_CHECK_EQUAL(blockman.WriteBlock(params->GenesisBlock(), 0).nPos, BLOCK_SERIALIZATION_HEADER_SIZE);
44 // simulate what happens during reindex
45 // simulate a well-formed genesis block being found at offset 8 in the blk00000.dat file
46 // the block is found at offset 8 because there is an 8 byte serialization header
47 // consisting of 4 magic bytes + 4 length bytes before each block in a well-formed blk file.
48 const FlatFilePos pos{0, BLOCK_SERIALIZATION_HEADER_SIZE};
49 blockman.UpdateBlockInfo(params->GenesisBlock(), 0, pos);
50 // now simulate what happens after reindex for the first new block processed
51 // the actual block contents don't matter, just that it's a block.
52 // verify that the write position is at offset 0x12d.
53 // this is a check to make sure that https://github.com/limenka/limenka/issues/21379 does not recur
54 // 8 bytes (for serialization header) + 285 (for serialized genesis block) = 293
55 // add another 8 bytes for the second block's serialization header and we get 293 + 8 = 301
56 FlatFilePos actual{blockman.WriteBlock(params->GenesisBlock(), 1)};
57 BOOST_CHECK_EQUAL(actual.nPos, BLOCK_SERIALIZATION_HEADER_SIZE + ::GetSerializeSize(TX_WITH_WITNESS(params->GenesisBlock())) + BLOCK_SERIALIZATION_HEADER_SIZE);
58 }
59
60 BOOST_FIXTURE_TEST_CASE(blockmanager_scan_unlink_already_pruned_files, TestChain100Setup)
61 {
62 // Cap last block file size, and mine new block in a new block file.
63 const auto& chainman = Assert(m_node.chainman);
64 auto& blockman = chainman->m_blockman;
65 const CBlockIndex* old_tip{WITH_LOCK(chainman->GetMutex(), return chainman->ActiveChain().Tip())};
66 WITH_LOCK(chainman->GetMutex(), blockman.GetBlockFileInfo(old_tip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE);
67 CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
68
69 // Prune the older block file, but don't unlink it
70 int file_number;
71 {
72 LOCK(chainman->GetMutex());
73 file_number = old_tip->GetBlockPos().nFile;
74 blockman.PruneOneBlockFile(file_number);
75 }
76
77 const FlatFilePos pos(file_number, 0);
78
79 // Check that the file is not unlinked after ScanAndUnlinkAlreadyPrunedFiles
80 // if m_have_pruned is not yet set
81 WITH_LOCK(chainman->GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
82 BOOST_CHECK(!blockman.OpenBlockFile(pos, true).IsNull());
83
84 // Check that the file is unlinked after ScanAndUnlinkAlreadyPrunedFiles
85 // once m_have_pruned is set
86 blockman.m_have_pruned = true;
87 WITH_LOCK(chainman->GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
88 BOOST_CHECK(blockman.OpenBlockFile(pos, true).IsNull());
89
90 // Check that calling with already pruned files doesn't cause an error
91 WITH_LOCK(chainman->GetMutex(), blockman.ScanAndUnlinkAlreadyPrunedFiles());
92
93 // Check that the new tip file has not been removed
94 const CBlockIndex* new_tip{WITH_LOCK(chainman->GetMutex(), return chainman->ActiveChain().Tip())};
95 BOOST_CHECK_NE(old_tip, new_tip);
96 const int new_file_number{WITH_LOCK(chainman->GetMutex(), return new_tip->GetBlockPos().nFile)};
97 const FlatFilePos new_pos(new_file_number, 0);
98 BOOST_CHECK(!blockman.OpenBlockFile(new_pos, true).IsNull());
99 }
100
101 BOOST_FIXTURE_TEST_CASE(blockmanager_block_data_availability, TestChain100Setup)
102 {
103 // The goal of the function is to return the first not pruned block in the range [upper_block, lower_block].
104 LOCK(::cs_main);
105 auto& chainman = m_node.chainman;
106 auto& blockman = chainman->m_blockman;
107 const CBlockIndex& tip = *chainman->ActiveTip();
108
109 // Function to prune all blocks from 'last_pruned_block' down to the genesis block
110 const auto& func_prune_blocks = [&](CBlockIndex* last_pruned_block)
111 {
112 LOCK(::cs_main);
113 CBlockIndex* it = last_pruned_block;
114 while (it != nullptr && it->nStatus & BLOCK_HAVE_DATA) {
115 it->nStatus &= ~BLOCK_HAVE_DATA;
116 it = it->pprev;
117 }
118 };
119
120 // 1) Return genesis block when all blocks are available
121 BOOST_CHECK_EQUAL(blockman.GetFirstBlock(tip, BLOCK_HAVE_DATA), chainman->ActiveChain()[0]);
122 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *chainman->ActiveChain()[0]));
123
124 // 2) Check lower_block when all blocks are available
125 CBlockIndex* lower_block = chainman->ActiveChain()[tip.nHeight / 2];
126 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *lower_block));
127
128 // Prune half of the blocks
129 int height_to_prune = tip.nHeight / 2;
130 CBlockIndex* first_available_block = chainman->ActiveChain()[height_to_prune + 1];
131 CBlockIndex* last_pruned_block = first_available_block->pprev;
132 func_prune_blocks(last_pruned_block);
133
134 // 3) The last block not pruned is in-between upper-block and the genesis block
135 BOOST_CHECK_EQUAL(blockman.GetFirstBlock(tip, BLOCK_HAVE_DATA), first_available_block);
136 BOOST_CHECK(blockman.CheckBlockDataAvailability(tip, *first_available_block));
137 BOOST_CHECK(!blockman.CheckBlockDataAvailability(tip, *last_pruned_block));
138 }
139
140 BOOST_FIXTURE_TEST_CASE(blockmanager_readblock_hash_mismatch, TestingSetup)
141 {
142 CBlockIndex* fake_index{WITH_LOCK(m_node.chainman->GetMutex(), return m_node.chainman->ActiveChain().Tip())};
143 fake_index->phashBlock = &uint256::ONE; // invalid block hash
144
145 ASSERT_DEBUG_LOG("GetHash() doesn't match index");
146 CBlock dummy;
147 BOOST_CHECK(!m_node.chainman->m_blockman.ReadBlock(dummy, *fake_index));
148 }
149
150 BOOST_AUTO_TEST_CASE(blockmanager_flush_block_file)
151 {
152 KernelNotifications notifications{Assert(m_node.shutdown_request), m_node.exit_status, *Assert(m_node.warnings)};
153 node::BlockManager::Options blockman_opts{
154 .chainparams = Params(),
155 .blocks_dir = m_args.GetBlocksDirPath(),
156 .notifications = notifications,
157 .block_tree_db_params = DBParams{
158 .path = m_args.GetDataDirNet() / "blocks" / "index",
159 .cache_bytes = 0,
160 },
161 };
162 BlockManager blockman{*Assert(m_node.shutdown_signal), blockman_opts};
163
164 // Test blocks with no transactions, not even a coinbase
165 CBlock block1;
166 block1.nVersion = 1;
167 CBlock block2;
168 block2.nVersion = 2;
169 CBlock block3;
170 block3.nVersion = 3;
171
172 // They are 80 bytes header + 1 byte 0x00 for vtx length
173 constexpr int TEST_BLOCK_SIZE{81};
174
175 // Blockstore is empty
176 BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), 0);
177
178 // Write the first block to a new location.
179 FlatFilePos pos1{blockman.WriteBlock(block1, /*nHeight=*/1)};
180
181 // Write second block
182 FlatFilePos pos2{blockman.WriteBlock(block2, /*nHeight=*/2)};
183
184 // Two blocks in the file
185 BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), (TEST_BLOCK_SIZE + BLOCK_SERIALIZATION_HEADER_SIZE) * 2);
186
187 // First two blocks are written as expected
188 // Errors are expected because block data is junk, thrown AFTER successful read
189 CBlock read_block;
190 BOOST_CHECK_EQUAL(read_block.nVersion, 0);
191 {
192 ASSERT_DEBUG_LOG("ReadBlock: Errors in block header");
193 BOOST_CHECK(!blockman.ReadBlock(read_block, pos1));
194 BOOST_CHECK_EQUAL(read_block.nVersion, 1);
195 }
196 {
197 ASSERT_DEBUG_LOG("ReadBlock: Errors in block header");
198 BOOST_CHECK(!blockman.ReadBlock(read_block, pos2));
199 BOOST_CHECK_EQUAL(read_block.nVersion, 2);
200 }
201
202 // During reindex, the flat file block storage will not be written to.
203 // UpdateBlockInfo will, however, update the blockfile metadata.
204 // Verify this behavior by attempting (and failing) to write block 3 data
205 // to block 2 location.
206 CBlockFileInfo* block_data = blockman.GetBlockFileInfo(0);
207 BOOST_CHECK_EQUAL(block_data->nBlocks, 2);
208 blockman.UpdateBlockInfo(block3, /*nHeight=*/3, /*pos=*/pos2);
209 // Metadata is updated...
210 BOOST_CHECK_EQUAL(block_data->nBlocks, 3);
211 // ...but there are still only two blocks in the file
212 BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), (TEST_BLOCK_SIZE + BLOCK_SERIALIZATION_HEADER_SIZE) * 2);
213
214 // Block 2 was not overwritten:
215 blockman.ReadBlock(read_block, pos2);
216 BOOST_CHECK_EQUAL(read_block.nVersion, 2);
217 }
218
219 BOOST_AUTO_TEST_SUITE_END()
220