def __init__(self, input_str=None):
"""
Initializes the json string that should be turn into a local entity
"""
self.log = LoggerManager().get_new_logger(
"auto correction-json translator")
self.json = input_str
class JSONToAutoCorrectionTranslator():
"""
This class' responsability is limited to generate automatic correction entities out of the json strings recieved from the rest api
"""
def __init__(self, input_str=None):
"""
Initializes the json string that should be turn into a local entity
"""
self.log = LoggerManager().get_new_logger(
"auto correction-json translator")
self.json = input_str
def get_automatic_corrections(self):
self.log.debug("parsing: %s", self.json)
automatic_correction_data_list = json.loads(self.json)['results']
automatic_correction_list = []
for automatic_correction_data in automatic_correction_data_list:
automatic_correction = AutomaticCorrection(
automatic_correction_data['id'])
automatic_correction.captured_stdout = automatic_correction_data[
'captured_stdout']
automatic_correction.exit_value = automatic_correction_data[
'exit_value']
automatic_correction.status = automatic_correction_data['status']
automatic_correction.delivery_id = automatic_correction_data[
'delivery']
automatic_correction.delivery = automatic_correction_data[
'get_delivery_file']
automatic_correction.script = automatic_correction_data[
'get_correction_script']
automatic_correction.user_mail = automatic_correction_data[
'user_mail']
automatic_correction_list.append(automatic_correction)
return automatic_correction_list
def run(self):
self.log = LoggerManager().get_new_logger("daemon control")
self.log.info("Daemon's game loop started.")
while True:
start_timestamp = datetime.today()
try:
result = self.automatic_correction_runner.run()
self.log.info(
"Automatic correction process completed.\nResult summary: \n\tsuccessfull: %d\n\tfailed: %d",
result[AutomaticCorrectionRunner.SUCCESSFULL_RESULTS_KEY],
result[AutomaticCorrectionRunner.FAILED_RESULTS_KEY])
except:
self.log.exception(
"The automatic correction process failed. Have in mind that is required that the web service must be online."
)
try:
self.administrator_mail.send_mails()
except:
self.log.exception(
"The mail sending process failed. Have in mind that is required that the web service must be online."
)
finish_timestamp = datetime.today()
self.stall_loop(start_timestamp, finish_timestamp)
class JSONToAutoCorrectionTranslator():
"""
This class' responsability is limited to generate automatic correction entities out of the json strings recieved from the rest api
"""
def __init__(self, input_str=None):
"""
Initializes the json string that should be turn into a local entity
"""
self.log = LoggerManager().get_new_logger("auto correction-json translator")
self.json = input_str
def get_automatic_corrections(self):
self.log.debug("parsing: %s", self.json)
automatic_correction_data_list = json.loads(self.json)['results']
automatic_correction_list = []
for automatic_correction_data in automatic_correction_data_list:
automatic_correction = AutomaticCorrection(automatic_correction_data['id'])
automatic_correction.captured_stdout = automatic_correction_data['captured_stdout']
automatic_correction.exit_value = automatic_correction_data['exit_value']
automatic_correction.status = automatic_correction_data['status']
automatic_correction.delivery_id = automatic_correction_data['delivery']
automatic_correction.delivery = automatic_correction_data['get_delivery_file']
automatic_correction.script = automatic_correction_data['get_correction_script']
automatic_correction.user_mail = automatic_correction_data['user_mail']
automatic_correction_list.append(automatic_correction);
return automatic_correction_list
def __init__(self, json_str=None):
"""
Constructor
"""
self.json = json_str
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("json translator")
class AutomaticCorrectionSelectionStrategyThroughRestApi(
AutomaticCorrectionSelectionStrategy):
"""
Implementation of the selection strategy that brings the automatic correction information from the rest api
"""
HTTP_AUTOMATIC_CORRECTION_SERIALIZER = REST_BASE_URL + '/richautomaticcorrectionserializer/'
def __init__(self, auth_user, auth_pass):
"""
Constructor
"""
self.log = LoggerManager().get_new_logger("auto correction selection")
self.rest_api_helper = RestApiHelper(
auth_user, auth_pass,
AutomaticCorrectionSelectionStrategyThroughRestApi.
HTTP_AUTOMATIC_CORRECTION_SERIALIZER)
def get_automatic_corrections(self):
self.log.debug("searching for deliveries with status pending...")
pending_automatic_corrections = self.rest_api_helper.get_automatic_corrections(
)
count = len(pending_automatic_corrections)
if count > 0:
self.log.debug("%d deliveries obtained.", count)
return pending_automatic_corrections
def __init__(self, json_str=None):
"""
Constructor
"""
self.json = json_str
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("json translator")
def __init__(self, auth_user, auth_pass):
self.log = LoggerManager().get_new_logger("result publication mail")
self.rest_api_helper = RestApiHelper(
auth_user,
auth_pass,
http_mail_serializer=PublishResultsVisitorMail.HTTP_MAIL_SERIALIZER
)
def __init__(self, auth_user, auth_pass):
"""
Constructor
"""
self.log = LoggerManager().get_new_logger("auto correction selection")
self.rest_api_helper = RestApiHelper(
auth_user, auth_pass,
AutomaticCorrectionSelectionStrategyThroughRestApi.
HTTP_AUTOMATIC_CORRECTION_SERIALIZER)
def __init__(self):
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("administrator mail")
self.mail_handle_strategy = MailHandleRESTAPIStrategy(
http_serializer=HTTP_SERIALIZER,
auth_user=settings.SERIALIZER_AUTH_USER,
auth_pass=settings.SERIALIZER_AUTH_PASS)
self.session_helper = MailSessionHelper(email_host=settings.EMAIL_HOST,
email_port=settings.EMAIL_PORT,
email_host_user=settings.EMAIL_HOST_USER,
email_host_password=settings.EMAIL_HOST_PASSWORD)
def __init__(self):
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("loop runner")
self.loop_interval = LoopRunner.LOOP_INTERVAL # in seconds
self.stdin_path = '/dev/null'
self.stdout_path = '/dev/tty'
self.stderr_path = '/dev/tty'
self.pidfile_path = '/tmp/foo.pid'
self.pidfile_timeout = 5
self.automatic_correction_runner = AutomaticCorrectionRunner()
self.administrator_mail = AdministratorMail()
def __init__(self):
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("loop runner")
self.loop_interval = LoopRunner.LOOP_INTERVAL # in seconds
self.stdin_path = '/dev/null'
self.stdout_path = '/dev/tty'
self.stderr_path = '/dev/tty'
self.pidfile_path = '/tmp/foo.pid'
self.pidfile_timeout = 5
self.automatic_correction_runner = AutomaticCorrectionRunner()
self.administrator_mail = AdministratorMail()
def __init__(self, http_serializer=None, auth_user=None, auth_pass=None):
"""
Constructor
"""
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("administrator mail")
self.http_serializer = http_serializer
self.auth_user = auth_user
self.auth_pass = auth_pass
self.json_translator = JSONToMailTranslator()
self.requests = requests
def __init__(self, http_serializer=None, auth_user=None, auth_pass=None):
"""
Constructor
"""
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("administrator mail")
self.http_serializer = http_serializer
self.auth_user = auth_user
self.auth_pass = auth_pass
self.json_translator = JSONToMailTranslator()
self.requests = requests
def __init__(self):
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("administrator mail")
self.mail_handle_strategy = MailHandleRESTAPIStrategy(
http_serializer=HTTP_SERIALIZER,
auth_user=settings.SERIALIZER_AUTH_USER,
auth_pass=settings.SERIALIZER_AUTH_PASS)
self.session_helper = MailSessionHelper(
email_host=settings.EMAIL_HOST,
email_port=settings.EMAIL_PORT,
email_host_user=settings.EMAIL_HOST_USER,
email_host_password=settings.EMAIL_HOST_PASSWORD)
def __init__(self, auth_user, auth_pass):
"""
Constructor
"""
self.log = LoggerManager().get_new_logger("auto correction selection")
self.rest_api_helper = RestApiHelper(auth_user, auth_pass,
AutomaticCorrectionSelectionStrategyThroughRestApi.HTTP_AUTOMATIC_CORRECTION_SERIALIZER)
class LoopRunner():
LOOP_INTERVAL = 65
def __init__(self):
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("loop runner")
self.loop_interval = LoopRunner.LOOP_INTERVAL # in seconds
self.stdin_path = '/dev/null'
self.stdout_path = '/dev/tty'
self.stderr_path = '/dev/tty'
self.pidfile_path = '/tmp/foo.pid'
self.pidfile_timeout = 5
self.automatic_correction_runner = AutomaticCorrectionRunner()
self.administrator_mail = AdministratorMail()
def stall_loop(self, start_timestamp, finish_timestamp):
delta = finish_timestamp - start_timestamp
time_to_wait = self.loop_interval - delta.seconds # if the process took less than 30 seconds, we will wait
if (time_to_wait > 0):
time.sleep(time_to_wait)
else:
print("not sleeping... delta: " + str(delta))
start_timestamp = datetime.today()
def print_result(self, result):
# TODO: pass to a log entry
print str(datetime.today()) + " | " + str(result)
def run(self):
self.log = LoggerManager().get_new_logger("daemon control")
self.log.info("Daemon's game loop started.")
while True:
start_timestamp = datetime.today()
try:
result = self.automatic_correction_runner.run()
self.log.info(
"Automatic correction process completed.\nResult summary: \n\tsuccessfull: %d\n\tfailed: %d",
result[AutomaticCorrectionRunner.SUCCESSFULL_RESULTS_KEY],
result[AutomaticCorrectionRunner.FAILED_RESULTS_KEY])
except:
self.log.exception(
"The automatic correction process failed. Have in mind that is required that the web service must be online."
)
try:
self.administrator_mail.send_mails()
except:
self.log.exception(
"The mail sending process failed. Have in mind that is required that the web service must be online."
)
finish_timestamp = datetime.today()
self.stall_loop(start_timestamp, finish_timestamp)
class PublishResultsVisitorWeb(PublishResultsVisitor):
"""
This is the visitor in charge of publishing the results to the web.
"""
HTTP_MAIL_SERIALIZER = REST_BASE_URL + '/automaticcorrectionserializer/'
def __init__(self, auth_user, auth_pass):
self.log = LoggerManager().get_new_logger("result publication")
self.rest_api_helper = RestApiHelper(auth_user, auth_pass, PublishResultsVisitorWeb.HTTP_MAIL_SERIALIZER)
def visit(self, visitable):
self.log.debug("publishing results...")
visitable.automatic_correction.exit_value = visitable.exit_value
visitable.automatic_correction.captured_stdout = visitable.captured_stdout
visitable.automatic_correction.status = 1 + (-2 * visitable.exit_value)
self.rest_api_helper.save_automatic_correction(visitable.automatic_correction)
self.log.debug("results published in through the web interface.")
def __init__(self, auth_user, auth_pass,
http_automatic_correction_serializer=None,
http_delivery_serializer=None,
http_practice_serializer=None,
http_script_serializer=None,
http_mail_serializer=None):
"""
Constructor
"""
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("auto-correction-strategy")
self.http_automatic_correction_serializer = http_automatic_correction_serializer
self.http_delivery_serializer = http_delivery_serializer
self.http_practice_serializer = http_practice_serializer
self.http_script_serializer = http_script_serializer
self.http_mail_serializer = http_mail_serializer
self.auth_user = auth_user
self.auth_pass = auth_pass
self.requests = requests
self.json_translator = JSONToAutoCorrectionTranslator()
class LoopRunner():
LOOP_INTERVAL = 65
def __init__(self):
logger_manager = LoggerManager()
self.log = logger_manager.get_new_logger("loop runner")
self.loop_interval = LoopRunner.LOOP_INTERVAL # in seconds
self.stdin_path = '/dev/null'
self.stdout_path = '/dev/tty'
self.stderr_path = '/dev/tty'
self.pidfile_path = '/tmp/foo.pid'
self.pidfile_timeout = 5
self.automatic_correction_runner = AutomaticCorrectionRunner()
self.administrator_mail = AdministratorMail()
def stall_loop(self, start_timestamp, finish_timestamp):
delta = finish_timestamp - start_timestamp
time_to_wait = self.loop_interval - delta.seconds # if the process took less than 30 seconds, we will wait
if (time_to_wait > 0):
time.sleep(time_to_wait)
else:
print("not sleeping... delta: " + str(delta))
start_timestamp = datetime.today()
def print_result(self, result):
# TODO: pass to a log entry
print str(datetime.today()) + " | " + str(result)
def run(self):
self.log = LoggerManager().get_new_logger("daemon control")
self.log.info("Daemon's game loop started.")
while True:
start_timestamp = datetime.today()
try:
result = self.automatic_correction_runner.run()
self.log.info("Automatic correction process completed.\nResult summary: \n\tsuccessfull: %d\n\tfailed: %d",
result[AutomaticCorrectionRunner.SUCCESSFULL_RESULTS_KEY],
result[AutomaticCorrectionRunner.FAILED_RESULTS_KEY])
except:
self.log.exception("The automatic correction process failed. Have in mind that is required that the web service must be online.")
try:
self.administrator_mail.send_mails()
except:
self.log.exception("The mail sending process failed. Have in mind that is required that the web service must be online.")
finish_timestamp = datetime.today()
self.stall_loop(start_timestamp, finish_timestamp)
class AutomaticCorrectionSelectionStrategyThroughRestApi(AutomaticCorrectionSelectionStrategy):
"""
Implementation of the selection strategy that brings the automatic correction information from the rest api
"""
HTTP_AUTOMATIC_CORRECTION_SERIALIZER = REST_BASE_URL + '/richautomaticcorrectionserializer/'
def __init__(self, auth_user, auth_pass):
"""
Constructor
"""
self.log = LoggerManager().get_new_logger("auto correction selection")
self.rest_api_helper = RestApiHelper(auth_user, auth_pass,
AutomaticCorrectionSelectionStrategyThroughRestApi.HTTP_AUTOMATIC_CORRECTION_SERIALIZER)
def get_automatic_corrections(self):
self.log.debug("searching for deliveries with status pending...")
pending_automatic_corrections = self.rest_api_helper.get_automatic_corrections()
count = len(pending_automatic_corrections)
if count > 0:
self.log.debug("%d deliveries obtained.", count)
return pending_automatic_corrections
class PublishResultsVisitorMail(PublishResultsVisitor):
"""
Implementation of the publishing visitor which posts a mail through the web interface to await sending
"""
HTTP_MAIL_SERIALIZER = REST_BASE_URL + '/mailserializer/'
STATUS_STRINGS = {-1: "failed", 0: "pending", 1: "successfull"}
STATUS_UNKNOWN = 'unknown status'
def __init__(self, auth_user, auth_pass):
self.log = LoggerManager().get_new_logger("result publication mail")
self.rest_api_helper = RestApiHelper(
auth_user,
auth_pass,
http_mail_serializer=PublishResultsVisitorMail.HTTP_MAIL_SERIALIZER
)
def get_status(self, status=10):
"""Returns a status raw value as a human readable value"""
self.log.debug("translating status %d", status)
try:
status_string = PublishResultsVisitorMail.STATUS_STRINGS[status]
except:
status_string = PublishResultsVisitorMail.STATUS_UNKNOWN
return status_string
def build_mail(self, result):
self.log.debug("building mail...")
mail = Mail()
mail.subject = "Resultado de la correccion automatica"
mail.recipient = result.automatic_correction.user_mail
exit_value = result.exit_value
mail.body = "Ejecucion "
if (exit_value == 0):
mail.body += "exitosa, trabajo aprobado"
else:
mail.body += "fallida, trabajo no aprobado. Puede corregirlo y volver a intentarlo"
mail.body += ".\n\n"
return mail
def visit(self, visitable):
self.log.debug("publishing results...")
visitable.automatic_correction.exit_value = visitable.exit_value
visitable.automatic_correction.captured_stdout = visitable.captured_stdout
visitable.automatic_correction.status = 1 + (-2 * visitable.exit_value)
mail = self.build_mail(visitable)
self.rest_api_helper.save_mail(mail)
self.log.debug("results published in through mail.")
class PublishResultsVisitorWeb(PublishResultsVisitor):
"""
This is the visitor in charge of publishing the results to the web.
"""
HTTP_MAIL_SERIALIZER = REST_BASE_URL + '/automaticcorrectionserializer/'
def __init__(self, auth_user, auth_pass):
self.log = LoggerManager().get_new_logger("result publication")
self.rest_api_helper = RestApiHelper(
auth_user, auth_pass,
PublishResultsVisitorWeb.HTTP_MAIL_SERIALIZER)
def visit(self, visitable):
self.log.debug("publishing results...")
visitable.automatic_correction.exit_value = visitable.exit_value
visitable.automatic_correction.captured_stdout = visitable.captured_stdout
visitable.automatic_correction.status = 1 + (-2 * visitable.exit_value)
self.rest_api_helper.save_automatic_correction(
visitable.automatic_correction)
self.log.debug("results published in through the web interface.")
class PublishResultsVisitorMail(PublishResultsVisitor):
"""
Implementation of the publishing visitor which posts a mail through the web interface to await sending
"""
HTTP_MAIL_SERIALIZER = REST_BASE_URL + '/mailserializer/'
STATUS_STRINGS = {-1:"failed", 0:"pending", 1:"successfull"}
STATUS_UNKNOWN = 'unknown status'
def __init__(self, auth_user, auth_pass):
self.log = LoggerManager().get_new_logger("result publication mail")
self.rest_api_helper = RestApiHelper(auth_user, auth_pass,
http_mail_serializer=PublishResultsVisitorMail.HTTP_MAIL_SERIALIZER)
def get_status(self, status=10):
"""Returns a status raw value as a human readable value"""
self.log.debug("translating status %d", status)
try:
status_string = PublishResultsVisitorMail.STATUS_STRINGS[status]
except:
status_string = PublishResultsVisitorMail.STATUS_UNKNOWN
return status_string
def build_mail(self, result):
self.log.debug("building mail...")
mail = Mail()
mail.subject = "Resultado de la correccion automatica"
mail.recipient = result.automatic_correction.user_mail
exit_value = result.exit_value
mail.body = "Ejecucion "
if(exit_value==0):
mail.body += "exitosa, trabajo aprobado"
else:
mail.body += "fallida, trabajo no aprobado. Puede corregirlo y volver a intentarlo"
mail.body += ".\n\n"
return mail
def visit(self, visitable):
self.log.debug("publishing results...")
visitable.automatic_correction.exit_value = visitable.exit_value
visitable.automatic_correction.captured_stdout = visitable.captured_stdout
visitable.automatic_correction.status = 1 + (-2 * visitable.exit_value)
mail = self.build_mail(visitable)
self.rest_api_helper.save_mail(mail)
self.log.debug("results published in through mail.")
class SetupEnviroment():
def __init__(self):
self.prepare_files_strategy = PrepareFilesStrategyZip()
self.log = LoggerManager().get_new_logger("setup enviroment")
def run(self, automatic_correction, working_dir):
self.log.debug("setting up enviroment...")
self.log.debug("cleaning up working directory...")
shutil.rmtree(working_dir, ignore_errors=True)
self.log.debug("preparing delivery files...")
self.prepare_files_strategy.zip = automatic_correction.delivery
os.mkdir(working_dir)
self.prepare_files_strategy.prepare_files(working_dir)
shutil.copy(automatic_correction.script, working_dir + "/" + os.path.basename(automatic_correction.script))
# We must ensure the script is runnable
process = subprocess.Popen(["chmod", "a+x", working_dir + "/" + os.path.basename(automatic_correction.script)])
process.wait()
self.log.debug("enviroment set.")
def run(self):
self.log = LoggerManager().get_new_logger("daemon control")
self.log.info("Daemon's game loop started.")
while True:
start_timestamp = datetime.today()
try:
result = self.automatic_correction_runner.run()
self.log.info("Automatic correction process completed.\nResult summary: \n\tsuccessfull: %d\n\tfailed: %d",
result[AutomaticCorrectionRunner.SUCCESSFULL_RESULTS_KEY],
result[AutomaticCorrectionRunner.FAILED_RESULTS_KEY])
except:
self.log.exception("The automatic correction process failed. Have in mind that is required that the web service must be online.")
try:
self.administrator_mail.send_mails()
except:
self.log.exception("The mail sending process failed. Have in mind that is required that the web service must be online.")
finish_timestamp = datetime.today()
self.stall_loop(start_timestamp, finish_timestamp)
class SetupEnviroment():
def __init__(self):
self.prepare_files_strategy = PrepareFilesStrategyZip()
self.log = LoggerManager().get_new_logger("setup enviroment")
def run(self, automatic_correction, working_dir):
self.log.debug("setting up enviroment...")
self.log.debug("cleaning up working directory...")
shutil.rmtree(working_dir, ignore_errors=True)
self.log.debug("preparing delivery files...")
self.prepare_files_strategy.zip = automatic_correction.delivery
os.mkdir(working_dir)
self.prepare_files_strategy.prepare_files(working_dir)
shutil.copy(
automatic_correction.script,
working_dir + "/" + os.path.basename(automatic_correction.script))
# We must ensure the script is runnable
process = subprocess.Popen([
"chmod", "a+x",
working_dir + "/" + os.path.basename(automatic_correction.script)
])
process.wait()
self.log.debug("enviroment set.")
class RunScriptCommand():
"""
Top class for the hierarchy of the Command in charge of running the scripts
of autocorrection for Practices. This should ONLY run the script and
capture the results, so that they can be published afterwards when the
visitors in the 'publication' package are run.
"""
TIME_OUT = 60 # seconds
def __init__(self):
self.script = None
self.log = LoggerManager().get_new_logger("run script")
def set_script(self, script):
self.script = script
def execute(self):
if(self.script is None):
self.log.error("attempt to run the correction process but the script to be run is not defined.")
raise IllegalStateException(reason="In order to execute the script, you must set it first.")
# now we may call the script
self.log.debug("launching correction process...")
# FIXME: this is plain shit. We should try to use 'with'
automatic_correction_tmp_dir = os.path.dirname(self.script) # managepath.get_instance().get_automatic_correction_tmp_dir()
current_dir = os.getcwd()
self.log.debug("current dir: %s", current_dir)
self.log.debug("script dir : %s", automatic_correction_tmp_dir)
os.chdir(automatic_correction_tmp_dir)
process = subprocess.Popen([self.script], shell=False, stdout = subprocess.PIPE, stderr=subprocess.PIPE)
os.chdir(current_dir)
# fin FIXME!!!
# must ensure that the process won't run forever
process_timer = ProcessTimeout(process, RunScriptCommand.TIME_OUT)
process_timer.start_timer()
self.log.debug("Process timeout timer launched")
# finally, we must capture all results so the can be published
script_result = ScriptResult()
self.log.debug("waiting for process to finish...")
script_result.exit_value = process.wait()
self.log.debug("process finished with exit value %d", script_result.exit_value)
#if the result has been obtained, the is no point on keeping the timer alive
if process_timer.ran:
self.log.info("Execution has been terminated for exceding the timeout limit.")
else:
process_timer.cancel_timer()
self.log.debug("Process finished correctly without exceding timeout limit.")
output = process.communicate()
script_result.captured_stdout = output[0]
self.log.debug("stdout captured.")
self.log.debug("excecution completed.")
return script_result
def __init__(self):
self.script = None
self.log = LoggerManager().get_new_logger("run script")
def __init__(self):
self.script = None
self.log = LoggerManager().get_new_logger("run script")
class RunScriptCommand():
"""
Top class for the hierarchy of the Command in charge of running the scripts
of autocorrection for Practices. This should ONLY run the script and
capture the results, so that they can be published afterwards when the
visitors in the 'publication' package are run.
"""
TIME_OUT = 60 # seconds
def __init__(self):
self.script = None
self.log = LoggerManager().get_new_logger("run script")
def set_script(self, script):
self.script = script
def execute(self):
if (self.script is None):
self.log.error(
"attempt to run the correction process but the script to be run is not defined."
)
raise IllegalStateException(
reason="In order to execute the script, you must set it first."
)
# now we may call the script
self.log.debug("launching correction process...")
# FIXME: this is plain shit. We should try to use 'with'
automatic_correction_tmp_dir = os.path.dirname(
self.script
) # managepath.get_instance().get_automatic_correction_tmp_dir()
current_dir = os.getcwd()
self.log.debug("current dir: %s", current_dir)
self.log.debug("script dir : %s", automatic_correction_tmp_dir)
os.chdir(automatic_correction_tmp_dir)
process = subprocess.Popen([self.script],
shell=False,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
os.chdir(current_dir)
# fin FIXME!!!
# must ensure that the process won't run forever
process_timer = ProcessTimeout(process, RunScriptCommand.TIME_OUT)
process_timer.start_timer()
self.log.debug("Process timeout timer launched")
# finally, we must capture all results so the can be published
script_result = ScriptResult()
self.log.debug("waiting for process to finish...")
script_result.exit_value = process.wait()
self.log.debug("process finished with exit value %d",
script_result.exit_value)
#if the result has been obtained, the is no point on keeping the timer alive
if process_timer.ran:
self.log.info(
"Execution has been terminated for exceding the timeout limit."
)
else:
process_timer.cancel_timer()
self.log.debug(
"Process finished correctly without exceding timeout limit.")
output = process.communicate()
script_result.captured_stdout = output[0]
self.log.debug("stdout captured.")
self.log.debug("excecution completed.")
return script_result
def __init__(self, auth_user, auth_pass):
self.log = LoggerManager().get_new_logger("result publication mail")
self.rest_api_helper = RestApiHelper(auth_user, auth_pass,
http_mail_serializer=PublishResultsVisitorMail.HTTP_MAIL_SERIALIZER)
def __init__(self):
self.prepare_files_strategy = PrepareFilesStrategyZip()
self.log = LoggerManager().get_new_logger("setup enviroment")
self.log.exception(
"The mail sending process failed. Have in mind that is required that the web service must be online."
)
finish_timestamp = datetime.today()
self.stall_loop(start_timestamp, finish_timestamp)
parser = argparse.ArgumentParser(
description='Starts or stops the seal daemon.')
parser.add_argument('command',
metavar='start/stop',
help='the command that should be executed on the daemon')
args = parser.parse_args()
logger_manager = LoggerManager()
log = logger_manager.getLogger()
log.info("Daemon action recived: '%s'", args.command)
loop_runner = LoopRunner()
daemon_runner = DaemonRunner(loop_runner) # runner.DaemonRunner(loop_runner)
daemon_runner.daemon_context.files_preserve = [
logger_manager.get_file_handler().stream
]
daemon_runner.do_action()
if ("start".__eq__(args.command.lower())):
log.info("Daemon launched.")
else:
log.info("Daemon stopped.")
def __init__(self):
self.prepare_files_strategy = PrepareFilesStrategyZip()
self.log = LoggerManager().get_new_logger("setup enviroment")
self.log.exception("The automatic correction process failed. Have in mind that is required that the web service must be online.")
try:
self.administrator_mail.send_mails()
except:
self.log.exception("The mail sending process failed. Have in mind that is required that the web service must be online.")
finish_timestamp = datetime.today()
self.stall_loop(start_timestamp, finish_timestamp)
parser = argparse.ArgumentParser(description='Starts or stops the seal daemon.')
parser.add_argument('command', metavar='start/stop',
help='the command that should be executed on the daemon')
args = parser.parse_args()
logger_manager = LoggerManager()
log = logger_manager.getLogger()
log.info("Daemon action recived: '%s'", args.command)
loop_runner = LoopRunner()
daemon_runner = DaemonRunner(loop_runner) # runner.DaemonRunner(loop_runner)
daemon_runner.daemon_context.files_preserve=[logger_manager.get_file_handler().stream]
daemon_runner.do_action()
if("start".__eq__(args.command.lower())):
log.info("Daemon launched.")
else:
log.info("Daemon stopped.")
class ProcessTimeout:
"""
Handler of the timer for setting a timeout to the automatic correction process
"""
def __init__(self, process, timeout):
self.process = process
self.timeout = timeout
self.ran = False
self.timer = Timer(self.timeout, self.kill_proc)
self.logger = LoggerManager().get_new_logger("process timeout")
def killtree(self):
parent = psutil.Process(self.process.pid)
for child in parent.get_children(recursive=True):
self.logger.debug("killing process %d", child.pid)
child.kill()
self.logger.debug("killing process %d", parent.pid)
parent.kill()
def kill_proc(self):
self.logger.debug("timer expired, killing process...")
self.killtree()
self.logger.debug("process terminate invoked.")
self.ran = True
def start_timer(self):
self.logger.debug("timer started")
self.timer.start()
def cancel_timer(self):
self.logger.debug("timer cancelled")
self.timer.cancel()
def testLoggerManagerMustReturnALoggerAppropiatelyConfiguredWhenProvidedAName(self):
logger_manager = LoggerManager()
logger = logger_manager.getLogger("a_name")
pass
def __init__(self, auth_user, auth_pass):
self.log = LoggerManager().get_new_logger("result publication")
self.rest_api_helper = RestApiHelper(
auth_user, auth_pass,
PublishResultsVisitorWeb.HTTP_MAIL_SERIALIZER)
def __init__(self, input_str=None):
"""
Initializes the json string that should be turn into a local entity
"""
self.log = LoggerManager().get_new_logger("auto correction-json translator")
self.json = input_str
def __init__(self):
"""Initializes the zip file path to None"""
self.zip = None
self.log = LoggerManager().get_new_logger("preparation")
def __init__(self, auth_user, auth_pass):
self.log = LoggerManager().get_new_logger("result publication")
self.rest_api_helper = RestApiHelper(auth_user, auth_pass, PublishResultsVisitorWeb.HTTP_MAIL_SERIALIZER)
class PrepareFilesStrategyZip(PrepareFilesStrategy):
"""
Strategy meant to obtain the files to be "auto-checked" from a zip file uploaded to the app.
"""
def __init__(self):
"""Initializes the zip file path to None"""
self.zip = None
self.log = LoggerManager().get_new_logger("preparation")
def prepare_files(self, destination_path):
self.log.debug("preparing files for automatic correction process...")
if (self.zip is None):
raise IllegalStateException(reason="In order to prepare the files by unzipping them, you must set the zip file as source.\
Try setting the zip attribute for this object.")
zipfile = ZipFile(self.zip)
zipfile.extractall(destination_path)
self.log.debug("\n\nWalking destination path...")
for path, directories, files in os.walk(destination_path):
self.log.debug("path: %s", path)
for directory in directories:
self.log.debug("directory: %s", directory)
for a_file in files:
self.log.debug("file: %s", a_file)
self.log.debug("\n\n")
self.log.debug("zip file extracted to %s.", destination_path)
def __init__(self, process, timeout):
self.process = process
self.timeout = timeout
self.ran = False
self.timer = Timer(self.timeout, self.kill_proc)
self.logger = LoggerManager().get_new_logger("process timeout")
def testLoggerManagerMustReturnALoggerAppropiatelyConfiguredWhenProvidedAName(
self):
logger_manager = LoggerManager()
logger = logger_manager.getLogger("a_name")
pass
def testLoggerManagerMustReturnALoggerAppropiatelyConfiguredWhenANameIsNotProvided(self):
logger_manager = LoggerManager()
logger = logger_manager.getLogger()
pass
class ProcessTimeout:
"""
Handler of the timer for setting a timeout to the automatic correction process
"""
def __init__(self, process, timeout):
self.process = process
self.timeout = timeout
self.ran = False
self.timer = Timer(self.timeout, self.kill_proc)
self.logger = LoggerManager().get_new_logger("process timeout")
def killtree(self):
parent = psutil.Process(self.process.pid)
for child in parent.get_children(recursive=True):
self.logger.debug("killing process %d", child.pid)
child.kill()
self.logger.debug("killing process %d", parent.pid)
parent.kill()
def kill_proc(self):
self.logger.debug("timer expired, killing process...")
self.killtree()
self.logger.debug("process terminate invoked.")
self.ran = True
def start_timer(self):
self.logger.debug("timer started")
self.timer.start()
def cancel_timer(self):
self.logger.debug("timer cancelled")
self.timer.cancel()
def testLoggerManagerMustReturnALoggerAppropiatelyConfiguredWhenANameIsNotProvided(
self):
logger_manager = LoggerManager()
logger = logger_manager.getLogger()
pass
def __init__(self, process, timeout):
self.process = process
self.timeout = timeout
self.ran = False
self.timer = Timer(self.timeout, self.kill_proc)
self.logger = LoggerManager().get_new_logger("process timeout")
