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):
resource.setrlimit(resource.RLIMIT_MEMLOCK, x2(100))
resource.setrlimit(resource.RLIMIT_NOFILE, x2(100))
resource.setrlimit(resource.RLIMIT_NPROC, x2(0))
- sleep(0) # para tratar de forzar un sync para que entre al sleep del padre
+ # 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
+ global hijo_muerto, log
+ log.debug('Murió el hijo')
hijo_muerto = True
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')
+ 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)
#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):
- global hijo_muerto # Viene del SIGCHLD
+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:
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
params = ['/tp']
if caso_de_prueba.parametros:
log.debug('Ejecutando %s', ' '.join(params))
os.seteuid(0) # Dios! (para chroot)
try:
- proc = subprocess.Popen(params, 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
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)
seq.append(buff)
return seq
-# Conecto señales
+# Manejadores de señales
signal.signal(signal.SIGTERM, sigterm)
signal.signal(signal.SIGINT, sigterm)
signal.signal(signal.SIGCHLD, sigchld)
-hijo_muerto = False
+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
# 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)
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
projects / software / sercom-old.git / blobdiff