def _subscribe(self, subscriptions=None, last_known_block_ids=None):
if subscriptions is None:
subscriptions = [
events_pb2.EventSubscription(
event_type="sawtooth/block-commit"),
# Subscribe to the settings state events, to test genesis
# catch-up.
events_pb2.EventSubscription(
event_type="sawtooth/state-delta",
filters=[events_pb2.EventFilter(
key='address',
match_string='000000.*',
filter_type=events_pb2.EventFilter.REGEX_ANY)]),
# Subscribe to the intkey state events, to test additional
# events.
events_pb2.EventSubscription(
event_type="sawtooth/state-delta",
filters=[events_pb2.EventFilter(
key='address',
match_string='{}.*'.format(INTKEY_ADDRESS_PREFIX),
filter_type=events_pb2.EventFilter.REGEX_ANY)]),
]
if last_known_block_ids is None:
last_known_block_ids = []
request = client_event_pb2.ClientEventsSubscribeRequest(
subscriptions=subscriptions,
last_known_block_ids=last_known_block_ids)
response = self.stream.send(
validator_pb2.Message.CLIENT_EVENTS_SUBSCRIBE_REQUEST,
request.SerializeToString()).result()
return response
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 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 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 _subscribe(self, subscriptions=None):
if subscriptions is None:
subscriptions = [
events_pb2.EventSubscription(event_type="block_commit"),
]
request = events_pb2.ClientEventsSubscribeRequest(
subscriptions=subscriptions)
response = self.stream.send(
validator_pb2.Message.CLIENT_EVENTS_SUBSCRIBE_REQUEST,
request.SerializeToString()).result()
return response
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 subscribe_to_events(delta_filters=None):
'''Listen to attestation state-delta events.'''
# Subscribe to events
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=[trust_path_subscription, trust_entry_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
def _subscribe(self, subscriptions=None, last_known_block_ids=None):
if subscriptions is None:
subscriptions = [
events_pb2.EventSubscription(
event_type="sawtooth/block-commit"),
]
if last_known_block_ids is None:
last_known_block_ids = []
request = client_event_pb2.ClientEventsSubscribeRequest(
subscriptions=subscriptions,
last_known_block_ids=last_known_block_ids)
response = self.stream.send(
validator_pb2.Message.CLIENT_EVENTS_SUBSCRIBE_REQUEST,
request.SerializeToString()).result()
return response
def generateSubscritionRequest(self, eventTypes, deltaFilters):
susbscriptions = []
if (len(eventTypes) == len(deltaFilters)):
print("same length")
for i in range(0, len(events)):
subscription = events_pb2.EventSubscription(
event_type=event[i], filters=deltaFilters[i])
susbscriptions.append(subscription)
print(susbscriptions)
subscritionRequest = client_event_pb2.ClientEventsSubscribeRequest(
subscriptions=susbscriptions)
return subscritionRequest
else:
print("Error : EventType and delta filter length mismatch ! ",
flush=True)
def _make_subscriptions(address_prefixes=None):
return [
events_pb2.EventSubscription(event_type="sawtooth/state-delta"),
events_pb2.EventSubscription(event_type="sawtooth/block-commit"),
]
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
