def test_get_events(self): """Tests that block commit events are properly received on block boundaries.""" self._subscribe() self.batch_submitter.submit_next_batch() msg = self.stream.receive().result() self._unsubscribe() event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) events = event_list.events block_commit_event = events[0] block_id = list( filter(lambda attr: attr.key == "block_id", block_commit_event.attributes))[0].value block_num = list( filter(lambda attr: attr.key == "block_num", block_commit_event.attributes))[0].value response = self._get_events( block_id, [events_pb2.EventSubscription(event_type="sawtooth/block-commit")]) events = self.assert_events_get_response(response) self.assert_block_commit_event(events[0], block_num)
def listen_to_events(delta_filters=None): '''Listen to cookiejar state-delta events.''' # Subscribe to events block_commit_subscription = events_pb2.EventSubscription( event_type="sawtooth/block-commit") state_delta_subscription = events_pb2.EventSubscription( event_type="sawtooth/state-delta", filters=delta_filters) fine_subscription = events_pb2.EventSubscription( event_type="AC is in good condition") problem_subscription = events_pb2.EventSubscription( event_type="AC is malfunctioning") fixed_subscription = events_pb2.EventSubscription( event_type="Maintenance fixed the AC") notfixed_subscription = events_pb2.EventSubscription( event_type="Maintenance hasn't fixed the AC yet") request = client_event_pb2.ClientEventsSubscribeRequest( subscriptions=[fine_subscription,problem_subscription,fixed_subscription,notfixed_subscription]) # Send the subscription request stream = Stream(DEFAULT_VALIDATOR_URL) msg = stream.send(message_type=Message.CLIENT_EVENTS_SUBSCRIBE_REQUEST, content=request.SerializeToString()).result() assert msg.message_type == Message.CLIENT_EVENTS_SUBSCRIBE_RESPONSE # Parse the subscription response response = client_event_pb2.ClientEventsSubscribeResponse() response.ParseFromString(msg.content) assert response.status == \ client_event_pb2.ClientEventsSubscribeResponse.OK # Listen for events in an infinite loop print("Listening to events.") msg = stream.receive().result() assert msg.message_type == Message.CLIENT_EVENTS # Parse the response event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) print("Received the following events: ----------") notification=[] for event in event_list.events: notification.append((event.event_type,event.attributes)) #server_socket(notification) # Unsubscribe from events request = client_event_pb2.ClientEventsUnsubscribeRequest() msg = stream.send(Message.CLIENT_EVENTS_UNSUBSCRIBE_REQUEST, request.SerializeToString()).result() assert msg.message_type == Message.CLIENT_EVENTS_UNSUBSCRIBE_RESPONSE # Parse the unsubscribe response response = client_event_pb2.ClientEventsUnsubscribeResponse() response.ParseFromString(msg.content) assert response.status == \ client_event_pb2.ClientEventsUnsubscribeResponse.OK return notification
def start(self, known_ids=None): """Subscribes to state delta events, and then waits to receive deltas. Sends any events received to delta handlers. """ self._stream.wait_for_ready() LOGGER.debug("Subscribing to client state events") request = client_event_pb2.ClientEventsSubscribeRequest( last_known_block_ids=known_ids, subscriptions=[ events_pb2.EventSubscription( event_type="sawtooth/block-commit"), events_pb2.EventSubscription( event_type="sawtooth/state-delta", filters=[ events_pb2.EventFilter( key="address", match_string="^" + addresser.family.namespace + ".*", filter_type=events_pb2.EventFilter.REGEX_ANY, ) ], ), ], ) response_future = self._stream.send( Message.CLIENT_EVENTS_SUBSCRIBE_REQUEST, request.SerializeToString()) response = client_event_pb2.ClientEventsSubscribeResponse() response.ParseFromString(response_future.result().content) # Forked all the way back to genesis, restart with no known_ids if (known_ids and response.status == client_event_pb2.ClientEventsSubscribeResponse.UNKNOWN_BLOCK): return self.start() if response.status != client_event_pb2.ClientEventsSubscribeResponse.OK: raise RuntimeError("Subscription failed with status: {}".format( client_event_pb2.ClientEventsSubscribeResponse.Status.Name( response.status))) self._is_active = True LOGGER.debug("Successfully subscribed to state delta events") while self._is_active: message_future = self._stream.receive() msg = message_future.result() if msg.message_type == Message.CLIENT_EVENTS: event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) events = list(event_list.events) event = StateDeltaEvent(events) delta_count = len(event.state_changes) if delta_count > 0: for handler in self._delta_handlers: handler(event)
def test_catchup(self): """Tests that a subscriber correctly receives catchup events.""" self._subscribe() blocks = [] for i in range(4): self.batch_submitter.submit_next_batch() msg = self.stream.receive().result() event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) events = event_list.events block_commit_event = events[0] block_id = list( filter(lambda attr: attr.key == "block_id", block_commit_event.attributes))[0].value block_num = list( filter(lambda attr: attr.key == "block_num", block_commit_event.attributes))[0].value blocks.append((block_num, block_id)) self._unsubscribe() self.assert_subscribe_response( self._subscribe(last_known_block_ids=[blocks[0][1]])) LOGGER.warning("Waiting for catchup events") for i in range(3): msg = self.stream.receive().result() LOGGER.warning("Got catchup events: ") event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) events = event_list.events self.assertEqual(len(events), 1) block_commit_event = events[0] block_id = list( filter(lambda attr: attr.key == "block_id", block_commit_event.attributes))[0].value block_num = list( filter(lambda attr: attr.key == "block_num", block_commit_event.attributes))[0].value self.assertEqual((block_num, block_id), blocks[i + 1]) self._unsubscribe()
def listen_to_events(delta_filters=None): '''Listen to cookiejar state-delta events.''' # Subscribe to events block_commit_subscription = events_pb2.EventSubscription( event_type="sawtooth/block-commit") state_delta_subscription = events_pb2.EventSubscription( event_type="sawtooth/state-delta", filters=delta_filters) bake_subscription = events_pb2.EventSubscription( event_type="cookiejar/bake") eat_subscription = events_pb2.EventSubscription(event_type="cookiejar/eat") request = client_event_pb2.ClientEventsSubscribeRequest(subscriptions=[ block_commit_subscription, state_delta_subscription, bake_subscription, eat_subscription ]) # Send the subscription request stream = Stream(DEFAULT_VALIDATOR_URL) msg = stream.send(message_type=Message.CLIENT_EVENTS_SUBSCRIBE_REQUEST, content=request.SerializeToString()).result() assert msg.message_type == Message.CLIENT_EVENTS_SUBSCRIBE_RESPONSE # Parse the subscription response response = client_event_pb2.ClientEventsSubscribeResponse() response.ParseFromString(msg.content) assert response.status == \ client_event_pb2.ClientEventsSubscribeResponse.OK # Listen for events in an infinite loop print("Listening to events.") while True: msg = stream.receive().result() assert msg.message_type == Message.CLIENT_EVENTS # Parse the response event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) print("Received the following events: ----------") for event in event_list.events: print(event) # Unsubscribe from events request = client_event_pb2.ClientEventsUnsubscribeRequest() msg = stream.send(Message.CLIENT_EVENTS_UNSUBSCRIBE_REQUEST, request.SerializeToString()).result() assert msg.message_type == Message.CLIENT_EVENTS_UNSUBSCRIBE_RESPONSE # Parse the unsubscribe response response = client_event_pb2.ClientEventsUnsubscribeResponse() response.ParseFromString(msg.content) assert response.status == \ client_event_pb2.ClientEventsUnsubscribeResponse.OK
def listen_to_events(): # Listen for events in an infinite loop stream = Stream(DEFAULT_VALIDATOR_URL) print("Listening to events.") while True: msg = stream.receive().result() assert msg.message_type == Message.CLIENT_EVENTS # Parse the response event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) print("Received the following events: ----------") for event in event_list.events: print(event)
def test_block_commit_event_received(self): """Tests that block commit events are properly received on block boundaries.""" self._subscribe() for i in range(1, 5): self.batch_submitter.submit_next_batch() msg = self.stream.receive().result() self.assertEqual(msg.message_type, validator_pb2.Message.CLIENT_EVENTS) event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) events = event_list.events self.assertEqual(len(events), 1) self.assert_block_commit_event(events[0], i) self._unsubscribe()
async def _listen_for_events(self): LOGGER.debug('Subscribing to state delta events') while self._listening: try: msg = await self._connection.receive() except asyncio.CancelledError: return # Note: if there are other messages that the REST API will listen # for, a way of splitting the incoming messages will be needed. if msg.message_type == Message.CLIENT_EVENTS: event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) events = list(event_list.events) try: state_delta_event = StateDeltaEvent(events) except KeyError as err: LOGGER.warning("Received unexpected event list: %s", err) LOGGER.debug('Received event %s: %s changes', state_delta_event.block_id[:8], len(state_delta_event.state_changes)) base_event = { 'block_id': state_delta_event.block_id, 'block_num': state_delta_event.block_num, 'previous_block_id': state_delta_event.previous_block_id, } if self._latest_state_delta_event is not None and \ state_delta_event.block_num <= \ self._latest_state_delta_event.block_num: base_event['fork_detected'] = True LOGGER.debug('Updating %s subscribers', len(self._subscribers)) for (web_sock, addr_prefixes) in self._subscribers: base_event['state_changes'] = self._client_deltas( state_delta_event.state_changes, addr_prefixes) try: await web_sock.send_str(json.dumps(base_event)) except asyncio.CancelledError: return self._latest_state_delta_event = state_delta_event
def test_subscribe_and_unsubscribe_with_catch_up(self): """Tests that a client can subscribe and unsubscribe from events.""" response = self._subscribe( last_known_block_ids=[NULL_BLOCK_IDENTIFIER]) self.assert_subscribe_response(response) # Ensure that it receives the genesis block msg = self.stream.receive().result() self.assertEqual(msg.message_type, validator_pb2.Message.CLIENT_EVENTS) event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) events = event_list.events self.assertEqual(len(events), 2) self.assert_block_commit_event(events[0], 0) self.assert_state_event(events[1], '000000') response = self._unsubscribe() self.assert_unsubscribe_response(response)
def listenToEvents(self, eventTypes, subsciptionRequest): print("here", eventTypes) message = self.stream.send( message_type=Message.CLIENT_EVENTS_SUBSCRIBE_REQUEST, content=subsciptionRequest.SerializeToString()).result() assert message.message_tyype == Message.CLIENT_EVENTS_SUBSCRIBE_RESPONSE, "Undefined Message Responce Type" response = client_event_pb2.ClientEventsSubscribeResponse() response.ParseFromString(message.content) assert response.status == client_event_pb2.ClientEventsSubscribeResponse.OK, "Status : Message Responce Not Okay " while True: streamMsg = self.stream.receive().result() assert streamMsg.message_type == Message.CLIENT_EVENTS, "Stream Message Type Undefined" # Parse the response eventList = events_pb2.EventList() eventList.ParseFromString(streamMsg.content) for event in eventList: if (event.event_type in eventTypes): print("Event Of Type " + eventType + " Received", flush=True) print("Event : " + event, flush=True)
def listen_to_events(delta_filters=None): BenLogDB.set_table('beneficiary_log', '(id,beneficiary_id,beneficiary_type_id)') '''Listen to vaccination state-delta events.''' # Subscribe to events add_beneficiary_subscription = events_pb2.EventSubscription( event_type="Beneficiary/Add_Beneficiary", filters=delta_filters) block_commit_subscription = events_pb2.EventSubscription( event_type="sawtooth/block-commit", filters=delta_filters) #Create subscription request requestBen = client_event_pb2.ClientEventsSubscribeRequest( subscriptions=[ block_commit_subscription, add_beneficiary_subscription ], last_known_block_ids=['0000000000000000']) # Send the subscription request streamBen = Stream(BEN_VALIDATOR_URL) msgBen = streamBen.send( message_type=Message.CLIENT_EVENTS_SUBSCRIBE_REQUEST, content=requestBen.SerializeToString()).result() assert msgBen.message_type == Message.CLIENT_EVENTS_SUBSCRIBE_RESPONSE # Parse the subscription response responseBen = client_event_pb2.ClientEventsSubscribeResponse() responseBen.ParseFromString(msgBen.content) assert responseBen.status == client_event_pb2.ClientEventsSubscribeResponse.OK # Listen for events in an infinite loop while True: msgBen = streamBen.receive().result() assert msgBen.message_type == Message.CLIENT_EVENTS # Parse the response event_list_ben = events_pb2.EventList() event_list_ben.ParseFromString(msgBen.content) # Log each Beneficiary event into the DB for event in event_list_ben.events: if event.event_type == "Beneficiary/Add_Beneficiary": print("Received the beneficiry event", flush=True) print("Beneficiary ID : ", event.attributes[0].value, flush=True) print("Beneficiary Type : ", event.attributes[1].value, flush=True) BenLogDB.insert_data( uuid.uuid4(), #uuid event.attributes[0].value, #beneficiaryId event.attributes[1].value) #beneficiaryType # Unsubscribe from events request = client_event_pb2.ClientEventsUnsubscribeRequest() msg = stream.send(Message.CLIENT_EVENTS_UNSUBSCRIBE_REQUEST, request.SerializeToString()).result() assert msg.message_type == Message.CLIENT_EVENTS_UNSUBSCRIBE_RESPONSE # Parse the unsubscribe response response = client_event_pb2.ClientEventsUnsubscribeResponse() response.ParseFromString(msg.content) assert response.status == \ client_event_pb2.ClientEventsUnsubscribeResponse.OK
def listen_to_events(delta_filters=None): '''Listen to all state-delta events from the attestation TF.''' trustQueryHits = 0 trustQueryMisses = 0 # Subscribe to events evidence_submission_subscription = events_pb2.EventSubscription( event_type="attestation/evidence_submission", filters=delta_filters) evidence_deletion_subscription = events_pb2.EventSubscription( event_type="attestation/evidence_deletion", filters=delta_filters) trust_path_subscription = events_pb2.EventSubscription( event_type="attestation/trustpath", filters=delta_filters) trust_entry_subscription = events_pb2.EventSubscription( event_type="attestation/entrypoint", filters=delta_filters) request = client_event_pb2.ClientEventsSubscribeRequest( subscriptions=[evidence_submission_subscription, evidence_deletion_subscription, trust_path_subscription, trust_entry_subscription]) ''' block_commit_subscription = events_pb2.EventSubscription( event_type="sawtooth/block-commit") state_delta_subscription = events_pb2.EventSubscription( event_type="sawtooth/state-delta", filters=delta_filters) request = client_event_pb2.ClientEventsSubscribeRequest( subscriptions=[block_commit_subscription, state_delta_subscription]) ''' # Send the subscription request stream = Stream(DEFAULT_VALIDATOR_URL) msg = stream.send(message_type=Message.CLIENT_EVENTS_SUBSCRIBE_REQUEST, content=request.SerializeToString()).result() assert msg.message_type == Message.CLIENT_EVENTS_SUBSCRIBE_RESPONSE # Parse the subscription response response = client_event_pb2.ClientEventsSubscribeResponse() response.ParseFromString(msg.content) assert response.status == \ client_event_pb2.ClientEventsSubscribeResponse.OK # Listen for events in an infinite loop print("Listening to events.") lastevent = None while True: msg = stream.receive().result() assert msg.message_type == Message.CLIENT_EVENTS # Parse the response event_list = events_pb2.EventList() event_list.ParseFromString(msg.content) print("Received the following events: ----------") for event in event_list.events: if event == lastevent: continue else: lastevent = event print(event) if (event.event_type == "attestation/evidence_submission"): vrf = event.attributes[0].value prv = event.attributes[1].value writeEdgeData(vrf, prv) elif (event.event_type == "attestation/evidence_deletion"): vrf = event.attributes[0].value prv = event.attributes[1].value deleteEdgeData(vrf, prv) elif (event.event_type == "attestation/trustpath"): trustQueryHits +=1 elif (event.event_type == "attestation/entrypoint"): trustQueryMisses +=1 # Unsubscribe from events request = client_event_pb2.ClientEventsUnsubscribeRequest() msg = stream.send(Message.CLIENT_EVENTS_UNSUBSCRIBE_REQUEST, request.SerializeToString()).result() assert msg.message_type == Message.CLIENT_EVENTS_UNSUBSCRIBE_RESPONSE # Parse the unsubscribe response response = client_event_pb2.ClientEventsUnsubscribeResponse() response.ParseFromString(msg.content) assert response.status == \ client_event_pb2.ClientEventsUnsubscribeResponse.OK