def a_question_was_asked(self, user_email, mail, messageid):
""""
Process a question that was asked by a user.
"""
mail_subject = str(mail['subject'])
logmsg = 'The user has a question, please take care of that!'
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
c.send_email(self.sender_queue, user_email, "", "Question", "", "", "")
# was the question asked to a specific task_nr that is valid?
search_obj = re.search('[0-9]+', mail_subject, )
if (search_obj != None) and int(search_obj.group()) <= c.get_num_tasks(self.coursedb, \
self.logger_queue, self.name):
fwd_mails = self.get_taskoperator_emails(search_obj.group())
else:
fwd_mails = self.get_admin_emails()
for mail_address in fwd_mails:
c.send_email(self.sender_queue, mail_address, "", "QFwd", "", mail, messageid)
c.increment_db_statcounter(self.semesterdb, 'nr_questions_received', \
self.logger_queue, self.name)
def send_out_email(self, recipient, message, msg_type):
"""
connect to the smtp server and send out an e-mail
"""
try:
# connecting to smtp server
if self.smtp_info["security"] == 'ssl':
server = smtplib.SMTP_SSL(self.smtp_info["server"],
int(self.smtp_info["port"]))
else:
server = smtplib.SMTP(self.smtp_info["server"],
int(self.smtp_info["port"]))
#server.ehlo_or_helo_if_needed()
server.ehlo()
if self.smtp_info["security"] == 'starttls':
server.starttls()
server.login(self.smtp_info["user"], self.smtp_info["passwd"])
except smtplib.SMTPConnectError:
logmsg = "Error while login to server with security= " + \
self.smtp_info["security"] + " , port= " + str(self.smtp_info["port"])
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
except smtplib.SMTPAuthenticationError:
logmsg = ("Authentication error")
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
except Exception as exc:
logmsg = str(exc)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
logmsg = "Error with server connection with security= " + \
self.smtp_info["security"] + " , port= " + str(self.smtp_info["port"])
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
try:
server.sendmail(self.smtp_info["mail"], recipient.split(','),
message)
server.close()
c.log_a_msg(self.queues["logger"], self.name,\
"Successfully sent an e-mail of type '{0}' to {1}!".format(msg_type, recipient), "INFO")
c.increment_db_statcounter(self.dbs["semester"], 'nr_mails_sent', \
self.queues["logger"], self.name)
except Exception as exc:
logmsg = str(exc)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
c.log_a_msg(
self.queues["logger"], self.name,
"Failed to send out an e-mail of type '{0}'!".format(msg_type),
"ERROR")
def send_out_email(self, recipient, message, msg_type):
"""
connect to the smtp server and send out an e-mail
"""
try:
# connecting to smtp server
if self.smtp_security == 'ssl':
server = smtplib.SMTP_SSL(self.smtp_server,
int(self.smtp_port))
else:
server = smtplib.SMTP(self.smtp_server, int(self.smtp_port))
#server.ehlo_or_helo_if_needed()
server.ehlo()
if self.smtp_security == 'starttls':
server.starttls()
server.login(self.smtp_user, self.smtp_pwd)
except smtplib.SMTPConnectError:
logmsg = "Error while login to server with security= " + \
self.smtp_security + " , port= " + str(self.smtp_port)
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
except smtplib.SMTPAuthenticationError:
logmsg = ("Authentication error")
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
except:
logmsg = "Error with server connection with security= " + \
self.smtp_security + " , port= " + str(self.smtp_port)
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
try:
server.sendmail(self.smtp_mail, recipient, message)
server.close()
c.log_a_msg(
self.logger_queue, self.name,
"Successfully sent an e-mail of type '{0}'!".format(msg_type),
"DEBUG")
c.increment_db_statcounter(self.semesterdb, 'nr_mails_sent', \
self.logger_queue, self.name)
except Exception as e:
logmsg = str(e)
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
c.log_a_msg(
self.logger_queue, self.name,
"Failed to send out an e-mail of type '{0}'!".format(msg_type),
"ERROR")
def send_out_email(self, recipient, message, msg_type):
"""
connect to the smtp server and send out an e-mail
"""
try:
# port 465 doesn't seem to work!
server = smtplib.SMTP(self.smtpserver, 587)
server.ehlo()
server.starttls()
server.login(self.autosub_user, self.mail_pwd)
server.sendmail(self.mail_user, recipient, message)
server.close()
c.log_a_msg(self.logger_queue, self.name, "Successfully sent an e-mail of type '{0}'!".format(msg_type), "DEBUG")
c.increment_db_statcounter(self.semesterdb, 'nr_mails_sent', \
self.logger_queue, self.name)
except:
c.log_a_msg(self.logger_queue, self.name, "Failed to send out an e-mail of type '{0}'!".format(msg_type), "ERROR")
def a_question_was_asked(self, user_id, user_email, mail, messageid):
"""
Process a question that was asked by a user.
"""
mail_subject = str(mail['subject'])
logmsg = 'The user has a question, please take care of that!'
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
c.send_email(self.sender_queue, user_email, "", "Question", "", "", "")
# was the question asked to a specific task_nr that is valid?
search_obj = re.search(
'[0-9]+',
mail_subject,
)
if (search_obj != None) and int(search_obj.group()) <= c.get_num_tasks(self.coursedb, \
self.logger_queue, self.name):
tasknr = search_obj.group()
fwd_mails = self.get_taskoperator_emails(tasknr)
if fwd_mails == "":
logmsg = ("Error getting the taskoperator email for task {0}. "
"Question from user with email={1} "
"dropped.").format(tasknr, user_email)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
return
else:
fwd_mails = self.get_admin_emails()
if fwd_mails == "":
logmsg = ("Error getting the admin email for task {0}. "
"Question from user with email={1} "
"dropped.").format(tasknr, user_email)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
return
for mail_address in fwd_mails:
c.send_email(self.sender_queue, mail_address, user_id, "QFwd", "",
mail, messageid)
c.increment_db_statcounter(self.semesterdb, 'nr_questions_received', \
self.logger_queue, self.name)
def a_status_is_requested(self, user_email, messageid):
"""
Process a question about a user status.
"""
curs, cons = c.connect_to_db(self.semesterdb, self.logger_queue, self.name)
data = {'Email': user_email}
sql_cmd = "SELECT UserId, CurrentTask FROM Users WHERE Email == :Email"
curs.execute(sql_cmd, data)
res = curs.fetchone()
user_id = res[0]
current_task = res[1]
cons.close()
c.send_email(self.sender_queue, user_email, user_id, "Status", current_task, \
"", messageid)
c.increment_db_statcounter(self.semesterdb, 'nr_status_requests', \
self.logger_queue, self.name)
def check_if_whitelisted(self, user_email):
"""
Check if the given e-mail address is in the whitelist.
"""
curs, cons = c.connect_to_db(self.semesterdb, self.logger_queue, self.name)
data = {'Email': user_email}
sql_cmd = "SELECT * FROM WhiteList WHERE Email == :Email"
curs.execute(sql_cmd, data)
res = curs.fetchone()
cons.close()
if res != None:
return 1
else:
logmsg = "Got Mail from a User not on the WhiteList: " + user_email
c.log_a_msg(self.logger_queue, self.name, logmsg, "Warning")
c.increment_db_statcounter(self.semesterdb, 'nr_non_registered', \
self.logger_queue, self.name)
return 0
def a_status_is_requested(self, user_id, user_email, messageid):
"""
Tell sender to send out a status email.
"""
logmsg = ("STATUS requested: User with UserId:{0}, Email: {1}").format(\
user_id, user_email)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
curs, cons = c.connect_to_db(self.semesterdb, self.logger_queue,
self.name)
data = {'user_id': user_id}
sql_cmd = "SELECT CurrentTask FROM Users WHERE UserId == :user_id"
curs.execute(sql_cmd, data)
res = curs.fetchone()
current_task = res[0]
cons.close()
c.send_email(self.sender_queue, user_email, user_id, "Status", current_task, \
"", messageid)
c.increment_db_statcounter(self.semesterdb, 'nr_status_requests', \
self.logger_queue, self.name)
def check_if_whitelisted(self, user_email):
"""
Check if the given e-mail address is in the whitelist.
"""
curs, cons = c.connect_to_db(self.dbs["semester"],
self.queues["logger"], self.name)
data = {'Email': user_email}
sql_cmd = "SELECT * FROM WhiteList WHERE Email == :Email"
curs.execute(sql_cmd, data)
res = curs.fetchone()
cons.close()
if res != None:
return True
logmsg = "Got mail from a user not on the WhiteList: " + user_email
c.log_a_msg(self.queues["logger"], self.name, logmsg, "Warning")
c.increment_db_statcounter(self.dbs["semester"], 'nr_non_registered', \
self.queues["logger"], self.name)
return False
def a_question_was_asked(self, user_id, user_email, mail, message_id):
"""
Process a question that was asked by a user.
"""
mail_subject = str(mail['subject'])
logmsg = 'The user has a question, please take care of that!'
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
# was the question asked to a specific task_nr
search_obj = re.search(
'[0-9]+',
mail_subject,
)
task_nr = ""
if (search_obj != None):
task_nr = search_obj.group()
#task with this task_nr exists?
is_task = c.is_valid_task_nr(self.dbs["course"], task_nr, self.queues["logger"], \
self.name)
if not is_task:
# task_nr is not valid
c.send_email(self.queues["sender"], user_email, "", "InvalidTask", str(task_nr), \
"", message_id)
logmsg = ("Question from user with email {0} contains an "
"invalid TaskNr. Informing user, message dropped"
).format(user_email)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "INFO")
return
fwd_mails = self.get_taskoperator_emails(task_nr)
if not fwd_mails:
logmsg = ("Error getting the taskoperator email for task {0}. "
"Question from user with email={1} "
"dropped.").format(task_nr, user_email)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
return
else:
fwd_mails = self.get_admin_emails()
if not fwd_mails:
logmsg = ("Error getting the admin email."
"Question from user with email={1} "
"dropped.").format(task_nr, user_email)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
return
# send Question received message to user
c.send_email(self.queues["sender"], user_email, "", "Question", "", "",
"")
# forward email to admins/taskoperators
mail["Reply-To"] = user_email
c.send_email(self.queues["sender"], fwd_mails, user_id, "QFwd",
task_nr, mail, message_id)
c.increment_db_statcounter(self.dbs["semester"], 'nr_questions_received', \
self.queues["logger"], self.name)
def handle_new(self, m):
"""
Fetch new emails and initiate appropriate action
"""
uid_of_mid = self.idmap_new_emails(m)
# no new or imap connection error
if not uid_of_mid:
return
curs, cons = c.connect_to_db(self.dbs["semester"],
self.queues["logger"], self.name)
# iterate over all new e-mails and take action according to the structure
# of the subject line
for message_id, uid in uid_of_mid.items():
c.increment_db_statcounter(self.dbs["semester"], 'nr_mails_fetched', \
self.queues["logger"], self.name)
# fetching the mail, "`(RFC822)`" means "get the whole stuff", but you
# can ask for headers only, etc
try:
resp, data = m.uid('fetch', uid, "(RFC822)")
except Exception as e:
logmsg = ("Failed to fetch message with uid {0} from "
"inbox with error {1}").format(uid, str(e))
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
continue
# parsing the mail content to get a mail object
mail = email.message_from_bytes(data[0][1])
mail_subject = str(mail['subject'])
from_header = str(mail['From'])
split_header = str(from_header).split("<")
user_name = split_header[0]
try:
user_email = str(split_header[1].split(">")[0])
except:
user_email = str(mail['From'])
# Now let's decide what actions to take with the received email
whitelisted = self.check_if_whitelisted(user_email)
if whitelisted:
# On Whitelist
data = {'Email': user_email}
sql_cmd = "SELECT UserId FROM Users WHERE Email = :Email"
curs.execute(sql_cmd, data)
res = curs.fetchone()
if res != None:
# Already registered
user_id = res[0]
logmsg = ("Got mail from an already known user! "
"(UserId:{0}, Email:{1}").format(
user_id, user_email)
c.log_a_msg(self.queues["logger"], self.name, logmsg,
"INFO")
# Take action based on the subject
self.action_by_subject(user_id, user_email, message_id, mail, \
mail_subject)
else:
# Not yet registered
reg_deadline = self.get_registration_deadline()
if reg_deadline > datetime.datetime.now():
# Before Registraton deadline?
#Name for user specified in Whitelist? -> take it
data = {'Email': user_email}
sql_cmd = ("SELECT Name FROM Whitelist "
"WHERE Email = :Email")
curs.execute(sql_cmd, data)
res = curs.fetchone()
if res[0] and res[0].strip():
user_name = res[0]
# Create user and send Welcome message
self.add_new_user(user_name, user_email)
c.send_email(self.queues["sender"], user_email, "", "Welcome", \
"", "", message_id)
else:
# After Registration deadline
c.send_email(self.queues["sender"], user_email, "", "RegOver", \
"", "", message_id)
else:
# Not on Whitelist
# Check if user has an UserID and was therefore deleted after registration
data = {'Email': user_email}
sql_cmd = "SELECT UserId FROM Users WHERE Email = :Email"
curs.execute(sql_cmd, data)
res = curs.fetchone()
if res == None:
# Not a registered user
c.send_email(self.queues["sender"], user_email, "", "NotAllowed", \
"", "", message_id)
else:
# A registered user, who was removed from the whitelist after registration
c.send_email(self.queues["sender"], user_email, "", "DeletedFromWhitelist", \
"", "", message_id)
cons.close()
def loop_code(self):
"""
The code run in the while True loop of the mail fetcher thread.
"""
m = self.connect_to_imapserver()
if m != 0:
curs, cons = c.connect_to_db(self.semesterdb, self.logger_queue, self.name)
items = self.fetch_new_emails(m)
# iterate over all new e-mails and take action according to the structure
# of the subject line
for emailid in items:
c.increment_db_statcounter(self.semesterdb, 'nr_mails_fetched', \
self.logger_queue, self.name)
# fetching the mail, "`(RFC822)`" means "get the whole stuff", but you
# can ask for headers only, etc
resp, data = m.fetch(emailid, "(RFC822)")
# parsing the mail content to get a mail object
mail = email.message_from_bytes(data[0][1])
mail_subject = str(mail['subject'])
from_header = str(mail['From'])
split_header = str(from_header).split("<")
user_name = split_header[0]
try:
user_email = str(split_header[1].split(">")[0])
except:
user_email = str(mail['From'])
messageid = mail.get('Message-ID')
whitelisted = self.check_if_whitelisted(user_email)
if whitelisted:
data = {'Email': user_email}
sql_cmd = "SELECT UserId FROM Users WHERE Email = :Email"
curs.execute(sql_cmd, data)
res = curs.fetchall()
if res:
logmsg = "Got mail from an already known user!"
c.log_a_msg(self.logger_queue, self.name, logmsg, "INFO")
#TODO: Does sending a mail "Result bla" without number crash this?
if re.search('[Rr][Ee][Ss][Uu][Ll][Tt]', mail_subject):
searchObj = re.search('[0-9]+', mail_subject, )
if int(searchObj.group()) <= c.get_num_tasks(self.coursedb, \
self.logger_queue, self.name):
logmsg = "Processing a Result, UserId:{0} TaskNr:{1}"\
.format(user_email, searchObj.group())
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
self.take_new_results(user_email, searchObj.group(), \
mail, messageid)
else:
logmsg = ("Given Task number is higher than actual Number"
"of Tasks!")
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
c.send_email(self.sender_queue, user_email, "", \
"InvalidTask", "", "", messageid)
elif re.search('[Qq][Uu][Ee][Ss][Tt][Ii][Oo][Nn]', mail_subject):
self.a_question_was_asked(user_email, mail, messageid)
elif re.search('[Ss][Tt][Aa][Tt][Uu][Ss]', mail_subject):
self.a_status_is_requested(user_email, messageid)
else:
logmsg = ("Got a kind of message I do not understand. "
"Sending a usage mail...")
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
c.send_email(self.sender_queue, user_email, "", "Usage", "", \
"", messageid)
else:
reg_deadline = self.get_registration_deadline()
if reg_deadline > datetime.datetime.now():
self.add_new_user(user_name, user_email)
c.send_email(self.sender_queue, user_email, "", "Welcome", \
"", "", messageid)
else:
c.send_email(self.sender_queue, user_email, "", "RegOver", \
"", "", messageid)
else:
c.send_email(self.sender_queue, user_email, "", "NotAllowed", \
"", "", messageid)
try:
m.close()
except imaplib.IMAP4.abort:
logmsg = ("Closing connection to server was aborted "
"(probably a server-side problem). Trying to connect again ...")
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
#m.close()
except imaplib.IMAP4.error:
logmsg = ("Got an error when trying to connect to the imap server."
"Trying to connect again ...")
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
except:
logmsg = ("Got an unknown exception when trying to connect to the "
"imap server. Trying to connect again ...")
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
finally:
logmsg = "closed connection to imapserver"
c.log_a_msg(self.logger_queue, self.name, logmsg, "INFO")
# check if messages have been handled and need to be archived now
try:
next_send_msg = self.arch_queue.get(False)
except:
next_send_msg = 'NONE'
if next_send_msg != 'NONE':
c.log_a_msg(self.logger_queue, self.name, "moving a message!!!!!!!", \
"INFO")
m = self.connect_to_imapserver()
for next_msg in next_send_msg:
email_ids = self.fetch_all_emails(m)
for emailid in email_ids:
typ, msg_data = m.fetch(str(int(emailid)), "(BODY[HEADER])")
mail = email.message_from_bytes(msg_data[0][1])
if mail['Message-ID'] == next_send_msg.get('mid'):
logmsg = "Moving Message with ID: {0}"\
.format(mail['Message-ID'])
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
resp, data = m.fetch(emailid, "(UID)")
pattern_uid = re.compile('\d+ \(UID (?P<uid>\d+)\)')
match = pattern_uid.match(str(data[0]).split("'")[1])
msg_uid = match.group('uid')
result = m.uid('COPY', msg_uid, 'archive_vels')
if result[0] == 'OK':
mov, data = m.uid('STORE', msg_uid, '+FLAGS', \
'(\Deleted)')
m.expunge()
break
# m==0 is only possible in test-code (e.g. load_test.py)
if m != 0:
m.logout()
cons.close()
time.sleep(self.poll_period)
def loop_code(self):
"""
The code run in the while True loop of the mail fetcher thread.
"""
m = self.connect_to_imapserver()
if m != 0:
curs, cons = c.connect_to_db(self.semesterdb, self.logger_queue,
self.name)
items = self.fetch_new_emails(m)
# iterate over all new e-mails and take action according to the structure
# of the subject line
for emailid in items:
c.increment_db_statcounter(self.semesterdb, 'nr_mails_fetched', \
self.logger_queue, self.name)
# fetching the mail, "`(RFC822)`" means "get the whole stuff", but you
# can ask for headers only, etc
resp, data = m.fetch(emailid, "(RFC822)")
# parsing the mail content to get a mail object
mail = email.message_from_bytes(data[0][1])
mail_subject = str(mail['subject'])
from_header = str(mail['From'])
split_header = str(from_header).split("<")
user_name = split_header[0]
try:
user_email = str(split_header[1].split(">")[0])
except:
user_email = str(mail['From'])
messageid = mail.get('Message-ID')
# Now let's decide what actions to take with the received email
whitelisted = self.check_if_whitelisted(user_email)
if whitelisted:
# On Whitelist
data = {'Email': user_email}
sql_cmd = "SELECT UserId FROM Users WHERE Email = :Email"
curs.execute(sql_cmd, data)
res = curs.fetchone()
if res != None:
# Already registered
user_id = res[0]
logmsg = ("Got mail from an already known user! "
"(UserId:{0}, Email:{1}").format(
user_id, user_email)
c.log_a_msg(self.logger_queue, self.name, logmsg,
"INFO")
# Take action based on the subject
self.action_by_subject(user_id, user_email, messageid, mail, \
mail_subject)
else:
# Not yet registered
reg_deadline = self.get_registration_deadline()
if reg_deadline > datetime.datetime.now():
# Before Registraton deadline
self.add_new_user(user_name, user_email)
c.send_email(self.sender_queue, user_email, "", "Welcome", \
"", "", messageid)
else:
# After Registration deadline
c.send_email(self.sender_queue, user_email, "", "RegOver", \
"", "", messageid)
else:
# Not on Whitelist
c.send_email(self.sender_queue, user_email, "", "NotAllowed", \
"", "", messageid)
try:
m.close()
except imaplib.IMAP4.abort:
logmsg = (
"Closing connection to server was aborted "
"(probably a server-side problem). Trying to connect again ..."
)
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
#m.close()
except imaplib.IMAP4.error:
logmsg = (
"Got an error when trying to connect to the imap server."
"Trying to connect again ...")
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
except:
logmsg = (
"Got an unknown exception when trying to connect to the "
"imap server. Trying to connect again ...")
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
finally:
logmsg = "closed connection to imapserver"
c.log_a_msg(self.logger_queue, self.name, logmsg, "INFO")
# check if messages have been handled and need to be archived now
try:
next_send_msg = self.arch_queue.get(False)
except:
next_send_msg = 'NONE'
if next_send_msg != 'NONE':
c.log_a_msg(self.logger_queue, self.name, "moving a message!!!!!!!", \
"INFO")
m = self.connect_to_imapserver()
archive_dir = self.get_archive_dir()
for next_msg in next_send_msg:
email_ids = self.fetch_all_emails(m)
for emailid in email_ids:
typ, msg_data = m.fetch(str(int(emailid)),
"(BODY[HEADER])")
mail = email.message_from_bytes(msg_data[0][1])
if mail['Message-ID'] == next_send_msg.get('mid'):
logmsg = "Moving Message with ID: {0}"\
.format(mail['Message-ID'])
c.log_a_msg(self.logger_queue, self.name, logmsg,
"DEBUG")
resp, data = m.fetch(emailid, "(UID)")
pattern_uid = re.compile(
'\d+ \(UID (?P<uid>\d+)\)')
match = pattern_uid.match(
str(data[0]).split("'")[1])
msg_uid = match.group('uid')
result = m.uid('COPY', msg_uid, archive_dir)
if result[0] == 'OK':
mov, data = m.uid('STORE', msg_uid, '+FLAGS', \
'(\Deleted)')
m.expunge()
else:
log_msg = (
"Error moving a message. Is the "
"configured archive_dir '{0}' existing "
"on the IMAP server?!").format(archive_dir)
c.log_a_msg(self.logger_queue, self.name, \
log_msg, "ERROR")
break
# m==0 is only possible in test-code (e.g. load_test.py)
if m != 0:
m.logout()
cons.close()
time.sleep(self.poll_period)
def send_out_email(self, recipient, message, msg_type, retry_cnt):
"""
connect to the smtp server and send out an e-mail
"""
try:
logmsg=""
# DEBUG: Just a debug excpetion for testing failed email sending
#if msg_type == "Status":
# raise Exception("Fake Exception for testing resending")
# connecting to smtp server
if self.smtp_info["security"] == 'ssl':
server = smtplib.SMTP_SSL(self.smtp_info["server"], int(self.smtp_info["port"]))
else:
server = smtplib.SMTP(self.smtp_info["server"], int(self.smtp_info["port"]))
#server.ehlo_or_helo_if_needed()
server.ehlo()
if self.smtp_info["security"] == 'starttls':
server.starttls()
server.login(self.smtp_info["user"], self.smtp_info["passwd"])
except smtplib.SMTPConnectError:
logmsg = "Error while login to server with security= " + \
self.smtp_info["security"] + " , port= " + str(self.smtp_info["port"])
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
except smtplib.SMTPAuthenticationError:
logmsg = ("Authentication error")
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
except Exception as exc:
logmsg = str(exc)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
logmsg = "Error with server connection with security= " + \
self.smtp_info["security"] + " , port= " + str(self.smtp_info["port"])
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
finally:
if logmsg != "":
# failed to send the mail, retry according to config
self.resend_mail(msg_type,recipient,message,retry_cnt)
try:
server.close()
except Exception as exc:
logmsg = str(exc)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
return
try:
# DEBUG: Just a debug exception for testing failed email sending
#if msg_type == "NoMultipleRequest":
# raise Exception("Fake Exception for testing resending")
#if msg_type == "RetrySendingFailedMail":
# if retry_cnt<9:
# raise Exception("Fake Exception for testing resending")
server.sendmail(self.smtp_info["mail"], recipient.split(','), message)
c.log_a_msg(self.queues["logger"], self.name,\
"Successfully sent an e-mail of type '{0}' to {1}!".format(msg_type, recipient), "INFO")
c.increment_db_statcounter(self.dbs["semester"], 'nr_mails_sent', \
self.queues["logger"], self.name)
except Exception as exc:
logmsg = str(exc)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
c.log_a_msg(self.queues["logger"], self.name, ("Failed to send out an e-mail of type "
"'{0} for user {1}'!").format(msg_type,recipient), "ERROR")
# failed to send the mail, retry according to config
self.resend_mail(msg_type, recipient, message,retry_cnt)
try:
server.close()
except Exception as exc:
logmsg = str(exc)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
return
try:
server.close()
except Exception as exc:
logmsg = str(exc)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
