def send_pgp_alerts(self, node_desc, receiver_desc, notification_settings):
fakeevent = OD()
fakeevent.type = u'pgp_expiration_alert'
fakeevent.node_info = node_desc
fakeevent.context_info = None
fakeevent.steps_info = None
fakeevent.receiver_info = receiver_desc
fakeevent.tip_info = None
fakeevent.subevent_info = None
body = Templating().format_template(
notification_settings['pgp_alert_mail_template'], fakeevent)
title = Templating().format_template(
notification_settings['pgp_alert_mail_title'], fakeevent)
to_address = receiver_desc['mail_address']
message = MIME_mail_build(GLSetting.memory_copy.notif_source_name,
GLSetting.memory_copy.notif_source_email,
to_address,
to_address,
title,
body)
yield sendmail(authentication_username=GLSetting.memory_copy.notif_username,
authentication_password=GLSetting.memory_copy.notif_password,
from_address=GLSetting.memory_copy.notif_source_email,
to_address=to_address,
message_file=message,
smtp_host=GLSetting.memory_copy.notif_server,
smtp_port=GLSetting.memory_copy.notif_port,
security=GLSetting.memory_copy.notif_security,
event=None)
def send_pgp_alerts(self, node_desc, receiver_desc, notification_settings):
fakeevent = OD()
fakeevent.type = u'pgp_expiration_alert'
fakeevent.node_info = node_desc
fakeevent.context_info = None
fakeevent.steps_info = None
fakeevent.receiver_info = receiver_desc
fakeevent.tip_info = None
fakeevent.subevent_info = None
body = Templating().format_template(
notification_settings['pgp_alert_mail_template'], fakeevent)
title = Templating().format_template(
notification_settings['pgp_alert_mail_title'], fakeevent)
to_address = receiver_desc['mail_address']
message = MIME_mail_build(GLSetting.memory_copy.notif_source_name,
GLSetting.memory_copy.notif_source_email,
to_address,
to_address,
title,
body)
yield sendmail(authentication_username=GLSetting.memory_copy.notif_username,
authentication_password=GLSetting.memory_copy.notif_password,
from_address=GLSetting.memory_copy.notif_source_email,
to_address=to_address,
message_file=message,
smtp_host=GLSetting.memory_copy.notif_server,
smtp_port=GLSetting.memory_copy.notif_port,
security=GLSetting.memory_copy.notif_security,
event=None)
def load_complete_events(store, event_number=GLSetting.notification_limit):
"""
_complete_ is explicit because do not serialize, but make an OD() of the description.
event_number represent the amount of event that can be returned by the function,
event to be notified are taken in account later.
"""
node_desc = db_admin_serialize_node(store, GLSetting.defaults.language)
event_list = []
storedevnts = store.find(EventLogs, EventLogs.mail_sent == False)
storedevnts.order_by(Desc(EventLogs.creation_date))
for i, stev in enumerate(storedevnts):
if len(event_list) == event_number:
log.debug(
"Maximum number of notification event reach (Mailflush) %d, after %d"
% (event_number, i))
break
if not stev.description['receiver_info']['file_notification'] and \
stev.event_reference['kind'] == 'File':
continue
if not stev.description['receiver_info']['message_notification'] and \
stev.event_reference['kind'] == 'Message':
continue
if not stev.description['receiver_info']['comment_notification'] and \
stev.event_reference['kind'] == 'Comment':
continue
if not stev.description['receiver_info']['tip_notification'] and \
stev.event_reference['kind'] == 'Tip':
continue
eventcomplete = OD()
# node level information are not stored in the node, but fetch now
eventcomplete.notification_settings = admin_serialize_notification(
store.find(Notification).one(),
stev.description['receiver_info']['language'])
eventcomplete.node_info = node_desc
# event level information are decoded form DB in the old 'Event'|nametuple format:
eventcomplete.receiver_info = stev.description['receiver_info']
eventcomplete.tip_info = stev.description['tip_info']
eventcomplete.subevent_info = stev.description['subevent_info']
eventcomplete.context_info = stev.description['context_info']
eventcomplete.steps_info = stev.description['steps_info']
eventcomplete.type = stev.description['type'] # 'Tip', 'Comment'
eventcomplete.trigger = stev.event_reference[
'kind'] # 'plaintext_blah' ...
eventcomplete.storm_id = stev.id
event_list.append(eventcomplete)
return event_list
def load_complete_events(store, events_limit=GLSettings.notification_limit):
"""
This function do not serialize, but make an OD() of the description.
events_limit represent the amount of event that can be returned by the function,
events to be notified are taken in account later.
"""
node_desc = db_admin_serialize_node(store, GLSettings.memory_copy.default_language)
event_list = []
totaleventinqueue = store.find(EventLogs, EventLogs.mail_sent == False).count()
storedevnts = store.find(EventLogs, EventLogs.mail_sent == False)[: events_limit * 3]
debug_event_counter = {}
for i, stev in enumerate(storedevnts):
if len(event_list) == events_limit:
log.debug("Reached maximum number of event notifications doable on a single loop %d" % events_limit)
break
debug_event_counter.setdefault(stev.event_reference["kind"], 0)
debug_event_counter[stev.event_reference["kind"]] += 1
if not stev.description["receiver_info"]["tip_notification"]:
continue
eventcomplete = OD()
# node level information are not stored in the node, but fetch now
eventcomplete.notification_settings = admin_serialize_notification(
store.find(Notification).one(), stev.description["receiver_info"]["language"]
)
eventcomplete.node_info = node_desc
# event level information are decoded form DB in the old 'Event'|nametuple format:
eventcomplete.receiver_info = stev.description["receiver_info"]
eventcomplete.tip_info = stev.description["tip_info"]
eventcomplete.subevent_info = stev.description["subevent_info"]
eventcomplete.context_info = stev.description["context_info"]
eventcomplete.type = stev.description["type"] # 'Tip', 'Comment'
eventcomplete.trigger = stev.event_reference["kind"] # 'blah' ...
eventcomplete.orm_id = stev.id
event_list.append(eventcomplete)
if debug_event_counter:
if totaleventinqueue > (events_limit * 3):
log.debug("load_complete_events: %s from %d Events" % (debug_event_counter, totaleventinqueue))
else:
log.debug(
"load_complete_events: %s from %d Events, with a protection limit of %d"
% (debug_event_counter, totaleventinqueue, events_limit * 3)
)
return event_list
def load_complete_events(store, events_limit=GLSettings.notification_limit):
"""
This function do not serialize, but make an OD() of the description.
events_limit represent the amount of event that can be returned by the function,
events to be notified are taken in account later.
"""
node_desc = db_admin_serialize_node(store, GLSettings.defaults.language)
event_list = []
totaleventinqueue = store.find(EventLogs, EventLogs.mail_sent == False).count()
storedevnts = store.find(EventLogs, EventLogs.mail_sent == False)[:events_limit * 3]
debug_event_counter = {}
for i, stev in enumerate(storedevnts):
if len(event_list) == events_limit:
log.debug("Maximum number of notification event reach (Mailflush) %d, after %d" %
(events_limit, i))
break
debug_event_counter.setdefault(stev.event_reference['kind'], 0)
debug_event_counter[stev.event_reference['kind']] += 1
if not stev.description['receiver_info']['tip_notification']:
continue
eventcomplete = OD()
# node level information are not stored in the node, but fetch now
eventcomplete.notification_settings = admin_serialize_notification(
store.find(Notification).one(), stev.description['receiver_info']['language']
)
eventcomplete.node_info = node_desc
# event level information are decoded form DB in the old 'Event'|nametuple format:
eventcomplete.receiver_info = stev.description['receiver_info']
eventcomplete.tip_info = stev.description['tip_info']
eventcomplete.subevent_info = stev.description['subevent_info']
eventcomplete.context_info = stev.description['context_info']
eventcomplete.type = stev.description['type'] # 'Tip', 'Comment'
eventcomplete.trigger = stev.event_reference['kind'] # 'blah' ...
eventcomplete.orm_id = stev.id
event_list.append(eventcomplete)
if debug_event_counter:
if totaleventinqueue > (events_limit * 3):
log.debug("load_complete_events: %s from %d Events" %
(debug_event_counter, totaleventinqueue ))
else:
log.debug("load_complete_events: %s from %d Events, with a protection limit of %d" %
(debug_event_counter, totaleventinqueue, events_limit * 3 ))
return event_list
def load_complete_events(store, event_number=GLSetting.notification_limit):
"""
_complete_ is explicit because do not serialize, but make an OD() of the description.
event_number represent the amount of event that can be returned by the function,
event to be notified are taken in account later.
"""
node_desc = db_admin_serialize_node(store, GLSetting.defaults.language)
event_list = []
storedevnts = store.find(EventLogs, EventLogs.mail_sent == False)
storedevnts.order_by(Asc(EventLogs.creation_date))
debug_event_counter = {}
for i, stev in enumerate(storedevnts):
if len(event_list) == event_number:
log.debug("Maximum number of notification event reach (Mailflush) %d, after %d" %
(event_number, i))
break
debug_event_counter.setdefault(stev.event_reference['kind'], 0)
debug_event_counter[stev.event_reference['kind']] += 1
if not stev.description['receiver_info']['tip_notification']:
continue
eventcomplete = OD()
# node level information are not stored in the node, but fetch now
eventcomplete.notification_settings = admin_serialize_notification(
store.find(Notification).one(), stev.description['receiver_info']['language']
)
eventcomplete.node_info = node_desc
# event level information are decoded form DB in the old 'Event'|nametuple format:
eventcomplete.receiver_info = stev.description['receiver_info']
eventcomplete.tip_info = stev.description['tip_info']
eventcomplete.subevent_info = stev.description['subevent_info']
eventcomplete.context_info = stev.description['context_info']
eventcomplete.steps_info = stev.description['steps_info']
eventcomplete.type = stev.description['type'] # 'Tip', 'Comment'
eventcomplete.trigger = stev.event_reference['kind'] # 'plaintext_blah' ...
eventcomplete.storm_id = stev.id
event_list.append(eventcomplete)
if debug_event_counter:
log.debug("load_complete_events: %s" % debug_event_counter)
return event_list
def generate_anomaly_email(self, plausible_event):
anomalevent = OD()
anomalevent.type = u'receiver_notification_limit_reached'
anomalevent.notification_settings = plausible_event.notification_settings
anomalevent.node_info = plausible_event.node_info
anomalevent.context_info = None
anomalevent.receiver_info = plausible_event.receiver_info
anomalevent.tip_info = None
anomalevent.subevent_info = None
anomalevent.orm_id = 0
return anomalevent
def generate_anomaly_email(self, plausible_event):
anomalevent = OD()
anomalevent.type = u'receiver_notification_limit_reached'
anomalevent.notification_settings = plausible_event.notification_settings
anomalevent.node_info = plausible_event.node_info
anomalevent.context_info = None
anomalevent.receiver_info = plausible_event.receiver_info
anomalevent.tip_info = None
anomalevent.subevent_info = None
anomalevent.orm_id = 0
return anomalevent
def ping_mail_flush(self, notification_settings, receivers_syntesis):
"""
TODO This function should be implemented as a clean and testable plugin in the
way defined in plugin/base.py and plugin/notification.py, and/or is the opportunity
to review these classes, at the moment is a simplified version that just create a
ping email and send it via sendmail.
"""
for _, data in receivers_syntesis.iteritems():
receiver_dict, winks = data
receiver_name = receiver_dict['name']
receiver_email = receiver_dict['ping_mail_address']
fakeevent = OD()
fakeevent.type = u'ping_mail'
fakeevent.node_info = None
fakeevent.context_info = None
fakeevent.steps_info = None
fakeevent.receiver_info = receiver_dict
fakeevent.tip_info = None
fakeevent.subevent_info = {'counter': winks}
body = Templating().format_template(
notification_settings['ping_mail_template'], fakeevent)
title = Templating().format_template(
notification_settings['ping_mail_title'], fakeevent)
# so comfortable for a developer!! :)
source_mail_name = GLSetting.developer_name if GLSetting.devel_mode \
else GLSetting.memory_copy.notif_source_name
message = MIME_mail_build(source_mail_name,
GLSetting.memory_copy.notif_source_email,
receiver_name,
receiver_email,
title,
body)
fakeevent2 = OD()
fakeevent2.type = "Ping mail for %s (%d info)" % (receiver_email, winks)
return sendmail(authentication_username=GLSetting.memory_copy.notif_username,
authentication_password=GLSetting.memory_copy.notif_password,
from_address= GLSetting.memory_copy.notif_source_email,
to_address= [receiver_email],
message_file=message,
smtp_host=GLSetting.memory_copy.notif_server,
smtp_port=GLSetting.memory_copy.notif_port,
security=GLSetting.memory_copy.notif_security,
event=fakeevent2)
def ping_mail_flush(self, notification_settings, receivers_synthesis):
"""
TODO This function should be implemented as a clean and testable plugin in the
way defined in plugin/base.py and plugin/notification.py, and/or is the opportunity
to review these classes, at the moment is a simplified version that just create a
ping email and send it via sendmail.
"""
for _, data in receivers_synthesis.iteritems():
receiver_dict, winks = data
receiver_name = receiver_dict['name']
receiver_email = receiver_dict['ping_mail_address']
fakeevent = OD()
fakeevent.type = u'ping_mail'
fakeevent.node_info = None
fakeevent.context_info = None
fakeevent.receiver_info = receiver_dict
fakeevent.tip_info = None
fakeevent.subevent_info = {'counter': winks}
body = Templating().format_template(
notification_settings['ping_mail_template'], fakeevent)
title = Templating().format_template(
notification_settings['ping_mail_title'], fakeevent)
# so comfortable for a developer!! :)
source_mail_name = GLSettings.developer_name if GLSettings.devel_mode \
else GLSettings.memory_copy.notif_source_name
message = MIME_mail_build(source_mail_name,
GLSettings.memory_copy.notif_source_email,
receiver_name,
receiver_email,
title,
body)
fakeevent2 = OD()
fakeevent2.type = "Ping mail for %s (%d info)" % (receiver_email, winks)
return sendmail(authentication_username=GLSettings.memory_copy.notif_username,
authentication_password=GLSettings.memory_copy.notif_password,
from_address= GLSettings.memory_copy.notif_source_email,
to_address= [receiver_email],
message_file=message,
smtp_host=GLSettings.memory_copy.notif_server,
smtp_port=GLSettings.memory_copy.notif_port,
security=GLSettings.memory_copy.notif_security,
event=fakeevent2)
def send_pgp_alerts(self, receiver_desc):
user_language = receiver_desc["language"]
node_desc = yield admin_serialize_node(user_language)
notification_settings = yield get_notification(user_language)
fakeevent = OD()
fakeevent.type = u"pgp_expiration_alert"
fakeevent.node_info = node_desc
fakeevent.context_info = None
fakeevent.receiver_info = receiver_desc
fakeevent.tip_info = None
fakeevent.subevent_info = None
subject = Templating().format_template(notification_settings["pgp_alert_mail_title"], fakeevent)
body = Templating().format_template(notification_settings["pgp_alert_mail_template"], fakeevent)
yield sendmail(receiver_desc["mail_address"], subject, body)
def send_pgp_alerts(self, receiver_desc):
user_language = receiver_desc['language']
node_desc = yield admin_serialize_node(user_language)
notification_settings = yield get_notification(user_language)
fakeevent = OD()
fakeevent.type = u'pgp_expiration_alert'
fakeevent.node_info = node_desc
fakeevent.context_info = None
fakeevent.receiver_info = receiver_desc
fakeevent.tip_info = None
fakeevent.subevent_info = None
subject = Templating().format_template(
notification_settings['pgp_alert_mail_title'], fakeevent)
body = Templating().format_template(
notification_settings['pgp_alert_mail_template'], fakeevent)
yield sendmail(receiver_desc['mail_address'], subject, body)
def ping_mail_flush(self, notification_settings, receivers_synthesis):
for _, data in receivers_synthesis.iteritems():
receiver_dict, winks = data
receiver_name = receiver_dict['name']
receiver_email = receiver_dict['ping_mail_address']
fakeevent = OD()
fakeevent.type = u'ping_mail'
fakeevent.node_info = None
fakeevent.context_info = None
fakeevent.receiver_info = receiver_dict
fakeevent.tip_info = None
fakeevent.subevent_info = {'counter': winks}
subject = Templating().format_template(notification_settings['ping_mail_template'], fakeevent)
body = Templating().format_template(notification_settings['ping_mail_title'], fakeevent)
return sendmail(receiver_email, subject, body)
def send_admin_pgp_alerts(self, admin_desc, expired_or_expiring):
user_language = admin_desc["language"]
node_desc = yield admin_serialize_node(user_language)
notification_settings = yield get_notification(user_language)
fakeevent = OD()
fakeevent.type = u"admin_pgp_expiration_alert"
fakeevent.node_info = node_desc
fakeevent.context_info = None
fakeevent.receiver_info = None
fakeevent.tip_info = None
fakeevent.subevent_info = {"expired_or_expiring": expired_or_expiring}
subject = Templating().format_template(notification_settings["admin_pgp_alert_mail_title"], fakeevent)
body = Templating().format_template(notification_settings["admin_pgp_alert_mail_template"], fakeevent)
admin_users = yield get_admin_users()
for u in admin_users:
yield sendmail(u["mail_address"], subject, body)
def send_admin_pgp_alerts(self, admin_desc, expired_or_expiring):
user_language = admin_desc['language']
node_desc = yield admin_serialize_node(user_language)
notification_settings = yield get_notification(user_language)
fakeevent = OD()
fakeevent.type = u'admin_pgp_expiration_alert'
fakeevent.node_info = node_desc
fakeevent.context_info = None
fakeevent.receiver_info = None
fakeevent.tip_info = None
fakeevent.subevent_info = {'expired_or_expiring': expired_or_expiring}
subject = Templating().format_template(
notification_settings['admin_pgp_alert_mail_title'], fakeevent)
body = Templating().format_template(
notification_settings['admin_pgp_alert_mail_template'], fakeevent)
admin_users = yield get_admin_users()
for u in admin_users:
yield sendmail(u['mail_address'], subject, body)
def filter_notification_event(notifque):
"""
:param notifque: the current notification event queue
:return: a modified queue in the case some email has not to be sent
Basically performs two filtering; they are defined in:
1) issue #444
2) issue #798
"""
# Here we collect the Storm event of Files having as key the Tip
files_event_by_tip = {}
_tmp_list = []
return_filtered_list = []
# to be smoked Storm.id
orm_id_to_be_skipped = []
for ne in notifque:
if ne['trigger'] != u'Tip':
continue
files_event_by_tip.update({ne['tip_info']['id'] : []})
log.debug("Filtering function: iterating over %d Tip" % len(files_event_by_tip.keys()))
# not files_event_by_tip contains N keys with an empty list,
# I'm looping two times because dict has random ordering
for ne in notifque:
if GLSettings.memory_copy.disable_receiver_notification_emails:
orm_id_to_be_skipped.append(ne['orm_id'])
continue
if ne['trigger'] != u'File':
_tmp_list.append(ne)
continue
if ne['tip_info']['id'] in files_event_by_tip:
orm_id_to_be_skipped.append(ne['orm_id'])
else:
_tmp_list.append(ne)
if len(orm_id_to_be_skipped):
if GLSettings.memory_copy.disable_receiver_notification_emails:
log.debug("All the %d mails will be marked as sent because the admin has disabled receivers notifications" %
len(orm_id_to_be_skipped))
else:
log.debug("Filtering function: Marked %d Files notification to be suppressed cause part of a submission" %
len(orm_id_to_be_skipped))
for ne in _tmp_list:
receiver_id = ne['receiver_info']['id']
sent_emails = GLSettings.get_mail_counter(receiver_id)
if sent_emails >= GLSettings.memory_copy.notification_threshold_per_hour:
log.debug("Discarding email for receiver %s due to threshold already exceeded for the current hour" %
receiver_id)
orm_id_to_be_skipped.append(ne['orm_id'])
continue
GLSettings.increment_mail_counter(receiver_id)
if sent_emails + 1 >= GLSettings.memory_copy.notification_threshold_per_hour:
log.info("Reached threshold of %d emails with limit of %d for receiver %s" % (
sent_emails,
GLSettings.memory_copy.notification_threshold_per_hour,
receiver_id)
)
# Append
anomalyevent = OD()
anomalyevent.type = u'receiver_notification_limit_reached'
anomalyevent.notification_settings = ne.notification_settings
anomalyevent.node_info = ne.node_info
anomalyevent.context_info = None
anomalyevent.receiver_info = ne.receiver_info
anomalyevent.tip_info = None
anomalyevent.subevent_info = None
anomalyevent.orm_id = '0'
return_filtered_list.append(anomalyevent)
orm_id_to_be_skipped.append(ne['orm_id'])
continue
return_filtered_list.append(ne)
log.debug("Mails filtering completed passing from #%d to #%d events" %
(len(notifque), len(return_filtered_list)))
# return the new list of event and the list of Storm.id
return return_filtered_list, orm_id_to_be_skipped
