LBRYCommunity/lbrycrd
1
0
Fork 0
Code Issues 29 Pull requests 1 Projects Releases 32 Packages Wiki Activity

[tests] style fixes in feature_pruning.py

Browse source 
Minor style fixups. No functional change.
This commit is contained in:
John Newbery 2019-03-29 10:07:56 -04:00
parent 3702e1c17b
commit 1c29ac40fb
1 changed files with 34 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

81
test/functional/feature_pruning.py
View file

@ -23,7 +23,7 @@ TIMESTAMP_WINDOW = 2 * 60 * 60
def calc_usage(blockdir): def calc_usage(blockdir):
return sum(os.path.getsize(blockdir+f) for f in os.listdir(blockdir) if os.path.isfile(os.path.join(blockdir, f))) / (1024. * 1024.) return sum(os.path.getsize(blockdir + f) for f in os.listdir(blockdir) if os.path.isfile(os.path.join(blockdir, f))) / (1024. * 1024.)
class PruneTest(BitcoinTestFramework): class PruneTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
@ -55,7 +55,7 @@ class PruneTest(BitcoinTestFramework):
connect_nodes(self.nodes[0], 1) connect_nodes(self.nodes[0], 1)
connect_nodes(self.nodes[1], 2) connect_nodes(self.nodes[1], 2)
connect_nodes(self.nodes[2], 0) connect_nodes(self.nodes[0], 2)
connect_nodes(self.nodes[0], 3) connect_nodes(self.nodes[0], 3)
connect_nodes(self.nodes[0], 4) connect_nodes(self.nodes[0], 4)
sync_blocks(self.nodes[0:5]) sync_blocks(self.nodes[0:5])
@ -71,6 +71,7 @@ class PruneTest(BitcoinTestFramework):
self.nodes[1].generate(200) self.nodes[1].generate(200)
sync_blocks(self.nodes[0:2]) sync_blocks(self.nodes[0:2])
self.nodes[0].generate(150) self.nodes[0].generate(150)
# Then mine enough full blocks to create more than 550MiB of data # Then mine enough full blocks to create more than 550MiB of data
for i in range(645): for i in range(645):
mine_large_block(self.nodes[0], self.utxo_cache_0) mine_large_block(self.nodes[0], self.utxo_cache_0)
@ -78,8 +79,7 @@ class PruneTest(BitcoinTestFramework):
sync_blocks(self.nodes[0:5]) sync_blocks(self.nodes[0:5])
def test_height_min(self): def test_height_min(self):
if not os.path.isfile(os.path.join(self.prunedir, "blk00000.dat")): assert os.path.isfile(os.path.join(self.prunedir, "blk00000.dat")), "blk00000.dat is missing, pruning too early"
raise AssertionError("blk00000.dat is missing, pruning too early")
self.log.info("Success") self.log.info("Success")
self.log.info("Though we're already using more than 550MiB, current usage: %d" % calc_usage(self.prunedir)) self.log.info("Though we're already using more than 550MiB, current usage: %d" % calc_usage(self.prunedir))
self.log.info("Mining 25 more blocks should cause the first block file to be pruned") self.log.info("Mining 25 more blocks should cause the first block file to be pruned")
@ -93,8 +93,7 @@ class PruneTest(BitcoinTestFramework):
self.log.info("Success") self.log.info("Success")
usage = calc_usage(self.prunedir) usage = calc_usage(self.prunedir)
self.log.info("Usage should be below target: %d" % usage) self.log.info("Usage should be below target: %d" % usage)
if (usage > 550): assert_greater_than(550, usage)
raise AssertionError("Pruning target not being met")
def create_chain_with_staleblocks(self): def create_chain_with_staleblocks(self):
# Create stale blocks in manageable sized chunks # Create stale blocks in manageable sized chunks
@ -121,8 +120,8 @@ class PruneTest(BitcoinTestFramework):
mine_large_block(self.nodes[0], self.utxo_cache_0) mine_large_block(self.nodes[0], self.utxo_cache_0)
# Create connections in the order so both nodes can see the reorg at the same time # Create connections in the order so both nodes can see the reorg at the same time
connect_nodes(self.nodes[1], 0) connect_nodes(self.nodes[0], 1)
connect_nodes(self.nodes[2], 0) connect_nodes(self.nodes[0], 2)
sync_blocks(self.nodes[0:3]) sync_blocks(self.nodes[0:3])
self.log.info("Usage can be over target because of high stale rate: %d" % calc_usage(self.prunedir)) self.log.info("Usage can be over target because of high stale rate: %d" % calc_usage(self.prunedir))
@ -138,20 +137,20 @@ class PruneTest(BitcoinTestFramework):
height = self.nodes[1].getblockcount() height = self.nodes[1].getblockcount()
self.log.info("Current block height: %d" % height) self.log.info("Current block height: %d" % height)
invalidheight = height-287 self.forkheight = height - 287
badhash = self.nodes[1].getblockhash(invalidheight) self.forkhash = self.nodes[1].getblockhash(self.forkheight)
self.log.info("Invalidating block %s at height %d" % (badhash,invalidheight)) self.log.info("Invalidating block %s at height %d" % (self.forkhash, self.forkheight))
self.nodes[1].invalidateblock(badhash) self.nodes[1].invalidateblock(self.forkhash)
# We've now switched to our previously mined-24 block fork on node 1, but that's not what we want # We've now switched to our previously mined-24 block fork on node 1, but that's not what we want
# So invalidate that fork as well, until we're on the same chain as node 0/2 (but at an ancestor 288 blocks ago) # So invalidate that fork as well, until we're on the same chain as node 0/2 (but at an ancestor 288 blocks ago)
mainchainhash = self.nodes[0].getblockhash(invalidheight - 1) mainchainhash = self.nodes[0].getblockhash(self.forkheight - 1)
curhash = self.nodes[1].getblockhash(invalidheight - 1) curhash = self.nodes[1].getblockhash(self.forkheight - 1)
while curhash != mainchainhash: while curhash != mainchainhash:
self.nodes[1].invalidateblock(curhash) self.nodes[1].invalidateblock(curhash)
curhash = self.nodes[1].getblockhash(invalidheight - 1) curhash = self.nodes[1].getblockhash(self.forkheight - 1)
assert self.nodes[1].getblockcount() == invalidheight - 1 assert self.nodes[1].getblockcount() == self.forkheight - 1
self.log.info("New best height: %d" % self.nodes[1].getblockcount()) self.log.info("New best height: %d" % self.nodes[1].getblockcount())
# Reboot node1 to clear those giant tx's from mempool # Reboot node1 to clear those giant tx's from mempool
@ -163,13 +162,12 @@ class PruneTest(BitcoinTestFramework):
self.log.info("Reconnect nodes") self.log.info("Reconnect nodes")
connect_nodes(self.nodes[0], 1) connect_nodes(self.nodes[0], 1)
connect_nodes(self.nodes[2], 1) connect_nodes(self.nodes[1], 2)
sync_blocks(self.nodes[0:3], timeout=120) sync_blocks(self.nodes[0:3], timeout=120)
self.log.info("Verify height on node 2: %d" % self.nodes[2].getblockcount()) self.log.info("Verify height on node 2: %d" % self.nodes[2].getblockcount())
self.log.info("Usage possibly still high bc of stale blocks in block files: %d" % calc_usage(self.prunedir)) self.log.info("Usage possibly still high because of stale blocks in block files: %d" % calc_usage(self.prunedir))
self.log.info("Mine 220 more large blocks so we have requisite history")
self.log.info("Mine 220 more blocks so we have requisite history (some blocks will be big and cause pruning of previous chain)")
# Get node0's wallet transactions back in its mempool, to avoid the # Get node0's wallet transactions back in its mempool, to avoid the
# mined blocks from being too small. # mined blocks from being too small.
@ -183,10 +181,7 @@ class PruneTest(BitcoinTestFramework):
usage = calc_usage(self.prunedir) usage = calc_usage(self.prunedir)
self.log.info("Usage should be below target: %d" % usage) self.log.info("Usage should be below target: %d" % usage)
if (usage > 550): assert_greater_than(550, usage)
raise AssertionError("Pruning target not being met")
return invalidheight,badhash
def reorg_back(self): def reorg_back(self):
# Verify that a block on the old main chain fork has been pruned away # Verify that a block on the old main chain fork has been pruned away
@ -219,17 +214,17 @@ class PruneTest(BitcoinTestFramework):
blocks_to_mine = first_reorg_height + 1 - self.mainchainheight blocks_to_mine = first_reorg_height + 1 - self.mainchainheight
self.log.info("Rewind node 0 to prev main chain to mine longer chain to trigger redownload. Blocks needed: %d" % blocks_to_mine) self.log.info("Rewind node 0 to prev main chain to mine longer chain to trigger redownload. Blocks needed: %d" % blocks_to_mine)
self.nodes[0].invalidateblock(curchainhash) self.nodes[0].invalidateblock(curchainhash)
assert self.nodes[0].getblockcount() == self.mainchainheight assert_equal(self.nodes[0].getblockcount(), self.mainchainheight)
assert self.nodes[0].getbestblockhash() == self.mainchainhash2 assert_equal(self.nodes[0].getbestblockhash(), self.mainchainhash2)
goalbesthash = self.nodes[0].generate(blocks_to_mine)[-1] goalbesthash = self.nodes[0].generate(blocks_to_mine)[-1]
goalbestheight = first_reorg_height + 1 goalbestheight = first_reorg_height + 1
self.log.info("Verify node 2 reorged back to the main chain, some blocks of which it had to redownload") self.log.info("Verify node 2 reorged back to the main chain, some blocks of which it had to redownload")
# Wait for Node 2 to reorg to proper height # Wait for Node 2 to reorg to proper height
wait_until(lambda: self.nodes[2].getblockcount() >= goalbestheight, timeout=900) wait_until(lambda: self.nodes[2].getblockcount() >= goalbestheight, timeout=900)
assert self.nodes[2].getbestblockhash() == goalbesthash assert_equal(self.nodes[2].getbestblockhash(), goalbesthash)
# Verify we can now have the data for a block previously pruned # Verify we can now have the data for a block previously pruned
assert self.nodes[2].getblock(self.forkhash)["height"] == self.forkheight assert_equal(self.nodes[2].getblock(self.forkhash)["height"], self.forkheight)
def manual_test(self, node_number, use_timestamp): def manual_test(self, node_number, use_timestamp):
# at this point, node has 995 blocks and has not yet run in prune mode # at this point, node has 995 blocks and has not yet run in prune mode
@ -287,38 +282,30 @@ class PruneTest(BitcoinTestFramework):
# height=100 too low to prune first block file so this is a no-op # height=100 too low to prune first block file so this is a no-op
prune(100) prune(100)
if not has_block(0): assert has_block(0), "blk00000.dat is missing when should still be there"
raise AssertionError("blk00000.dat is missing when should still be there")
# Does nothing # Does nothing
node.pruneblockchain(height(0)) node.pruneblockchain(height(0))
if not has_block(0): assert has_block(0), "blk00000.dat is missing when should still be there"
raise AssertionError("blk00000.dat is missing when should still be there")
# height=500 should prune first file # height=500 should prune first file
prune(500) prune(500)
if has_block(0): assert not has_block(0), "blk00000.dat is still there, should be pruned by now"
raise AssertionError("blk00000.dat is still there, should be pruned by now") assert has_block(1), "blk00001.dat is missing when should still be there"
if not has_block(1):
raise AssertionError("blk00001.dat is missing when should still be there")
# height=650 should prune second file # height=650 should prune second file
prune(650) prune(650)
if has_block(1): assert not has_block(1), "blk00001.dat is still there, should be pruned by now"
raise AssertionError("blk00001.dat is still there, should be pruned by now")
# height=1000 should not prune anything more, because tip-288 is in blk00002.dat. # height=1000 should not prune anything more, because tip-288 is in blk00002.dat.
prune(1000, 1001 - MIN_BLOCKS_TO_KEEP) prune(1000, 1001 - MIN_BLOCKS_TO_KEEP)
if not has_block(2): assert has_block(2), "blk00002.dat is still there, should be pruned by now"
raise AssertionError("blk00002.dat is still there, should be pruned by now")
# advance the tip so blk00002.dat and blk00003.dat can be pruned (the last 288 blocks should now be in blk00004.dat) # advance the tip so blk00002.dat and blk00003.dat can be pruned (the last 288 blocks should now be in blk00004.dat)
node.generate(288) node.generate(288)
prune(1000) prune(1000)
if has_block(2): assert not has_block(2), "blk00002.dat is still there, should be pruned by now"
raise AssertionError("blk00002.dat is still there, should be pruned by now") assert not has_block(3), "blk00003.dat is still there, should be pruned by now"
if has_block(3):
raise AssertionError("blk00003.dat is still there, should be pruned by now")
# stop node, start back up with auto-prune at 550 MiB, make sure still runs # stop node, start back up with auto-prune at 550 MiB, make sure still runs
self.stop_node(node_number) self.stop_node(node_number)
@ -339,7 +326,7 @@ class PruneTest(BitcoinTestFramework):
connect_nodes(self.nodes[0], 5) connect_nodes(self.nodes[0], 5)
nds = [self.nodes[0], self.nodes[5]] nds = [self.nodes[0], self.nodes[5]]
sync_blocks(nds, wait=5, timeout=300) sync_blocks(nds, wait=5, timeout=300)
self.stop_node(5) #stop and start to trigger rescan self.stop_node(5) # stop and start to trigger rescan
self.start_node(5, extra_args=["-prune=550"]) self.start_node(5, extra_args=["-prune=550"])
self.log.info("Success") self.log.info("Success")
@ -394,11 +381,11 @@ class PruneTest(BitcoinTestFramework):
# +...+(1044) &.. $...$(1319) # +...+(1044) &.. $...$(1319)
# Save some current chain state for later use # Save some current chain state for later use
self.mainchainheight = self.nodes[2].getblockcount() #1320 self.mainchainheight = self.nodes[2].getblockcount() # 1320
self.mainchainhash2 = self.nodes[2].getblockhash(self.mainchainheight) self.mainchainhash2 = self.nodes[2].getblockhash(self.mainchainheight)
self.log.info("Check that we can survive a 288 block reorg still") self.log.info("Check that we can survive a 288 block reorg still")
(self.forkheight,self.forkhash) = self.reorg_test() #(1033, ) self.reorg_test() # (1033, )
# Now create a 288 block reorg by mining a longer chain on N1 # Now create a 288 block reorg by mining a longer chain on N1
# First disconnect N1 # First disconnect N1
# Then invalidate 1033 on main chain and 1032 on fork so height is 1032 on main chain # Then invalidate 1033 on main chain and 1032 on fork so height is 1032 on main chain