v14/tc_enter_chroot.py

#!/usr/bin/python2.6
#
# Copyright 2010 Google Inc. All Rights Reserved.

"""Script to enter the ChromeOS chroot with mounted sources.

This script enters the chroot with mounted sources.
"""

__author__ = "asharif@google.com (Ahmad Sharif)"

import getpass
import optparse
import os
import pwd
import sys
from utils import command_executer
from utils import logger
from utils import utils

# Common initializations
cmd_executer = command_executer.GetCommandExecuter()


class MountPoint:
  def __init__(self, external_dir, mount_dir, owner, options=None):
    self.external_dir = external_dir
    self.mount_dir = mount_dir
    self.owner = owner
    self.options = options


  def CreateAndOwnDir(self, dir_name):
    retval = 0
    if not os.path.exists(dir_name):
      command = "mkdir -p " + dir_name
      command += " || sudo mkdir -p " + dir_name
      retval = cmd_executer.RunCommand(command)
    if retval != 0:
      return retval
    pw = pwd.getpwnam(self.owner)
    if os.stat(dir_name).st_uid != pw.pw_uid:
      command = "sudo chown -f " + self.owner + " " + dir_name
      retval = cmd_executer.RunCommand(command)
    return retval


  def DoMount(self):
    retval = self.CreateAndOwnDir(self.mount_dir)
    utils.AssertTrue(retval == 0)
    retval = self.CreateAndOwnDir(self.external_dir)
    utils.AssertTrue(retval == 0)
    retval = self.MountDir()
    utils.AssertTrue(retval == 0)
    return retval


  def MountDir(self):
    command = "sudo mount --bind " + self.external_dir + " " + self.mount_dir
    if self.options == "ro":
      command += " && sudo mount --bind -oremount,ro " + self.mount_dir
    retval = cmd_executer.RunCommand(command)
    return retval


  def __str__(self):
    ret = ""
    ret += self.external_dir + "\n"
    ret += self.mount_dir + "\n"
    if self.owner:
      ret += self.owner + "\n"
    if self.options:
      ret += self.options + "\n"
    return ret


def Main(argv, return_output=False):
  """The main function."""
  parser = optparse.OptionParser()
  parser.add_option("-c", "--chromeos_root", dest="chromeos_root",
                    default="../..",
                    help="ChromeOS root checkout directory.")
  parser.add_option("-t", "--toolchain_root", dest="toolchain_root",
                    help="Toolchain root directory.")
  parser.add_option("-o", "--output", dest="output",
                    help="Toolchain output directory")
  parser.add_option("-m", "--other_mounts", dest="other_mounts",
                    help="Other mount points in the form: " + 
                         "dir:mounted_dir:options")

  relevant_argv = []
  passthrough_argv = []
  i = 0
  while i < len(argv):
    found = False
    for option in parser.option_list:
      for long_opt in option._long_opts:
        if argv[i].startswith(long_opt):
          relevant_argv.append(argv[i])
          found = True
          break
      for short_opt in option._short_opts:
        if argv[i].startswith(short_opt):
          relevant_argv.append(argv[i])
          relevant_argv.append(argv[i+1])
	  i = i + 1
          found = True
          break

      if found == True:
        break

    if found == False:
      passthrough_argv.append(argv[i])
    i = i + 1

  options = parser.parse_args(relevant_argv)[0]

  chromeos_root = options.chromeos_root

  chromeos_root = os.path.expanduser(chromeos_root)
  if options.toolchain_root:
    options.toolchain_root = os.path.expanduser(options.toolchain_root)

  chromeos_root = os.path.abspath(chromeos_root)

  if options.toolchain_root is None:
    logger.GetLogger().LogError("--toolchain_root not specified")
    parser.print_help()
    sys.exit(1)

  tc_dirs = [options.toolchain_root + "/google_vendor_src_branch/gcc",
             options.toolchain_root + "/google_vendor_src_branch/binutils"]

  for tc_dir in tc_dirs:
    if not os.path.exists(tc_dir):
      logger.GetLogger().LogError("toolchain path " +
                                 tc_dir + " does not exist!")
      parser.print_help()
      sys.exit(1)

  if not os.path.exists(chromeos_root):
    logger.GetLogger().LogError("chromeos_root " + options.chromeos_root +
                                 " does not exist!")
    parser.print_help()
    sys.exit(1)

  if not os.path.exists(chromeos_root + "/src/scripts/enter_chroot.sh"):
    logger.GetLogger().LogError(options.chromeos_root + 
                                 "/src/scripts/enter_chroot.sh"
                                 " not found!")
    parser.print_help()
    sys.exit(1)

  rootdir = utils.GetRoot(sys.argv[0])[0]
  version_dir = rootdir

  mounted_tc_root = "/usr/local/toolchain_root"
  full_mounted_tc_root = chromeos_root + "/chroot/" + mounted_tc_root
  full_mounted_tc_root = os.path.abspath(full_mounted_tc_root)
 
  mount_points = []
  for tc_dir in tc_dirs:
    last_dir = utils.GetRoot(tc_dir)[1]
    mount_point = MountPoint(tc_dir, full_mounted_tc_root + "/" + last_dir,
                             getpass.getuser(), "ro")
    mount_points.append(mount_point)

  output = options.output
  if output is None:
    output = version_dir + "/output"
  mount_points.append(MountPoint(output, full_mounted_tc_root + "/output",
                                 getpass.getuser()))
  mount_points += CreateMountPointsFromString(options.other_mounts, 
                                              chromeos_root + "/chroot/")

  last_dir = utils.GetRoot(version_dir)[1]
  mount_point = MountPoint(version_dir, full_mounted_tc_root + "/" + last_dir,
                           getpass.getuser())
  mount_points.append(mount_point)

  for mount_point in mount_points:
    retval = mount_point.DoMount()
    if retval != 0:
      return retval

  # Finally, create the symlink to build-gcc.
  command = "sudo chown " + getpass.getuser() + " " + full_mounted_tc_root
  retval = cmd_executer.RunCommand(command)

  try:
    os.symlink(last_dir + "/build-gcc", full_mounted_tc_root + "/build-gcc")
    os.symlink(last_dir + "/build-binutils", full_mounted_tc_root + "/build-binutils")
  except Exception as e:
    logger.GetLogger().LogError(str(e))

  # Now call enter_chroot with the rest of the arguments.
  command = chromeos_root + "/src/scripts/enter_chroot.sh"

  if len(passthrough_argv) > 1:
    command += " <<EC_EOF"
    command += " " + " ".join(passthrough_argv[1:])
    command += "\nEC_EOF"
    retval = cmd_executer.RunCommand(command, return_output)
    return retval
  else:
    return os.execv(command, [""])


def CreateMountPointsFromString(mount_strings, chroot_dir):
  # String has options in the form dir:mount:options
  mount_points = []
  if not mount_strings:
    return mount_points
  mount_list = mount_strings.split()
  for mount_string in mount_list:
    mount_values = mount_string.split(":")
    external_dir = mount_values[0]
    mount_dir = mount_values[1]
    if len(mount_values)>2:
      options = mount_values[2]
    else:
      options = None
    mount_point = MountPoint(external_dir, chroot_dir + "/" + mount_dir, 
                             getpass.getuser(), options)
    mount_points.append(mount_point)
  return mount_points


if __name__ == "__main__":
  Main(sys.argv)