Merge lp:~nuclearbob/ubuntu-test-cases/touch-trace-export into lp:~coreygoldberg/ubuntu-test-cases/touch-trace-export

[Max Brustkern]

Here are bits to make a utah testsuite to gather the traces. I'm still looking at the actual job creation.

[lp:~nuclearbob/ubuntu-test-cases/touch-trace-export]

183. By Max Brustkern on 2014-02-05

Added section to upload benchmark data

184. By Max Brustkern on 2014-02-07

Made MongoDB optional

185. By Max Brustkern on 2014-02-07

Merged Corey's changes, keeping DB optional

186. By Max Brustkern on 2014-02-07

Made port into an int

187. By Max Brustkern on 2014-02-07

Putting client back in

188. By Max Brustkern on 2014-07-15

Merged latest changes

189. By Max Brustkern on 2014-07-16

Resolved conflicts

190. By Max Brustkern on 2014-07-17

Updated to UbuntuAppLaunch

191. By Max Brustkern on 2014-07-17

Fixed permissions

192. By Max Brustkern on 2014-07-17

Opening with write permissions

193. By Max Brustkern on 2014-07-18

Stringify datetime

194. By Max Brustkern on 2014-07-21

Updated trace point names

195. By Max Brustkern on 2014-07-21

Removed prefixes to support old and new ual

196. By Max Brustkern on 2014-07-21

Cleaned up diff

197. By Max Brustkern on 2014-07-22

Added repeat option to app startup benchmark script

198. By Max Brustkern on 2014-07-22

Exporting REPEAT

199. By Max Brustkern on 2014-07-22

Set default repeat

200. By Max Brustkern on 2014-07-22

Using 10 runs

201. By Max Brustkern on 2014-07-23

Add options to getopts

202. By Max Brustkern on 2014-07-23

Updated template to use production and single venv activation

203. By Max Brustkern on 2014-07-23

Added app-startup-benchmark to test config

204. By Max Brustkern on 2014-07-29

Updated ppa instructions

205. By Max Brustkern on 2014-07-29

Passing in app_id

206. By Max Brustkern on 2014-07-30

Added type to job variables

207. By Max Brustkern on 2014-07-30

Fixed a couple flake8 issues

208. By Max Brustkern on 2014-08-06

Added nfss insertion script

209. By Max Brustkern on 2014-08-07

Merged changes

210. By Ted Gould on 2014-08-11

Make it so that we can have an Upstart config file for our env vars

211. By Ted Gould on 2014-08-11

Dropping setting env per test

212. By Ted Gould on 2014-08-11

Make sure to install UTAH too

213. By Ted Gould on 2014-08-11

Ensure the LTTng tools are installed

214. By Ted Gould on 2014-08-11

Switch to using UAL completely

215. By Ted Gould on 2014-08-11

Since the tests reboot anyway, settling is pretty useless

216. By Ted Gould on 2014-08-11

Use the reboot-and-unlock from autopilot to ensure we're in a good Unity

217. By Ted Gould on 2014-08-11

Fix command name

218. By Ted Gould on 2014-08-11

Ensure we're engaged

219. By Ted Gould on 2014-08-11

Don't think we need the update

220. By Ted Gould on 2014-08-11

Quiet

221. By Ted Gould on 2014-08-11

Give two secs for the display to come up, to ensure we're stable

222. By Ted Gould on 2014-08-12

Different tracepoitns

223. By Ted Gould on 2014-08-12

Cleanup the PIDs to turn on the screen

224. By Ted Gould on 2014-08-12

Give the dash more time to settle

225. By Ted Gould on 2014-08-12

Stop the dash so it can't screw things up

226. By Ted Gould on 2014-08-15

Make sure to trap on error

227. By Ted Gould on 2014-10-20

Change the tracking of tracepoints

228. By Ted Gould on 2014-10-20

Merge trunk

229. By Max Brustkern on 2014-10-20

Skipping actual launch

230. By Max Brustkern on 2014-10-20

Merged latest changes

231. By Max Brustkern on 2014-10-20

Adding local krillin

232. By Max Brustkern on 2014-10-20

Launch back in

233. By Max Brustkern on 2014-10-20

Cleaning up leftovers from iteration

234. By Max Brustkern on 2014-10-20

Updating nfss variable reading

235. By Max Brustkern on 2014-10-21

Job configuration updates

236. By Max Brustkern on 2014-10-21

Restored old name

237. By Max Brustkern on 2014-10-21

Re-applying Ted's updates

238. By Max Brustkern on 2014-10-21

Using sudo for apt-get

239. By Max Brustkern on 2014-10-21

Being -ex(plicit) about setup

240. By Max Brustkern on 2014-10-21

Updated nfss insert path

241. By Max Brustkern on 2014-10-21

Reverted some bootspeed changes that should go in a different branch

242. By Max Brustkern on 2014-10-21

Multiple runs of all click packages

243. By Max Brustkern on 2014-10-21

Removed testing configuration

244. By Max Brustkern on 2014-10-21

Updated installation instructions to use phase 0 PPA

245. By Max Brustkern on 2014-10-21

Adding application whitelist and blacklist and blacklisting file manager

246. By Max Brustkern on 2014-10-21

Removed file manager from blacklist

247. By Max Brustkern on 2014-10-21

Raised timeout

248. By Max Brustkern on 2014-10-21

Fixed blacklist

249. By Max Brustkern on 2014-10-22

Added blacklist apps

250. By Max Brustkern on 2014-10-22

Merged upstream changes

251. By Max Brustkern on 2014-10-23

Fixed environment variables

252. By Max Brustkern on 2014-10-23

Removed uneeded environment variables

253. By Max Brustkern on 2014-10-23

Integrated more tracepoints

254. By Max Brustkern on 2014-10-24

Giving a little extra time before timeout

255. By Max Brustkern on 2014-11-14

Merged changes

Unmerged revisions

255. By Max Brustkern on 2014-11-14

Merged changes

254. By Max Brustkern on 2014-10-24

Giving a little extra time before timeout

253. By Max Brustkern on 2014-10-23

Integrated more tracepoints

252. By Max Brustkern on 2014-10-23

Removed uneeded environment variables

251. By Max Brustkern on 2014-10-23

Fixed environment variables

250. By Max Brustkern on 2014-10-22

Merged upstream changes

249. By Max Brustkern on 2014-10-22

Added blacklist apps

248. By Max Brustkern on 2014-10-21

Fixed blacklist

247. By Max Brustkern on 2014-10-21

Raised timeout

246. By Max Brustkern on 2014-10-21

Removed file manager from blacklist

=== renamed file 'README-cli.rst' => 'README-cli.rst'
--- README-cli.rst	2013-10-17 22:58:29 +0000
+++ README-cli.rst	2014-11-14 15:22:01 +0000
@@ -3,7 +3,7 @@
 
 The touch testing execution framework was written so that its very easy to
 run tests from home in the exact same way test are run in the lab. The only
-thigs you need are:
+things you need are:
 
  * This bzr branch
  * The phablet-tools_ package
@@ -13,7 +13,7 @@
 .. _supported: http://wiki.ubuntu.com/Touch/Devices
 
 There are two pieces to touch testing, provisioning and test execution. These
-functions are independent of one another. eg, If your device already
+functions are independent of one another. i.e., if your device already
 has the proper image/configuration, you can simply use the test-runner.
 
 Provisioning
@@ -27,6 +27,10 @@
 
 will list supported options.
 
+NOTE: provision.sh requires a path to a network-manager wifi connection that
+can be copied to the target device. By default this is set to
+${HOME}/.ubuntu-ci/wifi.conf. This can be overridden with the -n parameter.
+
 Executing Tests
 ---------------
 
@@ -60,7 +64,7 @@
 
   sudo add-apt-repository ppa:utah/stable
   sudo apt-get update
-  sudo apt-get install utah-client
+  sudo apt-get install utah utah-client
 
 With that package installed UTAH tests can be run with::
 
@@ -74,3 +78,21 @@
 
   ./scripts/jenkins.sh -a sdk
 
+Provisioning and Executing tests for an MP
+------------------------------------------
+
+These scripts are used by jenkins for the testing of MPs that generate Debian
+packages. 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

=== renamed directory 'jenkins' => 'jenkins'
=== added file 'jenkins/custom-demo.py'
--- jenkins/custom-demo.py	1970-01-01 00:00:00 +0000
+++ jenkins/custom-demo.py	2014-11-14 15:22:01 +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-krillin.py'
--- jenkins/production-krillin.py	1970-01-01 00:00:00 +0000
+++ jenkins/production-krillin.py	2014-11-14 15:22:01 +0000
@@ -0,0 +1,48 @@
+# The configuration matrix of our staging device testing
+
+JENKINS = 'http://dev-jenkins.ubuntu-ci:8080/'
+
+UTOPIC_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/ubuntu-rtm/14.09-proposed/krillin/index.json',
+                'num-workers': 4,
+            }
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+            '--channel=ubuntu-touch/ubuntu-rtm/14.09-proposed"'
+    },
+]
+
+VIVID_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/index.json',
+                'num-workers': 4,
+            }
+        ],
+    },
+]
+
+MATRIX = {
+    'utopic': UTOPIC_MATRIX,
+    'vivid': VIVID_MATRIX,
+}

=== modified file 'jenkins/production.py'
--- jenkins/production.py	2013-12-13 18:47:35 +0000
+++ jenkins/production.py	2014-11-14 15:22:01 +0000
@@ -1,77 +1,96 @@
 # The configuration matrix of our production device testing
 
-JENKINS = 'http://q-jenkins:8080'
+JENKINS = 'http://q-jenkins.ubuntu-ci:8080'
 
 
 def _url(channel, device):
-    return 'http://system-image.ubuntu.com/%s/%s/index.json' \
+    return 'http://system-image.ubuntu.com/ubuntu-touch/%s/%s/index.json' \
            % (channel, device)
 
 
-TRUSTY_MATRIX = [
-    {
-        'image-type': 'touch_sf4p',
-        'node-label': 'touch-daily',
-        'devices': [
-            {
-                'name': 'mako-05',
-                'trigger_url': _url('trusty-proposed', 'mako'),
-            },
-            {
-                'name': 'maguro-02',
-                'trigger_url': _url('trusty-proposed', 'maguro'),
-            },
-        ],
-    },
+VIVID_MATRIX = [
     {
         'image-type': 'touch',
-        'node-label': 'touch-daily',
-        'devices': [
-            {
-                'name': 'mako-02',
-                'trigger_url': _url('trusty-proposed', 'mako'),
-            },
-            {
-                'name': 'maguro-01',
-                'trigger_url': _url('trusty-proposed', 'maguro'),
-            },
-        ],
+        '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', 'mako'),
+                'num-workers': 3,
+            },
+            {
+                'name': 'flo',
+                'slave-label': 'daily-flo',
+                'trigger_url': _url('devel-proposed', 'flo'),
+                'num-workers': 2,
+            },
+            {
+                'name': 'manta',
+                'slave-label': 'daily-manta',
+                'trigger_url': _url('devel-proposed', 'manta'),
+                'num-workers': 2,
+            },
+        ],
+    },
+]
+
+UTOPIC_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('ubuntu-rtm/14.09-proposed', 'mako'),
+                'num-workers': 3,
+            },
+            {
+                'name': 'flo',
+                'slave-label': 'daily-flo',
+                'trigger_url': _url('ubuntu-rtm/14.09-proposed', 'flo'),
+                'num-workers': 2,
+            },
+            {
+                'name': 'manta',
+                'slave-label': 'daily-manta',
+                'trigger_url': _url('ubuntu-rtm/14.09-proposed', 'manta'),
+                'num-workers': 2,
+            },
+        ],
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+                     '--channel ubuntu-touch/ubuntu-rtm/14.09-proposed"'
     },
     {
         'image-type': 'touch_custom',
-        'node-label': 'touch-daily',
+        '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-10',
-                'trigger_url': _url('trusty-proposed-customized', 'mako'),
+                'name': 'mako',
+                'slave-label': 'daily-mako',
+                'trigger_url': _url('utopic-proposed-customized', 'mako'),
             },
         ],
-        'IMAGE_OPT': 'export IMAGE_OPT="ubuntu-system -b '
-                     '--channel trusty-proposed-customized"'
+        'IMAGE_OPT': 'export IMAGE_OPT="--bootstrap --developer-mode '
+                     '--channel ubuntu-touch/utopic-proposed-customized"'
     },
 ]
 
-SAUCY_MATRIX = [
-    {
-        'image-type': 'touch_mir',
-        'node-label': 'touch-daily',
-        'devices': [
-            {
-                # mako-11 should be the least utilized trusty device
-                'name': 'mako-11',
-                'trigger_url': _url('saucy-proposed', 'mako'),
-            },
-            {
-                'name': 'maguro-03',
-                'trigger_url': _url('saucy-proposed', 'maguro'),
-            },
-        ],
-        'IMAGE_OPT': 'export IMAGE_OPT="ubuntu-system -b '
-                     '--channel saucy-proposed"'
-    },
-]
 
 MATRIX = {
-    'trusty': TRUSTY_MATRIX,
-    'saucy': SAUCY_MATRIX,
+    'utopic': UTOPIC_MATRIX,
+    'vivid': VIVID_MATRIX,
 }

=== modified file 'jenkins/setup_jenkins.py'
--- jenkins/setup_jenkins.py	2013-12-18 17:08:42 +0000
+++ jenkins/setup_jenkins.py	2014-11-14 15:22:01 +0000
@@ -22,13 +22,11 @@
 import logging
 import os
 
+import testconfig
+
 from distro_info import UbuntuDistroInfo
 DEV_SERIES = UbuntuDistroInfo().devel()
 
-import testconfig
-
-DEFINE_MEGA = os.environ.get('MEGA', False)
-
 
 def _get_parser():
     """Create and return command line parser.
@@ -45,6 +43,10 @@
                         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,
@@ -97,89 +99,97 @@
         instance.create_job(jobname, cfg)
 
 
-if DEFINE_MEGA:
-    def _get_job_name(args, device_type, image_type):
-        prefix = ""
-        if(args.prefix):
-            prefix = args.prefix + "-"
-
-        return '{}{}-{}-{}-smoke'.format(
-            prefix, args.series, image_type, device_type)
-
-    def _configure_jobs(instance, env, args, config_item, device, tests):
-        name = device['name']
-        defserial = '$(${BZRDIR}/scripts/get-adb-id ${NODE_NAME})'
-
-        params = {
-            'name': name,
-            'serial': device.get('serial', defserial),
-            'publish': args.publish,
-            'branch': args.branch,
-            'trigger_url': device['trigger_url'],
-            'imagetype': config_item['image-type'],
-            'image_opt': config_item.get('IMAGE_OPT', ''),
-            'statsd_key': config_item.get('statsd-key', ''),
-        }
-
-        job = _get_job_name(args, name, config_item['image-type'])
-        _publish(instance, env, args, 'touch-smoke.xml.jinja2', job, **params)
-else:
-    def _get_job_name(args, device, test, image_type):
-        prefix = ""
-        if(args.prefix):
-            prefix = args.prefix + "-"
-        return test.fmt.format(prefix=prefix,
-                               series=args.series,
-                               testname=test.name,
-                               imagetype=image_type,
-                               type=device[:device.index("-")])
-
-    def _configure_job(instance, env, args, config_item, device, test):
-        tmpl_name = 'touch-{}.xml.jinja2'.format(test.name)
-        if type(test) == testconfig.APTest:
-            tmpl_name = 'touch-autopilot-base.xml.jinja2'
-        defserial = '$(${BZRDIR}/scripts/get-adb-id %s)' % device['name']
-        params = {
-            'host': config_item['node-label'],
-            'name': device['name'],
-            'serial': device.get('serial', defserial),
-            'publish': args.publish,
-            'branch': args.branch,
-            'wait': args.wait,
-            'imagetype': config_item['image-type'],
-            'image_opt': config_item.get('IMAGE_OPT', ''),
-            'testname': test.name,
-        }
-        job = _get_job_name(args, params['name'], test, params['imagetype'])
-        _publish(instance, env, args, tmpl_name, job, **params)
-        return job
-
-    def _configure_master(instance, env, args, projects, config_item, device):
-        params = {
-            'host': config_item['node-label'],
-            'name': device['name'],
-            'publish': args.publish,
-            'branch': args.branch,
-            'projects': projects,
-            'trigger_url': device['trigger_url'],
-        }
-        image_type = config_item['image-type']
-        test = testconfig.Test('master')
-        job = _get_job_name(args, device['name'], test, image_type)
-        _publish(instance, env, args, 'touch-master.xml.jinja2', job, **params)
-
-        job = 'smoke-master-free'
-        _publish(instance, env, args,
-                 'touch-master-free.xml.jinja2', job, **params)
-
-    def _configure_jobs(instance, env, args, config_item, device, tests):
-        projects = []
-        for test in tests:
-            logging.debug("configuring %s job for %s",
-                          device['name'], test.name)
-            p = _configure_job(instance, env, args, config_item, device, test)
-            projects.append(p)
-        _configure_master(instance, env, args, projects, config_item, device)
+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', ''),
+        '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', ''),
+        '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):
@@ -205,9 +215,12 @@
 
     for item in config.MATRIX[args.series]:
         for device in item['devices']:
-            tests = testconfig.TESTSUITES
-            tests = testconfig.filter_tests(tests, item['image-type'])
-            _configure_jobs(jenkins_inst, env, args, item, device, tests)
+            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()

=== modified file 'jenkins/staging.py'
--- jenkins/staging.py	2013-11-14 17:42:01 +0000
+++ jenkins/staging.py	2014-11-14 15:22:01 +0000
@@ -1,26 +1,42 @@
 # The configuration matrix of our staging device testing
 
-import os
-
-if not os.environ.get('MEGA', False):
-    raise RuntimeError('staging server only supports MEGA jobs')
-
-JENKINS = 'http://jenkins-dev-image-test:8080/'
-
-TRUSTY_MATRIX = [
+JENKINS = 'http://dev-jenkins.ubuntu-ci:8080/'
+
+UTOPIC_MATRIX = [
     {
         'image-type': 'touch',
-        'node-label': 'touch-dev',
-        'statsd-key': 'ubuntu-ci.test-execution-service.staging',
-        'devices': [
-            {
-                'name': 'mako',
-                'trigger_url': 'http://system-image.ubuntu.com/trusty-proposed/mako/index.json'
-            }
-        ],
+        '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 = {
-    'trusty': TRUSTY_MATRIX,
+    'utopic': UTOPIC_MATRIX,
 }

=== removed file 'jenkins/templates/touch-autopilot-base.xml.jinja2'
--- jenkins/templates/touch-autopilot-base.xml.jinja2	2013-11-04 23:46:23 +0000
+++ jenkins/templates/touch-autopilot-base.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,31 +0,0 @@
-{% extends "touch-base.xml.jinja2" %}
-<?xml version='1.0' encoding='UTF-8'?>
-{% block triggers %}
-  <triggers class="vector"/>
-{% endblock %}
-{% block timeout %}
-  <timeoutMinutes>30</timeoutMinutes>
-{% endblock timeout %}
-
-{% block shellcmds %}
-      <command>set -e
-rm -rf *
-{% include "touch-setup.xml.jinja2" %}
-
-{% block apptest %}{% endblock %}
-
-${BZRDIR}/scripts/jenkins.sh -s $ANDROID_SERIAL -a {{testname}} $EXTRA_PULLS
-      </command>
-{% endblock %}
-
-{% block junitresults %}
-    <hudson.tasks.junit.JUnitResultArchiver>
-      <testResults>clientlogs/*.xml</testResults>
-      <keepLongStdio>true</keepLongStdio>
-      <testDataPublishers/>
-    </hudson.tasks.junit.JUnitResultArchiver>
-{% endblock %}
-
-{% block artifacts %}
-      <artifacts>clientlogs/*, **/jenkins.sh</artifacts>
-{% endblock %}

=== modified file 'jenkins/templates/touch-base.xml.jinja2'
--- jenkins/templates/touch-base.xml.jinja2	2013-11-21 01:38:41 +0000
+++ jenkins/templates/touch-base.xml.jinja2	2014-11-14 15:22:01 +0000
@@ -9,66 +9,132 @@
   </description>
   <keepDependencies>false</keepDependencies>
   <properties>
-    <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/>
+    <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>{{ host }}</assignedNode>
+  <assignedNode>{{ name }}</assignedNode>
   <canRoam>false</canRoam>
   <disabled>false</disabled>
   <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
   <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
-{% block triggers %}{% endblock %}
-  <concurrentBuild>false</concurrentBuild>
+  <concurrentBuild>true</concurrentBuild>
   <builders>
-{% block shellblock %}
     <hudson.tasks.Shell>
-{% block shellcmds %}{% endblock %}
+      <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}}
+${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 %}
+{% if test == 'app-startup-benchmark' %}
+NFSS_CONFIG_FILE=${WORKSPACE}/nfss_config
+cat - > ${NFSS_CONFIG_FILE} <<EOD
+{{nfss_config}}
+EOD
+adb pull /home/phablet/lttng-traces ./clientlogs/lttng-traces
+cd ./clientlogs/lttng-traces
+for DIR in $(find -mindepth 1 -maxdepth 1 -type d)
+do
+    export PACKAGE_NAME=$(echo "$DIR" | sed 's/\.\/\(.*\)-startup.*/\1/')
+    export APP_ID=$(cat $DIR/app_id)
+    export JSON_FILE=$DIR/results.json
+    ${BZRDIR}/scripts/app-trace-export.py ${PACKAGE_NAME} ${APP_ID} ${DIR}/ust/uid/32011/32-bit/
+    cat $JSON_FILE | nfss_insert.py ${NFSS_CONFIG_FILE} app-startup $PACKAGE_NAME
+done
+{% endif %}
+      ]]></command>
     </hudson.tasks.Shell>
-{% endblock %}
-{% block extrasteps %}{% endblock %}
   </builders>
   <publishers>
-{% block artifactblock %}
     <hudson.tasks.ArtifactArchiver>
-{% block artifacts %}{% endblock %}
+      <artifacts>clientlogs/*, clientlogs/**/*</artifacts>
       <latestOnly>false</latestOnly>
     </hudson.tasks.ArtifactArchiver>
-{% endblock %}
-{% block descriptionsetter %}
     <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>
-{% endblock %}
-{% block mailer %}
     <hudson.tasks.Mailer>
       <recipients>[e-mail] [e-mail]</recipients>
       <dontNotifyEveryUnstableBuild>false</dontNotifyEveryUnstableBuild>
       <sendToIndividuals>false</sendToIndividuals>
     </hudson.tasks.Mailer>
-{% endblock %}
+    <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 %}
-{% block buildpublisher %}
     <hudson.plugins.build__publisher.BuildPublisher>
       <publishUnstableBuilds>true</publishUnstableBuilds>
       <publishFailedBuilds>true</publishFailedBuilds>
       <postActions class="vector"/>
     </hudson.plugins.build__publisher.BuildPublisher>
-{% endblock %}
 {% endif %}
-{% block buildtrigger %}{% endblock %}
-{% block junitresults %}{% endblock %}
   </publishers>
   <buildWrappers>
       <hudson.plugins.build__timeout.BuildTimeoutWrapper>
-          {% block timeout %}{% endblock %}
+        <timeoutMinutes>{{timeout}}</timeoutMinutes>
       <failBuild>true</failBuild>
       <writingDescription>false</writingDescription>
       <timeoutPercentage>0</timeoutPercentage>

=== removed file 'jenkins/templates/touch-click_image_tests.xml.jinja2'
--- jenkins/templates/touch-click_image_tests.xml.jinja2	2013-10-11 02:10:21 +0000
+++ jenkins/templates/touch-click_image_tests.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-{% extends "touch-autopilot-base.xml.jinja2" %}
-<?xml version='1.0' encoding='UTF-8'?>
-
-{% block apptest %}
-export APP=&quot;click_image_tests&quot;
-{% endblock %}
-
-{% block junitresults %}{% endblock %}

=== removed file 'jenkins/templates/touch-customizations.xml.jinja2'
--- jenkins/templates/touch-customizations.xml.jinja2	2013-10-09 03:38:14 +0000
+++ jenkins/templates/touch-customizations.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-{% extends "touch-autopilot-base.xml.jinja2" %}
-<?xml version='1.0' encoding='UTF-8'?>
-
-{% block apptest %}
-export APP=&quot;customizations&quot;
-{% endblock %}

=== removed file 'jenkins/templates/touch-default.xml.jinja2'
--- jenkins/templates/touch-default.xml.jinja2	2013-10-09 03:05:50 +0000
+++ jenkins/templates/touch-default.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,9 +0,0 @@
-{% extends "touch-autopilot-base.xml.jinja2" %}
-<?xml version='1.0' encoding='UTF-8'?>
-
-{% block apptest %}
-export APP=&quot;default&quot;
-{% endblock %}
-
-{% block junitresults %}{% endblock %}
-

=== removed file 'jenkins/templates/touch-eventstat.xml.jinja2'
--- jenkins/templates/touch-eventstat.xml.jinja2	2013-10-02 18:09:32 +0000
+++ jenkins/templates/touch-eventstat.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-{% extends "touch-base.xml.jinja2" %}
-
-{% block timeout %}
-  <timeoutMinutes>45</timeoutMinutes>
-{% endblock timeout %}
-
-{% block shellcmds %}
-      <command>set -e
-rm -rf *
-{% include "touch-setup.xml.jinja2" %}
-
-export APP=eventstat
-
-${BZRDIR}/scripts/jenkins.sh -s $ANDROID_SERIAL -a $APP -p /tmp/results
-      </command>
-{% endblock %}
-
-{% block artifacts %}
-      <artifacts>clientlogs/*, **/jenkins.sh</artifacts>
-{% endblock %}

=== removed file 'jenkins/templates/touch-install-and-boot.xml.jinja2'
--- jenkins/templates/touch-install-and-boot.xml.jinja2	2013-10-15 20:28:28 +0000
+++ jenkins/templates/touch-install-and-boot.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,29 +0,0 @@
-{% extends "touch-base.xml.jinja2" %}
-<?xml version='1.0' encoding='UTF-8'?>
-{% block triggers %}
-  <triggers class="vector"/>
-{% endblock %}
-{% block timeout %}
-  <timeoutMinutes>30</timeoutMinutes>
-{% endblock timeout %}
-
-{% block shellcmds %}
-      <command>set -e
-apt-cache policy phablet-tools
-rm -rf *
-mkdir clientlogs
-
-{% include "touch-setup.xml.jinja2" %}
-
-#Wait for images to actually show up on cdimage
-sleep {{wait}}
-{{image_opt}}
-${BZRDIR}/scripts/provision.sh -s $ANDROID_SERIAL -i {{imagetype}} -w
-
-${BZRDIR}/scripts/jenkins.sh -s $ANDROID_SERIAL -a install-and-boot
-      </command>
-{% endblock %}
-
-{% block artifacts %}
-      <artifacts>clientlogs/*</artifacts>
-{% endblock %}

=== removed file 'jenkins/templates/touch-master-free.xml.jinja2'
--- jenkins/templates/touch-master-free.xml.jinja2	2013-10-21 17:14:21 +0000
+++ jenkins/templates/touch-master-free.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-{% extends "touch-base.xml.jinja2" %}
-
-{% block timeout %}
-  <timeoutMinutes>10</timeoutMinutes>
-{% endblock timeout %}
-
-{% block shellcmds %}
-      <command>set -e
-rm -rf *
-{% include "touch-setup.xml.jinja2" %}
-
-echo LOCK_FILE=$LOCK_FILE > device-lock
-${BZRDIR}/scripts/device free --tokenfile device-lock
-      </command>
-{% endblock %}
-
-{% block artifactblock %}{% endblock %}
-{% block descriptionsetter %}{% endblock %}
-{% block buildpublisher %}{% endblock %}
-{% block mailer %}{% endblock %}

=== modified file 'jenkins/templates/touch-master.xml.jinja2'
--- jenkins/templates/touch-master.xml.jinja2	2013-10-21 03:21:14 +0000
+++ jenkins/templates/touch-master.xml.jinja2	2014-11-14 15:22:01 +0000
@@ -1,84 +1,80 @@
-{% extends "touch-base.xml.jinja2" %}
-{% block triggers %}
+<?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>
-{% endblock %}
-
-{% block shellcmds %}
-      <command>set -e
-rm -rf *
-{% include "touch-setup.xml.jinja2" %}
-
-mv .device.$$ device-lock
-      </command>
-{% endblock %}
-
-{% block extrasteps %}
+{% 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 %}
-    <hudson.plugins.parameterizedtrigger.TriggerBuilder>
-      <configs>
-        <hudson.plugins.parameterizedtrigger.BlockableBuildTriggerConfig>
-	  <configs>
-            <hudson.plugins.parameterizedtrigger.FileBuildParameters>
-              <propertiesFile>device-lock</propertiesFile>
-              <failTriggerOnMissing>true</failTriggerOnMissing>
-            </hudson.plugins.parameterizedtrigger.FileBuildParameters>
-          </configs>
-          <projects>{{project}}</projects>
-          <condition>ALWAYS</condition>
-          <triggerWithNoParameters>false</triggerWithNoParameters>
-          <block>
-{% if "install-and-boot" in project %}
-            <buildStepFailureThreshold>
-              <name>FAILURE</name>
-              <ordinal>2</ordinal>
-              <color>RED</color>
-            </buildStepFailureThreshold>
-{% endif %}
-            <unstableThreshold>
-              <name>UNSTABLE</name>
-              <ordinal>1</ordinal>
-              <color>YELLOW</color>
-            </unstableThreshold>
-{% if "install-and-boot" in project or "default" in project %}
-            <failureThreshold>
-              <name>FAILURE</name>
-              <ordinal>2</ordinal>
-              <color>RED</color>
-            </failureThreshold>
-{% endif %}
-          </block>
-          <buildAllNodesWithLabel>false</buildAllNodesWithLabel>
-        </hudson.plugins.parameterizedtrigger.BlockableBuildTriggerConfig>
-      </configs>
-    </hudson.plugins.parameterizedtrigger.TriggerBuilder>
+    {build("{{project}}", INSTALL_URL: install_url)},
 {% endfor %}
-{% endblock %}
-{% block timeout %}
-  <timeoutMinutes>300</timeoutMinutes>
-{% endblock timeout %}
-{% block artifactblock %}{% endblock %}
-{% block descriptionsetter %}{% endblock %}
-{% block buildpublisher %}{% endblock %}
-{% block mailer %}{% endblock %}
-{% block buildtrigger %}
-    <hudson.plugins.parameterizedtrigger.BuildTrigger>
-      <configs>
-        <hudson.plugins.parameterizedtrigger.BuildTriggerConfig>
-          <configs>
-            <hudson.plugins.parameterizedtrigger.FileBuildParameters>
-              <propertiesFile>device-lock</propertiesFile>
-              <failTriggerOnMissing>true</failTriggerOnMissing>
-            </hudson.plugins.parameterizedtrigger.FileBuildParameters>
-          </configs>
-          <projects>smoke-master-free</projects>
-          <condition>ALWAYS</condition>
-          <triggerWithNoParameters>false</triggerWithNoParameters>
-        </hudson.plugins.parameterizedtrigger.BuildTriggerConfig>
-      </configs>
-    </hudson.plugins.parameterizedtrigger.BuildTrigger>
-{% endblock %}
+)
+{% endif %}
+  ]]></dsl>
+</com.cloudbees.plugins.flow.BuildFlow>

=== removed file 'jenkins/templates/touch-memevent.xml.jinja2'
--- jenkins/templates/touch-memevent.xml.jinja2	2013-10-17 20:55:26 +0000
+++ jenkins/templates/touch-memevent.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-{% extends "touch-autopilot-base.xml.jinja2" %}
-<?xml version='1.0' encoding='UTF-8'?>
-{% block timeout %}
-  <timeoutMinutes>30</timeoutMinutes>
-{% endblock timeout %}
-
-{% block apptest %}
-export APP=&quot;memevent&quot;
-export EXTRA_PULLS=&quot;-p /tmp/memory_usage.json&quot;
-{% endblock %}

=== removed file 'jenkins/templates/touch-sdk.xml.jinja2'
--- jenkins/templates/touch-sdk.xml.jinja2	2013-10-09 03:05:50 +0000
+++ jenkins/templates/touch-sdk.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,9 +0,0 @@
-{% extends "touch-autopilot-base.xml.jinja2" %}
-<?xml version='1.0' encoding='UTF-8'?>
-
-{% block apptest %}
-export APP=&quot;sdk&quot;
-{% endblock %}
-
-{% block junitresults %}{% endblock %}
-

=== removed file 'jenkins/templates/touch-security.xml.jinja2'
--- jenkins/templates/touch-security.xml.jinja2	2013-10-09 03:05:50 +0000
+++ jenkins/templates/touch-security.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,9 +0,0 @@
-{% extends "touch-autopilot-base.xml.jinja2" %}
-<?xml version='1.0' encoding='UTF-8'?>
-
-{% block apptest %}
-export APP=&quot;security&quot;
-{% endblock %}
-
-{% block junitresults %}{% endblock %}
-

=== removed file 'jenkins/templates/touch-setup.xml.jinja2'
--- jenkins/templates/touch-setup.xml.jinja2	2013-12-03 14:21:24 +0000
+++ jenkins/templates/touch-setup.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-BRANCH=&quot;{{branch}}&quot;
-BZRDIR=`echo &quot;$BRANCH&quot; | awk -F/ &apos;{ print $(NF) }&apos;`
-BZRDIR=$(readlink -f $BZRDIR)
-bzr branch ${BRANCH} ${BZRDIR}
-
-device_free() {
-  if [ -f .device.$$ ] ; then
-    ${BZRDIR}/scripts/device free
-  fi
-}
-
-if [ -z $ANDROID_SERIAL ] ; then
-  echo No device lock found. Aquiring...
-  ${BZRDIR}/scripts/device get --name {{name}}
-  . ./.device.$$  # source in the device serial
-  trap "exit -2" TERM INT
-  trap device_free EXIT
-fi

=== removed file 'jenkins/templates/touch-smem.xml.jinja2'
--- jenkins/templates/touch-smem.xml.jinja2	2013-10-10 21:18:29 +0000
+++ jenkins/templates/touch-smem.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,22 +0,0 @@
-{% extends "touch-base.xml.jinja2" %}
-
-{% block triggers %}
-  <triggers class="vector"/>
-{% endblock %}
-{% block timeout %}
-  <timeoutMinutes>60</timeoutMinutes>
-{% endblock timeout %}
-
-{% block shellcmds %}
-      <command>rm -rf *
-{% include "touch-setup.xml.jinja2" %}
-
-export APP=smem
-
-${BZRDIR}/scripts/jenkins.sh -s $ANDROID_SERIAL -a $APP -p /tmp/results
-</command>
-{% endblock %}
-
-{% block artifacts %}
-      <artifacts>clientlogs/**/*</artifacts>
-{% endblock %}

=== modified file 'jenkins/templates/touch-smoke.xml.jinja2'
--- jenkins/templates/touch-smoke.xml.jinja2	2013-12-17 19:06:46 +0000
+++ jenkins/templates/touch-smoke.xml.jinja2	2014-11-14 15:22:01 +0000
@@ -12,15 +12,12 @@
   <dt>Full Test Run</dt>
   <dd>TESTS=ALL</dd>
   <dd>APPS=ALL</dd>
-  <dd>PACKAGES=ALL</dd>
   <dt>Re-run a Failed Autopilot Test</dt>
-  <dd>INSTALL_URL=http://jenkins-dev-image-test:8080/job/saucy-touch_ro-mako/9</dd>
-  <dd>APPS=share_app</dd>
-  <dt>Run Several Autopilot Tests on Latest Build</dt>
-  <dd>APPS=share_app music_app</dd>
-  <dd>PACKAGES=share-app-autopilot</dd>
-  <dt>Run All Tests Under Utah</dt>
-  <dd>TESTS=ALL_INCLUDING_AUTOPILOT</dd>
+  <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
@@ -29,8 +26,8 @@
 {% 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}}.test_autopilot.mean%2C0.000016667%29%2C%22Autopilot%20Tests%20Time%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.test_utah.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}}.test_autopilot.mean%2C0.000016667%29%2C%22Autopilot%20Tests%20Time%22%29&target=alias%28scale%28statsd.{{statsd_key}}.{{imagetype}}.test_utah.mean%2C0.000016667%29%2C%22UTAH%20Tests%20Time%22%29&from=-4weeks">Timings (4 weeks)</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=-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 %}
 ]]>
@@ -47,25 +44,31 @@
         </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 tests.
+          <description>A space separated list of utah tests to run. "ALL" can be used to run all known utah tests.
 	  </description>
-          <defaultValue></defaultValue>
+          <defaultValue>ALL</defaultValue>
         </hudson.model.StringParameterDefinition>
-        <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></defaultValue>
-        </hudson.model.StringParameterDefinition>
-	<hudson.model.StringParameterDefinition>
-          <name>PACKAGES</name>
-          <description>A space separated list of packages to install. "ALL" can be used to install required packages for all known autopilot tests.
-	  </description>
           <defaultValue>ALL</defaultValue>
         </hudson.model.StringParameterDefinition>
 	<hudson.model.StringParameterDefinition>
-          <name>PPAS</name>
-          <description>A space separated list of PPAs to configure on the device.
+          <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>
@@ -94,10 +97,41 @@
 
 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}}
 ${BZRDIR}/scripts/run-smoke
       </command>
@@ -109,7 +143,7 @@
       <latestOnly>false</latestOnly>
     </hudson.tasks.ArtifactArchiver>
     <hudson.tasks.junit.JUnitResultArchiver>
-      <testResults>clientlogs/**/test_results.xml</testResults>
+      <testResults>clientlogs/**/*.xml</testResults>
       <keepLongStdio>true</keepLongStdio>
       <testDataPublishers>
         <hudson.plugins.junitattachments.AttachmentPublisher/>
@@ -120,6 +154,23 @@
       <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>
@@ -135,7 +186,7 @@
   </publishers>
   <buildWrappers>
       <hudson.plugins.build__timeout.BuildTimeoutWrapper>
-          <timeoutMinutes>180</timeoutMinutes>
+          <timeoutMinutes>300</timeoutMinutes>
       <failBuild>true</failBuild>
       <writingDescription>false</writingDescription>
       <timeoutPercentage>0</timeoutPercentage>

=== removed file 'jenkins/templates/touch-upgrade.xml.jinja2'
--- jenkins/templates/touch-upgrade.xml.jinja2	2013-08-30 18:37:05 +0000
+++ jenkins/templates/touch-upgrade.xml.jinja2	1970-01-01 00:00:00 +0000
@@ -1,28 +0,0 @@
-{% extends "touch-base.xml.jinja2" %}
-<?xml version='1.0' encoding='UTF-8'?>
-{% block triggers %}
-  <triggers class="vector"/>
-{% endblock %}
-{% block timeout %}
-  <timeoutMinutes>30</timeoutMinutes>
-{% endblock timeout %}
-
-{% block shellcmds %}
-      <command>rm -rf *
-{% include "touch-setup.xml.jinja2" %}
-
-${BZRDIR}/scrips/run-touch-upgrade.sh
-</command>
-{% endblock %}
-
-{% block artifacts %}
-      <artifacts>clientlogs/*, **/jenkins.sh</artifacts>
-{% endblock %}
-
-{% block descriptionsetter %}
-    <hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
-      <regexp>^UPGRADED TO VERSION: (.*)</regexp>
-      <regexpForFailed>^UPGRADED TO VERSION: (.*)</regexpForFailed>
-      <setForMatrix>false</setForMatrix>
-    </hudson.plugins.descriptionsetter.DescriptionSetterPublisher>
-{% endblock %}

=== modified file 'jenkins/testconfig.py'
--- jenkins/testconfig.py	2014-02-04 22:50:58 +0000
+++ jenkins/testconfig.py	2014-11-14 15:22:01 +0000
@@ -22,9 +22,20 @@
 
 
 class Test(object):
-    def __init__(self, name, fmt=DEF_FMT):
+    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):
@@ -38,32 +49,34 @@
 
 
 TESTSUITES = [
-    Test('install-and-boot'),
     Test('default'),
 ]
 TESTSUITES += [
-    APTest('friends-app-autopilot', pkgs=['friends-app-autopilot']),
     APTest('mediaplayer-app-autopilot', pkgs=['mediaplayer-app-autopilot']),
-    APTest('gallery-app-autopilot', pkgs=['gallery-app-autopilot']),
+    APTest('gallery-app-autopilot'),
     APTest('webbrowser-app-autopilot', pkgs=['webbrowser-app-autopilot']),
-    APTest('unity8-autopilot', 'unity8', pkgs=['python-gi']),
-    APTest('notes-app-autopilot'),
-    APTest('camera-app-autopilot', pkgs=['camera-app-autopilot']),
+    APTest('webapp-container-autopilot', pkgs=['webapp-container-autopilot']),
+    APTest('unity8-autopilot', 'unity8'),
+    APTest('camera-app-autopilot'),
     APTest('dialer-app-autopilot', pkgs=['dialer-app-autopilot']),
     APTest('messaging-app-autopilot', pkgs=['messaging-app-autopilot']),
     APTest('address-book-app-autopilot', pkgs=['address-book-app-autopilot']),
-    APTest('calendar-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('ubuntu-filemanager-app-autopilot'),
-    APTest('ubuntu-rssreader-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'),
+    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']),
@@ -72,39 +85,66 @@
     Test('click_image_tests'),
     Test('sdk'),
     Test('security'),
-    Test('eventstat', IDLE_FMT),
-    Test('smem', IDLE_FMT),
+    Test('eventstat', fmt=IDLE_FMT, smoke=False),
+    Test('smem', fmt=IDLE_FMT, smoke=False),
+    Test('health-check', timeout=300, smoke=False),
     Test('memevent',
-         '{prefix}{testname}-{series}-{imagetype}-armhf-default-{type}'),
+         fmt='{prefix}{testname}-{series}-{imagetype}-armhf-default-{type}',
+         smoke=False),
+    Test('bootspeed',
+         fmt='{prefix}{testname}-{series}-{imagetype}-{type}-{type}',
+         smoke=False),
+    Test('app-startup-benchmark',
+         fmt='{prefix}{testname}-{series}-{imagetype}-{type}-{type}',
+         smoke=False,
+         timeout=24300),
 ]
 
 
-def filter_tests(tests, image_type):
+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)
-        elif image_type not in ['touch', 'touch_mir']:
+            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)
-    return tests
-
-
-def _get_tests(test_type, image_type):
-    tests = [t for t in TESTSUITES if type(t) == test_type]
-    return filter_tests(tests, image_type)
+    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)
     if args.with_autopilot:
-        tests += _get_tests(APTest, args.image_type)
-    # NOTE: this is only called by MEGA jobs, so we can skip install-and-boot
-    print(' '.join([t.name for t in tests if t.name != 'install-and-boot']))
+        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)
+    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]))
 
 
@@ -118,24 +158,29 @@
     print(' '.join(pkgs))
 
 
-def get_tests_touch_sf4p(common_tests):
-    tests = []
-    test_set = [
-        'install-and-boot',
-        'default',
-        'unity8-autopilot',
-    ]
-
-    tests = [t for t in common_tests if t.name in test_set]
+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):
+def get_tests_touch_custom(common_tests, device_type):
     tests = common_tests
     tests.insert(1, Test('customizations'))
     return tests
 
 
+def get_tests_touch_stable(common_tests, device_type):
+    if device_type == 'krillin':
+        remove_for_krillin = ['filemanager', 'ubuntu-terminal-app-autopilot',
+                              'dropping-letters-app-autopilot',
+                              'sudoku-app-autopilot']
+        tests = [t for t in common_tests if t.name not in remove_for_krillin]
+    else:
+        tests = common_tests
+    return tests
+
+
 def _get_parser():
     parser = argparse.ArgumentParser(
         description='List information on configured tests for touch')
@@ -147,11 +192,23 @@
                    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)

=== renamed directory 'scripts' => 'scripts'
=== modified file 'scripts/app-trace-export.py'
--- scripts/app-trace-export.py	2014-02-06 20:39:18 +0000
+++ scripts/app-trace-export.py	2014-11-14 15:22:01 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 #!/usr/bin/env python3
 
 """
@@ -88,3 +89,106 @@
     pprint(doc)
 
     send_to_db('localhost', 27017, doc)
+=======
+#!/usr/bin/env python3
+
+"""
+Export application trace events for app startup.
+"""
+
+import argparse
+import json
+import os
+
+from datetime import datetime
+from pprint import pprint
+
+from babeltrace import TraceCollection
+# Install Python bindings for libbabeltrace:
+#     $ sudo add-apt-repository -y \
+#     $ ppa:canonical-ci-engineering/ci-airline-phase-0
+#     $ sudo apt-get update
+#     $ sudo apt-get -qy install babeltrace python3-babeltrace
+
+
+def parse_traces(trace_path):
+    """
+    Read binary traces and convert to dict of
+    tracepoint names and timestamps.  Timestamp format is:
+    epoch secs + nanosecs.
+    """
+
+    # Tracepoints to include for app startup
+    tracepoints = {
+        'libual_start': {},
+        'libual_start_message_sent': {},
+        'libual_start_message_callback': {},
+        'handshake_wait': {},
+        'handshake_complete': {},
+        'exec_pre_exec': {},
+    }
+
+    # Build up the traces collection
+    traces = TraceCollection()
+    ret = traces.add_trace(trace_path, 'ctf')
+    if ret is None:
+        raise IOError('Error adding trace')
+
+    # Record the timestamps
+    timestamps = {}
+    for event in traces.events:
+        name = event.name.split(':')[1]
+        # We only want the event if it's the first occurance to
+        # handle possibly messy traces.
+        if name not in timestamps:
+            # Keep only the timestamps we care about by event name
+            if name in tracepoints:
+                if len(tracepoints[name]) == 0:
+                    timestamps[name] = event.timestamp
+                else:
+                    fieldname = name
+                    for field in tracepoints[name]:
+                        if not event[field] == tracepoints[name][field]:
+                            fieldname = None
+                            break
+                        else:
+                            fieldname += ":{}={}".format(
+                                field, tracepoints[name][field])
+
+                    if fieldname is not None and fieldname not in timestamps:
+                        timestamps[fieldname] = event.timestamp
+
+    return timestamps
+
+
+def generate_doc(tracepoints, app_id):
+    return dict(
+        package_name=args.package_name,
+        app_id=app_id,
+        android_serial=os.environ.get('ANDROID_SERIAL'),
+        image_type=os.environ.get('IMAGE_TYPE'),
+        build_num=os.environ.get('BUILD_NUMBER'),
+        build_id=os.environ.get('BUILD_ID'),
+        job_name=os.environ.get('JOB_NAME'),
+        node_name=os.environ.get('NODE_NAME'),
+        datetime=datetime.utcnow().isoformat(),
+        tracepoints=tracepoints,
+    )
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('package_name', help='click package name')
+    parser.add_argument('app_id', help='application identifier')
+    parser.add_argument('path', help='path to trace')
+    args = parser.parse_args()
+
+    tracepoints = parse_traces(args.path),
+    doc = generate_doc(tracepoints, args.app_id)
+
+    pprint(doc)
+
+    if os.environ.get('JSON_FILE'):
+        with open(os.environ.get('JSON_FILE'), 'w') as jsonfile:
+            json.dump(doc, jsonfile)
+>>>>>>> MERGE-SOURCE

=== modified file 'scripts/assert-image'
--- scripts/assert-image	2013-11-06 22:06:54 +0000
+++ scripts/assert-image	2014-11-14 15:22:01 +0000
@@ -17,9 +17,14 @@
 	CUST=$(curl ${INSTALL_URL}/artifact/clientlogs/.ci-customizations | tr -d '\r\n')
 	echo "reprovisioning device with: $ARGS"
 	echo "customizing device with: $CUST"
-	UUID=$REQUIRED_UUID IMAGE_OPT=$ARGS CUSTOMIZATIONS=$CUST \
+        #Make the image writable if we reprovision by adding a space
+        #after to CUSTOMIZE so it is never empty
+	UUID=$REQUIRED_UUID 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
 

=== modified file 'scripts/combine_results'
--- scripts/combine_results	2013-10-24 18:17:03 +0000
+++ scripts/combine_results	2014-11-14 15:22:01 +0000
@@ -13,10 +13,25 @@
 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'] = 'settle_%s' % name
+    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')
@@ -53,33 +68,48 @@
 
 
 def _get_classname(results):
-    return results[0].attrib.get('classname', '???').split('.')[0]
+    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)
 
-    rc = os.path.join(resdir, 'settle_before.rc')
-    log = os.path.join(resdir, 'settle_before.log')
-    node, failed = _build_node(classname, 'before', rc, log)
-    ap_results.insert(0, node)
-    if failed:
-        errors += 1
-
-    rc = os.path.join(resdir, 'settle_after.rc')
-    log = os.path.join(resdir, 'settle_after.log')
-    node, failed = _build_node(classname, 'after', rc, log)
-    ap_results.append(node)
-    if failed:
-        errors += 1
-
-    num = int(ap_results.attrib['tests']) + 2
+    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)
 

=== added file 'scripts/dashboard.py'
--- scripts/dashboard.py	1970-01-01 00:00:00 +0000
+++ scripts/dashboard.py	2014-11-14 15:22:01 +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))

=== removed file 'scripts/device'
--- scripts/device	2013-10-21 15:59:19 +0000
+++ scripts/device	1970-01-01 00:00:00 +0000
@@ -1,191 +0,0 @@
-#!/usr/bin/python
-
-import argparse
-import contextlib
-import fcntl
-import imp
-import logging
-import os
-import sys
-import time
-
-
-class DeviceException(Exception):
-    """Just a handy way to pass errors to the CLI."""
-    pass
-
-
[e-mail]
-def _device_pool(args):
-    lockfile = os.path.join(args.device_pool, 'lockfile')
-    with open(lockfile, 'w') as f:
-        logging.debug('aquiring lock for device pool')
-        try:
-            fcntl.lockf(f, fcntl.LOCK_EX)
-            yield args.device_pool
-        finally:
-            fcntl.lockf(f, fcntl.LOCK_UN)
-
-
-def _get_tokenfile():
-    return '.device.%d' % os.getppid()
-
-
-def _lock_device(device_file):
-    logging.info('locking file %s', device_file)
-
-    name = os.path.basename(device_file)
-    lockfile = device_file + '.lck'
-
-    with open(device_file) as f:
-        contents = f.read()
-        with open(_get_tokenfile(), 'w') as w:
-            w.write(contents)
-            if contents[-1] != '\n':
-                w.write('\n')
-            w.write('DEVICE_NAME=%s\n' % name)
-            w.write('LOCK_FILE=%s\n' % lockfile)
-    os.rename(device_file, lockfile)
-
-
-def _get_by_name(args):
-    loops = 0
-    while True:
-        with _device_pool(args) as pool:
-            f = os.path.join(pool, args.name)
-            if os.path.exists(f):
-                _lock_device(f)
-                break
-            elif os.path.exists(f + '.lck'):
-                # throttle back logging as time progresses
-                if (loops < 10) or \
-                   (loops < 100 and loops % 4 == 0) or \
-                   (loops % 12 == 0):
-                    logging.info(
-                        'device is locked, waiting... attempts(%d)', loops)
-            else:
-                raise DeviceException('No such device exists.')
-        time.sleep(5)
-        loops += 1
-
-
-def _get_by_type(args):
-    while True:
-        with _device_pool(args) as pool:
-            match = False
-            for d in os.listdir(pool):
-                if args.type in d:
-                    match = True
-                    if not d.endswith('.lck'):
-                        _lock_device(os.path.join(pool, d))
-                        return
-            if not match:
-                raise DeviceException(
-                    'No "%s" devices found in pool.' % args.type)
-        time.sleep(5)
-
-
-def _get_by_env(args, jobname):
-    # find the device portion of a string like:
-    #  saucy-touch_ro-DEVICETYPE-smoke-ubuntu-terminal-app-autopilot
-    parts = jobname.split('-')
-    if len(parts) < 3:
-        raise DeviceException('Invalid jobname: %s.' % jobname)
-    args.type = parts[2]
-    _get_by_type(args)
-
-
-def _device_get(args):
-    job = os.environ.get('JOBNAME', False)
-
-    if args.name:
-        _get_by_name(args)
-    elif args.type:
-        _get_by_type(args)
-    elif job:
-        _get_by_env(args, job)
-    else:
-        raise DeviceException('no device, type or $JOBNAME specified.')
-
-
-def _device_free(args):
-    if not os.path.exists(args.tokenfile):
-        raise DeviceException('tokenfile(%s) does not exist.' % args.tokenfile)
-
-    lockfile = None
-    with open(args.tokenfile) as f:
-        for line in f.readlines():
-            if line.startswith('LOCK_FILE='):
-                lockfile = line.split('=', 2)[1].strip()
-                break
-
-    device_file = os.path.splitext(lockfile)[0]
-    with _device_pool(args):
-        logging.info('releasing lock for %s', device_file)
-        os.rename(lockfile, device_file)
-    os.unlink(args.tokenfile)
-
-
-def _populate(args):
-    if os.path.exists(args.device_pool):
-        raise DeviceException('pool(%s) already exists.' % args.device_pool)
-    os.makedirs(args.device_pool)
-
-    # jump through some hoops to import this module since it has dashes
-    # and doesn't have a .py extension
-    module = 'get-adb-id'
-    fname = os.path.join(os.path.dirname(__file__), module)
-    adb = imp.load_source(module, fname)
-
-    # import the config
-    config_module = imp.load_source('config', args.config)
-    for config in config_module.MATRIX.values():
-        for item in config:
-            for device in item['devices']:
-                name = device['name']
-                serial = device.get('serial', None)
-                if not serial:
-                    serial = adb.DEVICES[name]
-                with open(os.path.join(args.device_pool, name), 'w') as f:
-                    f.write('ANDROID_SERIAL=%s' % serial)
-
-
-def _get_args():
-    parser = argparse.ArgumentParser(
-        description='''Provides a mechanism to aquire a lock on a device in
-                    a given resource pool. The lock info will be written in
-                    the format .device.<calling pid>. This file can be sourced
-                    by a shell script to get ANDROID_SERIAL etc.''')
-    parser.add_argument('--device-pool', default='/var/lib/jenkins/ci-devices',
-                        help='location of the device pool. %(default)s')
-
-    sub = parser.add_subparsers(title='Commands', metavar='')
-    p = sub.add_parser('get', help='Aquire a lock on an idle device.')
-    grp = p.add_mutually_exclusive_group()
-    grp.add_argument('--name', help='Get device by name')
-    grp.add_argument('--type', help='Get device by type')
-    p.set_defaults(func=_device_get)
-
-    p = sub.add_parser('free', help='Release a lock on a device.')
-    p.add_argument('--tokenfile', default=_get_tokenfile(),
-                   help='token file for device reservation. %(default)s')
-    p.set_defaults(func=_device_free)
-
-    p = sub.add_parser('populate', help='Initialize a device pool for usage')
-    p.add_argument('-c', '--config', required=True,
-                   help='The jenkins config to find devices in.')
-    p.set_defaults(func=_populate)
-
-    return parser.parse_args()
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    args = _get_args()
-    rc = 0
-    try:
-        args.func(args)
-    except DeviceException as e:
-        rc = 1
-        print('ERROR: %s' % e)
-    sys.exit(rc)

=== added file 'scripts/device_info.py'
--- scripts/device_info.py	1970-01-01 00:00:00 +0000
+++ scripts/device_info.py	2014-11-14 15:22:01 +0000
@@ -0,0 +1,257 @@
+#!/usr/bin/env python
+
+import logging
+import re
+import subprocess
+import time
+
+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):
+        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
+
+    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
+        log.info("Flashing the last stable image")
+        subprocess.check_output(['ubuntu-device-flash', 'touch', '--serial',
+                                 self.serial, '--channel',
+                                 'ubuntu-touch/stable', '--bootstrap',
+                                 '--developer-mode',
+                                 '--password', '0000'])
+        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 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 bootloader_func and callable(bootloader_func):
+            bootloader_func()
+        else:
+            raise DeviceError("Full recovery not possible with this device")
+
+    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(10)
+        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 = {
+    "krillin-01": TouchDevice("krillin", "JB011018"),
+    "krillin-02": TouchDevice("krillin", "JB010894"),
+    "krillin-03": TouchDevice("krillin", "JB015156",
+                              relay_url="http://ferris.ubuntu-ci",
+                              bank=2, power_pin=0, volume_up_pin=1,
+                              volume_down_pin=2),
+    "krillin-04": TouchDevice("krillin", "JB006885",
+                              relay_url="http://ferris.ubuntu-ci",
+                              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://ferris.ubuntu-ci",
+                              bank=2, power_pin=4, volume_up_pin=5,
+                              volume_down_pin=6),
+    "krillin-08": TouchDevice("krillin", "JW013513",
+                              relay_url="http://ferris.ubuntu-ci",
+                              bank=1, power_pin=0, volume_up_pin=1,
+                              volume_down_pin=2),
+    "krillin-09": TouchDevice("krillin", "JW010053",
+                              relay_url="http://ferris.ubuntu-ci",
+                              bank=0, power_pin=4, volume_up_pin=5,
+                              volume_down_pin=6),
+    "krillin-10": TouchDevice("krillin", "JB012976",
+                              relay_url="http://decatur.ubuntu-ci",
+                              bank=2, power_pin=0, volume_up_pin=1,
+                              volume_down_pin=2),
+    "ps-mako-01": TouchDevice("mako", "0090f741e3d141bc"),
+    "ps-mako-02": TouchDevice("mako", "04ccca120acd4dea"),
+    "ps-mako-03": TouchDevice("mako", "04cb53b598546534"),
+    "ps-mako-04": TouchDevice("mako", "04cbcc545f5328a5"),
+    "mako-01": TouchDevice("mako", "01aa3d7a5dcba4a2"),
+    "mako-02": TouchDevice("mako", "01ade38b552014d4"),
+    "mako-03": TouchDevice("mako", "04c6714ed7c863f2"),
+    "mako-04": TouchDevice("mako", "04df89cf0f9d0933",
+                           relay_url="http://qa-relay-control.ubuntu-ci",
+                           bank=1, power_pin=4, volume_down_pin=5),
+    "mako-05": TouchDevice("mako", "01b22f82dc5cec63",
+                           relay_url="http://decatur.ubuntu-ci",
+                           bank=0, power_pin=0, volume_down_pin=1),
+    "mako-06": TouchDevice("mako", "04ed70928fdc13ba",
+                           relay_url="http://decatur.ubuntu-ci",
+                           bank=0, power_pin=2, volume_down_pin=3),
+    "mako-07": TouchDevice("mako", "01e2f64788556934",
+                           relay_url="http://decatur.ubuntu-ci",
+                           bank=0, power_pin=4, volume_down_pin=5),
+    "mako-08": TouchDevice("mako", "04ea16a163930769",
+                           relay_url="http://decatur.ubuntu-ci",
+                           bank=0, power_pin=6, volume_down_pin=7),
+    "mako-09": TouchDevice("mako", "04fda12ea08fe3c7"),
+    "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://qa-relay-control.ubuntu-ci",
+                           bank=0, power_pin=1, volume_down_pin=2),
+    "mako-13": TouchDevice("mako", "0084e99c5315731b",
+                           relay_url="http://qa-relay-control.ubuntu-ci",
+                           bank=0, power_pin=3, volume_down_pin=4),
+    "mako-14": TouchDevice("mako", "007c6d84d348838e",
+                           relay_url="http://qa-relay-control.ubuntu-ci",
+                           bank=0, power_pin=5, volume_down_pin=6),
+    "mako-15": TouchDevice("mako", "00763b4a61ce0f87",
+                           relay_url="http://qa-relay-control.ubuntu-ci",
+                           bank=1, power_pin=0, volume_down_pin=1),
+    "mako-16": TouchDevice("mako", "017121eacf5282c4",
+                           relay_url="http://qa-relay-control.ubuntu-ci",
+                           bank=1, power_pin=2, volume_down_pin=3),
+    #mako-17 has a broken screen but should work, on ashes
+    "mako-17": TouchDevice("mako", "04e0d2f6d3cab77d"),
+    "mako-18": TouchDevice("mako", "027b981a4c1110dd",
+                           relay_url="http://decatur.ubuntu-ci",
+                           bank=1, power_pin=0, volume_down_pin=1),
+    "mako-19": TouchDevice("mako", "021c8cdfd5d38602"),
+    "mako-20": TouchDevice("mako", "05083705e0d29402",
+                           relay_url="http://decatur.ubuntu-ci",
+                           bank=1, power_pin=2, volume_down_pin=3),
+    "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://ferris.ubuntu-ci",
+                          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]

=== modified file 'scripts/get-adb-id'
--- scripts/get-adb-id	2013-12-13 18:47:35 +0000
+++ scripts/get-adb-id	2014-11-14 15:22:01 +0000
@@ -1,39 +1,14 @@
 #!/usr/bin/python
 
 import sys
-
-DEVICES = {
-    "maguro-01": "0149BD7E0A019003",
-    "maguro-02": "0149BD7E0200E00F",
-    "maguro-03": "0149C7A50A00C011",
-    "maguro-04": "0149BDCC0500701B",
-    "maguro-05": "0149BD3418014013",
-    "maguro-06": "014E058C0F00C013",
-    "maguro-07": "01498FE717002014",
-    "mako-01": "01aa3d7a5dcba4a2",
-    "mako-02": "01ade38b552014d4",
-    "mako-03": "04c6714ed7c863f2",
-    "mako-05": "01b22f82dc5cec63",
-    "mako-06": "04ed70928fdc13ba",
-    "mako-07": "01e2f64788556934",
-    "mako-08": "04ea16a163930769",
-    "mako-10": "01ce848e48dfa6a2",
-    "mako-11": "04ed727c929709ba",
-    "grouper-02": "015d1884951c020e",
-    "grouper-03": "015d18ad5c27f80d",
-    "grouper-04": "015d188445242611",
-    "grouper-05": "015d21d9151c0019",
-    "manta-01": "R32D102RPZL",
-    "manta-02": "R32D102RPPK",
-    "manta-04": "R32D203DDZR",
-    "manta-05": "R32D203DMBY",
-}
+from device_info import get_device
 
 if __name__ == '__main__':
     name = sys.argv[1]
 
     try:
-        print(DEVICES[name])
-    except KeyError:
+        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	2014-11-14 15:22:01 +0000
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+import argparse
+import device_info
+
+
+def _get_state(args):
+    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))

=== modified file 'scripts/jenkins.sh'
--- scripts/jenkins.sh	2013-11-01 17:07:18 +0000
+++ scripts/jenkins.sh	2014-11-14 15:22:01 +0000
@@ -46,20 +46,48 @@
 
 	[ -z $ANDROID_SERIAL ] || ADBOPTS="-s $ANDROID_SERIAL"
 
-	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 \
-		$EXTRA_PULL \
-		-l ${TESTSUITE_HOST}/master.run
+	# 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.
-	sudo chown -R `whoami` ${RESDIR}
+	# only run this if we had to run under sudo
+	if [ "${SUDO}" = "sudo" ] ; then
+		sudo chown -R "${USER}" ${RESDIR}
+	fi
 }
 
 assert_image() {
@@ -91,7 +119,7 @@
 	adb shell "top -n1 -b" > ${RESDIR}/top.log
 
 	set -x
-	adb shell 'rm -f /var/crash/*'
+	adb shell 'sudo rm -f /var/crash/*'
 	if [ -z $QUICK ] ; then
 		# get the phone in sane place
 		adb reboot
@@ -102,19 +130,19 @@
 		sleep 5
 		adb wait-for-device
 		phablet-network --skip-setup -t 90s
-		adb shell powerd-cli active &
+		adb shell sudo powerd-cli active &
 		PIDS="$PIDS $!"
-		adb shell powerd-cli display on &
+		adb shell sudo powerd-cli display on &
 		PIDS="$PIDS $!"
 	else
 		echo "SKIPPING phone reboot..."
 	fi
 
-	${BASEDIR}/utils/host/adb-shell "aa-clickhook -f --include=/usr/share/autopilot-touch/apparmor/click.rules"
+	${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 'rm -f /var/crash/*'
+	adb shell 'sudo rm -f /var/crash/*'
 
 	if ! `grep "^errors: [!0]" < $UTAHFILE >/dev/null` ; then
 		echo "errors found"

=== added file 'scripts/junit2utah.py'
--- scripts/junit2utah.py	1970-01-01 00:00:00 +0000
+++ scripts/junit2utah.py	2014-11-14 15:22:01 +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/ncd_usb.py'
--- scripts/ncd_usb.py	1970-01-01 00:00:00 +0000
+++ scripts/ncd_usb.py	2014-11-14 15:22:01 +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')

=== modified file 'scripts/provision.sh'
--- scripts/provision.sh	2013-12-05 18:14:27 +0000
+++ scripts/provision.sh	2014-11-14 15:22:01 +0000
@@ -5,17 +5,19 @@
 set -e
 
 BASEDIR=$(dirname $(readlink -f $0))
+export PATH=${BASEDIR}/../utils/host:${PATH}
 
 RESDIR=`pwd`/clientlogs
 
-NETWORK_FILE="${NETWORK_FILE-/home/ubuntu/magners-wifi}"
+NETWORK_FILE="${NETWORK_FILE-${HOME}/.ubuntu-ci/wifi.conf}"
 
-IMAGE_OPT="${IMAGE_OPT-ubuntu-system -b --channel trusty-proposed}"
+IMAGE_OPT="${IMAGE_OPT---bootstrap --developer-mode --channel ubuntu-touch/devel-proposed}"
 UUID="${UUID-$(uuidgen -r)}"
+PHABLET_PASSWORD="${PHABLET_PASSWORD-0000}"
 
 usage() {
 cat <<EOF
-usage: $0 [-s ANDROID_SERIAL] [-n NETWORK_FILE] [-P ppa] [-p package] [-w]
+usage: $0 [-s ANDROID_SERIAL] [-n NETWORK_FILE] [-P ppa] [-p package] [-r revision] [-w]
 
 Provisions the given device with the latest build
 
@@ -24,7 +26,9 @@
   -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
@@ -33,8 +37,8 @@
 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 "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 "system-image-cli -i | sed -n -e 's/channel: \(.*\)/\1/p' | paste -s -d:")
+	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" || IMAGE_OPT="${IMAGE_OPT} --revision $REV"
 	echo "$IMAGE_OPT" | grep -q "\-\-channel" || IMAGE_OPT="${IMAGE_OPT} --channel $CHAN"
@@ -53,7 +57,80 @@
 	echo = $(date): $*
 }
 
-while getopts i:s:n:P:p:wh opt; do
+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 whre '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
+}
+
+full_flash() {
+	log "FLASHING DEVICE"
+	# 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
+	# 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 touch --password $PHABLET_PASSWORD $IMAGE_OPT
+	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
@@ -75,9 +152,16 @@
 	P)
 		CUSTOMIZE="$CUSTOMIZE --ppa $OPTARG"
 		;;
+	D)
+		CUSTOMIZE="$CUSTOMIZE --package-dir $OPTARG"
+		;;
 	p)
 		CUSTOMIZE="$CUSTOMIZE -p $OPTARG"
 		;;
+	r)
+		IMAGE_OPT="$IMAGE_OPT --revision $OPTARG"
+		;;
+
 	esac
 done
 
@@ -92,35 +176,64 @@
 	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
 
-log "FLASHING DEVICE"
-phablet-flash $IMAGE_OPT
-adb wait-for-device
-sleep 20  #give the system a little time
-
-log "SETTING UP CLICK PACKAGES"
-phablet-click-test-setup
-
-log "SETTING UP WIFI"
-phablet-network -n $NETWORK_FILE
-
-if [ "$IMAGE_TYPE" = "touch_sf4p" ]; then
-    adb shell rm -f /home/phablet/.display-mir
-fi
-
-phablet-config edges-intro --disable
+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
 
-if [ -n "$CUSTOMIZE" ] ; then
-	log "CUSTOMIZING IMAGE"
-	phablet-config writable-image $CUSTOMIZE
-        # Make sure whoopsie-upload-all can work (bug #1245524)
-        adb shell "sed -i '/Waiting for whoopsie/ a\    subprocess.call([\"restart\", \"whoopsie\"])' /usr/share/apport/whoopsie-upload-all"
-fi
+set_hwclock

=== modified file 'scripts/reboot-and-wait'
--- scripts/reboot-and-wait	2013-10-31 17:53:58 +0000
+++ scripts/reboot-and-wait	2014-11-14 15:22:01 +0000
@@ -2,10 +2,14 @@
 
 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(
@@ -34,8 +38,17 @@
     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()
-    exit(main(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	2014-11-14 15:22:01 +0000
@@ -0,0 +1,120 @@
+#!/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', 'recovery'):
+        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 == '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 ('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)

=== modified file 'scripts/run-autopilot-tests.sh'
--- scripts/run-autopilot-tests.sh	2013-11-06 20:42:39 +0000
+++ scripts/run-autopilot-tests.sh	2014-11-14 15:22:01 +0000
@@ -31,22 +31,45 @@
 	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 120s $settle -c5 -d6 -p 97.5 -l $label || rc=1
+		timeout $timeout $settle -c5 -d6 -p 95 -l $label || rc=1
 		echo $rc > ${odir}/settle_${label}.rc
 	} 2>&1 | tee ${odir}/settle_${label}.log
-
-	if [ "$label" = "after" ] ; then
-		${BASEDIR}/scripts/combine_results ${odir}
-	fi
 }
 
 test_app() {
@@ -59,41 +82,60 @@
 	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"
-
-	if adb-shell /home/phablet/bin/unlock_screen.sh ; then
-		phablet-test-run \
-			$NOSHELL \
-			-o ${odir} \
-			-a /var/crash -a /home/phablet/.cache/upstart \
-			-v $app || true
-	else
-		log_error "screen unlock failed, skipping $app"
-	fi
+	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
-		${BASEDIR}/scripts/reboot-and-wait
-		files="/var/crash/* /home/phablet/.cache/upstart/*.log"
-		if ! adb shell rm -rf "$FILES" ; then
+		reboot-and-unlock.sh
+		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 rm -rf "$FILES"
+			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 powerd-cli active &
+	adb shell sudo powerd-cli active &
 	PIDS="$!"
-	adb shell powerd-cli display on &
+	adb shell sudo powerd-cli display on &
 	PIDS="$PIDS $!"
 }
 
@@ -105,14 +147,45 @@
 		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() {
-	# print the build date so the jenkins job can use it as the
-	# build description
-	BUILDID=$(adb shell cat /home/phablet/.ci-version)
-	echo "= TOUCH IMAGE VERSION:$BUILDID"
-
 	[ -d $RESDIR ] || mkdir -p $RESDIR
 
 	set -x
@@ -123,6 +196,7 @@
 		echo "= testing $app"
 		echo "========================================================"
 		set -x
+		dashboard_result_running $app
 		reboot_wait
 
 		grab_powerd
@@ -136,6 +210,7 @@
 			adb wait-for-device
 			test_app $app
 		fi
+		dashboard_result_syncing $app
 
 		release_powerd
 	done
@@ -182,4 +257,8 @@
 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	2014-11-14 15:22:01 +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	2014-11-14 15:22:01 +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}

=== modified file 'scripts/run-smoke'
--- scripts/run-smoke	2013-12-17 19:06:46 +0000
+++ scripts/run-smoke	2014-11-14 15:22:01 +0000
@@ -1,17 +1,37 @@
 #!/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):
@@ -60,12 +80,23 @@
                         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-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
 
 
@@ -92,6 +123,9 @@
     _arg_from_env(args, 'image_opt', 'IMAGE_OPT', 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):
@@ -115,18 +149,25 @@
         args.package = [x for x in out.decode().split()]
 
     if args.app and args.app[0] == 'ALL':
+        device_type = os.environ.get('DEVICE_TYPE')
+        if device_type is None:
+            device_type = detect_device(None)
         logging.info('Discovering all autopilot tests')
         out = subprocess.check_output(
-            [script, 'apps', '-i', args.image_type])
+            [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')
-        argv = [script, 'utah', '-i', args.image_type]
+        argv = [script, 'utah', '-i', args.image_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)
 
@@ -148,12 +189,93 @@
             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:
@@ -168,13 +290,31 @@
     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'):
-        _run(cargs)
-
-
-def _test_autopilot(args):
+        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])
@@ -182,13 +322,33 @@
             _run(cargs)
 
 
-def _test_utah(args):
+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)
-                _run(cargs + ['-a', test], ignore_error=True)
+                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):
@@ -198,14 +358,30 @@
             shutil.rmtree(res_dir)
         os.mkdir(res_dir)
 
-        if args.install_url:
+        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)
 
-        _test_autopilot(args)
-
-        _test_utah(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
 
@@ -213,6 +389,7 @@
 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):

=== renamed directory 'selftests' => 'selftests'
=== added file 'selftests/test_junit2utah.py'
--- selftests/test_junit2utah.py	1970-01-01 00:00:00 +0000
+++ selftests/test_junit2utah.py	2014-11-14 15:22:01 +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'])

=== modified file 'selftests/test_run_smoke.py'
--- selftests/test_run_smoke.py	2013-11-06 22:12:21 +0000
+++ selftests/test_run_smoke.py	2014-11-14 15:22:01 +0000
@@ -134,8 +134,10 @@
         with mock.patch.object(self.run_smoke, '_run') as run:
             with mock.patch.dict('os.environ'):
                 run.side_effects = [subprocess.CalledProcessError, None]
-                self.run_smoke._test_utah(args)
-                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)
+                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)

=== renamed directory 'tests' => 'tests'
=== removed directory 'tests/address-book-app-autopilot'
=== removed file 'tests/address-book-app-autopilot/master.run'
--- tests/address-book-app-autopilot/master.run	2013-08-30 17:40:26 +0000
+++ tests/address-book-app-autopilot/master.run	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
----
-testsuites:
-  - name: settle-before
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-before
-  - name: address-book-app-autopilot
-    fetch_method: dev
-    fetch_location: ./
-  - name: settle-after
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-after

=== removed file 'tests/address-book-app-autopilot/ts_control'
--- tests/address-book-app-autopilot/ts_control	2013-08-30 17:40:26 +0000
+++ tests/address-book-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-ts_setup: PKGS=address-book-app-autopilot prepare-autopilot-test.sh

=== removed file 'tests/address-book-app-autopilot/tslist.auto'
--- tests/address-book-app-autopilot/tslist.auto	2013-08-30 17:40:26 +0000
+++ tests/address-book-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
--
-  discovery_cmd: autopilot-list address_book_app
-  test_cmd: autopilot-run address_book_app.tests.{}
-

=== added directory 'tests/app-startup-benchmark'
=== added file 'tests/app-startup-benchmark/app-startup.sh'
--- tests/app-startup-benchmark/app-startup.sh	1970-01-01 00:00:00 +0000
+++ tests/app-startup-benchmark/app-startup.sh	2014-11-14 15:22:01 +0000
@@ -0,0 +1,107 @@
+#!/bin/bash
+
+## This is the script jenkins should run for app startup benchmarks
+
+set -e
+
+CMD_PREFIX=""
+BENCHMARK_CMD="app-startup-benchmark.sh"
+
+
+usage() {
+	cat <<EOF
+usage: $0 -a APP [-s ANDROID_SERIAL] [-Q] [-t TIMEOUT]
+
+Benchmark the startup of APP
+
+OPTIONS:
+  -h	Show this message
+  -s    Specify the serial of the device to install
+  -a    The name of the application to start
+  -Q    "Quick" don't do a reboot of the device before running the test
+  -t	Time to wait for application startup (Default is 60)
+  -r    Number of times to repeat (Default is 1)
+
+EOF
+}
+
+PIDS=""
+
+cleanup() {
+	set +e
+	echo "killing child pids: $PIDS"
+	for p in $PIDS ; do
+	kill $p
+	done
+}
+
+main() {
+	PIDS=""
+
+	set -x
+	if [ -z $QUICK ] ; then
+		reboot-and-unlock.sh
+		adb-shell ${CMD_PREFIX} initctl stop unity8-dash
+		adb shell powerd-cli active &
+		PIDS="$PIDS $!"
+		adb shell powerd-cli display on &
+		PIDS="$PIDS $!"
+		sleep 5
+	else
+		echo "SKIPPING phone reboot..."
+	fi
+
+	echo "launching benchmark...."
+	[ -z $ANDROID_SERIAL ] || ADBOPTS="-s $ANDROID_SERIAL"
+	adb-shell ${CMD_PREFIX} ${BENCHMARK_CMD} $APP $TIMEOUT
+
+	cleanup
+}
+
+export REPEAT=1
+
+while getopts p:s:a:Qt:r:h opt; do
+    case $opt in
+    h)
+        usage
+        exit 0
+        ;;
+    s)
+        export ANDROID_SERIAL=$OPTARG
+        ;;
+    a)
+        APP=$OPTARG
+        ;;
+    Q)
+        QUICK=1
+        ;;
+    t)
+	export TIMEOUT=$OPTARG
+	;;
+    r)
+	export REPEAT=$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 [ -z $APP ] ; then
+    echo "ERROR: No app specified"
+    usage
+    exit 1
+fi
+
+trap cleanup TERM INT EXIT
+
+for X in $(seq $REPEAT) ; do
+    main
+done

=== added file 'tests/app-startup-benchmark/blacklist'
--- tests/app-startup-benchmark/blacklist	1970-01-01 00:00:00 +0000
+++ tests/app-startup-benchmark/blacklist	2014-11-14 15:22:01 +0000
@@ -0,0 +1,3 @@
+com.canonical.payui
+com.ubuntu.reminders
+com.ubuntu.scopes.youtube

=== added file 'tests/app-startup-benchmark/master.run'
--- tests/app-startup-benchmark/master.run	1970-01-01 00:00:00 +0000
+++ tests/app-startup-benchmark/master.run	2014-11-14 15:22:01 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: app-startup-benchmark
+    fetch_method: dev
+    fetch_location: ./

=== added file 'tests/app-startup-benchmark/setup.sh'
--- tests/app-startup-benchmark/setup.sh	1970-01-01 00:00:00 +0000
+++ tests/app-startup-benchmark/setup.sh	2014-11-14 15:22:01 +0000
@@ -0,0 +1,23 @@
+#!/bin/sh
+
+set -ex
+
+echo "Installing LTTng"
+adb-shell "sudo apt-get install -yq lttng-modules-dkms lttng-tools"
+
+echo "Removing old traces"
+adb-shell "rm -rf /home/phablet/lttng-traces"
+
+echo "Allowing LTTng events from confined applications"
+adb-shell "sudo sed 's/deny \\(.*shm\\/lttng-ust-.*\\)/\\1\nowner @{HOME}\/.lttng\/ rw,\nowner @{HOME}\/.lttng\/\* rwk,\n\/run\/lttng\/ rw,\n\/run\/lttng\/** rwk,/' -i /usr/share/apparmor/easyprof/templates/ubuntu/*/ubuntu-*"
+
+echo "Regenerating AppArmor profiles for installed click applications"
+adb-shell "sudo aa-clickhook -f"
+
+echo "Setting environment variables for session"
+adb-shell "mkdir -p /home/phablet/.config/upstart"
+adb-shell "echo \"start on starting dbus\" > /home/phablet/.config/upstart/lttng-trace.conf"
+adb-shell "echo \"script\" >> /home/phablet/.config/upstart/lttng-trace.conf"
+adb-shell "echo \"initctl set-env --global LTTNG_UST_REGISTER_TIMEOUT=-1\" >> /home/phablet/.config/upstart/lttng-trace.conf"
+adb-shell "echo \"initctl set-env --global UBUNTU_APP_LAUNCH_LTTNG_ENABLED=TRUE\" >> /home/phablet/.config/upstart/lttng-trace.conf"
+adb-shell "echo \"end script\" >> /home/phablet/.config/upstart/lttng-trace.conf"

=== added file 'tests/app-startup-benchmark/ts_control'
--- tests/app-startup-benchmark/ts_control	1970-01-01 00:00:00 +0000
+++ tests/app-startup-benchmark/ts_control	2014-11-14 15:22:01 +0000
@@ -0,0 +1,1 @@
+ts_setup: ./setup.sh

=== added file 'tests/app-startup-benchmark/tslist.auto'
--- tests/app-startup-benchmark/tslist.auto	1970-01-01 00:00:00 +0000
+++ tests/app-startup-benchmark/tslist.auto	2014-11-14 15:22:01 +0000
@@ -0,0 +1,4 @@
+-
+  discovery_cmd: adb-shell click list | grep -v "ADB_RC" | awk '{print $1}' | grep -vf app-startup-benchmark/blacklist | cat - app-startup-benchmark/whitelist | sort | uniq
+  test_cmd: ../app-startup.sh -a {} -r 10 -t 10
+

=== added file 'tests/app-startup-benchmark/whitelist'
=== 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	2014-11-14 15:22:01 +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	2014-11-14 15:22:01 +0000
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+${TARGET_PREFIX} apt-get install bootchart
+

=== added file 'tests/bootspeed/bootchart/tc_control'
--- tests/bootspeed/bootchart/tc_control	1970-01-01 00:00:00 +0000
+++ tests/bootspeed/bootchart/tc_control	2014-11-14 15:22:01 +0000
@@ -0,0 +1,12 @@
+description: run phablet-bootchart on a phone
+dependencies: none
+action: |
+  1. setup bootchart
+  2. reboot 3 times
+  3. collect
+expected_results: |
+  1. boot chart data
+type: userland
+timeout: 2000
+command: ./run.py
+tc_setup: ./setup.sh

=== added file 'tests/bootspeed/master.run'
--- tests/bootspeed/master.run	1970-01-01 00:00:00 +0000
+++ tests/bootspeed/master.run	2014-11-14 15:22:01 +0000
@@ -0,0 +1,5 @@
+---
+testsuites:
+  - name: bootspeed
+    fetch_method: dev
+    fetch_location: ./

=== added file 'tests/bootspeed/tslist.run'
--- tests/bootspeed/tslist.run	1970-01-01 00:00:00 +0000
+++ tests/bootspeed/tslist.run	2014-11-14 15:22:01 +0000
@@ -0,0 +1,1 @@
+- test: bootchart

=== removed directory 'tests/calendar-app-autopilot'
=== removed file 'tests/calendar-app-autopilot/master.run'
--- tests/calendar-app-autopilot/master.run	2013-08-30 17:40:26 +0000
+++ tests/calendar-app-autopilot/master.run	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
----
-testsuites:
-  - name: settle-before
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-before
-  - name: calendar-app-autopilot
-    fetch_method: dev
-    fetch_location: ./
-  - name: settle-after
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-after

=== removed file 'tests/calendar-app-autopilot/ts_control'
--- tests/calendar-app-autopilot/ts_control	2013-10-08 17:38:57 +0000
+++ tests/calendar-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-ts_setup: PKGS=python-dateutil prepare-autopilot-test.sh

=== removed file 'tests/calendar-app-autopilot/tslist.auto'
--- tests/calendar-app-autopilot/tslist.auto	2013-08-30 17:40:26 +0000
+++ tests/calendar-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
--
-  discovery_cmd: autopilot-list calendar_app
-  test_cmd: autopilot-run calendar_app.tests.{}
-

=== removed directory 'tests/camera-app-autopilot'
=== removed file 'tests/camera-app-autopilot/master.run'
--- tests/camera-app-autopilot/master.run	2013-08-30 17:40:26 +0000
+++ tests/camera-app-autopilot/master.run	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
----
-testsuites:
-  - name: settle-before
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-before
-  - name: camera-app-autopilot
-    fetch_method: dev
-    fetch_location: ./
-  - name: settle-after
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-after

=== removed file 'tests/camera-app-autopilot/ts_control'
--- tests/camera-app-autopilot/ts_control	2013-08-30 17:40:26 +0000
+++ tests/camera-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-ts_setup: PKGS=camera-app-autopilot prepare-autopilot-test.sh

=== removed file 'tests/camera-app-autopilot/tslist.auto'
--- tests/camera-app-autopilot/tslist.auto	2013-08-30 17:40:26 +0000
+++ tests/camera-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
--
-  discovery_cmd: autopilot-list camera_app
-  test_cmd: autopilot-run camera_app.tests.{}
-

=== modified file 'tests/click_image_tests/check_preinstalled_list/check_preinstalled_list.py'
--- tests/click_image_tests/check_preinstalled_list/check_preinstalled_list.py	2013-10-01 18:24:18 +0000
+++ tests/click_image_tests/check_preinstalled_list/check_preinstalled_list.py	2014-11-14 15:22:01 +0000
@@ -35,8 +35,8 @@
 
 def get_image_list():
     click_list = subprocess.check_output(
-        ['adb', 'shell', 'sudo', '-u', 'phablet',
-         'bash', '-ic', 'click list']).decode('utf-8').split('\n')
+        ['adb', 'shell', 'sudo', '-iu', 'phablet',
+         'click', 'list']).decode('utf-8').split('\n')
     click_entries = [x for x in click_list if x]
     click_apps = {}
     for entry in click_entries:
@@ -50,11 +50,11 @@
     def setUp(self):
         self.image_list = get_image_list()
         self.install_list = get_install_list()
-        print('Search for %s on image' % self.install_list.keys())
+        print('Search for {} on image'.format(list(self.install_list.keys())))
 
     def testPreinstalled(self):
         for entry in self.install_list:
-            self.assertIn(entry, self.image_list.keys())
+            self.assertIn(entry, list(self.image_list.keys()))
 
 
 if __name__ == '__main__':

=== modified file 'tests/customizations/tslist.auto'
--- tests/customizations/tslist.auto	2014-02-06 20:10:08 +0000
+++ tests/customizations/tslist.auto	2014-11-14 15:22:01 +0000
@@ -1,4 +1,4 @@
 -
-  discovery_cmd: autopilot-list customization_tests
-  test_cmd: autopilot-run {}
+  discovery_cmd: autopilot-list -3 customization_tests
+  test_cmd: autopilot-run -3 {}
 

=== added directory 'tests/default/apport'
=== added file 'tests/default/apport/tc_control'
--- tests/default/apport/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/apport/tc_control	2014-11-14 15:22:01 +0000
@@ -0,0 +1,9 @@
+description: check that apport is enabled
+dependencies: none
+action: |
+  1. status apport | grep running
+expected_results: |
+  1. status apport says that it is running
+type: userland
+timeout: 60
+command: $TARGET_PREFIX sudo status apport | grep running

=== modified file 'tests/default/install/tc_control'
--- tests/default/install/tc_control	2013-09-10 12:51:04 +0000
+++ tests/default/install/tc_control	2014-11-14 15:22:01 +0000
@@ -6,7 +6,7 @@
   1. apt-get install can install a package and ends with exit code 0
 type: userland
 timeout: 120
-command: $TARGET_PREFIX apt-get install -y curl
+command: $TARGET_PREFIX sudo apt-get install -y curl
 #build_cmd:
 #tc_setup:
-tc_cleanup: $TARGET_PREFIX apt-get remove -y curl
+tc_cleanup: $TARGET_PREFIX sudo apt-get remove -y curl

=== modified file 'tests/default/systemsettle/systemsettle.sh'
--- tests/default/systemsettle/systemsettle.sh	2013-09-10 12:51:04 +0000
+++ tests/default/systemsettle/systemsettle.sh	2014-11-14 15:22:01 +0000
@@ -26,10 +26,11 @@
    echo " -m  maximum loops of top before giving up if minimum idle"
    echo "     percent is not reached (Default: 10)"
    echo " -l  label to include for the top_log file"
+   echo " -s  sleep timeout for %cpu calculation (Default: 10)"
    exit 129
 }
 
-while getopts "h?rp:c:d:i:m:l:" opt; do
+while getopts "h?rp:c:d:i:m:l:s:" opt; do
     case "$opt" in
         h|\?) show_usage
               ;;
@@ -47,9 +48,13 @@
               ;;
         l)    top_log_label=$OPTARG
               ;;
+        s)    sleep_len=$OPTARG
+              ;;
     esac
 done
 
+sleep_len=${sleep_len:-10}
+HZ=`getconf CLK_TCK`
 # minimum average idle level required to succeed
 idle_avg_min=${idle_avg_min:-99}
 # measurement details: top $top_wait $top_repeat
@@ -77,7 +82,6 @@
 echo "  settle_max     = '$settle_max'"
 echo "  run_forever    = '$settle_prefix' (- = yes)"
 echo "  log files   = $top_log $top_log.reduced"
-echo "  target prefix = $TARGET_PREFIX"
 echo
 
 while test `calc $idle_avg '<' $idle_avg_min` = 1 -a "$settle_prefix$settle_count" -lt "$settle_max"; do
@@ -86,27 +90,30 @@
   # get top
   echo "TOP DUMP (after settle run: $settle_count)" >> $top_log
   echo "========================" >> $top_log
-  ${TARGET_PREFIX} top -b -d $top_wait -n $top_repeat >> $top_log
+  ${TARGET_PREFIX} COLUMNS=900 top -c -b -d $top_wait -n $top_repeat >> $top_log
   cat $top_log | grep '.Cpu.*' | tail -n $top_tail > $top_log.reduced
   echo >> $top_log
 
-  # calc average of idle field for this measurement
-  sum=0
-  count=0
-  while read line; do
-     idle=`echo $line | sed -e 's/.* \([0-9\.]*\) id.*/\1/'`
-     sum=`calc $sum + $idle`
-     count=`calc $count + 1`
-  done < $top_log.reduced
-
-  idle_avg=`calc $sum / $count`
+  # Instead of using top, we need to use /proc/stat and compensate for
+  # the number of cpus and any frequency scaling that could be in effect
+  cpu_avg=$({
+    ${TARGET_PREFIX} cat /proc/stat
+    sleep "$sleep_len"
+    ${TARGET_PREFIX} cat /proc/stat
+  } | awk '
+    BEGIN       { iter = 0 }
+    /^cpu /     { iter = iter + 1; count = 0; next }
+    /^cpu/      { S[iter] = S[iter] + ($2+$3+$4+$6); count = count + 1;
+next }
+    END     { print (S[2] - S[1]) * 100 / ('"$HZ"' * count * '"$sleep_len"') }
+  ')
+  idle_avg=`calc 100 - $cpu_avg`
   settle_count=`calc $settle_count + 1`
 
   echo " DONE."
   echo
   echo "Measurement:"
   echo "  + idle level: $idle_avg"
-  echo "  + idle sum: $sum / count: $count"
   echo
 done
 

=== modified file 'tests/default/systemsettle/tc_control'
--- tests/default/systemsettle/tc_control	2013-11-06 10:14:50 +0000
+++ tests/default/systemsettle/tc_control	2014-11-14 15:22:01 +0000
@@ -6,4 +6,4 @@
   1. When doing nothing, system calms down to at least 99.25% idle level
 type: userland
 timeout: 720
-command: ./systemsettle.sh -c5 -d6 -p 97.5
+command: ./systemsettle.sh -c5 -d6 -p 95

=== modified file 'tests/default/tslist.run'
--- tests/default/tslist.run	2013-09-25 02:16:38 +0000
+++ tests/default/tslist.run	2014-11-14 15:22:01 +0000
@@ -8,3 +8,5 @@
 - test: ping
 - test: install
 - test: unity8
+- test: apport
+- test: whoopsie

=== added directory 'tests/default/whoopsie'
=== added file 'tests/default/whoopsie/tc_control'
--- tests/default/whoopsie/tc_control	1970-01-01 00:00:00 +0000
+++ tests/default/whoopsie/tc_control	2014-11-14 15:22:01 +0000
@@ -0,0 +1,10 @@
+description: verify whoopsie functionality
+dependencies: None
+action: |
+  1. trigger a segfault and verify that whoopsie uploads it
+expected_results: |
+  1. /var/crash/_bin_sleep.0.uploaded is created, indicating a successful upload
+type: userland
+timeout: 720
+command: adb-shell sudo /tmp/whoopsie-test.sh
+tc_setup: adb push whoopsie-test.sh /tmp

=== added file 'tests/default/whoopsie/whoopsie-test.sh'
--- tests/default/whoopsie/whoopsie-test.sh	1970-01-01 00:00:00 +0000
+++ tests/default/whoopsie/whoopsie-test.sh	2014-11-14 15:22:01 +0000
@@ -0,0 +1,86 @@
+#!/bin/sh
+
+set -e
+
+cleanup()
+{
+	stop whoopsie || true
+	rm -f /var/crash/_bin_sleep.0.*
+	start whoopsie
+}
+
+if [ ! -e /var/lib/apport/autoreport ]; then
+    echo "Automatic crash reporting not enabled."
+    exit 1
+fi
+
+if [ -e /var/crash/_bin_sleep.0.crash ] || [ -e /var/crash/_bin_sleep.0.upload ] \
+   || [ -e /var/crash/_bin_sleep.0.uploaded ]
+then
+	echo "Error: existing crash data found on disk.  Did a previous run fail?"
+	exit 1
+fi
+
+trap cleanup 0 2 3 5 10 13 15
+
+echo "Configuring whoopsie for staging"
+stop whoopsie
+if ! start whoopsie CRASH_DB_URL=https://daisy.staging.ubuntu.com
+then
+	echo "Failed to start whoopsie"
+	exit 1
+fi
+
+sleep 10 &
+echo "Background process id $!"
+ps $!
+echo "Sending SIGSEGV"
+kill -SEGV $!
+
+echo "Polling for .crash file"
+crash_found=false
+for i in $(seq 0 99); do
+	if [ -e /var/crash/_bin_sleep.0.crash ]; then
+		echo "Crash file created after $(($i*2)) seconds."
+		crash_found=:
+		break
+	fi
+	sleep 2
+done
+if ! $crash_found; then
+	echo "whoopsie failed to create crash file within 200 seconds."
+	exit 1
+fi
+
+echo "Polling for .upload file"
+upload_found=false
+for i in $(seq 0 19); do
+	if [ -e /var/crash/_bin_sleep.0.upload ]; then
+		echo "Upload file created after $i seconds."
+		upload_found=:
+		break
+	fi
+	sleep 1
+done
+if ! $upload_found; then
+	echo "whoopsie_upload_all failed to run within 20 seconds."
+	exit 1
+fi
+
+echo "Polling for .uploaded file"
+uploaded_found=false
+for i in $(seq 0 79); do
+	if [ -e /var/crash/_bin_sleep.0.uploaded ]; then
+		echo ".uploaded file created after $(($i*5)) seconds."
+		uploaded_found=:
+		break
+	fi
+	sleep 5
+done
+if ! $uploaded_found; then
+	echo "whoopsie failed to upload crash file within 400 seconds."
+	exit 1
+fi
+
+echo "crash file successfully uploaded."
+exit 0

=== removed directory 'tests/dialer-app-autopilot'
=== removed file 'tests/dialer-app-autopilot/master.run'
--- tests/dialer-app-autopilot/master.run	2013-08-30 17:40:26 +0000
+++ tests/dialer-app-autopilot/master.run	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
----
-testsuites:
-  - name: settle-before
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-before
-  - name: dialer-app-autopilot
-    fetch_method: dev
-    fetch_location: ./
-  - name: settle-after
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-after

=== removed file 'tests/dialer-app-autopilot/ts_control'
--- tests/dialer-app-autopilot/ts_control	2013-08-30 17:40:26 +0000
+++ tests/dialer-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-ts_setup: PKGS="dialer-app-autopilot ubuntu-ui-toolkit-autopilot" prepare-autopilot-test.sh

=== removed file 'tests/dialer-app-autopilot/tslist.auto'
--- tests/dialer-app-autopilot/tslist.auto	2013-08-30 17:40:26 +0000
+++ tests/dialer-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
--
-  discovery_cmd: autopilot-list dialer_app
-  test_cmd: autopilot-run dialer_app.tests.{}
-

=== removed directory 'tests/dropping-letters-app-autopilot'
=== removed file 'tests/dropping-letters-app-autopilot/master.run'
--- tests/dropping-letters-app-autopilot/master.run	2013-10-03 14:33:33 +0000
+++ tests/dropping-letters-app-autopilot/master.run	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
----
-testsuites:
-  - name: settle-before
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-before
-  - name: dropping-letters-app-autopilot
-    fetch_method: dev
-    fetch_location: ./
-  - name: settle-after
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-after

=== removed file 'tests/dropping-letters-app-autopilot/ts_control'
--- tests/dropping-letters-app-autopilot/ts_control	2013-10-03 14:33:33 +0000
+++ tests/dropping-letters-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-ts_setup: prepare-autopilot-test.sh

=== removed file 'tests/dropping-letters-app-autopilot/tslist.auto'
--- tests/dropping-letters-app-autopilot/tslist.auto	2013-10-03 14:33:33 +0000
+++ tests/dropping-letters-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
--
-  discovery_cmd: autopilot-list dropping_letters_app
-  test_cmd: autopilot-run dropping_letters_app.tests.{}
-

=== removed directory 'tests/friends-app-autopilot'
=== removed file 'tests/friends-app-autopilot/master.run'
--- tests/friends-app-autopilot/master.run	2013-08-30 17:40:26 +0000
+++ tests/friends-app-autopilot/master.run	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
----
-testsuites:
-  - name: settle-before
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-before
-  - name: friends-app-autopilot
-    fetch_method: dev
-    fetch_location: ./
-  - name: settle-after
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-after

=== removed file 'tests/friends-app-autopilot/ts_control'
--- tests/friends-app-autopilot/ts_control	2013-08-30 17:40:26 +0000
+++ tests/friends-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-ts_setup: PKGS=friends-app-autopilot prepare-autopilot-test.sh

=== removed file 'tests/friends-app-autopilot/tslist.auto'
--- tests/friends-app-autopilot/tslist.auto	2013-08-30 17:40:26 +0000
+++ tests/friends-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
--
-  discovery_cmd: autopilot-list friends_app
-  test_cmd: autopilot-run friends_app.tests.{}
-

=== removed directory 'tests/gallery-app-autopilot'
=== removed file 'tests/gallery-app-autopilot/master.run'
--- tests/gallery-app-autopilot/master.run	2013-08-30 17:40:26 +0000
+++ tests/gallery-app-autopilot/master.run	1970-01-01 00:00:00 +0000
@@ -1,15 +0,0 @@
----
-testsuites:
-  - name: settle-before
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-before
-  - name: gallery-app-autopilot
-    fetch_method: dev
-    fetch_location: ./
-  - name: settle-after
-    fetch_method: dev
-    fetch_location: ../systemsettle
-    include_tests:
-      - systemsettle-after

=== removed file 'tests/gallery-app-autopilot/ts_control'
--- tests/gallery-app-autopilot/ts_control	2013-08-30 17:40:26 +0000
+++ tests/gallery-app-autopilot/ts_control	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-ts_setup: PKGS=gallery-app-autopilot prepare-autopilot-test.sh

=== removed file 'tests/gallery-app-autopilot/tslist.auto'
--- tests/gallery-app-autopilot/tslist.auto	2013-08-30 17:40:26 +0000
+++ tests/gallery-app-autopilot/tslist.auto	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
--
-  discovery_cmd: autopilot-list gallery_app
-  test_cmd: autopilot-run gallery_app.tests.{}
-

=== added directory 'tests/health-check'
=== added file 'tests/health-check/health-check-test-get-pids.py'
--- tests/health-check/health-check-test-get-pids.py	1970-01-01 00:00:00 +0000
+++ tests/health-check/health-check-test-get-pids.py	2014-11-14 15:22:01 +0000
@@ -0,0 +1,38 @@
+#!/usr/bin/python3
+
+import os
+import psutil
+import platform
+
+basedir = os.path.dirname(__file__)
+default_threshold_path = os.path.join(
+    os.path.join(basedir, 'thresholds'), platform.machine())
+
+ignore_procs = [
+    'health-check', 'init', 'cat', 'vi', 'emacs', 'getty', 'csh', 'bash',
+    'sh', 'powerd', 'thermald', 'mpdecision', 'polkitd', 'whoopsie',
+    'mediascanner-service', 'window-stack-bridge', 'dconf-service',
+    'pulseaudio', 'hud-service', 'indicator-bluetooth-service',
+    'indicator-location-service', 'indicator-sound-service',
+    'indicator-secret-agent', 'mtp-server', 'address-book-service',
+    'dnsmasq', 'systemd-logind', 'systemd-udevd']
+
+with open(os.path.join(basedir, 'procmapping.txt'), 'w') as mapping:
+    procnames = {}
+    for p in psutil.process_iter():
+        try:
+            proc = p.as_dict(attrs=['pid', 'name'])
+            if os.getpgid(proc['pid']) != 0:
+                procname = os.path.basename(proc['name'])
+                fname = os.path.join(
+                    default_threshold_path, procname + ".threshold")
+                count = procnames.get(procname, 0)
+                procnames[procname] = count + 1
+                if count > 0:
+                    procname = '%s_%d' % (procname, count)
+                if not proc['name'] in ignore_procs:
+                    if os.path.isfile(fname):
+                        mapping.write('%s:%d\n' % (procname, proc['pid']))
+                        print(procname)
+        except:
+            pass

=== added file 'tests/health-check/health-check-test-pid.py'
--- tests/health-check/health-check-test-pid.py	1970-01-01 00:00:00 +0000
+++ tests/health-check/health-check-test-pid.py	2014-11-14 15:22:01 +0000
@@ -0,0 +1,198 @@
+#!/usr/bin/python3
+#
+#
+# Copyright (C) 2013 Canonical
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY 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, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+#
+#
+# Syntax:
+# 	health-check-test-pid.py pid [ path-to-threshold-files ]
+#
+# The process name is resolved and the tool will use a
+# `procname`.threshold file to compare against.  If this file does not exist,
+# default.threshold is used.
+#
+
+import json
+import os
+import subprocess
+import sys
+import psutil
+import platform
+
+#
+# Default test run durations in seconds
+#
+default_duration = 60
+
+default_threshold_path = os.path.join(
+    os.path.join(os.path.dirname(__file__), 'thresholds'), platform.machine())
+
+default_pass_unknown_process = True
+
+
+def read_threshold(procname):
+    """Parse thresholds file.
+
+    lines starting with '#' are comments
+    format is: key value, e.g.
+       health-check.cpu-load.cpu-load-total.total-cpu-percent  0.5
+       health-check.cpu-load.cpu-load-total.user-cpu-percent   0.5
+       health-check.cpu-load.cpu-load-total.system-cpu-percent 0.5
+    """
+    fname = default_threshold_path + "/" + procname + ".threshold"
+    thresholds = {}
+    n = 0
+
+    with open(fname) as file:
+        for line in file:
+            n = n + 1
+            if len(line) > 1 and not line.startswith("#"):
+                tmp = line.split()
+                if len(tmp) == 2:
+                    thresholds[tmp[0]] = tmp[1]
+                else:
+                    sys.stderr.write(
+                        "Threshold file %s line %d format error" % (fname, n))
+
+    return thresholds
+
+
+def check_threshold(data, key, fullkey, threshold):
+    """Locate a threshold in the JSON data, compare it to the threshold"""
+
+    try: