teuthology 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

teuthology/orchestra/run.py

@@ -9,7 +9,7 @@ from paramiko import ChannelFile
 import gevent
 import gevent.event
 import socket
-import pipes
+import shlex
 import logging
 import shutil
 
@@ -252,7 +252,7 @@ def quote(args):
             if isinstance(a, Raw):
                 yield a.value
             else:
-                yield pipes.quote(a)
+                yield shlex.quote(a)
     if isinstance(args, list):
         return ' '.join(_quote(args))
     else:
@@ -400,7 +400,7 @@ def run(
     """
     Run a command remotely.  If any of 'args' contains shell metacharacters
     that you want to pass unquoted, pass it as an instance of Raw(); otherwise
-    it will be quoted with pipes.quote() (single quote, and single quotes
+    it will be quoted with shlex.quote() (single quote, and single quotes
     enclosed in double quotes).
 
     :param client: SSHConnection to run the command with

teuthology/packaging.py

@@ -395,12 +395,12 @@ def _get_config_value_for_remote(ctx, remote, config, key):
 
         config = {
             'all':
-                {'branch': 'master'},
+                {'branch': 'main'},
             'branch': 'next'
         }
         _get_config_value_for_remote(ctx, remote, config, 'branch')
 
-    would return 'master'.
+    would return 'main'.
 
     :param ctx: the argparse.Namespace object
     :param remote: the teuthology.orchestra.remote.Remote object
@@ -479,7 +479,7 @@ class GitbuilderProject(object):
         )
         # when we're initializing with a remote we most likely have
         # a task config, not the entire teuthology job config
-        self.flavor = self.job_config.get("flavor", "basic")
+        self.flavor = self.job_config.get("flavor", "default")
         self.tag = self.job_config.get("tag")
 
     def _init_from_config(self):
@@ -549,10 +549,6 @@ class GitbuilderProject(object):
         """
         The base url that points at this project on gitbuilder.
 
-        For example::
-
-            http://gitbuilder.ceph.com/ceph-deb-raring-x86_64-basic/ref/master
-
         :returns: A string of the base url for this project
         """
         return self._get_base_url()
@@ -656,9 +652,9 @@ class GitbuilderProject(object):
         remote, the sha1 from the config will be used.
 
         If a tag, branch or sha1 can't be found it will default to use the
-        build from the master branch.
+        build from the main branch.
 
-        :returns: A string URI. Ex: ref/master
+        :returns: A string URI. Ex: ref/main
         """
         ref_name, ref_val = next(iter(self._choose_reference().items()))
         if ref_name == 'sha1':
@@ -673,7 +669,7 @@ class GitbuilderProject(object):
         Decide which to use.
 
         :returns: a single-key dict containing the name and value of the
-                  reference to use, e.g. {'branch': 'master'}
+                  reference to use, e.g. {'branch': 'main'}
         """
         tag = branch = sha1 = None
         if self.remote:
@@ -716,8 +712,8 @@ class GitbuilderProject(object):
             warn('sha1')
             return dict(sha1=sha1)
         else:
-            log.warning("defaulting to master branch")
-            return dict(branch='master')
+            log.warning("defaulting to main branch")
+            return dict(branch='main')
 
     def _get_base_url(self):
         """
@@ -879,8 +875,6 @@ class ShamanProject(GitbuilderProject):
     @property
     def _search_uri(self):
         flavor = self.flavor
-        if flavor == 'basic':
-            flavor = 'default'
         req_obj = OrderedDict()
         req_obj['status'] = 'ready'
         req_obj['project'] = self.project
@@ -983,6 +977,9 @@ class ShamanProject(GitbuilderProject):
         except VersionNotFoundError:
             return False
 
+        # self._result has status, project, flavor, distros, arch, and sha1
+        # restrictions, so the only reason for multiples should be "multiple
+        # builds of the same sha1 etc."; the first entry is the newest
         search_result = self._result.json()[0]
 
         # now look for the build complete status
@@ -996,14 +993,20 @@ class ShamanProject(GitbuilderProject):
             resp.raise_for_status()
         except requests.HttpError:
             return False
+        log.debug(f'looking for {self.distro} {self.arch} {self.flavor}')
         for build in resp.json():
+            log.debug(f'build: {build["distro"]}/{build["distro_version"]} {build["distro_arch"]} {build["flavor"]}')
             if (
+                # we must compare build arch to self.arch, since shaman's
+                # results can have multiple arches but we're searching
+                # for precisely one here
                 build['distro'] == search_result['distro'] and
                 build['distro_version'] == search_result['distro_version'] and
                 build['flavor'] == search_result['flavor'] and
-                build['distro_arch'] in search_result['archs']
+                build['distro_arch'] == self.arch and
+                build['status'] == 'completed'
                ):
-                return build['status'] == 'completed'
+                return True
         return False
 
     def _get_repo(self):

teuthology/provision/__init__.py

@@ -1,5 +1,7 @@
 import logging
+import os
 
+import teuthology.exporter
 import teuthology.lock.query
 from teuthology.misc import decanonicalize_hostname, get_distro, get_distro_version
 
@@ -8,19 +10,19 @@ from teuthology.provision import downburst
 from teuthology.provision import fog
 from teuthology.provision import openstack
 from teuthology.provision import pelagos
-import os
 
 log = logging.getLogger(__name__)
 
 
-def _logfile(ctx, shortname):
-    if hasattr(ctx, 'config') and ctx.config.get('archive_path'):
-        return os.path.join(ctx.config['archive_path'],
-                            shortname + '.downburst.log')
+def _logfile(shortname: str, archive_path: str = ""):
+    if os.path.isfile(archive_path):
+        return f"{archive_path}/{shortname}.downburst.log"
+
 
 def get_reimage_types():
     return pelagos.get_types() + fog.get_types()
 
+
 def reimage(ctx, machine_name, machine_type):
     os_type = get_distro(ctx)
     os_version = get_distro_version(ctx)
@@ -36,7 +38,21 @@ def reimage(ctx, machine_name, machine_type):
     else:
         raise Exception("The machine_type '%s' is not known to any "
                         "of configured provisioners" % machine_type)
-    return obj.create()
+    status = "fail"
+    try:
+        result = obj.create()
+        status = "success"
+    except Exception:
+        # We only need this clause so that we avoid triggering the finally
+        # clause below in cases where the exception raised is KeyboardInterrupt
+        # or SystemExit
+        raise
+    finally:
+        teuthology.exporter.NodeReimagingResults().record(
+            machine_type=machine_type,
+            status=status,
+        )
+    return result
 
 
 def create_if_vm(ctx, machine_name, _downburst=None):
@@ -78,8 +94,12 @@ def create_if_vm(ctx, machine_name, _downburst=None):
     return dbrst.create()
 
 
-def destroy_if_vm(ctx, machine_name, user=None, description=None,
-                  _downburst=None):
+def destroy_if_vm(
+    machine_name: str,
+    user: str = "",
+    description: str = "",
+    _downburst=None
+):
     """
     Use downburst to destroy a virtual machine
 
@@ -99,7 +119,7 @@ def destroy_if_vm(ctx, machine_name, user=None, description=None,
         log.error(msg.format(node=machine_name, as_user=user,
                              locked_by=status_info['locked_by']))
         return False
-    if (description is not None and description !=
+    if (description and description !=
             status_info['description']):
         msg = "Tried to destroy {node} with description {desc_arg} " + \
             "but it is locked with description {desc_lock}"
@@ -117,5 +137,5 @@ def destroy_if_vm(ctx, machine_name, user=None, description=None,
     dbrst = _downburst or \
         downburst.Downburst(name=machine_name, os_type=None,
                             os_version=None, status=status_info,
-                            logfile=_logfile(ctx, shortname))
+                            logfile=_logfile(description, shortname))
     return dbrst.destroy()

teuthology/provision/cloud/openstack.py

@@ -84,7 +84,13 @@ class OpenStackProvider(Provider):
     @property
     def images(self):
         if not hasattr(self, '_images'):
-            self._images = retry(self.driver.list_images)
+            exclude_image = self.conf.get('exclude_image', [])
+            if exclude_image and not isinstance(exclude_image, list):
+                exclude_image = [exclude_image]
+            exclude_re = [re.compile(x) for x in exclude_image]
+            images = retry(self.driver.list_images)
+            self._images = [_ for _ in images
+                if not any(x.match(_.name) for x in exclude_re)]
         return self._images
 
     @property
@@ -126,7 +132,7 @@ class OpenStackProvider(Provider):
                 else:
                     self._networks = list()
             except AttributeError:
-                log.warn("Unable to list networks for %s", self.driver)
+                log.warning("Unable to list networks for %s", self.driver)
                 self._networks = list()
         return self._networks
 
@@ -144,7 +150,7 @@ class OpenStackProvider(Provider):
                     self.driver.ex_list_security_groups
                 )
             except AttributeError:
-                log.warn("Unable to list security groups for %s", self.driver)
+                log.warning("Unable to list security groups for %s", self.driver)
                 self._security_groups = list()
         return self._security_groups
 
@@ -420,7 +426,7 @@ class OpenStackProvisioner(base.Provisioner):
         msg = "Unknown error locating %s"
         if not matches:
             msg = "No nodes found with name '%s'" % self.name
-            log.warn(msg)
+            log.warning(msg)
             return
         elif len(matches) > 1:
             msg = "More than one node found with name '%s'"
@@ -438,9 +444,9 @@ class OpenStackProvisioner(base.Provisioner):
         self._destroy_volumes()
         nodes = self._find_nodes()
         if not nodes:
-            log.warn("Didn't find any nodes named '%s' to destroy!", self.name)
+            log.warning("Didn't find any nodes named '%s' to destroy!", self.name)
             return True
         if len(nodes) > 1:
-            log.warn("Found multiple nodes named '%s' to destroy!", self.name)
+            log.warning("Found multiple nodes named '%s' to destroy!", self.name)
         log.info("Destroying nodes: %s", nodes)
         return all([node.destroy() for node in nodes])

teuthology/provision/cloud/util.py

@@ -1,5 +1,4 @@
 import datetime
-import dateutil.tz
 import dateutil.parser
 import json
 import os
@@ -103,7 +102,7 @@ class AuthToken(object):
     def expired(self):
         if self.expires is None:
             return True
-        utcnow = datetime.datetime.now(dateutil.tz.tzutc())
+        utcnow = datetime.datetime.now(datetime.timezone.utc)
         offset = datetime.timedelta(minutes=30)
         return self.expires < (utcnow + offset)
 

teuthology/provision/downburst.py

@@ -44,6 +44,7 @@ def downburst_executable():
 
 def downburst_environment():
     env = dict()
+    env['PATH'] = os.environ.get('PATH')
     discover_url = os.environ.get('DOWNBURST_DISCOVER_URL')
     if config.downburst and not discover_url:
         if isinstance(config.downburst, dict):
@@ -165,7 +166,7 @@ class Downburst(object):
         if proc.returncode != 0:
             not_found_msg = "no domain with matching name '%s'" % self.shortname
             if not_found_msg in err:
-                log.warn("Ignoring error during destroy: %s", err)
+                log.warning("Ignoring error during destroy: %s", err)
                 return True
             log.error("Error destroying %s: %s", self.name, err)
             return False
@@ -215,7 +216,7 @@ class Downburst(object):
             'additional-disks-size': machine['volumes']['size'],
             'arch': 'x86_64',
         }
-        fqdn = self.name.split('@')[1]
+        fqdn = self.name.split('@')[-1]
         file_out = {
             'downburst': file_info,
             'local-hostname': fqdn,
@@ -307,7 +308,7 @@ def get_distro_from_downburst():
     executable_cmd = downburst_executable()
     environment_dict = downburst_environment()
     if not executable_cmd:
-        log.warn("Downburst not found!")
+        log.warning("Downburst not found!")
         log.info('Using default values for supported os_type/os_version')
         return default_table
     try:

teuthology/provision/fog.py

@@ -1,10 +1,10 @@
+import datetime
 import json
 import logging
 import requests
 import socket
 import re
 
-from datetime import datetime
 from paramiko import SSHException
 from paramiko.ssh_exception import NoValidConnectionsError
 
@@ -13,6 +13,7 @@ import teuthology.orchestra
 from teuthology.config import config
 from teuthology.contextutil import safe_while
 from teuthology.exceptions import MaxWhileTries
+from teuthology.orchestra.opsys import OS
 from teuthology import misc
 
 log = logging.getLogger(__name__)
@@ -29,7 +30,7 @@ def enabled(warn=False):
     params = ['endpoint', 'api_token', 'user_token', 'machine_types']
     unset = [param for param in params if not fog_conf.get(param)]
     if unset and warn:
-        log.warn(
+        log.warning(
             "FOG disabled; set the following config options to enable: %s",
             ' '.join(unset),
         )
@@ -89,6 +90,7 @@ class FOG(object):
             raise
         self._wait_for_ready()
         self._fix_hostname()
+        self._verify_installed_os()
         self.log.info("Deploy complete!")
 
     def do_request(self, url_suffix, data=None, method='GET', verify=True):
@@ -147,18 +149,39 @@ class FOG(object):
         represents it
         :returns: A dict describing the image
         """
-        name = '_'.join([
-            self.remote.machine_type, self.os_type.lower(), self.os_version])
-        resp = self.do_request(
-            '/image',
-            data=json.dumps(dict(name=name)),
-        )
-        obj = resp.json()
-        if not obj['count']:
+        def do_get(name):
+            resp = self.do_request(
+                '/image',
+                data=json.dumps(dict(name=name)),
+            )
+            obj = resp.json()
+            if obj['count']:
+                return obj['images'][0]
+
+        os_type = self.os_type.lower()
+        os_version = self.os_version
+        name = f"{self.remote.machine_type}_{os_type}_{os_version}"
+        if image := do_get(name):
+            return image
+        elif os_type == 'centos' and not os_version.endswith('.stream'):
+            image = do_get(f"{name}.stream")
+        if image:
+            return image
+        else:
             raise RuntimeError(
-                "Could not find an image for %s %s" %
-                (self.os_type, self.os_version))
-        return obj['images'][0]
+                "Fog has no %s image. Available %s images: %s" %
+                (name, self.remote.machine_type, self.suggest_image_names()))
+
+    def suggest_image_names(self):
+        """
+        Suggest available image names for this machine type.
+
+        :returns: A list of image names.
+        """
+        resp = self.do_request('/image/search/%s' % self.remote.machine_type)
+        obj = resp.json()
+        images = obj['images']
+        return [image['name'] for image in images]
 
     def set_image(self, host_id):
         """
@@ -167,6 +190,8 @@ class FOG(object):
         """
         image_data = self.get_image_data()
         image_id = int(image_data['id'])
+        image_name = image_data.get("name")
+        self.log.debug(f"Requesting image {image_name} (ID {image_id})")
         self.do_request(
             '/host/%s' % host_id,
             method='PUT',
@@ -202,8 +227,8 @@ class FOG(object):
         for task in host_tasks:
             timestamp = task['createdTime']
             time_delta = (
-                datetime.utcnow() - datetime.strptime(
-                    timestamp, self.timestamp_format)
+                datetime.datetime.now(datetime.timezone.utc) - datetime.datetime.strptime(
+                    timestamp, self.timestamp_format).replace(tzinfo=datetime.timezone.utc)
             ).total_seconds()
             # There should only be one deploy task matching our host. Just in
             # case there are multiple, select a very recent one.
@@ -240,13 +265,14 @@ class FOG(object):
         completed)
         """
         self.log.info("Waiting for deploy to finish")
-        with safe_while(sleep=15, tries=60) as proceed:
+        with safe_while(sleep=15, tries=120, timeout=config.fog_reimage_timeout) as proceed:
             while proceed():
                 if not self.deploy_task_active(task_id):
                     break
 
     def cancel_deploy_task(self,  task_id):
         """ Cancel an active deploy task """
+        self.log.debug(f"Canceling deploy task with ID {task_id}")
         resp = self.do_request(
             '/task/cancel',
             method='DELETE',
@@ -256,7 +282,7 @@ class FOG(object):
 
     def _wait_for_ready(self):
         """ Attempt to connect to the machine via SSH """
-        with safe_while(sleep=6, tries=100) as proceed:
+        with safe_while(sleep=6, timeout=config.fog_wait_for_ssh_timeout) as proceed:
             while proceed():
                 try:
                     self.remote.connect()
@@ -267,12 +293,26 @@ class FOG(object):
                     NoValidConnectionsError,
                     MaxWhileTries,
                     EOFError,
-                ):
-                    pass
+                ) as e:
+                    # log this, because otherwise lots of failures just
+                    # keep retrying without any notification (like, say,
+                    # a mismatched host key in ~/.ssh/known_hosts, or
+                    # something)
+                    self.log.warning(e)
         sentinel_file = config.fog.get('sentinel_file', None)
         if sentinel_file:
             cmd = "while [ ! -e '%s' ]; do sleep 5; done" % sentinel_file
-            self.remote.run(args=cmd, timeout=600)
+            action = f"wait for sentinel on {self.shortname}"
+            with safe_while(action=action, timeout=1800, increment=3) as proceed:
+                while proceed():
+                    try:
+                        self.remote.run(args=cmd, timeout=600)
+                        break
+                    except (
+                        ConnectionError,
+                        EOFError,
+                    ) as e:
+                        log.error(f"{e} on {self.shortname}")
         self.log.info("Node is ready")
 
     def _fix_hostname(self):
@@ -307,6 +347,14 @@ class FOG(object):
             check_status=False,
         )
 
+    def _verify_installed_os(self):
+        wanted_os = OS(name=self.os_type, version=self.os_version)
+        if self.remote.os != wanted_os:
+            raise RuntimeError(
+                f"Expected {self.remote.shortname}'s OS to be {wanted_os} but "
+                f"found {self.remote.os}"
+            )
+
     def destroy(self):
         """A no-op; we just leave idle nodes as-is"""
         pass

teuthology/provision/openstack.py

@@ -27,7 +27,8 @@ class ProvisionOpenStack(OpenStack):
     """
     def __init__(self):
         super(ProvisionOpenStack, self).__init__()
-        self.user_data = tempfile.mktemp()
+        fd, self.user_data = tempfile.mkstemp()
+        os.close(fd)
         log.debug("ProvisionOpenStack: " + str(config.openstack))
         self.basename = 'target'
         self.up_string = 'The system is finally up'
@@ -77,7 +78,7 @@ class ProvisionOpenStack(OpenStack):
             if 'No volume with a name or ID' not in e.output:
                 raise e
         if volume_id:
-            log.warn("Volume {} already exists with ID {}; using it"
+            log.warning("Volume {} already exists with ID {}; using it"
                      .format(volume_name, volume_id))
         volume_id = self._openstack(
             "volume create %s" % config['openstack'].get('volume-create','')
@@ -106,7 +107,7 @@ class ProvisionOpenStack(OpenStack):
                         log.debug("volume %s not in '%s' status yet"
                                   % (volume_id, status))
                 except subprocess.CalledProcessError:
-                        log.warn("volume " + volume_id +
+                        log.warning("volume " + volume_id +
                                  " not information available yet")
 
     def _attach_volume(self, volume_id, name):
@@ -151,7 +152,7 @@ class ProvisionOpenStack(OpenStack):
         """
         return the instance name suffixed with the IP address.
         """
-        digits = map(int, re.findall('(\d+)\.(\d+)\.(\d+)\.(\d+)', ip)[0])
+        digits = map(int, re.findall(r'(\d+)\.(\d+)\.(\d+)\.(\d+)', ip)[0])
         return prefix + "%03d%03d%03d%03d" % tuple(digits)
 
     def create(self, num, os_type, os_version, arch, resources_hint):

teuthology/provision/pelagos.py

@@ -26,7 +26,7 @@ def enabled(warn=False):
     params = ['endpoint', 'machine_types']
     unset = [_ for _ in params if not conf.get(_)]
     if unset and warn:
-        log.warn(
+        log.warning(
             "Pelagos is disabled; set the following config options to enable: %s",
             ' '.join(unset),
         )

teuthology/repo_utils.py

@@ -1,3 +1,4 @@
+import functools
 import logging
 import os
 import re
@@ -5,6 +6,8 @@ import shutil
 import subprocess
 import time
 
+import teuthology.exporter as exporter
+
 from teuthology import misc
 from teuthology.util.flock import FileLock
 from teuthology.config import config
@@ -50,10 +53,11 @@ def build_git_url(project, project_owner='ceph'):
         base = config.get_ceph_git_url()
     else:
         base = 'https://github.com/{project_owner}/{project}'
-    url_templ = re.sub('\.git$', '', base)
+    url_templ = re.sub(r'\.git$', '', base)
     return url_templ.format(project_owner=project_owner, project=project)
 
 
+@functools.lru_cache()
 def ls_remote(url, ref):
     """
     Return the current sha1 for a given repository and ref
@@ -70,6 +74,27 @@ def ls_remote(url, ref):
     return sha1
 
 
+def current_branch(path: str) -> str:
+    """
+    Return the current branch for a given on-disk repository.
+
+    :returns: the current branch, or an empty string if none is found.
+    """
+    # git branch --show-current was added in 2.22.0, and we can't assume
+    # our version is new enough.
+    cmd = "git rev-parse --abbrev-ref HEAD"
+    result = subprocess.Popen(
+        cmd,
+        shell=True,
+        cwd=path,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        ).communicate()[0].strip().decode()
+    if result == "HEAD":
+        return ""
+    return result
+
+
 def enforce_repo_state(repo_url, dest_path, branch, commit=None, remove_on_error=True):
     """
     Use git to either clone or update a given repo, forcing it to switch to the
@@ -96,8 +121,6 @@ def enforce_repo_state(repo_url, dest_path, branch, commit=None, remove_on_error
             set_remote(dest_path, repo_url)
             fetch_branch(dest_path, branch)
             touch_file(sentinel)
-        else:
-            log.info("%s was just updated or references a specific commit; assuming it is current", dest_path)
 
         if commit and os.path.exists(repo_reset):
             return
@@ -142,8 +165,9 @@ def clone_repo(repo_url, dest_path, branch, shallow=True):
     result = proc.wait()
     # Newer git versions will bail if the branch is not found, but older ones
     # will not. Fortunately they both output similar text.
-    if not_found_str in out:
+    if result != 0:
         log.error(out)
+    if not_found_str in out:
         if result == 0:
             # Old git left a repo with the wrong branch. Remove it.
             shutil.rmtree(dest_path, ignore_errors=True)
@@ -251,7 +275,7 @@ def fetch_branch(repo_path, branch, shallow=True):
                       GitError for other errors
     """
     validate_branch(branch)
-    log.info("Fetching %s from origin", branch)
+    log.info("Fetching %s from origin", repo_path.split("/")[-1])
     args = ['git', 'fetch']
     if shallow:
         args.extend(['--depth', '1'])
@@ -288,7 +312,7 @@ def reset_repo(repo_url, dest_path, branch, commit=None):
     else:
         reset_branch = 'origin/%s' % branch
     reset_ref = commit or reset_branch
-    log.info('Resetting repo at %s to %s', dest_path, reset_ref)
+    log.debug('Resetting repo at %s to %s', dest_path, reset_ref)
     # This try/except block will notice if the requested branch doesn't
     # exist, whether it was cloned or fetched.
     try:
@@ -334,7 +358,7 @@ def fetch_repo(url, branch, commit=None, bootstrap=None, lock=True):
     # only let one worker create/update the checkout at a time
     lock_path = dest_path.rstrip('/') + '.lock'
     with FileLock(lock_path, noop=not lock):
-        with safe_while(sleep=10, tries=60) as proceed:
+        with safe_while(sleep=10, tries=6) as proceed:
             try:
                 while proceed():
                     try:
@@ -416,6 +440,7 @@ def fetch_teuthology(branch, commit=None, lock=True):
 
 
 def bootstrap_teuthology(dest_path):
+    with exporter.BootstrapTime().time():
         log.info("Bootstrapping %s", dest_path)
         # This magic makes the bootstrap script not attempt to clobber an
         # existing virtualenv. But the branch's bootstrap needs to actually
@@ -423,15 +448,20 @@ def bootstrap_teuthology(dest_path):
         env = os.environ.copy()
         env['NO_CLOBBER'] = '1'
         cmd = './bootstrap'
-        boot_proc = subprocess.Popen(cmd, shell=True, cwd=dest_path, env=env,
-                                     stdout=subprocess.PIPE,
-                                     stderr=subprocess.STDOUT)
-        out, err = boot_proc.communicate()
+        boot_proc = subprocess.Popen(
+            cmd, shell=True,
+            cwd=dest_path,
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True
+        )
+        out, _ = boot_proc.communicate()
         returncode = boot_proc.wait()
         log.info("Bootstrap exited with status %s", returncode)
         if returncode != 0:
-            for line in out.split():
-                log.warn(line.strip())
+            for line in out.split("\n"):
+                log.warning(line.strip())
             venv_path = os.path.join(dest_path, 'virtualenv')
             log.info("Removing %s", venv_path)
             shutil.rmtree(venv_path, ignore_errors=True)