def main(argv):
if len(argv) > 1:
_Usage(sys.stderr)
return 1
if not argv:
path = git.FindRepoCheckoutRoot(os.getcwd())
if path is None:
_Usage(sys.stderr)
print >> sys.stderr, "We're not in a repo checkout."
return 1
else:
if argv[0] in ('-h', '--help', '--usage'):
_Usage(sys.stderr)
return 0
path = argv[0]
if not repository.IsARepoRoot(path):
_Usage(sys.stderr)
print >> sys.stderr, ("Path %s doesn't point to the root of a repository."
% (argv[0],))
return 1
print "Cleaning stale git configuration from %s" % (path,)
configure_repo.FixBrokenExistingRepos(path)
print "\nAdding git push configuration to %s" % (path,)
configure_repo.FixExternalRepoPushUrls(path)
def Initialize(cls,
root,
manifest_url,
repo_url=None,
repo_branch=None,
groups=None):
"""Initialize the checkout if necessary. Otherwise a no-op.
Args:
root: The repo root.
manifest_url: Manifest repository URL.
repo_url: Repo repository URL. Uses default googlesource repo if None.
repo_branch: Repo repository branch.
groups: Repo groups to sync.
"""
osutils.SafeMakedirs(root)
if git.FindRepoCheckoutRoot(root) is None:
logging.notice('Will initialize checkout %s for this run.', root)
repo_util.Repository.Initialize(root,
manifest_url,
repo_url=repo_url,
repo_branch=repo_branch,
groups=groups)
else:
logging.notice('Will use existing checkout %s for this run.', root)
return cls(root,
manifest_url=manifest_url,
repo_url=repo_url,
groups=groups)
def _Run(self, repo_cmd, cwd=None, capture_output=False):
"""Wrapper for `repo`.
Args:
repo_cmd: List of arguments to pass to `repo`.
cwd: The path to run the command in. Defaults to Repository root.
Must be within the root.
capture_output: Whether to capture the output, making it available in the
CommandResult object, or print it to stdout/err. Defaults to False.
Returns:
A CommandResult object.
Raises:
NotInRepoError: if cwd is not within the Repository root.
RunCommandError: if the command failed.
"""
# Use the checkout's copy of repo so that it doesn't have to be in PATH.
cmd = [os.path.join(self._repo_dir, 'repo', 'repo')] + repo_cmd
if cwd is None:
cwd = self.root
elif git.FindRepoCheckoutRoot(cwd) != self.root:
raise NotInRepoError(
'cannot run `repo` outside of Repository root '
'(cwd=%r root=%r)' % (cwd, self.root))
return cros_build_lib.run(cmd,
cwd=cwd,
capture_output=capture_output,
debug_level=logging.DEBUG,
encoding='utf-8')
def Initialize(cls,
root,
manifest_url,
manifest_branch=None,
manifest_name=None,
mirror=False,
reference=None,
depth=None,
groups=None,
repo_url=None,
repo_branch=None):
"""Initialize and return a new Repository with `repo init`.
Args:
root: Path to the new repo root. Must not be within an existing
repo repository.
manifest_url: Manifest repository URL.
manifest_branch: Manifest branch or revision.
manifest_name: Initial manifest file from manifest repository.
mirror: If True, create a repo mirror instead of a checkout.
reference: Location of a mirror directory to reference.
depth: Create shallow git clones with the given depth.
groups: Restrict manifest projects to the given groups.
repo_url: Repo command repository URL.
repo_branch: Repo command repository branch or revision.
Raises:
Error: root already contained a .repo subdir.
RunCommandError: `repo init` failed.
"""
existing_root = git.FindRepoCheckoutRoot(root)
if existing_root is not None:
raise Error('cannot init in existing repo %r.' % existing_root)
# TODO(lannm): Use 'chromite/bootstrap/repo'?
cmd = ['repo', 'init', '--manifest-url', manifest_url]
if manifest_branch is not None:
cmd += ['--manifest-branch', manifest_branch]
if manifest_name is not None:
cmd += ['--manifest-name', manifest_name]
if mirror:
cmd += ['--mirror']
if reference is not None:
if isinstance(reference, Repository):
reference = reference.root
cmd += ['--reference', reference]
if depth is not None:
cmd += ['--depth', str(depth)]
if groups is not None:
cmd += ['--groups', groups]
if repo_url is not None:
cmd += ['--repo-url', repo_url]
if repo_branch is not None:
cmd += ['--repo-branch', repo_branch]
repo_dir = os.path.join(root, '.repo')
warning_msg = 'Removing %r due to `repo init` failures.' % repo_dir
with _RmDirOnError(repo_dir, msg=warning_msg):
cros_build_lib.run(cmd, cwd=root)
return cls(root)
def _GetProjectPath(path):
"""Find the absolute path of the git checkout that contains |path|."""
if git.FindRepoCheckoutRoot(path):
manifest = git.ManifestCheckout.Cached(path)
return manifest.FindCheckoutFromPath(path).GetPath(absolute=True)
else:
# Maybe they're running on a file outside of a checkout.
# e.g. cros lint ~/foo.py /tmp/test.py
return os.path.dirname(path)
def Find(cls, path):
"""Searches for a repo directory and returns a Repository if found.
Args:
path: The path where the search starts.
"""
repo_root = git.FindRepoCheckoutRoot(path)
if repo_root is None:
return None
return cls(repo_root)
def FindCacheDir(cls, _parser, _opts):
debug_msg = 'Cache dir lookup: looking for %s checkout root.'
logging.debug(debug_msg, 'repo')
path = git.FindRepoCheckoutRoot(os.getcwd())
path = os.path.join(path, cls.REPO_CACHE_DIR) if path else path
if path is None:
logging.debug(debug_msg, 'gclient')
path = gclient.FindGclientCheckoutRoot(os.getcwd())
path = os.path.join(path, cls.CHROME_CACHE_DIR) if path else path
if path is None:
logging.debug(debug_msg, 'git submodule')
chrome_url = '%s/%s.git' % (constants.GIT_HTTP_URL,
constants.CHROMIUM_SRC_PROJECT)
path = git.FindGitSubmoduleCheckoutRoot(os.getcwd(), 'origin', chrome_url)
path = os.path.join(path, cls.CHROME_CACHE_DIR) if path else path
if path is None:
path = os.path.join(tempfile.gettempdir(), 'chromeos-cache')
return path
def _GenerateTestArtifactsInMoblabDisk(self, vms):
"""Generates test artifacts into devserver cache directory in moblab's disk.
Args:
vms: A moblab_vm.MoblabVm instance that has been Createed but not Started.
Returns:
The absolute path inside moblab VM where the image cache is located.
"""
with vms.MountedMoblabDiskContext() as disk_dir:
# If by any chance this path exists, the permission bits are surely
# nonsense, since 'moblab' user doesn't exist on the host system.
osutils.RmDir(os.path.join(disk_dir, _MOBLAB_PAYLOAD_CACHE_DIR),
ignore_missing=True,
sudo=True)
payloads_dir = os.path.join(disk_dir, _MOBLAB_PAYLOAD_CACHE_DIR,
self._SubDutTargetImage())
# moblab VM will chown this folder upon boot, so once again permission
# bits from the host don't matter.
osutils.SafeMakedirsNonRoot(payloads_dir)
source_dir = git.FindRepoCheckoutRoot(__file__)
commands.GeneratePayloads(
build_root=source_dir,
target_image_path=os.path.join(
self.GetImageDirSymlink(),
constants.TEST_IMAGE_BIN,
),
archive_dir=payloads_dir,
full=True,
delta=False,
stateful=True,
)
cwd = os.path.abspath(
os.path.join(self._build_root, 'chroot', 'build',
self._current_board,
constants.AUTOTEST_BUILD_PATH, '..'))
commands.BuildAutotestTarballsForHWTest(self._build_root, cwd,
payloads_dir)
return os.path.join(_MOBLAB_STATIC_MOUNT_PATH,
_MOBLAB_PAYLOAD_CACHE_DIR)
def DetermineCheckout(cwd):
"""Gather information on the checkout we are in.
Returns:
A CheckoutInfo object with these attributes:
type: The type of checkout. Valid values are CHECKOUT_TYPE_*.
root: The root of the checkout.
chrome_src_dir: If the checkout is a Chrome checkout, the path to the
Chrome src/ directory.
"""
debug_msg = 'Looking for %s checkout root.'
logging.debug(debug_msg, 'repo')
# Determine checkout checkout_type and root.
checkout_type = CHECKOUT_TYPE_UNKNOWN
root = git.FindRepoCheckoutRoot(cwd)
checkout_type = CHECKOUT_TYPE_REPO if root else checkout_type
if root is None:
logging.debug(debug_msg, 'gclient')
root = gclient.FindGclientCheckoutRoot(cwd)
checkout_type = CHECKOUT_TYPE_GCLIENT if root else checkout_type
if root is None:
logging.debug(debug_msg, 'git submodule')
chrome_url = '%s/%s.git' % (constants.PUBLIC_GOB_URL,
constants.CHROMIUM_SRC_PROJECT)
root = git.FindGitSubmoduleCheckoutRoot(os.getcwd(), 'origin',
chrome_url)
checkout_type = CHECKOUT_TYPE_SUBMODULE if root else checkout_type
if root is None:
checkout_type = CHECKOUT_TYPE_UNKNOWN
# Determine the chrome src directory.
chrome_src_dir = None
if checkout_type == CHECKOUT_TYPE_GCLIENT:
chrome_src_dir = os.path.join(root, 'src')
elif checkout_type == CHECKOUT_TYPE_SUBMODULE:
chrome_src_dir = root
return CheckoutInfo(checkout_type, root, chrome_src_dir)
def Copy(self, dest_root):
"""Efficiently `cp` the .repo directory, using hardlinks if possible.
Args:
dest_root: Path to copy the .repo directory into. Must exist and must
not already contain a .repo directory.
Returns:
A Repository pointing at dest_root.
Raises:
Error: if dest_root already contained a .repo subdir.
RunCommandError: if `cp` failed.
"""
existing_root = git.FindRepoCheckoutRoot(dest_root)
if existing_root is not None:
raise Error('cannot copy into existing repo %r' % existing_root)
dest_path = os.path.abspath(dest_root)
with _RmDirOnError(os.path.join(dest_root, '.repo')):
# First, try to hard link project objects to dest_dir; this may fail if
# e.g. the src and dest are on different mounts.
for project in self.List():
objects_dir = PROJECT_OBJECTS_PATH_FORMAT % project.name
try:
cros_build_lib.run([
'cp', '--archive', '--link', '--parents', objects_dir,
dest_path
],
debug_level=logging.DEBUG,
capture_output=True,
encoding='utf-8',
extra_env={'LC_MESSAGES': 'C'},
cwd=self.root)
except cros_build_lib.RunCommandError as e:
if 'Invalid cross-device link' in e.result.error:
logging.warning(
"Can't hard link across devices; aborting linking."
)
break
logging.warning('Copy linking failed: %s', e.result.error)
# Copy everything that wasn't created by the hard linking above.
try:
cros_build_lib.run(
['cp', '--archive', '--no-clobber', '.repo', dest_path],
debug_level=logging.DEBUG,
capture_output=True,
encoding='utf-8',
extra_env={'LC_MESSAGES': 'C'},
cwd=self.root)
except cros_build_lib.RunCommandError as e:
# Despite the --no-clobber, `cp` still complains when trying to copy a
# file to its existing hard link. Filter these errors from the output
# to see if there were any real failures.
errors = e.result.error.splitlines()
real_errors = [
x for x in errors if 'are the same file' not in x
]
if real_errors:
e.result.error = '\n'.join(real_errors)
raise e
return Repository(dest_root)
def main(argv):
usage = 'usage: %prog [-d <DEPS.git file>] [command]'
parser = optparse.OptionParser(usage=usage)
# TODO(rcui): have -d accept a URL.
parser.add_option('-d',
'--deps',
default=None,
help=('DEPS file to use. Defaults to '
'<chrome_src_root>/.DEPS.git'))
parser.add_option('--internal',
action='store_false',
dest='internal',
default=True,
help='Allow chrome-internal URLs')
parser.add_option('--runhooks',
action='store_true',
dest='runhooks',
default=False,
help="Run hooks as well.")
parser.add_option('-v',
'--verbose',
default=False,
action='store_true',
help='Run with debug output.')
(options, _inputs) = parser.parse_args(argv)
# Set cros_build_lib debug level to hide RunCommand spew.
if options.verbose:
cros_build_lib.logger.setLevel(logging.DEBUG)
else:
cros_build_lib.logger.setLevel(logging.WARNING)
if cros_build_lib.IsInsideChroot():
ssh_path = '/usr/bin/ssh_no_update'
if os.path.isfile(ssh_path):
os.environ['GIT_SSH'] = ssh_path
else:
cros_build_lib.Warning(
"Can't find %s. Run build_packages or setup_board to update "
"your choot." % ssh_path)
repo_root = git.FindRepoCheckoutRoot(os.getcwd())
chromium_src_root = os.path.join(repo_root, _CHROMIUM_SRC_ROOT)
if not os.path.isdir(os.path.join(chromium_src_root, '.git')):
error_msg = 'chromium checkout not found at %s.\n' % chromium_src_root
manifest = os.path.join(repo_root, '.repo', 'manifest.xml')
if os.path.basename(os.path.realpath(manifest)) == 'gerrit-source.xml':
error_msg += ("Please run repo sync and try again.")
else:
link = 'http://www.chromium.org/chromium-os/new-chrome-developer-workflow'
error_msg += (
'Detected you are not using gerrit_source.xml. Follow '
'instructions at %s to use repo checkout of chrome.' % link)
cros_build_lib.Die(error_msg)
# Add DEPS files to parse.
deps_files_to_parse = []
if options.deps:
deps_files_to_parse.append(options.deps)
else:
deps_files_to_parse.append(os.path.join(chromium_src_root,
'.DEPS.git'))
internal_deps = os.path.join(repo_root, _CHROMIUM_SRC_INTERNAL,
'.DEPS.git')
if os.path.exists(internal_deps):
deps_files_to_parse.append(internal_deps)
# Prepare source tree for resetting.
chromium_root = os.path.join(repo_root, _CHROMIUM_ROOT)
_CreateCrosSymlink(repo_root)
# Parse DEPS files and store hooks.
hook_dicts = []
for deps_file in deps_files_to_parse:
deps, merged_deps = GetParsedDeps(deps_file)
_ResetGitCheckout(repo_root, merged_deps)
hook_dicts.append(deps.get('hooks', {}))
# Run hooks after checkout has been reset properly.
if options.runhooks:
for hooks in hook_dicts:
_RunHooks(chromium_root, hooks)
def main(argv=None):
if argv is None:
argv = sys.argv[1:]
usage = 'usage: %prog'
parser = commandline.OptionParser(usage=usage)
parser.add_option('-r',
'--testroot',
action='store',
type='path',
help=('Directory where test checkout is stored.'))
parser.add_option('-f',
'--force',
default=True,
action='store_false',
dest='dryrun',
help='If enabled, allow committing.')
parser.add_option(
'--internal-manifest-url',
default='%s/%s' %
(constants.GERRIT_INT_SSH_URL, _INTERNAL_MANIFEST_PROJECT),
help='Url to fetch the internal manifest from.')
parser.add_option('--external-manifest-url',
default='%s/%s' %
(constants.GERRIT_SSH_URL, _EXTERNAL_MANIFEST_PROJECT),
help='Url to fetch the external manifest from.')
parser.add_option('-v',
'--verbose',
default=False,
action='store_true',
help='Run with debug output.')
parser.add_option('--reference',
default=None,
help="Repository to reference")
(options, _inputs) = parser.parse_args(argv)
if not options.testroot:
parser.error('Please specify a test root!')
# Set cros_build_lib debug level to hide RunCommand spew.
logging.getLogger().setLevel(
logging.DEBUG if options.verbose else logging.WARN)
if options.reference is None:
options.reference = git.FindRepoCheckoutRoot(os.getcwd())
def process_target(internal, manifest_url, reference):
subdir = 'internal' if internal else 'external'
root = os.path.join(options.testroot, subdir)
repo_dir = os.path.join(root, 'repo')
osutils.SafeMakedirs(repo_dir)
manifest_dir = os.path.join(root, 'manifest')
if os.path.exists(manifest_dir):
git.CleanAndCheckoutUpstream(manifest_dir)
git.RunGit(manifest_dir,
['checkout', '-B', 'master', '-t', 'origin/master'])
else:
repository.CloneGitRepo(manifest_dir, manifest_url)
m = Manifest(repo_dir,
manifest_dir,
internal,
reference=reference,
dryrun=options.dryrun)
m.PerformUpdate()
if options.dryrun:
print "%s manifest is now:" % subdir
print osutils.ReadFile(os.path.join(manifest_dir, MANIFEST_FILE))
# Process internal first so that any references to the passed in repo
# are utilized in full, w/ external then slaving from the new internal.
process_target(True, options.internal_manifest_url, options.reference)
process_target(False, options.external_manifest_url,
os.path.join(options.testroot, 'internal', 'repo'))