X-Git-Url: https://git.llucax.com/software/sercom-old.git/blobdiff_plain/219f7ebe037bf26449f4d211cdf7b486fb8b847c..35176aa3e23a4660af9f139262213e7f47af0794:/src/sc_test?ds=inline diff --git a/src/sc_test b/src/sc_test index 34402ff..a1a4a06 100755 --- a/src/sc_test +++ b/src/sc_test @@ -7,12 +7,14 @@ import os import pwd import time import signal +import glob import shutil import datetime import subprocess # Módulos locales import sercom -from sercom.dbo import * +import sercom.sqlo +from sercom.sqlo import * class secure_process: def __init__(self, chroot, uid, gid, cpu): @@ -36,12 +38,14 @@ class secure_process: resource.setrlimit(resource.RLIMIT_MEMLOCK, x2(100)) resource.setrlimit(resource.RLIMIT_NOFILE, x2(100)) resource.setrlimit(resource.RLIMIT_NPROC, x2(0)) + # Tratamos de forzar un sync para que entre al sleep del padre + time.sleep(0) def sigchld(signum, frame): """Signal handler para SIGCHILD.""" - #global hijo_muerto - #hijo_muerto = True - pass + global hijo_muerto, log + log.debug('Murió el hijo') + hijo_muerto = True def sigterm(signum, frame): """Signal handler para SIGTERM y SIGINT.""" @@ -49,17 +53,18 @@ def sigterm(signum, frame): continuar = False log.debug('Señal %d recibida', signum) -def compilar(intento, intento_dir, entrega_dir, log): +def chroot_dir(intento): + return os.path.join(intento.path, 'chroot') + +def compilar(intento): + global log # Busco makefile - makefile = os.path.join(entrega_dir, 'Makefile') - if not os.path.exists(makefile): - makefile = os.path.join(data_dir, 'Makefile') - shutil.copy(makefile, intento_dir) + makefile = os.path.join(intento.entrega.ejercicio.path, 'Makefile') # Compilo log.debug('Ejecutando: make -f %s', makefile) intento.inicioCompila = datetime.datetime.now() make = subprocess.Popen(('make', '-f', makefile), stdout=subprocess.PIPE, - stderr=subprocess.PIPE, cwd=intento_dir) + stderr=subprocess.PIPE, cwd=intento.path) make.wait() intento.finCompila = datetime.datetime.now() log.debug('Fin del comando: make -f %s', makefile) @@ -76,13 +81,22 @@ def compilar(intento, intento_dir, entrega_dir, log): #TODO mail acumulativo return True -def preparar(intento_dir, chroot_dir): +def preparar(intento): # Creo chroot - TODO copiarlo de algún lado donde ande el valgrind? - ejecutable = os.path.join(chroot_dir, 'tp') - os.mkdir(chroot_dir) - shutil.move(os.path.join(intento_dir, 'tp'), ejecutable) + os.mkdir(chroot_dir(intento)) + shutil.copy(os.path.join(intento.path, 'tp'), + os.path.join(chroot_dir(intento), 'tp')) + +def limpiar(intento): + # Borro chroot entero + shutil.rmtree(chroot_dir(intento)) -def probar(intento, caso_de_prueba, uid, gid, chroot_dir, conf, conn, log): +def probar(intento, caso_de_prueba): + # Cosas útiles + global log, conn, conf, uid, gid + # Para manejo de SIGCHLD + global hijo_muerto + hijo_muerto = False # Obtengo datos útiles del caso de prueba tiempo_cpu = caso_de_prueba.tiempoCpu if tiempo_cpu is None: @@ -90,20 +104,29 @@ def probar(intento, caso_de_prueba, uid, gid, chroot_dir, conf, conn, log): tiempo_cpu = int(tiempo_cpu) # Creo prueba nueva prueba = Prueba(intento=intento, casoDePrueba=caso_de_prueba, - inicio=datetime.datetime.now(), connection = conn) - log.debug('Prueba: %s', prueba) + inicio=datetime.datetime.now(), connection=conn) + log.debug('Iniciando prueba: %s', prueba) # Abro archivos para fds básicos #XXX sacar nombres de archivos de prueba???? - #stdin = file(os.path.join(intento_dir, 'stdin'), 'r') - stdout = file(os.path.join(intento_dir, 'stdout'), 'w') - stderr = file(os.path.join(intento_dir, 'stderr'), 'w') + options = { + 'cwd': chroot_dir(intento), + 'close_fds': True, + 'preexec_fn': secure_process(chroot_dir(intento), uid, gid, tiempo_cpu), + } + if os.path.exists(os.path.join(caso_de_prueba.path, 'stdin')): + options['stdin'] = file(os.path.join(caso_de_prueba.path, 'stdin'), 'r') + if os.path.exists(os.path.join(caso_de_prueba.path, 'stdout')): + options['stdout'] = subprocess.PIPE + if os.path.exists(os.path.join(caso_de_prueba.path, 'stderr')): + options['stderr'] = subprocess.PIPE # Ejecuto programa - log.debug('Ejecutando /tp %s', caso_de_prueba.parametros) + params = ['/tp'] + if caso_de_prueba.parametros: + params += params2seq(caso_de_prueba.parametros) + log.debug('Ejecutando %s', ' '.join(params)) os.seteuid(0) # Dios! (para chroot) - # FIXME caso_de_prueba.parametros try: - proc = subprocess.Popen('/tp', stdout=stdout, stderr=stderr, #stdin=stdin, - preexec_fn=secure_process(chroot_dir, uid, gid, tiempo_cpu)) + proc = subprocess.Popen(params, **options) except Exception, e: # FIXME poner en el manejo de exceptiones estandar try: print e.child_traceback @@ -111,9 +134,10 @@ def probar(intento, caso_de_prueba, uid, gid, chroot_dir, conf, conn, log): except: raise os.seteuid(uid) # Mortal de nuevo - time.sleep(tiempo_cpu) + if not hijo_muerto: # Recibido por el sigchld, para saber si murió + time.sleep(tiempo_cpu) # Si el proceso sigue andando lo tenemos que matar - if proc.poll() is None: + if not hijo_muerto: log.debug('La prueba tardó más del tiempo permitido (%d segundos)', tiempo_cpu) os.seteuid(0) # Dios! (corre como Dios, hay que matarlo como Dios) @@ -161,27 +185,95 @@ def probar(intento, caso_de_prueba, uid, gid, chroot_dir, conf, conn, log): log.debug('Prueba OK: %s', prueba) return prueba -# Conecto señales -signal.signal(signal.SIGCHLD, sigchld) +def params2seq(params): + r"""Parsea un string de forma similar al bash, separando por espacios y + teniendo en cuenta comillas simples y dobles para agrupar. Para poner + comillas se puede usar el \ como caracter de escape (\' y \") y también + interpreta \n y \t. Devuelve una lista con los parámetros encontrados.""" + # Constantes + SEP, TOKEN, DQUOTE, SQUOTE = ' ', None, '"', "'" + seq = [] + buff = '' + escape = False + state = SEP + for c in params: + # Es un caracter escapado + if escape: + if c == 'n': + buff += '\n' + elif c == 't': + buff += '\t' + else: + buff += c + escape = False + continue + # Es una secuencia de escape + if c == '\\': + escape = True + continue + # Si está buscando espacios + if state == SEP: + if c == SEP: + continue + else: + state = TOKEN # Encontró + if state == TOKEN: + if c == DQUOTE: + state = DQUOTE + continue + if c == SQUOTE: + state = SQUOTE + continue + if c == SEP: + state = SEP + seq.append(buff) + buff = '' + continue + buff += c + continue + if state == DQUOTE: + if c == DQUOTE: + state = TOKEN + continue + buff += c + continue + if state == SQUOTE: + if c == SQUOTE: + state = TOKEN + continue + buff += c + continue + raise Exception, 'No tiene sentido' + if state == DQUOTE or state == SQUOTE: + raise Exception, 'Parse error, falta cerrar comilla (%s)' % state + if buff: + seq.append(buff) + return seq + +# Manejadores de señales signal.signal(signal.SIGTERM, sigterm) signal.signal(signal.SIGINT, sigterm) +signal.signal(signal.SIGCHLD, sigchld) +hijo_muerto = False # Cambia con SIGCHLD +continuar = True # Cambia con SIGTERM o SIGINT # Inicializo -conf, conn, log = sercom.init('test') +conf, conn, log = sercom.init('test') log.info('Iniciado') # Obtengo id de usuario con el cual ejecutar las pruebas -(uid, gid) = pwd.getpwnam(conf.get('general', 'user'))[2:4] +uid, gid = pwd.getpwnam(conf.get('general', 'user'))[2:4] # Cambio UID efectivo os.seteuid(uid) -# Algunas variables de configuración útiles -data_dir = conf.get('general', 'data_dir') +# Atajo intervalo = float(conf.get('general', 'intervalo')) +# Utilizo el directorio de datos como base para todos los SQLObjects +sercom.sqlo.dir_base = conf.get('general', 'data_dir') + # Hasta que nos maten -continuar = True # Cambia con una señal while continuar: # Busco intento a probar intento = Intento.getProximoAProbar(conn) @@ -190,22 +282,25 @@ while continuar: time.sleep(intervalo) continue log.info('Nuevo intento a probar (%s)', intento) - # Obtengo paths - intento_dir = os.path.join(data_dir, intento.path('intentos')) - entrega_dir = os.path.join(data_dir, 'ejercicios', str(intento.entrega.ejercicioID)) - chroot_dir = os.path.join(intento_dir, 'chroot') # Compila - if not compilar(intento, intento_dir, entrega_dir, log): + if not compilar(intento): + #TODO mandar mail continue - # Prepara archivos - preparar(intento_dir, chroot_dir) # Ejecución de casos de prueba intento.inicioPruebas = datetime.datetime.now() pruebas = [] for caso_de_prueba in intento.entrega.ejercicio.casosDePrueba: - pruebas.append(probar(intento, caso_de_prueba, uid, gid, chroot_dir, conf, conn, log)) + # Preparo chroot + preparar(intento) + # Pruebo y agrego prueba a la lista + pruebas.append(probar(intento, caso_de_prueba)) + # Limpio chroot + limpiar(intento) intento.finPruebas = datetime.datetime.now() - #TODO make clean + # Limpio directorio + log.debug('Borrando ejecutable y código objeto (*.o)') + os.remove(os.path.join(intento.path, 'tp')) + [os.remove(obj) for obj in glob.glob(os.path.join(intento.path, '*.o'))] #TODO Armar mail de respuesta al alumno for prueba in pruebas: #TODO Si es publica, veo si se hizo ok o no y voy creando mail