Changeset 91

Timestamp:

07/06/06 16:42:30 (3 years ago)

Author:

robin

Message:

support for per test slaveservices

Files:

• slavetools/trunk/lib/slavetools/slaveapi_posix.py (modified) (3 diffs)
• slavetools/trunk/lib/slavetools/slaveplug.py (modified) (9 diffs)

slavetools/trunk/lib/slavetools/slaveapi_posix.py

@@ -1 +1 @@
-#!/usr/bin/env python
-
+, time, logging
-from subprocess import Popen
-from optionsapi import COMMON_OPTS, build_parser
@@ -10 +10 @@
-        'daemonize_posix '
-        'start_posix start_posix_noforward stop_posix main_posix_boilerplate '
+        'launch_process '
-        'minimal_daemon_example '
-        'COMMON_POSIX_OPTS START_POSIX_OPTS STOP_POSIX_OPTS MAIN_POSIX_OPTS '
@@ -288 +289 @@
-
-
+def launch_process(options, argv, grace=2.5, prevpid=None, 
+        time=time.time, sleep=time.sleep, log=None):
+    """launch a process, returning it's pid if we can.
+
+    There is a lot of unpythonic guess work going on here. However, given
+    the primary aim is to support developer testing, its not un reasonable
+    to assume the user has a degree of control over there environment. 
+    Certainly enough to compensate for the bad guesses this function makes.
+
+    WARNING: If the process, or any of its children, implements the
+    (typical) idiom of read pid, kill if read, write pid then that child
+    becomes a suicide. (this abnormal termination will be noticed by this
+    function. It can be avoided in your own programs by using the 
+    `kill_posix` method above - as it guards against this::
+
+        if readpid and readpid != os.getpid():
+            kill(readpid)
+
+    """
+
+    readpidfile = False
+    pidfile = None
+    abspidfile = None
+    log = log or logging.getLogger(__name__)
+    options.directory = os.path.expanduser(options.directory)
+    slave_progname = argv[0]
+    cwd = os.getcwd()
+    try:
+        os.chdir(options.directory)
+        # deal with predecessor unless otherwise directed
+        if prevpid != -1:
+            log.info('*** attempting to kill of predecessor')
+            # we could possibly avoid the directory change if an explicit
+            # pid for the predecessor is provided . Not
+            # convinced this would be usefull.
+            # Note: if --pidfile was specified then that is *exactly*
+            # the filename we get back here.
+            pidfile=kill_posix(log, options, slave_progname,
+                # unless the user explicitly sets prevpid then prevpid will 
+                # be None and ``pid`` is then ignored.
+                pid=prevpid)
+        if pidfile is None: # None if explicit prevpid is provided
+            pidfile = pidfile_name(options, slave_program)
+        if pidfile: # could still be None
+            abspidfile=os.path.abspath(pidfile)
+        # launch the process
+        p = Popen(argv)
+        tstart = time() # for benefit of `finalize`
+        sleep(grace)
+        rcode=p.poll()
+        if rcode is None:
+            log.info('*** [%s] is running, pid = [%s]' %
+                (argv[0], p.pid))
+            pid=p.pid
+            return pid
+        if abspidfile:
+            log.info((
+                '*** [%s] exited with [%s], ' % (p.pid, rcode)))
+            log.info('*** ATTEMPTING TO READ pid from file: %s' % abspidfile)
+            pid, readpidfile = read_pidfile(abspidfile, p.pid)
+            if not readpidfile:
+                log.warning(
+                    '*** FAILED TO READ pid from file %s' % abspidfile)
+            else:
+                log.info("*** READ pid [%s] from [%s]" % (pid, abspidfile))
+        else:
+            pid=p.pid
+        if readpidfile:
+            rcode = pollpid_posix(pid)
+        if rcode is not None:
+            log.warning(
+                '*** FAILED TO GET PID, exit code: %s' % rcode)
+            pid = -1
+    finally:
+        os.chdir(cwd)
+    return pid
+    
-COMMON_POSIX_OPTS=[
-    ('--daemonize',dict(default=False,action='store_true',

slavetools/trunk/lib/slavetools/slaveplug.py

@@ -68 +68 @@
-"""
-
-
+,re,types
-from time import time,sleep
-from subprocess import Popen
-from nose.plugins import Plugin
+from nose.case import FunctionTestCase
-from slavetools.optionsapi import add_options, prefix_longopts
-#from slavetools.optionsapi import prune_shortopts, update_options
-#from slavetools.optionsapi import COMMON_OPTS
-#from slavetools.slaveapi_posix import COMMON_POSIX_OPTS, START_POSIX_OPTS
-from slavetools.slaveapi_posix import read_pidfile, pidfile_name
-
+, launch_process
-
-PRUNE_SLAVE_LONGOPTS=['--dont-forward-opts']
-PLUGIN_OPTS = [
+    ('--wingdbstub', dict(default=False, action='store_true')),
-    ('--slave-program', dict(
-        default=None,
@@ -150 +149 @@
-            'use this when --slave-program is just an indirect step.')),
-        ('--dont-forward-opts', dict(default=False, action='store_true',
-
+
+
-            ' command are copied into the *begining* of the argumets passed '
-            ' to the child. Set this flag to disable this behaviour.')),
@@ -179 +179 @@
-    def configure(self, options, conf):
-        log = logging.getLogger(self.LOGCHAN)
+        self.log = log
+        if getattr(options,'wingdbstub'):
+            try:
+                import wingdbstub
+            except ImportError:
+                pass
-        super(SlaveService, self).configure(options, conf)
-        if getattr(options, ('%smore-help' % self.OPT_PREFIX).replace(
@@ -187 +193 @@
-        if not self.enabled:
-            return
+
+        self.match=re.compile(r'(?:^|[\b_\.%s-])[Ss]lave[Tt]est' % os.sep)
-        self.slave_options_xlate = [
-            (self.sourced_longopts[iopt][0], 
@@ -221 +229 @@
-        except ValueError:
-            self.slave_grace=2.5
-
+False and 
-            self.enabled=False
+    def loadTestsFromModule(self, module):
+        self.log.info("loadfrom: %s" % module.__name__)
+        modulefilepath = os.path.split(module.__file__)[0]
+        self.log.info("modulefilepath:%s" % modulefilepath)
+        for candidate in dir(module):
+            candidate = getattr(module, candidate)
+            if type(candidate) is not types.FunctionType:
+                continue
+            if (os.path.split(candidate.func_code.co_filename)[0] !=
+                    modulefilepath):
+                continue
+            if (None == self.match.search(candidate.__name__)):
+                continue
+            slave_program=getattr(candidate, 'slave_program')
+            if not slave_program:
+                continue
+            log = logging.getLogger(self.LOGCHAN)
+            options = self.slave_known_options
+            args=self.prepare_slave_program(slave_program)
+            pid=[-1]
+            def setup():
+                pid[0]=launch_process(options, args, log=log)
+            def teardown():
+                if pid[0] == -1:
+                    return
+                kill_posix(log, None, args[0], pid=pid[0])
+            yield FunctionTestCase(candidate,setUp=setup,tearDown=teardown)
+
+    def wantFunction(self, function):
+        if not self.match.search(function.__name__):
+            return
+        if not hasattr(function, 'slave_program'):
+            return
+        # somewhat counter intuitive, return False to prevent other plugins
+        # from seeing this method, then actualy select it in
+        # loadTestsFromModule above.
+        self.log.info("selecting:%s" % function.__name__)
+        return False
+
+    def prepareTest(self, test):
+        self.log.info('preparing test %s' % test)
+        return test
-
-    def _getprefixedattr(self, options, attr):
@@ -229 +279 @@
-            )
- 
-
+, slave_program=None
-        """If the heuristics for spliting the program don't suit 
-        override this method."""
+        if slave_program is None:
+            slave_program = self.slave_program
-        if self.slave_program_split is not None:
-            return [arg 
-elf.s
+
-                if arg]
-elf.slave_program and [self.
+lave_program and [
-
-    def prepare_slave_args(self):
@@ -278 +330 @@
-    
-    def begin(self):
+        if not self.slave_program:
+            return
+        return
-        log = logging.getLogger(self.LOGCHAN)
-        args = self.prepare_slave_program()
@@ -287 +342 @@
-        log.info(' '.join(args))
-        log.info(str(args))
-
+
+
+
-
-    def launch_slave(self, args):
@@ -367 +424 @@
-
-    def finalize(self, result):
+        return
+        if not self.slave_program:
+            return
-        log = logging.getLogger(self.LOGCHAN)
-        if self.pid == -1: