def on_block(self, callback):
def new_block_callback(block_hash):
self._last_block_time = datetime.datetime.now()
block = self.web3.eth.getBlock(block_hash)
block_number = block['number']
if not self.web3.eth.syncing:
max_block_number = self.web3.eth.blockNumber
if block_number == max_block_number:
def on_start():
self.logger.debug(f"Processing block #{block_number} ({block_hash})")
def on_finish():
self.logger.debug(f"Finished processing block #{block_number} ({block_hash})")
if not self._on_block_callback.trigger(on_start, on_finish):
self.logger.info(f"Ignoring block #{block_number} ({block_hash}),"
f" as previous callback is still running")
else:
self.logger.info(f"Ignoring block #{block_number} ({block_hash}),"
f" as there is already block #{max_block_number} available")
else:
self.logger.info(f"Ignoring block #{block_number} ({block_hash}), as the node is syncing")
self._on_block_callback = AsyncCallback(callback)
block_filter = self.web3.eth.filter('latest')
block_filter.watch(new_block_callback)
register_filter_thread(block_filter)
self.logger.info("Watching for new blocks")
def test_should_call_callback(self, callbacks):
# given
async_callback = AsyncCallback(callbacks.short_running_callback)
# when
result = async_callback.trigger()
# then
assert result
assert callbacks.counter == 1
def test_should_wait_for_the_callback_to_finish(self, callbacks):
# given
async_callback = AsyncCallback(callbacks.long_running_callback)
async_callback.trigger()
assert callbacks.counter == 0
# when
async_callback.wait()
# then
assert callbacks.counter == 1
def test_should_not_call_callback_if_previous_one_is_still_running(
self, callbacks):
# given
async_callback = AsyncCallback(callbacks.long_running_callback)
# when
result1 = async_callback.trigger()
result2 = async_callback.trigger()
# and
time.sleep(2)
# then
assert result1
assert not result2
assert callbacks.counter == 1
def test_should_call_callback_again_if_previous_one_is_finished(
self, callbacks):
# given
async_callback = AsyncCallback(callbacks.long_running_callback)
# when
result1 = async_callback.trigger()
time.sleep(2)
# and
result2 = async_callback.trigger()
time.sleep(2)
# then
assert result1
assert result2
assert callbacks.counter == 2
def test_should_call_on_start_and_on_finish_before_and_after_the_callback(
self, callbacks):
# given
mock = Mock()
on_start = mock.on_start
callback = mock.callback
on_finish = mock.on_finish
# when
async_callback = AsyncCallback(callback)
async_callback.trigger(on_start, on_finish)
# then
assert mock.mock_calls == [
call.on_start(),
call.callback(),
call.on_finish()
]