#!/usr/bin/env python2.4 # -*- encoding: iso-8859-1 -*- # vim: set et sw=4 sts=4 : # Módulos estándar import os import sys import pwd import time import signal import locale import shutil import datetime import logging import logging.config import subprocess import ConfigParser # Módulos externos import sqlobject # Módulos locales from sercom.dbo import * class secure: def __init__(self, chroot, uid, gid, cpu): self.chroot = chroot self.uid = uid self.gid = gid self.cpu = cpu def __call__(self): from os import chroot, setuid, setgid import resource chroot(self.chroot) setgid(self.gid) setuid(self.uid) resource.setrlimit(resource.RLIMIT_AS, 20*1024*1024) resource.setrlimit(resource.RLIMIT_CORE, 0) resource.setrlimit(resource.RLIMIT_CPU, (self.cpu, self.cpu)) resource.setrlimit(resource.RLIMIT_DATA, 20*1024*1024) resource.setrlimit(resource.RLIMIT_FSIZE, 20*1024*1024) #XXX Obtener de archivos esperados? resource.setrlimit(resource.RLIMIT_LOCKS, 100) resource.setrlimit(resource.RLIMIT_MEMLOCK, 100) resource.setrlimit(resource.RLIMIT_NOFILE, 100) resource.setrlimit(resource.RLIMIT_NPROC, 0) def logger(): log = None for log_conf in ('log.ini', os.path.expanduser('~/.sercom/log.ini'), '/etc/sercom/log.ini'): if (os.access(log_conf, os.R_OK)): logging.config.fileConfig(log_conf) log = logging.getLogger('test') return log def sigchld(signum, frame): """Signal handler para SIGCHILD.""" #global hijo_muerto #hijo_muerto = True pass def sigterm(signum, frame): """Signal handler para SIGTERM y SIGINT.""" global continuar, log continuar = False log.debug('Señal %d recibida', signum) # Seteo locale locale.setlocale(locale.LC_ALL, '') # Obtengo configuración conf = ConfigParser.SafeConfigParser() if not conf.read(('/etc/sercom/sercom.ini', os.path.expanduser('~/.sercom/sercom.ini'), 'sercom.ini')): sys.stderr.write('No se pudo obtener configuración!\n') sys.exit(1) # Obtengo id de usuario con el cual ejecutar las pruebas (uid, gid) = pwd.getpwnam(conf.get('general', 'user'))[2:4] # Cambio UID efectivo os.seteuid(uid) # Seteo umask para que el grupo pueda leer os.umask(00027) # Conecto señales signal.signal(signal.SIGCHLD, sigchld) signal.signal(signal.SIGTERM, sigterm) signal.signal(signal.SIGINT, sigterm) # Conexión a la DB conn = sqlobject.connectionForURI(conf.get('dbo', 'database')) # Cargo config del logger log = logger() if not log: print >>sys.stderr, 'No se pudo cargar archivo de configuración de log.' sys.exit(1) log.info('Iniciado') # Algunas variables de configuración útiles data_dir = conf.get('general', 'data_dir') intervalo = float(conf.get('general', 'intervalo')) # Hasta que nos maten continuar = True # Cambia con una señal while continuar: # Busco intento a probar intento = Intento.getProximoAProbar(conn) if not intento: log.debug('No hay intento para probar') 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)) print entrega_dir # 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) # 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) make.wait() intento.finCompila = datetime.datetime.now() log.debug('Fin del comando: make -f %s', makefile) # Verifico compilación if make.returncode: log.debug('Error al compilar, código de retorno: %d, salida estándar: ' '%s, salida de error: %s)', make.returncode, make.stdout.read(), make.stderr.read()) intento.compila = False #TODO enviar_respuesta(R_ERR, $mail, "ERROR AL COMPILAR!\n\n$err\n\nCódigo de retorno: $ret\n", $intento); continue; else: log.debug('Compilado OK') intento.compila = True #TODO mail acumulativo # Creo chroot - TODO copiarlo de algún lado donde ande el valgrind? chroot_dir = os.path.join(intento_dir, 'chroot') ejecutable = os.path.join(chroot_dir, 'tp') os.mkdir(chroot_dir) shutil.move(os.path.join(intento_dir, 'tp'), ejecutable) # Cambio permisos - XXX al pedo? Hice seteuid() os.chmod(chroot_dir, 02770) os.chown(chroot_dir, uid, gid) os.chmod(ejecutable, 0550) os.chown(ejecutable, uid, gid) # Ejecución de casos de prueba intento.inicioPruebas = datetime.datetime.now() for caso_de_prueba in intento.entrega.ejercicio.casosDePrueba: # Obtengo datos útiles del caso de prueba tiempo_cpu = caso_de_prueba.tiempoCpu if tiempo_cpu is None: tiempo_cpu = conf.get('general', 'tiempo_cpu') # Creo prueba nueva prueba = Prueba(intento.id, caso_de_prueba.id, datetime.datetime.now()) log.debug('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') # Ejecuto programa log.debug('Ejecutando /tp %s', prueba.params) os.seteuid(0) # Dios! (para chroot) proc = subprocess.Popen('/tp', stdin=stdin, stdout=stdout, stderr=stderr, preexec_fn=secure(chroot_dir, uid, gid, tiempo_cpu)) os.seteuid(uid) # Mortal de nuevo time.sleep(tiempo_cpu) # Si el proceso sigue andando lo tenemos que matar if proc.poll() is None: 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) os.kill(proc.pid, signal.SIGKILL) os.seteuid(uid) # Mortal de nuevo log.debug('Prueba cancelada (kill)') proc.wait() prueba.observaciones = 'Excedió el límite de tiempo de ejecución ' \ '(%d seg)' % tiempo_cpu prueba.fin = datetime.datetime.now() prueba.pasada = False continue proc.wait() # Para que no queden zombies prueba.fin = datetime.datetime.now() # Salió con una señal? if proc.returncode < 0: sig = -proc.returncode log.debug('El programa salió con la señal %d', sig) prueba.pasada = False #TODO otras señales conocidas if sig == signal.SIGXCPU: prueba.observaciones = 'Excedió el límite de tiempo de CPU ' \ '(%d seg)' % tiempo_cpu else: prueba.observaciones = 'Salió con la señal %d' % sig continue # Si tenemos que verificar el código de retorno if caso_de_prueba.codigoRetorno is not None: #FIXME trucho lo de 256 # Si el código de error esperado es 256 => el código de error debe ser != 0 # Si no el código de error esperado debe ser igual al obtenido if caso_de_prueba.codigoRetorno != proc.returncode \ or caso_de_prueba.codigoRetorno == 256 \ and proc.returncode != 0: log.debug('Código de retorno incorrecto (debía ser %d y se obtuvo %d)', caso_de_prueba.codigoRetorno, proc.returncode) prueba.pasada = False prueba.observaciones = 'Código de retorno incorrecto (debía ' \ 'ser %d y se obtuvo %d)' % (caso_de_prueba.codigoRetorno, proc.returncode) #TODO verificar salidas, hacer diff log.debug('Fin de ejecución de caso de prueba (hijo: %d, ret: %d)', proc.pid, proc.returncode) log.debug('Prueba OK') prueba.pasada = True intento.finPruebas = datetime.datetime.now() #TODO make clean #TODO Armar mail de respuesta al alumno for prueba in Prueba.selectBy(conn, Prueba.q.intento == intento): #TODO Si es publica, veo si se hizo ok o no y voy creando mail pass time.sleep(conf.get('general', 'intervalo'))