Merge lp:~thomir-deactivatedaccount/ubuntu-test-cases/touch-convert-boottest-to-spaces into lp:ubuntu-test-cases

[Thomi Richards]

Convert tabs to spaces in scripts/*

Convert tabs to spaces in scripts/*

[lp:~thomir-deactivatedaccount/ubuntu-test-cases/touch-convert-boottest-to-spaces]

407. By Thomi Richards on 2015-06-03

realign comments.

Unmerged revisions

407. By Thomi Richards on 2015-06-03

realign comments.

406. By Thomi Richards on 2015-06-03

Convert tabs to spaces in scripts/*

405. By Francis Ginther on 2015-06-03

Extract the package version from the first installed binary package and supply that of the version of the source package under test in the result file sent to britney. [r=Paul Larson]

404. By Thomi Richards on 2015-06-02

Add a simple utility to retry adt-run several times in case of failure. [r=Francis Ginther]

403. By Paul Larson on 2015-06-02

Eliminate the need for getinstalledpkgs test in boottest [r=Francis Ginther]

402. By Francis Ginther on 2015-06-02

Install boottest binary packages during getinstalledpkgs, removing that responsibility from the boottest dep8 test.

401. By Francis Ginther on 2015-06-02

Remove boottest dependencies on the actual source package contents for the package under test.

400. By Paul Larson on 2015-06-01

Improve recovery image download logic [r=Parameswaran Sivatharman]

399. By Paul Larson on 2015-06-01

typo with quotes

398. By Paul Larson on 2015-06-01

include offline as a state we want to recover from

=== added file 'README.rst'
--- README.rst	1970-01-01 00:00:00 +0000
+++ README.rst	2015-06-03 20:37:20 +0000
@@ -0,0 +1,259 @@
+Touch Testing From the CLI
+==========================
+
+The CI touch testing execution framework was written so that it's very easy to
+run tests from home in the exact same way tests are run for the CI dashboard
+and CI MP testing. The only things you need are:
+
+ * This bzr branch: `lp:ubuntu-test-cases/touch <https://code.launchpad.net/~ubuntu-test-case-dev/ubuntu-test-cases/touch>`_
+ * The phablet-tools_ and ubuntu-device-flash_ packages
+ * An Ubuntu Touch supported_ device
+
+.. _phablet-tools: http://launchpad.net/phablet-tools
+.. _ubuntu-device-flash: http://launchpad.net/goget-ubuntu-touch
+.. _supported: http://wiki.ubuntu.com/Touch/Devices
+
+There are two pieces to touch testing, provisioning and test execution.
+The provisioning step is required, but once provisioned, you can proceed with
+any of the test methods described in this document.
+
+.. note::
+  Re-creating test results to match those on http://ci.ubuntu.com/ is not
+  always possible. The Ubuntu touch images are created using the Ubuntu
+  archive which changes over time as packages are constantly being updated.
+  Even when using identical images, test dependencies may change making it
+  impossible to recreate an identical test environment.
+
+  For best results, it's recommended to always use the most recent image.
+
+Prerequisites
+-------------
+
+Before proceeding, a network configuration file is required. This is a one time
+setup and can be used for all future provisioning and testing as long as your
+wifi network does not change. This file is the same network configuration file
+used by *phablet-network* and can be found by running *phablet-network* with no
+options. For example::
+
+  $ phablet-network
+  Network file is /etc/NetworkManager/system-connections/my-network-ssid
+  Provisioning network on device
+  
+  Network setup complete
+  PING launchpad.net (91.189.89.222) 56(84) bytes of data.
+
+Once the network configuration file is identified, it can be copied into the
+default location to be used by the provisioning scripts::
+
+  mkdir ~/.ubuntu-ci
+  sudo cp /etc/NetworkManager/system-connections/my-network-ssid ~/.ubuntu-ci/wifi.conf
+  sudo chown $USER:$USER ~/.ubuntu-ci/wifi.conf
+
+Provisioning
+------------
+
+Provisioning is a required step before performing CI dashboard or MP testing.
+It is necessary to configure the device into a known state so that the tests
+can run in a predictible manner.
+
+.. warning::
+  This provisioning step will completely erase your device. Be sure to
+  backup any data before proceeding.
+
+The provisioning script is a simple wrapper to commands from phablet-tools
+and some additional device setup to get it ready for testing. Provisioning
+is performed with the scripts/provision.sh command. Running::
+
+  ./scripts/provision.sh -w
+
+will install the latest ubuntu-touch/devel-proposed image.  If you
+wish to install the latest ubuntu-rtm image instead, use::
+
+  export IMAGE_OPT="--bootstrap --developer-mode --channel=ubuntu-touch/ubuntu-rtm/14.09-proposed"
+  ./scripts/provision.sh -w
+
+Provisioning using this script requires that you start off with the
+device booted and accessible via ADB. The device will be rebooted
+automatically and completely reinstalled - **ALL DATA WILL BE LOST**.
+
+.. note::
+  provision.sh requires a path to a network-manager wifi configuration file
+  that can be copied to the target device as described above in the
+  Prerequisites section. By default this is set to
+  ${HOME}/.ubuntu-ci/wifi.conf. This can be overridden with the -n parameter.
+
+Other customizations can be performed during provisioning, for a full list
+of options, use::
+
+  ./scripts/provision.sh -h
+
+Executing Tests
+---------------
+
+The touch testing tools are intended to provide CI Dashboard and CI MP testing
+for specific applications. The supported applications and test suites are
+visible in the `CI Dashboard <http://ci.ubuntu.com/>`_.  These tests include
+both autopilot and UTAH test definitions. The following sections describe how
+to use these tools for testing on a local device.
+
+.. note::
+  These tools will *only* work on a device that has been provisioned using the
+  methods described above.
+
+.. note::
+
+  Some of the tests generate subunit result files. These subunit result files
+  provide richer content and potentially more test artifacts over the xml
+  result files. To view the contents of these files, use the trv_ viewer
+  application or your favorite subunit viewer.
+
+.. _trv: https://launchpad.net/trv
+
+Executing Autopilot Tests
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+One or more autopilot tests can be run on the target device using the command::
+
+  ./scripts/run-autopilot-tests.sh
+
+This is a small wrapper that uses phablet-tools to drive the tests. The
+script can run one or more autopilot tests. By default it will reboot the
+device between each test and ensure the device is settled using the
+*system-settle* script. Both of those options can be disabled via command
+line options. By default the script will create a directory named
+*clientlogs* and then a subdirectory for each testsuite with result files.
+These sub-directories include a xUnit XML formatted file, *test_results.xml*,
+a subunit result stream, *test_results.subunit*, as well as several log files
+from the device to help with debugging failures.
+
+.. note::
+  run-autopilot-tests.sh will call a script that installs 
+  unity8-autopilot if it is not already installed, to allow the device to
+  be unlocked automatically.
+
+Examples
+^^^^^^^^
+
+An example testing two applications::
+
+  ./scripts/provision.sh -w
+  ./scripts/run-autopilot-tests.sh -a dropping_letters_app -a music_app
+
+And an example for running all dashboard autopilot tests::
+
+  ./scripts/provision.sh -w
+  ./scripts/run-autopilot-tests.sh
+
+Executing UTAH Tests
+~~~~~~~~~~~~~~~~~~~~
+
+Executing UTAH tests locally will require you to install the UTAH client
+package from a PPA::
+
+  sudo add-apt-repository ppa:utah/stable
+  sudo apt-get update
+  sudo apt-get install utah-client
+
+With that package installed UTAH tests can be run with::
+
+  ./scripts/jenkins.sh
+
+This script runs one test at a time and will put its test artifacts under the
+*clientlogs* directory similar to the autopilot runner. The UTAH result file
+will be named clientlogs/utah.yaml.
+
+An example of running the sdk test suite::
+
+  ./scripts/jenkins.sh -a sdk
+
+Provisioning and Executing Autopilot Tests for an MP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+These scripts are used by jenkins for the testing of MPs that generate Debian
+packages. The *run-mp.sh* script used below includes provisioning, so for this
+one case, it is not necessary to call provision.sh separately.
+
+To re-create the testing performed by jenkins, set the following
+environment variables based on the jenkins build parameters::
+
+  export package_archive=<from jenkins build parameter>
+  export test_packages=<from jenkins build parameter>
+  export test_suite=<from jenkins build parameter>
+
+and set the variable::
+
+  export ANDROID_SERIAL=<adb id from your test device>
+
+Then execute the following script::
+
+  ./scripts/run-mp.sh
+
+Running Autopilot Tests for a Modified Click Application
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+First provision the device with the desired image using the instructions
+in the "Provisioning" section of this README.
+
+Once the image has been provisioned, install the click app to test.
+The dropping-letters application is used in this example::
+
+  adb push com.ubuntu.dropping-letters_0.1.2.2.67_all.click /tmp
+  adb shell pkcon --allow-untrusted install-local \
+      /tmp/com.ubuntu.dropping-letters_0.1.2.2.67_all.click
+
+Now install the test sources ('--wipe' will remove any previously installed
+test sources)::
+
+  phablet-click-test-setup --wipe --click com.ubuntu.dropping-letters
+
+The above phablet-click-test-setup command will install the standard test
+dependencies and the click application's test sources as specified in the
+manifest. This is usually the application's trunk branch. To override the test
+sources with local changes, replace the test sources that were copied to the
+device. This example assumes the application code is checked out under the
+'dropping-letters' directory with the test sources under 'tests/autopilot'::
+
+  adb shell rm -rf /home/phablet/autopilot/dropping_letters_app
+  adb push dropping-letters/tests/autopilot \
+      /home/phablet/autopilot
+
+Finally, run the application tests::
+
+  ./scripts/run-autopilot-tests.sh -a dropping_letters_app
+
+The test results are available under::
+
+  clientlogs/dropping_letters_app/test_results.subunit
+  clientlogs/dropping_letters_app/test_results.xml
+
+Running Autopilot Tests for a Modified Debian Package
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+First provision the device with the desired image using the instructions
+in the "Provisioning" section of this README.
+
+If the device is provisioned, and you have built the debian package
+you wish to test with locally, install it on the device. For instance,
+if you are building and installing dialer-app::
+
+  phablet-config writable-image -r 0000 --package-dir /path/to/packages -p dialer-app
+
+Alternatively, if you have built the packages in a ppa, you could use::
+
+  phablet-config writable-image -r 0000 --ppa ppa:ci-train-ppa-service/landing-004 -p dialer-app
+
+.. note::
+  If you have updates to the dependencies or tests in debian
+  packages, make sure to also install packages for those if required for
+  the change you are making. Some tests need a few extra dependencies 
+  installed for the tests to function correctly.  To see a list of them, 
+  look at jenkins/testconfig.py.
+
+Finally, run the application tests::
+
+  ./scripts/run-autopilot-tests.sh -a dialer_app
+
+The test results are available under::
+
+  clientlogs/dialer_app/test_results.subunit
+  clientlogs/dialer_app/test_results.xml

=== added directory 'config'
=== added file 'config/boottest.rc.example'
--- config/boottest.rc.example	1970-01-01 00:00:00 +0000
+++ config/boottest.rc.example	2015-06-03 20:37:20 +0000
@@ -0,0 +1,10 @@
+# This file is sourced by boottest.sh
+
+# Example Config Follows - These are the current defaults
+#
+# REVISION=81
+# ARCH=krillin
+# PHABLET_PASSWORD=0000
+# ADT_TIMEOUT=600
+# Disable rsync but echo the commands for feedback
+# RSYNC="echo rsync"

=== added directory 'jenkins'
=== added file 'jenkins/custom-demo.py'
--- jenkins/custom-demo.py	1970-01-01 00:00:00 +0000
+++ jenkins/custom-demo.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,32 @@
+# The configuration matrix of our production device testing
+
+JENKINS = 'http://q-jenkins.ubuntu-ci:8080'
+
+
+def _url(channel, device):
+    return 'http://system-image.ubuntu.com/ubuntu-touch/%s/%s/index.json' \
+           % (channel, device)
+
+
+TRUSTY_MATRIX = [
+    {
+        'image-type': 'touch_custom_demo',
+        'include-qa': True,
+        'dashboard-host': 'ci.ubuntu.com',
+        'dashboard-port': '80',
+        'dashboard-user': 'doanac',
+        'devices': [
+            {
+                'name': 'mako',
+                'slave-label': 'daily-mako',
+                'trigger_url': _url('trusty-proposed-customized-demo', 'mako'),
+            },
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="ubuntu-system -b '
+                     '--channel ubuntu-touch/trusty-proposed-customized-demo"'
+    },
+]
+
+MATRIX = {
+    'trusty': TRUSTY_MATRIX,
+}

=== added file 'jenkins/production-arale.py'
--- jenkins/production-arale.py	1970-01-01 00:00:00 +0000
+++ jenkins/production-arale.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,56 @@
+# The configuration matrix of our staging device testing
+
+JENKINS = 'http://dev-jenkins.ubuntu-ci:8080/'
+
+VIVID_MATRIX = [
+    {
+        'image-type': 'touch_stable',
+        'statsd-key': 'ubuntu-ci.daily-image.staging',
+        'include-qa': True,
+        'dashboard-host': 'dashboard.ubuntu-ci',
+        'dashboard-port': '8080',
+        'dashboard-user': 'ci-bot',
+        'devices': [
+            {
+                'name': 'arale',
+                'slave-label': 'arale',
+                'trigger_url': 'http://system-image.ubuntu.com/'
+                               'ubuntu-touch/rc-proposed/meizu.en/'
+                               'arale/index.json',
+                'num-workers': 4,
+            }
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+                     '--channel=ubuntu-touch/rc-proposed/meizu.en '
+                     '--device=arale"',
+    },
+]
+
+WILY_MATRIX = [
+    {
+        'image-type': 'touch',
+        'statsd-key': 'ubuntu-ci.daily-image.staging',
+        'include-qa': True,
+        'dashboard-host': 'dashboard.ubuntu-ci',
+        'dashboard-port': '8080',
+        'dashboard-user': 'ci-bot',
+        'devices': [
+            {
+                'name': 'arale',
+                'slave-label': 'arale',
+                'trigger_url': 'http://system-image.ubuntu.com/'
+                               'ubuntu-touch/devel-proposed/meizu.en/'
+                               'arale/index.json',
+                'num-workers': 4,
+            }
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+                     '--channel=ubuntu-touch/devel-proposed/meizu.en '
+                     '--device=arale"',
+    },
+]
+
+MATRIX = {
+    'wily': WILY_MATRIX,
+    'vivid': VIVID_MATRIX,
+}

=== added file 'jenkins/production-krillin.py'
--- jenkins/production-krillin.py	1970-01-01 00:00:00 +0000
+++ jenkins/production-krillin.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,50 @@
+# The configuration matrix of our staging device testing
+
+JENKINS = 'http://dev-jenkins.ubuntu-ci:8080/'
+
+VIVID_MATRIX = [
+    {
+        'image-type': 'touch_stable',
+        'statsd-key': 'ubuntu-ci.daily-image.staging',
+        'include-qa': True,
+        'dashboard-host': 'dashboard.ubuntu-ci',
+        'dashboard-port': '8080',
+        'dashboard-user': 'ci-bot',
+        'devices': [
+            {
+                'name': 'krillin',
+                'slave-label': 'krillin',
+                'trigger_url': 'http://system-image.ubuntu.com/ubuntu-touch/rc-proposed/bq-aquaris.en/krillin/index.json',
+                'num-workers': 4,
+            }
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+            '--channel=ubuntu-touch/rc-proposed/bq-aquaris.en"'
+    },
+]
+
+WILY_MATRIX = [
+    {
+        'image-type': 'touch',
+        'statsd-key': 'ubuntu-ci.daily-image.staging',
+        'include-qa': True,
+        'dashboard-host': 'dashboard.ubuntu-ci',
+        'dashboard-port': '8080',
+        'dashboard-user': 'ci-bot',
+        'devices': [
+            {
+                'name': 'krillin',
+                'slave-label': 'krillin',
+                'trigger_url': 'http://system-image.ubuntu.com/ubuntu-touch/devel-proposed/krillin.en/index.json',
+                'num-workers': 4,
+            }
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+            '--channel=ubuntu-touch/devel-proposed/krillin.en"'
+    },
+]
+
+MATRIX = {
+    'vivid': VIVID_MATRIX,
+    'wily': WILY_MATRIX,
+}

=== added file 'jenkins/production.py'
--- jenkins/production.py	1970-01-01 00:00:00 +0000
+++ jenkins/production.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,96 @@
+# The configuration matrix of our production device testing
+
+JENKINS = 'http://q-jenkins.ubuntu-ci:8080'
+
+
+def _url(channel, device):
+    return 'http://system-image.ubuntu.com/ubuntu-touch/%s/%s/index.json' \
+           % (channel, device)
+
+
+WILY_MATRIX = [
+    {
+        'image-type': 'touch',
+        'statsd-key': 'ubuntu-ci.daily-image.production',
+        'include-qa': True,
+        'dashboard-host': 'ci.ubuntu.com',
+        'dashboard-port': '80',
+        'dashboard-user': 'uci-bot',
+        'devices': [
+            {
+                'name': 'mako',
+                'slave-label': 'daily-mako',
+                'trigger_url': _url('devel-proposed/ubuntu', 'mako'),
+                'num-workers': 3,
+            },
+            {
+                'name': 'flo',
+                'slave-label': 'daily-flo',
+                'trigger_url': _url('devel-proposed/ubuntu', 'flo'),
+                'num-workers': 2,
+            },
+            {
+                'name': 'manta',
+                'slave-label': 'daily-manta',
+                'trigger_url': _url('devel-proposed/ubuntu', 'manta'),
+                'num-workers': 2,
+            },
+        ],
+    },
+]
+
+VIVID_MATRIX = [
+    {
+        'image-type': 'touch_stable',
+        'statsd-key': 'ubuntu-ci.daily-image.production',
+        'include-qa': True,
+        'dashboard-host': 'ci.ubuntu.com',
+        'dashboard-port': '80',
+        'dashboard-user': 'uci-bot',
+        'devices': [
+            {
+                'name': 'mako',
+                'slave-label': 'daily-mako',
+                'trigger_url': _url('rc-proposed/ubuntu', 'mako'),
+                'num-workers': 3,
+            },
+            {
+                'name': 'flo',
+                'slave-label': 'daily-flo',
+                'trigger_url': _url('rc-proposed/ubuntu', 'flo'),
+                'num-workers': 2,
+            },
+            {
+                'name': 'manta',
+                'slave-label': 'daily-manta',
+                'trigger_url': _url('rc-proposed/ubuntu', 'manta'),
+                'num-workers': 2,
+            },
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+                     '--channel ubuntu-touch/rc-proposed/ubuntu"'
+    },
+    {
+        'image-type': 'touch_custom',
+        'statsd-key': 'ubuntu-ci.daily-image.production',
+        'include-qa': False,
+        'dashboard-host': 'ci.ubuntu.com',
+        'dashboard-port': '80',
+        'dashboard-user': 'uci-bot',
+        'devices': [
+            {
+                'name': 'mako',
+                'slave-label': 'daily-mako',
+                'trigger_url': _url('utopic-proposed-customized', 'mako'),
+            },
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+                     '--channel ubuntu-touch/utopic-proposed-customized"'
+    },
+]
+
+
+MATRIX = {
+    'vivid': VIVID_MATRIX,
+    'wily': WILY_MATRIX,
+}

=== added file 'jenkins/setup_jenkins.py'
--- jenkins/setup_jenkins.py	1970-01-01 00:00:00 +0000
+++ jenkins/setup_jenkins.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,228 @@
+#!/usr/bin/env python
+
+# Ubuntu Testing Automation Harness
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import argparse
+import imp
+import jenkins
+import jinja2
+import logging
+import os
+
+import testconfig
+
+from distro_info import UbuntuDistroInfo
+DEV_SERIES = UbuntuDistroInfo().devel()
+
+
+def _get_parser():
+    """Create and return command line parser.
+
+    :returns: command line parser
+    :rtype: argparse.ArgumentParser
+
+    """
+    parser = argparse.ArgumentParser(
+        description='Create/Update upgrade testing jenkins jobs.')
+    parser.add_argument("-d", "--dryrun", action="store_true",
+                        help="Dry run mode. Don't execute jenkins commands.")
+    parser.add_argument("-u", "--username",
+                        help="username to use when logging into Jenkins.")
+    parser.add_argument("-p", "--password",
+                        help="username to use when logging into Jenkins")
+    parser.add_argument("--dashboard-key", default="",
+                        help="The api-key for dashboard updates")
+    parser.add_argument("--nfss-config", default="",
+                        help="The path to the config file for nfss insertion")
+    parser.add_argument("-b", "--branch", default="lp:ubuntu-test-cases/touch",
+                        help="The branch this is located. default=%(default)s")
+    parser.add_argument("-c", "--config", required=True,
+                        type=argparse.FileType('r'),
+                        help="The job config to use.")
+    parser.add_argument("-P", "--publish", action="store_true",
+                        help="Publish at the end of the job")
+    parser.add_argument("--prefix",
+                        help="Prefix to add to the beginning of the job name")
+    parser.add_argument("-s", "--series", default=DEV_SERIES,
+                        help=("series of Ubuntu to download "
+                              "(default=%(default)s)"))
+    parser.add_argument("-w", "--wait", type=int, default=300,
+                        help=("How long to wait after jenkins triggers the"
+                              "install-and-boot job (default=%(default)d)"))
+    return parser
+
+
+def _get_jenkins(url, username, password):
+    logging.info('Attempting to login to jenkins at %s', url)
+    if username is not None:
+        logging.info('...with authentication as user: %s', username)
+        instance = jenkins.Jenkins(url, username=username, password=password)
+    else:
+        logging.info('...without authentication')
+        instance = jenkins.Jenkins(url)
+
+    return instance
+
+
+def _get_environment():
+    base = os.path.join(os.path.dirname(__file__), 'templates')
+    return jinja2.Environment(
+        loader=jinja2.FileSystemLoader(base),
+        undefined=jinja2.StrictUndefined,
+        trim_blocks=True)
+
+
+def _publish(instance, env, args, template, jobname, **params):
+    tmpl = env.get_template(template)
+    cfg = tmpl.render(**params)
+    if args.dryrun:
+        _dryrun_func(jobname, cfg)
+        return
+    if instance.job_exists(jobname):
+        logging.info('reconfiguring job %s', jobname)
+        instance.reconfig_job(jobname, cfg)
+    else:
+        logging.info('creating job %s', jobname)
+        instance.create_job(jobname, cfg)
+
+
+def _configure_smoke(instance, env, args, config_item, device):
+    defserial = '$(${BZRDIR}/scripts/get-adb-id ${NODE_NAME})'
+
+    params = {
+        'name': device['slave-label'],
+        'device_type': device['name'],
+        'serial': device.get('serial', defserial),
+        'publish': args.publish,
+        'branch': args.branch,
+        'imagetype': config_item['image-type'],
+        'series': args.series,
+        'image_opt': config_item.get('IMAGE_OPT', ''),
+        'image_server': config_item.get('IMAGE_SERVER', ''),
+        'statsd_key': config_item.get('statsd-key', ''),
+        'dashboard_host': config_item.get('dashboard-host', ''),
+        'dashboard_port': config_item.get('dashboard-port', ''),
+        'dashboard_prefix': config_item.get('dashboard-prefix', ''),
+        'dashboard_user': config_item.get('dashboard-user', ''),
+        'dashboard_key': args.dashboard_key,
+        'nfss_config': args.nfss_config,
+    }
+
+    prefix = ""
+    if(args.prefix):
+        prefix = args.prefix + "-"
+
+    job = '{}{}-{}-{}-smoke-daily'.format(
+        prefix, args.series, config_item['image-type'], device['name'])
+    _publish(instance, env, args, 'touch-smoke.xml.jinja2', job, **params)
+    return job
+
+
+def _configure_qa_job(instance, env, args, config_item, device, test):
+    defserial = '$(${BZRDIR}/scripts/get-adb-id ${NODE_NAME})'
+    # If the slave is specified for this test, set it
+    slave = getattr(test, 'device', device['slave-label'])
+    params = {
+        'name': slave,
+        'device_type': device['name'],
+        'serial': device.get('serial', defserial),
+        'publish': args.publish,
+        'branch': args.branch,
+        'imagetype': config_item['image-type'],
+        'series': args.series,
+        'image_opt': config_item.get('IMAGE_OPT', ''),
+        'image_server': config_item.get('IMAGE_SERVER', ''),
+        'timeout': test.timeout,
+        'test': test.name,
+        'nfss_config': args.nfss_config,
+    }
+    prefix = ""
+    if(args.prefix):
+        prefix = args.prefix + "-"
+    job = test.fmt.format(prefix=prefix,
+                          series=args.series,
+                          testname=test.name,
+                          imagetype=config_item['image-type'],
+                          type=device['name'])
+    _publish(instance, env, args, 'touch-base.xml.jinja2', job, **params)
+    return job
+
+
+def _configure_qa_jobs(instance, env, args, config_item, device):
+    tests = list(testconfig.TESTSUITES)
+    tests = testconfig.filter_tests(tests, config_item['image-type'],
+                                    device['name'])
+    tests = [t for t in tests if not t.smoke]
+    jobs = []
+    for t in tests:
+        j = _configure_qa_job(instance, env, args, config_item, device, t)
+        jobs.append(j)
+    return jobs
+
+
+def _configure_master(instance, env, args, config_item, device, smoke, jobs):
+    params = {
+        'branch': args.branch,
+        'trigger_url': device.get('trigger_url', ''),
+        'wait': args.wait,
+        'projects': jobs,
+        'smoke_job': smoke,
+        'num_workers': device.get('num-workers', 1),
+    }
+    prefix = ""
+    if(args.prefix):
+        prefix = args.prefix + "-"
+    job = testconfig.DEF_FMT.format(prefix=prefix,
+                                    series=args.series,
+                                    testname='master',
+                                    imagetype=config_item['image-type'],
+                                    type=device['name'])
+    _publish(instance, env, args, 'touch-master.xml.jinja2', job, **params)
+    return job
+
+
+def _dryrun_func(jobname, config):
+    logging.debug(jobname)
+    logging.debug(config)
+
+
+def main():
+    logging.basicConfig(level=logging.DEBUG)
+    args = _get_parser().parse_args()
+
+    config = imp.load_source('', 'config.py', args.config)
+    if args.series not in config.MATRIX:
+        print('"%s" series is not supported by this config.' % args.series)
+        exit(1)
+
+    jenkins_inst = _get_jenkins(config.JENKINS, args.username, args.password)
+    if args.dryrun:
+        jenkins_inst.create_job = _dryrun_func
+        jenkins_inst.reconfig_job = _dryrun_func
+
+    env = _get_environment()
+
+    for item in config.MATRIX[args.series]:
+        for device in item['devices']:
+            job = _configure_smoke(jenkins_inst, env, args, item, device)
+            jobs = []
+            if item.get('include-qa'):
+                jobs = _configure_qa_jobs(
+                    jenkins_inst, env, args, item, device)
+            _configure_master(jenkins_inst, env, args, item, device, job, jobs)
+
+if __name__ == '__main__':
+    main()

=== added file 'jenkins/staging.py'
--- jenkins/staging.py	1970-01-01 00:00:00 +0000
+++ jenkins/staging.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,42 @@
+# The configuration matrix of our staging device testing
+
+JENKINS = 'http://dev-jenkins.ubuntu-ci:8080/'
+
+UTOPIC_MATRIX = [
+    {
+        'image-type': 'touch',
+        'statsd-key': 'ubuntu-ci.daily-image.staging',
+        'include-qa': True,
+        'dashboard-host': 'dashboard.ubuntu-ci',
+        'dashboard-port': '8080',
+        'dashboard-user': 'ci-bot',
+        'devices': [
+            {
+                'name': 'mako',
+                'slave-label': 'mako',
+                #'trigger_url': 'http://system-image.ubuntu.com/utopic-proposed/mako/index.json',
+            }
+        ],
+    },
+    {
+        'image-type': 'touch_stable',
+        'statsd-key': 'ubuntu-ci.daily-image.staging',
+        'include-qa': True,
+        'dashboard-host': 'dashboard.ubuntu-ci',
+        'dashboard-port': '8080',
+        'dashboard-user': 'ci-bot',
+        'devices': [
+            {
+                'name': 'mako',
+                'slave-label': 'mako',
+                #'trigger_url': 'http://system-image.ubuntu.com/utopic-proposed/mako/index.json',
+            }
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+                     '--channel ubuntu-touch/staging-stable-proposed"'
+    },
+]
+
+MATRIX = {
+    'utopic': UTOPIC_MATRIX,
+}

=== added directory 'jenkins/templates'
=== added file 'jenkins/templates/touch-base.xml.jinja2'
--- jenkins/templates/touch-base.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-base.xml.jinja2	2015-06-03 20:37:20 +0000
@@ -0,0 +1,130 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project>
+  <actions/>
+  <description>
+&lt;pre&gt;
+#NOTE: Automatically created from a script as part of daily smoke testing&#xd;
+  {{branch}}&#xd;
+&lt;/pre&gt;
+  </description>
+  <keepDependencies>false</keepDependencies>
+  <properties>
+    <hudson.model.ParametersDefinitionProperty>
+      <parameterDefinitions>
+        <hudson.model.StringParameterDefinition>
+          <name>INSTALL_URL</name>
+          <description>A URL to the previous job. If provided this job will use the same install options as it used. If the device executing the job happens to have the exact same image, then provisioning can be skipped.
+	  </description>
+          <defaultValue></defaultValue>
+        </hudson.model.StringParameterDefinition>
+      </parameterDefinitions>
+    </hudson.model.ParametersDefinitionProperty>
+    <com.sonyericsson.rebuild.RebuildSettings>
+      <autoRebuild>false</autoRebuild>
+    </com.sonyericsson.rebuild.RebuildSettings>
+  </properties>
+  <scm class="hudson.scm.NullSCM"/>
+  <assignedNode>{{ name }}</assignedNode>
+  <canRoam>false</canRoam>
+  <disabled>false</disabled>
+  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
+  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+  <concurrentBuild>true</concurrentBuild>
+  <builders>
+    <hudson.tasks.Shell>
+      <command><![CDATA[
+set -e
+sudo rm -rf *
+
+BRANCH="{{branch}}"
+BZRDIR=`echo "$BRANCH" | awk -F/ '{ print $(NF) }'`
+BZRDIR=$(readlink -f $BZRDIR)
+bzr branch ${BRANCH} ${BZRDIR}
+
+export ANDROID_SERIAL={{serial}}
+export IMAGE_TYPE={{imagetype}}
+export IMAGE_SERIES={{series}}
+export DEVICE_TYPE={{device_type}}
+
+${BZRDIR}/scripts/recover.py ${NODE_NAME}
+
+{{image_opt}}
+{{image_server}}
+${BZRDIR}/scripts/run-smoke -t {{test}}
+
+# move results to base directory as expected by dashboard:
+mv clientlogs/{{test}}/* ./clientlogs/
+rm -rf clientlogs/{{test}}
+
+{% if test == 'health-check' %}
+# Post to nfss
+if [ "$NFSS_CONFIG" ] ; then
+    for FILE in clientlogs/*.json ; do
+        cat "$FILE" | nfss_insert.py "$NFSS_CONFIG" healthcheck $DEVICE_TYPE
+    done
+fi
+{% endif %}
+{% if test == 'memevent' %}
+adb shell ls /tmp/memory_usage*.json | tr '\r' ' ' | sed 's/ $//' | xargs -n1 -I {} adb pull {} ./clientlogs/
+{% if nfss_config %}
+NFSS_CONFIG_FILE=${WORKSPACE}/nfss_config
+cat - > ${NFSS_CONFIG_FILE} <<EOD
+{{nfss_config}}
+EOD
+python3 ${BZRDIR}/tests/memevent/nfss_upload_results.py ./clientlogs/ nfss_insert.py ${NFSS_CONFIG_FILE}
+{% endif %}
+{% endif %}
+      ]]></command>
+    </hudson.tasks.Shell>
+  </builders>
+  <publishers>
+    <hudson.tasks.ArtifactArchiver>
+      <artifacts>clientlogs/*, clientlogs/**/*</artifacts>
+      <latestOnly>false</latestOnly>
+    </hudson.tasks.ArtifactArchiver>
+    <hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+      <regexp>^= TOUCH IMAGE VERSION:([0-9]+.*)</regexp>
+      <regexpForFailed>^= TOUCH IMAGE VERSION:([0-9]+.*)</regexpForFailed>
+      <setForMatrix>false</setForMatrix>
+    </hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+    <hudson.tasks.Mailer>
+      <recipients>[e-mail] [e-mail]</recipients>
+      <dontNotifyEveryUnstableBuild>false</dontNotifyEveryUnstableBuild>
+      <sendToIndividuals>false</sendToIndividuals>
+    </hudson.tasks.Mailer>
+    <hudson.plugins.postbuildtask.PostbuildTask>
+      <tasks>
+        <hudson.plugins.postbuildtask.TaskProperties>
+          <logTexts>
+            <hudson.plugins.postbuildtask.LogProperties>
+              <logText/>
+              <operator>AND</operator>
+            </hudson.plugins.postbuildtask.LogProperties>
+          </logTexts>
+          <EscalateStatus>false</EscalateStatus>
+          <RunIfJobSuccessful>false</RunIfJobSuccessful>
+          <script>
+touch/scripts/recover.py ${NODE_NAME}
+          </script>
+        </hudson.plugins.postbuildtask.TaskProperties>
+      </tasks>
+    </hudson.plugins.postbuildtask.PostbuildTask>
+{% if publish %}
+    <hudson.plugins.build__publisher.BuildPublisher>
+      <publishUnstableBuilds>true</publishUnstableBuilds>
+      <publishFailedBuilds>true</publishFailedBuilds>
+      <postActions class="vector"/>
+    </hudson.plugins.build__publisher.BuildPublisher>
+{% endif %}
+  </publishers>
+  <buildWrappers>
+      <hudson.plugins.build__timeout.BuildTimeoutWrapper>
+        <timeoutMinutes>{{timeout}}</timeoutMinutes>
+      <failBuild>true</failBuild>
+      <writingDescription>false</writingDescription>
+      <timeoutPercentage>0</timeoutPercentage>
+      <timeoutType>absolute</timeoutType>
+      <timeoutMinutesElasticDefault>3</timeoutMinutesElasticDefault>
+    </hudson.plugins.build__timeout.BuildTimeoutWrapper>
+  </buildWrappers>
+</project>

=== added file 'jenkins/templates/touch-master.xml.jinja2'
--- jenkins/templates/touch-master.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-master.xml.jinja2	2015-06-03 20:37:20 +0000
@@ -0,0 +1,80 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<com.cloudbees.plugins.flow.BuildFlow>
+  <actions/>
+  <description>
+&lt;pre&gt;
+#NOTE: Automatically created from a script as part of daily smoke testing&#xd;
+  {{branch}}&#xd;
+&lt;/pre&gt;
+  </description>
+  <keepDependencies>false</keepDependencies>
+  <properties>
+    <hudson.model.ParametersDefinitionProperty>
+      <parameterDefinitions>
+        <hudson.model.StringParameterDefinition>
+          <name>sleep</name>
+          <description>Seconds to sleep before starting the job
+          </description>
+          <defaultValue>{{ wait }}</defaultValue>
+        </hudson.model.StringParameterDefinition>
+      </parameterDefinitions>
+    </hudson.model.ParametersDefinitionProperty>
+    <hudson.plugins.throttleconcurrents.ThrottleJobProperty>
+      <maxConcurrentPerNode>0</maxConcurrentPerNode>
+      <maxConcurrentTotal>0</maxConcurrentTotal>
+      <throttleEnabled>false</throttleEnabled>
+      <throttleOption>project</throttleOption>
+    </hudson.plugins.throttleconcurrents.ThrottleJobProperty>
+    <hudson.plugins.build__publisher.ExternalProjectProperty/>
+  </properties>
+  <scm class="hudson.scm.NullSCM"/>
+  <assignedNode>master</assignedNode>
+  <canRoam>false</canRoam>
+  <disabled>false</disabled>
+  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
+  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+{%if trigger_url %}
+  <triggers class="vector">
+    <com.redfin.hudson.UrlChangeTrigger>
+      <spec></spec>
+      <url>{{trigger_url}}</url>
+    </com.redfin.hudson.UrlChangeTrigger>
+  </triggers>
+{% endif %}
+  <concurrentBuild>false</concurrentBuild>
+  <builders/>
+  <publishers/>
+  <buildWrappers>
+      <hudson.plugins.build__timeout.BuildTimeoutWrapper>
+        <timeoutMinutes>300</timeoutMinutes>
+      <failBuild>true</failBuild>
+      <writingDescription>false</writingDescription>
+      <timeoutPercentage>0</timeoutPercentage>
+      <timeoutType>absolute</timeoutType>
+      <timeoutMinutesElasticDefault>3</timeoutMinutesElasticDefault>
+    </hudson.plugins.build__timeout.BuildTimeoutWrapper>
+  </buildWrappers>
+  <dsl><![CDATA[
+// give the image time to show up before running tests
+out.println("sleeping for a bit")
+def sleep = build.environment.get("sleep").toLong()
+build.sleep(sleep * 1000)
+
+ignore(UNSTABLE) {
+    join = parallel ([
+{% for x in range(num_workers) %}
+        worker_{{x}}:  { build("{{smoke_job}}", worker_idx: {{x}}, workers: {{num_workers}}) },
+{% endfor %}
+    ])
+}
+{% if projects %}
+out.println("kicking off downstream projects in parellel")
+install_url = build.environment.get("HUDSON_URL") + join.worker_0.lastBuild.build.url
+parallel (
+{% for project in projects %}
+    {build("{{project}}", INSTALL_URL: install_url)},
+{% endfor %}
+)
+{% endif %}
+  ]]></dsl>
+</com.cloudbees.plugins.flow.BuildFlow>

=== added file 'jenkins/templates/touch-smoke.xml.jinja2'
--- jenkins/templates/touch-smoke.xml.jinja2	1970-01-01 00:00:00 +0000
+++ jenkins/templates/touch-smoke.xml.jinja2	2015-06-03 20:37:20 +0000
@@ -0,0 +1,199 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<project>
+  <actions/>
+  <description>
+<![CDATA[
+This job provides a flexible way to execute all the tests in our daily image
+testing process that contribute to the
+<a href="http://reports.qa.ubuntu.com/smokeng/">QA Dashboard</a>.
+The job is parameterized to give flexibility in what gets tested. A couple of
+common ways to run this job are:
+<dl>
+  <dt>Full Test Run</dt>
+  <dd>TESTS=ALL</dd>
+  <dd>APPS=ALL</dd>
+  <dt>Re-run a Failed Autopilot Test</dt>
+  <dd>INSTALL_URL=http://dev-jenkins:8080/job/utopic-touch_ro-mako/9</dd>
+  <dd>APPS=dropping_letters_app</dd>
+  <dt>Re-run a Failed UTAH Test</dt>
+  <dd>INSTALL_URL=http://dev-jenkins:8080/job/utopic-touch_ro-mako/9</dd>
+  <dd>TESTS=security</dd>
+</dl>
+<pre>
+#NOTE: Automatically created from a script as part of daily smoke testing
+  {{branch}}
+</pre>
+{% if statsd_key %}
+<h3>Graphite Reports</h3>
+<ul>
+  <li><a href="https://graphite.engineering.canonical.com/graphlot/?width=841&height=770&&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.provision.mean%2C0.000016667%29%2C%22Provisioning%20Time(minutes)%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.APPS.mean%2C0.000016667%29%2C%22Autopilot%20Tests%20Time%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.TESTS.mean%2C0.000016667%29%2C%22UTAH%20Tests%20Time%22%29&from=-1weeks">Timings (1 week)</a></li>
+  <li><a href="https://graphite.engineering.canonical.com/graphlot/?width=841&height=770&&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.provision.mean%2C0.000016667%29%2C%22Provisioning%20Time(minutes)%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.APPS.mean%2C0.000016667%29%2C%22Autopilot%20Tests%20Time%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.TESTS.mean%2C0.000016667%29%2C%22UTAH%20Tests%20Time%22%29&from=-4weeks">Timings (4 weeks)</a></li>
+</ul>
+{% endif %}
+]]>
+  </description>
+  <keepDependencies>false</keepDependencies>
+  <properties>
+    <hudson.model.ParametersDefinitionProperty>
+      <parameterDefinitions>
+        <hudson.model.StringParameterDefinition>
+          <name>INSTALL_URL</name>
+          <description>A URL to the previous job. If provided this job will use the same install options as it used. If the device executing the job happens to have the exact same image, then provisioning can be skipped.
+	  </description>
+          <defaultValue></defaultValue>
+        </hudson.model.StringParameterDefinition>
+        <hudson.model.StringParameterDefinition>
+          <name>TESTS</name>
+          <description>A space separated list of utah tests to run. "ALL" can be used to run all known utah tests.
+	  </description>
+          <defaultValue>ALL</defaultValue>
+        </hudson.model.StringParameterDefinition>
+	<hudson.model.StringParameterDefinition>
+          <name>APPS</name>
+          <description>A space separated list of autopilot tests to run. "ALL" can be used to run all known tests.
+	  </description>
+          <defaultValue>ALL</defaultValue>
+        </hudson.model.StringParameterDefinition>
+	<hudson.model.StringParameterDefinition>
+          <name>REVISION</name>
+          <description>The image revision to test with.
+	  </description>
+          <defaultValue></defaultValue>
+        </hudson.model.StringParameterDefinition>
+	<hudson.model.StringParameterDefinition>
+          <name>workers</name>
+          <description>The number of workers
+	  </description>
+          <defaultValue></defaultValue>
+        </hudson.model.StringParameterDefinition>
+	<hudson.model.StringParameterDefinition>
+          <name>worker_idx</name>
+          <description>The index of this worker
+	  </description>
+          <defaultValue></defaultValue>
+        </hudson.model.StringParameterDefinition>
+      </parameterDefinitions>
+    </hudson.model.ParametersDefinitionProperty>
+    <com.sonyericsson.rebuild.RebuildSettings>
+      <autoRebuild>false</autoRebuild>
+    </com.sonyericsson.rebuild.RebuildSettings>
+  </properties>
+  <scm class="hudson.scm.NullSCM"/>
+  <assignedNode>{{ name }}</assignedNode>
+  <canRoam>false</canRoam>
+  <disabled>false</disabled>
+  <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
+  <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
+  <triggers class="vector"/>
+  <concurrentBuild>true</concurrentBuild>
+  <builders>
+    <hudson.tasks.Shell>
+      <command>set -e
+BRANCH=&quot;{{branch}}&quot;
+BZRDIR=`echo &quot;$BRANCH&quot; | awk -F/ &apos;{ print $(NF) }&apos;`
+BZRDIR=$(readlink -f $BZRDIR)
+[ -d $BZRDIR ] &amp;&amp; rm -rf $BZRDIR
+bzr branch ${BRANCH} ${BZRDIR}
+
+export ANDROID_SERIAL={{serial}}
+export IMAGE_TYPE={{imagetype}}
+export IMAGE_SERIES={{series}}
+export DEVICE_TYPE={{device_type}}
+
+${BZRDIR}/scripts/recover.py ${NODE_NAME}
+
+{% if statsd_key %}
+# the txstatsd package is too old, use the one from LP:
+[ -d txstatsd ] &amp;&amp; rm -rf txstatsd
+bzr branch -r 109 lp:txstatsd
+export PYTHONPATH=`pwd`/txstatsd
+
+export STATSD_KEY={{statsd_key}}.{{imagetype}}
+{% endif %}
+
+{% if dashboard_host %}
+export DASHBOARD_HOST="{{dashboard_host}}"
+{% endif %}
+{% if dashboard_user %}
+export DASHBOARD_USER="{{dashboard_user}}"
+{% endif %}
+{% if dashboard_key %}
+set +x   # don't let this leak into the public
+export DASHBOARD_KEY="{{dashboard_key}}"
+set -x
+{% endif %}
+{% if dashboard_prefix %}
+export DASHBOARD_PREFIX="{{dashboard_prefix}}"
+{% endif %}
+{% if dashboard_port %}
+export DASHBOARD_PORT="{{dashboard_port}}"
+{% endif %}
+{% if nfss_config %}
+export NFSS_CONFIG="{{nfss_config}}"
+{% endif %}
+
+{{image_opt}}
+{{image_server}}
+${BZRDIR}/scripts/run-smoke
+      </command>
+    </hudson.tasks.Shell>
+  </builders>
+  <publishers>
+    <hudson.tasks.ArtifactArchiver>
+      <artifacts>clientlogs/**</artifacts>
+      <latestOnly>false</latestOnly>
+    </hudson.tasks.ArtifactArchiver>
+    <hudson.tasks.junit.JUnitResultArchiver>
+      <testResults>clientlogs/**/*.xml</testResults>
+      <keepLongStdio>true</keepLongStdio>
+      <testDataPublishers>
+        <hudson.plugins.junitattachments.AttachmentPublisher/>
+      </testDataPublishers>
+    </hudson.tasks.junit.JUnitResultArchiver>
+    <hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+      <regexp>^= TOUCH IMAGE VERSION:([0-9]+.*)</regexp>
+      <regexpForFailed>^= TOUCH IMAGE VERSION:([0-9]+.*)</regexpForFailed>
+      <setForMatrix>false</setForMatrix>
+    </hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
+    <hudson.plugins.postbuildtask.PostbuildTask>
+      <tasks>
+        <hudson.plugins.postbuildtask.TaskProperties>
+          <logTexts>
+            <hudson.plugins.postbuildtask.LogProperties>
+              <logText/>
+              <operator>AND</operator>
+            </hudson.plugins.postbuildtask.LogProperties>
+          </logTexts>
+          <EscalateStatus>false</EscalateStatus>
+          <RunIfJobSuccessful>false</RunIfJobSuccessful>
+          <script>
+touch/scripts/recover.py ${NODE_NAME}
+          </script>
+        </hudson.plugins.postbuildtask.TaskProperties>
+      </tasks>
+    </hudson.plugins.postbuildtask.PostbuildTask>
+{% if publish %}
+    <hudson.tasks.Mailer>
+      <recipients>[e-mail]</recipients>
+      <dontNotifyEveryUnstableBuild>false</dontNotifyEveryUnstableBuild>
+      <sendToIndividuals>false</sendToIndividuals>
+    </hudson.tasks.Mailer>
+    <hudson.plugins.build__publisher.BuildPublisher>
+      <publishUnstableBuilds>true</publishUnstableBuilds>
+      <publishFailedBuilds>true</publishFailedBuilds>
+      <postActions class="vector"/>
+    </hudson.plugins.build__publisher.BuildPublisher>
+{% endif %}
+  </publishers>
+  <buildWrappers>
+      <hudson.plugins.build__timeout.BuildTimeoutWrapper>
+          <timeoutMinutes>300</timeoutMinutes>
+      <failBuild>true</failBuild>
+      <writingDescription>false</writingDescription>
+      <timeoutPercentage>0</timeoutPercentage>
+      <timeoutType>absolute</timeoutType>
+      <timeoutMinutesElasticDefault>3</timeoutMinutesElasticDefault>
+    </hudson.plugins.build__timeout.BuildTimeoutWrapper>
+  </buildWrappers>
+</project>
+

=== added file 'jenkins/testconfig.py'
--- jenkins/testconfig.py	1970-01-01 00:00:00 +0000
+++ jenkins/testconfig.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,242 @@
+#!/usr/bin/env python
+
+# Ubuntu Testing Automation Harness
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import argparse
+
+DEF_FMT = '{prefix}{series}-{imagetype}-{type}-smoke-{testname}'
+IDLE_FMT = '{prefix}{testname}-{series}-{imagetype}-armhf-install-idle-{type}'
+
+
+class Test(object):
+    def __init__(self, name, timeout=60, fmt=DEF_FMT, smoke=True):
+        self.name = name
+        self.timeout = timeout
+        self.fmt = fmt
+        self.smoke = smoke
+
+    def __repr__(self):
+        return self.name
+
+
+class DevTest(Test):
+    def __init__(self, name, device):
+        Test.__init__(self, name, fmt=IDLE_FMT, smoke=False)
+        self.device = device
+
+
+class APTest(Test):
+    def __init__(self, name, app=None, pkgs=None):
+        Test.__init__(self, name)
+        self.pkgs = pkgs
+        if not app:
+            # convert share-app-autopilot to share_app
+            app = name.replace('-', '_').replace('_autopilot', '')
+        self.app = app
+
+
+TESTSUITES = [
+    Test('default'),
+]
+TESTSUITES += [
+    APTest('mediaplayer-app-autopilot', pkgs=['mediaplayer-app-autopilot']),
+    APTest('gallery-app-autopilot'),
+    APTest('webbrowser-app-autopilot', pkgs=['webbrowser-app-autopilot']),
+    APTest('webapp-container-autopilot', pkgs=['webapp-container-autopilot']),
+    APTest('unity8-autopilot', 'unity8'),
+    APTest('camera-app-autopilot',
+           pkgs=['python3-wand', 'python3-mediainfodll']),
+    APTest('dialer-app-autopilot', pkgs=['dialer-app-autopilot']),
+    APTest('ubuntu-keyboard-autopilot', pkgs=['ubuntu-keyboard-autopilot']),
+    APTest('messaging-app-autopilot', pkgs=['messaging-app-autopilot']),
+    APTest('address-book-app-autopilot', pkgs=['address-book-app-autopilot']),
+    APTest('reminders-autopilot',
+           pkgs=['python3-dbusmock', 'python3-requests-oauthlib',
+                 'account-plugin-evernote-sandbox']),
+    APTest('music-app-autopilot'),
+    APTest('dropping-letters-app-autopilot'),
+    APTest('sudoku-app-autopilot'),
+    APTest('ubuntu-calculator-app-autopilot'),
+    APTest('ubuntu-clock-app-autopilot'),
+    APTest('filemanager', pkgs=['python3-lxml']),
+    APTest('shorts-app-autopilot'),
+    APTest('ubuntu-terminal-app-autopilot'),
+    APTest('ubuntu-weather-app-autopilot'),
+    APTest('ubuntu-ui-toolkit-autopilot', 'ubuntuuitoolkit',
+           ['ubuntu-ui-toolkit-autopilot']),
+    APTest('ubuntu-system-settings-autopilot',
+           pkgs=['ubuntu-system-settings-autopilot']),
+    APTest('ubuntu-system-settings-online-accounts-autopilot',
+           'online_accounts_ui',
+           ['ubuntu-system-settings-online-accounts-autopilot']),
+]
+TESTSUITES += [
+    Test('click_image_tests'),
+    Test('sdk'),
+    Test('security'),
+    Test('eventstat', fmt=IDLE_FMT, smoke=False),
+    Test('smem', fmt=IDLE_FMT, smoke=False),
+    Test('health-check', timeout=300, smoke=False),
+    Test('memevent',
+         fmt='{prefix}{testname}-{series}-{imagetype}-armhf-default-{type}',
+         smoke=False),
+    Test('bootspeed',
+         fmt='{prefix}{testname}-{series}-{imagetype}-{type}-{type}',
+         smoke=False),
+]
+
+
+def filter_tests(tests, image_type, device_type=None):
+    if image_type:
+        func = globals().get('get_tests_%s' % image_type)
+        if func:
+            tests = func(tests, device_type)
+        elif image_type not in ['touch_stable', 'touch',
+                                'touch_custom_demo']:
+            print('Unsupported image type: %s' % image_type)
+            exit(1)
+    if device_type:
+        func = globals().get('get_tests_%s' % device_type)
+        if func:
+            tests = func(tests)
+    return tests
+
+
+def _get_tests(test_type, image_type, device_type=None):
+    # take all our known tests, then call filter tests which should give
+    # us a list of tests customized for things like touch_custom.
+    # then eliminate tests that aren't of the proper test_type
+    tests = [t for t in filter_tests(TESTSUITES, image_type, device_type)
+             if type(t) == test_type and t.fmt == DEF_FMT]
+    return tests
+
+
+def _split_work(tests, total_workers, worker_idx):
+    assigned = []
+    for x in range(len(tests)):
+        if x % total_workers == worker_idx:
+            assigned.append(tests[x])
+    return assigned
+
+
+def _handle_utah(args):
+    tests = _get_tests(Test, args.image_type, args.device_type)
+    if args.with_autopilot:
+        tests = [t for t in TESTSUITES if t.fmt == DEF_FMT]
+    tests = _split_work(tests, args.total_workers, args.worker)
+    print(' '.join([t.name for t in tests if t.smoke is True]))
+
+
+def _handle_ap_apps(args):
+    tests = _get_tests(APTest, args.image_type, args.device_type)
+    tests = _split_work(tests, args.total_workers, args.worker)
+    print(' '.join([t.app for t in tests]))
+
+
+def _handle_ap_packages(args):
+    pkgs = []
+    tests = _get_tests(APTest, args.image_type)
+    for test in tests:
+        if not args.app or test.app in args.app:
+            if test.pkgs:
+                pkgs.extend(test.pkgs)
+    print(' '.join(pkgs))
+
+
+def get_tests_mako(common_tests):
+    tests = common_tests
+    tests.extend([DevTest('suspend-blocker', 'mako-01')])
+    return tests
+
+
+def get_tests_touch_custom(common_tests, device_type):
+    tests = common_tests
+    tests.insert(1, Test('customizations'))
+    return tests
+
+
+def get_tests_touch(common_tests, device_type):
+    if device_type in ('krillin', 'arale'):
+        filter_tests = ['filemanager', 'ubuntu-terminal-app-autopilot',
+                        'dropping-letters-app-autopilot',
+                        'shorts-app-autopilot', 'sudoku-app-autopilot',
+                        'click_image_tests']
+        tests = [t for t in common_tests if t.name not in filter_tests]
+    else:
+        tests = common_tests
+    return tests
+
+
+def get_tests_touch_stable(common_tests, device_type):
+    if device_type in ('krillin', 'arale'):
+        filter_tests = ['filemanager', 'ubuntu-terminal-app-autopilot',
+                        'dropping-letters-app-autopilot',
+                        'shorts-app-autopilot', 'sudoku-app-autopilot',
+                        'click_image_tests']
+        tests = [t for t in common_tests if t.name not in filter_tests]
+    else:
+        tests = common_tests
+    return tests
+
+
+def _get_parser():
+    parser = argparse.ArgumentParser(
+        description='List information on configured tests for touch')
+    sub = parser.add_subparsers(title='Commands', metavar='')
+
+    p = sub.add_parser('utah', help='List UTAH tests')
+    p.set_defaults(func=_handle_utah)
+    p.add_argument('-d', '--device-type',
+                   help='Specify the device type where the tests will run')
+    p.add_argument('-i', '--image-type',
+                   help='Return list of test configured for an image type.')
+    p.add_argument('-a', '--with-autopilot', action='store_true',
+                   help='Include autopilot tests that can be run under UTAH.')
+    p.add_argument('-t', '--total-workers', type=int, default=1,
+                   help='''The total number of workers available for running
+                        tests.''')
+    p.add_argument('-w', '--worker', type=int, default=0,
+                   help='The worker to allocate applications for testing to.')
+
+    p = sub.add_parser('apps', help='List autopilot application names')
+    p.set_defaults(func=_handle_ap_apps)
+    p.add_argument('-d', '--device-type',
+                   help='Specify the device type where the tests will run')
+    p.add_argument('-i', '--image-type',
+                   help='Return list of test configured for an image type.')
+    p.add_argument('-t', '--total-workers', type=int, default=1,
+                   help='''The total number of workers available for running
+                        tests.''')
+    p.add_argument('-w', '--worker', type=int, default=0,
+                   help='The worker to allocate applications for testing to.')
+
+    p = sub.add_parser('packages', help='List packages required for autopilot')
+    p.set_defaults(func=_handle_ap_packages)
+    g = p.add_mutually_exclusive_group()
+    g.add_argument('-i', '--image-type',
+                   help='''If no apps are listed, limit to tests for an
+                        image type.''')
+    g.add_argument('-a', '--app', action='append',
+                   help='Autopilot test application. eg share_app')
+    return parser
+
+
+def main():
+    args = _get_parser().parse_args()
+    return args.func(args)
+
+if __name__ == '__main__':
+    exit(main())

=== added directory 'scripts'
=== renamed directory 'scripts' => 'scripts.moved'
=== added file 'scripts/assert-image'
--- scripts/assert-image	1970-01-01 00:00:00 +0000
+++ scripts/assert-image	2015-06-03 20:37:20 +0000
@@ -0,0 +1,31 @@
+#!/bin/sh
+
+set -e
+
+BASEDIR=$(readlink -f $(dirname $0)/..)
+
+# a simple script to ensure the proper image is installed on the target
+
+[ -z $INSTALL_URL ] && echo "= INSTALL_URL not set. Using target as-is." && exit 0
+
+echo "Ensuring target has proper image..."
+REQUIRED_UUID=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-uuid)
+ACTUAL_UUID=$(adb shell "cat /home/phablet/.ci-uuid | tr -d '\r\n'")
+if [ "$REQUIRED_UUID" != "$ACTUAL_UUID" ] ; then
+    echo "= UUIDs $REQUIRED_UUID != $ACTUAL_UUID"
+    SERVER=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-flash-server | tr -d '\r\n')
+    ARGS=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-flash-args | tr -d '\r\n')
+    CUST=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-customizations | tr -d '\r\n')
+    echo "reprovisioning device with: $ARGS"
+    echo "customizing device with: $CUST"
+        #Make the image writable if we reprovision by adding a space
+        #after to CUSTOMIZE so it is never empty
+    UUID=$REQUIRED_UUID IMAGE_SERVER=$SERVER IMAGE_OPT=$ARGS \
+        CUSTOMIZE="$CUST " ${BASEDIR}/scripts/provision.sh
+else
+    echo "= UUIDS match, reusing image on target"
+    echo $REQUIRED_UUID > clientlogs/.ci-uuid
+    curl ${INSTALL_URL}/artifact/clientlogs/.ci-flash-args > clientlogs/.ci-flash-args
+    curl ${INSTALL_URL}/artifact/clientlogs/.ci-customizations > clientlogs/.ci-customizations
+fi
+

=== added file 'scripts/boottest.sh'
--- scripts/boottest.sh	1970-01-01 00:00:00 +0000
+++ scripts/boottest.sh	2015-06-03 20:37:20 +0000
@@ -0,0 +1,204 @@
+#!/bin/bash
+set -ex
+
+# Where am I ?
+BASEDIR=$(dirname $(readlink -f $0))/..
+
+# Provide a message to report special information
+END_MESSAGE=""
+
+# The release to test the package on.
+export RELEASE=${1:-vivid}
+# The source package under test.
+export SRC_PKG_NAME=${2:-libpng}
+# The phone name.
+export NODE_NAME=$3
+
+# Default values can be provided via a local rc file (see
+# ../config/boottest.rc.example).
+BOOTTESTRC=${HOME}/.ubuntu-ci/boottest.rc
+if [ -f $BOOTTESTRC ]; then
+    source $BOOTTESTRC
+fi
+
+# Default adt-run timeout
+export ADT_TIMEOUT=${ADT_TIMEOUT:-600}
+
+# rsync can be disabled for local testing by defining:
+# export RSYNC="echo rsync"
+export RSYNC=${RSYNC:-rsync}
+# XXX psivaa 20150130: This is to use /var/local/boottest
+# directory in tachash for rsyncing the results back.
+# This should be revisited and fixed when the actual directory
+# is decided for final
+# May need tweaking/ removing the boottest section of /etc/rsyncd.conf
+# in tachash
+export RSYNC_DEST=${RSYNC_DEST:-rsync://tachash.ubuntu-ci/boottest/}
+
+# Look for a known bug, lp1421009, that results in unity8 not starting
+# and prevents adt-run from accepting the testbed
+check_for_lp1421009() {
+    SYMPTOM="ERROR: timed out waiting for Unity greeter"
+    LINK="http://launchpad.net/bugs/1421009"
+    if [ $1 -eq 16 ] && grep -q "${SYMPTOM}" ${2}/log; then
+        END_MESSAGE="Test failed due to ${LINK}"
+    fi
+}
+
+# Create an exit handler so that we are sure to create a error file even
+# when the unexpected occurs.
+exit_handler() {
+    # The errfile and resultfile variables can be used to determine if the
+    # exit was normal. If either exists, it's a normal exit, so don't overwrite
+    # the original errfile or resultfile.
+    if [ -z ${errfile} ] && [ -z ${resultfile} ]; then
+        errfile=${RELEASE}_${ARCH}_${SRC_PKG_NAME}_$(date +%Y%m%d-%H%M%S).error
+        echo "$RELEASE $ARCH $SRC_PKG_NAME" > $errfile
+        [ -f "$errfile" ] && ${RSYNC} -a $errfile $RSYNC_DEST/${RELEASE}/tmp/ || true
+    fi
+
+    # Ensure we leave a usable phone
+    [ -z ${NODE_NAME} ] || ${BASEDIR}/scripts/recover.py ${NODE_NAME}
+
+    # Leave a parting message
+    # (disable command tracing as it confuses the output)
+    set +x
+    [ -z "${END_MESSAGE}" ] || echo -e "\n\n${END_MESSAGE}\n\n"
+    set -x
+}
+trap exit_handler SIGINT SIGTERM EXIT
+
+# If the NODE_NAME is unset, we're running locally, the commands that
+# requires a phone are prefixed with "[ -z ${NODE_NAME} ] ||"
+# If you have a phone available locally, set ANDROID_SERIAL and NODE_NAME=yes
+
+# These can be set by jenkins when running in that context
+
+# ANDROID_SERIAL: The phone ID.
+[ -z ${NODE_NAME} ] || export ANDROID_SERIAL=${ANDROID_SERIAL:-$(${BASEDIR}/scripts/get-adb-id ${NODE_NAME})}
+
+# FIXME: Should be provided -- vila 2015-01-26
+ARCH="${ARCH:-krillin}"
+
+PHABLET_PASSWORD="${PHABLET_PASSWORD-0000}"
+
+# The provision.sh and run-smoke scripts can install extra packages to meet
+# the needs of image testing. Since we are installing specific packages from
+# the archive, this needs to be disabled.
+export SKIP_CLICK=1
+export SKIP_TESTCONFIG=1
+
+# Ensures we start with a usable phone
+[ -z ${NODE_NAME} ] || ${BASEDIR}/scripts/recover.py ${NODE_NAME}
+
+TESTS=${BASEDIR}/tests
+
+# Provision the device
+# Allow the image revision to be overridden if the latest is unusable
+REVISION="${REVISION:-0}"
+PROV_CMD="${BASEDIR}/scripts/provision.sh \
+    -r $REVISION \
+    -n ${HOME}/.ubuntu-ci/wifi.conf -w"
+RETRY=3
+if [ -n "${NODE_NAME}" ]; then
+    while [ ${RETRY} -gt 0 ]; do
+        echo "Provisioning device"
+        ${PROV_CMD} && break
+        PROV_ERR=$?
+        # Make sure the device doesn't need to be recovered first
+        ${BASEDIR}/scripts/recover.py ${NODE_NAME}
+        if [ ${PROV_ERR} -eq 124 ]; then
+            # The provisioning fails with a timeout, the image is not
+            # flashable/bootable
+            echo ERROR: Device provisioning failed!
+            END_MESSAGE="Test failed because the image couldn't be flashed/booted"
+            exit 1
+        fi
+        RETRY=$((${RETRY}-1))
+        echo "Provisioning failed, retrying up to ${RETRY} more times..."
+    done
+    if [ ${RETRY} -eq 0 ]; then
+        echo ERROR: Device provisioning failed!
+        exit 1
+    fi
+fi
+
+# Generate the adt-run setup-command
+rm -f adt-commands || true
+# apt-get update like adt-run does it
+echo "(apt-get update || (sleep 15; apt-get update))" >> adt-commands
+# We need dctrl-tools installed so we can use grep-aptavail below
+echo "apt-get install -f dctrl-tools" >> adt-commands
+echo 'dpkg-query -f "\${binary:Package}\n" -W | sed -e "s/:.*$//" > installed.packages' >> adt-commands
+echo "grep-aptavail -X -n -S -sPackage ${SRC_PKG_NAME}| sort | uniq > binary.packages" >> adt-commands
+echo "comm  -1 -2 binary.packages installed.packages > needs_install.packages" >> adt-commands
+echo 'release=$(lsb_release -s -c)' >> adt-commands
+echo 'cat needs_install.packages | xargs apt-get install -f -t ${release}-proposed 2> apt-get-install.stderr' >> adt-commands
+# The sourcepkg-version file contains the version of the first binary in the
+# list of binaries to install. This version data is passed back to britney
+# via the final .result file. Britney uses this to determine if the package
+# that was tested matches the version requested.
+# An assumption is made that this binary package version matches the other
+# packages installed for this test. This works because the 'apt-get install'
+# command is all or nothing. So all packages have either been updated to the
+# new version or are all stuck at the original version.
+echo 'head -n 1 needs_install.packages | xargs dpkg-query --show --showformat=\${Version} > /home/phablet/sourcepkg-version' >> adt-commands
+
+
+# --no-built-binaries should come first
+# --debug helps while debugging, can be removed otherwise
+# 'timeout' returns 124 if ${ADT_TIMEOUT} is reached.
+ADT_CMD=${ADT_CMD:-timeout ${ADT_TIMEOUT} adt-run --debug --no-built-binaries}
+# ADT_VIRT can be overridden for local tests, 
+# it defaults to ${ANDROID_SERIAL} phone via the adb/ssh combo
+ADT_VIRT=${ADT_VIRT:-adt-virt-ssh -s /usr/share/autopkgtest/ssh-setup/adb \
+    -- -s "${ANDROID_SERIAL}"}
+# - setting up -proposed and doing apt-get update
+# - via adt-virt-ssh with a setup from adb
+# - using --apt-upgrade to ensure we only deal with packages already on the
+#   phone (see above)
+ADT_OPTS="--apt-pocket=proposed\
+    --setup-commands=adt-commands \
+    --- ${ADT_VIRT}"
+
+
+if [ -n "${FORCE_FAILURE}" ]; then
+    # Force a boottest failure by running an alternate DEP8 test
+    set +e
+    ${ADT_CMD} --unbuilt-tree ${TESTS}/bootfail -o results ${ADT_OPTS}
+    RET=$?
+    set -e
+else
+    # Now execute the boot test
+    set +e
+    ${BASEDIR}/scripts/run-adt.py ${ADT_CMD} --unbuilt-tree ${TESTS}/boottest -o results ${ADT_OPTS}
+    RET=$?
+    # Fetch the sourcepkg-version file that contains the version data
+    # for the package under test. We can't use the testpkg-version file
+    # that adt-run generates because it provides the version of the
+    # fake boottest package, not the package we're actually testing.
+    adb pull /home/phablet/sourcepkg-version results/sourcepkg-version
+    set -e
+fi
+
+check_for_lp1421009 $RET results
+
+# Return Skipped as Passed
+[ $RET -eq 2 ] && RET=0
+
+if [ -e "results/sourcepkg-version" -a -e "results/testbed-packages" ]; then
+    result='PASS'
+    resultfile=results/${RELEASE}_${ARCH}_${SRC_PKG_NAME}_$(date +%Y%m%d-%H%M%S).result
+    [ $RET -gt 0 ] && result="FAIL"
+    set +x  # quiet mode as it pollutes output
+    echo "$RELEASE $ARCH ${SRC_PKG_NAME} $(cat results/sourcepkg-version) $result $(sort -u results/*-packages|tr -s '[\n\t]' ' ')" > $resultfile
+    set -x
+    [ -f "$resultfile" ] && ${RSYNC} -a $resultfile $RSYNC_DEST/${RELEASE}/tmp/ || true
+else
+    # Something went wrong with the testbed
+    errfile=results/${RELEASE}_${ARCH}_${SRC_PKG_NAME}_$(date +%Y%m%d-%H%M%S).error
+    echo "$RELEASE $ARCH $SRC_PKG_NAME" > $errfile
+    [ -f "$errfile" ] && ${RSYNC} -a $errfile $RSYNC_DEST/${RELEASE}/tmp/ || true
+fi
+
+exit $RET

=== added file 'scripts/combine_results'
--- scripts/combine_results	1970-01-01 00:00:00 +0000
+++ scripts/combine_results	2015-06-03 20:37:20 +0000
@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+
+"""
+We always run the system-settle test before and after an autopilot test. This
+script takes the results of the before/after results and combines them in with
+the junit xml results from the autopilot test so we have one unified report.
+"""
+
+
+import os
+import sys
+
+from xml.etree import ElementTree
+
+
+PRE_COMBINE = [
+    ('settle_before', 'settle_before'),
+    ('setup_setup', 'setup'),
+]
+
+POST_COMBINE = [
+    ('settle_after', 'settle_after'),
+    ('setup_teardown', 'teardown'),
+]
+
+
+def _build_node(classname, name, rcfile, stdout):
+    e = ElementTree.Element('testcase')
+    e.attrib['classname'] = classname
+    e.attrib['name'] = name
+
+    if not os.path.exists(rcfile):
+        return None, False
+
+    rc = int(open(rcfile).read())
+    if rc != 0:
+        f = ElementTree.Element('failure')
+        e.append(f)
+        f.attrib['type'] = 'testtools.testresult.real._StringException'
+        f.text = open(stdout).read()
+    return e, rc != 0
+
+
+def _get_results(apfile):
+    try:
+        tree = ElementTree.parse(apfile)
+    except Exception as ex:
+        e = ElementTree.Element('testsuite')
+        tree = ElementTree.ElementTree(e)
+        e.attrib['errors'] = '1'
+        e.attrib['failures'] = '0'
+        e.attrib['tests'] = '1'
+
+        # make a guess at the classname:
+        classname = os.path.basename(os.path.dirname(apfile))
+
+        t = ElementTree.Element('testcase')
+        e.append(t)
+        t.attrib['classname'] = classname
+        t.attrib['name'] = 'phablet-test-run'
+
+        f = ElementTree.Element('failure')
+        t.append(f)
+        f.attrib['type'] = 'testtools.testresult.real._StringException'
+        f.text = str(ex)
+
+    return tree
+
+
+def _get_classname(results):
+    if len(results) < 1:
+        return '???'
+
+    cname = results[0].attrib.get('classname')
+    if cname:
+        cname = cname.split('.')[0]
+    else:
+        cname = '???'
+    return cname
+
+
+def combine(resdir):
+    ap_file = os.path.join(resdir, 'test_results.xml')
+    tree = _get_results(ap_file)
+    ap_results = tree.getroot()
+    added_results = 0
+
+    errors = int(ap_results.attrib['errors'])
+
+    classname = _get_classname(ap_results)
+
+    for basename, label in PRE_COMBINE:
+        rc = os.path.join(resdir, basename + '.rc')
+        log = os.path.join(resdir, basename + '.log')
+        node, failed = _build_node(classname, label, rc, log)
+        if node is not None:
+            ap_results.insert(0, node)
+            if failed:
+                errors += 1
+            added_results += 1
+
+    for basename, label in POST_COMBINE:
+        rc = os.path.join(resdir, basename + '.rc')
+        log = os.path.join(resdir, basename + '.log')
+        node, failed = _build_node(classname, label, rc, log)
+        if node is not None:
+            ap_results.append(node)
+            if failed:
+                errors += 1
+            added_results += 1
+
+    num = int(ap_results.attrib['tests']) + added_results
+    ap_results.attrib['tests'] = str(num)
+    ap_results.attrib['errors'] = str(errors)
+
+    tree.write(ap_file)
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        print('usage: {} <results directory>'.format(sys.argv[0]))
+        sys.exit(1)
+
+    combine(sys.argv[1])

=== added file 'scripts/dashboard.py'
--- scripts/dashboard.py	1970-01-01 00:00:00 +0000
+++ scripts/dashboard.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,305 @@
+#!/usr/bin/python
+
+import argparse
+import datetime
+import json
+import logging
+import os
+
+import yaml
+
+from httplib import ACCEPTED, HTTPConnection, HTTPException, OK, CREATED
+from urllib import urlencode
+from urlparse import urlparse
+
+log = logging.getLogger()
+
+
+class API(object):
+    def __init__(self, host=None, port=None, user=None, key=None, prefix=None):
+        if not host:
+            host = os.environ.get('DASHBOARD_HOST', None)
+        if not port:
+            port = int(os.environ.get('DASHBOARD_PORT', '80'))
+        if not user:
+            user = os.environ.get('DASHBOARD_USER', None)
+        if not key:
+            key = os.environ.get('DASHBOARD_KEY', None)
+        if not prefix:
+            prefix = os.environ.get('DASHBOARD_PREFIX', None)
+
+        self.host = host
+        self.port = port
+        self.resource_base = prefix
+
+        self._headers = None
+        if user and key:
+            self._headers = {
+                'Content-Type': 'application/json',
+                'Authorization': 'ApiKey %s:%s' % (user, key)
+            }
+            # mod_wsgi will strip the Authorization header, but tastypie
+            # allows it as GET param also. More details for fixing apache:
+            #  http://django-tastypie.rtfd.org/en/latest/authentication.html
+            self._auth_param = '?username=%s&api_key=%s' % (user, key)
+
+    def _connect(self):
+        if self.host:
+            return HTTPConnection(self.host, self.port)
+        return None
+
+    def _http_get(self, resource):
+        con = self._connect()
+        if not con:
+            # we just mock this for the case where the caller wants to
+            # use our API transparently enabled/disabled
+            return {}
+
+        if self.resource_base:
+            resource = self.resource_base + resource
+
+        logging.debug('doing get on: %s', resource)
+        headers = {'Content-Type': 'application/json'}
+        con.request('GET', resource, headers=headers)
+        resp = con.getresponse()
+        if resp.status != OK:
+            msg = ''
+            try:
+                msg = resp.read().decode()
+            except:
+                pass
+            fmt = '%d error getting resource(%s): %s'
+            raise HTTPException(fmt % (resp.status, resource, msg))
+        data = json.loads(resp.read().decode())
+        if len(data['objects']) == 0:
+            raise HTTPException('resource not found: %s' % resource)
+        assert len(data['objects']) == 1
+        return data['objects'][0]['resource_uri']
+
+    def _http_post(self, resource, params):
+        con = self._connect()
+        if not con or not self._headers:
+            return None
+
+        if self.resource_base:
+            resource = self.resource_base + resource
+        resource += self._auth_param
+
+        params = json.dumps(params)
+        log.debug('posting (%s): %s', resource, params)
+        con.request('POST', resource, params, self._headers)
+        resp = con.getresponse()
+        if resp.status != CREATED:
+            msg = ''
+            try:
+                msg = str(resp.getheaders())
+                msg += resp.read().decode()
+            except:
+                pass
+            raise HTTPException(
+                '%d creating resource(%s): %s' % (resp.status, resource, msg))
+        uri = resp.getheader('Location')
+        return urlparse(uri).path
+
+    def _http_patch(self, resource, params):
+        con = self._connect()
+        if not con or not self._headers:
+            return None
+
+        resource += self._auth_param
+
+        con.request('PATCH', resource, json.dumps(params), self._headers)
+        resp = con.getresponse()
+        if resp.status != ACCEPTED:
+            msg = ''
+            try:
+                msg = resp.getheaders()
+            except:
+                pass
+            raise HTTPException(
+                '%d patching resource(%s): %s' % (resp.status, resource, msg))
+        return resource
+
+    @staticmethod
+    def _uri_to_pk(resource_uri):
+        if resource_uri:
+            return resource_uri.split('/')[-2]
+        return None  # we are mocked
+
+    def job_get(self, name):
+        resource = '/smokeng/api/v1/job/?' + urlencode({'name': name})
+        return self._http_get(resource)
+
+    def job_add(self, name):
+        resource = '/smokeng/api/v1/job/'
+        params = {
+            'name': name,
+            'url': 'http://jenkins.qa.ubuntu.com/job/' + name + '/'
+        }
+        return self._http_post(resource, params)
+
+    def build_add(self, job_name, job_number):
+        try:
+            logging.debug('trying to find job: %s', job_name)
+            job = self.job_get(job_name)
+        except HTTPException:
+            job = self.job_add(job_name)
+        logging.info('job is: %s', job)
+
+        resource = '/smokeng/api/v1/build/'
+        params = {
+            'build_number': job_number,
+            'job': job,
+            'ran_at': datetime.datetime.now().isoformat(),
+            'build_description': 'inprogress',
+        }
+        return self._http_post(resource, params)
+
+    def _image_get(self, build_number, release, variant, arch, flavor):
+        resource = '/smokeng/api/v1/image/?'
+        resource += urlencode({
+            'build_number': build_number,
+            'release': release,
+            'flavor': flavor,
+            'variant': variant,
+            'arch': arch,
+        })
+        return self._http_get(resource)
+
+    def image_add(self, build_number, release, variant, arch, flavor):
+        try:
+            img = self._image_get(build_number, release, variant, arch, flavor)
+            return img
+        except HTTPException:
+            # image doesn't exist so go continue and create
+            pass
+
+        resource = '/smokeng/api/v1/image/'
+        params = {
+            'build_number': build_number,
+            'release': release,
+            'flavor': flavor,
+            'variant': variant,
+            'arch': arch,
+        }
+        try:
+            return self._http_post(resource, params)
+        except HTTPException:
+            # race situation. Both callers saw _image_get fail and tried to
+            # create. Only one of them can succeed, so the failed call should
+            # now safely be able to get the image created by the other
+            img = self._image_get(build_number, release, variant, arch, flavor)
+            return img
+
+    def result_get(self, image, test):
+        # deal with getting resource uri's as parameters instead of id's
+        image = API._uri_to_pk(image)
+
+        resource = '/smokeng/api/v1/result/?'
+        resource += urlencode({
+            'image': image,
+            'name': test,
+        })
+        return self._http_get(resource)
+
+    def _result_status(self, image, build, test, status, results=None):
+        create = False
+        params = {
+            'ran_at': datetime.datetime.now().isoformat(),
+            'status': status,
+            'jenkins_build': build,
+        }
+        if results:
+            params['results'] = results
+
+        try:
+            resource = self.result_get(image, test)
+        except HTTPException:
+            create = True
+            resource = '/smokeng/api/v1/result/'
+            params['image'] = image
+            params['name'] = test
+
+        if create:
+            return self._http_post(resource, params)
+        else:
+            return self._http_patch(resource, params)
+
+    def result_queue(self, image, build, test):
+        return self._result_status(image, build, test, 0)
+
+    def result_running(self, image, build, test):
+        return self._result_status(image, build, test, 1)
+
+    def result_syncing(self, image, build, test, results):
+        return self._result_status(image, build, test, 2, results)
+
+
+def _result_running(api, args):
+    return api.result_running(args.image, args.build, args.test)
+
+
+def _result_syncing(api, args):
+    results = {}
+    with open(args.results) as f:
+        results = yaml.safe_load(f.read())
+    return api.result_syncing(args.image, args.build, args.test, results)
+
+
+def _set_args(parser, names, func):
+    for n in names:
+        parser.add_argument(n, required=True)
+    parser.set_defaults(func=func)
+
+
+def _get_parser():
+    parser = argparse.ArgumentParser(
+        description='Interact with the CI dashboard API')
+
+    sub = parser.add_subparsers(title='Commands', metavar='')
+
+    args = ['--image', '--build', '--test']
+    p = sub.add_parser('result-running', help='Set a SmokeResult "Running".')
+    _set_args(p, args, _result_running)
+
+    p = sub.add_parser('result-syncing', help='Set a SmokeResult "Syncing".')
+    _set_args(p, args, _result_syncing)
+    p.add_argument('--results', required=True, help='UTAH yaml file')
+
+    return parser
+
+
+def _assert_env():
+    required = [
+        'DASHBOARD_HOST', 'DASHBOARD_PORT', 'DASHBOARD_USER', 'DASHBOARD_KEY']
+    missing = []
+    for r in required:
+        if r not in os.environ:
+            missing.append(r)
+    if len(missing):
+        print('Missing the following environment variables:')
+        for x in missing:
+            print('  %s' % x)
+        exit(1)
+
+
+def _main(args):
+    _assert_env()
+
+    api = API()
+    try:
+        val = args.func(api, args)
+        if val:
+            if '/?' in val:
+                log.debug('stripping api-key from response')
+                val = val.split('/?')[0] + '/'
+            print(val)
+    except HTTPException as e:
+        print('ERROR: %s' % e)
+        exit(1)
+
+    exit(0)
+
+if __name__ == '__main__':
+    args = _get_parser().parse_args()
+    exit(_main(args))

=== added file 'scripts/device_info.py'
--- scripts/device_info.py	1970-01-01 00:00:00 +0000
+++ scripts/device_info.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,381 @@
+#!/usr/bin/env python
+
+import logging
+import os
+import re
+import requests
+import subprocess
+import sys
+import time
+import urlparse
+
+from masher_control import set_button
+from ncd_usb import set_relay
+
+log = logging.getLogger()
+logging.basicConfig(level=logging.INFO)
+
+
+class DeviceError(Exception):
+    pass
+
+
+class TouchDevice(object):
+    def __init__(self, devtype, serial, relay_url=None, bank=None,
+                 power_pin=None, volume_down_pin=None, volume_up_pin=None,
+                 image_server='https://system-image.ubuntu.com',
+                 image_channel='ubuntu-touch/stable',
+                 extra_args=None):
+        self.devtype = devtype
+        self.serial = serial
+        self.relay_url = relay_url
+        self.bank = bank
+        self.power_pin = power_pin
+        self.volume_down_pin = volume_down_pin
+        self.volume_up_pin = volume_up_pin
+        self.image_server = image_server
+        self.image_channel = image_channel
+        self.extra_args = extra_args
+
+    def get_serial(self):
+        return self.serial
+
+    def get_state(self):
+        """
+        Check adb and fastboot to determine the state a device is in.
+        Possible return values are:
+            device, recovery, unknown, bootloader, disconnected
+        """
+        pattern = "{}\t(.+)\n".format(self.serial)
+        adb_devices = subprocess.check_output(['adb', 'devices'])
+        found = re.search(pattern, adb_devices)
+        if not found:
+            #Otherwise, check fastboot
+            fastboot_devices = subprocess.check_output(['fastboot', 'devices'])
+            found = re.search(pattern, fastboot_devices)
+        if found:
+            state = found.group(1)
+            return state
+        else:
+            return 'disconnected'
+
+    def check_adb_shell(self):
+        # Run a quick command in adb to see if the device is responding
+        # subprocess will handle raising an exception if anything
+        # goes wrong
+        subprocess.check_call(['timeout', '10', 'adb', '-s',
+                               self.serial, 'shell', 'pwd'])
+
+    def reimage_from_fastboot(self):
+        #Starting from fastboot mode, put a known-good image on the device
+        recovery_base = 'http://people.canonical.com/~plars/touch'
+        recovery_img = 'recovery-{}.img'.format(self.devtype)
+        recovery_url = os.path.join(recovery_base, recovery_img)
+        # For certain devices, we need to first pull an alternate
+        # recovery image that has adb enabled. If it's needed, it will
+        # be at that url, otherwise we don't even try to use it.
+        try:
+            _download(recovery_url, 'recovery')
+        except:
+            # Don't fail for any reason, if attempt to flash without
+            pass
+        udf_command = ['ubuntu-device-flash',
+                       '--server', self.image_server,
+                       'touch', '--serial', self.serial,
+                       '--channel', self.image_channel,
+                       '--bootstrap', '--developer-mode',
+                       '--password', '0000']
+        if self.extra_args:
+            udf_command.extend(self.extra_args)
+        if os.path.exists(os.path.join('recovery', recovery_img)):
+            udf_command.extend(['--recovery-image',
+                                os.path.join('recovery', recovery_img)])
+        log.info("Flashing the last stable image")
+        subprocess.check_output(udf_command)
+        return self.wait_for_device(600)
+
+    def wait_for_fastboot(self, timeout=120):
+        if timeout > 10:
+            wait = 10
+        else:
+            wait = timeout
+        waited = 0
+        while waited < timeout:
+            state = self.get_state()
+            if state == 'fastboot':
+                return 0
+            time.sleep(wait)
+            waited += wait
+        else:
+            state = self.get_state()
+            if state == 'fastboot':
+                return 0
+            log.error("Timed out waiting for fastboot. Recover device "
+                      "manually")
+            raise DeviceError("Device in state: {0}, still not available "
+                              "after {1} seconds".format(state, timeout))
+
+    def reboot(self):
+        dev_state = self.get_state()
+        if dev_state not in ('device', 'recovery'):
+            raise DeviceError('Unable to reboot device from this state')
+        subprocess.check_call(['adb', '-s', self.serial, 'reboot'])
+
+    def wait_for_device(self, timeout=120):
+        # Wait for the device to come up to a good/booted state
+        log.info("Waiting for the device to become available")
+        try:
+            subprocess.check_call(['timeout', str(timeout), 'adb', '-s',
+                                  self.serial, 'wait-for-device'])
+        except:
+            log.error("Timed out waiting for device.")
+            raise
+        dev_state = self.get_state()
+        if dev_state != 'device':
+            log.error("Device in state: {0}, still not available after "
+                      "{1} seconds".format(dev_state, timeout))
+            raise DeviceError("Timed out waiting for device to respond after "
+                              "{1} seconds".format(dev_state, timeout))
+        else:
+            log.info("Device is now available")
+            return 0
+
+    def force_bootloader(self):
+        bootloader_func = getattr(
+            self, '_{}_to_bootloader'.format(self.devtype))
+        if not self.relay_url:
+            log.error("Device cannot be recovered, no relay data exists!")
+            sys.exit(-1)
+        if bootloader_func and callable(bootloader_func):
+            bootloader_func()
+        else:
+            raise DeviceError("Full recovery not possible with this device")
+
+    def _arale_to_bootloader(self):
+        log.info("Forcing the device to enter the bootloader")
+        # XXX fginther - 2015-03-29
+        # Refine the power off and fastboot sequence
+        set_button(self.relay_url, self.volume_down_pin, 1)
+        set_button(self.relay_url, self.power_pin, 1)
+        time.sleep(10)
+        set_button(self.relay_url, self.power_pin, 0)
+        time.sleep(10)
+        set_button(self.relay_url, self.volume_down_pin, 0)
+
+    def _krillin_to_bootloader(self):
+        log.info("Forcing the device to enter the bootloader")
+        #Power off the device from any state
+        set_relay(self.relay_url, self.bank, self.power_pin, 1)
+        set_relay(self.relay_url, self.bank, self.volume_down_pin, 1)
+        set_relay(self.relay_url, self.bank, self.volume_up_pin, 1)
+        time.sleep(16)
+        set_relay(self.relay_url, self.bank, self.power_pin, 0)
+        time.sleep(6)
+        set_relay(self.relay_url, self.bank, self.volume_down_pin, 0)
+        set_relay(self.relay_url, self.bank, self.volume_up_pin, 0)
+
+    def _flo_to_bootloader(self):
+        log.info("Forcing the device to enter the bootloader")
+        #Power off the device from any state
+        set_relay(self.relay_url, self.bank, self.power_pin, 1)
+        time.sleep(12)
+        set_relay(self.relay_url, self.bank, self.power_pin, 0)
+        time.sleep(10)
+        set_relay(self.relay_url, self.bank, self.volume_down_pin, 1)
+        set_relay(self.relay_url, self.bank, self.power_pin, 1)
+        time.sleep(5)
+        set_relay(self.relay_url, self.bank, self.power_pin, 0)
+        time.sleep(1)
+        set_relay(self.relay_url, self.bank, self.volume_down_pin, 0)
+
+    def _mako_to_bootloader(self):
+        log.info("Forcing the device to enter the bootloader")
+        #Power off the device from any state
+        set_relay(self.relay_url, self.bank, self.power_pin, 1)
+        time.sleep(12)
+        set_relay(self.relay_url, self.bank, self.power_pin, 0)
+        time.sleep(10)
+        #Enter the bootloader
+        set_relay(self.relay_url, self.bank, self.volume_down_pin, 1)
+        set_relay(self.relay_url, self.bank, self.power_pin, 1)
+        time.sleep(5)
+        set_relay(self.relay_url, self.bank, self.volume_down_pin, 0)
+        set_relay(self.relay_url, self.bank, self.power_pin, 0)
+
+
+# When looking at the relay webUI for the mapping, we consider all
+# ports and banks to start numbering from 0
+DEVICES = {
+    "arale-01": TouchDevice("arale", "75UABKPUK9EW",
+                            relay_url="http://10.74.120.150:8000",
+                            power_pin=0, volume_down_pin=1,
+                            image_channel="ubuntu-touch/rc-proposed/meizu.en",
+                            extra_args=['--device', 'arale']),
+    "arale-02": TouchDevice("arale", "75UABKPN2CND",
+                            relay_url="http://10.74.120.150:8000",
+                            power_pin=2, volume_down_pin=3,
+                            image_channel="ubuntu-touch/rc-proposed/meizu.en",
+                            extra_args=['--device', 'arale']),
+    "arale-03": TouchDevice("arale", "75UABKP44J83",
+                            relay_url="http://10.74.120.150:8000",
+                            power_pin=4, volume_down_pin=5,
+                            image_channel="ubuntu-touch/rc-proposed/meizu.en",
+                            extra_args=['--device', 'arale']),
+    "arale-04": TouchDevice("arale", "75UABKPUFHL9",
+                            relay_url="http://10.74.120.150:8000",
+                            power_pin=6, volume_down_pin=7,
+                            image_channel="ubuntu-touch/rc-proposed/meizu.en",
+                            extra_args=['--device', 'arale']),
+    "arale-05": TouchDevice("arale", "75UABL662MQ3",
+                            image_channel="ubuntu-touch/rc-proposed/meizu.en",
+                            extra_args=['--device', 'arale']),
+    "arale-06": TouchDevice("arale", "75UABL6NEYKR",
+                            image_channel="ubuntu-touch/rc-proposed/meizu.en",
+                            extra_args=['--device', 'arale']),
+    "arale-07": TouchDevice("arale", "75UABL6K4KPD",
+                            image_channel="ubuntu-touch/rc-proposed/meizu.en",
+                            extra_args=['--device', 'arale']),
+    "arale-08": TouchDevice("arale", "75UABL65U7BB",
+                            image_channel="ubuntu-touch/rc-proposed/meizu.en",
+                            extra_args=['--device', 'arale']),
+    "krillin-01": TouchDevice("krillin", "JB011018"),
+    "krillin-02": TouchDevice("krillin", "JB010894"),
+    "krillin-03": TouchDevice("krillin", "JB015156",
+                              relay_url="http://bos01-a-04-shelf03-relay.power",
+                              bank=2, power_pin=0, volume_up_pin=1,
+                              volume_down_pin=2),
+    "krillin-04": TouchDevice("krillin", "JB006885",
+                              relay_url="http://bos01-a-04-shelf03-relay.power",
+                              bank=1, power_pin=4, volume_up_pin=5,
+                              volume_down_pin=6),
+    "krillin-05": TouchDevice("krillin", "JB015256"),
+    "krillin-06": TouchDevice("krillin", "JW010687"),
+    "krillin-07": TouchDevice("krillin", "JW011999",
+                              relay_url="http://bos01-a-04-shelf03-relay.power",
+                              bank=2, power_pin=4, volume_up_pin=5,
+                              volume_down_pin=6),
+    "krillin-08": TouchDevice("krillin", "JW013513",
+                              relay_url="http://bos01-a-04-shelf03-relay.power",
+                              bank=1, power_pin=0, volume_up_pin=1,
+                              volume_down_pin=2),
+    "krillin-09": TouchDevice("krillin", "JW010053",
+                              relay_url="http://bos01-a-04-shelf03-relay.power",
+                              bank=0, power_pin=4, volume_up_pin=5,
+                              volume_down_pin=6),
+    "krillin-10": TouchDevice("krillin", "JB012976",
+                              relay_url="http://bos01-a-04-shelf02-relay.power",
+                              bank=2, power_pin=0, volume_up_pin=1,
+                              volume_down_pin=2),
+    "krillin-11": TouchDevice("krillin", "JB072312"),
+    "krillin-12": TouchDevice("krillin", "JB071487"),
+    "krillin-13": TouchDevice("krillin", "JB044235"),
+    "krillin-14": TouchDevice("krillin", "JB072205"),
+    "krillin-15": TouchDevice("krillin", "JB071743"),
+    "mako-21": TouchDevice("mako", "0090f741e3d141bc",
+                           relay_url="http://bos01-a-04-shelf01-relay.power",
+                           bank=0, power_pin=0, volume_down_pin=1),
+    "mako-22": TouchDevice("mako", "04ccca120acd4dea",
+                           relay_url="http://bos01-a-04-shelf01-relay.power",
+                           bank=0, power_pin=2, volume_down_pin=3),
+    "mako-23": TouchDevice("mako", "04cb53b598546534",
+                           relay_url="http://bos01-a-04-shelf01-relay.power",
+                           bank=0, power_pin=4, volume_down_pin=5),
+    "mako-24": TouchDevice("mako", "04cbcc545f5328a5",
+                           relay_url="http://bos01-a-04-shelf01-relay.power",
+                           bank=0, power_pin=6, volume_down_pin=7),
+    "mako-01": TouchDevice("mako", "01aa3d7a5dcba4a2"),
+    "mako-02": TouchDevice("mako", "01ade38b552014d4"),
+    "mako-03": TouchDevice("mako", "04c6714ed7c863f2"),
+    "mako-04": TouchDevice("mako", "04df89cf0f9d0933",
+                           relay_url="http://bos01-a-04-shelf01-relay.power",
+                           bank=2, power_pin=2, volume_down_pin=3),
+    "mako-05": TouchDevice("mako", "01b22f82dc5cec63",
+                           relay_url="http://bos01-a-04-shelf02-relay.power",
+                           bank=0, power_pin=0, volume_down_pin=1),
+    "mako-06": TouchDevice("mako", "04ed70928fdc13ba",
+                           relay_url="http://bos01-a-04-shelf02-relay.power",
+                           bank=0, power_pin=2, volume_down_pin=3),
+    "mako-07": TouchDevice("mako", "01e2f64788556934",
+                           relay_url="http://bos01-a-04-shelf02-relay.power",
+                           bank=0, power_pin=4, volume_down_pin=5),
+    "mako-08": TouchDevice("mako", "04ea16a163930769",
+                           relay_url="http://bos01-a-04-shelf02-relay.power",
+                           bank=0, power_pin=6, volume_down_pin=7),
+    "mako-09": TouchDevice("mako", "04fda12ea08fe3c7",
+                           relay_url="http://bos01-a-04-shelf01-relay.power",
+                           bank=2, power_pin=0, volume_down_pin=1),
+    "mako-10": TouchDevice("mako", "01ce848e48dfa6a2"),
+    "mako-11": TouchDevice("mako", "04ed727c929709ba"),
+    #If looking at the LAB wiki page, subtract 1 from the bank and pin numbers
+    #from what it says on the wiki (our numbers start at 0)
+    "mako-12": TouchDevice("mako", "00693fd555c9186a",
+                           relay_url="http://bos01-a-04-shelf04-relay.power",
+                           bank=2, power_pin=0, volume_down_pin=1),
+    "mako-13": TouchDevice("mako", "0084e99c5315731b",
+                           relay_url="http://bos01-a-04-shelf04-relay.power",
+                           bank=0, power_pin=3, volume_down_pin=4),
+    "mako-14": TouchDevice("mako", "007c6d84d348838e",
+                           relay_url="http://bos01-a-04-shelf04-relay.power",
+                           bank=0, power_pin=1, volume_down_pin=2),
+    "mako-15": TouchDevice("mako", "00763b4a61ce0f87",
+                           relay_url="http://bos01-a-04-shelf04-relay.power",
+                           bank=0, power_pin=6, volume_down_pin=7),
+    "mako-16": TouchDevice("mako", "017121eacf5282c4",
+                           relay_url="http://bos01-a-04-shelf04-relay.power",
+                           bank=0, power_pin=4, volume_down_pin=5),
+    #mako-17 has a broken screen but should work, on ashes
+    "mako-17": TouchDevice("mako", "04e0d2f6d3cab77d"),
+    "mako-18": TouchDevice("mako", "027b981a4c1110dd",
+                           relay_url="http://bos01-a-04-shelf02-relay.power",
+                           bank=1, power_pin=0, volume_down_pin=1),
+    "mako-19": TouchDevice("mako", "021c8cdfd5d38602",
+                           relay_url="http://bos01-a-04-shelf02-relay.power",
+                           bank=1, power_pin=4, volume_down_pin=5),
+    "mako-20": TouchDevice("mako", "05083705e0d29402",
+                           relay_url="http://bos01-a-04-shelf02-relay.power",
+                           bank=1, power_pin=2, volume_down_pin=3),
+    "mako-fginther": TouchDevice("mako", "04c3c2be1d5248b3"),
+    "ps-manta-01": TouchDevice("manta", "R32D203DDZR"),
+    "manta-01": TouchDevice("manta", "R32D102RPZL"),
+    "manta-02": TouchDevice("manta", "R32D102RPPK"),
+    "manta-03": TouchDevice("manta", "R32D200N4YH"),
+    "manta-05": TouchDevice("manta", "R32D203DMBY"),  # Out of lab for now
+    "flo-01": TouchDevice("flo", "09f306dc"),
+    "flo-02": TouchDevice("flo", "08dbee36"),
+    "flo-03": TouchDevice("flo", "09d55fa8"),
+    "flo-04": TouchDevice("flo", "09e68682"),
+    "flo-05": TouchDevice("flo", "0a22f7cf",
+                          relay_url="http://bos01-a-04-shelf03-relay.power",
+                          bank=0, power_pin=0, volume_down_pin=2),
+    "flo-06": TouchDevice("flo", "08f09bb0"),
+}
+
+
+def get_device(name):
+    # This raises KeyError if we don't have any record of that device
+    return DEVICES[name]
+
+
+def _download(url, path):
+    try:
+        os.makedirs(path)
+    except OSError:
+        # Don't fail if the directory already exists
+        pass
+    urlpath = urlparse.urlsplit(url).path
+    filename = os.path.basename(urlpath)
+    filename = os.path.join(path, filename)
+    if os.path.exists(filename):
+        # Don't re-download if it's already there
+        return filename
+
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+    with open(filename, 'wb') as f:
+        for chunk in response.iter_content(chunk_size=64 * 1024):
+            # Ignore keep-alives
+            if not chunk:
+                continue
+            f.write(chunk)
+            f.flush()
+    return filename

=== added file 'scripts/get-adb-id'
--- scripts/get-adb-id	1970-01-01 00:00:00 +0000
+++ scripts/get-adb-id	2015-06-03 20:37:20 +0000
@@ -0,0 +1,14 @@
+#!/usr/bin/python
+
+import sys
+from device_info import get_device
+
+if __name__ == '__main__':
+    name = sys.argv[1]
+
+    try:
+        device = get_device(name)
+        print(device.get_serial())
+    except:
+        print("Unknown device name: '%s'" % name)
+        sys.exit(-1)

=== added file 'scripts/get-device-info'
--- scripts/get-device-info	1970-01-01 00:00:00 +0000
+++ scripts/get-device-info	2015-06-03 20:37:20 +0000
@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+import argparse
+import device_info
+import sys
+
+
+def _get_state(args):
+    if args.name == 'all':
+        for device in device_info.DEVICES:
+            sys.stdout.write("{}: ".format(device))
+            print(device_info.get_device(device).get_state())
+    else:
+        device = device_info.get_device(args.name)
+        print(device.get_state())
+
+
+def _get_serial(args):
+    device = device_info.get_device(args.name)
+    print(device.get_serial())
+
+
+def _get_parser():
+    parser = argparse.ArgumentParser(
+        description='Get information about a device')
+    sub = parser.add_subparsers(title='Commands', metavar='')
+    serial = sub.add_parser('serial', help='Get serial for a device name')
+    serial.set_defaults(func=_get_serial)
+    serial.add_argument('name', help='Device name')
+    state = sub.add_parser('state', help='Get device state for a device')
+    state.set_defaults(func=_get_state)
+    state.add_argument('name', help='Device name')
+    return parser
+
+
+if __name__ == '__main__':
+    args = _get_parser().parse_args()
+    exit(args.func(args))

=== added file 'scripts/jenkins.sh'
--- scripts/jenkins.sh	1970-01-01 00:00:00 +0000
+++ scripts/jenkins.sh	2015-06-03 20:37:20 +0000
@@ -0,0 +1,216 @@
+#!/bin/bash
+
+## This is the script jenkins should run to execute various touch applications
+
+set -e
+
+BASEDIR=$(dirname $(readlink -f $0))/..
+
+RESDIR="${RESDIR-`pwd`/clientlogs}"
+UTAHFILE=${RESDIR}/utah.yaml
+UTAH_PHABLET_CMD="${UTAH_PHABLET_CMD-/usr/share/utah/examples/run_utah_phablet.py}"
+
+
+usage() {
+    cat <<EOF
+usage: $0 -a APP [-s ANDROID_SERIAL] [-p FILE -p FILE ...] [-Q]
+
+Provisions the given device with the latest build
+
+OPTIONS:
+  -h    Show this message
+  -s    Specify the serial of the device to install
+  -a    The application under the "tests" directory to test
+  -p    Extra file to pull from target (absolute path or relative to /home/phablet)
+  -Q    "Quick" don't do a reboot of the device before running the test
+
+EOF
+}
+
+PIDS=""
+
+cleanup() {
+    set +e
+    echo "killing child pids: $PIDS"
+    for p in $PIDS ; do
+        kill $p
+    done
+}
+
+test_from_host() {
+    export PATH=${BASEDIR}/utils/host:${PATH}
+
+    # allow for certain commands to run from host/target
+    # see unity8-autopilot/ts_control for example
+    export TARGET_PREFIX=adb-shell
+
+    [ -z $ANDROID_SERIAL ] || ADBOPTS="-s $ANDROID_SERIAL"
+
+    # If we are not in the utah group, then we don't have permissions
+    # for /var/lib/utah, so run under sudo
+    if ! groups |grep -q utah ; then
+        SUDO="sudo"
+        sudo TARGET_PREFIX="${TARGET_PREFIX}" PATH="${PATH}" \
+            ${UTAH_PHABLET_CMD} \
+            ${ADBOPTS} \
+            --from-host \
+            --whoopsie \
+            --results-dir "${RESDIR}" \
+            --skip-install --skip-network --skip-utah \
+            --pull /var/crash \
+            --pull /home/phablet/.cache/upstart \
+            --pull /tmp/xmlresults \
+                    --pull /var/log/syslog \
+                    --pull /var/log/kern.log \
+                    --pull /var/log/upstart/whoopsie.log \
+            $EXTRA_PULL \
+            -l "${TESTSUITE_HOST}/master.run"
+    else
+        TARGET_PREFIX="${TARGET_PREFIX}" PATH="${PATH}" \
+            ${UTAH_PHABLET_CMD} \
+            ${ADBOPTS} \
+            --from-host \
+            --whoopsie \
+            --results-dir "${RESDIR}" \
+            --skip-install --skip-network --skip-utah \
+            --pull /var/crash \
+            --pull /home/phablet/.cache/upstart \
+            --pull /tmp/xmlresults \
+                    --pull /var/log/syslog \
+                    --pull /var/log/kern.log \
+                    --pull /var/log/upstart/whoopsie.log \
+            $EXTRA_PULL \
+            -l "${TESTSUITE_HOST}/master.run"
+    fi
+
+    # make sure the user running this script can remove its artifacts.
+    # only run this if we had to run under sudo
+    if [ "${SUDO}" = "sudo" ] ; then
+        sudo chown -R "${USER}" ${RESDIR}
+    fi
+}
+
+assert_image() {
+    [ -z $INSTALL_URL ] && return
+    echo "Ensuring target has proper image..."
+    REQUIRED_UUID=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-uuid)
+    ACTUAL_UUID=$(adb shell "cat /home/phablet/.ci-uuid | tr -d '\r\n'")
+    if [ "$REQUIRED_UUID" != "$ACTUAL_UUID" ] ; then
+        echo "UUIDs $REQUIRED_UUID != $ACTUAL_UUID, reprovisioning device..."
+        ARGS=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-utah-args | tr -d '\r\n')
+        SERVER=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-flash-server | tr -d '\r\n')
+        UUID=$REQUIRED_UUID IMAGE_SERVER=$SERVER IMAGE_OPT=$ARGS \
+            ${BASEDIR}/scripts/provision.sh
+    else
+        echo "UUIDS match"
+    fi
+}
+
+main() {
+    rm -rf $RESDIR
+    mkdir $RESDIR
+
+    assert_image
+
+    # print the build date so the jenkins job can use it as the
+    # build description
+    adb pull /var/log/installer/media-info ${RESDIR}
+    BUILDID=$(adb shell cat /home/phablet/.ci-version)
+    echo "= TOUCH IMAGE VERSION:$BUILDID"
+
+    adb shell "top -n1 -b" > ${RESDIR}/top.log
+
+    set -x
+    adb shell 'sudo rm -f /var/crash/*'
+    if [ -z $QUICK ] ; then
+        # get the phone in sane place
+        adb reboot
+        # sometimes reboot doesn't happen fast enough, so add a little
+        # delay to help ensure its actually rebooted and we didn't just
+        # connect back to the device before it rebooted
+        adb wait-for-device
+        sleep 5
+        adb wait-for-device
+        phablet-network --skip-setup -t 90s
+        adb shell sudo powerd-cli active &
+        PIDS="$PIDS $!"
+        adb shell sudo powerd-cli display on &
+        PIDS="$PIDS $!"
+    else
+        echo "SKIPPING phone reboot..."
+    fi
+
+    ${BASEDIR}/utils/host/adb-shell "sudo aa-clickhook -f --include=/usr/share/autopilot-touch/apparmor/click.rules"
+
+    echo "launching test from the host...."
+    test_from_host
+    adb shell 'sudo rm -f /var/crash/*'
+
+    if ! `grep "^errors: [!0]" < $UTAHFILE >/dev/null` ; then
+        echo "errors found"
+        EXITCODE=1
+    fi
+    if ! `grep "^failures: [!0]" < $UTAHFILE >/dev/null` ; then
+        echo "failures found"
+        EXITCODE=2
+    fi
+    echo "Results Summary"
+    echo "---------------"
+    egrep '^(errors|failures|passes|fetch_errors):' $UTAHFILE
+    exit $EXITCODE
+}
+
+while getopts p:s:a:Qh opt; do
+    case $opt in
+    h)
+        usage
+        exit 0
+        ;;
+    s)
+        export ANDROID_SERIAL=$OPTARG
+        ;;
+    a)
+        APP=$OPTARG
+        ;;
+    p)
+        EXTRA_PULL_FILE=$OPTARG
+
+        if [ ! -z $EXTRA_PULL_FILE ]; then
+            # relative paths are assumed to be relative to /home/phablet
+            E_P_START=`echo $EXTRA_PULL_FILE | cut -c1`
+
+            if [ $E_P_START = '/' ]; then
+                EXTRA_PULL="$EXTRA_PULL --pull $EXTRA_PULL_FILE"
+            else
+                EXTRA_PULL="$EXTRA_PULL --pull /home/phablet/$EXTRA_PULL_FILE"
+            fi
+        fi
+        ;;
+    Q)
+        QUICK=1
+        ;;
+  esac
+done
+
+if [ -z $ANDROID_SERIAL ] ; then
+    # ensure we only have one device attached
+    lines=$(adb devices | wc -l)
+    if [ $lines -gt 3 ] ; then
+        echo "ERROR: More than one device attached, please use -s option"
+    echo
+        usage
+        exit 1
+    fi
+fi
+if [ -z $APP ] ; then
+    echo "ERROR: No app specified"
+    usage
+    exit 1
+fi
+
+TESTSUITE_HOST=$(readlink -f ${BASEDIR}/tests/${APP})
+TESTSUITE_TARGET_BASE=/tmp/tests
+TESTSUITE_TARGET=${TESTSUITE_TARGET_BASE}/$(basename ${TESTSUITE_HOST})
+
+trap cleanup TERM INT EXIT
+main

=== added file 'scripts/junit2utah.py'
--- scripts/junit2utah.py	1970-01-01 00:00:00 +0000
+++ scripts/junit2utah.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,70 @@
+#!/usr/bin/python
+
+import datetime
+import sys
+
+from xml.etree import ElementTree
+
+import yaml
+
+
+def _convert_testcase(tc):
+    x = {
+        'testcase': tc.attrib['name'],
+        'testsuite': tc.attrib['classname'],
+        'command': 'autopilot',
+        'cmd_type': 'testcase_test',
+        'stdout': '',
+        'stderr': '',
+        'returncode': 0
+    }
+    t = tc.attrib.get('time', False)
+    if t:
+        x['time_delta'] = t
+
+    for e in tc.getchildren():
+        if e.tag in ('failure', 'error'):
+            x['stderr'] = e.text
+            x['returncode'] = 1
+        elif e.tag == 'skip':
+            # NOTE: this isn't a real thing in UTAH. However, the
+            # qa-dashboard code doesn't care and will display it as skipped
+            x['cmd_type'] = 'testcase_skipped'
+            x['stdout'] = e.text
+        else:
+            raise RuntimeError('Unknown element type: %s' % e.tag)
+    return x
+
+
+def _get_results(stream):
+    tree = ElementTree.fromstring(stream.read())
+    results = {
+        'errors': int(tree.attrib.get('errors', '0')),
+        'failures': int(tree.attrib.get('failures', '0')),
+        'commands': [],
+        'fetch_errors': 0,
+        'uname': 'n/a',
+        'media-info': 'n/a',
+        'install_type': 'n/a',
+        'arch': 'n/a',
+        'release': 'n/a',
+        'build_number': 'n/a',
+        'name': 'unamed',
+        'runlist': 'n/a',
+        'ran_at': datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S'),
+    }
+    results['passes'] = \
+        int(tree.attrib['tests']) - results['errors'] - results['failures']
+
+    for tc in tree.getchildren():
+        results['commands'].append(_convert_testcase(tc))
+    return results
+
+
+def _main(stream):
+    results = _get_results(stream)
+    print(yaml.safe_dump(results, default_flow_style=False))
+
+
+if __name__ == '__main__':
+    exit(_main(sys.stdin))

=== added file 'scripts/masher_control.py'
--- scripts/masher_control.py	1970-01-01 00:00:00 +0000
+++ scripts/masher_control.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+"""A utility to control the uci-phone-masher controllers in the CI lab."""
+
+import argparse
+import json
+import sys
+import urllib
+import urllib2
+
+
+def set_button(urlbase, button, on):
+    '''Set the desired button to on for any non-false value of "on"'''
+    state = 'on' if on else 'off'
+    data = {
+        'state': state,
+    }
+    url = '{}/button/{}'.format(urlbase, button)
+    try:
+        url_resp = urllib2.urlopen(url, data=urllib.urlencode(data))
+    except urllib2.URLError as e:
+        print('ERROR: URL connection or read error on {}: {}'.format(url, e))
+        return -1
+
+    try:
+        content = url_resp.read()
+    except urllib2.URLError as e:
+        print('ERROR: URL read error on {}: {}'.format(url_resp, e))
+        return -1
+
+    try:
+        json_resp = json.loads(content)
+    except ValueError as e:
+        print('ERROR: json conversion failed on {}: {}'.format(content, e))
+        return -1
+
+    if not json_resp.get('button_states', None) == state:
+        # This is a fail safe to make sure the controller attempted to set
+        # the button to what was requested. If it fails, dump the original
+        # content.
+        print('ERROR: unexpected response: {}'.format(content))
+        return -1
+
+    return 0
+
+
+def _get_parser():
+    parser = argparse.ArgumentParser(
+        description='Toggles a button connected to a uci-phone-masher on/off')
+    parser.add_argument('-u', '--url',
+                        default='http://ci-phone-masher.ubuntu-ci',
+                        help='Phone Masher controller. default=%(default)s')
+    parser.add_argument('-b', '--button', type=int, required=True,
+                        help='The uci-phone-master button ID.')
+    parser.add_argument('action', metavar='action',
+                        choices=('on', 'off'),
+                        help='Action to perform on|off')
+    return parser
+
+
+if __name__ == '__main__':
+    args = _get_parser().parse_args()
+
+    sys.exit(set_button(args.url, args.button, args.action == 'on'))

=== added file 'scripts/ncd_usb.py'
--- scripts/ncd_usb.py	1970-01-01 00:00:00 +0000
+++ scripts/ncd_usb.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,48 @@
+#! /usr/bin/python
+
+"""A utility to control the USB relay's in the QA lab."""
+
+import argparse
+import sys
+import urllib2
+
+
+def set_relay(urlbase, bank, relay, on):
+    # the values 100/108 came from the JavaScript of our web-based management
+    # system for the relays. The meaning of the values isn't documented.
+    if on:
+        relay += 108
+    else:
+        relay += 100
+    cmd = '254,{},{}'.format(relay, bank + 1)
+    url = '{}/cgi-bin/runcommand.sh?1:cmd={}'.format(urlbase, cmd)
+    resp = urllib2.urlopen(url)
+    resp = resp.read()
+    if 'OK' not in resp:
+        print('ERROR: bad response: {}'.format(resp))
+        sys.exit(1)
+
+
+def _get_parser():
+    parser = argparse.ArgumentParser(
+        description='Toggles an NCD relay connected to a USB cable on/off')
+    parser.add_argument('-u', '--url',
+                        default='http://qa-relay-control.ubuntu-ci',
+                        help='NCD relay URL. default=%(default)s')
+    parser.add_argument('-b', '--bank', type=int, required=True,
+                        help='NCD relay 0-based bank ID.')
+    parser.add_argument('-r', '--relay', type=int, required=True,
+                        help='NCD relay 0-based relay ID.')
+    parser.add_argument('action', metavar='action',
+                        choices=('on', 'off'),
+                        help='action to perform on|off')
+    return parser
+
+
+if __name__ == '__main__':
+    args = _get_parser().parse_args()
+
+    # NOTE: when the relay is ON usb is actually OFF. ie the logic
+    # is backwards between them, thus action=off actually turns
+    # the relay on
+    set_relay(args.url, args.bank, args.relay, args.action == 'off')

=== added file 'scripts/provision.sh'
--- scripts/provision.sh	1970-01-01 00:00:00 +0000
+++ scripts/provision.sh	2015-06-03 20:37:20 +0000
@@ -0,0 +1,267 @@
+#!/bin/bash
+
+## This is the script jenkins should run to provision a device in the lab
+
+set -e
+
+BASEDIR=$(dirname $(readlink -f $0))
+export PATH=${BASEDIR}/../utils/host:${PATH}
+
+RESDIR=`pwd`/clientlogs
+RECOVERY_URL="http://people.canonical.com/~plars/touch"
+
+NETWORK_FILE="${NETWORK_FILE-${HOME}/.ubuntu-ci/wifi.conf}"
+
+IMAGE_OPT="${IMAGE_OPT---bootstrap --developer-mode --channel ubuntu-touch/devel-proposed/ubuntu}"
+UUID="${UUID-$(uuidgen -r)}"
+PHABLET_PASSWORD="${PHABLET_PASSWORD-0000}"
+
+usage() {
+cat <<EOF
+usage: $0 [-s ANDROID_SERIAL] [-n NETWORK_FILE] [-P ppa] [-p package] [-r revision] [-w]
+
+Provisions the given device with the latest build
+
+OPTIONS:
+  -h    Show this message
+  -s    Specify the serial of the device to install
+  -n    Select network file
+  -P    add the ppa to the target (can be repeated)
+  -D    add a debian package dir to the target (can be repeated)
+  -p    add the package to the target (can be repeated)
+  -r    Specify the image revision to flash
+  -w    make the system writeable (implied with -p and -P arguments)
+
+EOF
+}
+
+image_info() {
+    # mark the version we installed in /home/phablet/.ci-[uuid,flash-args]
+    # adb shell messes up \n's with \r\n's so do the whole of the regex on the target
+    IMAGEVER=$(adb shell "sudo system-image-cli -i | sed -n -e 's/version version: \([0-9]*\)/\1/p' -e 's/version ubuntu: \([0-9]*\)/\1/p' -e 's/version device: \([0-9]*\)/\1/p' | paste -s -d:")
+    CHAN=$(adb shell "sudo system-image-cli -i | sed -n -e 's/channel: \(.*\)/\1/p' | paste -s -d:")
+    REV=$(echo $IMAGEVER | cut -d: -f1)
+    echo "$IMAGE_OPT" | grep -q "\-\-revision" || REVISION="--revision=${REV}"
+    echo "$IMAGE_OPT" | grep -q "\-\-channel" || IMAGE_OPT="${IMAGE_OPT} --channel $CHAN"
+    adb shell "echo '${IMAGEVER}' > /home/phablet/.ci-version"
+    echo $UUID > $RESDIR/.ci-uuid
+    adb push $RESDIR/.ci-uuid /home/phablet/
+    cat > $RESDIR/.ci-flash-args <<EOF
+$IMAGE_OPT
+EOF
+    adb push $RESDIR/.ci-flash-args /home/phablet/.ci-flash-args
+    cat > $RESDIR/.ci-flash-server <<EOF
+$IMAGE_SERVER
+EOF
+    adb push $RESDIR/.ci-flash-args /home/phablet/.ci-flash-server
+    echo $CUSTOMIZE > $RESDIR/.ci-customizations
+    adb push $RESDIR/.ci-customizations /home/phablet/.ci-customizations
+}
+
+log() {
+    echo = $(date): $*
+}
+
+set_hwclock() {
+    log "SETTING HWCLOCK TO CURRENT TIME"
+        # Use ip for ntp.ubuntu.com in case resolving doesn't work yet
+    adb-shell sudo ntpdate 91.189.94.4 || log "WARNING: could not set ntpdate"
+    # hwclock sync has to happen after we set writable image
+    adb-shell sudo hwclock -w || log "WARNING: could not sync hwclock"
+    log "Current date on device is:"
+    adb shell date
+    log "Current hwclock on device is:"
+    adb shell sudo hwclock
+}
+
+retry() {
+    timeout=$1
+    shift
+    loops=$1
+    shift
+    cmd=$*
+    loopcnt=0
+    while true; do
+        $cmd && break || {
+            if [ $loopcnt -lt $loops ] ; then
+                loopcnt=$[$loopcnt+1]
+                echo "Retry [$loopcnt/$loops] after $timeout seconds..."
+                sleep $timeout
+            else
+                echo Failed on \'$cmd\' after $loops retries
+                exit 1
+            fi
+        }
+    done
+}
+
+reboot_bootloader() {
+    # In CI, we've seen cases where 'adb reboot bootloader' will just
+    # reboot the device and not enter the bootloader. Adding another
+    # reboot and retrying was found to be a successful workaround:
+    # https://bugs.launchpad.net/ubuntu/+source/android-tools/+bug/1359488
+    #
+    # We only want to do this if we know ANDROID_SERIAL. Attempting
+    # to guess might end up flashing the wrong device.
+
+    log "Attempting adb reboot bootloader"
+    adb reboot bootloader
+    if [ -n "${ANDROID_SERIAL}" ] ; then
+            # Entering the bootloader should take < 10 seconds, add some
+        # padding for device variance.
+        sleep 30
+        if ! fastboot devices | grep -q "${ANDROID_SERIAL}"; then
+            log "Device not in fastboot after adb reboot bootloader"
+            # After a failed 'reboot bootloader' attempt, a reboot
+            # is used to get the device back to a saner state.
+            adb reboot
+            return 1
+        fi
+    fi
+    return 0
+}
+
+download_recovery () {
+    # FIXME: ev mentioned on irc that we should add some cheksum for
+    # those images -- vila 2015-02-20
+        wget -P recovery ${RECOVERY_URL}/recovery-${DEVICE_TYPE}.img
+        if [ -f recovery/recovery-${DEVICE_TYPE}.img ]; then
+                RECOVERY="--recovery-image=recovery/recovery-${DEVICE_TYPE}.img"
+                return 0
+        fi
+        return 1
+}
+
+full_flash() {
+    log "FLASHING DEVICE"
+    DEVICE_TYPE=$(get-device-type)
+    # Use a 60 second retry loop for reboot_bootloader.
+    # If the attempt failed, it may take nearly 60 seconds to complete
+    # the reboot cycle to get the device back to a sane state.
+    retry 60 3 reboot_bootloader
+    RECOVERY=""
+    # We need to distinguish between devices with no recovery images and
+    # failures to download existing recovery images. Only krillin
+        # and arale have a recovery image for now.
+    if [ "${DEVICE_TYPE}" == 'krillin' ] || 
+       [ "${DEVICE_TYPE}" == 'arale' ]; then
+        mkdir -p recovery
+        retry 10 3 download_recovery
+    fi
+    # Use a 10 second retry loop for ubuntu-device-flash.
+    # Most failures appear to be transient and work with an immediate
+    # retry.
+    retry 10 3 timeout 1800 ubuntu-device-flash ${IMAGE_SERVER} ${REVISION} touch ${RECOVERY} --password $PHABLET_PASSWORD $IMAGE_OPT
+    # If the flashed image fails to install and reboots, wait-for-device
+    # will timeout
+    timeout 600 adb wait-for-device
+    sleep 60  #give the system a little time
+}
+
+while getopts i:s:n:P:D:p:r:wh opt; do
+    case $opt in
+    h)
+        usage
+        exit 0
+        ;;
+    n)
+        NETWORK_FILE=$OPTARG
+        ;;
+    s)
+        export ANDROID_SERIAL=$OPTARG
+        ;;
+    i)
+        IMAGE_TYPE=$OPTARG
+        ;;
+    w)
+        # making this a non-zero length string enables the logic
+        CUSTOMIZE=" "
+        ;;
+    P)
+        CUSTOMIZE="$CUSTOMIZE --ppa $OPTARG"
+        ;;
+    D)
+        CUSTOMIZE="$CUSTOMIZE --package-dir $OPTARG"
+        ;;
+    p)
+        CUSTOMIZE="$CUSTOMIZE -p $OPTARG"
+        ;;
+    r)
+                REVISION="--revision=$OPTARG"
+        ;;
+
+    esac
+done
+
+if [ -z $ANDROID_SERIAL ] ; then
+    # ensure we only have one device attached
+    lines=$(adb devices | wc -l)
+    if [ $lines -gt 3 ] ; then
+        echo "ERROR: More than one device attached, please use -s option"
+        echo
+        usage
+        exit 1
+    fi
+fi
+
+if [ ! -f $NETWORK_FILE ] && [ -z $USE_EMULATOR ] ; then
+    echo "ERROR: NETWORK_FILE, $NETWORK_FILE, not found"
+    exit 1
+fi
+
+set -x
+[ -d $RESDIR ] && rm -rf $RESDIR
+mkdir -p $RESDIR
+
+if [ -z $USE_EMULATOR ] ; then
+    full_flash
+else
+    log "CREATING EMULATOR"
+    ubuntu-emulator destroy --yes $ANDROID_SERIAL || true
+    sudo ubuntu-emulator create $ANDROID_SERIAL $IMAGE_OPT
+    ${BASEDIR}/reboot-and-wait
+fi
+
+if [ -z $USE_EMULATOR ] ; then
+    log "SETTING UP WIFI"
+    retry 60 5 adb-shell 'sudo -iu phablet env |grep UPSTART_SESSION=unix'
+    retry 60 5 phablet-network -n $NETWORK_FILE
+fi
+
+phablet-config welcome-wizard --disable
+
+if [ -n "$CUSTOMIZE" ] ; then
+    log "CUSTOMIZING IMAGE"
+    phablet-config writable-image -r ${PHABLET_PASSWORD} $CUSTOMIZE
+fi
+
+log "SETTING UP SUDO"
+adb shell "echo ${PHABLET_PASSWORD} |sudo -S bash -c 'echo phablet ALL=\(ALL\) NOPASSWD: ALL > /etc/sudoers.d/phablet && chmod 600 /etc/sudoers.d/phablet'"
+
+# FIXME: Can't do this through phablet-config for now because it needs auth
+# phablet-config edges-intro --disable
+adb shell "sudo dbus-send --system --print-reply --dest=org.freedesktop.Accounts /org/freedesktop/Accounts/User32011 org.freedesktop.DBus.Properties.Set string:com.canonical.unity.AccountsService string:demo-edges variant:boolean:false"
+
+if [ -n "${SKIP_CLICK}" ]; then
+    log "SKIPPING CLICK PACKAGE SETUP AS REQUESTED"
+else
+    log "SETTING UP CLICK PACKAGES"
+    CLICK_TEST_OPTS=""
+    channel_name=$(adb shell "sudo system-image-cli -i | sed -n -e 's/channel: \(.*\)/\1/p' | paste -s -d:")
+    # Before running phablet-click-test setup, we need to make sure the
+    # session is available
+    retry 60 5 adb-shell 'sudo -iu phablet env |grep UPSTART_SESSION=unix'
+
+    # FIXME: workaround for phablet-click-test-setup to pull the right sources
+    if [[ $channel_name == *rtm* ]] ; then
+        CLICK_TEST_OPTS="--distribution ubuntu-rtm --series 14.09"
+    fi
+    phablet-click-test-setup $CLICK_TEST_OPTS
+fi
+
+# get our target-based utilities into our PATH
+adb push ${BASEDIR}/../utils/target /home/phablet/bin
+
+image_info
+
+set_hwclock

=== added file 'scripts/reboot-and-wait'
--- scripts/reboot-and-wait	1970-01-01 00:00:00 +0000
+++ scripts/reboot-and-wait	2015-06-03 20:37:20 +0000
@@ -0,0 +1,54 @@
+#!/usr/bin/python
+
+import argparse
+import logging
+import os
+import subprocess
+import time
+
+from phabletutils.device import AndroidBridge
+
+EMULATOR = os.environ.get('USE_EMULATOR', '')
+
+
+def _get_arg_parser():
+    parser = argparse.ArgumentParser(
+        description='Reboot device and waits for networking to become active.')
+    parser.add_argument('-s', '--serial', help='Device serial')
+    parser.add_argument('-n', '--num-tries', type=int, default=3,
+                        help='''How many times to retry on failure.
+                             default=%(default)d''')
+    return parser
+
+
+def main(args):
+    device = AndroidBridge(args.serial)
+    device.wait_for_device()
+    for i in range(args.num_tries):
+        device.reboot()
+        device.wait_for_device()
+        time.sleep(5)
+        device.wait_for_device()
+        try:
+            device.wait_for_network()
+            return 0
+        except:
+            pass  # try the loop again
+    logging.error('device failed to start and activate networking')
+    return 1
+
+
+def emulator_main(args):
+    emulator = os.path.join(os.path.dirname(__file__), 'run-emulator')
+    subprocess.check_call([emulator])
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+    logging.getLogger().name = 'reboot-and-wait'
+    args = _get_arg_parser().parse_args()
+    if EMULATOR:
+        logging.info('using emulator logic for reboot')
+        exit(emulator_main(args))
+    else:
+        exit(main(args))

=== added file 'scripts/recover.py'
--- scripts/recover.py	1970-01-01 00:00:00 +0000
+++ scripts/recover.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+
+import device_info
+import logging
+import os
+import requests
+import sys
+import time
+import yaml
+
+log = logging.getLogger()
+logging.basicConfig(level=logging.INFO)
+
+
+def _full_recovery(device):
+    try:
+        device.force_bootloader()
+    except:
+        #This device does not have information about relays
+        _offline_device()
+        raise
+    try:
+        device.wait_for_fastboot()
+        device.reimage_from_fastboot()
+    except:
+        _offline_device()
+        raise
+    try:
+        device.check_adb_shell()
+    except:
+        # The device looks like it's available, but not responding
+        _offline_device()
+        raise device_info.DeviceError("Could not fully recover device")
+    return 0
+
+
+def _get_jenkins_creds(url):
+    try:
+        home = os.environ.get('HOME')
+        credpath = os.path.join(home, '.ubuntu-ci/jenkins-keys.yaml')
+        with open(credpath) as credfile:
+            creds = yaml.load(credfile.read())
+        jenkins = creds.get(url)
+        user = jenkins.get('user')
+        key = jenkins.get('key')
+    except (AttributeError, IOError):
+        user = None
+        key = None
+    return (user, key)
+
+
+def _offline_device():
+    # It's unlikely the node name will be different, but just in case
+    node = os.environ.get('NODE_NAME', None)
+    host = os.environ.get('JENKINS_URL', None)
+    (user, key) = _get_jenkins_creds(host)
+    if not (user and key and host and node):
+        log.warn("Unable to mark device offline automatically")
+        return
+    url = "{}/computer/{}/toggleOffline".format(host, node)
+    param_data = {'offlineMessage': 'unrecoverable'}
+    delay = 2
+    # Retry with exponential delay from 1 to 128 seconds
+    # This will retry for no longer than 4 min 15 sec before failing
+    for attempt in range(8):
+        time.sleep(delay ** attempt)
+        try:
+            response = requests.post(url, params=param_data, auth=(user, key))
+        except Exception as exc:
+            log.exception('Error contacting jenkins: {}'.format(exc.message))
+            continue
+        if response.status_code != 200:
+            log.warn("Error marking {} offline, retrying".format(node))
+        else:
+            log.info("{} has been marked offline".format(node))
+            return
+    log.error("Fatal error marking {} offline".format(node))
+
+
+def recover(device_name):
+    try:
+        device = device_info.get_device(device_name)
+    except KeyError:
+        log.error("No device found for '{}'".format(device_name))
+        raise
+    state = device.get_state()
+    if state in ('device'):
+        try:
+            device.check_adb_shell()
+        except:
+            # The device looks like it's available, but not responding
+            return _full_recovery(device)
+        #The device can proceed with testing
+        return 0
+    if state == 'recovery':
+        try:
+            device.reboot()
+            device.wait_for_device()
+            device.check_adb_shell()
+            return 0
+        except:
+            return _full_recovery(device)
+    if state == 'fastboot':
+        #The device is in fastboot right now, we need it booted first
+        try:
+            device.reimage_from_fastboot()
+            device.check_adb_shell()
+            return 0
+        except:
+            # The device looks like it's available, but not responding
+            return _full_recovery(device)
+    if state in ('offline', 'unknown', 'disconnected'):
+        #The device is in an unknown state, we need full recovery
+        return _full_recovery(device)
+    #In theory, we should never get here, but....
+    _offline_device()
+    raise device_info.DeviceError(
+        "Device '{}' is in an unknown state!".format(device_name))
+
+
+if __name__ == '__main__':
+    name = sys.argv[1]
+    try:
+        print(recover(name))
+    except AttributeError:
+        #This is what we'll get if it's an unknown device, raise for
+        #everything else so we get better debugging information
+        sys.exit(-1)

=== added file 'scripts/run-adt.py'
--- scripts/run-adt.py	1970-01-01 00:00:00 +0000
+++ scripts/run-adt.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,38 @@
+#!/usr/bin/python3
+
+# A simple script that runs adt-run, and retries a certain number of times
+# if it didn't succeed.
+#
+# To use: simply call this with all the adt-run arguments afterwards, including
+# the adt-run call as well:
+#
+# ./scripts/run-adt.py adt-run --unbuilt-tree foo -o results .....
+
+import subprocess
+import sys
+
+# Number of times to run adt-run before giving up.
+MAX_RUN_COUNT = 3
+
+# adt-run exit codes we should re-run the adt-run call on:
+RETRY_CODES = (16, 20)
+
+
+def main():
+    arguments = sys.argv[1:]
+    for _ in range(MAX_RUN_COUNT):
+        with open('adt-run-stdout', 'wb') as stdout_file, \
+        open('adt-run-stderr', 'wb') as stderr_file:
+            process = subprocess.Popen(
+                arguments,
+                stdout=stdout_file,
+                stderr=stderr_file,
+            )
+            returncode = process.wait()
+            if returncode not in RETRY_CODES:
+                break
+    sys.exit(returncode)
+
+
+if __name__ == '__main__':
+    main()

=== added file 'scripts/run-autopilot-tests.sh'
--- scripts/run-autopilot-tests.sh	1970-01-01 00:00:00 +0000
+++ scripts/run-autopilot-tests.sh	2015-06-03 20:37:20 +0000
@@ -0,0 +1,267 @@
+#!/bin/sh
+
+set -e
+
+BASEDIR=$(dirname $(readlink -f $0))/..
+RESDIR=`pwd`/clientlogs
+
+export PATH=${BASEDIR}/utils/host:${PATH}
+export TARGET_PREFIX=adb-shell
+
+
+usage() {
+    cat <<EOF
+usage: $0 -a APP [-s ANDROID_SERIAL] [-Q] [-o results_dir] [-S]
+
+Runs a set of autopilot tests on the target
+
+OPTIONS:
+  -h    Show this message
+  -s    Specify the serial of the device to test
+  -a    The application to test (can be repeated)
+  -o    Specify the directory to place results in.
+        Default: $RESDIR
+  -Q    "Quick" don't do a reboot of the device before/between testsuites.
+  -S    Skip the system-settle tests that run before/after each testsuite.
+
+EOF
+}
+
+log_error() {
+    echo ERROR: $* >> ${RESDIR}/runner-errors.txt
+}
+
+setup_test() {
+    app=$1
+    label=$2
+    odir=$3
+    {
+        pkgs=$(${BASEDIR}/jenkins/testconfig.py packages -a $app)
+        if [ "$label" = "setup" ] ; then
+            if [ -z "${SKIP_TESTCONFIG}" ]; then
+                adb-shell sudo apt-get install -yq --force-yes $pkgs
+            fi
+        else
+            if [ -z "${SKIP_TESTCONFIG}" ]; then
+                #Always remove dbus-x11 because it causes
+                #problems when we leave it around
+                pkgs="$pkgs dbus-x11"
+                adb-shell sudo apt-get autoremove --purge -y $pkgs || /bin/true
+            fi
+        fi
+        echo $? > ${odir}/setup_${label}.rc
+    } 2>&1 | tee ${odir}/setup_${label}.log
+}
+
+system_settle() {
+    [ -z $NOSETTLE ] || return 0
+
+    label=$1
+    odir=$2
+    rc=0
+    timeout=120s
+    if [ "$label" = "before" ] ; then
+        timeout=300s
+    fi
+
+    settle=${BASEDIR}/tests/systemsettle/systemsettle.sh
+    {
+        export UTAH_PROBE_DIR=${odir}  # needed for log file location
+        timeout $timeout $settle -c5 -d6 -p 95 -l $label || rc=1
+        echo $rc > ${odir}/settle_${label}.rc
+    } 2>&1 | tee ${odir}/settle_${label}.log
+}
+
+test_app() {
+    app=$1
+
+    odir=${RESDIR}/${app}
+    [ -d $odir ] && rm -rf $odir
+    mkdir -p $odir || return 1
+
+    system_settle before $odir
+    phablet-config autopilot --dbus-probe enable || \
+        (log_error "'autopilot dbus-probe enable' failed"; return 1)
+    adb-shell /home/phablet/bin/check-clickhook-rules || \
+        (log_error "some click profiles missing autopilot rules")
+
+    setup_test $app setup $odir
+
+    NOSHELL=""
+    [ "$app" = "unity8" ] && NOSHELL="-n"
+    EXTRA=""
+        # Use --timeout-profile=long only if we are using the emulator
+    [ -z $USE_EMULATOR ] || EXTRA="-A '--timeout-profile=long'"
+
+    phablet-test-run \
+        $NOSHELL $EXTRA \
+        -o ${odir} -f subunit \
+        -a /var/crash -a /home/phablet/.cache/upstart \
+        -a /var/log/syslog \
+        -A --timeout-profile=long \
+        -v $app || true
+    adb shell rm -rf /tmp/ci-logs
+    adb shell mkdir /tmp/ci-logs
+    adb shell sudo install -o phablet \
+        -m 666 /var/log/upstart/whoopsie.log /tmp/ci-logs
+    adb-shell "sudo system-image-cli --info > /tmp/ci-logs/system-image-cli.log"
+    adb-shell "dpkg -l > /tmp/ci-logs/dpkg-l.log"
+    adb pull /tmp/ci-logs ${odir}
+
+    system_settle after $odir
+    setup_test $app teardown $odir
+    if [ -f ${odir}/test_results.subunit ] ; then
+        cat ${odir}/test_results.subunit | subunit2junitxml > ${odir}/test_results.xml
+    fi
+    ${BASEDIR}/scripts/combine_results ${odir}
+}
+
+reboot_wait() {
+    if [ -z $QUICK ] ; then
+        if ! reboot-and-unlock.sh; then
+                    log_error "Failed to unlock screen, retrying..."
+                    reboot-and-unlock.sh || log_error "Screen unlock still fails, continuing anyway"
+                fi
+        FILES="/var/crash/* /home/phablet/.cache/upstart/*.log*"
+        if ! adb shell "sudo rm -rf $FILES" ; then
+            log_error "unable to remove crash and log files, retrying"
+            adb wait-for-device
+            adb shell "sudo rm -rf $FILES"
+        fi
+    else
+        echo "SKIPPING phone reboot..."
+    fi
+}
+
+if [ -z $USE_EMULATOR ] ; then
+grab_powerd() {
+    echo "grabbing powerd cli locks..."
+    adb shell sudo powerd-cli active &
+    PIDS="$!"
+    adb shell sudo powerd-cli display on &
+    PIDS="$PIDS $!"
+}
+
+release_powerd() {
+    if [ -n "$PIDS" ] ; then
+        echo "killing child pids: $PIDS"
+        for p in $PIDS ; do
+            kill $p || true
+        done
+        PIDS=""
+    fi
+        adb shell sudo pkill powerd-cli
+}
+
+else
+grab_powerd() {
+    #emulator does not use powerd, so this is noop
+    return 0
+}
+
+release_powerd() {
+    #emulator does not use powerd, so this is noop
+    return 0
+}
+fi
+
+dashboard_update() {
+    # only try and update the dashboard if we are configured to
+    [ -z $DASHBOARD_KEY ] && return 0
+    [ -z $DASHBOARD_BUILD ] && return 0
+    [ -z $DASHBOARD_IMAGE ] && return 0
+    ${BASEDIR}/scripts/dashboard.py $* \
+        --image $DASHBOARD_IMAGE \
+        --build $DASHBOARD_BUILD || true
+}
+
+dashboard_result_running() {
+    dashboard_update result-running --test $1
+}
+
+dashboard_result_syncing() {
+    xunit=${RESDIR}/${app}/test_results.xml
+    [ -f $xunit ] || return 0
+
+    # save a utah.yaml version of the results so the dashboard can process
+    cat $xunit | ${BASEDIR}/scripts/junit2utah.py > ${RESDIR}/${app}/utah.yaml
+    dashboard_update result-syncing --test $1 --results ${RESDIR}/${app}/utah.yaml
+}
+
+main() {
+    [ -d $RESDIR ] || mkdir -p $RESDIR
+
+    set -x
+
+    for app in $APPS ; do
+        set +x
+        echo "========================================================"
+        echo "= testing $app"
+        echo "========================================================"
+        set -x
+        dashboard_result_running $app
+        reboot_wait
+
+        grab_powerd
+
+        if ! test_app $app ; then
+            log_error "testing $app, retrying"
+            # we sometimes see sporatic adb failures that seem to
+            # related to MTP. This adds a retry for the test.
+            # test_app only fails on a device error (not a test
+            # case error)
+            adb wait-for-device
+            test_app $app
+        fi
+        dashboard_result_syncing $app
+
+        release_powerd
+    done
+}
+
+while getopts s:a:o:QSh opt; do
+    case $opt in
+    h)
+        usage
+        exit 0
+        ;;
+    s)
+        export ANDROID_SERIAL=$OPTARG
+        ;;
+    o)
+        RESDIR=$OPTARG
+        ;;
+    a)
+        APPS="$APPS $OPTARG"
+        ;;
+    Q)
+        QUICK=1
+        ;;
+    S)
+        NOSETTLE=1
+        ;;
+    esac
+done
+
+if [ -z $ANDROID_SERIAL ] ; then
+    # ensure we only have one device attached
+    lines=$(adb devices | wc -l)
+    if [ $lines -gt 3 ] ; then
+        echo "ERROR: More than one device attached, please use -s option"
+        echo
+        usage
+        exit 1
+    fi
+fi
+if [ -z "$APPS" ] ; then
+    echo "ERROR: No app specified"
+    usage
+    exit 1
+fi
+
+trap release_powerd TERM INT EXIT
+if [ -n "$USE_EMULATOR" ] ; then
+    echo "disabling system-settle testing for emulator"
+    NOSETTLE=1
+fi
+main

=== added file 'scripts/run-emulator'
--- scripts/run-emulator	1970-01-01 00:00:00 +0000
+++ scripts/run-emulator	2015-06-03 20:37:20 +0000
@@ -0,0 +1,97 @@
+#!/usr/bin/python
+
+import logging
+import os
+import subprocess
+import sys
+import time
+
+FULL_RETRIES = 3
+# unity8 takes a long time because it needs apparmor to start. apparmor is
+# slow because its parsing all the profiles on first boot. qemu seems to
+# be inconsisent, sometimes this takes 8 tries, sometimes >40.
+UNITY_RETRIES = 50
+UNITY_WAIT = 20
+ADB_RETRIES = 3
+ADB_WAIT = 120
+
+EMULATOR_ARCH = os.environ.get('EMULATOR_ARCH', 'x86')
+
+
+class RetryException(Exception):
+    pass
+
+
+def _kill():
+    logging.info('killing all emulator pids')
+    with open('/dev/null', 'w') as f:
+        subprocess.call(['killall', 'ubuntu-emulator'], stderr=f)
+        time.sleep(1)
+        subprocess.call(['killall', 'emulator-' + EMULATOR_ARCH], stderr=f)
+        time.sleep(1)
+
+
+def _launch():
+    logging.info('launching emulator...')
+    subprocess.Popen(['ubuntu-emulator', 'run', os.environ['ANDROID_SERIAL']])
+
+
+def _adb_wait(retries, timeout):
+    timeout = '%ds' % timeout
+    for i in range(retries):
+        logging.info('waiting for emulator via adb (%d of %d)...', i, retries)
+        rc = subprocess.call(['timeout', timeout, 'adb', 'wait-for-device'])
+        if rc == 0:
+            return
+        # the emulator isn't always being detected by the adb-server
+        # running kill-server works around this. NOTE: this is only
+        # safe when run on a slave hooked up to a single emulator
+        logging.info('emulator not found, restarting adbd')
+        subprocess.check_call(['adb', 'kill-server'])
+    return RetryException('emulator not found via adb')
+
+
+def _unity_wait(retries, timeout):
+    for i in range(retries):
+        logging.info('waiting for unity8 (%d of %d)...', i, retries)
+        time.sleep(timeout)
+        try:
+            out = subprocess.check_output(
+                ['adb', 'shell', 'sudo -i -u phablet status unity8'])
+            if 'start/running' in out:
+                return
+        except subprocess.CalledProcessError:
+            logging.info('adb shell failed, retrying')
+    raise RetryException('unity8 not running on device')
+
+
+def main():
+    for i in range(FULL_RETRIES):
+        try:
+            _kill()
+            _launch()
+            _adb_wait(ADB_RETRIES, ADB_WAIT)
+            logging.info('emulator is running, waiting on unity8')
+            if EMULATOR_ARCH == 'arm':
+                logging.info('sleeping for 160s to wait for ARM emulator')
+                time.sleep(160)
+            _unity_wait(UNITY_RETRIES, UNITY_WAIT)
+            logging.info('emulator is booted and ready')
+            return 0
+        except RetryException as e:
+            logging.warn('emulator failed to boot: %s', e.message)
+            logging.warn('kill and retry %d more times', FULL_RETRIES - i)
+            next
+    logging.error('emulator failed to boot')
+    _kill()
+    return 1
+
+if __name__ == '__main__':
+    handler = logging.StreamHandler(stream=sys.stderr)
+    formatter = logging.Formatter(
+        '%(asctime)s %(levelname)s: %(message)s', datefmt='%H:%M:%S')
+    handler.setFormatter(formatter)
+    l = logging.getLogger('')
+    l.addHandler(handler)
+    l.setLevel(logging.INFO)
+    exit(main())

=== added file 'scripts/run-mp.sh'
--- scripts/run-mp.sh	1970-01-01 00:00:00 +0000
+++ scripts/run-mp.sh	2015-06-03 20:37:20 +0000
@@ -0,0 +1,44 @@
+#!/bin/bash
+set -ex
+
+# These are all set via jenkins when running in that context
+if [ -z "${ANDROID_SERIAL}" ] || [ -z "${package_archive}" ] || \
+    [ -z "${test_packages}" ] || [ -z "${test_suite}" ]; then
+    echo "Missing an env variable: "
+    echo "    ANDROID_SERIAL, package_archive, test_packages or test_suite"
+    exit 1
+fi
+
+BASEDIR=$(dirname $(readlink -f $0))/..
+ARCHIVE_TMP=$(mktemp -d)
+trap 'rm -rf "${ARCHIVE_TMP}"' EXIT HUP INT TERM
+
+wget -O "${ARCHIVE_TMP}/archive.zip" ${package_archive}
+unzip "${ARCHIVE_TMP}/archive.zip" -d "${ARCHIVE_TMP}"
+package_dir="${ARCHIVE_TMP}/archive"
+
+# This is the list of packages to be installed from the archive
+# It's manually generated and supplied via the lp:cupstream2distro-config
+# configuration files when executed by jenkins.
+package_list=""
+for package in ${test_packages}; do
+    package_list="-p ${package} ${package_list}"
+done
+
+# This is a list of test suites to execute. It's normally just one.
+suite_list=""
+for suite in ${test_suite}; do
+    suite_list="-a ${suite} ${suite_list}"
+done
+
+# The provision.sh and run-smoke scripts can install extra packages to meet
+# the needs of image testing. Since we are installing specific packages from
+# a local archive, this needs to be disabled.
+export SKIP_CLICK=1
+export SKIP_TESTCONFIG=1
+
+# Provision the device and run the test suite.
+${BASEDIR}/scripts/provision.sh -s ${ANDROID_SERIAL} \
+    -n ${HOME}/.ubuntu-ci/wifi.conf \
+    -D ${package_dir} ${package_list}
+${BASEDIR}/scripts/run-smoke -s ${ANDROID_SERIAL} -n ${suite_list}

=== added file 'scripts/run-smoke'
--- scripts/run-smoke	1970-01-01 00:00:00 +0000
+++ scripts/run-smoke	2015-06-03 20:37:20 +0000
@@ -0,0 +1,408 @@
+#!/usr/bin/python
+
+import argparse
+import datetime
+import logging
+import os
+import shutil
+import subprocess
+
+import yaml
+
+from phabletutils.environment import detect_device
+
+import dashboard
+import statsd
+
+EMULATOR = os.environ.get('USE_EMULATOR')
+if EMULATOR:
+    def fake_detect(serial, device=None):
+        log.info('faking detect device for emulator')
+        return 'emulator'
+
+    # detect_device doesn't support the emulator
+    globals()['detect_device'] = fake_detect
+    if 'ANDROID_SERIAL' not in os.environ:
+        # we need something here or "serial required" logic fails
+        os.environ['ANDROID_SERIAL'] = 'emulator-5554'
+
+log = logging.getLogger()
+script_dir = os.path.dirname(__file__)
+res_dir = os.path.join(os.getcwd(), 'clientlogs')
+
+dashboard_api = dashboard.API()
+
+
+class SerialAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        log.info('android serial: %s', values[0])
+        os.environ['ANDROID_SERIAL'] = values[0]
+
+
+class DebugAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        log.setLevel(level=logging.DEBUG)
+        log.debug('debug logging enabled')
+
+
+def _serial_required():
+    required = 'ANDROID_SERIAL' not in os.environ
+    if required:
+        try:
+            out = subprocess.check_output(['adb', 'devices'])
+            required = (len(out.decode().split('\n')) != 4)
+        except subprocess.CalledProcessError as e:
+            logging.debug('error getting adb devices: %s', e)
+    return required
+
+
+def _get_parser():
+    parser = argparse.ArgumentParser(
+        description='Run the complete test-execution-service suite.')
+
+    parser.add_argument('-s', '--serial', action=SerialAction, nargs=1,
+                        required=_serial_required(),
+                        help='Android serial if more than one device present')
+    parser.add_argument('--debug', action=DebugAction, nargs=0,
+                        help='''Enable debug logging.''')
+
+    parser.add_argument('--install-url',
+                        help='''Flash with image from previous jenkins job.
+                        This option will check if the device already has image
+                        noted from this URL and will skip provisioning. The URL
+                        should be the path the job like:
+                        http://q-jenkins:8080/job/<your job>/<build number>''')
+    parser.add_argument('-p', '--package', action='append',
+                        help='Additional packages to install on target.')
+    parser.add_argument('-P', '--ppa', action='append',
+                        help='Additional PPA to configure on target.')
+    parser.add_argument('-a', '--app', action='append',
+                        help='Autopilot tests tor run.')
+    parser.add_argument('-t', '--test', action='append',
+                        help='UTAH tests tor run.')
+    parser.add_argument('-r', '--revision', help='Image revision to install.')
+    parser.add_argument('-n', '--no-provision', action='store_true',
+                        help='Skip provisioning of the target device')
+    parser.add_argument('--hooks-dir',
+                        help='''A directory containing scripts to be run after
+                        the target has been provisioned and before testing.''')
+    parser.add_argument('--image-server',
+                        help='Server to pass to phablet-flash')
+    parser.add_argument('--image-opt',
+                        help='Options to pass to phablet-flash')
+    parser.add_argument('--image-type', default='touch',
+                        help='''Image type being tested. This can be changed
+                        to 'touch_sf4p' so that SurfaceFlinger will be used
+                        instead of Mir. default=%(default)s''')
+    parser.add_argument('--num-workers', type=int, default=1,
+                        help='''The total number of workers available for
+                        running tests.''')
+    parser.add_argument('--worker-idx', type=int, default=0,
+                        help='The worker to allocate testing work to.')
+    return parser
+
+
+def _arg_from_env(args, attr, envkey, array):
+    val = os.environ.get(envkey, False)
+    if val:
+        if array:
+            setattr(args, attr, val.split())
+        else:
+            setattr(args, attr, val)
+        del os.environ[envkey]
+
+
+def _merge_env(args):
+    '''When run in Jenkins everything comes as environment variables.
+
+    Its makes a much simpler job this way. While command line args are
+    much easier for a user.
+    '''
+    _arg_from_env(args, 'app', 'APPS', True)
+    _arg_from_env(args, 'test', 'TESTS', True)
+    _arg_from_env(args, 'package', 'PACKAGES', True)
+    _arg_from_env(args, 'ppa', 'PPAS', True)
+    _arg_from_env(args, 'image_opt', 'IMAGE_OPT', False)
+    _arg_from_env(args, 'image_server', 'IMAGE_SERVER', False)
+    _arg_from_env(args, 'image_type', 'IMAGE_TYPE', False)
+    _arg_from_env(args, 'install_url', 'INSTALL_URL', False)
+    _arg_from_env(args, 'revision', 'REVISION', False)
+    _arg_from_env(args, 'num_workers', 'workers', False)
+    _arg_from_env(args, 'worker_idx', 'worker_idx', False)
+
+
+def _assert_args(args):
+    if args.install_url:
+        # this means you shouldn't specify packages, ppas, image server,
+        # or image options
+        if args.package or args.ppa or args.image_opt or args.image_server:
+            msg = 'ERROR: --install-url can\'t be used with ' \
+                  '--package, -ppa, --image_server, or --image_opt'
+            print(msg)
+            return False
+
+    # don't bother the install_url check, a user might be copy/pasting and
+    # doesn't hurt. Its just good to not encourage it.
+    _merge_env(args)
+
+    script = os.path.join(script_dir, '../jenkins/testconfig.py')
+    if args.package and args.package[0] == 'ALL':
+        logging.info('Discovering all required dependencies')
+        out = subprocess.check_output(
+            [script, 'packages', '-i', args.image_type])
+        args.package = [x for x in out.decode().split()]
+
+    if args.app and args.app[0] == 'ALL':
+        logging.info('Discovering all autopilot tests')
+        device_type = os.environ.get('DEVICE_TYPE')
+        if device_type is None:
+            device_type = detect_device(None)
+        out = subprocess.check_output(
+            [script, 'apps', '-i', args.image_type, '-d', device_type,
+             '-t', str(args.num_workers), '-w', str(args.worker_idx)])
+        args.app = [x for x in out.decode().split()]
+        logging.info('Autopilot test list: {}'.format(' '.join(args.app)))
+
+    if args.test and args.test[0].startswith('ALL'):
+        logging.info('Discovering all UTAH tests')
+        device_type = os.environ.get('DEVICE_TYPE')
+        if device_type is None:
+            device_type = detect_device(None)
+        argv = [script, 'utah', '-i', args.image_type, '-d', device_type,
+                '-t', str(args.num_workers), '-w', str(args.worker_idx)]
+        if args.test[0] == 'ALL_INCLUDING_AUTOPILOT':
+            argv.append('-a')
+        out = subprocess.check_output(argv)
+        args.test = [x for x in out.decode().split()]
+        logging.info('Utah test list: {}'.format(' '.join(args.test)))
+
+    logging.debug('ARGS: %r', args)
+
+    statsd.gauge_it('PACKAGES', args.package)
+    statsd.gauge_it('APPS', args.app)
+    statsd.gauge_it('TESTS', args.test)
+
+    return True
+
+
+def _run(args, ignore_error=False):
+    try:
+        logging.info('Running: %s', ' '.join(args))
+        subprocess.check_call(args)
+    except subprocess.CalledProcessError:
+        if ignore_error:
+            logging.error('failed to run %r, continuing', args)
+        else:
+            exit(1)
+
+
+def _image_info():
+    info = subprocess.check_output(['adb', 'shell', 'sudo',
+                                    'system-image-cli', '-i'])
+    v_ver = u_ver = d_ver = channel = None
+    for line in info.split('\n'):
+        if not line.strip():
+            continue
+        key, val = line.split(':', 1)
+        if key == 'version version':
+            v_ver = val.strip()
+        elif key == 'version ubuntu':
+            u_ver = val.strip()
+        elif key == 'version device':
+            d_ver = val.strip()
+        elif key == 'channel':
+            channel = val.strip()
+    ver = '%s:%s:%s' % (v_ver, u_ver, d_ver)
+    # required for the jenkins job's build description
+    print('= TOUCH IMAGE VERSION:' + ver)
+    return ver, channel
+
+
+def _assert_image(args):
+    log.info('checking if device has proper image ...')
+    os.environ['INSTALL_URL'] = args.install_url
+    _run([os.path.join(script_dir, 'assert-image')])
+
+
+def _write_utah(start, end, passed):
+    passes = failures = rc = 0
+    if passed:
+        passes = 1
+    else:
+        rc = failures = 1
+
+    delta = '%s' % (end - start)
+    start = start.strftime('%Y-%m-%d %H:%M:%S')
+    data = {
+        'name': 'install-and-boot',
+        'errors': 0,
+        'failures': failures,
+        'passes': passes,
+        'fetch_errors': 0,
+        'uname': 'n/a',
+        'media-info': 'n/a',
+        'install_type': 'n/a',
+        'arch': 'n/a',
+        'release': 'n/a',
+        'build_number': 'n/a',
+        'runlist': 'n/a',
+        'ran_at': start,
+        'commands': [{
+            'cmd_type': 'testcase_test',
+            'command': 'provision',
+            'returncode': rc,
+            'start_time': start,
+            'time_delta': delta,
+            'stderr': '',
+            'stdout': '',
+            'testcase': 'boot',
+            'testsuite': 'install-and-boot',
+        }]
+    }
+    path = os.path.join(res_dir, 'install-and-boot')
+    if not os.path.exists(path):
+        os.mkdir(path)
+    with open(os.path.join(path, 'utah.yaml'), 'w') as f:
+        f.write(yaml.safe_dump(data, default_flow_style=False))
+
+
+def _post_install_hooks(args):
+    if not args.hooks_dir:
+        return
+    log.info('running post install hooks ...')
+    if not os.path.isdir(args.hooks_dir):
+        log.warn('hooks directory (%s) does not exist ... skipping',
+                 args.hooks_dir)
+    for hook in sorted(os.listdir(args.hooks_dir)):
+        s = os.stat(os.path.join(args.hooks_dir, hook))
+        if s.st_mode & os.path.stat.S_IXUSR == 0:
+            log.warn('skipping hook (%s) - not executable', hook)
+            continue
+        log.info('executing hook: %s', hook)
+        hook = os.path.join(args.hooks_dir, hook)
+        subprocess.check_call([hook])
+
+
+def _provision(args):
+    log.info('provisioning device ...')
+    if args.image_opt:
+        log.debug('overriding IMAGE_OPT with: %s', args.image_opt)
+        os.environ['IMAGE_OPT'] = args.image_opt
+    if args.image_server:
+        log.debug('overriding IMAGE_SERVER with: %s', args.image_server)
+        os.environ['IMAGE_SERVER'] = args.image_server
+
+    cargs = [os.path.join(script_dir, 'provision.sh'), '-i', args.image_type]
+
+    if args.package:
+        for p in args.package:
+            cargs.extend(['-p', p])
+    if args.ppa:
+        for p in args.ppa:
+            cargs.extend(['-P', p])
+    if not args.ppa and not args.package:
+        # All tests require a writeable system the -p and -P args
+        # implicitly create a writable system. so we have to ensure here:
+        cargs.append('-w')
+    if args.revision:
+        cargs.extend(['-r', args.revision])
+
+    with statsd.time_it('provision'):
+        start = datetime.datetime.utcnow()
+        passed = False
+        try:
+            _run(cargs)
+            _post_install_hooks(args)
+            passed = True
+        finally:
+            end = datetime.datetime.utcnow()
+            _write_utah(start, end, passed)
+
+
+def _test_autopilot(args, build, image):
+    if args.app:
+        if build:
+            os.environ['DASHBOARD_BUILD'] = build
+        if image:
+            os.environ['DASHBOARD_IMAGE'] = image
+        cargs = [os.path.join(script_dir, 'run-autopilot-tests.sh')]
+        for app in args.app:
+            cargs.extend(['-a', app])
+        with statsd.time_it('APPS'):
+            _run(cargs)
+
+
+def _sync_results(build, image, test, fname):
+    with open(fname) as f:
+        d = yaml.safe_load(f)
+        dashboard_api.result_syncing(image, build, test, d)
+
+
+def _test_utah(args, build, image):
+    if args.test:
+        cargs = [os.path.join(script_dir, 'jenkins.sh')]
+        with statsd.time_it('TESTS'):
+            for test in args.test:
+                os.environ['RESDIR'] = os.path.join(res_dir, test)
+                dashboard_api.result_running(image, build, test)
+                _run(cargs + ['-a', test, '-p', '/tmp/results'],
+                     ignore_error=True)
+                fname = os.path.join(res_dir, test, 'utah.yaml')
+                _sync_results(build, image, test, fname)
+
+
+def _image_add(args):
+    build_number, channel = _image_info()
+    # get the release series (ex. trusty, utopic)
+    # this is set in the job environment variable IMAGE_SERIES
+    release = os.environ.get('IMAGE_SERIES')
+    if release:
+        return dashboard_api.image_add(build_number, release, args.image_type,
+                                       detect_device(None), 'ubuntu')
+
+
+def main(args):
+    with statsd.time_it('main'):
+        if os.path.exists(res_dir):
+            logging.info('deleting old result directory: %s', res_dir)
+            shutil.rmtree(res_dir)
+        os.mkdir(res_dir)
+
+        job_name = os.environ.get('JOB_NAME', '')
+        job_number = os.environ.get('BUILD_NUMBER', '')
+        build = dashboard_api.build_add(job_name, job_number)
+
+        if args.no_provision:
+            logging.info('Skipping the provisioning step as requested')
+        elif args.install_url:
+            _assert_image(args)
+        else:
+            _provision(args)
+
+        # TODO - this should be incororated into provision and assert_image
+        # so that the status is updated *before* flashing rather than after
+        image = _image_add(args)
+
+        if args.test:
+            for x in args.test:
+                dashboard_api.result_queue(image, build, x)
+        if args.app:
+            for x in args.app:
+                dashboard_api.result_queue(image, build, x)
+
+        _test_utah(args, build, image)
+        _test_autopilot(args, build, image)
+
+    return 0
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+    log.name = 'run-smoke'
+    dashboard.log = logging.getLogger('dashboard')
+
+    args = _get_parser().parse_args()
+    if not _assert_args(args):
+        exit(1)
+
+    exit(main(args))

=== added file 'scripts/run-touch-upgrade.sh'
--- scripts/run-touch-upgrade.sh	1970-01-01 00:00:00 +0000
+++ scripts/run-touch-upgrade.sh	2015-06-03 20:37:20 +0000
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+## This is the script jenkins should run to test upgrading a system image
+## in the lab.
+## Intersting environment variables that must be set:
+##  ANDROID_SERIAL - specify another android device
+##  RUNLIST - the path the runlist
+##  NETWORK_FILE - specify an alternative network file (passed to runlist)
+##  UPGRADE_FROM - the revision to upgrade from, eg -1 (passed to runlist)
+
+set -eux
+
+BASEDIR=$(dirname $(readlink -f $0))
+
+RESDIR=`pwd`/clientlogs
+
+UTAH_PHABLET_CMD="${UTAH_PHABLET_CMD-/usr/share/utah/examples/run_utah_phablet.py}"
+RUNLIST=${RUNLIST-"`pwd`/smoke-touch-apps/upgrade/master.run"}
+ANDROID_SERIAL="${ANDROID_SERIAL-015d1884b20c1c0f}"  #doanac's nexus7 at home
+NETWORK_FILE="${NETWORK_FILE-/home/ubuntu/magners-wifi}"
+
+rm -rf clientlogs
+mkdir clientlogs
+
+export ANDROID_SERIAL=$ANDROID_SERIAL
+
+set +e
+sudo NETWORK_FILE=$NETWORK_FILE \
+    $UTAH_PHABLET_CMD -s $ANDROID_SERIAL \
+    --from-host --skip-install --skip-utah --skip-network  -l $RUNLIST \
+    --results-dir=$RESDIR
+EXITCODE=$?
+
+UTAHFILE=$RESDIR/utah.yaml
+if ! `grep "^errors: [!0]" < $UTAHFILE >/dev/null` ; then
+  echo "errors found"
+  EXITCODE=1
+fi
+if ! `grep "^failures: [!0]" < $UTAHFILE >/dev/null` ; then
+  echo "failures found"
+  EXITCODE=2
+fi
+echo "Results Summary"
+echo "---------------"
+egrep '^(errors|failures|passes|fetch_errors):' $UTAHFILE
+exit $EXITCODE

=== added file 'scripts/statsd.py'
--- scripts/statsd.py	1970-01-01 00:00:00 +0000
+++ scripts/statsd.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,35 @@
+#!/usr/bin/python
+
+import os
+import contextlib
+import time
+
+
+_namespace = os.environ.get('STATSD_KEY')
+if _namespace:
+    from txstatsd.client import UdpStatsDClient
+    from txstatsd.metrics.timermetric import TimerMetric
+    from txstatsd.metrics.gaugemetric import GaugeMetric
+    _host = os.environ.get('SERVER', 'snakefruit.canonical.com')
+    _port = int(os.environ.get('PORT', '10041'))
+    _client = UdpStatsDClient(_host, _port)
+    _client.connect()
+
+
[e-mail]
+def time_it(key):
+    start = time.time()
+    try:
+        yield
+    finally:
+        if _namespace:
+            m = TimerMetric(_client, _namespace + '.' + key)
+            m.mark(time.time() - start)
+
+
+def gauge_it(key, array):
+    val = 0
+    if array:
+        val = len(array)
+    if _namespace:
+        GaugeMetric(_client, _namespace + '.' + key).mark(val)

=== added directory 'selftests'
=== added file 'selftests/test_junit2utah.py'
--- selftests/test_junit2utah.py	1970-01-01 00:00:00 +0000
+++ selftests/test_junit2utah.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,49 @@
+import StringIO
+import os
+import sys
+import unittest
+
+here = os.path.dirname(__file__)
+sys.path.append(os.path.join(here, '../scripts'))
+
+import junit2utah
+
+RESULT = '''
+<testsuite errors="0" failures="1" name="" tests="4" time="0.001">
+<testcase classname="classname" name="testFails" time="0.000">
+<failure type="testtools.testresult.real._StringException">
+testtools.testresult.real._StringException: Traceback (most recent call last):
+  File "junit2utah.py", line 14, in testFails
+    self.assertFalse(True)
+  File "/usr/lib/python2.7/unittest/case.py", line 418, in assertFalse
+    raise self.failureException(msg)
+AssertionError: True is not false
+</failure>
+</testcase>
+<testcase classname="classname" name="testPasses" time="0.100"/>
+<testcase classname="classname" name="testPasses2" time="0.200"/>
+<testcase classname="classname" name="testSkip" time="0.000">
+<skip>ensure skip works</skip>
+</testcase>
+</testsuite>
+'''
+
+
+class TestJunit2Utah(unittest.TestCase):
+    def testFull(self):
+        stream = StringIO.StringIO(RESULT)
+        results = junit2utah._get_results(stream)
+        self.assertEquals(3, results['passes'])
+        self.assertEquals(1, results['failures'])
+        self.assertEquals(0, results['errors'])
+
+        tcs = results['commands']
+        self.assertEqual('classname', tcs[0]['testsuite'])
+        self.assertEqual('testFails', tcs[0]['testcase'])
+        self.assertIn('AssertionError', tcs[0]['stderr'])
+
+        self.assertEqual('0.200', tcs[2]['time_delta'])
+
+        self.assertEqual('classname', tcs[3]['testsuite'])
+        self.assertEqual('testSkip', tcs[3]['testcase'])
+        self.assertEqual('ensure skip works', tcs[3]['stdout'])

=== added file 'selftests/test_reboot_and_wait.py'
--- selftests/test_reboot_and_wait.py	1970-01-01 00:00:00 +0000
+++ selftests/test_reboot_and_wait.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,66 @@
+# Ubuntu Test Cases for Touch
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import print_function
+
+import imp
+import mock
+import os
+import unittest
+
+
+class TestRebootAndWait(unittest.TestCase):
+
+    """Simple set of tests to make sure the reboot-and-wait command works."""
+
+    def setUp(self):
+        # do some trickery to load this as module
+        module = 'reboot-and-wait'
+        fname = os.path.join(os.path.dirname(__file__), '../scripts', module)
+        m = imp.load_source(module, fname)
+        self._main = m.main
+        self._get_parser = m._get_arg_parser
+
+    @mock.patch('phabletutils.device.AndroidBridge.reboot')
+    def testRebootFail(self, reboot):
+        reboot.side_effect = RuntimeError('foo')
+        args = self._get_parser().parse_args([])
+        with self.assertRaisesRegexp(RuntimeError, 'foo'):
+            self._main(args)
+
+    @mock.patch('phabletutils.device.AndroidBridge.reboot')
+    @mock.patch('phabletutils.device.AndroidBridge.wait_for_device')
+    def testWaitForDeviceFail(self, wait_for, reboot):
+        wait_for.side_effect = RuntimeError('foo')
+        args = self._get_parser().parse_args([])
+        with self.assertRaisesRegexp(RuntimeError, 'foo'):
+            self._main(args)
+        reboot.assert_called_once_with()
+
+    @mock.patch('phabletutils.device.AndroidBridge.reboot')
+    @mock.patch('phabletutils.device.AndroidBridge.wait_for_device')
+    @mock.patch('phabletutils.device.AndroidBridge.wait_for_network')
+    def testRetries(self, wait_for_net, wait_for_dev, reboot):
+        args = self._get_parser().parse_args([])
+        wait_for_net.side_effect = RuntimeError('foo')
+        self.assertEquals(1, self._main(args))
+        self.assertEquals(args.num_tries, reboot.call_count)
+
+        # now make sure it can recover after a single network failure
+        reboot.reset_mock()
+        wait_for_net.reset_mock()
+        wait_for_net.side_effect = [RuntimeError('foo'), None]
+        self.assertEquals(0, self._main(args))
+        self.assertEquals(2, reboot.call_count)

=== added file 'selftests/test_run_smoke.py'
--- selftests/test_run_smoke.py	1970-01-01 00:00:00 +0000
+++ selftests/test_run_smoke.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,148 @@
+# Ubuntu Test Cases for Touch
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import imp
+import mock
+import os
+import subprocess
+import sys
+import unittest
+
+
+class TestRunSmoke(unittest.TestCase):
+
+    """Simple set of tests to make sure the smoke-run command works."""
+
+    def setUp(self):
+        # load the module
+        module = 'run-smoke'
+        path = os.path.join(os.path.dirname(__file__), '../scripts')
+        sys.path.append(path)
+        fname = os.path.join(path, module)
+        self.run_smoke = imp.load_source(module, fname)
+        if 'ANDROID_SERIAL' in os.environ:
+            del os.environ['ANDROID_SERIAL']
+
+    @mock.patch.dict('os.environ')
+    @mock.patch('subprocess.check_output')
+    def testSerialRequired(self, check_output):
+        '''Ensure android serial is required when appropriate'''
+        check_output.return_value = '1'.encode()
+        self.assertTrue(self.run_smoke._serial_required())
+
+        check_output.return_value = '1\n2\n3\n4'.encode()
+        self.assertFalse(self.run_smoke._serial_required())
+
+        check_output.return_value = '1\n2\n3\n4\n5'.encode()
+        self.assertTrue(self.run_smoke._serial_required())
+
+        # make sure serial isn't required if specified in env
+        os.environ['ANDROID_SERIAL'] = 'foo'
+        check_output.return_value = '1\n2\n3\n4\n5'.encode()
+        self.assertFalse(self.run_smoke._serial_required())
+
+    @mock.patch.dict('os.environ')
+    @mock.patch('statsd.gauge_it')
+    def testAssertArgs(self, gauge):
+        '''Ensure install-url is used properly'''
+        patterns = [
+            (['--install-url', 'x', '-p', 'x'], False),
+            (['--install-url', 'x', '-P', 'x'], False),
+            (['--install-url', 'x', '--image-opt', 'x'], False),
+            (['-p', 'x', '-P', 'x', '--image-opt', 'x'], True),
+        ]
+        # Fake the device type
+        os.environ['DEVICE_TYPE'] = 'mako'
+        for pat, val in patterns:
+            args = self.run_smoke._get_parser().parse_args(['-s', 'foo'] + pat)
+            self.assertEqual(val, self.run_smoke._assert_args(args))
+
+        # ensure the -p ALL pulls in all packages
+        gauge.reset_mock()
+        args = self.run_smoke._get_parser().parse_args(['-p', 'ALL'])
+        self.assertTrue(self.run_smoke._assert_args(args))
+        self.assertTrue(len(args.package) > 1)
+        args = gauge.call_args_list[0][0]
+        self.assertEqual('PACKAGES', args[0])
+        self.assertLess(1, len(args[1]))
+
+        args = gauge.call_args_list[1][0]
+        self.assertEqual('APPS', args[0])
+        self.assertIsNone(args[1])
+        args = gauge.call_args_list[2][0]
+        self.assertEqual('TESTS', args[0])
+        self.assertIsNone(args[1])
+
+        # don't bother checking gauge calls for the remaining "ALL" tests
+
+        # ensure the -a ALL pulls in all APPS
+        args = self.run_smoke._get_parser().parse_args(['-a', 'ALL'])
+        self.assertTrue(self.run_smoke._assert_args(args))
+        self.assertTrue(len(args.app) > 1)
+
+        # ensure the -t ALL pulls in all TESTS
+        args = self.run_smoke._get_parser().parse_args(['-t', 'ALL'])
+        self.assertTrue(self.run_smoke._assert_args(args))
+        self.assertTrue(len(args.test) > 1)
+
+    def testAssertArgsEnv(self):
+        '''Ensure we pull in environment variables that jenkins uses.'''
+        with mock.patch.dict('os.environ'):
+            os.environ['APPS'] = 'apps'
+            os.environ['TESTS'] = 'tests'
+            os.environ['PACKAGES'] = 'packages'
+            os.environ['PPAS'] = 'ppas'
+            os.environ['IMAGE_TYPE'] = 'type'
+            os.environ['INSTALL_URL'] = 'url'
+            os.environ['IMAGE_OPT'] = 'opts opts'
+            os.environ['ANDROID_SERIAL'] = 'foo'
+
+            args = self.run_smoke._get_parser().parse_args([])
+            self.assertTrue(self.run_smoke._assert_args(args))
+
+            self.assertEqual(args.app, ['apps'])
+            self.assertEqual(args.test, ['tests'])
+            self.assertEqual(args.package, ['packages'])
+            self.assertEqual(args.ppa, ['ppas'])
+            self.assertEqual(args.image_type, 'type')
+            self.assertEqual(args.install_url, 'url')
+            self.assertEqual(args.image_opt, 'opts opts')
+
+    @mock.patch('__builtin__.open')
+    @mock.patch('os.mkdir')
+    def testProvision(self, a, b):
+        orig = os.environ.get('IMAGE_OPT', '')
+        with mock.patch.object(self.run_smoke, '_run') as run:
+            args = self.run_smoke._get_parser().parse_args(
+                ['-s', 'foo', '--image-opt', 'FOOBAR', '-p', '1', '-p', '2'])
+            self.run_smoke._provision(args)
+            self.assertTrue(run.called)
+            val = os.environ.get('IMAGE_OPT')
+            os.environ['IMAGE_OPT'] = orig
+            self.assertEqual('FOOBAR', val)
+
+    def testUtahTests(self):
+        args = self.run_smoke._get_parser().parse_args(
+            ['-s', 'foo', '-t', 'a', '-t', 'b'])
+        with mock.patch.object(self.run_smoke, '_run') as run:
+            with mock.patch.dict('os.environ'):
+                run.side_effects = [subprocess.CalledProcessError, None]
+                with mock.patch.object(self.run_smoke, '_sync_results') as sr:
+                    self.run_smoke._test_utah(args, None, None)
+                    p = os.path.join(self.run_smoke.res_dir, 'b')
+                    # ensuring b ran means, that we handled the failure of test
+                    # 'a' and that the environment is setup correctly
+                    self.assertEqual(os.environ['RESDIR'], p)
+                    self.assertTrue(sr.called)

=== added file 'selftests/test_statsd.py'
--- selftests/test_statsd.py	1970-01-01 00:00:00 +0000
+++ selftests/test_statsd.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,64 @@
+# Ubuntu Test Cases for Touch
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import mock
+import unittest
+import sys
+import time
+
+path = os.path.join(os.path.dirname(__file__), '../scripts')
+sys.path.append(path)
+
+import statsd
+
+
+class TestStatsd(unittest.TestCase):
+
+    def setUp(self):
+        self.origkey = os.environ.get('STATSD_KEY')
+        os.environ['STATSD_KEY'] = 'prefix'
+        reload(statsd)
+
+    def tearDown(self):
+        if not self.origkey:
+            del os.environ['STATSD_KEY']
+        else:
+            os.environ['STATSD_KEY'] = self.origkey
+        reload(statsd)
+
+    """Simple set of tests to make sure the statsd calls work."""
+
+    @mock.patch('txstatsd.metrics.metric.Metric.write')
+    def testGaugeIt(self, _statsd):
+        statsd.gauge_it('foo', None)
+        _statsd.assert_called_with('prefix.foo:0|g')
+        _statsd.reset_mock()
+
+        statsd.gauge_it('foo', [])
+        _statsd.assert_called_with('prefix.foo:0|g')
+        _statsd.reset_mock()
+
+        statsd.gauge_it('foo', [1, 2, 3])
+        _statsd.assert_called_with('prefix.foo:3|g')
+        _statsd.reset_mock()
+
+    @mock.patch('txstatsd.metrics.metric.Metric.write')
+    def testTimeIt(self, _statsd):
+        with statsd.time_it('foo'):
+            time.sleep(0.1)
+        # should have a timing of about 100ms
+        self.assertRegexpMatches(
+            _statsd.call_args[0][0], 'prefix.foo:100.[\d+]|ms')

=== added directory 'tests'
=== added directory 'tests/bootfail'
=== added file 'tests/bootfail/README'
--- tests/bootfail/README	1970-01-01 00:00:00 +0000
+++ tests/bootfail/README	2015-06-03 20:37:20 +0000
@@ -0,0 +1,15 @@
+!!CAUTION!!
+Do not execute this test on a device without manual control.
+The test will render the device unbootable and disable adb.
+Manual control is required to return the device to fastboot.
+
+To run the tests:
+
+$ export ANDROID_SERIAL=[adb device id]
+$ phablet-config writable-image
+
+$ adt-run --no-built-binaries --unbuilt-tree bootfail -o log-dir --- \
+      ssh -s /usr/share/autopkgtest/ssh-setup/adb -- -s $ANDROID_SERIAL
+
+Exit code is '0' if it passed.
+Logs are stored under log-dir as specified with the '-o' option.

=== added directory 'tests/bootfail/debian'
=== added file 'tests/bootfail/debian/changelog'
--- tests/bootfail/debian/changelog	1970-01-01 00:00:00 +0000
+++ tests/bootfail/debian/changelog	2015-06-03 20:37:20 +0000
@@ -0,0 +1,5 @@
+bootfail (0.1) vivid; urgency=medium
+
+  * Initial release.
+
+ -- Francis Ginther <[e-mail]>  Mon, 26 Jan 2015 21:34:20 -0600

=== added file 'tests/bootfail/debian/compat'
--- tests/bootfail/debian/compat	1970-01-01 00:00:00 +0000
+++ tests/bootfail/debian/compat	2015-06-03 20:37:20 +0000
@@ -0,0 +1,1 @@
+9

=== added file 'tests/bootfail/debian/control'
--- tests/bootfail/debian/control	1970-01-01 00:00:00 +0000
+++ tests/bootfail/debian/control	2015-06-03 20:37:20 +0000
@@ -0,0 +1,10 @@
+Source: bootfail
+Section: misc
+Maintainer: Canonical CI Engineering <[e-mail]>
+Build-Depends: debhelper (>= 9),
+Standards-Version: 3.9.4
+
+Package: bootfail
+Architecture: all
+Description: A boottest dep8 test package designed to fail
+ A boottest dep8 test package designed to fail.

=== added file 'tests/bootfail/debian/rules'
--- tests/bootfail/debian/rules	1970-01-01 00:00:00 +0000
+++ tests/bootfail/debian/rules	2015-06-03 20:37:20 +0000
@@ -0,0 +1,4 @@
+#!/usr/bin/make -f
+
+%:
+	dh $@

=== added directory 'tests/bootfail/debian/tests'
=== added file 'tests/bootfail/debian/tests/bootfail'
--- tests/bootfail/debian/tests/bootfail	1970-01-01 00:00:00 +0000
+++ tests/bootfail/debian/tests/bootfail	2015-06-03 20:37:20 +0000
@@ -0,0 +1,15 @@
+#!/bin/bash
+
+rc=0
+
+if [ "${ADT_REBOOT_MARK}" == "reboot_mark" ]; then
+    ls > "${ADT_ARTIFACTS}"/ls.txt
+    rc=$?
+else 
+    # CAUITON! The following will render a phone device unbootable
+    # It also requires manual control to reset the device into fastboot
+    sudo apt-get remove -y --force-yes lxc
+    /tmp/autopkgtest-reboot reboot_mark
+    echo "Are we having fun yet?"
+fi
+exit $rc

=== added file 'tests/bootfail/debian/tests/control'
--- tests/bootfail/debian/tests/control	1970-01-01 00:00:00 +0000
+++ tests/bootfail/debian/tests/control	2015-06-03 20:37:20 +0000
@@ -0,0 +1,3 @@
+Tests: bootfail
+Depends:
+Restrictions: needs-root

=== added directory 'tests/bootspeed'
=== added directory 'tests/bootspeed/bootchart'
=== added file 'tests/bootspeed/bootchart/run.py'
--- tests/bootspeed/bootchart/run.py	1970-01-01 00:00:00 +0000
+++ tests/bootspeed/bootchart/run.py	2015-06-03 20:37:20 +0000
@@ -0,0 +1,73 @@
+#!/usr/bin/python
+
+import datetime
+import json
+import os
+import shutil
+import subprocess
+
+
+def _get_dashboard_data(timing_file):
+    info = subprocess.check_output(['adb', 'shell', 'system-image-cli', '-i'])
+    data = {
+        'image_md5': 'n/a',
+        'machine_mac': 'ff:ff:ff:ff:ff:ff',
+        'ran_at': datetime.datetime.now().isoformat(),
+        'kernel_init': 0.0,
+    }
+    for line in info.split('\r\n'):
+        if not line:
+            continue
+        key, val = line.split(':', 1)
+        val = val.strip()
+        if key == 'device name':
+            data['image_arch'] = val
+        elif key == 'channel':
+            # get 'touch' and 'trusty' from something like:
+            # ubuntu-touch/trusty-proposed
+            variant, release = val.split('/')
+            data['image_variant'] = variant.split('-')[1]
+            data['image_release'] = release.split('-')[0]
+        elif key == 'version version':
+            data['number'] = val
+        elif key == 'version ubuntu':
+            data['version_ubuntu'] = val
+        elif key == 'version device':
+            data['version_device'] = val
+    data['build_number'] = '%s:%s:%s' % (
+        data['number'], data['version_ubuntu'], data['version_device'])
+
+    with open(timing_file) as f:
+        # the timings file is sequence of readings (in hundredths of a second):
+        #  line 0 - the total boot time
+        #  line X - the time from boot until the given annotation *started*
+        timings = [float(x) / 100.0 for x in f.read().split('\n') if x]
+        data['boot'] = timings[0]
+        data['kernel'] = timings[1]
+        data['plumbing'] = timings[2] - timings[1]
+        data['xorg'] = timings[3] - timings[2]
+        data['desktop'] = timings[0] - timings[3]
+    return data
+
+
+def chart(results_dir):
+    timings = os.path.join(results_dir, 'timings')
+    os.environ['CHARTOPTS'] = ' '.join([
+        '--crop-after=unity8',
+        '--annotate=mountall',
+        '--annotate=lightdm',
+        '--annotate=unity8',
+        '--annotate-file=%s' % timings,
+    ])
+    subprocess.check_call(['phablet-bootchart', '-n', '-k',
+                           '-w', '/home/ubuntu/magners-wifi',
+                           '-o', results_dir])
+    data = _get_dashboard_data(timings)
+    with open(os.path.join(results_dir, 'boot.json'), 'w') as f:
+        json.dump(data, f, indent=4)
+
+if __name__ == '__main__':
+    # run_utah_phablet will pass us a "UTAH_PROBE_DIR":
+    resdir = os.environ.get('UTAH_PROBE_DIR', '/tmp/results')
+    for x in range(3):
+        chart(os.path.join(resdir, str(x)))

=== added file 'tests/bootspeed/bootchart/setup.sh'
--- tests/bootspeed/bootchart/setup.sh	1970-01-01 00:00:00 +0000
+++ tests/bootspeed/bootchart/setup.sh	2015-06-03 20:37:20 +0000
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+${TARGET_PREFIX} apt-get install bootchart