Usar Comando.STDXXX en vez de strings.

[software/sercom.git] / sercom / tester.py

diff --git a/sercom/tester.py b/sercom/tester.py
index f1229b4ba1640dc3c93dcef4c40e5231f2784e7e..48227955a03d2bbdb1b0633e91ccd455c39220b0 100644 (file)
--- a/sercom/tester.py
+++ b/sercom/tester.py
@@ -6,9 +6,9 @@ from zipfile import ZipFile, BadZipfile
 from cStringIO import StringIO
 from shutil import rmtree
 from datetime import datetime
 from cStringIO import StringIO
 from shutil import rmtree
 from datetime import datetime

-from subprocess import Popen, PIPE, call #, check_call XXX Python 2.5

 from os.path import join
 from turbogears import config
 from os.path import join
 from turbogears import config

+import subprocess as sp

 import os, sys, pwd, grp
 import resource as rsrc
 import logging
 import os, sys, pwd, grp
 import resource as rsrc
 import logging


@@ -34,7 +34,7 @@ class UserInfo(object): #{{{
 
 user_info = UserInfo(config.get('sercom.tester.user', 65534))
 
 
 user_info = UserInfo(config.get('sercom.tester.user', 65534))
 

-def check_call(*popenargs, **kwargs): #{{{ Python 2.5 forward-compatibility
+def check_call(*popenargs, **kwargs): #{{{ XXX Python 2.5 forward-compatibility

     """Run command with arguments.  Wait for command to complete.  If
     the exit code was zero then return, otherwise raise
     CalledProcessError.  The CalledProcessError object will have the
     """Run command with arguments.  Wait for command to complete.  If
     the exit code was zero then return, otherwise raise
     CalledProcessError.  The CalledProcessError object will have the


@@ -45,18 +45,19 @@ def check_call(*popenargs, **kwargs): #{{{ Python 2.5 forward-compatibility
 
     check_call(["ls", "-l"])
     """
 
     check_call(["ls", "-l"])
     """

-    retcode = call(*popenargs, **kwargs)
+    retcode = sp.call(*popenargs, **kwargs)

     cmd = kwargs.get("args")
     if cmd is None:
         cmd = popenargs[0]
     if retcode:
     cmd = kwargs.get("args")
     if cmd is None:
         cmd = popenargs[0]
     if retcode:

-        raise CalledProcessError(retcode, cmd)
+        raise sp.CalledProcessError(retcode, cmd)

     return retcode
     return retcode

+sp.check_call = check_call

 #}}}
 
 #{{{ Excepciones
 
 #}}}
 
 #{{{ Excepciones
 

-class CalledProcessError(Exception): #{{{ Python 2.5 forward-compatibility
+class CalledProcessError(Exception): #{{{ XXX Python 2.5 forward-compatibility

     """This exception is raised when a process run by check_call() returns
     a non-zero exit status.  The exit status will be stored in the
     returncode attribute."""
     """This exception is raised when a process run by check_call() returns
     a non-zero exit status.  The exit status will be stored in the
     returncode attribute."""


@@ -66,28 +67,41 @@ class CalledProcessError(Exception): #{{{ Python 2.5 forward-compatibility
     def __str__(self):
         return ("Command '%s' returned non-zero exit status %d"
             % (self.cmd, self.returncode))
     def __str__(self):
         return ("Command '%s' returned non-zero exit status %d"
             % (self.cmd, self.returncode))

+sp.CalledProcessError = CalledProcessError

 #}}}
 
 class Error(StandardError): pass
 
 #}}}
 
 class Error(StandardError): pass
 

-class ExecutionFailure(Error, RuntimeError): pass
+class ExecutionFailure(Error, RuntimeError): #{{{
+    def __init__(self, comando, tarea=None, caso_de_prueba=None):
+        self.comando = comando
+        self.tarea = tarea
+        self.caso_de_prueba = caso_de_prueba
+#}}}

 
 class RsyncError(Error, EnvironmentError): pass
 
 #}}}
 
 
 class RsyncError(Error, EnvironmentError): pass
 
 #}}}
 

-def unzip(bytes, dst): # {{{
-    log.debug(_(u'Intentando descomprimir en %s'), dst)
+def unzip(bytes, default_dst='.', specific_dst=dict()): # {{{
+    u"""Descomprime un buffer de datos en formato ZIP.
+    Los archivos se descomprimen en default_dst a menos que exista una entrada
+    en specific_dst cuya clave sea el nombre de archivo a descomprimir, en
+    cuyo caso, se descomprime usando como destino el valor de dicha clave.
+    """
+    log.debug(_(u'Intentando descomprimir'))

     if bytes is None:
         return
     zfile = ZipFile(StringIO(bytes), 'r')
     for f in zfile.namelist():
     if bytes is None:
         return
     zfile = ZipFile(StringIO(bytes), 'r')
     for f in zfile.namelist():

+        dst = join(specific_dst.get(f, default_dst), f)

         if f.endswith(os.sep):
         if f.endswith(os.sep):

-            log.debug(_(u'Creando directorio %s'), f)
-            os.mkdir(join(dst, f))
+            log.debug(_(u'Creando directorio "%s" en "%s"'), f, dst)
+            os.mkdir(dst)

         else:
         else:

-            log.debug(_(u'Descomprimiendo archivo %s'), f)
-            file(join(dst, f), 'w').write(zfile.read(f))
+            log.debug(_(u'Descomprimiendo archivo "%s" en "%s"'), f, dst)
+            file(dst, 'w').write(zfile.read(f))
+    zfile.close()

 #}}}
 
 class SecureProcess(object): #{{{
 #}}}
 
 class SecureProcess(object): #{{{


@@ -102,16 +116,31 @@ class SecureProcess(object): #{{{
     uid = config.get('sercom.tester.chroot.user', 65534)
     MB = 1048576
     # XXX probar! make de un solo archivo lleva nproc=100 y nofile=15
     uid = config.get('sercom.tester.chroot.user', 65534)
     MB = 1048576
     # XXX probar! make de un solo archivo lleva nproc=100 y nofile=15

-    def __init__(self, comando, chroot, cwd):
-            self.comando = comando
-            self.chroot = chroot
-            self.cwd = cwd
+    def __init__(self, comando, chroot, cwd, close_stdin=False,
+                 close_stdout=False, close_stderr=False):
+        self.comando = comando
+        self.chroot = chroot
+        self.cwd = cwd
+        self.close_stdin = close_stdin
+        self.close_stdout = close_stdout
+        self.close_stderr = close_stderr
+        log.debug(_(u'Proceso segurizado: chroot=%s, cwd=%s, user=%s, cpu=%s, '
+            u'as=%sMiB, fsize=%sMiB, nofile=%s, nproc=%s, memlock=%s'),
+            self.chroot, self.cwd, self.uid, self.max_tiempo_cpu,
+            self.max_memoria, self.max_tam_archivo, self.max_cant_archivos,
+            self.max_cant_procesos, self.max_locks_memoria)

     def __getattr__(self, name):
         if getattr(self.comando, name) is not None:
             return getattr(self.comando, name)
         return config.get('sercom.tester.limits.' + name, self.default[name])
     def __call__(self):
         x2 = lambda x: (x, x)
     def __getattr__(self, name):
         if getattr(self.comando, name) is not None:
             return getattr(self.comando, name)
         return config.get('sercom.tester.limits.' + name, self.default[name])
     def __call__(self):
         x2 = lambda x: (x, x)

+        if self.close_stdin:
+            os.close(0)
+        if self.close_stdout:
+            os.close(1)
+        if self.close_stderr:
+            os.close(2)

         os.chroot(self.chroot)
         os.chdir(self.cwd)
         uinfo = UserInfo(self.uid)
         os.chroot(self.chroot)
         os.chdir(self.cwd)
         uinfo = UserInfo(self.uid)


@@ -124,12 +153,6 @@ class SecureProcess(object): #{{{
         rsrc.setrlimit(rsrc.RLIMIT_NPROC, x2(self.max_cant_procesos))
         rsrc.setrlimit(rsrc.RLIMIT_MEMLOCK, x2(self.max_locks_memoria))
         rsrc.setrlimit(rsrc.RLIMIT_CORE, x2(0))
         rsrc.setrlimit(rsrc.RLIMIT_NPROC, x2(self.max_cant_procesos))
         rsrc.setrlimit(rsrc.RLIMIT_MEMLOCK, x2(self.max_locks_memoria))
         rsrc.setrlimit(rsrc.RLIMIT_CORE, x2(0))

-        log.debug('Proceso segurizado: chroot=%s, cwd=%s, user=%s(%s), '
-            'group=%s(%s), cpu=%s, as=%sMiB, fsize=%sMiB, nofile=%s, nproc=%s, '
-            'memlock=%s', self.chroot, self.cwd, uinfo.user, uinfo.uid,
-            uinfo.group, uinfo.gid, self.max_tiempo_cpu, self.max_memoria,
-            self.max_tam_archivo, self.max_cant_archivos,
-            self.max_cant_procesos, self.max_locks_memoria)

         # Tratamos de forzar un sync para que entre al sleep del padre FIXME
         import time
         time.sleep(0)
         # Tratamos de forzar un sync para que entre al sleep del padre FIXME
         import time
         time.sleep(0)


@@ -159,11 +182,11 @@ class Tester(object): #{{{
     @property
     def chroot(self):
         return join(self.path, 'chroot_' + self.name)
     @property
     def chroot(self):
         return join(self.path, 'chroot_' + self.name)

-    #}}}

 
     @property
     def orig_chroot(self):
         return join(self.path, 'chroot')
 
     @property
     def orig_chroot(self):
         return join(self.path, 'chroot')

+    #}}}

 
     def run(self): #{{{
         entrega_id = self.queue.get() # blocking
 
     def run(self): #{{{
         entrega_id = self.queue.get() # blocking


@@ -191,10 +214,10 @@ class Tester(object): #{{{
             except Exception, e:
                 if isinstance(e, SystemExit): raise
                 entrega.observaciones += error_interno
             except Exception, e:
                 if isinstance(e, SystemExit): raise
                 entrega.observaciones += error_interno

-                log.exception(_(u'Hubo una excepción inesperada: %s'), e)
+                log.exception(_('Hubo una excepcion inesperada')) # FIXME encoding

             except:
                 entrega.observaciones += error_interno
             except:
                 entrega.observaciones += error_interno

-                log.exception(_(u'Hubo una excepción inesperada desconocida'))
+                log.exception(_('Hubo una excepcion inesperada desconocida')) # FIXME encoding

             else:
                 entrega.correcta = True
                 log.debug(_(u'Entrega correcta: %s'), entrega)
             else:
                 entrega.correcta = True
                 log.debug(_(u'Entrega correcta: %s'), entrega)


@@ -211,7 +234,7 @@ class Tester(object): #{{{
         os.seteuid(0) # Dios! (para chroot)
         os.setegid(0)
         try:
         os.seteuid(0) # Dios! (para chroot)
         os.setegid(0)
         try:

-            check_call(rsync)
+            sp.check_call(rsync)

         finally:
             log.debug(_(u'Cambiando usuario y grupo efectivos a %s:%s (%s:%s)'),
                 user_info.user, user_info.group, user_info.uid, user_info.gid)
         finally:
             log.debug(_(u'Cambiando usuario y grupo efectivos a %s:%s (%s:%s)'),
                 user_info.user, user_info.group, user_info.uid, user_info.gid)


@@ -256,7 +279,7 @@ def ejecutar_caso_de_prueba(self, path, entrega): #{{{
             if self.rechazar_si_falla:
                 entrega.exito = False
             if self.terminar_si_falla:
             if self.rechazar_si_falla:
                 entrega.exito = False
             if self.terminar_si_falla:

-                raise ExecutionError(e.comando, e.tarea, prueba)
+                raise ExecutionFailure(e.comando, e.tarea, self)

         else:
             prueba.exito = True
     finally:
         else:
             prueba.exito = True
     finally:


@@ -274,7 +297,7 @@ def ejecutar_tarea_fuente(self, path, entrega): #{{{
         if self.rechazar_si_falla:
             entrega.exito = False
         if self.terminar_si_falla:
         if self.rechazar_si_falla:
             entrega.exito = False
         if self.terminar_si_falla:

-            raise ExecutionError(e.comando, tarea)
+            raise ExecutionFailure(e.comando, self)

 TareaFuente.ejecutar = ejecutar_tarea_fuente
 #}}}
 
 TareaFuente.ejecutar = ejecutar_tarea_fuente
 #}}}
 


@@ -288,41 +311,127 @@ def ejecutar_tarea_prueba(self, path, prueba): #{{{
         if self.rechazar_si_falla:
             prueba.exito = False
         if self.terminar_si_falla:
         if self.rechazar_si_falla:
             prueba.exito = False
         if self.terminar_si_falla:

-            raise ExecutionError(e.comando, tarea)
+            raise ExecutionFailure(e.comando, self)

 TareaPrueba.ejecutar = ejecutar_tarea_prueba
 #}}}
 
 def ejecutar_comando_fuente(self, path, entrega): #{{{
     log.debug(_(u'ComandoFuente.ejecutar(path=%s, entrega=%s)'), path,
         entrega.shortrepr())
 TareaPrueba.ejecutar = ejecutar_tarea_prueba
 #}}}
 
 def ejecutar_comando_fuente(self, path, entrega): #{{{
     log.debug(_(u'ComandoFuente.ejecutar(path=%s, entrega=%s)'), path,
         entrega.shortrepr())

-    unzip(self.archivos_entrada, path) # TODO try/except

     comando_ejecutado = entrega.add_comando_ejecutado(self)
     comando_ejecutado = entrega.add_comando_ejecutado(self)

-    # Abro archivos para fds básicos (FIXME)
+    unzip(self.archivos_entrada, path, # TODO try/except
+        {self.STDIN: '/tmp/sercom.tester.%s.stdin' % comando_ejecutado.id}) # TODO /var/run/sercom

     options = dict(
         close_fds=True,
     options = dict(
         close_fds=True,

-        stdin=None,
-        stdout=None,
-        stderr=None,

         shell=True,
         preexec_fn=SecureProcess(self, 'var/chroot_pepe', '/home/sercom/build')
     )
         shell=True,
         preexec_fn=SecureProcess(self, 'var/chroot_pepe', '/home/sercom/build')
     )

+    if os.path.exists('/tmp/sercom.tester.%s.stdin' % comando_ejecutado.id): # TODO
+        options['stdin'] = file('/tmp/sercom.tester.%s.stdin' % comando_ejecutado.id, 'r') # TODO
+    else:
+        options['preexec_fn'].close_stdin = True
+    a_guardar = set(self.archivos_a_guardar)
+    if self.STDOUTERR in a_guardar:
+        options['stdout'] = file('/tmp/sercom.tester.%s.stdouterr'
+            % comando_ejecutado.id, 'w') #TODO /var/run/sercom?
+        options['stderr'] = sp.STDOUT
+    else:
+        if self.STDOUT in a_guardar:
+            options['stdout'] = file('/tmp/sercom.tester.%s.stdout'
+                % comando_ejecutado.id, 'w') #TODO /run/lib/sercom?
+        else:
+            options['preexec_fn'].close_stdout = True
+        if self.STDERR in a_guardar:
+            options['stderr'] = file('/tmp/sercom.tester.%s.stderr'
+                % comando_ejecutado.id, 'w') #TODO /var/run/sercom?
+        else:
+            options['preexec_fn'].close_stderr = True

     log.debug(_(u'Ejecutando como root: %s'), self.comando)
     os.seteuid(0) # Dios! (para chroot)
     os.setegid(0)
     try:
         try:
     log.debug(_(u'Ejecutando como root: %s'), self.comando)
     os.seteuid(0) # Dios! (para chroot)
     os.setegid(0)
     try:
         try:

-            proc = Popen(self.comando, **options)
+            proc = sp.Popen(self.comando, **options)

         finally:
             log.debug(_(u'Cambiando usuario y grupo efectivos a %s:%s (%s:%s)'),
                 user_info.user, user_info.group, user_info.uid, user_info.gid)
             os.setegid(user_info.gid) # Mortal de nuevo
             os.seteuid(user_info.uid)
         finally:
             log.debug(_(u'Cambiando usuario y grupo efectivos a %s:%s (%s:%s)'),
                 user_info.user, user_info.group, user_info.uid, user_info.gid)
             os.setegid(user_info.gid) # Mortal de nuevo
             os.seteuid(user_info.uid)

-    except Exception, e: # FIXME poner en el manejo de exceptiones estandar
+    except Exception, e:

         if hasattr(e, 'child_traceback'):
             log.error(_(u'Error en el hijo: %s'), e.child_traceback)
         raise
         if hasattr(e, 'child_traceback'):
             log.error(_(u'Error en el hijo: %s'), e.child_traceback)
         raise

-    proc.wait()
+    proc.wait() #TODO un sleep grande nos caga todo, ver sercom viejo
+    if self.retorno != self.RET_ANY:
+        if self.retorno == self.RET_FAIL:
+            if proc.returncode == 0:
+                if self.rechazar_si_falla:
+                    entrega.correcta = False
+                comando_ejecutado.exito = False
+                comando_ejecutado.observaciones += _(u'Se esperaba que el '
+                    u'programa termine con un error (código de retorno '
+                    u'distinto de 0) pero terminó bien (código de retorno '
+                    u'0).\n')
+                log.debug(_(u'Se esperaba que el programa termine '
+                    u'con un error (código de retorno distinto de 0) pero '
+                    u'terminó bien (código de retorno 0).\n'))
+        elif self.retorno != proc.returncode:
+            if self.rechazar_si_falla:
+                entrega.correcta = False
+            comando_ejecutado.exito = False
+            if proc.returncode < 0:
+                comando_ejecutado.observaciones += _(u'Se esperaba terminar '
+                    u'con un código de retorno %s pero se obtuvo una señal %s '
+                    u'(%s).\n') % (self.retorno, -proc.returncode,
+                        -proc.returncode) # TODO poner con texto
+                log.debug(_(u'Se esperaba terminar con un código '
+                    u'de retorno %s pero se obtuvo una señal %s (%s).\n'),
+                    self.retorno, -proc.returncode, -proc.returncode)
+            else:
+                comando_ejecutado.observaciones += _(u'Se esperaba terminar '
+                    u'con un código de retorno %s pero se obtuvo %s.\n') \
+                    % (self.retorno, proc.returncode)
+                log.debug(_(u'Se esperaba terminar con un código de retorno '
+                    u'%s pero se obtuvo %s.\n'), self.retorno, proc.returncode)
+    if comando_ejecutado.exito is None:
+        log.debug(_(u'Código de retorno OK'))

     comando_ejecutado.fin = datetime.now()
     comando_ejecutado.fin = datetime.now()

+    if a_guardar:
+        buffer = StringIO()
+        zip = ZipFile(buffer, 'w')
+        # Guardamos stdout/stderr
+        if self.STDOUTERR in a_guardar:
+            a_guardar.remove(self.STDOUTERR)
+            zip.write('/tmp/sercom.tester.%s.stdouterr'
+                % comando_ejecutado.id, self.STDOUTERR)
+        else:
+            if self.STDOUT in a_guardar:
+                a_guardar.remove(self.STDOUT)
+                zip.write('/tmp/sercom.tester.%s.stdout'
+                    % comando_ejecutado.id, self.STDOUT)
+            if self.STDERR in a_guardar:
+                a_guardar.remove(self.STDERR)
+                zip.write('/tmp/sercom.tester.%s.stderr'
+                    % comando_ejecutado.id, self.STDERR)
+        # Guardamos otros
+        for f in a_guardar:
+            if not os.path.exists(join(path, f)):
+                if self.rechazar_si_falla:
+                    entrega.correcta = False
+                comando_ejecutado.exito = False
+                comando_ejecutado.observaciones += _(u'Se esperaba un archivo '
+                    u'"%s" pero no fue encontrado') % f
+                log.debug(_(u'Se esperaba un archivo "%s" pero no fue '
+                    u'encontrado'), f)
+            else:
+                zip.write(join(path, f), f)
+        zip.close()
+        comando_ejecutado.archivos_guardados = buffer.getvalue()
+    if comando_ejecutado.exito is None:
+        comando_ejecutado.exito = True
+    elif self.terminar_si_falla:
+        raise ExecutionFailure(self)
+

 #    if no_anda_ejecucion: # TODO
 #        comando_ejecutado.exito = False
 #        comando_ejecutado.observaciones += 'No anduvo xxx' # TODO mas info
 #    if no_anda_ejecucion: # TODO
 #        comando_ejecutado.exito = False
 #        comando_ejecutado.observaciones += 'No anduvo xxx' # TODO mas info


@@ -345,8 +454,6 @@ def ejecutar_comando_fuente(self, path, entrega): #{{{
 #    else:
 #        comando_ejecutado.exito = True
 #        comando_ejecutado.observaciones += 'xxx OK' # TODO
 #    else:
 #        comando_ejecutado.exito = True
 #        comando_ejecutado.observaciones += 'xxx OK' # TODO

-    comando_ejecutado.exito = True
-    comando_ejecutado.observaciones += 'xxx OK' # TODO

 ComandoFuente.ejecutar = ejecutar_comando_fuente
 #}}}
 
 ComandoFuente.ejecutar = ejecutar_comando_fuente
 #}}}