src/sc_test

   1 #!/usr/bin/env python2.4
   2 # -*- encoding: iso-8859-1 -*-
   3 # vim: set et sw=4 sts=4 :
   4
   5 # Módulos estándar
   6 import os
   7 import pwd
   8 import time
   9 import signal
  10 import glob
  11 import shutil
  12 import datetime
  13 import subprocess
  14 # Módulos locales
  15 import sercom
  16 import sercom.sqlo
  17 from sercom.sqlo import *
  18
  19 class secure_process:
  20     def __init__(self, chroot, uid, gid, cpu):
  21         self.chroot = chroot
  22         self.uid = uid
  23         self.gid = gid
  24         self.cpu = cpu
  25     def __call__(self):
  26         from os import chroot, setuid, setgid
  27         import resource
  28         chroot(self.chroot)
  29         setgid(self.gid)
  30         setuid(self.uid)
  31         x2 = lambda val: (val, val) # Devuelve una tupla con val 2 veces
  32         resource.setrlimit(resource.RLIMIT_AS, x2(20*1024*1024))
  33         resource.setrlimit(resource.RLIMIT_CORE, x2(0))
  34         resource.setrlimit(resource.RLIMIT_CPU, x2(self.cpu))
  35         resource.setrlimit(resource.RLIMIT_DATA, x2(20*1024*1024))
  36         resource.setrlimit(resource.RLIMIT_FSIZE, x2(20*1024*1024)) #XXX Obtener de archivos esperados?
  37         #resource.setrlimit(resource.RLIMIT_LOCKS, x2(100)) XXX NO EXISTE EN python
  38         resource.setrlimit(resource.RLIMIT_MEMLOCK, x2(100))
  39         resource.setrlimit(resource.RLIMIT_NOFILE, x2(100))
  40         resource.setrlimit(resource.RLIMIT_NPROC, x2(0))
  41         # Tratamos de forzar un sync para que entre al sleep del padre
  42         time.sleep(0)
  43
  44 def sigchld(signum, frame):
  45     """Signal handler para SIGCHILD."""
  46     global hijo_muerto, log
  47     log.debug('Murió el hijo')
  48     hijo_muerto = True
  49
  50 def sigterm(signum, frame):
  51     """Signal handler para SIGTERM y SIGINT."""
  52     global continuar, log
  53     continuar = False
  54     log.debug('Señal %d recibida', signum)
  55
  56 def chroot_dir(intento):
  57     return os.path.join(intento.path, 'chroot')
  58
  59 def compilar(intento):
  60     global log
  61     # Busco makefile
  62     makefile = os.path.join(intento.entrega.ejercicio.path, 'Makefile')
  63     # Compilo
  64     log.debug('Ejecutando: make -f %s', makefile)
  65     intento.inicioCompila = datetime.datetime.now()
  66     make = subprocess.Popen(('make', '-f', makefile), stdout=subprocess.PIPE,
  67         stderr=subprocess.PIPE, cwd=intento.path)
  68     make.wait()
  69     intento.finCompila = datetime.datetime.now()
  70     log.debug('Fin del comando: make -f %s', makefile)
  71     # Verifico compilación
  72     if make.returncode:
  73         log.debug('Error al compilar, código de retorno: %d, salida estándar: '
  74             '%s, salida de error: %s)', make.returncode, make.stdout.read(),
  75             make.stderr.read())
  76         intento.compila = False
  77         #TODO enviar_respuesta(R_ERR, $mail, "ERROR AL COMPILAR!\n\n$err\n\nCódigo de retorno: $ret\n", $intento);
  78         return False
  79     log.debug('Compilado OK')
  80     intento.compila = True
  81     #TODO mail acumulativo
  82     return True
  83
  84 def preparar(intento):
  85     # Creo chroot - TODO copiarlo de algún lado donde ande el valgrind?
  86     os.mkdir(chroot_dir(intento))
  87     shutil.copy(os.path.join(intento.path, 'tp'),
  88         os.path.join(chroot_dir(intento), 'tp'))
  89
  90 def limpiar(intento):
  91     # Borro chroot entero
  92     shutil.rmtree(chroot_dir(intento))
  93
  94 def probar(intento, caso_de_prueba):
  95     # Cosas útiles
  96     global log, conn, conf, uid, gid
  97     # Para manejo de SIGCHLD
  98     global hijo_muerto
  99     hijo_muerto = False
 100     # Obtengo datos útiles del caso de prueba
 101     tiempo_cpu = caso_de_prueba.tiempoCpu
 102     if tiempo_cpu is None:
 103         tiempo_cpu = conf.get('general', 'tiempo_cpu')
 104     tiempo_cpu = int(tiempo_cpu)
 105     # Creo prueba nueva
 106     prueba = Prueba(intento=intento, casoDePrueba=caso_de_prueba,
 107         inicio=datetime.datetime.now(), connection=conn)
 108     log.debug('Iniciando prueba: %s', prueba)
 109     # Abro archivos para fds básicos
 110     #XXX sacar nombres de archivos de prueba????
 111     options = {
 112         'cwd': chroot_dir(intento),
 113         'close_fds': True,
 114         'preexec_fn': secure_process(chroot_dir(intento), uid, gid, tiempo_cpu),
 115     }
 116     if os.path.exists(os.path.join(caso_de_prueba.path, 'stdin')):
 117         options['stdin'] = file(os.path.join(caso_de_prueba.path, 'stdin'), 'r')
 118     if os.path.exists(os.path.join(caso_de_prueba.path, 'stdout')):
 119         options['stdout'] = subprocess.PIPE
 120     if os.path.exists(os.path.join(caso_de_prueba.path, 'stderr')):
 121         options['stderr'] = subprocess.PIPE
 122     # Ejecuto programa
 123     params = ['/tp']
 124     if caso_de_prueba.parametros:
 125         params += params2seq(caso_de_prueba.parametros)
 126     log.debug('Ejecutando %s', ' '.join(params))
 127     os.seteuid(0) # Dios! (para chroot)
 128     try:
 129         proc = subprocess.Popen(params, **options)
 130     except Exception, e: # FIXME poner en el manejo de exceptiones estandar
 131         try:
 132             print e.child_traceback
 133             raise
 134         except:
 135             raise
 136     os.seteuid(uid) # Mortal de nuevo
 137     if not hijo_muerto: # Recibido por el sigchld, para saber si murió
 138         time.sleep(tiempo_cpu)
 139     # Si el proceso sigue andando lo tenemos que matar
 140     if not hijo_muerto:
 141         log.debug('La prueba tardó más del tiempo permitido (%d segundos)',
 142             tiempo_cpu)
 143         os.seteuid(0) # Dios! (corre como Dios, hay que matarlo como Dios)
 144         os.kill(proc.pid, signal.SIGKILL)
 145         os.seteuid(uid) # Mortal de nuevo
 146         log.debug('Prueba cancelada (kill)')
 147         proc.wait()
 148         prueba.observaciones = 'Excedió el límite de tiempo de ejecución ' \
 149             '(%d seg)' % tiempo_cpu
 150         prueba.fin = datetime.datetime.now()
 151         prueba.pasada = False
 152         return prueba
 153     proc.wait() # Para que no queden zombies
 154     prueba.fin = str(datetime.datetime.now())
 155     # Salió con una señal?
 156     if proc.returncode < 0:
 157         sig = -proc.returncode
 158         log.debug('El programa salió con la señal %d', sig)
 159         prueba.pasada = False
 160         #TODO otras señales conocidas
 161         if sig == signal.SIGXCPU:
 162             prueba.observaciones = 'Excedió el límite de tiempo de CPU ' \
 163                 '(%d seg)' % tiempo_cpu
 164         else:
 165             prueba.observaciones = 'Salió con la señal %d' % sig
 166         return prueba
 167     # Si tenemos que verificar el código de retorno
 168     if caso_de_prueba.codigoRetorno is not None:
 169         #FIXME trucho lo de 256
 170         # Si el código de error esperado es 256 => el código de error debe ser != 0
 171         # Si no el código de error esperado debe ser igual al obtenido
 172         if caso_de_prueba.codigoRetorno != proc.returncode \
 173                 or caso_de_prueba.codigoRetorno == 256 \
 174                     and proc.returncode != 0:
 175             log.debug('Código de retorno incorrecto (debía ser %d y se obtuvo %d)',
 176                 caso_de_prueba.codigoRetorno, proc.returncode)
 177             prueba.pasada = False
 178             prueba.observaciones = 'Código de retorno incorrecto (debía ' \
 179                 'ser %d y se obtuvo %d)' % (caso_de_prueba.codigoRetorno,
 180                 proc.returncode)
 181     #TODO verificar salidas, hacer diff
 182     log.debug('Fin de ejecución de caso de prueba (hijo: %d, ret: %d)',
 183         proc.pid, proc.returncode)
 184     prueba.pasada = True
 185     log.debug('Prueba OK: %s', prueba)
 186     return prueba
 187
 188 def params2seq(params):
 189     r"""Parsea un string de forma similar al bash, separando por espacios y
 190     teniendo en cuenta comillas simples y dobles para agrupar. Para poner
 191     comillas se puede usar el \ como caracter de escape (\' y \") y también
 192     interpreta \n y \t. Devuelve una lista con los parámetros encontrados."""
 193     # Constantes
 194     SEP, TOKEN, DQUOTE, SQUOTE = ' ', None, '"', "'"
 195     seq = []
 196     buff = ''
 197     escape = False
 198     state = SEP
 199     for c in params:
 200         # Es un caracter escapado
 201         if escape:
 202             if c == 'n':
 203                 buff += '\n'
 204             elif c == 't':
 205                 buff += '\t'
 206             else:
 207                 buff += c
 208             escape = False
 209             continue
 210         # Es una secuencia de escape
 211         if c == '\\':
 212             escape = True
 213             continue
 214         # Si está buscando espacios
 215         if state == SEP:
 216             if c == SEP:
 217                 continue
 218             else:
 219                 state = TOKEN # Encontró
 220         if state == TOKEN:
 221             if c == DQUOTE:
 222                 state = DQUOTE
 223                 continue
 224             if c == SQUOTE:
 225                 state = SQUOTE
 226                 continue
 227             if c == SEP:
 228                 state = SEP
 229                 seq.append(buff)
 230                 buff = ''
 231                 continue
 232             buff += c
 233             continue
 234         if state == DQUOTE:
 235             if c == DQUOTE:
 236                 state = TOKEN
 237                 continue
 238             buff += c
 239             continue
 240         if state == SQUOTE:
 241             if c == SQUOTE:
 242                 state = TOKEN
 243                 continue
 244             buff += c
 245             continue
 246         raise Exception, 'No tiene sentido'
 247     if state == DQUOTE or state == SQUOTE:
 248         raise Exception, 'Parse error, falta cerrar comilla (%s)' % state
 249     if buff:
 250         seq.append(buff)
 251     return seq
 252
 253 # Manejadores de señales
 254 signal.signal(signal.SIGTERM, sigterm)
 255 signal.signal(signal.SIGINT, sigterm)
 256 signal.signal(signal.SIGCHLD, sigchld)
 257 hijo_muerto = False # Cambia con SIGCHLD
 258 continuar = True # Cambia con SIGTERM o SIGINT
 259
 260 # Inicializo
 261 conf, conn, log = sercom.init('test')
 262 log.info('Iniciado')
 263
 264 # Obtengo id de usuario con el cual ejecutar las pruebas
 265 uid, gid = pwd.getpwnam(conf.get('general', 'user'))[2:4]
 266
 267 # Cambio UID efectivo
 268 os.seteuid(uid)
 269
 270 # Atajo
 271 intervalo = float(conf.get('general', 'intervalo'))
 272
 273 # Utilizo el directorio de datos como base para todos los SQLObjects
 274 sercom.sqlo.dir_base = conf.get('general', 'data_dir')
 275
 276 # Hasta que nos maten
 277 while continuar:
 278     # Busco intento a probar
 279     intento = Intento.getProximoAProbar(conn)
 280     if not intento:
 281         log.debug('No hay intento para probar')
 282         time.sleep(intervalo)
 283         continue
 284     log.info('Nuevo intento a probar (%s)', intento)
 285     # Compila
 286     if not compilar(intento):
 287         #TODO mandar mail
 288         continue
 289     # Ejecución de casos de prueba
 290     intento.inicioPruebas = datetime.datetime.now()
 291     pruebas = []
 292     for caso_de_prueba in intento.entrega.ejercicio.casosDePrueba:
 293         # Preparo chroot
 294         preparar(intento)
 295         # Pruebo y agrego prueba a la lista
 296         pruebas.append(probar(intento, caso_de_prueba))
 297         # Limpio chroot
 298         limpiar(intento)
 299     intento.finPruebas = datetime.datetime.now()
 300     # Limpio directorio
 301     log.debug('Borrando ejecutable y código objeto (*.o)')
 302     os.remove(os.path.join(intento.path, 'tp'))
 303     [os.remove(obj) for obj in glob.glob(os.path.join(intento.path, '*.o'))]
 304     #TODO Armar mail de respuesta al alumno
 305     for prueba in pruebas:
 306         #TODO Si es publica, veo si se hizo ok o no y voy creando mail
 307         pass
 308     time.sleep(intervalo)
 309