scripts/cros_generate_sysroot.py

# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Generates a sysroot tarball for building a specific package.

Meant for use after setup_board and build_packages have been run.
"""

import os

from chromite.lib import build_target_lib
from chromite.lib import constants
from chromite.lib import cros_build_lib
from chromite.lib import commandline
from chromite.lib import osutils
from chromite.lib import sudo
from chromite.lib import sysroot_lib
from chromite.lib import toolchain

DEFAULT_NAME = 'sysroot_%(package)s.tar.xz'
PACKAGE_SEPARATOR = '/'
SYSROOT = 'sysroot'


def ParseCommandLine(argv):
  """Parse args, and run environment-independent checks."""
  parser = commandline.ArgumentParser(description=__doc__)
  parser.add_argument('--board', required=True,
                      help='The board to generate the sysroot for.')
  parser.add_argument('--package', required=True,
                      help='The packages to generate the sysroot for.')
  parser.add_argument('--deps-only', action='store_true',
                      default=False,
                      help='Build dependencies only.')
  parser.add_argument('--out-dir', type='path', required=True,
                      help='Directory to place the generated tarball.')
  parser.add_argument('--out-file', default=DEFAULT_NAME,
                      help='The name to give to the tarball. '
                           'Defaults to %(default)s.')
  options = parser.parse_args(argv)

  options.out_file %= {
      'package': options.package.split()[0].replace(PACKAGE_SEPARATOR, '_'),
  }

  return options


class GenerateSysroot(object):
  """Wrapper for generation functionality."""

  PARALLEL_EMERGE = os.path.join(constants.CHROMITE_BIN_DIR, 'parallel_emerge')

  def __init__(self, sysroot, options):
    """Initialize

    Args:
      sysroot: Path to sysroot.
      options: Parsed options.
    """
    self.sysroot = sysroot
    self.options = options
    self.extra_env = {'ROOT': self.sysroot, 'USE': os.environ.get('USE', '')}

  def _Emerge(self, *args, **kwargs):
    """Emerge the given packages using parallel_emerge."""
    cmd = [self.PARALLEL_EMERGE, '--board=%s' % self.options.board,
           '--usepkgonly', '--noreplace'] + list(args)
    kwargs.setdefault('extra_env', self.extra_env)
    cros_build_lib.sudo_run(cmd, **kwargs)

  def _WriteConfig(self, sysroot):
    sysroot.WriteConfig(sysroot.GenerateBoardSetupConfig(self.options.board))
    # For the config to be correctly read, a stub make.conf is needed.
    # pylint: disable=protected-access
    make_conf_path = os.path.join(self.sysroot, sysroot_lib._MAKE_CONF)
    assert not os.path.exists(make_conf_path), 'Expecting an empty sysroot.'
    osutils.WriteFile(os.path.join(make_conf_path),
                      'source make.conf.board_setup', makedirs=True, sudo=True)

  def _InstallToolchain(self):
    # Create the sysroot's config.
    sysroot = sysroot_lib.Sysroot(self.sysroot)
    self._WriteConfig(sysroot)
    toolchain.InstallToolchain(sysroot, configure=False)

  def _InstallKernelHeaders(self):
    self._Emerge('sys-kernel/linux-headers')

  def _InstallBuildDependencies(self):
    # Calculate buildtime deps that are not runtime deps.
    raw_sysroot = build_target_lib.get_default_sysroot_path(self.options.board)
    packages = []
    if not self.options.deps_only:
      packages = self.options.package.split()
    else:
      for pkg in self.options.package.split():
        cmd = ['qdepends', '-q', '-C', pkg]
        output = cros_build_lib.run(
            cmd, extra_env={'ROOT': raw_sysroot}, capture_output=True,
            encoding='utf-8').stdout

        if output.count('\n') > 1:
          raise AssertionError('Too many packages matched for given pattern')

        # qdepend outputs "package: deps", so only grab the deps.
        deps = output.partition(':')[2].split()
        packages.extend(deps)
    # Install the required packages.
    if packages:
      self._Emerge(*packages)

  def _CreateTarball(self):
    tarball_path = os.path.join(self.options.out_dir, self.options.out_file)
    cros_build_lib.CreateTarball(tarball_path, self.sysroot, sudo=True)

  def Perform(self):
    """Generate the sysroot."""
    self._InstallToolchain()
    self._InstallKernelHeaders()
    self._InstallBuildDependencies()
    self._CreateTarball()


def FinishParsing(options):
  """Run environment dependent checks on parsed args."""
  target = os.path.join(options.out_dir, options.out_file)
  if os.path.exists(target):
    cros_build_lib.Die('Output file %r already exists.' % target)

  if not os.path.isdir(options.out_dir):
    cros_build_lib.Die(
        'Non-existent directory %r specified for --out-dir' % options.out_dir)


def main(argv):
  options = ParseCommandLine(argv)
  FinishParsing(options)

  cros_build_lib.AssertInsideChroot()

  with sudo.SudoKeepAlive(ttyless_sudo=False):
    with osutils.TempDir(set_global=True, sudo_rm=True) as tempdir:
      sysroot = os.path.join(tempdir, SYSROOT)
      os.mkdir(sysroot)
      GenerateSysroot(sysroot, options).Perform()