~launchpad-pqm/launchpad/devel

#!/usr/bin/python -S

#

# Copyright 2009 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

"""Tests that get run automatically on a merge."""

import _pythonpath

import sys, time

import os, errno

import tabnanny

from StringIO import StringIO

import psycopg2

from subprocess import Popen, PIPE, STDOUT

from signal import SIGKILL, SIGTERM

from select import select

# The TIMEOUT setting (expressed in seconds) affects how long a test will run

# before it is deemed to be hung, and then appropriately terminated.

# It's principal use is preventing a PQM job from hanging indefinitely and

# backing up the queue.

# e.g. Usage: TIMEOUT = 60 * 15

# This will set the timeout to 15 minutes.

TIMEOUT = 60 * 15

def main():

    """Call bin/test with whatever arguments this script was run with.

    If the tests ran ok (last line of stderr is 'OK<return>') then suppress

    output and exit(0).

    Otherwise, print output and exit(1).

    """

    here = os.path.dirname(os.path.realpath(__file__))

    # Tabnanny

    # NB. If tabnanny raises an exception, run

    # python /usr/lib/python2.5/tabnanny.py -vv lib/canonical

    # for more detailed output.

    org_stdout = sys.stdout

    sys.stdout = StringIO()

    tabnanny.check(os.path.join(here, 'lib', 'canonical'))

    tabnanny_results = sys.stdout.getvalue()

    sys.stdout = org_stdout

    if len(tabnanny_results) > 0:

        print '---- tabnanny bitching ----'

        print tabnanny_results

        print '---- end tabnanny bitching ----'

        return 1

    # Sanity check PostgreSQL version. No point in trying to create a test

    # database when PostgreSQL is too old.

    con = psycopg2.connect('dbname=template1')

    cur = con.cursor()

    cur.execute('show server_version')

    server_version = cur.fetchone()[0]

    try:

        numeric_server_version = tuple(map(int, server_version.split('.')))

    except ValueError:

        # Skip this check if the version number is more complicated than

        # we expected.

        pass

    else:

        if numeric_server_version < (8, 0):

            print 'Your PostgreSQL version is too old.  You need 8.x.x'

            print 'You have %s' % server_version

            return 1

    # Drop the template database if it exists - the Makefile does this

    # too, but we can explicity check for errors here

    con = psycopg2.connect('dbname=template1')

    con.set_isolation_level(0)

    cur = con.cursor()

    try:

        cur.execute('drop database launchpad_ftest_template')

    except psycopg2.ProgrammingError, x:

        if 'does not exist' not in str(x):

            raise

    cur.execute("""

        select count(*) from pg_stat_activity

        where datname in ('launchpad_dev',

            'launchpad_ftest_template', 'launchpad_ftest')

        """)

    existing_connections = cur.fetchone()[0]

    if existing_connections > 0:

        print 'Cannot rebuild database. There are %d open connections.' % (

                existing_connections,

                )

        return 1

    cur.close()

    con.close()

    # Build the template database. Tests duplicate this.

    here = os.path.dirname(os.path.realpath(__file__))

    schema_dir = os.path.join(here, 'database', 'schema')

    if os.system('cd %s; make test > /dev/null' % (schema_dir)) != 0:

        print 'Failed to create database or load sampledata.'

        return 1

    # Sanity check the database. No point running tests if the

    # bedrock is crumbling.

    con = psycopg2.connect('dbname=launchpad_ftest_template')

    cur = con.cursor()

    cur.execute('show search_path')

    search_path = cur.fetchone()[0]

    if search_path != '$user,public,ts2':

        print 'Search path incorrect.'

        print 'Add the following line to /etc/postgresql/postgresql.conf:'

        print "    search_path = '$user,public,ts2'"

        print "and tell postgresql to reload its configuration file."

        return 1

    cur.execute("""

        select pg_encoding_to_char(encoding) as encoding from pg_database

        where datname='launchpad_ftest_template'

        """)

    enc = cur.fetchone()[0]

    if enc not in ('UNICODE', 'UTF8'):

        print 'Database encoding incorrectly set'

        return 1

    cur.execute(r"""

        SELECT setting FROM pg_settings

        WHERE context='internal' AND name='lc_ctype'

        """)

    loc = cur.fetchone()[0]

    #if not (loc.startswith('en_') or loc in ('C', 'en')):

    if loc != 'C':

        print 'Database locale incorrectly set. Need to rerun initdb.'

        return 1

    # Explicity close our connections - things will fail if we leave open

    # connections.

    cur.close()

    del cur

    con.close()

    del con

    print 'Running tests.'

    os.chdir(here)

    cmd = [

        'xvfb-run',

        '-s',

        "'-screen 0 1024x768x24'",

        os.path.join(here, 'bin', 'test')] + sys.argv[1:]

    command_line = ' '.join(cmd)

    print command_line

    # Run the test suite and return the error code

    #return call(cmd)

    proc = Popen(

        command_line, stdin=PIPE, stdout=PIPE, stderr=STDOUT, shell=True)

    proc.stdin.close()

    # Do proc.communicate(), but timeout if there's no activity on stdout or

    # stderr for too long.

    open_readers = set([proc.stdout])

    while open_readers:

        rlist, wlist, xlist = select(open_readers, [], [], TIMEOUT)

        if len(rlist) == 0:

            if proc.poll() is not None:

                break

            print ("\nA test appears to be hung. There has been no output for"

                " %d seconds. Sending SIGTERM." % TIMEOUT)

            killem(proc.pid, SIGTERM)

            time.sleep(3)

            if proc.poll() is not None:

                print ("\nSIGTERM did not work. Sending SIGKILL.")

                killem(proc.pid, SIGKILL)

            # Drain the subprocess's stdout and stderr.

            sys.stdout.write(proc.stdout.read())

            break

        if proc.stdout in rlist:

            chunk = os.read(proc.stdout.fileno(), 1024)

            sys.stdout.write(chunk)

            if chunk == "":

                open_readers.remove(proc.stdout)

    rv = proc.wait()

    if rv == 0:

        print '\nSuccessfully ran all tests.'

    else:

        print '\nTests failed (exit code %d)' % rv

    return rv

def killem(pid, signal):

    """Kill the process group leader identified by pid and other group members

    Note that bin/test sets its process to a process group leader.

    """

    try:

        os.killpg(os.getpgid(pid), signal)

    except OSError, x:

        if x.errno == errno.ESRCH:

            pass

        else:

            raise

if __name__ == '__main__':

    sys.exit(main())