mirror/bitcoin
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: fix interface_ipc.py template destruction

Browse Source 
Use context managers to destroy block templates. Previously, block templates
were not being destroyed before disconnecting because the destroy coroutines
were called but never awaited. It's not necessary to explicitly destroy the
templates since they will get garbage collected asynchronously, but it's good
to destroy them to make the test more predictable, and to make the destroy
calls that are present actually do something.

This change also removes `await waitnext` expressions without changing
behavior, because the previous code was misleading about what order waitNext
calls were executed.

This change is easiest to review ignoring whitespace.

Co-authored-by: Sjors Provoost <sjors@sprovoost.nl>
This commit is contained in:
Ryan OfskyandSjors Provoost committed 2025-12-03 16:04:10 -05:00
1 parent 9a29b2d331
commit ded11fb04d
1 file changed
+36 -30
Download Patch File Download Diff File Expand all files Collapse all files
test/functional/interface_ipc.py
+36 -30
View File
@@ -4,6 +4,7 @@
# file COPYING or http://www.opensource.org/licenses/mit-license.php. # file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test the IPC (multiprocess) interface.""" """Test the IPC (multiprocess) interface."""
import asyncio import asyncio
from contextlib import asynccontextmanager, AsyncExitStack
from io import BytesIO from io import BytesIO
from pathlib import Path from pathlib import Path
import shutil import shutil
@@ -21,6 +22,21 @@ try:
except ImportError: except ImportError:
pass pass
@asynccontextmanager
async def destroying(obj, ctx):
"""Call obj.destroy(ctx) at end of with: block. Similar to contextlib.closing."""
try:
yield obj
finally:
await obj.destroy(ctx)
async def create_block_template(mining, stack, ctx, opts):
"""Call mining.createNewBlock() and return template, then call template.destroy() when stack exits."""
return await stack.enter_async_context(destroying((await mining.createNewBlock(opts)).result, ctx))
async def wait_next_template(template, stack, ctx, opts):
"""Call template.waitNext() and return template, then call template.destroy() when stack exits."""
return await stack.enter_async_context(destroying((await template.waitNext(ctx, opts)).result, ctx))
class IPCInterfaceTest(BitcoinTestFramework): class IPCInterfaceTest(BitcoinTestFramework):
@@ -77,13 +93,13 @@ class IPCInterfaceTest(BitcoinTestFramework):
return ctx, init return ctx, init
async def parse_and_deserialize_block(self, block_template, ctx): async def parse_and_deserialize_block(self, block_template, ctx):
block_data = BytesIO((await block_template.result.getBlock(ctx)).result) block_data = BytesIO((await block_template.getBlock(ctx)).result)
block = CBlock() block = CBlock()
block.deserialize(block_data) block.deserialize(block_data)
return block return block
async def parse_and_deserialize_coinbase_tx(self, block_template, ctx): async def parse_and_deserialize_coinbase_tx(self, block_template, ctx):
coinbase_data = BytesIO((await block_template.result.getCoinbaseTx(ctx)).result) coinbase_data = BytesIO((await block_template.getCoinbaseTx(ctx)).result)
tx = CTransaction() tx = CTransaction()
tx.deserialize(coinbase_data) tx.deserialize(coinbase_data)
return tx return tx
@@ -134,23 +150,24 @@ class IPCInterfaceTest(BitcoinTestFramework):
assert_equal(oldblockref.result.hash, newblockref.result.hash) assert_equal(oldblockref.result.hash, newblockref.result.hash)
assert_equal(oldblockref.result.height, newblockref.result.height) assert_equal(oldblockref.result.height, newblockref.result.height)
async with AsyncExitStack() as stack:
self.log.debug("Create a template") self.log.debug("Create a template")
opts = self.capnp_modules['mining'].BlockCreateOptions() opts = self.capnp_modules['mining'].BlockCreateOptions()
opts.useMempool = True opts.useMempool = True
opts.blockReservedWeight = 4000 opts.blockReservedWeight = 4000
opts.coinbaseOutputMaxAdditionalSigops = 0 opts.coinbaseOutputMaxAdditionalSigops = 0
template = mining.result.createNewBlock(opts) template = await create_block_template(mining.result, stack, ctx, opts)
self.log.debug("Test some inspectors of Template") self.log.debug("Test some inspectors of Template")
header = await template.result.getBlockHeader(ctx) header = await template.getBlockHeader(ctx)
assert_equal(len(header.result), block_header_size) assert_equal(len(header.result), block_header_size)
block = await self.parse_and_deserialize_block(template, ctx) block = await self.parse_and_deserialize_block(template, ctx)
assert_equal(ser_uint256(block.hashPrevBlock), newblockref.result.hash) assert_equal(ser_uint256(block.hashPrevBlock), newblockref.result.hash)
assert len(block.vtx) >= 1 assert len(block.vtx) >= 1
txfees = await template.result.getTxFees(ctx) txfees = await template.getTxFees(ctx)
assert_equal(len(txfees.result), 0) assert_equal(len(txfees.result), 0)
txsigops = await template.result.getTxSigops(ctx) txsigops = await template.getTxSigops(ctx)
assert_equal(len(txsigops.result), 0) assert_equal(len(txsigops.result), 0)
coinbase_data = BytesIO((await template.result.getCoinbaseTx(ctx)).result) coinbase_data = BytesIO((await template.getCoinbaseTx(ctx)).result)
coinbase = CTransaction() coinbase = CTransaction()
coinbase.deserialize(coinbase_data) coinbase.deserialize(coinbase_data)
assert_equal(coinbase.vin[0].prevout.hash, 0) assert_equal(coinbase.vin[0].prevout.hash, 0)
@@ -158,34 +175,31 @@ class IPCInterfaceTest(BitcoinTestFramework):
waitoptions = self.capnp_modules['mining'].BlockWaitOptions() waitoptions = self.capnp_modules['mining'].BlockWaitOptions()
waitoptions.timeout = timeout waitoptions.timeout = timeout
waitoptions.feeThreshold = 1 waitoptions.feeThreshold = 1
waitnext = template.result.waitNext(ctx, waitoptions)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
template2 = await waitnext template2 = await wait_next_template(template, stack, ctx, waitoptions)
block2 = await self.parse_and_deserialize_block(template2, ctx) block2 = await self.parse_and_deserialize_block(template2, ctx)
assert_equal(len(block2.vtx), 1) assert_equal(len(block2.vtx), 1)
self.log.debug("Wait for another, but time out") self.log.debug("Wait for another, but time out")
template3 = await template2.result.waitNext(ctx, waitoptions) template3 = await template2.waitNext(ctx, waitoptions)
assert_equal(template3.to_dict(), {}) assert_equal(template3.to_dict(), {})
self.log.debug("Wait for another, get one after increase in fees in the mempool") self.log.debug("Wait for another, get one after increase in fees in the mempool")
waitnext = template2.result.waitNext(ctx, waitoptions)
miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]) miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
template4 = await waitnext template4 = await wait_next_template(template2, stack, ctx, waitoptions)
block3 = await self.parse_and_deserialize_block(template4, ctx) block3 = await self.parse_and_deserialize_block(template4, ctx)
assert_equal(len(block3.vtx), 2) assert_equal(len(block3.vtx), 2)
self.log.debug("Wait again, this should return the same template, since the fee threshold is zero") self.log.debug("Wait again, this should return the same template, since the fee threshold is zero")
waitoptions.feeThreshold = 0 waitoptions.feeThreshold = 0
template5 = await template4.result.waitNext(ctx, waitoptions) template5 = await wait_next_template(template4, stack, ctx, waitoptions)
block4 = await self.parse_and_deserialize_block(template5, ctx) block4 = await self.parse_and_deserialize_block(template5, ctx)
assert_equal(len(block4.vtx), 2) assert_equal(len(block4.vtx), 2)
waitoptions.feeThreshold = 1 waitoptions.feeThreshold = 1
self.log.debug("Wait for another, get one after increase in fees in the mempool") self.log.debug("Wait for another, get one after increase in fees in the mempool")
waitnext = template5.result.waitNext(ctx, waitoptions)
miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]) miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
template6 = await waitnext template6 = await wait_next_template(template5, stack, ctx, waitoptions)
block4 = await self.parse_and_deserialize_block(template6, ctx) block4 = await self.parse_and_deserialize_block(template6, ctx)
assert_equal(len(block4.vtx), 3) assert_equal(len(block4.vtx), 3)
self.log.debug("Wait for another, but time out, since the fee threshold is set now") self.log.debug("Wait for another, but time out, since the fee threshold is set now")
template7 = await template6.result.waitNext(ctx, waitoptions) template7 = await template6.waitNext(ctx, waitoptions)
assert_equal(template7.to_dict(), {}) assert_equal(template7.to_dict(), {})
self.log.debug("interruptWait should abort the current wait") self.log.debug("interruptWait should abort the current wait")
@@ -195,12 +209,12 @@ class IPCInterfaceTest(BitcoinTestFramework):
new_waitoptions.timeout = waitoptions.timeout * 60 # 1 minute wait new_waitoptions.timeout = waitoptions.timeout * 60 # 1 minute wait
new_waitoptions.feeThreshold = 1 new_waitoptions.feeThreshold = 1
wait_started.set() wait_started.set()
return await template6.result.waitNext(ctx, new_waitoptions) return await template6.waitNext(ctx, new_waitoptions)
async def interrupt_wait(): async def interrupt_wait():
await wait_started.wait() # Wait for confirmation wait started await wait_started.wait() # Wait for confirmation wait started
await asyncio.sleep(0.1) # Minimal buffer await asyncio.sleep(0.1) # Minimal buffer
template6.result.interruptWait() template6.interruptWait()
miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0]) miniwallet.send_self_transfer(fee_rate=10, from_node=self.nodes[0])
wait_task = asyncio.create_task(wait_for_block()) wait_task = asyncio.create_task(wait_for_block())
@@ -212,7 +226,7 @@ class IPCInterfaceTest(BitcoinTestFramework):
current_block_height = self.nodes[0].getchaintips()[0]["height"] current_block_height = self.nodes[0].getchaintips()[0]["height"]
check_opts = self.capnp_modules['mining'].BlockCheckOptions() check_opts = self.capnp_modules['mining'].BlockCheckOptions()
template = await mining.result.createNewBlock(opts) async with destroying((await mining.result.createNewBlock(opts)).result, ctx) as template:
block = await self.parse_and_deserialize_block(template, ctx) block = await self.parse_and_deserialize_block(template, ctx)
coinbase = await self.parse_and_deserialize_coinbase_tx(template, ctx) coinbase = await self.parse_and_deserialize_coinbase_tx(template, ctx)
balance = miniwallet.get_balance() balance = miniwallet.get_balance()
@@ -227,7 +241,7 @@ class IPCInterfaceTest(BitcoinTestFramework):
res = await mining.result.checkBlock(block.serialize(), check_opts) res = await mining.result.checkBlock(block.serialize(), check_opts)
assert_equal(res.result, False) assert_equal(res.result, False)
assert_equal(res.reason, "bad-version(0x00000000)") assert_equal(res.reason, "bad-version(0x00000000)")
res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize()) res = await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
assert_equal(res.result, False) assert_equal(res.result, False)
self.log.debug("Submit a valid block") self.log.debug("Submit a valid block")
block.nVersion = original_version block.nVersion = original_version
@@ -242,7 +256,7 @@ class IPCInterfaceTest(BitcoinTestFramework):
self.log.debug("Submitted coinbase must include witness") self.log.debug("Submitted coinbase must include witness")
assert_not_equal(coinbase.serialize_without_witness().hex(), coinbase.serialize().hex()) assert_not_equal(coinbase.serialize_without_witness().hex(), coinbase.serialize().hex())
res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize_without_witness()) res = await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize_without_witness())
assert_equal(res.result, False) assert_equal(res.result, False)
self.log.debug("Even a rejected submitBlock() mutates the template's block") self.log.debug("Even a rejected submitBlock() mutates the template's block")
@@ -252,7 +266,7 @@ class IPCInterfaceTest(BitcoinTestFramework):
assert_not_equal(remote_block_before.serialize().hex(), remote_block_after.serialize().hex()) assert_not_equal(remote_block_before.serialize().hex(), remote_block_after.serialize().hex())
self.log.debug("Submit again, with the witness") self.log.debug("Submit again, with the witness")
res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize()) res = await template.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
assert_equal(res.result, True) assert_equal(res.result, True)
self.log.debug("Block should propagate") self.log.debug("Block should propagate")
@@ -270,14 +284,6 @@ class IPCInterfaceTest(BitcoinTestFramework):
assert_equal(res.result, False) assert_equal(res.result, False)
assert_equal(res.reason, "inconclusive-not-best-prevblk") assert_equal(res.reason, "inconclusive-not-best-prevblk")
self.log.debug("Destroy template objects")
template.result.destroy(ctx)
template2.result.destroy(ctx)
template3.result.destroy(ctx)
template4.result.destroy(ctx)
template5.result.destroy(ctx)
template6.result.destroy(ctx)
template7.result.destroy(ctx)
asyncio.run(capnp.run(async_routine())) asyncio.run(capnp.run(async_routine()))
def run_test(self): def run_test(self):