scripts/cros_choose_profile.py - third_party/chromite - Git at Google

 # Copyright 2018 The ChromiumOS Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.

 """Choose the profile for a board that has been or is being setup."""

 import functools
 import logging
 import os
 from typing import Optional

 from chromite.lib import build_target_lib
 from chromite.lib import commandline
 from chromite.lib import cros_build_lib
 from chromite.lib import osutils
 from chromite.lib import sysroot_lib


 # Default value constants.
 _DEFAULT_PROFILE = "base"


 def PathPrefixDecorator(f):
     """Add a prefix to the path or paths returned by the decorated function.

     Will not prepend the prefix if the path already starts with the prefix, so
     the decorator may be applied to functions that have mixed sources that may
     or may not already have applied them. This is especially useful for allowing
     tests and CLI args a little more leniency in how paths are provided.
     """

     @functools.wraps(f)
     def wrapper(*args, **kwargs):
         result = f(*args, **kwargs)
         prefix = PathPrefixDecorator.prefix

         if not prefix or not result:
             # Nothing to do.
             return result

         # Convert Path objects to str.
         if isinstance(prefix, os.PathLike):
             prefix = str(prefix)

         if not isinstance(result, str):
             # Transform each path in the collection.
             new_result = []
             for path in result:
                 prefixed_path = os.path.join(prefix, path.lstrip(os.sep))
                 new_result.append(
                     path if path.startswith(prefix) else prefixed_path
                 )

             return new_result
         elif not result.startswith(prefix):
             # Add the prefix.
             return os.path.join(prefix, result.lstrip(os.sep))

         # An already prefixed path.
         return result

     return wrapper


 PathPrefixDecorator.prefix = None


 class Error(Exception):
     """Base error for custom exceptions in this script."""


 class InvalidArgumentsError(Error):
     """Invalid arguments."""


 class MakeProfileIsNotLinkError(Error):
     """The make profile exists but is not a link."""


 class ProfileDirectoryNotFoundError(Error):
     """Unable to find the profile directory."""


 def ChooseProfile(board, profile) -> None:
     """Make the link to choose the profile, print relevant warnings.

     Args:
         board: Board - the board being used.
         profile: Profile - the profile being used.

     Raises:
         OSError when the board's make_profile path exists and is not a link.
     """
     if not os.path.isfile(os.path.join(profile.directory, "parent")):
         logging.warning(
             "Portage profile directory %s has no 'parent' file. "
             "This likely means your profile directory is invalid and "
             "`cros build-packages` will fail.",
             profile.directory,
         )

     current_profile = None
     if os.path.exists(board.make_profile):
         # Only try to read if it exists; we only want it to raise an error when
         # the path exists and is not a link.
         try:
             current_profile = os.readlink(board.make_profile)
         except OSError:
             raise MakeProfileIsNotLinkError(
                 "%s is not a link." % board.make_profile
             )

     if current_profile == profile.directory:
         # The existing link is what we were going to make, so nothing to do.
         return
     elif current_profile is not None:
         # It exists and is changing, emit warning.
         fmt = {"board": board.board_variant, "profile": profile.name}
         msg = (
             "You are switching profiles for a board that is already setup. "
             "This can cause trouble for Portage. If you experience problems "
             "with `cros build-packages` you may need to run:\n"
             "\t'setup_board --board %(board)s --force --profile %(profile)s'\n"
             "\nAlternatively, you can correct the dependency graph by using "
             "'emerge-%(board)s -c' or 'emerge-%(board)s -C <ebuild>'."
         )
         logging.warning(msg, fmt)

     # Make the symlink, overwrites existing link if one already exists.
     osutils.SafeSymlink(profile.directory, board.make_profile, sudo=True)

     # Update the profile override value.
     if profile.override:
         board.profile_override = profile.override


 class Profile:
     """Simple data container class for the profile data."""

     def __init__(self, name, directory, override) -> None:
         self.name = name
         self._directory = directory
         self.override = override

     @property
     @PathPrefixDecorator
     def directory(self):
         return self._directory


 def _GetProfile(opts, board):
     """Get the profile list."""
     # Determine the override value - which profile is being selected.
     override = opts.profile if opts.profile else board.profile_override

     profile = _DEFAULT_PROFILE
     profile_directory = None

     if override and os.path.exists(override):
         profile_directory = os.path.abspath(override)
         profile = os.path.basename(profile_directory)
     elif override:
         profile = override

     if profile_directory is None:
         # Build profile directories in reverse order, so we can search from most
         # to least specific.
         profile_dirs = [
             "%s/profiles/%s" % (overlay, profile)
             for overlay in reversed(board.overlays)
         ]

         for profile_dir in profile_dirs:
             if os.path.isdir(profile_dir):
                 profile_directory = profile_dir
                 break
         else:
             searched = ", ".join(profile_dirs)
             raise ProfileDirectoryNotFoundError(
                 "Profile directory not found, searched in (%s)." % searched
             )

     return Profile(profile, profile_directory, override)


 class Board:
     """Manage the board arguments and configs."""

     # Files located on the board.
     MAKE_PROFILE = "%(board_root)s/etc/portage/make.profile"

     def __init__(
         self,
         board: Optional[str] = None,
         variant: Optional[str] = None,
         board_root: Optional[str] = None,
     ) -> None:
         """Board constructor.

         board [+ variant] is given preference when both board and board_root are
         provided.

         Preconditions:
             Either board and build_root are not None, or board_root is not None.
                 With board + build_root we can construct the board root.
                 With the board root we can have the board directory.

         Args:
             board: The board name.
             variant: The variant name. TODO: Deprecate?
             board_root: The boards fully qualified build directory path.
         """
         if not board and not board_root:
             # Enforce preconditions.
             raise InvalidArgumentsError(
                 "Either board or board_root must be provided."
             )
         elif board:
             # The board and variant can be specified separately, or can both be
             # contained in the board name, separated by an underscore.
             board_split = board.split("_")
             variant_default = variant

             self._board_root = None
         else:
             self._board_root = os.path.normpath(board_root)

             board_split = os.path.basename(self._board_root).split("_")
             variant_default = None

         self.board = board_split.pop(0)
         self.variant = board_split.pop(0) if board_split else variant_default

         if self.variant:
             self.board_variant = "%s_%s" % (self.board, self.variant)
         else:
             self.board_variant = self.board

         self.make_profile = self.MAKE_PROFILE % {"board_root": self.root}
         # This must come after the arguments required to build each variant of
         # the build root have been processed.
         self._sysroot_config = sysroot_lib.Sysroot(self.root)

     @property
     @PathPrefixDecorator
     def root(self):
         if self._board_root:
             return self._board_root

         return build_target_lib.get_default_sysroot_path(self.board_variant)

     @property
     @PathPrefixDecorator
     def overlays(self):
         return self._sysroot_config.GetStandardField(
             sysroot_lib.STANDARD_FIELD_BOARD_OVERLAY
         ).split()

     @property
     def profile_override(self):
         return self._sysroot_config.GetCachedField("PROFILE_OVERRIDE")

     @profile_override.setter
     def profile_override(self, value) -> None:
         self._sysroot_config.SetCachedField("PROFILE_OVERRIDE", value)


 def _GetBoard(opts):
     """Factory method to build a Board from the parsed CLI arguments."""
     return Board(
         board=opts.board, variant=opts.variant, board_root=opts.board_root
     )


 def GetParser():
     """ArgumentParser builder and argument definitions."""
     parser = commandline.ArgumentParser(description=__doc__)
     parser.add_argument(
         "-b",
         "--board",
         default=os.environ.get("DEFAULT_BOARD"),
         help="The name of the board to set up.",
     )
     parser.add_argument(
         "-r",
         "--board-root",
         type="str_path",
         help="Board root where the profile should be created.",
     )
     parser.add_argument(
         "-p", "--profile", help="The portage configuration profile to use."
     )
     parser.add_argument("--variant", help="Board variant.")

     group = parser.add_argument_group("Advanced options")
     group.add_argument(
         "--filesystem-prefix",
         type="str_path",
         help="Force filesystem accesses to be prefixed by the given path.",
     )
     return parser


 def ParseArgs(argv):
     """Parse and validate the arguments."""
     parser = GetParser()
     opts = parser.parse_args(argv)

     # See Board.__init__ Preconditions.
     board_valid = opts.board is not None
     board_root_valid = opts.board_root and os.path.exists(opts.board_root)

     if not board_valid and not board_root_valid:
         parser.error("Either board or board_root must be provided.")

     PathPrefixDecorator.prefix = opts.filesystem_prefix
     del opts.filesystem_prefix

     opts.Freeze()
     return opts


 def main(argv) -> None:
     # Parse arguments.
     opts = ParseArgs(argv)

     # Build and validate the board and profile.
     board = _GetBoard(opts)

     if not os.path.exists(board.root):
         cros_build_lib.Die(
             "The board has not been setup, please run setup_board first."
         )

     try:
         profile = _GetProfile(opts, board)
     except ProfileDirectoryNotFoundError as e:
         cros_build_lib.Die(e)

     # Change the profile to the selected.
     logging.info("Selecting profile: %s for %s", profile.directory, board.root)

     try:
         ChooseProfile(board, profile)
     except MakeProfileIsNotLinkError as e:
         cros_build_lib.Die(e)
	# Copyright 2018 The ChromiumOS Authors
	# Use of this source code is governed by a BSD-style license that can be
	# found in the LICENSE file.

	"""Choose the profile for a board that has been or is being setup."""

	import functools
	import logging
	import os
	from typing import Optional

	from chromite.lib import build_target_lib
	from chromite.lib import commandline
	from chromite.lib import cros_build_lib
	from chromite.lib import osutils
	from chromite.lib import sysroot_lib


	# Default value constants.
	_DEFAULT_PROFILE = "base"


	def PathPrefixDecorator(f):
	"""Add a prefix to the path or paths returned by the decorated function.

	Will not prepend the prefix if the path already starts with the prefix, so
	the decorator may be applied to functions that have mixed sources that may
	or may not already have applied them. This is especially useful for allowing
	tests and CLI args a little more leniency in how paths are provided.
	"""

	@functools.wraps(f)
	def wrapper(args, *kwargs):
	result = f(args, *kwargs)
	prefix = PathPrefixDecorator.prefix

	if not prefix or not result:
	# Nothing to do.
	return result

	# Convert Path objects to str.
	if isinstance(prefix, os.PathLike):
	prefix = str(prefix)

	if not isinstance(result, str):
	# Transform each path in the collection.
	new_result = []
	for path in result:
	prefixed_path = os.path.join(prefix, path.lstrip(os.sep))
	new_result.append(
	path if path.startswith(prefix) else prefixed_path
	)

	return new_result
	elif not result.startswith(prefix):
	# Add the prefix.
	return os.path.join(prefix, result.lstrip(os.sep))

	# An already prefixed path.
	return result

	return wrapper


	PathPrefixDecorator.prefix = None


	class Error(Exception):
	"""Base error for custom exceptions in this script."""


	class InvalidArgumentsError(Error):
	"""Invalid arguments."""


	class MakeProfileIsNotLinkError(Error):
	"""The make profile exists but is not a link."""


	class ProfileDirectoryNotFoundError(Error):
	"""Unable to find the profile directory."""


	def ChooseProfile(board, profile) -> None:
	"""Make the link to choose the profile, print relevant warnings.

	Args:
	board: Board - the board being used.
	profile: Profile - the profile being used.

	Raises:
	OSError when the board's make_profile path exists and is not a link.
	"""
	if not os.path.isfile(os.path.join(profile.directory, "parent")):
	logging.warning(
	"Portage profile directory %s has no 'parent' file. "
	"This likely means your profile directory is invalid and "
	"`cros build-packages` will fail.",
	profile.directory,
	)

	current_profile = None
	if os.path.exists(board.make_profile):
	# Only try to read if it exists; we only want it to raise an error when
	# the path exists and is not a link.
	try:
	current_profile = os.readlink(board.make_profile)
	except OSError:
	raise MakeProfileIsNotLinkError(
	"%s is not a link." % board.make_profile
	)

	if current_profile == profile.directory:
	# The existing link is what we were going to make, so nothing to do.
	return
	elif current_profile is not None:
	# It exists and is changing, emit warning.
	fmt = {"board": board.board_variant, "profile": profile.name}
	msg = (
	"You are switching profiles for a board that is already setup. "
	"This can cause trouble for Portage. If you experience problems "
	"with `cros build-packages` you may need to run:\n"
	"\t'setup_board --board %(board)s --force --profile %(profile)s'\n"
	"\nAlternatively, you can correct the dependency graph by using "
	"'emerge-%(board)s -c' or 'emerge-%(board)s -C <ebuild>'."
	)
	logging.warning(msg, fmt)

	# Make the symlink, overwrites existing link if one already exists.
	osutils.SafeSymlink(profile.directory, board.make_profile, sudo=True)

	# Update the profile override value.
	if profile.override:
	board.profile_override = profile.override


	class Profile:
	"""Simple data container class for the profile data."""

	def __init__(self, name, directory, override) -> None:
	self.name = name
	self._directory = directory
	self.override = override

	@property
	@PathPrefixDecorator
	def directory(self):
	return self._directory


	def _GetProfile(opts, board):
	"""Get the profile list."""
	# Determine the override value - which profile is being selected.
	override = opts.profile if opts.profile else board.profile_override

	profile = _DEFAULT_PROFILE
	profile_directory = None

	if override and os.path.exists(override):
	profile_directory = os.path.abspath(override)
	profile = os.path.basename(profile_directory)
	elif override:
	profile = override

	if profile_directory is None:
	# Build profile directories in reverse order, so we can search from most
	# to least specific.
	profile_dirs = [
	"%s/profiles/%s" % (overlay, profile)
	for overlay in reversed(board.overlays)
	]

	for profile_dir in profile_dirs:
	if os.path.isdir(profile_dir):
	profile_directory = profile_dir
	break
	else:
	searched = ", ".join(profile_dirs)
	raise ProfileDirectoryNotFoundError(
	"Profile directory not found, searched in (%s)." % searched
	)

	return Profile(profile, profile_directory, override)


	class Board:
	"""Manage the board arguments and configs."""

	# Files located on the board.
	MAKE_PROFILE = "%(board_root)s/etc/portage/make.profile"

	def __init__(
	self,
	board: Optional[str] = None,
	variant: Optional[str] = None,
	board_root: Optional[str] = None,
	) -> None:
	"""Board constructor.

	board [+ variant] is given preference when both board and board_root are
	provided.

	Preconditions:
	Either board and build_root are not None, or board_root is not None.
	With board + build_root we can construct the board root.
	With the board root we can have the board directory.

	Args:
	board: The board name.
	variant: The variant name. TODO: Deprecate?
	board_root: The boards fully qualified build directory path.
	"""
	if not board and not board_root:
	# Enforce preconditions.
	raise InvalidArgumentsError(
	"Either board or board_root must be provided."
	)
	elif board:
	# The board and variant can be specified separately, or can both be
	# contained in the board name, separated by an underscore.
	board_split = board.split("_")
	variant_default = variant

	self._board_root = None
	else:
	self._board_root = os.path.normpath(board_root)

	board_split = os.path.basename(self._board_root).split("_")
	variant_default = None

	self.board = board_split.pop(0)
	self.variant = board_split.pop(0) if board_split else variant_default

	if self.variant:
	self.board_variant = "%s_%s" % (self.board, self.variant)
	else:
	self.board_variant = self.board

	self.make_profile = self.MAKE_PROFILE % {"board_root": self.root}
	# This must come after the arguments required to build each variant of
	# the build root have been processed.
	self._sysroot_config = sysroot_lib.Sysroot(self.root)

	@property
	@PathPrefixDecorator
	def root(self):
	if self._board_root:
	return self._board_root

	return build_target_lib.get_default_sysroot_path(self.board_variant)

	@property
	@PathPrefixDecorator
	def overlays(self):
	return self._sysroot_config.GetStandardField(
	sysroot_lib.STANDARD_FIELD_BOARD_OVERLAY
	).split()

	@property
	def profile_override(self):
	return self._sysroot_config.GetCachedField("PROFILE_OVERRIDE")

	@profile_override.setter
	def profile_override(self, value) -> None:
	self._sysroot_config.SetCachedField("PROFILE_OVERRIDE", value)


	def _GetBoard(opts):
	"""Factory method to build a Board from the parsed CLI arguments."""
	return Board(
	board=opts.board, variant=opts.variant, board_root=opts.board_root
	)


	def GetParser():
	"""ArgumentParser builder and argument definitions."""
	parser = commandline.ArgumentParser(description=__doc__)
	parser.add_argument(
	"-b",
	"--board",
	default=os.environ.get("DEFAULT_BOARD"),
	help="The name of the board to set up.",
	)
	parser.add_argument(
	"-r",
	"--board-root",
	type="str_path",
	help="Board root where the profile should be created.",
	)
	parser.add_argument(
	"-p", "--profile", help="The portage configuration profile to use."
	)
	parser.add_argument("--variant", help="Board variant.")

	group = parser.add_argument_group("Advanced options")
	group.add_argument(
	"--filesystem-prefix",
	type="str_path",
	help="Force filesystem accesses to be prefixed by the given path.",
	)
	return parser


	def ParseArgs(argv):
	"""Parse and validate the arguments."""
	parser = GetParser()
	opts = parser.parse_args(argv)

	# See Board.__init__ Preconditions.
	board_valid = opts.board is not None
	board_root_valid = opts.board_root and os.path.exists(opts.board_root)

	if not board_valid and not board_root_valid:
	parser.error("Either board or board_root must be provided.")

	PathPrefixDecorator.prefix = opts.filesystem_prefix
	del opts.filesystem_prefix

	opts.Freeze()
	return opts


	def main(argv) -> None:
	# Parse arguments.
	opts = ParseArgs(argv)

	# Build and validate the board and profile.
	board = _GetBoard(opts)

	if not os.path.exists(board.root):
	cros_build_lib.Die(
	"The board has not been setup, please run setup_board first."
	)

	try:
	profile = _GetProfile(opts, board)
	except ProfileDirectoryNotFoundError as e:
	cros_build_lib.Die(e)

	# Change the profile to the selected.
	logging.info("Selecting profile: %s for %s", profile.directory, board.root)

	try:
	ChooseProfile(board, profile)
	except MakeProfileIsNotLinkError as e:
	cros_build_lib.Die(e)