]> git.llucax.com Git - software/sercom.git/blob - sercom/tester.py
Usar nombre de archivo temporal más apropiado.
[software/sercom.git] / sercom / tester.py
1 # vim: set et sw=4 sts=4 encoding=utf-8 foldmethod=marker:
2
3 from sercom.model import Entrega, CasoDePrueba
4 from sercom.model import TareaFuente, TareaPrueba, ComandoFuente, ComandoPrueba
5 from difflib import unified_diff, HtmlDiff
6 from zipfile import ZipFile, BadZipfile
7 from cStringIO import StringIO
8 from shutil import rmtree
9 from datetime import datetime
10 from os.path import join
11 from turbogears import config
12 import subprocess as sp
13 import resource as rsrc
14 import os, sys, pwd, grp
15 import logging
16
17 log = logging.getLogger('sercom.tester')
18
19 error_interno = _(u'\n**Error interno al preparar la entrega.**')
20
21 class UserInfo(object): #{{{
22     def __init__(self, user):
23         try:
24             info = pwd.getpwnam(user)
25         except:
26             info = pwd.get(int(user))
27         self.user = info[0]
28         self.uid = info[2]
29         self.gid = info[3]
30         self.name = info[4]
31         self.home = info[5]
32         self.shell = info[6]
33         self.group = grp.getgrgid(self.gid)[0]
34 #}}}
35
36 user_info = UserInfo(config.get('sercom.tester.user', 65534))
37
38 def check_call(*popenargs, **kwargs): #{{{ XXX Python 2.5 forward-compatibility
39     """Run command with arguments.  Wait for command to complete.  If
40     the exit code was zero then return, otherwise raise
41     CalledProcessError.  The CalledProcessError object will have the
42     return code in the returncode attribute.
43     ret = call(*popenargs, **kwargs)
44
45     The arguments are the same as for the Popen constructor.  Example:
46
47     check_call(["ls", "-l"])
48     """
49     retcode = sp.call(*popenargs, **kwargs)
50     cmd = kwargs.get("args")
51     if cmd is None:
52         cmd = popenargs[0]
53     if retcode:
54         raise sp.CalledProcessError(retcode, cmd)
55     return retcode
56 sp.check_call = check_call
57 #}}}
58
59 #{{{ Excepciones
60
61 class CalledProcessError(Exception): #{{{ XXX Python 2.5 forward-compatibility
62     """This exception is raised when a process run by check_call() returns
63     a non-zero exit status.  The exit status will be stored in the
64     returncode attribute."""
65     def __init__(self, returncode, cmd):
66         self.returncode = returncode
67         self.cmd = cmd
68     def __str__(self):
69         return ("Command '%s' returned non-zero exit status %d"
70             % (self.cmd, self.returncode))
71 sp.CalledProcessError = CalledProcessError
72 #}}}
73
74 class Error(StandardError): pass
75
76 class ExecutionFailure(Error, RuntimeError): #{{{
77     def __init__(self, comando, tarea=None, caso_de_prueba=None):
78         self.comando = comando
79         self.tarea = tarea
80         self.caso_de_prueba = caso_de_prueba
81 #}}}
82
83 class RsyncError(Error, EnvironmentError): pass
84
85 #}}}
86
87 def unzip(bytes, default_dst='.', specific_dst=dict()): # {{{
88     u"""Descomprime un buffer de datos en formato ZIP.
89     Los archivos se descomprimen en default_dst a menos que exista una entrada
90     en specific_dst cuya clave sea el nombre de archivo a descomprimir, en
91     cuyo caso, se descomprime usando como destino el valor de dicha clave.
92     """
93     log.debug(_(u'Intentando descomprimir'))
94     if bytes is None:
95         return
96     zfile = ZipFile(StringIO(bytes), 'r')
97     for f in zfile.namelist():
98         dst = join(specific_dst.get(f, default_dst), f)
99         if f.endswith(os.sep):
100             log.debug(_(u'Creando directorio "%s" en "%s"'), f, dst)
101             os.mkdir(dst)
102         else:
103             log.debug(_(u'Descomprimiendo archivo "%s" en "%s"'), f, dst)
104             file(dst, 'w').write(zfile.read(f))
105     zfile.close()
106 #}}}
107
108 class SecureProcess(object): #{{{
109     default = dict(
110         max_tiempo_cpu      = 120,
111         max_memoria         = 16,
112         max_tam_archivo     = 5,
113         max_cant_archivos   = 5,
114         max_cant_procesos   = 0,
115         max_locks_memoria   = 0,
116     )
117     uid = config.get('sercom.tester.chroot.user', 65534)
118     MB = 1048576
119     # XXX probar! make de un solo archivo lleva nproc=100 y nofile=15
120     def __init__(self, comando, chroot, cwd, close_stdin=False,
121                  close_stdout=False, close_stderr=False):
122         self.comando = comando
123         self.chroot = chroot
124         self.cwd = cwd
125         self.close_stdin = close_stdin
126         self.close_stdout = close_stdout
127         self.close_stderr = close_stderr
128         log.debug(_(u'Proceso segurizado: chroot=%s, cwd=%s, user=%s, cpu=%s, '
129             u'as=%sMiB, fsize=%sMiB, nofile=%s, nproc=%s, memlock=%s'),
130             self.chroot, self.cwd, self.uid, self.max_tiempo_cpu,
131             self.max_memoria, self.max_tam_archivo, self.max_cant_archivos,
132             self.max_cant_procesos, self.max_locks_memoria)
133     def __getattr__(self, name):
134         if getattr(self.comando, name) is not None:
135             return getattr(self.comando, name)
136         return config.get('sercom.tester.limits.' + name, self.default[name])
137     def __call__(self):
138         x2 = lambda x: (x, x)
139         if self.close_stdin:
140             os.close(0)
141         if self.close_stdout:
142             os.close(1)
143         if self.close_stderr:
144             os.close(2)
145         os.chroot(self.chroot)
146         os.chdir(self.cwd)
147         uinfo = UserInfo(self.uid)
148         os.setgid(uinfo.gid)
149         os.setuid(uinfo.uid) # Somos mortales irreversiblemente
150         rsrc.setrlimit(rsrc.RLIMIT_CPU, x2(self.max_tiempo_cpu))
151         rsrc.setrlimit(rsrc.RLIMIT_AS, x2(self.max_memoria*self.MB))
152         rsrc.setrlimit(rsrc.RLIMIT_FSIZE, x2(self.max_tam_archivo*self.MB)) # XXX calcular en base a archivos esperados?
153         rsrc.setrlimit(rsrc.RLIMIT_NOFILE, x2(self.max_cant_archivos)) #XXX Obtener de archivos esperados?
154         rsrc.setrlimit(rsrc.RLIMIT_NPROC, x2(self.max_cant_procesos))
155         rsrc.setrlimit(rsrc.RLIMIT_MEMLOCK, x2(self.max_locks_memoria))
156         rsrc.setrlimit(rsrc.RLIMIT_CORE, x2(0))
157         # Tratamos de forzar un sync para que entre al sleep del padre FIXME
158         import time
159         time.sleep(0)
160 #}}}
161
162 class Tester(object): #{{{
163
164     def __init__(self, name, path, home, queue): #{{{ y properties
165         self.name = name
166         self.path = path
167         self.home = home
168         self.queue = queue
169         # Ahora somos mortales (oid mortales)
170         log.debug(_(u'Cambiando usuario y grupo efectivos a %s:%s (%s:%s)'),
171             user_info.user, user_info.group, user_info.uid, user_info.gid)
172         os.setegid(user_info.gid)
173         os.seteuid(user_info.uid)
174
175     @property
176     def build_path(self):
177         return join(self.chroot, self.home, 'build')
178
179     @property
180     def test_path(self):
181         return join(self.chroot, self.home, 'test')
182
183     @property
184     def chroot(self):
185         return join(self.path, 'chroot_' + self.name)
186
187     @property
188     def orig_chroot(self):
189         return join(self.path, 'chroot')
190     #}}}
191
192     def run(self): #{{{
193         entrega_id = self.queue.get() # blocking
194         while entrega_id is not None:
195             entrega = Entrega.get(entrega_id)
196             log.debug(_(u'Nueva entrega para probar en tester %s: %s'),
197                 self.name, entrega)
198             self.test(entrega)
199             log.debug(_(u'Fin de pruebas de: %s'), entrega)
200             entrega_id = self.queue.get() # blocking
201     #}}}
202
203     def test(self, entrega): #{{{
204         log.debug(_(u'Tester.test(entrega=%s)'), entrega)
205         entrega.inicio_tareas = datetime.now()
206         try:
207             try:
208                 self.setup_chroot(entrega)
209                 self.ejecutar_tareas_fuente(entrega)
210                 self.ejecutar_tareas_prueba(entrega)
211                 self.clean_chroot(entrega)
212             except ExecutionFailure, e:
213                 entrega.correcta = False
214                 log.info(_(u'Entrega incorrecta: %s'), entrega)
215             except Exception, e:
216                 if isinstance(e, SystemExit): raise
217                 entrega.observaciones += error_interno
218                 log.exception(_('Hubo una excepcion inesperada')) # FIXME encoding
219             except:
220                 entrega.observaciones += error_interno
221                 log.exception(_('Hubo una excepcion inesperada desconocida')) # FIXME encoding
222             else:
223                 entrega.correcta = True
224                 log.debug(_(u'Entrega correcta: %s'), entrega)
225         finally:
226             entrega.fin_tareas = datetime.now()
227     #}}}
228
229     def setup_chroot(self, entrega): #{{{ y clean_chroot()
230         log.debug(_(u'Tester.setup_chroot(entrega=%s)'), entrega.shortrepr())
231         rsync = ('rsync', '--stats', '--itemize-changes', '--human-readable',
232             '--archive', '--acls', '--delete-during', '--force', # TODO config
233             join(self.orig_chroot, ''), self.chroot)
234         log.debug(_(u'Ejecutando como root: %s'), ' '.join(rsync))
235         os.seteuid(0) # Dios! (para chroot)
236         os.setegid(0)
237         try:
238             sp.check_call(rsync)
239         finally:
240             log.debug(_(u'Cambiando usuario y grupo efectivos a %s:%s (%s:%s)'),
241                 user_info.user, user_info.group, user_info.uid, user_info.gid)
242             os.setegid(user_info.gid) # Mortal de nuevo
243             os.seteuid(user_info.uid)
244         unzip(entrega.archivos, self.build_path)
245
246     def clean_chroot(self, entrega):
247         log.debug(_(u'Tester.clean_chroot(entrega=%s)'), entrega.shortrepr())
248         pass # Se limpia con el próximo rsync
249     #}}}
250
251     def ejecutar_tareas_fuente(self, entrega): #{{{ y tareas_prueba
252         log.debug(_(u'Tester.ejecutar_tareas_fuente(entrega=%s)'),
253             entrega.shortrepr())
254         tareas = [t for t in entrega.instancia.ejercicio.enunciado.tareas
255                     if isinstance(t, TareaFuente)]
256         for tarea in tareas:
257             tarea.ejecutar(self.build_path, entrega)
258
259     def ejecutar_tareas_prueba(self, entrega):
260         log.debug(_(u'Tester.ejecutar_tareas_prueba(entrega=%s)'),
261             entrega.shortrepr())
262         for caso in entrega.instancia.ejercicio.enunciado.casos_de_prueba:
263             caso.ejecutar(self.test_path, entrega)
264     #}}}
265
266 #}}}
267
268 def ejecutar_caso_de_prueba(self, path, entrega): #{{{
269     log.debug(_(u'CasoDePrueba.ejecutar(path=%s, entrega=%s)'), path,
270         entrega.shortrepr())
271     tareas = [t for t in entrega.instancia.ejercicio.enunciado.tareas
272                 if isinstance(t, TareaPrueba)]
273     prueba = entrega.add_prueba(self)
274     try:
275         try:
276             for tarea in tareas:
277                 tarea.ejecutar(path, prueba)
278         except ExecutionFailure, e:
279             prueba.exito = False
280             if self.rechazar_si_falla:
281                 entrega.exito = False
282             if self.terminar_si_falla:
283                 raise ExecutionFailure(e.comando, e.tarea, self)
284         else:
285             prueba.exito = True
286     finally:
287         prueba.fin = datetime.now()
288 CasoDePrueba.ejecutar = ejecutar_caso_de_prueba
289 #}}}
290
291 def ejecutar_tarea_fuente(self, path, entrega): #{{{
292     log.debug(_(u'TareaFuente.ejecutar(path=%s, entrega=%s)'), path,
293         entrega.shortrepr())
294     try:
295         for cmd in self.comandos:
296             cmd.ejecutar(path, entrega)
297     except ExecutionFailure, e:
298         if self.rechazar_si_falla:
299             entrega.exito = False
300         if self.terminar_si_falla:
301             raise ExecutionFailure(e.comando, self)
302 TareaFuente.ejecutar = ejecutar_tarea_fuente
303 #}}}
304
305 def ejecutar_tarea_prueba(self, path, prueba): #{{{
306     log.debug(_(u'TareaPrueba.ejecutar(path=%s, prueba=%s)'), path,
307         prueba.shortrepr())
308     try:
309         for cmd in self.comandos:
310             cmd.ejecutar(path, prueba)
311     except ExecutionFailure, e:
312         if self.rechazar_si_falla:
313             prueba.exito = False
314         if self.terminar_si_falla:
315             raise ExecutionFailure(e.comando, self)
316 TareaPrueba.ejecutar = ejecutar_tarea_prueba
317 #}}}
318
319 def ejecutar_comando_fuente(self, path, entrega): #{{{
320     log.debug(_(u'ComandoFuente.ejecutar(path=%s, entrega=%s)'), path,
321         entrega.shortrepr())
322     comando_ejecutado = entrega.add_comando_ejecutado(self)
323     basetmp = '/tmp/sercom.tester.fuente' # FIXME TODO /var/run/sercom?
324     unzip(self.archivos_entrada, path, # TODO try/except
325         {self.STDIN: '%s.%s.stdin' % (basetmp, comando_ejecutado.id)})
326     options = dict(
327         close_fds=True,
328         shell=True,
329         preexec_fn=SecureProcess(self, 'var/chroot_pepe', '/home/sercom/build')
330     )
331     if os.path.exists('%s.%s.stdin' % (basetmp, comando_ejecutado.id)):
332         options['stdin'] = file('%s.%s.stdin' % (basetmp, comando_ejecutado.id),
333             'r')
334     else:
335         options['preexec_fn'].close_stdin = True
336     a_guardar = set(self.archivos_a_guardar)
337     if self.archivos_a_comparar:
338         zip_a_comparar = ZipFile(StringIO(self.archivos_a_comparar), 'r')
339         a_comparar = set(zip_a_comparar.namelist())
340     else:
341         zip_a_comparar = None
342         a_comparar = frozenset()
343     a_usar = frozenset(a_guardar | a_comparar)
344     if self.STDOUTERR in a_usar:
345         options['stdout'] = file('%s.%s.stdouterr' % (basetmp,
346             comando_ejecutado.id), 'w')
347         options['stderr'] = sp.STDOUT
348     else:
349         if self.STDOUT in a_usar:
350             options['stdout'] = file('%s.%s.stdout' % (basetmp,
351                 comando_ejecutado.id), 'w')
352         else:
353             options['preexec_fn'].close_stdout = True
354         if self.STDERR in a_usar:
355             options['stderr'] = file('%s.%s.stderr' % (basetmp,
356                 comando_ejecutado.id), 'w')
357         else:
358             options['preexec_fn'].close_stderr = True
359     log.debug(_(u'Ejecutando como root: %s'), self.comando)
360     os.seteuid(0) # Dios! (para chroot)
361     os.setegid(0)
362     try:
363         try:
364             proc = sp.Popen(self.comando, **options)
365         finally:
366             log.debug(_(u'Cambiando usuario y grupo efectivos a %s:%s (%s:%s)'),
367                 user_info.user, user_info.group, user_info.uid, user_info.gid)
368             os.setegid(user_info.gid) # Mortal de nuevo
369             os.seteuid(user_info.uid)
370     except Exception, e:
371         if hasattr(e, 'child_traceback'):
372             log.error(_(u'Error en el hijo: %s'), e.child_traceback)
373         raise
374     proc.wait() #TODO un sleep grande nos caga todo, ver sercom viejo
375     if self.retorno != self.RET_ANY:
376         if self.retorno == self.RET_FAIL:
377             if proc.returncode == 0:
378                 if self.rechazar_si_falla:
379                     entrega.correcta = False
380                 comando_ejecutado.exito = False
381                 comando_ejecutado.observaciones += _(u'Se esperaba que el '
382                     u'programa termine con un error (código de retorno '
383                     u'distinto de 0) pero terminó bien (código de retorno '
384                     u'0).\n')
385                 log.debug(_(u'Se esperaba que el programa termine '
386                     u'con un error (código de retorno distinto de 0) pero '
387                     u'terminó bien (código de retorno 0).\n'))
388         elif self.retorno != proc.returncode:
389             if self.rechazar_si_falla:
390                 entrega.correcta = False
391             comando_ejecutado.exito = False
392             if proc.returncode < 0:
393                 comando_ejecutado.observaciones += _(u'Se esperaba terminar '
394                     u'con un código de retorno %s pero se obtuvo una señal %s '
395                     u'(%s).\n') % (self.retorno, -proc.returncode,
396                         -proc.returncode) # TODO poner con texto
397                 log.debug(_(u'Se esperaba terminar con un código '
398                     u'de retorno %s pero se obtuvo una señal %s (%s).\n'),
399                     self.retorno, -proc.returncode, -proc.returncode)
400             else:
401                 comando_ejecutado.observaciones += _(u'Se esperaba terminar '
402                     u'con un código de retorno %s pero se obtuvo %s.\n') \
403                     % (self.retorno, proc.returncode)
404                 log.debug(_(u'Se esperaba terminar con un código de retorno '
405                     u'%s pero se obtuvo %s.\n'), self.retorno, proc.returncode)
406     if comando_ejecutado.exito is None:
407         log.debug(_(u'Código de retorno OK'))
408     comando_ejecutado.fin = datetime.now()
409     if a_guardar:
410         buffer = StringIO()
411         zip = ZipFile(buffer, 'w')
412         # Guardamos stdout/stderr
413         if self.STDOUTERR in a_guardar:
414             a_guardar.remove(self.STDOUTERR)
415             zip.write('%s.%s.stdouterr' % (basetmp, comando_ejecutado.id),
416                 self.STDOUTERR)
417         else:
418             if self.STDOUT in a_guardar:
419                 a_guardar.remove(self.STDOUT)
420                 zip.write('%s.%s.stdout' % (basetmp, comando_ejecutado.id),
421                     self.STDOUT)
422             if self.STDERR in a_guardar:
423                 a_guardar.remove(self.STDERR)
424                 zip.write('%s.%s.stderr' % (basetmp, comando_ejecutado.id),
425                     self.STDERR)
426         # Guardamos otros
427         for f in a_guardar:
428             if not os.path.exists(join(path, f)):
429                 if self.rechazar_si_falla:
430                     entrega.correcta = False
431                 comando_ejecutado.exito = False
432                 comando_ejecutado.observaciones += _(u'Se esperaba un archivo '
433                     u'"%s" para guardar pero no fue encontrado.\n') % f
434                 log.debug(_(u'Se esperaba un archivo "%s" para guardar pero '
435                     u'no fue encontrado'), f)
436             else:
437                 zip.write(join(path, f), f)
438         zip.close()
439         comando_ejecutado.archivos_guardados = buffer.getvalue()
440     def diff(new, zip_in, zip_out, name, longname=None, origname='correcto',
441              newname='entregado'):
442         if longname is None:
443             longname = name
444         new = file(new, 'r').readlines()
445         orig = zip_in.read(name).split('\n')
446         udiff = ''.join(list(unified_diff(orig, new, fromfile=name+'.'+origname,
447             tofile=name+'.'+newname)))
448         if udiff:
449             if self.rechazar_si_falla:
450                 entrega.correcta = False
451             comando_ejecutado.exito = False
452             comando_ejecutado.observaciones += _(u'%s no coincide con lo '
453                 u'esperado (archivo "%s.diff").\n') % (longname, name)
454             log.debug(_(u'%s no coincide con lo esperado (archivo "%s.diff")'),
455                 longname, name)
456             htmldiff = HtmlDiff().make_file(orig, new,
457                 fromdesc=name+'.'+origname, todesc=name+'.'+newname,
458                 context=True, numlines=3)
459             zip_out.writestr(name + '.diff', udiff)
460             zip_out.writestr(name + '.diff.html', htmldiff)
461             return True
462         else:
463             return False
464     if a_comparar:
465         buffer = StringIO()
466         zip = ZipFile(buffer, 'w')
467         # Comparamos stdout/stderr
468         if self.STDOUTERR in a_comparar:
469             a_comparar.remove(self.STDOUTERR)
470             diff('%s.%s.stdouterr' % (basetmp, comando_ejecutado.id),
471                 zip_a_comparar, zip, self.STDOUTERR,
472                 _(u'La salida estándar y de error combinada'))
473         else:
474             if self.STDOUT in a_comparar:
475                 a_comparar.remove(self.STDOUT)
476                 diff('%s.%s.stdout' % (basetmp, comando_ejecutado.id),
477                     zip_a_comparar, zip, self.STDOUT, _(u'La salida estándar'))
478             if self.STDERR in a_comparar:
479                 a_comparar.remove(self.STDERR)
480                 diff('%s.%s.stderr' % (basetmp, comando_ejecutado.id),
481                     zip_a_comparar, zip, self.STDERR, _(u'La salida de error'))
482         # Comparamos otros
483         for f in a_comparar:
484             if not os.path.exists(join(path, f)):
485                 if self.rechazar_si_falla:
486                     entrega.correcta = False
487                 comando_ejecutado.exito = False
488                 comando_ejecutado.observaciones += _(u'Se esperaba un archivo '
489                     u'"%s" para comparar pero no fue encontrado') % f
490                 log.debug(_(u'Se esperaba un archivo "%s" para comparar pero '
491                     u'no fue encontrado'), f)
492             else:
493                 diff(join(path, f), zip_a_comparar, zip, f)
494         zip.close()
495         comando_ejecutado.archivos_guardados = buffer.getvalue()
496     if comando_ejecutado.exito is None:
497         comando_ejecutado.exito = True
498     elif self.terminar_si_falla:
499         raise ExecutionFailure(self)
500
501 ComandoFuente.ejecutar = ejecutar_comando_fuente
502 #}}}
503
504 def ejecutar_comando_prueba(self, path, prueba): #{{{
505     log.debug(_(u'ComandoPrueba.ejecutar(path=%s, prueba=%s)'), path,
506         prueba.shortrepr())
507     rmtree(path)
508     os.mkdir(path)
509     unzip(prueba.caso_de_prueba.archivos_entrada, path) # TODO try/except
510     unzip(self.archivos_entrada, path) # TODO try/except
511     comando_ejecutado = prueba.add_comando_ejecutado(self)
512     # TODO ejecutar en chroot (path)
513     comando_ejecutado.fin = datetime.now()
514 #    if no_anda_ejecucion: # TODO
515 #        comando_ejecutado.exito = False
516 #        comando_ejecutado.observaciones += 'No anduvo xxx' # TODO
517 #        if self.rechazar_si_falla:
518 #            entrega.exito = False
519 #        if self.terminar_si_falla: # TODO
520 #            raise ExecutionFailure(self) # TODO info de error
521 #    for archivo in self.archivos_salida:
522 #        pass # TODO hacer diff
523 #    if archivos_mal: # TODO
524 #        comando_ejecutado.exito = False
525 #        comando_ejecutado.observaciones += 'No anduvo xxx' # TODO
526 #        if self.rechazar_si_falla:
527 #            entrega.exito = False
528 #        if self.terminar_si_falla: # TODO
529 #            raise ExecutionFailure(comando=self) # TODO info de error
530 #    else:
531 #        comando_ejecutado.exito = True
532 #        comando_ejecutado.observaciones += 'xxx OK' # TODO
533     comando_ejecutado.exito = True
534     comando_ejecutado.observaciones += 'xxx OK' # TODO
535 ComandoPrueba.ejecutar = ejecutar_comando_prueba
536 #}}}
537