def commit(self):
"""Store the new height and along with block hash."""
self.abort_if_abci_chain_is_not_synced()
data = self.block_txn_hash.encode('utf-8')
# register a new block only when new transactions are received
if self.block_txn_ids:
self.bigchaindb.store_bulk_transactions(self.block_transactions)
block = Block(app_hash=self.block_txn_hash,
height=self.new_height,
transactions=self.block_txn_ids)
# NOTE: storing the block should be the last operation during commit
# this effects crash recovery. Refer BEP#8 for details
self.bigchaindb.store_block(block._asdict())
logger.debug(
'Commit-ing new block with hash: apphash=%s ,'
'height=%s, txn ids=%s', data, self.new_height, self.block_txn_ids)
if self.events_queue:
event = Event(EventTypes.BLOCK_VALID, {
'height': self.new_height,
'transactions': self.block_transactions
})
self.events_queue.put(event)
return ResponseCommit(data=data)
def test_event_handler():
from bigchaindb.events import EventTypes, Event, Exchange
# create and event
event_data = {'msg': 'some data'}
event = Event(EventTypes.BLOCK_VALID, event_data)
# create the events pub sub
exchange = Exchange()
sub0 = exchange.get_subscriber_queue(EventTypes.BLOCK_VALID)
sub1 = exchange.get_subscriber_queue(EventTypes.BLOCK_VALID
| EventTypes.BLOCK_INVALID)
# Subscribe to all events
sub2 = exchange.get_subscriber_queue()
sub3 = exchange.get_subscriber_queue(EventTypes.BLOCK_INVALID)
# push and event to the queue
exchange.dispatch(event)
# get the event from the queue
event_sub0 = sub0.get()
event_sub1 = sub1.get()
event_sub2 = sub2.get()
assert event_sub0.type == event.type
assert event_sub0.data == event.data
assert event_sub1.type == event.type
assert event_sub1.data == event.data
assert event_sub2.type == event.type
assert event_sub2.data == event.data
assert sub3.qsize() == 0
def handle_block_events(self, result, block_id):
if self.event_handler:
if result['status'] == self.bigchain.BLOCK_UNDECIDED:
return
elif result['status'] == self.bigchain.BLOCK_INVALID:
event_type = EventTypes.BLOCK_INVALID
elif result['status'] == self.bigchain.BLOCK_VALID:
event_type = EventTypes.BLOCK_VALID
event = Event(event_type, self.bigchain.get_block(block_id))
self.event_handler.put_event(event)
def process_event(event_queue, event, stream_id):
event_stream_id = stream_id + '#event'
event = json.loads(event)
if (event['id'] == event_stream_id and event['result']['query'] == 'tm.event=\'NewBlock\''):
block = event['result']['data']['value']['block']
block_id = block['header']['height']
block_txs = block['data']['txs']
# Only push non empty blocks
if block_txs:
block_txs = [decode_transaction_base64(txn) for txn in block_txs]
new_block = {'height': block_id, 'transactions': block_txs}
event = Event(EventTypes.BLOCK_VALID, new_block)
event_queue.put(event)
def test_exchange_stops_with_poison_pill():
from bigchaindb.events import EventTypes, Event, Exchange, POISON_PILL
# create and event
event_data = {'msg': 'some data'}
event = Event(EventTypes.BLOCK_VALID, event_data)
# create the events pub sub
exchange = Exchange()
publisher_queue = exchange.get_publisher_queue()
# push and event to the queue
publisher_queue.put(event)
publisher_queue.put(POISON_PILL)
exchange.run()
assert publisher_queue.qsize() == 0
def tests_event_handler():
from bigchaindb.events import (EventTypes, Event, EventHandler,
setup_events_queue)
# create and event
event_data = {'msg': 'some data'}
event = Event(EventTypes.BLOCK_VALID, event_data)
# create the events queue
events_queue = setup_events_queue()
# create event handler
event_handler = EventHandler(events_queue)
# push and event to the queue
event_handler.put_event(event)
# get the event from the queue
event_from_queue = event_handler.get_event()
assert event_from_queue.type == event.type
assert event_from_queue.data == event.data
