Merge lp:~javier.collado/utah/trunk-0.8 into lp:~nuclearbob/utah/trunk

[Javier Collado]

This branch contains all the changes for version 0.8.

[Javier Collado (javier.collado)]

I see the changes merged, so this request can be approved.

review: Approve

=== modified file 'debian/changelog'
--- debian/changelog	2013-01-29 19:18:51 +0000
+++ debian/changelog	2013-02-15 17:42:27 +0000
@@ -1,3 +1,20 @@
+utah (0.8ubuntu1) quantal; urgency=low
+
+  [Max Brustkern]
+  * Raise exception on mount ISO error (LP: #1110550, LP: #1123899)
+
+  [Javier Collado]
+  * SIGTERM signal captured to ensure cleanup happens (LP: #1100550, LP: #1123899)
+  * Warning messages contain command on failure return code (LP: #1123896)
+  * Battery information added to test report if available
+  * /etc/rc.local truncation problems fixed (LP: #1118581)
+  * Ability to execute runlists in an already provisioned system
+
+  [Joe Talbott]
+  * Fixed client behavior on `bzr revno` failure (LP: #1110310, LP: #1123303)
+
+ -- Javier Collado <[e-mail]>  Fri, 15 Feb 2013 18:32:06 +0100
+
 utah (0.7ubuntu1) precise; urgency=low
 
   * Updating to version 0.7

=== modified file 'examples/run_test_vm.py'
--- examples/run_test_vm.py	2013-01-23 12:26:38 +0000
+++ examples/run_test_vm.py	2013-02-15 17:42:27 +0000
@@ -21,7 +21,11 @@
 from utah.exceptions import UTAHException
 from utah.group import check_user_group, print_group_error_message
 from utah.provisioning.vm.vm import TinySQLiteInventory
-from utah.run import common_arguments, run_tests, configure_logging
+from utah.run import (
+    common_arguments,
+    run_tests,
+    configure_logging,
+)
 
 
 def get_parser():

=== modified file 'examples/run_utah_tests.py'
--- examples/run_utah_tests.py	2013-01-23 12:26:38 +0000
+++ examples/run_utah_tests.py	2013-02-15 17:42:27 +0000
@@ -26,10 +26,13 @@
     file_arguments,
     name_argument,
     virtual_arguments,
-    configure_logging
+    configure_logging,
+    run_tests,
 )
 from utah.timeout import timeout, UTAHTimeout
 from run_install_test import run_install_test
+from utah.provisioning.ssh import ProvisionedMachine
+from utah.exceptions import UTAHException
 
 
 def get_parser():
@@ -50,6 +53,9 @@
                         help='Type of machine to provision (%(choices)s)')
     parser.add_argument('-v', '--variant',
                         help='Variant of architecture, i.e., armel, armhf')
+    parser.add_argument('--skip-provisioning', action='store_true',
+                        help=('Reuse a system that is already provisioned '
+                              '(name argument must be passed)'))
     parser = common_arguments(parser)
     parser = custom_arguments(parser)
     parser = file_arguments(parser)
@@ -76,6 +82,26 @@
     # Default is now CustomVM
     function = run_install_test
 
+    if args.skip_provisioning:
+        def run_provisioned_tests(args):
+            """Run test cases in a provisioned machine."""
+            locallogs = []
+            exitstatus = 0
+            try:
+                # TBD: Inventory should be used to verify machine
+                # is not running other tests
+                machine = ProvisionedMachine(name=args.name)
+                exitstatus, locallogs = run_tests(args, machine)
+            except UTAHException as error:
+                sys.stderr.write('Exception: ' + str(error))
+                exitstatus = 2
+            finally:
+                if len(locallogs) != 0:
+                    print('Test logs copied to the following files:')
+                    print("\t" + "\n\t".join(locallogs))
+            sys.exit(exitstatus)
+
+        function = run_provisioned_tests
     if args.arch is not None and 'arm' in args.arch:
         # If arch is arm, use BambooFeederMachine
         from run_test_bamboo_feeder import run_test_bamboo_feeder

=== added file 'utah/client/battery.py'
--- utah/client/battery.py	1970-01-01 00:00:00 +0000
+++ utah/client/battery.py	2013-02-15 17:42:27 +0000
@@ -0,0 +1,83 @@
+"""Helpers for battery measurements."""
+import os
+import re
+import logging
+
+
+class _Battery(object):
+    """Battery information gathering."""
+    POWER_SUPPLY_DIR = '/sys/class/power_supply'
+    BATTERY_DIR_REGEX = re.compile(r'bat.*', re.IGNORECASE)
+    BATTERY_FILE_REGEX = re.compile(r'(.*_now|capacity|status)')
+
+    def __init__(self):
+        self.filenames = self._get_files()
+
+    def get_data(self):
+        """Get data from the battery information files
+
+        Every file is read and the contents of the file is written to a
+        dictionary using as key the basename of the file.
+
+        :returns: Data as read from the battery information files
+        :rtype: dict
+        """
+        def read_file(filename):
+            """Read contents of a file and try to convert data to integer
+
+            :param filename: Path to file to be read
+            :type filename: str
+            :returns: File contents converted to integer if possible
+            :rtype: str | int
+            """
+            with open(filename, 'r') as f:
+                data_str = f.read().strip()
+                try:
+                    data_int = int(data_str)
+                    return data_int
+                except ValueError:
+                    return data_str
+
+        return {os.path.basename(filename): read_file(filename)
+                for filename in self.filenames}
+
+    def _get_files(self):
+        """Figure out which files to look at.
+
+        :returns: Paths to files with battery information.
+        :rtype: list(str)
+
+        """
+        if not os.path.isdir(self.POWER_SUPPLY_DIR):
+            logging.warning('Power supply directory not found: {!r}'
+                            .format(self.POWER_SUPPLY_DIR))
+            return []
+
+        entries = [os.path.join(self.POWER_SUPPLY_DIR, entry)
+                   for entry in os.listdir(self.POWER_SUPPLY_DIR)
+                   if self.BATTERY_DIR_REGEX.match(entry)]
+        subdirectories = [entry for entry in entries
+                          if os.path.isdir(entry)]
+
+        if not subdirectories:
+            logging.warning('Battery information directory not found')
+            return []
+
+        if len(subdirectories) > 1:
+            logging.error('Multiple battery information directories found: '
+                          '{}'.format(', '.join(subdirectories)))
+            return []
+
+        subdirectory = subdirectories[0]
+        entries = [os.path.join(subdirectory, filename)
+                   for filename in os.listdir(subdirectory)
+                   if self.BATTERY_FILE_REGEX.match(filename)]
+        filenames = [filename for filename in entries
+                     if os.path.isfile(filename)]
+
+        logging.debug('Battery information files found: {}'
+                      .format(', '.join(filenames)))
+        return filenames
+
+# Use singleton object to avoid multiple unneeded initializations
+battery = _Battery()

=== modified file 'utah/client/common.py'
--- utah/client/common.py	2012-12-10 14:07:05 +0000
+++ utah/client/common.py	2013-02-15 17:42:27 +0000
@@ -35,6 +35,8 @@
     YAMLEmptyFile,
 )
 
+from utah.client.battery import battery
+
 
 PASS = 0
 FAIL = 1
@@ -101,6 +103,7 @@
     def alarm_handler(_signum, _frame):
         raise TimeoutAlarm
 
+    start_battery = battery.get_data()
     start_time = datetime.datetime.now()
     p = subprocess.Popen("{} {}".format(cmd_prefix, command),
                          shell=True, cwd=cwd,
@@ -141,6 +144,7 @@
                            )
 
     time_delta = datetime.datetime.now() - start_time
+    end_battery = battery.get_data()
 
     return make_result(command=command,
                        retcode=p.returncode,
@@ -150,6 +154,8 @@
                        time_delta=str(time_delta),
                        cmd_type=cmd_type,
                        user=run_as,
+                       start_battery=start_battery,
+                       end_battery=end_battery,
                        )
 
 
@@ -172,7 +178,8 @@
 # TODO: it might make sense to have a result object that keeps track of
 # test pass, fail, error and serializes it's data.
 def make_result(command, retcode, stdout='', stderr='', start_time='',
-                time_delta='', cmd_type=CMD_TC_TEST, user="unknown"):
+                time_delta='', cmd_type=CMD_TC_TEST, user="unknown",
+                start_battery=None, end_battery=None):
     """
     Make a result dictionary.
     """
@@ -187,6 +194,13 @@
         'user': user,
     }
 
+    if start_battery or end_battery:
+        res['battery'] = {}
+    if start_battery:
+        res['battery']['start'] = start_battery
+    if end_battery:
+        res['battery']['end'] = end_battery
+
     return res
 
 

=== modified file 'utah/client/result.py'
--- utah/client/result.py	2012-12-08 02:10:12 +0000
+++ utah/client/result.py	2013-02-15 17:42:27 +0000
@@ -71,6 +71,8 @@
         self.publish_type = publish_type
         self.publish = None
         self.install_type = install_type
+        self.start_battery = None
+        self.end_battery = None
 
         self.errors = 0
         self.fetch_errors = 0
@@ -207,6 +209,13 @@
         if self.publish is not None:
             data['publish'] = self.publish
 
+        if self.start_battery or self.end_battery:
+            data['battery'] = {}
+            if self.start_battery:
+                data['battery']['start'] = self.start_battery
+            if self.end_battery:
+                data['battery']['end'] = self.end_battery
+
         return data
 
 

=== modified file 'utah/client/runner.py'
--- utah/client/runner.py	2012-12-12 11:21:10 +0000
+++ utah/client/runner.py	2013-02-15 17:42:27 +0000
@@ -18,12 +18,17 @@
 from utah.client.testsuite import TestSuite
 from utah.client.state_agent import StateAgentYAML
 from utah.client import exceptions
+from utah.exceptions import UTAHException
+from utah.timeout import timeout
+from utah.retry import retry
+from utah.client.battery import battery
 
 import os
 import shutil
 import stat
 import urllib
 import jsonschema
+import time
 
 from utah.client.common import (
     MASTER_RUNLIST,
@@ -251,6 +256,7 @@
         """
         Run the test suites we've parsed.
         """
+        self.result.start_battery = battery.get_data()
 
         # Return value to indicate whether processing of a Runner should
         # continue.  This is to avoid a shutdown race on reboot cases.
@@ -273,6 +279,7 @@
         self.status = "DONE"
         self.save_state()
 
+        self.result.end_battery = battery.get_data()
         return self.process_results()
 
     def add_suite(self, suite):
@@ -443,9 +450,20 @@
             if not os.path.exists(name):
                 os.mkdir(name)
 
+            def vcs_get_retriable():
+                result = vcs_handler.get(directory=name)
+                if (isinstance(vcs_handler, BzrHandler) and
+                        result['returncode'] == 3 and
+                        'Unable to handle http code 502' in result['stderr']):
+                    # Separate every retry attempt with a timeout of 3 seconds
+                    time.sleep(3)
+                    raise UTAHException('Launchpad temporary error detected',
+                                        retry=True)
+                return result
+
             if name not in self.fetched_suites:
-
-                res = vcs_handler.get(directory=name)
+                # Retry bzr export on http errors for 60 seconds
+                res = timeout(60, retry, vcs_get_retriable)
                 self.result.add_result(res)
 
                 # If fetch failed move on to the next testsuite.
@@ -457,6 +475,11 @@
                 res = vcs_handler.revision(directory=rev_dir)
                 self.result.add_result(res)
 
+                # If we're unable to get the revision number indicate a
+                # fetch failure but allow the test runs to proceed.
+                if self.result.status != 'PASS':
+                    self.result.status = 'PASS'
+
                 self.fetched_suites.append(name)
 
                 # Create a TestSuite

=== modified file 'utah/provisioning/baremetal/cobbler.py'
--- utah/provisioning/baremetal/cobbler.py	2013-01-29 16:43:59 +0000
+++ utah/provisioning/baremetal/cobbler.py	2013-02-15 17:42:27 +0000
@@ -20,7 +20,6 @@
 import netifaces
 import os
 import pipes
-import shutil
 import subprocess
 import tempfile
 import time
@@ -107,8 +106,14 @@
             self.cleanfunction(self._removenfs)
             os.makedirs(self.isodir, mode=0775)
             self.logger.debug('Mounting ISO')
-            self._runargs(['sudo', 'mount', '-o', 'loop', self.image.image,
-                           self.isodir])
+            result = self._runargs(['sudo', 'mount', '-o', 'loop',
+                                    self.image.image,
+                                    self.isodir])
+            returncode = result['returncode']
+            if returncode != 0:
+                raise UTAHBMProvisioningException(
+                    'Mount failed with return code: {} Output: {}'
+                    .format(returncode, result['output']))
 
         kernel = self._preparekernel()
         if self.cinitrd is None:
@@ -282,14 +287,14 @@
 
     def _depcheck(self):
         """
-        Check for NFS if installtype is desktop.
+        Check for NFS if installtype requires it.
         """
         super(CobblerMachine, self)._depcheck()
-        if self.installtype == 'desktop':
+        if self.installtype in ['alternate', 'desktop', 'server']:
             cmd = config.nfscommand + ['status']
             if self._runargs(cmd)['returncode'] != 0:
-                raise UTAHBMProvisioningException('NFS needed for desktop'
-                                                  ' install')
+                raise UTAHBMProvisioningException(
+                    'NFS needed for {} install'.format(self.installtype))
             if not os.path.isfile(config.nfsconfigfile):
                 raise UTAHBMProvisioningException(
                     'NFS config file: {nfsconfigfile} not available'

=== modified file 'utah/provisioning/provisioning.py'
--- utah/provisioning/provisioning.py	2013-01-24 16:31:58 +0000
+++ utah/provisioning/provisioning.py	2013-02-15 17:42:27 +0000
@@ -302,15 +302,29 @@
             self._start()
 
     def pingcheck(self, timeout=config.checktimeout):
-        """Check network connectivity using ping."""
-        self.logger.info('Sleeping {timeout} seconds'
-                         .format(timeout=timeout))
-        time.sleep(timeout)
+        """Check network connectivity using ping.
+
+        :param timeout: Amount of time in seconds to sleep after a failure
+        :type timeout: int
+        :raises: UTAHProvisioningException
+
+        If there's a network connectivity failure, then sleep ``timeout``
+        seconds and raise a retriable exception.
+
+        .. seealso:: :func:`utah.retry.retry`, :meth:`pingpoll`
+
+        """
         self.logger.info('Checking network connectivity (ping)')
         returncode = \
             self._runargs(['ping', '-c1', '-w5', self.name])['returncode']
         if returncode != 0:
             err = 'Ping returned {0}'.format(returncode)
+
+            if timeout > 0:
+                self.logger.info('Sleeping {timeout} seconds'
+                                 .format(timeout=timeout))
+                time.sleep(timeout)
+
             raise UTAHProvisioningException(err, retry=True)
 
     def pingpoll(self,
@@ -551,9 +565,11 @@
         output = '\n'.join(output)
 
         returncode = p.returncode
-        log_level = logging.DEBUG if returncode == 0 else logging.WARNING
-        log_message = 'Return code: {}'.format(returncode)
-        self.logger.log(log_level, log_message)
+        if returncode == 0:
+            self.logger.debug('Return code: {}'.format(returncode))
+        else:
+            self.logger.warning('Command ({}) failed with return code: {}'
+                                .format(' '.join(arglist), returncode))
 
         return {'returncode': returncode,
                 'output': output}
@@ -854,12 +870,18 @@
                           .format(self.CHECK_LOCK_COMMAND, pkg_name, log_file)
                           for pkg_name in config.installpackages]))
             postinstall_commands = (
-                'sed -i -e "/^exit 0$/i{}" /etc/rc.local;'
+                'sed -i -e \'/^exit 0$/i{}\' /etc/rc.local;'
                 .format(install_commands)
             )
             chroot_command = ' '.join([install_commands, postinstall_commands])
-            question.value.prepend('in-target sh -c \'{}\'; '
-                                   .format(chroot_command))
+            # Note that since the chroot command is passed to sh within single
+            # quotes, the single quotes inside the chroot command have to be
+            # escaped using '"'"'
+            # For more information, please refer to:
+            # http://stackoverflow.com/q/1250079/183066
+            question.value.prepend(
+                'in-target sh -c \'{}\'; '
+                .format(chroot_command.replace('\'', '\'"\'"\'')))
             question.prepend("ubiquity ubiquity/summary note")
             question.prepend("ubiquity ubiquity/reboot boolean true")
         else:

=== modified file 'utah/provisioning/ssh.py'
--- utah/provisioning/ssh.py	2013-01-23 09:10:16 +0000
+++ utah/provisioning/ssh.py	2013-02-15 17:42:27 +0000
@@ -14,7 +14,8 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Provide a mixin class for machines with SSH support.
+SSH based machine class for a provisioned system
+and SSHMixin for every machine class that needs SSH support.
 """
 
 import logging
@@ -29,6 +30,7 @@
 
 from utah import config
 from utah.provisioning.exceptions import UTAHProvisioningException
+from utah.provisioning.provisioning import Machine
 from utah.retry import retry
 
 
@@ -40,6 +42,15 @@
         # Note: Since this is a mixin it doesn't expect any argument
         # However, it calls super to initialize any other mixins in the mro
         super(SSHMixin, self).__init__(*args, **kwargs)
+        self.initialize()
+
+    def initialize(self):
+        """SSH mixin initialization
+
+        Use this method when it isn't appropriate to follow the MRO as in
+        __init__
+
+        """
         ssh_client = paramiko.SSHClient()
         ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         self.ssh_client = ssh_client
@@ -85,9 +96,12 @@
         self.ssh_logger.debug('Closing SSH connection')
         self.ssh_client.close()
 
-        log_level = logging.DEBUG if retval == 0 else logging.WARNING
-        log_message = 'Return code: {}'.format(retval)
-        self.ssh_logger.log(log_level, log_message)
+        if retval == 0:
+            self.ssh_logger.debug('Return code: {}'.format(retval))
+        else:
+            self.ssh_logger.warning(
+                'SSH command ({}) failed with return code: {}'
+                .format(commandstring, retval))
 
         self.ssh_logger.debug('Standard output follows:')
         stdout_lines = stdout.readlines()
@@ -223,20 +237,29 @@
         super(SSHMixin, self).destroy(*args, **kw)
 
     def sshcheck(self, timeout=config.checktimeout):
-        """
-        Sleep for a while and check if the machine is available via ssh.
-        Return a retryable exception if it is not.
-        Intended for use with retry.
-        """
-        self.ssh_logger.info('Sleeping {timeout} seconds'
-                             .format(timeout=timeout))
-        time.sleep(timeout)
+        """Check if the machine is available via ssh.
+
+        :param timeout: Amount of time in seconds to sleep after a failure
+        :type timeout: int
+        :raises: UTAHProvisioningException
+
+        If there's a network connectivity failure, then sleep ``timeout``
+        seconds and raise a retriable exception.
+
+        .. seealso:: :func:`utah.retry.retry`, :meth:`sshpoll`
+
+        """
         self.ssh_logger.info('Checking for ssh availability')
         try:
             self.ssh_client.connect(self.name,
                                     username=config.user,
                                     key_filename=config.sshprivatekey)
         except socket.error as err:
+            if timeout > 0:
+                self.ssh_logger.info('Sleeping {timeout} seconds'
+                                     .format(timeout=timeout))
+                time.sleep(timeout)
+
             raise UTAHProvisioningException(str(err), retry=True)
 
     def sshpoll(self, timeout=None,
@@ -260,3 +283,41 @@
         if not self.active:
             self._start()
             self.sshcheck()
+
+
+class ProvisionedMachine(SSHMixin, Machine):
+    """A machine that is provisioned and can be accessed through ssh."""
+    def __init__(self, name, installtype=None):
+        SSHMixin.initialize(self)
+        self.name = name
+        self._loggersetup()
+
+        # No cleanup needed for systems that are already provisioned
+        self.clean = False
+
+        # System is expected to be available already, so there's no need to
+        # wait before trying to connect through ssh
+        self.check_timeout = 3
+        self.connectivity_timeout = 60
+
+        # TBD: Figure out install type by getting information through ssh
+        if installtype is None:
+            self.installtype = config.installtype
+
+    def activecheck(self):
+        """Check if machine is active.
+
+        Given that the machine is already provisioned, it's considered to be
+        active as long as it's reachable through ssh
+
+        """
+        try:
+            self.pingpoll(timeout=self.connectivity_timeout,
+                          checktimeout=self.check_timeout)
+        except utah.timeout.UTAHTimeout:
+            # Ignore timeout for ping, since depending on the network
+            # configuration ssh might still work despite of the ping failure.
+            self.logger.warning('Network connectivity (ping) failure')
+
+        self.sshpoll(timeout=self.connectivity_timeout,
+                     checktimeout=self.check_timeout)

=== modified file 'utah/retry.py'
--- utah/retry.py	2012-12-03 14:02:18 +0000
+++ utah/retry.py	2013-02-15 17:42:27 +0000
@@ -23,9 +23,26 @@
 
 
 def retry(command, *args, **kw):
-    """
-    Retry an operation until it completes or an exception is raised without
-    retry set to True.
+    """Retry a command as long as a retriable exception is captured.
+
+    A retriable exception is considered to be a
+    ``UTAHException`` that has the attribute ``retry`` set to
+    ``True``.
+
+    :param command: Command to be executed.
+    :type command: callable
+    :param args: Positional arguments to be passed to the callable.
+    :param kwargs:
+        Keyword arguments to be passed to the callable.
+
+        .. note::
+            If a keyword argument named ``logmethod`` is found, it will be
+            extracted (i.e. it won't be passed to the callable) and used to log
+            every retry attempt (using ``sys.stderr`` by default).
+    :returns: The value returned by the callable.
+
+    .. seealso:: :func:`utah.timeout.timeout`
+
     """
     try:
         logmethod = kw.pop('logmethod')

=== modified file 'utah/run.py'
--- utah/run.py	2013-01-23 12:26:38 +0000
+++ utah/run.py	2013-02-15 17:42:27 +0000
@@ -22,10 +22,12 @@
 import urllib
 import traceback
 import shutil
+import signal
 
 from utah import config
 from utah.exceptions import UTAHException
 from utah.url import url_argument
+from utah.provisioning.ssh import ProvisionedMachine
 
 
 def common_arguments(parser):
@@ -111,6 +113,8 @@
     """
     Run some tests and retrieve results.
     """
+    install_sigterm_handler()
+
     if args.json:
         report_type = 'json'
     else:
@@ -193,7 +197,10 @@
             except Exception as err:
                 logging.warning('Failed to download files: ' + str(err))
 
-    if args.outputpreseed or config.outputpreseed:
+    # Provisioned systems have an image already installed
+    # and the preseed file is no longer available
+    if (not isinstance(machine, ProvisionedMachine) and
+            (args.outputpreseed or config.outputpreseed)):
         if args.outputpreseed:
             logging.debug('Capturing preseed due to command line option')
         elif config.outputpreseed:
@@ -287,3 +294,19 @@
     logger = logging.getLogger('paramiko')
     logger.propagate = False
     logger.addHandler(ssh_file_handler)
+
+
+def install_sigterm_handler():
+    """Capture SIGTERM signal to avoid abrupt process termination.
+
+    This function registers a handler that raises an exception when SIGTERM is
+    received to ensure that machine object cleanup methods are called.
+    Otherwise, cleanup methods aren't called when the process is abruptly
+    terminated.
+
+    """
+    def handler(signum, frame):
+        """Raise exception when signal is received."""
+        raise UTAHException('Signal received: {}'.format(signum))
+
+    signal.signal(signal.SIGTERM, handler)

=== modified file 'utah/timeout.py'
--- utah/timeout.py	2012-12-08 02:10:12 +0000
+++ utah/timeout.py	2013-02-15 17:42:27 +0000
@@ -25,18 +25,29 @@
 
 
 class UTAHTimeout(UTAHException):
-    """
-    Provide a special exception to indicate an operation timed out.
-    """
+    """Provide a special exception to indicate an operation timed out."""
 
 
 # Mostly pulled from utah/client/common.py
 # Inspired by:
 # http://stackoverflow.com/a/3326559
 def timeout(timeout, command, *args, **kw):
-    """
-    Run command with all other arguments for up to timeout seconds, after with
-    a UTAHTimeout exception is returned.
+    """Run a command for up to ``timeout`` seconds.
+
+    :param timeout:
+        Maximum amount of time to wait for the command to complete in seconds.
+    :type timeout: int
+    :param command:
+        Command whose execution should complete before timeout expires.
+    :type command: callable
+    :param args: Positional arguments to be passed to the callable.
+    :param kwargs: Keyword arguments to be passed to the callable.
+    :returns: The value returned by the callable.
+    :raises UTAHTimeout:
+        If command execution hasn't finished before ``timeout`` seconds.
+
+    .. seealso:: :func:`utah.retry.retry`
+
     """
     #TODO: Better support for nested timeouts.
     if command is None:
@@ -71,11 +82,20 @@
 
 
 def subprocesstimeout(timeout, *args, **kw):
-    """
-    Pass all arguments except timeout to subprocess.Popen and run for timeout
-    seconds.
-    After the timeout is reached, kill all subprocesses and return a
-    UTAHTimeout exception.
+    """Run command through ``subprocess.Popen`` for up to ``timeout`` seconds.
+
+    Command termination is checked using ``subprocess.Popen.poll``.
+
+    :param timeout:
+        Maximum amount of time to wait for the command to complete in seconds.
+    :type timeout: int
+    :param args: Positional arguments to be passed to ``subprocess.Popen``.
+    :param kwargs: Keyword arguments to be passed to the ``subprocess.Popen``.
+    :returns: The subprocess object
+    :rtype: ``subprocess.Popen``
+    :raises UTAHTimeout:
+        If command execution hasn't finished before ``timeout`` seconds.
+
     """
     if args is None:
         return
@@ -118,8 +138,13 @@
 
 
 def get_process_children(pid):
-    """
-    Find process children so they can be killed when the timeout expires.
+    """Find process children so they can be killed when the timeout expires.
+
+    :param pid: Process ID for the parent process
+    :type pid: int
+    :returns: The pid for each children process
+    :rtype: list(int)
+
     """
     p = subprocess.Popen('ps --no-headers -o pid --ppid %d' % pid, shell=True,
                          stdout=subprocess.PIPE, stderr=subprocess.PIPE)

=== modified file 'utah/url.py'
--- utah/url.py	2012-12-13 13:48:54 +0000
+++ utah/url.py	2013-02-15 17:42:27 +0000
@@ -24,6 +24,7 @@
 import urllib2
 import tempfile
 import logging
+import time
 from urlparse import urlparse
 from argparse import ArgumentTypeError
 
@@ -32,6 +33,8 @@
 import bzrlib.errors
 
 from utah.exceptions import UTAHException
+from utah.timeout import timeout
+from utah.retry import retry
 
 
 # Inspired by: http://stackoverflow.com/a/2070916/183066
@@ -212,8 +215,25 @@
         cmd = bzrlib.builtins.cmd_export()
         assert cmd is not None
         tmp_dir = tempfile.mkdtemp(prefix='utah_')
+
+        def bzr_export_retriable():
+            """bzr export a URL retrying on http errors
+
+            This is a workaround to launchpad problems with http URLs that
+            happen from time to time
+
+            """
+            try:
+                cmd.run(tmp_dir, url)
+            except bzrlib.errors.InvalidHttpResponse as exception:
+                # Separate every retry attempt with a timeout of 3 seconds
+                time.sleep(3)
+                raise UTAHException(exception.path, exception.msg, retry=True)
+
         try:
-            cmd.run(tmp_dir, url)
+            # Retry bzr export on http errors for 60 seconds
+            timeout(60, retry, bzr_export_retriable,
+                    logmethod=bzr_logger.debug)
         except bzrlib.errors.BzrError as exception:
             raise ArgumentTypeError('Bazaar export error: {}'
                                     .format(exception))