def process_event(self, msg, headers):
"""
Callback method for the subscriber listening for all events
"""
#------------------------------------------------------------------------------------
# From the reverse user info dict find out which users have subscribed to that event
#------------------------------------------------------------------------------------
user_ids = []
if self.reverse_user_info:
user_ids = check_user_notification_interest(
event=msg, reverse_user_info=self.reverse_user_info)
#log.debug("Notification worker found interested users %s" % user_ids)
#------------------------------------------------------------------------------------
# Send email to the users
#------------------------------------------------------------------------------------
for user_id in user_ids:
msg_recipient = self.user_info[user_id]['user_contact'].email
self.smtp_client = setting_up_smtp_client()
send_email(event=msg,
msg_recipient=msg_recipient,
smtp_client=self.smtp_client,
rr_client=self.resource_registry)
self.smtp_client.quit()
def on_start(self):
#---------------------------------------------------------------------------------------------------
# Get the event Repository
#---------------------------------------------------------------------------------------------------
self.event_repo = self.container.instance.event_repository
self.smtp_client = setting_up_smtp_client()
self.ION_NOTIFICATION_EMAIL_ADDRESS = '*****@*****.**'
#---------------------------------------------------------------------------------------------------
# Create an event processor
#---------------------------------------------------------------------------------------------------
self.event_processor = EmailEventProcessor(self.smtp_client)
#---------------------------------------------------------------------------------------------------
# load event originators, types, and table
#---------------------------------------------------------------------------------------------------
self.notifications = {}
#---------------------------------------------------------------------------------------------------
# Get the clients
#---------------------------------------------------------------------------------------------------
self.discovery = DiscoveryServiceClient()
self.process_dispatcher = ProcessDispatcherServiceClient()
self.event_publisher = EventPublisher()
self.start_time = UserNotificationService.makeEpochTime(self.__now())
def process_event(self, msg, headers):
"""
Callback method for the subscriber listening for all events
"""
#------------------------------------------------------------------------------------
# From the reverse user info dict find out which users have subscribed to that event
#------------------------------------------------------------------------------------
user_ids = []
if self.reverse_user_info:
user_ids = check_user_notification_interest(event = msg, reverse_user_info = self.reverse_user_info)
log.debug("Notification worker found interested users %s" % user_ids)
#------------------------------------------------------------------------------------
# Send email to the users
#------------------------------------------------------------------------------------
for user_id in user_ids:
msg_recipient = self.user_info[user_id]['user_contact'].email
self.smtp_client = setting_up_smtp_client()
send_email(event=msg,
msg_recipient=msg_recipient,
smtp_client=self.smtp_client,
rr_client=self.resource_registry)
self.smtp_client.quit()
def on_start(self):
#---------------------------------------------------------------------------------------------------
# Get the event Repository
#---------------------------------------------------------------------------------------------------
self.event_repo = self.container.instance.event_repository
self.smtp_client = setting_up_smtp_client()
self.ION_NOTIFICATION_EMAIL_ADDRESS = '*****@*****.**'
#---------------------------------------------------------------------------------------------------
# Create an event processor
#---------------------------------------------------------------------------------------------------
self.event_processor = EmailEventProcessor(self.smtp_client)
#---------------------------------------------------------------------------------------------------
# load event originators, types, and table
#---------------------------------------------------------------------------------------------------
self.event_types = CFG.event.types
self.event_table = {}
#---------------------------------------------------------------------------------------------------
# Get the clients
#---------------------------------------------------------------------------------------------------
self.discovery = DiscoveryServiceClient()
self.process_dispatcher = ProcessDispatcherServiceClient()
self.datastore_manager = DatastoreManager()
self.event_publisher = EventPublisher()
self.scheduler_service = SchedulerService()
def on_start(self):
super(NotificationWorker, self).on_start()
self.smtp_client = setting_up_smtp_client()
# ------------------------------------------------------------------------------------
# Start by loading the user info and reverse user info dictionaries
# ------------------------------------------------------------------------------------
try:
self.user_info = self.load_user_info()
self.reverse_user_info = calculate_reverse_user_info(self.user_info)
log.info("On start up, notification workers loaded the following user_info dictionary: %s" % self.user_info)
log.info("The calculated reverse user info: %s" % self.reverse_user_info)
except NotFound as exc:
if exc.message.find("users_index") > -1:
log.warning("Notification workers found on start up that users_index have not been loaded yet.")
else:
raise NotFound(exc.message)
# ------------------------------------------------------------------------------------
# Create an event subscriber for Reload User Info events
# ------------------------------------------------------------------------------------
def reload_user_info(event_msg, headers):
"""
Callback method for the subscriber to ReloadUserInfoEvent
"""
notification_id = event_msg.notification_id
log.info(
"(Notification worker received a ReloadNotificationEvent. The relevant notification_id is %s"
% notification_id
)
try:
self.user_info = self.load_user_info()
except NotFound:
log.warning("ElasticSearch has not yet loaded the user_index.")
self.reverse_user_info = calculate_reverse_user_info(self.user_info)
self.test_hook(self.user_info, self.reverse_user_info)
log.debug("After a reload, the user_info: %s" % self.user_info)
log.debug("The recalculated reverse_user_info: %s" % self.reverse_user_info)
# the subscriber for the ReloadUSerInfoEvent
self.reload_user_info_subscriber = EventSubscriber(event_type="ReloadUserInfoEvent", callback=reload_user_info)
self.reload_user_info_subscriber.start()
# ------------------------------------------------------------------------------------
# Create an event subscriber for all events that are of interest for notifications
# ------------------------------------------------------------------------------------
self.event_subscriber = EventSubscriber(queue_name="uns_queue", callback=self.process_event)
self.event_subscriber.start()
def process_batch(self, start_time = '', end_time = ''):
"""
This method is launched when an process_batch event is received. The user info dictionary maintained
by the User Notification Service is used to query the event repository for all events for a particular
user that have occurred in a provided time interval, and then an email is sent to the user containing
the digest of all the events.
@param start_time int milliseconds
@param end_time int milliseconds
"""
self.smtp_client = setting_up_smtp_client()
if end_time <= start_time:
return
for user_id, value in self.user_info.iteritems():
notifications = self.get_user_notifications(user_info_id=user_id)
notifications_disabled = value['notifications_disabled']
notifications_daily_digest = value['notifications_daily_digest']
# Ignore users who do NOT want batch notifications or who have disabled the delivery switch
# However, if notification preferences have not been set for the user, use the default mechanism and do not bother
if notifications_disabled or not notifications_daily_digest:
continue
events_for_message = []
search_time = "SEARCH 'ts_created' VALUES FROM %s TO %s FROM 'events_index'" % (start_time, end_time)
for notification in notifications:
# If the notification request has expired, then do not use it in the search
if notification.temporal_bounds.end_datetime:
continue
event_tuples = self.container.event_repository.find_events(
origin=notification.origin,
event_type=notification.event_type,
start_ts=start_time,
end_ts=end_time)
events = [item[2] for item in event_tuples]
events_for_message.extend(events)
log.debug("Found following events of interest to user, %s: %s", user_id, events_for_message)
# send a notification email to each user using a _send_email() method
if events_for_message:
self.format_and_send_email(events_for_message = events_for_message,
user_id = user_id,
smtp_client=self.smtp_client)
self.smtp_client.quit()
def process_event(self, msg, headers):
"""
Callback method for the subscriber listening for all events
"""
#------------------------------------------------------------------------------------
# From the reverse user info dict find out which users have subscribed to that event
#------------------------------------------------------------------------------------
user_ids = []
if self.reverse_user_info:
log.debug("Notification worker checking for users interested in %s" % msg.type_)
user_ids = check_user_notification_interest(event = msg, reverse_user_info = self.reverse_user_info)
log.debug("Notification worker deduced the following users were interested in the event: %s, event_type: %s, origin: %s" % (user_ids, msg.type_, msg.origin ))
#------------------------------------------------------------------------------------
# Send email to the users
#------------------------------------------------------------------------------------
for user_id in user_ids:
msg_recipient = self.user_info[user_id]['user_contact'].email
self.smtp_client = setting_up_smtp_client()
send_email(message = msg, msg_recipient = msg_recipient, smtp_client = self.smtp_client )
self.smtp_client.quit()
def process_batch(self, start_time = '', end_time = ''):
"""
This method is launched when an process_batch event is received. The user info dictionary maintained
by the User Notification Service is used to query the event repository for all events for a particular
user that have occurred in a provided time interval, and then an email is sent to the user containing
the digest of all the events.
@param start_time int milliseconds
@param end_time int milliseconds
"""
self.smtp_client = setting_up_smtp_client()
if end_time <= start_time:
return
for user_id, value in self.user_info.iteritems():
notifications = value['notifications']
notifications_disabled = value['notifications_disabled']
notifications_daily_digest = value['notifications_daily_digest']
# Ignore users who do NOT want batch notifications or who have disabled the delivery switch
# However, if notification preferences have not been set for the user, use the default mechanism and do not bother
if notifications_disabled or not notifications_daily_digest:
continue
events_for_message = []
search_time = "SEARCH 'ts_created' VALUES FROM %s TO %s FROM 'events_index'" % (start_time, end_time)
for notification in notifications:
# If the notification request has expired, then do not use it in the search
if notification.temporal_bounds.end_datetime:
continue
if notification.origin:
search_origin = 'search "origin" is "%s" from "events_index"' % notification.origin
else:
search_origin = 'search "origin" is "*" from "events_index"'
if notification.origin_type:
search_origin_type= 'search "origin_type" is "%s" from "events_index"' % notification.origin_type
else:
search_origin_type= 'search "origin_type" is "*" from "events_index"'
if notification.event_type:
search_event_type = 'search "type_" is "%s" from "events_index"' % notification.event_type
else:
search_event_type = 'search "type_" is "*" from "events_index"'
search_string = search_time + ' and ' + search_origin + ' and ' + search_origin_type + ' and ' + search_event_type
# get the list of ids corresponding to the events
log.debug('process_batch search_string: %s', search_string)
ret_vals = self.discovery.parse(search_string)
events_for_message.extend(self.datastore.read_mult(ret_vals))
log.debug("Found following events of interest to user, %s: %s", user_id, events_for_message)
# send a notification email to each user using a _send_email() method
if events_for_message:
self.format_and_send_email(events_for_message = events_for_message,
user_id = user_id,
smtp_client=self.smtp_client)
self.smtp_client.quit()
def process_batch(self, start_time='', end_time=''):
"""
This method is launched when an process_batch event is received. The user info dictionary maintained
by the User Notification Service is used to query the event repository for all events for a particular
user that have occurred in a provided time interval, and then an email is sent to the user containing
the digest of all the events.
@param start_time int milliseconds
@param end_time int milliseconds
"""
self.smtp_client = setting_up_smtp_client()
if end_time <= start_time:
return
for user_id, value in self.user_info.iteritems():
notifications = self.get_user_notifications(user_info_id=user_id)
notifications_disabled = value['notifications_disabled']
notifications_daily_digest = value['notifications_daily_digest']
# Ignore users who do NOT want batch notifications or who have disabled the delivery switch
# However, if notification preferences have not been set for the user, use the default mechanism and do not bother
if notifications_disabled or not notifications_daily_digest:
continue
events_for_message = []
search_time = "SEARCH 'ts_created' VALUES FROM %s TO %s FROM 'events_index'" % (
start_time, end_time)
for notification in notifications:
# If the notification request has expired, then do not use it in the search
if notification.temporal_bounds.end_datetime:
continue
if CFG_ELASTIC_SEARCH:
if notification.origin:
search_origin = 'search "origin" is "%s" from "events_index"' % notification.origin
else:
search_origin = 'search "origin" is "*" from "events_index"'
if notification.origin_type:
search_origin_type = 'search "origin_type" is "%s" from "events_index"' % notification.origin_type
else:
search_origin_type = 'search "origin_type" is "*" from "events_index"'
if notification.event_type:
search_event_type = 'search "type_" is "%s" from "events_index"' % notification.event_type
else:
search_event_type = 'search "type_" is "*" from "events_index"'
search_string = search_time + ' and ' + search_origin + ' and ' + search_origin_type + ' and ' + search_event_type
# get the list of ids corresponding to the events
log.debug('process_batch search_string: %s',
search_string)
ret_vals = self.discovery.parse(search_string)
events_for_message.extend(
self.datastore.read_mult(ret_vals))
else:
# Adding a branch
event_tuples = self.container.event_repository.find_events(
origin=notification.origin,
event_type=notification.event_type,
start_ts=start_time,
end_ts=end_time)
events = [item[2] for item in event_tuples]
events_for_message.extend(events)
log.debug("Found following events of interest to user, %s: %s",
user_id, events_for_message)
# send a notification email to each user using a _send_email() method
if events_for_message:
self.format_and_send_email(
events_for_message=events_for_message,
user_id=user_id,
smtp_client=self.smtp_client)
self.smtp_client.quit()