shell/subcmds/build_cmd.py

# Copyright (c) 2011 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.

"""Implementation of the 'build' chromite command."""

# Python imports
import optparse
import os


# Local imports
import chromite.lib.cros_build_lib as cros_lib
from chromite.shell import utils
from chromite.shell import subcmd


def _DoMakeChroot(chroot_config, clean_first):
  """Build the chroot, if needed.

  Args:
    chroot_config: A SafeConfigParser representing the config for the chroot.
    clean_first: Delete any old chroot first.
  """
  # Skip this whole command if things already exist.
  # TODO(dianders): Theoretically, calling make_chroot a second time is OK
  # and "fixes up" the chroot.  ...but build_packages will do the fixups
  # anyway (I think), so this isn't that important.
  chroot_dir = utils.GetChrootAbsDir(chroot_config)
  if (not clean_first) and utils.DoesChrootExist(chroot_config):
    cros_lib.Info('%s already exists, skipping make_chroot.' % chroot_dir)
    return

  cros_lib.Info('MAKING THE CHROOT')

  # Put together command.
  cmd_list = [
      './make_chroot',
      '--chroot="%s"' % chroot_dir,
      chroot_config.get('CHROOT', 'make_chroot_flags'),
  ]
  if clean_first:
    cmd_list.insert(1, '--replace')

  # We're going convert to a string and force the shell to do all of the
  # splitting of arguments, since we're throwing all of the flags from the
  # config file in there.
  cmd = ' '.join(cmd_list)

  # We'll put CWD as src/scripts when running the command.  Since everyone
  # running by hand has their cwd there, it is probably the safest.
  cwd = os.path.join(utils.SRCROOT_PATH, 'src', 'scripts')

  # Run it.  Exceptions will cause the program to exit.
  cros_lib.RunCommand(cmd, shell=True, cwd=cwd, ignore_sigint=True)


def _DoSetupBoard(build_config, clean_first):
  """Setup the board, if needed.

  This just runs the setup_board command with the proper args, if needed.

  Args:
    build_config: A SafeConfigParser representing the build config.
    clean_first: Delete any old board config first.
  """
  # Skip this whole command if things already exist.
  board_dir = utils.GetBoardDir(build_config)
  if (not clean_first) and os.path.isdir(board_dir):
    cros_lib.Info('%s already exists, skipping setup_board.' % board_dir)
    return

  cros_lib.Info('SETTING UP THE BOARD')

  # Put together command.
  cmd_list = [
      './setup_board',
      '--board="%s"' % build_config.get('DEFAULT', 'target'),
      build_config.get('BUILD', 'setup_board_flags'),
  ]
  if clean_first:
    cmd_list.insert(1, '--force')

  # We're going convert to a string and force the shell to do all of the
  # splitting of arguments, since we're throwing all of the flags from the
  # config file in there.
  cmd = ' '.join(cmd_list)

  # We'll put CWD as src/scripts when running the command.  Since everyone
  # running by hand has their cwd there, it is probably the safest.
  cwd = os.path.join(utils.SRCROOT_PATH, 'src', 'scripts')

  # Run it.  Exceptions will cause the program to exit.
  cros_lib.RunCommand(cmd, shell=True, cwd=cwd, ignore_sigint=True)


def _DoBuildPackages(build_config):
  """Build packages.

  This just runs the build_packages command with the proper args.

  Args:
    build_config: A SafeConfigParser representing the build config.
  """
  cros_lib.Info('BUILDING PACKAGES')

  # Put together command.  We're going to force the shell to do all of the
  # splitting of arguments, since we're throwing all of the flags from the
  # config file in there.
  cmd = '%s ./build_packages --board="%s" %s' % (
      build_config.get('BUILD', 'build_packages_environ'),
      build_config.get('DEFAULT', 'target'),
      build_config.get('BUILD', 'build_packages_flags')
  )

  # We'll put CWD as src/scripts when running the command.  Since everyone
  # running by hand has their cwd there, it is probably the safest.
  cwd = os.path.join(utils.SRCROOT_PATH, 'src', 'scripts')

  # Run it.  Exceptions will cause the program to exit.
  cros_lib.RunCommand(cmd, shell=True, cwd=cwd, ignore_sigint=True)


def _DoBuildImage(build_config):
  """Build an image.

  This just runs the build_image command with the proper args.

  Args:
    build_config: A SafeConfigParser representing the build config.
  """
  cros_lib.Info('BUILDING THE IMAGE')

  # Put together command.  We're going to force the shell to do all of the
  # splitting of arguments, since we're throwing all of the flags from the
  # config file in there.
  cmd = '%s ./build_image --board="%s" %s' % (
      build_config.get('IMAGE', 'build_image_environ'),
      build_config.get('DEFAULT', 'target'),
      build_config.get('IMAGE', 'build_image_flags')
  )

  # We'll put CWD as src/scripts when running the command.  Since everyone
  # running by hand has their cwd there, it is probably the safest.
  cwd = os.path.join(utils.SRCROOT_PATH, 'src', 'scripts')

  # Run it.  Exceptions will cause the program to exit.
  cros_lib.RunCommand(cmd, shell=True, cwd=cwd, ignore_sigint=True)


def _DoImagePostProcessing(build_config):
  """Do post processing steps after the build image runs.

  Args:
    build_config: A SafeConfigParser representing the build config.
  """
  # We'll put CWD as src/scripts when running the commands, since many of these
  # legacy commands live in src/scripts.
  # TODO(dianders): Don't set CWD once crosutils are properly installed.
  cwd = os.path.join(utils.SRCROOT_PATH, 'src', 'scripts')

  # The user specifies a list of "steps" in this space-separated variable.
  # We'll use each step name to construct other variable names to look for
  # the actual commands.
  steps = build_config.get('IMAGE', 'post_process_steps')
  for step_name in steps.split():
    cros_lib.Info('IMAGING POST-PROCESS: %s' % step_name)

    # Get the name of the variable that the user stored the cmd in.
    cmd_var_name = 'post_process_%s_cmd' % step_name

    # Run the command.  Exceptions will cause the program to exit.
    cmd = build_config.get('IMAGE', cmd_var_name)
    cros_lib.RunCommand(cmd, shell=True, cwd=cwd, ignore_sigint=True)


class BuildCmd(subcmd.ChromiteCmd):
  """Build the chroot (if needed), the packages for a target, and the image."""

  def Run(self, raw_argv, chroot_config=None,
          loaded_config=False, build_config=None):
    """Run the command.

    Args:
      raw_argv: Command line arguments, including this command's name, but not
          the chromite command name or chromite options.
      chroot_config: A SafeConfigParser for the chroot config; or None chromite
          was called from within the chroot.
      loaded_config: If True, we've already loaded the config.
      build_config: None when called normally, but contains the SafeConfigParser
          for the build config if we call ourselves with _DoEnterChroot().  Note
          that even when called through _DoEnterChroot(), could still be None
          if user chose 'HOST' as the target.
    """
    # Parse options for command...
    usage_str = ('usage: %%prog [chromite_options] %s [options] [target]' %
                 raw_argv[0])
    parser = optparse.OptionParser(usage=usage_str)
    parser.add_option('--clean', default=False, action='store_true',
                      help='Clean before building.')
    (options, argv) = parser.parse_args(raw_argv[1:])

    # Load the build config if needed...
    if not loaded_config:
      argv, build_config = utils.GetBuildConfigFromArgs(argv)
      if argv:
        cros_lib.Die('Unknown arguments: %s' % ' '.join(argv))

    if not cros_lib.IsInsideChroot():
      # Note: we only want to clean the chroot if they do --clean and have the
      # host target.  If they do --clean and have a board target, it means
      # that they just want to clean the board...
      want_clean_chroot = options.clean and build_config is None

      _DoMakeChroot(chroot_config, want_clean_chroot)

      if build_config is not None:
        utils.EnterChroot(chroot_config, (self, 'Run'), raw_argv,
                          build_config=build_config, loaded_config=True)

      cros_lib.Info('Done building.')
    else:
      if build_config is None:
        cros_lib.Die("You can't build the host chroot from within the chroot.")

      _DoSetupBoard(build_config, options.clean)
      _DoBuildPackages(build_config)
      _DoBuildImage(build_config)
      _DoImagePostProcessing(build_config)