Merge lp:ubuntu-automation-test-harness/dev into lp:ubuntu-automation-test-harness

[Max Brustkern]

Merging working version into trunk for use in kernel backport testing.

[Max Brustkern (nuclearbob)]

review: Approve

=== removed file '.profile'
--- .profile	2012-04-06 20:13:15 +0000
+++ .profile	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-export UQT_VM_TOOLS=/opt/canonical.com/ubuntu-qa-tools/vm-tools
-export DISPLAY=""

=== modified file 'Makefile'
--- Makefile	2012-03-29 20:14:50 +0000
+++ Makefile	2012-05-09 00:33:18 +0000
@@ -1,4 +1,15 @@
 PYC_PATTERN?=*.pyc
+all: client uath_sudoers
+
+client:
+	cd ubuntu-automation-test-harness-client ; make
+
+uath_sudoers:
+	ls examples | grep -v "~$$" | grep -v "\.pyc$$" | sed 's/^/ALL ALL = (uath) NOPASSWD: \/usr\/share\/uath\/examples\//' > uath_sudoers
 
 clean:
 	find . -name "$(PYC_PATTERN)" -delete
+	cd ubuntu-automation-test-harness-client ; make clean
+	rm uath_sudoers
+
+.PHONY: client clean

=== modified file 'TODO'
--- TODO	2012-04-09 19:43:57 +0000
+++ TODO	2012-05-09 00:33:18 +0000
@@ -1,6 +1,7 @@
 # Mon 26 Mar 2012 01:48:25 PM EDT Joe Talbott <[e-mail]>
 
 1. Write/Implement
+  * make sure a new Result object is created for each suite.
   * add support for 'run_as'.
   * add proper support for testcase types as we currently only support
     userland.
@@ -18,9 +19,8 @@
     # proposed layout of UATH directory
     /var/uath/
       master.run
-      suite_one/ # to be created by runner
-        # fetch suite_one into here (currently this is done one level up.
-      suite_two/ # to be created by runner
+      suite_one/ # the Runner will create this and run the fetch_cmd in here
+      suite_two/ # the Runner will create this and run the fetch_cmd in here
         suite_two/ # fetched
           test_one/
             test_one.py

=== renamed file 'main.py' => 'client.py'
--- main.py	2012-04-10 20:42:15 +0000
+++ client.py	2012-05-09 00:33:18 +0000
@@ -1,109 +1,113 @@
 #!/usr/bin/env python
 
 import logging
+import platform
 import sys
 
-from uath.runner import Runner
-from uath.state_agent import StateAgentYAML
-from uath.result import Result, ResultYAML
+from uath.client.runner import Runner
+from uath.client.state_agent import StateAgentYAML
+from uath.client.result import Result, ResultYAML, ResultJSON
 
-from uath.common import DEFAULT_STATE_FILE
-from uath import exceptions
+from uath.client.common import DEFAULT_STATE_FILE
+from uath.client import exceptions
 
 def process_cmdline_argparse():
-  """
-  Process the command line arguments.
-  """
-
-  # requires Python2.7+
-  import argparse
-
-  parser = argparse.ArgumentParser(description='Ubuntu Automation Testing Harness')
-  parser.add_argument('--resume', action='store_true', help='Continue a previous run.  Used after a reboot')
-  parser.add_argument('-s', '--state-file', help='File to use for storing state (default "%s"' % DEFAULT_STATE_FILE)
-  parser.add_argument('-f', '--format', choices=['text', 'yaml'], default='yaml', help='Output format (default "yaml")')
-  parser.add_argument('-t', '--testdir', default='/var/uath', help='Main test directory')
-  parser.add_argument('-r', '--runlist', default='master.run', help='runlist file name')
-  parser.add_argument('-o', '--output', help='write output to this file')
-  parser.add_argument('-a', '--append', action='store_true', help='append to output')
-  parser.add_argument('-d', '--debug', action='store_true', help='Print debugging output')
-
-  args = parser.parse_args()
-
-  return args
+    """
+    Process the command line arguments.
+    """
+
+    # requires Python2.7+
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Ubuntu Automation Testing Harness')
+    parser.add_argument('--resume', action='store_true', help='Continue a previous run.  Used after a reboot')
+    parser.add_argument('-s', '--state-file', help='File to use for storing state (default "%s"' % DEFAULT_STATE_FILE)
+    parser.add_argument('-f', '--format', choices=['text', 'yaml', 'json'], default='yaml', help='Output format (default "yaml")')
+    parser.add_argument('-t', '--testdir', default='/var/lib/uath', help='Main test directory')
+    parser.add_argument('-r', '--runlist', default='master.run', help='runlist file name')
+    parser.add_argument('-o', '--output', help='write output to this file')
+    parser.add_argument('-a', '--append', action='store_true', help='append to output')
+    parser.add_argument('-d', '--debug', action='store_true', help='Print debugging output')
+
+    args = parser.parse_args()
+
+    return args
 
 # TODO: write <2.7 optparse version and set based on version of python
 #       being used.
 process_cmdline = process_cmdline_argparse
 
 def exit(returncode, msg):
-  print msg
-  sys.exit(returncode)
+    print msg
+    sys.exit(returncode)
 
 def setup_logging(debug=False):
-  if debug:
-    level = logging.DEBUG
-  else:
-    level = logging.WARNING
+    if debug:
+        level = logging.DEBUG
+    else:
+        level = logging.WARNING
 
-  logging.basicConfig(level=level,
-      format='%(asctime)s - %(levelname)s - %(message)s')
+    logging.basicConfig(level=level,
+                        format='%(asctime)s - %(levelname)s - %(message)s')
 
 def main():
-  """
-  The main driver for the 'uath' application.
-  """
-
-  args = process_cmdline()
-
-  setup_logging(args.debug)
-
-  logging.debug(args)
-
-  """
-  print args
-  import sys
-  sys.exit(0)
-  """
-  resume = args.resume
-  state_file = args.state_file
-  testdir = args.testdir
-  runlist = args.runlist
-  output = args.output
-
-  if args.append:
-    open_flags = 'a'
-  else:
-    open_flags = 'w'
-
-  # Redirect stdout to a file if requested.
-  if output:
+    """
+    The main driver for the 'uath' application.
+    """
+
+    args = process_cmdline()
+
+    setup_logging(args.debug)
+
+    logging.debug(args)
+    logging.info(platform.uname())
+
+    """
+    print args
+    import sys
+    sys.exit(0)
+    """
+    resume = args.resume
+    state_file = args.state_file
+    testdir = args.testdir
+    runlist = args.runlist
+    output = args.output
+
+    if args.append:
+        open_flags = 'a'
+    else:
+        open_flags = 'w'
+
+    # Redirect stdout to a file if requested.
+    if output:
+        try:
+            sys.stdout = open(output, open_flags)
+        except IOError as e:
+            exit(e.errno, e)
+
+    if args.format == 'text':
+        result_class = Result
+    elif args.format == 'json':
+        result_class = ResultJSON
+    else:
+        result_class = ResultYAML
+
+    state_agent = StateAgentYAML(state_file=state_file)
     try:
-      sys.stdout = open(output, open_flags)
-    except IOError as e:
-      exit(e.errno, e)
-
-  if args.format == 'text':
-    result_class = Result
-  else:
-    result_class = ResultYAML
-
-  state_agent = StateAgentYAML(state_file=state_file)
-  try:
-    runner = Runner(state_agent=state_agent, result_class=result_class,
-        runlist=runlist, resume=resume, testdir=testdir)
-  except (exceptions.BadDir, exceptions.MissingFile) as e:
-    errno = 1
-
-    if hasattr(e, 'errno'):
-      errno = e.errno
-
-    exit(errno, e)
-
-  if resume:
-    runner.load_state()
-
-  runner.run()
+        runner = Runner(state_agent=state_agent, result_class=result_class,
+                        runlist=runlist, resume=resume, testdir=testdir)
+    except (exceptions.BadDir, exceptions.MissingFile) as e:
+        errno = 1
+
+        if hasattr(e, 'errno'):
+            errno = e.errno
+
+        exit(errno, e)
+
+    if resume:
+        runner.load_state()
+
+    runner.run()
 
 if __name__ == "__main__":
-  main()
+    main()

=== modified file 'debian/changelog'
--- debian/changelog	2012-04-11 13:22:05 +0000
+++ debian/changelog	2012-05-09 00:33:18 +0000
@@ -1,3 +1,828 @@
+ubuntu-automation-test-harness (0.1ubuntu266) precise; urgency=low
+
+  * vm-start runs fine on a started vm, so always run it as part of
+    activecheck debcommit
+
+ -- Max Brustkern <[e-mail]>  Thu, 03 May 2012 10:38:56 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu265) precise; urgency=low
+
+  * Changed vm-wait to run all the time to make sure ssh is up
+
+ -- Max Brustkern <[e-mail]>  Thu, 03 May 2012 09:28:44 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu264) precise; urgency=low
+
+  * Removed permissions change from postinstall since it breaks SSH key
+
+ -- Max Brustkern <[e-mail]>  Wed, 02 May 2012 17:51:54 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu263) precise; urgency=low
+
+  * Fixed typo
+
+ -- Max Brustkern <[e-mail]>  Wed, 02 May 2012 14:38:20 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu262) precise; urgency=low
+
+  * Added file this time
+
+ -- Max Brustkern <[e-mail]>  Wed, 02 May 2012 14:35:38 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu261) precise; urgency=low
+
+  * Fixed exception import
+
+ -- Max Brustkern <[e-mail]>  Wed, 02 May 2012 14:30:17 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu260) precise; urgency=low
+
+  * Updated permissions to facilitate non-uath user use
+
+ -- Max Brustkern <[e-mail]>  Wed, 02 May 2012 12:33:45 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu259) precise; urgency=low
+
+  * Corrected exceptions
+
+ -- Max Brustkern <[e-mail]>  Wed, 02 May 2012 10:29:46 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu258) precise; urgency=low
+
+  * Resolved changes
+
+ -- Max Brustkern <[e-mail]>  Wed, 02 May 2012 09:53:20 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu257) precise; urgency=low
+
+  * Actually saved changes this time
+
+ -- Max Brustkern <[e-mail]>  Wed, 02 May 2012 09:24:50 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu256) precise; urgency=low
+
+  * Changed runargs to _runargs
+
+ -- Max Brustkern <[e-mail]>  Wed, 02 May 2012 08:56:51 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu255) precise; urgency=low
+
+  * Better handle missing tc_control files
+
+ -- Joe Talbott <[e-mail]>  Tue, 01 May 2012 17:30:58 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu254) precise; urgency=low
+
+  * Updated client dependencies
+
+ -- Max Brustkern <[e-mail]>  Tue, 01 May 2012 16:46:40 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu253) precise; urgency=low
+
+  * Running client as root
+
+ -- Max Brustkern <[e-mail]>  Tue, 01 May 2012 16:14:22 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu252) precise; urgency=low
+
+  * Updated documentation a lot, got some of it into correct column
+    limit; changed iso to image in test runner; added variant to test
+    runner
+
+ -- Max Brustkern <[e-mail]>  Tue, 01 May 2012 15:16:50 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu251) precise; urgency=low
+
+  * Updated Catalog documentation
+
+ -- Max Brustkern <[e-mail]>  Tue, 01 May 2012 13:18:30 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu250) precise; urgency=low
+
+  * Updated documentation further and corrected classes to use private
+    methods
+
+ -- Max Brustkern <[e-mail]>  Tue, 01 May 2012 13:07:29 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu249) precise; urgency=low
+
+  * Updated documentation further and corrected classes to use private
+    methods
+
+ -- Max Brustkern <[e-mail]>  Tue, 01 May 2012 13:06:44 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu248) precise; urgency=low
+
+  * Updated documentation further and corrected classes to use private
+    methods
+
+ -- Max Brustkern <[e-mail]>  Tue, 01 May 2012 13:03:44 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu247) precise; urgency=low
+
+  * Updated documentation further and corrected classes to use private
+    methods
+
+ -- Max Brustkern <[e-mail]>  Tue, 01 May 2012 13:00:06 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu246) precise; urgency=low
+
+  * Updated documentation and moved methods around
+
+ -- Max Brustkern <[e-mail]>  Tue, 01 May 2012 11:24:09 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu245) precise; urgency=low
+
+  * Added exception when vm-wait times out
+
+ -- Max Brustkern <[e-mail]>  Mon, 30 Apr 2012 18:50:36 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu244) precise; urgency=low
+
+  * Added vm-wait check to VMToolsKVM startup
+
+ -- Max Brustkern <[e-mail]>  Mon, 30 Apr 2012 17:38:10 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu243) precise; urgency=low
+
+  * Made changes to update things to precise
+
+ -- Max Brustkern <[e-mail]>  Fri, 27 Apr 2012 12:32:27 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu242) precise; urgency=low
+
+  * Updated current example scripts and removed outdated ones
+
+ -- Max Brustkern <[e-mail]>  Fri, 27 Apr 2012 09:29:30 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu241) precise; urgency=low
+
+  * Corrected suggested command for no vm-tools config file
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 17:03:07 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu240) precise; urgency=low
+
+  * Corrected error handling for no hvm support
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 16:58:36 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu239) precise; urgency=low
+
+  * Updated vm-tools config to handle non-standard uath user home
+    directory better
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 16:56:26 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu238) precise; urgency=low
+
+  * Fixed script to remove debug argument print
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 16:46:58 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu237) precise; urgency=low
+
+  * Updated postinst to handle non-standard uath user home directory
+    better
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 16:43:15 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu236) precise; urgency=low
+
+  * Throw an exception when no vm-tools config file exists
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 16:37:31 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu235) precise; urgency=low
+
+  * Updated postinst to handle non-standard uath user home directory
+    better
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 16:18:44 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu234) precise; urgency=low
+
+  * Updated script to better deal with failure to create virtual machine
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 16:12:57 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu233) precise; urgency=low
+
+  * Fixed no-destroy to no_destroy
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 16:04:54 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu232) precise; urgency=low
+
+  * Added check for no HVM support
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 15:34:01 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu231) precise; urgency=low
+
+  * Made server default install type
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 14:58:38 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu230) precise; urgency=low
+
+  * Added run_uath_tests.py master script
+
+ -- Max Brustkern <[e-mail]>  Thu, 26 Apr 2012 14:52:11 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu229) precise; urgency=low
+
+  * Initial draft of output processing for vm creation
+
+ -- Max Brustkern <[e-mail]>  Wed, 25 Apr 2012 19:14:57 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu228) precise; urgency=low
+
+  * Updated output handling
+
+ -- Max Brustkern <[e-mail]>  Wed, 25 Apr 2012 16:47:53 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu227) precise; urgency=low
+
+  * Removed shell=True
+
+ -- Max Brustkern <[e-mail]>  Wed, 25 Apr 2012 13:13:29 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu226) precise; urgency=low
+
+  * Updated package to use new vm-tools package which places all
+    necessary scripts in /usr/bin
+
+ -- Max Brustkern <[e-mail]>  Tue, 24 Apr 2012 17:59:21 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu225) precise; urgency=low
+
+  * Removed DISPLAY clearing from .profile since vm-new has the -v
+    option now
+
+ -- Max Brustkern <[e-mail]>  Tue, 24 Apr 2012 17:31:33 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu224) precise; urgency=low
+
+  * Added -v option to vm-new call
+
+ -- Max Brustkern <[e-mail]>  Tue, 24 Apr 2012 17:27:24 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu223) precise; urgency=low
+
+  * Changed exit status conditions for client
+
+ -- Max Brustkern <[e-mail]>  Tue, 24 Apr 2012 16:43:45 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu222) precise; urgency=low
+
+  * Added machine info to client script
+
+ -- Max Brustkern <[e-mail]>  Tue, 24 Apr 2012 16:10:35 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu221) precise; urgency=low
+
+  * Added machine info to client script
+
+ -- Max Brustkern <[e-mail]>  Tue, 24 Apr 2012 16:10:27 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu220) oneiric; urgency=low
+
+  * Adding source format files
+
+ -- Max Brustkern <[e-mail]>  Mon, 23 Apr 2012 10:13:00 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu219) oneiric; urgency=low
+
+  * Fixed argument order error when calling client
+
+ -- Max Brustkern <[e-mail]>  Sat, 21 Apr 2012 01:05:54 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu218) oneiric; urgency=low
+
+  * Changed indention in client script and added json output support
+
+ -- Max Brustkern <[e-mail]>  Fri, 20 Apr 2012 17:59:23 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu217) oneiric; urgency=low
+
+  * Removed sudoers file from install pending further testing
+
+ -- Max Brustkern <[e-mail]>  Thu, 19 Apr 2012 17:54:20 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu216) oneiric; urgency=low
+
+  * Updated example syntax
+
+ -- Max Brustkern <[e-mail]>  Thu, 19 Apr 2012 17:51:39 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu215) oneiric; urgency=low
+
+  * Fixed sudoers syntax
+
+ -- Max Brustkern <[e-mail]>  Thu, 19 Apr 2012 17:45:37 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu214) oneiric; urgency=low
+
+  * Implemented initial logging and updated example
+
+ -- Max Brustkern <[e-mail]>  Thu, 19 Apr 2012 17:31:05 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu213) oneiric; urgency=low
+
+  * Added sudoers file
+
+ -- Max Brustkern <[e-mail]>  Thu, 19 Apr 2012 15:59:08 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu212) oneiric; urgency=low
+
+  * Changed default iso type to mini since desktop seems to not run
+    latecommand until a user logs in
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 21:38:57 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu211) oneiric; urgency=low
+
+  * Fixed error in test runner
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 19:35:31 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu210) oneiric; urgency=low
+
+  * Added new example script
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 18:18:02 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu209) oneiric; urgency=low
+
+  * Added timeout to example test case since it is now mandatory
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 17:55:47 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu208) oneiric; urgency=low
+
+  * Improved command handling in run function
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 17:51:35 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu207) oneiric; urgency=low
+
+  * Fixed indentation typos and added /var/log/uath directory to client
+    installation
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 17:19:06 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu206) oneiric; urgency=low
+
+  * Updated example to not use precise mini iso
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 16:06:31 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu205) oneiric; urgency=low
+
+  * Updated includes and module init files
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 16:05:52 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu204) oneiric; urgency=low
+
+  * Fixed a typo and added creation of /var/log/uath to packaging
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 14:56:37 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu203) oneiric; urgency=low
+
+  * Made action requires in testcase
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 10:54:43 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu202) oneiric; urgency=low
+
+  * Cleaned up named arguments, removed env from command running,
+    removed relative imports
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 10:36:07 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu201) oneiric; urgency=low
+
+  * Changed SUCCESS to PASS and FAILUE to FAIL
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 10:16:52 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu200) oneiric; urgency=low
+
+  * Made timeout for testcase mandatory
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 09:51:43 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu199) oneiric; urgency=low
+
+  * Updated indentation: Changed default spacing from 2 to 4 spaces,
+    continued multiline function arguments after parentheses, spaces
+    multiline lists after opening bracket, used 4 space to indent
+    multiline dictionaries and tuples, 80 column limit exceed in some
+    cases (may fix in another pass,) if you see anything you don't agree
+    with, let me know and I'll keep it in mind in the future
+
+ -- Max Brustkern <[e-mail]>  Wed, 18 Apr 2012 09:47:24 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu198) oneiric; urgency=low
+
+  * Put response back in
+
+ -- Max Brustkern <[e-mail]>  Tue, 17 Apr 2012 10:05:03 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu197) precise; urgency=low
+
+  * Collapse client package installation and post-installation to one
+    command
+
+ -- Max Brustkern <[e-mail]>  Mon, 16 Apr 2012 19:50:27 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu196) precise; urgency=low
+
+  * Set TinySQLiteCatalog to autocommit
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 19:49:59 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu195) precise; urgency=low
+
+  * Added batch mode to scp commands
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 19:15:59 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu194) precise; urgency=low
+
+  * Updated example and code based on testing
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 18:18:46 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu193) precise; urgency=low
+
+  * Updated example and code based on testing
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 18:17:53 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu192) precise; urgency=low
+
+  * Updated example and code based on testing
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 17:45:10 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu191) precise; urgency=low
+
+  * Cleaned up based on testing
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 15:27:22 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu190) precise; urgency=low
+
+  * Cleaned up syntax
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 14:47:23 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu189) precise; urgency=low
+
+  * Made some changes so most methods that aren't returning an object
+    should be returning a boolean value and modified the example
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 14:44:35 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu188) precise; urgency=low
+
+  * Updated example and client package
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 14:27:09 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu187) precise; urgency=low
+
+  * Updated postinstall files
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 14:17:30 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu186) precise; urgency=low
+
+  * Updated example and setup vm-tools VMs to install python-yaml by
+    default
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 14:05:12 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu185) precise; urgency=low
+
+  * Added example for provisioning a VM and running a test
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 11:50:42 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu184) precise; urgency=low
+
+  * Updated Makefile to create python modules properly with __init__.py
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 11:37:00 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu183) precise; urgency=low
+
+  * Changing make file to build uath module properly for client
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 11:25:50 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu182) precise; urgency=low
+
+  * Adjusting build to fix error when using pbuilder
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 10:48:28 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu181) precise; urgency=low
+
+  * Adjusting build to fix error when using pbuilder
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 10:46:37 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu180) precise; urgency=low
+
+  * Adjusting build to fix error when using pbuilder
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 10:45:19 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu179) precise; urgency=low
+
+  * Updated client packaging
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 10:32:12 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu178) precise; urgency=low
+
+  * Updating client packaging
+
+ -- Max Brustkern <[e-mail]>  Fri, 13 Apr 2012 10:01:29 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu177) precise; urgency=low
+
+  * Changed copy command for client examples
+
+ -- Max Brustkern <[e-mail]>  Thu, 12 Apr 2012 18:01:06 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu176) precise; urgency=low
+
+  * Updated examples in client deb
+
+ -- Max Brustkern <[e-mail]>  Thu, 12 Apr 2012 17:57:43 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu175) precise; urgency=low
+
+  * Made additional changes to downloadfiles, still broken
+
+ -- Max Brustkern <[e-mail]>  Thu, 12 Apr 2012 17:43:51 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu174) precise; urgency=low
+
+  * Changed client Makefile to install uath.client instead of just uath
+
+ -- Max Brustkern <[e-mail]>  Thu, 12 Apr 2012 17:22:21 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu173) precise; urgency=low
+
+  * Renamed copyfile to uploadfiles, began implementation of
+    downloadfiles
+
+ -- Max Brustkern <[e-mail]>  Thu, 12 Apr 2012 17:21:07 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu172) precise; urgency=low
+
+  * Implemented installclient for VMToolsKVM
+
+ -- Max Brustkern <[e-mail]>  Thu, 12 Apr 2012 16:58:39 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu171) precise; urgency=low
+
+  * Add start_time and time_delta to results
+
+ -- Joe Talbott <[e-mail]>  Thu, 12 Apr 2012 16:55:48 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu170) precise; urgency=low
+
+  * Update uath_howto.txt
+
+ -- Joe Talbott <[e-mail]>  Thu, 12 Apr 2012 16:38:31 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu169) precise; urgency=low
+
+  * Move /var/uath to /var/lib/uath and fix client examples
+
+ -- Joe Talbott <[e-mail]>  Thu, 12 Apr 2012 16:30:09 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu168) precise; urgency=low
+
+  * move client code into its own subdirectory
+
+ -- Joe Talbott <[e-mail]>  Thu, 12 Apr 2012 16:17:14 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu167) oneiric; urgency=low
+
+  * Adding distribute tarball to source because buildds can't download
+    it
+
+ -- Max Brustkern <[e-mail]>  Thu, 12 Apr 2012 11:36:27 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu166) precise; urgency=low
+
+  * Update debian/postinst for new name client.py and fix self_test.py
+    to output nosetest instructions.
+
+ -- Joe Talbott <[e-mail]>  Thu, 12 Apr 2012 10:32:26 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu165) precise; urgency=low
+
+  * Rename main.py to client.py and update README
+
+ -- Joe Talbott <[e-mail]>  Thu, 12 Apr 2012 10:27:36 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu164) precise; urgency=low
+
+  * Cleanup /etc/rc.local handling
+
+ -- Joe Talbott <[e-mail]>  Thu, 12 Apr 2012 09:17:28 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu163) oneiric; urgency=low
+
+  * Attempting to get build working in pbuilder
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 18:45:10 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu162) oneiric; urgency=low
+
+  * Attempting to get build working in pbuilder
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 18:40:55 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu161) oneiric; urgency=low
+
+  * Attempting to get build working in pbuilder
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 18:37:45 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu160) oneiric; urgency=low
+
+  * Attempting to use correct package name for build-dep
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 18:11:56 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu159) oneiric; urgency=low
+
+  * Adding debuild build-dep
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 18:09:10 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu158) oneiric; urgency=low
+
+  * Trying rule override to use python build system and Makefile
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 18:05:50 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu157) oneiric; urgency=low
+
+  * Additional changes to support inner package
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 18:00:57 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu156) oneiric; urgency=low
+
+  * Additional changes to support inner package
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:50:46 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu155) oneiric; urgency=low
+
+  * Made possibly final changes to inner package Makefile
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:44:51 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu154) oneiric; urgency=low
+
+  * Made changes to inner package Makefile
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:37:56 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu153) oneiric; urgency=low
+
+  * Made getroot executable
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:35:25 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu152) oneiric; urgency=low
+
+  * Made changes to inner package Makefile
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:34:30 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu151) oneiric; urgency=low
+
+  * Made changes to inner package Makefile
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:32:57 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu150) oneiric; urgency=low
+
+  * Added Makefile instead of Makefile~
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:28:33 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu149) oneiric; urgency=low
+
+  * bzr removed file instead of just removing it
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:26:51 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu148) oneiric; urgency=low
+
+  * Created initial attempt at inner package
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:25:53 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu147) oneiric; urgency=low
+
+  * Moving back to a single package; will build the client package
+    separately from the Makefile
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 17:17:13 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu146) precise; urgency=low
+
+  * Treat timeouts as errors
+
+ -- Joe Talbott <[e-mail]>  Wed, 11 Apr 2012 16:27:31 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu145) oneiric; urgency=low
+
+  * Trying different method of target-dependent override_dh_auto_build
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 16:20:53 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu144) oneiric; urgency=low
+
+  * Trying target-dependent override_dh_auto_build
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 16:18:29 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu143) oneiric; urgency=low
+
+  * Trying override_dh_auto_build again
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 16:15:04 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu142) oneiric; urgency=low
+
+  * Trying override_dh_auto_build again
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 16:12:13 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu141) oneiric; urgency=low
+
+  * Trying override_dh_auto_build
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 16:09:25 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu140) oneiric; urgency=low
+
+  * Trying override_dh_auto_install stanza for client package only
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 15:55:34 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu139) oneiric; urgency=low
+
+  * Trying override_dh_auto_install stanza
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 15:44:03 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu138) oneiric; urgency=low
+
+  * Attempting to add usr dir to install files
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 15:39:01 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu137) oneiric; urgency=low
+
+  * Retrying package split to get build differences
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 15:28:49 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu136) oneiric; urgency=low
+
+  * Attempting to get the package building correctly again
+
+ -- Max Brustkern <[e-mail]>  Wed, 11 Apr 2012 15:22:27 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu135) precise; urgency=low
+
+  * Add better results indication and tests
+
+ -- Joe Talbott <[e-mail]>  Wed, 11 Apr 2012 15:11:57 -0400
+
+ubuntu-automation-test-harness (0.1ubuntu134) precise; urgency=low
+
+  * clean up uath/self_test.py
+
+ -- Joe Talbott <[e-mail]>  Wed, 11 Apr 2012 11:48:14 -0400
+
 ubuntu-automation-test-harness (0.1ubuntu133) oneiric; urgency=low
 
   * First attempt at split binary configuration

=== renamed file 'debian/ubuntu-automation-test-harness.conffiles' => 'debian/conffiles'
--- debian/ubuntu-automation-test-harness.conffiles	2012-04-11 13:22:05 +0000
+++ debian/conffiles	2012-05-09 00:33:18 +0000
@@ -1,2 +1,1 @@
-var/lib/uath/.profile
 var/lib/uath/.ssh/config

=== modified file 'debian/control'
--- debian/control	2012-04-11 13:22:05 +0000
+++ debian/control	2012-05-09 00:33:18 +0000
@@ -3,7 +3,7 @@
 X-Python-Version: >= 2.5
 Priority: optional
 Maintainer: Max Brustkern <[e-mail]>
-Build-Depends: debhelper, python-all
+Build-Depends: debhelper, python-all, devscripts
 Standards-Version: 3.9.2
 Homepage: https://code.launchpad.net/ubuntu-automation-test-harness
 Vcs-Bzr: https://code.launchpad.net/ubuntu-automation-test-harness
@@ -16,9 +16,3 @@
 Conflicts: ubuntu-automation-test-harness-client
 Description: Ubuntu Automation Test Harness
  Automation framework for testing in Ubuntu
-
-Package: ubuntu-automation-test-harness-client
-Architecture: all
-Depends: ${python:Depends}, python-apt, python-yaml
-Description: Ubuntu Automation Test Harness Client
- Automation framework for testing in Ubuntu, client portion

=== renamed file 'debian/ubuntu-automation-test-harness.dirs' => 'debian/dirs'
--- debian/ubuntu-automation-test-harness.dirs	2012-04-11 13:22:05 +0000
+++ debian/dirs	2012-05-09 00:33:18 +0000
@@ -1,2 +1,3 @@
 var/cache/uath/iso/cache
 var/lib/uath/vm
+var/log/uath

=== renamed file 'debian/ubuntu-automation-test-harness.install' => 'debian/install'
--- debian/ubuntu-automation-test-harness.install	2012-04-11 13:22:05 +0000
+++ debian/install	2012-05-09 00:33:18 +0000
@@ -1,4 +1,6 @@
 uqt-vm-tools.conf etc/uath
-.profile var/lib/uath
+shell-profile etc/uath
 config var/lib/uath/.ssh
 examples usr/share/uath
+ubuntu-automation-test-harness-client_*_all.deb usr/share/uath
+uath/client/examples/master.run usr/share/uath/examples

=== renamed file 'debian/ubuntu-automation-test-harness.postinst' => 'debian/postinst'
--- debian/ubuntu-automation-test-harness.postinst	2012-04-11 13:22:05 +0000
+++ debian/postinst	2012-05-09 00:33:18 +0000
@@ -5,7 +5,7 @@
   # Sane defaults:
 
   [ -z "$SERVER_HOME" ] && SERVER_HOME=/var/lib/uath
-  [ -z "$SERVER_DIRS" ] && SERVER_DIRS="$SERVER_HOME /var/cache/uath"
+  [ -z "$SERVER_DIRS" ] && SERVER_DIRS="$SERVER_HOME /var/cache/uath /var/log/uath"
   [ -z "$SERVER_USER" ] && SERVER_USER=uath
   [ -z "$SERVER_NAME" ] && SERVER_NAME="UATH"
   [ -z "$SERVER_GROUP" ] && SERVER_GROUP=uath
@@ -24,8 +24,8 @@
   do
     if ! dpkg-statoverride --list $DIR >/dev/null
     then
-      chown -R $SERVER_USER:adm $DIR
-      chmod 2755 $DIR
+      chown -R $SERVER_USER:$SERVER_GROUP $DIR
+      chmod 2775 $DIR
     fi
   done
 }
@@ -50,18 +50,19 @@
 
 usersetup
 
-ln -sf /etc/uath/uqt-vm-tools.conf /var/lib/uath/.uqt-vm-tools.conf
-ln -sf /usr/share/pyshared/uath/main.py /usr/bin/uath
+ln -sf /etc/uath/uqt-vm-tools.conf ~uath/.uqt-vm-tools.conf
+ln -sf /etc/uath/shell-profile ~uath/.profile
+ln -sf /usr/share/pyshared/uath/client.py /usr/bin/uath
 
-if ! ([ -f "/var/lib/uath/.ssh/uath" ] && [ -f "/var/lib/uath/.ssh/uath.pub" ])
+if ! ([ -f ~uath/.ssh/uath ] && [ -f ~uath/.ssh/uath.pub ])
 then
   echo "Generating RSA keypair for uath user..." 1>&2
   su - uath -c 'ssh-keygen -t rsa -f ~/.ssh/uath -q -P ""'
 fi
 
-if ! [ -f "/var/lib/uath/.ssh/known_hosts" ]
+if ! [ -f ~uath/.ssh/known_hosts ]
 then
-  su - uath -c "touch /var/lib/uath/.ssh/known_hosts"
+  su - uath -c "touch ~/.ssh/known_hosts"
 fi
 
 dnssetup

=== renamed file 'debian/ubuntu-automation-test-harness.postrm' => 'debian/postrm'
=== modified file 'debian/rules'
--- debian/rules	2012-04-02 19:33:08 +0000
+++ debian/rules	2012-05-09 00:33:18 +0000
@@ -1,4 +1,8 @@
 #!/usr/bin/make -f
 
 %:
-	dh $@ --buildsystem=python_distutils --with=python2 
+	dh $@ --buildsystem=python_distutils --with=python2
+
+override_dh_auto_build:
+	dh_auto_build
+	make

=== added directory 'debian/source'
=== added file 'debian/source/format'
--- debian/source/format	1970-01-01 00:00:00 +0000
+++ debian/source/format	2012-05-09 00:33:18 +0000
@@ -0,0 +1,1 @@
+3.0 (quilt)

=== removed file 'debian/ubuntu-automation-test-harness-client.install'
--- debian/ubuntu-automation-test-harness-client.install	2012-04-11 13:22:05 +0000
+++ debian/ubuntu-automation-test-harness-client.install	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-examples usr/share/uath

=== added file 'distribute-0.6.25.tar.gz'
Binary files distribute-0.6.25.tar.gz	1970-01-01 00:00:00 +0000 and distribute-0.6.25.tar.gz	2012-05-09 00:33:18 +0000 differ
=== removed file 'examples/provision.py'
--- examples/provision.py	2012-04-09 20:46:17 +0000
+++ examples/provision.py	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-#!/usr/bin/python
-
-from uath import UATHException
-import uath.provisioning
-import os.path
-
-try:
-    # Create a catalog to manage VMs
-    # Default catalog configuration attempts to prevent multiple scripts from requesting the same resources
-    # We use a non-default db and lockfile to work around this for the example
-    # For normal use, omit the db and lockfile parameters
-    catalog = uath.provisioning.catalog.TinySQLiteCatalog(db = os.path.expanduser('~/.uath-example-sqlite-catalog'), lockfile = os.path.expanduser('~/.uath-example-catalog'))
-
-    # Request a VM from the catalog
-    # arch can be i386 or amd64/x86_64
-    # installtype is used for automatic iso selection (desktop, server, mini, alternate)
-    # prefix is used by vm-tools to allow opportunities on multiple simultaneous VMs
-    # default is uath, we use a non-default option to avoid collision with existing VMs
-    # machineid is appened to prefix to give unique names
-    # only mini currently works for precise, all should work on release
-    # series can be any supported series, should be all lowercase
-    # no arguments will give i386, desktop, precise, which currently fails to download, but should work on release
-    # For normal use, omit prefix, and the other parameters are optional
-    machine = catalog.request(arch='i386', installtype='mini', prefix='uath-example', series='precise')
-
-    # Run a command
-    # This will check if the machine is provisioned, and provision it if it is not using vm-new
-    # Provisioning may take a while, and currently times out at a max of around 90 minutes
-    # After provision(), the machine will be stopped, so it will be automatically started before running the command
-    # machine.provision() and machine.run() could be run manually before this, but that is not required
-    machine.run('/sbin/ifconfig')
-
-    # Destroy the VM
-    # This uses vm-remove to do a hard stop and then delete the machine
-    machine.destroy()
-
-    # Remove the machine from the catalog and delete it
-    catalog.destroy(machine.machineid)
-    del machine
-
-    # Delete the catalog
-    catalog.delete()
-
-except UATHException as error:
-    print('Exception: ' + error.msg)

=== added file 'examples/run_test_vm.py'
--- examples/run_test_vm.py	1970-01-01 00:00:00 +0000
+++ examples/run_test_vm.py	2012-05-09 00:33:18 +0000
@@ -0,0 +1,105 @@
+#!/usr/bin/python
+
+import argparse
+import getpass
+import grp
+import logging
+import os
+import sys
+import time
+import urllib
+
+from uath import UATHException
+import uath.provisioning
+
+def check_user_group(group='uath'):
+    return grp.getgrnam(group)[2] in os.getgroups()
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(description='Create a virtual machine and run a UATH runlist there.', epilog="For example:\n\t%(prog)s -s oneiric -t server -a i386 /usr/share/uath/examples/master.run 'http://people.canonical.com/~max/max_test.run'", formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('runlists', metavar='runlist', nargs='+', help='URLs of runlist files to run')
+    parser.add_argument('-s', '--series', choices=('hardy', 'lucid', 'natty', 'oneiric', 'precise', 'quantal'), default='oneiric', help='Series to use for VM creation')
+    parser.add_argument('-t', '--type', choices=('desktop', 'server', 'mini', 'alternate'), default='server', help='Install type to use for VM creation')
+    parser.add_argument('-a', '--arch', choices=('i386', 'amd64'), default='i386', help='Architecture to use for VM creation')
+    parser.add_argument('-n', '--no-destroy', action='store_true', help='Preserve VM after tests have run')
+    parser.add_argument('-d', '--debug', action='store_true', help='Enable debug logging')
+    parser.add_argument('-j', '--json', action='store_true', help='Enable json logging (Default is YAML)')
+    return parser
+
+
+def run_test_vm(args = None):
+    if not check_user_group():
+        sys.stderr.write("Error: you are not in the UATH group.\n")
+        sys.stderr.write("If you believe you have properly configured your user account for UATH use, try:\n")
+        sys.stderr.write('    sudo usermod -a -G uath ' + getpass.getuser() + "\n")
+        sys.stderr.write("Otherwise, please run this script as the uath user, i.e.:\n")
+        argv = list(sys.argv)
+        argv[0] = os.path.abspath(__file__)
+        sys.stderr.write("    sudo su - uath -c '" + ' '.join(argv) + "'\n")
+        sys.exit(3)
+
+    if args is None:
+        args = get_parser().parse_args()
+
+    locallogs = []
+    machine = None
+
+    if args.json:
+        extraopts = ' -f json'
+        suffix = '.json'
+    else:
+        extraopts = ''
+        suffix = '.yaml'
+
+    try:
+        catalog = uath.provisioning.catalog.TinySQLiteCatalog()
+        machine = catalog.request(arch=args.arch, debug=args.debug, installtype=args.type, new=True, dlpercentincrement=10, series=args.series)
+        for logger in [machine.logger] + machine.logger.handlers:
+            if logger.level > logging.INFO:
+                logger.setLevel(logging.INFO)
+        machine.installclient()
+        for runlist in args.runlists:
+            locallist = urllib.urlretrieve(runlist)[0]
+            listname = os.path.split(runlist)[1]
+            remotelog = os.path.normpath('/var/log/uath/' + machine.name + '_' + listname + '_tmp')
+            locallog = os.path.normpath('/var/log/uath/' + machine.name + '_' + listname + time.strftime('_%Y-%m-%d_%H-%m-%S', time.gmtime()) + suffix)
+            try:
+                machine.uploadfiles([locallist], os.path.normpath('/tmp'))
+                machine.run('uath' + extraopts + ' -r /tmp/' + os.path.split(locallist)[1] + ' -o ' + remotelog, root=True)
+                machine.downloadfiles([remotelog], locallog)
+                print('Test log copied to ' + locallog)
+                locallogs.append(locallog)
+            except UATHException as error:
+                print('Failed to run test: ' + error.msg)
+            finally:
+                try:
+                    pass
+                    machine.run('rm -f ' + remotelog)
+                except UATHException as error:
+                    print('Failed to cleanup test: ' + error.msg)
+
+    except UATHException as error:
+        print('Exception: ' + error.msg)
+
+    finally:
+        urllib.urlcleanup()
+        if not args.no_destroy and machine is not None:
+            try:
+                machine.destroy()
+            except UATHException as error:
+                print('Failed to destroy machine: ' + error.msg)
+            finally:
+                try:
+                    catalog.destroy(machine.machineid)
+                except UATHException as error:
+                    print('Failed to update catalog: ' + error.msg)
+                finally:
+                    del machine
+        if len(locallogs) != 0:
+            print('Test logs copied to the following files:')
+            print("\t" + "\n\t".join(locallogs))
+
+
+if __name__ == '__main__':
+    run_test_vm()

=== added file 'examples/run_uath_tests.py'
--- examples/run_uath_tests.py	1970-01-01 00:00:00 +0000
+++ examples/run_uath_tests.py	2012-05-09 00:33:18 +0000
@@ -0,0 +1,71 @@
+#!/usr/bin/python
+
+import argparse
+import getpass
+import grp
+import logging
+import os
+import sys
+import time
+import urllib
+
+from uath import UATHException
+import uath.provisioning
+
+def check_user_group(group='uath'):
+    return grp.getgrnam(group)[2] in os.getgroups()
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(description='Provision a machine and run one or more UATH runlists there.', epilog="For example:\n\t%(prog)s -s oneiric -t server -a i386 /usr/share/uath/examples/master.run 'http://people.canonical.com/~max/max_test.run'", formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('runlists', metavar='runlist', nargs='+', help='URLs of runlist files to run')
+    parser.add_argument('-m', '--machinetype', choices=('physical', 'virtual'), default='virtual', help='Type of machine to provision')
+    parser.add_argument('-i', '--image', type=argparse.FileType('r'), help='Image/ISO file to use for installation')
+    parser.add_argument('-k', '--kernel', type=argparse.FileType('r'), help='Kernel file to use for installation')
+    parser.add_argument('-r', '--initrd', type=argparse.FileType('r'), help='InitRD file to use for installation')
+    parser.add_argument('-p', '--preseed', type=argparse.FileType('r'), help='Preseed file to use for installation')
+    parser.add_argument('-s', '--series', choices=('hardy', 'lucid', 'natty', 'oneiric', 'precise', 'quantal'), default='oneiric', help='Series to use for installation')
+    parser.add_argument('-t', '--type', choices=('desktop', 'server', 'mini', 'alternate'), default='server', help='Install type to use for installation')
+    parser.add_argument('-a', '--arch', choices=('i386', 'amd64', 'arm'), default='i386', help='Architecture to use for installation')
+    parser.add_argument('-v', '--variant', help='Variant of architecture, i.e., armel, armhf')
+    parser.add_argument('-n', '--no-destroy', action='store_true', help='Preserve machine after tests have run')
+    parser.add_argument('-d', '--debug', action='store_true', help='Enable debug logging')
+    parser.add_argument('-j', '--json', action='store_true', help='Enable json logging (Default is YAML)')
+    return parser
+
+
+def run_uath_tests(args=None):
+    if not check_user_group():
+        sys.stderr.write("Error: you are not in the UATH group.\n")
+        sys.stderr.write("If you believe you have properly configured your user account for UATH use, try:\n")
+        sys.stderr.write('    sudo usermod -a -G uath ' + getpass.getuser() + "\n")
+        sys.stderr.write("Otherwise, please run this script as the uath user, i.e.:\n")
+        argv = list(sys.argv)
+        argv[0] = os.path.abspath(__file__)
+        sys.stderr.write("    sudo su - uath -c '" + ' '.join(argv) + "'\n")
+        sys.exit(3)
+
+    if args is None:
+        args = get_parser().parse_args()
+
+    if args.machinetype == 'physical':
+        sys.stderr.write("Physical machine provisioning is not supported in this release.\n")
+        sys.stderr.write("Please check the roadmap, as it will be included in a future version.\n")
+        sys.exit(4)
+
+    for option in [args.image, args.kernel, args.initrd, args.preseed]:
+        if option is not None:
+            sys.stderr.write("Custom VM provisioning is not supported in this release.\n")
+            sys.stderr.write("Please check the roadmap, as it will be included in a future version.\n")
+            sys.exit(4)
+
+    if 'arm' in args.arch:
+        sys.stderr.write("ARM support is not included in this release.\n")
+        sys.stderr.write("Please check the roadmap, as it will be included in a future version.\n")
+        sys.exit(4)
+
+    from run_test_vm import run_test_vm
+    run_test_vm(args=args)
+
+if __name__ == '__main__':
+    run_uath_tests()

=== added file 'shell-profile'
--- shell-profile	1970-01-01 00:00:00 +0000
+++ shell-profile	2012-05-09 00:33:18 +0000
@@ -0,0 +1,1 @@
+umask 002

=== added directory 'uath/client'
=== renamed file 'uath/README' => 'uath/client/README'
--- uath/README	2012-04-10 20:49:15 +0000
+++ uath/client/README	2012-05-09 00:33:18 +0000
@@ -79,4 +79,4 @@
 [command: <testcase command>]
 [tc_setup: <testcase setup command>]
 [tc_cleanup: <testcase cleanup command>]
-[reboot: {always, success, never}] # defaults to 'never'
+[reboot: {always, pass, never}] # defaults to 'never'

=== added file 'uath/client/__init__.py'
=== renamed file 'uath/common.py' => 'uath/client/common.py'
--- uath/common.py	2012-04-04 21:52:30 +0000
+++ uath/client/common.py	2012-05-09 00:33:18 +0000
@@ -2,19 +2,20 @@
 Common methods.
 """
 
+import datetime
 import os
 import signal
 import subprocess
 import yaml
 
 
-SUCCESS=0
-FAILURE=1
+PASS=0
+FAIL=1
 ERROR_TIMEOUT=-9
 
 CONFIG = {
-  'DEBUG': False,
-  'TEST_DIR': '/var/uath',
+    'DEBUG': False,
+    'TEST_DIR': '/var/lib/uath',
 }
 
 # Default TestSuite filenames
@@ -22,134 +23,149 @@
 DEFAULT_TSCONTROL='ts_control'
 
 MASTER_RUNLIST="master.run"
-UATH_DIR="/var/uath"
+UATH_DIR=CONFIG['TEST_DIR']
 DEFAULT_STATE_FILE=os.path.join(UATH_DIR, "state.yaml")
 
+RETURN_CODES={'PASS': 0, 'ERROR': -1, 'FAIL': 1}
+
 def do_nothing(obj=None):
-  """
-  Do nothing method used a placeholder for save_state_callbacks.
-  """
-  pass
+    """
+    Do nothing method used a placeholder for save_state_callbacks.
+    """
+    pass
 
 # Inspired by:
 # http://stackoverflow.com/a/3326559
 def run_cmd(command, cwd=None, timeout=0):
 
-  if command is None:
-    return
-
-  class TimeoutAlarm(Exception):
-    pass
-
-  def alarm_handler(signum, frame):
-    raise TimeoutAlarm
-
-  p = subprocess.Popen(command, shell=True, cwd=cwd, stdout=subprocess.PIPE,
-      stderr=subprocess.PIPE)
-
-  if timeout != 0:
-    signal.signal(signal.SIGALRM, alarm_handler)
-    signal.alarm(timeout)
-
-  try:
-    stdout, stderr = p.communicate()
+    if command is None:
+        return
+
+    class TimeoutAlarm(Exception):
+        pass
+
+    def alarm_handler(signum, frame):
+        raise TimeoutAlarm
+
+    start_time = datetime.datetime.now()
+    p = subprocess.Popen(command, shell=True, cwd=cwd, stdout=subprocess.PIPE,
+                         stderr=subprocess.PIPE)
+
     if timeout != 0:
-      signal.alarm(0)
-  except TimeoutAlarm:
-    pids = [p.pid]
-    # Kill p's children too.
-    pids.extend(get_process_children(p.pid))
-
-    for pid in pids:
-      # process might have died before getting to this line
-      # so wrap to avoid OSError: no such process
-      try:
-        os.kill(pid, signal.SIGKILL)
-      except OSError:
-        pass
-    return make_result((command, ERROR_TIMEOUT, '', ''))
-
-  return make_result((command, p.returncode, stdout, stderr))
+        signal.signal(signal.SIGALRM, alarm_handler)
+        signal.alarm(timeout)
+
+    try:
+        stdout, stderr = p.communicate()
+        if timeout != 0:
+            signal.alarm(0)
+    except TimeoutAlarm:
+        pids = [p.pid]
+        # Kill p's children too.
+        pids.extend(get_process_children(p.pid))
+
+        for pid in pids:
+            # process might have died before getting to this line
+            # so wrap to avoid OSError: no such process
+            try:
+                os.kill(pid, signal.SIGKILL)
+            except OSError:
+                pass
+
+        time_delta = datetime.datetime.now() - start_time
+
+        return make_result(command=command,
+                           retcode=ERROR_TIMEOUT,
+                           start_time=str(start_time),
+                           time_delta=str(time_delta),
+                          )
+
+    time_delta = datetime.datetime.now() - start_time
+
+    return make_result(command=command,
+                       retcode=p.returncode,
+                       stdout=stdout,
+                       stderr=stderr,
+                       start_time=str(start_time),
+                       time_delta=str(time_delta),
+                      )
 
 # TODO: it might make sense to have a result object that keeps track of
-# test success, failure, error and serializes it's data.
-def make_result(result):
-  """
-  Turn a tuple of (returncode, stdout, stderr) into a dict.
-  """
-
-  # If result is not a tuple of size 3 return a blank result
-  if len(result) != 4:
-    result = (None, None, '', '')
-
-  res = {
-    'command': result[0],
-    'returncode': result[1],
-    'stdout': result[2],
-    'stderr': result[3]
-  }
-
-  return res
+# test pass, fail, error and serializes it's data.
+def make_result(command, retcode, stdout='', stderr='', start_time='', time_delta=''):
+    """
+    Make a result dictionary.
+    """
+    res = {
+        'command': command,
+        'returncode': retcode,
+        'stdout': stdout,
+        'stderr': stderr,
+        'start_time': start_time,
+        'time_delta': time_delta,
+    }
+
+    return res
 
 def get_process_children(pid):
-  p = subprocess.Popen('ps --no-headers -o pid --ppid %d' % pid, shell=True,
-      stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-  stdout, stderr = p.communicate()
+    p = subprocess.Popen('ps --no-headers -o pid --ppid %d' % pid, shell=True,
+                         stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout, stderr = p.communicate()
 
-  return [int(pid) for pid in stdout.split()]
+    return [int(pid) for pid in stdout.split()]
 
 
 def run_cmd_depricated(command):
-  """
-  Runs 'command' using a shell, so be careful.
-  """
-
-  if command is None:
-    return
-
-  rc = subprocess.call(command, shell=True)
-  if rc != 0:
-    raise Exception("command failed: %s: %d" % (command, rc))
+    """
+    Runs 'command' using a shell, so be careful.
+    """
+
+    if command is None:
+        return
+
+    rc = subprocess.call(command, shell=True)
+    if rc != 0:
+        raise Exception("command failed: %s: %d" % (command, rc))
 
 def parse_control_file(filename, required=None, optional=None):
-  """
-  Parse a control file and only include the items in required and optional.
+    """
+    Parse a control file and only include the items in required and optional.
   
-  If any required items are missing an exception is raised. Optional items
-  that are not in the control file are set to None.
-  """
-  fp = open(filename, 'r')
-
-  data = yaml.load(fp)
-
-  fp.close()
-
-  control_data = {}
-
-  for item in required:
-    control_data[item] = data[item]
-
-  for item in optional:
-    control_data[item] = data.get(item)
-
-  if not required and not optional:
-    control_data = data
-
-  return control_data
+    If any required items are missing an exception is raised. Optional items
+    that are not in the control file are set to None.
+    """
+    fp = open(filename, 'r')
+
+    data = yaml.load(fp)
+
+    fp.close()
+
+    control_data = {}
+
+    for item in required:
+        control_data[item] = data[item]
+
+    for item in optional:
+        control_data[item] = data.get(item)
+
+    if not required and not optional:
+        control_data = data
+
+    return control_data
 
 def debug_print(data, force=False):
-  """
-  Print debugging information if CONFIG['DEBUG'] is defined and True
-  """
-  try:
-    debug = CONFIG['DEBUG']
-  except NameError:
-    debug = False
-
-  debug = debug or force
-
-  if debug:
-    print "DEBUG:", data
-
-  # return True if we printed some output
-  return debug
+    """
+    Print debugging information if CONFIG['DEBUG'] is defined and True
+    """
+    try:
+        debug = CONFIG['DEBUG']
+    except NameError:
+        debug = False
+
+    debug = debug or force
+
+    if debug:
+        print "DEBUG:", data
+
+    # return True if we printed some output
+    return debug

=== renamed directory 'uath/examples' => 'uath/client/examples'
=== modified file 'uath/client/examples/master.run'
--- uath/examples/master.run	2012-04-10 20:42:15 +0000
+++ uath/client/examples/master.run	2012-05-09 00:33:18 +0000
@@ -1,3 +1,3 @@
 ---
 - name: uath_tests
-  fetch_cmd: rm -fr uath_tests && cp -r /usr/share/uath/examples/uath_tests .
+  fetch_cmd: rm -fr uath_tests && cp -r /usr/share/uath/client/examples/uath_tests .

=== modified file 'uath/client/examples/uath_tests/test_one/tc_control'
--- uath/examples/uath_tests/test_one/tc_control	2012-04-10 20:23:50 +0000
+++ uath/client/examples/uath_tests/test_one/tc_control	2012-05-09 00:33:18 +0000
@@ -7,7 +7,7 @@
   1. Expected result 1
   2. Expected result 2
 type: userland
-#timeout: 200
+timeout: 200
 build_cmd: echo "building for test_one"
 tc_setup: echo "setup for test_one"
 tc_cleanup: echo "cleanup for test_one"

=== added file 'uath/client/exceptions.py'
--- uath/client/exceptions.py	1970-01-01 00:00:00 +0000
+++ uath/client/exceptions.py	2012-05-09 00:33:18 +0000
@@ -0,0 +1,7 @@
+#!/usr/bin/python
+
+class BadDir(Exception):
+    pass
+
+class MissingFile(Exception):
+    pass

=== renamed file 'uath/result.py' => 'uath/client/result.py'
--- uath/result.py	2012-04-06 20:40:47 +0000
+++ uath/client/result.py	2012-05-09 00:33:18 +0000
@@ -1,87 +1,110 @@
+import json
 import sys
 import yaml
-import datetime
+
+from common import debug_print
 
 RESULT_FIELD_COUNT = 4
 
 class Result(object):
-  """
-  Result collection class.
-  """
-  def __init__(self, name=None):
-    self.results = []
-    self.status = 'SUCCESS'
-    self.name = name
-
-  def add_result(self, result):
-    """
-    Add a result to the object.
-
-    Note: 'result' is expected to be a dictionary like this:
-    {
-      'command': '',
-      'returncode': 0,
-      'stdout': '',
-      'stderr': '',
-    }
-
-    """
-    if result is None:
-      return
-
-    result['date'] = str(datetime.datetime.now())
-    self.results.append(result)
-
-    if result['returncode'] == 1 and self.status != 'ERROR':
-      self.status = 'FAILURE'
-
-    if result['returncode'] not in [0, 1]:
-      self.status = 'ERROR'
-
-  def result(self, verbose=False):
-    """
-    Output a text based result.
-    """
-    sep = '-'*70
-
-    print sep
-
-    if self.name:
-      print self.name
-      print sep
-
-    for result in self.results:
-      print "command: %s" % result['command']
-      print "returned: %d" % result['returncode']
-
-      if self.status != 'SUCCESS' or verbose and result['stdout'] != '':
-        print "stdout: "
-        print result['stdout']
-
-      if self.status != 'SUCCESS' or verbose and result['stderr'] != '':
-        print "stderr: "
-        print result['stderr']
-
-    print
-    self.clear_results()
-
-  def clear_results(self):
-    # reset the list of results so this object can be reused.
-    self.results = []
-
-    # reset the status, this should be safe since the only places that
-    # should be calling clear_results() is testcase.run(), testsuite.run(),
-    # and runner after attempting to fetch the testsuite.
-    self.status = 'SUCCESS'
-
-  def count_results(self):
-    return len(self.results)
+    """
+    Result collection class.
+    """
+    def __init__(self, name=None):
+        self.results = []
+        self.status = 'PASS'
+        self.name = name
+
+    def add_result(self, result):
+        """
+        Add a result to the object.
+
+        Note: 'result' is expected to be a dictionary like this:
+        {
+            'command': '',
+            'returncode': 0,
+            'stdout': '',
+            'stderr': '',
+            'start_time': '',
+            'time_delta': '',
+        }
+
+        """
+        if result is None:
+            return
+
+        self.results.append(result)
+
+        if result['returncode'] == 1 and self.status != 'ERROR':
+            self.status = 'FAIL'
+
+        if result['returncode'] not in [0, 1]:
+            self.status = 'ERROR'
+
+    def result(self, verbose=False):
+        """
+        Output a text based result.
+        """
+        status = self.status
+        sep = '-'*70
+
+        print sep
+
+        if self.name:
+            print self.name
+            print sep
+
+        for result in self.results:
+            print "command: %s" % result['command']
+            print "returned: %d" % result['returncode']
+            print "started: %s" % result['start_time']
+            print "runtime: %s" % result['time_delta']
+
+            if self.status != 'PASS' or verbose and result['stdout'] != '':
+                print "stdout: "
+                print result['stdout']
+
+            if self.status != 'PASS' or verbose and result['stderr'] != '':
+                print "stderr: "
+                print result['stderr']
+
+        print
+        self.clear_results()
+
+        return status
+
+    def clear_results(self):
+        # reset the list of results so this object can be reused.
+        self.results = []
+
+        # reset the status, this should be safe since the only places that
+        # should be calling clear_results() is testcase.run(), testsuite.run(),
+        # and runner after attempting to fetch the testsuite.
+        self.status = 'PASS'
+
+    def count_results(self):
+        return len(self.results)
 
 class ResultYAML(Result):
-  def result(self, verbose=False):
-
-    if self.results:
-      print "---"
-      yaml.dump(self.results, sys.stdout, default_flow_style=False)
-
-    self.clear_results()
+    def result(self, verbose=False):
+
+        if self.results:
+            print "---"
+            yaml.dump(self.results, sys.stdout, default_flow_style=False)
+
+        status = self.status
+        self.clear_results()
+
+        return status
+
+class ResultJSON(Result):
+    def result(self, verbose=False):
+
+        if self.results:
+            json.dump(self.results, sys.stdout, indent=4)
+
+        status = self.status
+        self.clear_results()
+
+        return status
+

=== renamed file 'uath/runner.py' => 'uath/client/runner.py'
--- uath/runner.py	2012-04-10 15:46:12 +0000
+++ uath/client/runner.py	2012-05-09 00:33:18 +0000
@@ -10,280 +10,318 @@
 import yaml
 
 from common import MASTER_RUNLIST, UATH_DIR, DEFAULT_STATE_FILE
+from common import RETURN_CODES
 
 RC_LOCAL='/etc/rc.local'
 RC_LOCAL_BACKUP='%s-uath.bak' % RC_LOCAL
 
 rc_local_content="""#!/bin/sh
 
-cd /home/josepht/bazaar/uath-dev || exit 1
-python main.py --resume --append -o /var/uath/uath.out
+/usr/bin/uath --resume --append -o /var/lib/uath/uath.out
 """
 
 class Runner(object):
-  """
-  The main runner.
-
-  Parses a master runlist, builds a list of TestSuites, and runs them.
-  """
-
-  status = "NOTRUN"
-  uath_exec_path = '/usr/bin/uath'
-
-  def __init__(self, runlist=MASTER_RUNLIST, result_class=Result,
-      testdir=UATH_DIR, state_agent=None, resume=False):
-
-    self.master_runlist = runlist
-    self.testdir = testdir
-    self.suites = []
-    self.result = result_class()
-    self.result_class = result_class
-    self.state_file = DEFAULT_STATE_FILE
-    self.fetched_suites = {}
-
-    self.state_agent = state_agent or StateAgentYAML()
-
-    # Cleanup the state file if this is supposed to be a fresh run.
-    if not resume:
-      self.state_agent.clean()
-    else:
-      self.reset_rc_local()
-
-    try:
-      os.chdir(self.testdir)
-    except OSError as e:
-      raise exceptions.BadDir(str(e))
-
-    # needs to be run prior to process_master_runlist since that's where
-    # test suites are fetched.
-    self.fetched_suites = self.get_fetched_suites()
-
-    self.process_master_runlist()
-
-  def backup_rc_local(self):
-    """
-    Backup /etc/rc.local if it exists.
-    """
-
-    cmd = None
-
-    if os.path.exists(RC_LOCAL):
-      cmd = ['mv', RC_LOCAL, RC_LOCAL_BACKUP]
-
-    if cmd:
-      subprocess.call(cmd)
-
-  def reset_rc_local(self):
-    """
-    Restore original /etc/rc.local if there is a backup otherwise remove it.
-    """
-    cmd = None
-
-    if os.path.exists(RC_LOCAL_BACKUP):
-      cmd = ['mv', RC_LOCAL_BACKUP, RC_LOCAL]
-    elif os.path.exists(RC_LOCAL):
-      cmd = ['rm', RC_LOCAL]
-
-    if cmd:
-      subprocess.call(cmd)
-
-  def run(self):
-    """
-    Run the test suites we've parsed.
-    """
-
-    # Return value to indicate whether processing of a Runner should
-    # continue.  This is to avoid a shutdown race on reboot cases.
-    keep_going = True
-
-    self.status = "RUN"
-    for suite in self.suites:
-      # Start in self.testdir.
-      os.chdir(self.testdir)
-
-      if not suite.is_done():
-        keep_going = suite.run()
-        if not keep_going:
-          return keep_going
-
-    self.status = "DONE"
-    self.save_state()
-
-    return keep_going
-
-  def add_suite(self, suite):
-    self.suites.append(suite)
-
-  def get_fetched_suites(self):
-    """
-    Return a list of fetched suites from the state_agent.
-    """
-    state = self.state_agent.load_state()
-
-    fetched_suites = []
+    """
+    The main runner.
+
+    Parses a master runlist, builds a list of TestSuites, and runs them.
+    """
+
+    status = "NOTRUN"
+    uath_exec_path = '/usr/bin/uath'
+
+    def __init__(self, runlist=MASTER_RUNLIST, result_class=Result,
+            testdir=UATH_DIR, state_agent=None, resume=False):
+
+        self.master_runlist = runlist
+        self.testdir = testdir
+        self.suites = []
+        self.result = result_class()
+        self.result_class = result_class
+        self.state_file = DEFAULT_STATE_FILE
+        self.fetched_suites = {}
+
+        self.errors = 0
+        self.passes = 0
+        self.failures = 0
+        self.fetch_errors = 0
+
+        self.state_agent = state_agent or StateAgentYAML()
+
+        # Cleanup the state file if this is supposed to be a fresh run.
+        if not resume:
+            self.state_agent.clean()
+        else:
+            self.reset_rc_local()
+
+        try:
+            os.chdir(self.testdir)
+        except OSError as e:
+            raise exceptions.BadDir(str(e))
+
+        # needs to be run prior to process_master_runlist since that's where
+        # test suites are fetched.
+        self.fetched_suites = self.get_fetched_suites()
+
+        self.process_master_runlist()
+
+    def backup_rc_local(self):
+        """
+        Backup /etc/rc.local if it exists.
+        """
+
+        # Ignore permission denied errors since we only care if a reboot is
+        # pending whether or not we can write to RC_LOCAL(_BACKUP).
+        try:
+            os.rename(RC_LOCAL, RC_LOCAL_BACKUP)
+        except OSError as e:
+            if e.errno in [13]:
+                pass
+
+    def reset_rc_local(self):
+        """
+        Restore original /etc/rc.local if there is a backup otherwise remove it.
+        """
+
+        # Ignore permission denied errors since we only care if a reboot is
+        # pending whether or not we can write to RC_LOCAL(_BACKUP).
+        try:
+            if os.path.exists(RC_LOCAL_BACKUP):
+                os.rename(RC_LOCAL_BACKUP, RC_LOCAL)
+            elif os.path.exists(RC_LOCAL):
+                os.remove(RC_LOCAL)
+        except OSError as e:
+            if e.errno in [13]:
+                pass
+
+    def setup_rc_local(self, rc_local=RC_LOCAL):
+        """
+        Setup /etc/rc.local to kick-off a --resume on successful boot.
+        """
+
+        self.rc_local_content = rc_local_content
+
+        fp = open(rc_local, 'w')
+        fp.write(self.rc_local_content)
+        fp.close()
+
+        os.chmod(rc_local, stat.S_IRWXU | stat.S_IROTH | stat.S_IRGRP)
+
+    def run(self):
+        """
+        Run the test suites we've parsed.
+        """
+
+        # Return value to indicate whether processing of a Runner should
+        # continue.  This is to avoid a shutdown race on reboot cases.
+        keep_going = True
+
+        self.status = "RUN"
+        for suite in self.suites:
+            # Start in self.testdir.
+            os.chdir(self.testdir)
+
+            if not suite.is_done():
+                keep_going = suite.run()
+                if not keep_going:
+                    return self.returncode()
+
+                self.errors += suite.errors
+                self.passes += suite.passes
+                self.failures += suite.failures
+
+        self.status = "DONE"
+        self.save_state()
+
+        return self.returncode()
+
+    def add_suite(self, suite):
+        self.suites.append(suite)
+
+    def get_fetched_suites(self):
+        """
+        Return a list of fetched suites from the state_agent.
+        """
+        state = self.state_agent.load_state()
+
+        fetched_suites = []
     
-    if state and 'fetched_suites' in state:
-      fetched_suites = state['fetched_suites']
-
-    return fetched_suites
-
-  def load_state(self):
-    state = self.state_agent.load_state()
-
-    self.master_runlist = state['master_runlist']
-    self.status = state['status']
-    self.result_class = state['result_class']
-
-    self.suites = []
-    for state_suite in state['suites']:
-      suite = TestSuite(name=state_suite['name'],
-          path=self.testdir,
-          result_class=self.result_class,
-          _save_state_callback=self.save_state,
-          _reboot_callback=self.reboot)
-      suite.load_state(state_suite)
-      self.suites.append(suite)
-
-    self.fetched_suites = state['fetched_suites']
-
-  def save_state(self):
-    """
-    Save the list of tests we are to run and whether we've run them.
-    """
-
-    state = {
-        'master_runlist': self.master_runlist,
-        'status': self.status,
-        'result_class': self.result_class,
-        'suites': [],
-        'fetched_suites': self.fetched_suites,
-    }
-
-    for suite in self.suites:
-      state['suites'].append(suite.save_state())
-
-    # hand the state dictionary off to the StateAgent to process
-    self.state_agent.save_state(state)
-
-    return state
-
-  def count_suites(self):
-    return len(self.suites)
-
-  def count_tests(self):
-    tests = 0
-
-    for suite in self.suites:
-      tests += suite.count_tests()
-
-    return tests
-
-  def process_master_runlist(self):
-    """
-    Parse a master runlist building a list of suites from the parsed data.
-    """
-
-    try:
-      fp = open(self.master_runlist, 'r')
-      data = yaml.load(fp)
-      fp.close()
-    except IOError as e:
-      raise exceptions.MissingFile(str(e))
-
-    seen = []
-
-    for suite in data:
-      fetch_cmd = suite['fetch_cmd']
-
-      name = suite['name']
-      includes = suite.get('include_tests')
-      excludes = suite.get('exclude_tests')
-
-      suite_runlist = suite.get('runlist', DEFAULT_TSLIST)
-
-      if name in seen:
-        raise Exception("%s duplicated in runlist" % name)
-
-      # Fetch the testsuite.
-
-      if not os.path.exists(name):
-        os.mkdir(name)
-
-      if name not in  self.fetched_suites:
-        self.result.add_result(run_cmd(fetch_cmd, cwd=name))
-        self.fetched_suites.append(name)
-
-      # If fetch_cmd failed move on to the next testsuite.
-      if self.result.status != 'SUCCESS':
-        self.result.result()
-        continue
-
-      # Create a TestSuite
-      # TODO: pass master.run overrides into the test suite.
-      s = TestSuite(name=name, runlist_file=suite_runlist,
-          includes=includes, excludes=excludes, result=self.result,
-          path=self.testdir, _save_state_callback=self.save_state,
-          _reboot_callback=self.reboot)
-      self.add_suite(s)
-
-    self.result.result()
-
-  def get_next_suite(self):
-    """
-    Return the next suite to be run.
-
-    Mainly used for debugging.
-    """
-
-    suite = None
-
-    for s in self.suites:
-      if not s.is_done():
-        suite = s
-        break
-
-    return suite
-
-  def get_next_test(self):
-    """
-    Return the next test to be run.
-
-    Mainly used for debugging.
-    """
-    return self.get_next_suite().get_next_test()
-
-  def setup_rc_local(self, rc_local='/etc/rc.local'):
-    """
-    Setup /etc/rc.local to kick-off a --resume on successful boot.
-    """
-    # temporary override while developing/testing
-    self.uath_exec_path = '/home/josepht/bazaar/uath-dev'
-    self.rc_local_content = """#!/bin/sh\n\ncd %s || exit 1\npython main.py --resume >>/tmp/uath.out 2>&1 \n""" % self.uath_exec_path
-    self.rc_local_content = """#!/bin/sh\n\necho "I'd be resuming here... >>/var/uath/uath.out 2>&1\n"""
-
-    self.rc_local_content = rc_local_content
-
-    fp = open(rc_local, 'w')
-    fp.write(self.rc_local_content)
-    fp.close()
-
-    os.chmod(rc_local, stat.S_IRWXU | stat.S_IROTH | stat.S_IRGRP)
-
-  def reboot(self):
-    """
-    Reboot the machine.
-
-    Save state, setup /etc/rc.local, and shutdown.
-    """
-
-    self.result.result()
-
-    self.save_state()
-
-    self.backup_rc_local()
-    self.setup_rc_local()
-
-    import subprocess
-    subprocess.call(['shutdown', '-r', 'now'])
-
-    # End of execution
+        if state and 'fetched_suites' in state:
+            fetched_suites = state['fetched_suites']
+
+        return fetched_suites
+
+    def load_state(self):
+        state = self.state_agent.load_state()
+
+        self.master_runlist = state['master_runlist']
+        self.status = state['status']
+        self.result_class = state['result_class']
+
+        self.suites = []
+        for state_suite in state['suites']:
+            suite = TestSuite(name=state_suite['name'],
+                              path=self.testdir,
+                              result_class=self.result_class,
+                              _save_state_callback=self.save_state,
+                              _reboot_callback=self.reboot)
+            suite.load_state(state_suite)
+            self.suites.append(suite)
+
+        self.fetched_suites = state['fetched_suites']
+
+    def save_state(self):
+        """
+        Save the list of tests we are to run and whether we've run them.
+        """
+
+        state = {
+            'master_runlist': self.master_runlist,
+            'status': self.status,
+            'passes': self.passes,
+            'failures': self.failures,
+            'errors': self.errors,
+            'fetch_errors': self.fetch_errors,
+            'result_class': self.result_class,
+            'suites': [],
+            'fetched_suites': self.fetched_suites,
+        }
+
+        for suite in self.suites:
+            state['suites'].append(suite.save_state())
+
+        # hand the state dictionary off to the StateAgent to process
+        self.state_agent.save_state(state)
+
+        return state
+
+    def count_suites(self):
+        return len(self.suites)
+
+    def count_tests(self):
+        tests = 0
+
+        for suite in self.suites:
+            tests += suite.count_tests()
+
+        return tests
+
+    def process_master_runlist(self):
+        """
+        Parse a master runlist building a list of suites from the parsed data.
+        """
+
+        try:
+            fp = open(self.master_runlist, 'r')
+            data = yaml.load(fp)
+            fp.close()
+        except IOError as e:
+            raise exceptions.MissingFile(str(e))
+
+        seen = []
+
+        for suite in data:
+            fetch_cmd = suite['fetch_cmd']
+
+            name = suite['name']
+            includes = suite.get('include_tests')
+            excludes = suite.get('exclude_tests')
+
+            suite_runlist = suite.get('runlist', DEFAULT_TSLIST)
+
+            if name in seen:
+                raise Exception("%s duplicated in runlist" % name)
+
+            # Fetch the testsuite.
+
+            if not os.path.exists(name):
+                os.mkdir(name)
+
+            if name not in  self.fetched_suites:
+                self.result.add_result(run_cmd(fetch_cmd, cwd=name))
+                self.fetched_suites.append(name)
+
+            # If fetch_cmd failed move on to the next testsuite.
+            if self.result.status != 'PASS':
+                self.result.result()
+                self.fetch_errors += 1
+                continue
+
+            # Create a TestSuite
+            # TODO: pass master.run overrides into the test suite.
+            s = TestSuite(name=name, runlist_file=suite_runlist,
+                          includes=includes, excludes=excludes, result=self.result,
+                          path=self.testdir, _save_state_callback=self.save_state,
+                          _reboot_callback=self.reboot)
+            self.add_suite(s)
+
+        self.result.result()
+
+    def get_next_suite(self):
+        """
+        Return the next suite to be run.
+
+        Mainly used for debugging.
+        """
+
+        suite = None
+
+        for s in self.suites:
+            if not s.is_done():
+                suite = s
+                break
+
+        return suite
+
+    def get_next_test(self):
+        """
+        Return the next test to be run.
+
+        Mainly used for debugging.
+        """
+        return self.get_next_suite().get_next_test()
+
+    def reboot(self):
+        """
+        Reboot the machine.
+
+        Save state, setup /etc/rc.local, and shutdown.
+        """
+
+        self.result.result()
+
+        self.save_state()
+
+        self.backup_rc_local()
+        self.setup_rc_local()
+
+        import subprocess
+        subprocess.call(['shutdown', '-r', 'now'])
+
+        # End of execution
+
+    def returncode(self):
+#        if self.errors > 0 or self.fetch_errors:
+#       In the code review, we determined that errors at the suite level should produce a non-zero exit status for the overall process
+        if self.fetch_errors > 0:
+            return RETURN_CODES['ERROR']
+        elif self.failures > 0:
+            return RETURN_CODES['FAIL']
+        else:
+            return RETURN_CODES['PASS']
+
+    def report(self):
+        tests_run = self.passes + self.errors + self.failures
+
+        output = "total: %d, passes: %d, failure: %d, error: %d" % (tests_run, self.passes, self.failures, self.errors + self.fetch_errors)
+
+#        if self.errors > 0 or self.fetch_errors:
+#       In the code review, we determined that errors at the suite level should produce a non-zero exit status for the overall process
+        if self.fetch_errors > 0:
+            result = "ERROR"
+        elif self.failures > 0:
+            result = "FAIL"
+        else:
+            result = "PASS"
+
+        return "%s - %s" % (result, output)

=== renamed file 'uath/self_test.py' => 'uath/client/self_test.py'
--- uath/self_test.py	2012-04-10 15:46:12 +0000
+++ uath/client/self_test.py	2012-05-09 00:33:18 +0000
@@ -4,6 +4,7 @@
 from state_agent import StateAgent, StateAgentYAML
 
 from common import UATH_DIR, MASTER_RUNLIST
+from common import RETURN_CODES
 
 import exceptions
 import os
@@ -17,385 +18,444 @@
 master_runlist_content="""# uath/self_test.py master runlist
 # needed for uath/self_test.py runs
 - name: examples
-  fetch_cmd: rsync -a /home/josepht/bazaar/uath-dev/uath/examples/ .
+    fetch_cmd: rsync -a /usr/share/uath/client/examples/examples .
 - name: uath_tests
-  fetch_cmd: git clone /home/josepht/git/uath_tests.git || sh -c 'cd uath_tests && git pull'
+    fetch_cmd: rsync -a /usr/share/uath/client/examples/uath_tests .
 - name: uath_tests_sample
-  fetch_cmd: git clone /home/josepht/git/uath_tests_sample.git || sh -c 'cd uath_tests_sample && git pull'
+    fetch_cmd: rsync -a /usr/share/uath/client/examples/uath_tests_sample .
 """
 
 partial_state_file_content="""master_runlist: master.run
 status: RUN
-result_class: !!python/name:uath.result.ResultYAML ''
+result_class: !!python/name:uath.client.result.ResultYAML ''
 fetched_suites:
 - uath_tests
 - uath_tests_sample
 suites:
 - build_cmd: null
-  name: uath_tests
-  status: INPROGRESS
-  tests:
-  - build_cmd: echo "building for test_one"
-    command: python test_one.py
-    description: A first sample test case.
-    name: test_one
-    path: uath_tests/test_one
-    status: DONE
-    tc_cleanup: echo "cleanup for test_one"
-    tc_setup: echo "setup for test_one"
-    timeout: 3
-    type: userland
-  - build_cmd: echo "building for test_two"
-    command: python test_two.py
-    description: A second sample test case.
-    name: test_two
-    path: uath_tests/test_two
-    status: SETUP
-    tc_cleanup: echo "cleanup for test_two"
-    tc_setup: echo "setup for test_two"
-    timeout: 300
-    type: userland
-  timeout: 0
-  ts_cleanup: null
-  ts_setup: null
+    name: uath_tests
+    status: INPROGRESS
+    tests:
+    - build_cmd: echo "building for test_one"
+        command: python test_one.py
+        description: A first sample test case.
+        name: test_one
+        path: uath_tests/test_one
+        status: DONE
+        tc_cleanup: echo "cleanup for test_one"
+        tc_setup: echo "setup for test_one"
+        timeout: 3
+        type: userland
+    - build_cmd: echo "building for test_two"
+        command: python test_two.py
+        description: A second sample test case.
+        name: test_two
+        path: uath_tests/test_two
+        status: SETUP
+        tc_cleanup: echo "cleanup for test_two"
+        tc_setup: echo "setup for test_two"
+        timeout: 300
+        type: userland
+    timeout: 0
+    ts_cleanup: null
+    ts_setup: null
 - build_cmd: null
-  name: uath_tests_sample
-  status: DONE
-  tests:
-  - build_cmd: echo "building for sample_one"
-    command: python sample.py
-    description: A sample test case.
-    name: sample_one
-    path: uath_tests_sample/sample_one
+    name: uath_tests_sample
     status: DONE
-    tc_cleanup: echo "cleanup for sample_one"
-    tc_setup: echo "setup for sample_one"
-    timeout: 200
-    type: userland
-  timeout: 0
-  ts_cleanup: null
-  ts_setup: null
+    tests:
+    - build_cmd: echo "building for sample_one"
+        command: python sample.py
+        description: A sample test case.
+        name: sample_one
+        path: uath_tests_sample/sample_one
+        status: DONE
+        tc_cleanup: echo "cleanup for sample_one"
+        tc_setup: echo "setup for sample_one"
+        timeout: 200
+        type: userland
+    timeout: 0
+    ts_cleanup: null
+    ts_setup: null
 """
 master_runlist = os.path.join(UATH_DIR, MASTER_RUNLIST)
 master_runlist_bak = master_runlist + ".bak"
 
 def setUp():
-  """
-  Set up a master.run file that will copy our 'examples' directory to the
-  testing directory (usually /var/uath).
-  """
-
-  # save a copy of the master runlist
-  subprocess.call(['mv', master_runlist, master_runlist_bak])
-
-  fp = open(master_runlist, 'w')
-  fp.write(master_runlist_content)
-  fp.close()
+    """
+    Set up a master.run file that will copy our 'examples' directory to the
+    testing directory (usually /var/lib/uath).
+    """
+
+    # save a copy of the master runlist
+    if os.path.exists(master_runlist):
+        subprocess.call(['mv', master_runlist, master_runlist_bak])
+
+    fp = open(master_runlist, 'w')
+    fp.write(master_runlist_content)
+    fp.close()
 
 def tearDown():
-  """
-  Cleanup after ourselves.
-  """
+    """
+    Cleanup after ourselves.
+    """
 
-  # restore the copy of the master runlist
-  subprocess.call(['mv', master_runlist_bak, master_runlist])
+    # restore the copy of the master runlist
+    if os.path.exists(master_runlist_bak):
+        subprocess.call(['mv', master_runlist_bak, master_runlist])
+    else:
+        os.remove(master_runlist)
 
 class TestTestSuite(unittest.TestCase):
-  """
-  Tests for the TestSuite class.
-  """
-  def setUp(self):
-    """
-    Use the 'examples' test suite that's part of the UATH package.
-    """
-    self.suite = testsuite.TestSuite(name='examples', path='/var/uath', result_class=ResultYAML,
-        _save_state_callback=state_saver)
-
-  def test_run(self):
-    print "found %d tests" % self.suite.count_tests()
-    self.suite.run()
-
-  def test_count_tests(self):
-    self.assertEquals(self.suite.count_tests(), 2)
-
-  def test_next_test(self):
-    self.assertEquals(self.suite.get_next_test().name, 'test_one')
-
-  def test_is_done(self):
-    self.assertFalse(self.suite.is_done())
-
-  def test_save_state(self):
-    state = self.suite.save_state()
-
-    print state
-    self.assertEqual(state['status'], 'NOTRUN')
-
-    tests = 0
-    for test in state['tests']:
-      self.assertEqual(test['status'], 'NOTRUN')
-      tests += 1
-
-    self.assertEqual(tests, self.suite.count_tests())
+    """
+    Tests for the TestSuite class.
+    """
+    def setUp(self):
+        """
+        Use the 'examples' test suite that's part of the UATH package.
+        """
+        self.suite = testsuite.TestSuite(name='examples', path='/var/lib/uath', result_class=ResultYAML,
+                                         _save_state_callback=state_saver)
+
+    def test_run(self):
+        print "found %d tests" % self.suite.count_tests()
+        self.suite.run()
+        self.assertEqual(self.suite.result.status, 'PASS')
+
+    def test_count_tests(self):
+        self.assertEquals(self.suite.count_tests(), 2)
+
+    def test_next_test(self):
+        self.assertEquals(self.suite.get_next_test().name, 'test_one')
+
+    def test_is_done(self):
+        self.assertFalse(self.suite.is_done())
+
+    def test_save_state(self):
+        state = self.suite.save_state()
+
+        print state
+        self.assertEqual(state['status'], 'NOTRUN')
+
+        tests = 0
+        for test in state['tests']:
+            self.assertEqual(test['status'], 'NOTRUN')
+            tests += 1
+
+        self.assertEqual(tests, self.suite.count_tests())
 
 class TestTestCase(unittest.TestCase):
-  """
-  Tests for the TestCase class.
-  """
-  def setUp(self):
-    self.timeout = 10
-    self.command = 'echo "command"'
-    self.result = ResultYAML()
-    self.name = "test_one"
-    self.path = "examples/test_one"
-    self.suite_dir = os.path.join(UATH_DIR, 'examples')
+    """
+    Tests for the TestCase class.
+    """
+    def setUp(self):
+        self.timeout = 10
+        self.command = 'echo "command"'
+        self.result = ResultYAML()
+        self.name = "test_one"
+        self.path = "examples/test_one"
+        self.suite_dir = os.path.join(UATH_DIR, 'examples')
     
-    # Change to the testsuite's working directory
-    os.chdir(self.suite_dir)
-
-    self.case = testcase.TestCase(
-        name=self.name,
-        path=self.path,
-        command=self.command,
-        timeout=self.timeout,
-        result=self.result,
-    )
-
-  def test_run(self):
-    """
-    Test that a TestCase can be run.
-    """
-    self.case.run()
-
-    # make sure after a testcase run that the cwd hasn't changed.
-    self.assertEqual(os.getcwd(), self.suite_dir)
-    self.assertTrue(self.case.is_done())
-
-  def test_timeout(self):
-    self.assertEqual(self.case.timeout, self.timeout)
-
-  def test_command(self):
-    self.assertEqual(self.case.command, self.command)
-
-  def test_save_state(self):
-    state = self.case.save_state()
-
-    self.assertEqual(state['status'], 'NOTRUN')
-    self.assertEqual(state['command'], self.command)
-    self.assertEqual(state['timeout'], self.timeout)
-
-  def test_save_and_load_state(self):
-    state = self.case.save_state()
-
-    case = testcase.TestCase(name=self.name, path=self.path)
-    case.load_state(state)
-
-    self.assertFalse(case.is_done())
-
-    self.assertEqual(case.name, self.name)
-    self.assertEqual(case.path, self.path)
-    self.assertEqual(case.command, self.command)
-    self.assertEqual(case.timeout, self.timeout)
-
-    case.run()
-
-    self.assertTrue(case.is_done())
+        # Change to the testsuite's working directory
+        os.chdir(self.suite_dir)
+
+        self.case = testcase.TestCase(
+            name=self.name,
+            path=self.path,
+            command=self.command,
+            timeout=self.timeout,
+            result=self.result,
+        )
+
+    def test_run(self):
+        """
+        Test that a TestCase can be run.
+        """
+        self.case.run()
+
+        # make sure after a testcase run that the cwd hasn't changed.
+        self.assertEqual(os.getcwd(), self.suite_dir)
+        self.assertTrue(self.case.is_done())
+
+    def test_timeout(self):
+        self.assertEqual(self.case.timeout, self.timeout)
+
+    def test_command(self):
+        self.assertEqual(self.case.command, self.command)
+
+    def test_save_state(self):
+        state = self.case.save_state()
+
+        self.assertEqual(state['status'], 'NOTRUN')
+        self.assertEqual(state['command'], self.command)
+        self.assertEqual(state['timeout'], self.timeout)
+
+    def test_save_and_load_state(self):
+        state = self.case.save_state()
+
+        case = testcase.TestCase(name=self.name, path=self.path)
+        case.load_state(state)
+
+        self.assertFalse(case.is_done())
+
+        self.assertEqual(case.name, self.name)
+        self.assertEqual(case.path, self.path)
+        self.assertEqual(case.command, self.command)
+        self.assertEqual(case.timeout, self.timeout)
+
+        case.run()
+
+        self.assertTrue(case.is_done())
 
 class TestResult(unittest.TestCase):
-  def setUp(self):
-    self.result_yaml = ResultYAML("result_yaml")
-    self.result_text = Result("result")
-
-    self.result = {
-        'command': 'echo hi',
-        'returncode': 0,
-        'stdout': 'hi',
-        'stderr': ''
-    }
-
-    self.result_fail = {
-        'command': 'echo failure',
-        'returncode': 2,
-        'stdout': 'hi',
-        'stderr': ''
-    }
-
-  def test_add_result(self):
-    self.result_yaml.add_result(self.result)
-
-    self.assertEqual(self.result_yaml.count_results(), 1)
-
-    self.result_yaml.result()
-
-  def test_result(self):
-    self.result_yaml.add_result(self.result)
-
-    # check that the result was added.
-    self.assertEqual(self.result_yaml.count_results(), 1)
-
-    self.result_yaml.result()
-
-    # check that the result was processed and removed.
-    self.assertEqual(self.result_yaml.count_results(), 0)
-
-  def test_result_success(self):
-    """
-    Test that adding a successful result sets the Result object's status
-    to 'SUCCESS'.
-    """
-    self.result_yaml.add_result(self.result)
-
-    self.assertEqual(self.result_yaml.status, 'SUCCESS')
-
-  def test_result_failure(self):
-    """
-    Test that adding a failure result sets the Result object's status
-    to 'ERROR'.
-    """
-    self.result_yaml.add_result(self.result_fail)
-
-    self.assertEqual(self.result_yaml.status, 'ERROR')
-
-  def test_result_yaml(self):
-    self.result_yaml.add_result(self.result)
-
-    import sys
-    import StringIO
-
-    str_output = StringIO.StringIO()
-
-    # redirect output to a string
-    old_stdout = sys.stdout
-    sys.stdout = str_output
-
-    self.result_yaml.result()
-
-    sys.stdout = old_stdout
-
-    result_str = str_output.getvalue()
-
-    print("result_str: %s" % result_str)
-
-
-    data = yaml.load(result_str)
-
-    self.assertEqual(len(data), 1)
-
-    result = data[0]
-
-    print("data: %s" % data)
-
-    self.assertEqual(result['command'], self.result['command'])
-    self.assertEqual(result['returncode'], self.result['returncode'])
-    self.assertEqual(result['stdout'], self.result['stdout'])
-    self.assertEqual(result['stderr'], self.result['stderr'])
+    def setUp(self):
+        self.result_yaml = ResultYAML("result_yaml")
+        self.result_text = Result("result")
+
+        self.result = {
+            'command': 'echo hi',
+            'returncode': 0,
+            'stdout': 'hi',
+            'stderr': ''
+        }
+
+        self.result_fail = {
+            'command': 'echo failure',
+            'returncode': 2,
+            'stdout': 'hi',
+            'stderr': ''
+        }
+
+    def test_add_result(self):
+        self.result_yaml.add_result(self.result)
+
+        self.assertEqual(self.result_yaml.count_results(), 1)
+
+        self.result_yaml.result()
+
+    def test_result(self):
+        self.result_yaml.add_result(self.result)
+
+        # check that the result was added.
+        self.assertEqual(self.result_yaml.count_results(), 1)
+
+        self.result_yaml.result()
+
+        # check that the result was processed and removed.
+        self.assertEqual(self.result_yaml.count_results(), 0)
+
+    def test_result_pass(self):
+        """
+        Test that adding a pass result sets the Result object's status
+        to 'PASS'.
+        """
+        self.result_yaml.add_result(self.result)
+
+        self.assertEqual(self.result_yaml.status, 'PASS')
+
+    def test_result_failure(self):
+        """
+        Test that adding a failure result sets the Result object's status
+        to 'ERROR'.
+        """
+        self.result_yaml.add_result(self.result_fail)
+
+        self.assertEqual(self.result_yaml.status, 'ERROR')
+
+    def test_result_clear_result(self):
+        """
+        Test that the result is actually cleared.
+        """
+        self.result_yaml.add_result(self.result_fail)
+        self.assertEqual(self.result_yaml.status, 'ERROR')
+
+        self.result_yaml.clear_results()
+
+        self.assertEqual(self.result_yaml.status, 'PASS')
+        self.assertEqual(self.result_yaml.count_results(), 0)
+
+    def test_result_result(self):
+        """
+        Test that ERROR status is retained after adding pass
+        results.
+        """
+        self.result_yaml.add_result(self.result_fail)
+
+        self.assertEqual(self.result_yaml.status, 'ERROR')
+
+        self.result_yaml.add_result(self.result)
+
+        self.assertEqual(self.result_yaml.status, 'ERROR')
+
+
+    def test_result_yaml(self):
+        self.result_yaml.add_result(self.result)
+
+        import sys
+        import StringIO
+
+        str_output = StringIO.StringIO()
+
+        # redirect output to a string
+        old_stdout = sys.stdout
+        sys.stdout = str_output
+
+        self.result_yaml.result()
+
+        sys.stdout = old_stdout
+
+        result_str = str_output.getvalue()
+
+        print("result_str: %s" % result_str)
+
+        data = yaml.load(result_str)
+
+        self.assertEqual(len(data), 1)
+
+        result = data[0]
+
+        print("data: %s" % data)
+
+        self.assertEqual(result['command'], self.result['command'])
+        self.assertEqual(result['returncode'], self.result['returncode'])
+        self.assertEqual(result['stdout'], self.result['stdout'])
+        self.assertEqual(result['stderr'], self.result['stderr'])
 
 class TestRunner(unittest.TestCase):
-  def setUp(self):
-    self.result_class = ResultYAML
-    self.state_file = '/tmp/state.yaml'
-    self.state_agent = StateAgentYAML(state_file=self.state_file)
-    self.runner = Runner(result_class=self.result_class,
-        state_agent=self.state_agent)
-    self.bad_dir = "/tmp/does_not_exist"
-
-    self.assertFalse(os.path.exists(self.bad_dir))
-
-  def tearDown(self):
-
-    # Remove self.bad_dir if it got created.
-    try:
-      os.removedirs(self.bad_dir)
-    except OSError as e:
-      if e.errno == 2:
-        pass
-      else:
-        raise
-
-  def test_rc_local(self):
-    tmp_rc_local = '/tmp/rc.local'
-    self.runner.setup_rc_local(tmp_rc_local)
-
-    self.assertTrue(os.path.exists(tmp_rc_local))
-
-  def test_run(self):
-    self.runner.run()
-
-    for suite in self.runner.suites:
-      self.assertTrue(suite.is_done())
-
-  def test_missing_testdir(self):
-    """
-    Test that the runner fails gracefully on missing testdir.
-    """
-
-    self.assertRaises(exceptions.BadDir,
-        Runner, result_class=self.result_class, testdir=self.bad_dir)
-
-  def test_missing_master_runlist(self):
-    """
-    Test that the runner fails gracefully on missing 'master.run'
-    """
-
-    tmp_master_runlist = os.path.join(self.bad_dir, 'master.run')
-
-    if not os.path.exists(self.bad_dir):
-      os.mkdir(self.bad_dir)
-
-    # TODO: fix to use --master-runlist flag once it's been added.
-    if os.path.exists(tmp_master_runlist):
-      os.remove(tmp_master_runlist)
-
-    self.assertRaises(exceptions.MissingFile,
-        Runner, result_class=self.result_class, testdir=self.bad_dir)
-
-  def test_runlist(self):
-    """
-    Test that passing a runlist to the Runner works properly.
-    """
-    runlist = '/tmp/master_runlist_test'
-
-    # fail if there is already a runlist there.
-    self.assertFalse(os.path.exists(runlist))
-
-    fp = open(runlist, 'w')
-    fp.write(master_runlist_content)
-    fp.close()
-
-    runner = Runner(result_class=self.result_class, runlist=runlist)
-
-    self.assertTrue(runner.count_tests(), 0)
-
-    os.remove(runlist)
+    def setUp(self):
+        self.result_class = ResultYAML
+        self.state_file = '/tmp/state.yaml'
+        self.state_agent = StateAgentYAML(state_file=self.state_file)
+        self.runner = Runner(result_class=self.result_class,
+                             state_agent=self.state_agent)
+        self.bad_dir = "/tmp/does_not_exist"
+
+        self.assertFalse(os.path.exists(self.bad_dir))
+
+    def tearDown(self):
+
+        # Remove self.bad_dir if it got created.
+        try:
+            os.removedirs(self.bad_dir)
+        except OSError as e:
+            if e.errno == 2:
+                pass
+            else:
+                raise
+
+    def test_fetch_failed(self):
+        print "Starting test"
+        # exit 2 should be flagged as an error.
+        bad_runlist_content="""---\n- name: fake_tests\n  fetch_cmd: exit 2\n"""
+        runlist = '/tmp/master_fetch_fails.run'
+
+        self.assertFalse(os.path.exists(runlist), runlist)
+
+        fp = open(runlist, 'w')
+        fp.write(bad_runlist_content)
+        fp.close()
+
+        runner = Runner(result_class=self.result_class,
+                state_agent=self.state_agent, runlist=runlist)
+
+        # remove the runlist as early as possible to avoid leaving it
+        # laying around if this test fails.
+        try:
+            os.remove(runlist)
+        except OSError:
+            pass
+
+        runner.run()
+        print runner.report()
+
+        self.assertEqual(runner.fetch_errors, 1)
+
+    def test_rc_local(self):
+        tmp_rc_local = '/tmp/rc.local'
+        self.runner.setup_rc_local(tmp_rc_local)
+
+        self.assertTrue(os.path.exists(tmp_rc_local))
+
+    def test_run(self):
+        retcode = self.runner.run()
+
+        for suite in self.runner.suites:
+            self.assertTrue(suite.is_done())
+
+        self.assertEqual(retcode, RETURN_CODES['ERROR'])
+
+    def test_missing_testdir(self):
+        """
+        Test that the runner fails gracefully on missing testdir.
+        """
+
+        self.assertRaises(exceptions.BadDir,
+                          Runner, result_class=self.result_class, testdir=self.bad_dir)
+
+    def test_missing_master_runlist(self):
+        """
+        Test that the runner fails gracefully on missing 'master.run'
+        """
+
+        tmp_master_runlist = os.path.join(self.bad_dir, 'master.run')
+
+        if not os.path.exists(self.bad_dir):
+            os.mkdir(self.bad_dir)
+
+        # TODO: fix to use --master-runlist flag once it's been added.
+        if os.path.exists(tmp_master_runlist):
+            os.remove(tmp_master_runlist)
+
+        self.assertRaises(exceptions.MissingFile,
+                          Runner, result_class=self.result_class, testdir=self.bad_dir)
+
+    def test_runlist(self):
+        """
+        Test that passing a runlist to the Runner works properly.
+        """
+        runlist = '/tmp/master_runlist_test'
+
+        # fail if there is already a runlist there.
+        self.assertFalse(os.path.exists(runlist), "%s exists" % runlist)
+
+        fp = open(runlist, 'w')
+        fp.write(master_runlist_content)
+        fp.close()
+
+        runner = Runner(result_class=self.result_class, runlist=runlist)
+
+        self.assertTrue(runner.count_tests(), 0)
+
+        os.remove(runlist)
 
 def state_saver():
-  debug_print("Saving state", force=True)
+    debug_print("Saving state", force=True)
 
 class TestCommon(unittest.TestCase):
 
-  def test_run_cmd(self):
-    result = run_cmd('find . -name "*.py"')
-
-    self.assertEqual(result['returncode'], 0)
-
-  def test_debug_print(self):
-    """
-    Test that debug_print doesn't print when DEBUG is False unless
-    'debug' is passed in and is True.
-    """
-    from common import CONFIG
-
-    old_debug = CONFIG['DEBUG']
-
-    CONFIG['DEBUG'] = True
-    if not debug_print("testing debug_print"):
-      raise Exception("didn't print with CONFIG['DEBUG'] set to True")
-
-    CONFIG['DEBUG'] = False
-    self.assertEqual(debug_print("shouldn't be printed unless common.CONFIG['DEBUG'] is True"), CONFIG['DEBUG'], "printed with CONFIG['DEBUG'] set to False")
-
-    self.assertEqual(debug_print("should be printed (using 'force=True')", force=True), True)
-
-    CONFIG['DEBUG'] = old_debug
+    def test_run_cmd(self):
+        result = run_cmd('find . -name "*.py"')
+
+        self.assertEqual(result['returncode'], 0)
+
+    def test_debug_print(self):
+        """
+        Test that debug_print doesn't print when DEBUG is False unless
+        'debug' is passed in and is True.
+        """
+        from common import CONFIG
+
+        old_debug = CONFIG['DEBUG']
+
+        CONFIG['DEBUG'] = True
+        if not debug_print("testing debug_print"):
+            raise Exception("didn't print with CONFIG['DEBUG'] set to True")
+
+        CONFIG['DEBUG'] = False
+        self.assertEqual(debug_print("shouldn't be printed unless common.CONFIG['DEBUG'] is True"), CONFIG['DEBUG'], "printed with CONFIG['DEBUG'] set to False")
+
+        self.assertEqual(debug_print("should be printed (using 'force=True')", force=True), True)
+
+        CONFIG['DEBUG'] = old_debug
 
 ######################################################################
 ### The tests after this comment really need to be moved into the
@@ -404,123 +464,98 @@
 
 
 class TestStateAgentYAML(unittest.TestCase):
-  def setUp(self):
-    """
-    Create a state agent for testing.
-    """
-    self.state_file = '/tmp/state.yaml'
-
-    # Fail if there is already a test state file.
-    self.assertFalse(os.path.exists(self.state_file), "state file (%s) already exists" % self.state_file)
-
-    self.state_agent = StateAgentYAML(state_file=self.state_file)
-    self.runner = Runner(result_class=ResultYAML, state_agent=self.state_agent)
-    self.partial_state_file_content = partial_state_file_content
-
-  def tearDown(self):
-    """
-    Clean up the test state file.
-    """
-    try:
-      os.remove(self.state_file)
-    except OSError as e:
-      if e.errno == 2: # does not exist
-        pass
-      else:
-        raise
-
-  def test_creation(self):
-    suite_count = self.runner.count_suites()
-    test_count = self.runner.count_tests()
-
-    self.runner.run()
-
-    self.assertTrue(os.path.exists(self.state_file))
-
-  def test_cleanup(self):
-    self.runner.save_state()
-
-    self.assertTrue(os.path.exists(self.state_file), "Runner failed to save state")
-
-    self.state_agent.clean()
-
-    self.assertFalse(os.path.exists(self.state_file), "Failed to remove state file (%s)" % self.state_file)
-
-  def test_status(self):
-    """
-    Test that a runner properly saves its state during test runs.
-    """
-    suite_count = self.runner.count_suites()
-    test_count = self.runner.count_tests()
-
-    self.runner.run()
-
-    self.assertTrue(os.path.exists(self.state_file))
-
-    self.runner.load_state()
-
-    self.assertEqual(self.runner.count_suites(), suite_count)
-    self.assertEqual(self.runner.count_tests(), test_count)
-
-    fp = open(self.state_file, 'r')
-    state_data = yaml.load(fp)
-    fp.close()
-
-    self.assertEqual(state_data['status'], 'DONE')
-
-  def test_load_state_partial(self):
-    """
-    Test that a partially run state file can be resumed.
-    """
-    fp = open(self.state_file, 'w')
-    fp.write(self.partial_state_file_content)
-    fp.close()
-
-    state_agent = StateAgentYAML(state_file=self.state_file)
-    runner = Runner(state_agent=state_agent, resume=True)
-    runner.load_state()
-
-    self.assertEqual(runner.status, 'RUN')
-
-    next_test = runner.get_next_test()
-
-    self.assertEqual(next_test.name, 'test_two')
-
-    runner.run()
+    def setUp(self):
+        """
+        Create a state agent for testing.
+        """
+        self.state_file = '/tmp/state.yaml'
+
+        # Fail if there is already a test state file.
+        self.assertFalse(os.path.exists(self.state_file), "state file (%s) already exists" % self.state_file)
+
+        self.state_agent = StateAgentYAML(state_file=self.state_file)
+        self.runner = Runner(result_class=ResultYAML, state_agent=self.state_agent)
+        self.partial_state_file_content = partial_state_file_content
+
+    def tearDown(self):
+        """
+        Clean up the test state file.
+        """
+        try:
+            os.remove(self.state_file)
+        except OSError as e:
+            if e.errno == 2: # does not exist
+                pass
+            else:
+                raise
+
+    def test_creation(self):
+        suite_count = self.runner.count_suites()
+        test_count = self.runner.count_tests()
+
+        self.runner.run()
+
+        self.assertTrue(os.path.exists(self.state_file))
+
+    def test_cleanup(self):
+        self.runner.save_state()
+
+        self.assertTrue(os.path.exists(self.state_file), "Runner failed to save state")
+
+        self.state_agent.clean()
+
+        self.assertFalse(os.path.exists(self.state_file), "Failed to remove state file (%s)" % self.state_file)
+
+    def test_status(self):
+        """
+        Test that a runner properly saves its state during test runs.
+        """
+        suite_count = self.runner.count_suites()
+        test_count = self.runner.count_tests()
+
+        self.runner.run()
+
+        self.assertTrue(os.path.exists(self.state_file))
+
+        self.runner.load_state()
+
+        self.assertEqual(self.runner.count_suites(), suite_count)
+        self.assertEqual(self.runner.count_tests(), test_count)
+
+        fp = open(self.state_file, 'r')
+        state_data = yaml.load(fp)
+        fp.close()
+
+        self.assertEqual(state_data['status'], 'DONE')
+
+    def test_load_state_partial(self):
+        """
+        Test that a partially run state file can be resumed.
+        """
+        fp = open(self.state_file, 'w')
+        fp.write(self.partial_state_file_content)
+        fp.close()
+
+        state_agent = StateAgentYAML(state_file=self.state_file)
+        runner = Runner(state_agent=state_agent, resume=True)
+        runner.load_state()
+
+        self.assertEqual(runner.status, 'RUN')
+
+        next_test = runner.get_next_test()
+
+        self.assertEqual(next_test.name, 'test_two')
+
+        runner.run()
 
 def main():
-  """
-  Run any tests listed in 'funcs'.  Comment ones out if you want to skip them.
-
-  Also you can run all tests via nose like this:
-
-    nosetests main.py
-
-  See nosetests(1) for more info.
-
-  """
-  funcs = [
-      #test_testcase_default_results,
-      #test_run_cmd,
-      #test_testcase,
-      #test_testsuite,
-      #test_result_success,
-      #test_result_failure,
-      #test_result_yaml_success,
-      #test_result_yaml_failure,
-      #test_runner,
-      #test_debug_print,
-      #test_save_state,
-      #test_testcase_save_and_load_state,
-      #test_testsuite_save_and_load_state,
-      #test_state_agent_YAML,
-      #test_load_state_partial,
-      test_state_agent_cleanup,
-      test_testsuite_is_done,
-  ]
-
-  for func in funcs:
-    func()
-
+    print """
+    You can run all tests via nose like this:
+
+        nosetests self_test.py
+
+    See nosetests(1) for more info.
+
+    """
 if __name__ == "__main__":
-  main()
+    main()

=== renamed file 'uath/state_agent.py' => 'uath/client/state_agent.py'
--- uath/state_agent.py	2012-04-09 19:43:57 +0000
+++ uath/client/state_agent.py	2012-05-09 00:33:18 +0000
@@ -6,75 +6,75 @@
 
 
 class StateAgent(object):
-  """
-  State saving base class.
-
-  Accepts a dictionary of state info and prints it to STDOUT.
-  """
-
-  state_file = DEFAULT_STATE_FILE
-
-  def __init__(self, state_file=None):
-    if state_file is not None:
-      self.state_file = state_file
-
-  def clean(self):
-    """
-    Clean up the state file if it exists.
-    """
-    import os
-
-    # Don't fail if the state_file doesn't exists.
-    try:
-      os.remove(self.state_file)
-    except OSError as e:
-      if e.errno == 2: # file not found
-        pass
-
-  def save_state(self, state):
-    """
-    Save state to the state_file.
-    """
-
-    fp = open(self.state_file, 'w')
-    fp.write(str(state))
-    fp.close()
-
-  def load_state(self):
-    """
-    Load state from the state_file.
-    """
-    state = {}
-
-    if os.path.exists(self.state_file):
-      fp = open(self.state_file, 'r')
-      state = fp.read()
-      fp.close()
-
-    return state
+    """
+    State saving base class.
+
+    Accepts a dictionary of state info and prints it to STDOUT.
+    """
+
+    state_file = DEFAULT_STATE_FILE
+
+    def __init__(self, state_file=None):
+        if state_file is not None:
+            self.state_file = state_file
+
+    def clean(self):
+        """
+        Clean up the state file if it exists.
+        """
+        import os
+
+        # Don't fail if the state_file doesn't exists.
+        try:
+            os.remove(self.state_file)
+        except OSError as e:
+            if e.errno == 2: # file not found
+                pass
+
+    def save_state(self, state):
+        """
+        Save state to the state_file.
+        """
+
+        fp = open(self.state_file, 'w')
+        fp.write(str(state))
+        fp.close()
+
+    def load_state(self):
+        """
+        Load state from the state_file.
+        """
+        state = {}
+
+        if os.path.exists(self.state_file):
+            fp = open(self.state_file, 'r')
+            state = fp.read()
+            fp.close()
+
+        return state
 
 class StateAgentYAML(StateAgent):
-  """
-  YAML based state saver.
-  """
-
-  def save_state(self, state):
-    """
-    Output the state as YAML.
-    """
-
-    super(StateAgentYAML, self).save_state(yaml.dump(state, default_flow_style=False))
-
-  def load_state(self):
-    """
-    Load state from YAML state_file.
-    """
-
-    state = {}
-
-    if os.path.exists(self.state_file):
-      fp = open(self.state_file, 'r')
-      state = yaml.load(fp)
-      fp.close()
-
-    return state
+    """
+    YAML based state saver.
+    """
+
+    def save_state(self, state):
+        """
+        Output the state as YAML.
+        """
+
+        super(StateAgentYAML, self).save_state(yaml.dump(state, default_flow_style=False))
+
+    def load_state(self):
+        """
+        Load state from YAML state_file.
+        """
+
+        state = {}
+
+        if os.path.exists(self.state_file):
+            fp = open(self.state_file, 'r')
+            state = yaml.load(fp)
+            fp.close()
+
+        return state

=== renamed file 'uath/testcase.py' => 'uath/client/testcase.py'
--- uath/testcase.py	2012-04-06 15:44:09 +0000
+++ uath/client/testcase.py	2012-05-09 00:33:18 +0000
@@ -5,198 +5,201 @@
 from common import run_cmd, parse_control_file, debug_print
 from common import do_nothing
 from result import Result
+from exceptions import MissingFile
 
 class TestCase(object):
-  """
-  The TestCase class.
-
-  status is one of 'NOTRUN', 'BUILD', 'SETUP', 'RUN', 'CLEANUP', or 'DONE'
-  """
-
-  status = 'NOTRUN'
-  build_cmd = None
-  tc_setup = None
-  tc_cleanup = None
-  reboot = 'never'
-  reboot_callback = None
-  save_state_callback = do_nothing
-
-  def __init__(self, name, path, command=None, result=None, timeout=0,
-      _control_data=None, _save_state_callback=None, _reboot_callback=None):
-    """
-    Build a TestCase from a control file's data.
-
-    'name' is a directory where the test case resides.
-    """
-    self.name = name
-    self.path = path
-    self.working_dir = path
-    self.filename = "%s/tc_control" % path
-    self.results = []
-    self.result = result
-    self.timeout = timeout
-    self.command = command
-    self.reboot_callback = _reboot_callback
-
-    if _save_state_callback is not None:
-      self.save_state_callback = _save_state_callback
-
-    required_items = ['description', 'type']
-    optional_items = ['build_cmd',
-                      'timeout',
-                      'command',
-                      'tc_setup',
-                      'tc_cleanup',
-                      'reboot',           # 'always', 'success', or 'never'
-                     ]
-
-
-    control_data = None
-    import os
-    if _control_data is None and os.path.exists(self.filename):
-      control_data = parse_control_file(self.filename, required=required_items,
-          optional=optional_items)
-    else:
-      control_data = _control_data
-
-    if control_data is not None:
-      self.__dict__.update(control_data)
-
-    # Set any values passed into __init__() as final values
-    if timeout != 0 or self.timeout == 0:
-      self.timeout = timeout
-    if command is not None:
-      self.command = command
-
-  def __str__(self):
-    return "%s: %s, %s, %s" % (self.name, self.description, self.command, self.timeout)
-
-  def set_status(self, status):
-    """
-    Set the status for the test case and call the save state callback.
-    """
-    self.status = status
-    self.save_state_callback()
-
-  def build(self, result):
-    """
-    Run build, but only if we haven't started a run yet.
-    """
-    if self.status == 'NOTRUN':
-      self.set_status('BUILD')
-      result.add_result(run_cmd(self.build_cmd, cwd=self.working_dir))
-
-  def setup(self, result):
-    """
-    Run tc_setup, but only if build() has just run successfully.
-    """
-    if self.status == 'BUILD' and result.status == 'SUCCESS':
-      self.set_status('SETUP')
-      result.add_result(run_cmd(self.tc_setup, cwd=self.working_dir))
-
-  def cleanup(self, result):
-    """
-    Run tc_cleanup after a run.
-    """
-    if self.status == 'RUN':
-      self.set_status('CLEANUP')
-      result.add_result(run_cmd(self.tc_cleanup, cwd=self.working_dir))
-
-  def run(self, result=None):
-    """
-    Run the test case; including any build, setup, and cleanup commands.
-    """
-
-    # Return value to indicate whether processing of a TestSuite should
-    # continue.  This is to avoid a shutdown race on reboot cases.
-    keep_going = True
-
-    # If no result object was passed in and the instance does not have
-    # one either then create a basic text result object.
-    if result is None:
-      if self.result is not None:
-        result = self.result
-      else:
-        result = Result(self.name)
-
-    self.build(result)
-
-    # if the build fails don't run the test command
-    if result.status != 'SUCCESS':
-      return result.result()
-
-    self.setup(result)
-
-    # if the setup fails don't run the test command
-    if result.status != 'SUCCESS':
-      return result.result()
-
-    if self.status == 'SETUP': 
-      timeout = self.timeout or 0
-      self.status = "RUN"
-      self.save_state_callback()
-      result.add_result(run_cmd(self.command, timeout=timeout, cwd=self.working_dir))
-
-    # Clean up whether 'command' failed or not.
-    self.cleanup(result)
-
-    need_reboot = False
-    if self.reboot == 'always' or self.reboot == 'success' and result.status == 'SUCCESS':
-      need_reboot = True
-
-    result.result()
-
-    if self.status == 'CLEANUP':
-      self.status = "DONE"
-      self.save_state_callback()
-
-    if need_reboot and self.reboot_callback is not None:
-      #print("JAT: *** HERE I WOULD HAVE REBOOTED ***")
-      self.reboot_callback()
-      keep_going = False
-
-    return keep_going
-
-  def process_overrides(self, overrides):
-    """
-    Sets override values from a TestSuite runlist for this test case.
-    """
-    for item in overrides:
-      for key, value in item.iteritems():
-        setattr(self, key, value)
-
-  def load_state(self, state):
-    """
-    Restore state from the supplied dictionary.
-
-    Requires that 'state' has the same fieldnames as the TestCase class.
-    """
-    self.__dict__.update(state)
-
-  def save_state(self):
-    """
-    Returns a dictionary representing the test's state.
-    """
-    state = {
-        'name': self.name,
-        'path': self.path,
-        'command': self.command,
-        'timeout': self.timeout,
-        'status': self.status,
-        'build_cmd': self.build_cmd,
-        'tc_setup': self.tc_setup,
-        'tc_cleanup': self.tc_cleanup,
-        'type': self.type,
-        'description': self.description,
-    }
-
-    return state
-
-  def is_done(self):
-    """
-    Determine if the case is done.  This might mean that something has
-    failed.  Used by suite to determine if the suite needs to be re-run
-    on resume.
-    """
-    return self.status == 'DONE' or self.status == 'CLEANUP'
+    """
+    The TestCase class.
+
+    status is one of 'NOTRUN', 'BUILD', 'SETUP', 'RUN', 'CLEANUP', or 'DONE'
+    """
+
+    status = 'NOTRUN'
+    build_cmd = None
+    tc_setup = None
+    tc_cleanup = None
+    reboot = 'never'
+    reboot_callback = None
+    save_state_callback = do_nothing
+    type = 'userland'
+
+    def __init__(self, name, path, command=None, result=None, timeout=0,
+                 _control_data=None, _save_state_callback=None, _reboot_callback=None):
+        """
+        Build a TestCase from a control file's data.
+
+        'name' is a directory where the test case resides.
+        """
+        self.name = name
+        self.path = path
+        self.working_dir = path
+        self.filename = "%s/tc_control" % path
+        self.results = []
+        self.result = result
+        self.timeout = timeout
+        self.command = command
+        self.reboot_callback = _reboot_callback
+
+        if _save_state_callback is not None:
+            self.save_state_callback = _save_state_callback
+
+        required_items = ['description', 'type', 'timeout', 'action']
+        optional_items = ['build_cmd',
+                          'command',
+                          'tc_setup',
+                          'tc_cleanup',
+                          'reboot',           # 'always', 'pass', or 'never'
+                         ]
+
+
+        control_data = None
+        import os
+        if _control_data is None:
+          if os.path.exists(self.filename):
+            control_data = parse_control_file(self.filename, required=required_items,
+                                              optional=optional_items)
+          else:
+            raise MissingFile(self.filename)
+        else:
+            control_data = _control_data
+
+        if control_data is not None:
+            self.__dict__.update(control_data)
+
+        # Set any values passed into __init__() as final values
+        if timeout != 0 or self.timeout == 0:
+            self.timeout = timeout
+        if command is not None:
+            self.command = command
+
+    def __str__(self):
+        return "%s: %s, %s, %s" % (self.name, self.description, self.command, self.timeout)
+
+    def set_status(self, status):
+        """
+        Set the status for the test case and call the save state callback.
+        """
+        self.status = status
+        self.save_state_callback()
+
+    def build(self, result):
+        """
+        Run build, but only if we haven't started a run yet.
+        """
+        if self.status == 'NOTRUN':
+            self.set_status('BUILD')
+            result.add_result(run_cmd(self.build_cmd, cwd=self.working_dir))
+
+    def setup(self, result):
+        """
+        Run tc_setup, but only if build() has just passed.
+        """
+        if self.status == 'BUILD' and result.status == 'PASS':
+            self.set_status('SETUP')
+            result.add_result(run_cmd(self.tc_setup, cwd=self.working_dir))
+
+    def cleanup(self, result):
+        """
+        Run tc_cleanup after a run.
+        """
+        if self.status == 'RUN':
+            self.set_status('CLEANUP')
+            result.add_result(run_cmd(self.tc_cleanup, cwd=self.working_dir))
+
+    def run(self, result=None):
+        """
+        Run the test case; including any build, setup, and cleanup commands.
+        """
+
+        # Return value to indicate whether processing of a TestSuite should
+        # continue.  This is to avoid a shutdown race on reboot cases.
+        keep_going = True
+
+        # If no result object was passed in and the instance does not have
+        # one either then create a basic text result object.
+        if result is None:
+            if self.result is not None:
+                result = self.result
+            else:
+                result = Result(self.name)
+
+        self.build(result)
+
+        # if the build fails don't run the test command
+        if result.status != 'PASS':
+            return result.result()
+
+        self.setup(result)
+
+        # if the setup fails don't run the test command
+        if result.status != 'PASS':
+            return result.result()
+
+        if self.status == 'SETUP': 
+            timeout = self.timeout or 0
+            self.status = "RUN"
+            self.save_state_callback()
+            result.add_result(run_cmd(self.command, timeout=timeout, cwd=self.working_dir))
+
+        # Clean up whether 'command' failed or not.
+        self.cleanup(result)
+
+        need_reboot = False
+        if self.reboot == 'always' or self.reboot == 'pass' and result.status == 'PASS':
+            need_reboot = True
+
+        self.run_status = result.result()
+
+        if self.status == 'CLEANUP':
+            self.status = "DONE"
+            self.save_state_callback()
+
+        if need_reboot and self.reboot_callback is not None:
+            self.reboot_callback()
+            keep_going = False
+
+        return keep_going
+
+    def process_overrides(self, overrides):
+        """
+        Sets override values from a TestSuite runlist for this test case.
+        """
+        for item in overrides:
+            for key, value in item.iteritems():
+                setattr(self, key, value)
+
+    def load_state(self, state):
+        """
+        Restore state from the supplied dictionary.
+
+        Requires that 'state' has the same fieldnames as the TestCase class.
+        """
+        self.__dict__.update(state)
+
+    def save_state(self):
+        """
+        Returns a dictionary representing the test's state.
+        """
+        state = {
+                'name': self.name,
+                'path': self.path,
+                'command': self.command,
+                'timeout': self.timeout,
+                'status': self.status,
+                'build_cmd': self.build_cmd,
+                'tc_setup': self.tc_setup,
+                'tc_cleanup': self.tc_cleanup,
+                'type': self.type,
+                'description': self.description,
+        }
+
+        return state
+
+    def is_done(self):
+        """
+        Determine if the case is done.  This might mean that something has
+        failed.  Used by suite to determine if the suite needs to be re-run
+        on resume.
+        """
+        return self.status == 'DONE' or self.status == 'CLEANUP'
 

=== renamed file 'uath/testsuite.py' => 'uath/client/testsuite.py'
--- uath/testsuite.py	2012-04-10 20:23:50 +0000
+++ uath/client/testsuite.py	2012-05-09 00:33:18 +0000
@@ -12,255 +12,268 @@
 import yaml
 
 def parse_runlist_file(runlist_file):
-  """
-  Parse a tslist.run runlist file for a list of test cases.
-  """
-
-  fp = open(runlist_file, 'r')
-  data = yaml.load(fp)
-  fp.close()
-
-  return data
+    """
+    Parse a tslist.run runlist file for a list of test cases.
+    """
+
+    fp = open(runlist_file, 'r')
+    data = yaml.load(fp)
+    fp.close()
+
+    return data
 
 class TestSuite(object):
-  """
-  The TestSuite class.
-  """
-
-  build_cmd = None
-  timeout = 0
-  ts_setup = None
-  ts_cleanup = None
-  control_file = None
-  # status is one of 'NOTRUN', 'BUILD', 'SETUP', 'INPROGRESS', 'CLEANUP', and 'DONE'
-  status = "NOTRUN"
-  save_state_callback = do_nothing
-
-
-  def __init__(self, name, path, runlist_file=DEFAULT_TSLIST,
-      control_file=DEFAULT_TSCONTROL, includes=None, excludes=None,
-      result=None, result_class=Result,
-      _control_data=None, _runlist_data=None,
-      _save_state_callback=None, _reboot_callback=None):
-
-    self.path = os.path.join(path, name)
-    self.reboot_callback = _reboot_callback
-
-    # work from within the testsuite's directory. eg. /var/uath/examples
-    old_cwd = os.getcwd()
-    os.chdir(self.path)
-    """
-    Build a TestSuite from a control file's data.
-    """
-    control_file = os.path.join(name, control_file)
-
-    if os.path.exists(control_file):
-      self.control_file = control_file
-
-    self.runlist_file = os.path.join(name, runlist_file)
-    self.tests = []
-    self.name = name
-
-    if _save_state_callback is not None:
-      self.save_state_callback = _save_state_callback
-
-    # Either use the result object passed in or create one.
-    if result is None:
-      self.result = result_class()
-    else:
-      self.result = result
-
-    required_items = []
-    optional_items = ['build_cmd',
-                      'timeout',
-                      'ts_setup',
-                      'ts_cleanup',
-                     ]
-
-    control_data = None
-
-    if _control_data is not None:
-      control_data = _control_data
-    elif self.control_file is not None:
-      control_data = parse_control_file(self.control_file,
-          required=required_items, optional=optional_items)
-
-    if control_data is not None:
-      self.__dict__.update(control_data)
-
-    if _runlist_data is not None:
-      runlist_data = _runlist_data
-    elif os.path.exists(self.runlist_file):
-      runlist_data = parse_runlist_file(self.runlist_file)
-    else:
-      runlist_data = []
-
-    for test in runlist_data:
-      name = test['test']
-      test_path = os.path.join(self.name, name)
-
-      if includes is not None and name not in includes:
-        continue
-
-      if excludes is not None and name in excludes:
-        continue
-
-      command = test.get('command')
-
-      tc = TestCase(name=name, path=test_path,
-          command=command, timeout=self.timeout,
-          result=self.result,
-          _save_state_callback=self.save_state_callback,
-          _reboot_callback=self.reboot_callback)
-      if 'overrides' in test:
-        tc.process_overrides(test['overrides'])
-
-      self.tests.append(tc)
-
-    # restore the old working directory
-    os.chdir(old_cwd)
-
-  def __str__(self):
-    return "%s: %s" % (self.control_file, self.runlist_file)
-
-  def set_status(self, status):
-    """
-    Set the status for the test suite and call the save state callback.
-    """
-    self.status = status
-    self.save_state_callback()
-
-  def build(self, result):
-    """
-    Run build, but only if we haven't started a run yet.
-    """
-    if self.status == 'NOTRUN':
-      self.set_status('BUILD')
-      result.add_result(run_cmd(self.build_cmd, cwd=self.name))
-
-  def setup(self, result):
-    """
-    Run ts_setup, but only if build() has just run successfully.
-    """
-    if self.status == 'BUILD' and result.status == 'SUCCESS':
-      self.set_status('SETUP')
-      result.add_result(run_cmd(self.ts_setup, cwd=self.name))
-
-  def cleanup(self, result):
-    """
-    Run ts_cleanup after a run.
-    """
-    if self.status == 'INPROGRESS':
-      self.set_status('CLEANUP')
-      result.add_result(run_cmd(self.ts_cleanup, cwd=self.name))
-
-
-  def run(self):
-    """
-    Run the test cases; including any build, setup, and cleanup commands.
-    """
-
-    # Return value to indicate whether processing of a Runner should
-    # continue.  This is to avoid a shutdown race on reboot cases.
-    keep_going = True
-
-    # Work from the testsuite directory
-    os.chdir(self.path)
-
-    result = self.result
-
-    self.build(result)
-    self.setup(result)
-
-    # Always enter this loop since test.run() will handle checking if
-    # the test has already been run.
-    self.status = "INPROGRESS"
-    if result.status == 'SUCCESS':
-      for test in self.tests:
-        keep_going = test.run(self.result)
-
-        if not keep_going:
-          return keep_going
-
-    self.cleanup(result)
-
-    if self.status == 'CLEANUP':
-      result.result()
-      self.set_status("DONE")
-
-    return keep_going
-
-  def add_test(self, tests):
-    """
-    Add a single test or list of tests to this suite.
-    """
-    if isinstance(tests, TestCase):
-      self.tests.append(tests)
-    else:
-      try:
-        for test in tests:
-          self.add_test(test)
-      except TypeError:
-        pass
-
-  def count_tests(self):
-    return len(self.tests)
-
-  def load_state(self, state):
-    """
-    Restore our state from the supplied dictionary.
-
-    Requires that the fieldnames in the dictionary match the class
-    properties.
-    """
-    # XXX: Should this be done explicitly?
-    self.__dict__.update(state)
-
-    self.tests = []
-    for state_test in state['tests']:
-      test = TestCase(name=state_test['name'], path=state_test['path'],
-          result=self.result,
-          _save_state_callback=self.save_state_callback,
-          _reboot_callback=self.reboot_callback)
-      test.load_state(state_test)
-      self.tests.append(test)
-
-  def save_state(self):
-    state = {
-        'name': self.name,
-        'status': self.status,
-        'tests': [],
-        'ts_setup': self.ts_setup,
-        'ts_cleanup': self.ts_cleanup,
-        'build_cmd': self.build_cmd,
-        'timeout': self.timeout,
-    }
-
-    for test in self.tests:
-      state['tests'].append(test.save_state())
-
-    return state
-
-  def is_done(self):
-    """
-    Determine if the suite is done.  This might mean that something has
-    failed.  Used by Runner to determine if the suite needs to be re-run
-    on resume.
-    """
-    return self.status == 'DONE' or self.status == 'CLEANUP'
-
-  def get_next_test(self):
-    """
-    Return the next test to be run.
-
-    Mainly used for debugging.
-    """
-
-    test = None
-
-    for t in self.tests:
-      if not t.is_done():
-        test = t
-        break
-
-    return test
+    """
+    The TestSuite class.
+    """
+
+    build_cmd = None
+    timeout = 0
+    ts_setup = None
+    ts_cleanup = None
+    control_file = None
+    # status is one of 'NOTRUN', 'BUILD', 'SETUP', 'INPROGRESS', 'CLEANUP', and 'DONE'
+    status = "NOTRUN"
+    save_state_callback = do_nothing
+
+
+    def __init__(self, name, path, runlist_file=DEFAULT_TSLIST,
+                 control_file=DEFAULT_TSCONTROL, includes=None, excludes=None,
+                 result=None, result_class=Result,
+                 _control_data=None, _runlist_data=None,
+                 _save_state_callback=None, _reboot_callback=None):
+
+        self.path = os.path.join(path, name)
+        self.reboot_callback = _reboot_callback
+        self.passes = 0
+        self.failures = 0
+        self.errors = 0
+
+        # work from within the testsuite's directory. eg. /var/lib/uath/examples
+        old_cwd = os.getcwd()
+        os.chdir(self.path)
+        """
+        Build a TestSuite from a control file's data.
+        """
+        control_file = os.path.join(name, control_file)
+
+        if os.path.exists(control_file):
+            self.control_file = control_file
+
+        self.runlist_file = os.path.join(name, runlist_file)
+        self.tests = []
+        self.name = name
+
+        if _save_state_callback is not None:
+            self.save_state_callback = _save_state_callback
+
+        # Either use the result object passed in or create one.
+        if result is None:
+            self.result = result_class()
+        else:
+            self.result = result
+
+        required_items = []
+        optional_items = ['build_cmd',
+                          'timeout',
+                          'ts_setup',
+                          'ts_cleanup',
+                         ]
+
+        control_data = None
+
+        if _control_data is not None:
+            control_data = _control_data
+        elif self.control_file is not None:
+            control_data = parse_control_file(self.control_file,
+                                              required=required_items, optional=optional_items)
+
+        if control_data is not None:
+            self.__dict__.update(control_data)
+
+        if _runlist_data is not None:
+            runlist_data = _runlist_data
+        elif os.path.exists(self.runlist_file):
+            runlist_data = parse_runlist_file(self.runlist_file)
+        else:
+            runlist_data = []
+
+        for test in runlist_data:
+            name = test['test']
+            test_path = os.path.join(self.name, name)
+
+            if includes is not None and name not in includes:
+                continue
+
+            if excludes is not None and name in excludes:
+                continue
+
+            command = test.get('command')
+
+            tc = TestCase(name=name, path=test_path,
+                          command=command, timeout=self.timeout,
+                          result=self.result,
+                          _save_state_callback=self.save_state_callback,
+                          _reboot_callback=self.reboot_callback)
+            if 'overrides' in test:
+                tc.process_overrides(test['overrides'])
+
+            self.tests.append(tc)
+
+        # restore the old working directory
+        os.chdir(old_cwd)
+
+    def __str__(self):
+        return "%s: %s" % (self.control_file, self.runlist_file)
+
+    def set_status(self, status):
+        """
+        Set the status for the test suite and call the save state callback.
+        """
+        self.status = status
+        self.save_state_callback()
+
+    def build(self, result):
+        """
+        Run build, but only if we haven't started a run yet.
+        """
+        if self.status == 'NOTRUN':
+            self.set_status('BUILD')
+            result.add_result(run_cmd(self.build_cmd, cwd=self.name))
+
+    def setup(self, result):
+        """
+        Run ts_setup, but only if build() has just passed.
+        """
+        if self.status == 'BUILD' and result.status == 'PASS':
+            self.set_status('SETUP')
+            result.add_result(run_cmd(self.ts_setup, cwd=self.name))
+
+    def cleanup(self, result):
+        """
+        Run ts_cleanup after a run.
+        """
+        if self.status == 'INPROGRESS':
+            self.set_status('CLEANUP')
+            result.add_result(run_cmd(self.ts_cleanup, cwd=self.name))
+
+
+    def run(self):
+        """
+        Run the test cases; including any build, setup, and cleanup commands.
+        """
+
+        # Return value to indicate whether processing of a Runner should
+        # continue.  This is to avoid a shutdown race on reboot cases.
+        keep_going = True
+
+        # Work from the testsuite directory
+        os.chdir(self.path)
+
+        result = self.result
+
+        self.build(result)
+        self.setup(result)
+
+        # Always enter this loop since test.run() will handle checking if
+        # the test has already been run.
+        self.status = "INPROGRESS"
+        if result.status == 'PASS':
+            for test in self.tests:
+                keep_going = test.run(self.result)
+
+                if test.run_status == 'PASS':
+                    self.passes += 1
+                elif test.run_status == 'FAIL':
+                    self.failures += 1
+                elif test.run_status == 'ERROR':
+                    self.errors += 1
+
+                if not keep_going:
+                    return keep_going
+
+        self.cleanup(result)
+
+        if self.status == 'CLEANUP':
+            result.result()
+            self.set_status("DONE")
+
+        return keep_going
+
+    def add_test(self, tests):
+        """
+        Add a single test or list of tests to this suite.
+        """
+        if isinstance(tests, TestCase):
+            self.tests.append(tests)
+        else:
+            try:
+                for test in tests:
+                    self.add_test(test)
+            except TypeError:
+                pass
+
+    def count_tests(self):
+        return len(self.tests)
+
+    def load_state(self, state):
+        """
+        Restore our state from the supplied dictionary.
+
+        Requires that the fieldnames in the dictionary match the class
+        properties.
+        """
+        # XXX: Should this be done explicitly?
+        self.__dict__.update(state)
+
+        self.tests = []
+        for state_test in state['tests']:
+            test = TestCase(name=state_test['name'], path=state_test['path'],
+                            result=self.result,
+                            _save_state_callback=self.save_state_callback,
+                            _reboot_callback=self.reboot_callback)
+            test.load_state(state_test)
+            self.tests.append(test)
+
+    def save_state(self):
+        state = {
+            'name': self.name,
+            'status': self.status,
+            'passes': self.passes,
+            'failures': self.failures,
+            'errors': self.errors,
+            'tests': [],
+            'ts_setup': self.ts_setup,
+            'ts_cleanup': self.ts_cleanup,
+            'build_cmd': self.build_cmd,
+            'timeout': self.timeout,
+        }
+
+        for test in self.tests:
+            state['tests'].append(test.save_state())
+
+        return state
+
+    def is_done(self):
+        """
+        Determine if the suite is done.  This might mean that something has
+        failed.  Used by Runner to determine if the suite needs to be re-run
+        on resume.
+        """
+        return self.status == 'DONE' or self.status == 'CLEANUP'
+
+    def get_next_test(self):
+        """
+        Return the next test to be run.
+
+        Mainly used for debugging.
+        """
+
+        test = None
+
+        for t in self.tests:
+            if not t.is_done():
+                test = t
+                break
+
+        return test

=== modified file 'uath/exceptions.py'
--- uath/exceptions.py	2012-04-05 15:39:41 +0000
+++ uath/exceptions.py	2012-05-09 00:33:18 +0000
@@ -6,9 +6,3 @@
     """
     def __init__(self, msg):
         self.msg = msg
-
-class BadDir(Exception):
-  pass
-
-class MissingFile(Exception):
-  pass

=== modified file 'uath/provisioning/catalog/__init__.py'
--- uath/provisioning/catalog/__init__.py	2012-04-06 15:23:15 +0000
+++ uath/provisioning/catalog/__init__.py	2012-05-09 00:33:18 +0000
@@ -1,3 +1,3 @@
+from .exceptions import *
 from .base import *
-from .exceptions import *
 from .sqlite import *

=== modified file 'uath/provisioning/catalog/base.py'
--- uath/provisioning/catalog/base.py	2012-04-06 21:35:03 +0000
+++ uath/provisioning/catalog/base.py	2012-05-09 00:33:18 +0000
@@ -1,20 +1,29 @@
 #!/usr/bin/python
 
 import os
-from .exceptions import *
+from uath.provisioning.catalog.exceptions import *
 
 class Catalog(object):
     """
-    Provide a generic class for an arbitrary catlog of machines.
+    Provide a generic class for an arbitrary catalog of machines.
 
-    Raise exceptions for most methods.
+    Raise exceptions for most methods, since they should be defined by
+    subclasses.
+    Except for special read-only cases, subclasses should provide request().
+    Subclasses will generally also need to provide delete() for cleanup
+    purposes.
+    All other methods (read, write, release, destroy) are optional.
     """
-    def __init__(self, uniqueid, lockfile = os.path.expanduser('~/.uath-catalog')):
+    def __init__(self, uniqueid, lockfile=os.path.expanduser('~/.uath-catalog')):
         """
-        To avoid provisioning machines to multiple requestors simultaneously, Catalog implements a lock file.
-        Each catalog type should provide a unique id, which is combined with the class name to generate a catalog identifier.
-        This identifier is stored in the lock file and checked on class instantiation to ensure the same catalog is running.
-        Subclasses can circumvent this by not calling the superclass __init__ function if necessary.
+        To avoid provisioning machines to multiple requestors simultaneously,
+        Catalog implements a lock file.
+        Each catalog type should provide a unique id, which is combined with
+        the class name to generate a catalog identifier.
+        This identifier is stored in the lock file and checked on class
+        instantiation to ensure the same catalog is running.
+        Subclasses can circumvent this by not calling the superclass __init__
+        function if necessary.
         """
         catalog = self.__class__.__name__ + str(uniqueid)
         self.lockfile = lockfile
@@ -31,22 +40,50 @@
 
     def delete(self):
         """
-        Deleting a catalog removes the lock file so another catalog can be created.
+        Delete this catalog and remove the lockfile to facilitate use of
+        another one.
+        Subclasses can call this via super to delete the lockfile, or
+        implement lockfile deletion in their delete() method.
         """
         os.unlink(self.lockfile)
         del self
         
     def read(self):
-        raise UATHProvisioningCatalogException('Method not defined for this catalog')
+        """
+        Read information about the catalog from any available sources.
+        Primarily intended to force a synchronization of new external data if
+        any exists.
+        """
+        return False
 
     def write(self):
-        raise UATHProvisioningCatalogException('Method not defined for this catalog')
+        """
+        Force a commit all current catalog data in memory to internal or
+        external storage.
+        """
+        return False
 
-    def provision(self):
+    def request(self, machinetype=None, *args, **kw):
+        """
+        Return a Machine object that can be provisioned and used to run tests.
+        May interpret arguments and call the appropriate constructor with the
+        appropriate arguments, or may take a Machine class as an argument and
+        send all arguments to that constructor.
+        """
         raise UATHProvisioningCatalogException('Method not defined for this catalog')
 
     def release(self):
-        raise UATHProvisioningCatalogException('Method not defined for this catalog')
+        """
+        Indicate that a machine is not now in use for tests, but may still have
+        a working installed system, potentially suitable for further use.
+        """
+        return False
 
     def destroy(self):
-        raise UATHProvisioningCatalogException('Method not defined for this catalog')
+        """
+        Remove a machine from a catalog so that no further use of it will be
+        requested or expected.
+        Current implementations do not call machine.destroy(), requiring that
+        do be done separately.
+        """
+        return False

=== modified file 'uath/provisioning/catalog/sqlite.py'
--- uath/provisioning/catalog/sqlite.py	2012-04-09 20:29:51 +0000
+++ uath/provisioning/catalog/sqlite.py	2012-05-09 00:33:18 +0000
@@ -2,15 +2,15 @@
 
 import sqlite3
 import os
-from .exceptions import *
-from .base import Catalog
+from uath.provisioning.catalog.exceptions import *
+from uath.provisioning.catalog.base import Catalog
 from uath.provisioning.vm import VMToolsKVM
 
 class SQLiteCatalog(Catalog):
     """
     Base class for SQLite catalog, opens a database connection and sets up a cursor.
     """
-    def __init__(self, db = os.path.expanduser('~/.uath-sqlite-catalog'), *args, **kw):
+    def __init__(self, db=os.path.expanduser('~/.uath-sqlite-catalog'), *args, **kw):
         super(SQLiteCatalog, self).__init__(uniqueid = db, *args, **kw)
         self.db = db
         self.connection = sqlite3.connect(self.db)
@@ -31,9 +31,10 @@
         Initialize simple database.
         """
         super(TinySQLiteCatalog, self).__init__(*args, **kw)
+        self.connection.isolation_level = None
         self.connection.execute('CREATE TABLE IF NOT EXISTS machines(machineid INTEGER PRIMARY KEY, state TEXT)')
 
-    def request(self, machinetype = VMToolsKVM, *args, **kw):
+    def request(self, machinetype=VMToolsKVM, *args, **kw):
         """
         Takes a Machine class as machinetype, and passes the newly generated machineid along with all other arguments to that class's constructor, returning the resulting object.
         """
@@ -46,10 +47,16 @@
         """
         Updates the database to indicate the machine is available.
         """
-        return self.connection.execute("UPDATE machines SET state='available' WHERE machineid=?", [machineid])
+        if self.connection.execute("UPDATE machines SET state='available' WHERE machineid=?", [machineid]):
+            return True
+        else:
+            return False
 
     def destroy(self, machineid):
         """
         Updates the database to indicate the machine is destroyed, but does not destroy the machine.
         """
-        return self.connection.execute("UPDATE machines SET state='destroyed' WHERE machineid=?", [machineid])
+        if self.connection.execute("UPDATE machines SET state='destroyed' WHERE machineid=?", [machineid]):
+            return True
+        else:
+            return False

=== modified file 'uath/provisioning/provisioning.py'
--- uath/provisioning/provisioning.py	2012-04-05 17:14:32 +0000
+++ uath/provisioning/provisioning.py	2012-05-09 00:33:18 +0000
@@ -1,18 +1,52 @@
 #!/usr/bin/python
 
-from .exceptions import *
+import logging
+import logging.handlers
+import os.path
+import socket
+import sys
+
+import apt.cache
+
+from uath.provisioning.exceptions import *
 
 class Machine(object):
     """
     Provide a generic class to provision an arbitrary machine.
 
-    Raise exceptions for most methods.
+    Raise exceptions for most methods, since subclasses should provide them.
+    A fully implemented subclass will provide all public methods except read,
+    I.E.:
+        provisioncheck, activecheck, getclientdeb, installclient
+            (all these can be used from Machine or replaced.)
+        destroy, stop, uploadfiles, downloadfiles, run
+            (these must be implemented separately.)
     """
-    def __init__(self, arch = None, initrd = None, installtype = None, iso = None, kernel = None, machineid = None, name = None, new = False, preseed = None, series = None, template = None):
+    def __init__(self, arch=None, debug=False, image=None, initrd=None,
+                 installtype=None, kernel=None, machineid=None, name=None,
+                 new=False, preseed=None, series=None, template=None):
+        """
+        Initialize the object representing the machine.
+        One of these groups of arguments should be included to specify the
+        provisioning method:
+            series, installtype, arch: Download an ISO from the mirrors and use
+                it to install the machine.
+            image, kernel, initrd, preseed: Install the machine from a
+                specified image/ISO file, with an optional kernel, initrd, and
+                preseed.
+            template: Clone the machine from a template or existing machine.
+            name: Request a specific machine.  Combine with other groups to
+                reinstall a specific machine.
+        Other arguments:
+            debug: Enable debug logging.
+            new: Request a new machine (or a reinstall if a specific machine
+                was requested.)
+        """
         self.arch = arch
+        self.debug = debug
+        self.image = image
         self.initrd = initrd
         self.installtype = installtype
-        self.iso = iso
         self.kernel = kernel
         self.machineid = machineid
         self.name = name
@@ -22,36 +56,176 @@
         self.template = template
         self.provisioned = False
         self.active = False
+        self.logger = logging.getLogger('uath.provisioning' + self.name)
+        self._loggersetup()
+        self.logger.debug('Machine init finished')
+
+    def _loggersetup(self):
+        """
+        Initialize the logging for the machine.
+        Subclasses can override or supplement to customize logging.
+        """
+        self.consolehandler = logging.StreamHandler(stream = sys.stderr)
+        self.consolehandler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
+        self.consolehandler.setLevel(logging.WARNING)
+        self.filehandler = logging.handlers.WatchedFileHandler('/var/log/uath/' + socket.gethostname() + '.log')
+        self.filehandler.setFormatter(logging.Formatter('%(asctime)s ' + self.name + ' %(levelname)s: %(message)s'))
+        self.filehandler.setLevel(logging.DEBUG)
+        self.logger.addHandler(self.consolehandler)
+        self.logger.addHandler(self.filehandler)
+        if self.debug:
+            self.logger.setLevel(logging.DEBUG)
+        else:
+            self.logger.setLevel(logging.INFO)
 
     def provisioncheck(self):
         """
-        Make sure the machine is provisioned.
+        Check if the machine is provisioned, provision it if necessary, and
+        raise an exception if it cannot be provisioned.
         """
+        self.logger.debug('Checking if machine is provisioned')
         if not self.provisioned:
-            self.provision()
+            self._provision()
 
     def activecheck(self):
         """
-        Make sure the machine is running.
+        Check if the machine is running and able to accept comamnds, start it
+        if necessary, and raise an exception if it cannot be started.
         """
+        self.logger.debug('Checking if machine is active')
         if not self.active:
-            self.start()
-
-    def provision(self):
+            self._start()
+
+    def getclientdeb(self):
+        """
+        Return the path of the .deb file for the
+        ubuntu-automation-test-harness-client installed as part of the main
+        package.
+        """
+        debpath = os.path.normpath(os.path.join('/usr','share','uath','ubuntu-automation-test-harness-client_' + apt.cache.Cache()['ubuntu-automation-test-harness'].installedVersion + '_all.deb'))
+        self.logger.debug('Client deb path is ' + debpath)
+        return debpath
+
+    def installclient(self):
+        """
+        Install the ubuntu-automation-test-harness-client package on the
+        machine, and raise an exception if this fails.
+        """
+        self.logger.info('Installing client deb on machine')
+        tmppath = os.path.normpath('/tmp')
+        if self.uploadfiles([self.getclientdeb()], tmppath):
+            if self.run('DEBIAN_FRONTEND=noninteractive dpkg -i ' + os.path.join(tmppath, os.path.split(self.getclientdeb())[1]) + ' || apt-get -y -f install', root = True) == 0:
+                return True
+            else:
+                self.logger.error('Failed to install and configure ' + self.getclientdeb())
+                raise UATHProvisioningException('Failed to install and configure ' + self.getclientdeb())
+        else:
+            self.logger.error('Failed to copy ' + self.getclientdeb() + ' to machine')
+            raise UATHProvisioningException('Failed to copy ' + self.getclientdeb() + ' to machine')
+
+    def _provision(self):
+        """
+        Ready the machine for use, and set provisioned to True.
+        If new=True or the machine is not installed, this should install the
+        machine, possibly by calling _create().
+        If an existing machine is requested, this should make the machine
+        available, possibly by caling _load().
+        Should generally not be called directly outside of the class;
+        provisioncheck() or activecheck() should be used.
+        """
         raise UATHProvisioningException('Method not defined for this machine type')
 
-    def create(self):
+    def _create(self):
+        """
+        Install the system on the machine, and return True on success.
+        Can take arguments if provided by provisioncheck(), or can read
+        internal variables populated by __init__().
+        Should generally not be called directly outside of the class;
+        provisioncheck() or activecheck() should be used.