← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to test_on_merge.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2005-07-08 14:14:20 UTC
  • mfrom: (unknown (missing))
  • Revision ID: Arch-1:rocketfuel@canonical.com%launchpad--devel--0--patch-2053
[r=jamesh] testrunner improvements (?)
Patches applied:

 * stuart.bishop@canonical.com/launchpad--testrunner--0--base-0
   tag of rocketfuel@canonical.com/launchpad--devel--0--patch-1981

 * stuart.bishop@canonical.com/launchpad--testrunner--0--patch-1
   Make test_on_merge.py kill tests if they take too long and refuse to run if there are existing database connections open

 * stuart.bishop@canonical.com/launchpad--testrunner--0--patch-2
   Mmmm.... Curry....

 * stuart.bishop@canonical.com/launchpad--testrunner--0--patch-3
   Splurge on Rocketfuel and disolve cornflakes

 * stuart.bishop@canonical.com/launchpad--testrunner--0--patch-4
   Tweaks from review

 * stuart.bishop@canonical.com/launchpad--testrunner--0--patch-5
   Wait for test process to die

Show diffs side-by-side

added added

removed removed

Lines of Context:
test_on_merge.py
3
3
 
4
4
"""Tests that get run automatically on a merge."""
5
5
 
6
 
import sys, re
7
 
import os, os.path
8
 
import popen2
 
6
import sys, re, time
 
7
import os, os.path, errno
9
8
import tabnanny
10
9
import checkarchtag
11
10
from StringIO import StringIO
12
 
from threading import Thread
13
11
import psycopg
14
 
 
15
 
class NonBlockingReader(Thread):
16
 
 
17
 
    result = None
18
 
 
19
 
    def __init__(self,file):
20
 
        Thread.__init__(self)
21
 
        self.file = file
22
 
 
23
 
    def run(self):
24
 
        self.result = self.file.read()
25
 
 
26
 
    def read(self):
27
 
        if self.result is None:
28
 
            raise RuntimeError("read() called before run()")
29
 
        return self.result
30
 
 
31
 
    def readlines(self):
32
 
        if self.result is None:
33
 
            raise RuntimeError("readlines() called before run()")
34
 
        return self.result.splitlines()
35
 
 
 
12
from subprocess import Popen, PIPE
 
13
from signal import SIGKILL, SIGTERM
 
14
from select import select
 
15
 
 
16
# Die and kill the kids if no output for 10 minutes. Tune this if if your
 
17
# slow arsed machine needs it. The main use for this is to keep the pqm
 
18
# queue flowing without having to give it a lifeless enema.
 
19
TIMEOUT = 10 * 60 
36
20
 
37
21
def main():
38
22
    """Call test.py with whatever arguments this script was run with.
91
75
    # Drop the template database if it exists - the Makefile does this
92
76
    # too, but we can explicity check for errors here
93
77
    con = psycopg.connect('dbname=template1')
 
78
    con.set_isolation_level(0)
94
79
    cur = con.cursor()
95
80
    try:
96
 
        cur.execute('end transaction; drop database launchpad_ftest_template')
 
81
        cur.execute('drop database launchpad_ftest_template')
97
82
    except psycopg.ProgrammingError, x:
98
83
        if 'does not exist' not in str(x):
99
84
            raise
 
85
    cur.execute("""
 
86
        select count(*) from pg_stat_activity
 
87
        where datname in ('launchpad_dev',
 
88
            'launchpad_ftest_template', 'launchpad_ftest')
 
89
        """)
 
90
    existing_connections = cur.fetchone()[0]
 
91
    if existing_connections > 0:
 
92
        print 'Cannot rebuild database. There are %d open connections.' % (
 
93
                existing_connections,
 
94
                )
 
95
        return 1
100
96
    cur.close()
101
97
    con.close()
102
98
    
134
130
        WHERE context='internal' AND name='lc_ctype'
135
131
        """)
136
132
    loc = cur.fetchone()[0]
137
 
    if not (loc.startswith('en_') or loc in ('C', 'en')):
 
133
    #if not (loc.startswith('en_') or loc in ('C', 'en')):
 
134
    if loc != 'C':
138
135
        print 'Database locale incorrectly set. Need to rerun initdb.'
139
136
        return 1
140
137
 
147
144
    
148
145
 
149
146
    print 'Running tests.'
150
 
    cmd = 'cd %s; %s test.py %s < /dev/null' % (
151
 
            here, sys.executable, ' '.join(sys.argv[1:])
152
 
            )
153
 
    print cmd
154
 
    proc = popen2.Popen3(cmd, True)
155
 
    stdin, out, err = proc.tochild, proc.fromchild, proc.childerr
156
 
 
157
 
    # Use non-blocking reader threads to cope with differing expectations
158
 
    # from the proess of when to consume data from out and error.
159
 
    errthread = NonBlockingReader(err)
160
 
    outthread = NonBlockingReader(out)
161
 
    errthread.start()
162
 
    outthread.start()
163
 
    errthread.join()
164
 
    outthread.join()
165
 
    exitcode = proc.wait()
166
 
    test_ok = (os.WIFEXITED(exitcode) and os.WEXITSTATUS(exitcode) == 0)
167
 
 
168
 
    errlines = errthread.readlines()
169
 
    dataout = outthread.read()
 
147
    os.chdir(here)
 
148
    cmd = [sys.executable, 'test.py'] + sys.argv[1:]
 
149
    print ' '.join(cmd)
 
150
    # This would be simpler if we set stderr=STDOUT to combine the streams
 
151
    proc = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
 
152
    proc.stdin.close()
 
153
 
 
154
    out =  [] # stdout from tests
 
155
    err = [] # stderr from tests
 
156
    open_readers = set([proc.stderr, proc.stdout])
 
157
    while open_readers:
 
158
        rlist, wlist, xlist = select(open_readers, [], [], TIMEOUT)
 
159
 
 
160
        if len(rlist) == 0:
 
161
            if proc.poll() is None:
 
162
                break
 
163
            print 'Tests hung - no output for %d seconds. Killing.' % TIMEOUT
 
164
            killem(proc.pid, SIGTERM)
 
165
            time.sleep(3)
 
166
            if proc.poll() is None:
 
167
                print 'Not dead yet! - slaughtering mercilessly'
 
168
                killem(proc.pid, SIGKILL)
 
169
            break
 
170
 
 
171
        if proc.stdout in rlist:
 
172
            out.append(os.read(proc.stdout.fileno(), 1024))
 
173
            if out[-1] == "":
 
174
                open_readers.remove(proc.stdout)
 
175
        if proc.stderr in rlist:
 
176
            err.append(os.read(proc.stderr.fileno(), 1024))
 
177
            if err[-1] == "":
 
178
                open_readers.remove(proc.stderr)
 
179
 
 
180
    test_ok = (proc.wait() == 0)
 
181
 
 
182
    out = ''.join(out)
 
183
    err = ''.join(err)
170
184
 
171
185
    if test_ok:
172
 
        for line in errlines:
 
186
        for line in err.split('\n'):
173
187
            if re.match('^Ran\s\d+\stest(s)?\sin\s[\d\.]+s$', line):
174
188
                print line
175
189
        return 0
176
190
    else:
177
191
        print '---- test stdout ----'
178
 
        print dataout
 
192
        print out
179
193
        print '---- end test stdout ----'
180
194
 
181
195
        print '---- test stderr ----'
182
 
        print '\n'.join(errlines)
 
196
        print err
183
197
        print '---- end test stderr ----'
184
198
        return 1
185
199
 
 
200
def killem(pid, signal):
 
201
    """Kill the process group leader identified by pid and other group members
 
202
 
 
203
    Note that test.py sets its process to a process group leader.
 
204
    """
 
205
    try:
 
206
        os.killpg(os.getpgid(pid), signal)
 
207
    except OSError, x:
 
208
        if x.errno == errno.ESRCH:
 
209
            pass
 
210
        else:
 
211
            raise
 
212
 
186
213
if __name__ == '__main__':
187
214
    sys.exit(main())