]> git.llucax.com Git - z.facultad/75.52/sercom.git/blob - sercom/tester.py
actualizo data de test para que sea coherente
[z.facultad/75.52/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, Tarea, TareaFuente, TareaPrueba
4 from sercom.model import 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 #}}}
84
85 def unzip(bytes, default_dst='.', specific_dst=dict()): # {{{
86     u"""Descomprime un buffer de datos en formato ZIP.
87     Los archivos se descomprimen en default_dst a menos que exista una entrada
88     en specific_dst cuya clave sea el nombre de archivo a descomprimir, en
89     cuyo caso, se descomprime usando como destino el valor de dicha clave.
90     """
91     log.debug(_(u'Intentando descomprimir'))
92     if bytes is None:
93         return
94     zfile = ZipFile(StringIO(bytes), 'r')
95     for f in zfile.namelist():
96         dst = join(specific_dst.get(f, default_dst), f)
97         if f.endswith(os.sep):
98             log.debug(_(u'Creando directorio "%s" en "%s"'), f, dst)
99             os.mkdir(dst)
100         else:
101             log.debug(_(u'Descomprimiendo archivo "%s" en "%s"'), f, dst)
102             file(dst, 'w').write(zfile.read(f))
103     zfile.close()
104 #}}}
105
106 class SecureProcess(object): #{{{
107     default = dict(
108         max_tiempo_cpu      = 120,
109         max_memoria         = 16,
110         max_tam_archivo     = 5,
111         max_cant_archivos   = 5,
112         max_cant_procesos   = 0,
113         max_locks_memoria   = 0,
114     )
115     uid = config.get('sercom.tester.chroot.user', 65534)
116     MB = 1048576
117     # XXX probar! make de un solo archivo lleva nproc=100 y nofile=15
118     def __init__(self, comando, chroot, cwd, close_stdin=False,
119                  close_stdout=False, close_stderr=False):
120         self.comando = comando
121         self.chroot = chroot
122         self.cwd = cwd
123         self.close_stdin = close_stdin
124         self.close_stdout = close_stdout
125         self.close_stderr = close_stderr
126         log.debug(_(u'Proceso segurizado: chroot=%s, cwd=%s, user=%s, cpu=%s, '
127             u'as=%sMiB, fsize=%sMiB, nofile=%s, nproc=%s, memlock=%s'),
128             self.chroot, self.cwd, self.uid, self.max_tiempo_cpu,
129             self.max_memoria, self.max_tam_archivo, self.max_cant_archivos,
130             self.max_cant_procesos, self.max_locks_memoria)
131     def __getattr__(self, name):
132         if getattr(self.comando, name) is not None:
133             return getattr(self.comando, name)
134         return config.get('sercom.tester.limits.' + name, self.default[name])
135     def __call__(self):
136         x2 = lambda x: (x, x)
137         if self.close_stdin:
138             os.close(0)
139         if self.close_stdout:
140             os.close(1)
141         if self.close_stderr:
142             os.close(2)
143         os.chroot(self.chroot)
144         os.chdir(self.cwd)
145         uinfo = UserInfo(self.uid)
146         os.setgid(uinfo.gid)
147         os.setuid(uinfo.uid) # Somos mortales irreversiblemente
148         rsrc.setrlimit(rsrc.RLIMIT_CPU, x2(self.max_tiempo_cpu))
149         rsrc.setrlimit(rsrc.RLIMIT_AS, x2(self.max_memoria*self.MB))
150         rsrc.setrlimit(rsrc.RLIMIT_FSIZE, x2(self.max_tam_archivo*self.MB)) # XXX calcular en base a archivos esperados?
151         rsrc.setrlimit(rsrc.RLIMIT_NOFILE, x2(self.max_cant_archivos)) #XXX Obtener de archivos esperados?
152         rsrc.setrlimit(rsrc.RLIMIT_NPROC, x2(self.max_cant_procesos))
153         rsrc.setrlimit(rsrc.RLIMIT_MEMLOCK, x2(self.max_locks_memoria))
154         rsrc.setrlimit(rsrc.RLIMIT_CORE, x2(0))
155         # Tratamos de forzar un sync para que entre al sleep del padre FIXME
156         import time
157         time.sleep(0)
158 #}}}
159
160 class Tester(object): #{{{
161
162     def __init__(self, name, path, home, queue): #{{{ y properties
163         self.name = name
164         self.path = path
165         self.home = home
166         self.queue = queue
167         # Ahora somos mortales (oid mortales)
168         os.setegid(user_info.gid)
169         os.seteuid(user_info.uid)
170         log.debug(_(u'usuario y grupo efectivos cambiados a %s:%s (%s:%s)'),
171             user_info.user, user_info.group, user_info.uid, user_info.gid)
172
173     @property
174     def build_path(self):
175         return join(self.chroot, self.home, 'build')
176
177     @property
178     def test_path(self):
179         return join(self.chroot, self.home, 'test')
180
181     @property
182     def chroot(self):
183         return join(self.path, 'chroot_' + self.name)
184
185     @property
186     def orig_chroot(self):
187         return join(self.path, 'chroot')
188     #}}}
189
190     def run(self): #{{{
191         entrega_id = self.queue.get() # blocking
192         while entrega_id is not None:
193             entrega = Entrega.get(entrega_id)
194             log.debug(_(u'Nueva entrega para probar en tester %s: %s'),
195                 self.name, entrega)
196             self.test(entrega)
197             log.debug(_(u'Fin de pruebas de: %s'), entrega)
198             entrega_id = self.queue.get() # blocking
199     #}}}
200
201     def test(self, entrega): #{{{
202         log.debug(_(u'Tester.test(entrega=%s)'), entrega)
203         entrega.inicio = datetime.now()
204         try:
205             try:
206                 self.setup_chroot(entrega)
207                 self.ejecutar_tareas_fuente(entrega)
208                 self.ejecutar_tareas_prueba(entrega)
209                 self.clean_chroot(entrega)
210             except ExecutionFailure, e:
211                 entrega.exito = False
212                 log.info(_(u'Entrega incorrecta: %s'), entrega)
213             except Exception, e:
214                 if isinstance(e, SystemExit): raise
215                 entrega.observaciones += error_interno
216                 log.exception(_('Hubo una excepcion inesperada')) # FIXME encoding
217             except:
218                 entrega.observaciones += error_interno
219                 log.exception(_('Hubo una excepcion inesperada desconocida')) # FIXME encoding
220             else:
221                 entrega.exito = True
222                 log.debug(_(u'Entrega correcta: %s'), entrega)
223         finally:
224             entrega.fin = datetime.now()
225     #}}}
226
227     def setup_chroot(self, entrega): #{{{ y clean_chroot()
228         log.debug(_(u'Tester.setup_chroot(entrega=%s)'), entrega.shortrepr())
229         rsync = ('rsync', '--stats', '--itemize-changes', '--human-readable',
230             '--archive', '--acls', '--delete-during', '--force', # TODO config
231             join(self.orig_chroot, ''), self.chroot)
232         log.debug(_(u'Ejecutando como root: %s'), ' '.join(rsync))
233         os.seteuid(0) # Dios! (para chroot)
234         os.setegid(0)
235         try:
236             sp.check_call(rsync)
237         finally:
238             os.setegid(user_info.gid) # Mortal de nuevo
239             os.seteuid(user_info.uid)
240             log.debug(_(u'Usuario y grupo efectivos cambiados a %s:%s (%s:%s)'),
241                 user_info.user, user_info.group, user_info.uid, user_info.gid)
242         unzip(entrega.archivos, self.build_path)
243
244     def clean_chroot(self, entrega):
245         log.debug(_(u'Tester.clean_chroot(entrega=%s)'), entrega.shortrepr())
246         pass # Se limpia con el próximo rsync
247     #}}}
248
249     def ejecutar_tareas_fuente(self, entrega): #{{{ y tareas_prueba
250         log.debug(_(u'Tester.ejecutar_tareas_fuente(entrega=%s)'),
251             entrega.shortrepr())
252         tareas = [t for t in entrega.instancia.ejercicio.enunciado.tareas
253                     if isinstance(t, TareaFuente)]
254         for tarea in tareas:
255             tarea.ejecutar(self.build_path, entrega)
256
257     def ejecutar_tareas_prueba(self, entrega):
258         log.debug(_(u'Tester.ejecutar_tareas_prueba(entrega=%s)'),
259             entrega.shortrepr())
260         for caso in entrega.instancia.ejercicio.enunciado.casos_de_prueba:
261             caso.ejecutar(self.test_path, entrega)
262     #}}}
263
264 #}}}
265
266 def ejecutar_caso_de_prueba(self, path, entrega): #{{{
267     log.debug(_(u'CasoDePrueba.ejecutar(path=%s, entrega=%s)'), path,
268         entrega.shortrepr())
269     tareas = [t for t in entrega.instancia.ejercicio.enunciado.tareas
270                 if isinstance(t, TareaPrueba)]
271     prueba = entrega.add_prueba(self)
272     try:
273         try:
274             for tarea in tareas:
275                 tarea.ejecutar(path, prueba)
276         except ExecutionFailure, e:
277             prueba.exito = False
278             if self.rechazar_si_falla:
279                 entrega.exito = False
280             if self.terminar_si_falla:
281                 raise ExecutionFailure(e.comando, e.tarea, self)
282         else:
283             prueba.exito = True
284     finally:
285         prueba.fin = datetime.now()
286 CasoDePrueba.ejecutar = ejecutar_caso_de_prueba
287 #}}}
288
289 def ejecutar_tarea(self, path, ejecucion): #{{{
290     log.debug(_(u'Tarea.ejecutar(path=%s, ejecucion=%s)'), path,
291         ejecucion.shortrepr())
292     for cmd in self.comandos:
293         cmd.ejecutar(path, ejecucion)
294 Tarea.ejecutar = ejecutar_tarea
295 #}}}
296
297 # TODO generalizar ejecutar_comando_xxxx!!!
298
299 def ejecutar_comando_fuente(self, path, entrega): #{{{
300     log.debug(_(u'ComandoFuente.ejecutar(path=%s, entrega=%s)'), path,
301         entrega.shortrepr())
302     comando_ejecutado = entrega.add_comando_ejecutado(self) # TODO debería rodear solo la ejecución del comando
303     basetmp = '/tmp/sercom.tester.fuente' # FIXME TODO /var/run/sercom?
304     unzip(self.archivos_entrada, path, # TODO try/except
305         {self.STDIN: '%s.%s.stdin' % (basetmp, comando_ejecutado.id)})
306     options = dict(
307         close_fds=True,
308         shell=True,
309         preexec_fn=SecureProcess(self, 'var/chroot_pepe', '/home/sercom/build') #FIXME!!! path
310     )
311     if os.path.exists('%s.%s.stdin' % (basetmp, comando_ejecutado.id)):
312         options['stdin'] = file('%s.%s.stdin' % (basetmp, comando_ejecutado.id),
313             'r')
314     else:
315         options['preexec_fn'].close_stdin = True
316     a_guardar = set(self.archivos_a_guardar)
317     if self.archivos_a_comparar:
318         zip_a_comparar = ZipFile(StringIO(self.archivos_a_comparar), 'r')
319         a_comparar = set(zip_a_comparar.namelist())
320     else:
321         zip_a_comparar = None
322         a_comparar = frozenset()
323     a_usar = frozenset(a_guardar | a_comparar)
324     if self.STDOUTERR in a_usar:
325         options['stdout'] = file('%s.%s.stdouterr' % (basetmp,
326             comando_ejecutado.id), 'w')
327         options['stderr'] = sp.STDOUT
328     else:
329         if self.STDOUT in a_usar:
330             options['stdout'] = file('%s.%s.stdout' % (basetmp,
331                 comando_ejecutado.id), 'w')
332         else:
333             options['preexec_fn'].close_stdout = True
334         if self.STDERR in a_usar:
335             options['stderr'] = file('%s.%s.stderr' % (basetmp,
336                 comando_ejecutado.id), 'w')
337         else:
338             options['preexec_fn'].close_stderr = True
339     log.debug(_(u'Ejecutando como root: %s'), self.comando)
340     os.seteuid(0) # Dios! (para chroot)
341     os.setegid(0)
342     try:
343         try:
344             proc = sp.Popen(self.comando, **options)
345         finally:
346             os.setegid(user_info.gid) # Mortal de nuevo
347             os.seteuid(user_info.uid)
348             log.debug(_(u'Usuario y grupo efectivos cambiados a %s:%s (%s:%s)'),
349                 user_info.user, user_info.group, user_info.uid, user_info.gid)
350     except Exception, e:
351         if hasattr(e, 'child_traceback'):
352             log.error(_(u'Error en el hijo: %s'), e.child_traceback)
353         raise
354     proc.wait() #TODO un sleep grande nos caga todo, ver sercom viejo
355     comando_ejecutado.fin = datetime.now() # TODO debería rodear solo la ejecución del comando
356     if self.retorno != self.RET_ANY:
357         if self.retorno == self.RET_FAIL:
358             if proc.returncode == 0:
359                 if self.rechazar_si_falla:
360                     entrega.exito = False
361                 comando_ejecutado.exito = False
362                 comando_ejecutado.observaciones += _(u'Se esperaba que el '
363                     u'programa termine con un error (código de retorno '
364                     u'distinto de 0) pero terminó bien (código de retorno '
365                     u'0).\n')
366                 log.debug(_(u'Se esperaba que el programa termine '
367                     u'con un error (código de retorno distinto de 0) pero '
368                     u'terminó bien (código de retorno 0).\n'))
369         elif self.retorno != proc.returncode:
370             if self.rechazar_si_falla:
371                 entrega.exito = False
372             comando_ejecutado.exito = False
373             if proc.returncode < 0:
374                 comando_ejecutado.observaciones += _(u'Se esperaba terminar '
375                     u'con un código de retorno %s pero se obtuvo una señal %s '
376                     u'(%s).\n') % (self.retorno, -proc.returncode,
377                         -proc.returncode) # TODO poner con texto
378                 log.debug(_(u'Se esperaba terminar con un código '
379                     u'de retorno %s pero se obtuvo una señal %s (%s).\n'),
380                     self.retorno, -proc.returncode, -proc.returncode)
381             else:
382                 comando_ejecutado.observaciones += _(u'Se esperaba terminar '
383                     u'con un código de retorno %s pero se obtuvo %s.\n') \
384                     % (self.retorno, proc.returncode)
385                 log.debug(_(u'Se esperaba terminar con un código de retorno '
386                     u'%s pero se obtuvo %s.\n'), self.retorno, proc.returncode)
387     if comando_ejecutado.exito is None:
388         log.debug(_(u'Código de retorno OK'))
389     if a_guardar:
390         buffer = StringIO()
391         zip = ZipFile(buffer, 'w')
392         # Guardamos stdout/stderr
393         if self.STDOUTERR in a_guardar:
394             a_guardar.remove(self.STDOUTERR)
395             zip.write('%s.%s.stdouterr' % (basetmp, comando_ejecutado.id),
396                 self.STDOUTERR)
397         else:
398             if self.STDOUT in a_guardar:
399                 a_guardar.remove(self.STDOUT)
400                 zip.write('%s.%s.stdout' % (basetmp, comando_ejecutado.id),
401                     self.STDOUT)
402             if self.STDERR in a_guardar:
403                 a_guardar.remove(self.STDERR)
404                 zip.write('%s.%s.stderr' % (basetmp, comando_ejecutado.id),
405                     self.STDERR)
406         # Guardamos otros
407         for f in a_guardar:
408             if not os.path.exists(join(path, f)):
409                 if self.rechazar_si_falla:
410                     entrega.exito = False
411                 comando_ejecutado.exito = False
412                 comando_ejecutado.observaciones += _(u'Se esperaba un archivo '
413                     u'"%s" para guardar pero no fue encontrado.\n') % f
414                 log.debug(_(u'Se esperaba un archivo "%s" para guardar pero '
415                     u'no fue encontrado'), f)
416             else:
417                 zip.write(join(path, f), f)
418         zip.close()
419         comando_ejecutado.archivos = buffer.getvalue()
420     def diff(new, zip_in, zip_out, name, longname=None, origname='correcto',
421              newname='entregado'):
422         if longname is None:
423             longname = name
424         new = file(new, 'r').readlines()
425         orig = zip_in.read(name).split('\n')
426         udiff = ''.join(list(unified_diff(orig, new, fromfile=name+'.'+origname,
427             tofile=name+'.'+newname)))
428         if udiff:
429             if self.rechazar_si_falla:
430                 entrega.exito = False
431             comando_ejecutado.exito = False
432             comando_ejecutado.observaciones += _(u'%s no coincide con lo '
433                 u'esperado (archivo "%s.diff").\n') % (longname, name)
434             log.debug(_(u'%s no coincide con lo esperado (archivo "%s.diff")'),
435                 longname, name)
436             htmldiff = HtmlDiff().make_file(orig, new,
437                 fromdesc=name+'.'+origname, todesc=name+'.'+newname,
438                 context=True, numlines=3)
439             zip_out.writestr(name + '.diff', udiff)
440             zip_out.writestr(name + '.diff.html', htmldiff)
441             return True
442         else:
443             return False
444     if a_comparar:
445         buffer = StringIO()
446         zip = ZipFile(buffer, 'w')
447         # Comparamos stdout/stderr
448         if self.STDOUTERR in a_comparar:
449             a_comparar.remove(self.STDOUTERR)
450             diff('%s.%s.stdouterr' % (basetmp, comando_ejecutado.id),
451                 zip_a_comparar, zip, self.STDOUTERR,
452                 _(u'La salida estándar y de error combinada'))
453         else:
454             if self.STDOUT in a_comparar:
455                 a_comparar.remove(self.STDOUT)
456                 diff('%s.%s.stdout' % (basetmp, comando_ejecutado.id),
457                     zip_a_comparar, zip, self.STDOUT, _(u'La salida estándar'))
458             if self.STDERR in a_comparar:
459                 a_comparar.remove(self.STDERR)
460                 diff('%s.%s.stderr' % (basetmp, comando_ejecutado.id),
461                     zip_a_comparar, zip, self.STDERR, _(u'La salida de error'))
462         # Comparamos otros
463         for f in a_comparar:
464             if not os.path.exists(join(path, f)):
465                 if self.rechazar_si_falla:
466                     entrega.exito = False
467                 comando_ejecutado.exito = False
468                 comando_ejecutado.observaciones += _(u'Se esperaba un archivo '
469                     u'"%s" para comparar pero no fue encontrado') % f
470                 log.debug(_(u'Se esperaba un archivo "%s" para comparar pero '
471                     u'no fue encontrado'), f)
472             else:
473                 diff(join(path, f), zip_a_comparar, zip, f)
474         zip.close()
475         comando_ejecutado.diferencias = buffer.getvalue()
476     if comando_ejecutado.exito is None:
477         comando_ejecutado.exito = True
478     elif self.terminar_si_falla:
479         raise ExecutionFailure(self)
480
481 ComandoFuente.ejecutar = ejecutar_comando_fuente
482 #}}}
483
484 def ejecutar_comando_prueba(self, path, prueba): #{{{
485     # Diferencia con comando fuente: s/entrega/prueba/ y s/build/test/ en path
486     # y setup/clean de test.
487     log.debug(_(u'ComandoPrueba.ejecutar(path=%s, prueba=%s)'), path,
488         prueba.shortrepr())
489     comando_ejecutado = prueba.add_comando_ejecutado(self) # TODO debería rodear solo la ejecución del comando
490     basetmp = '/tmp/sercom.tester.prueba' # FIXME TODO /var/run/sercom?
491     #{{{ Código que solo va en ComandoPrueba (setup de directorio)
492     rsync = ('rsync', '--stats', '--itemize-changes', '--human-readable',
493         '--archive', '--acls', '--delete-during', '--force', # TODO config
494         'var/chroot_pepe/home/sercom/build/', path) # FIXME!!!! path
495     log.debug(_(u'Ejecutando como root: %s'), ' '.join(rsync))
496     os.seteuid(0) # Dios! (para chroot)
497     os.setegid(0)
498     try:
499         sp.check_call(rsync)
500     finally:
501         os.setegid(user_info.gid) # Mortal de nuevo
502         os.seteuid(user_info.uid)
503         log.debug(_(u'Usuario y grupo efectivos cambiados a %s:%s (%s:%s)'),
504             user_info.user, user_info.group, user_info.uid, user_info.gid)
505     unzip(prueba.caso_de_prueba.archivos_entrada, path, # TODO try/except
506         {self.STDIN: '%s.%s.stdin' % (basetmp, comando_ejecutado.id)})
507     #}}}
508     unzip(self.archivos_entrada, path, # TODO try/except
509         {self.STDIN: '%s.%s.stdin' % (basetmp, comando_ejecutado.id)})
510     options = dict(
511         close_fds=True,
512         shell=True,
513         preexec_fn=SecureProcess(self, 'var/chroot_pepe', '/home/sercom/test') # FIXME!!!! path
514     )
515     if os.path.exists('%s.%s.stdin' % (basetmp, comando_ejecutado.id)):
516         options['stdin'] = file('%s.%s.stdin' % (basetmp, comando_ejecutado.id),
517             'r')
518     else:
519         options['preexec_fn'].close_stdin = True
520     a_guardar = set(self.archivos_a_guardar)
521     if self.archivos_a_comparar:
522         zip_a_comparar = ZipFile(StringIO(self.archivos_a_comparar), 'r')
523         a_comparar = set(zip_a_comparar.namelist())
524     else:
525         zip_a_comparar = None
526         a_comparar = frozenset()
527     a_usar = frozenset(a_guardar | a_comparar)
528     if self.STDOUTERR in a_usar:
529         options['stdout'] = file('%s.%s.stdouterr' % (basetmp,
530             comando_ejecutado.id), 'w')
531         options['stderr'] = sp.STDOUT
532     else:
533         if self.STDOUT in a_usar:
534             options['stdout'] = file('%s.%s.stdout' % (basetmp,
535                 comando_ejecutado.id), 'w')
536         else:
537             options['preexec_fn'].close_stdout = True
538         if self.STDERR in a_usar:
539             options['stderr'] = file('%s.%s.stderr' % (basetmp,
540                 comando_ejecutado.id), 'w')
541         else:
542             options['preexec_fn'].close_stderr = True
543     log.debug(_(u'Ejecutando como root: %s'), self.comando)
544     os.seteuid(0) # Dios! (para chroot)
545     os.setegid(0)
546     try:
547         try:
548             proc = sp.Popen(self.comando, **options)
549         finally:
550             os.setegid(user_info.gid) # Mortal de nuevo
551             os.seteuid(user_info.uid)
552             log.debug(_(u'Usuario y grupo efectivos cambiados a %s:%s (%s:%s)'),
553                 user_info.user, user_info.group, user_info.uid, user_info.gid)
554     except Exception, e:
555         if hasattr(e, 'child_traceback'):
556             log.error(_(u'Error en el hijo: %s'), e.child_traceback)
557         raise
558     proc.wait() #TODO un sleep grande nos caga todo, ver sercom viejo
559     comando_ejecutado.fin_tareas = datetime.now() # TODO debería rodear solo la ejecución del comando
560     if self.retorno != self.RET_ANY:
561         if self.retorno == self.RET_FAIL:
562             if proc.returncode == 0:
563                 if self.rechazar_si_falla:
564                     prueba.exito = False
565                 comando_ejecutado.exito = False
566                 comando_ejecutado.observaciones += _(u'Se esperaba que el '
567                     u'programa termine con un error (código de retorno '
568                     u'distinto de 0) pero terminó bien (código de retorno '
569                     u'0).\n')
570                 log.debug(_(u'Se esperaba que el programa termine '
571                     u'con un error (código de retorno distinto de 0) pero '
572                     u'terminó bien (código de retorno 0).\n'))
573         elif self.retorno != proc.returncode:
574             if self.rechazar_si_falla:
575                 prueba.exito = False
576             comando_ejecutado.exito = False
577             if proc.returncode < 0:
578                 comando_ejecutado.observaciones += _(u'Se esperaba terminar '
579                     u'con un código de retorno %s pero se obtuvo una señal %s '
580                     u'(%s).\n') % (self.retorno, -proc.returncode,
581                         -proc.returncode) # TODO poner con texto
582                 log.debug(_(u'Se esperaba terminar con un código '
583                     u'de retorno %s pero se obtuvo una señal %s (%s).\n'),
584                     self.retorno, -proc.returncode, -proc.returncode)
585             else:
586                 comando_ejecutado.observaciones += _(u'Se esperaba terminar '
587                     u'con un código de retorno %s pero se obtuvo %s.\n') \
588                     % (self.retorno, proc.returncode)
589                 log.debug(_(u'Se esperaba terminar con un código de retorno '
590                     u'%s pero se obtuvo %s.\n'), self.retorno, proc.returncode)
591     if comando_ejecutado.exito is None:
592         log.debug(_(u'Código de retorno OK'))
593     if a_guardar:
594         buffer = StringIO()
595         zip = ZipFile(buffer, 'w')
596         # Guardamos stdout/stderr
597         if self.STDOUTERR in a_guardar:
598             a_guardar.remove(self.STDOUTERR)
599             zip.write('%s.%s.stdouterr' % (basetmp, comando_ejecutado.id),
600                 self.STDOUTERR)
601         else:
602             if self.STDOUT in a_guardar:
603                 a_guardar.remove(self.STDOUT)
604                 zip.write('%s.%s.stdout' % (basetmp, comando_ejecutado.id),
605                     self.STDOUT)
606             if self.STDERR in a_guardar:
607                 a_guardar.remove(self.STDERR)
608                 zip.write('%s.%s.stderr' % (basetmp, comando_ejecutado.id),
609                     self.STDERR)
610         # Guardamos otros
611         for f in a_guardar:
612             if not os.path.exists(join(path, f)):
613                 if self.rechazar_si_falla:
614                     prueba.exito = False
615                 comando_ejecutado.exito = False
616                 comando_ejecutado.observaciones += _(u'Se esperaba un archivo '
617                     u'"%s" para guardar pero no fue encontrado.\n') % f
618                 log.debug(_(u'Se esperaba un archivo "%s" para guardar pero '
619                     u'no fue encontrado'), f)
620             else:
621                 zip.write(join(path, f), f)
622         zip.close()
623         comando_ejecutado.archivos = buffer.getvalue()
624     def diff(new, zip_in, zip_out, name, longname=None, origname='correcto',
625              newname='entregado'):
626         if longname is None:
627             longname = name
628         new = file(new, 'r').readlines()
629         orig = zip_in.read(name).split('\n')
630         udiff = ''.join(list(unified_diff(orig, new, fromfile=name+'.'+origname,
631             tofile=name+'.'+newname)))
632         if udiff:
633             if self.rechazar_si_falla:
634                 prueba.exito = False
635             comando_ejecutado.exito = False
636             comando_ejecutado.observaciones += _(u'%s no coincide con lo '
637                 u'esperado (archivo "%s.diff").\n') % (longname, name)
638             log.debug(_(u'%s no coincide con lo esperado (archivo "%s.diff")'),
639                 longname, name)
640             htmldiff = HtmlDiff().make_file(orig, new,
641                 fromdesc=name+'.'+origname, todesc=name+'.'+newname,
642                 context=True, numlines=3)
643             zip_out.writestr(name + '.diff', udiff)
644             zip_out.writestr(name + '.diff.html', htmldiff)
645             return True
646         else:
647             return False
648     if a_comparar:
649         buffer = StringIO()
650         zip = ZipFile(buffer, 'w')
651         # Comparamos stdout/stderr
652         if self.STDOUTERR in a_comparar:
653             a_comparar.remove(self.STDOUTERR)
654             diff('%s.%s.stdouterr' % (basetmp, comando_ejecutado.id),
655                 zip_a_comparar, zip, self.STDOUTERR,
656                 _(u'La salida estándar y de error combinada'))
657         else:
658             if self.STDOUT in a_comparar:
659                 a_comparar.remove(self.STDOUT)
660                 diff('%s.%s.stdout' % (basetmp, comando_ejecutado.id),
661                     zip_a_comparar, zip, self.STDOUT, _(u'La salida estándar'))
662             if self.STDERR in a_comparar:
663                 a_comparar.remove(self.STDERR)
664                 diff('%s.%s.stderr' % (basetmp, comando_ejecutado.id),
665                     zip_a_comparar, zip, self.STDERR, _(u'La salida de error'))
666         # Comparamos otros
667         for f in a_comparar:
668             if not os.path.exists(join(path, f)):
669                 if self.rechazar_si_falla:
670                     prueba.exito = False
671                 comando_ejecutado.exito = False
672                 comando_ejecutado.observaciones += _(u'Se esperaba un archivo '
673                     u'"%s" para comparar pero no fue encontrado') % f
674                 log.debug(_(u'Se esperaba un archivo "%s" para comparar pero '
675                     u'no fue encontrado'), f)
676             else:
677                 diff(join(path, f), zip_a_comparar, zip, f)
678         zip.close()
679         comando_ejecutado.diferencias = buffer.getvalue()
680     if comando_ejecutado.exito is None:
681         comando_ejecutado.exito = True
682     elif self.terminar_si_falla:
683         raise ExecutionFailure(self)
684
685 ComandoPrueba.ejecutar = ejecutar_comando_prueba
686 #}}}
687