def skip_was_requested(self, user_id, user_email, messageid):
# at which task_nr is the user
cur_task = c.user_get_current_task(self.semesterdb, user_id, self.logger_queue, \
self.name)
next_task = cur_task + 1
logmsg = ("Skip requested: User with UserId:{0}, from "
"TaskNr= {1} to {2}").format(user_id, cur_task, next_task)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
#task with this tasknr exists?
is_task = c.is_valid_task_nr(self.coursedb, next_task, self.logger_queue,\
self.name)
if is_task == True:
task_starttime = c.get_task_starttime(self.coursedb, next_task,
self.logger_queue, self.name)
task_has_started = task_starttime < datetime.datetime.now()
if task_has_started == True:
#set new current task
c.user_set_current_task(self.semesterdb, next_task, user_id, \
self.logger_queue, self.name)
#tell generator thread to create new task
logmsg = ("Calling Generator to create "
"TaskNr:{0} for UserId:{1}").format(
next_task, user_id)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
self.gen_queue.put(dict({"user_id": user_id, "user_email": user_email, \
"task_nr": next_task, "messageid": messageid}))
logmsg = ("Skip done: User with UserId:{0}, from "
"TaskNr= {1} to {2}").format(user_id, cur_task,
next_task)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
return
#Skip not possible
logmsg = ("Skip NOT POSSIBLE: User with UserId:{0}, from "
"TaskNr= {1} to {2}").format(user_id, cur_task, next_task)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
c.send_email(self.sender_queue, user_email, "", "SkipNotPossible", \
"", "", messageid)
def handle_next_mail(self):
"""
parse the subject/content of a mail and take appropriate action.
"""
#blocking wait on sender_queue
next_send_msg = self.queues["sender"].get(True)
task_nr = str(next_send_msg.get('task_nr'))
message_id = str(next_send_msg.get('message_id'))
user_id = str(next_send_msg.get('user_id'))
recipient = str(next_send_msg.get('recipient'))
message_type = str(next_send_msg.get('message_type'))
curs, cons = c.connect_to_db(self.dbs["semester"], self.queues["logger"], \
self.name)
curc, conc = c.connect_to_db(self.dbs["course"], self.queues["logger"], \
self.name)
attachments = []
# prepare fields for the e-mail
msg = MIMEMultipart()
msg['From'] = self.smtp_info["mail"]
msg['To'] = recipient
logmsg = "RECIPIENT: " + recipient
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
msg['Date'] = formatdate(localtime=True)
if message_type == "Task":
#################
# TASK #
#################
logmsg = "Task in send_queue: " + str(next_send_msg)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
# 2 Cases:
# allow_requests == "once" or "multiple" -> send Task anyway
# allow_requests == "no" : check if he is at a higher task_nr,
# if yes: do not send
cur_task = c.user_get_current_task(self.dbs["semester"], user_id, \
self.queues["logger"], self.name)
at_higher_task = (cur_task > int(task_nr))
should_not_send = (self.allow_requests == "no") and at_higher_task
if should_not_send:
logmsg = ("Task sending initiated, but user already reveived "
"this task!!!")
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
return
data = {'task_nr': str(task_nr)}
sql_cmd = ("SELECT TaskName FROM TaskConfiguration "
"WHERE TaskNr == :task_nr")
curc.execute(sql_cmd, data)
res = curc.fetchone()
if not res:
logmsg = ("Failed to fetch Configuration for TaskNr: "
"{0} from the database! Table "
"TaskConfiguration corrupted?").format(task_nr)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
message_text = ("Sorry, but something went wrong... "
"probably misconfiguration or missing"
"configuration of Task {0}").format(task_nr)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), \
message_type)
self.archive_message(message_id)
return
task_name = res[0]
description_path = self.course_info['tasks_dir'] + \
'/' + task_name + '/description.txt'
if not os.path.isfile(description_path):
logmsg = "No description.txt found for Task {0}.".format(
task_nr)
c.log_a_msg(self.queues["logger"], self.name, \
logmsg, "ERROR")
message_text = ("Sorry, but something went wrong... "
"probably misconfiguration or missing"
"configuration of Task {0}").format(task_nr)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
return
msg['Subject'] = "Description Task" + str(task_nr)
task_deadline = c.get_task_deadline(self.dbs["course"], task_nr,
self.queues["logger"],
self.name)
dl_text = "\nDeadline for this Task: {0}\n".format(task_deadline)
message_text = self.read_text_file(description_path) \
+ dl_text
data = {'task_nr': str(task_nr), 'user_id': user_id}
sql_cmd = ("SELECT TaskAttachments FROM UserTasks "
"WHERE TaskNr == :task_nr AND UserId == :user_id")
curs.execute(sql_cmd, data)
res = curs.fetchone()
logmsg = "got the following attachments: " + str(res)
c.log_a_msg(self.queues["logger"], self.name, logmsg, \
"DEBUG")
if res:
attachments = str(res[0]).split()
else:
attachments = ""
msg = self.assemble_email(msg, message_text, attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
# Everything went okay -> adjust cur_task_nr
c.user_set_current_task(self.dbs["semester"], task_nr, user_id, \
self.queues["logger"], self.name)
elif message_type == "Failed":
#################
# FAILED #
#################
# did user already solve this task?
data = {"user_id": user_id, "task_nr": task_nr}
sql_cmd = ("SELECT UserId FROM UserTasks WHERE UserId = :user_id "
"AND TaskNr = :task_nr AND FirstSuccessful IS NOT NULL")
curs.execute(sql_cmd, data)
res = curs.fetchone()
task_already_solved = (res != None)
#only update stat if user did not solve this task
if not task_already_solved:
self.increment_db_taskcounter('NrSubmissions', task_nr)
path_to_msg = "users/{0}/Task{1}".format(user_id, task_nr)
error_msg = self.read_text_file(
"{0}/error_msg".format(path_to_msg))
msg['Subject'] = "Failure Task" + task_nr
message_text = "Error report:\n\n" "" + error_msg
reply_attachments = []
try:
logmsg = "searching attachments in: {0}/error_attachments".format(
path_to_msg)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
ats = os.listdir("{0}/error_attachments".format(path_to_msg))
logmsg = "got the following attachments: {0}".format(ats)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
for next_attachment in ats:
reply_attachments.append(
"{0}/error_attachments/{1}".format(
path_to_msg, next_attachment))
except:
logmsg = "no attachments for failed task."
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
msg = self.assemble_email(msg, message_text, reply_attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
# archive and notify that worker finished
self.archive_message(message_id, is_finished_job=True)
elif message_type == "Success":
#################
# SUCCESS #
#################
msg['Subject'] = "Success Task " + task_nr
message_text = "You solved the task successfully. Congratulations!"
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
#set first done if not set yet
self.check_and_set_first_successful(user_id, task_nr)
# last done had to be set now? --> Send Congrats
if self.check_and_set_last_done(user_id):
#new message, prepare it
msg = MIMEMultipart()
msg['From'] = self.smtp_info["mail"]
msg['To'] = recipient
logmsg = "RECIPIENT: " + recipient
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
msg['Date'] = formatdate(localtime=True)
message_text = self.read_specialmessage('CONGRATS')
msg['Subject'] = "Congratulations on solving all Tasks!"
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), "LastSolved")
# archive and notify that worker finished
self.archive_message(message_id, is_finished_job=True)
elif message_type == "SecAlert":
#################
# SEC ALERT #
#################
admin_mails = self.get_admin_emails()
for admin_mail in admin_mails:
msg['To'] = admin_mail
path_to_msg = "users/" + user_id + "/Task" + task_nr + "/error_msg"
error_msg = self.read_text_file(path_to_msg)
msg['Subject'] = "Security Alert User:"******"Error report:\n\n" "" + error_msg
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(admin_mail, msg.as_string(), message_type)
elif message_type == "TaskAlert":
#################
# TASK ALERT #
#################
admin_mails = self.get_admin_emails()
for admin_mail in admin_mails:
msg['To'] = admin_mail
msg['Subject'] = "Task Error Alert Task{0} User{1}".format( \
str(task_nr), str(user_id))
message_text = ("There was an error with the Task {0} " \
"and User {1}. Check the logfiles(tasks.stderr, tasks.stdout, "
"autosub.log) to find what caused it.").format(task_nr, user_id)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(admin_mail, msg.as_string(), message_type)
elif message_type == "TaskErrorNotice":
####################
# TASKERROR NOTICE #
####################
admins = ",".join(self.get_admin_emails())
msg['Subject'] = "Error processing your last message"
message_text = (
"There was an error processing your last message, please write an "
"email to the administrators {0} and tell them about the time and what you did last. "
"They will work on resolving the issue as soon as possible."
).format(admins)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
# archive, is_finished_job=True for tester errors, so the job can be
# deleted from the active jobs
# in the case this error is from a generator, the is_finished will be
# ignored as the message_id will not be in the active jobs (see
# fetcher.py)
self.archive_message(message_id, is_finished_job=True)
elif message_type == "Status":
#################
# STATUS #
#################
msg['Subject'] = "Your current status"
message_text = self.generate_status_update(user_id, recipient, \
task_nr)
numtasks = c.get_num_tasks(self.dbs["course"], self.queues["logger"], \
self.name)
if int(numtasks) >= int(task_nr):
#also attach current task
data = {'task_nr': str(task_nr), 'user_id': user_id}
sql_cmd = ("SELECT TaskAttachments FROM UserTasks "
"WHERE TaskNr == :task_nr AND UserId == :user_id")
curs.execute(sql_cmd, data)
res = curs.fetchone()
logmsg = "got the following attachments: " + str(res)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
if res:
attachments = str(res[0]).split()
msg = self.assemble_email(msg, message_text, attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
else:
msg = self.assemble_email(msg, message_text, attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "TasksList":
#################
# TASKSLIST #
#################
msg['Subject'] = "List of tasks"
message_text = self.generate_tasks_list()
msg = self.assemble_email(msg, message_text, attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "InvalidTask":
#################
# INVALID TASK #
#################
msg['Subject'] = "Invalid Task Number"
message_text = self.read_specialmessage('INVALID')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "TaskNotSubmittable":
#########################
# TASK NOT SUBMITTABLE #
#########################
msg['Subject'] = "Submission for Task{0} not possible".format(
str(task_nr))
message_text = self.read_specialmessage('TASKNOTSUBMITTABLE')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "TaskNotActive":
#########################
# TASK NOT ACTIVE #
#########################
msg['Subject'] = "Task{0} not active yet".format(str(task_nr))
message_text = self.read_specialmessage('TASKNOTACTIVE')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "NoMultipleRequest":
#########################
# NO MULTIPLE REQUEST #
#########################
msg['Subject'] = "Already received Task{0}".format(str(task_nr))
message_text = self.read_specialmessage('NOMULTIPLEREQUEST')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "CurLast":
#################
# CUR LAST #
#################
# we still need to increment the users task counter!
c.user_set_current_task(self.dbs["semester"], task_nr, user_id, \
self.queues["logger"], self.name)
msg['Subject'] = "Task{0} is not available yet".format(
str(task_nr))
message_text = self.read_specialmessage('CURLAST')
message_text = "{0}\n\nThe Task is currently scheduled for: {1}".format(message_text, \
c.get_task_starttime(self.dbs["course"], str(task_nr), \
self.queues["logger"], self.name))
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "DeadTask":
#################
# DEAD TASK #
#################
msg['Subject'] = "Deadline for Task{0} has passed.".format(
str(task_nr))
message_text = self.read_specialmessage('DEADTASK')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "Usage":
#################
# USAGE #
#################
msg['Subject'] = "Usage"
message_text = self.read_specialmessage('USAGE')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "Question":
#################
# QUESTION #
#################
msg['Subject'] = "Question received"
message_text = self.read_specialmessage('QUESTION')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
elif message_type == "QFwd":
#################
# QFWD #
#################
orig_mail = next_send_msg.get('body')
orig_from = orig_mail['from']
orig_mail.replace_header("From", self.smtp_info["mail"])
orig_mail.replace_header("To", recipient)
if task_nr:
orig_mail.replace_header(
"Subject",
"Question Task" + task_nr + " from " + orig_from)
else:
orig_mail.replace_header("Subject",
"Question from " + orig_from)
self.send_out_email(recipient, orig_mail.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "Welcome":
#################
# WELCOME #
#################
msg['Subject'] = "Welcome!"
message_text = self.read_specialmessage('WELCOME')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "RegOver":
#################
# REGOVER #
#################
msg['Subject'] = "Registration Deadline has passed"
message_text = self.read_specialmessage('REGOVER')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "NotAllowed":
#################
# NOT ALLOWED #
#################
msg['Subject'] = "Registration not successful."
message_text = self.read_specialmessage('NOTALLOWED')
message_text = message_text.replace("[[recipient]]", recipient)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
elif message_type == "DeletedFromWhitelist":
############################
# DELETED FROM WHITELIST #
############################
msg['Subject'] = "Not whitelisted anymore"
message_text = self.read_specialmessage('DeletedFromWhitelist')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
else:
#################
# UNKNOWN #
#################
c.log_a_msg(self.queues["logger"], self.name, \
"Unkown Message Type in the sender_queue!", "ERROR")
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.archive_message(message_id)
cons.close()
conc.close()
def handle_next_mail(self):
"""
parse the subject/content of a mail and take appropriate action.
"""
#blocking wait on sender_queue
next_send_msg = self.sender_queue.get(True)
task_nr = str(next_send_msg.get('Task'))
messageid = str(next_send_msg.get('MessageId'))
user_id = str(next_send_msg.get('UserId'))
recipient = str(next_send_msg.get('recipient'))
message_type = str(next_send_msg.get('message_type'))
curs, cons = c.connect_to_db(self.semesterdb, self.logger_queue, \
self.name)
curc, conc = c.connect_to_db(self.coursedb, self.logger_queue, \
self.name)
attachments = []
# prepare fields for the e-mail
msg = MIMEMultipart()
msg['From'] = self.smtp_mail
msg['To'] = recipient
logmsg = "RECIPIENT: " + recipient
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
msg['Date'] = formatdate(localtime=True)
if message_type == "Task":
#################
# TASK #
#################
logmsg = "Task in send_queue: " + str(next_send_msg)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
numtasks = c.get_num_tasks(self.coursedb, \
self.logger_queue, self.name)
cur_task_nr = c.user_get_current_task(self.semesterdb, user_id, \
self.logger_queue, self.name)
########################### NEEDED? #########################
# did user solve this task already?
data = {"user_id": user_id, "task_nr": task_nr}
sql_cmd = ("SELECT UserId FROM UserTasks WHERE UserId = :user_id "
"AND TaskNr = :task_nr AND FirstSuccessful IS NOT NULL")
curs.execute(sql_cmd, data)
res = curs.fetchone()
task_already_solved = (res != None)
#did the user solve the previous task?
data = {"user_id": user_id, "task_nr": int(task_nr) - 1}
sql_cmd = ("SELECT UserId FROM UserTasks WHERE UserId = :user_id "
"AND TaskNr = :task_nr AND FirstSuccessful IS NOT NULL")
curs.execute(sql_cmd, data)
res = curs.fetchone()
prev_task_already_solved = (res != None)
#############################################################
# user did not solve the task with highest TaskNr
if numtasks + 1 != int(task_nr):
# only send the task description, when the user just now got
# to this task or it is the first task
if int(task_nr) - 1 <= int(cur_task_nr) or int(
cur_task_nr) == 1:
msg['Subject'] = "Description Task" + str(task_nr)
dl_text = "\nDeadline for this Task: {0}\n".format(
c.get_task_deadline(self.coursedb, task_nr,
self.logger_queue, self.name))
data = {'task_nr': str(task_nr)}
sql_cmd = "SELECT PathToTask FROM TaskConfiguration WHERE TaskNr == :task_nr;"
curc.execute(sql_cmd, data)
paths = curc.fetchone()
if not paths:
logmsg = "It seems, the Path to Task {0} is not configured.".format(
task_nr)
c.log_a_msg(self.logger_queue, self.name, \
logmsg, "WARNING")
message_text = "Sorry, but something went wrong... probably misconfiguration or missing configuration of Task {0}".format(
task_nr)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), \
message_type)
self.backup_message(messageid)
else:
path_to_task = str(paths[0])
path_to_msg = path_to_task + "/description.txt"
message_text = self.read_text_file(path_to_msg) \
+ dl_text
data = {'task_nr': str(task_nr), 'user_id': user_id}
sql_cmd = "SELECT TaskAttachments FROM UserTasks WHERE TaskNr == :task_nr AND UserId == :user_id;"
curs.execute(sql_cmd, data)
res = curs.fetchone()
logmsg = "got the following attachments: " + str(res)
c.log_a_msg(self.logger_queue, self.name, logmsg, \
"DEBUG")
if res:
attachments = str(res[0]).split()
msg = self.assemble_email(msg, message_text, \
attachments)
self.send_out_email(recipient, msg.as_string(), \
message_type)
self.backup_message(messageid)
#advance user's current TaskNr to the Task task_nr if he is not
# at a higher task yet
if int(cur_task_nr) < int(task_nr):
c.user_set_current_task(self.semesterdb, task_nr, user_id, \
self.logger_queue, self.name)
elif message_type == "Failed":
#################
# FAILED #
#################
# did user already solve this task?
data = {"user_id": user_id, "task_nr": task_nr}
sql_cmd = ("SELECT UserId FROM UserTasks WHERE UserId = :user_id "
"AND TaskNr = :task_nr AND FirstSuccessful IS NOT NULL")
curs.execute(sql_cmd, data)
res = curs.fetchone()
task_already_solved = (res != None)
#only update stat if user did not solve this task
if not task_already_solved:
self.increment_db_taskcounter('NrSubmissions', task_nr)
path_to_msg = "users/{0}/Task{1}".format(user_id, task_nr)
error_msg = self.read_text_file(
"{0}/error_msg".format(path_to_msg))
msg['Subject'] = "Task" + task_nr + ": submission rejected"
message_text = "Error report:\n\n" "" + error_msg
reply_attachments = []
try:
logmsg = "searching attachments in: {0}/error_attachments".format(
path_to_msg)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
ats = os.listdir("{0}/error_attachments".format(path_to_msg))
logmsg = "got the following attachments: {0}".format(ats)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
for next_attachment in ats:
reply_attachments.append(
"{0}/error_attachments/{1}".format(
path_to_msg, next_attachment))
except:
logmsg = "no attachments for failed task."
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
msg = self.assemble_email(msg, message_text, reply_attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "SecAlert":
#################
# SEC ALERT #
#################
admin_mails = self.get_admin_emails()
for admin_mail in admin_mails:
msg['To'] = admin_mail
path_to_msg = "users/" + user_id + "/Task" + task_nr + "/error_msg"
error_msg = self.read_text_file(path_to_msg)
msg['Subject'] = "Security Alert User:"******"Error report:\n\n" "" + error_msg
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(admin_mail, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "TaskAlert":
#################
# TASK ALERT #
#################
admin_mails = self.get_admin_emails()
for admin_mail in admin_mails:
msg['To'] = admin_mail
msg['Subject'] = "Task Error Alert Task " \
+ task_nr + " User " + user_id
message_text = "Something went wrong with task/testbench analyzation for Task " + task_nr + " and User " + user_id + " . Either the entity or testbench analyzation threw an error."
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(admin_mail, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "Success":
#################
# SUCCESS #
#################
msg['Subject'] = "Task " + task_nr + " submitted successfully"
message_text = "Congratulations!"
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
#set first done if not set yet
self.check_and_set_first_successful(user_id, task_nr)
# last done had to be set now? --> Send Congrats
if self.check_and_set_last_done(user_id):
#new message, prepare it
msg = MIMEMultipart()
msg['From'] = self.smtp_mail
msg['To'] = recipient
logmsg = "RECIPIENT: " + recipient
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
msg['Date'] = formatdate(localtime=True)
message_text = self.read_specialmessage('CONGRATS')
msg['Subject'] = "Congratulations on solving all Tasks!"
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), "LastSolved")
self.backup_message(messageid)
elif message_type == "Status":
#################
# STATUS #
#################
msg['Subject'] = "Your Current Status"
message_text = self.generate_status_update(user_id, recipient, \
task_nr)
numtasks = c.get_num_tasks(self.coursedb, self.logger_queue, \
self.name)
if int(numtasks) >= int(task_nr):
#also attach current task
data = {'task_nr': str(task_nr), 'user_id': user_id}
sql_cmd = "SELECT TaskAttachments FROM UserTasks WHERE TaskNr == :task_nr AND UserId == :user_id;"
curs.execute(sql_cmd, data)
res = curs.fetchone()
logmsg = "got the following attachments: " + str(res)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
if res:
attachments = str(res[0]).split()
msg = self.assemble_email(msg, message_text, attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
else:
msg = self.assemble_email(msg, message_text, attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "InvalidTask":
#################
# INVALID TASK #
#################
msg['Subject'] = "Invalid Task Number"
message_text = self.read_specialmessage('INVALID')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "SkipNotPossible":
######################
# SKIP NOT POSSIBLE #
######################
msg['Subject'] = "Requested Skip not possible"
message_text = self.read_specialmessage('SKIPNOTPOSSIBLE')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "TaskNotSubmittable":
#########################
# TASK NOT SUBMITTABLE #
#########################
msg['Subject'] = "Submission for this task not possible"
message_text = self.read_specialmessage('TASKNOTSUBMITTABLE')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "CurLast":
#################
# CUR LAST #
#################
# we still need to increment the users task counter!
c.user_set_current_task(self.semesterdb, task_nr, user_id, \
self.logger_queue, self.name)
msg['Subject'] = "Task{0} is not available yet".format(
str(task_nr))
message_text = self.read_specialmessage('CURLAST')
message_text = "{0}\n\nThe Task is currently scheduled for: {1}".format(message_text, \
c.get_task_starttime(self.coursedb, str(task_nr), \
self.logger_queue, self.name))
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "DeadTask":
#################
# DEAD TASK #
#################
msg['Subject'] = "Deadline for Task{0} has passed.".format(
str(task_nr))
message_text = self.read_specialmessage('DEADTASK')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "Usage":
#################
# USAGE #
#################
msg['Subject'] = "Usage"
message_text = self.read_specialmessage('USAGE')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "Question":
#################
# QUESTION #
#################
msg['Subject'] = "Question received"
message_text = self.read_specialmessage('QUESTION')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "QFwd":
#################
# QFWD #
#################
orig_mail = next_send_msg.get('Body')
msg['Subject'] = "Question from " + orig_mail['from']
if orig_mail.get_content_maintype() == 'multipart':
part = orig_mail.get_payload(0)
mbody = part.get_payload()
message_text = "Original subject: " + orig_mail[
'subject'] + "\n\nNote: This e-mail contained attachments which have been removed!\n"
message_text = "{0}\n\nOriginal body:\n{1}".format(
message_text, mbody)
else:
mbody = orig_mail.get_payload()
message_text = "Original subject: " + orig_mail['subject'] + \
"\n\nOriginal body:\n" + str(mbody)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "Welcome":
#################
# WELCOME #
#################
msg['Subject'] = "Welcome!"
message_text = self.read_specialmessage('WELCOME')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "RegOver":
#################
# REGOVER #
#################
msg['Subject'] = "Registration Deadline has passed"
message_text = self.read_specialmessage('REGOVER')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "NotAllowed":
#################
# NOT ALLOWED #
#################
msg['Subject'] = "Registration Not Successful."
message_text = self.read_specialmessage('NOTALLOWED')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
else:
#################
# UNKNOWN #
#################
c.log_a_msg(self.logger_queue, self.name, \
"Unkown Message Type in the sender_queue!", "ERROR")
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
cons.close()
conc.close()
def handle_next_mail(self):
"""
parse the subject/content of a mail and take appropriate action.
"""
#blocking wait on sender_queue
next_send_msg = self.sender_queue.get(True)
tasknr = str(next_send_msg.get('Task'))
messageid = str(next_send_msg.get('MessageId'))
uid = str(next_send_msg.get('UserId'))
recipient = str(next_send_msg.get('recipient'))
message_type = str(next_send_msg.get('message_type'))
curs, cons = c.connect_to_db(self.semesterdb, self.logger_queue, \
self.name)
curc, conc = c.connect_to_db(self.coursedb, self.logger_queue, \
self.name)
attachments = []
# prepare fields for the e-mail
msg = MIMEMultipart()
msg['From'] = self.mail_user
msg['To'] = recipient
logmsg = "RECIPIENT: " + recipient
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
msg['Date'] = formatdate(localtime=True)
if message_type == "Task":
logmsg = "Task in send_queue: " + str(next_send_msg)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
numtasks = c.get_num_tasks(self.coursedb, \
self.logger_queue, self.name)
ctasknr = c.user_get_current_task(self.semesterdb, uid, \
self.logger_queue, self.name)
if numtasks+1 == int(tasknr): # last task solved!
msg['Subject'] = "Congratulations!"
message_text = self.read_specialmessage('CONGRATS')
if int(tasknr)-1 == int(ctasknr):
# statistics shall only be udated on the first
# successful submission
c.user_set_current_task(self.semesterdb, tasknr, uid, \
self.logger_queue, self.name)
self.increment_db_taskcounter(curs, cons, 'NrSuccessful', \
str(int(tasknr)-1))
self.increment_db_taskcounter(curs, cons, 'NrSubmissions', \
str(int(tasknr)-1))
self.check_and_set_last_done(curs, cons, uid)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
else: # at least one more task to do: send out the description
# only send the task description, after the first
# successful submission
if int(tasknr)-1 <= int(ctasknr) or int(ctasknr) == 1:
msg['Subject'] = "Description Task" + str(tasknr)
dl_text = "\nDeadline for this Task: {0}\n".format(c.get_task_deadline(self.coursedb, tasknr, self.logger_queue, self.name))
data = {'tasknr': str(tasknr)}
sql_cmd = "SELECT PathToTask FROM TaskConfiguration WHERE TaskNr == :tasknr;"
curc.execute(sql_cmd, data)
paths = curc.fetchone()
if not paths:
logmsg = "It seems, the Path to Task {0} is not configured.".format(tasknr)
c.log_a_msg(self.logger_queue, self.name, \
logmsg, "WARNING")
message_text = "Sorry, but something went wrong... probably misconfiguration or missing configuration of Task {0}".format(tasknr)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), \
message_type)
else:
path_to_task = str(paths[0])
path_to_msg = path_to_task + "/description.txt"
message_text = self.read_text_file(path_to_msg) \
+ dl_text
data = {'tasknr': str(tasknr), 'uid': uid}
sql_cmd = "SELECT TaskAttachments FROM UserTasks WHERE TaskNr == :tasknr AND UserId == :uid;"
curs.execute(sql_cmd, data)
res = curs.fetchone()
logmsg = "got the following attachments: " + str(res)
c.log_a_msg(self.logger_queue, self.name, logmsg, \
"DEBUG")
if res:
attachments = str(res[0]).split()
# statistics shall only be udated on the first
# succesful submission
c.user_set_current_task(self.semesterdb, tasknr, uid, \
self.logger_queue, self.name)
self.increment_db_taskcounter(curs, cons, \
'NrSuccessful', \
str(int(tasknr)-1))
self.increment_db_taskcounter(curs, cons, \
'NrSubmissions', \
str(int(tasknr)-1))
msg = self.assemble_email(msg, message_text, \
attachments)
self.send_out_email(recipient, msg.as_string(), \
message_type)
self.backup_message(messageid)
elif message_type == "Failed":
self.increment_db_taskcounter(curs, cons, 'NrSubmissions', tasknr)
path_to_msg = "users/{0}/Task{1}".format(uid, tasknr)
error_msg = self.read_text_file("{0}/error_msg".format(path_to_msg))
msg['Subject'] = "Task" + tasknr + ": submission rejected"
message_text = "Error report:\n\n""" + error_msg
reply_attachments = []
try:
logmsg = "searching attachments in: {0}/error_attachments".format(path_to_msg)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
ats = os.listdir("{0}/error_attachments".format(path_to_msg))
logmsg = "got the following attachments: {0}".format(ats)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
for next_attachment in ats:
reply_attachments.append("{0}/error_attachments/{1}".format(path_to_msg, next_attachment))
except:
logmsg = "no attachments for failed task."
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
msg = self.assemble_email(msg, message_text, reply_attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "SecAlert":
admin_mails = self.get_admin_emails()
for admin_mail in admin_mails:
msg['To'] = admin_mail
path_to_msg = "users/"+ uid + "/Task" + tasknr + "/error_msg"
error_msg = self.read_text_file(path_to_msg)
msg['Subject'] = "Autosub Security Alert User:"******"Error report:\n\n""" + error_msg
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(admin_mail, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "TaskAlert":
admin_mails = self.get_admin_emails()
for admin_mail in admin_mails:
msg['To'] = admin_mail
msg['Subject'] = "Autosub Task Error Alert Task " \
+ tasknr + " User " + uid
message_text = "Something went wrong with task/testbench analyzation for Task " + tasknr +" and User " + uid + " . Either the entity or testbench analyzation threw an error."
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(admin_mail, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "Success":
msg['Subject'] = "Task " + tasknr + " submitted successfully"
message_text = "Congratulations!"
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
#set first done if not set yet
self.check_and_set_first_successful(curs, cons, uid, tasknr)
# no backup of message -- this is done after the new task
# description was sent to the user!
elif message_type == "Status":
msg['Subject'] = "Your Current Status"
message_text = self.generate_status_update(curs, recipient)
numtasks = c.get_num_tasks(self.coursedb, self.logger_queue, \
self.name)
if int(numtasks) >= int(tasknr):
#also attach current task
data = {'tasknr': str(tasknr), 'uid': uid}
sql_cmd = "SELECT TaskAttachments FROM UserTasks WHERE TaskNr == :tasknr AND UserId == :uid;"
curs.execute(sql_cmd, data)
res = curs.fetchone()
logmsg = "got the following attachments: " + str(res)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
if res:
attachments = str(res[0]).split()
msg = self.assemble_email(msg, message_text, attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
else:
msg = self.assemble_email(msg, message_text, attachments)
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
elif message_type == "InvalidTask":
msg['Subject'] = "Invalid Task Number"
message_text = self.read_specialmessage('INVALID')
self.backup_message(messageid)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
elif message_type == "CurLast":
# we still need to increment the users task counter!
c.user_set_current_task(self.semesterdb, tasknr, uid, \
self.logger_queue, self.name)
msg['Subject'] = "Task{0} is not available yet".format(str(tasknr))
message_text = self.read_specialmessage('CURLAST')
message_text = "{0}\n\nThe Task is currently scheduled for: {1}".format(message_text, \
c.get_task_starttime(self.coursedb, str(tasknr), \
self.logger_queue, self.name))
self.backup_message(messageid)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
elif message_type == "DeadTask":
msg['Subject'] = "Deadline for Task{0} has passed.".format(str(tasknr))
message_text = self.read_specialmessage('DEADTASK')
self.backup_message(messageid)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
elif message_type == "Usage":
msg['Subject'] = "Autosub Usage"
message_text = self.read_specialmessage('USAGE')
self.backup_message(messageid)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
elif message_type == "Question":
msg['Subject'] = "Question received"
message_text = self.read_specialmessage('QUESTION')
self.backup_message(messageid)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
elif message_type == "QFwd":
orig_mail = next_send_msg.get('Body')
msg['Subject'] = "Question from " + orig_mail['from']
if orig_mail.get_content_maintype() == 'multipart':
part = orig_mail.get_payload(0)
mbody = part.get_payload()
message_text = "Original subject: " + orig_mail['subject'] + "\n\nNote: This e-mail contained attachments which have been removed!\n"
message_text = "{0}\n\nOriginal body:\n{1}".format(message_text, mbody)
else:
mbody = orig_mail.get_payload()
message_text = "Original subject: " + orig_mail['subject'] + \
"\n\nOriginal body:\n" + str(mbody)
self.backup_message(messageid)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
elif message_type == "Welcome":
msg['Subject'] = "Welcome!"
message_text = self.read_specialmessage('WELCOME')
self.backup_message(messageid)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
elif message_type == "RegOver":
msg['Subject'] = "Registration Deadline has passed"
message_text = self.read_specialmessage('REGOVER')
self.backup_message(messageid)
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
elif message_type == "NotAllowed":
msg['Subject'] = "Registration Not Successful."
message_text = self.read_specialmessage('NOTALLOWED')
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
else:
c.log_a_msg(self.logger_queue, self.name, \
"Unkown Message Type in the sender_queue!", "ERROR")
msg = self.assemble_email(msg, message_text, '')
self.send_out_email(recipient, msg.as_string(), message_type)
self.backup_message(messageid)
cons.close()
conc.close()
def add_new_user(self, user_name, user_email):
"""
Add the necessary entries to database for a newly registered user.
Call generator thread to create the first task.
"""
curs, cons = c.connect_to_db(self.dbs["semester"],
self.queues["logger"], self.name)
logmsg = 'Creating new Account: User: %s' % user_name
c.log_a_msg(self.queues["logger"], self.name, logmsg, "INFO")
data = {
'Name': user_name,
'Email': user_email,
'TimeNow': str(int(time.time()))
}
sql_cmd = (
"INSERT INTO Users "
"(UserId, Name, Email, RegisteredAt, LastDone, CurrentTask) "
"VALUES(NULL, :Name, :Email, datetime(:TimeNow, 'unixepoch', 'localtime')"
", NULL, 1)")
curs.execute(sql_cmd, data)
cons.commit()
# read back the new users UserId and create a directory for putting his
# submissions in.
data = {'Email': user_email}
sql_cmd = "SELECT UserId FROM Users WHERE Email = :Email"
curs.execute(sql_cmd, data)
res = curs.fetchone()
if res is None:
logmsg = ("Created new user with "
"name= {0} , email={1} failed").format(
user_name, user_email)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
return
user_id = str(res[0])
dir_name = 'users/' + user_id
c.check_dir_mkdir(dir_name, self.queues["logger"], self.name)
cons.close()
# in allow_requests mode the user gets no first task send
if self.allow_requests != "no":
return
# Give the user the task which is starttime <= now < deadline AND
# min(TaskNr) as initial task
curc, conc = c.connect_to_db(self.dbs["course"], self.queues["logger"],
self.name)
data = {'TimeNow': str(int(time.time()))}
sql_cmd = (
"SELECT MIN(TaskNr) FROM TaskConfiguration "
"WHERE TaskStart <= datetime(:TimeNow, 'unixepoch','localtime') AND "
"TaskDeadline > datetime(:TimeNow, 'unixepoch', 'localtime')")
curc.execute(sql_cmd, data)
res = curc.fetchone()
conc.close()
if not res or not res[0]:
logmsg = (
"Error generating initial Task for UserId = {0}. Could not "
"find a initial task for this user").format(user_id)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "ERROR")
return
task_nr = int(res[0])
#adjust users CurrentTask if he does not get Task with task_nr=1
if task_nr != 1:
c.user_set_current_task(self.dbs["semester"], task_nr, user_id, \
self.queues["logger"], self.name)
logmsg = ("Calling Generator to create"
"TaskNr:{0} for UserId:{1}").format(task_nr, user_id)
c.log_a_msg(self.queues["logger"], self.name, logmsg, "DEBUG")
c.generate_task(self.queues["generator"], user_id, task_nr, user_email,
"")
def add_new_user(self, user_name, user_email):
"""
Add the necessary entries to database for a newly registered user.
Call generator thread to create the first task.
"""
curs, cons = c.connect_to_db(self.semesterdb, self.logger_queue,
self.name)
logmsg = 'Creating new Account: User: %s' % user_name
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
data = {
'Name': user_name,
'Email': user_email,
'TimeNow': str(int(time.time()))
}
sql_cmd = (
"INSERT INTO Users "
"(UserId, Name, Email, FirstMail, LastDone, CurrentTask) "
"VALUES(NULL, :Name, :Email, datetime(:TimeNow, 'unixepoch', 'localtime')"
", NULL, 1)")
curs.execute(sql_cmd, data)
cons.commit()
# the new user has now been added to the database. Next we need
# to send him an email with the first task.
# read back the new users UserId and create a directory for putting his
# submissions in.
data = {'Email': user_email}
sql_cmd = "SELECT UserId FROM Users WHERE Email = :Email"
curs.execute(sql_cmd, data)
res = curs.fetchone()
if res == None:
logmsg = ("Created new user with "
"name= {0} , email={1} failed").format(
user_name, user_email)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
user_id = str(res[0])
dir_name = 'users/' + user_id
c.check_dir_mkdir(dir_name, self.logger_queue, self.name)
cons.close()
# Give the user the task which is starttime <= now < deadline AND
# min(TaskNr)
curc, conc = c.connect_to_db(self.coursedb, self.logger_queue,
self.name)
data = {'TimeNow': str(int(time.time()))}
sql_cmd = (
"SELECT MIN(TaskNr) FROM TaskConfiguration "
"WHERE TaskStart <= datetime(:TimeNow, 'unixepoch','localtime') AND "
"TaskDeadline > datetime(:TimeNow, 'unixepoch', 'localtime')")
curc.execute(sql_cmd, data)
res = curc.fetchone()
conc.close()
if res == None:
logmsg = (
"Error generating first Task for UserId = {0}. Could not "
"find first task for this user").format(user_id)
c.log_a_msg(self.logger_queue, self.name, logmsg, "ERROR")
else:
task_nr = int(res[0])
#adjust users CurrentTask if he does not get Task with task_nr=1
if task_nr != 1:
c.user_set_current_task(self.semesterdb, task_nr, user_id, \
self.logger_queue, self.name)
logmsg = ("Calling Generator to create"
"TaskNr:{0} for UserId:{1}").format(task_nr, user_id)
c.log_a_msg(self.logger_queue, self.name, logmsg, "DEBUG")
self.gen_queue.put(dict({"user_id": user_id, "user_email": user_email, \
"task_nr": task_nr, "messageid": ""}))