async def _list_events_by_id(self, request):
id = request.id
timeout_seconds = request.timeout_seconds
if 0 == timeout_seconds:
event_models = self._query_all_events_by_id(id)
event_proto_list = event_list_to_proto(event_models)
return notification_service_pb2.ListEventsResponse(
return_code=str(notification_service_pb2.ReturnStatus.SUCCESS),
return_msg='',
events=event_proto_list)
else:
start = time.time()
event_models = self._query_all_events_by_id(id)
async with self.write_condition:
while time.time() - start < timeout_seconds and len(
event_models) == 0:
try:
await asyncio.wait_for(
self.write_condition.wait(),
timeout_seconds - time.time() + start)
event_models = self._query_all_events_by_id(id)
except asyncio.TimeoutError:
pass
event_proto_list = event_list_to_proto(event_models)
return notification_service_pb2.ListEventsResponse(
return_code=str(notification_service_pb2.ReturnStatus.SUCCESS),
return_msg='',
events=event_proto_list)
async def _list_events(self, request):
keys = request.keys
event_type = request.event_type
start_time = request.start_time
start_version = request.start_version
namespace = None if request.namespace == '' else request.namespace
sender = None if request.sender == '' else request.sender
timeout_seconds = request.timeout_seconds
if timeout_seconds == 0:
event_models = self._query_events(keys, event_type, start_time,
start_version, namespace, sender)
event_proto_list = event_list_to_proto(event_models)
return notification_service_pb2.ListEventsResponse(
return_code=notification_service_pb2.ReturnStatus.SUCCESS,
return_msg='',
events=event_proto_list)
else:
start = time.time()
# Lock conditions dict for get/check/update of key
await self.lock.acquire()
for key in keys:
if self.notification_conditions.get(key) is None:
self.notification_conditions.update({
(key, asyncio.Condition())
})
# Release lock after check/update key of notification conditions dict
self.lock.release()
event_models = []
if len(keys) == 1:
key = keys[0]
condition = self.notification_conditions.get(key)
else:
condition = self.write_condition
async with condition:
while time.time() - start < timeout_seconds and len(
event_models) == 0:
try:
await asyncio.wait_for(
condition.wait(),
timeout_seconds - time.time() + start)
event_models = self._query_events(
keys, event_type, start_time, start_version,
namespace, sender)
except asyncio.TimeoutError:
pass
if len(event_models) == 0:
event_models = self._query_events(keys, event_type,
start_time,
start_version, namespace,
sender)
event_proto_list = event_list_to_proto(event_models)
return notification_service_pb2.ListEventsResponse(
return_code=notification_service_pb2.ReturnStatus.SUCCESS,
return_msg='',
events=event_proto_list)
def listEvents(self, request, context):
try:
return self._list_events(request)
except Exception as e:
return notification_service_pb2.ListEventsResponse(
return_code=str(notification_service_pb2.ReturnStatus.ERROR),
return_msg=str(e))
async def _get_latest_version_by_key(self, request):
key = request.key
namespace = request.namespace
timeout_seconds = request.timeout_seconds
if 0 == timeout_seconds:
latest_version = self._query_latest_version_by_key(key, namespace)
return notification_service_pb2.GetLatestVersionResponse(
return_code=str(notification_service_pb2.ReturnStatus.SUCCESS),
return_msg='',
version=latest_version)
else:
start = time.time()
latest_version = self._query_latest_version_by_key(key, namespace)
async with self.write_condition:
while time.time(
) - start < timeout_seconds and latest_version == 0:
try:
await asyncio.wait_for(
self.write_condition.wait(),
timeout_seconds - time.time() + start)
latest_version = self._query_latest_version_by_key(
key, namespace)
except asyncio.TimeoutError:
pass
return notification_service_pb2.ListEventsResponse(
return_code=str(notification_service_pb2.ReturnStatus.SUCCESS),
return_msg='',
version=latest_version)
async def _list_events(self, request):
event_proto = request.event
key = event_proto.key
version = event_proto.version
timeout_seconds = request.timeout_seconds
if timeout_seconds == 0:
event_models = self._query_events(key, version)
event_proto_list = event_list_to_proto(event_models)
return notification_service_pb2.ListEventsResponse(
return_code=str(notification_service_pb2.ReturnStatus.SUCCESS),
return_msg='',
events=event_proto_list)
else:
start = time.time()
# Lock conditions dict for get/check/update of key
await self.lock.acquire()
if self.notification_conditions.get(key) is None:
self.notification_conditions.update({(key, asyncio.Condition())
})
# Release lock after check/update key of notification conditions dict
self.lock.release()
event_models = self._query_events(key, version)
async with self.notification_conditions.get(key):
while time.time() - start < timeout_seconds and len(
event_models) == 0:
try:
await asyncio.wait_for(
self.notification_conditions.get(key).wait(),
timeout_seconds - time.time() + start)
event_models = self._query_events(key, version)
except asyncio.TimeoutError:
pass
event_proto_list = event_list_to_proto(event_models)
return notification_service_pb2.ListEventsResponse(
return_code=str(notification_service_pb2.ReturnStatus.SUCCESS),
return_msg='',
events=event_proto_list)
